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

Allow ANA to receive RPLR (recoverable packet loss rate) indications

Browse Source 
This is part of a series of CLs. Next CLs:
1. CL for RPLR-based FecController
2. CL for allowing experiment-driven configuration of the above (through both field-trials and protobuf)

BUG=webrtc:7058

Review-Url: https://codereview.webrtc.org/2661043003
Cr-Commit-Position: refs/heads/master@{#17368}
This commit is contained in:
elad.alon
2017-03-23 15:29:50 -07:00
committed by Commit bot
parent d1c44356c5
commit dadb4dc3c9
23 changed files with 127 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.cc
View File

@ -68,6 +68,18 @@ void AudioNetworkAdaptorImpl::SetUplinkPacketLossFraction(
UpdateNetworkMetrics(network_metrics);
}
void AudioNetworkAdaptorImpl::SetUplinkRecoverablePacketLossFraction(
float uplink_recoverable_packet_loss_fraction) {
last_metrics_.uplink_recoverable_packet_loss_fraction =
rtc::Optional<float>(uplink_recoverable_packet_loss_fraction);
DumpNetworkMetrics();
Controller::NetworkMetrics network_metrics;
network_metrics.uplink_recoverable_packet_loss_fraction =
rtc::Optional<float>(uplink_recoverable_packet_loss_fraction);
UpdateNetworkMetrics(network_metrics);
}
void AudioNetworkAdaptorImpl::SetRtt(int rtt_ms) {
last_metrics_.rtt_ms = rtc::Optional<int>(rtt_ms);
DumpNetworkMetrics();

3
webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.h
View File

@ -45,6 +45,9 @@ class AudioNetworkAdaptorImpl final : public AudioNetworkAdaptor {
void SetUplinkPacketLossFraction(float uplink_packet_loss_fraction) override;
void SetUplinkRecoverablePacketLossFraction(
float uplink_recoverable_packet_loss_fraction) override;
void SetRtt(int rtt_ms) override;
void SetTargetAudioBitrate(int target_audio_bitrate_bps) override;

27
webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl_unittest.cc
View File

@ -36,7 +36,10 @@ MATCHER_P(NetworkMetricsIs, metric, "") {
arg.target_audio_bitrate_bps == metric.target_audio_bitrate_bps &&
arg.rtt_ms == metric.rtt_ms &&
arg.overhead_bytes_per_packet == metric.overhead_bytes_per_packet &&
arg.uplink_packet_loss_fraction == metric.uplink_packet_loss_fraction;
arg.uplink_packet_loss_fraction ==
metric.uplink_packet_loss_fraction &&
arg.uplink_recoverable_packet_loss_fraction ==
metric.uplink_recoverable_packet_loss_fraction;
}
MATCHER_P(EncoderRuntimeConfigIs, config, "") {
@ -127,6 +130,18 @@ TEST(AudioNetworkAdaptorImplTest,
states.audio_network_adaptor->SetUplinkPacketLossFraction(kPacketLoss);
}
TEST(AudioNetworkAdaptorImplTest,
UpdateNetworkMetricsIsCalledOnSetUplinkRecoverablePacketLossFraction) {
auto states = CreateAudioNetworkAdaptor();
constexpr float kRecoverablePacketLoss = 0.1f;
Controller::NetworkMetrics check;
check.uplink_recoverable_packet_loss_fraction =
rtc::Optional<float>(kRecoverablePacketLoss);
SetExpectCallToUpdateNetworkMetrics(states.mock_controllers, check);
states.audio_network_adaptor->SetUplinkRecoverablePacketLossFraction(
kRecoverablePacketLoss);
}
TEST(AudioNetworkAdaptorImplTest, UpdateNetworkMetricsIsCalledOnSetRtt) {
auto states = CreateAudioNetworkAdaptor();
constexpr int kRtt = 100;
@ -186,6 +201,7 @@ TEST(AudioNetworkAdaptorImplTest,
constexpr int kBandwidth = 16000;
constexpr float kPacketLoss = 0.7f;
const auto kRecoverablePacketLoss = 0.2f;
constexpr int kRtt = 100;
constexpr int kTargetAudioBitrate = 15000;
constexpr size_t kOverhead = 64;
@ -205,6 +221,15 @@ TEST(AudioNetworkAdaptorImplTest,
DumpNetworkMetrics(NetworkMetricsIs(check), timestamp_check));
states.audio_network_adaptor->SetUplinkPacketLossFraction(kPacketLoss);
states.simulated_clock->AdvanceTimeMilliseconds(50);
timestamp_check += 50;
check.uplink_recoverable_packet_loss_fraction =
rtc::Optional<float>(kRecoverablePacketLoss);
EXPECT_CALL(*states.mock_debug_dump_writer,
DumpNetworkMetrics(NetworkMetricsIs(check), timestamp_check));
states.audio_network_adaptor->SetUplinkRecoverablePacketLossFraction(
kRecoverablePacketLoss);
states.simulated_clock->AdvanceTimeMilliseconds(200);
timestamp_check += 200;
check.rtt_ms = rtc::Optional<int>(kRtt);

1
webrtc/modules/audio_coding/audio_network_adaptor/controller.h
View File

@ -23,6 +23,7 @@ class Controller {
~NetworkMetrics();
rtc::Optional<int> uplink_bandwidth_bps;
rtc::Optional<float> uplink_packet_loss_fraction;
rtc::Optional<float> uplink_recoverable_packet_loss_fraction;
rtc::Optional<int> target_audio_bitrate_bps;
rtc::Optional<int> rtt_ms;
rtc::Optional<size_t> overhead_bytes_per_packet;

1
webrtc/modules/audio_coding/audio_network_adaptor/controller_manager.h
View File

@ -81,6 +81,7 @@ class ControllerManagerImpl final : public ControllerManager {
// Scoring point is a subset of NetworkMetrics that is used for comparing the
// significance of controllers.
struct ScoringPoint {
// TODO(elad.alon): Do we want to experiment with RPLR-based scoring?
ScoringPoint(int uplink_bandwidth_bps, float uplink_packet_loss_fraction);
// Calculate the normalized [0,1] distance between two scoring points.

6
webrtc/modules/audio_coding/audio_network_adaptor/debug_dump.proto
View File

@ -7,14 +7,20 @@ message NetworkMetrics {
optional float uplink_packet_loss_fraction = 2;
optional int32 target_audio_bitrate_bps = 3;
optional int32 rtt_ms = 4;
optional int32 uplink_recoverable_packet_loss_fraction = 5;
}
message EncoderRuntimeConfig {
optional int32 bitrate_bps = 1;
optional int32 frame_length_ms = 2;
// Note: This is what we tell the encoder. It doesn't have to reflect
// the actual NetworkMetrics; it's subject to our decision.
optional float uplink_packet_loss_fraction = 3;
optional bool enable_fec = 4;
optional bool enable_dtx = 5;
// Some encoders can encode fewer channels than the actual input to make
// better use of the bandwidth. |num_channels| sets the number of channels
// to encode.
optional uint32 num_channels = 6;
}

5
webrtc/modules/audio_coding/audio_network_adaptor/debug_dump_writer.cc
View File

@ -94,6 +94,11 @@ void DebugDumpWriterImpl::DumpNetworkMetrics(
if (metrics.rtt_ms)
dump_metrics->set_rtt_ms(*metrics.rtt_ms);
if (metrics.uplink_recoverable_packet_loss_fraction) {
dump_metrics->set_uplink_recoverable_packet_loss_fraction(
*metrics.uplink_recoverable_packet_loss_fraction);
}
DumpEventToFile(event, dump_file_.get());
#endif // WEBRTC_AUDIO_NETWORK_ADAPTOR_DEBUG_DUMP
}

5
webrtc/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h
View File

@ -26,6 +26,8 @@ class AudioNetworkAdaptor {
~EncoderRuntimeConfig();
rtc::Optional<int> bitrate_bps;
rtc::Optional<int> frame_length_ms;
// Note: This is what we tell the encoder. It doesn't have to reflect
// the actual NetworkMetrics; it's subject to our decision.
rtc::Optional<float> uplink_packet_loss_fraction;
rtc::Optional<bool> enable_fec;
rtc::Optional<bool> enable_dtx;
@ -43,6 +45,9 @@ class AudioNetworkAdaptor {
virtual void SetUplinkPacketLossFraction(
float uplink_packet_loss_fraction) = 0;
virtual void SetUplinkRecoverablePacketLossFraction(
float uplink_recoverable_packet_loss_fraction) = 0;
virtual void SetRtt(int rtt_ms) = 0;
virtual void SetTargetAudioBitrate(int target_audio_bitrate_bps) = 0;

3
webrtc/modules/audio_coding/audio_network_adaptor/mock/mock_audio_network_adaptor.h
View File

@ -26,6 +26,9 @@ class MockAudioNetworkAdaptor : public AudioNetworkAdaptor {
MOCK_METHOD1(SetUplinkPacketLossFraction,
void(float uplink_packet_loss_fraction));
MOCK_METHOD1(SetUplinkRecoverablePacketLossFraction,
void(float uplink_recoverable_packet_loss_fraction));
MOCK_METHOD1(SetRtt, void(int rtt_ms));
MOCK_METHOD1(SetTargetAudioBitrate, void(int target_audio_bitrate_bps));

3
webrtc/modules/audio_coding/codecs/audio_encoder.cc
View File

@ -76,6 +76,9 @@ void AudioEncoder::DisableAudioNetworkAdaptor() {}
void AudioEncoder::OnReceivedUplinkPacketLossFraction(
float uplink_packet_loss_fraction) {}
void AudioEncoder::OnReceivedUplinkRecoverablePacketLossFraction(
float uplink_recoverable_packet_loss_fraction) {}
void AudioEncoder::OnReceivedTargetAudioBitrate(int target_audio_bitrate_bps) {
OnReceivedUplinkBandwidth(target_audio_bitrate_bps, rtc::Optional<int64_t>());
}

6
webrtc/modules/audio_coding/codecs/audio_encoder.h
View File

@ -175,6 +175,12 @@ class AudioEncoder {
virtual void OnReceivedUplinkPacketLossFraction(
float uplink_packet_loss_fraction);
// Provides 1st-order-FEC-recoverable uplink packet loss rate to this encoder
// to allow it to adapt.
// |uplink_recoverable_packet_loss_fraction| is in the range [0.0, 1.0].
virtual void OnReceivedUplinkRecoverablePacketLossFraction(
float uplink_recoverable_packet_loss_fraction);
// Provides target audio bitrate to this encoder to allow it to adapt.
virtual void OnReceivedTargetAudioBitrate(int target_bps);

6
webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng.cc
View File

@ -190,6 +190,12 @@ void AudioEncoderCng::OnReceivedUplinkPacketLossFraction(
uplink_packet_loss_fraction);
}
void AudioEncoderCng::OnReceivedUplinkRecoverablePacketLossFraction(
float uplink_recoverable_packet_loss_fraction) {
speech_encoder_->OnReceivedUplinkRecoverablePacketLossFraction(
uplink_recoverable_packet_loss_fraction);
}
void AudioEncoderCng::OnReceivedUplinkBandwidth(
int target_audio_bitrate_bps,
rtc::Optional<int64_t> probing_interval_ms) {

2
webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng.h
View File

@ -65,6 +65,8 @@ class AudioEncoderCng final : public AudioEncoder {
override;
void OnReceivedUplinkPacketLossFraction(
float uplink_packet_loss_fraction) override;
void OnReceivedUplinkRecoverablePacketLossFraction(
float uplink_recoverable_packet_loss_fraction) override;
void OnReceivedUplinkBandwidth(
int target_audio_bitrate_bps,
rtc::Optional<int64_t> probing_interval_ms) override;

9
webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.cc
View File

@ -304,6 +304,15 @@ void AudioEncoderOpus::OnReceivedUplinkPacketLossFraction(
ApplyAudioNetworkAdaptor();
}
void AudioEncoderOpus::OnReceivedUplinkRecoverablePacketLossFraction(
float uplink_recoverable_packet_loss_fraction) {
if (!audio_network_adaptor_)
return;
audio_network_adaptor_->SetUplinkRecoverablePacketLossFraction(
uplink_recoverable_packet_loss_fraction);
ApplyAudioNetworkAdaptor();
}
void AudioEncoderOpus::OnReceivedUplinkBandwidth(
int target_audio_bitrate_bps,
rtc::Optional<int64_t> probing_interval_ms) {

2
webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.h
View File

@ -114,6 +114,8 @@ class AudioEncoderOpus final : public AudioEncoder {
void DisableAudioNetworkAdaptor() override;
void OnReceivedUplinkPacketLossFraction(
float uplink_packet_loss_fraction) override;
void OnReceivedUplinkRecoverablePacketLossFraction(
float uplink_recoverable_packet_loss_fraction) override;
void OnReceivedUplinkBandwidth(
int target_audio_bitrate_bps,
rtc::Optional<int64_t> probing_interval_ms) override;

6
webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red.cc
View File

@ -126,6 +126,12 @@ void AudioEncoderCopyRed::OnReceivedUplinkPacketLossFraction(
uplink_packet_loss_fraction);
}
void AudioEncoderCopyRed::OnReceivedUplinkRecoverablePacketLossFraction(
float uplink_recoverable_packet_loss_fraction) {
speech_encoder_->OnReceivedUplinkRecoverablePacketLossFraction(
uplink_recoverable_packet_loss_fraction);
}
void AudioEncoderCopyRed::OnReceivedUplinkBandwidth(
int target_audio_bitrate_bps,
rtc::Optional<int64_t> probing_interval_ms) {

2
webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red.h
View File

@ -53,6 +53,8 @@ class AudioEncoderCopyRed final : public AudioEncoder {
override;
void OnReceivedUplinkPacketLossFraction(
float uplink_packet_loss_fraction) override;
void OnReceivedUplinkRecoverablePacketLossFraction(
float uplink_recoverable_packet_loss_fraction) override;
void OnReceivedUplinkBandwidth(
int target_audio_bitrate_bps,
rtc::Optional<int64_t> probing_interval_ms) override;