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> // max | 10 #include <algorithm> // max |
(...skipping 18 matching lines...) Expand all Loading... |
29 #include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h" | 29 #include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h" |
30 #include "webrtc/system_wrappers/include/sleep.h" | 30 #include "webrtc/system_wrappers/include/sleep.h" |
31 #include "webrtc/test/call_test.h" | 31 #include "webrtc/test/call_test.h" |
32 #include "webrtc/test/configurable_frame_size_encoder.h" | 32 #include "webrtc/test/configurable_frame_size_encoder.h" |
33 #include "webrtc/test/fake_texture_frame.h" | 33 #include "webrtc/test/fake_texture_frame.h" |
34 #include "webrtc/test/frame_generator.h" | 34 #include "webrtc/test/frame_generator.h" |
35 #include "webrtc/test/frame_utils.h" | 35 #include "webrtc/test/frame_utils.h" |
36 #include "webrtc/test/gtest.h" | 36 #include "webrtc/test/gtest.h" |
37 #include "webrtc/test/null_transport.h" | 37 #include "webrtc/test/null_transport.h" |
38 #include "webrtc/test/testsupport/perf_test.h" | 38 #include "webrtc/test/testsupport/perf_test.h" |
| 39 |
39 #include "webrtc/video/send_statistics_proxy.h" | 40 #include "webrtc/video/send_statistics_proxy.h" |
40 #include "webrtc/video_frame.h" | 41 #include "webrtc/video_frame.h" |
41 #include "webrtc/video_send_stream.h" | 42 #include "webrtc/video_send_stream.h" |
42 | 43 |
43 namespace webrtc { | 44 namespace webrtc { |
44 | 45 |
45 enum VideoFormat { kGeneric, kVP8, }; | 46 enum VideoFormat { kGeneric, kVP8, }; |
46 | 47 |
47 void ExpectEqualFramesVector(const std::vector<VideoFrame>& frames1, | 48 void ExpectEqualFramesVector(const std::vector<VideoFrame>& frames1, |
48 const std::vector<VideoFrame>& frames2); | 49 const std::vector<VideoFrame>& frames2); |
(...skipping 851 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
900 void OnVideoStreamsCreated( | 901 void OnVideoStreamsCreated( |
901 VideoSendStream* send_stream, | 902 VideoSendStream* send_stream, |
902 const std::vector<VideoReceiveStream*>& receive_streams) override { | 903 const std::vector<VideoReceiveStream*>& receive_streams) override { |
903 stream_ = send_stream; | 904 stream_ = send_stream; |
904 } | 905 } |
905 | 906 |
906 void ModifyVideoConfigs( | 907 void ModifyVideoConfigs( |
907 VideoSendStream::Config* send_config, | 908 VideoSendStream::Config* send_config, |
908 std::vector<VideoReceiveStream::Config>* receive_configs, | 909 std::vector<VideoReceiveStream::Config>* receive_configs, |
909 VideoEncoderConfig* encoder_config) override { | 910 VideoEncoderConfig* encoder_config) override { |
| 911 RTC_DCHECK_EQ(1u, encoder_config->number_of_streams); |
910 transport_adapter_.reset( | 912 transport_adapter_.reset( |
911 new internal::TransportAdapter(send_config->send_transport)); | 913 new internal::TransportAdapter(send_config->send_transport)); |
912 transport_adapter_->Enable(); | 914 transport_adapter_->Enable(); |
913 send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs; | 915 send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs; |
914 send_config->pre_encode_callback = this; | 916 send_config->pre_encode_callback = this; |
915 send_config->suspend_below_min_bitrate = true; | 917 send_config->suspend_below_min_bitrate = true; |
916 int min_bitrate_bps = encoder_config->streams[0].min_bitrate_bps; | 918 int min_bitrate_bps = |
| 919 test::DefaultVideoStreamFactory::kDefaultMinBitratePerStream[0]; |
917 set_low_remb_bps(min_bitrate_bps - 10000); | 920 set_low_remb_bps(min_bitrate_bps - 10000); |
918 int threshold_window = std::max(min_bitrate_bps / 10, 20000); | 921 int threshold_window = std::max(min_bitrate_bps / 10, 20000); |
919 ASSERT_GT(encoder_config->streams[0].max_bitrate_bps, | 922 ASSERT_GT(encoder_config->max_bitrate_bps, |
920 min_bitrate_bps + threshold_window + 5000); | 923 min_bitrate_bps + threshold_window + 5000); |
921 set_high_remb_bps(min_bitrate_bps + threshold_window + 5000); | 924 set_high_remb_bps(min_bitrate_bps + threshold_window + 5000); |
922 } | 925 } |
923 | 926 |
924 void PerformTest() override { | 927 void PerformTest() override { |
925 EXPECT_TRUE(Wait()) << "Timed out during suspend-below-min-bitrate test."; | 928 EXPECT_TRUE(Wait()) << "Timed out during suspend-below-min-bitrate test."; |
926 } | 929 } |
927 | 930 |
928 enum TestState { | 931 enum TestState { |
929 kBeforeSuspend, | 932 kBeforeSuspend, |
(...skipping 292 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1222 void OnVideoStreamsCreated( | 1225 void OnVideoStreamsCreated( |
1223 VideoSendStream* send_stream, | 1226 VideoSendStream* send_stream, |
1224 const std::vector<VideoReceiveStream*>& receive_streams) override { | 1227 const std::vector<VideoReceiveStream*>& receive_streams) override { |
1225 send_stream_ = send_stream; | 1228 send_stream_ = send_stream; |
1226 } | 1229 } |
1227 | 1230 |
1228 void ModifyVideoConfigs( | 1231 void ModifyVideoConfigs( |
1229 VideoSendStream::Config* send_config, | 1232 VideoSendStream::Config* send_config, |
1230 std::vector<VideoReceiveStream::Config>* receive_configs, | 1233 std::vector<VideoReceiveStream::Config>* receive_configs, |
1231 VideoEncoderConfig* encoder_config) override { | 1234 VideoEncoderConfig* encoder_config) override { |
1232 RTC_DCHECK_EQ(1u, encoder_config->streams.size()); | 1235 RTC_DCHECK_EQ(1u, encoder_config->number_of_streams); |
1233 if (running_without_padding_) { | 1236 if (running_without_padding_) { |
1234 encoder_config->min_transmit_bitrate_bps = 0; | 1237 encoder_config->min_transmit_bitrate_bps = 0; |
1235 encoder_config->content_type = | 1238 encoder_config->content_type = |
1236 VideoEncoderConfig::ContentType::kRealtimeVideo; | 1239 VideoEncoderConfig::ContentType::kRealtimeVideo; |
1237 } else { | 1240 } else { |
1238 encoder_config->min_transmit_bitrate_bps = kMinTransmitBitrateBps; | 1241 encoder_config->min_transmit_bitrate_bps = kMinTransmitBitrateBps; |
1239 encoder_config->content_type = VideoEncoderConfig::ContentType::kScreen; | 1242 encoder_config->content_type = VideoEncoderConfig::ContentType::kScreen; |
1240 } | 1243 } |
1241 encoder_config_ = encoder_config->Copy(); | 1244 encoder_config_ = encoder_config->Copy(); |
1242 } | 1245 } |
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1290 TEST_F(VideoSendStreamTest, RespectsMinTransmitBitrate) { | 1293 TEST_F(VideoSendStreamTest, RespectsMinTransmitBitrate) { |
1291 MaxPaddingSetTest test(false); | 1294 MaxPaddingSetTest test(false); |
1292 RunBaseTest(&test); | 1295 RunBaseTest(&test); |
1293 } | 1296 } |
1294 | 1297 |
1295 TEST_F(VideoSendStreamTest, RespectsMinTransmitBitrateAfterContentSwitch) { | 1298 TEST_F(VideoSendStreamTest, RespectsMinTransmitBitrateAfterContentSwitch) { |
1296 MaxPaddingSetTest test(true); | 1299 MaxPaddingSetTest test(true); |
1297 RunBaseTest(&test); | 1300 RunBaseTest(&test); |
1298 } | 1301 } |
1299 | 1302 |
| 1303 // This test verifies that new frame sizes reconfigures encoders even though not |
| 1304 // (yet) sending. The purpose of this is to permit encoding as quickly as |
| 1305 // possible once we start sending. Likely the frames being input are from the |
| 1306 // same source that will be sent later, which just means that we're ready |
| 1307 // earlier. |
| 1308 TEST_F(VideoSendStreamTest, |
| 1309 EncoderReconfigureOnResolutionChangeWhenNotSending) { |
| 1310 class EncoderObserver : public test::FakeEncoder { |
| 1311 public: |
| 1312 EncoderObserver() |
| 1313 : FakeEncoder(Clock::GetRealTimeClock()), |
| 1314 init_encode_called_(false, false), |
| 1315 number_of_initializations_(0), |
| 1316 last_initialized_frame_width_(0), |
| 1317 last_initialized_frame_height_(0) {} |
| 1318 |
| 1319 void WaitForResolution(int width, int height) { |
| 1320 { |
| 1321 rtc::CritScope lock(&crit_); |
| 1322 if (last_initialized_frame_width_ == width && |
| 1323 last_initialized_frame_height_ == height) { |
| 1324 return; |
| 1325 } |
| 1326 } |
| 1327 init_encode_called_.Wait(VideoSendStreamTest::kDefaultTimeoutMs); |
| 1328 { |
| 1329 rtc::CritScope lock(&crit_); |
| 1330 EXPECT_EQ(width, last_initialized_frame_width_); |
| 1331 EXPECT_EQ(height, last_initialized_frame_height_); |
| 1332 } |
| 1333 } |
| 1334 |
| 1335 private: |
| 1336 int32_t InitEncode(const VideoCodec* config, |
| 1337 int32_t number_of_cores, |
| 1338 size_t max_payload_size) override { |
| 1339 rtc::CritScope lock(&crit_); |
| 1340 last_initialized_frame_width_ = config->width; |
| 1341 last_initialized_frame_height_ = config->height; |
| 1342 ++number_of_initializations_; |
| 1343 // First time InitEncode is called, the frame size is unknown. |
| 1344 if (number_of_initializations_ > 1) |
| 1345 init_encode_called_.Set(); |
| 1346 return FakeEncoder::InitEncode(config, number_of_cores, max_payload_size); |
| 1347 } |
| 1348 |
| 1349 int32_t Encode(const VideoFrame& input_image, |
| 1350 const CodecSpecificInfo* codec_specific_info, |
| 1351 const std::vector<FrameType>* frame_types) override { |
| 1352 ADD_FAILURE() |
| 1353 << "Unexpected Encode call since the send stream is not started"; |
| 1354 return 0; |
| 1355 } |
| 1356 |
| 1357 rtc::CriticalSection crit_; |
| 1358 rtc::Event init_encode_called_; |
| 1359 size_t number_of_initializations_ GUARDED_BY(&crit_); |
| 1360 int last_initialized_frame_width_ GUARDED_BY(&crit_); |
| 1361 int last_initialized_frame_height_ GUARDED_BY(&crit_); |
| 1362 }; |
| 1363 |
| 1364 CreateSenderCall(Call::Config()); |
| 1365 test::NullTransport transport; |
| 1366 CreateSendConfig(1, 0, &transport); |
| 1367 EncoderObserver encoder; |
| 1368 video_send_config_.encoder_settings.encoder = &encoder; |
| 1369 CreateVideoStreams(); |
| 1370 CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth, |
| 1371 kDefaultHeight); |
| 1372 frame_generator_capturer_->Start(); |
| 1373 |
| 1374 encoder.WaitForResolution(kDefaultWidth, kDefaultHeight); |
| 1375 frame_generator_capturer_->ChangeResolution(kDefaultWidth * 2, |
| 1376 kDefaultHeight * 2); |
| 1377 encoder.WaitForResolution(kDefaultWidth * 2, kDefaultHeight * 2); |
| 1378 DestroyStreams(); |
| 1379 } |
| 1380 |
1300 TEST_F(VideoSendStreamTest, CanReconfigureToUseStartBitrateAbovePreviousMax) { | 1381 TEST_F(VideoSendStreamTest, CanReconfigureToUseStartBitrateAbovePreviousMax) { |
1301 class StartBitrateObserver : public test::FakeEncoder { | 1382 class StartBitrateObserver : public test::FakeEncoder { |
1302 public: | 1383 public: |
1303 StartBitrateObserver() | 1384 StartBitrateObserver() |
1304 : FakeEncoder(Clock::GetRealTimeClock()), | 1385 : FakeEncoder(Clock::GetRealTimeClock()), |
1305 start_bitrate_changed_(false, false), | 1386 start_bitrate_changed_(false, false), |
1306 start_bitrate_kbps_(0) {} | 1387 start_bitrate_kbps_(0) {} |
1307 int32_t InitEncode(const VideoCodec* config, | 1388 int32_t InitEncode(const VideoCodec* config, |
1308 int32_t number_of_cores, | 1389 int32_t number_of_cores, |
1309 size_t max_payload_size) override { | 1390 size_t max_payload_size) override { |
(...skipping 25 matching lines...) Expand all Loading... |
1335 rtc::Event start_bitrate_changed_; | 1416 rtc::Event start_bitrate_changed_; |
1336 int start_bitrate_kbps_ GUARDED_BY(crit_); | 1417 int start_bitrate_kbps_ GUARDED_BY(crit_); |
1337 }; | 1418 }; |
1338 | 1419 |
1339 CreateSenderCall(Call::Config()); | 1420 CreateSenderCall(Call::Config()); |
1340 | 1421 |
1341 test::NullTransport transport; | 1422 test::NullTransport transport; |
1342 CreateSendConfig(1, 0, &transport); | 1423 CreateSendConfig(1, 0, &transport); |
1343 | 1424 |
1344 Call::Config::BitrateConfig bitrate_config; | 1425 Call::Config::BitrateConfig bitrate_config; |
1345 bitrate_config.start_bitrate_bps = | 1426 bitrate_config.start_bitrate_bps = 2 * video_encoder_config_.max_bitrate_bps; |
1346 2 * video_encoder_config_.streams[0].max_bitrate_bps; | |
1347 sender_call_->SetBitrateConfig(bitrate_config); | 1427 sender_call_->SetBitrateConfig(bitrate_config); |
1348 | 1428 |
1349 StartBitrateObserver encoder; | 1429 StartBitrateObserver encoder; |
1350 video_send_config_.encoder_settings.encoder = &encoder; | 1430 video_send_config_.encoder_settings.encoder = &encoder; |
| 1431 // Since this test does not use a capturer, set |internal_source| = true. |
| 1432 // Encoder configuration is otherwise updated on the next video frame. |
| 1433 video_send_config_.encoder_settings.internal_source = true; |
1351 | 1434 |
1352 CreateVideoStreams(); | 1435 CreateVideoStreams(); |
1353 | 1436 |
1354 EXPECT_TRUE(encoder.WaitForStartBitrate()); | 1437 EXPECT_TRUE(encoder.WaitForStartBitrate()); |
1355 EXPECT_EQ(video_encoder_config_.streams[0].max_bitrate_bps / 1000, | 1438 EXPECT_EQ(video_encoder_config_.max_bitrate_bps / 1000, |
1356 encoder.GetStartBitrateKbps()); | 1439 encoder.GetStartBitrateKbps()); |
1357 | 1440 |
1358 video_encoder_config_.streams[0].max_bitrate_bps = | 1441 video_encoder_config_.max_bitrate_bps = 2 * bitrate_config.start_bitrate_bps; |
1359 2 * bitrate_config.start_bitrate_bps; | |
1360 video_send_stream_->ReconfigureVideoEncoder(video_encoder_config_.Copy()); | 1442 video_send_stream_->ReconfigureVideoEncoder(video_encoder_config_.Copy()); |
1361 | 1443 |
1362 // New bitrate should be reconfigured above the previous max. As there's no | 1444 // New bitrate should be reconfigured above the previous max. As there's no |
1363 // network connection this shouldn't be flaky, as no bitrate should've been | 1445 // network connection this shouldn't be flaky, as no bitrate should've been |
1364 // reported in between. | 1446 // reported in between. |
1365 EXPECT_TRUE(encoder.WaitForStartBitrate()); | 1447 EXPECT_TRUE(encoder.WaitForStartBitrate()); |
1366 EXPECT_EQ(bitrate_config.start_bitrate_bps / 1000, | 1448 EXPECT_EQ(bitrate_config.start_bitrate_bps / 1000, |
1367 encoder.GetStartBitrateKbps()); | 1449 encoder.GetStartBitrateKbps()); |
1368 | 1450 |
1369 DestroyStreams(); | 1451 DestroyStreams(); |
(...skipping 105 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1475 | 1557 |
1476 test::NullTransport transport; | 1558 test::NullTransport transport; |
1477 CreateSendConfig(1, 0, &transport); | 1559 CreateSendConfig(1, 0, &transport); |
1478 FrameObserver observer; | 1560 FrameObserver observer; |
1479 video_send_config_.pre_encode_callback = &observer; | 1561 video_send_config_.pre_encode_callback = &observer; |
1480 CreateVideoStreams(); | 1562 CreateVideoStreams(); |
1481 | 1563 |
1482 // Prepare five input frames. Send ordinary VideoFrame and texture frames | 1564 // Prepare five input frames. Send ordinary VideoFrame and texture frames |
1483 // alternatively. | 1565 // alternatively. |
1484 std::vector<VideoFrame> input_frames; | 1566 std::vector<VideoFrame> input_frames; |
1485 int width = static_cast<int>(video_encoder_config_.streams[0].width); | 1567 int width = 168; |
1486 int height = static_cast<int>(video_encoder_config_.streams[0].height); | 1568 int height = 132; |
| 1569 |
1487 test::FakeNativeHandle* handle1 = new test::FakeNativeHandle(); | 1570 test::FakeNativeHandle* handle1 = new test::FakeNativeHandle(); |
1488 test::FakeNativeHandle* handle2 = new test::FakeNativeHandle(); | 1571 test::FakeNativeHandle* handle2 = new test::FakeNativeHandle(); |
1489 test::FakeNativeHandle* handle3 = new test::FakeNativeHandle(); | 1572 test::FakeNativeHandle* handle3 = new test::FakeNativeHandle(); |
1490 input_frames.push_back(test::FakeNativeHandle::CreateFrame( | 1573 input_frames.push_back(test::FakeNativeHandle::CreateFrame( |
1491 handle1, width, height, 1, 1, kVideoRotation_0)); | 1574 handle1, width, height, 1, 1, kVideoRotation_0)); |
1492 input_frames.push_back(test::FakeNativeHandle::CreateFrame( | 1575 input_frames.push_back(test::FakeNativeHandle::CreateFrame( |
1493 handle2, width, height, 2, 2, kVideoRotation_0)); | 1576 handle2, width, height, 2, 2, kVideoRotation_0)); |
1494 input_frames.push_back(CreateVideoFrame(width, height, 3)); | 1577 input_frames.push_back(CreateVideoFrame(width, height, 3)); |
1495 input_frames.push_back(CreateVideoFrame(width, height, 4)); | 1578 input_frames.push_back(CreateVideoFrame(width, height, 4)); |
1496 input_frames.push_back(test::FakeNativeHandle::CreateFrame( | 1579 input_frames.push_back(test::FakeNativeHandle::CreateFrame( |
1497 handle3, width, height, 5, 5, kVideoRotation_0)); | 1580 handle3, width, height, 5, 5, kVideoRotation_0)); |
1498 | 1581 |
1499 video_send_stream_->Start(); | 1582 video_send_stream_->Start(); |
1500 test::FrameForwarder forwarder; | 1583 test::FrameForwarder forwarder; |
1501 video_send_stream_->SetSource(&forwarder); | 1584 video_send_stream_->SetSource(&forwarder); |
1502 for (size_t i = 0; i < input_frames.size(); i++) { | 1585 for (size_t i = 0; i < input_frames.size(); i++) { |
1503 forwarder.IncomingCapturedFrame(input_frames[i]); | 1586 forwarder.IncomingCapturedFrame(input_frames[i]); |
1504 // Do not send the next frame too fast, so the frame dropper won't drop it. | |
1505 if (i < input_frames.size() - 1) | |
1506 SleepMs(1000 / video_encoder_config_.streams[0].max_framerate); | |
1507 // Wait until the output frame is received before sending the next input | 1587 // Wait until the output frame is received before sending the next input |
1508 // frame. Or the previous input frame may be replaced without delivering. | 1588 // frame. Or the previous input frame may be replaced without delivering. |
1509 observer.WaitOutputFrame(); | 1589 observer.WaitOutputFrame(); |
1510 } | 1590 } |
1511 video_send_stream_->Stop(); | 1591 video_send_stream_->Stop(); |
1512 video_send_stream_->SetSource(nullptr); | 1592 video_send_stream_->SetSource(nullptr); |
1513 | 1593 |
1514 // Test if the input and output frames are the same. render_time_ms and | 1594 // Test if the input and output frames are the same. render_time_ms and |
1515 // timestamp are not compared because capturer sets those values. | 1595 // timestamp are not compared because capturer sets those values. |
1516 ExpectEqualFramesVector(input_frames, observer.output_frames()); | 1596 ExpectEqualFramesVector(input_frames, observer.output_frames()); |
(...skipping 106 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1623 void ModifyVideoConfigs( | 1703 void ModifyVideoConfigs( |
1624 VideoSendStream::Config* send_config, | 1704 VideoSendStream::Config* send_config, |
1625 std::vector<VideoReceiveStream::Config>* receive_configs, | 1705 std::vector<VideoReceiveStream::Config>* receive_configs, |
1626 VideoEncoderConfig* encoder_config) override { | 1706 VideoEncoderConfig* encoder_config) override { |
1627 send_config->encoder_settings.encoder = this; | 1707 send_config->encoder_settings.encoder = this; |
1628 encoder_config_ = encoder_config->Copy(); | 1708 encoder_config_ = encoder_config->Copy(); |
1629 } | 1709 } |
1630 | 1710 |
1631 void PerformTest() override { | 1711 void PerformTest() override { |
1632 EXPECT_TRUE(Wait()) << "Timed out while waiting for Encode."; | 1712 EXPECT_TRUE(Wait()) << "Timed out while waiting for Encode."; |
1633 EXPECT_EQ(0u, num_releases()); | 1713 // Expect |num_releases| == 1 since the encoder has been reconfigured |
| 1714 // once when the first frame is encoded. Not until at that point is the |
| 1715 // frame size known and the encoder can be properly initialized. |
| 1716 EXPECT_EQ(1u, num_releases()); |
1634 stream_->ReconfigureVideoEncoder(std::move(encoder_config_)); | 1717 stream_->ReconfigureVideoEncoder(std::move(encoder_config_)); |
1635 EXPECT_EQ(0u, num_releases()); | 1718 EXPECT_EQ(1u, num_releases()); |
1636 stream_->Stop(); | 1719 stream_->Stop(); |
1637 // Encoder should not be released before destroying the VideoSendStream. | 1720 // Encoder should not be released before destroying the VideoSendStream. |
1638 EXPECT_FALSE(IsReleased()); | 1721 EXPECT_FALSE(IsReleased()); |
1639 EXPECT_TRUE(IsReadyForEncode()); | 1722 EXPECT_TRUE(IsReadyForEncode()); |
1640 stream_->Start(); | 1723 stream_->Start(); |
1641 // Sanity check, make sure we still encode frames with this encoder. | 1724 // Sanity check, make sure we still encode frames with this encoder. |
1642 EXPECT_TRUE(Wait()) << "Timed out while waiting for Encode."; | 1725 EXPECT_TRUE(Wait()) << "Timed out while waiting for Encode."; |
1643 } | 1726 } |
1644 | 1727 |
1645 rtc::CriticalSection crit_; | 1728 rtc::CriticalSection crit_; |
1646 VideoSendStream* stream_; | 1729 VideoSendStream* stream_; |
1647 bool initialized_ GUARDED_BY(crit_); | 1730 bool initialized_ GUARDED_BY(crit_); |
1648 bool callback_registered_ GUARDED_BY(crit_); | 1731 bool callback_registered_ GUARDED_BY(crit_); |
1649 size_t num_releases_ GUARDED_BY(crit_); | 1732 size_t num_releases_ GUARDED_BY(crit_); |
1650 bool released_ GUARDED_BY(crit_); | 1733 bool released_ GUARDED_BY(crit_); |
1651 VideoEncoderConfig encoder_config_; | 1734 VideoEncoderConfig encoder_config_; |
1652 } test_encoder; | 1735 } test_encoder; |
1653 | 1736 |
1654 RunBaseTest(&test_encoder); | 1737 RunBaseTest(&test_encoder); |
1655 | 1738 |
1656 EXPECT_TRUE(test_encoder.IsReleased()); | 1739 EXPECT_TRUE(test_encoder.IsReleased()); |
1657 EXPECT_EQ(1u, test_encoder.num_releases()); | 1740 EXPECT_EQ(2u, test_encoder.num_releases()); |
1658 } | 1741 } |
1659 | 1742 |
1660 TEST_F(VideoSendStreamTest, EncoderSetupPropagatesCommonEncoderConfigValues) { | 1743 TEST_F(VideoSendStreamTest, EncoderSetupPropagatesCommonEncoderConfigValues) { |
1661 class VideoCodecConfigObserver : public test::SendTest, | 1744 class VideoCodecConfigObserver : public test::SendTest, |
1662 public test::FakeEncoder { | 1745 public test::FakeEncoder { |
1663 public: | 1746 public: |
1664 VideoCodecConfigObserver() | 1747 VideoCodecConfigObserver() |
1665 : SendTest(kDefaultTimeoutMs), | 1748 : SendTest(kDefaultTimeoutMs), |
1666 FakeEncoder(Clock::GetRealTimeClock()), | 1749 FakeEncoder(Clock::GetRealTimeClock()), |
1667 init_encode_event_(false, false), | 1750 init_encode_event_(false, false), |
(...skipping 62 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1730 FakeEncoder(Clock::GetRealTimeClock()), | 1813 FakeEncoder(Clock::GetRealTimeClock()), |
1731 video_codec_type_(video_codec_type), | 1814 video_codec_type_(video_codec_type), |
1732 codec_name_(codec_name), | 1815 codec_name_(codec_name), |
1733 init_encode_event_(false, false), | 1816 init_encode_event_(false, false), |
1734 num_initializations_(0), | 1817 num_initializations_(0), |
1735 stream_(nullptr) { | 1818 stream_(nullptr) { |
1736 memset(&encoder_settings_, 0, sizeof(encoder_settings_)); | 1819 memset(&encoder_settings_, 0, sizeof(encoder_settings_)); |
1737 } | 1820 } |
1738 | 1821 |
1739 private: | 1822 private: |
| 1823 class VideoStreamFactory |
| 1824 : public VideoEncoderConfig::VideoStreamFactoryInterface { |
| 1825 public: |
| 1826 VideoStreamFactory() {} |
| 1827 |
| 1828 private: |
| 1829 std::vector<VideoStream> CreateEncoderStreams( |
| 1830 int width, |
| 1831 int height, |
| 1832 const VideoEncoderConfig& encoder_config) override { |
| 1833 std::vector<VideoStream> streams = |
| 1834 test::CreateVideoStreams(width, height, encoder_config); |
| 1835 for (size_t i = 0; i < streams.size(); ++i) { |
| 1836 streams[i].temporal_layer_thresholds_bps.resize( |
| 1837 kVideoCodecConfigObserverNumberOfTemporalLayers - 1); |
| 1838 } |
| 1839 return streams; |
| 1840 } |
| 1841 }; |
| 1842 |
1740 void ModifyVideoConfigs( | 1843 void ModifyVideoConfigs( |
1741 VideoSendStream::Config* send_config, | 1844 VideoSendStream::Config* send_config, |
1742 std::vector<VideoReceiveStream::Config>* receive_configs, | 1845 std::vector<VideoReceiveStream::Config>* receive_configs, |
1743 VideoEncoderConfig* encoder_config) override { | 1846 VideoEncoderConfig* encoder_config) override { |
1744 send_config->encoder_settings.encoder = this; | 1847 send_config->encoder_settings.encoder = this; |
1745 send_config->encoder_settings.payload_name = codec_name_; | 1848 send_config->encoder_settings.payload_name = codec_name_; |
1746 | 1849 |
1747 for (size_t i = 0; i < encoder_config->streams.size(); ++i) { | |
1748 encoder_config->streams[i].temporal_layer_thresholds_bps.resize( | |
1749 kVideoCodecConfigObserverNumberOfTemporalLayers - 1); | |
1750 } | |
1751 | |
1752 encoder_config->encoder_specific_settings = GetEncoderSpecificSettings(); | 1850 encoder_config->encoder_specific_settings = GetEncoderSpecificSettings(); |
| 1851 encoder_config->video_stream_factory = |
| 1852 new rtc::RefCountedObject<VideoStreamFactory>(); |
1753 encoder_config_ = encoder_config->Copy(); | 1853 encoder_config_ = encoder_config->Copy(); |
1754 } | 1854 } |
1755 | 1855 |
1756 void OnVideoStreamsCreated( | 1856 void OnVideoStreamsCreated( |
1757 VideoSendStream* send_stream, | 1857 VideoSendStream* send_stream, |
1758 const std::vector<VideoReceiveStream*>& receive_streams) override { | 1858 const std::vector<VideoReceiveStream*>& receive_streams) override { |
1759 stream_ = send_stream; | 1859 stream_ = send_stream; |
1760 } | 1860 } |
1761 | 1861 |
1762 int32_t InitEncode(const VideoCodec* config, | 1862 int32_t InitEncode(const VideoCodec* config, |
(...skipping 175 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1938 rtc::CriticalSection crit_; | 2038 rtc::CriticalSection crit_; |
1939 size_t rtp_packets_sent_ GUARDED_BY(&crit_); | 2039 size_t rtp_packets_sent_ GUARDED_BY(&crit_); |
1940 size_t media_bytes_sent_ GUARDED_BY(&crit_); | 2040 size_t media_bytes_sent_ GUARDED_BY(&crit_); |
1941 } test; | 2041 } test; |
1942 | 2042 |
1943 RunBaseTest(&test); | 2043 RunBaseTest(&test); |
1944 } | 2044 } |
1945 | 2045 |
1946 TEST_F(VideoSendStreamTest, TranslatesTwoLayerScreencastToTargetBitrate) { | 2046 TEST_F(VideoSendStreamTest, TranslatesTwoLayerScreencastToTargetBitrate) { |
1947 static const int kScreencastTargetBitrateKbps = 200; | 2047 static const int kScreencastTargetBitrateKbps = 200; |
| 2048 |
| 2049 class VideoStreamFactory |
| 2050 : public VideoEncoderConfig::VideoStreamFactoryInterface { |
| 2051 public: |
| 2052 VideoStreamFactory() {} |
| 2053 |
| 2054 private: |
| 2055 std::vector<VideoStream> CreateEncoderStreams( |
| 2056 int width, |
| 2057 int height, |
| 2058 const VideoEncoderConfig& encoder_config) override { |
| 2059 std::vector<VideoStream> streams = |
| 2060 test::CreateVideoStreams(width, height, encoder_config); |
| 2061 EXPECT_TRUE(streams[0].temporal_layer_thresholds_bps.empty()); |
| 2062 streams[0].temporal_layer_thresholds_bps.push_back( |
| 2063 kScreencastTargetBitrateKbps * 1000); |
| 2064 return streams; |
| 2065 } |
| 2066 }; |
| 2067 |
1948 class ScreencastTargetBitrateTest : public test::SendTest, | 2068 class ScreencastTargetBitrateTest : public test::SendTest, |
1949 public test::FakeEncoder { | 2069 public test::FakeEncoder { |
1950 public: | 2070 public: |
1951 ScreencastTargetBitrateTest() | 2071 ScreencastTargetBitrateTest() |
1952 : SendTest(kDefaultTimeoutMs), | 2072 : SendTest(kDefaultTimeoutMs), |
1953 test::FakeEncoder(Clock::GetRealTimeClock()) {} | 2073 test::FakeEncoder(Clock::GetRealTimeClock()) {} |
1954 | 2074 |
1955 private: | 2075 private: |
1956 int32_t InitEncode(const VideoCodec* config, | 2076 int32_t InitEncode(const VideoCodec* config, |
1957 int32_t number_of_cores, | 2077 int32_t number_of_cores, |
1958 size_t max_payload_size) override { | 2078 size_t max_payload_size) override { |
1959 EXPECT_EQ(static_cast<unsigned int>(kScreencastTargetBitrateKbps), | 2079 EXPECT_EQ(static_cast<unsigned int>(kScreencastTargetBitrateKbps), |
1960 config->targetBitrate); | 2080 config->targetBitrate); |
1961 observation_complete_.Set(); | 2081 observation_complete_.Set(); |
1962 return test::FakeEncoder::InitEncode( | 2082 return test::FakeEncoder::InitEncode( |
1963 config, number_of_cores, max_payload_size); | 2083 config, number_of_cores, max_payload_size); |
1964 } | 2084 } |
1965 void ModifyVideoConfigs( | 2085 void ModifyVideoConfigs( |
1966 VideoSendStream::Config* send_config, | 2086 VideoSendStream::Config* send_config, |
1967 std::vector<VideoReceiveStream::Config>* receive_configs, | 2087 std::vector<VideoReceiveStream::Config>* receive_configs, |
1968 VideoEncoderConfig* encoder_config) override { | 2088 VideoEncoderConfig* encoder_config) override { |
1969 send_config->encoder_settings.encoder = this; | 2089 send_config->encoder_settings.encoder = this; |
1970 EXPECT_EQ(1u, encoder_config->streams.size()); | 2090 EXPECT_EQ(1u, encoder_config->number_of_streams); |
1971 EXPECT_TRUE( | 2091 encoder_config->video_stream_factory = |
1972 encoder_config->streams[0].temporal_layer_thresholds_bps.empty()); | 2092 new rtc::RefCountedObject<VideoStreamFactory>(); |
1973 encoder_config->streams[0].temporal_layer_thresholds_bps.push_back( | |
1974 kScreencastTargetBitrateKbps * 1000); | |
1975 encoder_config->content_type = VideoEncoderConfig::ContentType::kScreen; | 2093 encoder_config->content_type = VideoEncoderConfig::ContentType::kScreen; |
1976 } | 2094 } |
1977 | 2095 |
1978 void PerformTest() override { | 2096 void PerformTest() override { |
1979 EXPECT_TRUE(Wait()) | 2097 EXPECT_TRUE(Wait()) |
1980 << "Timed out while waiting for the encoder to be initialized."; | 2098 << "Timed out while waiting for the encoder to be initialized."; |
1981 } | 2099 } |
1982 } test; | 2100 } test; |
1983 | 2101 |
1984 RunBaseTest(&test); | 2102 RunBaseTest(&test); |
(...skipping 20 matching lines...) Expand all Loading... |
2005 num_initializations_(0), | 2123 num_initializations_(0), |
2006 call_(nullptr), | 2124 call_(nullptr), |
2007 send_stream_(nullptr) {} | 2125 send_stream_(nullptr) {} |
2008 | 2126 |
2009 private: | 2127 private: |
2010 int32_t InitEncode(const VideoCodec* codecSettings, | 2128 int32_t InitEncode(const VideoCodec* codecSettings, |
2011 int32_t numberOfCores, | 2129 int32_t numberOfCores, |
2012 size_t maxPayloadSize) override { | 2130 size_t maxPayloadSize) override { |
2013 EXPECT_GE(codecSettings->startBitrate, codecSettings->minBitrate); | 2131 EXPECT_GE(codecSettings->startBitrate, codecSettings->minBitrate); |
2014 EXPECT_LE(codecSettings->startBitrate, codecSettings->maxBitrate); | 2132 EXPECT_LE(codecSettings->startBitrate, codecSettings->maxBitrate); |
2015 if (num_initializations_ == 0) { | 2133 // First reinitialization happens due to that the frame size is updated. |
| 2134 if (num_initializations_ == 0 || num_initializations_ == 1) { |
2016 EXPECT_EQ(static_cast<unsigned int>(kMinBitrateKbps), | 2135 EXPECT_EQ(static_cast<unsigned int>(kMinBitrateKbps), |
2017 codecSettings->minBitrate); | 2136 codecSettings->minBitrate); |
2018 EXPECT_EQ(static_cast<unsigned int>(kStartBitrateKbps), | 2137 EXPECT_EQ(static_cast<unsigned int>(kStartBitrateKbps), |
2019 codecSettings->startBitrate); | 2138 codecSettings->startBitrate); |
2020 EXPECT_EQ(static_cast<unsigned int>(kMaxBitrateKbps), | 2139 EXPECT_EQ(static_cast<unsigned int>(kMaxBitrateKbps), |
2021 codecSettings->maxBitrate); | 2140 codecSettings->maxBitrate); |
2022 observation_complete_.Set(); | 2141 observation_complete_.Set(); |
2023 } else if (num_initializations_ == 1) { | 2142 } else if (num_initializations_ == 2) { |
2024 EXPECT_EQ(static_cast<unsigned int>(kLowerMaxBitrateKbps), | 2143 EXPECT_EQ(static_cast<unsigned int>(kLowerMaxBitrateKbps), |
2025 codecSettings->maxBitrate); | 2144 codecSettings->maxBitrate); |
2026 // The start bitrate should be kept (-1) and capped to the max bitrate. | 2145 // The start bitrate should be kept (-1) and capped to the max bitrate. |
2027 // Since this is not an end-to-end call no receiver should have been | 2146 // Since this is not an end-to-end call no receiver should have been |
2028 // returning a REMB that could lower this estimate. | 2147 // returning a REMB that could lower this estimate. |
2029 EXPECT_EQ(codecSettings->startBitrate, codecSettings->maxBitrate); | 2148 EXPECT_EQ(codecSettings->startBitrate, codecSettings->maxBitrate); |
2030 } else if (num_initializations_ == 2) { | 2149 } else if (num_initializations_ == 3) { |
2031 EXPECT_EQ(static_cast<unsigned int>(kIncreasedMaxBitrateKbps), | 2150 EXPECT_EQ(static_cast<unsigned int>(kIncreasedMaxBitrateKbps), |
2032 codecSettings->maxBitrate); | 2151 codecSettings->maxBitrate); |
2033 // The start bitrate will be whatever the rate BitRateController | 2152 // The start bitrate will be whatever the rate BitRateController |
2034 // has currently configured but in the span of the set max and min | 2153 // has currently configured but in the span of the set max and min |
2035 // bitrate. | 2154 // bitrate. |
2036 } | 2155 } |
2037 ++num_initializations_; | 2156 ++num_initializations_; |
2038 init_encode_event_.Set(); | 2157 if (num_initializations_ > 1) { |
| 2158 init_encode_event_.Set(); |
| 2159 } |
2039 return FakeEncoder::InitEncode(codecSettings, numberOfCores, | 2160 return FakeEncoder::InitEncode(codecSettings, numberOfCores, |
2040 maxPayloadSize); | 2161 maxPayloadSize); |
2041 } | 2162 } |
2042 | 2163 |
2043 int32_t SetRates(uint32_t newBitRate, uint32_t frameRate) override { | 2164 int32_t SetRates(uint32_t newBitRate, uint32_t frameRate) override { |
2044 { | 2165 { |
2045 rtc::CritScope lock(&crit_); | 2166 rtc::CritScope lock(&crit_); |
| 2167 if (target_bitrate_ == newBitRate) { |
| 2168 return FakeEncoder::SetRates(newBitRate, frameRate); |
| 2169 } |
2046 target_bitrate_ = newBitRate; | 2170 target_bitrate_ = newBitRate; |
2047 } | 2171 } |
2048 bitrate_changed_event_.Set(); | 2172 bitrate_changed_event_.Set(); |
2049 return FakeEncoder::SetRates(newBitRate, frameRate); | 2173 return FakeEncoder::SetRates(newBitRate, frameRate); |
2050 } | 2174 } |
2051 | 2175 |
2052 void WaitForSetRates(uint32_t expected_bitrate) { | 2176 void WaitForSetRates(uint32_t expected_bitrate) { |
2053 EXPECT_TRUE( | 2177 EXPECT_TRUE( |
2054 bitrate_changed_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs)) | 2178 bitrate_changed_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs)) |
2055 << "Timed out while waiting encoder rate to be set."; | 2179 << "Timed out while waiting encoder rate to be set."; |
2056 rtc::CritScope lock(&crit_); | 2180 rtc::CritScope lock(&crit_); |
2057 EXPECT_EQ(expected_bitrate, target_bitrate_); | 2181 EXPECT_EQ(expected_bitrate, target_bitrate_); |
2058 } | 2182 } |
2059 | 2183 |
2060 Call::Config GetSenderCallConfig() override { | 2184 Call::Config GetSenderCallConfig() override { |
2061 Call::Config config; | 2185 Call::Config config; |
2062 config.bitrate_config.min_bitrate_bps = kMinBitrateKbps * 1000; | 2186 config.bitrate_config.min_bitrate_bps = kMinBitrateKbps * 1000; |
2063 config.bitrate_config.start_bitrate_bps = kStartBitrateKbps * 1000; | 2187 config.bitrate_config.start_bitrate_bps = kStartBitrateKbps * 1000; |
2064 config.bitrate_config.max_bitrate_bps = kMaxBitrateKbps * 1000; | 2188 config.bitrate_config.max_bitrate_bps = kMaxBitrateKbps * 1000; |
2065 return config; | 2189 return config; |
2066 } | 2190 } |
2067 | 2191 |
| 2192 class VideoStreamFactory |
| 2193 : public VideoEncoderConfig::VideoStreamFactoryInterface { |
| 2194 public: |
| 2195 explicit VideoStreamFactory(int min_bitrate_bps) |
| 2196 : min_bitrate_bps_(min_bitrate_bps) {} |
| 2197 |
| 2198 private: |
| 2199 std::vector<VideoStream> CreateEncoderStreams( |
| 2200 int width, |
| 2201 int height, |
| 2202 const VideoEncoderConfig& encoder_config) override { |
| 2203 std::vector<VideoStream> streams = |
| 2204 test::CreateVideoStreams(width, height, encoder_config); |
| 2205 streams[0].min_bitrate_bps = min_bitrate_bps_; |
| 2206 return streams; |
| 2207 } |
| 2208 |
| 2209 const int min_bitrate_bps_; |
| 2210 }; |
| 2211 |
2068 void ModifyVideoConfigs( | 2212 void ModifyVideoConfigs( |
2069 VideoSendStream::Config* send_config, | 2213 VideoSendStream::Config* send_config, |
2070 std::vector<VideoReceiveStream::Config>* receive_configs, | 2214 std::vector<VideoReceiveStream::Config>* receive_configs, |
2071 VideoEncoderConfig* encoder_config) override { | 2215 VideoEncoderConfig* encoder_config) override { |
2072 send_config->encoder_settings.encoder = this; | 2216 send_config->encoder_settings.encoder = this; |
2073 // Set bitrates lower/higher than min/max to make sure they are properly | 2217 // Set bitrates lower/higher than min/max to make sure they are properly |
2074 // capped. | 2218 // capped. |
2075 encoder_config->streams.front().min_bitrate_bps = kMinBitrateKbps * 1000; | 2219 encoder_config->max_bitrate_bps = kMaxBitrateKbps * 1000; |
2076 encoder_config->streams.front().max_bitrate_bps = kMaxBitrateKbps * 1000; | 2220 // Create a new StreamFactory to be able to set |
| 2221 // |VideoStream.min_bitrate_bps|. |
| 2222 encoder_config->video_stream_factory = |
| 2223 new rtc::RefCountedObject<VideoStreamFactory>(kMinBitrateKbps * 1000); |
2077 encoder_config_ = encoder_config->Copy(); | 2224 encoder_config_ = encoder_config->Copy(); |
2078 } | 2225 } |
2079 | 2226 |
2080 void OnCallsCreated(Call* sender_call, Call* receiver_call) override { | 2227 void OnCallsCreated(Call* sender_call, Call* receiver_call) override { |
2081 call_ = sender_call; | 2228 call_ = sender_call; |
2082 } | 2229 } |
2083 | 2230 |
2084 void OnVideoStreamsCreated( | 2231 void OnVideoStreamsCreated( |
2085 VideoSendStream* send_stream, | 2232 VideoSendStream* send_stream, |
2086 const std::vector<VideoReceiveStream*>& receive_streams) override { | 2233 const std::vector<VideoReceiveStream*>& receive_streams) override { |
2087 send_stream_ = send_stream; | 2234 send_stream_ = send_stream; |
2088 } | 2235 } |
2089 | 2236 |
2090 void PerformTest() override { | 2237 void PerformTest() override { |
2091 ASSERT_TRUE( | 2238 ASSERT_TRUE( |
2092 init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs)) | 2239 init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs)) |
2093 << "Timed out while waiting for encoder to be configured."; | 2240 << "Timed out while waiting for encoder to be configured."; |
2094 WaitForSetRates(kStartBitrateKbps); | 2241 WaitForSetRates(kStartBitrateKbps); |
2095 Call::Config::BitrateConfig bitrate_config; | 2242 Call::Config::BitrateConfig bitrate_config; |
2096 bitrate_config.start_bitrate_bps = kIncreasedStartBitrateKbps * 1000; | 2243 bitrate_config.start_bitrate_bps = kIncreasedStartBitrateKbps * 1000; |
2097 bitrate_config.max_bitrate_bps = kIncreasedMaxBitrateKbps * 1000; | 2244 bitrate_config.max_bitrate_bps = kIncreasedMaxBitrateKbps * 1000; |
2098 call_->SetBitrateConfig(bitrate_config); | 2245 call_->SetBitrateConfig(bitrate_config); |
2099 // Encoder rate is capped by EncoderConfig max_bitrate_bps. | 2246 // Encoder rate is capped by EncoderConfig max_bitrate_bps. |
2100 WaitForSetRates(kMaxBitrateKbps); | 2247 WaitForSetRates(kMaxBitrateKbps); |
2101 | 2248 encoder_config_.max_bitrate_bps = kLowerMaxBitrateKbps * 1000; |
2102 encoder_config_.streams[0].min_bitrate_bps = 0; | |
2103 encoder_config_.streams[0].max_bitrate_bps = kLowerMaxBitrateKbps * 1000; | |
2104 send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy()); | |
2105 ASSERT_TRUE( | |
2106 init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs)); | |
2107 EXPECT_EQ(2, num_initializations_) | |
2108 << "Encoder should have been reconfigured with the new value."; | |
2109 WaitForSetRates(kLowerMaxBitrateKbps); | |
2110 | |
2111 encoder_config_.streams[0].target_bitrate_bps = | |
2112 encoder_config_.streams[0].min_bitrate_bps; | |
2113 encoder_config_.streams[0].max_bitrate_bps = | |
2114 kIncreasedMaxBitrateKbps * 1000; | |
2115 send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy()); | 2249 send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy()); |
2116 ASSERT_TRUE( | 2250 ASSERT_TRUE( |
2117 init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs)); | 2251 init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs)); |
2118 EXPECT_EQ(3, num_initializations_) | 2252 EXPECT_EQ(3, num_initializations_) |
2119 << "Encoder should have been reconfigured with the new value."; | 2253 << "Encoder should have been reconfigured with the new value."; |
| 2254 WaitForSetRates(kLowerMaxBitrateKbps); |
| 2255 |
| 2256 encoder_config_.max_bitrate_bps = kIncreasedMaxBitrateKbps * 1000; |
| 2257 send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy()); |
| 2258 ASSERT_TRUE( |
| 2259 init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs)); |
| 2260 EXPECT_EQ(4, num_initializations_) |
| 2261 << "Encoder should have been reconfigured with the new value."; |
2120 // Expected target bitrate is the start bitrate set in the call to | 2262 // Expected target bitrate is the start bitrate set in the call to |
2121 // call_->SetBitrateConfig. | 2263 // call_->SetBitrateConfig. |
2122 WaitForSetRates(kIncreasedStartBitrateKbps); | 2264 WaitForSetRates(kIncreasedStartBitrateKbps); |
2123 } | 2265 } |
2124 | 2266 |
2125 rtc::Event init_encode_event_; | 2267 rtc::Event init_encode_event_; |
2126 rtc::Event bitrate_changed_event_; | 2268 rtc::Event bitrate_changed_event_; |
2127 rtc::CriticalSection crit_; | 2269 rtc::CriticalSection crit_; |
2128 uint32_t target_bitrate_ GUARDED_BY(&crit_); | 2270 uint32_t target_bitrate_ GUARDED_BY(&crit_); |
| 2271 |
2129 int num_initializations_; | 2272 int num_initializations_; |
2130 webrtc::Call* call_; | 2273 webrtc::Call* call_; |
2131 webrtc::VideoSendStream* send_stream_; | 2274 webrtc::VideoSendStream* send_stream_; |
2132 webrtc::VideoEncoderConfig encoder_config_; | 2275 webrtc::VideoEncoderConfig encoder_config_; |
2133 } test; | 2276 } test; |
2134 | 2277 |
2135 RunBaseTest(&test); | 2278 RunBaseTest(&test); |
2136 } | 2279 } |
2137 | 2280 |
2138 TEST_F(VideoSendStreamTest, ReportsSentResolution) { | 2281 TEST_F(VideoSendStreamTest, ReportsSentResolution) { |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2174 } | 2317 } |
2175 | 2318 |
2176 observation_complete_.Set(); | 2319 observation_complete_.Set(); |
2177 return 0; | 2320 return 0; |
2178 } | 2321 } |
2179 void ModifyVideoConfigs( | 2322 void ModifyVideoConfigs( |
2180 VideoSendStream::Config* send_config, | 2323 VideoSendStream::Config* send_config, |
2181 std::vector<VideoReceiveStream::Config>* receive_configs, | 2324 std::vector<VideoReceiveStream::Config>* receive_configs, |
2182 VideoEncoderConfig* encoder_config) override { | 2325 VideoEncoderConfig* encoder_config) override { |
2183 send_config->encoder_settings.encoder = this; | 2326 send_config->encoder_settings.encoder = this; |
2184 EXPECT_EQ(kNumStreams, encoder_config->streams.size()); | 2327 EXPECT_EQ(kNumStreams, encoder_config->number_of_streams); |
2185 } | 2328 } |
2186 | 2329 |
2187 size_t GetNumVideoStreams() const override { return kNumStreams; } | 2330 size_t GetNumVideoStreams() const override { return kNumStreams; } |
2188 | 2331 |
2189 void PerformTest() override { | 2332 void PerformTest() override { |
2190 EXPECT_TRUE(Wait()) | 2333 EXPECT_TRUE(Wait()) |
2191 << "Timed out while waiting for the encoder to send one frame."; | 2334 << "Timed out while waiting for the encoder to send one frame."; |
2192 VideoSendStream::Stats stats = send_stream_->GetStats(); | 2335 VideoSendStream::Stats stats = send_stream_->GetStats(); |
2193 | 2336 |
2194 for (size_t i = 0; i < kNumStreams; ++i) { | 2337 for (size_t i = 0; i < kNumStreams; ++i) { |
(...skipping 21 matching lines...) Expand all Loading... |
2216 } | 2359 } |
2217 | 2360 |
2218 #if !defined(RTC_DISABLE_VP9) | 2361 #if !defined(RTC_DISABLE_VP9) |
2219 class Vp9HeaderObserver : public test::SendTest { | 2362 class Vp9HeaderObserver : public test::SendTest { |
2220 public: | 2363 public: |
2221 Vp9HeaderObserver() | 2364 Vp9HeaderObserver() |
2222 : SendTest(VideoSendStreamTest::kLongTimeoutMs), | 2365 : SendTest(VideoSendStreamTest::kLongTimeoutMs), |
2223 vp9_encoder_(VP9Encoder::Create()), | 2366 vp9_encoder_(VP9Encoder::Create()), |
2224 vp9_settings_(VideoEncoder::GetDefaultVp9Settings()), | 2367 vp9_settings_(VideoEncoder::GetDefaultVp9Settings()), |
2225 packets_sent_(0), | 2368 packets_sent_(0), |
2226 frames_sent_(0) {} | 2369 frames_sent_(0), |
| 2370 expected_width_(0), |
| 2371 expected_height_(0) {} |
2227 | 2372 |
2228 virtual void ModifyVideoConfigsHook( | 2373 virtual void ModifyVideoConfigsHook( |
2229 VideoSendStream::Config* send_config, | 2374 VideoSendStream::Config* send_config, |
2230 std::vector<VideoReceiveStream::Config>* receive_configs, | 2375 std::vector<VideoReceiveStream::Config>* receive_configs, |
2231 VideoEncoderConfig* encoder_config) {} | 2376 VideoEncoderConfig* encoder_config) {} |
2232 | 2377 |
2233 virtual void InspectHeader(const RTPVideoHeaderVP9& vp9) = 0; | 2378 virtual void InspectHeader(const RTPVideoHeaderVP9& vp9) = 0; |
2234 | 2379 |
2235 private: | 2380 private: |
2236 const int kVp9PayloadType = 105; | 2381 const int kVp9PayloadType = 105; |
2237 | 2382 |
| 2383 class VideoStreamFactory |
| 2384 : public VideoEncoderConfig::VideoStreamFactoryInterface { |
| 2385 public: |
| 2386 explicit VideoStreamFactory(size_t number_of_temporal_layers) |
| 2387 : number_of_temporal_layers_(number_of_temporal_layers) {} |
| 2388 |
| 2389 private: |
| 2390 std::vector<VideoStream> CreateEncoderStreams( |
| 2391 int width, |
| 2392 int height, |
| 2393 const VideoEncoderConfig& encoder_config) override { |
| 2394 std::vector<VideoStream> streams = |
| 2395 test::CreateVideoStreams(width, height, encoder_config); |
| 2396 streams[0].temporal_layer_thresholds_bps.resize( |
| 2397 number_of_temporal_layers_ - 1); |
| 2398 return streams; |
| 2399 } |
| 2400 |
| 2401 const size_t number_of_temporal_layers_; |
| 2402 }; |
| 2403 |
2238 void ModifyVideoConfigs( | 2404 void ModifyVideoConfigs( |
2239 VideoSendStream::Config* send_config, | 2405 VideoSendStream::Config* send_config, |
2240 std::vector<VideoReceiveStream::Config>* receive_configs, | 2406 std::vector<VideoReceiveStream::Config>* receive_configs, |
2241 VideoEncoderConfig* encoder_config) override { | 2407 VideoEncoderConfig* encoder_config) override { |
2242 send_config->encoder_settings.encoder = vp9_encoder_.get(); | 2408 send_config->encoder_settings.encoder = vp9_encoder_.get(); |
2243 send_config->encoder_settings.payload_name = "VP9"; | 2409 send_config->encoder_settings.payload_name = "VP9"; |
2244 send_config->encoder_settings.payload_type = kVp9PayloadType; | 2410 send_config->encoder_settings.payload_type = kVp9PayloadType; |
2245 ModifyVideoConfigsHook(send_config, receive_configs, encoder_config); | 2411 ModifyVideoConfigsHook(send_config, receive_configs, encoder_config); |
2246 encoder_config->encoder_specific_settings = new rtc::RefCountedObject< | 2412 encoder_config->encoder_specific_settings = new rtc::RefCountedObject< |
2247 VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings_); | 2413 VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings_); |
2248 EXPECT_EQ(1u, encoder_config->streams.size()); | 2414 EXPECT_EQ(1u, encoder_config->number_of_streams); |
2249 encoder_config->streams[0].temporal_layer_thresholds_bps.resize( | 2415 encoder_config->video_stream_factory = |
2250 vp9_settings_.numberOfTemporalLayers - 1); | 2416 new rtc::RefCountedObject<VideoStreamFactory>( |
| 2417 vp9_settings_.numberOfTemporalLayers); |
2251 encoder_config_ = encoder_config->Copy(); | 2418 encoder_config_ = encoder_config->Copy(); |
2252 } | 2419 } |
2253 | 2420 |
| 2421 void ModifyVideoCaptureStartResolution(int* width, |
| 2422 int* height, |
| 2423 int* frame_rate) override { |
| 2424 expected_width_ = *width; |
| 2425 expected_height_ = *height; |
| 2426 } |
| 2427 |
2254 void PerformTest() override { | 2428 void PerformTest() override { |
2255 EXPECT_TRUE(Wait()) << "Test timed out waiting for VP9 packet, num frames " | 2429 EXPECT_TRUE(Wait()) << "Test timed out waiting for VP9 packet, num frames " |
2256 << frames_sent_; | 2430 << frames_sent_; |
2257 } | 2431 } |
2258 | 2432 |
2259 Action OnSendRtp(const uint8_t* packet, size_t length) override { | 2433 Action OnSendRtp(const uint8_t* packet, size_t length) override { |
2260 RTPHeader header; | 2434 RTPHeader header; |
2261 EXPECT_TRUE(parser_->Parse(packet, length, &header)); | 2435 EXPECT_TRUE(parser_->Parse(packet, length, &header)); |
2262 | 2436 |
2263 EXPECT_EQ(kVp9PayloadType, header.payloadType); | 2437 EXPECT_EQ(kVp9PayloadType, header.payloadType); |
(...skipping 169 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2433 // +-+-+-+-+-+-+-+-+ | 2607 // +-+-+-+-+-+-+-+-+ |
2434 // N_G: | T |U| R |-|-| N_G times | 2608 // N_G: | T |U| R |-|-| N_G times |
2435 // +-+-+-+-+-+-+-+-+ | 2609 // +-+-+-+-+-+-+-+-+ |
2436 // | P_DIFF | R times | 2610 // | P_DIFF | R times |
2437 // +-+-+-+-+-+-+-+-+ | 2611 // +-+-+-+-+-+-+-+-+ |
2438 void VerifySsData(const RTPVideoHeaderVP9& vp9) const { | 2612 void VerifySsData(const RTPVideoHeaderVP9& vp9) const { |
2439 EXPECT_TRUE(vp9.ss_data_available); // V | 2613 EXPECT_TRUE(vp9.ss_data_available); // V |
2440 EXPECT_EQ(vp9_settings_.numberOfSpatialLayers, // N_S + 1 | 2614 EXPECT_EQ(vp9_settings_.numberOfSpatialLayers, // N_S + 1 |
2441 vp9.num_spatial_layers); | 2615 vp9.num_spatial_layers); |
2442 EXPECT_TRUE(vp9.spatial_layer_resolution_present); // Y:1 | 2616 EXPECT_TRUE(vp9.spatial_layer_resolution_present); // Y:1 |
2443 size_t expected_width = encoder_config_.streams[0].width; | 2617 int expected_width = expected_width_; |
2444 size_t expected_height = encoder_config_.streams[0].height; | 2618 int expected_height = expected_height_; |
2445 for (int i = static_cast<int>(vp9.num_spatial_layers) - 1; i >= 0; --i) { | 2619 for (int i = static_cast<int>(vp9.num_spatial_layers) - 1; i >= 0; --i) { |
2446 EXPECT_EQ(expected_width, vp9.width[i]); // WIDTH | 2620 EXPECT_EQ(expected_width, vp9.width[i]); // WIDTH |
2447 EXPECT_EQ(expected_height, vp9.height[i]); // HEIGHT | 2621 EXPECT_EQ(expected_height, vp9.height[i]); // HEIGHT |
2448 expected_width /= 2; | 2622 expected_width /= 2; |
2449 expected_height /= 2; | 2623 expected_height /= 2; |
2450 } | 2624 } |
2451 } | 2625 } |
2452 | 2626 |
2453 void CompareConsecutiveFrames(const RTPHeader& header, | 2627 void CompareConsecutiveFrames(const RTPHeader& header, |
2454 const RTPVideoHeader& video) const { | 2628 const RTPVideoHeader& video) const { |
(...skipping 23 matching lines...) Expand all Loading... |
2478 VerifyTl0Idx(vp9); | 2652 VerifyTl0Idx(vp9); |
2479 } | 2653 } |
2480 | 2654 |
2481 std::unique_ptr<VP9Encoder> vp9_encoder_; | 2655 std::unique_ptr<VP9Encoder> vp9_encoder_; |
2482 VideoCodecVP9 vp9_settings_; | 2656 VideoCodecVP9 vp9_settings_; |
2483 webrtc::VideoEncoderConfig encoder_config_; | 2657 webrtc::VideoEncoderConfig encoder_config_; |
2484 RTPHeader last_header_; | 2658 RTPHeader last_header_; |
2485 RTPVideoHeaderVP9 last_vp9_; | 2659 RTPVideoHeaderVP9 last_vp9_; |
2486 size_t packets_sent_; | 2660 size_t packets_sent_; |
2487 size_t frames_sent_; | 2661 size_t frames_sent_; |
| 2662 int expected_width_; |
| 2663 int expected_height_; |
2488 }; | 2664 }; |
2489 | 2665 |
2490 TEST_F(VideoSendStreamTest, Vp9NonFlexMode_1Tl1SLayers) { | 2666 TEST_F(VideoSendStreamTest, Vp9NonFlexMode_1Tl1SLayers) { |
2491 const uint8_t kNumTemporalLayers = 1; | 2667 const uint8_t kNumTemporalLayers = 1; |
2492 const uint8_t kNumSpatialLayers = 1; | 2668 const uint8_t kNumSpatialLayers = 1; |
2493 TestVp9NonFlexMode(kNumTemporalLayers, kNumSpatialLayers); | 2669 TestVp9NonFlexMode(kNumTemporalLayers, kNumSpatialLayers); |
2494 } | 2670 } |
2495 | 2671 |
2496 TEST_F(VideoSendStreamTest, Vp9NonFlexMode_2Tl1SLayers) { | 2672 TEST_F(VideoSendStreamTest, Vp9NonFlexMode_2Tl1SLayers) { |
2497 const uint8_t kNumTemporalLayers = 2; | 2673 const uint8_t kNumTemporalLayers = 2; |
(...skipping 81 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2579 static const int kHeight = 4; | 2755 static const int kHeight = 4; |
2580 class NonFlexibleModeResolution : public Vp9HeaderObserver { | 2756 class NonFlexibleModeResolution : public Vp9HeaderObserver { |
2581 void ModifyVideoConfigsHook( | 2757 void ModifyVideoConfigsHook( |
2582 VideoSendStream::Config* send_config, | 2758 VideoSendStream::Config* send_config, |
2583 std::vector<VideoReceiveStream::Config>* receive_configs, | 2759 std::vector<VideoReceiveStream::Config>* receive_configs, |
2584 VideoEncoderConfig* encoder_config) override { | 2760 VideoEncoderConfig* encoder_config) override { |
2585 vp9_settings_.flexibleMode = false; | 2761 vp9_settings_.flexibleMode = false; |
2586 vp9_settings_.numberOfTemporalLayers = 1; | 2762 vp9_settings_.numberOfTemporalLayers = 1; |
2587 vp9_settings_.numberOfSpatialLayers = 1; | 2763 vp9_settings_.numberOfSpatialLayers = 1; |
2588 | 2764 |
2589 EXPECT_EQ(1u, encoder_config->streams.size()); | 2765 EXPECT_EQ(1u, encoder_config->number_of_streams); |
2590 encoder_config->streams[0].width = kWidth; | |
2591 encoder_config->streams[0].height = kHeight; | |
2592 } | 2766 } |
2593 | 2767 |
2594 void InspectHeader(const RTPVideoHeaderVP9& vp9_header) override { | 2768 void InspectHeader(const RTPVideoHeaderVP9& vp9_header) override { |
2595 if (frames_sent_ > kNumFramesToSend) | 2769 if (frames_sent_ > kNumFramesToSend) |
2596 observation_complete_.Set(); | 2770 observation_complete_.Set(); |
2597 } | 2771 } |
| 2772 |
| 2773 void ModifyVideoCaptureStartResolution(int* width, |
| 2774 int* height, |
| 2775 int* frame_rate) override { |
| 2776 expected_width_ = kWidth; |
| 2777 expected_height_ = kHeight; |
| 2778 *width = kWidth; |
| 2779 *height = kHeight; |
| 2780 } |
2598 } test; | 2781 } test; |
2599 | 2782 |
2600 RunBaseTest(&test); | 2783 RunBaseTest(&test); |
2601 } | 2784 } |
2602 | 2785 |
2603 TEST_F(VideoSendStreamTest, Vp9FlexModeRefCount) { | 2786 TEST_F(VideoSendStreamTest, Vp9FlexModeRefCount) { |
2604 class FlexibleMode : public Vp9HeaderObserver { | 2787 class FlexibleMode : public Vp9HeaderObserver { |
2605 void ModifyVideoConfigsHook( | 2788 void ModifyVideoConfigsHook( |
2606 VideoSendStream::Config* send_config, | 2789 VideoSendStream::Config* send_config, |
2607 std::vector<VideoReceiveStream::Config>* receive_configs, | 2790 std::vector<VideoReceiveStream::Config>* receive_configs, |
(...skipping 12 matching lines...) Expand all Loading... |
2620 observation_complete_.Set(); | 2803 observation_complete_.Set(); |
2621 } | 2804 } |
2622 } | 2805 } |
2623 } test; | 2806 } test; |
2624 | 2807 |
2625 RunBaseTest(&test); | 2808 RunBaseTest(&test); |
2626 } | 2809 } |
2627 #endif // !defined(RTC_DISABLE_VP9) | 2810 #endif // !defined(RTC_DISABLE_VP9) |
2628 | 2811 |
2629 } // namespace webrtc | 2812 } // namespace webrtc |
OLD | NEW |