zqz/platform-external-webrtc
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
Download Patch File Download Diff File Expand all files Collapse all files

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