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}
diff --git a/webrtc/modules/audio_coding/acm2/audio_coding_module.cc b/webrtc/modules/audio_coding/acm2/audio_coding_module.cc
index fe3b252..dd02964 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 @@
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 @@
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::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 5be2c3e..956c4e0 100644
--- a/webrtc/modules/audio_coding/codecs/audio_encoder.cc
+++ b/webrtc/modules/audio_coding/codecs/audio_encoder.cc
@@ -60,6 +60,10 @@
void AudioEncoder::SetMaxPlaybackRate(int frequency_hz) {}
+void AudioEncoder::SetProjectedPacketLossRate(double fraction) {}
+
+void AudioEncoder::SetTargetBitrate(int target_bps) {}
+
rtc::ArrayView<std::unique_ptr<AudioEncoder>>
AudioEncoder::ReclaimContainedEncoders() { return nullptr; }
@@ -73,9 +77,13 @@
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 e164fb5..2c8d9ce 100644
--- a/webrtc/modules/audio_coding/codecs/audio_encoder.h
+++ b/webrtc/modules/audio_coding/codecs/audio_encoder.h
@@ -144,6 +144,17 @@
// 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 @@
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 1beebd5..fe1b9de 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 @@
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<std::unique_ptr<AudioEncoder>>
AudioEncoderCng::ReclaimContainedEncoders() {
return rtc::ArrayView<std::unique_ptr<AudioEncoder>>(&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 8cec52c..a895e69 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 @@
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<std::unique_ptr<AudioEncoder>> 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 db58b0d..ace217e 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 @@
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 e277200..66f82b2 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 @@
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 40ad595..1dc312f 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 @@
// 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 @@
} else if (new_loss_rate >= kPacketLossRate1) {
return kPacketLossRate1;
} else {
- return 0.0f;
+ return 0.0;
}
}
@@ -259,6 +259,28 @@
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<int32_t>(packet_loss_rate_ * 100 + .5)));
+ }
+}
+
+void AudioEncoderOpus::SetTargetBitrate(int bits_per_second) {
+ config_.bitrate_bps = rtc::Optional<int>(
+ 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 @@
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<int32_t>(packet_loss_rate_ * 100 + .5)));
- }
-}
-
-void AudioEncoderOpus::SetTargetBitrate(int bits_per_second) {
- config_.bitrate_bps = rtc::Optional<int>(
- 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 4c4313c..f30d657 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 @@
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 @@
}
// 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 @@
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<AudioNetworkAdaptor> DefaultAudioNetworkAdaptorCreator(
const std::string& config_string,
const Clock* clock) const;
Config config_;
- float packet_loss_rate_;
+ double packet_loss_rate_;
std::vector<int16_t> 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 f07279f..8e59f49 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 @@
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 @@
// Returns a vector with the n evenly-spaced numbers a, a + (b - a)/(n - 1),
// ..., b.
-std::vector<float> IntervalSteps(float a, float b, size_t n) {
- RTC_DCHECK_GT(n, 1u);
- const float step = (b - a) / (n - 1);
- std::vector<float> points;
- points.push_back(a);
- for (size_t i = 1; i < n - 1; ++i)
+std::vector<double> IntervalSteps(double a, double b, size_t n) {
+ RTC_DCHECK_GT(n, 1);
+ const double step = (b - a) / (n - 1);
+ std::vector<double> 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<float>& 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<double>& losses,
+ double expected_return) {
+ for (double loss : losses) {
+ encoder->SetProjectedPacketLossRate(loss);
+ EXPECT_DOUBLE_EQ(expected_return, encoder->packet_loss_rate());
}
}
@@ -212,23 +204,23 @@
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 @@
// 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 @@
// (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 51b7064..07db78c 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 @@
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<std::unique_ptr<AudioEncoder>>
AudioEncoderCopyRed::ReclaimContainedEncoders() {
return rtc::ArrayView<std::unique_ptr<AudioEncoder>>(&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 d069cbe..a081183 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 @@
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<std::unique_ptr<AudioEncoder>> 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 8cf02f1..5509792 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 @@
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 0dd76da..3ff629a 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 @@
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,