From e69b46863a2876dc22b45f78e8a1c0b956b6f2fd Mon Sep 17 00:00:00 2001 From: minyue Date: Wed, 30 Nov 2016 01:18:58 -0800 Subject: [PATCH] Revert of Renaming AudioEncoder::SetTargetBitrate and SetProjectedPacketLossRate. (patchset #5 id:240001 of https://codereview.webrtc.org/2411613002/ ) Reason for revert: internal bot failure Original issue's description: > Renaming AudioEncoder::SetTargetBitrate and SetProjectedPacketLossRate. > > BUG=webrtc:6303 > > Committed: https://crrev.com/84e56d576806635c966093d5421c5d04c9b90746 > Cr-Commit-Position: refs/heads/master@{#15310} TBR=kwiberg@webrtc.org,henrik.lundin@webrtc.org # Skipping CQ checks because original CL landed less than 1 days ago. NOPRESUBMIT=true NOTREECHECKS=true NOTRY=true BUG=webrtc:6303 Review-Url: https://codereview.webrtc.org/2537243004 Cr-Commit-Position: refs/heads/master@{#15312} --- .../audio_coding/acm2/audio_coding_module.cc | 10 ++- .../audio_coding/codecs/audio_encoder.cc | 12 ++- .../audio_coding/codecs/audio_encoder.h | 12 ++- .../codecs/cng/audio_encoder_cng.cc | 19 ++--- .../codecs/cng/audio_encoder_cng.h | 5 +- .../codecs/cng/audio_encoder_cng_unittest.cc | 12 +-- .../codecs/mock/mock_audio_encoder.h | 6 +- .../codecs/opus/audio_encoder_opus.cc | 70 +++++++++--------- .../codecs/opus/audio_encoder_opus.h | 9 ++- .../opus/audio_encoder_opus_unittest.cc | 74 +++++++++---------- .../codecs/red/audio_encoder_copy_red.cc | 19 ++--- .../codecs/red/audio_encoder_copy_red.h | 5 +- .../red/audio_encoder_copy_red_unittest.cc | 12 +-- .../neteq/audio_decoder_unittest.cc | 2 +- 14 files changed, 137 insertions(+), 130 deletions(-) diff --git a/webrtc/modules/audio_coding/acm2/audio_coding_module.cc b/webrtc/modules/audio_coding/acm2/audio_coding_module.cc index fe3b252381..dd02964e90 100644 --- a/webrtc/modules/audio_coding/acm2/audio_coding_module.cc +++ b/webrtc/modules/audio_coding/acm2/audio_coding_module.cc @@ -407,6 +407,12 @@ class RawAudioEncoderWrapper final : public AudioEncoder { void SetMaxPlaybackRate(int frequency_hz) override { return enc_->SetMaxPlaybackRate(frequency_hz); } + void SetProjectedPacketLossRate(double fraction) override { + return enc_->SetProjectedPacketLossRate(fraction); + } + void SetTargetBitrate(int target_bps) override { + return enc_->SetTargetBitrate(target_bps); + } private: AudioEncoder* enc_; @@ -648,7 +654,7 @@ int AudioCodingModuleImpl::SendFrequency() const { void AudioCodingModuleImpl::SetBitRate(int bitrate_bps) { rtc::CritScope lock(&acm_crit_sect_); if (encoder_stack_) { - encoder_stack_->OnReceivedTargetAudioBitrate(bitrate_bps); + encoder_stack_->SetTargetBitrate(bitrate_bps); } } @@ -900,7 +906,7 @@ int AudioCodingModuleImpl::SetCodecFEC(bool enable_codec_fec) { int AudioCodingModuleImpl::SetPacketLossRate(int loss_rate) { rtc::CritScope lock(&acm_crit_sect_); if (HaveValidEncoder("SetPacketLossRate")) { - encoder_stack_->OnReceivedUplinkPacketLossFraction(loss_rate / 100.0); + encoder_stack_->SetProjectedPacketLossRate(loss_rate / 100.0); } return 0; } diff --git a/webrtc/modules/audio_coding/codecs/audio_encoder.cc b/webrtc/modules/audio_coding/codecs/audio_encoder.cc index 5be2c3e8df..956c4e086f 100644 --- a/webrtc/modules/audio_coding/codecs/audio_encoder.cc +++ b/webrtc/modules/audio_coding/codecs/audio_encoder.cc @@ -60,6 +60,10 @@ bool AudioEncoder::SetApplication(Application application) { void AudioEncoder::SetMaxPlaybackRate(int frequency_hz) {} +void AudioEncoder::SetProjectedPacketLossRate(double fraction) {} + +void AudioEncoder::SetTargetBitrate(int target_bps) {} + rtc::ArrayView> AudioEncoder::ReclaimContainedEncoders() { return nullptr; } @@ -73,9 +77,13 @@ void AudioEncoder::DisableAudioNetworkAdaptor() {} void AudioEncoder::OnReceivedUplinkBandwidth(int uplink_bandwidth_bps) {} void AudioEncoder::OnReceivedUplinkPacketLossFraction( - float uplink_packet_loss_fraction) {} + float uplink_packet_loss_fraction) { + SetProjectedPacketLossRate(uplink_packet_loss_fraction); +} -void AudioEncoder::OnReceivedTargetAudioBitrate(int target_audio_bitrate_bps) {} +void AudioEncoder::OnReceivedTargetAudioBitrate(int target_audio_bitrate_bps) { + SetTargetBitrate(target_audio_bitrate_bps); +} void AudioEncoder::OnReceivedRtt(int rtt_ms) {} diff --git a/webrtc/modules/audio_coding/codecs/audio_encoder.h b/webrtc/modules/audio_coding/codecs/audio_encoder.h index e164fb5065..2c8d9ce5ec 100644 --- a/webrtc/modules/audio_coding/codecs/audio_encoder.h +++ b/webrtc/modules/audio_coding/codecs/audio_encoder.h @@ -144,6 +144,17 @@ class AudioEncoder { // implementation does nothing. virtual void SetMaxPlaybackRate(int frequency_hz); + // Tells the encoder what the projected packet loss rate is. The rate is in + // the range [0.0, 1.0]. The encoder would typically use this information to + // adjust channel coding efforts, such as FEC. The default implementation + // does nothing. + virtual void SetProjectedPacketLossRate(double fraction); + + // Tells the encoder what average bitrate we'd like it to produce. The + // encoder is free to adjust or disregard the given bitrate (the default + // implementation does the latter). + virtual void SetTargetBitrate(int target_bps); + // Causes this encoder to let go of any other encoders it contains, and // returns a pointer to an array where they are stored (which is required to // live as long as this encoder). Unless the returned array is empty, you may @@ -164,7 +175,6 @@ class AudioEncoder { virtual void OnReceivedUplinkBandwidth(int uplink_bandwidth_bps); // Provides uplink packet loss fraction to this encoder to allow it to adapt. - // |uplink_packet_loss_fraction| is in the range [0.0, 1.0]. virtual void OnReceivedUplinkPacketLossFraction( float uplink_packet_loss_fraction); diff --git a/webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng.cc b/webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng.cc index 1beebd522d..fe1b9de683 100644 --- a/webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng.cc +++ b/webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng.cc @@ -179,22 +179,19 @@ void AudioEncoderCng::SetMaxPlaybackRate(int frequency_hz) { speech_encoder_->SetMaxPlaybackRate(frequency_hz); } +void AudioEncoderCng::SetProjectedPacketLossRate(double fraction) { + speech_encoder_->SetProjectedPacketLossRate(fraction); +} + +void AudioEncoderCng::SetTargetBitrate(int bits_per_second) { + speech_encoder_->SetTargetBitrate(bits_per_second); +} + rtc::ArrayView> AudioEncoderCng::ReclaimContainedEncoders() { return rtc::ArrayView>(&speech_encoder_, 1); } -void AudioEncoderCng::OnReceivedUplinkPacketLossFraction( - float uplink_packet_loss_fraction) { - speech_encoder_->OnReceivedUplinkPacketLossFraction( - uplink_packet_loss_fraction); -} - -void AudioEncoderCng::OnReceivedTargetAudioBitrate( - int target_audio_bitrate_bps) { - speech_encoder_->OnReceivedTargetAudioBitrate(target_audio_bitrate_bps); -} - AudioEncoder::EncodedInfo AudioEncoderCng::EncodePassive( size_t frames_to_encode, rtc::Buffer* encoded) { diff --git a/webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng.h b/webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng.h index 8cec52c394..a895e69de4 100644 --- a/webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng.h +++ b/webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng.h @@ -61,11 +61,10 @@ class AudioEncoderCng final : public AudioEncoder { bool SetDtx(bool enable) override; bool SetApplication(Application application) override; void SetMaxPlaybackRate(int frequency_hz) override; + void SetProjectedPacketLossRate(double fraction) override; + void SetTargetBitrate(int target_bps) override; rtc::ArrayView> ReclaimContainedEncoders() override; - void OnReceivedUplinkPacketLossFraction( - float uplink_packet_loss_fraction) override; - void OnReceivedTargetAudioBitrate(int target_audio_bitrate_bps) override; private: EncodedInfo EncodePassive(size_t frames_to_encode, diff --git a/webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng_unittest.cc b/webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng_unittest.cc index db58b0dcc3..ace217ea24 100644 --- a/webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng_unittest.cc +++ b/webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng_unittest.cc @@ -217,16 +217,16 @@ TEST_F(AudioEncoderCngTest, CheckFrameSizePropagation) { EXPECT_EQ(17U, cng_->Num10MsFramesInNextPacket()); } -TEST_F(AudioEncoderCngTest, CheckTargetAudioBitratePropagation) { +TEST_F(AudioEncoderCngTest, CheckChangeBitratePropagation) { CreateCng(MakeCngConfig()); - EXPECT_CALL(*mock_encoder_, OnReceivedTargetAudioBitrate(4711)); - cng_->OnReceivedTargetAudioBitrate(4711); + EXPECT_CALL(*mock_encoder_, SetTargetBitrate(4711)); + cng_->SetTargetBitrate(4711); } -TEST_F(AudioEncoderCngTest, CheckPacketLossFractionPropagation) { +TEST_F(AudioEncoderCngTest, CheckProjectedPacketLossRatePropagation) { CreateCng(MakeCngConfig()); - EXPECT_CALL(*mock_encoder_, OnReceivedUplinkPacketLossFraction(0.5)); - cng_->OnReceivedUplinkPacketLossFraction(0.5); + EXPECT_CALL(*mock_encoder_, SetProjectedPacketLossRate(0.5)); + cng_->SetProjectedPacketLossRate(0.5); } TEST_F(AudioEncoderCngTest, EncodeCallsVad) { diff --git a/webrtc/modules/audio_coding/codecs/mock/mock_audio_encoder.h b/webrtc/modules/audio_coding/codecs/mock/mock_audio_encoder.h index e277200f7e..66f82b22d5 100644 --- a/webrtc/modules/audio_coding/codecs/mock/mock_audio_encoder.h +++ b/webrtc/modules/audio_coding/codecs/mock/mock_audio_encoder.h @@ -39,12 +39,10 @@ class MockAudioEncoder : public AudioEncoder { MOCK_METHOD1(SetDtx, bool(bool enable)); MOCK_METHOD1(SetApplication, bool(Application application)); MOCK_METHOD1(SetMaxPlaybackRate, void(int frequency_hz)); + MOCK_METHOD1(SetProjectedPacketLossRate, void(double fraction)); + MOCK_METHOD1(SetTargetBitrate, void(int target_bps)); MOCK_METHOD1(SetMaxBitrate, void(int max_bps)); MOCK_METHOD1(SetMaxPayloadSize, void(int max_payload_size_bytes)); - MOCK_METHOD1(OnReceivedTargetAudioBitrate, - void(int target_audio_bitrate_bps)); - MOCK_METHOD1(OnReceivedUplinkPacketLossFraction, - void(float uplink_packet_loss_fraction)); // Note, we explicitly chose not to create a mock for the Encode method. MOCK_METHOD3(EncodeImpl, diff --git a/webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.cc b/webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.cc index 40ad595e5c..1dc312f5e9 100644 --- a/webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.cc +++ b/webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.cc @@ -56,18 +56,18 @@ AudioEncoderOpus::Config CreateConfig(const CodecInst& codec_inst) { // Additionally, to prevent toggling, margins are used, i.e., when jumping to // a loss rate from below, a higher threshold is used than jumping to the same // level from above. -float OptimizePacketLossRate(float new_loss_rate, float old_loss_rate) { - RTC_DCHECK_GE(new_loss_rate, 0.0f); - RTC_DCHECK_LE(new_loss_rate, 1.0f); - RTC_DCHECK_GE(old_loss_rate, 0.0f); - RTC_DCHECK_LE(old_loss_rate, 1.0f); - constexpr float kPacketLossRate20 = 0.20f; - constexpr float kPacketLossRate10 = 0.10f; - constexpr float kPacketLossRate5 = 0.05f; - constexpr float kPacketLossRate1 = 0.01f; - constexpr float kLossRate20Margin = 0.02f; - constexpr float kLossRate10Margin = 0.01f; - constexpr float kLossRate5Margin = 0.01f; +double OptimizePacketLossRate(double new_loss_rate, double old_loss_rate) { + RTC_DCHECK_GE(new_loss_rate, 0.0); + RTC_DCHECK_LE(new_loss_rate, 1.0); + RTC_DCHECK_GE(old_loss_rate, 0.0); + RTC_DCHECK_LE(old_loss_rate, 1.0); + const double kPacketLossRate20 = 0.20; + const double kPacketLossRate10 = 0.10; + const double kPacketLossRate5 = 0.05; + const double kPacketLossRate1 = 0.01; + const double kLossRate20Margin = 0.02; + const double kLossRate10Margin = 0.01; + const double kLossRate5Margin = 0.01; if (new_loss_rate >= kPacketLossRate20 + kLossRate20Margin * @@ -86,7 +86,7 @@ float OptimizePacketLossRate(float new_loss_rate, float old_loss_rate) { } else if (new_loss_rate >= kPacketLossRate1) { return kPacketLossRate1; } else { - return 0.0f; + return 0.0; } } @@ -259,6 +259,28 @@ void AudioEncoderOpus::SetMaxPlaybackRate(int frequency_hz) { RTC_CHECK(RecreateEncoderInstance(conf)); } +void AudioEncoderOpus::SetProjectedPacketLossRate(double fraction) { + double opt_loss_rate = OptimizePacketLossRate(fraction, packet_loss_rate_); + if (packet_loss_rate_ != opt_loss_rate) { + packet_loss_rate_ = opt_loss_rate; + RTC_CHECK_EQ( + 0, WebRtcOpus_SetPacketLossRate( + inst_, static_cast(packet_loss_rate_ * 100 + .5))); + } +} + +void AudioEncoderOpus::SetTargetBitrate(int bits_per_second) { + config_.bitrate_bps = rtc::Optional( + std::max(std::min(bits_per_second, kMaxBitrateBps), kMinBitrateBps)); + RTC_DCHECK(config_.IsOk()); + RTC_CHECK_EQ(0, WebRtcOpus_SetBitRate(inst_, config_.GetBitrateBps())); + const auto new_complexity = config_.GetNewComplexity(); + if (new_complexity && complexity_ != *new_complexity) { + complexity_ = *new_complexity; + RTC_CHECK_EQ(0, WebRtcOpus_SetComplexity(inst_, complexity_)); + } +} + bool AudioEncoderOpus::EnableAudioNetworkAdaptor( const std::string& config_string, const Clock* clock) { @@ -440,28 +462,6 @@ void AudioEncoderOpus::SetNumChannelsToEncode(size_t num_channels_to_encode) { num_channels_to_encode_ = num_channels_to_encode; } -void AudioEncoderOpus::SetProjectedPacketLossRate(float fraction) { - float opt_loss_rate = OptimizePacketLossRate(fraction, packet_loss_rate_); - if (packet_loss_rate_ != opt_loss_rate) { - packet_loss_rate_ = opt_loss_rate; - RTC_CHECK_EQ( - 0, WebRtcOpus_SetPacketLossRate( - inst_, static_cast(packet_loss_rate_ * 100 + .5))); - } -} - -void AudioEncoderOpus::SetTargetBitrate(int bits_per_second) { - config_.bitrate_bps = rtc::Optional( - std::max(std::min(bits_per_second, kMaxBitrateBps), kMinBitrateBps)); - RTC_DCHECK(config_.IsOk()); - RTC_CHECK_EQ(0, WebRtcOpus_SetBitRate(inst_, config_.GetBitrateBps())); - const auto new_complexity = config_.GetNewComplexity(); - if (new_complexity && complexity_ != *new_complexity) { - complexity_ = *new_complexity; - RTC_CHECK_EQ(0, WebRtcOpus_SetComplexity(inst_, complexity_)); - } -} - void AudioEncoderOpus::ApplyAudioNetworkAdaptor() { auto config = audio_network_adaptor_->GetEncoderRuntimeConfig(); // |audio_network_adaptor_| is supposed to be configured to output all diff --git a/webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.h b/webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.h index 4c4313c621..f30d657d13 100644 --- a/webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.h +++ b/webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.h @@ -102,6 +102,9 @@ class AudioEncoderOpus final : public AudioEncoder { bool SetApplication(Application application) override; void SetMaxPlaybackRate(int frequency_hz) override; + void SetProjectedPacketLossRate(double fraction) override; + void SetTargetBitrate(int target_bps) override; + bool EnableAudioNetworkAdaptor(const std::string& config_string, const Clock* clock) override; void DisableAudioNetworkAdaptor() override; @@ -117,7 +120,7 @@ class AudioEncoderOpus final : public AudioEncoder { } // Getters for testing. - float packet_loss_rate() const { return packet_loss_rate_; } + double packet_loss_rate() const { return packet_loss_rate_; } ApplicationMode application() const { return config_.application; } bool fec_enabled() const { return config_.fec_enabled; } size_t num_channels_to_encode() const { return num_channels_to_encode_; } @@ -137,15 +140,13 @@ class AudioEncoderOpus final : public AudioEncoder { bool RecreateEncoderInstance(const Config& config); void SetFrameLength(int frame_length_ms); void SetNumChannelsToEncode(size_t num_channels_to_encode); - void SetProjectedPacketLossRate(float fraction); - void SetTargetBitrate(int target_bps); void ApplyAudioNetworkAdaptor(); std::unique_ptr DefaultAudioNetworkAdaptorCreator( const std::string& config_string, const Clock* clock) const; Config config_; - float packet_loss_rate_; + double packet_loss_rate_; std::vector input_buffer_; OpusEncInst* inst_; uint32_t first_timestamp_in_buffer_; diff --git a/webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus_unittest.cc b/webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus_unittest.cc index f07279fac7..8e59f496d8 100644 --- a/webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus_unittest.cc +++ b/webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus_unittest.cc @@ -151,27 +151,26 @@ TEST(AudioEncoderOpusTest, ToggleDtx) { EXPECT_TRUE(states.encoder->SetDtx(false)); } -TEST(AudioEncoderOpusTest, - OnReceivedTargetAudioBitrateWithoutAudioNetworkAdaptor) { +TEST(AudioEncoderOpusTest, SetBitrate) { auto states = CreateCodec(1); // Constants are replicated from audio_states.encoderopus.cc. const int kMinBitrateBps = 500; const int kMaxBitrateBps = 512000; // Set a too low bitrate. - states.encoder->OnReceivedTargetAudioBitrate(kMinBitrateBps - 1); + states.encoder->SetTargetBitrate(kMinBitrateBps - 1); EXPECT_EQ(kMinBitrateBps, states.encoder->GetTargetBitrate()); // Set a too high bitrate. - states.encoder->OnReceivedTargetAudioBitrate(kMaxBitrateBps + 1); + states.encoder->SetTargetBitrate(kMaxBitrateBps + 1); EXPECT_EQ(kMaxBitrateBps, states.encoder->GetTargetBitrate()); // Set the minimum rate. - states.encoder->OnReceivedTargetAudioBitrate(kMinBitrateBps); + states.encoder->SetTargetBitrate(kMinBitrateBps); EXPECT_EQ(kMinBitrateBps, states.encoder->GetTargetBitrate()); // Set the maximum rate. - states.encoder->OnReceivedTargetAudioBitrate(kMaxBitrateBps); + states.encoder->SetTargetBitrate(kMaxBitrateBps); EXPECT_EQ(kMaxBitrateBps, states.encoder->GetTargetBitrate()); // Set rates from 1000 up to 32000 bps. for (int rate = 1000; rate <= 32000; rate += 1000) { - states.encoder->OnReceivedTargetAudioBitrate(rate); + states.encoder->SetTargetBitrate(rate); EXPECT_EQ(rate, states.encoder->GetTargetBitrate()); } } @@ -180,31 +179,24 @@ namespace { // Returns a vector with the n evenly-spaced numbers a, a + (b - a)/(n - 1), // ..., b. -std::vector IntervalSteps(float a, float b, size_t n) { - RTC_DCHECK_GT(n, 1u); - const float step = (b - a) / (n - 1); - std::vector points; - points.push_back(a); - for (size_t i = 1; i < n - 1; ++i) +std::vector IntervalSteps(double a, double b, size_t n) { + RTC_DCHECK_GT(n, 1); + const double step = (b - a) / (n - 1); + std::vector points; + for (size_t i = 0; i < n; ++i) points.push_back(a + i * step); - points.push_back(b); return points; } // Sets the packet loss rate to each number in the vector in turn, and verifies // that the loss rate as reported by the encoder is |expected_return| for all // of them. -void TestSetPacketLossRate(AudioEncoderOpusStates* states, - const std::vector& losses, - float expected_return) { - // |kSampleIntervalMs| is chosen to ease the calculation since - // 0.9999 ^ 184198 = 1e-8. Which minimizes the effect of - // PacketLossFractionSmoother used in AudioEncoderOpus. - constexpr int64_t kSampleIntervalMs = 184198; - for (float loss : losses) { - states->encoder->OnReceivedUplinkPacketLossFraction(loss); - states->simulated_clock->AdvanceTimeMilliseconds(kSampleIntervalMs); - EXPECT_FLOAT_EQ(expected_return, states->encoder->packet_loss_rate()); +void TestSetPacketLossRate(AudioEncoderOpus* encoder, + const std::vector& losses, + double expected_return) { + for (double loss : losses) { + encoder->SetProjectedPacketLossRate(loss); + EXPECT_DOUBLE_EQ(expected_return, encoder->packet_loss_rate()); } } @@ -212,23 +204,23 @@ void TestSetPacketLossRate(AudioEncoderOpusStates* states, TEST(AudioEncoderOpusTest, PacketLossRateOptimized) { auto states = CreateCodec(1); - auto I = [](float a, float b) { return IntervalSteps(a, b, 10); }; - constexpr float eps = 1e-8f; + auto I = [](double a, double b) { return IntervalSteps(a, b, 10); }; + const double eps = 1e-15; // Note that the order of the following calls is critical. // clang-format off - TestSetPacketLossRate(&states, I(0.00f , 0.01f - eps), 0.00f); - TestSetPacketLossRate(&states, I(0.01f + eps, 0.06f - eps), 0.01f); - TestSetPacketLossRate(&states, I(0.06f + eps, 0.11f - eps), 0.05f); - TestSetPacketLossRate(&states, I(0.11f + eps, 0.22f - eps), 0.10f); - TestSetPacketLossRate(&states, I(0.22f + eps, 1.00f ), 0.20f); + TestSetPacketLossRate(states.encoder.get(), I(0.00 , 0.01 - eps), 0.00); + TestSetPacketLossRate(states.encoder.get(), I(0.01 + eps, 0.06 - eps), 0.01); + TestSetPacketLossRate(states.encoder.get(), I(0.06 + eps, 0.11 - eps), 0.05); + TestSetPacketLossRate(states.encoder.get(), I(0.11 + eps, 0.22 - eps), 0.10); + TestSetPacketLossRate(states.encoder.get(), I(0.22 + eps, 1.00 ), 0.20); - TestSetPacketLossRate(&states, I(1.00f , 0.18f + eps), 0.20f); - TestSetPacketLossRate(&states, I(0.18f - eps, 0.09f + eps), 0.10f); - TestSetPacketLossRate(&states, I(0.09f - eps, 0.04f + eps), 0.05f); - TestSetPacketLossRate(&states, I(0.04f - eps, 0.01f + eps), 0.01f); - TestSetPacketLossRate(&states, I(0.01f - eps, 0.00f ), 0.00f); + TestSetPacketLossRate(states.encoder.get(), I(1.00 , 0.18 + eps), 0.20); + TestSetPacketLossRate(states.encoder.get(), I(0.18 - eps, 0.09 + eps), 0.10); + TestSetPacketLossRate(states.encoder.get(), I(0.09 - eps, 0.04 + eps), 0.05); + TestSetPacketLossRate(states.encoder.get(), I(0.04 - eps, 0.01 + eps), 0.01); + TestSetPacketLossRate(states.encoder.get(), I(0.01 - eps, 0.00 ), 0.00); // clang-format on } @@ -325,13 +317,13 @@ TEST(AudioEncoderOpusTest, // will fail. constexpr float kPacketLossFraction_1 = 0.02f; constexpr float kPacketLossFraction_2 = 0.198f; - // |kSecondSampleTimeMs| is chosen to ease the calculation since + // |kSecondSampleTimeMs| is chose to ease the calculation since // 0.9999 ^ 6931 = 0.5. - constexpr int64_t kSecondSampleTimeMs = 6931; + constexpr float kSecondSampleTimeMs = 6931; // First time, no filtering. states.encoder->OnReceivedUplinkPacketLossFraction(kPacketLossFraction_1); - EXPECT_FLOAT_EQ(0.01f, states.encoder->packet_loss_rate()); + EXPECT_DOUBLE_EQ(0.01, states.encoder->packet_loss_rate()); states.simulated_clock->AdvanceTimeMilliseconds(kSecondSampleTimeMs); states.encoder->OnReceivedUplinkPacketLossFraction(kPacketLossFraction_2); @@ -340,7 +332,7 @@ TEST(AudioEncoderOpusTest, // (0.02 + 0.198) / 2 = 0.109, which reach the threshold for the optimized // packet loss rate to increase to 0.05. If no smoothing has been made, the // optimized packet loss rate should have been increase to 0.1. - EXPECT_FLOAT_EQ(0.05f, states.encoder->packet_loss_rate()); + EXPECT_DOUBLE_EQ(0.05, states.encoder->packet_loss_rate()); } } // namespace webrtc diff --git a/webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red.cc b/webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red.cc index 51b706490b..07db78c911 100644 --- a/webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red.cc +++ b/webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red.cc @@ -115,20 +115,17 @@ void AudioEncoderCopyRed::SetMaxPlaybackRate(int frequency_hz) { speech_encoder_->SetMaxPlaybackRate(frequency_hz); } +void AudioEncoderCopyRed::SetProjectedPacketLossRate(double fraction) { + speech_encoder_->SetProjectedPacketLossRate(fraction); +} + +void AudioEncoderCopyRed::SetTargetBitrate(int bits_per_second) { + speech_encoder_->SetTargetBitrate(bits_per_second); +} + rtc::ArrayView> AudioEncoderCopyRed::ReclaimContainedEncoders() { return rtc::ArrayView>(&speech_encoder_, 1); } -void AudioEncoderCopyRed::OnReceivedUplinkPacketLossFraction( - float uplink_packet_loss_fraction) { - speech_encoder_->OnReceivedUplinkPacketLossFraction( - uplink_packet_loss_fraction); -} - -void AudioEncoderCopyRed::OnReceivedTargetAudioBitrate( - int target_audio_bitrate_bps) { - speech_encoder_->OnReceivedTargetAudioBitrate(target_audio_bitrate_bps); -} - } // namespace webrtc diff --git a/webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red.h b/webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red.h index d069cbef15..a08118364c 100644 --- a/webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red.h +++ b/webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red.h @@ -49,11 +49,10 @@ class AudioEncoderCopyRed final : public AudioEncoder { bool SetDtx(bool enable) override; bool SetApplication(Application application) override; void SetMaxPlaybackRate(int frequency_hz) override; + void SetProjectedPacketLossRate(double fraction) override; + void SetTargetBitrate(int target_bps) override; rtc::ArrayView> ReclaimContainedEncoders() override; - void OnReceivedUplinkPacketLossFraction( - float uplink_packet_loss_fraction) override; - void OnReceivedTargetAudioBitrate(int target_audio_bitrate_bps) override; protected: EncodedInfo EncodeImpl(uint32_t rtp_timestamp, diff --git a/webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red_unittest.cc b/webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red_unittest.cc index 8cf02f18d4..55097929a6 100644 --- a/webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red_unittest.cc +++ b/webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red_unittest.cc @@ -97,14 +97,14 @@ TEST_F(AudioEncoderCopyRedTest, CheckMaxFrameSizePropagation) { EXPECT_EQ(17U, red_->Max10MsFramesInAPacket()); } -TEST_F(AudioEncoderCopyRedTest, CheckTargetAudioBitratePropagation) { - EXPECT_CALL(*mock_encoder_, OnReceivedTargetAudioBitrate(4711)); - red_->OnReceivedTargetAudioBitrate(4711); +TEST_F(AudioEncoderCopyRedTest, CheckSetBitratePropagation) { + EXPECT_CALL(*mock_encoder_, SetTargetBitrate(4711)); + red_->SetTargetBitrate(4711); } -TEST_F(AudioEncoderCopyRedTest, CheckPacketLossFractionPropagation) { - EXPECT_CALL(*mock_encoder_, OnReceivedUplinkPacketLossFraction(0.5)); - red_->OnReceivedUplinkPacketLossFraction(0.5); +TEST_F(AudioEncoderCopyRedTest, CheckProjectedPacketLossRatePropagation) { + EXPECT_CALL(*mock_encoder_, SetProjectedPacketLossRate(0.5)); + red_->SetProjectedPacketLossRate(0.5); } // Checks that the an Encode() call is immediately propagated to the speech diff --git a/webrtc/modules/audio_coding/neteq/audio_decoder_unittest.cc b/webrtc/modules/audio_coding/neteq/audio_decoder_unittest.cc index 0dd76dadf5..3ff629ac89 100644 --- a/webrtc/modules/audio_coding/neteq/audio_decoder_unittest.cc +++ b/webrtc/modules/audio_coding/neteq/audio_decoder_unittest.cc @@ -469,7 +469,7 @@ TEST_F(AudioDecoderPcmUTest, EncodeDecode) { namespace { int SetAndGetTargetBitrate(AudioEncoder* audio_encoder, int rate) { - audio_encoder->OnReceivedTargetAudioBitrate(rate); + audio_encoder->SetTargetBitrate(rate); return audio_encoder->GetTargetBitrate(); } void TestSetAndGetTargetBitratesWithFixedCodec(AudioEncoder* audio_encoder,