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;
 
 // TODO(kwiberg): =default this when Visual Studio learns to handle it.
 AudioEncoderCng::Config::Config(Config&& c)
     : num_channels(c.num_channels),
       payload_type(c.payload_type),
       speech_encoder(std::move(c.speech_encoder)),
       vad_mode(c.vad_mode),
@@ skipping 21 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;
 
 size_t AudioEncoderCng::MaxEncodedBytes() const {
   const size_t max_encoded_bytes_active = speech_encoder_->MaxEncodedBytes();
   const size_t max_encoded_bytes_passive =
       rtc::CheckedDivExact(kMaxFrameSizeMs, 10) * SamplesPer10msFrame();
   return std::max(max_encoded_bytes_active, max_encoded_bytes_passive);
 }
@@ skipping 89 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_));

[kwiberg-webrtc, 2016/04/12 13:35:30]

A small utility function in an anonymous namespace that returns a
unique_ptr<ComfortNoiseEncoder>?

[ossu, 2016/04/12 13:54:49]

Actually, there's a Reset method in it right now, that I bet I could use... not
sure it should remain in, though.

 }
 
 bool AudioEncoderCng::SetFec(bool enable) {
   return speech_encoder_->SetFec(enable);
 }
 
 bool AudioEncoderCng::SetDtx(bool enable) {
   return speech_encoder_->SetDtx(enable);
 }
 
@@ skipping 21 matching lines @@
   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);
+        int encoded_bytes_tmp =
+            cng_encoder_->Encode(
+                rtc::ArrayView<const int16_t>(
+                    &speech_buffer_[i * samples_per_10ms_frame],
+                    samples_per_10ms_frame),
+                encoded, force_sid);
+        RTC_CHECK_GE(encoded_bytes_tmp, 0);

[kwiberg-webrtc, 2016/04/12 13:35:30]

Use rtc::Optional<size_t> if you need to return an error. But as I said, I agree
that Encode can probably just explode if called with invalid inputs.

Also, consider passing the Buffer* into Encode instead of an ArrayView. That
way, you completely remove the possibility of it being too small.

[ossu, 2016/04/12 13:54:49]

Yeah, Buffer is probably better. It's what we want to move to in general,
internally, anyway, right?

[hlundin-webrtc, 2016/04/13 07:05:23]

I'm fine with using a Buffer as well. But bear in mind that CNG is a special
breed. The length of the encoded data has no correlation with the number of
samples inserted. It will just estimate a predetermined number of noise
parameters from the input.

[kwiberg-webrtc, 2016/04/14 09:42:47]

Meaning its output length is a small constant? It probably doesn't hurt to use a
Buffer anyway---that way, callers won't depend on that constant, and the
interface is simpler.

         if (encoded_bytes_tmp > 0) {
           RTC_CHECK(!output_produced);
           info.encoded_bytes = encoded_bytes_tmp;
           output_produced = true;
           force_sid = false;
         }
       }
 
       return info.encoded_bytes;
     });
@@ skipping 25 matching lines @@
     }
   }
   return info;
 }
 
 size_t AudioEncoderCng::SamplesPer10msFrame() const {
   return rtc::CheckedDivExact(10 * SampleRateHz(), 1000);
 }
 
 }  // namespace webrtc