henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1 | /* |
| 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 Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 11 | #include "modules/audio_coding/neteq/neteq_impl.h" |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 12 | |
| 13 | #include <assert.h> |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 14 | |
| 15 | #include <algorithm> |
ossu | 61a208b | 2016-09-20 01:38:00 -0700 | [diff] [blame] | 16 | #include <utility> |
ossu | 97ba30e | 2016-04-25 07:55:58 -0700 | [diff] [blame] | 17 | #include <vector> |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 18 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 19 | #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.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 50 | |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 51 | namespace webrtc { |
| 52 | |
ossu | e352578 | 2016-05-25 07:37:43 -0700 | [diff] [blame] | 53 | NetEqImpl::Dependencies::Dependencies( |
| 54 | const NetEq::Config& config, |
| 55 | const rtc::scoped_refptr<AudioDecoderFactory>& decoder_factory) |
henrik.lundin | 1d9061e | 2016-04-26 12:19:34 -0700 | [diff] [blame] | 56 | : tick_timer(new TickTimer), |
| 57 | buffer_level_filter(new BufferLevelFilter), |
ossu | e352578 | 2016-05-25 07:37:43 -0700 | [diff] [blame] | 58 | decoder_database(new DecoderDatabase(decoder_factory)), |
henrik.lundin | f393370 | 2016-04-28 01:53:52 -0700 | [diff] [blame] | 59 | delay_peak_detector(new DelayPeakDetector(tick_timer.get())), |
henrik.lundin | 1d9061e | 2016-04-26 12:19:34 -0700 | [diff] [blame] | 60 | delay_manager(new DelayManager(config.max_packets_in_buffer, |
henrik.lundin | 8f8c96d | 2016-04-28 23:19:20 -0700 | [diff] [blame] | 61 | delay_peak_detector.get(), |
| 62 | tick_timer.get())), |
henrik.lundin | 1d9061e | 2016-04-26 12:19:34 -0700 | [diff] [blame] | 63 | 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())), |
ossu | a70695a | 2016-09-22 02:06:28 -0700 | [diff] [blame] | 67 | red_payload_splitter(new RedPayloadSplitter), |
henrik.lundin | 1d9061e | 2016-04-26 12:19:34 -0700 | [diff] [blame] | 68 | timestamp_scaler(new TimestampScaler(*decoder_database)), |
| 69 | accelerate_factory(new AccelerateFactory), |
| 70 | expand_factory(new ExpandFactory), |
| 71 | preemptive_expand_factory(new PreemptiveExpandFactory) {} |
| 72 | |
| 73 | NetEqImpl::Dependencies::~Dependencies() = default; |
| 74 | |
henrik.lundin@webrtc.org | ea25784 | 2014-08-07 12:27:37 +0000 | [diff] [blame] | 75 | NetEqImpl::NetEqImpl(const NetEq::Config& config, |
henrik.lundin | 1d9061e | 2016-04-26 12:19:34 -0700 | [diff] [blame] | 76 | Dependencies&& deps, |
turaj@webrtc.org | 8d1cdaa | 2014-04-11 18:47:55 +0000 | [diff] [blame] | 77 | bool create_components) |
henrik.lundin | 1d9061e | 2016-04-26 12:19:34 -0700 | [diff] [blame] | 78 | : 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)), |
ossu | a70695a | 2016-09-22 02:06:28 -0700 | [diff] [blame] | 86 | red_payload_splitter_(std::move(deps.red_payload_splitter)), |
henrik.lundin | 1d9061e | 2016-04-26 12:19:34 -0700 | [diff] [blame] | 87 | timestamp_scaler_(std::move(deps.timestamp_scaler)), |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 88 | vad_(new PostDecodeVad()), |
henrik.lundin | 1d9061e | 2016-04-26 12:19:34 -0700 | [diff] [blame] | 89 | 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.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 92 | last_mode_(kModeNormal), |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 93 | 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.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 99 | ssrc_(0), |
| 100 | first_packet_(true), |
henrik.lundin@webrtc.org | ea25784 | 2014-08-07 12:27:37 +0000 | [diff] [blame] | 101 | background_noise_mode_(config.background_noise_mode), |
henrik.lundin@webrtc.org | 7cbc4f9 | 2014-10-07 06:37:39 +0000 | [diff] [blame] | 102 | playout_mode_(config.playout_mode), |
Henrik Lundin | cf808d2 | 2015-05-27 14:33:29 +0200 | [diff] [blame] | 103 | enable_fast_accelerate_(config.enable_fast_accelerate), |
henrik.lundin | 7a92681 | 2016-05-12 13:51:28 -0700 | [diff] [blame] | 104 | nack_enabled_(false), |
| 105 | enable_muted_state_(config.enable_muted_state) { |
Henrik Lundin | 905495c | 2015-05-25 16:58:41 +0200 | [diff] [blame] | 106 | LOG(LS_INFO) << "NetEq config: " << config.ToString(); |
henrik.lundin@webrtc.org | ea25784 | 2014-08-07 12:27:37 +0000 | [diff] [blame] | 107 | int fs = config.sample_rate_hz; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 108 | 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.lundin | 1d9061e | 2016-04-26 12:19:34 -0700 | [diff] [blame] | 113 | delay_manager_->SetMaximumDelay(config.max_delay_ms); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 114 | fs_hz_ = fs; |
| 115 | fs_mult_ = fs / 8000; |
henrik.lundin | d89814b | 2015-11-23 06:49:25 -0800 | [diff] [blame] | 116 | last_output_sample_rate_hz_ = fs; |
Peter Kasting | dce40cf | 2015-08-24 14:52:23 -0700 | [diff] [blame] | 117 | output_size_samples_ = static_cast<size_t>(kOutputSizeMs * 8 * fs_mult_); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 118 | decoder_frame_length_ = 3 * output_size_samples_; |
| 119 | WebRtcSpl_Init(); |
turaj@webrtc.org | 8d1cdaa | 2014-04-11 18:47:55 +0000 | [diff] [blame] | 120 | if (create_components) { |
| 121 | SetSampleRateAndChannels(fs, 1); // Default is 1 channel. |
| 122 | } |
henrik.lundin | 9bc2667 | 2015-11-02 03:25:57 -0800 | [diff] [blame] | 123 | RTC_DCHECK(!vad_->enabled()); |
| 124 | if (config.enable_post_decode_vad) { |
| 125 | vad_->Enable(); |
| 126 | } |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 127 | } |
| 128 | |
Henrik Lundin | d67a219 | 2015-08-03 12:54:37 +0200 | [diff] [blame] | 129 | NetEqImpl::~NetEqImpl() = default; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 130 | |
Henrik Lundin | 70c09bd | 2017-04-24 15:56:56 +0200 | [diff] [blame] | 131 | int NetEqImpl::InsertPacket(const RTPHeader& rtp_header, |
kwiberg | ee2bac2 | 2015-11-11 10:34:00 -0800 | [diff] [blame] | 132 | rtc::ArrayView<const uint8_t> payload, |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 133 | uint32_t receive_timestamp) { |
kwiberg | ac554ee | 2016-09-02 00:39:33 -0700 | [diff] [blame] | 134 | rtc::MsanCheckInitialized(payload); |
henrik.lundin | a689b44 | 2015-12-17 03:50:05 -0800 | [diff] [blame] | 135 | TRACE_EVENT0("webrtc", "NetEqImpl::InsertPacket"); |
Tommi | 9090e0b | 2016-01-20 13:39:36 +0100 | [diff] [blame] | 136 | rtc::CritScope lock(&crit_sect_); |
Henrik Lundin | c417d9e | 2017-06-14 12:29:03 +0200 | [diff] [blame] | 137 | if (InsertPacketInternal(rtp_header, payload, receive_timestamp) != 0) { |
henrik.lundin@webrtc.org | e7ce437 | 2014-01-09 14:01:55 +0000 | [diff] [blame] | 138 | return kFail; |
| 139 | } |
| 140 | return kOK; |
turaj@webrtc.org | 7b75ac6 | 2013-09-26 00:27:56 +0000 | [diff] [blame] | 141 | } |
| 142 | |
henrik.lundin | b8c55b1 | 2017-05-10 07:38:01 -0700 | [diff] [blame] | 143 | void 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.lundin | 500c04b | 2016-03-08 02:36:04 -0800 | [diff] [blame] | 151 | namespace { |
| 152 | void SetAudioFrameActivityAndType(bool vad_enabled, |
henrik.lundin | 55480f5 | 2016-03-08 02:37:57 -0800 | [diff] [blame] | 153 | NetEqImpl::OutputType type, |
henrik.lundin | 500c04b | 2016-03-08 02:36:04 -0800 | [diff] [blame] | 154 | AudioFrame::VADActivity last_vad_activity, |
| 155 | AudioFrame* audio_frame) { |
| 156 | switch (type) { |
henrik.lundin | 55480f5 | 2016-03-08 02:37:57 -0800 | [diff] [blame] | 157 | case NetEqImpl::OutputType::kNormalSpeech: { |
henrik.lundin | 500c04b | 2016-03-08 02:36:04 -0800 | [diff] [blame] | 158 | audio_frame->speech_type_ = AudioFrame::kNormalSpeech; |
| 159 | audio_frame->vad_activity_ = AudioFrame::kVadActive; |
| 160 | break; |
| 161 | } |
henrik.lundin | 55480f5 | 2016-03-08 02:37:57 -0800 | [diff] [blame] | 162 | case NetEqImpl::OutputType::kVadPassive: { |
henrik.lundin | 500c04b | 2016-03-08 02:36:04 -0800 | [diff] [blame] | 163 | // 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.lundin | 55480f5 | 2016-03-08 02:37:57 -0800 | [diff] [blame] | 169 | case NetEqImpl::OutputType::kCNG: { |
henrik.lundin | 500c04b | 2016-03-08 02:36:04 -0800 | [diff] [blame] | 170 | audio_frame->speech_type_ = AudioFrame::kCNG; |
| 171 | audio_frame->vad_activity_ = AudioFrame::kVadPassive; |
| 172 | break; |
| 173 | } |
henrik.lundin | 55480f5 | 2016-03-08 02:37:57 -0800 | [diff] [blame] | 174 | case NetEqImpl::OutputType::kPLC: { |
henrik.lundin | 500c04b | 2016-03-08 02:36:04 -0800 | [diff] [blame] | 175 | audio_frame->speech_type_ = AudioFrame::kPLC; |
| 176 | audio_frame->vad_activity_ = last_vad_activity; |
| 177 | break; |
| 178 | } |
henrik.lundin | 55480f5 | 2016-03-08 02:37:57 -0800 | [diff] [blame] | 179 | case NetEqImpl::OutputType::kPLCCNG: { |
henrik.lundin | 500c04b | 2016-03-08 02:36:04 -0800 | [diff] [blame] | 180 | 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.lundin | bc89de3 | 2016-03-08 05:20:14 -0800 | [diff] [blame] | 192 | } // namespace |
henrik.lundin | 500c04b | 2016-03-08 02:36:04 -0800 | [diff] [blame] | 193 | |
henrik.lundin | 7a92681 | 2016-05-12 13:51:28 -0700 | [diff] [blame] | 194 | int NetEqImpl::GetAudio(AudioFrame* audio_frame, bool* muted) { |
henrik.lundin | e1ca167 | 2016-01-08 03:50:08 -0800 | [diff] [blame] | 195 | TRACE_EVENT0("webrtc", "NetEqImpl::GetAudio"); |
Tommi | 9090e0b | 2016-01-20 13:39:36 +0100 | [diff] [blame] | 196 | rtc::CritScope lock(&crit_sect_); |
Henrik Lundin | c417d9e | 2017-06-14 12:29:03 +0200 | [diff] [blame] | 197 | if (GetAudioInternal(audio_frame, muted) != 0) { |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 198 | return kFail; |
| 199 | } |
henrik.lundin | 5fac3f0 | 2016-08-24 11:18:49 -0700 | [diff] [blame] | 200 | RTC_DCHECK_EQ( |
| 201 | audio_frame->sample_rate_hz_, |
kwiberg | d3edd77 | 2017-03-01 18:52:48 -0800 | [diff] [blame] | 202 | rtc::dchecked_cast<int>(audio_frame->samples_per_channel_ * 100)); |
henrik.lundin | a449107 | 2017-07-06 05:23:53 -0700 | [diff] [blame] | 203 | RTC_DCHECK_EQ(*muted, audio_frame->muted()); |
henrik.lundin | 500c04b | 2016-03-08 02:36:04 -0800 | [diff] [blame] | 204 | SetAudioFrameActivityAndType(vad_->enabled(), LastOutputType(), |
| 205 | last_vad_activity_, audio_frame); |
| 206 | last_vad_activity_ = audio_frame->vad_activity_; |
henrik.lundin | 6d8e011 | 2016-03-04 10:34:21 -0800 | [diff] [blame] | 207 | last_output_sample_rate_hz_ = audio_frame->sample_rate_hz_; |
henrik.lundin | d89814b | 2015-11-23 06:49:25 -0800 | [diff] [blame] | 208 | 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.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 213 | return kOK; |
| 214 | } |
| 215 | |
kwiberg | 1c07c70 | 2017-03-27 07:15:49 -0700 | [diff] [blame] | 216 | void 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-webrtc | fae474c | 2017-07-05 11:17:40 +0200 | [diff] [blame] | 221 | packet_buffer_->DiscardPacketsWithPayloadType(pt, &stats_); |
kwiberg | 1c07c70 | 2017-03-27 07:15:49 -0700 | [diff] [blame] | 222 | } |
| 223 | } |
| 224 | |
kwiberg | ee1879c | 2015-10-29 06:20:28 -0700 | [diff] [blame] | 225 | int NetEqImpl::RegisterPayloadType(NetEqDecoder codec, |
henrik.lundin | 4cf61dd | 2015-12-09 06:20:58 -0800 | [diff] [blame] | 226 | const std::string& name, |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 227 | uint8_t rtp_payload_type) { |
Tommi | 9090e0b | 2016-01-20 13:39:36 +0100 | [diff] [blame] | 228 | rtc::CritScope lock(&crit_sect_); |
Henrik Lundin | d67a219 | 2015-08-03 12:54:37 +0200 | [diff] [blame] | 229 | LOG(LS_VERBOSE) << "RegisterPayloadType " |
kwiberg | ee1879c | 2015-10-29 06:20:28 -0700 | [diff] [blame] | 230 | << static_cast<int>(rtp_payload_type) << " " |
| 231 | << static_cast<int>(codec); |
Henrik Lundin | c417d9e | 2017-06-14 12:29:03 +0200 | [diff] [blame] | 232 | if (decoder_database_->RegisterPayload(rtp_payload_type, codec, name) != |
| 233 | DecoderDatabase::kOK) { |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 234 | return kFail; |
| 235 | } |
| 236 | return kOK; |
| 237 | } |
| 238 | |
| 239 | int NetEqImpl::RegisterExternalDecoder(AudioDecoder* decoder, |
kwiberg | ee1879c | 2015-10-29 06:20:28 -0700 | [diff] [blame] | 240 | NetEqDecoder codec, |
henrik.lundin | 4cf61dd | 2015-12-09 06:20:58 -0800 | [diff] [blame] | 241 | const std::string& codec_name, |
kwiberg | 342f740 | 2016-06-16 03:18:00 -0700 | [diff] [blame] | 242 | uint8_t rtp_payload_type) { |
Tommi | 9090e0b | 2016-01-20 13:39:36 +0100 | [diff] [blame] | 243 | rtc::CritScope lock(&crit_sect_); |
Henrik Lundin | d67a219 | 2015-08-03 12:54:37 +0200 | [diff] [blame] | 244 | LOG(LS_VERBOSE) << "RegisterExternalDecoder " |
kwiberg | ee1879c | 2015-10-29 06:20:28 -0700 | [diff] [blame] | 245 | << static_cast<int>(rtp_payload_type) << " " |
| 246 | << static_cast<int>(codec); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 247 | if (!decoder) { |
| 248 | LOG(LS_ERROR) << "Cannot register external decoder with NULL pointer"; |
| 249 | assert(false); |
| 250 | return kFail; |
| 251 | } |
Henrik Lundin | c417d9e | 2017-06-14 12:29:03 +0200 | [diff] [blame] | 252 | if (decoder_database_->InsertExternal(rtp_payload_type, codec, codec_name, |
| 253 | decoder) != DecoderDatabase::kOK) { |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 254 | return kFail; |
| 255 | } |
| 256 | return kOK; |
| 257 | } |
| 258 | |
kwiberg | 5adaf73 | 2016-10-04 09:33:27 -0700 | [diff] [blame] | 259 | bool 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 Lundin | c417d9e | 2017-06-14 12:29:03 +0200 | [diff] [blame] | 264 | return decoder_database_->RegisterPayload(rtp_payload_type, audio_format) == |
| 265 | DecoderDatabase::kOK; |
kwiberg | 5adaf73 | 2016-10-04 09:33:27 -0700 | [diff] [blame] | 266 | } |
| 267 | |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 268 | int NetEqImpl::RemovePayloadType(uint8_t rtp_payload_type) { |
Tommi | 9090e0b | 2016-01-20 13:39:36 +0100 | [diff] [blame] | 269 | rtc::CritScope lock(&crit_sect_); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 270 | int ret = decoder_database_->Remove(rtp_payload_type); |
Henrik Lundin | c417d9e | 2017-06-14 12:29:03 +0200 | [diff] [blame] | 271 | if (ret == DecoderDatabase::kOK || ret == DecoderDatabase::kDecoderNotFound) { |
minyue-webrtc | fae474c | 2017-07-05 11:17:40 +0200 | [diff] [blame] | 272 | packet_buffer_->DiscardPacketsWithPayloadType(rtp_payload_type, &stats_); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 273 | return kOK; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 274 | } |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 275 | return kFail; |
| 276 | } |
| 277 | |
kwiberg | 6b19b56 | 2016-09-20 04:02:25 -0700 | [diff] [blame] | 278 | void NetEqImpl::RemoveAllPayloadTypes() { |
| 279 | rtc::CritScope lock(&crit_sect_); |
| 280 | decoder_database_->RemoveAll(); |
| 281 | } |
| 282 | |
turaj@webrtc.org | f1efc57 | 2013-08-16 23:44:24 +0000 | [diff] [blame] | 283 | bool NetEqImpl::SetMinimumDelay(int delay_ms) { |
Tommi | 9090e0b | 2016-01-20 13:39:36 +0100 | [diff] [blame] | 284 | rtc::CritScope lock(&crit_sect_); |
Gustaf Ullberg | 48d96c0 | 2017-09-15 13:59:52 +0200 | [diff] [blame] | 285 | if (delay_ms >= 0 && delay_ms <= 10000) { |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 286 | assert(delay_manager_.get()); |
turaj@webrtc.org | f1efc57 | 2013-08-16 23:44:24 +0000 | [diff] [blame] | 287 | return delay_manager_->SetMinimumDelay(delay_ms); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 288 | } |
| 289 | return false; |
| 290 | } |
| 291 | |
turaj@webrtc.org | f1efc57 | 2013-08-16 23:44:24 +0000 | [diff] [blame] | 292 | bool NetEqImpl::SetMaximumDelay(int delay_ms) { |
Tommi | 9090e0b | 2016-01-20 13:39:36 +0100 | [diff] [blame] | 293 | rtc::CritScope lock(&crit_sect_); |
Gustaf Ullberg | 48d96c0 | 2017-09-15 13:59:52 +0200 | [diff] [blame] | 294 | if (delay_ms >= 0 && delay_ms <= 10000) { |
turaj@webrtc.org | f1efc57 | 2013-08-16 23:44:24 +0000 | [diff] [blame] | 295 | assert(delay_manager_.get()); |
| 296 | return delay_manager_->SetMaximumDelay(delay_ms); |
| 297 | } |
| 298 | return false; |
| 299 | } |
| 300 | |
| 301 | int NetEqImpl::LeastRequiredDelayMs() const { |
Tommi | 9090e0b | 2016-01-20 13:39:36 +0100 | [diff] [blame] | 302 | rtc::CritScope lock(&crit_sect_); |
turaj@webrtc.org | f1efc57 | 2013-08-16 23:44:24 +0000 | [diff] [blame] | 303 | assert(delay_manager_.get()); |
| 304 | return delay_manager_->least_required_delay_ms(); |
| 305 | } |
| 306 | |
Karl Wiberg | 7f6c4d4 | 2015-04-09 15:44:22 +0200 | [diff] [blame] | 307 | int NetEqImpl::SetTargetDelay() { |
| 308 | return kNotImplemented; |
| 309 | } |
| 310 | |
henrik.lundin | 114c1b3 | 2017-04-26 07:47:32 -0700 | [diff] [blame] | 311 | int 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 Wiberg | 7f6c4d4 | 2015-04-09 15:44:22 +0200 | [diff] [blame] | 319 | } |
| 320 | |
henrik.lundin | 9c3efd0 | 2015-08-27 13:12:22 -0700 | [diff] [blame] | 321 | int NetEqImpl::CurrentDelayMs() const { |
Tommi | 9090e0b | 2016-01-20 13:39:36 +0100 | [diff] [blame] | 322 | rtc::CritScope lock(&crit_sect_); |
henrik.lundin | 9c3efd0 | 2015-08-27 13:12:22 -0700 | [diff] [blame] | 323 | 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 = |
ossu | 61a208b | 2016-09-20 01:38:00 -0700 | [diff] [blame] | 328 | packet_buffer_->NumSamplesInBuffer(decoder_frame_length_) + |
henrik.lundin | 9c3efd0 | 2015-08-27 13:12:22 -0700 | [diff] [blame] | 329 | 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 Wiberg | 7f6c4d4 | 2015-04-09 15:44:22 +0200 | [diff] [blame] | 334 | } |
| 335 | |
henrik.lundin | b3f1c5d | 2016-08-22 15:39:53 -0700 | [diff] [blame] | 336 | int 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.org | 7cbc4f9 | 2014-10-07 06:37:39 +0000 | [diff] [blame] | 352 | // Deprecated. |
| 353 | // TODO(henrik.lundin) Delete. |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 354 | void NetEqImpl::SetPlayoutMode(NetEqPlayoutMode mode) { |
Tommi | 9090e0b | 2016-01-20 13:39:36 +0100 | [diff] [blame] | 355 | rtc::CritScope lock(&crit_sect_); |
henrik.lundin@webrtc.org | 7cbc4f9 | 2014-10-07 06:37:39 +0000 | [diff] [blame] | 356 | if (mode != playout_mode_) { |
| 357 | playout_mode_ = mode; |
| 358 | CreateDecisionLogic(); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 359 | } |
| 360 | } |
| 361 | |
henrik.lundin@webrtc.org | 7cbc4f9 | 2014-10-07 06:37:39 +0000 | [diff] [blame] | 362 | // Deprecated. |
| 363 | // TODO(henrik.lundin) Delete. |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 364 | NetEqPlayoutMode NetEqImpl::PlayoutMode() const { |
Tommi | 9090e0b | 2016-01-20 13:39:36 +0100 | [diff] [blame] | 365 | rtc::CritScope lock(&crit_sect_); |
henrik.lundin@webrtc.org | 7cbc4f9 | 2014-10-07 06:37:39 +0000 | [diff] [blame] | 366 | return playout_mode_; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 367 | } |
| 368 | |
| 369 | int NetEqImpl::NetworkStatistics(NetEqNetworkStatistics* stats) { |
Tommi | 9090e0b | 2016-01-20 13:39:36 +0100 | [diff] [blame] | 370 | rtc::CritScope lock(&crit_sect_); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 371 | assert(decoder_database_.get()); |
Peter Kasting | dce40cf | 2015-08-24 14:52:23 -0700 | [diff] [blame] | 372 | const size_t total_samples_in_buffers = |
ossu | 61a208b | 2016-09-20 01:38:00 -0700 | [diff] [blame] | 373 | packet_buffer_->NumSamplesInBuffer(decoder_frame_length_) + |
Peter Kasting | dce40cf | 2015-08-24 14:52:23 -0700 | [diff] [blame] | 374 | sync_buffer_->FutureLength(); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 375 | assert(delay_manager_.get()); |
| 376 | assert(decision_logic_.get()); |
Henrik Lundin | dccfc40 | 2017-09-25 12:30:58 +0200 | [diff] [blame] | 377 | 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.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 380 | stats_.GetNetworkStatistics(fs_hz_, total_samples_in_buffers, |
Henrik Lundin | dccfc40 | 2017-09-25 12:30:58 +0200 | [diff] [blame] | 381 | decoder_frame_length_, stats); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 382 | return 0; |
| 383 | } |
| 384 | |
Steve Anton | 2dbc69f | 2017-08-24 17:15:13 -0700 | [diff] [blame] | 385 | NetEqLifetimeStatistics NetEqImpl::GetLifetimeStatistics() const { |
| 386 | rtc::CritScope lock(&crit_sect_); |
| 387 | return stats_.GetLifetimeStatistics(); |
| 388 | } |
| 389 | |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 390 | void NetEqImpl::GetRtcpStatistics(RtcpStatistics* stats) { |
Tommi | 9090e0b | 2016-01-20 13:39:36 +0100 | [diff] [blame] | 391 | rtc::CritScope lock(&crit_sect_); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 392 | if (stats) { |
| 393 | rtcp_.GetStatistics(false, stats); |
| 394 | } |
| 395 | } |
| 396 | |
| 397 | void NetEqImpl::GetRtcpStatisticsNoReset(RtcpStatistics* stats) { |
Tommi | 9090e0b | 2016-01-20 13:39:36 +0100 | [diff] [blame] | 398 | rtc::CritScope lock(&crit_sect_); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 399 | if (stats) { |
| 400 | rtcp_.GetStatistics(true, stats); |
| 401 | } |
| 402 | } |
| 403 | |
| 404 | void NetEqImpl::EnableVad() { |
Tommi | 9090e0b | 2016-01-20 13:39:36 +0100 | [diff] [blame] | 405 | rtc::CritScope lock(&crit_sect_); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 406 | assert(vad_.get()); |
| 407 | vad_->Enable(); |
| 408 | } |
| 409 | |
| 410 | void NetEqImpl::DisableVad() { |
Tommi | 9090e0b | 2016-01-20 13:39:36 +0100 | [diff] [blame] | 411 | rtc::CritScope lock(&crit_sect_); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 412 | assert(vad_.get()); |
| 413 | vad_->Disable(); |
| 414 | } |
| 415 | |
henrik.lundin | 15c51e3 | 2016-04-06 08:38:56 -0700 | [diff] [blame] | 416 | rtc::Optional<uint32_t> NetEqImpl::GetPlayoutTimestamp() const { |
Tommi | 9090e0b | 2016-01-20 13:39:36 +0100 | [diff] [blame] | 417 | rtc::CritScope lock(&crit_sect_); |
henrik.lundin | 0d96ab7 | 2016-04-06 12:28:26 -0700 | [diff] [blame] | 418 | if (first_packet_ || last_mode_ == kModeRfc3389Cng || |
| 419 | last_mode_ == kModeCodecInternalCng) { |
wu@webrtc.org | 94454b7 | 2014-06-05 20:34:08 +0000 | [diff] [blame] | 420 | // We don't have a valid RTP timestamp until we have decoded our first |
henrik.lundin | 0d96ab7 | 2016-04-06 12:28:26 -0700 | [diff] [blame] | 421 | // RTP packet. Also, the RTP timestamp is not accurate while playing CNG, |
| 422 | // which is indicated by returning an empty value. |
henrik.lundin | 9a410dd | 2016-04-06 01:39:22 -0700 | [diff] [blame] | 423 | return rtc::Optional<uint32_t>(); |
wu@webrtc.org | 94454b7 | 2014-06-05 20:34:08 +0000 | [diff] [blame] | 424 | } |
henrik.lundin | 9a410dd | 2016-04-06 01:39:22 -0700 | [diff] [blame] | 425 | return rtc::Optional<uint32_t>( |
| 426 | timestamp_scaler_->ToExternal(playout_timestamp_)); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 427 | } |
| 428 | |
henrik.lundin | d89814b | 2015-11-23 06:49:25 -0800 | [diff] [blame] | 429 | int NetEqImpl::last_output_sample_rate_hz() const { |
Tommi | 9090e0b | 2016-01-20 13:39:36 +0100 | [diff] [blame] | 430 | rtc::CritScope lock(&crit_sect_); |
henrik.lundin | d89814b | 2015-11-23 06:49:25 -0800 | [diff] [blame] | 431 | return last_output_sample_rate_hz_; |
| 432 | } |
| 433 | |
kwiberg | 6f0f616 | 2016-09-20 03:07:46 -0700 | [diff] [blame] | 434 | rtc::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; |
kwiberg | e941306 | 2016-11-03 05:29:05 -0700 | [diff] [blame] | 447 | std::strncpy(ci.plname, di->get_name().c_str(), sizeof(ci.plname)); |
kwiberg | 6f0f616 | 2016-09-20 03:07:46 -0700 | [diff] [blame] | 448 | ci.plname[sizeof(ci.plname) - 1] = '\0'; |
solenberg | 2779bab | 2016-11-17 04:45:19 -0800 | [diff] [blame] | 449 | ci.plfreq = di->IsRed() ? 8000 : di->SampleRateHz(); |
kwiberg | 6f0f616 | 2016-09-20 03:07:46 -0700 | [diff] [blame] | 450 | AudioDecoder* const decoder = di->GetDecoder(); |
| 451 | ci.channels = decoder ? decoder->Channels() : 1; |
| 452 | return rtc::Optional<CodecInst>(ci); |
| 453 | } |
| 454 | |
ossu | f1b08da | 2016-09-23 02:19:43 -0700 | [diff] [blame] | 455 | rtc::Optional<SdpAudioFormat> NetEqImpl::GetDecoderFormat( |
| 456 | int payload_type) const { |
kwiberg | c4ccd4d | 2016-09-21 10:55:15 -0700 | [diff] [blame] | 457 | rtc::CritScope lock(&crit_sect_); |
| 458 | const DecoderDatabase::DecoderInfo* const di = |
| 459 | decoder_database_->GetDecoderInfo(payload_type); |
| 460 | if (!di) { |
ossu | f1b08da | 2016-09-23 02:19:43 -0700 | [diff] [blame] | 461 | return rtc::Optional<SdpAudioFormat>(); // Payload type not registered. |
kwiberg | c4ccd4d | 2016-09-21 10:55:15 -0700 | [diff] [blame] | 462 | } |
ossu | f1b08da | 2016-09-23 02:19:43 -0700 | [diff] [blame] | 463 | return rtc::Optional<SdpAudioFormat>(di->GetFormat()); |
kwiberg | c4ccd4d | 2016-09-21 10:55:15 -0700 | [diff] [blame] | 464 | } |
| 465 | |
Karl Wiberg | 7f6c4d4 | 2015-04-09 15:44:22 +0200 | [diff] [blame] | 466 | int NetEqImpl::SetTargetNumberOfChannels() { |
| 467 | return kNotImplemented; |
| 468 | } |
| 469 | |
| 470 | int NetEqImpl::SetTargetSampleRate() { |
| 471 | return kNotImplemented; |
| 472 | } |
| 473 | |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 474 | void NetEqImpl::FlushBuffers() { |
Tommi | 9090e0b | 2016-01-20 13:39:36 +0100 | [diff] [blame] | 475 | rtc::CritScope lock(&crit_sect_); |
Henrik Lundin | d67a219 | 2015-08-03 12:54:37 +0200 | [diff] [blame] | 476 | LOG(LS_VERBOSE) << "FlushBuffers"; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 477 | packet_buffer_->Flush(); |
henrik.lundin@webrtc.org | 0d5da25 | 2013-09-18 21:12:38 +0000 | [diff] [blame] | 478 | assert(sync_buffer_.get()); |
| 479 | assert(expand_.get()); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 480 | 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.org | 3170b57 | 2013-08-30 15:36:53 +0000 | [diff] [blame] | 487 | void NetEqImpl::PacketBufferStatistics(int* current_num_packets, |
henrik.lundin@webrtc.org | 116ed1d | 2014-04-28 08:20:04 +0000 | [diff] [blame] | 488 | int* max_num_packets) const { |
Tommi | 9090e0b | 2016-01-20 13:39:36 +0100 | [diff] [blame] | 489 | rtc::CritScope lock(&crit_sect_); |
henrik.lundin@webrtc.org | 116ed1d | 2014-04-28 08:20:04 +0000 | [diff] [blame] | 490 | packet_buffer_->BufferStat(current_num_packets, max_num_packets); |
turaj@webrtc.org | 3170b57 | 2013-08-30 15:36:53 +0000 | [diff] [blame] | 491 | } |
| 492 | |
henrik.lundin | 48ed930 | 2015-10-29 05:36:24 -0700 | [diff] [blame] | 493 | void NetEqImpl::EnableNack(size_t max_nack_list_size) { |
Tommi | 9090e0b | 2016-01-20 13:39:36 +0100 | [diff] [blame] | 494 | rtc::CritScope lock(&crit_sect_); |
henrik.lundin | 48ed930 | 2015-10-29 05:36:24 -0700 | [diff] [blame] | 495 | if (!nack_enabled_) { |
| 496 | const int kNackThresholdPackets = 2; |
henrik.lundin | 9195186 | 2016-06-08 06:43:41 -0700 | [diff] [blame] | 497 | nack_.reset(NackTracker::Create(kNackThresholdPackets)); |
henrik.lundin | 48ed930 | 2015-10-29 05:36:24 -0700 | [diff] [blame] | 498 | nack_enabled_ = true; |
| 499 | nack_->UpdateSampleRate(fs_hz_); |
| 500 | } |
| 501 | nack_->SetMaxNackListSize(max_nack_list_size); |
| 502 | } |
| 503 | |
| 504 | void NetEqImpl::DisableNack() { |
Tommi | 9090e0b | 2016-01-20 13:39:36 +0100 | [diff] [blame] | 505 | rtc::CritScope lock(&crit_sect_); |
henrik.lundin | 48ed930 | 2015-10-29 05:36:24 -0700 | [diff] [blame] | 506 | nack_.reset(); |
| 507 | nack_enabled_ = false; |
| 508 | } |
| 509 | |
| 510 | std::vector<uint16_t> NetEqImpl::GetNackList(int64_t round_trip_time_ms) const { |
Tommi | 9090e0b | 2016-01-20 13:39:36 +0100 | [diff] [blame] | 511 | rtc::CritScope lock(&crit_sect_); |
henrik.lundin | 48ed930 | 2015-10-29 05:36:24 -0700 | [diff] [blame] | 512 | 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.org | d730177 | 2013-08-29 00:58:14 +0000 | [diff] [blame] | 517 | } |
| 518 | |
henrik.lundin | 114c1b3 | 2017-04-26 07:47:32 -0700 | [diff] [blame] | 519 | std::vector<uint32_t> NetEqImpl::LastDecodedTimestamps() const { |
| 520 | rtc::CritScope lock(&crit_sect_); |
| 521 | return last_decoded_timestamps_; |
| 522 | } |
| 523 | |
| 524 | int 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.org | b287d96 | 2014-04-07 21:21:45 +0000 | [diff] [blame] | 530 | const SyncBuffer* NetEqImpl::sync_buffer_for_test() const { |
Tommi | 9090e0b | 2016-01-20 13:39:36 +0100 | [diff] [blame] | 531 | rtc::CritScope lock(&crit_sect_); |
henrik.lundin@webrtc.org | b287d96 | 2014-04-07 21:21:45 +0000 | [diff] [blame] | 532 | return sync_buffer_.get(); |
| 533 | } |
| 534 | |
minyue | 5bd3397 | 2016-05-02 04:46:11 -0700 | [diff] [blame] | 535 | Operations NetEqImpl::last_operation_for_test() const { |
| 536 | rtc::CritScope lock(&crit_sect_); |
| 537 | return last_operation_; |
| 538 | } |
| 539 | |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 540 | // Methods below this line are private. |
| 541 | |
Henrik Lundin | 70c09bd | 2017-04-24 15:56:56 +0200 | [diff] [blame] | 542 | int NetEqImpl::InsertPacketInternal(const RTPHeader& rtp_header, |
kwiberg | ee2bac2 | 2015-11-11 10:34:00 -0800 | [diff] [blame] | 543 | rtc::ArrayView<const uint8_t> payload, |
ossu | 17e3fa1 | 2016-09-08 04:52:55 -0700 | [diff] [blame] | 544 | uint32_t receive_timestamp) { |
kwiberg | ee2bac2 | 2015-11-11 10:34:00 -0800 | [diff] [blame] | 545 | if (payload.empty()) { |
| 546 | LOG_F(LS_ERROR) << "payload is empty"; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 547 | return kInvalidPointer; |
| 548 | } |
ossu | 17e3fa1 | 2016-09-08 04:52:55 -0700 | [diff] [blame] | 549 | |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 550 | PacketList packet_list; |
ossu | a73f6c9 | 2016-10-24 08:25:28 -0700 | [diff] [blame] | 551 | // Insert packet in a packet list. |
| 552 | packet_list.push_back([&rtp_header, &payload] { |
henrik.lundin@webrtc.org | e1d468c | 2013-01-30 07:37:20 +0000 | [diff] [blame] | 553 | // Convert to Packet. |
ossu | a73f6c9 | 2016-10-24 08:25:28 -0700 | [diff] [blame] | 554 | Packet packet; |
Henrik Lundin | 70c09bd | 2017-04-24 15:56:56 +0200 | [diff] [blame] | 555 | packet.payload_type = rtp_header.payloadType; |
| 556 | packet.sequence_number = rtp_header.sequenceNumber; |
| 557 | packet.timestamp = rtp_header.timestamp; |
ossu | a73f6c9 | 2016-10-24 08:25:28 -0700 | [diff] [blame] | 558 | packet.payload.SetData(payload.data(), payload.size()); |
henrik.lundin | 84f8cd6 | 2016-04-26 07:45:16 -0700 | [diff] [blame] | 559 | // Waiting time will be set upon inserting the packet in the buffer. |
ossu | a73f6c9 | 2016-10-24 08:25:28 -0700 | [diff] [blame] | 560 | RTC_DCHECK(!packet.waiting_time); |
| 561 | return packet; |
| 562 | }()); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 563 | |
Henrik Lundin | 70c09bd | 2017-04-24 15:56:56 +0200 | [diff] [blame] | 564 | bool update_sample_rate_and_channels = |
| 565 | first_packet_ || (rtp_header.ssrc != ssrc_); |
dkirovbroadsoft | e851a9a | 2017-03-14 10:00:27 -0700 | [diff] [blame] | 566 | |
| 567 | if (update_sample_rate_and_channels) { |
| 568 | // Reset timestamp scaling. |
| 569 | timestamp_scaler_->Reset(); |
| 570 | } |
| 571 | |
Henrik Lundin | 70c09bd | 2017-04-24 15:56:56 +0200 | [diff] [blame] | 572 | if (!decoder_database_->IsRed(rtp_header.payloadType)) { |
dkirovbroadsoft | e851a9a | 2017-03-14 10:00:27 -0700 | [diff] [blame] | 573 | // 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.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 583 | // Reinitialize NetEq if it's needed (changed SSRC or first call). |
dkirovbroadsoft | e851a9a | 2017-03-14 10:00:27 -0700 | [diff] [blame] | 584 | if (update_sample_rate_and_channels) { |
henrik.lundin@webrtc.org | 6ff3ac1 | 2014-11-20 14:14:49 +0000 | [diff] [blame] | 585 | // 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 Lundin | 70c09bd | 2017-04-24 15:56:56 +0200 | [diff] [blame] | 588 | rtcp_.Init(rtp_header.sequenceNumber); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 589 | |
| 590 | // Flush the packet buffer and DTMF buffer. |
| 591 | packet_buffer_->Flush(); |
| 592 | dtmf_buffer_->Flush(); |
| 593 | |
| 594 | // Store new SSRC. |
Henrik Lundin | 70c09bd | 2017-04-24 15:56:56 +0200 | [diff] [blame] | 595 | ssrc_ = rtp_header.ssrc; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 596 | |
turaj@webrtc.org | 4d06db5 | 2013-03-27 18:31:42 +0000 | [diff] [blame] | 597 | // Update audio buffer timestamp. |
dkirovbroadsoft | e851a9a | 2017-03-14 10:00:27 -0700 | [diff] [blame] | 598 | sync_buffer_->IncreaseEndTimestamp(main_timestamp - timestamp_); |
turaj@webrtc.org | 4d06db5 | 2013-03-27 18:31:42 +0000 | [diff] [blame] | 599 | |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 600 | // Update codecs. |
dkirovbroadsoft | e851a9a | 2017-03-14 10:00:27 -0700 | [diff] [blame] | 601 | timestamp_ = main_timestamp; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 602 | } |
| 603 | |
turaj@webrtc.org | 7b75ac6 | 2013-09-26 00:27:56 +0000 | [diff] [blame] | 604 | // Update RTCP statistics, only for regular packets. |
Henrik Lundin | 70c09bd | 2017-04-24 15:56:56 +0200 | [diff] [blame] | 605 | rtcp_.Update(rtp_header, receive_timestamp); |
ossu | 7a37761 | 2016-10-18 04:06:13 -0700 | [diff] [blame] | 606 | |
| 607 | if (nack_enabled_) { |
| 608 | RTC_DCHECK(nack_); |
| 609 | if (update_sample_rate_and_channels) { |
| 610 | nack_->Reset(); |
| 611 | } |
Henrik Lundin | 70c09bd | 2017-04-24 15:56:56 +0200 | [diff] [blame] | 612 | nack_->UpdateLastReceivedPacket(rtp_header.sequenceNumber, |
| 613 | rtp_header.timestamp); |
ossu | 7a37761 | 2016-10-18 04:06:13 -0700 | [diff] [blame] | 614 | } |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 615 | |
| 616 | // Check for RED payload type, and separate payloads into several packets. |
Henrik Lundin | 70c09bd | 2017-04-24 15:56:56 +0200 | [diff] [blame] | 617 | if (decoder_database_->IsRed(rtp_header.payloadType)) { |
ossu | a70695a | 2016-09-22 02:06:28 -0700 | [diff] [blame] | 618 | if (!red_payload_splitter_->SplitRed(&packet_list)) { |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 619 | return kRedundancySplitError; |
| 620 | } |
| 621 | // Only accept a few RED payloads of the same type as the main data, |
| 622 | // DTMF events and CNG. |
ossu | a70695a | 2016-09-22 02:06:28 -0700 | [diff] [blame] | 623 | red_payload_splitter_->CheckRedPayloads(&packet_list, *decoder_database_); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 624 | } |
| 625 | |
| 626 | // Check payload types. |
| 627 | if (decoder_database_->CheckPayloadTypes(packet_list) == |
| 628 | DecoderDatabase::kDecoderNotFound) { |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 629 | return kUnknownRtpPayloadType; |
| 630 | } |
| 631 | |
ossu | 7a37761 | 2016-10-18 04:06:13 -0700 | [diff] [blame] | 632 | RTC_DCHECK(!packet_list.empty()); |
ossu | 7a37761 | 2016-10-18 04:06:13 -0700 | [diff] [blame] | 633 | |
dkirovbroadsoft | e851a9a | 2017-03-14 10:00:27 -0700 | [diff] [blame] | 634 | // Update main_timestamp, if new packets appear in the list |
| 635 | // after RED splitting. |
Henrik Lundin | 70c09bd | 2017-04-24 15:56:56 +0200 | [diff] [blame] | 636 | if (decoder_database_->IsRed(rtp_header.payloadType)) { |
dkirovbroadsoft | e851a9a | 2017-03-14 10:00:27 -0700 | [diff] [blame] | 637 | 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.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 642 | |
| 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()) { |
ossu | a73f6c9 | 2016-10-24 08:25:28 -0700 | [diff] [blame] | 647 | const Packet& current_packet = (*it); |
| 648 | RTC_DCHECK(!current_packet.payload.empty()); |
| 649 | if (decoder_database_->IsDtmf(current_packet.payload_type)) { |
minyue@webrtc.org | 9721db7 | 2013-08-06 05:36:26 +0000 | [diff] [blame] | 650 | DtmfEvent event; |
ossu | a73f6c9 | 2016-10-24 08:25:28 -0700 | [diff] [blame] | 651 | int ret = DtmfBuffer::ParseEvent(current_packet.timestamp, |
| 652 | current_packet.payload.data(), |
| 653 | current_packet.payload.size(), &event); |
minyue@webrtc.org | 9721db7 | 2013-08-06 05:36:26 +0000 | [diff] [blame] | 654 | if (ret != DtmfBuffer::kOK) { |
minyue@webrtc.org | 9721db7 | 2013-08-06 05:36:26 +0000 | [diff] [blame] | 655 | return kDtmfParsingError; |
| 656 | } |
| 657 | if (dtmf_buffer_->InsertEvent(event) != DtmfBuffer::kOK) { |
minyue@webrtc.org | 9721db7 | 2013-08-06 05:36:26 +0000 | [diff] [blame] | 658 | return kDtmfInsertError; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 659 | } |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 660 | it = packet_list.erase(it); |
| 661 | } else { |
| 662 | ++it; |
| 663 | } |
| 664 | } |
| 665 | |
ossu | 17e3fa1 | 2016-09-08 04:52:55 -0700 | [diff] [blame] | 666 | // Update bandwidth estimate, if the packet is not comfort noise. |
| 667 | if (!packet_list.empty() && |
ossu | 7a37761 | 2016-10-18 04:06:13 -0700 | [diff] [blame] | 668 | !decoder_database_->IsComfortNoise(main_payload_type)) { |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 669 | // The list can be empty here if we got nothing but DTMF payloads. |
ossu | 7a37761 | 2016-10-18 04:06:13 -0700 | [diff] [blame] | 670 | 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. |
ossu | a73f6c9 | 2016-10-24 08:25:28 -0700 | [diff] [blame] | 673 | 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.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 677 | receive_timestamp); |
| 678 | } |
| 679 | |
ossu | 61a208b | 2016-09-20 01:38:00 -0700 | [diff] [blame] | 680 | PacketList parsed_packet_list; |
| 681 | while (!packet_list.empty()) { |
ossu | a73f6c9 | 2016-10-24 08:25:28 -0700 | [diff] [blame] | 682 | Packet& packet = packet_list.front(); |
ossu | 61a208b | 2016-09-20 01:38:00 -0700 | [diff] [blame] | 683 | const DecoderDatabase::DecoderInfo* info = |
ossu | a73f6c9 | 2016-10-24 08:25:28 -0700 | [diff] [blame] | 684 | decoder_database_->GetDecoderInfo(packet.payload_type); |
ossu | 61a208b | 2016-09-20 01:38:00 -0700 | [diff] [blame] | 685 | 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. |
ossu | a73f6c9 | 2016-10-24 08:25:28 -0700 | [diff] [blame] | 692 | parsed_packet_list.splice(parsed_packet_list.end(), packet_list, |
| 693 | packet_list.begin()); |
ossu | 61a208b | 2016-09-20 01:38:00 -0700 | [diff] [blame] | 694 | } else { |
ossu | a73f6c9 | 2016-10-24 08:25:28 -0700 | [diff] [blame] | 695 | 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 | |
ossu | 61a208b | 2016-09-20 01:38:00 -0700 | [diff] [blame] | 709 | std::vector<AudioDecoder::ParseResult> results = |
ossu | a73f6c9 | 2016-10-24 08:25:28 -0700 | [diff] [blame] | 710 | 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 | } |
ossu | 61a208b | 2016-09-20 01:38:00 -0700 | [diff] [blame] | 728 | } |
ossu | 61a208b | 2016-09-20 01:38:00 -0700 | [diff] [blame] | 729 | } |
| 730 | } |
| 731 | } |
| 732 | |
Ivo Creusen | fd7c0a5 | 2017-10-20 12:35:04 +0200 | [diff] [blame] | 733 | // 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.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 738 | // Insert packets in buffer. |
ossu | a70695a | 2016-09-22 02:06:28 -0700 | [diff] [blame] | 739 | const int ret = packet_buffer_->InsertPacketList( |
ossu | 61a208b | 2016-09-20 01:38:00 -0700 | [diff] [blame] | 740 | &parsed_packet_list, *decoder_database_, ¤t_rtp_payload_type_, |
minyue-webrtc | 12d3084 | 2017-07-19 11:44:06 +0200 | [diff] [blame] | 741 | ¤t_cng_rtp_payload_type_, &stats_); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 742 | if (ret == PacketBuffer::kFlushed) { |
| 743 | // Reset DSP timestamp etc. if packet buffer flushed. |
| 744 | new_codec_ = true; |
turaj@webrtc.org | a6101d7 | 2013-10-01 22:01:09 +0000 | [diff] [blame] | 745 | update_sample_rate_and_channels = true; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 746 | } else if (ret != PacketBuffer::kOK) { |
minyue@webrtc.org | 7bb5436 | 2013-08-06 05:40:57 +0000 | [diff] [blame] | 747 | return kOtherError; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 748 | } |
henrik.lundin@webrtc.org | 6ff3ac1 | 2014-11-20 14:14:49 +0000 | [diff] [blame] | 749 | |
| 750 | if (first_packet_) { |
| 751 | first_packet_ = false; |
| 752 | // Update the codec on the next GetAudio call. |
| 753 | new_codec_ = true; |
| 754 | } |
| 755 | |
henrik.lundin | da8bbf6 | 2016-08-31 03:14:11 -0700 | [diff] [blame] | 756 | 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.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 761 | |
turaj@webrtc.org | a6101d7 | 2013-10-01 22:01:09 +0000 | [diff] [blame] | 762 | 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. |
ossu | 7a37761 | 2016-10-18 04:06:13 -0700 | [diff] [blame] | 769 | const Packet* next_packet = packet_buffer_->PeekNextPacket(); |
| 770 | RTC_DCHECK(next_packet); |
| 771 | const int payload_type = next_packet->payload_type; |
ossu | 97ba30e | 2016-04-25 07:55:58 -0700 | [diff] [blame] | 772 | 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.org | a6101d7 | 2013-10-01 22:01:09 +0000 | [diff] [blame] | 778 | const DecoderDatabase::DecoderInfo* decoder_info = |
| 779 | decoder_database_->GetDecoderInfo(payload_type); |
| 780 | assert(decoder_info); |
kwiberg | c0f2dcf | 2016-05-31 06:28:03 -0700 | [diff] [blame] | 781 | if (decoder_info->SampleRateHz() != fs_hz_ || |
ossu | 97ba30e | 2016-04-25 07:55:58 -0700 | [diff] [blame] | 782 | channels != algorithm_buffer_->Channels()) { |
kwiberg | c0f2dcf | 2016-05-31 06:28:03 -0700 | [diff] [blame] | 783 | SetSampleRateAndChannels(decoder_info->SampleRateHz(), |
| 784 | channels); |
henrik.lundin | 48ed930 | 2015-10-29 05:36:24 -0700 | [diff] [blame] | 785 | } |
| 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.org | a6101d7 | 2013-10-01 22:01:09 +0000 | [diff] [blame] | 791 | } |
| 792 | |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 793 | // TODO(hlundin): Move this code to DelayManager class. |
| 794 | const DecoderDatabase::DecoderInfo* dec_info = |
ossu | 7a37761 | 2016-10-18 04:06:13 -0700 | [diff] [blame] | 795 | decoder_database_->GetDecoderInfo(main_payload_type); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 796 | assert(dec_info); // Already checked that the payload type is known. |
ossu | f1b08da | 2016-09-23 02:19:43 -0700 | [diff] [blame] | 797 | delay_manager_->LastDecodedWasCngOrDtmf(dec_info->IsComfortNoise() || |
| 798 | dec_info->IsDtmf()); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 799 | if (delay_manager_->last_pack_cng_or_dtmf() == 0) { |
| 800 | // Calculate the total speech length carried in each packet. |
Ivo Creusen | fd7c0a5 | 2017-10-20 12:35:04 +0200 | [diff] [blame] | 801 | if (number_of_primary_packets > 0) { |
henrik.lundin | 116c84e | 2015-08-27 13:14:48 -0700 | [diff] [blame] | 802 | const size_t packet_length_samples = |
Ivo Creusen | fd7c0a5 | 2017-10-20 12:35:04 +0200 | [diff] [blame] | 803 | number_of_primary_packets * decoder_frame_length_; |
henrik.lundin | 116c84e | 2015-08-27 13:14:48 -0700 | [diff] [blame] | 804 | if (packet_length_samples != decision_logic_->packet_length_samples()) { |
| 805 | decision_logic_->set_packet_length_samples(packet_length_samples); |
| 806 | delay_manager_->SetPacketAudioLength( |
kwiberg | d3edd77 | 2017-03-01 18:52:48 -0800 | [diff] [blame] | 807 | rtc::dchecked_cast<int>((1000 * packet_length_samples) / fs_hz_)); |
henrik.lundin | 116c84e | 2015-08-27 13:14:48 -0700 | [diff] [blame] | 808 | } |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 809 | } |
| 810 | |
| 811 | // Update statistics. |
ossu | 7a37761 | 2016-10-18 04:06:13 -0700 | [diff] [blame] | 812 | if ((int32_t)(main_timestamp - timestamp_) >= 0 && !new_codec_) { |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 813 | // Only update statistics if incoming packet is not older than last played |
| 814 | // out packet, and if new codec flag is not set. |
ossu | 7a37761 | 2016-10-18 04:06:13 -0700 | [diff] [blame] | 815 | delay_manager_->Update(main_sequence_number, main_timestamp, fs_hz_); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 816 | } |
| 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.lundin | 7a92681 | 2016-05-12 13:51:28 -0700 | [diff] [blame] | 827 | int NetEqImpl::GetAudioInternal(AudioFrame* audio_frame, bool* muted) { |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 828 | PacketList packet_list; |
| 829 | DtmfEvent dtmf_event; |
| 830 | Operations operation; |
| 831 | bool play_dtmf; |
henrik.lundin | 7a92681 | 2016-05-12 13:51:28 -0700 | [diff] [blame] | 832 | *muted = false; |
henrik.lundin | 114c1b3 | 2017-04-26 07:47:32 -0700 | [diff] [blame] | 833 | last_decoded_timestamps_.clear(); |
henrik.lundin | ed49721 | 2016-04-25 10:11:38 -0700 | [diff] [blame] | 834 | tick_timer_->Increment(); |
henrik.lundin | 60f6ce2 | 2016-05-10 03:52:04 -0700 | [diff] [blame] | 835 | stats_.IncreaseCounter(output_size_samples_, fs_hz_); |
henrik.lundin | 7a92681 | 2016-05-12 13:51:28 -0700 | [diff] [blame] | 836 | |
| 837 | // Check for muted state. |
| 838 | if (enable_muted_state_ && expand_->Muted() && packet_buffer_->Empty()) { |
| 839 | RTC_DCHECK_EQ(last_mode_, kModeExpand); |
henrik.lundin | a449107 | 2017-07-06 05:23:53 -0700 | [diff] [blame] | 840 | audio_frame->Reset(); |
| 841 | RTC_DCHECK(audio_frame->muted()); // Reset() should mute the frame. |
henrik.lundin | 7a92681 | 2016-05-12 13:51:28 -0700 | [diff] [blame] | 842 | 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 Ullberg | 9a2e906 | 2017-09-18 09:28:20 +0200 | [diff] [blame] | 851 | stats_.ExpandedNoiseSamples(output_size_samples_, false); |
henrik.lundin | 7a92681 | 2016-05-12 13:51:28 -0700 | [diff] [blame] | 852 | *muted = true; |
| 853 | return 0; |
| 854 | } |
| 855 | |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 856 | int return_value = GetDecision(&operation, &packet_list, &dtmf_event, |
| 857 | &play_dtmf); |
| 858 | if (return_value != 0) { |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 859 | last_mode_ = kModeError; |
| 860 | return return_value; |
| 861 | } |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 862 | |
| 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.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 868 | assert(vad_.get()); |
| 869 | bool sid_frame_available = |
| 870 | (operation == kRfc3389Cng && !packet_list.empty()); |
Peter Kasting | dce40cf | 2015-08-24 14:52:23 -0700 | [diff] [blame] | 871 | vad_->Update(decoded_buffer_.get(), static_cast<size_t>(length), speech_type, |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 872 | sid_frame_available, fs_hz_); |
| 873 | |
henrik.lundin | b1fb72b | 2016-05-03 08:18:47 -0700 | [diff] [blame] | 874 | 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.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 879 | algorithm_buffer_->Clear(); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 880 | switch (operation) { |
| 881 | case kNormal: { |
henrik.lundin@webrtc.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 882 | DoNormal(decoded_buffer_.get(), length, speech_type, play_dtmf); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 883 | break; |
| 884 | } |
| 885 | case kMerge: { |
henrik.lundin@webrtc.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 886 | DoMerge(decoded_buffer_.get(), length, speech_type, play_dtmf); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 887 | break; |
| 888 | } |
| 889 | case kExpand: { |
henrik.lundin@webrtc.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 890 | return_value = DoExpand(play_dtmf); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 891 | break; |
| 892 | } |
Henrik Lundin | cf808d2 | 2015-05-27 14:33:29 +0200 | [diff] [blame] | 893 | case kAccelerate: |
| 894 | case kFastAccelerate: { |
| 895 | const bool fast_accelerate = |
| 896 | enable_fast_accelerate_ && (operation == kFastAccelerate); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 897 | return_value = DoAccelerate(decoded_buffer_.get(), length, speech_type, |
Henrik Lundin | cf808d2 | 2015-05-27 14:33:29 +0200 | [diff] [blame] | 898 | play_dtmf, fast_accelerate); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 899 | break; |
| 900 | } |
| 901 | case kPreemptiveExpand: { |
| 902 | return_value = DoPreemptiveExpand(decoded_buffer_.get(), length, |
henrik.lundin@webrtc.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 903 | speech_type, play_dtmf); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 904 | break; |
| 905 | } |
| 906 | case kRfc3389Cng: |
| 907 | case kRfc3389CngNoPacket: { |
henrik.lundin@webrtc.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 908 | return_value = DoRfc3389Cng(&packet_list, play_dtmf); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 909 | 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. |
minyuel | 6d92bf5 | 2015-09-23 15:20:39 +0200 | [diff] [blame] | 915 | DoCodecInternalCng(decoded_buffer_.get(), length); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 916 | break; |
| 917 | } |
| 918 | case kDtmf: { |
| 919 | // TODO(hlundin): Write test for this. |
henrik.lundin@webrtc.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 920 | return_value = DoDtmf(dtmf_event, &play_dtmf); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 921 | break; |
| 922 | } |
| 923 | case kAlternativePlc: { |
| 924 | // TODO(hlundin): Write test for this. |
henrik.lundin@webrtc.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 925 | DoAlternativePlc(false); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 926 | break; |
| 927 | } |
| 928 | case kAlternativePlcIncreaseTimestamp: { |
| 929 | // TODO(hlundin): Write test for this. |
henrik.lundin@webrtc.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 930 | DoAlternativePlc(true); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 931 | break; |
| 932 | } |
| 933 | case kAudioRepetitionIncreaseTimestamp: { |
| 934 | // TODO(hlundin): Write test for this. |
Peter Kasting | b7e5054 | 2015-06-11 12:55:50 -0700 | [diff] [blame] | 935 | sync_buffer_->IncreaseEndTimestamp( |
| 936 | static_cast<uint32_t>(output_size_samples_)); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 937 | // Skipping break on purpose. Execution should move on into the |
| 938 | // next case. |
kjellander | bdf3072 | 2017-09-08 11:00:21 -0700 | [diff] [blame] | 939 | FALLTHROUGH(); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 940 | } |
| 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.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 945 | algorithm_buffer_->PushBackFromIndex( |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 946 | *sync_buffer_, sync_buffer_->Size() - output_size_samples_); |
| 947 | expand_->Reset(); |
| 948 | break; |
| 949 | } |
| 950 | case kUndefined: { |
Henrik Lundin | d67a219 | 2015-08-03 12:54:37 +0200 | [diff] [blame] | 951 | LOG(LS_ERROR) << "Invalid operation kUndefined."; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 952 | assert(false); // This should not happen. |
| 953 | last_mode_ = kModeError; |
| 954 | return kInvalidOperation; |
| 955 | } |
| 956 | } // End of switch. |
minyue | 5bd3397 | 2016-05-02 04:46:11 -0700 | [diff] [blame] | 957 | last_operation_ = operation; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 958 | 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.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 967 | sync_buffer_->PushBack(*algorithm_buffer_); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 968 | |
| 969 | // Extract data from |sync_buffer_| to |output|. |
turaj@webrtc.org | 362a55e | 2013-09-20 16:25:28 +0000 | [diff] [blame] | 970 | size_t num_output_samples_per_channel = output_size_samples_; |
| 971 | size_t num_output_samples = output_size_samples_ * sync_buffer_->Channels(); |
henrik.lundin | 6d8e011 | 2016-03-04 10:34:21 -0800 | [diff] [blame] | 972 | 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.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 980 | } |
henrik.lundin | 6d8e011 | 2016-03-04 10:34:21 -0800 | [diff] [blame] | 981 | sync_buffer_->GetNextAudioInterleaved(num_output_samples_per_channel, |
| 982 | audio_frame); |
| 983 | audio_frame->sample_rate_hz_ = fs_hz_; |
Henrik Lundin | 05f71fc | 2015-09-01 11:51:58 +0200 | [diff] [blame] | 984 | 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(); |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 990 | RTC_DCHECK_GE(sync_buffer_->next_index(), missing_lookahead_samples); |
Henrik Lundin | 05f71fc | 2015-09-01 11:51:58 +0200 | [diff] [blame] | 991 | sync_buffer_->set_next_index(sync_buffer_->next_index() - |
| 992 | missing_lookahead_samples); |
| 993 | } |
henrik.lundin | 6d8e011 | 2016-03-04 10:34:21 -0800 | [diff] [blame] | 994 | 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 Lundin | d67a219 | 2015-08-03 12:54:37 +0200 | [diff] [blame] | 997 | << ") != output_size_samples_ (" << output_size_samples_ |
| 998 | << ")"; |
minyue@webrtc.org | db1cefc | 2013-08-13 01:39:21 +0000 | [diff] [blame] | 999 | // TODO(minyue): treatment of under-run, filling zeros |
yujo | 36b1a5f | 2017-06-12 12:45:32 -0700 | [diff] [blame] | 1000 | audio_frame->Mute(); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1001 | return kSampleUnderrun; |
| 1002 | } |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1003 | |
| 1004 | // Should always have overlap samples left in the |sync_buffer_|. |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 1005 | RTC_DCHECK_GE(sync_buffer_->FutureLength(), expand_->overlap_length()); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1006 | |
yujo | 36b1a5f | 2017-06-12 12:45:32 -0700 | [diff] [blame] | 1007 | // TODO(yujo): For muted frames, this can be a copy rather than an addition. |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1008 | if (play_dtmf) { |
yujo | 36b1a5f | 2017-06-12 12:45:32 -0700 | [diff] [blame] | 1009 | return_value = DtmfOverdub(dtmf_event, sync_buffer_->Channels(), |
| 1010 | audio_frame->mutable_data()); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1011 | } |
| 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.org | ed865b5 | 2014-03-06 10:28:07 +0000 | [diff] [blame] | 1030 | 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.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1034 | uint32_t temp_timestamp = sync_buffer_->end_timestamp() - |
turaj@webrtc.org | 362a55e | 2013-09-20 16:25:28 +0000 | [diff] [blame] | 1035 | static_cast<uint32_t>(sync_buffer_->FutureLength()); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1036 | 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 Kasting | b7e5054 | 2015-06-11 12:55:50 -0700 | [diff] [blame] | 1041 | playout_timestamp_ += static_cast<uint32_t>(output_size_samples_); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1042 | } |
henrik.lundin | 15c51e3 | 2016-04-06 08:38:56 -0700 | [diff] [blame] | 1043 | // 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.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1052 | |
henrik.lundin | b1fb72b | 2016-05-03 08:18:47 -0700 | [diff] [blame] | 1053 | if (!(last_mode_ == kModeRfc3389Cng || |
| 1054 | last_mode_ == kModeCodecInternalCng || |
| 1055 | last_mode_ == kModeExpand)) { |
| 1056 | generated_noise_stopwatch_.reset(); |
| 1057 | } |
| 1058 | |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1059 | if (decode_return_value) return decode_return_value; |
| 1060 | return return_value; |
| 1061 | } |
| 1062 | |
| 1063 | int 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.org | 0d5da25 | 2013-09-18 21:12:38 +0000 | [diff] [blame] | 1071 | assert(sync_buffer_.get()); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1072 | uint32_t end_timestamp = sync_buffer_->end_timestamp(); |
henrik.lundin@webrtc.org | 52b42cb | 2014-11-04 14:03:58 +0000 | [diff] [blame] | 1073 | if (!new_codec_) { |
| 1074 | const uint32_t five_seconds_samples = 5 * fs_hz_; |
minyue-webrtc | fae474c | 2017-07-05 11:17:40 +0200 | [diff] [blame] | 1075 | packet_buffer_->DiscardOldPackets(end_timestamp, five_seconds_samples, |
| 1076 | &stats_); |
henrik.lundin@webrtc.org | 52b42cb | 2014-11-04 14:03:58 +0000 | [diff] [blame] | 1077 | } |
ossu | 7a37761 | 2016-10-18 04:06:13 -0700 | [diff] [blame] | 1078 | const Packet* packet = packet_buffer_->PeekNextPacket(); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1079 | |
henrik.lundin | b1fb72b | 2016-05-03 08:18:47 -0700 | [diff] [blame] | 1080 | 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.org | ca8cb95 | 2014-03-12 10:26:52 +0000 | [diff] [blame] | 1089 | if (decision_logic_->CngRfc3389On() || last_mode_ == kModeRfc3389Cng) { |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1090 | // 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. |
ossu | 7a37761 | 2016-10-18 04:06:13 -0700 | [diff] [blame] | 1093 | while (packet && decoder_database_->IsComfortNoise(packet->payload_type) && |
| 1094 | (end_timestamp >= packet->timestamp || |
| 1095 | end_timestamp + generated_noise_samples > packet->timestamp)) { |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1096 | // Don't use this packet, discard it. |
minyue-webrtc | fae474c | 2017-07-05 11:17:40 +0200 | [diff] [blame] | 1097 | if (packet_buffer_->DiscardNextPacket(&stats_) != PacketBuffer::kOK) { |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1098 | assert(false); // Must be ok by design. |
| 1099 | } |
| 1100 | // Check buffer again. |
| 1101 | if (!new_codec_) { |
minyue-webrtc | fae474c | 2017-07-05 11:17:40 +0200 | [diff] [blame] | 1102 | packet_buffer_->DiscardOldPackets(end_timestamp, 5 * fs_hz_, &stats_); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1103 | } |
ossu | 7a37761 | 2016-10-18 04:06:13 -0700 | [diff] [blame] | 1104 | packet = packet_buffer_->PeekNextPacket(); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1105 | } |
| 1106 | } |
| 1107 | |
henrik.lundin@webrtc.org | 0d5da25 | 2013-09-18 21:12:38 +0000 | [diff] [blame] | 1108 | assert(expand_.get()); |
turaj@webrtc.org | 362a55e | 2013-09-20 16:25:28 +0000 | [diff] [blame] | 1109 | const int samples_left = static_cast<int>(sync_buffer_->FutureLength() - |
| 1110 | expand_->overlap_length()); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1111 | 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 Kasting | dce40cf | 2015-08-24 14:52:23 -0700 | [diff] [blame] | 1116 | decision_logic_->AddSampleMemory( |
kwiberg | d3edd77 | 2017-03-01 18:52:48 -0800 | [diff] [blame] | 1117 | -(samples_left + rtc::dchecked_cast<int>(output_size_samples_))); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1118 | } |
| 1119 | |
| 1120 | // Check if it is time to play a DTMF event. |
Peter Kasting | b7e5054 | 2015-06-11 12:55:50 -0700 | [diff] [blame] | 1121 | if (dtmf_buffer_->GetEvent( |
| 1122 | static_cast<uint32_t>( |
henrik.lundin | b1fb72b | 2016-05-03 08:18:47 -0700 | [diff] [blame] | 1123 | end_timestamp + generated_noise_samples), |
Peter Kasting | b7e5054 | 2015-06-11 12:55:50 -0700 | [diff] [blame] | 1124 | dtmf_event)) { |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1125 | *play_dtmf = true; |
| 1126 | } |
| 1127 | |
| 1128 | // Get instruction. |
henrik.lundin@webrtc.org | 0d5da25 | 2013-09-18 21:12:38 +0000 | [diff] [blame] | 1129 | assert(sync_buffer_.get()); |
| 1130 | assert(expand_.get()); |
henrik.lundin | b1fb72b | 2016-05-03 08:18:47 -0700 | [diff] [blame] | 1131 | 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( |
ossu | 7a37761 | 2016-10-18 04:06:13 -0700 | [diff] [blame] | 1137 | *sync_buffer_, *expand_, decoder_frame_length_, packet, last_mode_, |
henrik.lundin | b1fb72b | 2016-05-03 08:18:47 -0700 | [diff] [blame] | 1138 | *play_dtmf, generated_noise_samples, &reset_decoder_); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1139 | |
| 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. |
kwiberg | d3edd77 | 2017-03-01 18:52:48 -0800 | [diff] [blame] | 1143 | if (samples_left >= rtc::dchecked_cast<int>(output_size_samples_) && |
| 1144 | *operation != kMerge && *operation != kAccelerate && |
| 1145 | *operation != kFastAccelerate && *operation != kPreemptiveExpand) { |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1146 | *operation = kNormal; |
| 1147 | return 0; |
| 1148 | } |
| 1149 | |
turaj@webrtc.org | 8d1cdaa | 2014-04-11 18:47:55 +0000 | [diff] [blame] | 1150 | decision_logic_->ExpandDecision(*operation); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1151 | |
| 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_); |
ossu | 7a37761 | 2016-10-18 04:06:13 -0700 | [diff] [blame] | 1156 | if (*play_dtmf && !packet) { |
turaj@webrtc.org | 4d06db5 | 2013-03-27 18:31:42 +0000 | [diff] [blame] | 1157 | timestamp_ = dtmf_event->timestamp; |
| 1158 | } else { |
ossu | 7a37761 | 2016-10-18 04:06:13 -0700 | [diff] [blame] | 1159 | if (!packet) { |
Henrik Lundin | d67a219 | 2015-08-03 12:54:37 +0200 | [diff] [blame] | 1160 | LOG(LS_ERROR) << "Packet missing where it shouldn't."; |
turaj@webrtc.org | 4d06db5 | 2013-03-27 18:31:42 +0000 | [diff] [blame] | 1161 | return -1; |
| 1162 | } |
ossu | 7a37761 | 2016-10-18 04:06:13 -0700 | [diff] [blame] | 1163 | timestamp_ = packet->timestamp; |
ossu | 108ecec | 2016-07-08 08:45:18 -0700 | [diff] [blame] | 1164 | if (*operation == kRfc3389CngNoPacket && |
ossu | 7a37761 | 2016-10-18 04:06:13 -0700 | [diff] [blame] | 1165 | decoder_database_->IsComfortNoise(packet->payload_type)) { |
turaj@webrtc.org | 4d06db5 | 2013-03-27 18:31:42 +0000 | [diff] [blame] | 1166 | // 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.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1172 | } |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1173 | // Adjust |sync_buffer_| timestamp before setting |end_timestamp| to the |
| 1174 | // new value. |
| 1175 | sync_buffer_->IncreaseEndTimestamp(timestamp_ - end_timestamp); |
turaj@webrtc.org | 4d06db5 | 2013-03-27 18:31:42 +0000 | [diff] [blame] | 1176 | end_timestamp = timestamp_; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1177 | new_codec_ = false; |
| 1178 | decision_logic_->SoftReset(); |
| 1179 | buffer_level_filter_->Reset(); |
| 1180 | delay_manager_->Reset(); |
| 1181 | stats_.ResetMcu(); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1182 | } |
| 1183 | |
Peter Kasting | dce40cf | 2015-08-24 14:52:23 -0700 | [diff] [blame] | 1184 | 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.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1188 | |
| 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.lundin | b1fb72b | 2016-05-03 08:18:47 -0700 | [diff] [blame] | 1202 | 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.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1209 | // Make a jump in timestamp due to the recently played comfort noise. |
Peter Kasting | b7e5054 | 2015-06-11 12:55:50 -0700 | [diff] [blame] | 1210 | uint32_t timestamp_jump = |
henrik.lundin | b1fb72b | 2016-05-03 08:18:47 -0700 | [diff] [blame] | 1211 | static_cast<uint32_t>(generated_noise_samples); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1212 | sync_buffer_->IncreaseEndTimestamp(timestamp_jump); |
| 1213 | timestamp_ += timestamp_jump; |
| 1214 | } |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1215 | return 0; |
| 1216 | } |
Henrik Lundin | cf808d2 | 2015-05-27 14:33:29 +0200 | [diff] [blame] | 1217 | case kAccelerate: |
| 1218 | case kFastAccelerate: { |
| 1219 | // In order to do an accelerate we need at least 30 ms of audio data. |
Peter Kasting | dce40cf | 2015-08-24 14:52:23 -0700 | [diff] [blame] | 1220 | if (samples_left >= static_cast<int>(samples_30_ms)) { |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1221 | // 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 Kasting | dce40cf | 2015-08-24 14:52:23 -0700 | [diff] [blame] | 1225 | } else if (samples_left >= static_cast<int>(samples_10_ms) && |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1226 | 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 Kasting | dce40cf | 2015-08-24 14:52:23 -0700 | [diff] [blame] | 1230 | } else if (samples_left < static_cast<int>(samples_20_ms) && |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1231 | 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 Kasting | dce40cf | 2015-08-24 14:52:23 -0700 | [diff] [blame] | 1248 | if ((samples_left >= static_cast<int>(samples_30_ms)) || |
| 1249 | (samples_left >= static_cast<int>(samples_10_ms) && |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1250 | 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 Kasting | dce40cf | 2015-08-24 14:52:23 -0700 | [diff] [blame] | 1258 | if (samples_left < static_cast<int>(samples_20_ms) && |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1259 | 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.org | 8d1cdaa | 2014-04-11 18:47:55 +0000 | [diff] [blame] | 1267 | case kMerge: { |
| 1268 | required_samples = |
| 1269 | std::max(merge_->RequiredFutureSamples(), required_samples); |
| 1270 | break; |
| 1271 | } |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1272 | default: { |
| 1273 | // Do nothing. |
| 1274 | } |
| 1275 | } |
| 1276 | |
| 1277 | // Get packets from buffer. |
| 1278 | int extracted_samples = 0; |
ossu | 7a37761 | 2016-10-18 04:06:13 -0700 | [diff] [blame] | 1279 | if (packet && *operation != kAlternativePlc && |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1280 | *operation != kAlternativePlcIncreaseTimestamp && |
| 1281 | *operation != kAudioRepetition && |
| 1282 | *operation != kAudioRepetitionIncreaseTimestamp) { |
ossu | 7a37761 | 2016-10-18 04:06:13 -0700 | [diff] [blame] | 1283 | sync_buffer_->IncreaseEndTimestamp(packet->timestamp - end_timestamp); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1284 | 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. |
ossu | 7a37761 | 2016-10-18 04:06:13 -0700 | [diff] [blame] | 1289 | stats_.LostSamples(packet->timestamp - end_timestamp); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1290 | } |
| 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.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1296 | |
| 1297 | extracted_samples = ExtractPackets(required_samples, packet_list); |
| 1298 | if (extracted_samples < 0) { |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1299 | return kPacketBufferCorruption; |
| 1300 | } |
| 1301 | } |
| 1302 | |
Henrik Lundin | cf808d2 | 2015-05-27 14:33:29 +0200 | [diff] [blame] | 1303 | if (*operation == kAccelerate || *operation == kFastAccelerate || |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1304 | *operation == kPreemptiveExpand) { |
| 1305 | decision_logic_->set_sample_memory(samples_left + extracted_samples); |
| 1306 | decision_logic_->set_prev_time_scale(true); |
| 1307 | } |
| 1308 | |
Henrik Lundin | cf808d2 | 2015-05-27 14:33:29 +0200 | [diff] [blame] | 1309 | if (*operation == kAccelerate || *operation == kFastAccelerate) { |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1310 | // Check that we have enough data (30ms) to do accelerate. |
Peter Kasting | dce40cf | 2015-08-24 14:52:23 -0700 | [diff] [blame] | 1311 | if (extracted_samples + samples_left < static_cast<int>(samples_30_ms)) { |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1312 | // 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 | |
| 1322 | int NetEqImpl::Decode(PacketList* packet_list, Operations* operation, |
| 1323 | int* decoded_length, |
| 1324 | AudioDecoder::SpeechType* speech_type) { |
| 1325 | *speech_type = AudioDecoder::kSpeech; |
minyuel | 6d92bf5 | 2015-09-23 15:20:39 +0200 | [diff] [blame] | 1326 | |
| 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.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1331 | if (!packet_list->empty()) { |
ossu | a73f6c9 | 2016-10-24 08:25:28 -0700 | [diff] [blame] | 1332 | const Packet& packet = packet_list->front(); |
| 1333 | uint8_t payload_type = packet.payload_type; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1334 | if (!decoder_database_->IsComfortNoise(payload_type)) { |
| 1335 | decoder = decoder_database_->GetDecoder(payload_type); |
| 1336 | assert(decoder); |
| 1337 | if (!decoder) { |
Henrik Lundin | d67a219 | 2015-08-03 12:54:37 +0200 | [diff] [blame] | 1338 | LOG(LS_WARNING) << "Unknown payload type " |
| 1339 | << static_cast<int>(payload_type); |
ossu | a73f6c9 | 2016-10-24 08:25:28 -0700 | [diff] [blame] | 1340 | packet_list->clear(); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1341 | 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 Lundin | d67a219 | 2015-08-03 12:54:37 +0200 | [diff] [blame] | 1351 | LOG(LS_WARNING) << "Unknown payload type " |
| 1352 | << static_cast<int>(payload_type); |
ossu | a73f6c9 | 2016-10-24 08:25:28 -0700 | [diff] [blame] | 1353 | packet_list->clear(); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1354 | return kDecoderNotFound; |
| 1355 | } |
tina.legrand@webrtc.org | ba5a6c3 | 2014-03-23 09:58:48 +0000 | [diff] [blame] | 1356 | // If sampling rate or number of channels has changed, we need to make |
| 1357 | // a reset. |
kwiberg | c0f2dcf | 2016-05-31 06:28:03 -0700 | [diff] [blame] | 1358 | if (decoder_info->SampleRateHz() != fs_hz_ || |
henrik.lundin@webrtc.org | 6dba1eb | 2015-03-18 09:47:08 +0000 | [diff] [blame] | 1359 | decoder->Channels() != algorithm_buffer_->Channels()) { |
tina.legrand@webrtc.org | ba5a6c3 | 2014-03-23 09:58:48 +0000 | [diff] [blame] | 1360 | // TODO(tlegrand): Add unittest to cover this event. |
kwiberg | c0f2dcf | 2016-05-31 06:28:03 -0700 | [diff] [blame] | 1361 | SetSampleRateAndChannels(decoder_info->SampleRateHz(), |
| 1362 | decoder->Channels()); |
turaj@webrtc.org | a6101d7 | 2013-10-01 22:01:09 +0000 | [diff] [blame] | 1363 | } |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1364 | 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 Wiberg | 4376648 | 2015-08-27 15:22:11 +0200 | [diff] [blame] | 1372 | if (decoder) |
| 1373 | decoder->Reset(); |
| 1374 | |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1375 | // Reset comfort noise decoder. |
ossu | 97ba30e | 2016-04-25 07:55:58 -0700 | [diff] [blame] | 1376 | ComfortNoiseDecoder* cng_decoder = decoder_database_->GetActiveCngDecoder(); |
Karl Wiberg | 4376648 | 2015-08-27 15:22:11 +0200 | [diff] [blame] | 1377 | if (cng_decoder) |
| 1378 | cng_decoder->Reset(); |
| 1379 | |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1380 | reset_decoder_ = false; |
| 1381 | } |
| 1382 | |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1383 | *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 | |
minyuel | 6d92bf5 | 2015-09-23 15:20:39 +0200 | [diff] [blame] | 1389 | 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.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1397 | |
| 1398 | if (*decoded_length < 0) { |
| 1399 | // Error returned from the decoder. |
| 1400 | *decoded_length = 0; |
Peter Kasting | b7e5054 | 2015-06-11 12:55:50 -0700 | [diff] [blame] | 1401 | sync_buffer_->IncreaseEndTimestamp( |
| 1402 | static_cast<uint32_t>(decoder_frame_length_)); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1403 | 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.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1408 | return_value = kDecoderErrorCode; |
Henrik Lundin | d67a219 | 2015-08-03 12:54:37 +0200 | [diff] [blame] | 1409 | LOG(LS_WARNING) << "Decoder returned error code: " << error_code; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1410 | } else { |
| 1411 | // Decoder does not implement error codes. Return generic error. |
| 1412 | return_value = kOtherDecoderError; |
Henrik Lundin | d67a219 | 2015-08-03 12:54:37 +0200 | [diff] [blame] | 1413 | LOG(LS_WARNING) << "Decoder error (no error code)"; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1414 | } |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1415 | *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.org | 6dba1eb | 2015-03-18 09:47:08 +0000 | [diff] [blame] | 1422 | (decoder && decoder->Channels() == sync_buffer_->Channels())); |
turaj@webrtc.org | 362a55e | 2013-09-20 16:25:28 +0000 | [diff] [blame] | 1423 | sync_buffer_->IncreaseEndTimestamp( |
| 1424 | *decoded_length / static_cast<int>(sync_buffer_->Channels())); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1425 | } |
| 1426 | return return_value; |
| 1427 | } |
| 1428 | |
minyuel | 6d92bf5 | 2015-09-23 15:20:39 +0200 | [diff] [blame] | 1429 | int 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 | |
kwiberg | d3edd77 | 2017-03-01 18:52:48 -0800 | [diff] [blame] | 1437 | while (*decoded_length < rtc::dchecked_cast<int>(output_size_samples_)) { |
minyuel | 6d92bf5 | 2015-09-23 15:20:39 +0200 | [diff] [blame] | 1438 | 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; |
minyuel | 6d92bf5 | 2015-09-23 15:20:39 +0200 | [diff] [blame] | 1444 | } 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 | |
| 1459 | int NetEqImpl::DecodeLoop(PacketList* packet_list, const Operations& operation, |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1460 | AudioDecoder* decoder, int* decoded_length, |
| 1461 | AudioDecoder::SpeechType* speech_type) { |
henrik.lundin | 114c1b3 | 2017-04-26 07:47:32 -0700 | [diff] [blame] | 1462 | RTC_DCHECK(last_decoded_timestamps_.empty()); |
| 1463 | |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1464 | // Do decoding. |
ossu | a73f6c9 | 2016-10-24 08:25:28 -0700 | [diff] [blame] | 1465 | while ( |
| 1466 | !packet_list->empty() && |
| 1467 | !decoder_database_->IsComfortNoise(packet_list->front().payload_type)) { |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1468 | 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.org | 6dba1eb | 2015-03-18 09:47:08 +0000 | [diff] [blame] | 1471 | assert(sync_buffer_->Channels() == decoder->Channels()); |
| 1472 | assert(decoded_buffer_length_ >= kMaxFrameSize * decoder->Channels()); |
minyuel | 6d92bf5 | 2015-09-23 15:20:39 +0200 | [diff] [blame] | 1473 | assert(operation == kNormal || operation == kAccelerate || |
| 1474 | operation == kFastAccelerate || operation == kMerge || |
| 1475 | operation == kPreemptiveExpand); |
ossu | a73f6c9 | 2016-10-24 08:25:28 -0700 | [diff] [blame] | 1476 | |
| 1477 | auto opt_result = packet_list->front().frame->Decode( |
ossu | 61a208b | 2016-09-20 01:38:00 -0700 | [diff] [blame] | 1478 | rtc::ArrayView<int16_t>(&decoded_buffer_[*decoded_length], |
| 1479 | decoded_buffer_length_ - *decoded_length)); |
henrik.lundin | 114c1b3 | 2017-04-26 07:47:32 -0700 | [diff] [blame] | 1480 | last_decoded_timestamps_.push_back(packet_list->front().timestamp); |
ossu | a73f6c9 | 2016-10-24 08:25:28 -0700 | [diff] [blame] | 1481 | packet_list->pop_front(); |
ossu | 61a208b | 2016-09-20 01:38:00 -0700 | [diff] [blame] | 1482 | if (opt_result) { |
| 1483 | const auto& result = *opt_result; |
| 1484 | *speech_type = result.speech_type; |
| 1485 | if (result.num_decoded_samples > 0) { |
kwiberg | d3edd77 | 2017-03-01 18:52:48 -0800 | [diff] [blame] | 1486 | *decoded_length += rtc::dchecked_cast<int>(result.num_decoded_samples); |
ossu | 61a208b | 2016-09-20 01:38:00 -0700 | [diff] [blame] | 1487 | // 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.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1492 | // Error. |
ossu | 61a208b | 2016-09-20 01:38:00 -0700 | [diff] [blame] | 1493 | // TODO(ossu): What to put here? |
| 1494 | LOG(LS_WARNING) << "Decode error"; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1495 | *decoded_length = -1; |
ossu | a73f6c9 | 2016-10-24 08:25:28 -0700 | [diff] [blame] | 1496 | packet_list->clear(); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1497 | break; |
| 1498 | } |
kwiberg | d3edd77 | 2017-03-01 18:52:48 -0800 | [diff] [blame] | 1499 | if (*decoded_length > rtc::dchecked_cast<int>(decoded_buffer_length_)) { |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1500 | // Guard against overflow. |
Henrik Lundin | d67a219 | 2015-08-03 12:54:37 +0200 | [diff] [blame] | 1501 | LOG(LS_WARNING) << "Decoded too much."; |
ossu | a73f6c9 | 2016-10-24 08:25:28 -0700 | [diff] [blame] | 1502 | packet_list->clear(); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1503 | return kDecodedTooMuch; |
| 1504 | } |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1505 | } // End of decode loop. |
| 1506 | |
turaj@webrtc.org | 58cd316 | 2013-10-31 15:15:55 +0000 | [diff] [blame] | 1507 | // 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. |
ossu | a73f6c9 | 2016-10-24 08:25:28 -0700 | [diff] [blame] | 1509 | 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.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1513 | return 0; |
| 1514 | } |
| 1515 | |
| 1516 | void NetEqImpl::DoNormal(const int16_t* decoded_buffer, size_t decoded_length, |
henrik.lundin@webrtc.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 1517 | AudioDecoder::SpeechType speech_type, bool play_dtmf) { |
henrik.lundin@webrtc.org | 40d3fc6 | 2013-09-18 12:19:50 +0000 | [diff] [blame] | 1518 | assert(normal_.get()); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1519 | assert(mute_factor_array_.get()); |
henrik.lundin@webrtc.org | 40d3fc6 | 2013-09-18 12:19:50 +0000 | [diff] [blame] | 1520 | normal_->Process(decoded_buffer, decoded_length, last_mode_, |
henrik.lundin@webrtc.org | 0d5da25 | 2013-09-18 21:12:38 +0000 | [diff] [blame] | 1521 | mute_factor_array_.get(), algorithm_buffer_.get()); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1522 | 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 | |
| 1539 | void NetEqImpl::DoMerge(int16_t* decoded_buffer, size_t decoded_length, |
henrik.lundin@webrtc.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 1540 | AudioDecoder::SpeechType speech_type, bool play_dtmf) { |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1541 | assert(mute_factor_array_.get()); |
henrik.lundin@webrtc.org | 40d3fc6 | 2013-09-18 12:19:50 +0000 | [diff] [blame] | 1542 | assert(merge_.get()); |
Peter Kasting | dce40cf | 2015-08-24 14:52:23 -0700 | [diff] [blame] | 1543 | size_t new_length = merge_->Process(decoded_buffer, decoded_length, |
| 1544 | mute_factor_array_.get(), |
| 1545 | algorithm_buffer_.get()); |
henrik.lundin | 2979f55 | 2017-05-05 05:04:16 -0700 | [diff] [blame] | 1546 | // 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.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1550 | |
| 1551 | // Update in-call and post-call statistics. |
| 1552 | if (expand_->MuteFactor(0) == 0) { |
| 1553 | // Expand generates only noise. |
henrik.lundin | 2979f55 | 2017-05-05 05:04:16 -0700 | [diff] [blame] | 1554 | stats_.ExpandedNoiseSamplesCorrection(expand_length_correction); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1555 | } else { |
| 1556 | // Expansion generates more than only noise. |
henrik.lundin | 2979f55 | 2017-05-05 05:04:16 -0700 | [diff] [blame] | 1557 | stats_.ExpandedVoiceSamplesCorrection(expand_length_correction); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1558 | } |
| 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.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 1571 | int NetEqImpl::DoExpand(bool play_dtmf) { |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1572 | while ((sync_buffer_->FutureLength() - expand_->overlap_length()) < |
Peter Kasting | dce40cf | 2015-08-24 14:52:23 -0700 | [diff] [blame] | 1573 | output_size_samples_) { |
henrik.lundin@webrtc.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 1574 | algorithm_buffer_->Clear(); |
henrik.lundin@webrtc.org | 0d5da25 | 2013-09-18 21:12:38 +0000 | [diff] [blame] | 1575 | int return_value = expand_->Process(algorithm_buffer_.get()); |
Peter Kasting | dce40cf | 2015-08-24 14:52:23 -0700 | [diff] [blame] | 1576 | size_t length = algorithm_buffer_->Size(); |
Gustaf Ullberg | 9a2e906 | 2017-09-18 09:28:20 +0200 | [diff] [blame] | 1577 | bool is_new_concealment_event = (last_mode_ != kModeExpand); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1578 | |
| 1579 | // Update in-call and post-call statistics. |
| 1580 | if (expand_->MuteFactor(0) == 0) { |
| 1581 | // Expand operation generates only noise. |
Gustaf Ullberg | 9a2e906 | 2017-09-18 09:28:20 +0200 | [diff] [blame] | 1582 | stats_.ExpandedNoiseSamples(length, is_new_concealment_event); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1583 | } else { |
| 1584 | // Expand operation generates more than only noise. |
Gustaf Ullberg | 9a2e906 | 2017-09-18 09:28:20 +0200 | [diff] [blame] | 1585 | stats_.ExpandedVoiceSamples(length, is_new_concealment_event); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1586 | } |
| 1587 | |
| 1588 | last_mode_ = kModeExpand; |
| 1589 | |
| 1590 | if (return_value < 0) { |
| 1591 | return return_value; |
| 1592 | } |
| 1593 | |
henrik.lundin@webrtc.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 1594 | sync_buffer_->PushBack(*algorithm_buffer_); |
| 1595 | algorithm_buffer_->Clear(); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1596 | } |
| 1597 | if (!play_dtmf) { |
| 1598 | dtmf_tone_generator_->Reset(); |
| 1599 | } |
henrik.lundin | b1fb72b | 2016-05-03 08:18:47 -0700 | [diff] [blame] | 1600 | |
| 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.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1606 | return 0; |
| 1607 | } |
| 1608 | |
Henrik Lundin | cf808d2 | 2015-05-27 14:33:29 +0200 | [diff] [blame] | 1609 | int NetEqImpl::DoAccelerate(int16_t* decoded_buffer, |
| 1610 | size_t decoded_length, |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1611 | AudioDecoder::SpeechType speech_type, |
Henrik Lundin | cf808d2 | 2015-05-27 14:33:29 +0200 | [diff] [blame] | 1612 | bool play_dtmf, |
| 1613 | bool fast_accelerate) { |
Peter Kasting | dce40cf | 2015-08-24 14:52:23 -0700 | [diff] [blame] | 1614 | const size_t required_samples = |
| 1615 | static_cast<size_t>(240 * fs_mult_); // Must have 30 ms. |
turaj@webrtc.org | 362a55e | 2013-09-20 16:25:28 +0000 | [diff] [blame] | 1616 | size_t borrowed_samples_per_channel = 0; |
henrik.lundin@webrtc.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 1617 | size_t num_channels = algorithm_buffer_->Channels(); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1618 | 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.org | 362a55e | 2013-09-20 16:25:28 +0000 | [diff] [blame] | 1621 | borrowed_samples_per_channel = static_cast<int>(required_samples - |
| 1622 | decoded_length_per_channel); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1623 | 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 Kasting | dce40cf | 2015-08-24 14:52:23 -0700 | [diff] [blame] | 1631 | size_t samples_removed; |
Henrik Lundin | cf808d2 | 2015-05-27 14:33:29 +0200 | [diff] [blame] | 1632 | Accelerate::ReturnCodes return_code = |
| 1633 | accelerate_->Process(decoded_buffer, decoded_length, fast_accelerate, |
| 1634 | algorithm_buffer_.get(), &samples_removed); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1635 | 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.org | 362a55e | 2013-09-20 16:25:28 +0000 | [diff] [blame] | 1654 | size_t length = algorithm_buffer_->Size(); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1655 | if (length < borrowed_samples_per_channel) { |
| 1656 | // This destroys the beginning of the buffer, but will not cause any |
| 1657 | // problems. |
henrik.lundin@webrtc.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 1658 | sync_buffer_->ReplaceAtIndex(*algorithm_buffer_, |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1659 | sync_buffer_->Size() - |
| 1660 | borrowed_samples_per_channel); |
| 1661 | sync_buffer_->PushFrontZeros(borrowed_samples_per_channel - length); |
henrik.lundin@webrtc.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 1662 | algorithm_buffer_->PopFront(length); |
| 1663 | assert(algorithm_buffer_->Empty()); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1664 | } else { |
henrik.lundin@webrtc.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 1665 | sync_buffer_->ReplaceAtIndex(*algorithm_buffer_, |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1666 | borrowed_samples_per_channel, |
| 1667 | sync_buffer_->Size() - |
| 1668 | borrowed_samples_per_channel); |
henrik.lundin@webrtc.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 1669 | algorithm_buffer_->PopFront(borrowed_samples_per_channel); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1670 | } |
| 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 | |
| 1684 | int NetEqImpl::DoPreemptiveExpand(int16_t* decoded_buffer, |
| 1685 | size_t decoded_length, |
| 1686 | AudioDecoder::SpeechType speech_type, |
henrik.lundin@webrtc.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 1687 | bool play_dtmf) { |
Peter Kasting | dce40cf | 2015-08-24 14:52:23 -0700 | [diff] [blame] | 1688 | const size_t required_samples = |
| 1689 | static_cast<size_t>(240 * fs_mult_); // Must have 30 ms. |
henrik.lundin@webrtc.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 1690 | size_t num_channels = algorithm_buffer_->Channels(); |
Peter Kasting | dce40cf | 2015-08-24 14:52:23 -0700 | [diff] [blame] | 1691 | size_t borrowed_samples_per_channel = 0; |
| 1692 | size_t old_borrowed_samples_per_channel = 0; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1693 | 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 Kasting | dce40cf | 2015-08-24 14:52:23 -0700 | [diff] [blame] | 1696 | borrowed_samples_per_channel = |
| 1697 | required_samples - decoded_length_per_channel; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1698 | // Calculate how many of these were already played out. |
Peter Kasting | f045e4d | 2015-06-10 21:15:38 -0700 | [diff] [blame] | 1699 | old_borrowed_samples_per_channel = |
Peter Kasting | dce40cf | 2015-08-24 14:52:23 -0700 | [diff] [blame] | 1700 | (borrowed_samples_per_channel > sync_buffer_->FutureLength()) ? |
| 1701 | (borrowed_samples_per_channel - sync_buffer_->FutureLength()) : 0; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1702 | 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 Kasting | dce40cf | 2015-08-24 14:52:23 -0700 | [diff] [blame] | 1710 | size_t samples_added; |
henrik.lundin@webrtc.org | 40d3fc6 | 2013-09-18 12:19:50 +0000 | [diff] [blame] | 1711 | PreemptiveExpand::ReturnCodes return_code = preemptive_expand_->Process( |
Peter Kasting | dce40cf | 2015-08-24 14:52:23 -0700 | [diff] [blame] | 1712 | decoded_buffer, decoded_length, |
turaj@webrtc.org | 362a55e | 2013-09-20 16:25:28 +0000 | [diff] [blame] | 1713 | old_borrowed_samples_per_channel, |
henrik.lundin@webrtc.org | 0d5da25 | 2013-09-18 21:12:38 +0000 | [diff] [blame] | 1714 | algorithm_buffer_.get(), &samples_added); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1715 | 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.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 1735 | *algorithm_buffer_, borrowed_samples_per_channel, |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1736 | sync_buffer_->Size() - borrowed_samples_per_channel); |
henrik.lundin@webrtc.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 1737 | algorithm_buffer_->PopFront(borrowed_samples_per_channel); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1738 | } |
| 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.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 1751 | int NetEqImpl::DoRfc3389Cng(PacketList* packet_list, bool play_dtmf) { |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1752 | if (!packet_list->empty()) { |
| 1753 | // Must have exactly one SID frame at this point. |
| 1754 | assert(packet_list->size() == 1); |
ossu | a73f6c9 | 2016-10-24 08:25:28 -0700 | [diff] [blame] | 1755 | const Packet& packet = packet_list->front(); |
| 1756 | if (!decoder_database_->IsComfortNoise(packet.payload_type)) { |
henrik.lundin@webrtc.org | 73deaad | 2013-01-31 13:32:51 +0000 | [diff] [blame] | 1757 | LOG(LS_ERROR) << "Trying to decode non-CNG payload as CNG."; |
| 1758 | return kOtherError; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1759 | } |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1760 | if (comfort_noise_->UpdateParameters(packet) == |
| 1761 | ComfortNoise::kInternalError) { |
henrik.lundin@webrtc.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 1762 | algorithm_buffer_->Zeros(output_size_samples_); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1763 | return -comfort_noise_->internal_error_code(); |
| 1764 | } |
| 1765 | } |
| 1766 | int cn_return = comfort_noise_->Generate(output_size_samples_, |
henrik.lundin@webrtc.org | 0d5da25 | 2013-09-18 21:12:38 +0000 | [diff] [blame] | 1767 | algorithm_buffer_.get()); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1768 | expand_->Reset(); |
| 1769 | last_mode_ = kModeRfc3389Cng; |
| 1770 | if (!play_dtmf) { |
| 1771 | dtmf_tone_generator_->Reset(); |
| 1772 | } |
| 1773 | if (cn_return == ComfortNoise::kInternalError) { |
Henrik Lundin | c417d9e | 2017-06-14 12:29:03 +0200 | [diff] [blame] | 1774 | LOG(LS_WARNING) << "Comfort noise generator returned error code: " |
| 1775 | << comfort_noise_->internal_error_code(); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1776 | return kComfortNoiseErrorCode; |
| 1777 | } else if (cn_return == ComfortNoise::kUnknownPayloadType) { |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1778 | return kUnknownRtpPayloadType; |
| 1779 | } |
| 1780 | return 0; |
| 1781 | } |
| 1782 | |
minyuel | 6d92bf5 | 2015-09-23 15:20:39 +0200 | [diff] [blame] | 1783 | void 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.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1789 | last_mode_ = kModeCodecInternalCng; |
| 1790 | expand_->Reset(); |
| 1791 | } |
| 1792 | |
henrik.lundin@webrtc.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 1793 | int NetEqImpl::DoDtmf(const DtmfEvent& dtmf_event, bool* play_dtmf) { |
turaj@webrtc.org | 4d06db5 | 2013-03-27 18:31:42 +0000 | [diff] [blame] | 1794 | // 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.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1810 | |
| 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.org | 4d06db5 | 2013-03-27 18:31:42 +0000 | [diff] [blame] | 1817 | |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1818 | if (dtmf_return_value == 0) { |
| 1819 | // Generate DTMF signal. |
| 1820 | dtmf_return_value = dtmf_tone_generator_->Generate(output_size_samples_, |
henrik.lundin@webrtc.org | 0d5da25 | 2013-09-18 21:12:38 +0000 | [diff] [blame] | 1821 | algorithm_buffer_.get()); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1822 | } |
turaj@webrtc.org | 4d06db5 | 2013-03-27 18:31:42 +0000 | [diff] [blame] | 1823 | |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1824 | if (dtmf_return_value < 0) { |
henrik.lundin@webrtc.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 1825 | algorithm_buffer_->Zeros(output_size_samples_); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1826 | return dtmf_return_value; |
| 1827 | } |
| 1828 | |
turaj@webrtc.org | 4d06db5 | 2013-03-27 18:31:42 +0000 | [diff] [blame] | 1829 | // 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.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 1843 | // algorithm_buffer_); |
| 1844 | // assert((size_t) required_length == algorithm_buffer_->Size()); |
turaj@webrtc.org | 4d06db5 | 2013-03-27 18:31:42 +0000 | [diff] [blame] | 1845 | // if (dtmf_return_value < 0) { |
henrik.lundin@webrtc.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 1846 | // algorithm_buffer_->Zeros(output_size_samples_); |
turaj@webrtc.org | 4d06db5 | 2013-03-27 18:31:42 +0000 | [diff] [blame] | 1847 | // 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.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 1854 | // assert(algorithm_buffer_->Channels() == 1); |
| 1855 | // if (algorithm_buffer_->Channels() != 1) { |
turaj@webrtc.org | 4d06db5 | 2013-03-27 18:31:42 +0000 | [diff] [blame] | 1856 | // 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.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 1860 | // algorithm_buffer_->PopFront(sync_buffer_->FutureLength()); |
turaj@webrtc.org | 4d06db5 | 2013-03-27 18:31:42 +0000 | [diff] [blame] | 1861 | // } |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1862 | |
Peter Kasting | b7e5054 | 2015-06-11 12:55:50 -0700 | [diff] [blame] | 1863 | sync_buffer_->IncreaseEndTimestamp( |
| 1864 | static_cast<uint32_t>(output_size_samples_)); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1865 | 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.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 1873 | void NetEqImpl::DoAlternativePlc(bool increase_timestamp) { |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1874 | AudioDecoder* decoder = decoder_database_->GetActiveDecoder(); |
Peter Kasting | dce40cf | 2015-08-24 14:52:23 -0700 | [diff] [blame] | 1875 | size_t length; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1876 | 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 Kasting | dce40cf | 2015-08-24 14:52:23 -0700 | [diff] [blame] | 1881 | if (length > 0) |
henrik.lundin@webrtc.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 1882 | algorithm_buffer_->PushBackInterleaved(decoded_buffer, length); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1883 | } else { |
| 1884 | // Do simple zero-stuffing. |
| 1885 | length = output_size_samples_; |
henrik.lundin@webrtc.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 1886 | algorithm_buffer_->Zeros(length); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1887 | // By not advancing the timestamp, NetEq inserts samples. |
| 1888 | stats_.AddZeros(length); |
| 1889 | } |
| 1890 | if (increase_timestamp) { |
Peter Kasting | b7e5054 | 2015-06-11 12:55:50 -0700 | [diff] [blame] | 1891 | sync_buffer_->IncreaseEndTimestamp(static_cast<uint32_t>(length)); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1892 | } |
| 1893 | expand_->Reset(); |
| 1894 | } |
| 1895 | |
| 1896 | int NetEqImpl::DtmfOverdub(const DtmfEvent& dtmf_event, size_t num_channels, |
| 1897 | int16_t* output) const { |
| 1898 | size_t out_index = 0; |
Peter Kasting | dce40cf | 2015-08-24 14:52:23 -0700 | [diff] [blame] | 1899 | size_t overdub_length = output_size_samples_; // Default value. |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1900 | |
| 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 Kasting | dce40cf | 2015-08-24 14:52:23 -0700 | [diff] [blame] | 1905 | output_size_samples_); |
| 1906 | overdub_length = output_size_samples_ - out_index; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1907 | } |
| 1908 | |
henrik.lundin@webrtc.org | fd11bbf | 2013-09-30 20:38:44 +0000 | [diff] [blame] | 1909 | AudioMultiVector dtmf_output(num_channels); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1910 | 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 Kasting | dce40cf | 2015-08-24 14:52:23 -0700 | [diff] [blame] | 1918 | assert(overdub_length == dtmf_output.Size()); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1919 | } |
| 1920 | dtmf_output.ReadInterleaved(overdub_length, &output[out_index]); |
| 1921 | return dtmf_return_value < 0 ? dtmf_return_value : 0; |
| 1922 | } |
| 1923 | |
Peter Kasting | dce40cf | 2015-08-24 14:52:23 -0700 | [diff] [blame] | 1924 | int NetEqImpl::ExtractPackets(size_t required_samples, |
| 1925 | PacketList* packet_list) { |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1926 | 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 | |
ossu | 7a37761 | 2016-10-18 04:06:13 -0700 | [diff] [blame] | 1932 | const Packet* next_packet = packet_buffer_->PeekNextPacket(); |
| 1933 | RTC_DCHECK(next_packet); |
| 1934 | if (!next_packet) { |
Henrik Lundin | d67a219 | 2015-08-03 12:54:37 +0200 | [diff] [blame] | 1935 | LOG(LS_ERROR) << "Packet buffer unexpectedly empty."; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1936 | return -1; |
| 1937 | } |
ossu | 7a37761 | 2016-10-18 04:06:13 -0700 | [diff] [blame] | 1938 | uint32_t first_timestamp = next_packet->timestamp; |
ossu | 61a208b | 2016-09-20 01:38:00 -0700 | [diff] [blame] | 1939 | size_t extracted_samples = 0; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1940 | |
| 1941 | // Packet extraction loop. |
| 1942 | do { |
ossu | 7a37761 | 2016-10-18 04:06:13 -0700 | [diff] [blame] | 1943 | timestamp_ = next_packet->timestamp; |
ossu | a73f6c9 | 2016-10-24 08:25:28 -0700 | [diff] [blame] | 1944 | rtc::Optional<Packet> packet = packet_buffer_->GetNextPacket(); |
ossu | 7a37761 | 2016-10-18 04:06:13 -0700 | [diff] [blame] | 1945 | // |next_packet| may be invalid after the |packet_buffer_| operation. |
ossu | a73f6c9 | 2016-10-24 08:25:28 -0700 | [diff] [blame] | 1946 | next_packet = nullptr; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1947 | if (!packet) { |
Henrik Lundin | d67a219 | 2015-08-03 12:54:37 +0200 | [diff] [blame] | 1948 | LOG(LS_ERROR) << "Should always be able to extract a packet here"; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1949 | assert(false); // Should always be able to extract a packet here. |
| 1950 | return -1; |
| 1951 | } |
Gustaf Ullberg | b0a0207 | 2017-10-02 12:00:34 +0200 | [diff] [blame] | 1952 | const uint64_t waiting_time_ms = packet->waiting_time->ElapsedMs(); |
| 1953 | stats_.StoreWaitingTime(waiting_time_ms); |
ossu | 61a208b | 2016-09-20 01:38:00 -0700 | [diff] [blame] | 1954 | RTC_DCHECK(!packet->empty()); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1955 | |
| 1956 | if (first_packet) { |
| 1957 | first_packet = false; |
henrik.lundin | 48ed930 | 2015-10-29 05:36:24 -0700 | [diff] [blame] | 1958 | if (nack_enabled_) { |
| 1959 | RTC_DCHECK(nack_); |
| 1960 | // TODO(henrik.lundin): Should we update this for all decoded packets? |
ossu | 7a37761 | 2016-10-18 04:06:13 -0700 | [diff] [blame] | 1961 | nack_->UpdateLastDecodedPacket(packet->sequence_number, |
| 1962 | packet->timestamp); |
henrik.lundin | 48ed930 | 2015-10-29 05:36:24 -0700 | [diff] [blame] | 1963 | } |
ossu | 7a37761 | 2016-10-18 04:06:13 -0700 | [diff] [blame] | 1964 | prev_sequence_number = packet->sequence_number; |
| 1965 | prev_timestamp = packet->timestamp; |
| 1966 | prev_payload_type = packet->payload_type; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1967 | } |
| 1968 | |
ossu | cafb497 | 2017-01-02 07:00:50 -0800 | [diff] [blame] | 1969 | const bool has_cng_packet = |
| 1970 | decoder_database_->IsComfortNoise(packet->payload_type); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1971 | // Store number of extracted samples. |
ossu | 61a208b | 2016-09-20 01:38:00 -0700 | [diff] [blame] | 1972 | size_t packet_duration = 0; |
| 1973 | if (packet->frame) { |
| 1974 | packet_duration = packet->frame->Duration(); |
ossu | a70695a | 2016-09-22 02:06:28 -0700 | [diff] [blame] | 1975 | // TODO(ossu): Is this the correct way to track Opus FEC packets? |
| 1976 | if (packet->priority.codec_level > 0) { |
kwiberg | d3edd77 | 2017-03-01 18:52:48 -0800 | [diff] [blame] | 1977 | stats_.SecondaryDecodedSamples( |
| 1978 | rtc::dchecked_cast<int>(packet_duration)); |
minyue@webrtc.org | b28bfa7 | 2014-03-21 12:07:40 +0000 | [diff] [blame] | 1979 | } |
ossu | cafb497 | 2017-01-02 07:00:50 -0800 | [diff] [blame] | 1980 | } else if (!has_cng_packet) { |
Henrik Lundin | d67a219 | 2015-08-03 12:54:37 +0200 | [diff] [blame] | 1981 | LOG(LS_WARNING) << "Unknown payload type " |
ossu | 7a37761 | 2016-10-18 04:06:13 -0700 | [diff] [blame] | 1982 | << static_cast<int>(packet->payload_type); |
ossu | 61a208b | 2016-09-20 01:38:00 -0700 | [diff] [blame] | 1983 | RTC_NOTREACHED(); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1984 | } |
ossu | 61a208b | 2016-09-20 01:38:00 -0700 | [diff] [blame] | 1985 | |
| 1986 | if (packet_duration == 0) { |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1987 | // Decoder did not return a packet duration. Assume that the packet |
| 1988 | // contains the same number of samples as the previous one. |
ossu | 61a208b | 2016-09-20 01:38:00 -0700 | [diff] [blame] | 1989 | packet_duration = decoder_frame_length_; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1990 | } |
ossu | 7a37761 | 2016-10-18 04:06:13 -0700 | [diff] [blame] | 1991 | extracted_samples = packet->timestamp - first_timestamp + packet_duration; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1992 | |
Gustaf Ullberg | b0a0207 | 2017-10-02 12:00:34 +0200 | [diff] [blame] | 1993 | stats_.JitterBufferDelay(extracted_samples, waiting_time_ms); |
| 1994 | |
ossu | a73f6c9 | 2016-10-24 08:25:28 -0700 | [diff] [blame] | 1995 | 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.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1998 | // Check what packet is available next. |
ossu | 7a37761 | 2016-10-18 04:06:13 -0700 | [diff] [blame] | 1999 | next_packet = packet_buffer_->PeekNextPacket(); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 2000 | next_packet_available = false; |
ossu | cafb497 | 2017-01-02 07:00:50 -0800 | [diff] [blame] | 2001 | if (next_packet && prev_payload_type == next_packet->payload_type && |
| 2002 | !has_cng_packet) { |
ossu | 7a37761 | 2016-10-18 04:06:13 -0700 | [diff] [blame] | 2003 | 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.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 2005 | 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 | } |
ossu | 7a37761 | 2016-10-18 04:06:13 -0700 | [diff] [blame] | 2011 | prev_sequence_number = next_packet->sequence_number; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 2012 | } |
ossu | 61a208b | 2016-09-20 01:38:00 -0700 | [diff] [blame] | 2013 | } while (extracted_samples < required_samples && next_packet_available); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 2014 | |
henrik.lundin@webrtc.org | 6121715 | 2014-09-22 08:30:07 +0000 | [diff] [blame] | 2015 | 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-webrtc | fae474c | 2017-07-05 11:17:40 +0200 | [diff] [blame] | 2020 | packet_buffer_->DiscardAllOldPackets(timestamp_, &stats_); |
henrik.lundin@webrtc.org | 6121715 | 2014-09-22 08:30:07 +0000 | [diff] [blame] | 2021 | } |
| 2022 | |
kwiberg | d3edd77 | 2017-03-01 18:52:48 -0800 | [diff] [blame] | 2023 | return rtc::dchecked_cast<int>(extracted_samples); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 2024 | } |
| 2025 | |
turaj@webrtc.org | 8d1cdaa | 2014-04-11 18:47:55 +0000 | [diff] [blame] | 2026 | void 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 Lundin | bef77e2 | 2015-08-18 14:58:09 +0200 | [diff] [blame] | 2030 | &stats_, fs_hz, channels)); |
turaj@webrtc.org | 8d1cdaa | 2014-04-11 18:47:55 +0000 | [diff] [blame] | 2031 | merge_.reset(new Merge(fs_hz, channels, expand_.get(), sync_buffer_.get())); |
| 2032 | } |
| 2033 | |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 2034 | void NetEqImpl::SetSampleRateAndChannels(int fs_hz, size_t channels) { |
Henrik Lundin | d67a219 | 2015-08-03 12:54:37 +0200 | [diff] [blame] | 2035 | LOG(LS_VERBOSE) << "SetSampleRateAndChannels " << fs_hz << " " << channels; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 2036 | // 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 Kasting | dce40cf | 2015-08-24 14:52:23 -0700 | [diff] [blame] | 2042 | output_size_samples_ = static_cast<size_t>(kOutputSizeMs * 8 * fs_mult_); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 2043 | 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 | |
ossu | 97ba30e | 2016-04-25 07:55:58 -0700 | [diff] [blame] | 2053 | ComfortNoiseDecoder* cng_decoder = decoder_database_->GetActiveCngDecoder(); |
Karl Wiberg | 4376648 | 2015-08-27 15:22:11 +0200 | [diff] [blame] | 2054 | if (cng_decoder) |
| 2055 | cng_decoder->Reset(); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 2056 | |
| 2057 | // Reinit post-decode VAD with new sample rate. |
| 2058 | assert(vad_.get()); // Cannot be NULL here. |
| 2059 | vad_->Init(); |
| 2060 | |
henrik.lundin@webrtc.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 2061 | // Delete algorithm buffer and create a new one. |
henrik.lundin@webrtc.org | fd11bbf | 2013-09-30 20:38:44 +0000 | [diff] [blame] | 2062 | algorithm_buffer_.reset(new AudioMultiVector(channels)); |
henrik.lundin@webrtc.org | c487c6a | 2013-09-02 07:59:30 +0000 | [diff] [blame] | 2063 | |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 2064 | // Delete sync buffer and create a new one. |
henrik.lundin@webrtc.org | 0d5da25 | 2013-09-18 21:12:38 +0000 | [diff] [blame] | 2065 | sync_buffer_.reset(new SyncBuffer(channels, kSyncBufferSize * fs_mult_)); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 2066 | |
henrik.lundin@webrtc.org | ea25784 | 2014-08-07 12:27:37 +0000 | [diff] [blame] | 2067 | // Delete BackgroundNoise object and create a new one. |
henrik.lundin@webrtc.org | 0d5da25 | 2013-09-18 21:12:38 +0000 | [diff] [blame] | 2068 | background_noise_.reset(new BackgroundNoise(channels)); |
henrik.lundin@webrtc.org | ea25784 | 2014-08-07 12:27:37 +0000 | [diff] [blame] | 2069 | background_noise_->set_mode(background_noise_mode_); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 2070 | |
| 2071 | // Reset random vector. |
| 2072 | random_vector_.Reset(); |
| 2073 | |
turaj@webrtc.org | 8d1cdaa | 2014-04-11 18:47:55 +0000 | [diff] [blame] | 2074 | UpdatePlcComponents(fs_hz, channels); |
| 2075 | |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 2076 | // 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.org | 8d1cdaa | 2014-04-11 18:47:55 +0000 | [diff] [blame] | 2078 | expand_->overlap_length()); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 2079 | |
henrik.lundin@webrtc.org | 40d3fc6 | 2013-09-18 12:19:50 +0000 | [diff] [blame] | 2080 | normal_.reset(new Normal(fs_hz, decoder_database_.get(), *background_noise_, |
henrik.lundin@webrtc.org | 0d5da25 | 2013-09-18 21:12:38 +0000 | [diff] [blame] | 2081 | expand_.get())); |
henrik.lundin@webrtc.org | d9faa46 | 2014-01-14 10:18:45 +0000 | [diff] [blame] | 2082 | accelerate_.reset( |
| 2083 | accelerate_factory_->Create(fs_hz, channels, *background_noise_)); |
turaj@webrtc.org | 8d1cdaa | 2014-04-11 18:47:55 +0000 | [diff] [blame] | 2084 | preemptive_expand_.reset(preemptive_expand_factory_->Create( |
Peter Kasting | dce40cf | 2015-08-24 14:52:23 -0700 | [diff] [blame] | 2085 | fs_hz, channels, *background_noise_, expand_->overlap_length())); |
henrik.lundin@webrtc.org | 40d3fc6 | 2013-09-18 12:19:50 +0000 | [diff] [blame] | 2086 | |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 2087 | // Delete ComfortNoise object and create a new one. |
henrik.lundin@webrtc.org | 0d5da25 | 2013-09-18 21:12:38 +0000 | [diff] [blame] | 2088 | comfort_noise_.reset(new ComfortNoise(fs_hz, decoder_database_.get(), |
| 2089 | sync_buffer_.get())); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 2090 | |
| 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.org | 8d1cdaa | 2014-04-11 18:47:55 +0000 | [diff] [blame] | 2098 | // 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.org | 7cbc4f9 | 2014-10-07 06:37:39 +0000 | [diff] [blame] | 2101 | CreateDecisionLogic(); |
turaj@webrtc.org | 8d1cdaa | 2014-04-11 18:47:55 +0000 | [diff] [blame] | 2102 | } |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 2103 | decision_logic_->SetSampleRate(fs_hz_, output_size_samples_); |
| 2104 | } |
| 2105 | |
henrik.lundin | 55480f5 | 2016-03-08 02:37:57 -0800 | [diff] [blame] | 2106 | NetEqImpl::OutputType NetEqImpl::LastOutputType() { |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 2107 | assert(vad_.get()); |
henrik.lundin@webrtc.org | 0d5da25 | 2013-09-18 21:12:38 +0000 | [diff] [blame] | 2108 | assert(expand_.get()); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 2109 | if (last_mode_ == kModeCodecInternalCng || last_mode_ == kModeRfc3389Cng) { |
henrik.lundin | 55480f5 | 2016-03-08 02:37:57 -0800 | [diff] [blame] | 2110 | return OutputType::kCNG; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 2111 | } else if (last_mode_ == kModeExpand && expand_->MuteFactor(0) == 0) { |
| 2112 | // Expand mode has faded down to background noise only (very long expand). |
henrik.lundin | 55480f5 | 2016-03-08 02:37:57 -0800 | [diff] [blame] | 2113 | return OutputType::kPLCCNG; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 2114 | } else if (last_mode_ == kModeExpand) { |
henrik.lundin | 55480f5 | 2016-03-08 02:37:57 -0800 | [diff] [blame] | 2115 | return OutputType::kPLC; |
wu@webrtc.org | 24301a6 | 2013-12-13 19:17:43 +0000 | [diff] [blame] | 2116 | } else if (vad_->running() && !vad_->active_speech()) { |
henrik.lundin | 55480f5 | 2016-03-08 02:37:57 -0800 | [diff] [blame] | 2117 | return OutputType::kVadPassive; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 2118 | } else { |
henrik.lundin | 55480f5 | 2016-03-08 02:37:57 -0800 | [diff] [blame] | 2119 | return OutputType::kNormalSpeech; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 2120 | } |
| 2121 | } |
| 2122 | |
henrik.lundin@webrtc.org | 7cbc4f9 | 2014-10-07 06:37:39 +0000 | [diff] [blame] | 2123 | void NetEqImpl::CreateDecisionLogic() { |
Henrik Lundin | 47b17dc | 2016-05-10 10:20:59 +0200 | [diff] [blame] | 2124 | 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.org | 8d1cdaa | 2014-04-11 18:47:55 +0000 | [diff] [blame] | 2128 | } |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 2129 | } // namespace webrtc |