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

Hide the internal AudioEncoderOpus class by giving it an "Impl" suffix

Browse Source 
We've done this previously with the other audio encoders, but Opus had
to wait until all external users had been updated.

BUG=webrtc:7847

Change-Id: I70422d7b6c715f32a43bee88febcf6b6155e18b3
Reviewed-on: https://webrtc-review.googlesource.com/8000
Commit-Queue: Karl Wiberg <kwiberg@webrtc.org>
Reviewed-by: Oskar Sundbom <ossu@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#20424}
This commit is contained in:
Karl Wiberg
2017-10-25 09:57:40 +02:00
committed by Commit Bot
parent 7c8cca3dce
commit 7275e18439
10 changed files with 167 additions and 133 deletions
Download Patch File Download Diff File Expand all files Collapse all files

121
modules/audio_coding/codecs/opus/audio_encoder_opus.cc
View File

@ -215,7 +215,7 @@ int GetBitrateBps(const AudioEncoderOpusConfig& config) {
} // namespace
void AudioEncoderOpus::AppendSupportedEncoders(
void AudioEncoderOpusImpl::AppendSupportedEncoders(
std::vector<AudioCodecSpec>* specs) {
const SdpAudioFormat fmt = {
"opus", 48000, 2, {{"minptime", "10"}, {"useinbandfec", "1"}}};
@ -223,7 +223,7 @@ void AudioEncoderOpus::AppendSupportedEncoders(
specs->push_back({fmt, info});
}
AudioCodecInfo AudioEncoderOpus::QueryAudioEncoder(
AudioCodecInfo AudioEncoderOpusImpl::QueryAudioEncoder(
const AudioEncoderOpusConfig& config) {
RTC_DCHECK(config.IsOk());
AudioCodecInfo info(48000, config.num_channels, *config.bitrate_bps,
@ -234,14 +234,14 @@ AudioCodecInfo AudioEncoderOpus::QueryAudioEncoder(
return info;
}
std::unique_ptr<AudioEncoder> AudioEncoderOpus::MakeAudioEncoder(
std::unique_ptr<AudioEncoder> AudioEncoderOpusImpl::MakeAudioEncoder(
const AudioEncoderOpusConfig& config,
int payload_type) {
RTC_DCHECK(config.IsOk());
return rtc::MakeUnique<AudioEncoderOpus>(config, payload_type);
return rtc::MakeUnique<AudioEncoderOpusImpl>(config, payload_type);
}
rtc::Optional<AudioCodecInfo> AudioEncoderOpus::QueryAudioEncoder(
rtc::Optional<AudioCodecInfo> AudioEncoderOpusImpl::QueryAudioEncoder(
const SdpAudioFormat& format) {
if (STR_CASE_CMP(format.name.c_str(), GetPayloadName()) == 0 &&
format.clockrate_hz == 48000 && format.num_channels == 2) {
@ -260,16 +260,7 @@ rtc::Optional<AudioCodecInfo> AudioEncoderOpus::QueryAudioEncoder(
return rtc::Optional<AudioCodecInfo>();
}
AudioEncoderOpusConfig AudioEncoderOpus::CreateConfig(
int payload_type,
const SdpAudioFormat& format) {
auto opt_config = SdpToConfig(format);
RTC_CHECK(opt_config);
opt_config->payload_type = payload_type;
return *opt_config;
}
AudioEncoderOpusConfig AudioEncoderOpus::CreateConfig(
AudioEncoderOpusConfig AudioEncoderOpusImpl::CreateConfig(
const CodecInst& codec_inst) {
AudioEncoderOpusConfig config;
config.frame_size_ms = rtc::CheckedDivExact(codec_inst.pacsize, 48);
@ -282,7 +273,7 @@ AudioEncoderOpusConfig AudioEncoderOpus::CreateConfig(
return config;
}
rtc::Optional<AudioEncoderOpusConfig> AudioEncoderOpus::SdpToConfig(
rtc::Optional<AudioEncoderOpusConfig> AudioEncoderOpusImpl::SdpToConfig(
const SdpAudioFormat& format) {
if (STR_CASE_CMP(format.name.c_str(), "opus") != 0 ||
format.clockrate_hz != 48000 || format.num_channels != 2) {
@ -321,7 +312,7 @@ rtc::Optional<AudioEncoderOpusConfig> AudioEncoderOpus::SdpToConfig(
return rtc::Optional<AudioEncoderOpusConfig>(config);
}
rtc::Optional<int> AudioEncoderOpus::GetNewComplexity(
rtc::Optional<int> AudioEncoderOpusImpl::GetNewComplexity(
const AudioEncoderOpusConfig& config) {
RTC_DCHECK(config.IsOk());
const int bitrate_bps = GetBitrateBps(config);
@ -338,7 +329,7 @@ rtc::Optional<int> AudioEncoderOpus::GetNewComplexity(
}
}
class AudioEncoderOpus::PacketLossFractionSmoother {
class AudioEncoderOpusImpl::PacketLossFractionSmoother {
public:
explicit PacketLossFractionSmoother()
: last_sample_time_ms_(rtc::TimeMillis()),
@ -365,12 +356,9 @@ class AudioEncoderOpus::PacketLossFractionSmoother {
rtc::ExpFilter smoother_;
};
AudioEncoderOpus::AudioEncoderOpus(const AudioEncoderOpusConfig& config)
: AudioEncoderOpus(config, config.payload_type) {}
AudioEncoderOpus::AudioEncoderOpus(const AudioEncoderOpusConfig& config,
int payload_type)
: AudioEncoderOpus(
AudioEncoderOpusImpl::AudioEncoderOpusImpl(const AudioEncoderOpusConfig& config,
int payload_type)
: AudioEncoderOpusImpl(
config,
payload_type,
[this](const ProtoString& config_string, RtcEventLog* event_log) {
@ -379,7 +367,7 @@ AudioEncoderOpus::AudioEncoderOpus(const AudioEncoderOpusConfig& config,
// We choose 5sec as initial time constant due to empirical data.
rtc::MakeUnique<SmoothingFilterImpl>(5000)) {}
AudioEncoderOpus::AudioEncoderOpus(
AudioEncoderOpusImpl::AudioEncoderOpusImpl(
const AudioEncoderOpusConfig& config,
int payload_type,
const AudioNetworkAdaptorCreator& audio_network_adaptor_creator,
@ -401,42 +389,42 @@ AudioEncoderOpus::AudioEncoderOpus(
RTC_CHECK(RecreateEncoderInstance(config));
}
AudioEncoderOpus::AudioEncoderOpus(const CodecInst& codec_inst)
: AudioEncoderOpus(CreateConfig(codec_inst), codec_inst.pltype) {}
AudioEncoderOpusImpl::AudioEncoderOpusImpl(const CodecInst& codec_inst)
: AudioEncoderOpusImpl(CreateConfig(codec_inst), codec_inst.pltype) {}
AudioEncoderOpus::AudioEncoderOpus(int payload_type,
const SdpAudioFormat& format)
: AudioEncoderOpus(*SdpToConfig(format), payload_type) {}
AudioEncoderOpusImpl::AudioEncoderOpusImpl(int payload_type,
const SdpAudioFormat& format)
: AudioEncoderOpusImpl(*SdpToConfig(format), payload_type) {}
AudioEncoderOpus::~AudioEncoderOpus() {
AudioEncoderOpusImpl::~AudioEncoderOpusImpl() {
RTC_CHECK_EQ(0, WebRtcOpus_EncoderFree(inst_));
}
int AudioEncoderOpus::SampleRateHz() const {
int AudioEncoderOpusImpl::SampleRateHz() const {
return kSampleRateHz;
}
size_t AudioEncoderOpus::NumChannels() const {
size_t AudioEncoderOpusImpl::NumChannels() const {
return config_.num_channels;
}
size_t AudioEncoderOpus::Num10MsFramesInNextPacket() const {
size_t AudioEncoderOpusImpl::Num10MsFramesInNextPacket() const {
return Num10msFramesPerPacket();
}
size_t AudioEncoderOpus::Max10MsFramesInAPacket() const {
size_t AudioEncoderOpusImpl::Max10MsFramesInAPacket() const {
return Num10msFramesPerPacket();
}
int AudioEncoderOpus::GetTargetBitrate() const {
int AudioEncoderOpusImpl::GetTargetBitrate() const {
return GetBitrateBps(config_);
}
void AudioEncoderOpus::Reset() {
void AudioEncoderOpusImpl::Reset() {
RTC_CHECK(RecreateEncoderInstance(config_));
}
bool AudioEncoderOpus::SetFec(bool enable) {
bool AudioEncoderOpusImpl::SetFec(bool enable) {
if (enable) {
RTC_CHECK_EQ(0, WebRtcOpus_EnableFec(inst_));
} else {
@ -446,7 +434,7 @@ bool AudioEncoderOpus::SetFec(bool enable) {
return true;
}
bool AudioEncoderOpus::SetDtx(bool enable) {
bool AudioEncoderOpusImpl::SetDtx(bool enable) {
if (enable) {
RTC_CHECK_EQ(0, WebRtcOpus_EnableDtx(inst_));
} else {
@ -456,11 +444,11 @@ bool AudioEncoderOpus::SetDtx(bool enable) {
return true;
}
bool AudioEncoderOpus::GetDtx() const {
bool AudioEncoderOpusImpl::GetDtx() const {
return config_.dtx_enabled;
}
bool AudioEncoderOpus::SetApplication(Application application) {
bool AudioEncoderOpusImpl::SetApplication(Application application) {
auto conf = config_;
switch (application) {
case Application::kSpeech:
@ -473,13 +461,13 @@ bool AudioEncoderOpus::SetApplication(Application application) {
return RecreateEncoderInstance(conf);
}
void AudioEncoderOpus::SetMaxPlaybackRate(int frequency_hz) {
void AudioEncoderOpusImpl::SetMaxPlaybackRate(int frequency_hz) {
auto conf = config_;
conf.max_playback_rate_hz = frequency_hz;
RTC_CHECK(RecreateEncoderInstance(conf));
}
bool AudioEncoderOpus::EnableAudioNetworkAdaptor(
bool AudioEncoderOpusImpl::EnableAudioNetworkAdaptor(
const std::string& config_string,
RtcEventLog* event_log) {
audio_network_adaptor_ =
@ -487,11 +475,11 @@ bool AudioEncoderOpus::EnableAudioNetworkAdaptor(
return audio_network_adaptor_.get() != nullptr;
}
void AudioEncoderOpus::DisableAudioNetworkAdaptor() {
void AudioEncoderOpusImpl::DisableAudioNetworkAdaptor() {
audio_network_adaptor_.reset(nullptr);
}
void AudioEncoderOpus::OnReceivedUplinkPacketLossFraction(
void AudioEncoderOpusImpl::OnReceivedUplinkPacketLossFraction(
float uplink_packet_loss_fraction) {
if (!audio_network_adaptor_) {
packet_loss_fraction_smoother_->AddSample(uplink_packet_loss_fraction);
@ -503,7 +491,7 @@ void AudioEncoderOpus::OnReceivedUplinkPacketLossFraction(
ApplyAudioNetworkAdaptor();
}
void AudioEncoderOpus::OnReceivedUplinkRecoverablePacketLossFraction(
void AudioEncoderOpusImpl::OnReceivedUplinkRecoverablePacketLossFraction(
float uplink_recoverable_packet_loss_fraction) {
if (!audio_network_adaptor_)
return;
@ -512,7 +500,7 @@ void AudioEncoderOpus::OnReceivedUplinkRecoverablePacketLossFraction(
ApplyAudioNetworkAdaptor();
}
void AudioEncoderOpus::OnReceivedUplinkBandwidth(
void AudioEncoderOpusImpl::OnReceivedUplinkBandwidth(
int target_audio_bitrate_bps,
rtc::Optional<int64_t> bwe_period_ms) {
if (audio_network_adaptor_) {
@ -536,7 +524,7 @@ void AudioEncoderOpus::OnReceivedUplinkBandwidth(
} else if (send_side_bwe_with_overhead_) {
if (!overhead_bytes_per_packet_) {
LOG(LS_INFO)
<< "AudioEncoderOpus: Overhead unknown, target audio bitrate "
<< "AudioEncoderOpusImpl: Overhead unknown, target audio bitrate "
<< target_audio_bitrate_bps << " bps is ignored.";
return;
}
@ -551,14 +539,15 @@ void AudioEncoderOpus::OnReceivedUplinkBandwidth(
}
}
void AudioEncoderOpus::OnReceivedRtt(int rtt_ms) {
void AudioEncoderOpusImpl::OnReceivedRtt(int rtt_ms) {
if (!audio_network_adaptor_)
return;
audio_network_adaptor_->SetRtt(rtt_ms);
ApplyAudioNetworkAdaptor();
}
void AudioEncoderOpus::OnReceivedOverhead(size_t overhead_bytes_per_packet) {
void AudioEncoderOpusImpl::OnReceivedOverhead(
size_t overhead_bytes_per_packet) {
if (audio_network_adaptor_) {
audio_network_adaptor_->SetOverhead(overhead_bytes_per_packet);
ApplyAudioNetworkAdaptor();
@ -568,8 +557,9 @@ void AudioEncoderOpus::OnReceivedOverhead(size_t overhead_bytes_per_packet) {
}
}
void AudioEncoderOpus::SetReceiverFrameLengthRange(int min_frame_length_ms,
int max_frame_length_ms) {
void AudioEncoderOpusImpl::SetReceiverFrameLengthRange(
int min_frame_length_ms,
int max_frame_length_ms) {
// Ensure that |SetReceiverFrameLengthRange| is called before
// |EnableAudioNetworkAdaptor|, otherwise we need to recreate
// |audio_network_adaptor_|, which is not a needed use case.
@ -578,7 +568,7 @@ void AudioEncoderOpus::SetReceiverFrameLengthRange(int min_frame_length_ms,
&config_.supported_frame_lengths_ms);
}
AudioEncoder::EncodedInfo AudioEncoderOpus::EncodeImpl(
AudioEncoder::EncodedInfo AudioEncoderOpusImpl::EncodeImpl(
uint32_t rtp_timestamp,
rtc::ArrayView<const int16_t> audio,
rtc::Buffer* encoded) {
@ -624,15 +614,15 @@ AudioEncoder::EncodedInfo AudioEncoderOpus::EncodeImpl(
return info;
}
size_t AudioEncoderOpus::Num10msFramesPerPacket() const {
size_t AudioEncoderOpusImpl::Num10msFramesPerPacket() const {
return static_cast<size_t>(rtc::CheckedDivExact(config_.frame_size_ms, 10));
}
size_t AudioEncoderOpus::SamplesPer10msFrame() const {
size_t AudioEncoderOpusImpl::SamplesPer10msFrame() const {
return rtc::CheckedDivExact(kSampleRateHz, 100) * config_.num_channels;
}
size_t AudioEncoderOpus::SufficientOutputBufferSize() const {
size_t AudioEncoderOpusImpl::SufficientOutputBufferSize() const {
// Calculate the number of bytes we expect the encoder to produce,
// then multiply by two to give a wide margin for error.
const size_t bytes_per_millisecond =
@ -645,7 +635,7 @@ size_t AudioEncoderOpus::SufficientOutputBufferSize() const {
// If the given config is OK, recreate the Opus encoder instance with those
// settings, save the config, and return true. Otherwise, do nothing and return
// false.
bool AudioEncoderOpus::RecreateEncoderInstance(
bool AudioEncoderOpusImpl::RecreateEncoderInstance(
const AudioEncoderOpusConfig& config) {
if (!config.IsOk())
return false;
@ -690,11 +680,12 @@ bool AudioEncoderOpus::RecreateEncoderInstance(
return true;
}
void AudioEncoderOpus::SetFrameLength(int frame_length_ms) {
void AudioEncoderOpusImpl::SetFrameLength(int frame_length_ms) {
next_frame_length_ms_ = frame_length_ms;
}
void AudioEncoderOpus::SetNumChannelsToEncode(size_t num_channels_to_encode) {
void AudioEncoderOpusImpl::SetNumChannelsToEncode(
size_t num_channels_to_encode) {
RTC_DCHECK_GT(num_channels_to_encode, 0);
RTC_DCHECK_LE(num_channels_to_encode, config_.num_channels);
@ -705,7 +696,7 @@ void AudioEncoderOpus::SetNumChannelsToEncode(size_t num_channels_to_encode) {
num_channels_to_encode_ = num_channels_to_encode;
}
void AudioEncoderOpus::SetProjectedPacketLossRate(float fraction) {
void AudioEncoderOpusImpl::SetProjectedPacketLossRate(float fraction) {
float opt_loss_rate = OptimizePacketLossRate(fraction, packet_loss_rate_);
if (packet_loss_rate_ != opt_loss_rate) {
packet_loss_rate_ = opt_loss_rate;
@ -715,7 +706,7 @@ void AudioEncoderOpus::SetProjectedPacketLossRate(float fraction) {
}
}
void AudioEncoderOpus::SetTargetBitrate(int bits_per_second) {
void AudioEncoderOpusImpl::SetTargetBitrate(int bits_per_second) {
config_.bitrate_bps = rtc::Optional<int>(rtc::SafeClamp<int>(
bits_per_second, AudioEncoderOpusConfig::kMinBitrateBps,
AudioEncoderOpusConfig::kMaxBitrateBps));
@ -728,7 +719,7 @@ void AudioEncoderOpus::SetTargetBitrate(int bits_per_second) {
}
}
void AudioEncoderOpus::ApplyAudioNetworkAdaptor() {
void AudioEncoderOpusImpl::ApplyAudioNetworkAdaptor() {
auto config = audio_network_adaptor_->GetEncoderRuntimeConfig();
if (config.bitrate_bps)
@ -746,7 +737,7 @@ void AudioEncoderOpus::ApplyAudioNetworkAdaptor() {
}
std::unique_ptr<AudioNetworkAdaptor>
AudioEncoderOpus::DefaultAudioNetworkAdaptorCreator(
AudioEncoderOpusImpl::DefaultAudioNetworkAdaptorCreator(
const ProtoString& config_string,
RtcEventLog* event_log) const {
AudioNetworkAdaptorImpl::Config config;
@ -759,7 +750,7 @@ AudioEncoderOpus::DefaultAudioNetworkAdaptorCreator(
GetTargetBitrate(), config_.fec_enabled, GetDtx())));
}
void AudioEncoderOpus::MaybeUpdateUplinkBandwidth() {
void AudioEncoderOpusImpl::MaybeUpdateUplinkBandwidth() {
if (audio_network_adaptor_) {
int64_t now_ms = rtc::TimeMillis();
if (!bitrate_smoother_last_update_time_ ||
@ -773,7 +764,7 @@ void AudioEncoderOpus::MaybeUpdateUplinkBandwidth() {
}
}
ANAStats AudioEncoderOpus::GetANAStats() const {
ANAStats AudioEncoderOpusImpl::GetANAStats() const {
if (audio_network_adaptor_) {
return audio_network_adaptor_->GetStats();
}

43
modules/audio_coding/codecs/opus/audio_encoder_opus.h
View File

@ -32,25 +32,9 @@ class RtcEventLog;
struct CodecInst;
class AudioEncoderOpus final : public AudioEncoder {
class AudioEncoderOpusImpl final : public AudioEncoder {
public:
static void AppendSupportedEncoders(std::vector<AudioCodecSpec>* specs);
static AudioCodecInfo QueryAudioEncoder(const AudioEncoderOpusConfig& config);
static std::unique_ptr<AudioEncoder> MakeAudioEncoder(
const AudioEncoderOpusConfig&,
int payload_type);
// NOTE: This alias will soon go away. See
// https://bugs.chromium.org/p/webrtc/issues/detail?id=7847
using Config = AudioEncoderOpusConfig;
// NOTE: This function will soon go away. See
// https://bugs.chromium.org/p/webrtc/issues/detail?id=7847
static Config CreateConfig(int payload_type, const SdpAudioFormat& format);
static AudioEncoderOpusConfig CreateConfig(const CodecInst& codec_inst);
static rtc::Optional<AudioEncoderOpusConfig> SdpToConfig(
const SdpAudioFormat& format);
// Returns empty if the current bitrate falls within the hysteresis window,
// defined by complexity_threshold_bps +/- complexity_threshold_window_bps.
@ -63,22 +47,18 @@ class AudioEncoderOpus final : public AudioEncoder {
std::function<std::unique_ptr<AudioNetworkAdaptor>(const std::string&,
RtcEventLog*)>;
// NOTE: This constructor will soon go away. See
// https://bugs.chromium.org/p/webrtc/issues/detail?id=7847
AudioEncoderOpus(const AudioEncoderOpusConfig& config);
AudioEncoderOpus(const AudioEncoderOpusConfig& config, int payload_type);
AudioEncoderOpusImpl(const AudioEncoderOpusConfig& config, int payload_type);
// Dependency injection for testing.
AudioEncoderOpus(
AudioEncoderOpusImpl(
const AudioEncoderOpusConfig& config,
int payload_type,
const AudioNetworkAdaptorCreator& audio_network_adaptor_creator,
std::unique_ptr<SmoothingFilter> bitrate_smoother);
explicit AudioEncoderOpus(const CodecInst& codec_inst);
AudioEncoderOpus(int payload_type, const SdpAudioFormat& format);
~AudioEncoderOpus() override;
explicit AudioEncoderOpusImpl(const CodecInst& codec_inst);
AudioEncoderOpusImpl(int payload_type, const SdpAudioFormat& format);
~AudioEncoderOpusImpl() override;
// Static interface for use by BuiltinAudioEncoderFactory.
static constexpr const char* GetPayloadName() { return "opus"; }
@ -138,6 +118,14 @@ class AudioEncoderOpus final : public AudioEncoder {
private:
class PacketLossFractionSmoother;
static rtc::Optional<AudioEncoderOpusConfig> SdpToConfig(
const SdpAudioFormat& format);
static void AppendSupportedEncoders(std::vector<AudioCodecSpec>* specs);
static AudioCodecInfo QueryAudioEncoder(const AudioEncoderOpusConfig& config);
static std::unique_ptr<AudioEncoder> MakeAudioEncoder(
const AudioEncoderOpusConfig&,
int payload_type);
size_t Num10msFramesPerPacket() const;
size_t SamplesPer10msFrame() const;
size_t SufficientOutputBufferSize() const;
@ -174,7 +162,8 @@ class AudioEncoderOpus final : public AudioEncoder {
const std::unique_ptr<SmoothingFilter> bitrate_smoother_;
rtc::Optional<int64_t> bitrate_smoother_last_update_time_;
RTC_DISALLOW_COPY_AND_ASSIGN(AudioEncoderOpus);
friend struct AudioEncoderOpus;
RTC_DISALLOW_COPY_AND_ASSIGN(AudioEncoderOpusImpl);
};
} // namespace webrtc

27
modules/audio_coding/codecs/opus/audio_encoder_opus_unittest.cc
View File

@ -12,6 +12,7 @@
#include <memory>
#include <utility>
#include "api/audio_codecs/opus/audio_encoder_opus.h"
#include "common_audio/mocks/mock_smoothing_filter.h"
#include "common_types.h" // NOLINT(build/include)
#include "modules/audio_coding/audio_network_adaptor/mock/mock_audio_network_adaptor.h"
@ -54,7 +55,7 @@ AudioEncoderOpusConfig CreateConfigWithParameters(
struct AudioEncoderOpusStates {
std::shared_ptr<MockAudioNetworkAdaptor*> mock_audio_network_adaptor;
MockSmoothingFilter* mock_bitrate_smoother;
std::unique_ptr<AudioEncoderOpus> encoder;
std::unique_ptr<AudioEncoderOpusImpl> encoder;
std::unique_ptr<rtc::ScopedFakeClock> fake_clock;
AudioEncoderOpusConfig config;
};
@ -67,7 +68,7 @@ AudioEncoderOpusStates CreateCodec(size_t num_channels) {
states.fake_clock->SetTimeMicros(kInitialTimeUs);
std::weak_ptr<MockAudioNetworkAdaptor*> mock_ptr(
states.mock_audio_network_adaptor);
AudioEncoderOpus::AudioNetworkAdaptorCreator creator =
AudioEncoderOpusImpl::AudioNetworkAdaptorCreator creator =
[mock_ptr](const std::string&, RtcEventLog* event_log) {
std::unique_ptr<MockAudioNetworkAdaptor> adaptor(
new NiceMock<MockAudioNetworkAdaptor>());
@ -87,9 +88,9 @@ AudioEncoderOpusStates CreateCodec(size_t num_channels) {
new MockSmoothingFilter());
states.mock_bitrate_smoother = bitrate_smoother.get();
states.encoder.reset(new AudioEncoderOpus(states.config, codec_inst.pltype,
std::move(creator),
std::move(bitrate_smoother)));
states.encoder.reset(new AudioEncoderOpusImpl(
states.config, codec_inst.pltype, std::move(creator),
std::move(bitrate_smoother)));
return states;
}
@ -111,7 +112,7 @@ AudioEncoderRuntimeConfig CreateEncoderRuntimeConfig() {
return config;
}
void CheckEncoderRuntimeConfig(const AudioEncoderOpus* encoder,
void CheckEncoderRuntimeConfig(const AudioEncoderOpusImpl* encoder,
const AudioEncoderRuntimeConfig& config) {
EXPECT_EQ(*config.bitrate_bps, encoder->GetTargetBitrate());
EXPECT_EQ(*config.frame_length_ms, encoder->next_frame_length_ms());
@ -122,7 +123,7 @@ void CheckEncoderRuntimeConfig(const AudioEncoderOpus* encoder,
// Create 10ms audio data blocks for a total packet size of "packet_size_ms".
std::unique_ptr<test::AudioLoop> Create10msAudioBlocks(
const std::unique_ptr<AudioEncoderOpus>& encoder,
const std::unique_ptr<AudioEncoderOpusImpl>& encoder,
int packet_size_ms) {
const std::string file_name =
test::ResourcePath("audio_coding/testfile32kHz", "pcm");
@ -465,19 +466,23 @@ TEST(AudioEncoderOpusTest, ConfigComplexityAdaptation) {
// Bitrate within hysteresis window. Expect empty output.
config.bitrate_bps = rtc::Optional<int>(12500);
EXPECT_EQ(rtc::Optional<int>(), AudioEncoderOpus::GetNewComplexity(config));
EXPECT_EQ(rtc::Optional<int>(),
AudioEncoderOpusImpl::GetNewComplexity(config));
// Bitrate below hysteresis window. Expect higher complexity.
config.bitrate_bps = rtc::Optional<int>(10999);
EXPECT_EQ(rtc::Optional<int>(8), AudioEncoderOpus::GetNewComplexity(config));
EXPECT_EQ(rtc::Optional<int>(8),
AudioEncoderOpusImpl::GetNewComplexity(config));
// Bitrate within hysteresis window. Expect empty output.
config.bitrate_bps = rtc::Optional<int>(12500);
EXPECT_EQ(rtc::Optional<int>(), AudioEncoderOpus::GetNewComplexity(config));
EXPECT_EQ(rtc::Optional<int>(),
AudioEncoderOpusImpl::GetNewComplexity(config));
// Bitrate above hysteresis window. Expect lower complexity.
config.bitrate_bps = rtc::Optional<int>(14001);
EXPECT_EQ(rtc::Optional<int>(6), AudioEncoderOpus::GetNewComplexity(config));
EXPECT_EQ(rtc::Optional<int>(6),
AudioEncoderOpusImpl::GetNewComplexity(config));
}
TEST(AudioEncoderOpusTest, EmptyConfigDoesNotAffectEncoderSettings) {

8
modules/audio_coding/codecs/opus/opus_complexity_unittest.cc
View File

@ -8,7 +8,7 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#include "modules/audio_coding/codecs/opus/audio_encoder_opus.h"
#include "api/audio_codecs/opus/audio_encoder_opus.h"
#include "modules/audio_coding/neteq/tools/audio_loop.h"
#include "rtc_base/format_macros.h"
#include "rtc_base/timeutils.h"
@ -22,13 +22,13 @@ namespace {
int64_t RunComplexityTest(const AudioEncoderOpusConfig& config) {
// Create encoder.
constexpr int payload_type = 17;
AudioEncoderOpus encoder(config, payload_type);
const auto encoder = AudioEncoderOpus::MakeAudioEncoder(config, payload_type);
// Open speech file.
const std::string kInputFileName =
webrtc::test::ResourcePath("audio_coding/speech_mono_32_48kHz", "pcm");
test::AudioLoop audio_loop;
constexpr int kSampleRateHz = 48000;
EXPECT_EQ(kSampleRateHz, encoder.SampleRateHz());
EXPECT_EQ(kSampleRateHz, encoder->SampleRateHz());
constexpr size_t kMaxLoopLengthSamples =
kSampleRateHz * 10; // 10 second loop.
constexpr size_t kInputBlockSizeSamples =
@ -42,7 +42,7 @@ int64_t RunComplexityTest(const AudioEncoderOpusConfig& config) {
uint32_t rtp_timestamp = 0u;
for (size_t i = 0; i < 10000; ++i) {
encoded.Clear();
info = encoder.Encode(rtp_timestamp, audio_loop.GetNextBlock(), &encoded);
info = encoder->Encode(rtp_timestamp, audio_loop.GetNextBlock(), &encoded);
rtp_timestamp += kInputBlockSizeSamples;
}
return rtc::TimeMillis() - start_time_ms;