diff --git a/webrtc/modules/audio_coding/acm2/audio_coding_module.cc b/webrtc/modules/audio_coding/acm2/audio_coding_module.cc index dd02964e90..fe3b252381 100644 --- a/webrtc/modules/audio_coding/acm2/audio_coding_module.cc +++ b/webrtc/modules/audio_coding/acm2/audio_coding_module.cc @@ -407,12 +407,6 @@ 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_; @@ -654,7 +648,7 @@ int AudioCodingModuleImpl::SendFrequency() const { void AudioCodingModuleImpl::SetBitRate(int bitrate_bps) { rtc::CritScope lock(&acm_crit_sect_); if (encoder_stack_) { - encoder_stack_->SetTargetBitrate(bitrate_bps); + encoder_stack_->OnReceivedTargetAudioBitrate(bitrate_bps); } } @@ -906,7 +900,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_->SetProjectedPacketLossRate(loss_rate / 100.0); + encoder_stack_->OnReceivedUplinkPacketLossFraction(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 956c4e086f..5be2c3e8df 100644 --- a/webrtc/modules/audio_coding/codecs/audio_encoder.cc +++ b/webrtc/modules/audio_coding/codecs/audio_encoder.cc @@ -60,10 +60,6 @@ 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; } @@ -77,13 +73,9 @@ void AudioEncoder::DisableAudioNetworkAdaptor() {} void AudioEncoder::OnReceivedUplinkBandwidth(int uplink_bandwidth_bps) {} void AudioEncoder::OnReceivedUplinkPacketLossFraction( - float uplink_packet_loss_fraction) { - SetProjectedPacketLossRate(uplink_packet_loss_fraction); -} + float uplink_packet_loss_fraction) {} -void AudioEncoder::OnReceivedTargetAudioBitrate(int target_audio_bitrate_bps) { - SetTargetBitrate(target_audio_bitrate_bps); -} +void AudioEncoder::OnReceivedTargetAudioBitrate(int 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 2c8d9ce5ec..e164fb5065 100644 --- a/webrtc/modules/audio_coding/codecs/audio_encoder.h +++ b/webrtc/modules/audio_coding/codecs/audio_encoder.h @@ -144,17 +144,6 @@ 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 @@ -175,6 +164,7 @@ 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 fe1b9de683..1beebd522d 100644 --- a/webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng.cc +++ b/webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng.cc @@ -179,19 +179,22 @@ 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 a895e69de4..8cec52c394 100644 --- a/webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng.h +++ b/webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng.h @@ -61,10 +61,11 @@ 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 ace217ea24..db58b0dcc3 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, CheckChangeBitratePropagation) { +TEST_F(AudioEncoderCngTest, CheckTargetAudioBitratePropagation) { CreateCng(MakeCngConfig()); - EXPECT_CALL(*mock_encoder_, SetTargetBitrate(4711)); - cng_->SetTargetBitrate(4711); + EXPECT_CALL(*mock_encoder_, OnReceivedTargetAudioBitrate(4711)); + cng_->OnReceivedTargetAudioBitrate(4711); } -TEST_F(AudioEncoderCngTest, CheckProjectedPacketLossRatePropagation) { +TEST_F(AudioEncoderCngTest, CheckPacketLossFractionPropagation) { CreateCng(MakeCngConfig()); - EXPECT_CALL(*mock_encoder_, SetProjectedPacketLossRate(0.5)); - cng_->SetProjectedPacketLossRate(0.5); + EXPECT_CALL(*mock_encoder_, OnReceivedUplinkPacketLossFraction(0.5)); + cng_->OnReceivedUplinkPacketLossFraction(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 66f82b22d5..e277200f7e 100644 --- a/webrtc/modules/audio_coding/codecs/mock/mock_audio_encoder.h +++ b/webrtc/modules/audio_coding/codecs/mock/mock_audio_encoder.h @@ -39,10 +39,12 @@ 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 1dc312f5e9..40ad595e5c 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. -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; +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; if (new_loss_rate >= kPacketLossRate20 + kLossRate20Margin * @@ -86,7 +86,7 @@ double OptimizePacketLossRate(double new_loss_rate, double old_loss_rate) { } else if (new_loss_rate >= kPacketLossRate1) { return kPacketLossRate1; } else { - return 0.0; + return 0.0f; } } @@ -259,28 +259,6 @@ 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) { @@ -462,6 +440,28 @@ 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 f30d657d13..4c4313c621 100644 --- a/webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.h +++ b/webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.h @@ -102,9 +102,6 @@ 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; @@ -120,7 +117,7 @@ class AudioEncoderOpus final : public AudioEncoder { } // Getters for testing. - double packet_loss_rate() const { return packet_loss_rate_; } + float 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_; } @@ -140,13 +137,15 @@ 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_; - double packet_loss_rate_; + float 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 8e59f496d8..f07279fac7 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,26 +151,27 @@ TEST(AudioEncoderOpusTest, ToggleDtx) { EXPECT_TRUE(states.encoder->SetDtx(false)); } -TEST(AudioEncoderOpusTest, SetBitrate) { +TEST(AudioEncoderOpusTest, + OnReceivedTargetAudioBitrateWithoutAudioNetworkAdaptor) { 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->SetTargetBitrate(kMinBitrateBps - 1); + states.encoder->OnReceivedTargetAudioBitrate(kMinBitrateBps - 1); EXPECT_EQ(kMinBitrateBps, states.encoder->GetTargetBitrate()); // Set a too high bitrate. - states.encoder->SetTargetBitrate(kMaxBitrateBps + 1); + states.encoder->OnReceivedTargetAudioBitrate(kMaxBitrateBps + 1); EXPECT_EQ(kMaxBitrateBps, states.encoder->GetTargetBitrate()); // Set the minimum rate. - states.encoder->SetTargetBitrate(kMinBitrateBps); + states.encoder->OnReceivedTargetAudioBitrate(kMinBitrateBps); EXPECT_EQ(kMinBitrateBps, states.encoder->GetTargetBitrate()); // Set the maximum rate. - states.encoder->SetTargetBitrate(kMaxBitrateBps); + states.encoder->OnReceivedTargetAudioBitrate(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->SetTargetBitrate(rate); + states.encoder->OnReceivedTargetAudioBitrate(rate); EXPECT_EQ(rate, states.encoder->GetTargetBitrate()); } } @@ -179,24 +180,31 @@ namespace { // Returns a vector with the n evenly-spaced numbers a, a + (b - a)/(n - 1), // ..., b. -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) +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) 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(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()); +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()); } } @@ -204,23 +212,23 @@ void TestSetPacketLossRate(AudioEncoderOpus* encoder, TEST(AudioEncoderOpusTest, PacketLossRateOptimized) { auto states = CreateCodec(1); - auto I = [](double a, double b) { return IntervalSteps(a, b, 10); }; - const double eps = 1e-15; + auto I = [](float a, float b) { return IntervalSteps(a, b, 10); }; + constexpr float eps = 1e-8f; // Note that the order of the following calls is critical. // clang-format off - 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(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(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); + 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); // clang-format on } @@ -317,13 +325,13 @@ TEST(AudioEncoderOpusTest, // will fail. constexpr float kPacketLossFraction_1 = 0.02f; constexpr float kPacketLossFraction_2 = 0.198f; - // |kSecondSampleTimeMs| is chose to ease the calculation since + // |kSecondSampleTimeMs| is chosen to ease the calculation since // 0.9999 ^ 6931 = 0.5. - constexpr float kSecondSampleTimeMs = 6931; + constexpr int64_t kSecondSampleTimeMs = 6931; // First time, no filtering. states.encoder->OnReceivedUplinkPacketLossFraction(kPacketLossFraction_1); - EXPECT_DOUBLE_EQ(0.01, states.encoder->packet_loss_rate()); + EXPECT_FLOAT_EQ(0.01f, states.encoder->packet_loss_rate()); states.simulated_clock->AdvanceTimeMilliseconds(kSecondSampleTimeMs); states.encoder->OnReceivedUplinkPacketLossFraction(kPacketLossFraction_2); @@ -332,7 +340,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_DOUBLE_EQ(0.05, states.encoder->packet_loss_rate()); + EXPECT_FLOAT_EQ(0.05f, 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 07db78c911..51b706490b 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,17 +115,20 @@ 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 a08118364c..d069cbef15 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,10 +49,11 @@ 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 55097929a6..8cf02f18d4 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, CheckSetBitratePropagation) { - EXPECT_CALL(*mock_encoder_, SetTargetBitrate(4711)); - red_->SetTargetBitrate(4711); +TEST_F(AudioEncoderCopyRedTest, CheckTargetAudioBitratePropagation) { + EXPECT_CALL(*mock_encoder_, OnReceivedTargetAudioBitrate(4711)); + red_->OnReceivedTargetAudioBitrate(4711); } -TEST_F(AudioEncoderCopyRedTest, CheckProjectedPacketLossRatePropagation) { - EXPECT_CALL(*mock_encoder_, SetProjectedPacketLossRate(0.5)); - red_->SetProjectedPacketLossRate(0.5); +TEST_F(AudioEncoderCopyRedTest, CheckPacketLossFractionPropagation) { + EXPECT_CALL(*mock_encoder_, OnReceivedUplinkPacketLossFraction(0.5)); + red_->OnReceivedUplinkPacketLossFraction(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 3ff629ac89..0dd76dadf5 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->SetTargetBitrate(rate); + audio_encoder->OnReceivedTargetAudioBitrate(rate); return audio_encoder->GetTargetBitrate(); } void TestSetAndGetTargetBitratesWithFixedCodec(AudioEncoder* audio_encoder,