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