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

Experiment-driven configuration of PLR/RPLR-based FecController

Browse Source 
BUG=webrtc:7058

Review-Url: https://codereview.webrtc.org/2684773002
Cr-Commit-Position: refs/heads/master@{#17419}
This commit is contained in:
elad.alon
2017-03-28 05:03:55 -07:00
committed by Commit bot
parent 9c47b00e24
commit 2877048afe
7 changed files with 95 additions and 28 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
webrtc/modules/audio_coding/audio_network_adaptor/config.proto
View File

@ -39,6 +39,41 @@ message FecController {
optional int32 time_constant_ms = 3;
}
message FecControllerRplrBased {
message Threshold {
// Threshold defines a curve in the bandwidth/recoverable-packet-loss
// domain.
// The curve is characterized by the two conjunction points: A and B.
//
// recoverable ^
// packet | |
// loss | A|
// | \ A: (low_bandwidth_bps,
// | \ low_bandwidth_recoverable_packet_loss)
// | \ B: (high_bandwidth_bps,
// | \ high_bandwidth_recoverable_packet_loss)
// | B\________
// |---------------> bandwidth
optional int32 low_bandwidth_bps = 1;
optional float low_bandwidth_recoverable_packet_loss = 2;
optional int32 high_bandwidth_bps = 3;
optional float high_bandwidth_recoverable_packet_loss = 4;
}
// |fec_enabling_threshold| defines a curve, above which FEC should be
// enabled. |fec_disabling_threshold| defines a curve, under which FEC
// should be disabled. See below
//
// packet-loss ^ | |
// | | | FEC
// | \ \ ON
// | FEC \ \_______ fec_enabling_threshold
// | OFF \_________ fec_disabling_threshold
// |-----------------> bandwidth
optional Threshold fec_enabling_threshold = 1;
optional Threshold fec_disabling_threshold = 2;
}
message FrameLengthController {
// Uplink packet loss fraction below which frame length can increase.
optional float fl_increasing_packet_loss_fraction = 1;
@ -101,6 +136,7 @@ message Controller {
ChannelController channel_controller = 23;
DtxController dtx_controller = 24;
BitrateController bitrate_controller = 25;
FecControllerRplrBased fec_controller_rplr_based = 26;
}
}

42
webrtc/modules/audio_coding/audio_network_adaptor/controller_manager.cc
View File

@ -18,6 +18,7 @@
#include "webrtc/modules/audio_coding/audio_network_adaptor/channel_controller.h"
#include "webrtc/modules/audio_coding/audio_network_adaptor/dtx_controller.h"
#include "webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based.h"
#include "webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based.h"
#include "webrtc/modules/audio_coding/audio_network_adaptor/frame_length_controller.h"
#include "webrtc/system_wrappers/include/clock.h"
@ -73,6 +74,43 @@ std::unique_ptr<FecControllerPlrBased> CreateFecControllerPlrBased(
config.time_constant_ms(), clock)));
}
std::unique_ptr<FecControllerRplrBased> CreateFecControllerRplrBased(
const audio_network_adaptor::config::FecControllerRplrBased& config,
bool initial_fec_enabled) {
RTC_CHECK(config.has_fec_enabling_threshold());
RTC_CHECK(config.has_fec_disabling_threshold());
auto& fec_enabling_threshold = config.fec_enabling_threshold();
RTC_CHECK(fec_enabling_threshold.has_low_bandwidth_bps());
RTC_CHECK(fec_enabling_threshold.has_low_bandwidth_recoverable_packet_loss());
RTC_CHECK(fec_enabling_threshold.has_high_bandwidth_bps());
RTC_CHECK(
fec_enabling_threshold.has_high_bandwidth_recoverable_packet_loss());
auto& fec_disabling_threshold = config.fec_disabling_threshold();
RTC_CHECK(fec_disabling_threshold.has_low_bandwidth_bps());
RTC_CHECK(
fec_disabling_threshold.has_low_bandwidth_recoverable_packet_loss());
RTC_CHECK(fec_disabling_threshold.has_high_bandwidth_bps());
RTC_CHECK(
fec_disabling_threshold.has_high_bandwidth_recoverable_packet_loss());
return std::unique_ptr<FecControllerRplrBased>(
new FecControllerRplrBased(FecControllerRplrBased::Config(
initial_fec_enabled,
FecControllerRplrBased::Config::Threshold(
fec_enabling_threshold.low_bandwidth_bps(),
fec_enabling_threshold.low_bandwidth_recoverable_packet_loss(),
fec_enabling_threshold.high_bandwidth_bps(),
fec_enabling_threshold.high_bandwidth_recoverable_packet_loss()),
FecControllerRplrBased::Config::Threshold(
fec_disabling_threshold.low_bandwidth_bps(),
fec_disabling_threshold.low_bandwidth_recoverable_packet_loss(),
fec_disabling_threshold.high_bandwidth_bps(),
fec_disabling_threshold
.high_bandwidth_recoverable_packet_loss()))));
}
std::unique_ptr<FrameLengthController> CreateFrameLengthController(
const audio_network_adaptor::config::FrameLengthController& config,
rtc::ArrayView<const int> encoder_frame_lengths_ms,
@ -183,6 +221,10 @@ std::unique_ptr<ControllerManager> ControllerManagerImpl::Create(
controller = CreateFecControllerPlrBased(
controller_config.fec_controller(), initial_fec_enabled, clock);
break;
case audio_network_adaptor::config::Controller::kFecControllerRplrBased:
controller = CreateFecControllerRplrBased(
controller_config.fec_controller_rplr_based(), initial_fec_enabled);
break;
case audio_network_adaptor::config::Controller::kFrameLengthController:
controller = CreateFrameLengthController(
controller_config.frame_length_controller(),

6
webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based.cc
View File

@ -14,13 +14,11 @@
#include <utility>
#include "webrtc/base/checks.h"
#include "webrtc/system_wrappers/include/field_trial.h"
namespace webrtc {
namespace {
// TODO(elad.alon): Subsequent CL experiments with PLR source.
constexpr bool kUseTwccPlrForAna = false;
class NullSmoothingFilter final : public SmoothingFilter {
public:
void AddSample(float sample) override {
@ -85,7 +83,7 @@ FecControllerPlrBased::FecControllerPlrBased(
FecControllerPlrBased::FecControllerPlrBased(const Config& config)
: FecControllerPlrBased(
config,
kUseTwccPlrForAna
webrtc::field_trial::FindFullName("UseTwccPlrForAna") == "Enabled"
? std::unique_ptr<NullSmoothingFilter>(new NullSmoothingFilter())
: std::unique_ptr<SmoothingFilter>(
new SmoothingFilterImpl(config.time_constant_ms,

8
webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based.cc
View File

@ -31,14 +31,10 @@ FecControllerRplrBased::Config::Threshold::Threshold(
FecControllerRplrBased::Config::Config(bool initial_fec_enabled,
const Threshold& fec_enabling_threshold,
const Threshold& fec_disabling_threshold,
int time_constant_ms,
const Clock* clock)
const Threshold& fec_disabling_threshold)
: initial_fec_enabled(initial_fec_enabled),
fec_enabling_threshold(fec_enabling_threshold),
fec_disabling_threshold(fec_disabling_threshold),
time_constant_ms(time_constant_ms),
clock(clock) {}
fec_disabling_threshold(fec_disabling_threshold) {}
FecControllerRplrBased::FecControllerRplrBased(const Config& config)
: config_(config),

7
webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based.h
View File

@ -15,7 +15,6 @@
#include "webrtc/base/constructormagic.h"
#include "webrtc/modules/audio_coding/audio_network_adaptor/controller.h"
#include "webrtc/system_wrappers/include/clock.h"
namespace webrtc {
@ -58,14 +57,10 @@ class FecControllerRplrBased final : public Controller {
// |-----------------> bandwidth
Config(bool initial_fec_enabled,
const Threshold& fec_enabling_threshold,
const Threshold& fec_disabling_threshold,
int time_constant_ms,
const Clock* clock);
const Threshold& fec_disabling_threshold);
bool initial_fec_enabled;
Threshold fec_enabling_threshold;
Threshold fec_disabling_threshold;
int time_constant_ms;
const Clock* clock;
};
explicit FecControllerRplrBased(const Config& config);

19
webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based_unittest.cc
View File

@ -68,10 +68,10 @@ std::unique_ptr<FecControllerRplrBased> CreateFecControllerRplrBased(
Threshold(
kEnablingBandwidthLow, kEnablingRecoverablePacketLossAtLowBw,
kEnablingBandwidthHigh, kEnablingRecoverablePacketLossAtHighBw),
Threshold(
kDisablingBandwidthLow, kDisablingRecoverablePacketLossAtLowBw,
kDisablingBandwidthHigh, kDisablingRecoverablePacketLossAtHighBw),
0, nullptr)));
Threshold(kDisablingBandwidthLow,
kDisablingRecoverablePacketLossAtLowBw,
kDisablingBandwidthHigh,
kDisablingRecoverablePacketLossAtHighBw))));
}
void UpdateNetworkMetrics(
@ -372,8 +372,7 @@ TEST(FecControllerRplrBasedTest, CheckBehaviorOnSpecialCurves) {
kEnablingBandwidthHigh, kEnablingRecoverablePacketLossAtHighBw),
Threshold(kDisablingBandwidthLow, kDisablingRecoverablePacketLossAtLowBw,
kDisablingBandwidthHigh,
kDisablingRecoverablePacketLossAtHighBw),
0, nullptr));
kDisablingRecoverablePacketLossAtHighBw)));
UpdateNetworkMetrics(&controller,
rtc::Optional<int>(kDisablingBandwidthLow - 1),
@ -412,10 +411,10 @@ TEST(FecControllerRplrBasedDeathTest, InvalidConfig) {
Threshold(
kDisablingBandwidthLow - 1, kEnablingRecoverablePacketLossAtLowBw,
kEnablingBandwidthHigh, kEnablingRecoverablePacketLossAtHighBw),
Threshold(
kDisablingBandwidthLow, kDisablingRecoverablePacketLossAtLowBw,
kDisablingBandwidthHigh, kDisablingRecoverablePacketLossAtHighBw),
0, nullptr)),
Threshold(kDisablingBandwidthLow,
kDisablingRecoverablePacketLossAtLowBw,
kDisablingBandwidthHigh,
kDisablingRecoverablePacketLossAtHighBw))),
"Check failed");
}
#endif