Make an enum class out of NetEqDecoder, and hide the neteq_decoders_ table

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 72 matching lines @@
                                int* bitrate,
                                int* useRed);
 int NetEQTest_init_coders(webrtc::NetEqDecoder coder,
                           size_t enc_frameSize,
                           int bitrate,
                           int sampfreq,
                           int vad,
                           size_t numChannels);
 void defineCodecs(webrtc::NetEqDecoder* usedCodec, int* noOfCodecs);
 int NetEQTest_free_coders(webrtc::NetEqDecoder coder, size_t numChannels);
-size_t NetEQTest_encode(int coder,
+size_t NetEQTest_encode(webrtc::NetEqDecoder coder,
                         int16_t* indata,
                         size_t frameLen,
                         unsigned char* encoded,
                         int sampleRate,
                         int* vad,
                         int useVAD,
                         int bitrate,
                         size_t numChannels);
 void makeRTPheader(unsigned char* rtp_data,
                    int payloadType,
@@ skipping 377 matching lines @@
       defined(CODEC_CNGCODEC32) || defined(CODEC_CNGCODEC48))
   if (useVAD != 0) {
     printf("Error: this simulation does not support VAD/DTX/CNG\n");
   }
 #endif
 
   // check stereo type
   if (usingStereo) {
     switch (usedCodec) {
       // sample based codecs
-      case webrtc::kDecoderPCMu:
-      case webrtc::kDecoderPCMa:
-      case webrtc::kDecoderG722: {
+      case webrtc::NetEqDecoder::kDecoderPCMu:
+      case webrtc::NetEqDecoder::kDecoderPCMa:
+      case webrtc::NetEqDecoder::kDecoderG722: {
         // 1 octet per sample
         stereoMode = STEREO_MODE_SAMPLE_1;
         break;
       }
-      case webrtc::kDecoderPCM16B:
-      case webrtc::kDecoderPCM16Bwb:
-      case webrtc::kDecoderPCM16Bswb32kHz:
-      case webrtc::kDecoderPCM16Bswb48kHz: {
+      case webrtc::NetEqDecoder::kDecoderPCM16B:
+      case webrtc::NetEqDecoder::kDecoderPCM16Bwb:
+      case webrtc::NetEqDecoder::kDecoderPCM16Bswb32kHz:
+      case webrtc::NetEqDecoder::kDecoderPCM16Bswb48kHz: {
         // 2 octets per sample
         stereoMode = STEREO_MODE_SAMPLE_2;
         break;
       }
 
       // fixed-rate frame codecs (with internal VAD)
       default: {
         printf("Cannot use codec %s as stereo codec\n", argv[4]);
         exit(0);
       }
     }
   }
 
-  if ((usedCodec == webrtc::kDecoderISAC) ||
-      (usedCodec == webrtc::kDecoderISACswb)) {
+  if ((usedCodec == webrtc::NetEqDecoder::kDecoderISAC) ||
+      (usedCodec == webrtc::NetEqDecoder::kDecoderISACswb)) {
     if (argc != 7) {
-      if (usedCodec == webrtc::kDecoderISAC) {
+      if (usedCodec == webrtc::NetEqDecoder::kDecoderISAC) {
         bitrate = 32000;
         printf("Running iSAC at default bitrate of 32000 bps (to specify "
                "explicitly add the bps as last parameter)\n");
       } else  // (usedCodec==webrtc::kDecoderISACswb)
       {
         bitrate = 56000;
         printf("Running iSAC at default bitrate of 56000 bps (to specify "
                "explicitly add the bps as last parameter)\n");
       }
     } else {
       bitrate = atoi(argv[6]);
-      if (usedCodec == webrtc::kDecoderISAC) {
+      if (usedCodec == webrtc::NetEqDecoder::kDecoderISAC) {
         if ((bitrate < 10000) || (bitrate > 32000)) {
           printf("Error: iSAC bitrate must be between 10000 and 32000 bps (%i "
                  "is invalid)\n", bitrate);
           exit(0);
         }
         printf("Running iSAC at bitrate of %i bps\n", bitrate);
       } else  // (usedCodec==webrtc::kDecoderISACswb)
       {
         if ((bitrate < 32000) || (bitrate > 56000)) {
           printf("Error: iSAC SWB bitrate must be between 32000 and 56000 bps "
                  "(%i is invalid)\n", bitrate);
           exit(0);
         }
       }
     }
   } else {
     if (argc == 7) {
       printf("Error: Bitrate parameter can only be specified for iSAC, G.723, "
              "and G.729.1\n");
       exit(0);
     }
   }
 
   if (useRed) {
     printf("Redundancy engaged. ");
   }
-  printf("Used codec: %i\n", usedCodec);
+  printf("Used codec: %i\n", static_cast<int>(usedCodec));
   printf("Payload type: %i\n", payloadType);
 
   NetEQTest_init_coders(usedCodec, packet_size, bitrate, fs, useVAD,
                         numChannels);
 
   /* write file header */
   // fprintf(out_file, "#!RTPencode%s\n", "1.0");
   fprintf(out_file, "#!rtpplay%s \n",
           "1.0");               // this is the string that rtpplay needs
   uint32_t dummy_variable = 0;  // should be converted to network endian format,
@@ skipping 202 matching lines @@
         old_enc_len = enc_len;
         first_old_packet = 0;
         packet_age = 0;
       }
       packet_age += packet_size;
 #endif
 
       if (useRed) {
 /* move data to redundancy store */
 #ifdef CODEC_ISAC
-        if (usedCodec == webrtc::kDecoderISAC) {
+        if (usedCodec == webrtc::NetEqDecoder::kDecoderISAC) {
           assert(!usingStereo);  // Cannot handle stereo yet
           red_len[0] = WebRtcIsac_GetRedPayload(ISAC_inst[0], red_data);
         } else {
 #endif
           memcpy(red_data, &rtp_data[RTPheaderLen + red_len[0]], enc_len);
           red_len[0] = red_len[1];
 #ifdef CODEC_ISAC
         }
 #endif
         red_TS[0] = red_TS[1];
@@ skipping 32 matching lines @@
                                webrtc::NetEqDecoder* codec,
                                int* PT,
                                size_t frameLen,
                                int* fs,
                                int* bitrate,
                                int* useRed) {
   *bitrate = 0; /* Default bitrate setting */
   *useRed = 0;  /* Default no redundancy */
 
   if (!strcmp(name, "pcmu")) {
-    *codec = webrtc::kDecoderPCMu;
+    *codec = webrtc::NetEqDecoder::kDecoderPCMu;
     *PT = NETEQ_CODEC_PCMU_PT;
     *fs = 8000;
   } else if (!strcmp(name, "pcma")) {
-    *codec = webrtc::kDecoderPCMa;
+    *codec = webrtc::NetEqDecoder::kDecoderPCMa;
     *PT = NETEQ_CODEC_PCMA_PT;
     *fs = 8000;
   } else if (!strcmp(name, "pcm16b")) {
-    *codec = webrtc::kDecoderPCM16B;
+    *codec = webrtc::NetEqDecoder::kDecoderPCM16B;
     *PT = NETEQ_CODEC_PCM16B_PT;
     *fs = 8000;
   } else if (!strcmp(name, "pcm16b_wb")) {
-    *codec = webrtc::kDecoderPCM16Bwb;
+    *codec = webrtc::NetEqDecoder::kDecoderPCM16Bwb;
     *PT = NETEQ_CODEC_PCM16B_WB_PT;
     *fs = 16000;
   } else if (!strcmp(name, "pcm16b_swb32")) {
-    *codec = webrtc::kDecoderPCM16Bswb32kHz;
+    *codec = webrtc::NetEqDecoder::kDecoderPCM16Bswb32kHz;
     *PT = NETEQ_CODEC_PCM16B_SWB32KHZ_PT;
     *fs = 32000;
   } else if (!strcmp(name, "pcm16b_swb48")) {
-    *codec = webrtc::kDecoderPCM16Bswb48kHz;
+    *codec = webrtc::NetEqDecoder::kDecoderPCM16Bswb48kHz;
     *PT = NETEQ_CODEC_PCM16B_SWB48KHZ_PT;
     *fs = 48000;
   } else if (!strcmp(name, "g722")) {
-    *codec = webrtc::kDecoderG722;
+    *codec = webrtc::NetEqDecoder::kDecoderG722;
     *PT = NETEQ_CODEC_G722_PT;
     *fs = 16000;
   } else if ((!strcmp(name, "ilbc")) &&
              ((frameLen % 240 == 0) || (frameLen % 160 == 0))) {
     *fs = 8000;
-    *codec = webrtc::kDecoderILBC;
+    *codec = webrtc::NetEqDecoder::kDecoderILBC;
     *PT = NETEQ_CODEC_ILBC_PT;
   } else if (!strcmp(name, "isac")) {
     *fs = 16000;
-    *codec = webrtc::kDecoderISAC;
+    *codec = webrtc::NetEqDecoder::kDecoderISAC;
     *PT = NETEQ_CODEC_ISAC_PT;
   } else if (!strcmp(name, "isacswb")) {
     *fs = 32000;
-    *codec = webrtc::kDecoderISACswb;
+    *codec = webrtc::NetEqDecoder::kDecoderISACswb;
     *PT = NETEQ_CODEC_ISACSWB_PT;
   } else if (!strcmp(name, "red_pcm")) {
-    *codec = webrtc::kDecoderPCMa;
+    *codec = webrtc::NetEqDecoder::kDecoderPCMa;
     *PT = NETEQ_CODEC_PCMA_PT; /* this will be the PT for the sub-headers */
     *fs = 8000;
     *useRed = 1;
   } else if (!strcmp(name, "red_isac")) {
-    *codec = webrtc::kDecoderISAC;
+    *codec = webrtc::NetEqDecoder::kDecoderISAC;
     *PT = NETEQ_CODEC_ISAC_PT; /* this will be the PT for the sub-headers */
     *fs = 16000;
     *useRed = 1;
   } else {
     printf("Error: Not a supported codec (%s)\n", name);
     exit(0);
   }
 }
 
 int NetEQTest_init_coders(webrtc::NetEqDecoder coder,
@@ skipping 28 matching lines @@
       if (ok == -1) {
         printf("Error: Initialization of CNG struct failed. Error code %d\n",
                WebRtcCng_GetErrorCodeEnc(CNGenc_inst[k]));
         exit(0);
       }
     }
 #endif
 
     switch (coder) {
 #ifdef CODEC_PCM16B
-      case webrtc::kDecoderPCM16B:
+      case webrtc::NetEqDecoder::kDecoderPCM16B:
 #endif
 #ifdef CODEC_PCM16B_WB
-      case webrtc::kDecoderPCM16Bwb:
+      case webrtc::NetEqDecoder::kDecoderPCM16Bwb:
 #endif
 #ifdef CODEC_PCM16B_32KHZ
-      case webrtc::kDecoderPCM16Bswb32kHz:
+      case webrtc::NetEqDecoder::kDecoderPCM16Bswb32kHz:
 #endif
 #ifdef CODEC_PCM16B_48KHZ
-      case webrtc::kDecoderPCM16Bswb48kHz:
+      case webrtc::NetEqDecoder::kDecoderPCM16Bswb48kHz:
 #endif
 #ifdef CODEC_G711
-      case webrtc::kDecoderPCMu:
-      case webrtc::kDecoderPCMa:
+      case webrtc::NetEqDecoder::kDecoderPCMu:
+      case webrtc::NetEqDecoder::kDecoderPCMa:
 #endif
         // do nothing
         break;
 #ifdef CODEC_G729
       case webrtc::kDecoderG729:
         if (sampfreq == 8000) {
           if ((enc_frameSize == 80) || (enc_frameSize == 160) ||
               (enc_frameSize == 240) || (enc_frameSize == 320) ||
               (enc_frameSize == 400) || (enc_frameSize == 480)) {
             ok = WebRtcG729_CreateEnc(&G729enc_inst[k]);
@@ skipping 229 matching lines @@
           }
           WebRtcG7221C_EncoderInit48(
               (G722_1C_48_encinst_t*)G722_1C_48enc_inst[k]);
         } else {
           printf("\nError - G722.1 C is only developed for 32kHz \n");
           exit(0);
         }
         break;
 #endif
 #ifdef CODEC_G722
-      case webrtc::kDecoderG722:
+      case webrtc::NetEqDecoder::kDecoderG722:
         if (sampfreq == 16000) {
           if (enc_frameSize % 2 == 0) {
           } else {
             printf(
                 "\nError - g722 frames must have an even number of "
                 "enc_frameSize\n");
             exit(0);
           }
           WebRtcG722_CreateEncoder(&g722EncState[k]);
           WebRtcG722_EncoderInit(g722EncState[k]);
@@ skipping 62 matching lines @@
           }
           WebRtcAmrWb_EncodeBitmode(AMRWBenc_inst[k], AMRBandwidthEfficient);
 
         } else {
           printf("\nError - AMRwb is only developed for 16kHz \n");
           exit(0);
         }
         break;
 #endif
 #ifdef CODEC_ILBC
-      case webrtc::kDecoderILBC:
+      case webrtc::NetEqDecoder::kDecoderILBC:
         if (sampfreq == 8000) {
           ok = WebRtcIlbcfix_EncoderCreate(&iLBCenc_inst[k]);
           if (ok != 0) {
             printf("Error: Couldn't allocate memory for iLBC encoding "
                    "instance\n");
             exit(0);
           }
           if ((enc_frameSize == 160) || (enc_frameSize == 240) ||
               (enc_frameSize == 320) || (enc_frameSize == 480)) {
           } else {
             printf("\nError - iLBC only supports 160, 240, 320 and 480 "
                    "enc_frameSize (20, 30, 40 and 60 ms)\n");
             exit(0);
           }
           if ((enc_frameSize == 160) || (enc_frameSize == 320)) {
             /* 20 ms version */
             WebRtcIlbcfix_EncoderInit(iLBCenc_inst[k], 20);
           } else {
             /* 30 ms version */
             WebRtcIlbcfix_EncoderInit(iLBCenc_inst[k], 30);
           }
         } else {
           printf("\nError - iLBC is only developed for 8kHz \n");
           exit(0);
         }
         break;
 #endif
 #ifdef CODEC_ISAC
-      case webrtc::kDecoderISAC:
+      case webrtc::NetEqDecoder::kDecoderISAC:
         if (sampfreq == 16000) {
           ok = WebRtcIsac_Create(&ISAC_inst[k]);
           if (ok != 0) {
             printf("Error: Couldn't allocate memory for iSAC instance\n");
             exit(0);
           }
           if ((enc_frameSize == 480) || (enc_frameSize == 960)) {
           } else {
             printf("\nError - iSAC only supports frameSize (30 and 60 ms)\n");
             exit(0);
@@ skipping 35 matching lines @@
           }
           WebRtcIsacfix_Control(ISAC_inst[k], bitrate, enc_frameSize >> 4);
         } else {
           printf("\nError - iSAC only supports 480 or 960 enc_frameSize (30 or "
                  "60 ms)\n");
           exit(0);
         }
         break;
 #endif
 #ifdef CODEC_ISAC_SWB
-      case webrtc::kDecoderISACswb:
+      case webrtc::NetEqDecoder::kDecoderISACswb:
         if (sampfreq == 32000) {
           ok = WebRtcIsac_Create(&ISACSWB_inst[k]);
           if (ok != 0) {
             printf("Error: Couldn't allocate memory for iSAC SWB instance\n");
             exit(0);
           }
           if (enc_frameSize == 960) {
           } else {
             printf("\nError - iSAC SWB only supports frameSize 30 ms\n");
             exit(0);
@@ skipping 58 matching lines @@
 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]);
 #endif
 
     switch (coder) {
 #ifdef CODEC_PCM16B
-      case webrtc::kDecoderPCM16B:
+      case webrtc::NetEqDecoder::kDecoderPCM16B:
 #endif
 #ifdef CODEC_PCM16B_WB
-      case webrtc::kDecoderPCM16Bwb:
+      case webrtc::NetEqDecoder::kDecoderPCM16Bwb:
 #endif
 #ifdef CODEC_PCM16B_32KHZ
-      case webrtc::kDecoderPCM16Bswb32kHz:
+      case webrtc::NetEqDecoder::kDecoderPCM16Bswb32kHz:
 #endif
 #ifdef CODEC_PCM16B_48KHZ
-      case webrtc::kDecoderPCM16Bswb48kHz:
+      case webrtc::NetEqDecoder::kDecoderPCM16Bswb48kHz:
 #endif
 #ifdef CODEC_G711
-      case webrtc::kDecoderPCMu:
-      case webrtc::kDecoderPCMa:
+      case webrtc::NetEqDecoder::kDecoderPCMu:
+      case webrtc::NetEqDecoder::kDecoderPCMa:
 #endif
         // do nothing
         break;
 #ifdef CODEC_G729
-      case webrtc::kDecoderG729:
+      case webrtc::NetEqDecoder::kDecoderG729:
         WebRtcG729_FreeEnc(G729enc_inst[k]);
         break;
 #endif
 #ifdef CODEC_G729_1
-      case webrtc::kDecoderG729_1:
+      case webrtc::NetEqDecoder::kDecoderG729_1:
         WebRtcG7291_Free(G729_1_inst[k]);
         break;
 #endif
 #ifdef CODEC_SPEEX_8
-      case webrtc::kDecoderSPEEX_8:
+      case webrtc::NetEqDecoder::kDecoderSPEEX_8:
         WebRtcSpeex_FreeEnc(SPEEX8enc_inst[k]);
         break;
 #endif
 #ifdef CODEC_SPEEX_16
-      case webrtc::kDecoderSPEEX_16:
+      case webrtc::NetEqDecoder::kDecoderSPEEX_16:
         WebRtcSpeex_FreeEnc(SPEEX16enc_inst[k]);
         break;
 #endif
 
 #ifdef CODEC_G722_1_16
-      case webrtc::kDecoderG722_1_16:
+      case webrtc::NetEqDecoder::kDecoderG722_1_16:
         WebRtcG7221_FreeEnc16(G722_1_16enc_inst[k]);
         break;
 #endif
 #ifdef CODEC_G722_1_24
-      case webrtc::kDecoderG722_1_24:
+      case webrtc::NetEqDecoder::kDecoderG722_1_24:
         WebRtcG7221_FreeEnc24(G722_1_24enc_inst[k]);
         break;
 #endif
 #ifdef CODEC_G722_1_32
-      case webrtc::kDecoderG722_1_32:
+      case webrtc::NetEqDecoder::kDecoderG722_1_32:
         WebRtcG7221_FreeEnc32(G722_1_32enc_inst[k]);
         break;
 #endif
 #ifdef CODEC_G722_1C_24
-      case webrtc::kDecoderG722_1C_24:
+      case webrtc::NetEqDecoder::kDecoderG722_1C_24:
         WebRtcG7221C_FreeEnc24(G722_1C_24enc_inst[k]);
         break;
 #endif
 #ifdef CODEC_G722_1C_32
-      case webrtc::kDecoderG722_1C_32:
+      case webrtc::NetEqDecoder::kDecoderG722_1C_32:
         WebRtcG7221C_FreeEnc32(G722_1C_32enc_inst[k]);
         break;
 #endif
 #ifdef CODEC_G722_1C_48
-      case webrtc::kDecoderG722_1C_48:
+      case webrtc::NetEqDecoder::kDecoderG722_1C_48:
         WebRtcG7221C_FreeEnc48(G722_1C_48enc_inst[k]);
         break;
 #endif
 #ifdef CODEC_G722
-      case webrtc::kDecoderG722:
+      case webrtc::NetEqDecoder::kDecoderG722:
         WebRtcG722_FreeEncoder(g722EncState[k]);
         break;
 #endif
 #ifdef CODEC_AMR
-      case webrtc::kDecoderAMR:
+      case webrtc::NetEqDecoder::kDecoderAMR:
         WebRtcAmr_FreeEnc(AMRenc_inst[k]);
         break;
 #endif
 #ifdef CODEC_AMRWB
-      case webrtc::kDecoderAMRWB:
+      case webrtc::NetEqDecoder::kDecoderAMRWB:
         WebRtcAmrWb_FreeEnc(AMRWBenc_inst[k]);
         break;
 #endif
 #ifdef CODEC_ILBC
-      case webrtc::kDecoderILBC:
+      case webrtc::NetEqDecoder::kDecoderILBC:
         WebRtcIlbcfix_EncoderFree(iLBCenc_inst[k]);
         break;
 #endif
 #ifdef CODEC_ISAC
-      case webrtc::kDecoderISAC:
+      case webrtc::NetEqDecoder::kDecoderISAC:
         WebRtcIsac_Free(ISAC_inst[k]);
         break;
 #endif
 #ifdef NETEQ_ISACFIX_CODEC
-      case webrtc::kDecoderISAC:
+      case webrtc::NetEqDecoder::kDecoderISAC:
         WebRtcIsacfix_Free(ISAC_inst[k]);
         break;
 #endif
 #ifdef CODEC_ISAC_SWB
-      case webrtc::kDecoderISACswb:
+      case webrtc::NetEqDecoder::kDecoderISACswb:
         WebRtcIsac_Free(ISACSWB_inst[k]);
         break;
 #endif
 #ifdef CODEC_GSMFR
-      case webrtc::kDecoderGSMFR:
+      case webrtc::NetEqDecoder::kDecoderGSMFR:
         WebRtcGSMFR_FreeEnc(GSMFRenc_inst[k]);
         break;
 #endif
       default:
         printf("Error: unknown codec in call to NetEQTest_init_coders.\n");
         exit(0);
         break;
     }
   }
 
   return (0);
 }
 
-size_t NetEQTest_encode(int coder,
+size_t NetEQTest_encode(webrtc::NetEqDecoder coder,
                         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;
@@ skipping 51 matching lines @@
       first_cng = 0;
       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::kDecoderPCMu) { /*g711 u-law */
+    if (coder == webrtc::NetEqDecoder::kDecoderPCMu) { /*g711 u-law */
 #ifdef CODEC_G711
       cdlen = WebRtcG711_EncodeU(indata, frameLen, encoded);
 #endif
-    } else if (coder == webrtc::kDecoderPCMa) { /*g711 A-law */
+    } else if (coder == webrtc::NetEqDecoder::kDecoderPCMa) { /*g711 A-law */
 #ifdef CODEC_G711
       cdlen = WebRtcG711_EncodeA(indata, frameLen, encoded);
     }
 #endif
 #ifdef CODEC_PCM16B
-    else if ((coder == webrtc::kDecoderPCM16B) ||
-             (coder == webrtc::kDecoderPCM16Bwb) ||
-             (coder == webrtc::kDecoderPCM16Bswb32kHz) ||
-             (coder == webrtc::
+    else if ((coder == webrtc::NetEqDecoder::kDecoderPCM16B) ||
+             (coder == webrtc::NetEqDecoder::kDecoderPCM16Bwb) ||
+             (coder == webrtc::NetEqDecoder::kDecoderPCM16Bswb32kHz) ||
+             (coder == webrtc::NetEqDecoder::
                            kDecoderPCM16Bswb48kHz)) { /*pcm16b (8kHz, 16kHz,
-                                                         32kHz or 48kHz) */
+                                                        32kHz or 48kHz) */
       cdlen = WebRtcPcm16b_Encode(indata, frameLen, encoded);
     }
 #endif
 #ifdef CODEC_G722
-    else if (coder == webrtc::kDecoderG722) { /*g722 */
+    else if (coder == webrtc::NetEqDecoder::kDecoderG722) { /*g722 */
       cdlen = WebRtcG722_Encode(g722EncState[k], indata, frameLen, encoded);
       assert(cdlen == frameLen >> 1);
     }
 #endif
 #ifdef CODEC_ILBC
-    else if (coder == webrtc::kDecoderILBC) { /*iLBC */
+    else if (coder == webrtc::NetEqDecoder::kDecoderILBC) { /*iLBC */
       cdlen = static_cast<size_t>(std::max(
           WebRtcIlbcfix_Encode(iLBCenc_inst[k], indata, frameLen, encoded), 0));
     }
 #endif
 #if (defined(CODEC_ISAC) || \
      defined(NETEQ_ISACFIX_CODEC))            // TODO(hlundin): remove all
                                               // NETEQ_ISACFIX_CODEC
-    else if (coder == webrtc::kDecoderISAC) { /*iSAC */
+    else if (coder == webrtc::NetEqDecoder::kDecoderISAC) { /*iSAC */
       int noOfCalls = 0;
       int res = 0;
       while (res <= 0) {
 #ifdef CODEC_ISAC /* floating point */
         res =
             WebRtcIsac_Encode(ISAC_inst[k], &indata[noOfCalls * 160], encoded);
 #else /* fixed point */
         res = WebRtcIsacfix_Encode(ISAC_inst[k], &indata[noOfCalls * 160],
                                    encoded);
 #endif
         noOfCalls++;
       }
       cdlen = static_cast<size_t>(res);
     }
 #endif
 #ifdef CODEC_ISAC_SWB
-    else if (coder == webrtc::kDecoderISACswb) { /* iSAC SWB */
+    else if (coder == webrtc::NetEqDecoder::kDecoderISACswb) { /* iSAC SWB */
       int noOfCalls = 0;
       int res = 0;
       while (res <= 0) {
         res = WebRtcIsac_Encode(ISACSWB_inst[k], &indata[noOfCalls * 320],
                                 encoded);
         noOfCalls++;
       }
       cdlen = static_cast<size_t>(res);
     }
 #endif
@@ skipping 147 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;
   }
 }