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

Replace Clock with timeutils in AudioEncoder.

Browse Source 
BUG=webrtc:7398

Review-Url: https://codereview.webrtc.org/2782563003
Cr-Commit-Position: refs/heads/master@{#17732}
This commit is contained in:
michaelt 2017-04-18 00:11:48 -07:00 committed by Commit bot
parent 639c487187
commit 92aef17cb2
20 changed files with 140 additions and 170 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
webrtc/common_audio/BUILD.gn
View File

@ -396,6 +396,7 @@ if (rtc_include_tests) {
":sinc_resampler",
"..:webrtc_common",
"../base:rtc_base_approved",
"../base:rtc_base_tests_utils",
"../system_wrappers",
"../test:test_main",
"//testing/gmock",

16
webrtc/common_audio/smoothing_filter.cc
View File

@ -12,30 +12,32 @@
#include <cmath>
#include "webrtc/base/timeutils.h"
namespace webrtc {
SmoothingFilterImpl::SmoothingFilterImpl(int init_time_ms, const Clock* clock)
SmoothingFilterImpl::SmoothingFilterImpl(int init_time_ms)
: init_time_ms_(init_time_ms),
// Duing the initalization time, we use an increasing alpha. Specifically,
// alpha(n) = exp(-powf(init_factor_, n)),
// where |init_factor_| is chosen such that
// alpha(init_time_ms_) = exp(-1.0f / init_time_ms_),
init_factor_(init_time_ms_ == 0 ? 0.0f : powf(init_time_ms_,
-1.0f / init_time_ms_)),
init_factor_(init_time_ms_ == 0
? 0.0f
: powf(init_time_ms_, -1.0f / init_time_ms_)),
// |init_const_| is to a factor to help the calculation during
// initialization phase.
init_const_(init_time_ms_ == 0
? 0.0f
: init_time_ms_ -
powf(init_time_ms_, 1.0f - 1.0f / init_time_ms_)),
clock_(clock) {
powf(init_time_ms_, 1.0f - 1.0f / init_time_ms_)) {
UpdateAlpha(init_time_ms_);
}
SmoothingFilterImpl::~SmoothingFilterImpl() = default;
void SmoothingFilterImpl::AddSample(float sample) {
const int64_t now_ms = clock_->TimeInMilliseconds();
const int64_t now_ms = rtc::TimeMillis();
if (!init_end_time_ms_) {
// This is equivalent to assuming the filter has been receiving the same
@ -55,7 +57,7 @@ rtc::Optional<float> SmoothingFilterImpl::GetAverage() {
// |init_end_time_ms_| undefined since we have not received any sample.
return rtc::Optional<float>();
}
ExtrapolateLastSample(clock_->TimeInMilliseconds());
ExtrapolateLastSample(rtc::TimeMillis());
return rtc::Optional<float>(state_);
}

3
webrtc/common_audio/smoothing_filter.h
View File

@ -40,7 +40,7 @@ class SmoothingFilterImpl final : public SmoothingFilter {
// earlier samples quickly. After the initialization period, the time constant
// will be set to |init_time_ms| first and can be changed through
// |SetTimeConstantMs|.
SmoothingFilterImpl(int init_time_ms, const Clock* clock);
explicit SmoothingFilterImpl(int init_time_ms);
~SmoothingFilterImpl() override;
void AddSample(float sample) override;
@ -57,7 +57,6 @@ class SmoothingFilterImpl final : public SmoothingFilter {
const int init_time_ms_;
const float init_factor_;
const float init_const_;
const Clock* const clock_;
rtc::Optional<int64_t> init_end_time_ms_;
float last_sample_;

65
webrtc/common_audio/smoothing_filter_unittest.cc
View File

@ -11,6 +11,7 @@
#include <cmath>
#include <memory>
#include "webrtc/base/fakeclock.h"
#include "webrtc/common_audio/smoothing_filter.h"
#include "webrtc/test/gtest.h"
@ -22,18 +23,14 @@ constexpr float kMaxAbsError = 1e-5f;
constexpr int64_t kClockInitialTime = 123456;
struct SmoothingFilterStates {
std::unique_ptr<SimulatedClock> simulated_clock;
std::unique_ptr<SmoothingFilterImpl> smoothing_filter;
explicit SmoothingFilterStates(int init_time_ms)
: smoothing_filter(init_time_ms) {
fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(kClockInitialTime));
}
rtc::ScopedFakeClock fake_clock;
SmoothingFilterImpl smoothing_filter;
};
SmoothingFilterStates CreateSmoothingFilter(int init_time_ms) {
SmoothingFilterStates states;
states.simulated_clock.reset(new SimulatedClock(kClockInitialTime));
states.smoothing_filter.reset(
new SmoothingFilterImpl(init_time_ms, states.simulated_clock.get()));
return states;
}
// This function does the following:
// 1. Add a sample to filter at current clock,
// 2. Advance the clock by |advance_time_ms|,
@ -43,9 +40,10 @@ void CheckOutput(SmoothingFilterStates* states,
float sample,
int advance_time_ms,
float expected_ouput) {
states->smoothing_filter->AddSample(sample);
states->simulated_clock->AdvanceTimeMilliseconds(advance_time_ms);
auto output = states->smoothing_filter->GetAverage();
states->smoothing_filter.AddSample(sample);
states->fake_clock.AdvanceTime(
rtc::TimeDelta::FromMilliseconds(advance_time_ms));
auto output = states->smoothing_filter.GetAverage();
EXPECT_TRUE(output);
EXPECT_NEAR(expected_ouput, *output, kMaxAbsError);
}
@ -54,8 +52,8 @@ void CheckOutput(SmoothingFilterStates* states,
TEST(SmoothingFilterTest, NoOutputWhenNoSampleAdded) {
constexpr int kInitTimeMs = 100;
auto states = CreateSmoothingFilter(kInitTimeMs);
EXPECT_FALSE(states.smoothing_filter->GetAverage());
SmoothingFilterStates states(kInitTimeMs);
EXPECT_FALSE(states.smoothing_filter.GetAverage());
}
// Python script to calculate the reference values used in this test.
@ -104,7 +102,7 @@ TEST(SmoothingFilterTest, NoOutputWhenNoSampleAdded) {
// print filter.state
TEST(SmoothingFilterTest, CheckBehaviorAroundInitTime) {
constexpr int kInitTimeMs = 795;
auto states = CreateSmoothingFilter(kInitTimeMs);
SmoothingFilterStates states(kInitTimeMs);
CheckOutput(&states, 1.0f, 500, 1.0f);
CheckOutput(&states, 0.5f, 100, 0.680562264029f);
CheckOutput(&states, 1.0f, 100, 0.794207139813f);
@ -116,50 +114,51 @@ TEST(SmoothingFilterTest, CheckBehaviorAroundInitTime) {
TEST(SmoothingFilterTest, InitTimeEqualsZero) {
constexpr int kInitTimeMs = 0;
auto states = CreateSmoothingFilter(kInitTimeMs);
SmoothingFilterStates states(kInitTimeMs);
CheckOutput(&states, 1.0f, 1, 1.0f);
CheckOutput(&states, 0.5f, 1, 0.5f);
}
TEST(SmoothingFilterTest, InitTimeEqualsOne) {
constexpr int kInitTimeMs = 1;
auto states = CreateSmoothingFilter(kInitTimeMs);
SmoothingFilterStates states(kInitTimeMs);
CheckOutput(&states, 1.0f, 1, 1.0f);
CheckOutput(&states, 0.5f, 1, 1.0f * exp(-1.0f) + (1.0f - exp(-1.0f)) * 0.5f);
}
TEST(SmoothingFilterTest, GetAverageOutputsEmptyBeforeFirstSample) {
constexpr int kInitTimeMs = 100;
auto states = CreateSmoothingFilter(kInitTimeMs);
EXPECT_FALSE(states.smoothing_filter->GetAverage());
SmoothingFilterStates states(kInitTimeMs);
EXPECT_FALSE(states.smoothing_filter.GetAverage());
constexpr float kFirstSample = 1.2345f;
states.smoothing_filter->AddSample(kFirstSample);
states.smoothing_filter.AddSample(kFirstSample);
EXPECT_EQ(rtc::Optional<float>(kFirstSample),
states.smoothing_filter->GetAverage());
states.smoothing_filter.GetAverage());
}
TEST(SmoothingFilterTest, CannotChangeTimeConstantDuringInitialization) {
constexpr int kInitTimeMs = 100;
auto states = CreateSmoothingFilter(kInitTimeMs);
states.smoothing_filter->AddSample(0.0);
SmoothingFilterStates states(kInitTimeMs);
states.smoothing_filter.AddSample(0.0);
// During initialization, |SetTimeConstantMs| does not take effect.
states.simulated_clock->AdvanceTimeMilliseconds(kInitTimeMs - 1);
states.smoothing_filter->AddSample(0.0);
states.fake_clock.AdvanceTime(
rtc::TimeDelta::FromMilliseconds(kInitTimeMs - 1));
states.smoothing_filter.AddSample(0.0);
EXPECT_FALSE(states.smoothing_filter->SetTimeConstantMs(kInitTimeMs * 2));
EXPECT_NE(exp(-1.0f / (kInitTimeMs * 2)), states.smoothing_filter->alpha());
EXPECT_FALSE(states.smoothing_filter.SetTimeConstantMs(kInitTimeMs * 2));
EXPECT_NE(exp(-1.0f / (kInitTimeMs * 2)), states.smoothing_filter.alpha());
states.simulated_clock->AdvanceTimeMilliseconds(1);
states.smoothing_filter->AddSample(0.0);
states.fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(1));
states.smoothing_filter.AddSample(0.0);
// When initialization finishes, the time constant should be come
// |kInitTimeConstantMs|.
EXPECT_FLOAT_EQ(exp(-1.0f / kInitTimeMs), states.smoothing_filter->alpha());
EXPECT_FLOAT_EQ(exp(-1.0f / kInitTimeMs), states.smoothing_filter.alpha());
// After initialization, |SetTimeConstantMs| takes effect.
EXPECT_TRUE(states.smoothing_filter->SetTimeConstantMs(kInitTimeMs * 2));
EXPECT_TRUE(states.smoothing_filter.SetTimeConstantMs(kInitTimeMs * 2));
EXPECT_FLOAT_EQ(exp(-1.0f / (kInitTimeMs * 2)),
states.smoothing_filter->alpha());
states.smoothing_filter.alpha());
}
} // namespace webrtc

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

@ -13,6 +13,7 @@
#include <utility>
#include "webrtc/base/logging.h"
#include "webrtc/base/timeutils.h"
namespace webrtc {
@ -22,8 +23,7 @@ constexpr float kEventLogMinBitrateChangeFraction = 0.25;
constexpr float kEventLogMinPacketLossChangeFraction = 0.5;
} // namespace
AudioNetworkAdaptorImpl::Config::Config()
: event_log(nullptr), clock(nullptr){};
AudioNetworkAdaptorImpl::Config::Config() : event_log(nullptr){};
AudioNetworkAdaptorImpl::Config::~Config() = default;
@ -119,8 +119,7 @@ AudioEncoderRuntimeConfig AudioNetworkAdaptorImpl::GetEncoderRuntimeConfig() {
controller->MakeDecision(&config);
if (debug_dump_writer_)
debug_dump_writer_->DumpEncoderRuntimeConfig(
config, config_.clock->TimeInMilliseconds());
debug_dump_writer_->DumpEncoderRuntimeConfig(config, rtc::TimeMillis());
if (event_log_writer_)
event_log_writer_->MaybeLogEncoderConfig(config);
@ -138,8 +137,7 @@ void AudioNetworkAdaptorImpl::StopDebugDump() {
void AudioNetworkAdaptorImpl::DumpNetworkMetrics() {
if (debug_dump_writer_)
debug_dump_writer_->DumpNetworkMetrics(last_metrics_,
config_.clock->TimeInMilliseconds());
debug_dump_writer_->DumpNetworkMetrics(last_metrics_, rtc::TimeMillis());
}
void AudioNetworkAdaptorImpl::UpdateNetworkMetrics(

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

@ -19,7 +19,6 @@
#include "webrtc/modules/audio_coding/audio_network_adaptor/debug_dump_writer.h"
#include "webrtc/modules/audio_coding/audio_network_adaptor/event_log_writer.h"
#include "webrtc/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
#include "webrtc/system_wrappers/include/clock.h"
namespace webrtc {
@ -31,7 +30,6 @@ class AudioNetworkAdaptorImpl final : public AudioNetworkAdaptor {
Config();
~Config();
RtcEventLog* event_log;
const Clock* clock;
};
AudioNetworkAdaptorImpl(

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

@ -11,6 +11,7 @@
#include <utility>
#include <vector>
#include "webrtc/base/fakeclock.h"
#include "webrtc/logging/rtc_event_log/mock/mock_rtc_event_log.h"
#include "webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.h"
#include "webrtc/modules/audio_coding/audio_network_adaptor/mock/mock_controller.h"
@ -55,7 +56,6 @@ MATCHER_P(EncoderRuntimeConfigIs, config, "") {
struct AudioNetworkAdaptorStates {
std::unique_ptr<AudioNetworkAdaptorImpl> audio_network_adaptor;
std::vector<std::unique_ptr<MockController>> mock_controllers;
std::unique_ptr<SimulatedClock> simulated_clock;
std::unique_ptr<MockRtcEventLog> event_log;
MockDebugDumpWriter* mock_debug_dump_writer;
};
@ -80,7 +80,6 @@ AudioNetworkAdaptorStates CreateAudioNetworkAdaptor() {
EXPECT_CALL(*controller_manager, GetSortedControllers(_))
.WillRepeatedly(Return(controllers));
states.simulated_clock.reset(new SimulatedClock(kClockInitialTimeMs * 1000));
states.event_log.reset(new NiceMock<MockRtcEventLog>());
auto debug_dump_writer =
@ -89,7 +88,6 @@ AudioNetworkAdaptorStates CreateAudioNetworkAdaptor() {
states.mock_debug_dump_writer = debug_dump_writer.get();
AudioNetworkAdaptorImpl::Config config;
config.clock = states.simulated_clock.get();
config.event_log = states.event_log.get();
// AudioNetworkAdaptorImpl governs the lifetime of controller manager.
states.audio_network_adaptor.reset(new AudioNetworkAdaptorImpl(
@ -180,8 +178,9 @@ TEST(AudioNetworkAdaptorImplTest,
TEST(AudioNetworkAdaptorImplTest,
DumpEncoderRuntimeConfigIsCalledOnGetEncoderRuntimeConfig) {
rtc::ScopedFakeClock fake_clock;
fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(kClockInitialTimeMs));
auto states = CreateAudioNetworkAdaptor();
AudioEncoderRuntimeConfig config;
config.bitrate_bps = rtc::Optional<int>(32000);
config.enable_fec = rtc::Optional<bool>(true);
@ -197,6 +196,9 @@ TEST(AudioNetworkAdaptorImplTest,
TEST(AudioNetworkAdaptorImplTest,
DumpNetworkMetricsIsCalledOnSetNetworkMetrics) {
rtc::ScopedFakeClock fake_clock;
fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(kClockInitialTimeMs));
auto states = CreateAudioNetworkAdaptor();
constexpr int kBandwidth = 16000;
@ -214,14 +216,14 @@ TEST(AudioNetworkAdaptorImplTest,
DumpNetworkMetrics(NetworkMetricsIs(check), timestamp_check));
states.audio_network_adaptor->SetUplinkBandwidth(kBandwidth);
states.simulated_clock->AdvanceTimeMilliseconds(100);
fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(100));
timestamp_check += 100;
check.uplink_packet_loss_fraction = rtc::Optional<float>(kPacketLoss);
EXPECT_CALL(*states.mock_debug_dump_writer,
DumpNetworkMetrics(NetworkMetricsIs(check), timestamp_check));
states.audio_network_adaptor->SetUplinkPacketLossFraction(kPacketLoss);
states.simulated_clock->AdvanceTimeMilliseconds(50);
fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(50));
timestamp_check += 50;
check.uplink_recoverable_packet_loss_fraction =
rtc::Optional<float>(kRecoverablePacketLoss);
@ -230,21 +232,21 @@ TEST(AudioNetworkAdaptorImplTest,
states.audio_network_adaptor->SetUplinkRecoverablePacketLossFraction(
kRecoverablePacketLoss);
states.simulated_clock->AdvanceTimeMilliseconds(200);
fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(200));
timestamp_check += 200;
check.rtt_ms = rtc::Optional<int>(kRtt);
EXPECT_CALL(*states.mock_debug_dump_writer,
DumpNetworkMetrics(NetworkMetricsIs(check), timestamp_check));
states.audio_network_adaptor->SetRtt(kRtt);
states.simulated_clock->AdvanceTimeMilliseconds(150);
fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(150));
timestamp_check += 150;
check.target_audio_bitrate_bps = rtc::Optional<int>(kTargetAudioBitrate);
EXPECT_CALL(*states.mock_debug_dump_writer,
DumpNetworkMetrics(NetworkMetricsIs(check), timestamp_check));
states.audio_network_adaptor->SetTargetAudioBitrate(kTargetAudioBitrate);
states.simulated_clock->AdvanceTimeMilliseconds(50);
fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(50));
timestamp_check += 50;
check.overhead_bytes_per_packet = rtc::Optional<size_t>(kOverhead);
EXPECT_CALL(*states.mock_debug_dump_writer,

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

@ -14,6 +14,7 @@
#include <utility>
#include "webrtc/base/ignore_wundef.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/modules/audio_coding/audio_network_adaptor/bitrate_controller.h"
#include "webrtc/modules/audio_coding/audio_network_adaptor/channel_controller.h"
#include "webrtc/modules/audio_coding/audio_network_adaptor/dtx_controller.h"
@ -21,7 +22,6 @@
#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/modules/audio_coding/audio_network_adaptor/util/threshold_curve.h"
#include "webrtc/system_wrappers/include/clock.h"
#ifdef WEBRTC_AUDIO_NETWORK_ADAPTOR_DEBUG_DUMP
RTC_PUSH_IGNORING_WUNDEF()
@ -41,8 +41,7 @@ namespace {
std::unique_ptr<FecControllerPlrBased> CreateFecControllerPlrBased(
const audio_network_adaptor::config::FecController& config,
bool initial_fec_enabled,
const Clock* clock) {
bool initial_fec_enabled) {
RTC_CHECK(config.has_fec_enabling_threshold());
RTC_CHECK(config.has_fec_disabling_threshold());
RTC_CHECK(config.has_time_constant_ms());
@ -70,7 +69,7 @@ std::unique_ptr<FecControllerPlrBased> CreateFecControllerPlrBased(
fec_disabling_threshold.low_bandwidth_packet_loss(),
fec_disabling_threshold.high_bandwidth_bps(),
fec_disabling_threshold.high_bandwidth_packet_loss()),
config.time_constant_ms(), clock)));
config.time_constant_ms())));
}
std::unique_ptr<FecControllerRplrBased> CreateFecControllerRplrBased(
@ -186,11 +185,9 @@ std::unique_ptr<BitrateController> CreateBitrateController(
} // namespace
ControllerManagerImpl::Config::Config(int min_reordering_time_ms,
float min_reordering_squared_distance,
const Clock* clock)
float min_reordering_squared_distance)
: min_reordering_time_ms(min_reordering_time_ms),
min_reordering_squared_distance(min_reordering_squared_distance),
clock(clock) {}
min_reordering_squared_distance(min_reordering_squared_distance) {}
ControllerManagerImpl::Config::~Config() = default;
@ -203,8 +200,7 @@ std::unique_ptr<ControllerManager> ControllerManagerImpl::Create(
int initial_frame_length_ms,
int initial_bitrate_bps,
bool initial_fec_enabled,
bool initial_dtx_enabled,
const Clock* clock) {
bool initial_dtx_enabled) {
#ifdef WEBRTC_AUDIO_NETWORK_ADAPTOR_DEBUG_DUMP
audio_network_adaptor::config::ControllerManager controller_manager_config;
controller_manager_config.ParseFromString(config_string);
@ -218,7 +214,7 @@ std::unique_ptr<ControllerManager> ControllerManagerImpl::Create(
switch (controller_config.controller_case()) {
case audio_network_adaptor::config::Controller::kFecController:
controller = CreateFecControllerPlrBased(
controller_config.fec_controller(), initial_fec_enabled, clock);
controller_config.fec_controller(), initial_fec_enabled);
break;
case audio_network_adaptor::config::Controller::kFecControllerRplrBased:
controller = CreateFecControllerRplrBased(
@ -262,7 +258,7 @@ std::unique_ptr<ControllerManager> ControllerManagerImpl::Create(
return std::unique_ptr<ControllerManagerImpl>(new ControllerManagerImpl(
ControllerManagerImpl::Config(
controller_manager_config.min_reordering_time_ms(),
controller_manager_config.min_reordering_squared_distance(), clock),
controller_manager_config.min_reordering_squared_distance()),
std::move(controllers), chracteristic_points));
#else
RTC_NOTREACHED();
@ -299,7 +295,7 @@ ControllerManagerImpl::~ControllerManagerImpl() = default;
std::vector<Controller*> ControllerManagerImpl::GetSortedControllers(
const Controller::NetworkMetrics& metrics) {
int64_t now_ms = config_.clock->TimeInMilliseconds();
int64_t now_ms = rtc::TimeMillis();
if (!metrics.uplink_bandwidth_bps || !metrics.uplink_packet_loss_fraction)
return sorted_controllers_;

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

@ -21,8 +21,6 @@
namespace webrtc {
class Clock;
class ControllerManager {
public:
virtual ~ControllerManager() = default;
@ -37,16 +35,13 @@ class ControllerManager {
class ControllerManagerImpl final : public ControllerManager {
public:
struct Config {
Config(int min_reordering_time_ms,
float min_reordering_squared_distance,
const Clock* clock);
Config(int min_reordering_time_ms, float min_reordering_squared_distance);
~Config();
// Least time since last reordering for a new reordering to be made.
int min_reordering_time_ms;
// Least squared distance from last scoring point for a new reordering to be
// made.
float min_reordering_squared_distance;
const Clock* clock;
};
static std::unique_ptr<ControllerManager> Create(
@ -58,8 +53,7 @@ class ControllerManagerImpl final : public ControllerManager {
int initial_frame_length_ms,
int initial_bitrate_bps,
bool initial_fec_enabled,
bool initial_dtx_enabled,
const Clock* clock);
bool initial_dtx_enabled);
explicit ControllerManagerImpl(const Config& config);

31
webrtc/modules/audio_coding/audio_network_adaptor/controller_manager_unittest.cc
View File

@ -10,11 +10,11 @@
#include <utility>
#include "webrtc/base/fakeclock.h"
#include "webrtc/base/ignore_wundef.h"
#include "webrtc/base/protobuf_utils.h"
#include "webrtc/modules/audio_coding/audio_network_adaptor/controller_manager.h"
#include "webrtc/modules/audio_coding/audio_network_adaptor/mock/mock_controller.h"
#include "webrtc/system_wrappers/include/clock.h"
#include "webrtc/test/gtest.h"
#ifdef WEBRTC_AUDIO_NETWORK_ADAPTOR_DEBUG_DUMP
@ -47,12 +47,9 @@ constexpr int kMaxUplinkBandwidthBps = 120000;
constexpr int kMinBandwithChangeBps =
(kMaxUplinkBandwidthBps - kMinUplinkBandwidthBps) / kFactor;
constexpr int64_t kClockInitialTime = 123456789;
struct ControllerManagerStates {
std::unique_ptr<ControllerManager> controller_manager;
std::vector<MockController*> mock_controllers;
std::unique_ptr<SimulatedClock> simulated_clock;
};
ControllerManagerStates CreateControllerManager() {
@ -75,11 +72,9 @@ ControllerManagerStates CreateControllerManager() {
std::make_pair(kChracteristicBandwithBps[1],
kChracteristicPacketLossFraction[1]);
states.simulated_clock.reset(new SimulatedClock(kClockInitialTime));
states.controller_manager.reset(new ControllerManagerImpl(
ControllerManagerImpl::Config(kMinReorderingTimeMs,
kMinReorderingSquareDistance,
states.simulated_clock.get()),
kMinReorderingSquareDistance),
std::move(controllers), chracteristic_points));
return states;
}
@ -147,12 +142,14 @@ TEST(ControllerManagerTest, ControllersWithCharPointDependOnNetworkMetrics) {
}
TEST(ControllerManagerTest, DoNotReorderBeforeMinReordingTime) {
rtc::ScopedFakeClock fake_clock;
auto states = CreateControllerManager();
CheckControllersOrder(
&states, rtc::Optional<int>(kChracteristicBandwithBps[0]),
rtc::Optional<float>(kChracteristicPacketLossFraction[0]),
{kNumControllers - 2, kNumControllers - 1, 0, 1});
states.simulated_clock->AdvanceTimeMilliseconds(kMinReorderingTimeMs - 1);
fake_clock.AdvanceTime(
rtc::TimeDelta::FromMilliseconds(kMinReorderingTimeMs - 1));
// Move uplink bandwidth and packet loss fraction to the other controller's
// characteristic point, which would cause controller manager to reorder the
// controllers if time had reached min reordering time.
@ -163,6 +160,7 @@ TEST(ControllerManagerTest, DoNotReorderBeforeMinReordingTime) {
}
TEST(ControllerManagerTest, ReorderBeyondMinReordingTimeAndMinDistance) {
rtc::ScopedFakeClock fake_clock;
auto states = CreateControllerManager();
constexpr int kBandwidthBps =
(kChracteristicBandwithBps[0] + kChracteristicBandwithBps[1]) / 2;
@ -174,7 +172,8 @@ TEST(ControllerManagerTest, ReorderBeyondMinReordingTimeAndMinDistance) {
CheckControllersOrder(&states, rtc::Optional<int>(kBandwidthBps),
rtc::Optional<float>(kPacketLossFraction),
{kNumControllers - 2, kNumControllers - 1, 0, 1});
states.simulated_clock->AdvanceTimeMilliseconds(kMinReorderingTimeMs);
fake_clock.AdvanceTime(
rtc::TimeDelta::FromMilliseconds(kMinReorderingTimeMs));
// Then let network metrics move a little towards the other controller.
CheckControllersOrder(
&states, rtc::Optional<int>(kBandwidthBps - kMinBandwithChangeBps - 1),
@ -183,6 +182,7 @@ TEST(ControllerManagerTest, ReorderBeyondMinReordingTimeAndMinDistance) {
}
TEST(ControllerManagerTest, DoNotReorderIfNetworkMetricsChangeTooSmall) {
rtc::ScopedFakeClock fake_clock;
auto states = CreateControllerManager();
constexpr int kBandwidthBps =
(kChracteristicBandwithBps[0] + kChracteristicBandwithBps[1]) / 2;
@ -194,7 +194,8 @@ TEST(ControllerManagerTest, DoNotReorderIfNetworkMetricsChangeTooSmall) {
CheckControllersOrder(&states, rtc::Optional<int>(kBandwidthBps),
rtc::Optional<float>(kPacketLossFraction),
{kNumControllers - 2, kNumControllers - 1, 0, 1});
states.simulated_clock->AdvanceTimeMilliseconds(kMinReorderingTimeMs);
fake_clock.AdvanceTime(
rtc::TimeDelta::FromMilliseconds(kMinReorderingTimeMs));
// Then let network metrics move a little towards the other controller.
CheckControllersOrder(
&states, rtc::Optional<int>(kBandwidthBps - kMinBandwithChangeBps + 1),
@ -276,14 +277,12 @@ constexpr int kMinBitrateBps = 6000;
ControllerManagerStates CreateControllerManager(
const ProtoString& config_string) {
ControllerManagerStates states;
states.simulated_clock.reset(new SimulatedClock(kClockInitialTime));
constexpr size_t kNumEncoderChannels = 2;
const std::vector<int> encoder_frame_lengths_ms = {20, 60};
states.controller_manager = ControllerManagerImpl::Create(
config_string, kNumEncoderChannels, encoder_frame_lengths_ms,
kMinBitrateBps, kIntialChannelsToEncode, kInitialFrameLengthMs,
kInitialBitrateBps, kInitialFecEnabled, kInitialDtxEnabled,
states.simulated_clock.get());
kInitialBitrateBps, kInitialFecEnabled, kInitialDtxEnabled);
return states;
}
@ -361,6 +360,7 @@ TEST(ControllerManagerTest, CreateFromConfigStringAndCheckDefaultOrder) {
}
TEST(ControllerManagerTest, CreateFromConfigStringAndCheckReordering) {
rtc::ScopedFakeClock fake_clock;
audio_network_adaptor::config::ControllerManager config;
config.set_min_reordering_time_ms(kMinReorderingTimeMs);
config.set_min_reordering_squared_distance(kMinReorderingSquareDistance);
@ -399,7 +399,8 @@ TEST(ControllerManagerTest, CreateFromConfigStringAndCheckReordering) {
rtc::Optional<int>(kChracteristicBandwithBps[1]);
metrics.uplink_packet_loss_fraction =
rtc::Optional<float>(kChracteristicPacketLossFraction[1]);
states.simulated_clock->AdvanceTimeMilliseconds(kMinReorderingTimeMs - 1);
fake_clock.AdvanceTime(
rtc::TimeDelta::FromMilliseconds(kMinReorderingTimeMs - 1));
controllers = states.controller_manager->GetSortedControllers(metrics);
// Should not reorder since min reordering time is not met.
CheckControllersOrder(controllers,
@ -408,7 +409,7 @@ TEST(ControllerManagerTest, CreateFromConfigStringAndCheckReordering) {
ControllerType::CHANNEL, ControllerType::DTX,
ControllerType::BIT_RATE});
states.simulated_clock->AdvanceTimeMilliseconds(1);
fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(1));
controllers = states.controller_manager->GetSortedControllers(metrics);
// Reorder now.
CheckControllersOrder(controllers,

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

@ -41,13 +41,11 @@ FecControllerPlrBased::Config::Config(
bool initial_fec_enabled,
const ThresholdCurve& fec_enabling_threshold,
const ThresholdCurve& fec_disabling_threshold,
int time_constant_ms,
const Clock* clock)
int time_constant_ms)
: 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) {}
time_constant_ms(time_constant_ms) {}
FecControllerPlrBased::FecControllerPlrBased(
const Config& config,
@ -64,8 +62,7 @@ FecControllerPlrBased::FecControllerPlrBased(const Config& config)
webrtc::field_trial::FindFullName("UseTwccPlrForAna") == "Enabled"
? std::unique_ptr<NullSmoothingFilter>(new NullSmoothingFilter())
: std::unique_ptr<SmoothingFilter>(
new SmoothingFilterImpl(config.time_constant_ms,
config.clock))) {}
new SmoothingFilterImpl(config.time_constant_ms))) {}
FecControllerPlrBased::~FecControllerPlrBased() = default;

4
webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based.h
View File

@ -36,13 +36,11 @@ class FecControllerPlrBased final : public Controller {
Config(bool initial_fec_enabled,
const ThresholdCurve& fec_enabling_threshold,
const ThresholdCurve& fec_disabling_threshold,
int time_constant_ms,
const Clock* clock);
int time_constant_ms);
bool initial_fec_enabled;
ThresholdCurve fec_enabling_threshold;
ThresholdCurve fec_disabling_threshold;
int time_constant_ms;
const Clock* clock;
};
// Dependency injection for testing.

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

@ -63,7 +63,7 @@ FecControllerPlrBasedTestStates CreateFecControllerPlrBased(
kEnablingBandwidthHigh, kEnablingPacketLossAtHighBw),
ThresholdCurve(kDisablingBandwidthLow, kDisablingPacketLossAtLowBw,
kDisablingBandwidthHigh, kDisablingPacketLossAtHighBw),
0, nullptr),
0),
std::move(mock_smoothing_filter)));
return states;
}
@ -319,7 +319,7 @@ TEST(FecControllerPlrBasedTest, CheckBehaviorOnSpecialCurves) {
kEnablingBandwidthHigh, kEnablingPacketLossAtHighBw),
ThresholdCurve(kDisablingBandwidthLow, kDisablingPacketLossAtLowBw,
kDisablingBandwidthHigh, kDisablingPacketLossAtHighBw),
0, nullptr),
0),
std::move(mock_smoothing_filter)));
UpdateNetworkMetrics(&states, rtc::Optional<int>(kDisablingBandwidthLow - 1),
@ -361,7 +361,7 @@ TEST(FecControllerPlrBasedDeathTest, InvalidConfig) {
ThresholdCurve(
kDisablingBandwidthLow, kDisablingPacketLossAtLowBw,
kDisablingBandwidthHigh, kDisablingPacketLossAtHighBw),
0, nullptr),
0),
std::move(mock_smoothing_filter))),
"Check failed");
}

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

@ -66,8 +66,7 @@ rtc::ArrayView<std::unique_ptr<AudioEncoder>>
AudioEncoder::ReclaimContainedEncoders() { return nullptr; }
bool AudioEncoder::EnableAudioNetworkAdaptor(const std::string& config_string,
RtcEventLog* event_log,
const Clock* clock) {
RtcEventLog* event_log) {
return false;
}

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

@ -164,8 +164,7 @@ class AudioEncoder {
// Enables audio network adaptor. Returns true if successful.
virtual bool EnableAudioNetworkAdaptor(const std::string& config_string,
RtcEventLog* event_log,
const Clock* clock);
RtcEventLog* event_log);
// Disables audio network adaptor.
virtual void DisableAudioNetworkAdaptor();

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

@ -284,9 +284,8 @@ AudioEncoderOpus::Config AudioEncoderOpus::CreateConfig(
class AudioEncoderOpus::PacketLossFractionSmoother {
public:
explicit PacketLossFractionSmoother(const Clock* clock)
: clock_(clock),
last_sample_time_ms_(clock_->TimeInMilliseconds()),
explicit PacketLossFractionSmoother()
: last_sample_time_ms_(rtc::TimeMillis()),
smoother_(kAlphaForPacketLossFractionSmoother) {}
// Gets the smoothed packet loss fraction.
@ -297,14 +296,13 @@ class AudioEncoderOpus::PacketLossFractionSmoother {
// Add new observation to the packet loss fraction smoother.
void AddSample(float packet_loss_fraction) {
int64_t now_ms = clock_->TimeInMilliseconds();
int64_t now_ms = rtc::TimeMillis();
smoother_.Apply(static_cast<float>(now_ms - last_sample_time_ms_),
packet_loss_fraction);
last_sample_time_ms_ = now_ms;
}
private:
const Clock* const clock_;
int64_t last_sample_time_ms_;
// An exponential filter is used to smooth the packet loss fraction.
@ -366,21 +364,19 @@ AudioEncoderOpus::AudioEncoderOpus(
"WebRTC-SendSideBwe-WithOverhead")),
packet_loss_rate_(0.0),
inst_(nullptr),
packet_loss_fraction_smoother_(new PacketLossFractionSmoother(
config.clock)),
packet_loss_fraction_smoother_(new PacketLossFractionSmoother()),
audio_network_adaptor_creator_(
audio_network_adaptor_creator
? std::move(audio_network_adaptor_creator)
: [this](const ProtoString& config_string,
RtcEventLog* event_log,
const Clock* clock) {
RtcEventLog* event_log) {
return DefaultAudioNetworkAdaptorCreator(config_string,
event_log, clock);
event_log);
}),
bitrate_smoother_(bitrate_smoother
? std::move(bitrate_smoother) : std::unique_ptr<SmoothingFilter>(
// We choose 5sec as initial time constant due to empirical data.
new SmoothingFilterImpl(5000, config.clock))) {
new SmoothingFilterImpl(5000))) {
RTC_CHECK(RecreateEncoderInstance(config));
}
@ -464,10 +460,9 @@ void AudioEncoderOpus::SetMaxPlaybackRate(int frequency_hz) {
bool AudioEncoderOpus::EnableAudioNetworkAdaptor(
const std::string& config_string,
RtcEventLog* event_log,
const Clock* clock) {
RtcEventLog* event_log) {
audio_network_adaptor_ =
audio_network_adaptor_creator_(config_string, event_log, clock);
audio_network_adaptor_creator_(config_string, event_log);
return audio_network_adaptor_.get() != nullptr;
}
@ -723,17 +718,15 @@ void AudioEncoderOpus::ApplyAudioNetworkAdaptor() {
std::unique_ptr<AudioNetworkAdaptor>
AudioEncoderOpus::DefaultAudioNetworkAdaptorCreator(
const ProtoString& config_string,
RtcEventLog* event_log,
const Clock* clock) const {
RtcEventLog* event_log) const {
AudioNetworkAdaptorImpl::Config config;
config.clock = clock;
config.event_log = event_log;
return std::unique_ptr<AudioNetworkAdaptor>(new AudioNetworkAdaptorImpl(
config,
ControllerManagerImpl::Create(
config_string, NumChannels(), supported_frame_lengths_ms(),
kOpusMinBitrateBps, num_channels_to_encode_, next_frame_length_ms_,
GetTargetBitrate(), config_.fec_enabled, GetDtx(), clock)));
GetTargetBitrate(), config_.fec_enabled, GetDtx())));
}
void AudioEncoderOpus::MaybeUpdateUplinkBandwidth() {

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

@ -69,7 +69,6 @@ class AudioEncoderOpus final : public AudioEncoder {
int complexity_threshold_window_bps = 1500;
bool dtx_enabled = false;
std::vector<int> supported_frame_lengths_ms;
const Clock* clock = Clock::GetRealTimeClock();
int uplink_bandwidth_update_interval_ms = 200;
private:
@ -87,8 +86,7 @@ class AudioEncoderOpus final : public AudioEncoder {
using AudioNetworkAdaptorCreator =
std::function<std::unique_ptr<AudioNetworkAdaptor>(const std::string&,
RtcEventLog*,
const Clock*)>;
RtcEventLog*)>;
AudioEncoderOpus(
const Config& config,
AudioNetworkAdaptorCreator&& audio_network_adaptor_creator = nullptr,
@ -121,8 +119,7 @@ class AudioEncoderOpus final : public AudioEncoder {
bool SetApplication(Application application) override;
void SetMaxPlaybackRate(int frequency_hz) override;
bool EnableAudioNetworkAdaptor(const std::string& config_string,
RtcEventLog* event_log,
const Clock* clock) override;
RtcEventLog* event_log) override;
void DisableAudioNetworkAdaptor() override;
void OnReceivedUplinkPacketLossFraction(
float uplink_packet_loss_fraction) override;
@ -169,8 +166,7 @@ class AudioEncoderOpus final : public AudioEncoder {
void ApplyAudioNetworkAdaptor();
std::unique_ptr<AudioNetworkAdaptor> DefaultAudioNetworkAdaptorCreator(
const ProtoString& config_string,
RtcEventLog* event_log,
const Clock* clock) const;
RtcEventLog* event_log) const;
void MaybeUpdateUplinkBandwidth();

55
webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus_unittest.cc
View File

@ -23,7 +23,6 @@
#include "webrtc/test/gmock.h"
#include "webrtc/test/gtest.h"
#include "webrtc/test/testsupport/fileutils.h"
#include "webrtc/system_wrappers/include/clock.h"
namespace webrtc {
using ::testing::NiceMock;
@ -56,7 +55,7 @@ struct AudioEncoderOpusStates {
std::shared_ptr<MockAudioNetworkAdaptor*> mock_audio_network_adaptor;
MockSmoothingFilter* mock_bitrate_smoother;
std::unique_ptr<AudioEncoderOpus> encoder;
std::unique_ptr<SimulatedClock> simulated_clock;
std::unique_ptr<rtc::ScopedFakeClock> fake_clock;
AudioEncoderOpus::Config config;
};
@ -64,21 +63,22 @@ AudioEncoderOpusStates CreateCodec(size_t num_channels) {
AudioEncoderOpusStates states;
states.mock_audio_network_adaptor =
std::make_shared<MockAudioNetworkAdaptor*>(nullptr);
states.fake_clock.reset(new rtc::ScopedFakeClock());
states.fake_clock->SetTimeMicros(kInitialTimeUs);
std::weak_ptr<MockAudioNetworkAdaptor*> mock_ptr(
states.mock_audio_network_adaptor);
AudioEncoderOpus::AudioNetworkAdaptorCreator creator = [mock_ptr](
const std::string&, RtcEventLog* event_log, const Clock*) {
std::unique_ptr<MockAudioNetworkAdaptor> adaptor(
new NiceMock<MockAudioNetworkAdaptor>());
EXPECT_CALL(*adaptor, Die());
if (auto sp = mock_ptr.lock()) {
*sp = adaptor.get();
} else {
RTC_NOTREACHED();
}
return adaptor;
};
AudioEncoderOpus::AudioNetworkAdaptorCreator creator =
[mock_ptr](const std::string&, RtcEventLog* event_log) {
std::unique_ptr<MockAudioNetworkAdaptor> adaptor(
new NiceMock<MockAudioNetworkAdaptor>());
EXPECT_CALL(*adaptor, Die());
if (auto sp = mock_ptr.lock()) {
*sp = adaptor.get();
} else {
RTC_NOTREACHED();
}
return adaptor;
};
CodecInst codec_inst = kDefaultOpusSettings;
codec_inst.channels = num_channels;
@ -86,8 +86,6 @@ AudioEncoderOpusStates CreateCodec(size_t num_channels) {
std::unique_ptr<MockSmoothingFilter> bitrate_smoother(
new MockSmoothingFilter());
states.mock_bitrate_smoother = bitrate_smoother.get();
states.simulated_clock.reset(new SimulatedClock(kInitialTimeUs));
states.config.clock = states.simulated_clock.get();
states.encoder.reset(new AudioEncoderOpus(states.config, std::move(creator),
std::move(bitrate_smoother)));
@ -244,7 +242,8 @@ void TestSetPacketLossRate(AudioEncoderOpusStates* states,
constexpr int64_t kSampleIntervalMs = 184198;
for (float loss : losses) {
states->encoder->OnReceivedUplinkPacketLossFraction(loss);
states->simulated_clock->AdvanceTimeMilliseconds(kSampleIntervalMs);
states->fake_clock->AdvanceTime(
rtc::TimeDelta::FromMilliseconds(kSampleIntervalMs));
EXPECT_FLOAT_EQ(expected_return, states->encoder->packet_loss_rate());
}
}
@ -291,7 +290,7 @@ TEST(AudioEncoderOpusTest, SetReceiverFrameLengthRange) {
TEST(AudioEncoderOpusTest,
InvokeAudioNetworkAdaptorOnReceivedUplinkPacketLossFraction) {
auto states = CreateCodec(2);
states.encoder->EnableAudioNetworkAdaptor("", nullptr, nullptr);
states.encoder->EnableAudioNetworkAdaptor("", nullptr);
auto config = CreateEncoderRuntimeConfig();
EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig())
@ -308,7 +307,7 @@ TEST(AudioEncoderOpusTest,
TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnReceivedUplinkBandwidth) {
auto states = CreateCodec(2);
states.encoder->EnableAudioNetworkAdaptor("", nullptr, nullptr);
states.encoder->EnableAudioNetworkAdaptor("", nullptr);
auto config = CreateEncoderRuntimeConfig();
EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig())
@ -330,7 +329,7 @@ TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnReceivedUplinkBandwidth) {
TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnReceivedRtt) {
auto states = CreateCodec(2);
states.encoder->EnableAudioNetworkAdaptor("", nullptr, nullptr);
states.encoder->EnableAudioNetworkAdaptor("", nullptr);
auto config = CreateEncoderRuntimeConfig();
EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig())
@ -346,7 +345,7 @@ TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnReceivedRtt) {
TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnReceivedOverhead) {
auto states = CreateCodec(2);
states.encoder->EnableAudioNetworkAdaptor("", nullptr, nullptr);
states.encoder->EnableAudioNetworkAdaptor("", nullptr);
auto config = CreateEncoderRuntimeConfig();
EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig())
@ -376,7 +375,8 @@ TEST(AudioEncoderOpusTest,
states.encoder->OnReceivedUplinkPacketLossFraction(kPacketLossFraction_1);
EXPECT_FLOAT_EQ(0.01f, states.encoder->packet_loss_rate());
states.simulated_clock->AdvanceTimeMilliseconds(kSecondSampleTimeMs);
states.fake_clock->AdvanceTime(
rtc::TimeDelta::FromMilliseconds(kSecondSampleTimeMs));
states.encoder->OnReceivedUplinkPacketLossFraction(kPacketLossFraction_2);
// Now the output of packet loss fraction smoother should be
@ -475,7 +475,7 @@ TEST(AudioEncoderOpusTest, ConfigComplexityAdaptation) {
TEST(AudioEncoderOpusTest, EmptyConfigDoesNotAffectEncoderSettings) {
auto states = CreateCodec(2);
states.encoder->EnableAudioNetworkAdaptor("", nullptr, nullptr);
states.encoder->EnableAudioNetworkAdaptor("", nullptr);
auto config = CreateEncoderRuntimeConfig();
AudioEncoderRuntimeConfig empty_config;
@ -494,9 +494,8 @@ TEST(AudioEncoderOpusTest, EmptyConfigDoesNotAffectEncoderSettings) {
}
TEST(AudioEncoderOpusTest, UpdateUplinkBandwidthInAudioNetworkAdaptor) {
rtc::ScopedFakeClock fake_clock;
auto states = CreateCodec(2);
states.encoder->EnableAudioNetworkAdaptor("", nullptr, nullptr);
states.encoder->EnableAudioNetworkAdaptor("", nullptr);
std::array<int16_t, 480 * 2> audio;
audio.fill(0);
rtc::Buffer encoded;
@ -509,7 +508,7 @@ TEST(AudioEncoderOpusTest, UpdateUplinkBandwidthInAudioNetworkAdaptor) {
// Repeat update uplink bandwidth tests.
for (int i = 0; i < 5; i++) {
// Don't update till it is time to update again.
fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(
states.fake_clock->AdvanceTime(rtc::TimeDelta::FromMilliseconds(
states.config.uplink_bandwidth_update_interval_ms - 1));
states.encoder->Encode(
0, rtc::ArrayView<const int16_t>(audio.data(), audio.size()), &encoded);
@ -518,7 +517,7 @@ TEST(AudioEncoderOpusTest, UpdateUplinkBandwidthInAudioNetworkAdaptor) {
EXPECT_CALL(*states.mock_bitrate_smoother, GetAverage())
.WillOnce(Return(rtc::Optional<float>(40000)));
EXPECT_CALL(**states.mock_audio_network_adaptor, SetUplinkBandwidth(40000));
fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(1));
states.fake_clock->AdvanceTime(rtc::TimeDelta::FromMilliseconds(1));
states.encoder->Encode(
0, rtc::ArrayView<const int16_t>(audio.data(), audio.size()), &encoded);
}

7
webrtc/modules/audio_coding/codecs/opus/opus_complexity_unittest.cc
View File

@ -9,12 +9,12 @@
*/
#include "webrtc/base/format_macros.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.h"
#include "webrtc/modules/audio_coding/neteq/tools/audio_loop.h"
#include "webrtc/test/gtest.h"
#include "webrtc/test/testsupport/fileutils.h"
#include "webrtc/test/testsupport/perf_test.h"
#include "webrtc/system_wrappers/include/clock.h"
namespace webrtc {
@ -35,8 +35,7 @@ int64_t RunComplexityTest(const AudioEncoderOpus::Config& config) {
EXPECT_TRUE(audio_loop.Init(kInputFileName, kMaxLoopLengthSamples,
kInputBlockSizeSamples));
// Encode.
webrtc::Clock* clock = webrtc::Clock::GetRealTimeClock();
const int64_t start_time_ms = clock->TimeInMilliseconds();
const int64_t start_time_ms = rtc::TimeMillis();
AudioEncoder::EncodedInfo info;
rtc::Buffer encoded(500);
uint32_t rtp_timestamp = 0u;
@ -45,7 +44,7 @@ int64_t RunComplexityTest(const AudioEncoderOpus::Config& config) {
info = encoder.Encode(rtp_timestamp, audio_loop.GetNextBlock(), &encoded);
rtp_timestamp += kInputBlockSizeSamples;
}
return clock->TimeInMilliseconds() - start_time_ms;
return rtc::TimeMillis() - start_time_ms;
}
} // namespace

4
webrtc/voice_engine/channel.cc
View File

@ -1611,8 +1611,8 @@ bool Channel::EnableAudioNetworkAdaptor(const std::string& config_string) {
bool success = false;
audio_coding_->ModifyEncoder([&](std::unique_ptr<AudioEncoder>* encoder) {
if (*encoder) {
success = (*encoder)->EnableAudioNetworkAdaptor(
config_string, event_log_proxy_.get(), Clock::GetRealTimeClock());
success = (*encoder)->EnableAudioNetworkAdaptor(config_string,
event_log_proxy_.get());
}
});
return success;