Convert CNG into C++ and remove it from AudioDecoder

webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng.cc

 /*
  *  Copyright (c) 2014 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/codecs/cng/audio_encoder_cng.h"
 
 #include <algorithm>
 #include <memory>
 #include <limits>
 #include <utility>
 
 namespace webrtc {
 
 namespace {
 
 const int kMaxFrameSizeMs = 60;
 
-std::unique_ptr<CNG_enc_inst, CngInstDeleter> CreateCngInst(
-    int sample_rate_hz,
-    int sid_frame_interval_ms,
-    int num_cng_coefficients) {
-  CNG_enc_inst* ci;
-  RTC_CHECK_EQ(0, WebRtcCng_CreateEnc(&ci));
-  std::unique_ptr<CNG_enc_inst, CngInstDeleter> cng_inst(ci);
-  RTC_CHECK_EQ(0,
-               WebRtcCng_InitEnc(cng_inst.get(), sample_rate_hz,
-                                 sid_frame_interval_ms, num_cng_coefficients));
-  return cng_inst;
-}
-
 }  // namespace
 
 AudioEncoderCng::Config::Config() = default;
 AudioEncoderCng::Config::Config(Config&&) = default;
 AudioEncoderCng::Config::~Config() = default;
 
 bool AudioEncoderCng::Config::IsOk() const {
   if (num_channels != 1)
     return false;
   if (!speech_encoder)
@@ skipping 11 matching lines @@
 
 AudioEncoderCng::AudioEncoderCng(Config&& config)
     : speech_encoder_(
           ([&] { RTC_CHECK(config.IsOk()) << "Invalid configuration."; }(),
            std::move(config.speech_encoder))),
       cng_payload_type_(config.payload_type),
       num_cng_coefficients_(config.num_cng_coefficients),
       sid_frame_interval_ms_(config.sid_frame_interval_ms),
       last_frame_active_(true),
       vad_(config.vad ? std::unique_ptr<Vad>(config.vad)
-                      : CreateVad(config.vad_mode)) {
-  cng_inst_ = CreateCngInst(SampleRateHz(), sid_frame_interval_ms_,
-                            num_cng_coefficients_);
+           : CreateVad(config.vad_mode)),
+      cng_encoder_(new ComfortNoiseEncoder(SampleRateHz(),
+                                           sid_frame_interval_ms_,
+                                           num_cng_coefficients_)) {
 }
 
 AudioEncoderCng::~AudioEncoderCng() = default;
 
 int AudioEncoderCng::SampleRateHz() const {
   return speech_encoder_->SampleRateHz();
 }
 
 size_t AudioEncoderCng::NumChannels() const {
   return 1;
@@ skipping 82 matching lines @@
                         rtp_timestamps_.begin() + frames_to_encode);
   return info;
 }
 
 void AudioEncoderCng::Reset() {
   speech_encoder_->Reset();
   speech_buffer_.clear();
   rtp_timestamps_.clear();
   last_frame_active_ = true;
   vad_->Reset();
-  cng_inst_ = CreateCngInst(SampleRateHz(), sid_frame_interval_ms_,
-                            num_cng_coefficients_);
+  cng_encoder_.reset(
+      new ComfortNoiseEncoder(SampleRateHz(), sid_frame_interval_ms_,
+                              num_cng_coefficients_));
 }
 
 bool AudioEncoderCng::SetFec(bool enable) {
   return speech_encoder_->SetFec(enable);
 }
 
 bool AudioEncoderCng::SetDtx(bool enable) {
   return speech_encoder_->SetDtx(enable);
 }
 
@@ skipping 12 matching lines @@
 void AudioEncoderCng::SetTargetBitrate(int bits_per_second) {
   speech_encoder_->SetTargetBitrate(bits_per_second);
 }
 
 AudioEncoder::EncodedInfo AudioEncoderCng::EncodePassive(
     size_t frames_to_encode,
     rtc::Buffer* encoded) {
   bool force_sid = last_frame_active_;
   bool output_produced = false;
   const size_t samples_per_10ms_frame = SamplesPer10msFrame();
-  const size_t bytes_to_encode = frames_to_encode * samples_per_10ms_frame;
   AudioEncoder::EncodedInfo info;
 
-  encoded->AppendData(bytes_to_encode, [&] (rtc::ArrayView<uint8_t> encoded) {
-      for (size_t i = 0; i < frames_to_encode; ++i) {
-        // It's important not to pass &info.encoded_bytes directly to
-        // WebRtcCng_Encode(), since later loop iterations may return zero in
-        // that value, in which case we don't want to overwrite any value from
-        // an earlier iteration.
-        size_t encoded_bytes_tmp = 0;
-        RTC_CHECK_GE(
-            WebRtcCng_Encode(cng_inst_.get(),
-                             &speech_buffer_[i * samples_per_10ms_frame],
-                             samples_per_10ms_frame, encoded.data(),
-                             &encoded_bytes_tmp, force_sid),
-            0);
-        if (encoded_bytes_tmp > 0) {
-          RTC_CHECK(!output_produced);
-          info.encoded_bytes = encoded_bytes_tmp;
-          output_produced = true;
-          force_sid = false;
-        }
-      }
+  for (size_t i = 0; i < frames_to_encode; ++i) {
+    // It's important not to pass &info.encoded_bytes directly to
+    // WebRtcCng_Encode(), since later loop iterations may return zero in
+    // that value, in which case we don't want to overwrite any value from
+    // an earlier iteration.
+    size_t encoded_bytes_tmp =
+        cng_encoder_->Encode(
+            rtc::ArrayView<const int16_t>(
+                &speech_buffer_[i * samples_per_10ms_frame],
+                samples_per_10ms_frame),
+            force_sid, encoded);
 
-      return info.encoded_bytes;
-    });
+    if (encoded_bytes_tmp > 0) {
+      RTC_CHECK(!output_produced);
+      info.encoded_bytes = encoded_bytes_tmp;
+      output_produced = true;
+      force_sid = false;
+    }
+  }
 
   info.encoded_timestamp = rtp_timestamps_.front();
   info.payload_type = cng_payload_type_;
   info.send_even_if_empty = true;
   info.speech = false;
   return info;
 }
 
 AudioEncoder::EncodedInfo AudioEncoderCng::EncodeActive(
     size_t frames_to_encode,
@@ skipping 15 matching lines @@
     }
   }
   return info;
 }
 
 size_t AudioEncoderCng::SamplesPer10msFrame() const {
   return rtc::CheckedDivExact(10 * SampleRateHz(), 1000);
 }
 
 }  // namespace webrtc