Convert CNG into C++ and remove it from AudioDecoder

webrtc/modules/audio_coding/neteq/test/RTPencode.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.
  */
 
@@ skipping 247 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];
+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);
-    }
     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] = new webrtc::ComfortNoiseEncoder(sampfreq, 200, 5);
     }
 #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]);
+    delete CNG_encoder[k];
+    CNG_encoder[k] = nullptr;
 #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 118 matching lines @@
                         int16_t* indata,
                         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;
+  static bool first_cng = true;
   size_t tempLen;
   *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 size_t sampleRate_10 = static_cast<size_t>(10 * sampleRate / 1000);
+    const size_t sampleRate_20 = static_cast<size_t>(20 * sampleRate / 1000);
+    const size_t sampleRate_30 = static_cast<size_t>(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 11 matching lines @@
           tempLen -= sampleRate_10;
         }
       }
 
       // aggregate all VAD decisions over all channels
       *vad |= localVad;
     }
 
     if (!*vad) {
       // all channels are silent
+      rtc::Buffer workaround;
       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);
+        workaround.Clear();
+        tempLen = CNG_encoder[k]->Encode(
+            rtc::ArrayView<const int16_t>(
+                &indata[k * frameLen],
+                (frameLen <= 640 ? frameLen : 640) /* max 640 */),
+            first_cng,
+            &workaround);
+        memcpy(encoded, workaround.data(), tempLen);
         encoded += tempLen;
         cdlen += tempLen;
       }
       *vad = 0;
-      first_cng = 0;
+      first_cng = false;
       return (cdlen);
     }
   }
 
   // loop over all channels
   size_t totalLen = 0;
 
   for (size_t k = 0; k < numChannels; k++) {
     /* Encode with the selected coder type */
     if (coder == webrtc::NetEqDecoder::kDecoderPCMu) { /*g711 u-law */
@@ skipping 62 matching lines @@
     cdlen = WebRtcOpus_Encode(opus_inst[k], indata, frameLen, kRtpDataSize - 12,
                               encoded);
     RTC_CHECK_GT(cdlen, 0u);
 #endif
     indata += frameLen;
     encoded += cdlen;
     totalLen += cdlen;
 
   }  // end for
 
-  first_cng = 1;
+  first_cng = true;
   return (totalLen);
 }
 
 void makeRTPheader(unsigned char* rtp_data,
                    int payloadType,
                    int seqNo,
                    uint32_t timestamp,
                    uint32_t ssrc) {
   rtp_data[0] = 0x80;
   rtp_data[1] = payloadType & 0xFF;
@@ skipping 130 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;
   }
 }