blob: e7757ae5b16863fd4695ed6508e36527eda9c72b [file] [log] [blame]
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001/*
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020011#include "modules/audio_coding/neteq/neteq_impl.h"
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +000012
13#include <assert.h>
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +000014
15#include <algorithm>
ossu61a208b2016-09-20 01:38:00 -070016#include <utility>
ossu97ba30e2016-04-25 07:55:58 -070017#include <vector>
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +000018
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020019#include "api/audio_codecs/audio_decoder.h"
20#include "common_audio/signal_processing/include/signal_processing_library.h"
21#include "modules/audio_coding/neteq/accelerate.h"
22#include "modules/audio_coding/neteq/background_noise.h"
23#include "modules/audio_coding/neteq/buffer_level_filter.h"
24#include "modules/audio_coding/neteq/comfort_noise.h"
25#include "modules/audio_coding/neteq/decision_logic.h"
26#include "modules/audio_coding/neteq/decoder_database.h"
27#include "modules/audio_coding/neteq/defines.h"
28#include "modules/audio_coding/neteq/delay_manager.h"
29#include "modules/audio_coding/neteq/delay_peak_detector.h"
30#include "modules/audio_coding/neteq/dtmf_buffer.h"
31#include "modules/audio_coding/neteq/dtmf_tone_generator.h"
32#include "modules/audio_coding/neteq/expand.h"
33#include "modules/audio_coding/neteq/merge.h"
34#include "modules/audio_coding/neteq/nack_tracker.h"
35#include "modules/audio_coding/neteq/normal.h"
36#include "modules/audio_coding/neteq/packet.h"
37#include "modules/audio_coding/neteq/packet_buffer.h"
38#include "modules/audio_coding/neteq/post_decode_vad.h"
39#include "modules/audio_coding/neteq/preemptive_expand.h"
40#include "modules/audio_coding/neteq/red_payload_splitter.h"
41#include "modules/audio_coding/neteq/sync_buffer.h"
42#include "modules/audio_coding/neteq/tick_timer.h"
43#include "modules/audio_coding/neteq/timestamp_scaler.h"
44#include "modules/include/module_common_types.h"
45#include "rtc_base/checks.h"
46#include "rtc_base/logging.h"
47#include "rtc_base/safe_conversions.h"
48#include "rtc_base/sanitizer.h"
49#include "rtc_base/trace_event.h"
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +000050
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +000051namespace webrtc {
52
ossue3525782016-05-25 07:37:43 -070053NetEqImpl::Dependencies::Dependencies(
54 const NetEq::Config& config,
55 const rtc::scoped_refptr<AudioDecoderFactory>& decoder_factory)
henrik.lundin1d9061e2016-04-26 12:19:34 -070056 : tick_timer(new TickTimer),
57 buffer_level_filter(new BufferLevelFilter),
ossue3525782016-05-25 07:37:43 -070058 decoder_database(new DecoderDatabase(decoder_factory)),
henrik.lundinf3933702016-04-28 01:53:52 -070059 delay_peak_detector(new DelayPeakDetector(tick_timer.get())),
henrik.lundin1d9061e2016-04-26 12:19:34 -070060 delay_manager(new DelayManager(config.max_packets_in_buffer,
henrik.lundin8f8c96d2016-04-28 23:19:20 -070061 delay_peak_detector.get(),
62 tick_timer.get())),
henrik.lundin1d9061e2016-04-26 12:19:34 -070063 dtmf_buffer(new DtmfBuffer(config.sample_rate_hz)),
64 dtmf_tone_generator(new DtmfToneGenerator),
65 packet_buffer(
66 new PacketBuffer(config.max_packets_in_buffer, tick_timer.get())),
ossua70695a2016-09-22 02:06:28 -070067 red_payload_splitter(new RedPayloadSplitter),
henrik.lundin1d9061e2016-04-26 12:19:34 -070068 timestamp_scaler(new TimestampScaler(*decoder_database)),
69 accelerate_factory(new AccelerateFactory),
70 expand_factory(new ExpandFactory),
71 preemptive_expand_factory(new PreemptiveExpandFactory) {}
72
73NetEqImpl::Dependencies::~Dependencies() = default;
74
henrik.lundin@webrtc.orgea257842014-08-07 12:27:37 +000075NetEqImpl::NetEqImpl(const NetEq::Config& config,
henrik.lundin1d9061e2016-04-26 12:19:34 -070076 Dependencies&& deps,
turaj@webrtc.org8d1cdaa2014-04-11 18:47:55 +000077 bool create_components)
henrik.lundin1d9061e2016-04-26 12:19:34 -070078 : tick_timer_(std::move(deps.tick_timer)),
79 buffer_level_filter_(std::move(deps.buffer_level_filter)),
80 decoder_database_(std::move(deps.decoder_database)),
81 delay_manager_(std::move(deps.delay_manager)),
82 delay_peak_detector_(std::move(deps.delay_peak_detector)),
83 dtmf_buffer_(std::move(deps.dtmf_buffer)),
84 dtmf_tone_generator_(std::move(deps.dtmf_tone_generator)),
85 packet_buffer_(std::move(deps.packet_buffer)),
ossua70695a2016-09-22 02:06:28 -070086 red_payload_splitter_(std::move(deps.red_payload_splitter)),
henrik.lundin1d9061e2016-04-26 12:19:34 -070087 timestamp_scaler_(std::move(deps.timestamp_scaler)),
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +000088 vad_(new PostDecodeVad()),
henrik.lundin1d9061e2016-04-26 12:19:34 -070089 expand_factory_(std::move(deps.expand_factory)),
90 accelerate_factory_(std::move(deps.accelerate_factory)),
91 preemptive_expand_factory_(std::move(deps.preemptive_expand_factory)),
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +000092 last_mode_(kModeNormal),
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +000093 decoded_buffer_length_(kMaxFrameSize),
94 decoded_buffer_(new int16_t[decoded_buffer_length_]),
95 playout_timestamp_(0),
96 new_codec_(false),
97 timestamp_(0),
98 reset_decoder_(false),
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +000099 ssrc_(0),
100 first_packet_(true),
henrik.lundin@webrtc.orgea257842014-08-07 12:27:37 +0000101 background_noise_mode_(config.background_noise_mode),
henrik.lundin@webrtc.org7cbc4f92014-10-07 06:37:39 +0000102 playout_mode_(config.playout_mode),
Henrik Lundincf808d22015-05-27 14:33:29 +0200103 enable_fast_accelerate_(config.enable_fast_accelerate),
henrik.lundin7a926812016-05-12 13:51:28 -0700104 nack_enabled_(false),
105 enable_muted_state_(config.enable_muted_state) {
Henrik Lundin905495c2015-05-25 16:58:41 +0200106 LOG(LS_INFO) << "NetEq config: " << config.ToString();
henrik.lundin@webrtc.orgea257842014-08-07 12:27:37 +0000107 int fs = config.sample_rate_hz;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000108 if (fs != 8000 && fs != 16000 && fs != 32000 && fs != 48000) {
109 LOG(LS_ERROR) << "Sample rate " << fs << " Hz not supported. " <<
110 "Changing to 8000 Hz.";
111 fs = 8000;
112 }
henrik.lundin1d9061e2016-04-26 12:19:34 -0700113 delay_manager_->SetMaximumDelay(config.max_delay_ms);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000114 fs_hz_ = fs;
115 fs_mult_ = fs / 8000;
henrik.lundind89814b2015-11-23 06:49:25 -0800116 last_output_sample_rate_hz_ = fs;
Peter Kastingdce40cf2015-08-24 14:52:23 -0700117 output_size_samples_ = static_cast<size_t>(kOutputSizeMs * 8 * fs_mult_);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000118 decoder_frame_length_ = 3 * output_size_samples_;
119 WebRtcSpl_Init();
turaj@webrtc.org8d1cdaa2014-04-11 18:47:55 +0000120 if (create_components) {
121 SetSampleRateAndChannels(fs, 1); // Default is 1 channel.
122 }
henrik.lundin9bc26672015-11-02 03:25:57 -0800123 RTC_DCHECK(!vad_->enabled());
124 if (config.enable_post_decode_vad) {
125 vad_->Enable();
126 }
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000127}
128
Henrik Lundind67a2192015-08-03 12:54:37 +0200129NetEqImpl::~NetEqImpl() = default;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000130
Henrik Lundin70c09bd2017-04-24 15:56:56 +0200131int NetEqImpl::InsertPacket(const RTPHeader& rtp_header,
kwibergee2bac22015-11-11 10:34:00 -0800132 rtc::ArrayView<const uint8_t> payload,
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000133 uint32_t receive_timestamp) {
kwibergac554ee2016-09-02 00:39:33 -0700134 rtc::MsanCheckInitialized(payload);
henrik.lundina689b442015-12-17 03:50:05 -0800135 TRACE_EVENT0("webrtc", "NetEqImpl::InsertPacket");
Tommi9090e0b2016-01-20 13:39:36 +0100136 rtc::CritScope lock(&crit_sect_);
Henrik Lundinc417d9e2017-06-14 12:29:03 +0200137 if (InsertPacketInternal(rtp_header, payload, receive_timestamp) != 0) {
henrik.lundin@webrtc.orge7ce4372014-01-09 14:01:55 +0000138 return kFail;
139 }
140 return kOK;
turaj@webrtc.org7b75ac62013-09-26 00:27:56 +0000141}
142
henrik.lundinb8c55b12017-05-10 07:38:01 -0700143void NetEqImpl::InsertEmptyPacket(const RTPHeader& /*rtp_header*/) {
144 // TODO(henrik.lundin) Handle NACK as well. This will make use of the
145 // rtp_header parameter.
146 // https://bugs.chromium.org/p/webrtc/issues/detail?id=7611
147 rtc::CritScope lock(&crit_sect_);
148 delay_manager_->RegisterEmptyPacket();
149}
150
henrik.lundin500c04b2016-03-08 02:36:04 -0800151namespace {
152void SetAudioFrameActivityAndType(bool vad_enabled,
henrik.lundin55480f52016-03-08 02:37:57 -0800153 NetEqImpl::OutputType type,
henrik.lundin500c04b2016-03-08 02:36:04 -0800154 AudioFrame::VADActivity last_vad_activity,
155 AudioFrame* audio_frame) {
156 switch (type) {
henrik.lundin55480f52016-03-08 02:37:57 -0800157 case NetEqImpl::OutputType::kNormalSpeech: {
henrik.lundin500c04b2016-03-08 02:36:04 -0800158 audio_frame->speech_type_ = AudioFrame::kNormalSpeech;
159 audio_frame->vad_activity_ = AudioFrame::kVadActive;
160 break;
161 }
henrik.lundin55480f52016-03-08 02:37:57 -0800162 case NetEqImpl::OutputType::kVadPassive: {
henrik.lundin500c04b2016-03-08 02:36:04 -0800163 // This should only be reached if the VAD is enabled.
164 RTC_DCHECK(vad_enabled);
165 audio_frame->speech_type_ = AudioFrame::kNormalSpeech;
166 audio_frame->vad_activity_ = AudioFrame::kVadPassive;
167 break;
168 }
henrik.lundin55480f52016-03-08 02:37:57 -0800169 case NetEqImpl::OutputType::kCNG: {
henrik.lundin500c04b2016-03-08 02:36:04 -0800170 audio_frame->speech_type_ = AudioFrame::kCNG;
171 audio_frame->vad_activity_ = AudioFrame::kVadPassive;
172 break;
173 }
henrik.lundin55480f52016-03-08 02:37:57 -0800174 case NetEqImpl::OutputType::kPLC: {
henrik.lundin500c04b2016-03-08 02:36:04 -0800175 audio_frame->speech_type_ = AudioFrame::kPLC;
176 audio_frame->vad_activity_ = last_vad_activity;
177 break;
178 }
henrik.lundin55480f52016-03-08 02:37:57 -0800179 case NetEqImpl::OutputType::kPLCCNG: {
henrik.lundin500c04b2016-03-08 02:36:04 -0800180 audio_frame->speech_type_ = AudioFrame::kPLCCNG;
181 audio_frame->vad_activity_ = AudioFrame::kVadPassive;
182 break;
183 }
184 default:
185 RTC_NOTREACHED();
186 }
187 if (!vad_enabled) {
188 // Always set kVadUnknown when receive VAD is inactive.
189 audio_frame->vad_activity_ = AudioFrame::kVadUnknown;
190 }
191}
henrik.lundinbc89de32016-03-08 05:20:14 -0800192} // namespace
henrik.lundin500c04b2016-03-08 02:36:04 -0800193
henrik.lundin7a926812016-05-12 13:51:28 -0700194int NetEqImpl::GetAudio(AudioFrame* audio_frame, bool* muted) {
henrik.lundine1ca1672016-01-08 03:50:08 -0800195 TRACE_EVENT0("webrtc", "NetEqImpl::GetAudio");
Tommi9090e0b2016-01-20 13:39:36 +0100196 rtc::CritScope lock(&crit_sect_);
Henrik Lundinc417d9e2017-06-14 12:29:03 +0200197 if (GetAudioInternal(audio_frame, muted) != 0) {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000198 return kFail;
199 }
henrik.lundin5fac3f02016-08-24 11:18:49 -0700200 RTC_DCHECK_EQ(
201 audio_frame->sample_rate_hz_,
kwibergd3edd772017-03-01 18:52:48 -0800202 rtc::dchecked_cast<int>(audio_frame->samples_per_channel_ * 100));
henrik.lundina4491072017-07-06 05:23:53 -0700203 RTC_DCHECK_EQ(*muted, audio_frame->muted());
henrik.lundin500c04b2016-03-08 02:36:04 -0800204 SetAudioFrameActivityAndType(vad_->enabled(), LastOutputType(),
205 last_vad_activity_, audio_frame);
206 last_vad_activity_ = audio_frame->vad_activity_;
henrik.lundin6d8e0112016-03-04 10:34:21 -0800207 last_output_sample_rate_hz_ = audio_frame->sample_rate_hz_;
henrik.lundind89814b2015-11-23 06:49:25 -0800208 RTC_DCHECK(last_output_sample_rate_hz_ == 8000 ||
209 last_output_sample_rate_hz_ == 16000 ||
210 last_output_sample_rate_hz_ == 32000 ||
211 last_output_sample_rate_hz_ == 48000)
212 << "Unexpected sample rate " << last_output_sample_rate_hz_;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000213 return kOK;
214}
215
kwiberg1c07c702017-03-27 07:15:49 -0700216void NetEqImpl::SetCodecs(const std::map<int, SdpAudioFormat>& codecs) {
217 rtc::CritScope lock(&crit_sect_);
218 const std::vector<int> changed_payload_types =
219 decoder_database_->SetCodecs(codecs);
220 for (const int pt : changed_payload_types) {
minyue-webrtcfae474c2017-07-05 11:17:40 +0200221 packet_buffer_->DiscardPacketsWithPayloadType(pt, &stats_);
kwiberg1c07c702017-03-27 07:15:49 -0700222 }
223}
224
kwibergee1879c2015-10-29 06:20:28 -0700225int NetEqImpl::RegisterPayloadType(NetEqDecoder codec,
henrik.lundin4cf61dd2015-12-09 06:20:58 -0800226 const std::string& name,
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000227 uint8_t rtp_payload_type) {
Tommi9090e0b2016-01-20 13:39:36 +0100228 rtc::CritScope lock(&crit_sect_);
Henrik Lundind67a2192015-08-03 12:54:37 +0200229 LOG(LS_VERBOSE) << "RegisterPayloadType "
kwibergee1879c2015-10-29 06:20:28 -0700230 << static_cast<int>(rtp_payload_type) << " "
231 << static_cast<int>(codec);
Henrik Lundinc417d9e2017-06-14 12:29:03 +0200232 if (decoder_database_->RegisterPayload(rtp_payload_type, codec, name) !=
233 DecoderDatabase::kOK) {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000234 return kFail;
235 }
236 return kOK;
237}
238
239int NetEqImpl::RegisterExternalDecoder(AudioDecoder* decoder,
kwibergee1879c2015-10-29 06:20:28 -0700240 NetEqDecoder codec,
henrik.lundin4cf61dd2015-12-09 06:20:58 -0800241 const std::string& codec_name,
kwiberg342f7402016-06-16 03:18:00 -0700242 uint8_t rtp_payload_type) {
Tommi9090e0b2016-01-20 13:39:36 +0100243 rtc::CritScope lock(&crit_sect_);
Henrik Lundind67a2192015-08-03 12:54:37 +0200244 LOG(LS_VERBOSE) << "RegisterExternalDecoder "
kwibergee1879c2015-10-29 06:20:28 -0700245 << static_cast<int>(rtp_payload_type) << " "
246 << static_cast<int>(codec);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000247 if (!decoder) {
248 LOG(LS_ERROR) << "Cannot register external decoder with NULL pointer";
249 assert(false);
250 return kFail;
251 }
Henrik Lundinc417d9e2017-06-14 12:29:03 +0200252 if (decoder_database_->InsertExternal(rtp_payload_type, codec, codec_name,
253 decoder) != DecoderDatabase::kOK) {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000254 return kFail;
255 }
256 return kOK;
257}
258
kwiberg5adaf732016-10-04 09:33:27 -0700259bool NetEqImpl::RegisterPayloadType(int rtp_payload_type,
260 const SdpAudioFormat& audio_format) {
261 LOG(LS_VERBOSE) << "NetEqImpl::RegisterPayloadType: payload type "
262 << rtp_payload_type << ", codec " << audio_format;
263 rtc::CritScope lock(&crit_sect_);
Henrik Lundinc417d9e2017-06-14 12:29:03 +0200264 return decoder_database_->RegisterPayload(rtp_payload_type, audio_format) ==
265 DecoderDatabase::kOK;
kwiberg5adaf732016-10-04 09:33:27 -0700266}
267
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000268int NetEqImpl::RemovePayloadType(uint8_t rtp_payload_type) {
Tommi9090e0b2016-01-20 13:39:36 +0100269 rtc::CritScope lock(&crit_sect_);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000270 int ret = decoder_database_->Remove(rtp_payload_type);
Henrik Lundinc417d9e2017-06-14 12:29:03 +0200271 if (ret == DecoderDatabase::kOK || ret == DecoderDatabase::kDecoderNotFound) {
minyue-webrtcfae474c2017-07-05 11:17:40 +0200272 packet_buffer_->DiscardPacketsWithPayloadType(rtp_payload_type, &stats_);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000273 return kOK;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000274 }
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000275 return kFail;
276}
277
kwiberg6b19b562016-09-20 04:02:25 -0700278void NetEqImpl::RemoveAllPayloadTypes() {
279 rtc::CritScope lock(&crit_sect_);
280 decoder_database_->RemoveAll();
281}
282
turaj@webrtc.orgf1efc572013-08-16 23:44:24 +0000283bool NetEqImpl::SetMinimumDelay(int delay_ms) {
Tommi9090e0b2016-01-20 13:39:36 +0100284 rtc::CritScope lock(&crit_sect_);
Gustaf Ullberg48d96c02017-09-15 13:59:52 +0200285 if (delay_ms >= 0 && delay_ms <= 10000) {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000286 assert(delay_manager_.get());
turaj@webrtc.orgf1efc572013-08-16 23:44:24 +0000287 return delay_manager_->SetMinimumDelay(delay_ms);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000288 }
289 return false;
290}
291
turaj@webrtc.orgf1efc572013-08-16 23:44:24 +0000292bool NetEqImpl::SetMaximumDelay(int delay_ms) {
Tommi9090e0b2016-01-20 13:39:36 +0100293 rtc::CritScope lock(&crit_sect_);
Gustaf Ullberg48d96c02017-09-15 13:59:52 +0200294 if (delay_ms >= 0 && delay_ms <= 10000) {
turaj@webrtc.orgf1efc572013-08-16 23:44:24 +0000295 assert(delay_manager_.get());
296 return delay_manager_->SetMaximumDelay(delay_ms);
297 }
298 return false;
299}
300
301int NetEqImpl::LeastRequiredDelayMs() const {
Tommi9090e0b2016-01-20 13:39:36 +0100302 rtc::CritScope lock(&crit_sect_);
turaj@webrtc.orgf1efc572013-08-16 23:44:24 +0000303 assert(delay_manager_.get());
304 return delay_manager_->least_required_delay_ms();
305}
306
Karl Wiberg7f6c4d42015-04-09 15:44:22 +0200307int NetEqImpl::SetTargetDelay() {
308 return kNotImplemented;
309}
310
henrik.lundin114c1b32017-04-26 07:47:32 -0700311int NetEqImpl::TargetDelayMs() {
312 rtc::CritScope lock(&crit_sect_);
313 RTC_DCHECK(delay_manager_.get());
314 // The value from TargetLevel() is in number of packets, represented in Q8.
315 const size_t target_delay_samples =
316 (delay_manager_->TargetLevel() * decoder_frame_length_) >> 8;
317 return static_cast<int>(target_delay_samples) /
318 rtc::CheckedDivExact(fs_hz_, 1000);
Karl Wiberg7f6c4d42015-04-09 15:44:22 +0200319}
320
henrik.lundin9c3efd02015-08-27 13:12:22 -0700321int NetEqImpl::CurrentDelayMs() const {
Tommi9090e0b2016-01-20 13:39:36 +0100322 rtc::CritScope lock(&crit_sect_);
henrik.lundin9c3efd02015-08-27 13:12:22 -0700323 if (fs_hz_ == 0)
324 return 0;
325 // Sum up the samples in the packet buffer with the future length of the sync
326 // buffer, and divide the sum by the sample rate.
327 const size_t delay_samples =
ossu61a208b2016-09-20 01:38:00 -0700328 packet_buffer_->NumSamplesInBuffer(decoder_frame_length_) +
henrik.lundin9c3efd02015-08-27 13:12:22 -0700329 sync_buffer_->FutureLength();
330 // The division below will truncate.
331 const int delay_ms =
332 static_cast<int>(delay_samples) / rtc::CheckedDivExact(fs_hz_, 1000);
333 return delay_ms;
Karl Wiberg7f6c4d42015-04-09 15:44:22 +0200334}
335
henrik.lundinb3f1c5d2016-08-22 15:39:53 -0700336int NetEqImpl::FilteredCurrentDelayMs() const {
337 rtc::CritScope lock(&crit_sect_);
338 // Calculate the filtered packet buffer level in samples. The value from
339 // |buffer_level_filter_| is in number of packets, represented in Q8.
340 const size_t packet_buffer_samples =
341 (buffer_level_filter_->filtered_current_level() *
342 decoder_frame_length_) >>
343 8;
344 // Sum up the filtered packet buffer level with the future length of the sync
345 // buffer, and divide the sum by the sample rate.
346 const size_t delay_samples =
347 packet_buffer_samples + sync_buffer_->FutureLength();
348 // The division below will truncate. The return value is in ms.
349 return static_cast<int>(delay_samples) / rtc::CheckedDivExact(fs_hz_, 1000);
350}
351
henrik.lundin@webrtc.org7cbc4f92014-10-07 06:37:39 +0000352// Deprecated.
353// TODO(henrik.lundin) Delete.
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000354void NetEqImpl::SetPlayoutMode(NetEqPlayoutMode mode) {
Tommi9090e0b2016-01-20 13:39:36 +0100355 rtc::CritScope lock(&crit_sect_);
henrik.lundin@webrtc.org7cbc4f92014-10-07 06:37:39 +0000356 if (mode != playout_mode_) {
357 playout_mode_ = mode;
358 CreateDecisionLogic();
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000359 }
360}
361
henrik.lundin@webrtc.org7cbc4f92014-10-07 06:37:39 +0000362// Deprecated.
363// TODO(henrik.lundin) Delete.
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000364NetEqPlayoutMode NetEqImpl::PlayoutMode() const {
Tommi9090e0b2016-01-20 13:39:36 +0100365 rtc::CritScope lock(&crit_sect_);
henrik.lundin@webrtc.org7cbc4f92014-10-07 06:37:39 +0000366 return playout_mode_;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000367}
368
369int NetEqImpl::NetworkStatistics(NetEqNetworkStatistics* stats) {
Tommi9090e0b2016-01-20 13:39:36 +0100370 rtc::CritScope lock(&crit_sect_);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000371 assert(decoder_database_.get());
Peter Kastingdce40cf2015-08-24 14:52:23 -0700372 const size_t total_samples_in_buffers =
ossu61a208b2016-09-20 01:38:00 -0700373 packet_buffer_->NumSamplesInBuffer(decoder_frame_length_) +
Peter Kastingdce40cf2015-08-24 14:52:23 -0700374 sync_buffer_->FutureLength();
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000375 assert(delay_manager_.get());
376 assert(decision_logic_.get());
Henrik Lundindccfc402017-09-25 12:30:58 +0200377 const int ms_per_packet = rtc::dchecked_cast<int>(
378 decision_logic_->packet_length_samples() / (fs_hz_ / 1000));
379 stats_.PopulateDelayManagerStats(ms_per_packet, *delay_manager_.get(), stats);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000380 stats_.GetNetworkStatistics(fs_hz_, total_samples_in_buffers,
Henrik Lundindccfc402017-09-25 12:30:58 +0200381 decoder_frame_length_, stats);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000382 return 0;
383}
384
Steve Anton2dbc69f2017-08-24 17:15:13 -0700385NetEqLifetimeStatistics NetEqImpl::GetLifetimeStatistics() const {
386 rtc::CritScope lock(&crit_sect_);
387 return stats_.GetLifetimeStatistics();
388}
389
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000390void NetEqImpl::GetRtcpStatistics(RtcpStatistics* stats) {
Tommi9090e0b2016-01-20 13:39:36 +0100391 rtc::CritScope lock(&crit_sect_);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000392 if (stats) {
393 rtcp_.GetStatistics(false, stats);
394 }
395}
396
397void NetEqImpl::GetRtcpStatisticsNoReset(RtcpStatistics* stats) {
Tommi9090e0b2016-01-20 13:39:36 +0100398 rtc::CritScope lock(&crit_sect_);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000399 if (stats) {
400 rtcp_.GetStatistics(true, stats);
401 }
402}
403
404void NetEqImpl::EnableVad() {
Tommi9090e0b2016-01-20 13:39:36 +0100405 rtc::CritScope lock(&crit_sect_);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000406 assert(vad_.get());
407 vad_->Enable();
408}
409
410void NetEqImpl::DisableVad() {
Tommi9090e0b2016-01-20 13:39:36 +0100411 rtc::CritScope lock(&crit_sect_);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000412 assert(vad_.get());
413 vad_->Disable();
414}
415
henrik.lundin15c51e32016-04-06 08:38:56 -0700416rtc::Optional<uint32_t> NetEqImpl::GetPlayoutTimestamp() const {
Tommi9090e0b2016-01-20 13:39:36 +0100417 rtc::CritScope lock(&crit_sect_);
henrik.lundin0d96ab72016-04-06 12:28:26 -0700418 if (first_packet_ || last_mode_ == kModeRfc3389Cng ||
419 last_mode_ == kModeCodecInternalCng) {
wu@webrtc.org94454b72014-06-05 20:34:08 +0000420 // We don't have a valid RTP timestamp until we have decoded our first
henrik.lundin0d96ab72016-04-06 12:28:26 -0700421 // RTP packet. Also, the RTP timestamp is not accurate while playing CNG,
422 // which is indicated by returning an empty value.
henrik.lundin9a410dd2016-04-06 01:39:22 -0700423 return rtc::Optional<uint32_t>();
wu@webrtc.org94454b72014-06-05 20:34:08 +0000424 }
henrik.lundin9a410dd2016-04-06 01:39:22 -0700425 return rtc::Optional<uint32_t>(
426 timestamp_scaler_->ToExternal(playout_timestamp_));
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000427}
428
henrik.lundind89814b2015-11-23 06:49:25 -0800429int NetEqImpl::last_output_sample_rate_hz() const {
Tommi9090e0b2016-01-20 13:39:36 +0100430 rtc::CritScope lock(&crit_sect_);
henrik.lundind89814b2015-11-23 06:49:25 -0800431 return last_output_sample_rate_hz_;
432}
433
kwiberg6f0f6162016-09-20 03:07:46 -0700434rtc::Optional<CodecInst> NetEqImpl::GetDecoder(int payload_type) const {
435 rtc::CritScope lock(&crit_sect_);
436 const DecoderDatabase::DecoderInfo* di =
437 decoder_database_->GetDecoderInfo(payload_type);
438 if (!di) {
439 return rtc::Optional<CodecInst>();
440 }
441
442 // Create a CodecInst with some fields set. The remaining fields are zeroed,
443 // but we tell MSan to consider them uninitialized.
444 CodecInst ci = {0};
445 rtc::MsanMarkUninitialized(rtc::MakeArrayView(&ci, 1));
446 ci.pltype = payload_type;
kwiberge9413062016-11-03 05:29:05 -0700447 std::strncpy(ci.plname, di->get_name().c_str(), sizeof(ci.plname));
kwiberg6f0f6162016-09-20 03:07:46 -0700448 ci.plname[sizeof(ci.plname) - 1] = '\0';
solenberg2779bab2016-11-17 04:45:19 -0800449 ci.plfreq = di->IsRed() ? 8000 : di->SampleRateHz();
kwiberg6f0f6162016-09-20 03:07:46 -0700450 AudioDecoder* const decoder = di->GetDecoder();
451 ci.channels = decoder ? decoder->Channels() : 1;
452 return rtc::Optional<CodecInst>(ci);
453}
454
ossuf1b08da2016-09-23 02:19:43 -0700455rtc::Optional<SdpAudioFormat> NetEqImpl::GetDecoderFormat(
456 int payload_type) const {
kwibergc4ccd4d2016-09-21 10:55:15 -0700457 rtc::CritScope lock(&crit_sect_);
458 const DecoderDatabase::DecoderInfo* const di =
459 decoder_database_->GetDecoderInfo(payload_type);
460 if (!di) {
ossuf1b08da2016-09-23 02:19:43 -0700461 return rtc::Optional<SdpAudioFormat>(); // Payload type not registered.
kwibergc4ccd4d2016-09-21 10:55:15 -0700462 }
ossuf1b08da2016-09-23 02:19:43 -0700463 return rtc::Optional<SdpAudioFormat>(di->GetFormat());
kwibergc4ccd4d2016-09-21 10:55:15 -0700464}
465
Karl Wiberg7f6c4d42015-04-09 15:44:22 +0200466int NetEqImpl::SetTargetNumberOfChannels() {
467 return kNotImplemented;
468}
469
470int NetEqImpl::SetTargetSampleRate() {
471 return kNotImplemented;
472}
473
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000474void NetEqImpl::FlushBuffers() {
Tommi9090e0b2016-01-20 13:39:36 +0100475 rtc::CritScope lock(&crit_sect_);
Henrik Lundind67a2192015-08-03 12:54:37 +0200476 LOG(LS_VERBOSE) << "FlushBuffers";
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000477 packet_buffer_->Flush();
henrik.lundin@webrtc.org0d5da252013-09-18 21:12:38 +0000478 assert(sync_buffer_.get());
479 assert(expand_.get());
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000480 sync_buffer_->Flush();
481 sync_buffer_->set_next_index(sync_buffer_->next_index() -
482 expand_->overlap_length());
483 // Set to wait for new codec.
484 first_packet_ = true;
485}
486
turaj@webrtc.org3170b572013-08-30 15:36:53 +0000487void NetEqImpl::PacketBufferStatistics(int* current_num_packets,
henrik.lundin@webrtc.org116ed1d2014-04-28 08:20:04 +0000488 int* max_num_packets) const {
Tommi9090e0b2016-01-20 13:39:36 +0100489 rtc::CritScope lock(&crit_sect_);
henrik.lundin@webrtc.org116ed1d2014-04-28 08:20:04 +0000490 packet_buffer_->BufferStat(current_num_packets, max_num_packets);
turaj@webrtc.org3170b572013-08-30 15:36:53 +0000491}
492
henrik.lundin48ed9302015-10-29 05:36:24 -0700493void NetEqImpl::EnableNack(size_t max_nack_list_size) {
Tommi9090e0b2016-01-20 13:39:36 +0100494 rtc::CritScope lock(&crit_sect_);
henrik.lundin48ed9302015-10-29 05:36:24 -0700495 if (!nack_enabled_) {
496 const int kNackThresholdPackets = 2;
henrik.lundin91951862016-06-08 06:43:41 -0700497 nack_.reset(NackTracker::Create(kNackThresholdPackets));
henrik.lundin48ed9302015-10-29 05:36:24 -0700498 nack_enabled_ = true;
499 nack_->UpdateSampleRate(fs_hz_);
500 }
501 nack_->SetMaxNackListSize(max_nack_list_size);
502}
503
504void NetEqImpl::DisableNack() {
Tommi9090e0b2016-01-20 13:39:36 +0100505 rtc::CritScope lock(&crit_sect_);
henrik.lundin48ed9302015-10-29 05:36:24 -0700506 nack_.reset();
507 nack_enabled_ = false;
508}
509
510std::vector<uint16_t> NetEqImpl::GetNackList(int64_t round_trip_time_ms) const {
Tommi9090e0b2016-01-20 13:39:36 +0100511 rtc::CritScope lock(&crit_sect_);
henrik.lundin48ed9302015-10-29 05:36:24 -0700512 if (!nack_enabled_) {
513 return std::vector<uint16_t>();
514 }
515 RTC_DCHECK(nack_.get());
516 return nack_->GetNackList(round_trip_time_ms);
minyue@webrtc.orgd7301772013-08-29 00:58:14 +0000517}
518
henrik.lundin114c1b32017-04-26 07:47:32 -0700519std::vector<uint32_t> NetEqImpl::LastDecodedTimestamps() const {
520 rtc::CritScope lock(&crit_sect_);
521 return last_decoded_timestamps_;
522}
523
524int NetEqImpl::SyncBufferSizeMs() const {
525 rtc::CritScope lock(&crit_sect_);
526 return rtc::dchecked_cast<int>(sync_buffer_->FutureLength() /
527 rtc::CheckedDivExact(fs_hz_, 1000));
528}
529
henrik.lundin@webrtc.orgb287d962014-04-07 21:21:45 +0000530const SyncBuffer* NetEqImpl::sync_buffer_for_test() const {
Tommi9090e0b2016-01-20 13:39:36 +0100531 rtc::CritScope lock(&crit_sect_);
henrik.lundin@webrtc.orgb287d962014-04-07 21:21:45 +0000532 return sync_buffer_.get();
533}
534
minyue5bd33972016-05-02 04:46:11 -0700535Operations NetEqImpl::last_operation_for_test() const {
536 rtc::CritScope lock(&crit_sect_);
537 return last_operation_;
538}
539
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000540// Methods below this line are private.
541
Henrik Lundin70c09bd2017-04-24 15:56:56 +0200542int NetEqImpl::InsertPacketInternal(const RTPHeader& rtp_header,
kwibergee2bac22015-11-11 10:34:00 -0800543 rtc::ArrayView<const uint8_t> payload,
ossu17e3fa12016-09-08 04:52:55 -0700544 uint32_t receive_timestamp) {
kwibergee2bac22015-11-11 10:34:00 -0800545 if (payload.empty()) {
546 LOG_F(LS_ERROR) << "payload is empty";
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000547 return kInvalidPointer;
548 }
ossu17e3fa12016-09-08 04:52:55 -0700549
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000550 PacketList packet_list;
ossua73f6c92016-10-24 08:25:28 -0700551 // Insert packet in a packet list.
552 packet_list.push_back([&rtp_header, &payload] {
henrik.lundin@webrtc.orge1d468c2013-01-30 07:37:20 +0000553 // Convert to Packet.
ossua73f6c92016-10-24 08:25:28 -0700554 Packet packet;
Henrik Lundin70c09bd2017-04-24 15:56:56 +0200555 packet.payload_type = rtp_header.payloadType;
556 packet.sequence_number = rtp_header.sequenceNumber;
557 packet.timestamp = rtp_header.timestamp;
ossua73f6c92016-10-24 08:25:28 -0700558 packet.payload.SetData(payload.data(), payload.size());
henrik.lundin84f8cd62016-04-26 07:45:16 -0700559 // Waiting time will be set upon inserting the packet in the buffer.
ossua73f6c92016-10-24 08:25:28 -0700560 RTC_DCHECK(!packet.waiting_time);
561 return packet;
562 }());
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000563
Henrik Lundin70c09bd2017-04-24 15:56:56 +0200564 bool update_sample_rate_and_channels =
565 first_packet_ || (rtp_header.ssrc != ssrc_);
dkirovbroadsofte851a9a2017-03-14 10:00:27 -0700566
567 if (update_sample_rate_and_channels) {
568 // Reset timestamp scaling.
569 timestamp_scaler_->Reset();
570 }
571
Henrik Lundin70c09bd2017-04-24 15:56:56 +0200572 if (!decoder_database_->IsRed(rtp_header.payloadType)) {
dkirovbroadsofte851a9a2017-03-14 10:00:27 -0700573 // Scale timestamp to internal domain (only for some codecs).
574 timestamp_scaler_->ToInternal(&packet_list);
575 }
576
577 // Store these for later use, since the first packet may very well disappear
578 // before we need these values.
579 uint32_t main_timestamp = packet_list.front().timestamp;
580 uint8_t main_payload_type = packet_list.front().payload_type;
581 uint16_t main_sequence_number = packet_list.front().sequence_number;
582
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000583 // Reinitialize NetEq if it's needed (changed SSRC or first call).
dkirovbroadsofte851a9a2017-03-14 10:00:27 -0700584 if (update_sample_rate_and_channels) {
henrik.lundin@webrtc.org6ff3ac12014-11-20 14:14:49 +0000585 // Note: |first_packet_| will be cleared further down in this method, once
586 // the packet has been successfully inserted into the packet buffer.
587
Henrik Lundin70c09bd2017-04-24 15:56:56 +0200588 rtcp_.Init(rtp_header.sequenceNumber);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000589
590 // Flush the packet buffer and DTMF buffer.
591 packet_buffer_->Flush();
592 dtmf_buffer_->Flush();
593
594 // Store new SSRC.
Henrik Lundin70c09bd2017-04-24 15:56:56 +0200595 ssrc_ = rtp_header.ssrc;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000596
turaj@webrtc.org4d06db52013-03-27 18:31:42 +0000597 // Update audio buffer timestamp.
dkirovbroadsofte851a9a2017-03-14 10:00:27 -0700598 sync_buffer_->IncreaseEndTimestamp(main_timestamp - timestamp_);
turaj@webrtc.org4d06db52013-03-27 18:31:42 +0000599
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000600 // Update codecs.
dkirovbroadsofte851a9a2017-03-14 10:00:27 -0700601 timestamp_ = main_timestamp;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000602 }
603
turaj@webrtc.org7b75ac62013-09-26 00:27:56 +0000604 // Update RTCP statistics, only for regular packets.
Henrik Lundin70c09bd2017-04-24 15:56:56 +0200605 rtcp_.Update(rtp_header, receive_timestamp);
ossu7a377612016-10-18 04:06:13 -0700606
607 if (nack_enabled_) {
608 RTC_DCHECK(nack_);
609 if (update_sample_rate_and_channels) {
610 nack_->Reset();
611 }
Henrik Lundin70c09bd2017-04-24 15:56:56 +0200612 nack_->UpdateLastReceivedPacket(rtp_header.sequenceNumber,
613 rtp_header.timestamp);
ossu7a377612016-10-18 04:06:13 -0700614 }
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000615
616 // Check for RED payload type, and separate payloads into several packets.
Henrik Lundin70c09bd2017-04-24 15:56:56 +0200617 if (decoder_database_->IsRed(rtp_header.payloadType)) {
ossua70695a2016-09-22 02:06:28 -0700618 if (!red_payload_splitter_->SplitRed(&packet_list)) {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000619 return kRedundancySplitError;
620 }
621 // Only accept a few RED payloads of the same type as the main data,
622 // DTMF events and CNG.
ossua70695a2016-09-22 02:06:28 -0700623 red_payload_splitter_->CheckRedPayloads(&packet_list, *decoder_database_);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000624 }
625
626 // Check payload types.
627 if (decoder_database_->CheckPayloadTypes(packet_list) ==
628 DecoderDatabase::kDecoderNotFound) {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000629 return kUnknownRtpPayloadType;
630 }
631
ossu7a377612016-10-18 04:06:13 -0700632 RTC_DCHECK(!packet_list.empty());
ossu7a377612016-10-18 04:06:13 -0700633
dkirovbroadsofte851a9a2017-03-14 10:00:27 -0700634 // Update main_timestamp, if new packets appear in the list
635 // after RED splitting.
Henrik Lundin70c09bd2017-04-24 15:56:56 +0200636 if (decoder_database_->IsRed(rtp_header.payloadType)) {
dkirovbroadsofte851a9a2017-03-14 10:00:27 -0700637 timestamp_scaler_->ToInternal(&packet_list);
638 main_timestamp = packet_list.front().timestamp;
639 main_payload_type = packet_list.front().payload_type;
640 main_sequence_number = packet_list.front().sequence_number;
641 }
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000642
643 // Process DTMF payloads. Cycle through the list of packets, and pick out any
644 // DTMF payloads found.
645 PacketList::iterator it = packet_list.begin();
646 while (it != packet_list.end()) {
ossua73f6c92016-10-24 08:25:28 -0700647 const Packet& current_packet = (*it);
648 RTC_DCHECK(!current_packet.payload.empty());
649 if (decoder_database_->IsDtmf(current_packet.payload_type)) {
minyue@webrtc.org9721db72013-08-06 05:36:26 +0000650 DtmfEvent event;
ossua73f6c92016-10-24 08:25:28 -0700651 int ret = DtmfBuffer::ParseEvent(current_packet.timestamp,
652 current_packet.payload.data(),
653 current_packet.payload.size(), &event);
minyue@webrtc.org9721db72013-08-06 05:36:26 +0000654 if (ret != DtmfBuffer::kOK) {
minyue@webrtc.org9721db72013-08-06 05:36:26 +0000655 return kDtmfParsingError;
656 }
657 if (dtmf_buffer_->InsertEvent(event) != DtmfBuffer::kOK) {
minyue@webrtc.org9721db72013-08-06 05:36:26 +0000658 return kDtmfInsertError;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000659 }
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000660 it = packet_list.erase(it);
661 } else {
662 ++it;
663 }
664 }
665
ossu17e3fa12016-09-08 04:52:55 -0700666 // Update bandwidth estimate, if the packet is not comfort noise.
667 if (!packet_list.empty() &&
ossu7a377612016-10-18 04:06:13 -0700668 !decoder_database_->IsComfortNoise(main_payload_type)) {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000669 // The list can be empty here if we got nothing but DTMF payloads.
ossu7a377612016-10-18 04:06:13 -0700670 AudioDecoder* decoder = decoder_database_->GetDecoder(main_payload_type);
671 RTC_DCHECK(decoder); // Should always get a valid object, since we have
672 // already checked that the payload types are known.
ossua73f6c92016-10-24 08:25:28 -0700673 decoder->IncomingPacket(packet_list.front().payload.data(),
674 packet_list.front().payload.size(),
675 packet_list.front().sequence_number,
676 packet_list.front().timestamp,
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000677 receive_timestamp);
678 }
679
ossu61a208b2016-09-20 01:38:00 -0700680 PacketList parsed_packet_list;
681 while (!packet_list.empty()) {
ossua73f6c92016-10-24 08:25:28 -0700682 Packet& packet = packet_list.front();
ossu61a208b2016-09-20 01:38:00 -0700683 const DecoderDatabase::DecoderInfo* info =
ossua73f6c92016-10-24 08:25:28 -0700684 decoder_database_->GetDecoderInfo(packet.payload_type);
ossu61a208b2016-09-20 01:38:00 -0700685 if (!info) {
686 LOG(LS_WARNING) << "SplitAudio unknown payload type";
687 return kUnknownRtpPayloadType;
688 }
689
690 if (info->IsComfortNoise()) {
691 // Carry comfort noise packets along.
ossua73f6c92016-10-24 08:25:28 -0700692 parsed_packet_list.splice(parsed_packet_list.end(), packet_list,
693 packet_list.begin());
ossu61a208b2016-09-20 01:38:00 -0700694 } else {
ossua73f6c92016-10-24 08:25:28 -0700695 const auto sequence_number = packet.sequence_number;
696 const auto payload_type = packet.payload_type;
697 const Packet::Priority original_priority = packet.priority;
698 auto packet_from_result = [&] (AudioDecoder::ParseResult& result) {
699 Packet new_packet;
700 new_packet.sequence_number = sequence_number;
701 new_packet.payload_type = payload_type;
702 new_packet.timestamp = result.timestamp;
703 new_packet.priority.codec_level = result.priority;
704 new_packet.priority.red_level = original_priority.red_level;
705 new_packet.frame = std::move(result.frame);
706 return new_packet;
707 };
708
ossu61a208b2016-09-20 01:38:00 -0700709 std::vector<AudioDecoder::ParseResult> results =
ossua73f6c92016-10-24 08:25:28 -0700710 info->GetDecoder()->ParsePayload(std::move(packet.payload),
711 packet.timestamp);
712 if (results.empty()) {
713 packet_list.pop_front();
714 } else {
715 bool first = true;
716 for (auto& result : results) {
717 RTC_DCHECK(result.frame);
718 RTC_DCHECK_GE(result.priority, 0);
719 if (first) {
720 // Re-use the node and move it to parsed_packet_list.
721 packet_list.front() = packet_from_result(result);
722 parsed_packet_list.splice(parsed_packet_list.end(), packet_list,
723 packet_list.begin());
724 first = false;
725 } else {
726 parsed_packet_list.push_back(packet_from_result(result));
727 }
ossu61a208b2016-09-20 01:38:00 -0700728 }
ossu61a208b2016-09-20 01:38:00 -0700729 }
730 }
731 }
732
Ivo Creusenfd7c0a52017-10-20 12:35:04 +0200733 // Calculate the number of primary (non-FEC/RED) packets.
734 const int number_of_primary_packets = std::count_if(
735 parsed_packet_list.begin(), parsed_packet_list.end(),
736 [](const Packet& in) { return in.priority.codec_level == 0; });
737
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000738 // Insert packets in buffer.
ossua70695a2016-09-22 02:06:28 -0700739 const int ret = packet_buffer_->InsertPacketList(
ossu61a208b2016-09-20 01:38:00 -0700740 &parsed_packet_list, *decoder_database_, &current_rtp_payload_type_,
minyue-webrtc12d30842017-07-19 11:44:06 +0200741 &current_cng_rtp_payload_type_, &stats_);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000742 if (ret == PacketBuffer::kFlushed) {
743 // Reset DSP timestamp etc. if packet buffer flushed.
744 new_codec_ = true;
turaj@webrtc.orga6101d72013-10-01 22:01:09 +0000745 update_sample_rate_and_channels = true;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000746 } else if (ret != PacketBuffer::kOK) {
minyue@webrtc.org7bb54362013-08-06 05:40:57 +0000747 return kOtherError;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000748 }
henrik.lundin@webrtc.org6ff3ac12014-11-20 14:14:49 +0000749
750 if (first_packet_) {
751 first_packet_ = false;
752 // Update the codec on the next GetAudio call.
753 new_codec_ = true;
754 }
755
henrik.lundinda8bbf62016-08-31 03:14:11 -0700756 if (current_rtp_payload_type_) {
757 RTC_DCHECK(decoder_database_->GetDecoderInfo(*current_rtp_payload_type_))
758 << "Payload type " << static_cast<int>(*current_rtp_payload_type_)
759 << " is unknown where it shouldn't be";
760 }
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000761
turaj@webrtc.orga6101d72013-10-01 22:01:09 +0000762 if (update_sample_rate_and_channels && !packet_buffer_->Empty()) {
763 // We do not use |current_rtp_payload_type_| to |set payload_type|, but
764 // get the next RTP header from |packet_buffer_| to obtain the payload type.
765 // The reason for it is the following corner case. If NetEq receives a
766 // CNG packet with a sample rate different than the current CNG then it
767 // flushes its buffer, assuming send codec must have been changed. However,
768 // payload type of the hypothetically new send codec is not known.
ossu7a377612016-10-18 04:06:13 -0700769 const Packet* next_packet = packet_buffer_->PeekNextPacket();
770 RTC_DCHECK(next_packet);
771 const int payload_type = next_packet->payload_type;
ossu97ba30e2016-04-25 07:55:58 -0700772 size_t channels = 1;
773 if (!decoder_database_->IsComfortNoise(payload_type)) {
774 AudioDecoder* decoder = decoder_database_->GetDecoder(payload_type);
775 assert(decoder); // Payloads are already checked to be valid.
776 channels = decoder->Channels();
777 }
turaj@webrtc.orga6101d72013-10-01 22:01:09 +0000778 const DecoderDatabase::DecoderInfo* decoder_info =
779 decoder_database_->GetDecoderInfo(payload_type);
780 assert(decoder_info);
kwibergc0f2dcf2016-05-31 06:28:03 -0700781 if (decoder_info->SampleRateHz() != fs_hz_ ||
ossu97ba30e2016-04-25 07:55:58 -0700782 channels != algorithm_buffer_->Channels()) {
kwibergc0f2dcf2016-05-31 06:28:03 -0700783 SetSampleRateAndChannels(decoder_info->SampleRateHz(),
784 channels);
henrik.lundin48ed9302015-10-29 05:36:24 -0700785 }
786 if (nack_enabled_) {
787 RTC_DCHECK(nack_);
788 // Update the sample rate even if the rate is not new, because of Reset().
789 nack_->UpdateSampleRate(fs_hz_);
790 }
turaj@webrtc.orga6101d72013-10-01 22:01:09 +0000791 }
792
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000793 // TODO(hlundin): Move this code to DelayManager class.
794 const DecoderDatabase::DecoderInfo* dec_info =
ossu7a377612016-10-18 04:06:13 -0700795 decoder_database_->GetDecoderInfo(main_payload_type);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000796 assert(dec_info); // Already checked that the payload type is known.
ossuf1b08da2016-09-23 02:19:43 -0700797 delay_manager_->LastDecodedWasCngOrDtmf(dec_info->IsComfortNoise() ||
798 dec_info->IsDtmf());
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000799 if (delay_manager_->last_pack_cng_or_dtmf() == 0) {
800 // Calculate the total speech length carried in each packet.
Ivo Creusenfd7c0a52017-10-20 12:35:04 +0200801 if (number_of_primary_packets > 0) {
henrik.lundin116c84e2015-08-27 13:14:48 -0700802 const size_t packet_length_samples =
Ivo Creusenfd7c0a52017-10-20 12:35:04 +0200803 number_of_primary_packets * decoder_frame_length_;
henrik.lundin116c84e2015-08-27 13:14:48 -0700804 if (packet_length_samples != decision_logic_->packet_length_samples()) {
805 decision_logic_->set_packet_length_samples(packet_length_samples);
806 delay_manager_->SetPacketAudioLength(
kwibergd3edd772017-03-01 18:52:48 -0800807 rtc::dchecked_cast<int>((1000 * packet_length_samples) / fs_hz_));
henrik.lundin116c84e2015-08-27 13:14:48 -0700808 }
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000809 }
810
811 // Update statistics.
ossu7a377612016-10-18 04:06:13 -0700812 if ((int32_t)(main_timestamp - timestamp_) >= 0 && !new_codec_) {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000813 // Only update statistics if incoming packet is not older than last played
814 // out packet, and if new codec flag is not set.
ossu7a377612016-10-18 04:06:13 -0700815 delay_manager_->Update(main_sequence_number, main_timestamp, fs_hz_);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000816 }
817 } else if (delay_manager_->last_pack_cng_or_dtmf() == -1) {
818 // This is first "normal" packet after CNG or DTMF.
819 // Reset packet time counter and measure time until next packet,
820 // but don't update statistics.
821 delay_manager_->set_last_pack_cng_or_dtmf(0);
822 delay_manager_->ResetPacketIatCount();
823 }
824 return 0;
825}
826
henrik.lundin7a926812016-05-12 13:51:28 -0700827int NetEqImpl::GetAudioInternal(AudioFrame* audio_frame, bool* muted) {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000828 PacketList packet_list;
829 DtmfEvent dtmf_event;
830 Operations operation;
831 bool play_dtmf;
henrik.lundin7a926812016-05-12 13:51:28 -0700832 *muted = false;
henrik.lundin114c1b32017-04-26 07:47:32 -0700833 last_decoded_timestamps_.clear();
henrik.lundined497212016-04-25 10:11:38 -0700834 tick_timer_->Increment();
henrik.lundin60f6ce22016-05-10 03:52:04 -0700835 stats_.IncreaseCounter(output_size_samples_, fs_hz_);
henrik.lundin7a926812016-05-12 13:51:28 -0700836
837 // Check for muted state.
838 if (enable_muted_state_ && expand_->Muted() && packet_buffer_->Empty()) {
839 RTC_DCHECK_EQ(last_mode_, kModeExpand);
henrik.lundina4491072017-07-06 05:23:53 -0700840 audio_frame->Reset();
841 RTC_DCHECK(audio_frame->muted()); // Reset() should mute the frame.
henrik.lundin7a926812016-05-12 13:51:28 -0700842 playout_timestamp_ += static_cast<uint32_t>(output_size_samples_);
843 audio_frame->sample_rate_hz_ = fs_hz_;
844 audio_frame->samples_per_channel_ = output_size_samples_;
845 audio_frame->timestamp_ =
846 first_packet_
847 ? 0
848 : timestamp_scaler_->ToExternal(playout_timestamp_) -
849 static_cast<uint32_t>(audio_frame->samples_per_channel_);
850 audio_frame->num_channels_ = sync_buffer_->Channels();
Gustaf Ullberg9a2e9062017-09-18 09:28:20 +0200851 stats_.ExpandedNoiseSamples(output_size_samples_, false);
henrik.lundin7a926812016-05-12 13:51:28 -0700852 *muted = true;
853 return 0;
854 }
855
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000856 int return_value = GetDecision(&operation, &packet_list, &dtmf_event,
857 &play_dtmf);
858 if (return_value != 0) {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000859 last_mode_ = kModeError;
860 return return_value;
861 }
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000862
863 AudioDecoder::SpeechType speech_type;
864 int length = 0;
865 int decode_return_value = Decode(&packet_list, &operation,
866 &length, &speech_type);
867
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000868 assert(vad_.get());
869 bool sid_frame_available =
870 (operation == kRfc3389Cng && !packet_list.empty());
Peter Kastingdce40cf2015-08-24 14:52:23 -0700871 vad_->Update(decoded_buffer_.get(), static_cast<size_t>(length), speech_type,
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000872 sid_frame_available, fs_hz_);
873
henrik.lundinb1fb72b2016-05-03 08:18:47 -0700874 if (sid_frame_available || speech_type == AudioDecoder::kComfortNoise) {
875 // Start a new stopwatch since we are decoding a new CNG packet.
876 generated_noise_stopwatch_ = tick_timer_->GetNewStopwatch();
877 }
878
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +0000879 algorithm_buffer_->Clear();
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000880 switch (operation) {
881 case kNormal: {
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +0000882 DoNormal(decoded_buffer_.get(), length, speech_type, play_dtmf);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000883 break;
884 }
885 case kMerge: {
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +0000886 DoMerge(decoded_buffer_.get(), length, speech_type, play_dtmf);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000887 break;
888 }
889 case kExpand: {
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +0000890 return_value = DoExpand(play_dtmf);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000891 break;
892 }
Henrik Lundincf808d22015-05-27 14:33:29 +0200893 case kAccelerate:
894 case kFastAccelerate: {
895 const bool fast_accelerate =
896 enable_fast_accelerate_ && (operation == kFastAccelerate);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000897 return_value = DoAccelerate(decoded_buffer_.get(), length, speech_type,
Henrik Lundincf808d22015-05-27 14:33:29 +0200898 play_dtmf, fast_accelerate);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000899 break;
900 }
901 case kPreemptiveExpand: {
902 return_value = DoPreemptiveExpand(decoded_buffer_.get(), length,
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +0000903 speech_type, play_dtmf);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000904 break;
905 }
906 case kRfc3389Cng:
907 case kRfc3389CngNoPacket: {
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +0000908 return_value = DoRfc3389Cng(&packet_list, play_dtmf);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000909 break;
910 }
911 case kCodecInternalCng: {
912 // This handles the case when there is no transmission and the decoder
913 // should produce internal comfort noise.
914 // TODO(hlundin): Write test for codec-internal CNG.
minyuel6d92bf52015-09-23 15:20:39 +0200915 DoCodecInternalCng(decoded_buffer_.get(), length);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000916 break;
917 }
918 case kDtmf: {
919 // TODO(hlundin): Write test for this.
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +0000920 return_value = DoDtmf(dtmf_event, &play_dtmf);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000921 break;
922 }
923 case kAlternativePlc: {
924 // TODO(hlundin): Write test for this.
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +0000925 DoAlternativePlc(false);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000926 break;
927 }
928 case kAlternativePlcIncreaseTimestamp: {
929 // TODO(hlundin): Write test for this.
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +0000930 DoAlternativePlc(true);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000931 break;
932 }
933 case kAudioRepetitionIncreaseTimestamp: {
934 // TODO(hlundin): Write test for this.
Peter Kastingb7e50542015-06-11 12:55:50 -0700935 sync_buffer_->IncreaseEndTimestamp(
936 static_cast<uint32_t>(output_size_samples_));
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000937 // Skipping break on purpose. Execution should move on into the
938 // next case.
kjellanderbdf30722017-09-08 11:00:21 -0700939 FALLTHROUGH();
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000940 }
941 case kAudioRepetition: {
942 // TODO(hlundin): Write test for this.
943 // Copy last |output_size_samples_| from |sync_buffer_| to
944 // |algorithm_buffer|.
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +0000945 algorithm_buffer_->PushBackFromIndex(
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000946 *sync_buffer_, sync_buffer_->Size() - output_size_samples_);
947 expand_->Reset();
948 break;
949 }
950 case kUndefined: {
Henrik Lundind67a2192015-08-03 12:54:37 +0200951 LOG(LS_ERROR) << "Invalid operation kUndefined.";
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000952 assert(false); // This should not happen.
953 last_mode_ = kModeError;
954 return kInvalidOperation;
955 }
956 } // End of switch.
minyue5bd33972016-05-02 04:46:11 -0700957 last_operation_ = operation;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000958 if (return_value < 0) {
959 return return_value;
960 }
961
962 if (last_mode_ != kModeRfc3389Cng) {
963 comfort_noise_->Reset();
964 }
965
966 // Copy from |algorithm_buffer| to |sync_buffer_|.
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +0000967 sync_buffer_->PushBack(*algorithm_buffer_);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000968
969 // Extract data from |sync_buffer_| to |output|.
turaj@webrtc.org362a55e2013-09-20 16:25:28 +0000970 size_t num_output_samples_per_channel = output_size_samples_;
971 size_t num_output_samples = output_size_samples_ * sync_buffer_->Channels();
henrik.lundin6d8e0112016-03-04 10:34:21 -0800972 if (num_output_samples > AudioFrame::kMaxDataSizeSamples) {
973 LOG(LS_WARNING) << "Output array is too short. "
974 << AudioFrame::kMaxDataSizeSamples << " < "
975 << output_size_samples_ << " * "
976 << sync_buffer_->Channels();
977 num_output_samples = AudioFrame::kMaxDataSizeSamples;
978 num_output_samples_per_channel =
979 AudioFrame::kMaxDataSizeSamples / sync_buffer_->Channels();
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000980 }
henrik.lundin6d8e0112016-03-04 10:34:21 -0800981 sync_buffer_->GetNextAudioInterleaved(num_output_samples_per_channel,
982 audio_frame);
983 audio_frame->sample_rate_hz_ = fs_hz_;
Henrik Lundin05f71fc2015-09-01 11:51:58 +0200984 if (sync_buffer_->FutureLength() < expand_->overlap_length()) {
985 // The sync buffer should always contain |overlap_length| samples, but now
986 // too many samples have been extracted. Reinstall the |overlap_length|
987 // lookahead by moving the index.
988 const size_t missing_lookahead_samples =
989 expand_->overlap_length() - sync_buffer_->FutureLength();
henrikg91d6ede2015-09-17 00:24:34 -0700990 RTC_DCHECK_GE(sync_buffer_->next_index(), missing_lookahead_samples);
Henrik Lundin05f71fc2015-09-01 11:51:58 +0200991 sync_buffer_->set_next_index(sync_buffer_->next_index() -
992 missing_lookahead_samples);
993 }
henrik.lundin6d8e0112016-03-04 10:34:21 -0800994 if (audio_frame->samples_per_channel_ != output_size_samples_) {
995 LOG(LS_ERROR) << "audio_frame->samples_per_channel_ ("
996 << audio_frame->samples_per_channel_
Henrik Lundind67a2192015-08-03 12:54:37 +0200997 << ") != output_size_samples_ (" << output_size_samples_
998 << ")";
minyue@webrtc.orgdb1cefc2013-08-13 01:39:21 +0000999 // TODO(minyue): treatment of under-run, filling zeros
yujo36b1a5f2017-06-12 12:45:32 -07001000 audio_frame->Mute();
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001001 return kSampleUnderrun;
1002 }
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001003
1004 // Should always have overlap samples left in the |sync_buffer_|.
henrikg91d6ede2015-09-17 00:24:34 -07001005 RTC_DCHECK_GE(sync_buffer_->FutureLength(), expand_->overlap_length());
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001006
yujo36b1a5f2017-06-12 12:45:32 -07001007 // TODO(yujo): For muted frames, this can be a copy rather than an addition.
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001008 if (play_dtmf) {
yujo36b1a5f2017-06-12 12:45:32 -07001009 return_value = DtmfOverdub(dtmf_event, sync_buffer_->Channels(),
1010 audio_frame->mutable_data());
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001011 }
1012
1013 // Update the background noise parameters if last operation wrote data
1014 // straight from the decoder to the |sync_buffer_|. That is, none of the
1015 // operations that modify the signal can be followed by a parameter update.
1016 if ((last_mode_ == kModeNormal) ||
1017 (last_mode_ == kModeAccelerateFail) ||
1018 (last_mode_ == kModePreemptiveExpandFail) ||
1019 (last_mode_ == kModeRfc3389Cng) ||
1020 (last_mode_ == kModeCodecInternalCng)) {
1021 background_noise_->Update(*sync_buffer_, *vad_.get());
1022 }
1023
1024 if (operation == kDtmf) {
1025 // DTMF data was written the end of |sync_buffer_|.
1026 // Update index to end of DTMF data in |sync_buffer_|.
1027 sync_buffer_->set_dtmf_index(sync_buffer_->Size());
1028 }
1029
henrik.lundin@webrtc.orged865b52014-03-06 10:28:07 +00001030 if (last_mode_ != kModeExpand) {
1031 // If last operation was not expand, calculate the |playout_timestamp_| from
1032 // the |sync_buffer_|. However, do not update the |playout_timestamp_| if it
1033 // would be moved "backwards".
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001034 uint32_t temp_timestamp = sync_buffer_->end_timestamp() -
turaj@webrtc.org362a55e2013-09-20 16:25:28 +00001035 static_cast<uint32_t>(sync_buffer_->FutureLength());
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001036 if (static_cast<int32_t>(temp_timestamp - playout_timestamp_) > 0) {
1037 playout_timestamp_ = temp_timestamp;
1038 }
1039 } else {
1040 // Use dead reckoning to estimate the |playout_timestamp_|.
Peter Kastingb7e50542015-06-11 12:55:50 -07001041 playout_timestamp_ += static_cast<uint32_t>(output_size_samples_);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001042 }
henrik.lundin15c51e32016-04-06 08:38:56 -07001043 // Set the timestamp in the audio frame to zero before the first packet has
1044 // been inserted. Otherwise, subtract the frame size in samples to get the
1045 // timestamp of the first sample in the frame (playout_timestamp_ is the
1046 // last + 1).
1047 audio_frame->timestamp_ =
1048 first_packet_
1049 ? 0
1050 : timestamp_scaler_->ToExternal(playout_timestamp_) -
1051 static_cast<uint32_t>(audio_frame->samples_per_channel_);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001052
henrik.lundinb1fb72b2016-05-03 08:18:47 -07001053 if (!(last_mode_ == kModeRfc3389Cng ||
1054 last_mode_ == kModeCodecInternalCng ||
1055 last_mode_ == kModeExpand)) {
1056 generated_noise_stopwatch_.reset();
1057 }
1058
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001059 if (decode_return_value) return decode_return_value;
1060 return return_value;
1061}
1062
1063int NetEqImpl::GetDecision(Operations* operation,
1064 PacketList* packet_list,
1065 DtmfEvent* dtmf_event,
1066 bool* play_dtmf) {
1067 // Initialize output variables.
1068 *play_dtmf = false;
1069 *operation = kUndefined;
1070
henrik.lundin@webrtc.org0d5da252013-09-18 21:12:38 +00001071 assert(sync_buffer_.get());
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001072 uint32_t end_timestamp = sync_buffer_->end_timestamp();
henrik.lundin@webrtc.org52b42cb2014-11-04 14:03:58 +00001073 if (!new_codec_) {
1074 const uint32_t five_seconds_samples = 5 * fs_hz_;
minyue-webrtcfae474c2017-07-05 11:17:40 +02001075 packet_buffer_->DiscardOldPackets(end_timestamp, five_seconds_samples,
1076 &stats_);
henrik.lundin@webrtc.org52b42cb2014-11-04 14:03:58 +00001077 }
ossu7a377612016-10-18 04:06:13 -07001078 const Packet* packet = packet_buffer_->PeekNextPacket();
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001079
henrik.lundinb1fb72b2016-05-03 08:18:47 -07001080 RTC_DCHECK(!generated_noise_stopwatch_ ||
1081 generated_noise_stopwatch_->ElapsedTicks() >= 1);
1082 uint64_t generated_noise_samples =
1083 generated_noise_stopwatch_
1084 ? (generated_noise_stopwatch_->ElapsedTicks() - 1) *
1085 output_size_samples_ +
1086 decision_logic_->noise_fast_forward()
1087 : 0;
1088
henrik.lundin@webrtc.orgca8cb952014-03-12 10:26:52 +00001089 if (decision_logic_->CngRfc3389On() || last_mode_ == kModeRfc3389Cng) {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001090 // Because of timestamp peculiarities, we have to "manually" disallow using
1091 // a CNG packet with the same timestamp as the one that was last played.
1092 // This can happen when using redundancy and will cause the timing to shift.
ossu7a377612016-10-18 04:06:13 -07001093 while (packet && decoder_database_->IsComfortNoise(packet->payload_type) &&
1094 (end_timestamp >= packet->timestamp ||
1095 end_timestamp + generated_noise_samples > packet->timestamp)) {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001096 // Don't use this packet, discard it.
minyue-webrtcfae474c2017-07-05 11:17:40 +02001097 if (packet_buffer_->DiscardNextPacket(&stats_) != PacketBuffer::kOK) {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001098 assert(false); // Must be ok by design.
1099 }
1100 // Check buffer again.
1101 if (!new_codec_) {
minyue-webrtcfae474c2017-07-05 11:17:40 +02001102 packet_buffer_->DiscardOldPackets(end_timestamp, 5 * fs_hz_, &stats_);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001103 }
ossu7a377612016-10-18 04:06:13 -07001104 packet = packet_buffer_->PeekNextPacket();
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001105 }
1106 }
1107
henrik.lundin@webrtc.org0d5da252013-09-18 21:12:38 +00001108 assert(expand_.get());
turaj@webrtc.org362a55e2013-09-20 16:25:28 +00001109 const int samples_left = static_cast<int>(sync_buffer_->FutureLength() -
1110 expand_->overlap_length());
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001111 if (last_mode_ == kModeAccelerateSuccess ||
1112 last_mode_ == kModeAccelerateLowEnergy ||
1113 last_mode_ == kModePreemptiveExpandSuccess ||
1114 last_mode_ == kModePreemptiveExpandLowEnergy) {
1115 // Subtract (samples_left + output_size_samples_) from sampleMemory.
Peter Kastingdce40cf2015-08-24 14:52:23 -07001116 decision_logic_->AddSampleMemory(
kwibergd3edd772017-03-01 18:52:48 -08001117 -(samples_left + rtc::dchecked_cast<int>(output_size_samples_)));
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001118 }
1119
1120 // Check if it is time to play a DTMF event.
Peter Kastingb7e50542015-06-11 12:55:50 -07001121 if (dtmf_buffer_->GetEvent(
1122 static_cast<uint32_t>(
henrik.lundinb1fb72b2016-05-03 08:18:47 -07001123 end_timestamp + generated_noise_samples),
Peter Kastingb7e50542015-06-11 12:55:50 -07001124 dtmf_event)) {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001125 *play_dtmf = true;
1126 }
1127
1128 // Get instruction.
henrik.lundin@webrtc.org0d5da252013-09-18 21:12:38 +00001129 assert(sync_buffer_.get());
1130 assert(expand_.get());
henrik.lundinb1fb72b2016-05-03 08:18:47 -07001131 generated_noise_samples =
1132 generated_noise_stopwatch_
1133 ? generated_noise_stopwatch_->ElapsedTicks() * output_size_samples_ +
1134 decision_logic_->noise_fast_forward()
1135 : 0;
1136 *operation = decision_logic_->GetDecision(
ossu7a377612016-10-18 04:06:13 -07001137 *sync_buffer_, *expand_, decoder_frame_length_, packet, last_mode_,
henrik.lundinb1fb72b2016-05-03 08:18:47 -07001138 *play_dtmf, generated_noise_samples, &reset_decoder_);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001139
1140 // Check if we already have enough samples in the |sync_buffer_|. If so,
1141 // change decision to normal, unless the decision was merge, accelerate, or
1142 // preemptive expand.
kwibergd3edd772017-03-01 18:52:48 -08001143 if (samples_left >= rtc::dchecked_cast<int>(output_size_samples_) &&
1144 *operation != kMerge && *operation != kAccelerate &&
1145 *operation != kFastAccelerate && *operation != kPreemptiveExpand) {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001146 *operation = kNormal;
1147 return 0;
1148 }
1149
turaj@webrtc.org8d1cdaa2014-04-11 18:47:55 +00001150 decision_logic_->ExpandDecision(*operation);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001151
1152 // Check conditions for reset.
1153 if (new_codec_ || *operation == kUndefined) {
1154 // The only valid reason to get kUndefined is that new_codec_ is set.
1155 assert(new_codec_);
ossu7a377612016-10-18 04:06:13 -07001156 if (*play_dtmf && !packet) {
turaj@webrtc.org4d06db52013-03-27 18:31:42 +00001157 timestamp_ = dtmf_event->timestamp;
1158 } else {
ossu7a377612016-10-18 04:06:13 -07001159 if (!packet) {
Henrik Lundind67a2192015-08-03 12:54:37 +02001160 LOG(LS_ERROR) << "Packet missing where it shouldn't.";
turaj@webrtc.org4d06db52013-03-27 18:31:42 +00001161 return -1;
1162 }
ossu7a377612016-10-18 04:06:13 -07001163 timestamp_ = packet->timestamp;
ossu108ecec2016-07-08 08:45:18 -07001164 if (*operation == kRfc3389CngNoPacket &&
ossu7a377612016-10-18 04:06:13 -07001165 decoder_database_->IsComfortNoise(packet->payload_type)) {
turaj@webrtc.org4d06db52013-03-27 18:31:42 +00001166 // Change decision to CNG packet, since we do have a CNG packet, but it
1167 // was considered too early to use. Now, use it anyway.
1168 *operation = kRfc3389Cng;
1169 } else if (*operation != kRfc3389Cng) {
1170 *operation = kNormal;
1171 }
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001172 }
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001173 // Adjust |sync_buffer_| timestamp before setting |end_timestamp| to the
1174 // new value.
1175 sync_buffer_->IncreaseEndTimestamp(timestamp_ - end_timestamp);
turaj@webrtc.org4d06db52013-03-27 18:31:42 +00001176 end_timestamp = timestamp_;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001177 new_codec_ = false;
1178 decision_logic_->SoftReset();
1179 buffer_level_filter_->Reset();
1180 delay_manager_->Reset();
1181 stats_.ResetMcu();
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001182 }
1183
Peter Kastingdce40cf2015-08-24 14:52:23 -07001184 size_t required_samples = output_size_samples_;
1185 const size_t samples_10_ms = static_cast<size_t>(80 * fs_mult_);
1186 const size_t samples_20_ms = 2 * samples_10_ms;
1187 const size_t samples_30_ms = 3 * samples_10_ms;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001188
1189 switch (*operation) {
1190 case kExpand: {
1191 timestamp_ = end_timestamp;
1192 return 0;
1193 }
1194 case kRfc3389CngNoPacket:
1195 case kCodecInternalCng: {
1196 return 0;
1197 }
1198 case kDtmf: {
1199 // TODO(hlundin): Write test for this.
1200 // Update timestamp.
1201 timestamp_ = end_timestamp;
henrik.lundinb1fb72b2016-05-03 08:18:47 -07001202 const uint64_t generated_noise_samples =
1203 generated_noise_stopwatch_
1204 ? generated_noise_stopwatch_->ElapsedTicks() *
1205 output_size_samples_ +
1206 decision_logic_->noise_fast_forward()
1207 : 0;
1208 if (generated_noise_samples > 0 && last_mode_ != kModeDtmf) {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001209 // Make a jump in timestamp due to the recently played comfort noise.
Peter Kastingb7e50542015-06-11 12:55:50 -07001210 uint32_t timestamp_jump =
henrik.lundinb1fb72b2016-05-03 08:18:47 -07001211 static_cast<uint32_t>(generated_noise_samples);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001212 sync_buffer_->IncreaseEndTimestamp(timestamp_jump);
1213 timestamp_ += timestamp_jump;
1214 }
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001215 return 0;
1216 }
Henrik Lundincf808d22015-05-27 14:33:29 +02001217 case kAccelerate:
1218 case kFastAccelerate: {
1219 // In order to do an accelerate we need at least 30 ms of audio data.
Peter Kastingdce40cf2015-08-24 14:52:23 -07001220 if (samples_left >= static_cast<int>(samples_30_ms)) {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001221 // Already have enough data, so we do not need to extract any more.
1222 decision_logic_->set_sample_memory(samples_left);
1223 decision_logic_->set_prev_time_scale(true);
1224 return 0;
Peter Kastingdce40cf2015-08-24 14:52:23 -07001225 } else if (samples_left >= static_cast<int>(samples_10_ms) &&
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001226 decoder_frame_length_ >= samples_30_ms) {
1227 // Avoid decoding more data as it might overflow the playout buffer.
1228 *operation = kNormal;
1229 return 0;
Peter Kastingdce40cf2015-08-24 14:52:23 -07001230 } else if (samples_left < static_cast<int>(samples_20_ms) &&
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001231 decoder_frame_length_ < samples_30_ms) {
1232 // Build up decoded data by decoding at least 20 ms of audio data. Do
1233 // not perform accelerate yet, but wait until we only need to do one
1234 // decoding.
1235 required_samples = 2 * output_size_samples_;
1236 *operation = kNormal;
1237 }
1238 // If none of the above is true, we have one of two possible situations:
1239 // (1) 20 ms <= samples_left < 30 ms and decoder_frame_length_ < 30 ms; or
1240 // (2) samples_left < 10 ms and decoder_frame_length_ >= 30 ms.
1241 // In either case, we move on with the accelerate decision, and decode one
1242 // frame now.
1243 break;
1244 }
1245 case kPreemptiveExpand: {
1246 // In order to do a preemptive expand we need at least 30 ms of decoded
1247 // audio data.
Peter Kastingdce40cf2015-08-24 14:52:23 -07001248 if ((samples_left >= static_cast<int>(samples_30_ms)) ||
1249 (samples_left >= static_cast<int>(samples_10_ms) &&
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001250 decoder_frame_length_ >= samples_30_ms)) {
1251 // Already have enough data, so we do not need to extract any more.
1252 // Or, avoid decoding more data as it might overflow the playout buffer.
1253 // Still try preemptive expand, though.
1254 decision_logic_->set_sample_memory(samples_left);
1255 decision_logic_->set_prev_time_scale(true);
1256 return 0;
1257 }
Peter Kastingdce40cf2015-08-24 14:52:23 -07001258 if (samples_left < static_cast<int>(samples_20_ms) &&
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001259 decoder_frame_length_ < samples_30_ms) {
1260 // Build up decoded data by decoding at least 20 ms of audio data.
1261 // Still try to perform preemptive expand.
1262 required_samples = 2 * output_size_samples_;
1263 }
1264 // Move on with the preemptive expand decision.
1265 break;
1266 }
turaj@webrtc.org8d1cdaa2014-04-11 18:47:55 +00001267 case kMerge: {
1268 required_samples =
1269 std::max(merge_->RequiredFutureSamples(), required_samples);
1270 break;
1271 }
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001272 default: {
1273 // Do nothing.
1274 }
1275 }
1276
1277 // Get packets from buffer.
1278 int extracted_samples = 0;
ossu7a377612016-10-18 04:06:13 -07001279 if (packet && *operation != kAlternativePlc &&
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001280 *operation != kAlternativePlcIncreaseTimestamp &&
1281 *operation != kAudioRepetition &&
1282 *operation != kAudioRepetitionIncreaseTimestamp) {
ossu7a377612016-10-18 04:06:13 -07001283 sync_buffer_->IncreaseEndTimestamp(packet->timestamp - end_timestamp);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001284 if (decision_logic_->CngOff()) {
1285 // Adjustment of timestamp only corresponds to an actual packet loss
1286 // if comfort noise is not played. If comfort noise was just played,
1287 // this adjustment of timestamp is only done to get back in sync with the
1288 // stream timestamp; no loss to report.
ossu7a377612016-10-18 04:06:13 -07001289 stats_.LostSamples(packet->timestamp - end_timestamp);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001290 }
1291
1292 if (*operation != kRfc3389Cng) {
1293 // We are about to decode and use a non-CNG packet.
1294 decision_logic_->SetCngOff();
1295 }
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001296
1297 extracted_samples = ExtractPackets(required_samples, packet_list);
1298 if (extracted_samples < 0) {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001299 return kPacketBufferCorruption;
1300 }
1301 }
1302
Henrik Lundincf808d22015-05-27 14:33:29 +02001303 if (*operation == kAccelerate || *operation == kFastAccelerate ||
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001304 *operation == kPreemptiveExpand) {
1305 decision_logic_->set_sample_memory(samples_left + extracted_samples);
1306 decision_logic_->set_prev_time_scale(true);
1307 }
1308
Henrik Lundincf808d22015-05-27 14:33:29 +02001309 if (*operation == kAccelerate || *operation == kFastAccelerate) {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001310 // Check that we have enough data (30ms) to do accelerate.
Peter Kastingdce40cf2015-08-24 14:52:23 -07001311 if (extracted_samples + samples_left < static_cast<int>(samples_30_ms)) {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001312 // TODO(hlundin): Write test for this.
1313 // Not enough, do normal operation instead.
1314 *operation = kNormal;
1315 }
1316 }
1317
1318 timestamp_ = end_timestamp;
1319 return 0;
1320}
1321
1322int NetEqImpl::Decode(PacketList* packet_list, Operations* operation,
1323 int* decoded_length,
1324 AudioDecoder::SpeechType* speech_type) {
1325 *speech_type = AudioDecoder::kSpeech;
minyuel6d92bf52015-09-23 15:20:39 +02001326
1327 // When packet_list is empty, we may be in kCodecInternalCng mode, and for
1328 // that we use current active decoder.
1329 AudioDecoder* decoder = decoder_database_->GetActiveDecoder();
1330
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001331 if (!packet_list->empty()) {
ossua73f6c92016-10-24 08:25:28 -07001332 const Packet& packet = packet_list->front();
1333 uint8_t payload_type = packet.payload_type;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001334 if (!decoder_database_->IsComfortNoise(payload_type)) {
1335 decoder = decoder_database_->GetDecoder(payload_type);
1336 assert(decoder);
1337 if (!decoder) {
Henrik Lundind67a2192015-08-03 12:54:37 +02001338 LOG(LS_WARNING) << "Unknown payload type "
1339 << static_cast<int>(payload_type);
ossua73f6c92016-10-24 08:25:28 -07001340 packet_list->clear();
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001341 return kDecoderNotFound;
1342 }
1343 bool decoder_changed;
1344 decoder_database_->SetActiveDecoder(payload_type, &decoder_changed);
1345 if (decoder_changed) {
1346 // We have a new decoder. Re-init some values.
1347 const DecoderDatabase::DecoderInfo* decoder_info = decoder_database_
1348 ->GetDecoderInfo(payload_type);
1349 assert(decoder_info);
1350 if (!decoder_info) {
Henrik Lundind67a2192015-08-03 12:54:37 +02001351 LOG(LS_WARNING) << "Unknown payload type "
1352 << static_cast<int>(payload_type);
ossua73f6c92016-10-24 08:25:28 -07001353 packet_list->clear();
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001354 return kDecoderNotFound;
1355 }
tina.legrand@webrtc.orgba5a6c32014-03-23 09:58:48 +00001356 // If sampling rate or number of channels has changed, we need to make
1357 // a reset.
kwibergc0f2dcf2016-05-31 06:28:03 -07001358 if (decoder_info->SampleRateHz() != fs_hz_ ||
henrik.lundin@webrtc.org6dba1eb2015-03-18 09:47:08 +00001359 decoder->Channels() != algorithm_buffer_->Channels()) {
tina.legrand@webrtc.orgba5a6c32014-03-23 09:58:48 +00001360 // TODO(tlegrand): Add unittest to cover this event.
kwibergc0f2dcf2016-05-31 06:28:03 -07001361 SetSampleRateAndChannels(decoder_info->SampleRateHz(),
1362 decoder->Channels());
turaj@webrtc.orga6101d72013-10-01 22:01:09 +00001363 }
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001364 sync_buffer_->set_end_timestamp(timestamp_);
1365 playout_timestamp_ = timestamp_;
1366 }
1367 }
1368 }
1369
1370 if (reset_decoder_) {
1371 // TODO(hlundin): Write test for this.
Karl Wiberg43766482015-08-27 15:22:11 +02001372 if (decoder)
1373 decoder->Reset();
1374
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001375 // Reset comfort noise decoder.
ossu97ba30e2016-04-25 07:55:58 -07001376 ComfortNoiseDecoder* cng_decoder = decoder_database_->GetActiveCngDecoder();
Karl Wiberg43766482015-08-27 15:22:11 +02001377 if (cng_decoder)
1378 cng_decoder->Reset();
1379
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001380 reset_decoder_ = false;
1381 }
1382
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001383 *decoded_length = 0;
1384 // Update codec-internal PLC state.
1385 if ((*operation == kMerge) && decoder && decoder->HasDecodePlc()) {
1386 decoder->DecodePlc(1, &decoded_buffer_[*decoded_length]);
1387 }
1388
minyuel6d92bf52015-09-23 15:20:39 +02001389 int return_value;
1390 if (*operation == kCodecInternalCng) {
1391 RTC_DCHECK(packet_list->empty());
1392 return_value = DecodeCng(decoder, decoded_length, speech_type);
1393 } else {
1394 return_value = DecodeLoop(packet_list, *operation, decoder,
1395 decoded_length, speech_type);
1396 }
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001397
1398 if (*decoded_length < 0) {
1399 // Error returned from the decoder.
1400 *decoded_length = 0;
Peter Kastingb7e50542015-06-11 12:55:50 -07001401 sync_buffer_->IncreaseEndTimestamp(
1402 static_cast<uint32_t>(decoder_frame_length_));
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001403 int error_code = 0;
1404 if (decoder)
1405 error_code = decoder->ErrorCode();
1406 if (error_code != 0) {
1407 // Got some error code from the decoder.
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001408 return_value = kDecoderErrorCode;
Henrik Lundind67a2192015-08-03 12:54:37 +02001409 LOG(LS_WARNING) << "Decoder returned error code: " << error_code;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001410 } else {
1411 // Decoder does not implement error codes. Return generic error.
1412 return_value = kOtherDecoderError;
Henrik Lundind67a2192015-08-03 12:54:37 +02001413 LOG(LS_WARNING) << "Decoder error (no error code)";
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001414 }
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001415 *operation = kExpand; // Do expansion to get data instead.
1416 }
1417 if (*speech_type != AudioDecoder::kComfortNoise) {
1418 // Don't increment timestamp if codec returned CNG speech type
1419 // since in this case, the we will increment the CNGplayedTS counter.
1420 // Increase with number of samples per channel.
1421 assert(*decoded_length == 0 ||
henrik.lundin@webrtc.org6dba1eb2015-03-18 09:47:08 +00001422 (decoder && decoder->Channels() == sync_buffer_->Channels()));
turaj@webrtc.org362a55e2013-09-20 16:25:28 +00001423 sync_buffer_->IncreaseEndTimestamp(
1424 *decoded_length / static_cast<int>(sync_buffer_->Channels()));
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001425 }
1426 return return_value;
1427}
1428
minyuel6d92bf52015-09-23 15:20:39 +02001429int NetEqImpl::DecodeCng(AudioDecoder* decoder, int* decoded_length,
1430 AudioDecoder::SpeechType* speech_type) {
1431 if (!decoder) {
1432 // This happens when active decoder is not defined.
1433 *decoded_length = -1;
1434 return 0;
1435 }
1436
kwibergd3edd772017-03-01 18:52:48 -08001437 while (*decoded_length < rtc::dchecked_cast<int>(output_size_samples_)) {
minyuel6d92bf52015-09-23 15:20:39 +02001438 const int length = decoder->Decode(
1439 nullptr, 0, fs_hz_,
1440 (decoded_buffer_length_ - *decoded_length) * sizeof(int16_t),
1441 &decoded_buffer_[*decoded_length], speech_type);
1442 if (length > 0) {
1443 *decoded_length += length;
minyuel6d92bf52015-09-23 15:20:39 +02001444 } else {
1445 // Error.
1446 LOG(LS_WARNING) << "Failed to decode CNG";
1447 *decoded_length = -1;
1448 break;
1449 }
1450 if (*decoded_length > static_cast<int>(decoded_buffer_length_)) {
1451 // Guard against overflow.
1452 LOG(LS_WARNING) << "Decoded too much CNG.";
1453 return kDecodedTooMuch;
1454 }
1455 }
1456 return 0;
1457}
1458
1459int NetEqImpl::DecodeLoop(PacketList* packet_list, const Operations& operation,
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001460 AudioDecoder* decoder, int* decoded_length,
1461 AudioDecoder::SpeechType* speech_type) {
henrik.lundin114c1b32017-04-26 07:47:32 -07001462 RTC_DCHECK(last_decoded_timestamps_.empty());
1463
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001464 // Do decoding.
ossua73f6c92016-10-24 08:25:28 -07001465 while (
1466 !packet_list->empty() &&
1467 !decoder_database_->IsComfortNoise(packet_list->front().payload_type)) {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001468 assert(decoder); // At this point, we must have a decoder object.
1469 // The number of channels in the |sync_buffer_| should be the same as the
1470 // number decoder channels.
henrik.lundin@webrtc.org6dba1eb2015-03-18 09:47:08 +00001471 assert(sync_buffer_->Channels() == decoder->Channels());
1472 assert(decoded_buffer_length_ >= kMaxFrameSize * decoder->Channels());
minyuel6d92bf52015-09-23 15:20:39 +02001473 assert(operation == kNormal || operation == kAccelerate ||
1474 operation == kFastAccelerate || operation == kMerge ||
1475 operation == kPreemptiveExpand);
ossua73f6c92016-10-24 08:25:28 -07001476
1477 auto opt_result = packet_list->front().frame->Decode(
ossu61a208b2016-09-20 01:38:00 -07001478 rtc::ArrayView<int16_t>(&decoded_buffer_[*decoded_length],
1479 decoded_buffer_length_ - *decoded_length));
henrik.lundin114c1b32017-04-26 07:47:32 -07001480 last_decoded_timestamps_.push_back(packet_list->front().timestamp);
ossua73f6c92016-10-24 08:25:28 -07001481 packet_list->pop_front();
ossu61a208b2016-09-20 01:38:00 -07001482 if (opt_result) {
1483 const auto& result = *opt_result;
1484 *speech_type = result.speech_type;
1485 if (result.num_decoded_samples > 0) {
kwibergd3edd772017-03-01 18:52:48 -08001486 *decoded_length += rtc::dchecked_cast<int>(result.num_decoded_samples);
ossu61a208b2016-09-20 01:38:00 -07001487 // Update |decoder_frame_length_| with number of samples per channel.
1488 decoder_frame_length_ =
1489 result.num_decoded_samples / decoder->Channels();
1490 }
1491 } else {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001492 // Error.
ossu61a208b2016-09-20 01:38:00 -07001493 // TODO(ossu): What to put here?
1494 LOG(LS_WARNING) << "Decode error";
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001495 *decoded_length = -1;
ossua73f6c92016-10-24 08:25:28 -07001496 packet_list->clear();
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001497 break;
1498 }
kwibergd3edd772017-03-01 18:52:48 -08001499 if (*decoded_length > rtc::dchecked_cast<int>(decoded_buffer_length_)) {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001500 // Guard against overflow.
Henrik Lundind67a2192015-08-03 12:54:37 +02001501 LOG(LS_WARNING) << "Decoded too much.";
ossua73f6c92016-10-24 08:25:28 -07001502 packet_list->clear();
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001503 return kDecodedTooMuch;
1504 }
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001505 } // End of decode loop.
1506
turaj@webrtc.org58cd3162013-10-31 15:15:55 +00001507 // If the list is not empty at this point, either a decoding error terminated
1508 // the while-loop, or list must hold exactly one CNG packet.
ossua73f6c92016-10-24 08:25:28 -07001509 assert(
1510 packet_list->empty() || *decoded_length < 0 ||
1511 (packet_list->size() == 1 &&
1512 decoder_database_->IsComfortNoise(packet_list->front().payload_type)));
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001513 return 0;
1514}
1515
1516void NetEqImpl::DoNormal(const int16_t* decoded_buffer, size_t decoded_length,
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +00001517 AudioDecoder::SpeechType speech_type, bool play_dtmf) {
henrik.lundin@webrtc.org40d3fc62013-09-18 12:19:50 +00001518 assert(normal_.get());
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001519 assert(mute_factor_array_.get());
henrik.lundin@webrtc.org40d3fc62013-09-18 12:19:50 +00001520 normal_->Process(decoded_buffer, decoded_length, last_mode_,
henrik.lundin@webrtc.org0d5da252013-09-18 21:12:38 +00001521 mute_factor_array_.get(), algorithm_buffer_.get());
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001522 if (decoded_length != 0) {
1523 last_mode_ = kModeNormal;
1524 }
1525
1526 // If last packet was decoded as an inband CNG, set mode to CNG instead.
1527 if ((speech_type == AudioDecoder::kComfortNoise)
1528 || ((last_mode_ == kModeCodecInternalCng)
1529 && (decoded_length == 0))) {
1530 // TODO(hlundin): Remove second part of || statement above.
1531 last_mode_ = kModeCodecInternalCng;
1532 }
1533
1534 if (!play_dtmf) {
1535 dtmf_tone_generator_->Reset();
1536 }
1537}
1538
1539void NetEqImpl::DoMerge(int16_t* decoded_buffer, size_t decoded_length,
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +00001540 AudioDecoder::SpeechType speech_type, bool play_dtmf) {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001541 assert(mute_factor_array_.get());
henrik.lundin@webrtc.org40d3fc62013-09-18 12:19:50 +00001542 assert(merge_.get());
Peter Kastingdce40cf2015-08-24 14:52:23 -07001543 size_t new_length = merge_->Process(decoded_buffer, decoded_length,
1544 mute_factor_array_.get(),
1545 algorithm_buffer_.get());
henrik.lundin2979f552017-05-05 05:04:16 -07001546 // Correction can be negative.
1547 int expand_length_correction =
1548 rtc::dchecked_cast<int>(new_length) -
1549 rtc::dchecked_cast<int>(decoded_length / algorithm_buffer_->Channels());
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001550
1551 // Update in-call and post-call statistics.
1552 if (expand_->MuteFactor(0) == 0) {
1553 // Expand generates only noise.
henrik.lundin2979f552017-05-05 05:04:16 -07001554 stats_.ExpandedNoiseSamplesCorrection(expand_length_correction);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001555 } else {
1556 // Expansion generates more than only noise.
henrik.lundin2979f552017-05-05 05:04:16 -07001557 stats_.ExpandedVoiceSamplesCorrection(expand_length_correction);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001558 }
1559
1560 last_mode_ = kModeMerge;
1561 // If last packet was decoded as an inband CNG, set mode to CNG instead.
1562 if (speech_type == AudioDecoder::kComfortNoise) {
1563 last_mode_ = kModeCodecInternalCng;
1564 }
1565 expand_->Reset();
1566 if (!play_dtmf) {
1567 dtmf_tone_generator_->Reset();
1568 }
1569}
1570
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +00001571int NetEqImpl::DoExpand(bool play_dtmf) {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001572 while ((sync_buffer_->FutureLength() - expand_->overlap_length()) <
Peter Kastingdce40cf2015-08-24 14:52:23 -07001573 output_size_samples_) {
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +00001574 algorithm_buffer_->Clear();
henrik.lundin@webrtc.org0d5da252013-09-18 21:12:38 +00001575 int return_value = expand_->Process(algorithm_buffer_.get());
Peter Kastingdce40cf2015-08-24 14:52:23 -07001576 size_t length = algorithm_buffer_->Size();
Gustaf Ullberg9a2e9062017-09-18 09:28:20 +02001577 bool is_new_concealment_event = (last_mode_ != kModeExpand);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001578
1579 // Update in-call and post-call statistics.
1580 if (expand_->MuteFactor(0) == 0) {
1581 // Expand operation generates only noise.
Gustaf Ullberg9a2e9062017-09-18 09:28:20 +02001582 stats_.ExpandedNoiseSamples(length, is_new_concealment_event);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001583 } else {
1584 // Expand operation generates more than only noise.
Gustaf Ullberg9a2e9062017-09-18 09:28:20 +02001585 stats_.ExpandedVoiceSamples(length, is_new_concealment_event);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001586 }
1587
1588 last_mode_ = kModeExpand;
1589
1590 if (return_value < 0) {
1591 return return_value;
1592 }
1593
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +00001594 sync_buffer_->PushBack(*algorithm_buffer_);
1595 algorithm_buffer_->Clear();
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001596 }
1597 if (!play_dtmf) {
1598 dtmf_tone_generator_->Reset();
1599 }
henrik.lundinb1fb72b2016-05-03 08:18:47 -07001600
1601 if (!generated_noise_stopwatch_) {
1602 // Start a new stopwatch since we may be covering for a lost CNG packet.
1603 generated_noise_stopwatch_ = tick_timer_->GetNewStopwatch();
1604 }
1605
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001606 return 0;
1607}
1608
Henrik Lundincf808d22015-05-27 14:33:29 +02001609int NetEqImpl::DoAccelerate(int16_t* decoded_buffer,
1610 size_t decoded_length,
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001611 AudioDecoder::SpeechType speech_type,
Henrik Lundincf808d22015-05-27 14:33:29 +02001612 bool play_dtmf,
1613 bool fast_accelerate) {
Peter Kastingdce40cf2015-08-24 14:52:23 -07001614 const size_t required_samples =
1615 static_cast<size_t>(240 * fs_mult_); // Must have 30 ms.
turaj@webrtc.org362a55e2013-09-20 16:25:28 +00001616 size_t borrowed_samples_per_channel = 0;
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +00001617 size_t num_channels = algorithm_buffer_->Channels();
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001618 size_t decoded_length_per_channel = decoded_length / num_channels;
1619 if (decoded_length_per_channel < required_samples) {
1620 // Must move data from the |sync_buffer_| in order to get 30 ms.
turaj@webrtc.org362a55e2013-09-20 16:25:28 +00001621 borrowed_samples_per_channel = static_cast<int>(required_samples -
1622 decoded_length_per_channel);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001623 memmove(&decoded_buffer[borrowed_samples_per_channel * num_channels],
1624 decoded_buffer,
1625 sizeof(int16_t) * decoded_length);
1626 sync_buffer_->ReadInterleavedFromEnd(borrowed_samples_per_channel,
1627 decoded_buffer);
1628 decoded_length = required_samples * num_channels;
1629 }
1630
Peter Kastingdce40cf2015-08-24 14:52:23 -07001631 size_t samples_removed;
Henrik Lundincf808d22015-05-27 14:33:29 +02001632 Accelerate::ReturnCodes return_code =
1633 accelerate_->Process(decoded_buffer, decoded_length, fast_accelerate,
1634 algorithm_buffer_.get(), &samples_removed);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001635 stats_.AcceleratedSamples(samples_removed);
1636 switch (return_code) {
1637 case Accelerate::kSuccess:
1638 last_mode_ = kModeAccelerateSuccess;
1639 break;
1640 case Accelerate::kSuccessLowEnergy:
1641 last_mode_ = kModeAccelerateLowEnergy;
1642 break;
1643 case Accelerate::kNoStretch:
1644 last_mode_ = kModeAccelerateFail;
1645 break;
1646 case Accelerate::kError:
1647 // TODO(hlundin): Map to kModeError instead?
1648 last_mode_ = kModeAccelerateFail;
1649 return kAccelerateError;
1650 }
1651
1652 if (borrowed_samples_per_channel > 0) {
1653 // Copy borrowed samples back to the |sync_buffer_|.
turaj@webrtc.org362a55e2013-09-20 16:25:28 +00001654 size_t length = algorithm_buffer_->Size();
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001655 if (length < borrowed_samples_per_channel) {
1656 // This destroys the beginning of the buffer, but will not cause any
1657 // problems.
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +00001658 sync_buffer_->ReplaceAtIndex(*algorithm_buffer_,
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001659 sync_buffer_->Size() -
1660 borrowed_samples_per_channel);
1661 sync_buffer_->PushFrontZeros(borrowed_samples_per_channel - length);
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +00001662 algorithm_buffer_->PopFront(length);
1663 assert(algorithm_buffer_->Empty());
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001664 } else {
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +00001665 sync_buffer_->ReplaceAtIndex(*algorithm_buffer_,
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001666 borrowed_samples_per_channel,
1667 sync_buffer_->Size() -
1668 borrowed_samples_per_channel);
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +00001669 algorithm_buffer_->PopFront(borrowed_samples_per_channel);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001670 }
1671 }
1672
1673 // If last packet was decoded as an inband CNG, set mode to CNG instead.
1674 if (speech_type == AudioDecoder::kComfortNoise) {
1675 last_mode_ = kModeCodecInternalCng;
1676 }
1677 if (!play_dtmf) {
1678 dtmf_tone_generator_->Reset();
1679 }
1680 expand_->Reset();
1681 return 0;
1682}
1683
1684int NetEqImpl::DoPreemptiveExpand(int16_t* decoded_buffer,
1685 size_t decoded_length,
1686 AudioDecoder::SpeechType speech_type,
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +00001687 bool play_dtmf) {
Peter Kastingdce40cf2015-08-24 14:52:23 -07001688 const size_t required_samples =
1689 static_cast<size_t>(240 * fs_mult_); // Must have 30 ms.
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +00001690 size_t num_channels = algorithm_buffer_->Channels();
Peter Kastingdce40cf2015-08-24 14:52:23 -07001691 size_t borrowed_samples_per_channel = 0;
1692 size_t old_borrowed_samples_per_channel = 0;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001693 size_t decoded_length_per_channel = decoded_length / num_channels;
1694 if (decoded_length_per_channel < required_samples) {
1695 // Must move data from the |sync_buffer_| in order to get 30 ms.
Peter Kastingdce40cf2015-08-24 14:52:23 -07001696 borrowed_samples_per_channel =
1697 required_samples - decoded_length_per_channel;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001698 // Calculate how many of these were already played out.
Peter Kastingf045e4d2015-06-10 21:15:38 -07001699 old_borrowed_samples_per_channel =
Peter Kastingdce40cf2015-08-24 14:52:23 -07001700 (borrowed_samples_per_channel > sync_buffer_->FutureLength()) ?
1701 (borrowed_samples_per_channel - sync_buffer_->FutureLength()) : 0;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001702 memmove(&decoded_buffer[borrowed_samples_per_channel * num_channels],
1703 decoded_buffer,
1704 sizeof(int16_t) * decoded_length);
1705 sync_buffer_->ReadInterleavedFromEnd(borrowed_samples_per_channel,
1706 decoded_buffer);
1707 decoded_length = required_samples * num_channels;
1708 }
1709
Peter Kastingdce40cf2015-08-24 14:52:23 -07001710 size_t samples_added;
henrik.lundin@webrtc.org40d3fc62013-09-18 12:19:50 +00001711 PreemptiveExpand::ReturnCodes return_code = preemptive_expand_->Process(
Peter Kastingdce40cf2015-08-24 14:52:23 -07001712 decoded_buffer, decoded_length,
turaj@webrtc.org362a55e2013-09-20 16:25:28 +00001713 old_borrowed_samples_per_channel,
henrik.lundin@webrtc.org0d5da252013-09-18 21:12:38 +00001714 algorithm_buffer_.get(), &samples_added);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001715 stats_.PreemptiveExpandedSamples(samples_added);
1716 switch (return_code) {
1717 case PreemptiveExpand::kSuccess:
1718 last_mode_ = kModePreemptiveExpandSuccess;
1719 break;
1720 case PreemptiveExpand::kSuccessLowEnergy:
1721 last_mode_ = kModePreemptiveExpandLowEnergy;
1722 break;
1723 case PreemptiveExpand::kNoStretch:
1724 last_mode_ = kModePreemptiveExpandFail;
1725 break;
1726 case PreemptiveExpand::kError:
1727 // TODO(hlundin): Map to kModeError instead?
1728 last_mode_ = kModePreemptiveExpandFail;
1729 return kPreemptiveExpandError;
1730 }
1731
1732 if (borrowed_samples_per_channel > 0) {
1733 // Copy borrowed samples back to the |sync_buffer_|.
1734 sync_buffer_->ReplaceAtIndex(
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +00001735 *algorithm_buffer_, borrowed_samples_per_channel,
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001736 sync_buffer_->Size() - borrowed_samples_per_channel);
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +00001737 algorithm_buffer_->PopFront(borrowed_samples_per_channel);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001738 }
1739
1740 // If last packet was decoded as an inband CNG, set mode to CNG instead.
1741 if (speech_type == AudioDecoder::kComfortNoise) {
1742 last_mode_ = kModeCodecInternalCng;
1743 }
1744 if (!play_dtmf) {
1745 dtmf_tone_generator_->Reset();
1746 }
1747 expand_->Reset();
1748 return 0;
1749}
1750
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +00001751int NetEqImpl::DoRfc3389Cng(PacketList* packet_list, bool play_dtmf) {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001752 if (!packet_list->empty()) {
1753 // Must have exactly one SID frame at this point.
1754 assert(packet_list->size() == 1);
ossua73f6c92016-10-24 08:25:28 -07001755 const Packet& packet = packet_list->front();
1756 if (!decoder_database_->IsComfortNoise(packet.payload_type)) {
henrik.lundin@webrtc.org73deaad2013-01-31 13:32:51 +00001757 LOG(LS_ERROR) << "Trying to decode non-CNG payload as CNG.";
1758 return kOtherError;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001759 }
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001760 if (comfort_noise_->UpdateParameters(packet) ==
1761 ComfortNoise::kInternalError) {
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +00001762 algorithm_buffer_->Zeros(output_size_samples_);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001763 return -comfort_noise_->internal_error_code();
1764 }
1765 }
1766 int cn_return = comfort_noise_->Generate(output_size_samples_,
henrik.lundin@webrtc.org0d5da252013-09-18 21:12:38 +00001767 algorithm_buffer_.get());
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001768 expand_->Reset();
1769 last_mode_ = kModeRfc3389Cng;
1770 if (!play_dtmf) {
1771 dtmf_tone_generator_->Reset();
1772 }
1773 if (cn_return == ComfortNoise::kInternalError) {
Henrik Lundinc417d9e2017-06-14 12:29:03 +02001774 LOG(LS_WARNING) << "Comfort noise generator returned error code: "
1775 << comfort_noise_->internal_error_code();
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001776 return kComfortNoiseErrorCode;
1777 } else if (cn_return == ComfortNoise::kUnknownPayloadType) {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001778 return kUnknownRtpPayloadType;
1779 }
1780 return 0;
1781}
1782
minyuel6d92bf52015-09-23 15:20:39 +02001783void NetEqImpl::DoCodecInternalCng(const int16_t* decoded_buffer,
1784 size_t decoded_length) {
1785 RTC_DCHECK(normal_.get());
1786 RTC_DCHECK(mute_factor_array_.get());
1787 normal_->Process(decoded_buffer, decoded_length, last_mode_,
1788 mute_factor_array_.get(), algorithm_buffer_.get());
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001789 last_mode_ = kModeCodecInternalCng;
1790 expand_->Reset();
1791}
1792
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +00001793int NetEqImpl::DoDtmf(const DtmfEvent& dtmf_event, bool* play_dtmf) {
turaj@webrtc.org4d06db52013-03-27 18:31:42 +00001794 // This block of the code and the block further down, handling |dtmf_switch|
1795 // are commented out. Otherwise playing out-of-band DTMF would fail in VoE
1796 // test, DtmfTest.ManualSuccessfullySendsOutOfBandTelephoneEvents. This is
1797 // equivalent to |dtmf_switch| always be false.
1798 //
1799 // See http://webrtc-codereview.appspot.com/1195004/ for discussion
1800 // On this issue. This change might cause some glitches at the point of
1801 // switch from audio to DTMF. Issue 1545 is filed to track this.
1802 //
1803 // bool dtmf_switch = false;
1804 // if ((last_mode_ != kModeDtmf) && dtmf_tone_generator_->initialized()) {
1805 // // Special case; see below.
1806 // // We must catch this before calling Generate, since |initialized| is
1807 // // modified in that call.
1808 // dtmf_switch = true;
1809 // }
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001810
1811 int dtmf_return_value = 0;
1812 if (!dtmf_tone_generator_->initialized()) {
1813 // Initialize if not already done.
1814 dtmf_return_value = dtmf_tone_generator_->Init(fs_hz_, dtmf_event.event_no,
1815 dtmf_event.volume);
1816 }
turaj@webrtc.org4d06db52013-03-27 18:31:42 +00001817
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001818 if (dtmf_return_value == 0) {
1819 // Generate DTMF signal.
1820 dtmf_return_value = dtmf_tone_generator_->Generate(output_size_samples_,
henrik.lundin@webrtc.org0d5da252013-09-18 21:12:38 +00001821 algorithm_buffer_.get());
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001822 }
turaj@webrtc.org4d06db52013-03-27 18:31:42 +00001823
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001824 if (dtmf_return_value < 0) {
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +00001825 algorithm_buffer_->Zeros(output_size_samples_);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001826 return dtmf_return_value;
1827 }
1828
turaj@webrtc.org4d06db52013-03-27 18:31:42 +00001829 // if (dtmf_switch) {
1830 // // This is the special case where the previous operation was DTMF
1831 // // overdub, but the current instruction is "regular" DTMF. We must make
1832 // // sure that the DTMF does not have any discontinuities. The first DTMF
1833 // // sample that we generate now must be played out immediately, therefore
1834 // // it must be copied to the speech buffer.
1835 // // TODO(hlundin): This code seems incorrect. (Legacy.) Write test and
1836 // // verify correct operation.
1837 // assert(false);
1838 // // Must generate enough data to replace all of the |sync_buffer_|
1839 // // "future".
1840 // int required_length = sync_buffer_->FutureLength();
1841 // assert(dtmf_tone_generator_->initialized());
1842 // dtmf_return_value = dtmf_tone_generator_->Generate(required_length,
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +00001843 // algorithm_buffer_);
1844 // assert((size_t) required_length == algorithm_buffer_->Size());
turaj@webrtc.org4d06db52013-03-27 18:31:42 +00001845 // if (dtmf_return_value < 0) {
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +00001846 // algorithm_buffer_->Zeros(output_size_samples_);
turaj@webrtc.org4d06db52013-03-27 18:31:42 +00001847 // return dtmf_return_value;
1848 // }
1849 //
1850 // // Overwrite the "future" part of the speech buffer with the new DTMF
1851 // // data.
1852 // // TODO(hlundin): It seems that this overwriting has gone lost.
1853 // // Not adapted for multi-channel yet.
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +00001854 // assert(algorithm_buffer_->Channels() == 1);
1855 // if (algorithm_buffer_->Channels() != 1) {
turaj@webrtc.org4d06db52013-03-27 18:31:42 +00001856 // LOG(LS_WARNING) << "DTMF not supported for more than one channel";
1857 // return kStereoNotSupported;
1858 // }
1859 // // Shuffle the remaining data to the beginning of algorithm buffer.
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +00001860 // algorithm_buffer_->PopFront(sync_buffer_->FutureLength());
turaj@webrtc.org4d06db52013-03-27 18:31:42 +00001861 // }
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001862
Peter Kastingb7e50542015-06-11 12:55:50 -07001863 sync_buffer_->IncreaseEndTimestamp(
1864 static_cast<uint32_t>(output_size_samples_));
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001865 expand_->Reset();
1866 last_mode_ = kModeDtmf;
1867
1868 // Set to false because the DTMF is already in the algorithm buffer.
1869 *play_dtmf = false;
1870 return 0;
1871}
1872
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +00001873void NetEqImpl::DoAlternativePlc(bool increase_timestamp) {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001874 AudioDecoder* decoder = decoder_database_->GetActiveDecoder();
Peter Kastingdce40cf2015-08-24 14:52:23 -07001875 size_t length;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001876 if (decoder && decoder->HasDecodePlc()) {
1877 // Use the decoder's packet-loss concealment.
1878 // TODO(hlundin): Will probably need a longer buffer for multi-channel.
1879 int16_t decoded_buffer[kMaxFrameSize];
1880 length = decoder->DecodePlc(1, decoded_buffer);
Peter Kastingdce40cf2015-08-24 14:52:23 -07001881 if (length > 0)
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +00001882 algorithm_buffer_->PushBackInterleaved(decoded_buffer, length);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001883 } else {
1884 // Do simple zero-stuffing.
1885 length = output_size_samples_;
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +00001886 algorithm_buffer_->Zeros(length);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001887 // By not advancing the timestamp, NetEq inserts samples.
1888 stats_.AddZeros(length);
1889 }
1890 if (increase_timestamp) {
Peter Kastingb7e50542015-06-11 12:55:50 -07001891 sync_buffer_->IncreaseEndTimestamp(static_cast<uint32_t>(length));
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001892 }
1893 expand_->Reset();
1894}
1895
1896int NetEqImpl::DtmfOverdub(const DtmfEvent& dtmf_event, size_t num_channels,
1897 int16_t* output) const {
1898 size_t out_index = 0;
Peter Kastingdce40cf2015-08-24 14:52:23 -07001899 size_t overdub_length = output_size_samples_; // Default value.
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001900
1901 if (sync_buffer_->dtmf_index() > sync_buffer_->next_index()) {
1902 // Special operation for transition from "DTMF only" to "DTMF overdub".
1903 out_index = std::min(
1904 sync_buffer_->dtmf_index() - sync_buffer_->next_index(),
Peter Kastingdce40cf2015-08-24 14:52:23 -07001905 output_size_samples_);
1906 overdub_length = output_size_samples_ - out_index;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001907 }
1908
henrik.lundin@webrtc.orgfd11bbf2013-09-30 20:38:44 +00001909 AudioMultiVector dtmf_output(num_channels);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001910 int dtmf_return_value = 0;
1911 if (!dtmf_tone_generator_->initialized()) {
1912 dtmf_return_value = dtmf_tone_generator_->Init(fs_hz_, dtmf_event.event_no,
1913 dtmf_event.volume);
1914 }
1915 if (dtmf_return_value == 0) {
1916 dtmf_return_value = dtmf_tone_generator_->Generate(overdub_length,
1917 &dtmf_output);
Peter Kastingdce40cf2015-08-24 14:52:23 -07001918 assert(overdub_length == dtmf_output.Size());
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001919 }
1920 dtmf_output.ReadInterleaved(overdub_length, &output[out_index]);
1921 return dtmf_return_value < 0 ? dtmf_return_value : 0;
1922}
1923
Peter Kastingdce40cf2015-08-24 14:52:23 -07001924int NetEqImpl::ExtractPackets(size_t required_samples,
1925 PacketList* packet_list) {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001926 bool first_packet = true;
1927 uint8_t prev_payload_type = 0;
1928 uint32_t prev_timestamp = 0;
1929 uint16_t prev_sequence_number = 0;
1930 bool next_packet_available = false;
1931
ossu7a377612016-10-18 04:06:13 -07001932 const Packet* next_packet = packet_buffer_->PeekNextPacket();
1933 RTC_DCHECK(next_packet);
1934 if (!next_packet) {
Henrik Lundind67a2192015-08-03 12:54:37 +02001935 LOG(LS_ERROR) << "Packet buffer unexpectedly empty.";
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001936 return -1;
1937 }
ossu7a377612016-10-18 04:06:13 -07001938 uint32_t first_timestamp = next_packet->timestamp;
ossu61a208b2016-09-20 01:38:00 -07001939 size_t extracted_samples = 0;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001940
1941 // Packet extraction loop.
1942 do {
ossu7a377612016-10-18 04:06:13 -07001943 timestamp_ = next_packet->timestamp;
ossua73f6c92016-10-24 08:25:28 -07001944 rtc::Optional<Packet> packet = packet_buffer_->GetNextPacket();
ossu7a377612016-10-18 04:06:13 -07001945 // |next_packet| may be invalid after the |packet_buffer_| operation.
ossua73f6c92016-10-24 08:25:28 -07001946 next_packet = nullptr;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001947 if (!packet) {
Henrik Lundind67a2192015-08-03 12:54:37 +02001948 LOG(LS_ERROR) << "Should always be able to extract a packet here";
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001949 assert(false); // Should always be able to extract a packet here.
1950 return -1;
1951 }
Gustaf Ullbergb0a02072017-10-02 12:00:34 +02001952 const uint64_t waiting_time_ms = packet->waiting_time->ElapsedMs();
1953 stats_.StoreWaitingTime(waiting_time_ms);
ossu61a208b2016-09-20 01:38:00 -07001954 RTC_DCHECK(!packet->empty());
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001955
1956 if (first_packet) {
1957 first_packet = false;
henrik.lundin48ed9302015-10-29 05:36:24 -07001958 if (nack_enabled_) {
1959 RTC_DCHECK(nack_);
1960 // TODO(henrik.lundin): Should we update this for all decoded packets?
ossu7a377612016-10-18 04:06:13 -07001961 nack_->UpdateLastDecodedPacket(packet->sequence_number,
1962 packet->timestamp);
henrik.lundin48ed9302015-10-29 05:36:24 -07001963 }
ossu7a377612016-10-18 04:06:13 -07001964 prev_sequence_number = packet->sequence_number;
1965 prev_timestamp = packet->timestamp;
1966 prev_payload_type = packet->payload_type;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001967 }
1968
ossucafb4972017-01-02 07:00:50 -08001969 const bool has_cng_packet =
1970 decoder_database_->IsComfortNoise(packet->payload_type);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001971 // Store number of extracted samples.
ossu61a208b2016-09-20 01:38:00 -07001972 size_t packet_duration = 0;
1973 if (packet->frame) {
1974 packet_duration = packet->frame->Duration();
ossua70695a2016-09-22 02:06:28 -07001975 // TODO(ossu): Is this the correct way to track Opus FEC packets?
1976 if (packet->priority.codec_level > 0) {
kwibergd3edd772017-03-01 18:52:48 -08001977 stats_.SecondaryDecodedSamples(
1978 rtc::dchecked_cast<int>(packet_duration));
minyue@webrtc.orgb28bfa72014-03-21 12:07:40 +00001979 }
ossucafb4972017-01-02 07:00:50 -08001980 } else if (!has_cng_packet) {
Henrik Lundind67a2192015-08-03 12:54:37 +02001981 LOG(LS_WARNING) << "Unknown payload type "
ossu7a377612016-10-18 04:06:13 -07001982 << static_cast<int>(packet->payload_type);
ossu61a208b2016-09-20 01:38:00 -07001983 RTC_NOTREACHED();
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001984 }
ossu61a208b2016-09-20 01:38:00 -07001985
1986 if (packet_duration == 0) {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001987 // Decoder did not return a packet duration. Assume that the packet
1988 // contains the same number of samples as the previous one.
ossu61a208b2016-09-20 01:38:00 -07001989 packet_duration = decoder_frame_length_;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001990 }
ossu7a377612016-10-18 04:06:13 -07001991 extracted_samples = packet->timestamp - first_timestamp + packet_duration;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001992
Gustaf Ullbergb0a02072017-10-02 12:00:34 +02001993 stats_.JitterBufferDelay(extracted_samples, waiting_time_ms);
1994
ossua73f6c92016-10-24 08:25:28 -07001995 packet_list->push_back(std::move(*packet)); // Store packet in list.
1996 packet = rtc::Optional<Packet>(); // Ensure it's never used after the move.
1997
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001998 // Check what packet is available next.
ossu7a377612016-10-18 04:06:13 -07001999 next_packet = packet_buffer_->PeekNextPacket();
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00002000 next_packet_available = false;
ossucafb4972017-01-02 07:00:50 -08002001 if (next_packet && prev_payload_type == next_packet->payload_type &&
2002 !has_cng_packet) {
ossu7a377612016-10-18 04:06:13 -07002003 int16_t seq_no_diff = next_packet->sequence_number - prev_sequence_number;
2004 size_t ts_diff = next_packet->timestamp - prev_timestamp;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00002005 if (seq_no_diff == 1 ||
2006 (seq_no_diff == 0 && ts_diff == decoder_frame_length_)) {
2007 // The next sequence number is available, or the next part of a packet
2008 // that was split into pieces upon insertion.
2009 next_packet_available = true;
2010 }
ossu7a377612016-10-18 04:06:13 -07002011 prev_sequence_number = next_packet->sequence_number;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00002012 }
ossu61a208b2016-09-20 01:38:00 -07002013 } while (extracted_samples < required_samples && next_packet_available);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00002014
henrik.lundin@webrtc.org61217152014-09-22 08:30:07 +00002015 if (extracted_samples > 0) {
2016 // Delete old packets only when we are going to decode something. Otherwise,
2017 // we could end up in the situation where we never decode anything, since
2018 // all incoming packets are considered too old but the buffer will also
2019 // never be flooded and flushed.
minyue-webrtcfae474c2017-07-05 11:17:40 +02002020 packet_buffer_->DiscardAllOldPackets(timestamp_, &stats_);
henrik.lundin@webrtc.org61217152014-09-22 08:30:07 +00002021 }
2022
kwibergd3edd772017-03-01 18:52:48 -08002023 return rtc::dchecked_cast<int>(extracted_samples);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00002024}
2025
turaj@webrtc.org8d1cdaa2014-04-11 18:47:55 +00002026void NetEqImpl::UpdatePlcComponents(int fs_hz, size_t channels) {
2027 // Delete objects and create new ones.
2028 expand_.reset(expand_factory_->Create(background_noise_.get(),
2029 sync_buffer_.get(), &random_vector_,
Henrik Lundinbef77e22015-08-18 14:58:09 +02002030 &stats_, fs_hz, channels));
turaj@webrtc.org8d1cdaa2014-04-11 18:47:55 +00002031 merge_.reset(new Merge(fs_hz, channels, expand_.get(), sync_buffer_.get()));
2032}
2033
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00002034void NetEqImpl::SetSampleRateAndChannels(int fs_hz, size_t channels) {
Henrik Lundind67a2192015-08-03 12:54:37 +02002035 LOG(LS_VERBOSE) << "SetSampleRateAndChannels " << fs_hz << " " << channels;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00002036 // TODO(hlundin): Change to an enumerator and skip assert.
2037 assert(fs_hz == 8000 || fs_hz == 16000 || fs_hz == 32000 || fs_hz == 48000);
2038 assert(channels > 0);
2039
2040 fs_hz_ = fs_hz;
2041 fs_mult_ = fs_hz / 8000;
Peter Kastingdce40cf2015-08-24 14:52:23 -07002042 output_size_samples_ = static_cast<size_t>(kOutputSizeMs * 8 * fs_mult_);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00002043 decoder_frame_length_ = 3 * output_size_samples_; // Initialize to 30ms.
2044
2045 last_mode_ = kModeNormal;
2046
2047 // Create a new array of mute factors and set all to 1.
2048 mute_factor_array_.reset(new int16_t[channels]);
2049 for (size_t i = 0; i < channels; ++i) {
2050 mute_factor_array_[i] = 16384; // 1.0 in Q14.
2051 }
2052
ossu97ba30e2016-04-25 07:55:58 -07002053 ComfortNoiseDecoder* cng_decoder = decoder_database_->GetActiveCngDecoder();
Karl Wiberg43766482015-08-27 15:22:11 +02002054 if (cng_decoder)
2055 cng_decoder->Reset();
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00002056
2057 // Reinit post-decode VAD with new sample rate.
2058 assert(vad_.get()); // Cannot be NULL here.
2059 vad_->Init();
2060
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +00002061 // Delete algorithm buffer and create a new one.
henrik.lundin@webrtc.orgfd11bbf2013-09-30 20:38:44 +00002062 algorithm_buffer_.reset(new AudioMultiVector(channels));
henrik.lundin@webrtc.orgc487c6a2013-09-02 07:59:30 +00002063
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00002064 // Delete sync buffer and create a new one.
henrik.lundin@webrtc.org0d5da252013-09-18 21:12:38 +00002065 sync_buffer_.reset(new SyncBuffer(channels, kSyncBufferSize * fs_mult_));
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00002066
henrik.lundin@webrtc.orgea257842014-08-07 12:27:37 +00002067 // Delete BackgroundNoise object and create a new one.
henrik.lundin@webrtc.org0d5da252013-09-18 21:12:38 +00002068 background_noise_.reset(new BackgroundNoise(channels));
henrik.lundin@webrtc.orgea257842014-08-07 12:27:37 +00002069 background_noise_->set_mode(background_noise_mode_);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00002070
2071 // Reset random vector.
2072 random_vector_.Reset();
2073
turaj@webrtc.org8d1cdaa2014-04-11 18:47:55 +00002074 UpdatePlcComponents(fs_hz, channels);
2075
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00002076 // Move index so that we create a small set of future samples (all 0).
2077 sync_buffer_->set_next_index(sync_buffer_->next_index() -
turaj@webrtc.org8d1cdaa2014-04-11 18:47:55 +00002078 expand_->overlap_length());
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00002079
henrik.lundin@webrtc.org40d3fc62013-09-18 12:19:50 +00002080 normal_.reset(new Normal(fs_hz, decoder_database_.get(), *background_noise_,
henrik.lundin@webrtc.org0d5da252013-09-18 21:12:38 +00002081 expand_.get()));
henrik.lundin@webrtc.orgd9faa462014-01-14 10:18:45 +00002082 accelerate_.reset(
2083 accelerate_factory_->Create(fs_hz, channels, *background_noise_));
turaj@webrtc.org8d1cdaa2014-04-11 18:47:55 +00002084 preemptive_expand_.reset(preemptive_expand_factory_->Create(
Peter Kastingdce40cf2015-08-24 14:52:23 -07002085 fs_hz, channels, *background_noise_, expand_->overlap_length()));
henrik.lundin@webrtc.org40d3fc62013-09-18 12:19:50 +00002086
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00002087 // Delete ComfortNoise object and create a new one.
henrik.lundin@webrtc.org0d5da252013-09-18 21:12:38 +00002088 comfort_noise_.reset(new ComfortNoise(fs_hz, decoder_database_.get(),
2089 sync_buffer_.get()));
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00002090
2091 // Verify that |decoded_buffer_| is long enough.
2092 if (decoded_buffer_length_ < kMaxFrameSize * channels) {
2093 // Reallocate to larger size.
2094 decoded_buffer_length_ = kMaxFrameSize * channels;
2095 decoded_buffer_.reset(new int16_t[decoded_buffer_length_]);
2096 }
2097
turaj@webrtc.org8d1cdaa2014-04-11 18:47:55 +00002098 // Create DecisionLogic if it is not created yet, then communicate new sample
2099 // rate and output size to DecisionLogic object.
2100 if (!decision_logic_.get()) {
henrik.lundin@webrtc.org7cbc4f92014-10-07 06:37:39 +00002101 CreateDecisionLogic();
turaj@webrtc.org8d1cdaa2014-04-11 18:47:55 +00002102 }
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00002103 decision_logic_->SetSampleRate(fs_hz_, output_size_samples_);
2104}
2105
henrik.lundin55480f52016-03-08 02:37:57 -08002106NetEqImpl::OutputType NetEqImpl::LastOutputType() {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00002107 assert(vad_.get());
henrik.lundin@webrtc.org0d5da252013-09-18 21:12:38 +00002108 assert(expand_.get());
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00002109 if (last_mode_ == kModeCodecInternalCng || last_mode_ == kModeRfc3389Cng) {
henrik.lundin55480f52016-03-08 02:37:57 -08002110 return OutputType::kCNG;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00002111 } else if (last_mode_ == kModeExpand && expand_->MuteFactor(0) == 0) {
2112 // Expand mode has faded down to background noise only (very long expand).
henrik.lundin55480f52016-03-08 02:37:57 -08002113 return OutputType::kPLCCNG;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00002114 } else if (last_mode_ == kModeExpand) {
henrik.lundin55480f52016-03-08 02:37:57 -08002115 return OutputType::kPLC;
wu@webrtc.org24301a62013-12-13 19:17:43 +00002116 } else if (vad_->running() && !vad_->active_speech()) {
henrik.lundin55480f52016-03-08 02:37:57 -08002117 return OutputType::kVadPassive;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00002118 } else {
henrik.lundin55480f52016-03-08 02:37:57 -08002119 return OutputType::kNormalSpeech;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00002120 }
2121}
2122
henrik.lundin@webrtc.org7cbc4f92014-10-07 06:37:39 +00002123void NetEqImpl::CreateDecisionLogic() {
Henrik Lundin47b17dc2016-05-10 10:20:59 +02002124 decision_logic_.reset(DecisionLogic::Create(
2125 fs_hz_, output_size_samples_, playout_mode_, decoder_database_.get(),
2126 *packet_buffer_.get(), delay_manager_.get(), buffer_level_filter_.get(),
2127 tick_timer_.get()));
turaj@webrtc.org8d1cdaa2014-04-11 18:47:55 +00002128}
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00002129} // namespace webrtc