ACM: Move NACK functionality inside NetEq

webrtc/modules/audio_coding/main/acm2/acm_receiver.cc

 /*
  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/modules/audio_coding/main/acm2/acm_receiver.h"
 
 #include <stdlib.h>  // malloc
 
 #include <algorithm>  // sort
 #include <vector>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/format_macros.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
 #include "webrtc/common_types.h"
 #include "webrtc/modules/audio_coding/codecs/audio_decoder.h"
 #include "webrtc/modules/audio_coding/main/acm2/acm_common_defs.h"
 #include "webrtc/modules/audio_coding/main/acm2/acm_resampler.h"
 #include "webrtc/modules/audio_coding/main/acm2/call_statistics.h"
-#include "webrtc/modules/audio_coding/main/acm2/nack.h"
 #include "webrtc/modules/audio_coding/neteq/include/neteq.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/include/tick_util.h"
 #include "webrtc/system_wrappers/include/trace.h"
 
 namespace webrtc {
 
 namespace acm2 {
 
 namespace {
 
-const int kNackThresholdPackets = 2;
-
 // |vad_activity_| field of |audio_frame| is set to |previous_audio_activity_|
 // before the call to this function.
 void SetAudioFrameActivityAndType(bool vad_enabled,
                                   NetEqOutputType type,
                                   AudioFrame* audio_frame) {
   if (vad_enabled) {
     switch (type) {
       case kOutputNormal: {
         audio_frame->vad_activity_ = AudioFrame::kVadActive;
         audio_frame->speech_type_ = AudioFrame::kNormalSpeech;
@@ skipping 71 matching lines @@
 }  // namespace
 
 AcmReceiver::AcmReceiver(const AudioCodingModule::Config& config)
     : crit_sect_(CriticalSectionWrapper::CreateCriticalSection()),
       id_(config.id),
       last_audio_decoder_(nullptr),
       previous_audio_activity_(AudioFrame::kVadPassive),
       current_sample_rate_hz_(config.neteq_config.sample_rate_hz),
       audio_buffer_(new int16_t[AudioFrame::kMaxDataSizeSamples]),
       last_audio_buffer_(new int16_t[AudioFrame::kMaxDataSizeSamples]),
-      nack_(),
-      nack_enabled_(false),
       neteq_(NetEq::Create(config.neteq_config)),
       vad_enabled_(true),
       clock_(config.clock),
       resampled_last_output_frame_(true),
       av_sync_(false),
       initial_delay_manager_(),
       missing_packets_sync_stream_(),
       late_packets_sync_stream_() {
   assert(clock_);
 
@@ skipping 102 matching lines @@
       packet_type = InitialDelayManager::kCngPacket;
     } else if (decoder->acm_codec_id ==
                *RentACodec::CodecIndexFromId(RentACodec::CodecId::kAVT)) {
       packet_type = InitialDelayManager::kAvtPacket;
     } else {
       if (decoder != last_audio_decoder_) {
         // This is either the first audio packet or send codec is changed.
         // Therefore, either NetEq buffer is empty or will be flushed when this
         // packet is inserted.
         new_codec = true;
-
-        // Updating NACK'sampling rate is required, either first packet is
-        // received or codec is changed. Furthermore, reset is required if codec
-        // is changed (NetEq flushes its buffer so NACK should reset its list).
-        if (nack_enabled_) {
-          assert(nack_.get());
-          nack_->Reset();
-          nack_->UpdateSampleRate(sample_rate_hz);
-        }
         last_audio_decoder_ = decoder;
       }
       packet_type = InitialDelayManager::kAudioPacket;
     }
 
-    if (nack_enabled_) {
-      assert(nack_.get());
-      nack_->UpdateLastReceivedPacket(header->sequenceNumber,
-                                      header->timestamp);
-    }
-
     if (av_sync_) {
       assert(initial_delay_manager_.get());
       assert(missing_packets_sync_stream_.get());
       // This updates |initial_delay_manager_| and specifies an stream of
       // sync-packets, if required to be inserted. We insert the sync-packets
       // when AcmReceiver lock is released and |decoder_lock_| is acquired.
       initial_delay_manager_->UpdateLastReceivedPacket(
           rtp_header, receive_timestamp, packet_type, new_codec, sample_rate_hz,
           missing_packets_sync_stream_.get());
     }
@@ skipping 50 matching lines @@
   // Always write the output to |audio_buffer_| first.
   if (neteq_->GetAudio(AudioFrame::kMaxDataSizeSamples,
                        audio_buffer_.get(),
                        &samples_per_channel,
                        &num_channels,
                        &type) != NetEq::kOK) {
     LOG(LERROR) << "AcmReceiver::GetAudio - NetEq Failed.";
     return -1;
   }
 
-  // Update NACK.
-  int decoded_sequence_num = 0;
-  uint32_t decoded_timestamp = 0;
-  bool update_nack = nack_enabled_ &&  // Update NACK only if it is enabled.
-      neteq_->DecodedRtpInfo(&decoded_sequence_num, &decoded_timestamp);
-  if (update_nack) {
-    assert(nack_.get());
-    nack_->UpdateLastDecodedPacket(decoded_sequence_num, decoded_timestamp);
-  }
-
   // NetEq always returns 10 ms of audio.
   current_sample_rate_hz_ = static_cast<int>(samples_per_channel * 100);
 
   // Update if resampling is required.
   bool need_resampling = (desired_freq_hz != -1) &&
       (current_sample_rate_hz_ != desired_freq_hz);
 
   if (need_resampling && !resampled_last_output_frame_) {
     // Prime the resampler with the last frame.
     int16_t temp_output[AudioFrame::kMaxDataSizeSamples];
@@ skipping 266 matching lines @@
   const Decoder& decoder = it->second;
   memcpy(codec, &ACMCodecDB::database_[decoder.acm_codec_id],
          sizeof(CodecInst));
   codec->pltype = decoder.payload_type;
   codec->channels = decoder.channels;
   codec->plfreq = decoder.sample_rate_hz;
   return 0;
 }
 
 int AcmReceiver::EnableNack(size_t max_nack_list_size) {
-  // Don't do anything if |max_nack_list_size| is out of range.
-  if (max_nack_list_size == 0 || max_nack_list_size > Nack::kNackListSizeLimit)
-    return -1;
-
-  CriticalSectionScoped lock(crit_sect_.get());
-  if (!nack_enabled_) {
-    nack_.reset(Nack::Create(kNackThresholdPackets));
-    nack_enabled_ = true;
-
-    // Sampling rate might need to be updated if we change from disable to
-    // enable. Do it if the receive codec is valid.
-    if (last_audio_decoder_) {
-      nack_->UpdateSampleRate(
-          ACMCodecDB::database_[last_audio_decoder_->acm_codec_id].plfreq);
-    }
-  }
-  return nack_->SetMaxNackListSize(max_nack_list_size);
+  neteq_->EnableNack(max_nack_list_size);
+  return 0;
 }
 
 void AcmReceiver::DisableNack() {
-  CriticalSectionScoped lock(crit_sect_.get());
-  nack_.reset();  // Memory is released.
-  nack_enabled_ = false;
+  neteq_->DisableNack();
 }
 
 std::vector<uint16_t> AcmReceiver::GetNackList(
     int64_t round_trip_time_ms) const {
-  CriticalSectionScoped lock(crit_sect_.get());
-  if (round_trip_time_ms < 0) {
-    WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceAudioCoding, id_,
-                 "GetNackList: round trip time cannot be negative."
-                 " round_trip_time_ms=%" PRId64, round_trip_time_ms);
-  }
-  if (nack_enabled_ && round_trip_time_ms >= 0) {
-    assert(nack_.get());
-    return nack_->GetNackList(round_trip_time_ms);
-  }
-  std::vector<uint16_t> empty_list;
-  return empty_list;
+  return neteq_->GetNackList(round_trip_time_ms);
 }
 
 void AcmReceiver::ResetInitialDelay() {
   {
     CriticalSectionScoped lock(crit_sect_.get());
     av_sync_ = false;
     initial_delay_manager_.reset(NULL);
     missing_packets_sync_stream_.reset(NULL);
     late_packets_sync_stream_.reset(NULL);
   }
@@ skipping 94 matching lines @@
 
 void AcmReceiver::GetDecodingCallStatistics(
     AudioDecodingCallStats* stats) const {
   CriticalSectionScoped lock(crit_sect_.get());
   *stats = call_stats_.GetDecodingStatistics();
 }
 
 }  // namespace acm2
 
 }  // namespace webrtc