Convert CNG into C++ and remove it from AudioDecoder

webrtc/modules/audio_coding/neteq/neteq_impl.cc

 /*
  *  Copyright (c) 2012 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/neteq/neteq_impl.h"
 
 #include <assert.h>
 #include <memory.h>  // memset
 
 #include <algorithm>
+#include <vector>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/safe_conversions.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
 #include "webrtc/modules/audio_coding/codecs/audio_decoder.h"
 #include "webrtc/modules/audio_coding/neteq/accelerate.h"
 #include "webrtc/modules/audio_coding/neteq/background_noise.h"
 #include "webrtc/modules/audio_coding/neteq/buffer_level_filter.h"
@@ skipping 630 matching lines @@
     switch (ret) {
       case PayloadSplitter::kUnknownPayloadType:
         return kUnknownRtpPayloadType;
       case PayloadSplitter::kFrameSplitError:
         return kFrameSplitError;
       default:
         return kOtherError;
     }
   }
 
-  // Update bandwidth estimate, if the packet is not sync-packet.
-  if (!packet_list.empty() && !packet_list.front()->sync_packet) {
+  // Update bandwidth estimate, if the packet is not sync-packet nor comfort
+  // noise.
+  if (!packet_list.empty() && !packet_list.front()->sync_packet &&
+      !decoder_database_->IsComfortNoise(main_header.payloadType)) {
     // The list can be empty here if we got nothing but DTMF payloads.
     AudioDecoder* decoder =
         decoder_database_->GetDecoder(main_header.payloadType);
     assert(decoder);  // Should always get a valid object, since we have
-                      // already checked that the payload types are known.
+    // already checked that the payload types are known.
     decoder->IncomingPacket(packet_list.front()->payload,
                             packet_list.front()->payload_length,
                             packet_list.front()->header.sequenceNumber,
                             packet_list.front()->header.timestamp,
                             receive_timestamp);
   }
 
   if (nack_enabled_) {
     RTC_DCHECK(nack_);
     if (update_sample_rate_and_channels) {
@@ skipping 37 matching lines @@
   if (update_sample_rate_and_channels && !packet_buffer_->Empty()) {
     // We do not use |current_rtp_payload_type_| to |set payload_type|, but
     // get the next RTP header from |packet_buffer_| to obtain the payload type.
     // The reason for it is the following corner case. If NetEq receives a
     // CNG packet with a sample rate different than the current CNG then it
     // flushes its buffer, assuming send codec must have been changed. However,
     // payload type of the hypothetically new send codec is not known.
     const RTPHeader* rtp_header = packet_buffer_->NextRtpHeader();
     assert(rtp_header);
     int payload_type = rtp_header->payloadType;
-    AudioDecoder* decoder = decoder_database_->GetDecoder(payload_type);
-    assert(decoder);  // Payloads are already checked to be valid.
+    size_t channels = 1;
+    if (!decoder_database_->IsComfortNoise(payload_type)) {
+      AudioDecoder* decoder = decoder_database_->GetDecoder(payload_type);
+      assert(decoder);  // Payloads are already checked to be valid.
+      channels = decoder->Channels();
+    }
     const DecoderDatabase::DecoderInfo* decoder_info =
         decoder_database_->GetDecoderInfo(payload_type);
     assert(decoder_info);
     if (decoder_info->fs_hz != fs_hz_ ||
-        decoder->Channels() != algorithm_buffer_->Channels()) {
-      SetSampleRateAndChannels(decoder_info->fs_hz, decoder->Channels());
+        channels != algorithm_buffer_->Channels()) {
+      SetSampleRateAndChannels(decoder_info->fs_hz, channels);
     }
     if (nack_enabled_) {
       RTC_DCHECK(nack_);
       // Update the sample rate even if the rate is not new, because of Reset().
       nack_->UpdateSampleRate(fs_hz_);
     }
   }
 
   // TODO(hlundin): Move this code to DelayManager class.
   const DecoderDatabase::DecoderInfo* dec_info =
@@ skipping 541 matching lines @@
       }
     }
   }
 
   if (reset_decoder_) {
     // TODO(hlundin): Write test for this.
     if (decoder)
       decoder->Reset();
 
     // Reset comfort noise decoder.
-    AudioDecoder* cng_decoder = decoder_database_->GetActiveCngDecoder();
+    ComfortNoiseDecoder* cng_decoder = decoder_database_->GetActiveCngDecoder();
     if (cng_decoder)
       cng_decoder->Reset();
 
     reset_decoder_ = false;
   }
 
 #ifdef LEGACY_BITEXACT
   // Due to a bug in old SignalMCU, it could happen that CNG operation was
   // decided, but a speech packet was provided. The speech packet will be used
   // to update the comfort noise decoder, as if it was a SID frame, which is
@@ skipping 637 matching lines @@
       } else {
         if (packet->primary) {
           packet_duration = decoder->PacketDuration(packet->payload,
                                                     packet->payload_length);
         } else {
           packet_duration = decoder->
               PacketDurationRedundant(packet->payload, packet->payload_length);
           stats_.SecondaryDecodedSamples(packet_duration);
         }
       }
-    } else {
+    } else if (!decoder_database_->IsComfortNoise(packet->header.payloadType)) {
       LOG(LS_WARNING) << "Unknown payload type "
                       << static_cast<int>(packet->header.payloadType);
       assert(false);
     }
     if (packet_duration <= 0) {
       // Decoder did not return a packet duration. Assume that the packet
       // contains the same number of samples as the previous one.
       packet_duration = rtc::checked_cast<int>(decoder_frame_length_);
     }
     extracted_samples = packet->header.timestamp - first_timestamp +
@@ skipping 47 matching lines @@
   decoder_frame_length_ = 3 * output_size_samples_;  // Initialize to 30ms.
 
   last_mode_ = kModeNormal;
 
   // Create a new array of mute factors and set all to 1.
   mute_factor_array_.reset(new int16_t[channels]);
   for (size_t i = 0; i < channels; ++i) {
     mute_factor_array_[i] = 16384;  // 1.0 in Q14.
   }
 
-  AudioDecoder* cng_decoder = decoder_database_->GetActiveCngDecoder();
+  ComfortNoiseDecoder* cng_decoder = decoder_database_->GetActiveCngDecoder();
   if (cng_decoder)
     cng_decoder->Reset();
 
   // Reinit post-decode VAD with new sample rate.
   assert(vad_.get());  // Cannot be NULL here.
   vad_->Init();
 
   // Delete algorithm buffer and create a new one.
   algorithm_buffer_.reset(new AudioMultiVector(channels));
 
@@ skipping 58 matching lines @@
 
 void NetEqImpl::CreateDecisionLogic() {
   decision_logic_.reset(DecisionLogic::Create(fs_hz_, output_size_samples_,
                                               playout_mode_,
                                               decoder_database_.get(),
                                               *packet_buffer_.get(),
                                               delay_manager_.get(),
                                               buffer_level_filter_.get()));
 }
 }  // namespace webrtc