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

Pass a real audio codec pair ID to decoders that we create

Browse Source 
Bug: webrtc:8941
Change-Id: Ic2aed2ca759eb378164f3f65465e23fd7c13a9f8
Reviewed-on: https://webrtc-review.googlesource.com/63261
Reviewed-by: Oskar Sundbom <ossu@webrtc.org>
Commit-Queue: Karl Wiberg <kwiberg@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#22538}
This commit is contained in:
Karl Wiberg
2018-03-20 19:18:55 +01:00
committed by Commit Bot
parent 92be1caf4f
commit 08126349f5
18 changed files with 126 additions and 74 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
audio/audio_receive_stream.cc
View File

@ -70,13 +70,12 @@ std::unique_ptr<voe::ChannelProxy> CreateChannelAndProxy(
RTC_DCHECK(audio_state);
internal::AudioState* internal_audio_state =
static_cast<internal::AudioState*>(audio_state);
return std::unique_ptr<voe::ChannelProxy>(new voe::ChannelProxy(
std::unique_ptr<voe::Channel>(new voe::Channel(
module_process_thread,
internal_audio_state->audio_device_module(),
config.jitter_buffer_max_packets,
config.jitter_buffer_fast_accelerate,
config.decoder_factory))));
return std::unique_ptr<voe::ChannelProxy>(
new voe::ChannelProxy(std::unique_ptr<voe::Channel>(new voe::Channel(
module_process_thread, internal_audio_state->audio_device_module(),
config.jitter_buffer_max_packets,
config.jitter_buffer_fast_accelerate, config.decoder_factory,
config.codec_pair_id))));
}
} // namespace

7
audio/channel.cc
View File

@ -557,7 +557,8 @@ Channel::Channel(rtc::TaskQueue* encoder_queue,
audio_device_module,
0,
false,
rtc::scoped_refptr<AudioDecoderFactory>()) {
rtc::scoped_refptr<AudioDecoderFactory>(),
rtc::nullopt) {
RTC_DCHECK(encoder_queue);
encoder_queue_ = encoder_queue;
}
@ -566,7 +567,8 @@ Channel::Channel(ProcessThread* module_process_thread,
AudioDeviceModule* audio_device_module,
size_t jitter_buffer_max_packets,
bool jitter_buffer_fast_playout,
rtc::scoped_refptr<AudioDecoderFactory> decoder_factory)
rtc::scoped_refptr<AudioDecoderFactory> decoder_factory,
rtc::Optional<AudioCodecPairId> codec_pair_id)
: event_log_proxy_(new RtcEventLogProxy()),
rtcp_rtt_stats_proxy_(new RtcpRttStatsProxy()),
rtp_payload_registry_(new RTPPayloadRegistry()),
@ -610,6 +612,7 @@ Channel::Channel(ProcessThread* module_process_thread,
RTC_DCHECK(audio_device_module);
AudioCodingModule::Config acm_config;
acm_config.decoder_factory = decoder_factory;
acm_config.neteq_config.codec_pair_id = codec_pair_id;
acm_config.neteq_config.max_packets_in_buffer = jitter_buffer_max_packets;
acm_config.neteq_config.enable_fast_accelerate = jitter_buffer_fast_playout;
acm_config.neteq_config.enable_muted_state = true;

3
audio/channel.h
View File

@ -157,7 +157,8 @@ class Channel
AudioDeviceModule* audio_device_module,
size_t jitter_buffer_max_packets,
bool jitter_buffer_fast_playout,
rtc::scoped_refptr<AudioDecoderFactory> decoder_factory);
rtc::scoped_refptr<AudioDecoderFactory> decoder_factory,
rtc::Optional<AudioCodecPairId> codec_pair_id);
virtual ~Channel();
void SetSink(AudioSinkInterface* sink);

2
call/audio_receive_stream.h
View File

@ -111,6 +111,8 @@ class AudioReceiveStream {
std::map<int, SdpAudioFormat> decoder_map;
rtc::scoped_refptr<AudioDecoderFactory> decoder_factory;
rtc::Optional<AudioCodecPairId> codec_pair_id;
};
// Reconfigure the stream according to the Configuration.

5
media/engine/webrtcvoiceengine.cc
View File

@ -19,6 +19,7 @@
#include <utility>
#include <vector>
#include "api/audio_codecs/audio_codec_pair_id.h"
#include "api/call/audio_sink.h"
#include "media/base/audiosource.h"
#include "media/base/mediaconstants.h"
@ -1104,6 +1105,7 @@ class WebRtcVoiceMediaChannel::WebRtcAudioReceiveStream {
webrtc::Transport* rtcp_send_transport,
const rtc::scoped_refptr<webrtc::AudioDecoderFactory>& decoder_factory,
const std::map<int, webrtc::SdpAudioFormat>& decoder_map,
rtc::Optional<webrtc::AudioCodecPairId> codec_pair_id,
size_t jitter_buffer_max_packets,
bool jitter_buffer_fast_accelerate)
: call_(call), config_() {
@ -1121,6 +1123,7 @@ class WebRtcVoiceMediaChannel::WebRtcAudioReceiveStream {
}
config_.decoder_factory = decoder_factory;
config_.decoder_map = decoder_map;
config_.codec_pair_id = codec_pair_id;
RecreateAudioReceiveStream();
}
@ -1850,7 +1853,7 @@ bool WebRtcVoiceMediaChannel::AddRecvStream(const StreamParams& sp) {
ssrc, receiver_reports_ssrc_, recv_transport_cc_enabled_,
recv_nack_enabled_, sp.stream_ids(), recv_rtp_extensions_,
call_, this, engine()->decoder_factory_, decoder_map_,
engine()->audio_jitter_buffer_max_packets_,
codec_pair_id_, engine()->audio_jitter_buffer_max_packets_,
engine()->audio_jitter_buffer_fast_accelerate_)));
recv_streams_[ssrc]->SetPlayout(playout_);

4
media/engine/webrtcvoiceengine.h
View File

@ -272,6 +272,10 @@ class WebRtcVoiceMediaChannel final : public VoiceMediaChannel,
rtc::Optional<webrtc::AudioSendStream::Config::SendCodecSpec>
send_codec_spec_;
// TODO(kwiberg): Per-SSRC codec pair IDs?
const webrtc::AudioCodecPairId codec_pair_id_ =
webrtc::AudioCodecPairId::Create();
RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(WebRtcVoiceMediaChannel);
};
} // namespace cricket

2
modules/audio_coding/neteq/decision_logic_unittest.cc
View File

@ -26,7 +26,7 @@ TEST(DecisionLogic, CreateAndDestroy) {
int fs_hz = 8000;
int output_size_samples = fs_hz / 100; // Samples per 10 ms.
DecoderDatabase decoder_database(
new rtc::RefCountedObject<MockAudioDecoderFactory>);
new rtc::RefCountedObject<MockAudioDecoderFactory>, rtc::nullopt);
TickTimer tick_timer;
PacketBuffer packet_buffer(10, &tick_timer);
DelayPeakDetector delay_peak_detector(&tick_timer);

42
modules/audio_coding/neteq/decoder_database.cc
View File

@ -19,36 +19,46 @@
namespace webrtc {
DecoderDatabase::DecoderDatabase(
const rtc::scoped_refptr<AudioDecoderFactory>& decoder_factory)
const rtc::scoped_refptr<AudioDecoderFactory>& decoder_factory,
rtc::Optional<AudioCodecPairId> codec_pair_id)
: active_decoder_type_(-1),
active_cng_decoder_type_(-1),
decoder_factory_(decoder_factory) {}
decoder_factory_(decoder_factory),
codec_pair_id_(codec_pair_id) {}
DecoderDatabase::~DecoderDatabase() = default;
DecoderDatabase::DecoderInfo::DecoderInfo(const SdpAudioFormat& audio_format,
AudioDecoderFactory* factory,
const std::string& codec_name)
DecoderDatabase::DecoderInfo::DecoderInfo(
const SdpAudioFormat& audio_format,
rtc::Optional<AudioCodecPairId> codec_pair_id,
AudioDecoderFactory* factory,
const std::string& codec_name)
: name_(codec_name),
audio_format_(audio_format),
codec_pair_id_(codec_pair_id),
factory_(factory),
external_decoder_(nullptr),
cng_decoder_(CngDecoder::Create(audio_format)),
subtype_(SubtypeFromFormat(audio_format)) {}
DecoderDatabase::DecoderInfo::DecoderInfo(const SdpAudioFormat& audio_format,
AudioDecoderFactory* factory)
: DecoderInfo(audio_format, factory, audio_format.name) {}
DecoderDatabase::DecoderInfo::DecoderInfo(
const SdpAudioFormat& audio_format,
rtc::Optional<AudioCodecPairId> codec_pair_id,
AudioDecoderFactory* factory)
: DecoderInfo(audio_format, codec_pair_id, factory, audio_format.name) {}
DecoderDatabase::DecoderInfo::DecoderInfo(NetEqDecoder ct,
AudioDecoderFactory* factory)
: DecoderInfo(*NetEqDecoderToSdpAudioFormat(ct), factory) {}
DecoderDatabase::DecoderInfo::DecoderInfo(
NetEqDecoder ct,
rtc::Optional<AudioCodecPairId> codec_pair_id,
AudioDecoderFactory* factory)
: DecoderInfo(*NetEqDecoderToSdpAudioFormat(ct), codec_pair_id, factory) {}
DecoderDatabase::DecoderInfo::DecoderInfo(const SdpAudioFormat& audio_format,
AudioDecoder* ext_dec,
const std::string& codec_name)
: name_(codec_name),
audio_format_(audio_format),
codec_pair_id_(rtc::nullopt),
factory_(nullptr),
external_decoder_(ext_dec),
subtype_(Subtype::kNormal) {
@ -83,7 +93,7 @@ AudioDecoder* DecoderDatabase::DecoderInfo::GetDecoder() const {
// TODO(ossu): Keep a check here for now, since a number of tests create
// DecoderInfos without factories.
RTC_DCHECK(factory_);
decoder_ = factory_->MakeAudioDecoder(audio_format_, rtc::nullopt);
decoder_ = factory_->MakeAudioDecoder(audio_format_, codec_pair_id_);
}
RTC_DCHECK(decoder_) << "Failed to create: " << audio_format_;
return decoder_.get();
@ -156,7 +166,8 @@ std::vector<int> DecoderDatabase::SetCodecs(
RTC_DCHECK_LE(rtp_payload_type, 0x7f);
if (decoders_.count(rtp_payload_type) == 0) {
decoders_.insert(std::make_pair(
rtp_payload_type, DecoderInfo(audio_format, decoder_factory_.get())));
rtp_payload_type,
DecoderInfo(audio_format, codec_pair_id_, decoder_factory_.get())));
} else {
// The mapping for this payload type hasn't changed.
}
@ -178,7 +189,7 @@ int DecoderDatabase::RegisterPayload(uint8_t rtp_payload_type,
if (!opt_format) {
return kCodecNotSupported;
}
DecoderInfo info(*opt_format, decoder_factory_, name);
DecoderInfo info(*opt_format, codec_pair_id_, decoder_factory_, name);
if (!info.CanGetDecoder()) {
return kCodecNotSupported;
}
@ -197,7 +208,8 @@ int DecoderDatabase::RegisterPayload(int rtp_payload_type,
return kInvalidRtpPayloadType;
}
const auto ret = decoders_.insert(std::make_pair(
rtp_payload_type, DecoderInfo(audio_format, decoder_factory_.get())));
rtp_payload_type,
DecoderInfo(audio_format, codec_pair_id_, decoder_factory_.get())));
if (ret.second == false) {
// Database already contains a decoder with type |rtp_payload_type|.
return kDecoderExists;

8
modules/audio_coding/neteq/decoder_database.h
View File

@ -43,11 +43,14 @@ class DecoderDatabase {
class DecoderInfo {
public:
DecoderInfo(const SdpAudioFormat& audio_format,
rtc::Optional<AudioCodecPairId> codec_pair_id,
AudioDecoderFactory* factory,
const std::string& codec_name);
explicit DecoderInfo(const SdpAudioFormat& audio_format,
rtc::Optional<AudioCodecPairId> codec_pair_id,
AudioDecoderFactory* factory = nullptr);
explicit DecoderInfo(NetEqDecoder ct,
rtc::Optional<AudioCodecPairId> codec_pair_id,
AudioDecoderFactory* factory = nullptr);
DecoderInfo(const SdpAudioFormat& audio_format,
AudioDecoder* ext_dec,
@ -108,6 +111,7 @@ class DecoderDatabase {
const std::string name_;
const SdpAudioFormat audio_format_;
const rtc::Optional<AudioCodecPairId> codec_pair_id_;
AudioDecoderFactory* const factory_;
mutable std::unique_ptr<AudioDecoder> decoder_;
@ -138,7 +142,8 @@ class DecoderDatabase {
static const uint8_t kRtpPayloadTypeError = 0xFF;
DecoderDatabase(
const rtc::scoped_refptr<AudioDecoderFactory>& decoder_factory);
const rtc::scoped_refptr<AudioDecoderFactory>& decoder_factory,
rtc::Optional<AudioCodecPairId> codec_pair_id);
virtual ~DecoderDatabase();
@ -242,6 +247,7 @@ class DecoderDatabase {
int active_cng_decoder_type_;
mutable std::unique_ptr<ComfortNoiseDecoder> active_cng_decoder_;
rtc::scoped_refptr<AudioDecoderFactory> decoder_factory_;
const rtc::Optional<AudioCodecPairId> codec_pair_id_;
RTC_DISALLOW_COPY_AND_ASSIGN(DecoderDatabase);
};

20
modules/audio_coding/neteq/decoder_database_unittest.cc
View File

@ -28,7 +28,8 @@ using testing::Invoke;
namespace webrtc {
TEST(DecoderDatabase, CreateAndDestroy) {
DecoderDatabase db(new rtc::RefCountedObject<MockAudioDecoderFactory>);
DecoderDatabase db(new rtc::RefCountedObject<MockAudioDecoderFactory>,
rtc::nullopt);
EXPECT_EQ(0, db.Size());
EXPECT_TRUE(db.Empty());
}
@ -41,7 +42,7 @@ TEST(DecoderDatabase, InsertAndRemove) {
EXPECT_EQ("pcmu", format.name);
return true;
}));
DecoderDatabase db(factory);
DecoderDatabase db(factory, rtc::nullopt);
const uint8_t kPayloadType = 0;
const std::string kCodecName = "Robert\'); DROP TABLE Students;";
EXPECT_EQ(
@ -66,7 +67,7 @@ TEST(DecoderDatabase, InsertAndRemoveAll) {
EXPECT_EQ("pcma", format.name);
return true;
}));
DecoderDatabase db(factory);
DecoderDatabase db(factory, rtc::nullopt);
const std::string kCodecName1 = "Robert\'); DROP TABLE Students;";
const std::string kCodecName2 = "https://xkcd.com/327/";
EXPECT_EQ(DecoderDatabase::kOK,
@ -96,7 +97,7 @@ TEST(DecoderDatabase, GetDecoderInfo) {
EXPECT_EQ("pcmu", format.name);
dec->reset(decoder);
}));
DecoderDatabase db(factory);
DecoderDatabase db(factory, rtc::nullopt);
const uint8_t kPayloadType = 0;
const std::string kCodecName = "Robert\'); DROP TABLE Students;";
EXPECT_EQ(
@ -113,7 +114,7 @@ TEST(DecoderDatabase, GetDecoderInfo) {
}
TEST(DecoderDatabase, GetDecoder) {
DecoderDatabase db(CreateBuiltinAudioDecoderFactory());
DecoderDatabase db(CreateBuiltinAudioDecoderFactory(), rtc::nullopt);
const uint8_t kPayloadType = 0;
const std::string kCodecName = "Robert\'); DROP TABLE Students;";
EXPECT_EQ(DecoderDatabase::kOK,
@ -131,7 +132,7 @@ TEST(DecoderDatabase, TypeTests) {
EXPECT_EQ("pcmu", format.name);
return true;
}));
DecoderDatabase db(factory);
DecoderDatabase db(factory, rtc::nullopt);
const uint8_t kPayloadTypePcmU = 0;
const uint8_t kPayloadTypeCng = 13;
const uint8_t kPayloadTypeDtmf = 100;
@ -166,7 +167,8 @@ TEST(DecoderDatabase, TypeTests) {
}
TEST(DecoderDatabase, ExternalDecoder) {
DecoderDatabase db(new rtc::RefCountedObject<MockAudioDecoderFactory>);
DecoderDatabase db(new rtc::RefCountedObject<MockAudioDecoderFactory>,
rtc::nullopt);
const uint8_t kPayloadType = 0;
const std::string kCodecName = "Robert\'); DROP TABLE Students;";
MockAudioDecoder decoder;
@ -203,7 +205,7 @@ TEST(DecoderDatabase, CheckPayloadTypes) {
EXPECT_EQ("pcmu", format.name);
return true;
}));
DecoderDatabase db(factory);
DecoderDatabase db(factory, rtc::nullopt);
// Load a number of payloads into the database. Payload types are 0, 1, ...,
// while the decoder type is the same for all payload types (this does not
// matter for the test).
@ -243,7 +245,7 @@ TEST(DecoderDatabase, CheckPayloadTypes) {
// Test the methods for setting and getting active speech and CNG decoders.
TEST(DecoderDatabase, IF_ISAC(ActiveDecoders)) {
DecoderDatabase db(CreateBuiltinAudioDecoderFactory());
DecoderDatabase db(CreateBuiltinAudioDecoderFactory(), rtc::nullopt);
// Load payload types.
ASSERT_EQ(DecoderDatabase::kOK,
db.RegisterPayload(0, NetEqDecoder::kDecoderPCMu, "pcmu"));

31
modules/audio_coding/neteq/include/neteq.h
View File

@ -16,6 +16,7 @@
#include <string>
#include <vector>
#include "api/audio_codecs/audio_codec_pair_id.h"
#include "api/audio_codecs/audio_decoder.h"
#include "api/optional.h"
#include "api/rtp_headers.h"
@ -90,26 +91,24 @@ class NetEq {
};
struct Config {
Config()
: sample_rate_hz(16000),
enable_post_decode_vad(false),
max_packets_in_buffer(50),
// |max_delay_ms| has the same effect as calling SetMaximumDelay().
max_delay_ms(2000),
background_noise_mode(kBgnOff),
playout_mode(kPlayoutOn),
enable_fast_accelerate(false) {}
Config();
Config(const Config&);
Config(Config&&);
~Config();
Config& operator=(const Config&);
Config& operator=(Config&&);
std::string ToString() const;
int sample_rate_hz; // Initial value. Will change with input data.
bool enable_post_decode_vad;
size_t max_packets_in_buffer;
int max_delay_ms;
BackgroundNoiseMode background_noise_mode;
NetEqPlayoutMode playout_mode;
bool enable_fast_accelerate;
int sample_rate_hz = 16000; // Initial value. Will change with input data.
bool enable_post_decode_vad = false;
size_t max_packets_in_buffer = 50;
int max_delay_ms = 2000;
BackgroundNoiseMode background_noise_mode = kBgnOff;
NetEqPlayoutMode playout_mode = kPlayoutOn;
bool enable_fast_accelerate = false;
bool enable_muted_state = false;
rtc::Optional<AudioCodecPairId> codec_pair_id;
};
enum ReturnCodes {

2
modules/audio_coding/neteq/mock/mock_decoder_database.h
View File

@ -23,7 +23,7 @@ class MockDecoderDatabase : public DecoderDatabase {
public:
explicit MockDecoderDatabase(
rtc::scoped_refptr<AudioDecoderFactory> factory = nullptr)
: DecoderDatabase(factory) {}
: DecoderDatabase(factory, rtc::nullopt) {}
virtual ~MockDecoderDatabase() { Die(); }
MOCK_METHOD0(Die, void());
MOCK_CONST_METHOD0(Empty,

7
modules/audio_coding/neteq/neteq.cc
View File

@ -17,6 +17,13 @@
namespace webrtc {
NetEq::Config::Config() = default;
NetEq::Config::Config(const Config&) = default;
NetEq::Config::Config(Config&&) = default;
NetEq::Config::~Config() = default;
NetEq::Config& NetEq::Config::operator=(const Config&) = default;
NetEq::Config& NetEq::Config::operator=(Config&&) = default;
std::string NetEq::Config::ToString() const {
std::stringstream ss;
ss << "sample_rate_hz=" << sample_rate_hz

3
modules/audio_coding/neteq/neteq_impl.cc
View File

@ -57,7 +57,8 @@ NetEqImpl::Dependencies::Dependencies(
const rtc::scoped_refptr<AudioDecoderFactory>& decoder_factory)
: tick_timer(new TickTimer),
buffer_level_filter(new BufferLevelFilter),
decoder_database(new DecoderDatabase(decoder_factory)),
decoder_database(
new DecoderDatabase(decoder_factory, config.codec_pair_id)),
delay_peak_detector(new DelayPeakDetector(tick_timer.get())),
delay_manager(new DelayManager(config.max_packets_in_buffer,
delay_peak_detector.get(),

2
modules/audio_coding/neteq/neteq_impl_unittest.cc
View File

@ -335,7 +335,7 @@ TEST_F(NetEqImplTest, InsertPacket) {
*dec = std::move(mock_decoder);
}));
DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderPCMu,
DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderPCMu, rtc::nullopt,
mock_decoder_factory);
// Expectations for decoder database.

19
modules/audio_coding/neteq/packet_buffer_unittest.cc
View File

@ -175,7 +175,8 @@ TEST(PacketBuffer, InsertPacketList) {
MockDecoderDatabase decoder_database;
auto factory = CreateBuiltinAudioDecoderFactory();
const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderPCMu, factory);
const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderPCMu,
rtc::nullopt, factory);
EXPECT_CALL(decoder_database, GetDecoderInfo(0))
.WillRepeatedly(Return(&info));
@ -219,10 +220,12 @@ TEST(PacketBuffer, InsertPacketListChangePayloadType) {
MockDecoderDatabase decoder_database;
auto factory = CreateBuiltinAudioDecoderFactory();
const DecoderDatabase::DecoderInfo info0(NetEqDecoder::kDecoderPCMu, factory);
const DecoderDatabase::DecoderInfo info0(NetEqDecoder::kDecoderPCMu,
rtc::nullopt, factory);
EXPECT_CALL(decoder_database, GetDecoderInfo(0))
.WillRepeatedly(Return(&info0));
const DecoderDatabase::DecoderInfo info1(NetEqDecoder::kDecoderPCMa, factory);
const DecoderDatabase::DecoderInfo info1(NetEqDecoder::kDecoderPCMa,
rtc::nullopt, factory);
EXPECT_CALL(decoder_database, GetDecoderInfo(1))
.WillRepeatedly(Return(&info1));
@ -404,7 +407,8 @@ TEST(PacketBuffer, Reordering) {
MockDecoderDatabase decoder_database;
auto factory = CreateBuiltinAudioDecoderFactory();
const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderPCMu, factory);
const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderPCMu,
rtc::nullopt, factory);
EXPECT_CALL(decoder_database, GetDecoderInfo(0))
.WillRepeatedly(Return(&info));
rtc::Optional<uint8_t> current_pt;
@ -444,11 +448,11 @@ TEST(PacketBuffer, CngFirstThenSpeechWithNewSampleRate) {
MockDecoderDatabase decoder_database;
auto factory = CreateBuiltinAudioDecoderFactory();
const DecoderDatabase::DecoderInfo info_cng(NetEqDecoder::kDecoderCNGnb,
factory);
rtc::nullopt, factory);
EXPECT_CALL(decoder_database, GetDecoderInfo(kCngPt))
.WillRepeatedly(Return(&info_cng));
const DecoderDatabase::DecoderInfo info_speech(NetEqDecoder::kDecoderPCM16Bwb,
factory);
rtc::nullopt, factory);
EXPECT_CALL(decoder_database, GetDecoderInfo(kSpeechPt))
.WillRepeatedly(Return(&info_speech));
@ -545,7 +549,8 @@ TEST(PacketBuffer, Failures) {
list.push_back(gen.NextPacket(payload_len)); // Valid packet.
MockDecoderDatabase decoder_database;
auto factory = CreateBuiltinAudioDecoderFactory();
const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderPCMu, factory);
const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderPCMu,
rtc::nullopt, factory);
EXPECT_CALL(decoder_database, GetDecoderInfo(0))
.WillRepeatedly(Return(&info));
rtc::Optional<uint8_t> current_pt;

2
modules/audio_coding/neteq/red_payload_splitter_unittest.cc
View File

@ -299,7 +299,7 @@ TEST(RedPayloadSplitter, CheckRedPayloads) {
// easier to just register the payload types and let the actual implementation
// do its job.
DecoderDatabase decoder_database(
new rtc::RefCountedObject<MockAudioDecoderFactory>);
new rtc::RefCountedObject<MockAudioDecoderFactory>, rtc::nullopt);
decoder_database.RegisterPayload(0, NetEqDecoder::kDecoderCNGnb, "cng-nb");
decoder_database.RegisterPayload(1, NetEqDecoder::kDecoderPCMu, "pcmu");
decoder_database.RegisterPayload(2, NetEqDecoder::kDecoderAVT, "avt");

28
modules/audio_coding/neteq/timestamp_scaler_unittest.cc
View File

@ -25,7 +25,8 @@ TEST(TimestampScaler, TestNoScaling) {
MockDecoderDatabase db;
auto factory = CreateBuiltinAudioDecoderFactory();
// Use PCMu, because it doesn't use scaled timestamps.
const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderPCMu, factory);
const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderPCMu,
rtc::nullopt, factory);
static const uint8_t kRtpPayloadType = 0;
EXPECT_CALL(db, GetDecoderInfo(kRtpPayloadType))
.WillRepeatedly(Return(&info));
@ -46,7 +47,8 @@ TEST(TimestampScaler, TestNoScalingLargeStep) {
MockDecoderDatabase db;
auto factory = CreateBuiltinAudioDecoderFactory();
// Use PCMu, because it doesn't use scaled timestamps.
const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderPCMu, factory);
const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderPCMu,
rtc::nullopt, factory);
static const uint8_t kRtpPayloadType = 0;
EXPECT_CALL(db, GetDecoderInfo(kRtpPayloadType))
.WillRepeatedly(Return(&info));
@ -72,7 +74,8 @@ TEST(TimestampScaler, TestG722) {
MockDecoderDatabase db;
auto factory = CreateBuiltinAudioDecoderFactory();
// Use G722, which has a factor 2 scaling.
const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderG722, factory);
const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderG722,
rtc::nullopt, factory);
static const uint8_t kRtpPayloadType = 17;
EXPECT_CALL(db, GetDecoderInfo(kRtpPayloadType))
.WillRepeatedly(Return(&info));
@ -97,7 +100,8 @@ TEST(TimestampScaler, TestG722LargeStep) {
MockDecoderDatabase db;
auto factory = CreateBuiltinAudioDecoderFactory();
// Use G722, which has a factor 2 scaling.
const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderG722, factory);
const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderG722,
rtc::nullopt, factory);
static const uint8_t kRtpPayloadType = 17;
EXPECT_CALL(db, GetDecoderInfo(kRtpPayloadType))
.WillRepeatedly(Return(&info));
@ -127,9 +131,9 @@ TEST(TimestampScaler, TestG722WithCng) {
auto factory = CreateBuiltinAudioDecoderFactory();
// Use G722, which has a factor 2 scaling.
const DecoderDatabase::DecoderInfo info_g722(NetEqDecoder::kDecoderG722,
factory);
rtc::nullopt, factory);
const DecoderDatabase::DecoderInfo info_cng(NetEqDecoder::kDecoderCNGwb,
factory);
rtc::nullopt, factory);
static const uint8_t kRtpPayloadTypeG722 = 17;
static const uint8_t kRtpPayloadTypeCng = 13;
EXPECT_CALL(db, GetDecoderInfo(kRtpPayloadTypeG722))
@ -170,7 +174,8 @@ TEST(TimestampScaler, TestG722Packet) {
MockDecoderDatabase db;
auto factory = CreateBuiltinAudioDecoderFactory();
// Use G722, which has a factor 2 scaling.
const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderG722, factory);
const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderG722,
rtc::nullopt, factory);
static const uint8_t kRtpPayloadType = 17;
EXPECT_CALL(db, GetDecoderInfo(kRtpPayloadType))
.WillRepeatedly(Return(&info));
@ -199,7 +204,8 @@ TEST(TimestampScaler, TestG722PacketList) {
MockDecoderDatabase db;
auto factory = CreateBuiltinAudioDecoderFactory();
// Use G722, which has a factor 2 scaling.
const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderG722, factory);
const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderG722,
rtc::nullopt, factory);
static const uint8_t kRtpPayloadType = 17;
EXPECT_CALL(db, GetDecoderInfo(kRtpPayloadType))
.WillRepeatedly(Return(&info));
@ -232,7 +238,8 @@ TEST(TimestampScaler, TestG722Reset) {
MockDecoderDatabase db;
auto factory = CreateBuiltinAudioDecoderFactory();
// Use G722, which has a factor 2 scaling.
const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderG722, factory);
const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderG722,
rtc::nullopt, factory);
static const uint8_t kRtpPayloadType = 17;
EXPECT_CALL(db, GetDecoderInfo(kRtpPayloadType))
.WillRepeatedly(Return(&info));
@ -272,7 +279,8 @@ TEST(TimestampScaler, TestG722Reset) {
TEST(TimestampScaler, TestOpusLargeStep) {
MockDecoderDatabase db;
auto factory = CreateBuiltinAudioDecoderFactory();
const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderOpus, factory);
const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderOpus,
rtc::nullopt, factory);
static const uint8_t kRtpPayloadType = 17;
EXPECT_CALL(db, GetDecoderInfo(kRtpPayloadType))
.WillRepeatedly(Return(&info));