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 241 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
252 receiver_transport.SetReceiver(sender_call_->Receiver()); | 252 receiver_transport.SetReceiver(sender_call_->Receiver()); |
253 | 253 |
254 CreateSendConfig(1, 0, &sender_transport); | 254 CreateSendConfig(1, 0, &sender_transport); |
255 CreateMatchingReceiveConfigs(&receiver_transport); | 255 CreateMatchingReceiveConfigs(&receiver_transport); |
256 video_receive_configs_[0].renderer = &renderer; | 256 video_receive_configs_[0].renderer = &renderer; |
257 | 257 |
258 CreateVideoStreams(); | 258 CreateVideoStreams(); |
259 Start(); | 259 Start(); |
260 | 260 |
261 std::unique_ptr<test::FrameGenerator> frame_generator( | 261 std::unique_ptr<test::FrameGenerator> frame_generator( |
262 test::FrameGenerator::CreateChromaGenerator( | 262 test::FrameGenerator::CreateChromaGenerator(kDefaultWidth, |
263 video_encoder_config_.streams[0].width, | 263 kDefaultHeight)); |
264 video_encoder_config_.streams[0].height)); | |
265 test::FrameForwarder frame_forwarder; | 264 test::FrameForwarder frame_forwarder; |
266 video_send_stream_->SetSource(&frame_forwarder); | 265 video_send_stream_->SetSource(&frame_forwarder); |
267 frame_forwarder.IncomingCapturedFrame(*frame_generator->NextFrame()); | 266 frame_forwarder.IncomingCapturedFrame(*frame_generator->NextFrame()); |
268 | 267 |
269 EXPECT_TRUE(renderer.Wait()) | 268 EXPECT_TRUE(renderer.Wait()) |
270 << "Timed out while waiting for the frame to render."; | 269 << "Timed out while waiting for the frame to render."; |
271 | 270 |
272 Stop(); | 271 Stop(); |
273 | 272 |
274 sender_transport.StopSending(); | 273 sender_transport.StopSending(); |
(...skipping 23 matching lines...) Expand all Loading... |
298 << "Timed out while waiting for enough frames to be decoded."; | 297 << "Timed out while waiting for enough frames to be decoded."; |
299 } | 298 } |
300 | 299 |
301 void ModifyVideoConfigs( | 300 void ModifyVideoConfigs( |
302 VideoSendStream::Config* send_config, | 301 VideoSendStream::Config* send_config, |
303 std::vector<VideoReceiveStream::Config>* receive_configs, | 302 std::vector<VideoReceiveStream::Config>* receive_configs, |
304 VideoEncoderConfig* encoder_config) override { | 303 VideoEncoderConfig* encoder_config) override { |
305 send_config->encoder_settings.encoder = encoder_.get(); | 304 send_config->encoder_settings.encoder = encoder_.get(); |
306 send_config->encoder_settings.payload_name = payload_name_; | 305 send_config->encoder_settings.payload_name = payload_name_; |
307 send_config->encoder_settings.payload_type = 126; | 306 send_config->encoder_settings.payload_type = 126; |
308 encoder_config->streams[0].min_bitrate_bps = 50000; | |
309 encoder_config->streams[0].target_bitrate_bps = | |
310 encoder_config->streams[0].max_bitrate_bps = 2000000; | |
311 | 307 |
312 (*receive_configs)[0].renderer = this; | 308 (*receive_configs)[0].renderer = this; |
313 (*receive_configs)[0].decoders.resize(1); | 309 (*receive_configs)[0].decoders.resize(1); |
314 (*receive_configs)[0].decoders[0].payload_type = | 310 (*receive_configs)[0].decoders[0].payload_type = |
315 send_config->encoder_settings.payload_type; | 311 send_config->encoder_settings.payload_type; |
316 (*receive_configs)[0].decoders[0].payload_name = | 312 (*receive_configs)[0].decoders[0].payload_name = |
317 send_config->encoder_settings.payload_name; | 313 send_config->encoder_settings.payload_name; |
318 (*receive_configs)[0].decoders[0].decoder = decoder_.get(); | 314 (*receive_configs)[0].decoders[0].decoder = decoder_.get(); |
319 } | 315 } |
320 | 316 |
(...skipping 465 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
786 std::vector<VideoReceiveStream::Config>* receive_configs, | 782 std::vector<VideoReceiveStream::Config>* receive_configs, |
787 VideoEncoderConfig* encoder_config) override { | 783 VideoEncoderConfig* encoder_config) override { |
788 // Configure hybrid NACK/FEC. | 784 // Configure hybrid NACK/FEC. |
789 send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs; | 785 send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs; |
790 send_config->rtp.fec.red_payload_type = kRedPayloadType; | 786 send_config->rtp.fec.red_payload_type = kRedPayloadType; |
791 send_config->rtp.fec.ulpfec_payload_type = kUlpfecPayloadType; | 787 send_config->rtp.fec.ulpfec_payload_type = kUlpfecPayloadType; |
792 // Set codec to VP8, otherwise NACK/FEC hybrid will be disabled. | 788 // Set codec to VP8, otherwise NACK/FEC hybrid will be disabled. |
793 send_config->encoder_settings.encoder = encoder_.get(); | 789 send_config->encoder_settings.encoder = encoder_.get(); |
794 send_config->encoder_settings.payload_name = "VP8"; | 790 send_config->encoder_settings.payload_name = "VP8"; |
795 send_config->encoder_settings.payload_type = kFakeVideoSendPayloadType; | 791 send_config->encoder_settings.payload_type = kFakeVideoSendPayloadType; |
796 encoder_config->streams[0].min_bitrate_bps = 50000; | |
797 encoder_config->streams[0].max_bitrate_bps = | |
798 encoder_config->streams[0].target_bitrate_bps = 2000000; | |
799 | 792 |
800 (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs; | 793 (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs; |
801 (*receive_configs)[0].rtp.fec.red_payload_type = kRedPayloadType; | 794 (*receive_configs)[0].rtp.fec.red_payload_type = kRedPayloadType; |
802 (*receive_configs)[0].rtp.fec.ulpfec_payload_type = kUlpfecPayloadType; | 795 (*receive_configs)[0].rtp.fec.ulpfec_payload_type = kUlpfecPayloadType; |
803 | 796 |
804 (*receive_configs)[0].decoders.resize(1); | 797 (*receive_configs)[0].decoders.resize(1); |
805 (*receive_configs)[0].decoders[0].payload_type = | 798 (*receive_configs)[0].decoders[0].payload_type = |
806 send_config->encoder_settings.payload_type; | 799 send_config->encoder_settings.payload_type; |
807 (*receive_configs)[0].decoders[0].payload_name = | 800 (*receive_configs)[0].decoders[0].payload_name = |
808 send_config->encoder_settings.payload_name; | 801 send_config->encoder_settings.payload_name; |
(...skipping 305 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1114 test::DirectTransport send_transport(sender_call_.get()); | 1107 test::DirectTransport send_transport(sender_call_.get()); |
1115 test::DirectTransport receive_transport(receiver_call_.get()); | 1108 test::DirectTransport receive_transport(receiver_call_.get()); |
1116 PacketInputObserver input_observer(receiver_call_->Receiver()); | 1109 PacketInputObserver input_observer(receiver_call_->Receiver()); |
1117 send_transport.SetReceiver(&input_observer); | 1110 send_transport.SetReceiver(&input_observer); |
1118 receive_transport.SetReceiver(sender_call_->Receiver()); | 1111 receive_transport.SetReceiver(sender_call_->Receiver()); |
1119 | 1112 |
1120 CreateSendConfig(1, 0, &send_transport); | 1113 CreateSendConfig(1, 0, &send_transport); |
1121 CreateMatchingReceiveConfigs(&receive_transport); | 1114 CreateMatchingReceiveConfigs(&receive_transport); |
1122 | 1115 |
1123 CreateVideoStreams(); | 1116 CreateVideoStreams(); |
1124 CreateFrameGeneratorCapturer(); | 1117 CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth, |
| 1118 kDefaultHeight); |
1125 Start(); | 1119 Start(); |
1126 | 1120 |
1127 receiver_call_->DestroyVideoReceiveStream(video_receive_streams_[0]); | 1121 receiver_call_->DestroyVideoReceiveStream(video_receive_streams_[0]); |
1128 video_receive_streams_.clear(); | 1122 video_receive_streams_.clear(); |
1129 | 1123 |
1130 // Wait() waits for a received packet. | 1124 // Wait() waits for a received packet. |
1131 EXPECT_TRUE(input_observer.Wait()); | 1125 EXPECT_TRUE(input_observer.Wait()); |
1132 | 1126 |
1133 Stop(); | 1127 Stop(); |
1134 | 1128 |
(...skipping 136 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1271 uint32_t ssrc = codec_settings[i].ssrc; | 1265 uint32_t ssrc = codec_settings[i].ssrc; |
1272 int width = codec_settings[i].width; | 1266 int width = codec_settings[i].width; |
1273 int height = codec_settings[i].height; | 1267 int height = codec_settings[i].height; |
1274 | 1268 |
1275 VideoSendStream::Config send_config(sender_transport.get()); | 1269 VideoSendStream::Config send_config(sender_transport.get()); |
1276 send_config.rtp.ssrcs.push_back(ssrc); | 1270 send_config.rtp.ssrcs.push_back(ssrc); |
1277 send_config.encoder_settings.encoder = encoders[i].get(); | 1271 send_config.encoder_settings.encoder = encoders[i].get(); |
1278 send_config.encoder_settings.payload_name = "VP8"; | 1272 send_config.encoder_settings.payload_name = "VP8"; |
1279 send_config.encoder_settings.payload_type = 124; | 1273 send_config.encoder_settings.payload_type = 124; |
1280 VideoEncoderConfig encoder_config; | 1274 VideoEncoderConfig encoder_config; |
1281 encoder_config.streams = test::CreateVideoStreams(1); | 1275 test::FillEncoderConfiguration(1, &encoder_config); |
1282 VideoStream* stream = &encoder_config.streams[0]; | 1276 encoder_config.max_bitrate_bps = 100000; |
1283 stream->width = width; | |
1284 stream->height = height; | |
1285 stream->max_framerate = 5; | |
1286 stream->min_bitrate_bps = stream->target_bitrate_bps = | |
1287 stream->max_bitrate_bps = 100000; | |
1288 | 1277 |
1289 UpdateSendConfig(i, &send_config, &encoder_config, &frame_generators[i]); | 1278 UpdateSendConfig(i, &send_config, &encoder_config, &frame_generators[i]); |
1290 | 1279 |
1291 send_streams[i] = sender_call->CreateVideoSendStream( | 1280 send_streams[i] = sender_call->CreateVideoSendStream( |
1292 send_config.Copy(), encoder_config.Copy()); | 1281 send_config.Copy(), encoder_config.Copy()); |
1293 send_streams[i]->Start(); | 1282 send_streams[i]->Start(); |
1294 | 1283 |
1295 VideoReceiveStream::Config receive_config(receiver_transport.get()); | 1284 VideoReceiveStream::Config receive_config(receiver_transport.get()); |
1296 receive_config.rtp.remote_ssrc = ssrc; | 1285 receive_config.rtp.remote_ssrc = ssrc; |
1297 receive_config.rtp.local_ssrc = test::CallTest::kReceiverLocalVideoSsrc; | 1286 receive_config.rtp.local_ssrc = test::CallTest::kReceiverLocalVideoSsrc; |
(...skipping 257 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1555 size_t stream_index, | 1544 size_t stream_index, |
1556 VideoSendStream::Config* send_config, | 1545 VideoSendStream::Config* send_config, |
1557 VideoEncoderConfig* encoder_config, | 1546 VideoEncoderConfig* encoder_config, |
1558 test::FrameGeneratorCapturer** frame_generator) override { | 1547 test::FrameGeneratorCapturer** frame_generator) override { |
1559 send_config->rtp.extensions.clear(); | 1548 send_config->rtp.extensions.clear(); |
1560 send_config->rtp.extensions.push_back(RtpExtension( | 1549 send_config->rtp.extensions.push_back(RtpExtension( |
1561 RtpExtension::kTransportSequenceNumberUri, kExtensionId)); | 1550 RtpExtension::kTransportSequenceNumberUri, kExtensionId)); |
1562 | 1551 |
1563 // Force some padding to be sent. | 1552 // Force some padding to be sent. |
1564 const int kPaddingBitrateBps = 50000; | 1553 const int kPaddingBitrateBps = 50000; |
1565 int total_target_bitrate = 0; | 1554 encoder_config->max_bitrate_bps = 1000000; |
1566 for (const VideoStream& stream : encoder_config->streams) | |
1567 total_target_bitrate += stream.target_bitrate_bps; | |
1568 encoder_config->min_transmit_bitrate_bps = | 1555 encoder_config->min_transmit_bitrate_bps = |
1569 total_target_bitrate + kPaddingBitrateBps; | 1556 encoder_config->max_bitrate_bps + kPaddingBitrateBps; |
1570 | 1557 |
1571 // Configure RTX for redundant payload padding. | 1558 // Configure RTX for redundant payload padding. |
1572 send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs; | 1559 send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs; |
1573 send_config->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[stream_index]); | 1560 send_config->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[stream_index]); |
1574 send_config->rtp.rtx.payload_type = kSendRtxPayloadType; | 1561 send_config->rtp.rtx.payload_type = kSendRtxPayloadType; |
1575 rtx_to_media_ssrcs_[kSendRtxSsrcs[stream_index]] = | 1562 rtx_to_media_ssrcs_[kSendRtxSsrcs[stream_index]] = |
1576 send_config->rtp.ssrcs[0]; | 1563 send_config->rtp.ssrcs[0]; |
1577 | 1564 |
1578 if (stream_index == 0) | 1565 if (stream_index == 0) |
1579 first_media_ssrc_ = send_config->rtp.ssrcs[0]; | 1566 first_media_ssrc_ = send_config->rtp.ssrcs[0]; |
(...skipping 181 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1761 | 1748 |
1762 CreateSendConfig(1, 0, &sender_transport); | 1749 CreateSendConfig(1, 0, &sender_transport); |
1763 CreateMatchingReceiveConfigs(&receiver_transport); | 1750 CreateMatchingReceiveConfigs(&receiver_transport); |
1764 video_send_config_.post_encode_callback = &post_encode_observer; | 1751 video_send_config_.post_encode_callback = &post_encode_observer; |
1765 video_receive_configs_[0].pre_decode_callback = &pre_decode_observer; | 1752 video_receive_configs_[0].pre_decode_callback = &pre_decode_observer; |
1766 | 1753 |
1767 CreateVideoStreams(); | 1754 CreateVideoStreams(); |
1768 Start(); | 1755 Start(); |
1769 | 1756 |
1770 std::unique_ptr<test::FrameGenerator> frame_generator( | 1757 std::unique_ptr<test::FrameGenerator> frame_generator( |
1771 test::FrameGenerator::CreateChromaGenerator( | 1758 test::FrameGenerator::CreateChromaGenerator(kDefaultWidth, |
1772 video_encoder_config_.streams[0].width, | 1759 kDefaultHeight)); |
1773 video_encoder_config_.streams[0].height)); | |
1774 test::FrameForwarder forwarder; | 1760 test::FrameForwarder forwarder; |
1775 video_send_stream_->SetSource(&forwarder); | 1761 video_send_stream_->SetSource(&forwarder); |
1776 forwarder.IncomingCapturedFrame(*frame_generator->NextFrame()); | 1762 forwarder.IncomingCapturedFrame(*frame_generator->NextFrame()); |
1777 | 1763 |
1778 EXPECT_TRUE(post_encode_observer.Wait()) | 1764 EXPECT_TRUE(post_encode_observer.Wait()) |
1779 << "Timed out while waiting for send-side encoded-frame callback."; | 1765 << "Timed out while waiting for send-side encoded-frame callback."; |
1780 | 1766 |
1781 EXPECT_TRUE(pre_decode_observer.Wait()) | 1767 EXPECT_TRUE(pre_decode_observer.Wait()) |
1782 << "Timed out while waiting for pre-decode encoded-frame callback."; | 1768 << "Timed out while waiting for pre-decode encoded-frame callback."; |
1783 | 1769 |
(...skipping 130 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1914 VideoSendStream::Config* send_config, | 1900 VideoSendStream::Config* send_config, |
1915 std::vector<VideoReceiveStream::Config>* receive_configs, | 1901 std::vector<VideoReceiveStream::Config>* receive_configs, |
1916 VideoEncoderConfig* encoder_config) override { | 1902 VideoEncoderConfig* encoder_config) override { |
1917 ASSERT_EQ(1u, send_config->rtp.ssrcs.size()); | 1903 ASSERT_EQ(1u, send_config->rtp.ssrcs.size()); |
1918 send_config->rtp.extensions.clear(); | 1904 send_config->rtp.extensions.clear(); |
1919 send_config->rtp.extensions.push_back( | 1905 send_config->rtp.extensions.push_back( |
1920 RtpExtension(RtpExtension::kTransportSequenceNumberUri, | 1906 RtpExtension(RtpExtension::kTransportSequenceNumberUri, |
1921 test::kTransportSequenceNumberExtensionId)); | 1907 test::kTransportSequenceNumberExtensionId)); |
1922 sender_ssrc_ = send_config->rtp.ssrcs[0]; | 1908 sender_ssrc_ = send_config->rtp.ssrcs[0]; |
1923 | 1909 |
1924 encoder_config->streams[0].max_bitrate_bps = | 1910 encoder_config->max_bitrate_bps = 2000000; |
1925 encoder_config->streams[0].target_bitrate_bps = 2000000; | |
1926 | 1911 |
1927 ASSERT_EQ(1u, receive_configs->size()); | 1912 ASSERT_EQ(1u, receive_configs->size()); |
1928 (*receive_configs)[0].rtp.remb = false; | 1913 (*receive_configs)[0].rtp.remb = false; |
1929 (*receive_configs)[0].rtp.transport_cc = true; | 1914 (*receive_configs)[0].rtp.transport_cc = true; |
1930 (*receive_configs)[0].rtp.extensions = send_config->rtp.extensions; | 1915 (*receive_configs)[0].rtp.extensions = send_config->rtp.extensions; |
1931 RtpRtcp::Configuration config; | 1916 RtpRtcp::Configuration config; |
1932 config.receiver_only = true; | 1917 config.receiver_only = true; |
1933 config.clock = clock_; | 1918 config.clock = clock_; |
1934 config.outgoing_transport = receive_transport_; | 1919 config.outgoing_transport = receive_transport_; |
1935 config.retransmission_rate_limiter = &retransmission_rate_limiter_; | 1920 config.retransmission_rate_limiter = &retransmission_rate_limiter_; |
(...skipping 322 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2258 EXPECT_EQ(1, | 2243 EXPECT_EQ(1, |
2259 metrics::NumSamples("WebRTC.Video.ReceivedPacketsLostInPercent")); | 2244 metrics::NumSamples("WebRTC.Video.ReceivedPacketsLostInPercent")); |
2260 | 2245 |
2261 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "InputWidthInPixels")); | 2246 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "InputWidthInPixels")); |
2262 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "InputHeightInPixels")); | 2247 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "InputHeightInPixels")); |
2263 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "SentWidthInPixels")); | 2248 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "SentWidthInPixels")); |
2264 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "SentHeightInPixels")); | 2249 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "SentHeightInPixels")); |
2265 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.ReceivedWidthInPixels")); | 2250 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.ReceivedWidthInPixels")); |
2266 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.ReceivedHeightInPixels")); | 2251 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.ReceivedHeightInPixels")); |
2267 | 2252 |
2268 EXPECT_EQ(1, metrics::NumEvents( | 2253 EXPECT_EQ(1, metrics::NumEvents(video_prefix + "InputWidthInPixels", |
2269 video_prefix + "InputWidthInPixels", | 2254 kDefaultWidth)); |
2270 static_cast<int>(video_encoder_config_.streams[0].width))); | 2255 EXPECT_EQ(1, metrics::NumEvents(video_prefix + "InputHeightInPixels", |
2271 EXPECT_EQ(1, metrics::NumEvents( | 2256 kDefaultHeight)); |
2272 video_prefix + "InputHeightInPixels", | 2257 EXPECT_EQ( |
2273 static_cast<int>(video_encoder_config_.streams[0].height))); | 2258 1, metrics::NumEvents(video_prefix + "SentWidthInPixels", kDefaultWidth)); |
2274 EXPECT_EQ(1, metrics::NumEvents( | 2259 EXPECT_EQ(1, metrics::NumEvents(video_prefix + "SentHeightInPixels", |
2275 video_prefix + "SentWidthInPixels", | 2260 kDefaultHeight)); |
2276 static_cast<int>(video_encoder_config_.streams[0].width))); | 2261 EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.ReceivedWidthInPixels", |
2277 EXPECT_EQ(1, metrics::NumEvents( | 2262 kDefaultWidth)); |
2278 video_prefix + "SentHeightInPixels", | 2263 EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.ReceivedHeightInPixels", |
2279 static_cast<int>(video_encoder_config_.streams[0].height))); | 2264 kDefaultHeight)); |
2280 EXPECT_EQ(1, metrics::NumEvents( | |
2281 "WebRTC.Video.ReceivedWidthInPixels", | |
2282 static_cast<int>(video_encoder_config_.streams[0].width))); | |
2283 EXPECT_EQ(1, metrics::NumEvents( | |
2284 "WebRTC.Video.ReceivedHeightInPixels", | |
2285 static_cast<int>(video_encoder_config_.streams[0].height))); | |
2286 | 2265 |
2287 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "InputFramesPerSecond")); | 2266 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "InputFramesPerSecond")); |
2288 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "SentFramesPerSecond")); | 2267 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "SentFramesPerSecond")); |
2289 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.DecodedFramesPerSecond")); | 2268 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.DecodedFramesPerSecond")); |
2290 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.RenderFramesPerSecond")); | 2269 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.RenderFramesPerSecond")); |
2291 | 2270 |
2292 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.JitterBufferDelayInMs")); | 2271 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.JitterBufferDelayInMs")); |
2293 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.TargetDelayInMs")); | 2272 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.TargetDelayInMs")); |
2294 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.CurrentDelayInMs")); | 2273 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.CurrentDelayInMs")); |
2295 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.OnewayDelayInMs")); | 2274 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.OnewayDelayInMs")); |
(...skipping 185 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2481 } | 2460 } |
2482 | 2461 |
2483 if (ssrcs_to_observe_ == 0) | 2462 if (ssrcs_to_observe_ == 0) |
2484 observation_complete_.Set(); | 2463 observation_complete_.Set(); |
2485 | 2464 |
2486 return SEND_PACKET; | 2465 return SEND_PACKET; |
2487 } | 2466 } |
2488 | 2467 |
2489 size_t GetNumVideoStreams() const override { return num_ssrcs_; } | 2468 size_t GetNumVideoStreams() const override { return num_ssrcs_; } |
2490 | 2469 |
| 2470 // This test use other VideoStream settings than the the default settings |
| 2471 // implemented in DefaultVideoStreamFactory. Therefore this test implement |
| 2472 // its own VideoEncoderConfig::VideoStreamFactoryInterface which is created |
| 2473 // in ModifyVideoConfigs. |
| 2474 class VideoStreamFactory |
| 2475 : public VideoEncoderConfig::VideoStreamFactoryInterface { |
| 2476 public: |
| 2477 VideoStreamFactory() {} |
| 2478 |
| 2479 private: |
| 2480 std::vector<VideoStream> CreateEncoderStreams( |
| 2481 int width, |
| 2482 int height, |
| 2483 const VideoEncoderConfig& encoder_config) override { |
| 2484 std::vector<VideoStream> streams = |
| 2485 test::CreateVideoStreams(width, height, encoder_config); |
| 2486 // Set low simulcast bitrates to not have to wait for bandwidth ramp-up. |
| 2487 for (size_t i = 0; i < encoder_config.number_of_streams; ++i) { |
| 2488 streams[i].min_bitrate_bps = 10000; |
| 2489 streams[i].target_bitrate_bps = 15000; |
| 2490 streams[i].max_bitrate_bps = 20000; |
| 2491 } |
| 2492 return streams; |
| 2493 } |
| 2494 }; |
| 2495 |
2491 void ModifyVideoConfigs( | 2496 void ModifyVideoConfigs( |
2492 VideoSendStream::Config* send_config, | 2497 VideoSendStream::Config* send_config, |
2493 std::vector<VideoReceiveStream::Config>* receive_configs, | 2498 std::vector<VideoReceiveStream::Config>* receive_configs, |
2494 VideoEncoderConfig* encoder_config) override { | 2499 VideoEncoderConfig* encoder_config) override { |
2495 if (num_ssrcs_ > 1) { | 2500 encoder_config->video_stream_factory = |
2496 // Set low simulcast bitrates to not have to wait for bandwidth ramp-up. | 2501 new rtc::RefCountedObject<VideoStreamFactory>(); |
2497 for (size_t i = 0; i < encoder_config->streams.size(); ++i) { | |
2498 encoder_config->streams[i].min_bitrate_bps = 10000; | |
2499 encoder_config->streams[i].target_bitrate_bps = 15000; | |
2500 encoder_config->streams[i].max_bitrate_bps = 20000; | |
2501 } | |
2502 } | |
2503 | |
2504 video_encoder_config_all_streams_ = encoder_config->Copy(); | 2502 video_encoder_config_all_streams_ = encoder_config->Copy(); |
2505 if (send_single_ssrc_first_) | 2503 if (send_single_ssrc_first_) |
2506 encoder_config->streams.resize(1); | 2504 encoder_config->number_of_streams = 1; |
2507 } | 2505 } |
2508 | 2506 |
2509 void OnVideoStreamsCreated( | 2507 void OnVideoStreamsCreated( |
2510 VideoSendStream* send_stream, | 2508 VideoSendStream* send_stream, |
2511 const std::vector<VideoReceiveStream*>& receive_streams) override { | 2509 const std::vector<VideoReceiveStream*>& receive_streams) override { |
2512 send_stream_ = send_stream; | 2510 send_stream_ = send_stream; |
2513 } | 2511 } |
2514 | 2512 |
2515 void PerformTest() override { | 2513 void PerformTest() override { |
2516 EXPECT_TRUE(Wait()) << "Timed out while waiting for " | 2514 EXPECT_TRUE(Wait()) << "Timed out while waiting for " |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2556 VideoSendStream* send_stream, | 2554 VideoSendStream* send_stream, |
2557 const std::vector<VideoReceiveStream*>& receive_streams) override { | 2555 const std::vector<VideoReceiveStream*>& receive_streams) override { |
2558 send_stream_ = send_stream; | 2556 send_stream_ = send_stream; |
2559 } | 2557 } |
2560 | 2558 |
2561 void ModifyVideoConfigs( | 2559 void ModifyVideoConfigs( |
2562 VideoSendStream::Config* send_config, | 2560 VideoSendStream::Config* send_config, |
2563 std::vector<VideoReceiveStream::Config>* receive_configs, | 2561 std::vector<VideoReceiveStream::Config>* receive_configs, |
2564 VideoEncoderConfig* encoder_config) override { | 2562 VideoEncoderConfig* encoder_config) override { |
2565 send_config->encoder_settings.encoder = this; | 2563 send_config->encoder_settings.encoder = this; |
2566 RTC_DCHECK_EQ(1u, encoder_config->streams.size()); | 2564 RTC_DCHECK_EQ(1u, encoder_config->number_of_streams); |
2567 } | 2565 } |
2568 | 2566 |
2569 int32_t SetRates(uint32_t new_target_bitrate, uint32_t framerate) override { | 2567 int32_t SetRates(uint32_t new_target_bitrate, uint32_t framerate) override { |
2570 // Make sure not to trigger on any default zero bitrates. | 2568 // Make sure not to trigger on any default zero bitrates. |
2571 if (new_target_bitrate == 0) | 2569 if (new_target_bitrate == 0) |
2572 return 0; | 2570 return 0; |
2573 rtc::CritScope lock(&crit_); | 2571 rtc::CritScope lock(&crit_); |
2574 bitrate_kbps_ = new_target_bitrate; | 2572 bitrate_kbps_ = new_target_bitrate; |
2575 observation_complete_.Set(); | 2573 observation_complete_.Set(); |
2576 return 0; | 2574 return 0; |
(...skipping 251 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2828 return new test::PacketTransport( | 2826 return new test::PacketTransport( |
2829 sender_call, this, test::PacketTransport::kSender, network_config); | 2827 sender_call, this, test::PacketTransport::kSender, network_config); |
2830 } | 2828 } |
2831 | 2829 |
2832 Call::Config GetSenderCallConfig() override { | 2830 Call::Config GetSenderCallConfig() override { |
2833 Call::Config config = EndToEndTest::GetSenderCallConfig(); | 2831 Call::Config config = EndToEndTest::GetSenderCallConfig(); |
2834 config.bitrate_config.start_bitrate_bps = kStartBitrateBps; | 2832 config.bitrate_config.start_bitrate_bps = kStartBitrateBps; |
2835 return config; | 2833 return config; |
2836 } | 2834 } |
2837 | 2835 |
| 2836 // This test use other VideoStream settings than the the default settings |
| 2837 // implemented in DefaultVideoStreamFactory. Therefore this test implement |
| 2838 // its own VideoEncoderConfig::VideoStreamFactoryInterface which is created |
| 2839 // in ModifyVideoConfigs. |
| 2840 class VideoStreamFactory |
| 2841 : public VideoEncoderConfig::VideoStreamFactoryInterface { |
| 2842 public: |
| 2843 VideoStreamFactory() {} |
| 2844 |
| 2845 private: |
| 2846 std::vector<VideoStream> CreateEncoderStreams( |
| 2847 int width, |
| 2848 int height, |
| 2849 const VideoEncoderConfig& encoder_config) override { |
| 2850 std::vector<VideoStream> streams = |
| 2851 test::CreateVideoStreams(width, height, encoder_config); |
| 2852 // Set low simulcast bitrates to not have to wait for bandwidth ramp-up. |
| 2853 for (size_t i = 0; i < encoder_config.number_of_streams; ++i) { |
| 2854 streams[i].min_bitrate_bps = 10000; |
| 2855 streams[i].target_bitrate_bps = 15000; |
| 2856 streams[i].max_bitrate_bps = 20000; |
| 2857 } |
| 2858 return streams; |
| 2859 } |
| 2860 }; |
| 2861 |
2838 void ModifyVideoConfigs( | 2862 void ModifyVideoConfigs( |
2839 VideoSendStream::Config* send_config, | 2863 VideoSendStream::Config* send_config, |
2840 std::vector<VideoReceiveStream::Config>* receive_configs, | 2864 std::vector<VideoReceiveStream::Config>* receive_configs, |
2841 VideoEncoderConfig* encoder_config) override { | 2865 VideoEncoderConfig* encoder_config) override { |
2842 // Set low rates to avoid waiting for rampup. | 2866 encoder_config->video_stream_factory = |
2843 for (size_t i = 0; i < encoder_config->streams.size(); ++i) { | 2867 new rtc::RefCountedObject<VideoStreamFactory>(); |
2844 encoder_config->streams[i].min_bitrate_bps = 10000; | |
2845 encoder_config->streams[i].target_bitrate_bps = 15000; | |
2846 encoder_config->streams[i].max_bitrate_bps = 20000; | |
2847 } | |
2848 send_config->pre_encode_callback = this; // Used to inject delay. | 2868 send_config->pre_encode_callback = this; // Used to inject delay. |
2849 expected_cname_ = send_config->rtp.c_name = "SomeCName"; | 2869 expected_cname_ = send_config->rtp.c_name = "SomeCName"; |
2850 | 2870 |
2851 send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs; | 2871 send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs; |
2852 send_config->rtp.rtx.payload_type = kSendRtxPayloadType; | 2872 send_config->rtp.rtx.payload_type = kSendRtxPayloadType; |
2853 | 2873 |
2854 const std::vector<uint32_t>& ssrcs = send_config->rtp.ssrcs; | 2874 const std::vector<uint32_t>& ssrcs = send_config->rtp.ssrcs; |
2855 for (size_t i = 0; i < ssrcs.size(); ++i) { | 2875 for (size_t i = 0; i < ssrcs.size(); ++i) { |
2856 expected_send_ssrcs_.insert(ssrcs[i]); | 2876 expected_send_ssrcs_.insert(ssrcs[i]); |
2857 expected_receive_ssrcs_.push_back( | 2877 expected_receive_ssrcs_.push_back( |
(...skipping 172 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3030 observed_redundant_retransmission_[header.ssrc] = true; | 3050 observed_redundant_retransmission_[header.ssrc] = true; |
3031 if (--ssrcs_to_observe_ == 0) | 3051 if (--ssrcs_to_observe_ == 0) |
3032 observation_complete_.Set(); | 3052 observation_complete_.Set(); |
3033 } | 3053 } |
3034 | 3054 |
3035 return SEND_PACKET; | 3055 return SEND_PACKET; |
3036 } | 3056 } |
3037 | 3057 |
3038 size_t GetNumVideoStreams() const override { return kNumSsrcs; } | 3058 size_t GetNumVideoStreams() const override { return kNumSsrcs; } |
3039 | 3059 |
| 3060 // This test use other VideoStream settings than the the default settings |
| 3061 // implemented in DefaultVideoStreamFactory. Therefore this test implement |
| 3062 // its own VideoEncoderConfig::VideoStreamFactoryInterface which is created |
| 3063 // in ModifyVideoConfigs. |
| 3064 class VideoStreamFactory |
| 3065 : public VideoEncoderConfig::VideoStreamFactoryInterface { |
| 3066 public: |
| 3067 VideoStreamFactory() {} |
| 3068 |
| 3069 private: |
| 3070 std::vector<VideoStream> CreateEncoderStreams( |
| 3071 int width, |
| 3072 int height, |
| 3073 const VideoEncoderConfig& encoder_config) override { |
| 3074 std::vector<VideoStream> streams = |
| 3075 test::CreateVideoStreams(width, height, encoder_config); |
| 3076 // Set low simulcast bitrates to not have to wait for bandwidth ramp-up. |
| 3077 for (size_t i = 0; i < encoder_config.number_of_streams; ++i) { |
| 3078 streams[i].min_bitrate_bps = 10000; |
| 3079 streams[i].target_bitrate_bps = 15000; |
| 3080 streams[i].max_bitrate_bps = 20000; |
| 3081 } |
| 3082 return streams; |
| 3083 } |
| 3084 }; |
| 3085 |
3040 void ModifyVideoConfigs( | 3086 void ModifyVideoConfigs( |
3041 VideoSendStream::Config* send_config, | 3087 VideoSendStream::Config* send_config, |
3042 std::vector<VideoReceiveStream::Config>* receive_configs, | 3088 std::vector<VideoReceiveStream::Config>* receive_configs, |
3043 VideoEncoderConfig* encoder_config) override { | 3089 VideoEncoderConfig* encoder_config) override { |
3044 // Set low simulcast bitrates to not have to wait for bandwidth ramp-up. | 3090 // Set low simulcast bitrates to not have to wait for bandwidth ramp-up. |
3045 for (size_t i = 0; i < encoder_config->streams.size(); ++i) { | 3091 encoder_config->video_stream_factory = |
3046 encoder_config->streams[i].min_bitrate_bps = 10000; | 3092 new rtc::RefCountedObject<VideoStreamFactory>(); |
3047 encoder_config->streams[i].target_bitrate_bps = 15000; | |
3048 encoder_config->streams[i].max_bitrate_bps = 20000; | |
3049 } | |
3050 | |
3051 send_config->rtp.rtx.payload_type = kSendRtxPayloadType; | 3093 send_config->rtp.rtx.payload_type = kSendRtxPayloadType; |
3052 | 3094 |
3053 for (size_t i = 0; i < kNumSsrcs; ++i) | 3095 for (size_t i = 0; i < kNumSsrcs; ++i) |
3054 send_config->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]); | 3096 send_config->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]); |
3055 | 3097 |
3056 // Significantly higher than max bitrates for all video streams -> forcing | 3098 // Significantly higher than max bitrates for all video streams -> forcing |
3057 // padding to trigger redundant padding on all RTX SSRCs. | 3099 // padding to trigger redundant padding on all RTX SSRCs. |
3058 encoder_config->min_transmit_bitrate_bps = 100000; | 3100 encoder_config->min_transmit_bitrate_bps = 100000; |
3059 } | 3101 } |
3060 | 3102 |
3061 void PerformTest() override { | 3103 void PerformTest() override { |
3062 EXPECT_TRUE(Wait()) | 3104 EXPECT_TRUE(Wait()) |
3063 << "Timed out while waiting for redundant payloads on all SSRCs."; | 3105 << "Timed out while waiting for redundant payloads on all SSRCs."; |
3064 } | 3106 } |
3065 | 3107 |
3066 private: | 3108 private: |
3067 size_t ssrcs_to_observe_; | 3109 size_t ssrcs_to_observe_; |
3068 std::map<uint32_t, bool> observed_redundant_retransmission_; | 3110 std::map<uint32_t, bool> observed_redundant_retransmission_; |
3069 std::map<uint32_t, bool> registered_rtx_ssrc_; | 3111 std::map<uint32_t, bool> registered_rtx_ssrc_; |
3070 } test; | 3112 } test; |
3071 | 3113 |
3072 RunBaseTest(&test); | 3114 RunBaseTest(&test); |
3073 } | 3115 } |
3074 | 3116 |
3075 void EndToEndTest::TestRtpStatePreservation(bool use_rtx, | 3117 void EndToEndTest::TestRtpStatePreservation(bool use_rtx, |
3076 bool provoke_rtcpsr_before_rtp) { | 3118 bool provoke_rtcpsr_before_rtp) { |
| 3119 // This test use other VideoStream settings than the the default settings |
| 3120 // implemented in DefaultVideoStreamFactory. Therefore this test implement |
| 3121 // its own VideoEncoderConfig::VideoStreamFactoryInterface which is created |
| 3122 // in ModifyVideoConfigs. |
| 3123 class VideoStreamFactory |
| 3124 : public VideoEncoderConfig::VideoStreamFactoryInterface { |
| 3125 public: |
| 3126 VideoStreamFactory() {} |
| 3127 |
| 3128 private: |
| 3129 std::vector<VideoStream> CreateEncoderStreams( |
| 3130 int width, |
| 3131 int height, |
| 3132 const VideoEncoderConfig& encoder_config) override { |
| 3133 std::vector<VideoStream> streams = |
| 3134 test::CreateVideoStreams(width, height, encoder_config); |
| 3135 |
| 3136 if (encoder_config.number_of_streams > 1) { |
| 3137 // Lower bitrates so that all streams send initially. |
| 3138 RTC_DCHECK_EQ(3u, encoder_config.number_of_streams); |
| 3139 for (size_t i = 0; i < encoder_config.number_of_streams; ++i) { |
| 3140 streams[i].min_bitrate_bps = 10000; |
| 3141 streams[i].target_bitrate_bps = 15000; |
| 3142 streams[i].max_bitrate_bps = 20000; |
| 3143 } |
| 3144 } else { |
| 3145 // Use the same total bitrates when sending a single stream to avoid |
| 3146 // lowering |
| 3147 // the bitrate estimate and requiring a subsequent rampup. |
| 3148 streams[0].min_bitrate_bps = 3 * 10000; |
| 3149 streams[0].target_bitrate_bps = 3 * 15000; |
| 3150 streams[0].max_bitrate_bps = 3 * 20000; |
| 3151 } |
| 3152 return streams; |
| 3153 } |
| 3154 }; |
| 3155 |
3077 class RtpSequenceObserver : public test::RtpRtcpObserver { | 3156 class RtpSequenceObserver : public test::RtpRtcpObserver { |
3078 public: | 3157 public: |
3079 explicit RtpSequenceObserver(bool use_rtx) | 3158 explicit RtpSequenceObserver(bool use_rtx) |
3080 : test::RtpRtcpObserver(kDefaultTimeoutMs), | 3159 : test::RtpRtcpObserver(kDefaultTimeoutMs), |
3081 ssrcs_to_observe_(kNumSsrcs) { | 3160 ssrcs_to_observe_(kNumSsrcs) { |
3082 for (size_t i = 0; i < kNumSsrcs; ++i) { | 3161 for (size_t i = 0; i < kNumSsrcs; ++i) { |
3083 ssrc_is_rtx_[kVideoSendSsrcs[i]] = false; | 3162 ssrc_is_rtx_[kVideoSendSsrcs[i]] = false; |
3084 if (use_rtx) | 3163 if (use_rtx) |
3085 ssrc_is_rtx_[kSendRtxSsrcs[i]] = true; | 3164 ssrc_is_rtx_[kSendRtxSsrcs[i]] = true; |
3086 } | 3165 } |
(...skipping 115 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3202 | 3281 |
3203 CreateSendConfig(kNumSsrcs, 0, &send_transport); | 3282 CreateSendConfig(kNumSsrcs, 0, &send_transport); |
3204 | 3283 |
3205 if (use_rtx) { | 3284 if (use_rtx) { |
3206 for (size_t i = 0; i < kNumSsrcs; ++i) { | 3285 for (size_t i = 0; i < kNumSsrcs; ++i) { |
3207 video_send_config_.rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]); | 3286 video_send_config_.rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]); |
3208 } | 3287 } |
3209 video_send_config_.rtp.rtx.payload_type = kSendRtxPayloadType; | 3288 video_send_config_.rtp.rtx.payload_type = kSendRtxPayloadType; |
3210 } | 3289 } |
3211 | 3290 |
3212 // Lower bitrates so that all streams send initially. | 3291 video_encoder_config_.video_stream_factory = |
3213 for (size_t i = 0; i < video_encoder_config_.streams.size(); ++i) { | 3292 new rtc::RefCountedObject<VideoStreamFactory>(); |
3214 video_encoder_config_.streams[i].min_bitrate_bps = 10000; | |
3215 video_encoder_config_.streams[i].target_bitrate_bps = 15000; | |
3216 video_encoder_config_.streams[i].max_bitrate_bps = 20000; | |
3217 } | |
3218 | |
3219 // Use the same total bitrates when sending a single stream to avoid lowering | 3293 // Use the same total bitrates when sending a single stream to avoid lowering |
3220 // the bitrate estimate and requiring a subsequent rampup. | 3294 // the bitrate estimate and requiring a subsequent rampup. |
3221 VideoEncoderConfig one_stream = video_encoder_config_.Copy(); | 3295 VideoEncoderConfig one_stream = video_encoder_config_.Copy(); |
3222 one_stream.streams.resize(1); | 3296 // one_stream.streams.resize(1); |
3223 for (size_t i = 1; i < video_encoder_config_.streams.size(); ++i) { | 3297 one_stream.number_of_streams = 1; |
3224 one_stream.streams.front().min_bitrate_bps += | |
3225 video_encoder_config_.streams[i].min_bitrate_bps; | |
3226 one_stream.streams.front().target_bitrate_bps += | |
3227 video_encoder_config_.streams[i].target_bitrate_bps; | |
3228 one_stream.streams.front().max_bitrate_bps += | |
3229 video_encoder_config_.streams[i].max_bitrate_bps; | |
3230 } | |
3231 | |
3232 CreateMatchingReceiveConfigs(&receive_transport); | 3298 CreateMatchingReceiveConfigs(&receive_transport); |
3233 | 3299 |
3234 CreateVideoStreams(); | 3300 CreateVideoStreams(); |
3235 CreateFrameGeneratorCapturer(); | 3301 CreateFrameGeneratorCapturer(30, 1280, 720); |
3236 | 3302 |
3237 Start(); | 3303 Start(); |
3238 EXPECT_TRUE(observer.Wait()) | 3304 EXPECT_TRUE(observer.Wait()) |
3239 << "Timed out waiting for all SSRCs to send packets."; | 3305 << "Timed out waiting for all SSRCs to send packets."; |
3240 | 3306 |
3241 // Test stream resetting more than once to make sure that the state doesn't | 3307 // Test stream resetting more than once to make sure that the state doesn't |
3242 // get set once (this could be due to using std::map::insert for instance). | 3308 // get set once (this could be due to using std::map::insert for instance). |
3243 for (size_t i = 0; i < 3; ++i) { | 3309 for (size_t i = 0; i < 3; ++i) { |
3244 frame_generator_capturer_->Stop(); | 3310 frame_generator_capturer_->Stop(); |
3245 sender_call_->DestroyVideoSendStream(video_send_stream_); | 3311 sender_call_->DestroyVideoSendStream(video_send_stream_); |
3246 | 3312 |
3247 // Re-create VideoSendStream with only one stream. | 3313 // Re-create VideoSendStream with only one stream. |
3248 video_send_stream_ = sender_call_->CreateVideoSendStream( | 3314 video_send_stream_ = sender_call_->CreateVideoSendStream( |
3249 video_send_config_.Copy(), one_stream.Copy()); | 3315 video_send_config_.Copy(), one_stream.Copy()); |
3250 video_send_stream_->Start(); | 3316 video_send_stream_->Start(); |
3251 if (provoke_rtcpsr_before_rtp) { | 3317 if (provoke_rtcpsr_before_rtp) { |
3252 // Rapid Resync Request forces sending RTCP Sender Report back. | 3318 // Rapid Resync Request forces sending RTCP Sender Report back. |
3253 // Using this request speeds up this test because then there is no need | 3319 // Using this request speeds up this test because then there is no need |
3254 // to wait for a second for periodic Sender Report. | 3320 // to wait for a second for periodic Sender Report. |
3255 rtcp::RapidResyncRequest force_send_sr_back_request; | 3321 rtcp::RapidResyncRequest force_send_sr_back_request; |
3256 rtc::Buffer packet = force_send_sr_back_request.Build(); | 3322 rtc::Buffer packet = force_send_sr_back_request.Build(); |
3257 static_cast<webrtc::test::DirectTransport&>(receive_transport) | 3323 static_cast<webrtc::test::DirectTransport&>(receive_transport) |
3258 .SendRtcp(packet.data(), packet.size()); | 3324 .SendRtcp(packet.data(), packet.size()); |
3259 } | 3325 } |
3260 CreateFrameGeneratorCapturer(); | 3326 CreateFrameGeneratorCapturer(30, 1280, 720); |
3261 frame_generator_capturer_->Start(); | 3327 frame_generator_capturer_->Start(); |
3262 | 3328 |
3263 observer.ResetExpectedSsrcs(1); | 3329 observer.ResetExpectedSsrcs(1); |
3264 EXPECT_TRUE(observer.Wait()) << "Timed out waiting for single RTP packet."; | 3330 EXPECT_TRUE(observer.Wait()) << "Timed out waiting for single RTP packet."; |
3265 | 3331 |
3266 // Reconfigure back to use all streams. | 3332 // Reconfigure back to use all streams. |
3267 video_send_stream_->ReconfigureVideoEncoder(video_encoder_config_.Copy()); | 3333 video_send_stream_->ReconfigureVideoEncoder(video_encoder_config_.Copy()); |
3268 observer.ResetExpectedSsrcs(kNumSsrcs); | 3334 observer.ResetExpectedSsrcs(kNumSsrcs); |
3269 EXPECT_TRUE(observer.Wait()) | 3335 EXPECT_TRUE(observer.Wait()) |
3270 << "Timed out waiting for all SSRCs to send packets."; | 3336 << "Timed out waiting for all SSRCs to send packets."; |
(...skipping 234 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3505 test::DirectTransport sender_transport(config, sender_call_.get()); | 3571 test::DirectTransport sender_transport(config, sender_call_.get()); |
3506 config.queue_delay_ms = kReceiveDelayMs; | 3572 config.queue_delay_ms = kReceiveDelayMs; |
3507 test::DirectTransport receiver_transport(config, receiver_call_.get()); | 3573 test::DirectTransport receiver_transport(config, receiver_call_.get()); |
3508 sender_transport.SetReceiver(receiver_call_->Receiver()); | 3574 sender_transport.SetReceiver(receiver_call_->Receiver()); |
3509 receiver_transport.SetReceiver(sender_call_->Receiver()); | 3575 receiver_transport.SetReceiver(sender_call_->Receiver()); |
3510 | 3576 |
3511 CreateSendConfig(1, 0, &sender_transport); | 3577 CreateSendConfig(1, 0, &sender_transport); |
3512 CreateMatchingReceiveConfigs(&receiver_transport); | 3578 CreateMatchingReceiveConfigs(&receiver_transport); |
3513 | 3579 |
3514 CreateVideoStreams(); | 3580 CreateVideoStreams(); |
3515 CreateFrameGeneratorCapturer(); | 3581 CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth, |
| 3582 kDefaultHeight); |
3516 Start(); | 3583 Start(); |
3517 | 3584 |
3518 int64_t start_time_ms = clock_->TimeInMilliseconds(); | 3585 int64_t start_time_ms = clock_->TimeInMilliseconds(); |
3519 while (true) { | 3586 while (true) { |
3520 Call::Stats stats = sender_call_->GetStats(); | 3587 Call::Stats stats = sender_call_->GetStats(); |
3521 ASSERT_GE(start_time_ms + kDefaultTimeoutMs, | 3588 ASSERT_GE(start_time_ms + kDefaultTimeoutMs, |
3522 clock_->TimeInMilliseconds()) | 3589 clock_->TimeInMilliseconds()) |
3523 << "No RTT stats before timeout!"; | 3590 << "No RTT stats before timeout!"; |
3524 if (stats.rtt_ms != -1) { | 3591 if (stats.rtt_ms != -1) { |
3525 // To avoid failures caused by rounding or minor ntp clock adjustments, | 3592 // To avoid failures caused by rounding or minor ntp clock adjustments, |
(...skipping 12 matching lines...) Expand all Loading... |
3538 void EndToEndTest::VerifyNewVideoSendStreamsRespectNetworkState( | 3605 void EndToEndTest::VerifyNewVideoSendStreamsRespectNetworkState( |
3539 MediaType network_to_bring_down, | 3606 MediaType network_to_bring_down, |
3540 VideoEncoder* encoder, | 3607 VideoEncoder* encoder, |
3541 Transport* transport) { | 3608 Transport* transport) { |
3542 CreateSenderCall(Call::Config()); | 3609 CreateSenderCall(Call::Config()); |
3543 sender_call_->SignalChannelNetworkState(network_to_bring_down, kNetworkDown); | 3610 sender_call_->SignalChannelNetworkState(network_to_bring_down, kNetworkDown); |
3544 | 3611 |
3545 CreateSendConfig(1, 0, transport); | 3612 CreateSendConfig(1, 0, transport); |
3546 video_send_config_.encoder_settings.encoder = encoder; | 3613 video_send_config_.encoder_settings.encoder = encoder; |
3547 CreateVideoStreams(); | 3614 CreateVideoStreams(); |
3548 CreateFrameGeneratorCapturer(); | 3615 CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth, |
| 3616 kDefaultHeight); |
3549 | 3617 |
3550 Start(); | 3618 Start(); |
3551 SleepMs(kSilenceTimeoutMs); | 3619 SleepMs(kSilenceTimeoutMs); |
3552 Stop(); | 3620 Stop(); |
3553 | 3621 |
3554 DestroyStreams(); | 3622 DestroyStreams(); |
3555 } | 3623 } |
3556 | 3624 |
3557 void EndToEndTest::VerifyNewVideoReceiveStreamsRespectNetworkState( | 3625 void EndToEndTest::VerifyNewVideoReceiveStreamsRespectNetworkState( |
3558 MediaType network_to_bring_down, | 3626 MediaType network_to_bring_down, |
3559 Transport* transport) { | 3627 Transport* transport) { |
3560 CreateCalls(Call::Config(), Call::Config()); | 3628 CreateCalls(Call::Config(), Call::Config()); |
3561 receiver_call_->SignalChannelNetworkState(network_to_bring_down, | 3629 receiver_call_->SignalChannelNetworkState(network_to_bring_down, |
3562 kNetworkDown); | 3630 kNetworkDown); |
3563 | 3631 |
3564 test::DirectTransport sender_transport(sender_call_.get()); | 3632 test::DirectTransport sender_transport(sender_call_.get()); |
3565 sender_transport.SetReceiver(receiver_call_->Receiver()); | 3633 sender_transport.SetReceiver(receiver_call_->Receiver()); |
3566 CreateSendConfig(1, 0, &sender_transport); | 3634 CreateSendConfig(1, 0, &sender_transport); |
3567 CreateMatchingReceiveConfigs(transport); | 3635 CreateMatchingReceiveConfigs(transport); |
3568 CreateVideoStreams(); | 3636 CreateVideoStreams(); |
3569 CreateFrameGeneratorCapturer(); | 3637 CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth, |
| 3638 kDefaultHeight); |
3570 | 3639 |
3571 Start(); | 3640 Start(); |
3572 SleepMs(kSilenceTimeoutMs); | 3641 SleepMs(kSilenceTimeoutMs); |
3573 Stop(); | 3642 Stop(); |
3574 | 3643 |
3575 sender_transport.StopSending(); | 3644 sender_transport.StopSending(); |
3576 | 3645 |
3577 DestroyStreams(); | 3646 DestroyStreams(); |
3578 } | 3647 } |
3579 | 3648 |
(...skipping 273 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3853 std::unique_ptr<VideoEncoder> encoder_; | 3922 std::unique_ptr<VideoEncoder> encoder_; |
3854 std::unique_ptr<VideoDecoder> decoder_; | 3923 std::unique_ptr<VideoDecoder> decoder_; |
3855 rtc::CriticalSection crit_; | 3924 rtc::CriticalSection crit_; |
3856 int recorded_frames_ GUARDED_BY(crit_); | 3925 int recorded_frames_ GUARDED_BY(crit_); |
3857 } test(this); | 3926 } test(this); |
3858 | 3927 |
3859 RunBaseTest(&test); | 3928 RunBaseTest(&test); |
3860 } | 3929 } |
3861 | 3930 |
3862 } // namespace webrtc | 3931 } // namespace webrtc |
OLD | NEW |