1/*
2 *  Copyright (c) 2013 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
11#include "webrtc/modules/audio_coding/main/acm2/acm_receiver.h"
12
13#include <stdlib.h>  // malloc
14
15#include <algorithm>  // sort
16#include <vector>
17
18#include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
19#include "webrtc/common_types.h"
20#include "webrtc/modules/audio_coding/main/acm2/acm_common_defs.h"
21#include "webrtc/modules/audio_coding/main/acm2/acm_resampler.h"
22#include "webrtc/modules/audio_coding/main/acm2/call_statistics.h"
23#include "webrtc/modules/audio_coding/main/acm2/nack.h"
24#include "webrtc/modules/audio_coding/neteq/interface/audio_decoder.h"
25#include "webrtc/modules/audio_coding/neteq/interface/neteq.h"
26#include "webrtc/system_wrappers/interface/clock.h"
27#include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
28#include "webrtc/system_wrappers/interface/logging.h"
29#include "webrtc/system_wrappers/interface/tick_util.h"
30#include "webrtc/system_wrappers/interface/trace.h"
31
32namespace webrtc {
33
34namespace acm2 {
35
36namespace {
37
38const int kNackThresholdPackets = 2;
39
40// |vad_activity_| field of |audio_frame| is set to |previous_audio_activity_|
41// before the call to this function.
42void SetAudioFrameActivityAndType(bool vad_enabled,
43                                  NetEqOutputType type,
44                                  AudioFrame* audio_frame) {
45  if (vad_enabled) {
46    switch (type) {
47      case kOutputNormal: {
48        audio_frame->vad_activity_ = AudioFrame::kVadActive;
49        audio_frame->speech_type_ = AudioFrame::kNormalSpeech;
50        break;
51      }
52      case kOutputVADPassive: {
53        audio_frame->vad_activity_ = AudioFrame::kVadPassive;
54        audio_frame->speech_type_ = AudioFrame::kNormalSpeech;
55        break;
56      }
57      case kOutputCNG: {
58        audio_frame->vad_activity_ = AudioFrame::kVadPassive;
59        audio_frame->speech_type_ = AudioFrame::kCNG;
60        break;
61      }
62      case kOutputPLC: {
63        // Don't change |audio_frame->vad_activity_|, it should be the same as
64        // |previous_audio_activity_|.
65        audio_frame->speech_type_ = AudioFrame::kPLC;
66        break;
67      }
68      case kOutputPLCtoCNG: {
69        audio_frame->vad_activity_ = AudioFrame::kVadPassive;
70        audio_frame->speech_type_ = AudioFrame::kPLCCNG;
71        break;
72      }
73      default:
74        assert(false);
75    }
76  } else {
77    // Always return kVadUnknown when receive VAD is inactive
78    audio_frame->vad_activity_ = AudioFrame::kVadUnknown;
79    switch (type) {
80      case kOutputNormal: {
81        audio_frame->speech_type_ = AudioFrame::kNormalSpeech;
82        break;
83      }
84      case kOutputCNG: {
85        audio_frame->speech_type_ = AudioFrame::kCNG;
86        break;
87      }
88      case kOutputPLC: {
89        audio_frame->speech_type_ = AudioFrame::kPLC;
90        break;
91      }
92      case kOutputPLCtoCNG: {
93        audio_frame->speech_type_ = AudioFrame::kPLCCNG;
94        break;
95      }
96      case kOutputVADPassive: {
97        // Normally, we should no get any VAD decision if post-decoding VAD is
98        // not active. However, if post-decoding VAD has been active then
99        // disabled, we might be here for couple of frames.
100        audio_frame->speech_type_ = AudioFrame::kNormalSpeech;
101        LOG_F(LS_WARNING) << "Post-decoding VAD is disabled but output is "
102            << "labeled VAD-passive";
103        break;
104      }
105      default:
106        assert(false);
107    }
108  }
109}
110
111// Is the given codec a CNG codec?
112bool IsCng(int codec_id) {
113  return (codec_id == ACMCodecDB::kCNNB || codec_id == ACMCodecDB::kCNWB ||
114      codec_id == ACMCodecDB::kCNSWB || codec_id == ACMCodecDB::kCNFB);
115}
116
117}  // namespace
118
119AcmReceiver::AcmReceiver(const AudioCodingModule::Config& config)
120    : crit_sect_(CriticalSectionWrapper::CreateCriticalSection()),
121      id_(config.id),
122      last_audio_decoder_(-1),  // Invalid value.
123      previous_audio_activity_(AudioFrame::kVadPassive),
124      current_sample_rate_hz_(config.neteq_config.sample_rate_hz),
125      nack_(),
126      nack_enabled_(false),
127      neteq_(NetEq::Create(config.neteq_config)),
128      vad_enabled_(true),
129      clock_(config.clock),
130      av_sync_(false),
131      initial_delay_manager_(),
132      missing_packets_sync_stream_(),
133      late_packets_sync_stream_() {
134  assert(clock_);
135  for (int n = 0; n < ACMCodecDB::kMaxNumCodecs; ++n) {
136    decoders_[n].registered = false;
137  }
138
139  // Make sure we are on the same page as NetEq. Post-decode VAD is disabled by
140  // default in NetEq4, however, Audio Conference Mixer relies on VAD decision
141  // and fails if VAD decision is not provided.
142  if (vad_enabled_)
143    neteq_->EnableVad();
144  else
145    neteq_->DisableVad();
146}
147
148AcmReceiver::~AcmReceiver() {
149  delete neteq_;
150}
151
152int AcmReceiver::SetMinimumDelay(int delay_ms) {
153  if (neteq_->SetMinimumDelay(delay_ms))
154    return 0;
155  LOG_FERR1(LS_ERROR, "AcmReceiver::SetExtraDelay", delay_ms);
156  return -1;
157}
158
159int AcmReceiver::SetInitialDelay(int delay_ms) {
160  if (delay_ms < 0 || delay_ms > 10000) {
161    return -1;
162  }
163  CriticalSectionScoped lock(crit_sect_.get());
164
165  if (delay_ms == 0) {
166    av_sync_ = false;
167    initial_delay_manager_.reset();
168    missing_packets_sync_stream_.reset();
169    late_packets_sync_stream_.reset();
170    neteq_->SetMinimumDelay(0);
171    return 0;
172  }
173
174  if (av_sync_ && initial_delay_manager_->PacketBuffered()) {
175    // Too late for this API. Only works before a call is started.
176    return -1;
177  }
178
179  // Most of places NetEq calls are not within AcmReceiver's critical section to
180  // improve performance. Here, this call has to be placed before the following
181  // block, therefore, we keep it inside critical section. Otherwise, we have to
182  // release |neteq_crit_sect_| and acquire it again, which seems an overkill.
183  if (!neteq_->SetMinimumDelay(delay_ms))
184    return -1;
185
186  const int kLatePacketThreshold = 5;
187  av_sync_ = true;
188  initial_delay_manager_.reset(new InitialDelayManager(delay_ms,
189                                                       kLatePacketThreshold));
190  missing_packets_sync_stream_.reset(new InitialDelayManager::SyncStream);
191  late_packets_sync_stream_.reset(new InitialDelayManager::SyncStream);
192  return 0;
193}
194
195int AcmReceiver::SetMaximumDelay(int delay_ms) {
196  if (neteq_->SetMaximumDelay(delay_ms))
197    return 0;
198  LOG_FERR1(LS_ERROR, "AcmReceiver::SetExtraDelay", delay_ms);
199  return -1;
200}
201
202int AcmReceiver::LeastRequiredDelayMs() const {
203  return neteq_->LeastRequiredDelayMs();
204}
205
206int AcmReceiver::current_sample_rate_hz() const {
207  CriticalSectionScoped lock(crit_sect_.get());
208  return current_sample_rate_hz_;
209}
210
211// TODO(turajs): use one set of enumerators, e.g. the one defined in
212// common_types.h
213// TODO(henrik.lundin): This method is not used any longer. The call hierarchy
214// stops in voe::Channel::SetNetEQPlayoutMode(). Remove it.
215void AcmReceiver::SetPlayoutMode(AudioPlayoutMode mode) {
216  enum NetEqPlayoutMode playout_mode = kPlayoutOn;
217  switch (mode) {
218    case voice:
219      playout_mode = kPlayoutOn;
220      break;
221    case fax:  // No change to background noise mode.
222      playout_mode = kPlayoutFax;
223      break;
224    case streaming:
225      playout_mode = kPlayoutStreaming;
226      break;
227    case off:
228      playout_mode = kPlayoutOff;
229      break;
230  }
231  neteq_->SetPlayoutMode(playout_mode);
232}
233
234AudioPlayoutMode AcmReceiver::PlayoutMode() const {
235  AudioPlayoutMode acm_mode = voice;
236  NetEqPlayoutMode mode = neteq_->PlayoutMode();
237  switch (mode) {
238    case kPlayoutOn:
239      acm_mode = voice;
240      break;
241    case kPlayoutOff:
242      acm_mode = off;
243      break;
244    case kPlayoutFax:
245      acm_mode = fax;
246      break;
247    case kPlayoutStreaming:
248      acm_mode = streaming;
249      break;
250    default:
251      assert(false);
252  }
253  return acm_mode;
254}
255
256int AcmReceiver::InsertPacket(const WebRtcRTPHeader& rtp_header,
257                              const uint8_t* incoming_payload,
258                              int length_payload) {
259  uint32_t receive_timestamp = 0;
260  InitialDelayManager::PacketType packet_type =
261      InitialDelayManager::kUndefinedPacket;
262  bool new_codec = false;
263  const RTPHeader* header = &rtp_header.header;  // Just a shorthand.
264
265  {
266    CriticalSectionScoped lock(crit_sect_.get());
267
268    int codec_id = RtpHeaderToCodecIndex(*header, incoming_payload);
269    if (codec_id < 0) {
270      LOG_F(LS_ERROR) << "Payload-type " << header->payloadType
271          << " is not registered.";
272      return -1;
273    }
274    assert(codec_id < ACMCodecDB::kMaxNumCodecs);
275    const int sample_rate_hz = ACMCodecDB::CodecFreq(codec_id);
276    receive_timestamp = NowInTimestamp(sample_rate_hz);
277
278    if (IsCng(codec_id)) {
279      // If this is a CNG while the audio codec is not mono skip pushing in
280      // packets into NetEq.
281      if (last_audio_decoder_ >= 0 &&
282        decoders_[last_audio_decoder_].channels > 1)
283        return 0;
284      packet_type = InitialDelayManager::kCngPacket;
285    } else if (codec_id == ACMCodecDB::kAVT) {
286      packet_type = InitialDelayManager::kAvtPacket;
287    } else {
288      if (codec_id != last_audio_decoder_) {
289        // This is either the first audio packet or send codec is changed.
290        // Therefore, either NetEq buffer is empty or will be flushed when this
291        // packet inserted. Note that |last_audio_decoder_| is initialized to
292        // an invalid value (-1), hence, the above condition is true for the
293        // very first audio packet.
294        new_codec = true;
295
296        // Updating NACK'sampling rate is required, either first packet is
297        // received or codec is changed. Furthermore, reset is required if codec
298        // is changed (NetEq flushes its buffer so NACK should reset its list).
299        if (nack_enabled_) {
300          assert(nack_.get());
301          nack_->Reset();
302          nack_->UpdateSampleRate(sample_rate_hz);
303        }
304        last_audio_decoder_ = codec_id;
305      }
306      packet_type = InitialDelayManager::kAudioPacket;
307    }
308
309    if (nack_enabled_) {
310      assert(nack_.get());
311      nack_->UpdateLastReceivedPacket(header->sequenceNumber,
312                                      header->timestamp);
313    }
314
315    if (av_sync_) {
316      assert(initial_delay_manager_.get());
317      assert(missing_packets_sync_stream_.get());
318      // This updates |initial_delay_manager_| and specifies an stream of
319      // sync-packets, if required to be inserted. We insert the sync-packets
320      // when AcmReceiver lock is released and |decoder_lock_| is acquired.
321      initial_delay_manager_->UpdateLastReceivedPacket(
322          rtp_header, receive_timestamp, packet_type, new_codec, sample_rate_hz,
323          missing_packets_sync_stream_.get());
324    }
325  }  // |crit_sect_| is released.
326
327  // If |missing_packets_sync_stream_| is allocated then we are in AV-sync and
328  // we may need to insert sync-packets. We don't check |av_sync_| as we are
329  // outside AcmReceiver's critical section.
330  if (missing_packets_sync_stream_.get()) {
331    InsertStreamOfSyncPackets(missing_packets_sync_stream_.get());
332  }
333
334  if (neteq_->InsertPacket(rtp_header, incoming_payload, length_payload,
335                           receive_timestamp) < 0) {
336    LOG_FERR1(LS_ERROR, "AcmReceiver::InsertPacket", header->payloadType) <<
337        " Failed to insert packet";
338    return -1;
339  }
340  return 0;
341}
342
343int AcmReceiver::GetAudio(int desired_freq_hz, AudioFrame* audio_frame) {
344  enum NetEqOutputType type;
345  int16_t* ptr_audio_buffer = audio_frame->data_;
346  int samples_per_channel;
347  int num_channels;
348  bool return_silence = false;
349
350  {
351    // Accessing members, take the lock.
352    CriticalSectionScoped lock(crit_sect_.get());
353
354    if (av_sync_) {
355      assert(initial_delay_manager_.get());
356      assert(late_packets_sync_stream_.get());
357      return_silence = GetSilence(desired_freq_hz, audio_frame);
358      uint32_t timestamp_now = NowInTimestamp(current_sample_rate_hz_);
359      initial_delay_manager_->LatePackets(timestamp_now,
360                                          late_packets_sync_stream_.get());
361    }
362
363    if (!return_silence) {
364      // This is our initial guess regarding whether a resampling will be
365      // required. It is based on previous sample rate of netEq. Most often,
366      // this is a correct guess, however, in case that incoming payload changes
367      // the resampling might might be needed. By doing so, we avoid an
368      // unnecessary memcpy().
369      if (desired_freq_hz != -1 &&
370          current_sample_rate_hz_ != desired_freq_hz) {
371        ptr_audio_buffer = audio_buffer_;
372      }
373    }
374  }
375
376  // If |late_packets_sync_stream_| is allocated then we have been in AV-sync
377  // mode and we might have to insert sync-packets.
378  if (late_packets_sync_stream_.get()) {
379    InsertStreamOfSyncPackets(late_packets_sync_stream_.get());
380    if (return_silence)  // Silence generated, don't pull from NetEq.
381      return 0;
382  }
383
384  if (neteq_->GetAudio(AudioFrame::kMaxDataSizeSamples,
385                       ptr_audio_buffer,
386                       &samples_per_channel,
387                       &num_channels, &type) != NetEq::kOK) {
388    LOG_FERR0(LS_ERROR, "AcmReceiver::GetAudio") << "NetEq Failed.";
389    return -1;
390  }
391
392  // Accessing members, take the lock.
393  CriticalSectionScoped lock(crit_sect_.get());
394
395  // Update NACK.
396  int decoded_sequence_num = 0;
397  uint32_t decoded_timestamp = 0;
398  bool update_nack = nack_enabled_ &&  // Update NACK only if it is enabled.
399      neteq_->DecodedRtpInfo(&decoded_sequence_num, &decoded_timestamp);
400  if (update_nack) {
401    assert(nack_.get());
402    nack_->UpdateLastDecodedPacket(decoded_sequence_num, decoded_timestamp);
403  }
404
405  // NetEq always returns 10 ms of audio.
406  current_sample_rate_hz_ = samples_per_channel * 100;
407
408  // Update if resampling is required.
409  bool need_resampling = (desired_freq_hz != -1) &&
410      (current_sample_rate_hz_ != desired_freq_hz);
411
412  if (ptr_audio_buffer == audio_buffer_) {
413    // Data is written to local buffer.
414    if (need_resampling) {
415      samples_per_channel =
416          resampler_.Resample10Msec(audio_buffer_,
417                                    current_sample_rate_hz_,
418                                    desired_freq_hz,
419                                    num_channels,
420                                    AudioFrame::kMaxDataSizeSamples,
421                                    audio_frame->data_);
422      if (samples_per_channel < 0) {
423        LOG_FERR0(LS_ERROR, "AcmReceiver::GetAudio") << "Resampler Failed.";
424        return -1;
425      }
426    } else {
427      // We might end up here ONLY if codec is changed.
428      memcpy(audio_frame->data_, audio_buffer_, samples_per_channel *
429             num_channels * sizeof(int16_t));
430    }
431  } else {
432    // Data is written into |audio_frame|.
433    if (need_resampling) {
434      // We might end up here ONLY if codec is changed.
435      samples_per_channel =
436          resampler_.Resample10Msec(audio_frame->data_,
437                                    current_sample_rate_hz_,
438                                    desired_freq_hz,
439                                    num_channels,
440                                    AudioFrame::kMaxDataSizeSamples,
441                                    audio_buffer_);
442      if (samples_per_channel < 0) {
443        LOG_FERR0(LS_ERROR, "AcmReceiver::GetAudio") << "Resampler Failed.";
444        return -1;
445      }
446      memcpy(audio_frame->data_, audio_buffer_, samples_per_channel *
447             num_channels * sizeof(int16_t));
448    }
449  }
450
451  audio_frame->num_channels_ = num_channels;
452  audio_frame->samples_per_channel_ = samples_per_channel;
453  audio_frame->sample_rate_hz_ = samples_per_channel * 100;
454
455  // Should set |vad_activity| before calling SetAudioFrameActivityAndType().
456  audio_frame->vad_activity_ = previous_audio_activity_;
457  SetAudioFrameActivityAndType(vad_enabled_, type, audio_frame);
458  previous_audio_activity_ = audio_frame->vad_activity_;
459  call_stats_.DecodedByNetEq(audio_frame->speech_type_);
460
461  // Computes the RTP timestamp of the first sample in |audio_frame| from
462  // |GetPlayoutTimestamp|, which is the timestamp of the last sample of
463  // |audio_frame|.
464  uint32_t playout_timestamp = 0;
465  if (GetPlayoutTimestamp(&playout_timestamp)) {
466    audio_frame->timestamp_ =
467        playout_timestamp - audio_frame->samples_per_channel_;
468  } else {
469    // Remain 0 until we have a valid |playout_timestamp|.
470    audio_frame->timestamp_ = 0;
471  }
472
473  return 0;
474}
475
476int32_t AcmReceiver::AddCodec(int acm_codec_id,
477                              uint8_t payload_type,
478                              int channels,
479                              AudioDecoder* audio_decoder) {
480  assert(acm_codec_id >= 0 && acm_codec_id < ACMCodecDB::kMaxNumCodecs);
481  NetEqDecoder neteq_decoder = ACMCodecDB::neteq_decoders_[acm_codec_id];
482
483  // Make sure the right decoder is registered for Opus.
484  if (neteq_decoder == kDecoderOpus && channels == 2) {
485    neteq_decoder = kDecoderOpus_2ch;
486  }
487
488  CriticalSectionScoped lock(crit_sect_.get());
489
490  // The corresponding NetEq decoder ID.
491  // If this coder has been registered before.
492  if (decoders_[acm_codec_id].registered) {
493    if (decoders_[acm_codec_id].payload_type == payload_type &&
494        decoders_[acm_codec_id].channels == channels) {
495      // Re-registering the same codec with the same payload-type. Do nothing
496      // and return.
497      return 0;
498    }
499
500    // Changing the payload-type or number of channels for this codec.
501    // First unregister. Then register with new payload-type/channels.
502    if (neteq_->RemovePayloadType(decoders_[acm_codec_id].payload_type) !=
503        NetEq::kOK) {
504      LOG_F(LS_ERROR) << "Cannot remover payload "
505          << decoders_[acm_codec_id].payload_type;
506      return -1;
507    }
508  }
509
510  int ret_val;
511  if (!audio_decoder) {
512    ret_val = neteq_->RegisterPayloadType(neteq_decoder, payload_type);
513  } else {
514    ret_val = neteq_->RegisterExternalDecoder(
515        audio_decoder, neteq_decoder, payload_type);
516  }
517  if (ret_val != NetEq::kOK) {
518    LOG_FERR3(LS_ERROR, "AcmReceiver::AddCodec", acm_codec_id, payload_type,
519              channels);
520    // Registration failed, delete the allocated space and set the pointer to
521    // NULL, for the record.
522    decoders_[acm_codec_id].registered = false;
523    return -1;
524  }
525
526  decoders_[acm_codec_id].registered = true;
527  decoders_[acm_codec_id].payload_type = payload_type;
528  decoders_[acm_codec_id].channels = channels;
529  return 0;
530}
531
532void AcmReceiver::EnableVad() {
533  neteq_->EnableVad();
534  CriticalSectionScoped lock(crit_sect_.get());
535  vad_enabled_ = true;
536}
537
538void AcmReceiver::DisableVad() {
539  neteq_->DisableVad();
540  CriticalSectionScoped lock(crit_sect_.get());
541  vad_enabled_ = false;
542}
543
544void AcmReceiver::FlushBuffers() {
545  neteq_->FlushBuffers();
546}
547
548// If failed in removing one of the codecs, this method continues to remove as
549// many as it can.
550int AcmReceiver::RemoveAllCodecs() {
551  int ret_val = 0;
552  CriticalSectionScoped lock(crit_sect_.get());
553  for (int n = 0; n < ACMCodecDB::kMaxNumCodecs; ++n) {
554    if (decoders_[n].registered) {
555      if (neteq_->RemovePayloadType(decoders_[n].payload_type) == 0) {
556        decoders_[n].registered = false;
557      } else {
558        LOG_F(LS_ERROR) << "Cannot remove payload "
559            << decoders_[n].payload_type;
560        ret_val = -1;
561      }
562    }
563  }
564  // No codec is registered, invalidate last audio decoder.
565  last_audio_decoder_ = -1;
566  return ret_val;
567}
568
569int AcmReceiver::RemoveCodec(uint8_t payload_type) {
570  int codec_index = PayloadType2CodecIndex(payload_type);
571  if (codec_index < 0) {  // Such a payload-type is not registered.
572    return 0;
573  }
574  if (neteq_->RemovePayloadType(payload_type) != NetEq::kOK) {
575    LOG_FERR1(LS_ERROR, "AcmReceiver::RemoveCodec", payload_type);
576    return -1;
577  }
578  CriticalSectionScoped lock(crit_sect_.get());
579  decoders_[codec_index].registered = false;
580  if (last_audio_decoder_ == codec_index)
581    last_audio_decoder_ = -1;  // Codec is removed, invalidate last decoder.
582  return 0;
583}
584
585void AcmReceiver::set_id(int id) {
586  CriticalSectionScoped lock(crit_sect_.get());
587  id_ = id;
588}
589
590bool AcmReceiver::GetPlayoutTimestamp(uint32_t* timestamp) {
591  if (av_sync_) {
592    assert(initial_delay_manager_.get());
593    if (initial_delay_manager_->buffering()) {
594      return initial_delay_manager_->GetPlayoutTimestamp(timestamp);
595    }
596  }
597  return neteq_->GetPlayoutTimestamp(timestamp);
598}
599
600int AcmReceiver::last_audio_codec_id() const {
601  CriticalSectionScoped lock(crit_sect_.get());
602  return last_audio_decoder_;
603}
604
605int AcmReceiver::last_audio_payload_type() const {
606  CriticalSectionScoped lock(crit_sect_.get());
607  if (last_audio_decoder_ < 0)
608    return -1;
609  assert(decoders_[last_audio_decoder_].registered);
610  return decoders_[last_audio_decoder_].payload_type;
611}
612
613int AcmReceiver::RedPayloadType() const {
614  CriticalSectionScoped lock(crit_sect_.get());
615  if (ACMCodecDB::kRED < 0 ||
616      !decoders_[ACMCodecDB::kRED].registered) {
617    LOG_F(LS_WARNING) << "RED is not registered.";
618    return -1;
619  }
620  return decoders_[ACMCodecDB::kRED].payload_type;
621}
622
623int AcmReceiver::LastAudioCodec(CodecInst* codec) const {
624  CriticalSectionScoped lock(crit_sect_.get());
625  if (last_audio_decoder_ < 0) {
626    return -1;
627  }
628  assert(decoders_[last_audio_decoder_].registered);
629  memcpy(codec, &ACMCodecDB::database_[last_audio_decoder_], sizeof(CodecInst));
630  codec->pltype = decoders_[last_audio_decoder_].payload_type;
631  codec->channels = decoders_[last_audio_decoder_].channels;
632  return 0;
633}
634
635void AcmReceiver::NetworkStatistics(ACMNetworkStatistics* acm_stat) {
636  NetEqNetworkStatistics neteq_stat;
637  // NetEq function always returns zero, so we don't check the return value.
638  neteq_->NetworkStatistics(&neteq_stat);
639
640  acm_stat->currentBufferSize = neteq_stat.current_buffer_size_ms;
641  acm_stat->preferredBufferSize = neteq_stat.preferred_buffer_size_ms;
642  acm_stat->jitterPeaksFound = neteq_stat.jitter_peaks_found ? true : false;
643  acm_stat->currentPacketLossRate = neteq_stat.packet_loss_rate;
644  acm_stat->currentDiscardRate = neteq_stat.packet_discard_rate;
645  acm_stat->currentExpandRate = neteq_stat.expand_rate;
646  acm_stat->currentPreemptiveRate = neteq_stat.preemptive_rate;
647  acm_stat->currentAccelerateRate = neteq_stat.accelerate_rate;
648  acm_stat->clockDriftPPM = neteq_stat.clockdrift_ppm;
649  acm_stat->addedSamples = neteq_stat.added_zero_samples;
650
651  std::vector<int> waiting_times;
652  neteq_->WaitingTimes(&waiting_times);
653  size_t size = waiting_times.size();
654  if (size == 0) {
655    acm_stat->meanWaitingTimeMs = -1;
656    acm_stat->medianWaitingTimeMs = -1;
657    acm_stat->minWaitingTimeMs = -1;
658    acm_stat->maxWaitingTimeMs = -1;
659  } else {
660    std::sort(waiting_times.begin(), waiting_times.end());
661    if ((size & 0x1) == 0) {
662      acm_stat->medianWaitingTimeMs = (waiting_times[size / 2 - 1] +
663          waiting_times[size / 2]) / 2;
664    } else {
665      acm_stat->medianWaitingTimeMs = waiting_times[size / 2];
666    }
667    acm_stat->minWaitingTimeMs = waiting_times.front();
668    acm_stat->maxWaitingTimeMs = waiting_times.back();
669    double sum = 0;
670    for (size_t i = 0; i < size; ++i) {
671      sum += waiting_times[i];
672    }
673    acm_stat->meanWaitingTimeMs = static_cast<int>(sum / size);
674  }
675}
676
677int AcmReceiver::DecoderByPayloadType(uint8_t payload_type,
678                                      CodecInst* codec) const {
679  CriticalSectionScoped lock(crit_sect_.get());
680  int codec_index = PayloadType2CodecIndex(payload_type);
681  if (codec_index < 0) {
682    LOG_FERR1(LS_ERROR, "AcmReceiver::DecoderByPayloadType", payload_type);
683    return -1;
684  }
685  memcpy(codec, &ACMCodecDB::database_[codec_index], sizeof(CodecInst));
686  codec->pltype = decoders_[codec_index].payload_type;
687  codec->channels = decoders_[codec_index].channels;
688  return 0;
689}
690
691int AcmReceiver::PayloadType2CodecIndex(uint8_t payload_type) const {
692  for (int n = 0; n < ACMCodecDB::kMaxNumCodecs; ++n) {
693    if (decoders_[n].registered && decoders_[n].payload_type == payload_type) {
694      return n;
695    }
696  }
697  return -1;
698}
699
700int AcmReceiver::EnableNack(size_t max_nack_list_size) {
701  // Don't do anything if |max_nack_list_size| is out of range.
702  if (max_nack_list_size == 0 || max_nack_list_size > Nack::kNackListSizeLimit)
703    return -1;
704
705  CriticalSectionScoped lock(crit_sect_.get());
706  if (!nack_enabled_) {
707    nack_.reset(Nack::Create(kNackThresholdPackets));
708    nack_enabled_ = true;
709
710    // Sampling rate might need to be updated if we change from disable to
711    // enable. Do it if the receive codec is valid.
712    if (last_audio_decoder_ >= 0) {
713      nack_->UpdateSampleRate(
714          ACMCodecDB::database_[last_audio_decoder_].plfreq);
715    }
716  }
717  return nack_->SetMaxNackListSize(max_nack_list_size);
718}
719
720void AcmReceiver::DisableNack() {
721  CriticalSectionScoped lock(crit_sect_.get());
722  nack_.reset();  // Memory is released.
723  nack_enabled_ = false;
724}
725
726std::vector<uint16_t> AcmReceiver::GetNackList(
727    int round_trip_time_ms) const {
728  CriticalSectionScoped lock(crit_sect_.get());
729  if (round_trip_time_ms < 0) {
730    WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceAudioCoding, id_,
731                 "GetNackList: round trip time cannot be negative."
732                 " round_trip_time_ms=%d", round_trip_time_ms);
733  }
734  if (nack_enabled_ && round_trip_time_ms >= 0) {
735    assert(nack_.get());
736    return nack_->GetNackList(round_trip_time_ms);
737  }
738  std::vector<uint16_t> empty_list;
739  return empty_list;
740}
741
742void AcmReceiver::ResetInitialDelay() {
743  {
744    CriticalSectionScoped lock(crit_sect_.get());
745    av_sync_ = false;
746    initial_delay_manager_.reset(NULL);
747    missing_packets_sync_stream_.reset(NULL);
748    late_packets_sync_stream_.reset(NULL);
749  }
750  neteq_->SetMinimumDelay(0);
751  // TODO(turajs): Should NetEq Buffer be flushed?
752}
753
754// This function is called within critical section, no need to acquire a lock.
755bool AcmReceiver::GetSilence(int desired_sample_rate_hz, AudioFrame* frame) {
756  assert(av_sync_);
757  assert(initial_delay_manager_.get());
758  if (!initial_delay_manager_->buffering()) {
759    return false;
760  }
761
762  // We stop accumulating packets, if the number of packets or the total size
763  // exceeds a threshold.
764  int num_packets;
765  int max_num_packets;
766  const float kBufferingThresholdScale = 0.9f;
767  neteq_->PacketBufferStatistics(&num_packets, &max_num_packets);
768  if (num_packets > max_num_packets * kBufferingThresholdScale) {
769    initial_delay_manager_->DisableBuffering();
770    return false;
771  }
772
773  // Update statistics.
774  call_stats_.DecodedBySilenceGenerator();
775
776  // Set the values if already got a packet, otherwise set to default values.
777  if (last_audio_decoder_ >= 0) {
778    current_sample_rate_hz_ = ACMCodecDB::database_[last_audio_decoder_].plfreq;
779    frame->num_channels_ = decoders_[last_audio_decoder_].channels;
780  } else {
781    frame->num_channels_ = 1;
782  }
783
784  // Set the audio frame's sampling frequency.
785  if (desired_sample_rate_hz > 0) {
786    frame->sample_rate_hz_ = desired_sample_rate_hz;
787  } else {
788    frame->sample_rate_hz_ = current_sample_rate_hz_;
789  }
790
791  frame->samples_per_channel_ = frame->sample_rate_hz_ / 100;  // Always 10 ms.
792  frame->speech_type_ = AudioFrame::kCNG;
793  frame->vad_activity_ = AudioFrame::kVadPassive;
794  int samples = frame->samples_per_channel_ * frame->num_channels_;
795  memset(frame->data_, 0, samples * sizeof(int16_t));
796  return true;
797}
798
799int AcmReceiver::RtpHeaderToCodecIndex(
800    const RTPHeader &rtp_header, const uint8_t* payload) const {
801  uint8_t payload_type = rtp_header.payloadType;
802  if (ACMCodecDB::kRED >= 0 &&  // This ensures that RED is defined in WebRTC.
803      decoders_[ACMCodecDB::kRED].registered &&
804      payload_type == decoders_[ACMCodecDB::kRED].payload_type) {
805    // This is a RED packet, get the payload of the audio codec.
806    payload_type = payload[0] & 0x7F;
807  }
808
809  // Check if the payload is registered.
810  return PayloadType2CodecIndex(payload_type);
811}
812
813uint32_t AcmReceiver::NowInTimestamp(int decoder_sampling_rate) const {
814  // Down-cast the time to (32-6)-bit since we only care about
815  // the least significant bits. (32-6) bits cover 2^(32-6) = 67108864 ms.
816  // We masked 6 most significant bits of 32-bit so there is no overflow in
817  // the conversion from milliseconds to timestamp.
818  const uint32_t now_in_ms = static_cast<uint32_t>(
819      clock_->TimeInMilliseconds() & 0x03ffffff);
820  return static_cast<uint32_t>(
821      (decoder_sampling_rate / 1000) * now_in_ms);
822}
823
824// This function only interacts with |neteq_|, therefore, it does not have to
825// be within critical section of AcmReceiver. It is inserting packets
826// into NetEq, so we call it when |decode_lock_| is acquired. However, this is
827// not essential as sync-packets do not interact with codecs (especially BWE).
828void AcmReceiver::InsertStreamOfSyncPackets(
829    InitialDelayManager::SyncStream* sync_stream) {
830  assert(sync_stream);
831  assert(av_sync_);
832  for (int n = 0; n < sync_stream->num_sync_packets; ++n) {
833    neteq_->InsertSyncPacket(sync_stream->rtp_info,
834                             sync_stream->receive_timestamp);
835    ++sync_stream->rtp_info.header.sequenceNumber;
836    sync_stream->rtp_info.header.timestamp += sync_stream->timestamp_step;
837    sync_stream->receive_timestamp += sync_stream->timestamp_step;
838  }
839}
840
841void AcmReceiver::GetDecodingCallStatistics(
842    AudioDecodingCallStats* stats) const {
843  CriticalSectionScoped lock(crit_sect_.get());
844  *stats = call_stats_.GetDecodingStatistics();
845}
846
847}  // namespace acm2
848
849}  // namespace webrtc
850