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 847 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
858 if (stats.suspended == false) { | 858 if (stats.suspended == false) { |
859 // Stats flipped to false. Test is complete. | 859 // Stats flipped to false. Test is complete. |
860 observation_complete_.Set(); | 860 observation_complete_.Set(); |
861 } | 861 } |
862 SendRtcpFeedback(0); // REMB is only sent if value is > 0. | 862 SendRtcpFeedback(0); // REMB is only sent if value is > 0. |
863 } | 863 } |
864 | 864 |
865 return SEND_PACKET; | 865 return SEND_PACKET; |
866 } | 866 } |
867 | 867 |
868 // This method implements the rtc::VideoSinkInterface | 868 // This method implements the rtc::VideoSinkInterface. This is called when |
869 // a frame is provided to the VideoSendStream. | |
869 void OnFrame(const VideoFrame& video_frame) override { | 870 void OnFrame(const VideoFrame& video_frame) override { |
870 rtc::CritScope lock(&crit_); | 871 rtc::CritScope lock(&crit_); |
871 if (test_state_ == kDuringSuspend && | 872 if (test_state_ == kDuringSuspend && |
872 ++suspended_frame_count_ > kSuspendTimeFrames) { | 873 ++suspended_frame_count_ > kSuspendTimeFrames) { |
873 VideoSendStream::Stats stats = stream_->GetStats(); | 874 VideoSendStream::Stats stats = stream_->GetStats(); |
874 EXPECT_TRUE(stats.suspended); | 875 EXPECT_TRUE(stats.suspended); |
875 SendRtcpFeedback(high_remb_bps_); | 876 SendRtcpFeedback(high_remb_bps_); |
876 test_state_ = kWaitingForPacket; | 877 test_state_ = kWaitingForPacket; |
877 } | 878 } |
878 } | 879 } |
(...skipping 315 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1194 VideoEncoderConfig* encoder_config) override { | 1195 VideoEncoderConfig* encoder_config) override { |
1195 RTC_DCHECK_EQ(1u, encoder_config->streams.size()); | 1196 RTC_DCHECK_EQ(1u, encoder_config->streams.size()); |
1196 if (running_without_padding_) { | 1197 if (running_without_padding_) { |
1197 encoder_config->min_transmit_bitrate_bps = 0; | 1198 encoder_config->min_transmit_bitrate_bps = 0; |
1198 encoder_config->content_type = | 1199 encoder_config->content_type = |
1199 VideoEncoderConfig::ContentType::kRealtimeVideo; | 1200 VideoEncoderConfig::ContentType::kRealtimeVideo; |
1200 } else { | 1201 } else { |
1201 encoder_config->min_transmit_bitrate_bps = kMinTransmitBitrateBps; | 1202 encoder_config->min_transmit_bitrate_bps = kMinTransmitBitrateBps; |
1202 encoder_config->content_type = VideoEncoderConfig::ContentType::kScreen; | 1203 encoder_config->content_type = VideoEncoderConfig::ContentType::kScreen; |
1203 } | 1204 } |
1204 encoder_config_ = *encoder_config; | 1205 encoder_config_ = encoder_config->Copy(); |
1205 } | 1206 } |
1206 | 1207 |
1207 void OnCallsCreated(Call* sender_call, Call* receiver_call) override { | 1208 void OnCallsCreated(Call* sender_call, Call* receiver_call) override { |
1208 call_ = sender_call; | 1209 call_ = sender_call; |
1209 } | 1210 } |
1210 | 1211 |
1211 Action OnSendRtp(const uint8_t* packet, size_t length) override { | 1212 Action OnSendRtp(const uint8_t* packet, size_t length) override { |
1212 rtc::CritScope lock(&crit_); | 1213 rtc::CritScope lock(&crit_); |
1213 | 1214 |
1214 if (running_without_padding_) | 1215 if (running_without_padding_) |
1215 EXPECT_EQ(0, call_->GetStats().max_padding_bitrate_bps); | 1216 EXPECT_EQ(0, call_->GetStats().max_padding_bitrate_bps); |
1216 | 1217 |
1217 // Wait until at least kMinPacketsToSend frames have been encoded, so that | 1218 // Wait until at least kMinPacketsToSend frames have been encoded, so that |
1218 // we have reliable data. | 1219 // we have reliable data. |
1219 if (++packets_sent_ < kMinPacketsToSend) | 1220 if (++packets_sent_ < kMinPacketsToSend) |
1220 return SEND_PACKET; | 1221 return SEND_PACKET; |
1221 | 1222 |
1222 if (running_without_padding_) { | 1223 if (running_without_padding_) { |
1223 // We've sent kMinPacketsToSend packets with default configuration, switch | 1224 // We've sent kMinPacketsToSend packets with default configuration, switch |
1224 // to enabling screen content and setting min transmit bitrate. | 1225 // to enabling screen content and setting min transmit bitrate. |
1225 packets_sent_ = 0; | 1226 packets_sent_ = 0; |
1226 encoder_config_.min_transmit_bitrate_bps = kMinTransmitBitrateBps; | 1227 encoder_config_.min_transmit_bitrate_bps = kMinTransmitBitrateBps; |
1227 encoder_config_.content_type = VideoEncoderConfig::ContentType::kScreen; | 1228 encoder_config_.content_type = VideoEncoderConfig::ContentType::kScreen; |
1228 send_stream_->ReconfigureVideoEncoder(encoder_config_); | 1229 send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy()); |
1229 running_without_padding_ = false; | 1230 running_without_padding_ = false; |
1230 return SEND_PACKET; | 1231 return SEND_PACKET; |
1231 } | 1232 } |
1232 | 1233 |
1233 // Make sure the pacer has been configured with a min transmit bitrate. | 1234 // Make sure the pacer has been configured with a min transmit bitrate. |
1234 if (call_->GetStats().max_padding_bitrate_bps > 0) | 1235 if (call_->GetStats().max_padding_bitrate_bps > 0) |
1235 observation_complete_.Set(); | 1236 observation_complete_.Set(); |
1236 | 1237 |
1237 return SEND_PACKET; | 1238 return SEND_PACKET; |
1238 } | 1239 } |
(...skipping 74 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1313 video_send_config_.encoder_settings.encoder = &encoder; | 1314 video_send_config_.encoder_settings.encoder = &encoder; |
1314 | 1315 |
1315 CreateVideoStreams(); | 1316 CreateVideoStreams(); |
1316 | 1317 |
1317 EXPECT_TRUE(encoder.WaitForStartBitrate()); | 1318 EXPECT_TRUE(encoder.WaitForStartBitrate()); |
1318 EXPECT_EQ(video_encoder_config_.streams[0].max_bitrate_bps / 1000, | 1319 EXPECT_EQ(video_encoder_config_.streams[0].max_bitrate_bps / 1000, |
1319 encoder.GetStartBitrateKbps()); | 1320 encoder.GetStartBitrateKbps()); |
1320 | 1321 |
1321 video_encoder_config_.streams[0].max_bitrate_bps = | 1322 video_encoder_config_.streams[0].max_bitrate_bps = |
1322 2 * bitrate_config.start_bitrate_bps; | 1323 2 * bitrate_config.start_bitrate_bps; |
1323 video_send_stream_->ReconfigureVideoEncoder(video_encoder_config_); | 1324 video_send_stream_->ReconfigureVideoEncoder(video_encoder_config_.Copy()); |
1324 | 1325 |
1325 // New bitrate should be reconfigured above the previous max. As there's no | 1326 // New bitrate should be reconfigured above the previous max. As there's no |
1326 // network connection this shouldn't be flaky, as no bitrate should've been | 1327 // network connection this shouldn't be flaky, as no bitrate should've been |
1327 // reported in between. | 1328 // reported in between. |
1328 EXPECT_TRUE(encoder.WaitForStartBitrate()); | 1329 EXPECT_TRUE(encoder.WaitForStartBitrate()); |
1329 EXPECT_EQ(bitrate_config.start_bitrate_bps / 1000, | 1330 EXPECT_EQ(bitrate_config.start_bitrate_bps / 1000, |
1330 encoder.GetStartBitrateKbps()); | 1331 encoder.GetStartBitrateKbps()); |
1331 | 1332 |
1332 DestroyStreams(); | 1333 DestroyStreams(); |
1333 } | 1334 } |
(...skipping 243 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1577 VideoSendStream* send_stream, | 1578 VideoSendStream* send_stream, |
1578 const std::vector<VideoReceiveStream*>& receive_streams) override { | 1579 const std::vector<VideoReceiveStream*>& receive_streams) override { |
1579 stream_ = send_stream; | 1580 stream_ = send_stream; |
1580 } | 1581 } |
1581 | 1582 |
1582 void ModifyVideoConfigs( | 1583 void ModifyVideoConfigs( |
1583 VideoSendStream::Config* send_config, | 1584 VideoSendStream::Config* send_config, |
1584 std::vector<VideoReceiveStream::Config>* receive_configs, | 1585 std::vector<VideoReceiveStream::Config>* receive_configs, |
1585 VideoEncoderConfig* encoder_config) override { | 1586 VideoEncoderConfig* encoder_config) override { |
1586 send_config->encoder_settings.encoder = this; | 1587 send_config->encoder_settings.encoder = this; |
1587 encoder_config_ = *encoder_config; | 1588 encoder_config_ = encoder_config->Copy(); |
1588 } | 1589 } |
1589 | 1590 |
1590 void PerformTest() override { | 1591 void PerformTest() override { |
1591 EXPECT_TRUE(Wait()) << "Timed out while waiting for Encode."; | 1592 EXPECT_TRUE(Wait()) << "Timed out while waiting for Encode."; |
1592 EXPECT_EQ(0u, num_releases()); | 1593 EXPECT_EQ(0u, num_releases()); |
1593 stream_->ReconfigureVideoEncoder(encoder_config_); | 1594 stream_->ReconfigureVideoEncoder(std::move(encoder_config_)); |
1594 EXPECT_EQ(0u, num_releases()); | 1595 EXPECT_EQ(0u, num_releases()); |
1595 stream_->Stop(); | 1596 stream_->Stop(); |
1596 // Encoder should not be released before destroying the VideoSendStream. | 1597 // Encoder should not be released before destroying the VideoSendStream. |
1597 EXPECT_FALSE(IsReleased()); | 1598 EXPECT_FALSE(IsReleased()); |
1598 EXPECT_TRUE(IsReadyForEncode()); | 1599 EXPECT_TRUE(IsReadyForEncode()); |
1599 stream_->Start(); | 1600 stream_->Start(); |
1600 // Sanity check, make sure we still encode frames with this encoder. | 1601 // Sanity check, make sure we still encode frames with this encoder. |
1601 EXPECT_TRUE(Wait()) << "Timed out while waiting for Encode."; | 1602 EXPECT_TRUE(Wait()) << "Timed out while waiting for Encode."; |
1602 } | 1603 } |
1603 | 1604 |
(...skipping 21 matching lines...) Expand all Loading... | |
1625 FakeEncoder(Clock::GetRealTimeClock()), | 1626 FakeEncoder(Clock::GetRealTimeClock()), |
1626 init_encode_event_(false, false), | 1627 init_encode_event_(false, false), |
1627 num_initializations_(0) {} | 1628 num_initializations_(0) {} |
1628 | 1629 |
1629 private: | 1630 private: |
1630 void ModifyVideoConfigs( | 1631 void ModifyVideoConfigs( |
1631 VideoSendStream::Config* send_config, | 1632 VideoSendStream::Config* send_config, |
1632 std::vector<VideoReceiveStream::Config>* receive_configs, | 1633 std::vector<VideoReceiveStream::Config>* receive_configs, |
1633 VideoEncoderConfig* encoder_config) override { | 1634 VideoEncoderConfig* encoder_config) override { |
1634 send_config->encoder_settings.encoder = this; | 1635 send_config->encoder_settings.encoder = this; |
1635 encoder_config_ = *encoder_config; | 1636 encoder_config_ = encoder_config->Copy(); |
1636 } | 1637 } |
1637 | 1638 |
1638 void OnVideoStreamsCreated( | 1639 void OnVideoStreamsCreated( |
1639 VideoSendStream* send_stream, | 1640 VideoSendStream* send_stream, |
1640 const std::vector<VideoReceiveStream*>& receive_streams) override { | 1641 const std::vector<VideoReceiveStream*>& receive_streams) override { |
1641 stream_ = send_stream; | 1642 stream_ = send_stream; |
1642 } | 1643 } |
1643 | 1644 |
1644 int32_t InitEncode(const VideoCodec* config, | 1645 int32_t InitEncode(const VideoCodec* config, |
1645 int32_t number_of_cores, | 1646 int32_t number_of_cores, |
1646 size_t max_payload_size) override { | 1647 size_t max_payload_size) override { |
1647 if (num_initializations_ == 0) { | 1648 if (num_initializations_ == 0) { |
1648 // Verify default values. | 1649 // Verify default values. |
1649 EXPECT_EQ(kRealtimeVideo, config->mode); | 1650 EXPECT_EQ(kRealtimeVideo, config->mode); |
1650 } else { | 1651 } else { |
1651 // Verify that changed values are propagated. | 1652 // Verify that changed values are propagated. |
1652 EXPECT_EQ(kScreensharing, config->mode); | 1653 EXPECT_EQ(kScreensharing, config->mode); |
1653 } | 1654 } |
1654 ++num_initializations_; | 1655 ++num_initializations_; |
1655 init_encode_event_.Set(); | 1656 init_encode_event_.Set(); |
1656 return FakeEncoder::InitEncode(config, number_of_cores, max_payload_size); | 1657 return FakeEncoder::InitEncode(config, number_of_cores, max_payload_size); |
1657 } | 1658 } |
1658 | 1659 |
1659 void PerformTest() override { | 1660 void PerformTest() override { |
1660 EXPECT_TRUE(init_encode_event_.Wait(kDefaultTimeoutMs)); | 1661 EXPECT_TRUE(init_encode_event_.Wait(kDefaultTimeoutMs)); |
1661 EXPECT_EQ(1u, num_initializations_) << "VideoEncoder not initialized."; | 1662 EXPECT_EQ(1u, num_initializations_) << "VideoEncoder not initialized."; |
1662 | 1663 |
1663 encoder_config_.content_type = VideoEncoderConfig::ContentType::kScreen; | 1664 encoder_config_.content_type = VideoEncoderConfig::ContentType::kScreen; |
1664 stream_->ReconfigureVideoEncoder(encoder_config_); | 1665 stream_->ReconfigureVideoEncoder(std::move(encoder_config_)); |
1665 EXPECT_TRUE(init_encode_event_.Wait(kDefaultTimeoutMs)); | 1666 EXPECT_TRUE(init_encode_event_.Wait(kDefaultTimeoutMs)); |
1666 EXPECT_EQ(2u, num_initializations_) | 1667 EXPECT_EQ(2u, num_initializations_) |
1667 << "ReconfigureVideoEncoder did not reinitialize the encoder with " | 1668 << "ReconfigureVideoEncoder did not reinitialize the encoder with " |
1668 "new encoder settings."; | 1669 "new encoder settings."; |
1669 } | 1670 } |
1670 | 1671 |
1671 rtc::Event init_encode_event_; | 1672 rtc::Event init_encode_event_; |
1672 size_t num_initializations_; | 1673 size_t num_initializations_; |
1673 VideoSendStream* stream_; | 1674 VideoSendStream* stream_; |
1674 VideoEncoderConfig encoder_config_; | 1675 VideoEncoderConfig encoder_config_; |
(...skipping 25 matching lines...) Expand all Loading... | |
1700 VideoEncoderConfig* encoder_config) override { | 1701 VideoEncoderConfig* encoder_config) override { |
1701 send_config->encoder_settings.encoder = this; | 1702 send_config->encoder_settings.encoder = this; |
1702 send_config->encoder_settings.payload_name = codec_name_; | 1703 send_config->encoder_settings.payload_name = codec_name_; |
1703 | 1704 |
1704 for (size_t i = 0; i < encoder_config->streams.size(); ++i) { | 1705 for (size_t i = 0; i < encoder_config->streams.size(); ++i) { |
1705 encoder_config->streams[i].temporal_layer_thresholds_bps.resize( | 1706 encoder_config->streams[i].temporal_layer_thresholds_bps.resize( |
1706 kVideoCodecConfigObserverNumberOfTemporalLayers - 1); | 1707 kVideoCodecConfigObserverNumberOfTemporalLayers - 1); |
1707 } | 1708 } |
1708 | 1709 |
1709 encoder_config->encoder_specific_settings = &encoder_settings_; | 1710 encoder_config->encoder_specific_settings = &encoder_settings_; |
1710 encoder_config_ = *encoder_config; | 1711 encoder_config_ = encoder_config->Copy(); |
1711 } | 1712 } |
1712 | 1713 |
1713 void OnVideoStreamsCreated( | 1714 void OnVideoStreamsCreated( |
1714 VideoSendStream* send_stream, | 1715 VideoSendStream* send_stream, |
1715 const std::vector<VideoReceiveStream*>& receive_streams) override { | 1716 const std::vector<VideoReceiveStream*>& receive_streams) override { |
1716 stream_ = send_stream; | 1717 stream_ = send_stream; |
1717 } | 1718 } |
1718 | 1719 |
1719 int32_t InitEncode(const VideoCodec* config, | 1720 int32_t InitEncode(const VideoCodec* config, |
1720 int32_t number_of_cores, | 1721 int32_t number_of_cores, |
1721 size_t max_payload_size) override { | 1722 size_t max_payload_size) override { |
1722 EXPECT_EQ(video_codec_type_, config->codecType); | 1723 EXPECT_EQ(video_codec_type_, config->codecType); |
1723 VerifyCodecSpecifics(*config); | 1724 VerifyCodecSpecifics(*config); |
1724 ++num_initializations_; | 1725 ++num_initializations_; |
1725 init_encode_event_.Set(); | 1726 init_encode_event_.Set(); |
1726 return FakeEncoder::InitEncode(config, number_of_cores, max_payload_size); | 1727 return FakeEncoder::InitEncode(config, number_of_cores, max_payload_size); |
1727 } | 1728 } |
1728 | 1729 |
1729 void VerifyCodecSpecifics(const VideoCodec& config) const; | 1730 void VerifyCodecSpecifics(const VideoCodec& config) const; |
1730 | 1731 |
1731 void PerformTest() override { | 1732 void PerformTest() override { |
1732 EXPECT_TRUE( | 1733 EXPECT_TRUE( |
1733 init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs)); | 1734 init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs)); |
1734 ASSERT_EQ(1u, num_initializations_) << "VideoEncoder not initialized."; | 1735 ASSERT_EQ(1u, num_initializations_) << "VideoEncoder not initialized."; |
1735 | 1736 |
1736 encoder_settings_.frameDroppingOn = true; | 1737 encoder_settings_.frameDroppingOn = true; |
1737 stream_->ReconfigureVideoEncoder(encoder_config_); | 1738 stream_->ReconfigureVideoEncoder(std::move(encoder_config_)); |
1738 ASSERT_TRUE( | 1739 ASSERT_TRUE( |
1739 init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs)); | 1740 init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs)); |
1740 EXPECT_EQ(2u, num_initializations_) | 1741 EXPECT_EQ(2u, num_initializations_) |
1741 << "ReconfigureVideoEncoder did not reinitialize the encoder with " | 1742 << "ReconfigureVideoEncoder did not reinitialize the encoder with " |
1742 "new encoder settings."; | 1743 "new encoder settings."; |
1743 } | 1744 } |
1744 | 1745 |
1745 int32_t Encode(const VideoFrame& input_image, | 1746 int32_t Encode(const VideoFrame& input_image, |
1746 const CodecSpecificInfo* codec_specific_info, | 1747 const CodecSpecificInfo* codec_specific_info, |
1747 const std::vector<FrameType>* frame_types) override { | 1748 const std::vector<FrameType>* frame_types) override { |
(...skipping 176 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1924 static const int kMaxBitrateKbps = 413; | 1925 static const int kMaxBitrateKbps = 413; |
1925 static const int kIncreasedStartBitrateKbps = 451; | 1926 static const int kIncreasedStartBitrateKbps = 451; |
1926 static const int kIncreasedMaxBitrateKbps = 597; | 1927 static const int kIncreasedMaxBitrateKbps = 597; |
1927 class EncoderBitrateThresholdObserver : public test::SendTest, | 1928 class EncoderBitrateThresholdObserver : public test::SendTest, |
1928 public test::FakeEncoder { | 1929 public test::FakeEncoder { |
1929 public: | 1930 public: |
1930 EncoderBitrateThresholdObserver() | 1931 EncoderBitrateThresholdObserver() |
1931 : SendTest(kDefaultTimeoutMs), | 1932 : SendTest(kDefaultTimeoutMs), |
1932 FakeEncoder(Clock::GetRealTimeClock()), | 1933 FakeEncoder(Clock::GetRealTimeClock()), |
1933 init_encode_event_(false, false), | 1934 init_encode_event_(false, false), |
1935 bitrate_changed_event_(false, false), | |
1934 num_initializations_(0) {} | 1936 num_initializations_(0) {} |
1935 | 1937 |
1936 private: | 1938 private: |
1937 int32_t InitEncode(const VideoCodec* codecSettings, | 1939 int32_t InitEncode(const VideoCodec* codecSettings, |
1938 int32_t numberOfCores, | 1940 int32_t numberOfCores, |
1939 size_t maxPayloadSize) override { | 1941 size_t maxPayloadSize) override { |
1940 if (num_initializations_ == 0) { | 1942 if (num_initializations_ == 0) { |
1941 EXPECT_EQ(static_cast<unsigned int>(kMinBitrateKbps), | 1943 EXPECT_EQ(static_cast<unsigned int>(kMinBitrateKbps), |
1942 codecSettings->minBitrate); | 1944 codecSettings->minBitrate); |
1943 EXPECT_EQ(static_cast<unsigned int>(kStartBitrateKbps), | 1945 EXPECT_EQ(static_cast<unsigned int>(kStartBitrateKbps), |
1944 codecSettings->startBitrate); | 1946 codecSettings->startBitrate); |
1945 EXPECT_EQ(static_cast<unsigned int>(kMaxBitrateKbps), | 1947 EXPECT_EQ(static_cast<unsigned int>(kMaxBitrateKbps), |
1946 codecSettings->maxBitrate); | 1948 codecSettings->maxBitrate); |
1947 observation_complete_.Set(); | 1949 observation_complete_.Set(); |
1948 } else if (num_initializations_ == 1) { | 1950 } else if (num_initializations_ == 1) { |
1949 EXPECT_EQ(static_cast<unsigned int>(kLowerMaxBitrateKbps), | 1951 EXPECT_EQ(static_cast<unsigned int>(kLowerMaxBitrateKbps), |
1950 codecSettings->maxBitrate); | 1952 codecSettings->maxBitrate); |
1951 // The start bitrate should be kept (-1) and capped to the max bitrate. | 1953 // The start bitrate should be kept (-1) and capped to the max bitrate. |
1952 // Since this is not an end-to-end call no receiver should have been | 1954 // Since this is not an end-to-end call no receiver should have been |
1953 // returning a REMB that could lower this estimate. | 1955 // returning a REMB that could lower this estimate. |
1954 EXPECT_EQ(codecSettings->startBitrate, codecSettings->maxBitrate); | 1956 EXPECT_EQ(codecSettings->startBitrate, codecSettings->maxBitrate); |
1955 } else if (num_initializations_ == 2) { | 1957 } else if (num_initializations_ == 2) { |
1956 EXPECT_EQ(static_cast<unsigned int>(kIncreasedMaxBitrateKbps), | 1958 EXPECT_EQ(static_cast<unsigned int>(kIncreasedMaxBitrateKbps), |
1957 codecSettings->maxBitrate); | 1959 codecSettings->maxBitrate); |
1958 EXPECT_EQ(static_cast<unsigned int>(kIncreasedStartBitrateKbps), | |
1959 codecSettings->startBitrate); | |
1960 } | 1960 } |
1961 ++num_initializations_; | 1961 ++num_initializations_; |
1962 init_encode_event_.Set(); | 1962 init_encode_event_.Set(); |
1963 return FakeEncoder::InitEncode(codecSettings, numberOfCores, | 1963 return FakeEncoder::InitEncode(codecSettings, numberOfCores, |
1964 maxPayloadSize); | 1964 maxPayloadSize); |
1965 } | 1965 } |
1966 | 1966 |
1967 int32_t SetRates(uint32_t newBitRate, uint32_t frameRate) override { | |
1968 bitrate_changed_event_.Set(); | |
1969 return FakeEncoder::SetRates(newBitRate, frameRate); | |
1970 } | |
1971 | |
1967 Call::Config GetSenderCallConfig() override { | 1972 Call::Config GetSenderCallConfig() override { |
1968 Call::Config config; | 1973 Call::Config config; |
1969 config.bitrate_config.min_bitrate_bps = kMinBitrateKbps * 1000; | 1974 config.bitrate_config.min_bitrate_bps = kMinBitrateKbps * 1000; |
1970 config.bitrate_config.start_bitrate_bps = kStartBitrateKbps * 1000; | 1975 config.bitrate_config.start_bitrate_bps = kStartBitrateKbps * 1000; |
1971 config.bitrate_config.max_bitrate_bps = kMaxBitrateKbps * 1000; | 1976 config.bitrate_config.max_bitrate_bps = kMaxBitrateKbps * 1000; |
1972 return config; | 1977 return config; |
1973 } | 1978 } |
1974 | 1979 |
1975 void ModifyVideoConfigs( | 1980 void ModifyVideoConfigs( |
1976 VideoSendStream::Config* send_config, | 1981 VideoSendStream::Config* send_config, |
1977 std::vector<VideoReceiveStream::Config>* receive_configs, | 1982 std::vector<VideoReceiveStream::Config>* receive_configs, |
1978 VideoEncoderConfig* encoder_config) override { | 1983 VideoEncoderConfig* encoder_config) override { |
1979 send_config->encoder_settings.encoder = this; | 1984 send_config->encoder_settings.encoder = this; |
1980 // Set bitrates lower/higher than min/max to make sure they are properly | 1985 // Set bitrates lower/higher than min/max to make sure they are properly |
1981 // capped. | 1986 // capped. |
1982 encoder_config->streams.front().min_bitrate_bps = kMinBitrateKbps * 1000; | 1987 encoder_config->streams.front().min_bitrate_bps = kMinBitrateKbps * 1000; |
1983 encoder_config->streams.front().max_bitrate_bps = kMaxBitrateKbps * 1000; | 1988 encoder_config->streams.front().max_bitrate_bps = kMaxBitrateKbps * 1000; |
1984 encoder_config_ = *encoder_config; | 1989 encoder_config_ = encoder_config->Copy(); |
1985 } | 1990 } |
1986 | 1991 |
1987 void OnCallsCreated(Call* sender_call, Call* receiver_call) override { | 1992 void OnCallsCreated(Call* sender_call, Call* receiver_call) override { |
1988 call_ = sender_call; | 1993 call_ = sender_call; |
1989 } | 1994 } |
1990 | 1995 |
1991 void OnVideoStreamsCreated( | 1996 void OnVideoStreamsCreated( |
1992 VideoSendStream* send_stream, | 1997 VideoSendStream* send_stream, |
1993 const std::vector<VideoReceiveStream*>& receive_streams) override { | 1998 const std::vector<VideoReceiveStream*>& receive_streams) override { |
1994 send_stream_ = send_stream; | 1999 send_stream_ = send_stream; |
1995 } | 2000 } |
1996 | 2001 |
1997 void PerformTest() override { | 2002 void PerformTest() override { |
1998 ASSERT_TRUE( | 2003 ASSERT_TRUE( |
1999 init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs)) | 2004 init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs)) |
2000 << "Timed out while waiting encoder to be configured."; | 2005 << "Timed out while waiting for encoder to be configured."; |
2006 ASSERT_TRUE( | |
2007 bitrate_changed_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs)) | |
2008 << "Timed out while waiting encoder rate to be set."; | |
2001 Call::Config::BitrateConfig bitrate_config; | 2009 Call::Config::BitrateConfig bitrate_config; |
2002 bitrate_config.start_bitrate_bps = kIncreasedStartBitrateKbps * 1000; | 2010 bitrate_config.start_bitrate_bps = kIncreasedStartBitrateKbps * 1000; |
2003 bitrate_config.max_bitrate_bps = kIncreasedMaxBitrateKbps * 1000; | 2011 bitrate_config.max_bitrate_bps = kIncreasedMaxBitrateKbps * 1000; |
2004 call_->SetBitrateConfig(bitrate_config); | 2012 call_->SetBitrateConfig(bitrate_config); |
2005 EXPECT_TRUE(Wait()) | 2013 ASSERT_TRUE( |
2006 << "Timed out while waiting encoder to be configured."; | 2014 bitrate_changed_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs)) |
2015 << "Timed out while waiting for encoder rate to be set."; | |
pbos-webrtc
2016/07/13 12:35:39
This doesn't check kIncreasedStartBitrateKbps anym
perkj_webrtc
2016/07/14 10:11:28
fixed
| |
2016 | |
2007 encoder_config_.streams[0].min_bitrate_bps = 0; | 2017 encoder_config_.streams[0].min_bitrate_bps = 0; |
2008 encoder_config_.streams[0].max_bitrate_bps = kLowerMaxBitrateKbps * 1000; | 2018 encoder_config_.streams[0].max_bitrate_bps = kLowerMaxBitrateKbps * 1000; |
2009 send_stream_->ReconfigureVideoEncoder(encoder_config_); | 2019 send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy()); |
2010 ASSERT_TRUE( | 2020 ASSERT_TRUE( |
2011 init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs)); | 2021 init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs)); |
2012 EXPECT_EQ(2, num_initializations_) | 2022 EXPECT_EQ(2, num_initializations_) |
2013 << "Encoder should have been reconfigured with the new value."; | 2023 << "Encoder should have been reconfigured with the new value."; |
2014 encoder_config_.streams[0].target_bitrate_bps = | 2024 encoder_config_.streams[0].target_bitrate_bps = |
2015 encoder_config_.streams[0].min_bitrate_bps; | 2025 encoder_config_.streams[0].min_bitrate_bps; |
2016 encoder_config_.streams[0].max_bitrate_bps = | 2026 encoder_config_.streams[0].max_bitrate_bps = |
2017 kIncreasedMaxBitrateKbps * 1000; | 2027 kIncreasedMaxBitrateKbps * 1000; |
2018 send_stream_->ReconfigureVideoEncoder(encoder_config_); | 2028 send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy()); |
2019 ASSERT_TRUE( | 2029 ASSERT_TRUE( |
2020 init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs)); | 2030 init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs)); |
2021 EXPECT_EQ(3, num_initializations_) | 2031 EXPECT_EQ(3, num_initializations_) |
2022 << "Encoder should have been reconfigured with the new value."; | 2032 << "Encoder should have been reconfigured with the new value."; |
2023 } | 2033 } |
2024 | 2034 |
2025 rtc::Event init_encode_event_; | 2035 rtc::Event init_encode_event_; |
2036 rtc::Event bitrate_changed_event_; | |
2026 int num_initializations_; | 2037 int num_initializations_; |
2027 webrtc::Call* call_; | 2038 webrtc::Call* call_; |
2028 webrtc::VideoSendStream* send_stream_; | 2039 webrtc::VideoSendStream* send_stream_; |
2029 webrtc::VideoEncoderConfig encoder_config_; | 2040 webrtc::VideoEncoderConfig encoder_config_; |
2030 } test; | 2041 } test; |
2031 | 2042 |
2032 RunBaseTest(&test); | 2043 RunBaseTest(&test); |
2033 } | 2044 } |
2034 | 2045 |
2035 TEST_F(VideoSendStreamTest, ReportsSentResolution) { | 2046 TEST_F(VideoSendStreamTest, ReportsSentResolution) { |
(...skipping 100 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2136 std::vector<VideoReceiveStream::Config>* receive_configs, | 2147 std::vector<VideoReceiveStream::Config>* receive_configs, |
2137 VideoEncoderConfig* encoder_config) override { | 2148 VideoEncoderConfig* encoder_config) override { |
2138 encoder_config->encoder_specific_settings = &vp9_settings_; | 2149 encoder_config->encoder_specific_settings = &vp9_settings_; |
2139 send_config->encoder_settings.encoder = vp9_encoder_.get(); | 2150 send_config->encoder_settings.encoder = vp9_encoder_.get(); |
2140 send_config->encoder_settings.payload_name = "VP9"; | 2151 send_config->encoder_settings.payload_name = "VP9"; |
2141 send_config->encoder_settings.payload_type = kVp9PayloadType; | 2152 send_config->encoder_settings.payload_type = kVp9PayloadType; |
2142 ModifyVideoConfigsHook(send_config, receive_configs, encoder_config); | 2153 ModifyVideoConfigsHook(send_config, receive_configs, encoder_config); |
2143 EXPECT_EQ(1u, encoder_config->streams.size()); | 2154 EXPECT_EQ(1u, encoder_config->streams.size()); |
2144 encoder_config->streams[0].temporal_layer_thresholds_bps.resize( | 2155 encoder_config->streams[0].temporal_layer_thresholds_bps.resize( |
2145 vp9_settings_.numberOfTemporalLayers - 1); | 2156 vp9_settings_.numberOfTemporalLayers - 1); |
2146 encoder_config_ = *encoder_config; | 2157 encoder_config_ = encoder_config->Copy(); |
2147 } | 2158 } |
2148 | 2159 |
2149 void PerformTest() override { | 2160 void PerformTest() override { |
2150 EXPECT_TRUE(Wait()) << "Test timed out waiting for VP9 packet, num frames " | 2161 EXPECT_TRUE(Wait()) << "Test timed out waiting for VP9 packet, num frames " |
2151 << frames_sent_; | 2162 << frames_sent_; |
2152 } | 2163 } |
2153 | 2164 |
2154 Action OnSendRtp(const uint8_t* packet, size_t length) override { | 2165 Action OnSendRtp(const uint8_t* packet, size_t length) override { |
2155 RTPHeader header; | 2166 RTPHeader header; |
2156 EXPECT_TRUE(parser_->Parse(packet, length, &header)); | 2167 EXPECT_TRUE(parser_->Parse(packet, length, &header)); |
(...skipping 358 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2515 observation_complete_.Set(); | 2526 observation_complete_.Set(); |
2516 } | 2527 } |
2517 } | 2528 } |
2518 } test; | 2529 } test; |
2519 | 2530 |
2520 RunBaseTest(&test); | 2531 RunBaseTest(&test); |
2521 } | 2532 } |
2522 #endif // !defined(RTC_DISABLE_VP9) | 2533 #endif // !defined(RTC_DISABLE_VP9) |
2523 | 2534 |
2524 } // namespace webrtc | 2535 } // namespace webrtc |
OLD | NEW |