admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove packet loss rate optimization and minimum field trial.

Browse Source 
Bug: webrtc:11664
Change-Id: I63fab70e5ae85e2971bed4998ab3b15f61f9e1c0
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176752
Reviewed-by: Minyue Li <minyue@webrtc.org>
Commit-Queue: Jakob Ivarsson <jakobi@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31480}
This commit is contained in:
Jakob Ivarsson 2020-06-09 16:05:42 +02:00 committed by Commit Bot
parent 2d27b1ab0c
commit 7649006692
3 changed files with 12 additions and 179 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -66,46 +66,7 @@ constexpr int kOpusSupportedFrameLengths[] = {10, 20, 40, 60};
// PacketLossFractionSmoother uses an exponential filter with a time constant
// of -1.0 / ln(0.9999) = 10000 ms.
constexpr float kAlphaForPacketLossFractionSmoother = 0.9999f;
// Optimize the loss rate to configure Opus. Basically, optimized loss rate is
// the input loss rate rounded down to various levels, because a robustly good
// audio quality is achieved by lowering the packet loss down.
// 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;
if (new_loss_rate >=
kPacketLossRate20 +
kLossRate20Margin *
(kPacketLossRate20 - old_loss_rate > 0 ? 1 : -1)) {
return kPacketLossRate20;
} else if (new_loss_rate >=
kPacketLossRate10 +
kLossRate10Margin *
(kPacketLossRate10 - old_loss_rate > 0 ? 1 : -1)) {
return kPacketLossRate10;
} else if (new_loss_rate >=
kPacketLossRate5 +
kLossRate5Margin *
(kPacketLossRate5 - old_loss_rate > 0 ? 1 : -1)) {
return kPacketLossRate5;
} else if (new_loss_rate >= kPacketLossRate1) {
return kPacketLossRate1;
} else {
return 0.0f;
}
}
constexpr float kMaxPacketLossFraction = 0.2f;
int CalculateDefaultBitrate(int max_playback_rate, size_t num_channels) {
const int bitrate = [&] {
@ -201,35 +162,6 @@ int GetBitrateBps(const AudioEncoderOpusConfig& config) {
return *config.bitrate_bps;
}
bool IsValidPacketLossRate(int value) {
return value >= 0 && value <= 100;
}
float ToFraction(int percent) {
return static_cast<float>(percent) / 100;
}
float GetMinPacketLossRate() {
constexpr char kPacketLossFieldTrial[] = "WebRTC-Audio-OpusMinPacketLossRate";
const bool use_opus_min_packet_loss_rate =
webrtc::field_trial::IsEnabled(kPacketLossFieldTrial);
if (use_opus_min_packet_loss_rate) {
const std::string field_trial_string =
webrtc::field_trial::FindFullName(kPacketLossFieldTrial);
constexpr int kDefaultMinPacketLossRate = 1;
int value = kDefaultMinPacketLossRate;
if (sscanf(field_trial_string.c_str(), "Enabled-%d", &value) == 1 &&
!IsValidPacketLossRate(value)) {
RTC_LOG(LS_WARNING) << "Invalid parameter for " << kPacketLossFieldTrial
<< ", using default value: "
<< kDefaultMinPacketLossRate;
value = kDefaultMinPacketLossRate;
}
return ToFraction(value);
}
return 0.0;
}
std::vector<float> GetBitrateMultipliers() {
constexpr char kBitrateMultipliersName[] =
"WebRTC-Audio-OpusBitrateMultipliers";
@ -432,7 +364,6 @@ AudioEncoderOpusImpl::AudioEncoderOpusImpl(
bitrate_changed_(true),
bitrate_multipliers_(GetBitrateMultipliers()),
packet_loss_rate_(0.0),
min_packet_loss_rate_(GetMinPacketLossRate()),
inst_(nullptr),
packet_loss_fraction_smoother_(new PacketLossFractionSmoother()),
audio_network_adaptor_creator_(audio_network_adaptor_creator),
@ -789,8 +720,7 @@ void AudioEncoderOpusImpl::SetNumChannelsToEncode(
}
void AudioEncoderOpusImpl::SetProjectedPacketLossRate(float fraction) {
fraction = OptimizePacketLossRate(fraction, packet_loss_rate_);
fraction = std::max(fraction, min_packet_loss_rate_);
fraction = std::min(std::max(fraction, 0.0f), kMaxPacketLossFraction);
if (packet_loss_rate_ != fraction) {
packet_loss_rate_ = fraction;
RTC_CHECK_EQ(

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

@ -160,7 +160,6 @@ class AudioEncoderOpusImpl final : public AudioEncoder {
// 1 kbps range.
std::vector<float> bitrate_multipliers_;
float packet_loss_rate_;
const float min_packet_loss_rate_;
std::vector<int16_t> input_buffer_;
OpusEncInst* inst_;
uint32_t first_timestamp_in_buffer_;

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

@ -222,84 +222,6 @@ TEST_P(AudioEncoderOpusTest,
}
}
namespace {
// 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)
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(const 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->fake_clock->AdvanceTime(TimeDelta::Millis(kSampleIntervalMs));
EXPECT_FLOAT_EQ(expected_return, states->encoder->packet_loss_rate());
}
}
} // namespace
TEST_P(AudioEncoderOpusTest, PacketLossRateOptimized) {
auto states = CreateCodec(sample_rate_hz_, 1);
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.get(), I(0.00f , 0.01f - eps), 0.00f);
TestSetPacketLossRate(states.get(), I(0.01f + eps, 0.06f - eps), 0.01f);
TestSetPacketLossRate(states.get(), I(0.06f + eps, 0.11f - eps), 0.05f);
TestSetPacketLossRate(states.get(), I(0.11f + eps, 0.22f - eps), 0.10f);
TestSetPacketLossRate(states.get(), I(0.22f + eps, 1.00f ), 0.20f);
TestSetPacketLossRate(states.get(), I(1.00f , 0.18f + eps), 0.20f);
TestSetPacketLossRate(states.get(), I(0.18f - eps, 0.09f + eps), 0.10f);
TestSetPacketLossRate(states.get(), I(0.09f - eps, 0.04f + eps), 0.05f);
TestSetPacketLossRate(states.get(), I(0.04f - eps, 0.01f + eps), 0.01f);
TestSetPacketLossRate(states.get(), I(0.01f - eps, 0.00f ), 0.00f);
// clang-format on
}
TEST_P(AudioEncoderOpusTest, PacketLossRateLowerBounded) {
test::ScopedFieldTrials override_field_trials(
"WebRTC-Audio-OpusMinPacketLossRate/Enabled-5/");
auto states = CreateCodec(sample_rate_hz_, 1);
auto I = [](float a, float b) { return IntervalSteps(a, b, 10); };
constexpr float eps = 1e-8f;
// clang-format off
TestSetPacketLossRate(states.get(), I(0.00f , 0.01f - eps), 0.05f);
TestSetPacketLossRate(states.get(), I(0.01f + eps, 0.06f - eps), 0.05f);
TestSetPacketLossRate(states.get(), I(0.06f + eps, 0.11f - eps), 0.05f);
TestSetPacketLossRate(states.get(), I(0.11f + eps, 0.22f - eps), 0.10f);
TestSetPacketLossRate(states.get(), I(0.22f + eps, 1.00f ), 0.20f);
TestSetPacketLossRate(states.get(), I(1.00f , 0.18f + eps), 0.20f);
TestSetPacketLossRate(states.get(), I(0.18f - eps, 0.09f + eps), 0.10f);
TestSetPacketLossRate(states.get(), I(0.09f - eps, 0.04f + eps), 0.05f);
TestSetPacketLossRate(states.get(), I(0.04f - eps, 0.01f + eps), 0.05f);
TestSetPacketLossRate(states.get(), I(0.01f - eps, 0.00f ), 0.05f);
// clang-format on
}
TEST_P(AudioEncoderOpusTest, SetReceiverFrameLengthRange) {
auto states = CreateCodec(sample_rate_hz_, 2);
// Before calling to |SetReceiverFrameLengthRange|,
@ -404,16 +326,21 @@ TEST_P(AudioEncoderOpusTest,
// First time, no filtering.
states->encoder->OnReceivedUplinkPacketLossFraction(kPacketLossFraction_1);
EXPECT_FLOAT_EQ(0.01f, states->encoder->packet_loss_rate());
EXPECT_FLOAT_EQ(0.02f, states->encoder->packet_loss_rate());
states->fake_clock->AdvanceTime(TimeDelta::Millis(kSecondSampleTimeMs));
states->encoder->OnReceivedUplinkPacketLossFraction(kPacketLossFraction_2);
// Now the output of packet loss fraction smoother should be
// (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());
// (0.02 + 0.198) / 2 = 0.109.
EXPECT_NEAR(0.109f, states->encoder->packet_loss_rate(), 0.001);
}
TEST_P(AudioEncoderOpusTest, PacketLossRateUpperBounded) {
auto states = CreateCodec(sample_rate_hz_, 2);
states->encoder->OnReceivedUplinkPacketLossFraction(0.5);
EXPECT_FLOAT_EQ(0.2f, states->encoder->packet_loss_rate());
}
TEST_P(AudioEncoderOpusTest, DoNotInvokeSetTargetBitrateIfOverheadUnknown) {
@ -477,29 +404,6 @@ TEST_P(AudioEncoderOpusTest, BitrateBounded) {
EXPECT_EQ(kMaxBitrateBps, states->encoder->GetTargetBitrate());
}
TEST_P(AudioEncoderOpusTest, MinPacketLossRate) {
constexpr float kDefaultMinPacketLossRate = 0.01;
{
test::ScopedFieldTrials override_field_trials(
"WebRTC-Audio-OpusMinPacketLossRate/Enabled/");
auto states = CreateCodec(sample_rate_hz_, 1);
EXPECT_EQ(kDefaultMinPacketLossRate, states->encoder->packet_loss_rate());
}
{
test::ScopedFieldTrials override_field_trials(
"WebRTC-Audio-OpusMinPacketLossRate/Enabled-200/");
auto states = CreateCodec(sample_rate_hz_, 1);
EXPECT_EQ(kDefaultMinPacketLossRate, states->encoder->packet_loss_rate());
}
{
test::ScopedFieldTrials override_field_trials(
"WebRTC-Audio-OpusMinPacketLossRate/Enabled-50/");
constexpr float kMinPacketLossRate = 0.5;
auto states = CreateCodec(sample_rate_hz_, 1);
EXPECT_EQ(kMinPacketLossRate, states->encoder->packet_loss_rate());
}
}
// Verifies that the complexity adaptation in the config works as intended.
TEST(AudioEncoderOpusTest, ConfigComplexityAdaptation) {
AudioEncoderOpusConfig config;