OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2013 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2013 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 4 * Use of this source code is governed by a BSD-style license |
5 * that can be found in the LICENSE file in the root of the source | 5 * that can be found in the LICENSE file in the root of the source |
6 * tree. An additional intellectual property rights grant can be found | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 #include <algorithm> | 10 #include <algorithm> |
(...skipping 21 matching lines...) Expand all Loading... |
32 #include "webrtc/modules/rtp_rtcp/source/rtp_format.h" | 32 #include "webrtc/modules/rtp_rtcp/source/rtp_format.h" |
33 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h" | 33 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h" |
34 #include "webrtc/modules/video_coding/codecs/h264/include/h264.h" | 34 #include "webrtc/modules/video_coding/codecs/h264/include/h264.h" |
35 #include "webrtc/modules/video_coding/codecs/vp8/include/vp8.h" | 35 #include "webrtc/modules/video_coding/codecs/vp8/include/vp8.h" |
36 #include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h" | 36 #include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h" |
37 #include "webrtc/modules/video_coding/include/video_coding_defines.h" | 37 #include "webrtc/modules/video_coding/include/video_coding_defines.h" |
38 #include "webrtc/rtc_base/checks.h" | 38 #include "webrtc/rtc_base/checks.h" |
39 #include "webrtc/rtc_base/event.h" | 39 #include "webrtc/rtc_base/event.h" |
40 #include "webrtc/rtc_base/file.h" | 40 #include "webrtc/rtc_base/file.h" |
41 #include "webrtc/rtc_base/optional.h" | 41 #include "webrtc/rtc_base/optional.h" |
| 42 #include "webrtc/rtc_base/ptr_util.h" |
42 #include "webrtc/rtc_base/random.h" | 43 #include "webrtc/rtc_base/random.h" |
43 #include "webrtc/rtc_base/rate_limiter.h" | 44 #include "webrtc/rtc_base/rate_limiter.h" |
44 #include "webrtc/system_wrappers/include/metrics.h" | 45 #include "webrtc/system_wrappers/include/metrics.h" |
45 #include "webrtc/system_wrappers/include/metrics_default.h" | 46 #include "webrtc/system_wrappers/include/metrics_default.h" |
46 #include "webrtc/system_wrappers/include/sleep.h" | 47 #include "webrtc/system_wrappers/include/sleep.h" |
47 #include "webrtc/test/call_test.h" | 48 #include "webrtc/test/call_test.h" |
48 #include "webrtc/test/direct_transport.h" | 49 #include "webrtc/test/direct_transport.h" |
49 #include "webrtc/test/encoder_settings.h" | 50 #include "webrtc/test/encoder_settings.h" |
50 #include "webrtc/test/fake_decoder.h" | 51 #include "webrtc/test/fake_decoder.h" |
51 #include "webrtc/test/fake_encoder.h" | 52 #include "webrtc/test/fake_encoder.h" |
(...skipping 158 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
210 void OnFrame(const VideoFrame& video_frame) override { | 211 void OnFrame(const VideoFrame& video_frame) override { |
211 SleepMs(kRenderDelayMs); | 212 SleepMs(kRenderDelayMs); |
212 event_.Set(); | 213 event_.Set(); |
213 } | 214 } |
214 | 215 |
215 bool Wait() { return event_.Wait(kDefaultTimeoutMs); } | 216 bool Wait() { return event_.Wait(kDefaultTimeoutMs); } |
216 | 217 |
217 rtc::Event event_; | 218 rtc::Event event_; |
218 } renderer; | 219 } renderer; |
219 | 220 |
220 CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get())); | 221 test::FrameForwarder frame_forwarder; |
| 222 std::unique_ptr<test::DirectTransport> sender_transport; |
| 223 std::unique_ptr<test::DirectTransport> receiver_transport; |
221 | 224 |
222 test::DirectTransport sender_transport(sender_call_.get(), payload_type_map_); | 225 task_queue_.SendTask([this, &renderer, &frame_forwarder, &sender_transport, |
223 test::DirectTransport receiver_transport(receiver_call_.get(), | 226 &receiver_transport]() { |
224 payload_type_map_); | 227 CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get())); |
225 sender_transport.SetReceiver(receiver_call_->Receiver()); | |
226 receiver_transport.SetReceiver(sender_call_->Receiver()); | |
227 | 228 |
228 CreateSendConfig(1, 0, 0, &sender_transport); | 229 sender_transport = rtc::MakeUnique<test::DirectTransport>( |
229 CreateMatchingReceiveConfigs(&receiver_transport); | 230 &task_queue_, sender_call_.get(), payload_type_map_); |
| 231 receiver_transport = rtc::MakeUnique<test::DirectTransport>( |
| 232 &task_queue_, receiver_call_.get(), payload_type_map_); |
| 233 sender_transport->SetReceiver(receiver_call_->Receiver()); |
| 234 receiver_transport->SetReceiver(sender_call_->Receiver()); |
230 | 235 |
231 video_receive_configs_[0].renderer = &renderer; | 236 CreateSendConfig(1, 0, 0, sender_transport.get()); |
| 237 CreateMatchingReceiveConfigs(receiver_transport.get()); |
232 | 238 |
233 CreateVideoStreams(); | 239 video_receive_configs_[0].renderer = &renderer; |
234 Start(); | |
235 | 240 |
236 // Create frames that are smaller than the send width/height, this is done to | 241 CreateVideoStreams(); |
237 // check that the callbacks are done after processing video. | 242 Start(); |
238 std::unique_ptr<test::FrameGenerator> frame_generator( | |
239 test::FrameGenerator::CreateSquareGenerator(kWidth, kHeight)); | |
240 test::FrameForwarder frame_forwarder; | |
241 video_send_stream_->SetSource( | |
242 &frame_forwarder, | |
243 VideoSendStream::DegradationPreference::kMaintainFramerate); | |
244 | 243 |
245 frame_forwarder.IncomingCapturedFrame(*frame_generator->NextFrame()); | 244 // Create frames that are smaller than the send width/height, this is done |
| 245 // to check that the callbacks are done after processing video. |
| 246 std::unique_ptr<test::FrameGenerator> frame_generator( |
| 247 test::FrameGenerator::CreateSquareGenerator(kWidth, kHeight)); |
| 248 video_send_stream_->SetSource( |
| 249 &frame_forwarder, |
| 250 VideoSendStream::DegradationPreference::kMaintainFramerate); |
| 251 |
| 252 frame_forwarder.IncomingCapturedFrame(*frame_generator->NextFrame()); |
| 253 }); |
| 254 |
246 EXPECT_TRUE(renderer.Wait()) | 255 EXPECT_TRUE(renderer.Wait()) |
247 << "Timed out while waiting for the frame to render."; | 256 << "Timed out while waiting for the frame to render."; |
248 | 257 |
249 Stop(); | 258 task_queue_.SendTask([this, &sender_transport, &receiver_transport]() { |
250 | 259 Stop(); |
251 sender_transport.StopSending(); | 260 DestroyStreams(); |
252 receiver_transport.StopSending(); | 261 sender_transport.reset(); |
253 | 262 receiver_transport.reset(); |
254 DestroyStreams(); | 263 DestroyCalls(); |
| 264 }); |
255 } | 265 } |
256 | 266 |
257 TEST_F(EndToEndTest, TransmitsFirstFrame) { | 267 TEST_F(EndToEndTest, TransmitsFirstFrame) { |
258 class Renderer : public rtc::VideoSinkInterface<VideoFrame> { | 268 class Renderer : public rtc::VideoSinkInterface<VideoFrame> { |
259 public: | 269 public: |
260 Renderer() : event_(false, false) {} | 270 Renderer() : event_(false, false) {} |
261 | 271 |
262 void OnFrame(const VideoFrame& video_frame) override { event_.Set(); } | 272 void OnFrame(const VideoFrame& video_frame) override { event_.Set(); } |
263 | 273 |
264 bool Wait() { return event_.Wait(kDefaultTimeoutMs); } | 274 bool Wait() { return event_.Wait(kDefaultTimeoutMs); } |
265 | 275 |
266 rtc::Event event_; | 276 rtc::Event event_; |
267 } renderer; | 277 } renderer; |
268 | 278 |
269 CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get())); | 279 std::unique_ptr<test::FrameGenerator> frame_generator; |
| 280 test::FrameForwarder frame_forwarder; |
270 | 281 |
271 test::DirectTransport sender_transport(sender_call_.get(), payload_type_map_); | 282 std::unique_ptr<test::DirectTransport> sender_transport; |
272 test::DirectTransport receiver_transport(receiver_call_.get(), | 283 std::unique_ptr<test::DirectTransport> receiver_transport; |
273 payload_type_map_); | |
274 sender_transport.SetReceiver(receiver_call_->Receiver()); | |
275 receiver_transport.SetReceiver(sender_call_->Receiver()); | |
276 | 284 |
277 CreateSendConfig(1, 0, 0, &sender_transport); | 285 task_queue_.SendTask([this, &renderer, &frame_generator, &frame_forwarder, |
278 CreateMatchingReceiveConfigs(&receiver_transport); | 286 &sender_transport, &receiver_transport]() { |
279 video_receive_configs_[0].renderer = &renderer; | 287 CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get())); |
280 | 288 |
281 CreateVideoStreams(); | 289 sender_transport = rtc::MakeUnique<test::DirectTransport>( |
282 Start(); | 290 &task_queue_, sender_call_.get(), payload_type_map_); |
| 291 receiver_transport = rtc::MakeUnique<test::DirectTransport>( |
| 292 &task_queue_, receiver_call_.get(), payload_type_map_); |
| 293 sender_transport->SetReceiver(receiver_call_->Receiver()); |
| 294 receiver_transport->SetReceiver(sender_call_->Receiver()); |
283 | 295 |
284 std::unique_ptr<test::FrameGenerator> frame_generator( | 296 CreateSendConfig(1, 0, 0, sender_transport.get()); |
285 test::FrameGenerator::CreateSquareGenerator(kDefaultWidth, | 297 CreateMatchingReceiveConfigs(receiver_transport.get()); |
286 kDefaultHeight)); | 298 video_receive_configs_[0].renderer = &renderer; |
287 test::FrameForwarder frame_forwarder; | 299 |
288 video_send_stream_->SetSource( | 300 CreateVideoStreams(); |
289 &frame_forwarder, | 301 Start(); |
290 VideoSendStream::DegradationPreference::kMaintainFramerate); | 302 |
291 frame_forwarder.IncomingCapturedFrame(*frame_generator->NextFrame()); | 303 frame_generator = test::FrameGenerator::CreateSquareGenerator( |
| 304 kDefaultWidth, kDefaultHeight); |
| 305 video_send_stream_->SetSource( |
| 306 &frame_forwarder, |
| 307 VideoSendStream::DegradationPreference::kMaintainFramerate); |
| 308 frame_forwarder.IncomingCapturedFrame(*frame_generator->NextFrame()); |
| 309 }); |
292 | 310 |
293 EXPECT_TRUE(renderer.Wait()) | 311 EXPECT_TRUE(renderer.Wait()) |
294 << "Timed out while waiting for the frame to render."; | 312 << "Timed out while waiting for the frame to render."; |
295 | 313 |
296 Stop(); | 314 task_queue_.SendTask([this, &sender_transport, &receiver_transport]() { |
297 | 315 Stop(); |
298 sender_transport.StopSending(); | 316 DestroyStreams(); |
299 receiver_transport.StopSending(); | 317 sender_transport.reset(); |
300 | 318 receiver_transport.reset(); |
301 DestroyStreams(); | 319 DestroyCalls(); |
| 320 }); |
302 } | 321 } |
303 | 322 |
304 class CodecObserver : public test::EndToEndTest, | 323 class CodecObserver : public test::EndToEndTest, |
305 public rtc::VideoSinkInterface<VideoFrame> { | 324 public rtc::VideoSinkInterface<VideoFrame> { |
306 public: | 325 public: |
307 CodecObserver(int no_frames_to_wait_for, | 326 CodecObserver(int no_frames_to_wait_for, |
308 VideoRotation rotation_to_test, | 327 VideoRotation rotation_to_test, |
309 const std::string& payload_name, | 328 const std::string& payload_name, |
310 webrtc::VideoEncoder* encoder, | 329 webrtc::VideoEncoder* encoder, |
311 webrtc::VideoDecoder* decoder) | 330 webrtc::VideoDecoder* decoder) |
(...skipping 221 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
533 NackObserver() | 552 NackObserver() |
534 : EndToEndTest(kLongTimeoutMs), | 553 : EndToEndTest(kLongTimeoutMs), |
535 local_ssrc_(0), | 554 local_ssrc_(0), |
536 remote_ssrc_(0), | 555 remote_ssrc_(0), |
537 receive_transport_(nullptr) {} | 556 receive_transport_(nullptr) {} |
538 | 557 |
539 private: | 558 private: |
540 size_t GetNumVideoStreams() const override { return 0; } | 559 size_t GetNumVideoStreams() const override { return 0; } |
541 size_t GetNumAudioStreams() const override { return 1; } | 560 size_t GetNumAudioStreams() const override { return 1; } |
542 | 561 |
543 test::PacketTransport* CreateReceiveTransport() override { | 562 test::PacketTransport* CreateReceiveTransport( |
| 563 test::SingleThreadedTaskQueueForTesting* task_queue) override { |
544 test::PacketTransport* receive_transport = new test::PacketTransport( | 564 test::PacketTransport* receive_transport = new test::PacketTransport( |
545 nullptr, this, test::PacketTransport::kReceiver, payload_type_map_, | 565 task_queue, nullptr, this, test::PacketTransport::kReceiver, |
546 FakeNetworkPipe::Config()); | 566 payload_type_map_, FakeNetworkPipe::Config()); |
547 receive_transport_ = receive_transport; | 567 receive_transport_ = receive_transport; |
548 return receive_transport; | 568 return receive_transport; |
549 } | 569 } |
550 | 570 |
551 Action OnSendRtp(const uint8_t* packet, size_t length) override { | 571 Action OnSendRtp(const uint8_t* packet, size_t length) override { |
552 RTPHeader header; | 572 RTPHeader header; |
553 EXPECT_TRUE(parser_->Parse(packet, length, &header)); | 573 EXPECT_TRUE(parser_->Parse(packet, length, &header)); |
554 | 574 |
555 if (!sequence_number_to_retransmit_) { | 575 if (!sequence_number_to_retransmit_) { |
556 sequence_number_to_retransmit_ = | 576 sequence_number_to_retransmit_ = |
(...skipping 234 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
791 EXPECT_EQ(test::CallTest::kFlexfecSendSsrc, | 811 EXPECT_EQ(test::CallTest::kFlexfecSendSsrc, |
792 report_blocks[0].source_ssrc()); | 812 report_blocks[0].source_ssrc()); |
793 rtc::CritScope lock(&crit_); | 813 rtc::CritScope lock(&crit_); |
794 received_flexfec_rtcp_ = true; | 814 received_flexfec_rtcp_ = true; |
795 } | 815 } |
796 } | 816 } |
797 | 817 |
798 return SEND_PACKET; | 818 return SEND_PACKET; |
799 } | 819 } |
800 | 820 |
801 test::PacketTransport* CreateSendTransport(Call* sender_call) override { | 821 test::PacketTransport* CreateSendTransport( |
| 822 test::SingleThreadedTaskQueueForTesting* task_queue, |
| 823 Call* sender_call) override { |
802 // At low RTT (< kLowRttNackMs) -> NACK only, no FEC. | 824 // At low RTT (< kLowRttNackMs) -> NACK only, no FEC. |
803 const int kNetworkDelayMs = 100; | 825 const int kNetworkDelayMs = 100; |
804 FakeNetworkPipe::Config config; | 826 FakeNetworkPipe::Config config; |
805 config.queue_delay_ms = kNetworkDelayMs; | 827 config.queue_delay_ms = kNetworkDelayMs; |
806 return new test::PacketTransport(sender_call, this, | 828 return new test::PacketTransport(task_queue, sender_call, this, |
807 test::PacketTransport::kSender, | 829 test::PacketTransport::kSender, |
808 test::CallTest::payload_type_map_, config); | 830 test::CallTest::payload_type_map_, config); |
809 } | 831 } |
810 | 832 |
811 void OnFrame(const VideoFrame& video_frame) override { | 833 void OnFrame(const VideoFrame& video_frame) override { |
812 rtc::CritScope lock(&crit_); | 834 rtc::CritScope lock(&crit_); |
813 // Rendering frame with timestamp of packet that was dropped -> FEC | 835 // Rendering frame with timestamp of packet that was dropped -> FEC |
814 // protection worked. | 836 // protection worked. |
815 auto it = dropped_timestamps_.find(video_frame.timestamp()); | 837 auto it = dropped_timestamps_.find(video_frame.timestamp()); |
816 if (it != dropped_timestamps_.end()) { | 838 if (it != dropped_timestamps_.end()) { |
(...skipping 153 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
970 ulpfec_sequence_number_) == nacks.end()) | 992 ulpfec_sequence_number_) == nacks.end()) |
971 << "Got nack for ULPFEC packet"; | 993 << "Got nack for ULPFEC packet"; |
972 if (!nacks.empty() && | 994 if (!nacks.empty() && |
973 IsNewerSequenceNumber(nacks.back(), ulpfec_sequence_number_)) { | 995 IsNewerSequenceNumber(nacks.back(), ulpfec_sequence_number_)) { |
974 observation_complete_.Set(); | 996 observation_complete_.Set(); |
975 } | 997 } |
976 } | 998 } |
977 return SEND_PACKET; | 999 return SEND_PACKET; |
978 } | 1000 } |
979 | 1001 |
980 test::PacketTransport* CreateSendTransport(Call* sender_call) override { | 1002 test::PacketTransport* CreateSendTransport( |
| 1003 test::SingleThreadedTaskQueueForTesting* task_queue, |
| 1004 Call* sender_call) override { |
981 // At low RTT (< kLowRttNackMs) -> NACK only, no FEC. | 1005 // At low RTT (< kLowRttNackMs) -> NACK only, no FEC. |
982 // Configure some network delay. | 1006 // Configure some network delay. |
983 const int kNetworkDelayMs = 50; | 1007 const int kNetworkDelayMs = 50; |
984 FakeNetworkPipe::Config config; | 1008 FakeNetworkPipe::Config config; |
985 config.queue_delay_ms = kNetworkDelayMs; | 1009 config.queue_delay_ms = kNetworkDelayMs; |
986 return new test::PacketTransport(sender_call, this, | 1010 return new test::PacketTransport(task_queue, sender_call, this, |
987 test::PacketTransport::kSender, | 1011 test::PacketTransport::kSender, |
988 payload_type_map_, config); | 1012 payload_type_map_, config); |
989 } | 1013 } |
990 | 1014 |
991 // TODO(holmer): Investigate why we don't send FEC packets when the bitrate | 1015 // TODO(holmer): Investigate why we don't send FEC packets when the bitrate |
992 // is 10 kbps. | 1016 // is 10 kbps. |
993 Call::Config GetSenderCallConfig() override { | 1017 Call::Config GetSenderCallConfig() override { |
994 Call::Config config(event_log_.get()); | 1018 Call::Config config(event_log_.get()); |
995 const int kMinBitrateBps = 30000; | 1019 const int kMinBitrateBps = 30000; |
996 config.bitrate_config.min_bitrate_bps = kMinBitrateBps; | 1020 config.bitrate_config.min_bitrate_bps = kMinBitrateBps; |
(...skipping 321 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1318 EXPECT_EQ(DELIVERY_UNKNOWN_SSRC, delivery_status); | 1342 EXPECT_EQ(DELIVERY_UNKNOWN_SSRC, delivery_status); |
1319 delivered_packet_.Set(); | 1343 delivered_packet_.Set(); |
1320 return delivery_status; | 1344 return delivery_status; |
1321 } | 1345 } |
1322 } | 1346 } |
1323 | 1347 |
1324 PacketReceiver* receiver_; | 1348 PacketReceiver* receiver_; |
1325 rtc::Event delivered_packet_; | 1349 rtc::Event delivered_packet_; |
1326 }; | 1350 }; |
1327 | 1351 |
1328 CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get())); | 1352 std::unique_ptr<test::DirectTransport> send_transport; |
| 1353 std::unique_ptr<test::DirectTransport> receive_transport; |
| 1354 std::unique_ptr<PacketInputObserver> input_observer; |
1329 | 1355 |
1330 test::DirectTransport send_transport(sender_call_.get(), payload_type_map_); | 1356 task_queue_.SendTask([this, &send_transport, &receive_transport, |
1331 test::DirectTransport receive_transport(receiver_call_.get(), | 1357 &input_observer]() { |
1332 payload_type_map_); | 1358 CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get())); |
1333 PacketInputObserver input_observer(receiver_call_->Receiver()); | |
1334 send_transport.SetReceiver(&input_observer); | |
1335 receive_transport.SetReceiver(sender_call_->Receiver()); | |
1336 | 1359 |
1337 CreateSendConfig(1, 0, 0, &send_transport); | 1360 send_transport = rtc::MakeUnique<test::DirectTransport>( |
1338 CreateMatchingReceiveConfigs(&receive_transport); | 1361 &task_queue_, sender_call_.get(), payload_type_map_); |
| 1362 receive_transport = rtc::MakeUnique<test::DirectTransport>( |
| 1363 &task_queue_, receiver_call_.get(), payload_type_map_); |
| 1364 input_observer = |
| 1365 rtc::MakeUnique<PacketInputObserver>(receiver_call_->Receiver()); |
| 1366 send_transport->SetReceiver(input_observer.get()); |
| 1367 receive_transport->SetReceiver(sender_call_->Receiver()); |
1339 | 1368 |
1340 CreateVideoStreams(); | 1369 CreateSendConfig(1, 0, 0, send_transport.get()); |
1341 CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth, | 1370 CreateMatchingReceiveConfigs(receive_transport.get()); |
1342 kDefaultHeight); | |
1343 Start(); | |
1344 | 1371 |
1345 receiver_call_->DestroyVideoReceiveStream(video_receive_streams_[0]); | 1372 CreateVideoStreams(); |
1346 video_receive_streams_.clear(); | 1373 CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth, |
| 1374 kDefaultHeight); |
| 1375 Start(); |
| 1376 |
| 1377 receiver_call_->DestroyVideoReceiveStream(video_receive_streams_[0]); |
| 1378 video_receive_streams_.clear(); |
| 1379 }); |
1347 | 1380 |
1348 // Wait() waits for a received packet. | 1381 // Wait() waits for a received packet. |
1349 EXPECT_TRUE(input_observer.Wait()); | 1382 EXPECT_TRUE(input_observer->Wait()); |
1350 | 1383 |
1351 Stop(); | 1384 task_queue_.SendTask([this, &send_transport, &receive_transport]() { |
1352 | 1385 Stop(); |
1353 DestroyStreams(); | 1386 DestroyStreams(); |
1354 | 1387 send_transport.reset(); |
1355 send_transport.StopSending(); | 1388 receive_transport.reset(); |
1356 receive_transport.StopSending(); | 1389 DestroyCalls(); |
| 1390 }); |
1357 } | 1391 } |
1358 | 1392 |
1359 void EndToEndTest::RespectsRtcpMode(RtcpMode rtcp_mode) { | 1393 void EndToEndTest::RespectsRtcpMode(RtcpMode rtcp_mode) { |
1360 static const int kNumCompoundRtcpPacketsToObserve = 10; | 1394 static const int kNumCompoundRtcpPacketsToObserve = 10; |
1361 class RtcpModeObserver : public test::EndToEndTest { | 1395 class RtcpModeObserver : public test::EndToEndTest { |
1362 public: | 1396 public: |
1363 explicit RtcpModeObserver(RtcpMode rtcp_mode) | 1397 explicit RtcpModeObserver(RtcpMode rtcp_mode) |
1364 : EndToEndTest(kDefaultTimeoutMs), | 1398 : EndToEndTest(kDefaultTimeoutMs), |
1365 rtcp_mode_(rtcp_mode), | 1399 rtcp_mode_(rtcp_mode), |
1366 sent_rtp_(0), | 1400 sent_rtp_(0), |
(...skipping 86 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1453 const uint8_t kVideoPayloadType = 124; | 1487 const uint8_t kVideoPayloadType = 124; |
1454 const std::map<uint8_t, MediaType> payload_type_map_ = { | 1488 const std::map<uint8_t, MediaType> payload_type_map_ = { |
1455 {kVideoPayloadType, MediaType::VIDEO}}; | 1489 {kVideoPayloadType, MediaType::VIDEO}}; |
1456 | 1490 |
1457 struct CodecSettings { | 1491 struct CodecSettings { |
1458 uint32_t ssrc; | 1492 uint32_t ssrc; |
1459 int width; | 1493 int width; |
1460 int height; | 1494 int height; |
1461 } codec_settings[kNumStreams]; | 1495 } codec_settings[kNumStreams]; |
1462 | 1496 |
1463 MultiStreamTest() { | 1497 explicit MultiStreamTest(test::SingleThreadedTaskQueueForTesting* task_queue) |
| 1498 : task_queue_(task_queue) { |
1464 // TODO(sprang): Cleanup when msvc supports explicit initializers for array. | 1499 // TODO(sprang): Cleanup when msvc supports explicit initializers for array. |
1465 codec_settings[0] = {1, 640, 480}; | 1500 codec_settings[0] = {1, 640, 480}; |
1466 codec_settings[1] = {2, 320, 240}; | 1501 codec_settings[1] = {2, 320, 240}; |
1467 codec_settings[2] = {3, 240, 160}; | 1502 codec_settings[2] = {3, 240, 160}; |
1468 } | 1503 } |
1469 | 1504 |
1470 virtual ~MultiStreamTest() {} | 1505 virtual ~MultiStreamTest() {} |
1471 | 1506 |
1472 void RunTest() { | 1507 void RunTest() { |
1473 webrtc::RtcEventLogNullImpl event_log; | 1508 webrtc::RtcEventLogNullImpl event_log; |
1474 Call::Config config(&event_log); | 1509 Call::Config config(&event_log); |
1475 std::unique_ptr<Call> sender_call(Call::Create(config)); | 1510 std::unique_ptr<Call> sender_call; |
1476 std::unique_ptr<Call> receiver_call(Call::Create(config)); | 1511 std::unique_ptr<Call> receiver_call; |
1477 std::unique_ptr<test::DirectTransport> sender_transport( | 1512 std::unique_ptr<test::DirectTransport> sender_transport; |
1478 CreateSendTransport(sender_call.get())); | 1513 std::unique_ptr<test::DirectTransport> receiver_transport; |
1479 std::unique_ptr<test::DirectTransport> receiver_transport( | |
1480 CreateReceiveTransport(receiver_call.get())); | |
1481 sender_transport->SetReceiver(receiver_call->Receiver()); | |
1482 receiver_transport->SetReceiver(sender_call->Receiver()); | |
1483 | |
1484 std::unique_ptr<VideoEncoder> encoders[kNumStreams]; | |
1485 for (size_t i = 0; i < kNumStreams; ++i) | |
1486 encoders[i].reset(VP8Encoder::Create()); | |
1487 | 1514 |
1488 VideoSendStream* send_streams[kNumStreams]; | 1515 VideoSendStream* send_streams[kNumStreams]; |
1489 VideoReceiveStream* receive_streams[kNumStreams]; | 1516 VideoReceiveStream* receive_streams[kNumStreams]; |
1490 | |
1491 test::FrameGeneratorCapturer* frame_generators[kNumStreams]; | 1517 test::FrameGeneratorCapturer* frame_generators[kNumStreams]; |
1492 std::vector<std::unique_ptr<VideoDecoder>> allocated_decoders; | 1518 std::vector<std::unique_ptr<VideoDecoder>> allocated_decoders; |
1493 for (size_t i = 0; i < kNumStreams; ++i) { | 1519 std::unique_ptr<VideoEncoder> encoders[kNumStreams]; |
1494 uint32_t ssrc = codec_settings[i].ssrc; | |
1495 int width = codec_settings[i].width; | |
1496 int height = codec_settings[i].height; | |
1497 | 1520 |
1498 VideoSendStream::Config send_config(sender_transport.get()); | 1521 task_queue_->SendTask([&]() { |
1499 send_config.rtp.ssrcs.push_back(ssrc); | 1522 sender_call = rtc::WrapUnique(Call::Create(config)); |
1500 send_config.encoder_settings.encoder = encoders[i].get(); | 1523 receiver_call = rtc::WrapUnique(Call::Create(config)); |
1501 send_config.encoder_settings.payload_name = "VP8"; | 1524 sender_transport = |
1502 send_config.encoder_settings.payload_type = kVideoPayloadType; | 1525 rtc::WrapUnique(CreateSendTransport(task_queue_, sender_call.get())); |
1503 VideoEncoderConfig encoder_config; | 1526 receiver_transport = rtc::WrapUnique( |
1504 test::FillEncoderConfiguration(1, &encoder_config); | 1527 CreateReceiveTransport(task_queue_, receiver_call.get())); |
1505 encoder_config.max_bitrate_bps = 100000; | |
1506 | 1528 |
1507 UpdateSendConfig(i, &send_config, &encoder_config, &frame_generators[i]); | 1529 sender_transport->SetReceiver(receiver_call->Receiver()); |
| 1530 receiver_transport->SetReceiver(sender_call->Receiver()); |
1508 | 1531 |
1509 send_streams[i] = sender_call->CreateVideoSendStream( | 1532 for (size_t i = 0; i < kNumStreams; ++i) |
1510 send_config.Copy(), encoder_config.Copy()); | 1533 encoders[i].reset(VP8Encoder::Create()); |
1511 send_streams[i]->Start(); | |
1512 | 1534 |
1513 VideoReceiveStream::Config receive_config(receiver_transport.get()); | 1535 for (size_t i = 0; i < kNumStreams; ++i) { |
1514 receive_config.rtp.remote_ssrc = ssrc; | 1536 uint32_t ssrc = codec_settings[i].ssrc; |
1515 receive_config.rtp.local_ssrc = test::CallTest::kReceiverLocalVideoSsrc; | 1537 int width = codec_settings[i].width; |
1516 VideoReceiveStream::Decoder decoder = | 1538 int height = codec_settings[i].height; |
1517 test::CreateMatchingDecoder(send_config.encoder_settings); | |
1518 allocated_decoders.push_back( | |
1519 std::unique_ptr<VideoDecoder>(decoder.decoder)); | |
1520 receive_config.decoders.push_back(decoder); | |
1521 | 1539 |
1522 UpdateReceiveConfig(i, &receive_config); | 1540 VideoSendStream::Config send_config(sender_transport.get()); |
| 1541 send_config.rtp.ssrcs.push_back(ssrc); |
| 1542 send_config.encoder_settings.encoder = encoders[i].get(); |
| 1543 send_config.encoder_settings.payload_name = "VP8"; |
| 1544 send_config.encoder_settings.payload_type = kVideoPayloadType; |
| 1545 VideoEncoderConfig encoder_config; |
| 1546 test::FillEncoderConfiguration(1, &encoder_config); |
| 1547 encoder_config.max_bitrate_bps = 100000; |
1523 | 1548 |
1524 receive_streams[i] = | 1549 UpdateSendConfig(i, &send_config, &encoder_config, |
1525 receiver_call->CreateVideoReceiveStream(std::move(receive_config)); | 1550 &frame_generators[i]); |
1526 receive_streams[i]->Start(); | |
1527 | 1551 |
1528 frame_generators[i] = test::FrameGeneratorCapturer::Create( | 1552 send_streams[i] = sender_call->CreateVideoSendStream( |
1529 width, height, 30, Clock::GetRealTimeClock()); | 1553 send_config.Copy(), encoder_config.Copy()); |
1530 send_streams[i]->SetSource( | 1554 send_streams[i]->Start(); |
1531 frame_generators[i], | 1555 |
1532 VideoSendStream::DegradationPreference::kMaintainFramerate); | 1556 VideoReceiveStream::Config receive_config(receiver_transport.get()); |
1533 frame_generators[i]->Start(); | 1557 receive_config.rtp.remote_ssrc = ssrc; |
1534 } | 1558 receive_config.rtp.local_ssrc = test::CallTest::kReceiverLocalVideoSsrc; |
| 1559 VideoReceiveStream::Decoder decoder = |
| 1560 test::CreateMatchingDecoder(send_config.encoder_settings); |
| 1561 allocated_decoders.push_back( |
| 1562 std::unique_ptr<VideoDecoder>(decoder.decoder)); |
| 1563 receive_config.decoders.push_back(decoder); |
| 1564 |
| 1565 UpdateReceiveConfig(i, &receive_config); |
| 1566 |
| 1567 receive_streams[i] = |
| 1568 receiver_call->CreateVideoReceiveStream(std::move(receive_config)); |
| 1569 receive_streams[i]->Start(); |
| 1570 |
| 1571 frame_generators[i] = test::FrameGeneratorCapturer::Create( |
| 1572 width, height, 30, Clock::GetRealTimeClock()); |
| 1573 send_streams[i]->SetSource( |
| 1574 frame_generators[i], |
| 1575 VideoSendStream::DegradationPreference::kMaintainFramerate); |
| 1576 frame_generators[i]->Start(); |
| 1577 } |
| 1578 }); |
1535 | 1579 |
1536 Wait(); | 1580 Wait(); |
1537 | 1581 |
1538 for (size_t i = 0; i < kNumStreams; ++i) { | 1582 task_queue_->SendTask([&]() { |
1539 frame_generators[i]->Stop(); | 1583 for (size_t i = 0; i < kNumStreams; ++i) { |
1540 sender_call->DestroyVideoSendStream(send_streams[i]); | 1584 frame_generators[i]->Stop(); |
1541 receiver_call->DestroyVideoReceiveStream(receive_streams[i]); | 1585 sender_call->DestroyVideoSendStream(send_streams[i]); |
1542 delete frame_generators[i]; | 1586 receiver_call->DestroyVideoReceiveStream(receive_streams[i]); |
1543 } | 1587 delete frame_generators[i]; |
| 1588 } |
1544 | 1589 |
1545 sender_transport->StopSending(); | 1590 sender_transport.reset(); |
1546 receiver_transport->StopSending(); | 1591 receiver_transport.reset(); |
| 1592 |
| 1593 sender_call.reset(); |
| 1594 receiver_call.reset(); |
| 1595 }); |
1547 } | 1596 } |
1548 | 1597 |
1549 protected: | 1598 protected: |
1550 virtual void Wait() = 0; | 1599 virtual void Wait() = 0; |
1551 // Note: frame_generator is a point-to-pointer, since the actual instance | 1600 // Note: frame_generator is a point-to-pointer, since the actual instance |
1552 // hasn't been created at the time of this call. Only when packets/frames | 1601 // hasn't been created at the time of this call. Only when packets/frames |
1553 // start flowing should this be dereferenced. | 1602 // start flowing should this be dereferenced. |
1554 virtual void UpdateSendConfig( | 1603 virtual void UpdateSendConfig( |
1555 size_t stream_index, | 1604 size_t stream_index, |
1556 VideoSendStream::Config* send_config, | 1605 VideoSendStream::Config* send_config, |
1557 VideoEncoderConfig* encoder_config, | 1606 VideoEncoderConfig* encoder_config, |
1558 test::FrameGeneratorCapturer** frame_generator) {} | 1607 test::FrameGeneratorCapturer** frame_generator) {} |
1559 virtual void UpdateReceiveConfig(size_t stream_index, | 1608 virtual void UpdateReceiveConfig(size_t stream_index, |
1560 VideoReceiveStream::Config* receive_config) { | 1609 VideoReceiveStream::Config* receive_config) { |
1561 } | 1610 } |
1562 virtual test::DirectTransport* CreateSendTransport(Call* sender_call) { | 1611 virtual test::DirectTransport* CreateSendTransport( |
1563 return new test::DirectTransport(sender_call, payload_type_map_); | 1612 test::SingleThreadedTaskQueueForTesting* task_queue, |
| 1613 Call* sender_call) { |
| 1614 return new test::DirectTransport(task_queue, sender_call, |
| 1615 payload_type_map_); |
1564 } | 1616 } |
1565 virtual test::DirectTransport* CreateReceiveTransport(Call* receiver_call) { | 1617 virtual test::DirectTransport* CreateReceiveTransport( |
1566 return new test::DirectTransport(receiver_call, payload_type_map_); | 1618 test::SingleThreadedTaskQueueForTesting* task_queue, |
| 1619 Call* receiver_call) { |
| 1620 return new test::DirectTransport(task_queue, receiver_call, |
| 1621 payload_type_map_); |
1567 } | 1622 } |
| 1623 |
| 1624 test::SingleThreadedTaskQueueForTesting* const task_queue_; |
1568 }; | 1625 }; |
1569 | 1626 |
1570 // Each renderer verifies that it receives the expected resolution, and as soon | 1627 // Each renderer verifies that it receives the expected resolution, and as soon |
1571 // as every renderer has received a frame, the test finishes. | 1628 // as every renderer has received a frame, the test finishes. |
1572 TEST_F(EndToEndTest, SendsAndReceivesMultipleStreams) { | 1629 TEST_F(EndToEndTest, SendsAndReceivesMultipleStreams) { |
1573 class VideoOutputObserver : public rtc::VideoSinkInterface<VideoFrame> { | 1630 class VideoOutputObserver : public rtc::VideoSinkInterface<VideoFrame> { |
1574 public: | 1631 public: |
1575 VideoOutputObserver(const MultiStreamTest::CodecSettings& settings, | 1632 VideoOutputObserver(const MultiStreamTest::CodecSettings& settings, |
1576 uint32_t ssrc, | 1633 uint32_t ssrc, |
1577 test::FrameGeneratorCapturer** frame_generator) | 1634 test::FrameGeneratorCapturer** frame_generator) |
(...skipping 15 matching lines...) Expand all Loading... |
1593 | 1650 |
1594 private: | 1651 private: |
1595 const MultiStreamTest::CodecSettings& settings_; | 1652 const MultiStreamTest::CodecSettings& settings_; |
1596 const uint32_t ssrc_; | 1653 const uint32_t ssrc_; |
1597 test::FrameGeneratorCapturer** const frame_generator_; | 1654 test::FrameGeneratorCapturer** const frame_generator_; |
1598 rtc::Event done_; | 1655 rtc::Event done_; |
1599 }; | 1656 }; |
1600 | 1657 |
1601 class Tester : public MultiStreamTest { | 1658 class Tester : public MultiStreamTest { |
1602 public: | 1659 public: |
1603 Tester() {} | 1660 explicit Tester(test::SingleThreadedTaskQueueForTesting* task_queue) |
| 1661 : MultiStreamTest(task_queue) {} |
1604 virtual ~Tester() {} | 1662 virtual ~Tester() {} |
1605 | 1663 |
1606 protected: | 1664 protected: |
1607 void Wait() override { | 1665 void Wait() override { |
1608 for (const auto& observer : observers_) { | 1666 for (const auto& observer : observers_) { |
1609 EXPECT_TRUE(observer->Wait()) << "Time out waiting for from on ssrc " | 1667 EXPECT_TRUE(observer->Wait()) << "Time out waiting for from on ssrc " |
1610 << observer->Ssrc(); | 1668 << observer->Ssrc(); |
1611 } | 1669 } |
1612 } | 1670 } |
1613 | 1671 |
1614 void UpdateSendConfig( | 1672 void UpdateSendConfig( |
1615 size_t stream_index, | 1673 size_t stream_index, |
1616 VideoSendStream::Config* send_config, | 1674 VideoSendStream::Config* send_config, |
1617 VideoEncoderConfig* encoder_config, | 1675 VideoEncoderConfig* encoder_config, |
1618 test::FrameGeneratorCapturer** frame_generator) override { | 1676 test::FrameGeneratorCapturer** frame_generator) override { |
1619 observers_[stream_index].reset(new VideoOutputObserver( | 1677 observers_[stream_index].reset(new VideoOutputObserver( |
1620 codec_settings[stream_index], send_config->rtp.ssrcs.front(), | 1678 codec_settings[stream_index], send_config->rtp.ssrcs.front(), |
1621 frame_generator)); | 1679 frame_generator)); |
1622 } | 1680 } |
1623 | 1681 |
1624 void UpdateReceiveConfig( | 1682 void UpdateReceiveConfig( |
1625 size_t stream_index, | 1683 size_t stream_index, |
1626 VideoReceiveStream::Config* receive_config) override { | 1684 VideoReceiveStream::Config* receive_config) override { |
1627 receive_config->renderer = observers_[stream_index].get(); | 1685 receive_config->renderer = observers_[stream_index].get(); |
1628 } | 1686 } |
1629 | 1687 |
1630 private: | 1688 private: |
1631 std::unique_ptr<VideoOutputObserver> observers_[kNumStreams]; | 1689 std::unique_ptr<VideoOutputObserver> observers_[kNumStreams]; |
1632 } tester; | 1690 } tester(&task_queue_); |
1633 | 1691 |
1634 tester.RunTest(); | 1692 tester.RunTest(); |
1635 } | 1693 } |
1636 | 1694 |
1637 TEST_F(EndToEndTest, AssignsTransportSequenceNumbers) { | 1695 TEST_F(EndToEndTest, AssignsTransportSequenceNumbers) { |
1638 static const int kExtensionId = 5; | 1696 static const int kExtensionId = 5; |
1639 | 1697 |
1640 class RtpExtensionHeaderObserver : public test::DirectTransport { | 1698 class RtpExtensionHeaderObserver : public test::DirectTransport { |
1641 public: | 1699 public: |
1642 RtpExtensionHeaderObserver( | 1700 RtpExtensionHeaderObserver( |
| 1701 test::SingleThreadedTaskQueueForTesting* task_queue, |
1643 Call* sender_call, | 1702 Call* sender_call, |
1644 const uint32_t& first_media_ssrc, | 1703 const uint32_t& first_media_ssrc, |
1645 const std::map<uint32_t, uint32_t>& ssrc_map, | 1704 const std::map<uint32_t, uint32_t>& ssrc_map, |
1646 const std::map<uint8_t, MediaType>& payload_type_map) | 1705 const std::map<uint8_t, MediaType>& payload_type_map) |
1647 : DirectTransport(sender_call, payload_type_map), | 1706 : DirectTransport(task_queue, sender_call, payload_type_map), |
1648 done_(false, false), | 1707 done_(false, false), |
1649 parser_(RtpHeaderParser::Create()), | 1708 parser_(RtpHeaderParser::Create()), |
1650 first_media_ssrc_(first_media_ssrc), | 1709 first_media_ssrc_(first_media_ssrc), |
1651 rtx_to_media_ssrcs_(ssrc_map), | 1710 rtx_to_media_ssrcs_(ssrc_map), |
1652 padding_observed_(false), | 1711 padding_observed_(false), |
1653 rtx_padding_observed_(false), | 1712 rtx_padding_observed_(false), |
1654 retransmit_observed_(false), | 1713 retransmit_observed_(false), |
1655 started_(false) { | 1714 started_(false) { |
1656 parser_->RegisterRtpHeaderExtension(kRtpExtensionTransportSequenceNumber, | 1715 parser_->RegisterRtpHeaderExtension(kRtpExtensionTransportSequenceNumber, |
1657 kExtensionId); | 1716 kExtensionId); |
(...skipping 94 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1752 const uint32_t& first_media_ssrc_; | 1811 const uint32_t& first_media_ssrc_; |
1753 const std::map<uint32_t, uint32_t>& rtx_to_media_ssrcs_; | 1812 const std::map<uint32_t, uint32_t>& rtx_to_media_ssrcs_; |
1754 bool padding_observed_; | 1813 bool padding_observed_; |
1755 bool rtx_padding_observed_; | 1814 bool rtx_padding_observed_; |
1756 bool retransmit_observed_; | 1815 bool retransmit_observed_; |
1757 bool started_; | 1816 bool started_; |
1758 }; | 1817 }; |
1759 | 1818 |
1760 class TransportSequenceNumberTester : public MultiStreamTest { | 1819 class TransportSequenceNumberTester : public MultiStreamTest { |
1761 public: | 1820 public: |
1762 TransportSequenceNumberTester() | 1821 explicit TransportSequenceNumberTester( |
1763 : first_media_ssrc_(0), observer_(nullptr) {} | 1822 test::SingleThreadedTaskQueueForTesting* task_queue) |
| 1823 : MultiStreamTest(task_queue), |
| 1824 first_media_ssrc_(0), |
| 1825 observer_(nullptr) {} |
1764 virtual ~TransportSequenceNumberTester() {} | 1826 virtual ~TransportSequenceNumberTester() {} |
1765 | 1827 |
1766 protected: | 1828 protected: |
1767 void Wait() override { | 1829 void Wait() override { |
1768 RTC_DCHECK(observer_); | 1830 RTC_DCHECK(observer_); |
1769 EXPECT_TRUE(observer_->Wait()); | 1831 EXPECT_TRUE(observer_->Wait()); |
1770 } | 1832 } |
1771 | 1833 |
1772 void UpdateSendConfig( | 1834 void UpdateSendConfig( |
1773 size_t stream_index, | 1835 size_t stream_index, |
(...skipping 26 matching lines...) Expand all Loading... |
1800 void UpdateReceiveConfig( | 1862 void UpdateReceiveConfig( |
1801 size_t stream_index, | 1863 size_t stream_index, |
1802 VideoReceiveStream::Config* receive_config) override { | 1864 VideoReceiveStream::Config* receive_config) override { |
1803 receive_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs; | 1865 receive_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs; |
1804 receive_config->rtp.extensions.clear(); | 1866 receive_config->rtp.extensions.clear(); |
1805 receive_config->rtp.extensions.push_back(RtpExtension( | 1867 receive_config->rtp.extensions.push_back(RtpExtension( |
1806 RtpExtension::kTransportSequenceNumberUri, kExtensionId)); | 1868 RtpExtension::kTransportSequenceNumberUri, kExtensionId)); |
1807 receive_config->renderer = &fake_renderer_; | 1869 receive_config->renderer = &fake_renderer_; |
1808 } | 1870 } |
1809 | 1871 |
1810 test::DirectTransport* CreateSendTransport(Call* sender_call) override { | 1872 test::DirectTransport* CreateSendTransport( |
| 1873 test::SingleThreadedTaskQueueForTesting* task_queue, |
| 1874 Call* sender_call) override { |
1811 std::map<uint8_t, MediaType> payload_type_map = | 1875 std::map<uint8_t, MediaType> payload_type_map = |
1812 MultiStreamTest::payload_type_map_; | 1876 MultiStreamTest::payload_type_map_; |
1813 RTC_DCHECK(payload_type_map.find(kSendRtxPayloadType) == | 1877 RTC_DCHECK(payload_type_map.find(kSendRtxPayloadType) == |
1814 payload_type_map.end()); | 1878 payload_type_map.end()); |
1815 payload_type_map[kSendRtxPayloadType] = MediaType::VIDEO; | 1879 payload_type_map[kSendRtxPayloadType] = MediaType::VIDEO; |
1816 observer_ = | 1880 observer_ = new RtpExtensionHeaderObserver( |
1817 new RtpExtensionHeaderObserver(sender_call, first_media_ssrc_, | 1881 task_queue, sender_call, first_media_ssrc_, rtx_to_media_ssrcs_, |
1818 rtx_to_media_ssrcs_, payload_type_map); | 1882 payload_type_map); |
1819 return observer_; | 1883 return observer_; |
1820 } | 1884 } |
1821 | 1885 |
1822 private: | 1886 private: |
1823 test::FakeVideoRenderer fake_renderer_; | 1887 test::FakeVideoRenderer fake_renderer_; |
1824 uint32_t first_media_ssrc_; | 1888 uint32_t first_media_ssrc_; |
1825 std::map<uint32_t, uint32_t> rtx_to_media_ssrcs_; | 1889 std::map<uint32_t, uint32_t> rtx_to_media_ssrcs_; |
1826 RtpExtensionHeaderObserver* observer_; | 1890 RtpExtensionHeaderObserver* observer_; |
1827 } tester; | 1891 } tester(&task_queue_); |
1828 | 1892 |
1829 tester.RunTest(); | 1893 tester.RunTest(); |
1830 } | 1894 } |
1831 | 1895 |
1832 class TransportFeedbackTester : public test::EndToEndTest { | 1896 class TransportFeedbackTester : public test::EndToEndTest { |
1833 public: | 1897 public: |
1834 TransportFeedbackTester(bool feedback_enabled, | 1898 TransportFeedbackTester(bool feedback_enabled, |
1835 size_t num_video_streams, | 1899 size_t num_video_streams, |
1836 size_t num_audio_streams) | 1900 size_t num_audio_streams) |
1837 : EndToEndTest(::webrtc::EndToEndTest::kDefaultTimeoutMs), | 1901 : EndToEndTest(::webrtc::EndToEndTest::kDefaultTimeoutMs), |
(...skipping 192 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2030 | 2094 |
2031 private: | 2095 private: |
2032 std::unique_ptr<uint8_t[]> buffer_; | 2096 std::unique_ptr<uint8_t[]> buffer_; |
2033 size_t length_; | 2097 size_t length_; |
2034 FrameType frame_type_; | 2098 FrameType frame_type_; |
2035 rtc::Event called_; | 2099 rtc::Event called_; |
2036 }; | 2100 }; |
2037 | 2101 |
2038 EncodedFrameTestObserver post_encode_observer; | 2102 EncodedFrameTestObserver post_encode_observer; |
2039 EncodedFrameTestObserver pre_decode_observer; | 2103 EncodedFrameTestObserver pre_decode_observer; |
| 2104 test::FrameForwarder forwarder; |
| 2105 std::unique_ptr<test::FrameGenerator> frame_generator; |
2040 | 2106 |
2041 CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get())); | 2107 std::unique_ptr<test::DirectTransport> sender_transport; |
| 2108 std::unique_ptr<test::DirectTransport> receiver_transport; |
2042 | 2109 |
2043 test::DirectTransport sender_transport(sender_call_.get(), payload_type_map_); | 2110 task_queue_.SendTask([&]() { |
2044 test::DirectTransport receiver_transport(receiver_call_.get(), | 2111 CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get())); |
2045 payload_type_map_); | |
2046 sender_transport.SetReceiver(receiver_call_->Receiver()); | |
2047 receiver_transport.SetReceiver(sender_call_->Receiver()); | |
2048 | 2112 |
2049 CreateSendConfig(1, 0, 0, &sender_transport); | 2113 sender_transport = rtc::MakeUnique<test::DirectTransport>( |
2050 CreateMatchingReceiveConfigs(&receiver_transport); | 2114 &task_queue_, sender_call_.get(), payload_type_map_); |
2051 video_send_config_.post_encode_callback = &post_encode_observer; | 2115 receiver_transport = rtc::MakeUnique<test::DirectTransport>( |
2052 video_receive_configs_[0].pre_decode_callback = &pre_decode_observer; | 2116 &task_queue_, receiver_call_.get(), payload_type_map_); |
| 2117 sender_transport->SetReceiver(receiver_call_->Receiver()); |
| 2118 receiver_transport->SetReceiver(sender_call_->Receiver()); |
2053 | 2119 |
2054 CreateVideoStreams(); | 2120 CreateSendConfig(1, 0, 0, sender_transport.get()); |
2055 Start(); | 2121 CreateMatchingReceiveConfigs(receiver_transport.get()); |
| 2122 video_send_config_.post_encode_callback = &post_encode_observer; |
| 2123 video_receive_configs_[0].pre_decode_callback = &pre_decode_observer; |
2056 | 2124 |
2057 std::unique_ptr<test::FrameGenerator> frame_generator( | 2125 CreateVideoStreams(); |
2058 test::FrameGenerator::CreateSquareGenerator(kDefaultWidth, | 2126 Start(); |
2059 kDefaultHeight)); | 2127 |
2060 test::FrameForwarder forwarder; | 2128 frame_generator = test::FrameGenerator::CreateSquareGenerator( |
2061 video_send_stream_->SetSource( | 2129 kDefaultWidth, kDefaultHeight); |
2062 &forwarder, VideoSendStream::DegradationPreference::kMaintainFramerate); | 2130 video_send_stream_->SetSource( |
2063 forwarder.IncomingCapturedFrame(*frame_generator->NextFrame()); | 2131 &forwarder, VideoSendStream::DegradationPreference::kMaintainFramerate); |
| 2132 forwarder.IncomingCapturedFrame(*frame_generator->NextFrame()); |
| 2133 }); |
2064 | 2134 |
2065 EXPECT_TRUE(post_encode_observer.Wait()) | 2135 EXPECT_TRUE(post_encode_observer.Wait()) |
2066 << "Timed out while waiting for send-side encoded-frame callback."; | 2136 << "Timed out while waiting for send-side encoded-frame callback."; |
2067 | 2137 |
2068 EXPECT_TRUE(pre_decode_observer.Wait()) | 2138 EXPECT_TRUE(pre_decode_observer.Wait()) |
2069 << "Timed out while waiting for pre-decode encoded-frame callback."; | 2139 << "Timed out while waiting for pre-decode encoded-frame callback."; |
2070 | 2140 |
2071 post_encode_observer.ExpectEqualFrames(pre_decode_observer); | 2141 post_encode_observer.ExpectEqualFrames(pre_decode_observer); |
2072 | 2142 |
2073 Stop(); | 2143 task_queue_.SendTask([this, &sender_transport, &receiver_transport]() { |
2074 | 2144 Stop(); |
2075 sender_transport.StopSending(); | 2145 DestroyStreams(); |
2076 receiver_transport.StopSending(); | 2146 sender_transport.reset(); |
2077 | 2147 receiver_transport.reset(); |
2078 DestroyStreams(); | 2148 DestroyCalls(); |
| 2149 }); |
2079 } | 2150 } |
2080 | 2151 |
2081 TEST_F(EndToEndTest, ReceiveStreamSendsRemb) { | 2152 TEST_F(EndToEndTest, ReceiveStreamSendsRemb) { |
2082 class RembObserver : public test::EndToEndTest { | 2153 class RembObserver : public test::EndToEndTest { |
2083 public: | 2154 public: |
2084 RembObserver() : EndToEndTest(kDefaultTimeoutMs) {} | 2155 RembObserver() : EndToEndTest(kDefaultTimeoutMs) {} |
2085 | 2156 |
2086 void ModifyVideoConfigs( | 2157 void ModifyVideoConfigs( |
2087 VideoSendStream::Config* send_config, | 2158 VideoSendStream::Config* send_config, |
2088 std::vector<VideoReceiveStream::Config>* receive_configs, | 2159 std::vector<VideoReceiveStream::Config>* receive_configs, |
(...skipping 107 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2196 receive_transport_(nullptr), | 2267 receive_transport_(nullptr), |
2197 stop_event_(false, false), | 2268 stop_event_(false, false), |
2198 poller_thread_(&BitrateStatsPollingThread, | 2269 poller_thread_(&BitrateStatsPollingThread, |
2199 this, | 2270 this, |
2200 "BitrateStatsPollingThread"), | 2271 "BitrateStatsPollingThread"), |
2201 state_(kWaitForFirstRampUp), | 2272 state_(kWaitForFirstRampUp), |
2202 retransmission_rate_limiter_(clock_, 1000) {} | 2273 retransmission_rate_limiter_(clock_, 1000) {} |
2203 | 2274 |
2204 ~BweObserver() {} | 2275 ~BweObserver() {} |
2205 | 2276 |
2206 test::PacketTransport* CreateReceiveTransport() override { | 2277 test::PacketTransport* CreateReceiveTransport( |
| 2278 test::SingleThreadedTaskQueueForTesting* task_queue) override { |
2207 receive_transport_ = new test::PacketTransport( | 2279 receive_transport_ = new test::PacketTransport( |
2208 nullptr, this, test::PacketTransport::kReceiver, payload_type_map_, | 2280 task_queue, nullptr, this, test::PacketTransport::kReceiver, |
2209 FakeNetworkPipe::Config()); | 2281 payload_type_map_, FakeNetworkPipe::Config()); |
2210 return receive_transport_; | 2282 return receive_transport_; |
2211 } | 2283 } |
2212 | 2284 |
2213 Call::Config GetSenderCallConfig() override { | 2285 Call::Config GetSenderCallConfig() override { |
2214 Call::Config config(event_log_.get()); | 2286 Call::Config config(event_log_.get()); |
2215 // Set a high start bitrate to reduce the test completion time. | 2287 // Set a high start bitrate to reduce the test completion time. |
2216 config.bitrate_config.start_bitrate_bps = remb_bitrate_bps_; | 2288 config.bitrate_config.start_bitrate_bps = remb_bitrate_bps_; |
2217 return config; | 2289 return config; |
2218 } | 2290 } |
2219 | 2291 |
(...skipping 86 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2306 TestState state_; | 2378 TestState state_; |
2307 RateLimiter retransmission_rate_limiter_; | 2379 RateLimiter retransmission_rate_limiter_; |
2308 } test; | 2380 } test; |
2309 | 2381 |
2310 RunBaseTest(&test); | 2382 RunBaseTest(&test); |
2311 } | 2383 } |
2312 | 2384 |
2313 TEST_F(EndToEndTest, StopSendingKeyframeRequestsForInactiveStream) { | 2385 TEST_F(EndToEndTest, StopSendingKeyframeRequestsForInactiveStream) { |
2314 class KeyframeRequestObserver : public test::EndToEndTest { | 2386 class KeyframeRequestObserver : public test::EndToEndTest { |
2315 public: | 2387 public: |
2316 KeyframeRequestObserver() : clock_(Clock::GetRealTimeClock()) {} | 2388 explicit KeyframeRequestObserver( |
| 2389 test::SingleThreadedTaskQueueForTesting* task_queue) |
| 2390 : clock_(Clock::GetRealTimeClock()), task_queue_(task_queue) {} |
2317 | 2391 |
2318 void OnVideoStreamsCreated( | 2392 void OnVideoStreamsCreated( |
2319 VideoSendStream* send_stream, | 2393 VideoSendStream* send_stream, |
2320 const std::vector<VideoReceiveStream*>& receive_streams) override { | 2394 const std::vector<VideoReceiveStream*>& receive_streams) override { |
2321 RTC_DCHECK_EQ(1, receive_streams.size()); | 2395 RTC_DCHECK_EQ(1, receive_streams.size()); |
2322 send_stream_ = send_stream; | 2396 send_stream_ = send_stream; |
2323 receive_stream_ = receive_streams[0]; | 2397 receive_stream_ = receive_streams[0]; |
2324 } | 2398 } |
2325 | 2399 |
2326 void PerformTest() override { | 2400 void PerformTest() override { |
2327 bool frame_decoded = false; | 2401 bool frame_decoded = false; |
2328 int64_t start_time = clock_->TimeInMilliseconds(); | 2402 int64_t start_time = clock_->TimeInMilliseconds(); |
2329 while (clock_->TimeInMilliseconds() - start_time <= 5000) { | 2403 while (clock_->TimeInMilliseconds() - start_time <= 5000) { |
2330 if (receive_stream_->GetStats().frames_decoded > 0) { | 2404 if (receive_stream_->GetStats().frames_decoded > 0) { |
2331 frame_decoded = true; | 2405 frame_decoded = true; |
2332 break; | 2406 break; |
2333 } | 2407 } |
2334 SleepMs(100); | 2408 SleepMs(100); |
2335 } | 2409 } |
2336 ASSERT_TRUE(frame_decoded); | 2410 ASSERT_TRUE(frame_decoded); |
2337 send_stream_->Stop(); | 2411 task_queue_->SendTask([this]() { send_stream_->Stop(); }); |
2338 SleepMs(10000); | 2412 SleepMs(10000); |
2339 ASSERT_EQ( | 2413 ASSERT_EQ( |
2340 1U, receive_stream_->GetStats().rtcp_packet_type_counts.pli_packets); | 2414 1U, receive_stream_->GetStats().rtcp_packet_type_counts.pli_packets); |
2341 } | 2415 } |
2342 | 2416 |
2343 private: | 2417 private: |
2344 Clock* clock_; | 2418 Clock* clock_; |
2345 VideoSendStream* send_stream_; | 2419 VideoSendStream* send_stream_; |
2346 VideoReceiveStream* receive_stream_; | 2420 VideoReceiveStream* receive_stream_; |
2347 } test; | 2421 test::SingleThreadedTaskQueueForTesting* const task_queue_; |
| 2422 } test(&task_queue_); |
2348 | 2423 |
2349 RunBaseTest(&test); | 2424 RunBaseTest(&test); |
2350 } | 2425 } |
2351 | 2426 |
2352 class ProbingTest : public test::EndToEndTest { | 2427 class ProbingTest : public test::EndToEndTest { |
2353 public: | 2428 public: |
2354 explicit ProbingTest(int start_bitrate_bps) | 2429 explicit ProbingTest(int start_bitrate_bps) |
2355 : clock_(Clock::GetRealTimeClock()), | 2430 : clock_(Clock::GetRealTimeClock()), |
2356 start_bitrate_bps_(start_bitrate_bps), | 2431 start_bitrate_bps_(start_bitrate_bps), |
2357 state_(0), | 2432 state_(0), |
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2422 TEST_F(EndToEndTest, DISABLED_TriggerMidCallProbing) { | 2497 TEST_F(EndToEndTest, DISABLED_TriggerMidCallProbing) { |
2423 // Fails on iOS bots: bugs.webrtc.org/7851 | 2498 // Fails on iOS bots: bugs.webrtc.org/7851 |
2424 #elif defined(TARGET_IPHONE_SIMULATOR) && TARGET_IPHONE_SIMULATOR | 2499 #elif defined(TARGET_IPHONE_SIMULATOR) && TARGET_IPHONE_SIMULATOR |
2425 TEST_F(EndToEndTest, DISABLED_TriggerMidCallProbing) { | 2500 TEST_F(EndToEndTest, DISABLED_TriggerMidCallProbing) { |
2426 #else | 2501 #else |
2427 TEST_F(EndToEndTest, TriggerMidCallProbing) { | 2502 TEST_F(EndToEndTest, TriggerMidCallProbing) { |
2428 #endif | 2503 #endif |
2429 | 2504 |
2430 class TriggerMidCallProbingTest : public ProbingTest { | 2505 class TriggerMidCallProbingTest : public ProbingTest { |
2431 public: | 2506 public: |
2432 explicit TriggerMidCallProbingTest(bool* success) | 2507 TriggerMidCallProbingTest( |
2433 : ProbingTest(300000), success_(success) {} | 2508 test::SingleThreadedTaskQueueForTesting* task_queue, |
| 2509 bool* success) |
| 2510 : ProbingTest(300000), success_(success), task_queue_(task_queue) {} |
2434 | 2511 |
2435 void PerformTest() override { | 2512 void PerformTest() override { |
2436 *success_ = false; | 2513 *success_ = false; |
2437 int64_t start_time_ms = clock_->TimeInMilliseconds(); | 2514 int64_t start_time_ms = clock_->TimeInMilliseconds(); |
2438 do { | 2515 do { |
2439 if (clock_->TimeInMilliseconds() - start_time_ms > kTimeoutMs) | 2516 if (clock_->TimeInMilliseconds() - start_time_ms > kTimeoutMs) |
2440 break; | 2517 break; |
2441 | 2518 |
2442 Call::Stats stats = sender_call_->GetStats(); | 2519 Call::Stats stats = sender_call_->GetStats(); |
2443 | 2520 |
2444 switch (state_) { | 2521 switch (state_) { |
2445 case 0: | 2522 case 0: |
2446 if (stats.send_bandwidth_bps > 5 * 300000) { | 2523 if (stats.send_bandwidth_bps > 5 * 300000) { |
2447 Call::Config::BitrateConfig bitrate_config; | 2524 Call::Config::BitrateConfig bitrate_config; |
2448 bitrate_config.max_bitrate_bps = 100000; | 2525 bitrate_config.max_bitrate_bps = 100000; |
2449 sender_call_->SetBitrateConfig(bitrate_config); | 2526 task_queue_->SendTask([this, &bitrate_config]() { |
| 2527 sender_call_->SetBitrateConfig(bitrate_config); |
| 2528 }); |
2450 ++state_; | 2529 ++state_; |
2451 } | 2530 } |
2452 break; | 2531 break; |
2453 case 1: | 2532 case 1: |
2454 if (stats.send_bandwidth_bps < 110000) { | 2533 if (stats.send_bandwidth_bps < 110000) { |
2455 Call::Config::BitrateConfig bitrate_config; | 2534 Call::Config::BitrateConfig bitrate_config; |
2456 bitrate_config.max_bitrate_bps = 2500000; | 2535 bitrate_config.max_bitrate_bps = 2500000; |
2457 sender_call_->SetBitrateConfig(bitrate_config); | 2536 task_queue_->SendTask([this, &bitrate_config]() { |
| 2537 sender_call_->SetBitrateConfig(bitrate_config); |
| 2538 }); |
2458 ++state_; | 2539 ++state_; |
2459 } | 2540 } |
2460 break; | 2541 break; |
2461 case 2: | 2542 case 2: |
2462 // During high cpu load the pacer will not be able to pace packets | 2543 // During high cpu load the pacer will not be able to pace packets |
2463 // at the correct speed, but if we go from 110 to 1250 kbps | 2544 // at the correct speed, but if we go from 110 to 1250 kbps |
2464 // in 5 seconds then it is due to probing. | 2545 // in 5 seconds then it is due to probing. |
2465 if (stats.send_bandwidth_bps > 1250000) { | 2546 if (stats.send_bandwidth_bps > 1250000) { |
2466 *success_ = true; | 2547 *success_ = true; |
2467 observation_complete_.Set(); | 2548 observation_complete_.Set(); |
2468 } | 2549 } |
2469 break; | 2550 break; |
2470 } | 2551 } |
2471 } while (!observation_complete_.Wait(20)); | 2552 } while (!observation_complete_.Wait(20)); |
2472 } | 2553 } |
2473 | 2554 |
2474 private: | 2555 private: |
2475 const int kTimeoutMs = 5000; | 2556 const int kTimeoutMs = 5000; |
2476 bool* const success_; | 2557 bool* const success_; |
| 2558 test::SingleThreadedTaskQueueForTesting* const task_queue_; |
2477 }; | 2559 }; |
2478 | 2560 |
2479 bool success = false; | 2561 bool success = false; |
2480 const int kMaxAttempts = 3; | 2562 const int kMaxAttempts = 3; |
2481 for (int i = 0; i < kMaxAttempts; ++i) { | 2563 for (int i = 0; i < kMaxAttempts; ++i) { |
2482 TriggerMidCallProbingTest test(&success); | 2564 TriggerMidCallProbingTest test(&task_queue_, &success); |
2483 RunBaseTest(&test); | 2565 RunBaseTest(&test); |
2484 if (success) | 2566 if (success) |
2485 return; | 2567 return; |
2486 } | 2568 } |
2487 EXPECT_TRUE(success) << "Failed to perform mid call probing (" << kMaxAttempts | 2569 EXPECT_TRUE(success) << "Failed to perform mid call probing (" << kMaxAttempts |
2488 << " attempts)."; | 2570 << " attempts)."; |
2489 } | 2571 } |
2490 | 2572 |
2491 TEST_F(EndToEndTest, VerifyNackStats) { | 2573 TEST_F(EndToEndTest, VerifyNackStats) { |
2492 static const int kPacketNumberToDrop = 200; | 2574 static const int kPacketNumberToDrop = 200; |
(...skipping 211 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2704 const std::unique_ptr<VideoEncoder> vp8_encoder_; | 2786 const std::unique_ptr<VideoEncoder> vp8_encoder_; |
2705 Call* sender_call_; | 2787 Call* sender_call_; |
2706 Call* receiver_call_; | 2788 Call* receiver_call_; |
2707 int64_t start_runtime_ms_; | 2789 int64_t start_runtime_ms_; |
2708 int num_frames_received_ GUARDED_BY(&crit_); | 2790 int num_frames_received_ GUARDED_BY(&crit_); |
2709 } test(use_rtx, use_red, screenshare); | 2791 } test(use_rtx, use_red, screenshare); |
2710 | 2792 |
2711 metrics::Reset(); | 2793 metrics::Reset(); |
2712 RunBaseTest(&test); | 2794 RunBaseTest(&test); |
2713 | 2795 |
2714 // Delete the call for Call stats to be reported. | |
2715 sender_call_.reset(); | |
2716 receiver_call_.reset(); | |
2717 | |
2718 std::string video_prefix = | 2796 std::string video_prefix = |
2719 screenshare ? "WebRTC.Video.Screenshare." : "WebRTC.Video."; | 2797 screenshare ? "WebRTC.Video.Screenshare." : "WebRTC.Video."; |
2720 | 2798 |
2721 // Verify that stats have been updated once. | 2799 // Verify that stats have been updated once. |
2722 EXPECT_EQ(2, metrics::NumSamples("WebRTC.Call.LifetimeInSeconds")); | 2800 EXPECT_EQ(2, metrics::NumSamples("WebRTC.Call.LifetimeInSeconds")); |
2723 EXPECT_EQ(1, metrics::NumSamples( | 2801 EXPECT_EQ(1, metrics::NumSamples( |
2724 "WebRTC.Call.TimeReceivingVideoRtpPacketsInSeconds")); | 2802 "WebRTC.Call.TimeReceivingVideoRtpPacketsInSeconds")); |
2725 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Call.VideoBitrateReceivedInKbps")); | 2803 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Call.VideoBitrateReceivedInKbps")); |
2726 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Call.RtcpBitrateReceivedInBps")); | 2804 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Call.RtcpBitrateReceivedInBps")); |
2727 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Call.BitrateReceivedInKbps")); | 2805 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Call.BitrateReceivedInKbps")); |
(...skipping 146 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2874 | 2952 |
2875 rtc::CriticalSection crit_; | 2953 rtc::CriticalSection crit_; |
2876 int num_frames_received_ GUARDED_BY(&crit_); | 2954 int num_frames_received_ GUARDED_BY(&crit_); |
2877 } test; | 2955 } test; |
2878 | 2956 |
2879 test::ScopedFieldTrials override_field_trials( | 2957 test::ScopedFieldTrials override_field_trials( |
2880 "WebRTC-VideoContentTypeExtension/Enabled/"); | 2958 "WebRTC-VideoContentTypeExtension/Enabled/"); |
2881 metrics::Reset(); | 2959 metrics::Reset(); |
2882 | 2960 |
2883 Call::Config send_config(test.GetSenderCallConfig()); | 2961 Call::Config send_config(test.GetSenderCallConfig()); |
2884 CreateSenderCall(send_config); | |
2885 Call::Config recv_config(test.GetReceiverCallConfig()); | 2962 Call::Config recv_config(test.GetReceiverCallConfig()); |
2886 CreateReceiverCall(recv_config); | 2963 VideoEncoderConfig encoder_config_with_screenshare; |
2887 receive_transport_.reset(test.CreateReceiveTransport()); | |
2888 send_transport_.reset(test.CreateSendTransport(sender_call_.get())); | |
2889 send_transport_->SetReceiver(receiver_call_->Receiver()); | |
2890 receive_transport_->SetReceiver(sender_call_->Receiver()); | |
2891 receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp); | |
2892 CreateSendConfig(1, 0, 0, send_transport_.get()); | |
2893 CreateMatchingReceiveConfigs(receive_transport_.get()); | |
2894 | 2964 |
2895 // Modify send and receive configs. | 2965 task_queue_.SendTask([this, &test, &override_field_trials, &send_config, |
2896 video_send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs; | 2966 &recv_config, &encoder_config_with_screenshare]() { |
2897 video_receive_configs_[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs; | 2967 CreateSenderCall(send_config); |
2898 video_receive_configs_[0].renderer = &test; | 2968 CreateReceiverCall(recv_config); |
2899 // RTT needed for RemoteNtpTimeEstimator for the receive stream. | |
2900 video_receive_configs_[0].rtp.rtcp_xr.receiver_reference_time_report = true; | |
2901 // Start with realtime video. | |
2902 video_encoder_config_.content_type = | |
2903 VideoEncoderConfig::ContentType::kRealtimeVideo; | |
2904 // Second encoder config for the second part of the test uses screenshare | |
2905 VideoEncoderConfig encoder_config_with_screenshare_ = | |
2906 video_encoder_config_.Copy(); | |
2907 encoder_config_with_screenshare_.content_type = | |
2908 VideoEncoderConfig::ContentType::kScreen; | |
2909 | 2969 |
2910 CreateVideoStreams(); | 2970 receive_transport_.reset(test.CreateReceiveTransport(&task_queue_)); |
2911 CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth, | 2971 send_transport_.reset( |
2912 kDefaultHeight); | 2972 test.CreateSendTransport(&task_queue_, sender_call_.get())); |
2913 Start(); | 2973 send_transport_->SetReceiver(receiver_call_->Receiver()); |
| 2974 receive_transport_->SetReceiver(sender_call_->Receiver()); |
| 2975 |
| 2976 receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp); |
| 2977 CreateSendConfig(1, 0, 0, send_transport_.get()); |
| 2978 CreateMatchingReceiveConfigs(receive_transport_.get()); |
| 2979 |
| 2980 // Modify send and receive configs. |
| 2981 video_send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs; |
| 2982 video_receive_configs_[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs; |
| 2983 video_receive_configs_[0].renderer = &test; |
| 2984 // RTT needed for RemoteNtpTimeEstimator for the receive stream. |
| 2985 video_receive_configs_[0].rtp.rtcp_xr.receiver_reference_time_report = true; |
| 2986 // Start with realtime video. |
| 2987 video_encoder_config_.content_type = |
| 2988 VideoEncoderConfig::ContentType::kRealtimeVideo; |
| 2989 // Second encoder config for the second part of the test uses screenshare |
| 2990 encoder_config_with_screenshare = video_encoder_config_.Copy(); |
| 2991 encoder_config_with_screenshare.content_type = |
| 2992 VideoEncoderConfig::ContentType::kScreen; |
| 2993 |
| 2994 CreateVideoStreams(); |
| 2995 CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth, |
| 2996 kDefaultHeight); |
| 2997 Start(); |
| 2998 }); |
2914 | 2999 |
2915 test.PerformTest(); | 3000 test.PerformTest(); |
2916 | 3001 |
2917 // Replace old send stream. | 3002 // Replace old send stream. |
2918 sender_call_->DestroyVideoSendStream(video_send_stream_); | 3003 task_queue_.SendTask([this, &encoder_config_with_screenshare]() { |
2919 video_send_stream_ = sender_call_->CreateVideoSendStream( | 3004 sender_call_->DestroyVideoSendStream(video_send_stream_); |
2920 video_send_config_.Copy(), encoder_config_with_screenshare_.Copy()); | 3005 video_send_stream_ = sender_call_->CreateVideoSendStream( |
2921 video_send_stream_->SetSource( | 3006 video_send_config_.Copy(), encoder_config_with_screenshare.Copy()); |
2922 frame_generator_capturer_.get(), | 3007 video_send_stream_->SetSource( |
2923 VideoSendStream::DegradationPreference::kBalanced); | 3008 frame_generator_capturer_.get(), |
2924 video_send_stream_->Start(); | 3009 VideoSendStream::DegradationPreference::kBalanced); |
| 3010 video_send_stream_->Start(); |
| 3011 }); |
2925 | 3012 |
2926 // Continue to run test but now with screenshare. | 3013 // Continue to run test but now with screenshare. |
2927 test.PerformTest(); | 3014 test.PerformTest(); |
2928 | 3015 |
2929 send_transport_->StopSending(); | 3016 task_queue_.SendTask([this]() { |
2930 receive_transport_->StopSending(); | 3017 Stop(); |
2931 Stop(); | 3018 DestroyStreams(); |
2932 DestroyStreams(); | 3019 send_transport_.reset(); |
2933 DestroyCalls(); | 3020 receive_transport_.reset(); |
2934 // Delete the call for Call stats to be reported. | 3021 DestroyCalls(); |
2935 sender_call_.reset(); | 3022 }); |
2936 receiver_call_.reset(); | |
2937 | 3023 |
2938 // Verify that stats have been updated for both screenshare and video. | 3024 // Verify that stats have been updated for both screenshare and video. |
2939 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.EndToEndDelayInMs")); | 3025 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.EndToEndDelayInMs")); |
2940 EXPECT_EQ(1, | 3026 EXPECT_EQ(1, |
2941 metrics::NumSamples("WebRTC.Video.Screenshare.EndToEndDelayInMs")); | 3027 metrics::NumSamples("WebRTC.Video.Screenshare.EndToEndDelayInMs")); |
2942 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.EndToEndDelayMaxInMs")); | 3028 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.EndToEndDelayMaxInMs")); |
2943 EXPECT_EQ( | 3029 EXPECT_EQ( |
2944 1, metrics::NumSamples("WebRTC.Video.Screenshare.EndToEndDelayMaxInMs")); | 3030 1, metrics::NumSamples("WebRTC.Video.Screenshare.EndToEndDelayMaxInMs")); |
2945 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.InterframeDelayInMs")); | 3031 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.InterframeDelayInMs")); |
2946 EXPECT_EQ(1, | 3032 EXPECT_EQ(1, |
(...skipping 143 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3090 VideoEncoderConfig video_encoder_config_all_streams_; | 3176 VideoEncoderConfig video_encoder_config_all_streams_; |
3091 } test(kVideoSendSsrcs, num_ssrcs, send_single_ssrc_first); | 3177 } test(kVideoSendSsrcs, num_ssrcs, send_single_ssrc_first); |
3092 | 3178 |
3093 RunBaseTest(&test); | 3179 RunBaseTest(&test); |
3094 } | 3180 } |
3095 | 3181 |
3096 TEST_F(EndToEndTest, ReportsSetEncoderRates) { | 3182 TEST_F(EndToEndTest, ReportsSetEncoderRates) { |
3097 class EncoderRateStatsTest : public test::EndToEndTest, | 3183 class EncoderRateStatsTest : public test::EndToEndTest, |
3098 public test::FakeEncoder { | 3184 public test::FakeEncoder { |
3099 public: | 3185 public: |
3100 EncoderRateStatsTest() | 3186 explicit EncoderRateStatsTest( |
| 3187 test::SingleThreadedTaskQueueForTesting* task_queue) |
3101 : EndToEndTest(kDefaultTimeoutMs), | 3188 : EndToEndTest(kDefaultTimeoutMs), |
3102 FakeEncoder(Clock::GetRealTimeClock()), | 3189 FakeEncoder(Clock::GetRealTimeClock()), |
| 3190 task_queue_(task_queue), |
3103 send_stream_(nullptr), | 3191 send_stream_(nullptr), |
3104 bitrate_kbps_(0) {} | 3192 bitrate_kbps_(0) {} |
3105 | 3193 |
3106 void OnVideoStreamsCreated( | 3194 void OnVideoStreamsCreated( |
3107 VideoSendStream* send_stream, | 3195 VideoSendStream* send_stream, |
3108 const std::vector<VideoReceiveStream*>& receive_streams) override { | 3196 const std::vector<VideoReceiveStream*>& receive_streams) override { |
3109 send_stream_ = send_stream; | 3197 send_stream_ = send_stream; |
3110 } | 3198 } |
3111 | 3199 |
3112 void ModifyVideoConfigs( | 3200 void ModifyVideoConfigs( |
(...skipping 11 matching lines...) Expand all Loading... |
3124 return 0; | 3212 return 0; |
3125 rtc::CritScope lock(&crit_); | 3213 rtc::CritScope lock(&crit_); |
3126 bitrate_kbps_ = rate_allocation.get_sum_kbps(); | 3214 bitrate_kbps_ = rate_allocation.get_sum_kbps(); |
3127 observation_complete_.Set(); | 3215 observation_complete_.Set(); |
3128 return 0; | 3216 return 0; |
3129 } | 3217 } |
3130 | 3218 |
3131 void PerformTest() override { | 3219 void PerformTest() override { |
3132 ASSERT_TRUE(Wait()) | 3220 ASSERT_TRUE(Wait()) |
3133 << "Timed out while waiting for encoder SetRates() call."; | 3221 << "Timed out while waiting for encoder SetRates() call."; |
3134 WaitForEncoderTargetBitrateMatchStats(); | 3222 |
3135 send_stream_->Stop(); | 3223 task_queue_->SendTask([this]() { |
3136 WaitForStatsReportZeroTargetBitrate(); | 3224 WaitForEncoderTargetBitrateMatchStats(); |
3137 send_stream_->Start(); | 3225 send_stream_->Stop(); |
3138 WaitForEncoderTargetBitrateMatchStats(); | 3226 WaitForStatsReportZeroTargetBitrate(); |
| 3227 send_stream_->Start(); |
| 3228 WaitForEncoderTargetBitrateMatchStats(); |
| 3229 }); |
3139 } | 3230 } |
3140 | 3231 |
3141 void WaitForEncoderTargetBitrateMatchStats() { | 3232 void WaitForEncoderTargetBitrateMatchStats() { |
3142 for (int i = 0; i < kDefaultTimeoutMs; ++i) { | 3233 for (int i = 0; i < kDefaultTimeoutMs; ++i) { |
3143 VideoSendStream::Stats stats = send_stream_->GetStats(); | 3234 VideoSendStream::Stats stats = send_stream_->GetStats(); |
3144 { | 3235 { |
3145 rtc::CritScope lock(&crit_); | 3236 rtc::CritScope lock(&crit_); |
3146 if ((stats.target_media_bitrate_bps + 500) / 1000 == | 3237 if ((stats.target_media_bitrate_bps + 500) / 1000 == |
3147 static_cast<int>(bitrate_kbps_)) { | 3238 static_cast<int>(bitrate_kbps_)) { |
3148 return; | 3239 return; |
3149 } | 3240 } |
3150 } | 3241 } |
3151 SleepMs(1); | 3242 SleepMs(1); |
3152 } | 3243 } |
3153 FAIL() | 3244 FAIL() |
3154 << "Timed out waiting for stats reporting the currently set bitrate."; | 3245 << "Timed out waiting for stats reporting the currently set bitrate."; |
3155 } | 3246 } |
3156 | 3247 |
3157 void WaitForStatsReportZeroTargetBitrate() { | 3248 void WaitForStatsReportZeroTargetBitrate() { |
3158 for (int i = 0; i < kDefaultTimeoutMs; ++i) { | 3249 for (int i = 0; i < kDefaultTimeoutMs; ++i) { |
3159 if (send_stream_->GetStats().target_media_bitrate_bps == 0) { | 3250 if (send_stream_->GetStats().target_media_bitrate_bps == 0) { |
3160 return; | 3251 return; |
3161 } | 3252 } |
3162 SleepMs(1); | 3253 SleepMs(1); |
3163 } | 3254 } |
3164 FAIL() << "Timed out waiting for stats reporting zero bitrate."; | 3255 FAIL() << "Timed out waiting for stats reporting zero bitrate."; |
3165 } | 3256 } |
3166 | 3257 |
3167 private: | 3258 private: |
| 3259 test::SingleThreadedTaskQueueForTesting* const task_queue_; |
3168 rtc::CriticalSection crit_; | 3260 rtc::CriticalSection crit_; |
3169 VideoSendStream* send_stream_; | 3261 VideoSendStream* send_stream_; |
3170 uint32_t bitrate_kbps_ GUARDED_BY(crit_); | 3262 uint32_t bitrate_kbps_ GUARDED_BY(crit_); |
3171 } test; | 3263 } test(&task_queue_); |
3172 | 3264 |
3173 RunBaseTest(&test); | 3265 RunBaseTest(&test); |
3174 } | 3266 } |
3175 | 3267 |
3176 TEST_F(EndToEndTest, GetStats) { | 3268 TEST_F(EndToEndTest, GetStats) { |
3177 static const int kStartBitrateBps = 3000000; | 3269 static const int kStartBitrateBps = 3000000; |
3178 static const int kExpectedRenderDelayMs = 20; | 3270 static const int kExpectedRenderDelayMs = 20; |
3179 | 3271 |
3180 class ReceiveStreamRenderer : public rtc::VideoSinkInterface<VideoFrame> { | 3272 class ReceiveStreamRenderer : public rtc::VideoSinkInterface<VideoFrame> { |
3181 public: | 3273 public: |
(...skipping 186 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3368 } | 3460 } |
3369 | 3461 |
3370 bool AllStatsFilled(const std::map<std::string, bool>& stats_map) { | 3462 bool AllStatsFilled(const std::map<std::string, bool>& stats_map) { |
3371 for (const auto& stat : stats_map) { | 3463 for (const auto& stat : stats_map) { |
3372 if (!stat.second) | 3464 if (!stat.second) |
3373 return false; | 3465 return false; |
3374 } | 3466 } |
3375 return true; | 3467 return true; |
3376 } | 3468 } |
3377 | 3469 |
3378 test::PacketTransport* CreateSendTransport(Call* sender_call) override { | 3470 test::PacketTransport* CreateSendTransport( |
| 3471 test::SingleThreadedTaskQueueForTesting* task_queue, |
| 3472 Call* sender_call) override { |
3379 FakeNetworkPipe::Config network_config; | 3473 FakeNetworkPipe::Config network_config; |
3380 network_config.loss_percent = 5; | 3474 network_config.loss_percent = 5; |
3381 return new test::PacketTransport(sender_call, this, | 3475 return new test::PacketTransport(task_queue, sender_call, this, |
3382 test::PacketTransport::kSender, | 3476 test::PacketTransport::kSender, |
3383 payload_type_map_, network_config); | 3477 payload_type_map_, network_config); |
3384 } | 3478 } |
3385 | 3479 |
3386 Call::Config GetSenderCallConfig() override { | 3480 Call::Config GetSenderCallConfig() override { |
3387 Call::Config config = EndToEndTest::GetSenderCallConfig(); | 3481 Call::Config config = EndToEndTest::GetSenderCallConfig(); |
3388 config.bitrate_config.start_bitrate_bps = kStartBitrateBps; | 3482 config.bitrate_config.start_bitrate_bps = kStartBitrateBps; |
3389 return config; | 3483 return config; |
3390 } | 3484 } |
3391 | 3485 |
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3476 | 3570 |
3477 int64_t time_until_timout_ = stop_time - now; | 3571 int64_t time_until_timout_ = stop_time - now; |
3478 if (time_until_timout_ > 0) | 3572 if (time_until_timout_ > 0) |
3479 check_stats_event_.Wait(time_until_timout_); | 3573 check_stats_event_.Wait(time_until_timout_); |
3480 now = clock->TimeInMilliseconds(); | 3574 now = clock->TimeInMilliseconds(); |
3481 } | 3575 } |
3482 | 3576 |
3483 ADD_FAILURE() << "Timed out waiting for filled stats."; | 3577 ADD_FAILURE() << "Timed out waiting for filled stats."; |
3484 for (std::map<std::string, bool>::const_iterator it = | 3578 for (std::map<std::string, bool>::const_iterator it = |
3485 receive_stats_filled_.begin(); | 3579 receive_stats_filled_.begin(); |
3486 it != receive_stats_filled_.end(); | 3580 it != receive_stats_filled_.end(); ++it) { |
3487 ++it) { | |
3488 if (!it->second) { | 3581 if (!it->second) { |
3489 ADD_FAILURE() << "Missing receive stats: " << it->first; | 3582 ADD_FAILURE() << "Missing receive stats: " << it->first; |
3490 } | 3583 } |
3491 } | 3584 } |
3492 | 3585 |
3493 for (std::map<std::string, bool>::const_iterator it = | 3586 for (std::map<std::string, bool>::const_iterator it = |
3494 send_stats_filled_.begin(); | 3587 send_stats_filled_.begin(); |
3495 it != send_stats_filled_.end(); | 3588 it != send_stats_filled_.end(); ++it) { |
3496 ++it) { | |
3497 if (!it->second) { | 3589 if (!it->second) { |
3498 ADD_FAILURE() << "Missing send stats: " << it->first; | 3590 ADD_FAILURE() << "Missing send stats: " << it->first; |
3499 } | 3591 } |
3500 } | 3592 } |
3501 } | 3593 } |
3502 | 3594 |
3503 test::DelayedEncoder encoder_; | 3595 test::DelayedEncoder encoder_; |
3504 std::vector<VideoReceiveStream*> receive_streams_; | 3596 std::vector<VideoReceiveStream*> receive_streams_; |
3505 std::map<std::string, bool> receive_stats_filled_; | 3597 std::map<std::string, bool> receive_stats_filled_; |
3506 | 3598 |
(...skipping 468 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3975 SequenceNumberUnwrapper seq_numbers_unwrapper_; | 4067 SequenceNumberUnwrapper seq_numbers_unwrapper_; |
3976 std::map<uint32_t, std::list<int64_t>> last_observed_seq_numbers_; | 4068 std::map<uint32_t, std::list<int64_t>> last_observed_seq_numbers_; |
3977 std::map<uint32_t, uint32_t> last_observed_timestamp_; | 4069 std::map<uint32_t, uint32_t> last_observed_timestamp_; |
3978 std::map<uint32_t, bool> ssrc_is_rtx_; | 4070 std::map<uint32_t, bool> ssrc_is_rtx_; |
3979 | 4071 |
3980 rtc::CriticalSection crit_; | 4072 rtc::CriticalSection crit_; |
3981 size_t ssrcs_to_observe_ GUARDED_BY(crit_); | 4073 size_t ssrcs_to_observe_ GUARDED_BY(crit_); |
3982 std::map<uint32_t, bool> ssrc_observed_ GUARDED_BY(crit_); | 4074 std::map<uint32_t, bool> ssrc_observed_ GUARDED_BY(crit_); |
3983 } observer(use_rtx); | 4075 } observer(use_rtx); |
3984 | 4076 |
| 4077 std::unique_ptr<test::PacketTransport> send_transport; |
| 4078 std::unique_ptr<test::PacketTransport> receive_transport; |
| 4079 |
3985 Call::Config config(event_log_.get()); | 4080 Call::Config config(event_log_.get()); |
3986 CreateCalls(config, config); | 4081 VideoEncoderConfig one_stream; |
3987 | 4082 |
3988 test::PacketTransport send_transport( | 4083 task_queue_.SendTask([this, &observer, &send_transport, &receive_transport, |
3989 sender_call_.get(), &observer, test::PacketTransport::kSender, | 4084 &config, &one_stream, use_rtx]() { |
3990 payload_type_map_, FakeNetworkPipe::Config()); | 4085 CreateCalls(config, config); |
3991 test::PacketTransport receive_transport( | |
3992 nullptr, &observer, test::PacketTransport::kReceiver, payload_type_map_, | |
3993 FakeNetworkPipe::Config()); | |
3994 send_transport.SetReceiver(receiver_call_->Receiver()); | |
3995 receive_transport.SetReceiver(sender_call_->Receiver()); | |
3996 | 4086 |
3997 CreateSendConfig(kNumSsrcs, 0, 0, &send_transport); | 4087 send_transport = rtc::MakeUnique<test::PacketTransport>( |
| 4088 &task_queue_, sender_call_.get(), &observer, |
| 4089 test::PacketTransport::kSender, payload_type_map_, |
| 4090 FakeNetworkPipe::Config()); |
| 4091 receive_transport = rtc::MakeUnique<test::PacketTransport>( |
| 4092 &task_queue_, nullptr, &observer, test::PacketTransport::kReceiver, |
| 4093 payload_type_map_, FakeNetworkPipe::Config()); |
| 4094 send_transport->SetReceiver(receiver_call_->Receiver()); |
| 4095 receive_transport->SetReceiver(sender_call_->Receiver()); |
3998 | 4096 |
3999 if (use_rtx) { | 4097 CreateSendConfig(kNumSsrcs, 0, 0, send_transport.get()); |
4000 for (size_t i = 0; i < kNumSsrcs; ++i) { | 4098 |
4001 video_send_config_.rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]); | 4099 if (use_rtx) { |
| 4100 for (size_t i = 0; i < kNumSsrcs; ++i) { |
| 4101 video_send_config_.rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]); |
| 4102 } |
| 4103 video_send_config_.rtp.rtx.payload_type = kSendRtxPayloadType; |
4002 } | 4104 } |
4003 video_send_config_.rtp.rtx.payload_type = kSendRtxPayloadType; | |
4004 } | |
4005 | 4105 |
4006 video_encoder_config_.video_stream_factory = | 4106 video_encoder_config_.video_stream_factory = |
4007 new rtc::RefCountedObject<VideoStreamFactory>(); | 4107 new rtc::RefCountedObject<VideoStreamFactory>(); |
4008 // Use the same total bitrates when sending a single stream to avoid lowering | 4108 // Use the same total bitrates when sending a single stream to avoid |
4009 // the bitrate estimate and requiring a subsequent rampup. | 4109 // lowering the bitrate estimate and requiring a subsequent rampup. |
4010 VideoEncoderConfig one_stream = video_encoder_config_.Copy(); | 4110 one_stream = video_encoder_config_.Copy(); |
4011 // one_stream.streams.resize(1); | 4111 // one_stream.streams.resize(1); |
4012 one_stream.number_of_streams = 1; | 4112 one_stream.number_of_streams = 1; |
4013 CreateMatchingReceiveConfigs(&receive_transport); | 4113 CreateMatchingReceiveConfigs(receive_transport.get()); |
4014 | 4114 |
4015 CreateVideoStreams(); | 4115 CreateVideoStreams(); |
4016 CreateFrameGeneratorCapturer(30, 1280, 720); | 4116 CreateFrameGeneratorCapturer(30, 1280, 720); |
4017 | 4117 |
4018 Start(); | 4118 Start(); |
| 4119 }); |
| 4120 |
4019 EXPECT_TRUE(observer.Wait()) | 4121 EXPECT_TRUE(observer.Wait()) |
4020 << "Timed out waiting for all SSRCs to send packets."; | 4122 << "Timed out waiting for all SSRCs to send packets."; |
4021 | 4123 |
4022 // Test stream resetting more than once to make sure that the state doesn't | 4124 // Test stream resetting more than once to make sure that the state doesn't |
4023 // get set once (this could be due to using std::map::insert for instance). | 4125 // get set once (this could be due to using std::map::insert for instance). |
4024 for (size_t i = 0; i < 3; ++i) { | 4126 for (size_t i = 0; i < 3; ++i) { |
4025 frame_generator_capturer_->Stop(); | 4127 task_queue_.SendTask([&]() { |
4026 sender_call_->DestroyVideoSendStream(video_send_stream_); | 4128 frame_generator_capturer_->Stop(); |
| 4129 sender_call_->DestroyVideoSendStream(video_send_stream_); |
4027 | 4130 |
4028 // Re-create VideoSendStream with only one stream. | 4131 // Re-create VideoSendStream with only one stream. |
4029 video_send_stream_ = sender_call_->CreateVideoSendStream( | 4132 video_send_stream_ = sender_call_->CreateVideoSendStream( |
4030 video_send_config_.Copy(), one_stream.Copy()); | 4133 video_send_config_.Copy(), one_stream.Copy()); |
4031 video_send_stream_->Start(); | 4134 video_send_stream_->Start(); |
4032 if (provoke_rtcpsr_before_rtp) { | 4135 if (provoke_rtcpsr_before_rtp) { |
4033 // Rapid Resync Request forces sending RTCP Sender Report back. | 4136 // Rapid Resync Request forces sending RTCP Sender Report back. |
4034 // Using this request speeds up this test because then there is no need | 4137 // Using this request speeds up this test because then there is no need |
4035 // to wait for a second for periodic Sender Report. | 4138 // to wait for a second for periodic Sender Report. |
4036 rtcp::RapidResyncRequest force_send_sr_back_request; | 4139 rtcp::RapidResyncRequest force_send_sr_back_request; |
4037 rtc::Buffer packet = force_send_sr_back_request.Build(); | 4140 rtc::Buffer packet = force_send_sr_back_request.Build(); |
4038 static_cast<webrtc::test::DirectTransport&>(receive_transport) | 4141 static_cast<webrtc::test::DirectTransport*>(receive_transport.get()) |
4039 .SendRtcp(packet.data(), packet.size()); | 4142 ->SendRtcp(packet.data(), packet.size()); |
4040 } | 4143 } |
4041 CreateFrameGeneratorCapturer(30, 1280, 720); | 4144 CreateFrameGeneratorCapturer(30, 1280, 720); |
4042 frame_generator_capturer_->Start(); | 4145 frame_generator_capturer_->Start(); |
| 4146 }); |
4043 | 4147 |
4044 observer.ResetExpectedSsrcs(1); | 4148 observer.ResetExpectedSsrcs(1); |
4045 EXPECT_TRUE(observer.Wait()) << "Timed out waiting for single RTP packet."; | 4149 EXPECT_TRUE(observer.Wait()) << "Timed out waiting for single RTP packet."; |
4046 | 4150 |
4047 // Reconfigure back to use all streams. | 4151 // Reconfigure back to use all streams. |
4048 video_send_stream_->ReconfigureVideoEncoder(video_encoder_config_.Copy()); | 4152 task_queue_.SendTask([this]() { |
| 4153 video_send_stream_->ReconfigureVideoEncoder(video_encoder_config_.Copy()); |
| 4154 }); |
4049 observer.ResetExpectedSsrcs(kNumSsrcs); | 4155 observer.ResetExpectedSsrcs(kNumSsrcs); |
4050 EXPECT_TRUE(observer.Wait()) | 4156 EXPECT_TRUE(observer.Wait()) |
4051 << "Timed out waiting for all SSRCs to send packets."; | 4157 << "Timed out waiting for all SSRCs to send packets."; |
4052 | 4158 |
4053 // Reconfigure down to one stream. | 4159 // Reconfigure down to one stream. |
4054 video_send_stream_->ReconfigureVideoEncoder(one_stream.Copy()); | 4160 task_queue_.SendTask([this, &one_stream]() { |
| 4161 video_send_stream_->ReconfigureVideoEncoder(one_stream.Copy()); |
| 4162 }); |
4055 observer.ResetExpectedSsrcs(1); | 4163 observer.ResetExpectedSsrcs(1); |
4056 EXPECT_TRUE(observer.Wait()) << "Timed out waiting for single RTP packet."; | 4164 EXPECT_TRUE(observer.Wait()) << "Timed out waiting for single RTP packet."; |
4057 | 4165 |
4058 // Reconfigure back to use all streams. | 4166 // Reconfigure back to use all streams. |
4059 video_send_stream_->ReconfigureVideoEncoder(video_encoder_config_.Copy()); | 4167 task_queue_.SendTask([this]() { |
| 4168 video_send_stream_->ReconfigureVideoEncoder(video_encoder_config_.Copy()); |
| 4169 }); |
4060 observer.ResetExpectedSsrcs(kNumSsrcs); | 4170 observer.ResetExpectedSsrcs(kNumSsrcs); |
4061 EXPECT_TRUE(observer.Wait()) | 4171 EXPECT_TRUE(observer.Wait()) |
4062 << "Timed out waiting for all SSRCs to send packets."; | 4172 << "Timed out waiting for all SSRCs to send packets."; |
4063 } | 4173 } |
4064 | 4174 |
4065 send_transport.StopSending(); | 4175 task_queue_.SendTask([this, &send_transport, &receive_transport]() { |
4066 receive_transport.StopSending(); | 4176 Stop(); |
4067 | 4177 DestroyStreams(); |
4068 Stop(); | 4178 send_transport.reset(); |
4069 DestroyStreams(); | 4179 receive_transport.reset(); |
| 4180 DestroyCalls(); |
| 4181 }); |
4070 } | 4182 } |
4071 | 4183 |
4072 TEST_F(EndToEndTest, RestartingSendStreamPreservesRtpState) { | 4184 TEST_F(EndToEndTest, RestartingSendStreamPreservesRtpState) { |
4073 TestRtpStatePreservation(false, false); | 4185 TestRtpStatePreservation(false, false); |
4074 } | 4186 } |
4075 | 4187 |
4076 TEST_F(EndToEndTest, RestartingSendStreamPreservesRtpStatesWithRtx) { | 4188 TEST_F(EndToEndTest, RestartingSendStreamPreservesRtpStatesWithRtx) { |
4077 TestRtpStatePreservation(true, false); | 4189 TestRtpStatePreservation(true, false); |
4078 } | 4190 } |
4079 | 4191 |
(...skipping 70 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4150 | 4262 |
4151 return SEND_PACKET; | 4263 return SEND_PACKET; |
4152 } | 4264 } |
4153 | 4265 |
4154 rtc::Optional<uint16_t> last_observed_sequence_number_ GUARDED_BY(crit_); | 4266 rtc::Optional<uint16_t> last_observed_sequence_number_ GUARDED_BY(crit_); |
4155 rtc::Optional<uint32_t> last_observed_timestamp_ GUARDED_BY(crit_); | 4267 rtc::Optional<uint32_t> last_observed_timestamp_ GUARDED_BY(crit_); |
4156 size_t num_flexfec_packets_sent_ GUARDED_BY(crit_); | 4268 size_t num_flexfec_packets_sent_ GUARDED_BY(crit_); |
4157 rtc::CriticalSection crit_; | 4269 rtc::CriticalSection crit_; |
4158 } observer; | 4270 } observer; |
4159 | 4271 |
| 4272 constexpr int kFrameMaxWidth = 320; |
| 4273 constexpr int kFrameMaxHeight = 180; |
| 4274 constexpr int kFrameRate = 15; |
| 4275 |
4160 Call::Config config(event_log_.get()); | 4276 Call::Config config(event_log_.get()); |
4161 CreateCalls(config, config); | |
4162 | 4277 |
4163 FakeNetworkPipe::Config lossy_delayed_link; | 4278 std::unique_ptr<test::PacketTransport> send_transport; |
4164 lossy_delayed_link.loss_percent = 2; | 4279 std::unique_ptr<test::PacketTransport> receive_transport; |
4165 lossy_delayed_link.queue_delay_ms = 50; | 4280 std::unique_ptr<VideoEncoder> encoder; |
4166 test::PacketTransport send_transport(sender_call_.get(), &observer, | |
4167 test::PacketTransport::kSender, | |
4168 payload_type_map_, lossy_delayed_link); | |
4169 send_transport.SetReceiver(receiver_call_->Receiver()); | |
4170 | 4281 |
4171 FakeNetworkPipe::Config flawless_link; | 4282 task_queue_.SendTask([&]() { |
4172 test::PacketTransport receive_transport(nullptr, &observer, | 4283 CreateCalls(config, config); |
4173 test::PacketTransport::kReceiver, | |
4174 payload_type_map_, flawless_link); | |
4175 receive_transport.SetReceiver(sender_call_->Receiver()); | |
4176 | 4284 |
4177 // For reduced flakyness, we use a real VP8 encoder together with NACK | 4285 FakeNetworkPipe::Config lossy_delayed_link; |
4178 // and RTX. | 4286 lossy_delayed_link.loss_percent = 2; |
4179 const int kNumVideoStreams = 1; | 4287 lossy_delayed_link.queue_delay_ms = 50; |
4180 const int kNumFlexfecStreams = 1; | |
4181 CreateSendConfig(kNumVideoStreams, 0, kNumFlexfecStreams, &send_transport); | |
4182 std::unique_ptr<VideoEncoder> encoder(VP8Encoder::Create()); | |
4183 video_send_config_.encoder_settings.encoder = encoder.get(); | |
4184 video_send_config_.encoder_settings.payload_name = "VP8"; | |
4185 video_send_config_.encoder_settings.payload_type = kVideoSendPayloadType; | |
4186 video_send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs; | |
4187 video_send_config_.rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[0]); | |
4188 video_send_config_.rtp.rtx.payload_type = kSendRtxPayloadType; | |
4189 | 4288 |
4190 CreateMatchingReceiveConfigs(&receive_transport); | 4289 send_transport = rtc::MakeUnique<test::PacketTransport>( |
4191 video_receive_configs_[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs; | 4290 &task_queue_, sender_call_.get(), &observer, |
4192 video_receive_configs_[0].rtp.rtx_ssrc = kSendRtxSsrcs[0]; | 4291 test::PacketTransport::kSender, payload_type_map_, lossy_delayed_link); |
4193 video_receive_configs_[0].rtp.rtx_payload_types[kVideoSendPayloadType] = | 4292 send_transport->SetReceiver(receiver_call_->Receiver()); |
4194 kSendRtxPayloadType; | |
4195 | 4293 |
4196 // The matching FlexFEC receive config is not created by | 4294 FakeNetworkPipe::Config flawless_link; |
4197 // CreateMatchingReceiveConfigs since this is not a test::BaseTest. | 4295 receive_transport = rtc::MakeUnique<test::PacketTransport>( |
4198 // Set up the receive config manually instead. | 4296 &task_queue_, nullptr, &observer, test::PacketTransport::kReceiver, |
4199 FlexfecReceiveStream::Config flexfec_receive_config(&receive_transport); | 4297 payload_type_map_, flawless_link); |
4200 flexfec_receive_config.payload_type = | 4298 receive_transport->SetReceiver(sender_call_->Receiver()); |
4201 video_send_config_.rtp.flexfec.payload_type; | |
4202 flexfec_receive_config.remote_ssrc = video_send_config_.rtp.flexfec.ssrc; | |
4203 flexfec_receive_config.protected_media_ssrcs = | |
4204 video_send_config_.rtp.flexfec.protected_media_ssrcs; | |
4205 flexfec_receive_config.local_ssrc = kReceiverLocalVideoSsrc; | |
4206 flexfec_receive_config.transport_cc = true; | |
4207 flexfec_receive_config.rtp_header_extensions.emplace_back( | |
4208 RtpExtension::kTransportSequenceNumberUri, | |
4209 test::kTransportSequenceNumberExtensionId); | |
4210 flexfec_receive_configs_.push_back(flexfec_receive_config); | |
4211 | 4299 |
4212 CreateFlexfecStreams(); | 4300 // For reduced flakyness, we use a real VP8 encoder together with NACK |
4213 CreateVideoStreams(); | 4301 // and RTX. |
| 4302 const int kNumVideoStreams = 1; |
| 4303 const int kNumFlexfecStreams = 1; |
| 4304 CreateSendConfig(kNumVideoStreams, 0, kNumFlexfecStreams, |
| 4305 send_transport.get()); |
| 4306 encoder = rtc::WrapUnique(VP8Encoder::Create()); |
| 4307 video_send_config_.encoder_settings.encoder = encoder.get(); |
| 4308 video_send_config_.encoder_settings.payload_name = "VP8"; |
| 4309 video_send_config_.encoder_settings.payload_type = kVideoSendPayloadType; |
| 4310 video_send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs; |
| 4311 video_send_config_.rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[0]); |
| 4312 video_send_config_.rtp.rtx.payload_type = kSendRtxPayloadType; |
4214 | 4313 |
4215 // RTCP might be disabled if the network is "down". | 4314 CreateMatchingReceiveConfigs(receive_transport.get()); |
4216 sender_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp); | 4315 video_receive_configs_[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs; |
4217 receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp); | 4316 video_receive_configs_[0].rtp.rtx_ssrc = kSendRtxSsrcs[0]; |
| 4317 video_receive_configs_[0].rtp.rtx_payload_types[kVideoSendPayloadType] = |
| 4318 kSendRtxPayloadType; |
4218 | 4319 |
4219 const int kFrameMaxWidth = 320; | 4320 // The matching FlexFEC receive config is not created by |
4220 const int kFrameMaxHeight = 180; | 4321 // CreateMatchingReceiveConfigs since this is not a test::BaseTest. |
4221 const int kFrameRate = 15; | 4322 // Set up the receive config manually instead. |
4222 CreateFrameGeneratorCapturer(kFrameRate, kFrameMaxWidth, kFrameMaxHeight); | 4323 FlexfecReceiveStream::Config flexfec_receive_config( |
| 4324 receive_transport.get()); |
| 4325 flexfec_receive_config.payload_type = |
| 4326 video_send_config_.rtp.flexfec.payload_type; |
| 4327 flexfec_receive_config.remote_ssrc = video_send_config_.rtp.flexfec.ssrc; |
| 4328 flexfec_receive_config.protected_media_ssrcs = |
| 4329 video_send_config_.rtp.flexfec.protected_media_ssrcs; |
| 4330 flexfec_receive_config.local_ssrc = kReceiverLocalVideoSsrc; |
| 4331 flexfec_receive_config.transport_cc = true; |
| 4332 flexfec_receive_config.rtp_header_extensions.emplace_back( |
| 4333 RtpExtension::kTransportSequenceNumberUri, |
| 4334 test::kTransportSequenceNumberExtensionId); |
| 4335 flexfec_receive_configs_.push_back(flexfec_receive_config); |
| 4336 |
| 4337 CreateFlexfecStreams(); |
| 4338 CreateVideoStreams(); |
| 4339 |
| 4340 // RTCP might be disabled if the network is "down". |
| 4341 sender_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp); |
| 4342 receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp); |
| 4343 |
| 4344 CreateFrameGeneratorCapturer(kFrameRate, kFrameMaxWidth, kFrameMaxHeight); |
| 4345 |
| 4346 Start(); |
| 4347 }); |
4223 | 4348 |
4224 // Initial test. | 4349 // Initial test. |
4225 Start(); | |
4226 EXPECT_TRUE(observer.Wait()) << "Timed out waiting for packets."; | 4350 EXPECT_TRUE(observer.Wait()) << "Timed out waiting for packets."; |
4227 | 4351 |
4228 // Ensure monotonicity when the VideoSendStream is restarted. | 4352 task_queue_.SendTask([this, &observer]() { |
4229 Stop(); | 4353 // Ensure monotonicity when the VideoSendStream is restarted. |
4230 observer.ResetPacketCount(); | 4354 Stop(); |
4231 Start(); | 4355 observer.ResetPacketCount(); |
| 4356 Start(); |
| 4357 }); |
| 4358 |
4232 EXPECT_TRUE(observer.Wait()) << "Timed out waiting for packets."; | 4359 EXPECT_TRUE(observer.Wait()) << "Timed out waiting for packets."; |
4233 | 4360 |
4234 // Ensure monotonicity when the VideoSendStream is recreated. | 4361 task_queue_.SendTask([this, &observer, |
4235 frame_generator_capturer_->Stop(); | 4362 kFrameRate, kFrameMaxWidth, kFrameMaxHeight]() { |
4236 sender_call_->DestroyVideoSendStream(video_send_stream_); | 4363 // Ensure monotonicity when the VideoSendStream is recreated. |
4237 observer.ResetPacketCount(); | 4364 frame_generator_capturer_->Stop(); |
4238 video_send_stream_ = sender_call_->CreateVideoSendStream( | 4365 sender_call_->DestroyVideoSendStream(video_send_stream_); |
4239 video_send_config_.Copy(), video_encoder_config_.Copy()); | 4366 observer.ResetPacketCount(); |
4240 video_send_stream_->Start(); | 4367 video_send_stream_ = sender_call_->CreateVideoSendStream( |
4241 CreateFrameGeneratorCapturer(kFrameRate, kFrameMaxWidth, kFrameMaxHeight); | 4368 video_send_config_.Copy(), video_encoder_config_.Copy()); |
4242 frame_generator_capturer_->Start(); | 4369 video_send_stream_->Start(); |
| 4370 CreateFrameGeneratorCapturer(kFrameRate, kFrameMaxWidth, kFrameMaxHeight); |
| 4371 frame_generator_capturer_->Start(); |
| 4372 }); |
| 4373 |
4243 EXPECT_TRUE(observer.Wait()) << "Timed out waiting for packets."; | 4374 EXPECT_TRUE(observer.Wait()) << "Timed out waiting for packets."; |
4244 | 4375 |
4245 // Cleanup. | 4376 // Cleanup. |
4246 send_transport.StopSending(); | 4377 task_queue_.SendTask([this, &send_transport, &receive_transport]() { |
4247 receive_transport.StopSending(); | 4378 Stop(); |
4248 Stop(); | 4379 DestroyStreams(); |
4249 DestroyStreams(); | 4380 send_transport.reset(); |
| 4381 receive_transport.reset(); |
| 4382 DestroyCalls(); |
| 4383 }); |
4250 } | 4384 } |
4251 | 4385 |
4252 TEST_F(EndToEndTest, RespectsNetworkState) { | 4386 TEST_F(EndToEndTest, RespectsNetworkState) { |
4253 // TODO(pbos): Remove accepted downtime packets etc. when signaling network | 4387 // TODO(pbos): Remove accepted downtime packets etc. when signaling network |
4254 // down blocks until no more packets will be sent. | 4388 // down blocks until no more packets will be sent. |
4255 | 4389 |
4256 // Pacer will send from its packet list and then send required padding before | 4390 // Pacer will send from its packet list and then send required padding before |
4257 // checking paused_ again. This should be enough for one round of pacing, | 4391 // checking paused_ again. This should be enough for one round of pacing, |
4258 // otherwise increase. | 4392 // otherwise increase. |
4259 static const int kNumAcceptedDowntimeRtp = 5; | 4393 static const int kNumAcceptedDowntimeRtp = 5; |
4260 // A single RTCP may be in the pipeline. | 4394 // A single RTCP may be in the pipeline. |
4261 static const int kNumAcceptedDowntimeRtcp = 1; | 4395 static const int kNumAcceptedDowntimeRtcp = 1; |
4262 class NetworkStateTest : public test::EndToEndTest, public test::FakeEncoder { | 4396 class NetworkStateTest : public test::EndToEndTest, public test::FakeEncoder { |
4263 public: | 4397 public: |
4264 NetworkStateTest() | 4398 explicit NetworkStateTest( |
| 4399 test::SingleThreadedTaskQueueForTesting* task_queue) |
4265 : EndToEndTest(kDefaultTimeoutMs), | 4400 : EndToEndTest(kDefaultTimeoutMs), |
4266 FakeEncoder(Clock::GetRealTimeClock()), | 4401 FakeEncoder(Clock::GetRealTimeClock()), |
| 4402 task_queue_(task_queue), |
4267 encoded_frames_(false, false), | 4403 encoded_frames_(false, false), |
4268 packet_event_(false, false), | 4404 packet_event_(false, false), |
4269 sender_call_(nullptr), | 4405 sender_call_(nullptr), |
4270 receiver_call_(nullptr), | 4406 receiver_call_(nullptr), |
4271 sender_state_(kNetworkUp), | 4407 sender_state_(kNetworkUp), |
4272 sender_rtp_(0), | 4408 sender_rtp_(0), |
4273 sender_padding_(0), | 4409 sender_padding_(0), |
4274 sender_rtcp_(0), | 4410 sender_rtcp_(0), |
4275 receiver_rtcp_(0), | 4411 receiver_rtcp_(0), |
4276 down_frames_(0) {} | 4412 down_frames_(0) {} |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4313 void ModifyVideoConfigs( | 4449 void ModifyVideoConfigs( |
4314 VideoSendStream::Config* send_config, | 4450 VideoSendStream::Config* send_config, |
4315 std::vector<VideoReceiveStream::Config>* receive_configs, | 4451 std::vector<VideoReceiveStream::Config>* receive_configs, |
4316 VideoEncoderConfig* encoder_config) override { | 4452 VideoEncoderConfig* encoder_config) override { |
4317 send_config->encoder_settings.encoder = this; | 4453 send_config->encoder_settings.encoder = this; |
4318 } | 4454 } |
4319 | 4455 |
4320 void PerformTest() override { | 4456 void PerformTest() override { |
4321 EXPECT_TRUE(encoded_frames_.Wait(kDefaultTimeoutMs)) | 4457 EXPECT_TRUE(encoded_frames_.Wait(kDefaultTimeoutMs)) |
4322 << "No frames received by the encoder."; | 4458 << "No frames received by the encoder."; |
4323 // Wait for packets from both sender/receiver. | |
4324 WaitForPacketsOrSilence(false, false); | |
4325 | 4459 |
4326 // Sender-side network down for audio; there should be no effect on video | 4460 task_queue_->SendTask([this]() { |
4327 sender_call_->SignalChannelNetworkState(MediaType::AUDIO, kNetworkDown); | 4461 // Wait for packets from both sender/receiver. |
4328 WaitForPacketsOrSilence(false, false); | 4462 WaitForPacketsOrSilence(false, false); |
4329 | 4463 |
4330 // Receiver-side network down for audio; no change expected | 4464 // Sender-side network down for audio; there should be no effect on |
4331 receiver_call_->SignalChannelNetworkState(MediaType::AUDIO, kNetworkDown); | 4465 // video |
4332 WaitForPacketsOrSilence(false, false); | 4466 sender_call_->SignalChannelNetworkState(MediaType::AUDIO, kNetworkDown); |
| 4467 WaitForPacketsOrSilence(false, false); |
4333 | 4468 |
4334 // Sender-side network down. | 4469 // Receiver-side network down for audio; no change expected |
4335 sender_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkDown); | 4470 receiver_call_->SignalChannelNetworkState(MediaType::AUDIO, |
4336 { | 4471 kNetworkDown); |
4337 rtc::CritScope lock(&test_crit_); | 4472 WaitForPacketsOrSilence(false, false); |
4338 // After network goes down we shouldn't be encoding more frames. | |
4339 sender_state_ = kNetworkDown; | |
4340 } | |
4341 // Wait for receiver-packets and no sender packets. | |
4342 WaitForPacketsOrSilence(true, false); | |
4343 | 4473 |
4344 // Receiver-side network down. | 4474 // Sender-side network down. |
4345 receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkDown); | 4475 sender_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkDown); |
4346 WaitForPacketsOrSilence(true, true); | 4476 { |
| 4477 rtc::CritScope lock(&test_crit_); |
| 4478 // After network goes down we shouldn't be encoding more frames. |
| 4479 sender_state_ = kNetworkDown; |
| 4480 } |
| 4481 // Wait for receiver-packets and no sender packets. |
| 4482 WaitForPacketsOrSilence(true, false); |
4347 | 4483 |
4348 // Network up for audio for both sides; video is still not expected to | 4484 // Receiver-side network down. |
4349 // start | 4485 receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, |
4350 sender_call_->SignalChannelNetworkState(MediaType::AUDIO, kNetworkUp); | 4486 kNetworkDown); |
4351 receiver_call_->SignalChannelNetworkState(MediaType::AUDIO, kNetworkUp); | 4487 WaitForPacketsOrSilence(true, true); |
4352 WaitForPacketsOrSilence(true, true); | |
4353 | 4488 |
4354 // Network back up again for both. | 4489 // Network up for audio for both sides; video is still not expected to |
4355 { | 4490 // start |
4356 rtc::CritScope lock(&test_crit_); | 4491 sender_call_->SignalChannelNetworkState(MediaType::AUDIO, kNetworkUp); |
4357 // It's OK to encode frames again, as we're about to bring up the | 4492 receiver_call_->SignalChannelNetworkState(MediaType::AUDIO, kNetworkUp); |
4358 // network. | 4493 WaitForPacketsOrSilence(true, true); |
4359 sender_state_ = kNetworkUp; | |
4360 } | |
4361 sender_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp); | |
4362 receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp); | |
4363 WaitForPacketsOrSilence(false, false); | |
4364 | 4494 |
4365 // TODO(skvlad): add tests to verify that the audio streams are stopped | 4495 // Network back up again for both. |
4366 // when the network goes down for audio once the workaround in | 4496 { |
4367 // paced_sender.cc is removed. | 4497 rtc::CritScope lock(&test_crit_); |
| 4498 // It's OK to encode frames again, as we're about to bring up the |
| 4499 // network. |
| 4500 sender_state_ = kNetworkUp; |
| 4501 } |
| 4502 sender_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp); |
| 4503 receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp); |
| 4504 WaitForPacketsOrSilence(false, false); |
| 4505 |
| 4506 // TODO(skvlad): add tests to verify that the audio streams are stopped |
| 4507 // when the network goes down for audio once the workaround in |
| 4508 // paced_sender.cc is removed. |
| 4509 }); |
4368 } | 4510 } |
4369 | 4511 |
4370 int32_t Encode(const VideoFrame& input_image, | 4512 int32_t Encode(const VideoFrame& input_image, |
4371 const CodecSpecificInfo* codec_specific_info, | 4513 const CodecSpecificInfo* codec_specific_info, |
4372 const std::vector<FrameType>* frame_types) override { | 4514 const std::vector<FrameType>* frame_types) override { |
4373 { | 4515 { |
4374 rtc::CritScope lock(&test_crit_); | 4516 rtc::CritScope lock(&test_crit_); |
4375 if (sender_state_ == kNetworkDown) { | 4517 if (sender_state_ == kNetworkDown) { |
4376 ++down_frames_; | 4518 ++down_frames_; |
4377 EXPECT_LE(down_frames_, 1) | 4519 EXPECT_LE(down_frames_, 1) |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4427 static_cast<int64_t>(kSilenceTimeoutMs)) { | 4569 static_cast<int64_t>(kSilenceTimeoutMs)) { |
4428 receiver_done = true; | 4570 receiver_done = true; |
4429 } | 4571 } |
4430 } else { | 4572 } else { |
4431 if (receiver_rtcp_ > initial_receiver_rtcp + kNumAcceptedDowntimeRtcp) | 4573 if (receiver_rtcp_ > initial_receiver_rtcp + kNumAcceptedDowntimeRtcp) |
4432 receiver_done = true; | 4574 receiver_done = true; |
4433 } | 4575 } |
4434 } | 4576 } |
4435 } | 4577 } |
4436 | 4578 |
| 4579 test::SingleThreadedTaskQueueForTesting* const task_queue_; |
4437 rtc::CriticalSection test_crit_; | 4580 rtc::CriticalSection test_crit_; |
4438 rtc::Event encoded_frames_; | 4581 rtc::Event encoded_frames_; |
4439 rtc::Event packet_event_; | 4582 rtc::Event packet_event_; |
4440 Call* sender_call_; | 4583 Call* sender_call_; |
4441 Call* receiver_call_; | 4584 Call* receiver_call_; |
4442 NetworkState sender_state_ GUARDED_BY(test_crit_); | 4585 NetworkState sender_state_ GUARDED_BY(test_crit_); |
4443 int sender_rtp_ GUARDED_BY(test_crit_); | 4586 int sender_rtp_ GUARDED_BY(test_crit_); |
4444 int sender_padding_ GUARDED_BY(test_crit_); | 4587 int sender_padding_ GUARDED_BY(test_crit_); |
4445 int sender_rtcp_ GUARDED_BY(test_crit_); | 4588 int sender_rtcp_ GUARDED_BY(test_crit_); |
4446 int receiver_rtcp_ GUARDED_BY(test_crit_); | 4589 int receiver_rtcp_ GUARDED_BY(test_crit_); |
4447 int down_frames_ GUARDED_BY(test_crit_); | 4590 int down_frames_ GUARDED_BY(test_crit_); |
4448 } test; | 4591 } test(&task_queue_); |
4449 | 4592 |
4450 RunBaseTest(&test); | 4593 RunBaseTest(&test); |
4451 } | 4594 } |
4452 | 4595 |
4453 TEST_F(EndToEndTest, CallReportsRttForSender) { | 4596 TEST_F(EndToEndTest, CallReportsRttForSender) { |
4454 static const int kSendDelayMs = 30; | 4597 static const int kSendDelayMs = 30; |
4455 static const int kReceiveDelayMs = 70; | 4598 static const int kReceiveDelayMs = 70; |
4456 CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get())); | |
4457 | 4599 |
4458 FakeNetworkPipe::Config config; | 4600 std::unique_ptr<test::DirectTransport> sender_transport; |
4459 config.queue_delay_ms = kSendDelayMs; | 4601 std::unique_ptr<test::DirectTransport> receiver_transport; |
4460 test::DirectTransport sender_transport(config, sender_call_.get(), | |
4461 payload_type_map_); | |
4462 config.queue_delay_ms = kReceiveDelayMs; | |
4463 test::DirectTransport receiver_transport(config, receiver_call_.get(), | |
4464 payload_type_map_); | |
4465 sender_transport.SetReceiver(receiver_call_->Receiver()); | |
4466 receiver_transport.SetReceiver(sender_call_->Receiver()); | |
4467 | 4602 |
4468 CreateSendConfig(1, 0, 0, &sender_transport); | 4603 task_queue_.SendTask([this, &sender_transport, &receiver_transport]() { |
4469 CreateMatchingReceiveConfigs(&receiver_transport); | 4604 FakeNetworkPipe::Config config; |
| 4605 config.queue_delay_ms = kSendDelayMs; |
| 4606 CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get())); |
| 4607 sender_transport = rtc::MakeUnique<test::DirectTransport>( |
| 4608 &task_queue_, config, sender_call_.get(), payload_type_map_); |
| 4609 config.queue_delay_ms = kReceiveDelayMs; |
| 4610 receiver_transport = rtc::MakeUnique<test::DirectTransport>( |
| 4611 &task_queue_, config, receiver_call_.get(), payload_type_map_); |
| 4612 sender_transport->SetReceiver(receiver_call_->Receiver()); |
| 4613 receiver_transport->SetReceiver(sender_call_->Receiver()); |
4470 | 4614 |
4471 CreateVideoStreams(); | 4615 CreateSendConfig(1, 0, 0, sender_transport.get()); |
4472 CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth, | 4616 CreateMatchingReceiveConfigs(receiver_transport.get()); |
4473 kDefaultHeight); | 4617 |
4474 Start(); | 4618 CreateVideoStreams(); |
| 4619 CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth, |
| 4620 kDefaultHeight); |
| 4621 Start(); |
| 4622 }); |
4475 | 4623 |
4476 int64_t start_time_ms = clock_->TimeInMilliseconds(); | 4624 int64_t start_time_ms = clock_->TimeInMilliseconds(); |
4477 while (true) { | 4625 while (true) { |
4478 Call::Stats stats = sender_call_->GetStats(); | 4626 Call::Stats stats = sender_call_->GetStats(); |
4479 ASSERT_GE(start_time_ms + kDefaultTimeoutMs, | 4627 ASSERT_GE(start_time_ms + kDefaultTimeoutMs, |
4480 clock_->TimeInMilliseconds()) | 4628 clock_->TimeInMilliseconds()) |
4481 << "No RTT stats before timeout!"; | 4629 << "No RTT stats before timeout!"; |
4482 if (stats.rtt_ms != -1) { | 4630 if (stats.rtt_ms != -1) { |
4483 // To avoid failures caused by rounding or minor ntp clock adjustments, | 4631 // To avoid failures caused by rounding or minor ntp clock adjustments, |
4484 // relax expectation by 1ms. | 4632 // relax expectation by 1ms. |
4485 constexpr int kAllowedErrorMs = 1; | 4633 constexpr int kAllowedErrorMs = 1; |
4486 EXPECT_GE(stats.rtt_ms, kSendDelayMs + kReceiveDelayMs - kAllowedErrorMs); | 4634 EXPECT_GE(stats.rtt_ms, kSendDelayMs + kReceiveDelayMs - kAllowedErrorMs); |
4487 break; | 4635 break; |
4488 } | 4636 } |
4489 SleepMs(10); | 4637 SleepMs(10); |
4490 } | 4638 } |
4491 | 4639 |
4492 sender_transport.StopSending(); | 4640 task_queue_.SendTask([this, &sender_transport, &receiver_transport]() { |
4493 receiver_transport.StopSending(); | 4641 Stop(); |
4494 Stop(); | 4642 DestroyStreams(); |
4495 DestroyStreams(); | 4643 sender_transport.reset(); |
4496 DestroyCalls(); | 4644 receiver_transport.reset(); |
| 4645 DestroyCalls(); |
| 4646 }); |
4497 } | 4647 } |
4498 | 4648 |
4499 void EndToEndTest::VerifyNewVideoSendStreamsRespectNetworkState( | 4649 void EndToEndTest::VerifyNewVideoSendStreamsRespectNetworkState( |
4500 MediaType network_to_bring_up, | 4650 MediaType network_to_bring_up, |
4501 VideoEncoder* encoder, | 4651 VideoEncoder* encoder, |
4502 Transport* transport) { | 4652 Transport* transport) { |
4503 CreateSenderCall(Call::Config(event_log_.get())); | 4653 task_queue_.SendTask([this, network_to_bring_up, encoder, transport]() { |
4504 sender_call_->SignalChannelNetworkState(network_to_bring_up, kNetworkUp); | 4654 CreateSenderCall(Call::Config(event_log_.get())); |
| 4655 sender_call_->SignalChannelNetworkState(network_to_bring_up, kNetworkUp); |
4505 | 4656 |
4506 CreateSendConfig(1, 0, 0, transport); | 4657 CreateSendConfig(1, 0, 0, transport); |
4507 video_send_config_.encoder_settings.encoder = encoder; | 4658 video_send_config_.encoder_settings.encoder = encoder; |
4508 CreateVideoStreams(); | 4659 CreateVideoStreams(); |
4509 CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth, | 4660 CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth, |
4510 kDefaultHeight); | 4661 kDefaultHeight); |
4511 | 4662 |
4512 Start(); | 4663 Start(); |
| 4664 }); |
| 4665 |
4513 SleepMs(kSilenceTimeoutMs); | 4666 SleepMs(kSilenceTimeoutMs); |
4514 Stop(); | |
4515 | 4667 |
4516 DestroyStreams(); | 4668 task_queue_.SendTask([this]() { |
| 4669 Stop(); |
| 4670 DestroyStreams(); |
| 4671 DestroyCalls(); |
| 4672 }); |
4517 } | 4673 } |
4518 | 4674 |
4519 void EndToEndTest::VerifyNewVideoReceiveStreamsRespectNetworkState( | 4675 void EndToEndTest::VerifyNewVideoReceiveStreamsRespectNetworkState( |
4520 MediaType network_to_bring_up, | 4676 MediaType network_to_bring_up, |
4521 Transport* transport) { | 4677 Transport* transport) { |
4522 Call::Config config(event_log_.get()); | 4678 std::unique_ptr<test::DirectTransport> sender_transport; |
4523 CreateCalls(config, config); | |
4524 receiver_call_->SignalChannelNetworkState(network_to_bring_up, kNetworkUp); | |
4525 | 4679 |
4526 test::DirectTransport sender_transport(sender_call_.get(), payload_type_map_); | 4680 task_queue_.SendTask([this, &sender_transport, network_to_bring_up, |
4527 sender_transport.SetReceiver(receiver_call_->Receiver()); | 4681 transport]() { |
4528 CreateSendConfig(1, 0, 0, &sender_transport); | 4682 Call::Config config(event_log_.get()); |
4529 CreateMatchingReceiveConfigs(transport); | 4683 CreateCalls(config, config); |
4530 CreateVideoStreams(); | 4684 receiver_call_->SignalChannelNetworkState(network_to_bring_up, kNetworkUp); |
4531 CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth, | 4685 sender_transport = rtc::MakeUnique<test::DirectTransport>( |
4532 kDefaultHeight); | 4686 &task_queue_, sender_call_.get(), payload_type_map_); |
| 4687 sender_transport->SetReceiver(receiver_call_->Receiver()); |
| 4688 CreateSendConfig(1, 0, 0, sender_transport.get()); |
| 4689 CreateMatchingReceiveConfigs(transport); |
| 4690 CreateVideoStreams(); |
| 4691 CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth, |
| 4692 kDefaultHeight); |
| 4693 Start(); |
| 4694 }); |
4533 | 4695 |
4534 Start(); | |
4535 SleepMs(kSilenceTimeoutMs); | 4696 SleepMs(kSilenceTimeoutMs); |
4536 Stop(); | |
4537 | 4697 |
4538 sender_transport.StopSending(); | 4698 task_queue_.SendTask([this, &sender_transport]() { |
4539 | 4699 Stop(); |
4540 DestroyStreams(); | 4700 DestroyStreams(); |
| 4701 sender_transport.reset(); |
| 4702 DestroyCalls(); |
| 4703 }); |
4541 } | 4704 } |
4542 | 4705 |
4543 TEST_F(EndToEndTest, NewVideoSendStreamsRespectVideoNetworkDown) { | 4706 TEST_F(EndToEndTest, NewVideoSendStreamsRespectVideoNetworkDown) { |
4544 class UnusedEncoder : public test::FakeEncoder { | 4707 class UnusedEncoder : public test::FakeEncoder { |
4545 public: | 4708 public: |
4546 UnusedEncoder() : FakeEncoder(Clock::GetRealTimeClock()) {} | 4709 UnusedEncoder() : FakeEncoder(Clock::GetRealTimeClock()) {} |
4547 | 4710 |
4548 int32_t InitEncode(const VideoCodec* config, | 4711 int32_t InitEncode(const VideoCodec* config, |
4549 int32_t number_of_cores, | 4712 int32_t number_of_cores, |
4550 size_t max_payload_size) override { | 4713 size_t max_payload_size) override { |
(...skipping 289 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4840 std::unique_ptr<VideoEncoder> encoder_; | 5003 std::unique_ptr<VideoEncoder> encoder_; |
4841 std::unique_ptr<VideoDecoder> decoder_; | 5004 std::unique_ptr<VideoDecoder> decoder_; |
4842 rtc::CriticalSection crit_; | 5005 rtc::CriticalSection crit_; |
4843 int recorded_frames_ GUARDED_BY(crit_); | 5006 int recorded_frames_ GUARDED_BY(crit_); |
4844 } test(this); | 5007 } test(this); |
4845 | 5008 |
4846 RunBaseTest(&test); | 5009 RunBaseTest(&test); |
4847 } | 5010 } |
4848 | 5011 |
4849 } // namespace webrtc | 5012 } // namespace webrtc |
OLD | NEW |