zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove WebRTC-Audio-NewOpusPacketLossRateOptimization.

Browse Source 
This field trial is unused.

Bug: webrtc:11503
Change-Id: I34262ea4ab169479ceded820c1aa309981731f1b
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/173338
Commit-Queue: Mirko Bonadei <mbonadei@webrtc.org>
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31059}
This commit is contained in:
Mirko Bonadei
2020-04-11 14:04:31 +02:00
committed by Commit Bot
parent 39fb817efd
commit 9621377730
3 changed files with 2 additions and 123 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
modules/audio_coding/codecs/opus/audio_encoder_opus.cc
View File

@ -230,32 +230,6 @@ float GetMinPacketLossRate() {
return 0.0;
}
std::unique_ptr<AudioEncoderOpusImpl::NewPacketLossRateOptimizer>
GetNewPacketLossRateOptimizer() {
constexpr char kPacketLossOptimizationName[] =
"WebRTC-Audio-NewOpusPacketLossRateOptimization";
const bool use_new_packet_loss_optimization =
webrtc::field_trial::IsEnabled(kPacketLossOptimizationName);
if (use_new_packet_loss_optimization) {
const std::string field_trial_string =
webrtc::field_trial::FindFullName(kPacketLossOptimizationName);
int min_rate;
int max_rate;
float slope;
if (sscanf(field_trial_string.c_str(), "Enabled-%d-%d-%f", &min_rate,
&max_rate, &slope) == 3 &&
IsValidPacketLossRate(min_rate) && IsValidPacketLossRate(max_rate)) {
return std::make_unique<AudioEncoderOpusImpl::NewPacketLossRateOptimizer>(
ToFraction(min_rate), ToFraction(max_rate), slope);
}
RTC_LOG(LS_WARNING) << "Invalid parameters for "
<< kPacketLossOptimizationName
<< ", using default values.";
return std::make_unique<AudioEncoderOpusImpl::NewPacketLossRateOptimizer>();
}
return nullptr;
}
std::vector<float> GetBitrateMultipliers() {
constexpr char kBitrateMultipliersName[] =
"WebRTC-Audio-OpusBitrateMultipliers";
@ -298,21 +272,6 @@ int GetMultipliedBitrate(int bitrate, const std::vector<float>& multipliers) {
}
} // namespace
AudioEncoderOpusImpl::NewPacketLossRateOptimizer::NewPacketLossRateOptimizer(
float min_packet_loss_rate,
float max_packet_loss_rate,
float slope)
: min_packet_loss_rate_(min_packet_loss_rate),
max_packet_loss_rate_(max_packet_loss_rate),
slope_(slope) {}
float AudioEncoderOpusImpl::NewPacketLossRateOptimizer::OptimizePacketLossRate(
float packet_loss_rate) const {
packet_loss_rate = slope_ * packet_loss_rate;
return std::min(std::max(packet_loss_rate, min_packet_loss_rate_),
max_packet_loss_rate_);
}
void AudioEncoderOpusImpl::AppendSupportedEncoders(
std::vector<AudioCodecSpec>* specs) {
const SdpAudioFormat fmt = {"opus",
@ -474,7 +433,6 @@ AudioEncoderOpusImpl::AudioEncoderOpusImpl(
bitrate_multipliers_(GetBitrateMultipliers()),
packet_loss_rate_(0.0),
min_packet_loss_rate_(GetMinPacketLossRate()),
new_packet_loss_optimizer_(GetNewPacketLossRateOptimizer()),
inst_(nullptr),
packet_loss_fraction_smoother_(new PacketLossFractionSmoother()),
audio_network_adaptor_creator_(audio_network_adaptor_creator),
@ -831,12 +789,8 @@ void AudioEncoderOpusImpl::SetNumChannelsToEncode(
}
void AudioEncoderOpusImpl::SetProjectedPacketLossRate(float fraction) {
if (new_packet_loss_optimizer_) {
fraction = new_packet_loss_optimizer_->OptimizePacketLossRate(fraction);
} else {
fraction = OptimizePacketLossRate(fraction, packet_loss_rate_);
fraction = std::max(fraction, min_packet_loss_rate_);
}
fraction = OptimizePacketLossRate(fraction, packet_loss_rate_);
fraction = std::max(fraction, min_packet_loss_rate_);
if (packet_loss_rate_ != fraction) {
packet_loss_rate_ = fraction;
RTC_CHECK_EQ(

24
modules/audio_coding/codecs/opus/audio_encoder_opus.h
View File

@ -31,26 +31,6 @@ class RtcEventLog;
class AudioEncoderOpusImpl final : public AudioEncoder {
public:
class NewPacketLossRateOptimizer {
public:
NewPacketLossRateOptimizer(float min_packet_loss_rate = 0.01,
float max_packet_loss_rate = 0.2,
float slope = 1.0);
float OptimizePacketLossRate(float packet_loss_rate) const;
// Getters for testing.
float min_packet_loss_rate() const { return min_packet_loss_rate_; }
float max_packet_loss_rate() const { return max_packet_loss_rate_; }
float slope() const { return slope_; }
private:
const float min_packet_loss_rate_;
const float max_packet_loss_rate_;
const float slope_;
RTC_DISALLOW_COPY_AND_ASSIGN(NewPacketLossRateOptimizer);
};
// Returns empty if the current bitrate falls within the hysteresis window,
// defined by complexity_threshold_bps +/- complexity_threshold_window_bps.
// Otherwise, returns the current complexity depending on whether the
@ -122,9 +102,6 @@ class AudioEncoderOpusImpl final : public AudioEncoder {
// Getters for testing.
float packet_loss_rate() const { return packet_loss_rate_; }
NewPacketLossRateOptimizer* new_packet_loss_optimizer() const {
return new_packet_loss_optimizer_.get();
}
AudioEncoderOpusConfig::ApplicationMode application() const {
return config_.application;
}
@ -184,7 +161,6 @@ class AudioEncoderOpusImpl final : public AudioEncoder {
std::vector<float> bitrate_multipliers_;
float packet_loss_rate_;
const float min_packet_loss_rate_;
const std::unique_ptr<NewPacketLossRateOptimizer> new_packet_loss_optimizer_;
std::vector<int16_t> input_buffer_;
OpusEncInst* inst_;
uint32_t first_timestamp_in_buffer_;

51
modules/audio_coding/codecs/opus/audio_encoder_opus_unittest.cc
View File

@ -300,29 +300,6 @@ TEST_P(AudioEncoderOpusTest, PacketLossRateLowerBounded) {
// clang-format on
}
TEST_P(AudioEncoderOpusTest, NewPacketLossRateOptimization) {
{
test::ScopedFieldTrials override_field_trials(
"WebRTC-Audio-NewOpusPacketLossRateOptimization/Enabled-5-15-0.5/");
auto states = CreateCodec(sample_rate_hz_, 1);
TestSetPacketLossRate(states.get(), {0.00f}, 0.05f);
TestSetPacketLossRate(states.get(), {0.12f}, 0.06f);
TestSetPacketLossRate(states.get(), {0.22f}, 0.11f);
TestSetPacketLossRate(states.get(), {0.50f}, 0.15f);
}
{
test::ScopedFieldTrials override_field_trials(
"WebRTC-Audio-NewOpusPacketLossRateOptimization/Enabled/");
auto states = CreateCodec(sample_rate_hz_, 1);
TestSetPacketLossRate(states.get(), {0.00f}, 0.01f);
TestSetPacketLossRate(states.get(), {0.12f}, 0.12f);
TestSetPacketLossRate(states.get(), {0.22f}, 0.20f);
TestSetPacketLossRate(states.get(), {0.50f}, 0.20f);
}
}
TEST_P(AudioEncoderOpusTest, SetReceiverFrameLengthRange) {
auto states = CreateCodec(sample_rate_hz_, 2);
// Before calling to |SetReceiverFrameLengthRange|,
@ -523,34 +500,6 @@ TEST_P(AudioEncoderOpusTest, MinPacketLossRate) {
}
}
TEST_P(AudioEncoderOpusTest, NewPacketLossRateOptimizer) {
{
auto states = CreateCodec(sample_rate_hz_, 1);
auto optimizer = states->encoder->new_packet_loss_optimizer();
EXPECT_EQ(nullptr, optimizer);
}
{
test::ScopedFieldTrials override_field_trials(
"WebRTC-Audio-NewOpusPacketLossRateOptimization/Enabled/");
auto states = CreateCodec(sample_rate_hz_, 1);
auto optimizer = states->encoder->new_packet_loss_optimizer();
ASSERT_NE(nullptr, optimizer);
EXPECT_FLOAT_EQ(0.01, optimizer->min_packet_loss_rate());
EXPECT_FLOAT_EQ(0.20, optimizer->max_packet_loss_rate());
EXPECT_FLOAT_EQ(1.00, optimizer->slope());
}
{
test::ScopedFieldTrials override_field_trials(
"WebRTC-Audio-NewOpusPacketLossRateOptimization/Enabled-2-50-0.7/");
auto states = CreateCodec(sample_rate_hz_, 1);
auto optimizer = states->encoder->new_packet_loss_optimizer();
ASSERT_NE(nullptr, optimizer);
EXPECT_FLOAT_EQ(0.02, optimizer->min_packet_loss_rate());
EXPECT_FLOAT_EQ(0.50, optimizer->max_packet_loss_rate());
EXPECT_FLOAT_EQ(0.70, optimizer->slope());
}
}
// Verifies that the complexity adaptation in the config works as intended.
TEST(AudioEncoderOpusTest, ConfigComplexityAdaptation) {
AudioEncoderOpusConfig config;