From c9e80eee514a3db7b66f49c02e62e3d5b1f89a9d Mon Sep 17 00:00:00 2001 From: minyue Date: Tue, 29 Nov 2016 13:00:28 -0800 Subject: [PATCH] Adding packet overhead to audio network adaptor. BUG=webrtc:6303, webrtc:6762 Review-Url: https://codereview.webrtc.org/2530653003 Cr-Commit-Position: refs/heads/master@{#15305} --- .../audio_network_adaptor_impl.cc | 10 +- .../audio_network_adaptor_impl.h | 2 + .../audio_network_adaptor_impl_unittest.cc | 24 ++- .../bitrate_controller.cc | 42 ++-- .../bitrate_controller.h | 2 +- .../bitrate_controller_unittest.cc | 181 +++++++++++++----- .../audio_network_adaptor/controller.h | 1 + .../include/audio_network_adaptor.h | 2 + .../mock/mock_audio_network_adaptor.h | 2 + 9 files changed, 178 insertions(+), 88 deletions(-) diff --git a/webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.cc b/webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.cc index 46c21d1e4c..a9922b0987 100644 --- a/webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.cc +++ b/webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.cc @@ -42,6 +42,11 @@ void AudioNetworkAdaptorImpl::SetUplinkPacketLossFraction( DumpNetworkMetrics(); } +void AudioNetworkAdaptorImpl::SetRtt(int rtt_ms) { + last_metrics_.rtt_ms = rtc::Optional(rtt_ms); + DumpNetworkMetrics(); +} + void AudioNetworkAdaptorImpl::SetTargetAudioBitrate( int target_audio_bitrate_bps) { last_metrics_.target_audio_bitrate_bps = @@ -49,8 +54,9 @@ void AudioNetworkAdaptorImpl::SetTargetAudioBitrate( DumpNetworkMetrics(); } -void AudioNetworkAdaptorImpl::SetRtt(int rtt_ms) { - last_metrics_.rtt_ms = rtc::Optional(rtt_ms); +void AudioNetworkAdaptorImpl::SetOverhead(size_t overhead_bytes_per_packet) { + last_metrics_.overhead_bytes_per_packet = + rtc::Optional(overhead_bytes_per_packet); DumpNetworkMetrics(); } diff --git a/webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.h b/webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.h index 8853db526d..549eef9bdd 100644 --- a/webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.h +++ b/webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.h @@ -45,6 +45,8 @@ class AudioNetworkAdaptorImpl final : public AudioNetworkAdaptor { void SetTargetAudioBitrate(int target_audio_bitrate_bps) override; + void SetOverhead(size_t overhead_bytes_per_packet) override; + EncoderRuntimeConfig GetEncoderRuntimeConfig() override; void StartDebugDump(FILE* file_handle) override; diff --git a/webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl_unittest.cc b/webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl_unittest.cc index c7700fd906..b26d2f5db8 100644 --- a/webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl_unittest.cc +++ b/webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl_unittest.cc @@ -34,16 +34,10 @@ MATCHER_P(NetworkMetricsIs, metric, "") { return arg.uplink_bandwidth_bps == metric.uplink_bandwidth_bps && 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; } -MATCHER_P(ConstraintsReceiverFrameLengthRangeIs, frame_length_range, "") { - return arg.receiver_frame_length_range->min_frame_length_ms == - frame_length_range.min_frame_length_ms && - arg.receiver_frame_length_range->max_frame_length_ms == - frame_length_range.max_frame_length_ms; -} - MATCHER_P(EncoderRuntimeConfigIs, config, "") { return arg.bitrate_bps == config.bitrate_bps && arg.frame_length_ms == config.frame_length_ms && @@ -108,6 +102,7 @@ TEST(AudioNetworkAdaptorImplTest, constexpr float kPacketLoss = 0.7f; constexpr int kRtt = 100; constexpr int kTargetAudioBitrate = 15000; + constexpr size_t kOverhead = 64; Controller::NetworkMetrics check; check.uplink_bandwidth_bps = rtc::Optional(kBandwidth); @@ -137,6 +132,13 @@ TEST(AudioNetworkAdaptorImplTest, } states.audio_network_adaptor->SetTargetAudioBitrate(kTargetAudioBitrate); states.audio_network_adaptor->GetEncoderRuntimeConfig(); + + check.overhead_bytes_per_packet = rtc::Optional(kOverhead); + for (auto& mock_controller : states.mock_controllers) { + EXPECT_CALL(*mock_controller, MakeDecision(NetworkMetricsIs(check), _)); + } + states.audio_network_adaptor->SetOverhead(kOverhead); + states.audio_network_adaptor->GetEncoderRuntimeConfig(); } TEST(AudioNetworkAdaptorImplTest, @@ -164,6 +166,7 @@ TEST(AudioNetworkAdaptorImplTest, constexpr float kPacketLoss = 0.7f; constexpr int kRtt = 100; constexpr int kTargetAudioBitrate = 15000; + constexpr size_t kOverhead = 64; Controller::NetworkMetrics check; check.uplink_bandwidth_bps = rtc::Optional(kBandwidth); @@ -193,6 +196,13 @@ TEST(AudioNetworkAdaptorImplTest, EXPECT_CALL(*states.mock_debug_dump_writer, DumpNetworkMetrics(NetworkMetricsIs(check), timestamp_check)); states.audio_network_adaptor->SetTargetAudioBitrate(kTargetAudioBitrate); + + states.simulated_clock->AdvanceTimeMilliseconds(50); + timestamp_check += 50; + check.overhead_bytes_per_packet = rtc::Optional(kOverhead); + EXPECT_CALL(*states.mock_debug_dump_writer, + DumpNetworkMetrics(NetworkMetricsIs(check), timestamp_check)); + states.audio_network_adaptor->SetOverhead(kOverhead); } } // namespace webrtc diff --git a/webrtc/modules/audio_coding/audio_network_adaptor/bitrate_controller.cc b/webrtc/modules/audio_coding/audio_network_adaptor/bitrate_controller.cc index ac0045ec4d..2f64df066b 100644 --- a/webrtc/modules/audio_coding/audio_network_adaptor/bitrate_controller.cc +++ b/webrtc/modules/audio_coding/audio_network_adaptor/bitrate_controller.cc @@ -13,17 +13,11 @@ #include #include "webrtc/base/checks.h" +#include "webrtc/system_wrappers/include/field_trial.h" namespace webrtc { namespace audio_network_adaptor { -namespace { -// TODO(minyue): consider passing this from a higher layer through -// SetConstraints(). -// L2(14B) + IPv4(20B) + UDP(8B) + RTP(12B) + SRTP_AUTH(10B) = 64B = 512 bits -constexpr int kPacketOverheadBits = 512; -} - BitrateController::Config::Config(int initial_bitrate_bps, int initial_frame_length_ms) : initial_bitrate_bps(initial_bitrate_bps), @@ -34,10 +28,9 @@ BitrateController::Config::~Config() = default; BitrateController::BitrateController(const Config& config) : config_(config), bitrate_bps_(config_.initial_bitrate_bps), - overhead_rate_bps_(kPacketOverheadBits * 1000 / - config_.initial_frame_length_ms) { + frame_length_ms_(config_.initial_frame_length_ms) { RTC_DCHECK_GT(bitrate_bps_, 0); - RTC_DCHECK_GT(overhead_rate_bps_, 0); + RTC_DCHECK_GT(frame_length_ms_, 0); } void BitrateController::MakeDecision( @@ -45,23 +38,18 @@ void BitrateController::MakeDecision( AudioNetworkAdaptor::EncoderRuntimeConfig* config) { // Decision on |bitrate_bps| should not have been made. RTC_DCHECK(!config->bitrate_bps); - - if (metrics.target_audio_bitrate_bps) { - int overhead_rate = - config->frame_length_ms - ? kPacketOverheadBits * 1000 / *config->frame_length_ms - : overhead_rate_bps_; - // If |metrics.target_audio_bitrate_bps| had included overhead, we would - // simply do: - // bitrate_bps_ = metrics.target_audio_bitrate_bps - overhead_rate; - // Follow https://bugs.chromium.org/p/webrtc/issues/detail?id=6315 to track - // progress regarding this. - // Now we assume that |metrics.target_audio_bitrate_bps| can handle the - // overhead of most recent packets. - bitrate_bps_ = std::max(0, *metrics.target_audio_bitrate_bps + - overhead_rate_bps_ - overhead_rate); - // TODO(minyue): apply a smoothing on the |overhead_rate_bps_|. - overhead_rate_bps_ = overhead_rate; + if (metrics.target_audio_bitrate_bps && metrics.overhead_bytes_per_packet) { + // Current implementation of BitrateController can only work when + // |metrics.target_audio_bitrate_bps| includes overhead is enabled. This is + // currently governed by the following field trial. + RTC_DCHECK_EQ("Enabled", webrtc::field_trial::FindFullName( + "WebRTC-SendSideBwe-WithOverhead")); + if (config->frame_length_ms) + frame_length_ms_ = *config->frame_length_ms; + int overhead_rate_bps = + *metrics.overhead_bytes_per_packet * 8 * 1000 / frame_length_ms_; + bitrate_bps_ = + std::max(0, *metrics.target_audio_bitrate_bps - overhead_rate_bps); } config->bitrate_bps = rtc::Optional(bitrate_bps_); } diff --git a/webrtc/modules/audio_coding/audio_network_adaptor/bitrate_controller.h b/webrtc/modules/audio_coding/audio_network_adaptor/bitrate_controller.h index f363d3f3df..a41c5f46fd 100644 --- a/webrtc/modules/audio_coding/audio_network_adaptor/bitrate_controller.h +++ b/webrtc/modules/audio_coding/audio_network_adaptor/bitrate_controller.h @@ -34,7 +34,7 @@ class BitrateController final : public Controller { private: const Config config_; int bitrate_bps_; - int overhead_rate_bps_; + int frame_length_ms_; RTC_DISALLOW_COPY_AND_ASSIGN(BitrateController); }; diff --git a/webrtc/modules/audio_coding/audio_network_adaptor/bitrate_controller_unittest.cc b/webrtc/modules/audio_coding/audio_network_adaptor/bitrate_controller_unittest.cc index 1ba1e8212e..a4ebfc8860 100644 --- a/webrtc/modules/audio_coding/audio_network_adaptor/bitrate_controller_unittest.cc +++ b/webrtc/modules/audio_coding/audio_network_adaptor/bitrate_controller_unittest.cc @@ -9,6 +9,7 @@ */ #include "webrtc/modules/audio_coding/audio_network_adaptor/bitrate_controller.h" +#include "webrtc/test/field_trial.h" #include "webrtc/test/gtest.h" namespace webrtc { @@ -16,15 +17,14 @@ namespace audio_network_adaptor { namespace { -// L2(14B) + IPv4(20B) + UDP(8B) + RTP(12B) + SRTP_AUTH(10B) = 64B = 512 bits -constexpr int kPacketOverheadBits = 512; - void CheckDecision(BitrateController* controller, const rtc::Optional& target_audio_bitrate_bps, + const rtc::Optional& overhead_bytes_per_packet, const rtc::Optional& frame_length_ms, int expected_bitrate_bps) { Controller::NetworkMetrics metrics; metrics.target_audio_bitrate_bps = target_audio_bitrate_bps; + metrics.overhead_bytes_per_packet = overhead_bytes_per_packet; AudioNetworkAdaptor::EncoderRuntimeConfig config; config.frame_length_ms = frame_length_ms; controller->MakeDecision(metrics, &config); @@ -40,104 +40,183 @@ void CheckDecision(BitrateController* controller, TEST(AnaBitrateControllerTest, OutputInitValueWhenTargetBitrateUnknown) { constexpr int kInitialBitrateBps = 32000; constexpr int kInitialFrameLengthMs = 20; + constexpr size_t kOverheadBytesPerPacket = 64; BitrateController controller( BitrateController::Config(kInitialBitrateBps, kInitialFrameLengthMs)); CheckDecision(&controller, rtc::Optional(), + rtc::Optional(kOverheadBytesPerPacket), + rtc::Optional(kInitialFrameLengthMs * 2), + kInitialBitrateBps); +} + +TEST(AnaBitrateControllerTest, OutputInitValueWhenOverheadUnknown) { + constexpr int kInitialBitrateBps = 32000; + constexpr int kInitialFrameLengthMs = 20; + constexpr int kTargetBitrateBps = 48000; + BitrateController controller( + BitrateController::Config(kInitialBitrateBps, kInitialFrameLengthMs)); + CheckDecision(&controller, rtc::Optional(kTargetBitrateBps), + rtc::Optional(), rtc::Optional(kInitialFrameLengthMs * 2), kInitialBitrateBps); } TEST(AnaBitrateControllerTest, ChangeBitrateOnTargetBitrateChanged) { - constexpr int kInitialBitrateBps = 32000; + test::ScopedFieldTrials override_field_trials( + "WebRTC-SendSideBwe-WithOverhead/Enabled/"); constexpr int kInitialFrameLengthMs = 20; BitrateController controller( - BitrateController::Config(kInitialBitrateBps, kInitialFrameLengthMs)); + BitrateController::Config(32000, kInitialFrameLengthMs)); constexpr int kTargetBitrateBps = 48000; + constexpr size_t kOverheadBytesPerPacket = 64; + constexpr int kBitrateBps = + kTargetBitrateBps - + kOverheadBytesPerPacket * 8 * 1000 / kInitialFrameLengthMs; // Frame length unchanged, bitrate changes in accordance with - // |metrics.target_audio_bitrate_bps| + // |metrics.target_audio_bitrate_bps| and |metrics.overhead_bytes_per_packet|. CheckDecision(&controller, rtc::Optional(kTargetBitrateBps), - rtc::Optional(kInitialFrameLengthMs), kTargetBitrateBps); + rtc::Optional(kOverheadBytesPerPacket), + rtc::Optional(kInitialFrameLengthMs), kBitrateBps); } TEST(AnaBitrateControllerTest, TreatUnknownFrameLengthAsFrameLengthUnchanged) { - constexpr int kInitialBitrateBps = 32000; + test::ScopedFieldTrials override_field_trials( + "WebRTC-SendSideBwe-WithOverhead/Enabled/"); constexpr int kInitialFrameLengthMs = 20; BitrateController controller( - BitrateController::Config(kInitialBitrateBps, kInitialFrameLengthMs)); + BitrateController::Config(32000, kInitialFrameLengthMs)); constexpr int kTargetBitrateBps = 48000; + constexpr size_t kOverheadBytesPerPacket = 64; + constexpr int kBitrateBps = + kTargetBitrateBps - + kOverheadBytesPerPacket * 8 * 1000 / kInitialFrameLengthMs; CheckDecision(&controller, rtc::Optional(kTargetBitrateBps), - rtc::Optional(), kTargetBitrateBps); + rtc::Optional(kOverheadBytesPerPacket), + rtc::Optional(), kBitrateBps); } TEST(AnaBitrateControllerTest, IncreaseBitrateOnFrameLengthIncreased) { - constexpr int kInitialBitrateBps = 32000; + test::ScopedFieldTrials override_field_trials( + "WebRTC-SendSideBwe-WithOverhead/Enabled/"); constexpr int kInitialFrameLengthMs = 20; BitrateController controller( - BitrateController::Config(kInitialBitrateBps, kInitialFrameLengthMs)); + BitrateController::Config(32000, kInitialFrameLengthMs)); + + constexpr int kTargetBitrateBps = 48000; + constexpr size_t kOverheadBytesPerPacket = 64; + constexpr int kBitrateBps = + kTargetBitrateBps - + kOverheadBytesPerPacket * 8 * 1000 / kInitialFrameLengthMs; + CheckDecision(&controller, rtc::Optional(kTargetBitrateBps), + rtc::Optional(kOverheadBytesPerPacket), + rtc::Optional(), kBitrateBps); + constexpr int kFrameLengthMs = 60; - constexpr int kPacketOverheadRateDiff = - kPacketOverheadBits * 1000 / kInitialFrameLengthMs - - kPacketOverheadBits * 1000 / kFrameLengthMs; - CheckDecision(&controller, rtc::Optional(kInitialBitrateBps), + constexpr size_t kPacketOverheadRateDiff = + kOverheadBytesPerPacket * 8 * 1000 / 20 - + kOverheadBytesPerPacket * 8 * 1000 / 60; + CheckDecision(&controller, rtc::Optional(kTargetBitrateBps), + rtc::Optional(kOverheadBytesPerPacket), rtc::Optional(kFrameLengthMs), - kInitialBitrateBps + kPacketOverheadRateDiff); + kBitrateBps + kPacketOverheadRateDiff); } TEST(AnaBitrateControllerTest, DecreaseBitrateOnFrameLengthDecreased) { - constexpr int kInitialBitrateBps = 32000; + test::ScopedFieldTrials override_field_trials( + "WebRTC-SendSideBwe-WithOverhead/Enabled/"); constexpr int kInitialFrameLengthMs = 60; BitrateController controller( - BitrateController::Config(kInitialBitrateBps, kInitialFrameLengthMs)); + BitrateController::Config(32000, kInitialFrameLengthMs)); + + constexpr int kTargetBitrateBps = 48000; + constexpr size_t kOverheadBytesPerPacket = 64; + constexpr int kBitrateBps = + kTargetBitrateBps - + kOverheadBytesPerPacket * 8 * 1000 / kInitialFrameLengthMs; + CheckDecision(&controller, rtc::Optional(kTargetBitrateBps), + rtc::Optional(kOverheadBytesPerPacket), + rtc::Optional(), kBitrateBps); + constexpr int kFrameLengthMs = 20; - constexpr int kPacketOverheadRateDiff = - kPacketOverheadBits * 1000 / kInitialFrameLengthMs - - kPacketOverheadBits * 1000 / kFrameLengthMs; - CheckDecision(&controller, rtc::Optional(kInitialBitrateBps), + constexpr size_t kPacketOverheadRateDiff = + kOverheadBytesPerPacket * 8 * 1000 / 20 - + kOverheadBytesPerPacket * 8 * 1000 / 60; + CheckDecision(&controller, rtc::Optional(kTargetBitrateBps), + rtc::Optional(kOverheadBytesPerPacket), rtc::Optional(kFrameLengthMs), - kInitialBitrateBps + kPacketOverheadRateDiff); + kBitrateBps - kPacketOverheadRateDiff); +} + +TEST(AnaBitrateControllerTest, BitrateNeverBecomesNegative) { + test::ScopedFieldTrials override_field_trials( + "WebRTC-SendSideBwe-WithOverhead/Enabled/"); + BitrateController controller(BitrateController::Config(32000, 20)); + constexpr size_t kOverheadBytesPerPacket = 64; + constexpr int kFrameLengthMs = 60; + // Set a target rate smaller than overhead rate, the bitrate is bounded by 0. + constexpr int kTargetBitrateBps = + kOverheadBytesPerPacket * 8 * 1000 / kFrameLengthMs - 1; + CheckDecision(&controller, rtc::Optional(kTargetBitrateBps), + rtc::Optional(kOverheadBytesPerPacket), + rtc::Optional(kFrameLengthMs), 0); } TEST(AnaBitrateControllerTest, CheckBehaviorOnChangingCondition) { - constexpr int kInitialBitrateBps = 32000; - constexpr int kInitialFrameLengthMs = 20; - BitrateController controller( - BitrateController::Config(kInitialBitrateBps, kInitialFrameLengthMs)); + test::ScopedFieldTrials override_field_trials( + "WebRTC-SendSideBwe-WithOverhead/Enabled/"); + BitrateController controller(BitrateController::Config(32000, 20)); - int last_overhead_bitrate = - kPacketOverheadBits * 1000 / kInitialFrameLengthMs; - int current_overhead_bitrate = kPacketOverheadBits * 1000 / 20; // Start from an arbitrary overall bitrate. int overall_bitrate = 34567; - CheckDecision( - &controller, rtc::Optional(overall_bitrate - last_overhead_bitrate), - rtc::Optional(20), overall_bitrate - current_overhead_bitrate); + size_t overhead_bytes_per_packet = 64; + int frame_length_ms = 20; + int current_bitrate = + overall_bitrate - overhead_bytes_per_packet * 8 * 1000 / frame_length_ms; + + CheckDecision(&controller, rtc::Optional(overall_bitrate), + rtc::Optional(overhead_bytes_per_packet), + rtc::Optional(frame_length_ms), current_bitrate); // Next: increase overall bitrate. overall_bitrate += 100; - CheckDecision( - &controller, rtc::Optional(overall_bitrate - last_overhead_bitrate), - rtc::Optional(20), overall_bitrate - current_overhead_bitrate); + current_bitrate += 100; + CheckDecision(&controller, rtc::Optional(overall_bitrate), + rtc::Optional(overhead_bytes_per_packet), + rtc::Optional(frame_length_ms), current_bitrate); // Next: change frame length. - current_overhead_bitrate = kPacketOverheadBits * 1000 / 60; - CheckDecision( - &controller, rtc::Optional(overall_bitrate - last_overhead_bitrate), - rtc::Optional(60), overall_bitrate - current_overhead_bitrate); - last_overhead_bitrate = current_overhead_bitrate; + frame_length_ms = 60; + current_bitrate += overhead_bytes_per_packet * 8 * 1000 / 20 - + overhead_bytes_per_packet * 8 * 1000 / 60; + CheckDecision(&controller, rtc::Optional(overall_bitrate), + rtc::Optional(overhead_bytes_per_packet), + rtc::Optional(frame_length_ms), current_bitrate); + + // Next: change overhead. + overhead_bytes_per_packet -= 30; + current_bitrate += 30 * 8 * 1000 / frame_length_ms; + CheckDecision(&controller, rtc::Optional(overall_bitrate), + rtc::Optional(overhead_bytes_per_packet), + rtc::Optional(frame_length_ms), current_bitrate); // Next: change frame length. - current_overhead_bitrate = kPacketOverheadBits * 1000 / 20; - CheckDecision( - &controller, rtc::Optional(overall_bitrate - last_overhead_bitrate), - rtc::Optional(20), overall_bitrate - current_overhead_bitrate); - last_overhead_bitrate = current_overhead_bitrate; + frame_length_ms = 20; + current_bitrate -= overhead_bytes_per_packet * 8 * 1000 / 20 - + overhead_bytes_per_packet * 8 * 1000 / 60; + CheckDecision(&controller, rtc::Optional(overall_bitrate), + rtc::Optional(overhead_bytes_per_packet), + rtc::Optional(frame_length_ms), current_bitrate); // Next: decrease overall bitrate and frame length. overall_bitrate -= 100; - current_overhead_bitrate = kPacketOverheadBits * 1000 / 60; - CheckDecision( - &controller, rtc::Optional(overall_bitrate - last_overhead_bitrate), - rtc::Optional(60), overall_bitrate - current_overhead_bitrate); + current_bitrate -= 100; + frame_length_ms = 60; + current_bitrate += overhead_bytes_per_packet * 8 * 1000 / 20 - + overhead_bytes_per_packet * 8 * 1000 / 60; + + CheckDecision(&controller, rtc::Optional(overall_bitrate), + rtc::Optional(overhead_bytes_per_packet), + rtc::Optional(frame_length_ms), current_bitrate); } } // namespace audio_network_adaptor diff --git a/webrtc/modules/audio_coding/audio_network_adaptor/controller.h b/webrtc/modules/audio_coding/audio_network_adaptor/controller.h index 07806aa000..4f97804317 100644 --- a/webrtc/modules/audio_coding/audio_network_adaptor/controller.h +++ b/webrtc/modules/audio_coding/audio_network_adaptor/controller.h @@ -25,6 +25,7 @@ class Controller { rtc::Optional uplink_packet_loss_fraction; rtc::Optional target_audio_bitrate_bps; rtc::Optional rtt_ms; + rtc::Optional overhead_bytes_per_packet; }; virtual ~Controller() = default; diff --git a/webrtc/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h b/webrtc/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h index f592ce8224..14ddbca0a7 100644 --- a/webrtc/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h +++ b/webrtc/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h @@ -47,6 +47,8 @@ class AudioNetworkAdaptor { virtual void SetTargetAudioBitrate(int target_audio_bitrate_bps) = 0; + virtual void SetOverhead(size_t overhead_bytes_per_packet) = 0; + virtual EncoderRuntimeConfig GetEncoderRuntimeConfig() = 0; virtual void StartDebugDump(FILE* file_handle) = 0; diff --git a/webrtc/modules/audio_coding/audio_network_adaptor/mock/mock_audio_network_adaptor.h b/webrtc/modules/audio_coding/audio_network_adaptor/mock/mock_audio_network_adaptor.h index 44b63c0f7d..a826911c2f 100644 --- a/webrtc/modules/audio_coding/audio_network_adaptor/mock/mock_audio_network_adaptor.h +++ b/webrtc/modules/audio_coding/audio_network_adaptor/mock/mock_audio_network_adaptor.h @@ -30,6 +30,8 @@ class MockAudioNetworkAdaptor : public AudioNetworkAdaptor { MOCK_METHOD1(SetTargetAudioBitrate, void(int target_audio_bitrate_bps)); + MOCK_METHOD1(SetOverhead, void(size_t overhead_bytes_per_packet)); + MOCK_METHOD0(GetEncoderRuntimeConfig, EncoderRuntimeConfig()); MOCK_METHOD1(StartDebugDump, void(FILE* file_handle));