Convert CNG into C++ and remove it from AudioDecoder

webrtc/modules/audio_coding/neteq/test/RTPencode.cc

 /*

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

I'm truly sorry that you have to deal with this really old and equally ugly
piece of code. It will be the first against the wall when the revolution
comes...

[ossu, 2016/04/13 11:57:07]

Aww. It's alright. I've seen worse. :)

  *  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.
  */
 
 // TODO(hlundin): Reformat file to meet style guide.
@@ skipping 246 matching lines @@
 ISACFIX_MainStruct* ISAC_inst[2];
 #endif
 #ifdef CODEC_ISAC_SWB
 ISACStruct* ISACSWB_inst[2];
 #endif
 #ifdef CODEC_GSMFR
 GSMFR_encinst_t* GSMFRenc_inst[2];
 #endif
 #if (defined(CODEC_CNGCODEC8) || defined(CODEC_CNGCODEC16) || \
      defined(CODEC_CNGCODEC32) || defined(CODEC_CNGCODEC48))
-CNG_enc_inst* CNGenc_inst[2];
+std::unique_ptr<webrtc::ComfortNoiseEncoder> CNG_encoder[2];
 #endif
 #ifdef CODEC_SPEEX_8
 SPEEX_encinst_t* SPEEX8enc_inst[2];
 #endif
 #ifdef CODEC_SPEEX_16
 SPEEX_encinst_t* SPEEX16enc_inst[2];
 #endif
 #ifdef CODEC_OPUS
 OpusEncInst* opus_inst[2];
 #endif
@@ skipping 642 matching lines @@
       exit(0);
     }
     ok = WebRtcVad_Init(VAD_inst[k]);
     if (ok == -1) {
       printf("Error: Initialization of VAD struct failed\n");
       exit(0);
     }
 
 #if (defined(CODEC_CNGCODEC8) || defined(CODEC_CNGCODEC16) || \
      defined(CODEC_CNGCODEC32) || defined(CODEC_CNGCODEC48))
-    ok = WebRtcCng_CreateEnc(&CNGenc_inst[k]);
-    if (ok != 0) {
-      printf("Error: Couldn't allocate memory for CNG encoding instance\n");
-      exit(0);
-    }
+    // TODO(ossu): Why <= 16000?
     if (sampfreq <= 16000) {
-      ok = WebRtcCng_InitEnc(CNGenc_inst[k], sampfreq, 200, 5);
-      if (ok == -1) {
-        printf("Error: Initialization of CNG struct failed. Error code %d\n",
-               WebRtcCng_GetErrorCodeEnc(CNGenc_inst[k]));
-        exit(0);
-      }
+      CNG_encoder[k].reset(new webrtc::ComfortNoiseEncoder(sampfreq, 200, 5));

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

The old code created but didn't initialize a CNG encoder if sampfreq > 16000.
Was that an error?

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

I ... don't know. I put a TODO comment about that just above, hoping someone
would enlighten me. It seems CNG only supports up to 16k (according to its
docs). Maybe there needed to be a valid, bad state for all encoders, so that if
something used it later, it would fail with NOT_INITIALIZED rather than probably
generate garbage that no-one would notice.

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

I think we've always said that we only support CNG up to 16 kHz. There is no
technical limitation that prevents higher sample rates, but from a protocol
point of view we have not supported the combination of a super-wideband (>16
kHz) codec with CNG. As for the other peculiarities in this file, all bets are
off.

[ossu, 2016/04/13 11:57:07]

Acknowledged.

     }
 #endif
 
     switch (coder) {
 #ifdef CODEC_PCM16B
       case webrtc::NetEqDecoder::kDecoderPCM16B:
 #endif
 #ifdef CODEC_PCM16B_WB
       case webrtc::NetEqDecoder::kDecoderPCM16Bwb:
 #endif
@@ skipping 501 matching lines @@
   }  // end for
 
   return (0);
 }
 
 int NetEQTest_free_coders(webrtc::NetEqDecoder coder, size_t numChannels) {
   for (size_t k = 0; k < numChannels; k++) {
     WebRtcVad_Free(VAD_inst[k]);
 #if (defined(CODEC_CNGCODEC8) || defined(CODEC_CNGCODEC16) || \
      defined(CODEC_CNGCODEC32) || defined(CODEC_CNGCODEC48))
-    WebRtcCng_FreeEnc(CNGenc_inst[k]);
+    CNG_encoder[k].reset();
 #endif
 
     switch (coder) {
 #ifdef CODEC_PCM16B
       case webrtc::NetEqDecoder::kDecoderPCM16B:
 #endif
 #ifdef CODEC_PCM16B_WB
       case webrtc::NetEqDecoder::kDecoderPCM16Bwb:
 #endif
 #ifdef CODEC_PCM16B_32KHZ
@@ skipping 119 matching lines @@
                         size_t frameLen,
                         unsigned char* encoded,
                         int sampleRate,
                         int* vad,
                         int useVAD,
                         int bitrate,
                         size_t numChannels) {
   size_t cdlen = 0;
   int16_t* tempdata;
   static int first_cng = 1;
-  size_t tempLen;
+  int tempLen;

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

Why change this?

[ossu, 2016/04/13 11:57:07]

Because ComfortNoiseEncoder->Encode returns an int that needs to be checked for
-1. Though if we change that I can change this back.

   *vad = 1;
 
   // check VAD first
   if (useVAD) {
     *vad = 0;
 
-    size_t sampleRate_10 = static_cast<size_t>(10 * sampleRate / 1000);
-    size_t sampleRate_20 = static_cast<size_t>(20 * sampleRate / 1000);
-    size_t sampleRate_30 = static_cast<size_t>(30 * sampleRate / 1000);
+    const int sampleRate_10 = 10 * sampleRate / 1000;

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

And these?

[ossu, 2016/04/13 11:57:07]

Because changing tempLen to int caused a warning about unsigned vs. signed
comparisons. As with that one, I'll probably put it back and change Encode
instead.

+    const int sampleRate_20 = 20 * sampleRate / 1000;
+    const int sampleRate_30 = 30 * sampleRate / 1000;
     for (size_t k = 0; k < numChannels; k++) {
       tempLen = frameLen;
       tempdata = &indata[k * frameLen];
       int localVad = 0;
       /* Partition the signal and test each chunk for VAD.
          All chunks must be VAD=0 to produce a total VAD=0. */
       while (tempLen >= sampleRate_10) {
         if ((tempLen % sampleRate_30) == 0) {  // tempLen is multiple of 30ms
           localVad |= WebRtcVad_Process(VAD_inst[k], sampleRate, tempdata,
                                         sampleRate_30);
@@ skipping 13 matching lines @@
       }
 
       // aggregate all VAD decisions over all channels
       *vad |= localVad;
     }
 
     if (!*vad) {
       // all channels are silent
       cdlen = 0;
       for (size_t k = 0; k < numChannels; k++) {
-        WebRtcCng_Encode(CNGenc_inst[k], &indata[k * frameLen],
-                         (frameLen <= 640 ? frameLen : 640) /* max 640 */,
-                         encoded, &tempLen, first_cng);
+        tempLen = CNG_encoder[k]->Encode(
+            rtc::ArrayView<const int16_t>(
+                &indata[k * frameLen],
+                (frameLen <= 640 ? frameLen : 640) /* max 640 */),
+            // TODO(ossu): kRtpDataSize is wrong to use here, but we should be
+            // fine.
+            rtc::ArrayView<uint8_t>(encoded, kRtpDataSize),
+            first_cng);
+        RTC_CHECK_GE(tempLen, 0);
         encoded += tempLen;
         cdlen += tempLen;
       }
       *vad = 0;
       first_cng = 0;
       return (cdlen);
     }
   }
 
   // loop over all channels
@@ skipping 218 matching lines @@
     memmove(ptrL + stride, ptrL, ptrR - ptrL);
 
     // copy from temp to left pointer
     memcpy(ptrL, temp, stride);
 
     // advance pointers
     ptrL += stride * 2;
     ptrR += stride;
   }
 }