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

webrtc/modules/audio_coding/neteq/tools/neteq_rtpplay.cc

 /*
  *  Copyright (c) 2013 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 129 matching lines @@
 DEFINE_string(ssrc,
               "",
               "Only use packets with this SSRC (decimal or hex, the latter "
               "starting with 0x)");
 const bool hex_ssrc_dummy =
     google::RegisterFlagValidator(&FLAGS_ssrc, &ValidateSsrcValue);
 
 // Maps a codec type to a printable name string.
 std::string CodecName(webrtc::NetEqDecoder codec) {
   switch (codec) {
-    case webrtc::kDecoderPCMu:
+    case webrtc::NetEqDecoder::kDecoderPCMu:
       return "PCM-u";
-    case webrtc::kDecoderPCMa:
+    case webrtc::NetEqDecoder::kDecoderPCMa:
       return "PCM-a";
-    case webrtc::kDecoderILBC:
+    case webrtc::NetEqDecoder::kDecoderILBC:
       return "iLBC";
-    case webrtc::kDecoderISAC:
+    case webrtc::NetEqDecoder::kDecoderISAC:
       return "iSAC";
-    case webrtc::kDecoderISACswb:
+    case webrtc::NetEqDecoder::kDecoderISACswb:
       return "iSAC-swb (32 kHz)";
-    case webrtc::kDecoderOpus:
+    case webrtc::NetEqDecoder::kDecoderOpus:
       return "Opus";
-    case webrtc::kDecoderPCM16B:
+    case webrtc::NetEqDecoder::kDecoderPCM16B:
       return "PCM16b-nb (8 kHz)";
-    case webrtc::kDecoderPCM16Bwb:
+    case webrtc::NetEqDecoder::kDecoderPCM16Bwb:
       return "PCM16b-wb (16 kHz)";
-    case webrtc::kDecoderPCM16Bswb32kHz:
+    case webrtc::NetEqDecoder::kDecoderPCM16Bswb32kHz:
       return "PCM16b-swb32 (32 kHz)";
-    case webrtc::kDecoderPCM16Bswb48kHz:
+    case webrtc::NetEqDecoder::kDecoderPCM16Bswb48kHz:
       return "PCM16b-swb48 (48 kHz)";
-    case webrtc::kDecoderG722:
+    case webrtc::NetEqDecoder::kDecoderG722:
       return "G.722";
-    case webrtc::kDecoderRED:
+    case webrtc::NetEqDecoder::kDecoderRED:
       return "redundant audio (RED)";
-    case webrtc::kDecoderAVT:
+    case webrtc::NetEqDecoder::kDecoderAVT:
       return "AVT/DTMF";
-    case webrtc::kDecoderCNGnb:
+    case webrtc::NetEqDecoder::kDecoderCNGnb:
       return "comfort noise (8 kHz)";
-    case webrtc::kDecoderCNGwb:
+    case webrtc::NetEqDecoder::kDecoderCNGwb:
       return "comfort noise (16 kHz)";
-    case webrtc::kDecoderCNGswb32kHz:
+    case webrtc::NetEqDecoder::kDecoderCNGswb32kHz:
       return "comfort noise (32 kHz)";
-    case webrtc::kDecoderCNGswb48kHz:
+    case webrtc::NetEqDecoder::kDecoderCNGswb48kHz:
       return "comfort noise (48 kHz)";
     default:
       assert(false);
       return "undefined";
   }
 }
 
 void RegisterPayloadType(NetEq* neteq,
                          webrtc::NetEqDecoder codec,
                          google::int32 flag) {
   if (neteq->RegisterPayloadType(codec, static_cast<uint8_t>(flag))) {
     std::cerr << "Cannot register payload type " << flag << " as "
               << CodecName(codec) << std::endl;
     exit(1);
   }
 }
 
 // Registers all decoders in |neteq|.
 void RegisterPayloadTypes(NetEq* neteq) {
   assert(neteq);
-  RegisterPayloadType(neteq, webrtc::kDecoderPCMu, FLAGS_pcmu);
-  RegisterPayloadType(neteq, webrtc::kDecoderPCMa, FLAGS_pcma);
-  RegisterPayloadType(neteq, webrtc::kDecoderILBC, FLAGS_ilbc);
-  RegisterPayloadType(neteq, webrtc::kDecoderISAC, FLAGS_isac);
-  RegisterPayloadType(neteq, webrtc::kDecoderISACswb, FLAGS_isac_swb);
-  RegisterPayloadType(neteq, webrtc::kDecoderOpus, FLAGS_opus);
-  RegisterPayloadType(neteq, webrtc::kDecoderPCM16B, FLAGS_pcm16b);
-  RegisterPayloadType(neteq, webrtc::kDecoderPCM16Bwb, FLAGS_pcm16b_wb);
-  RegisterPayloadType(neteq, webrtc::kDecoderPCM16Bswb32kHz,
+  RegisterPayloadType(neteq, webrtc::NetEqDecoder::kDecoderPCMu, FLAGS_pcmu);
+  RegisterPayloadType(neteq, webrtc::NetEqDecoder::kDecoderPCMa, FLAGS_pcma);
+  RegisterPayloadType(neteq, webrtc::NetEqDecoder::kDecoderILBC, FLAGS_ilbc);
+  RegisterPayloadType(neteq, webrtc::NetEqDecoder::kDecoderISAC, FLAGS_isac);
+  RegisterPayloadType(neteq, webrtc::NetEqDecoder::kDecoderISACswb,
+                      FLAGS_isac_swb);
+  RegisterPayloadType(neteq, webrtc::NetEqDecoder::kDecoderOpus, FLAGS_opus);
+  RegisterPayloadType(neteq, webrtc::NetEqDecoder::kDecoderPCM16B,
+                      FLAGS_pcm16b);
+  RegisterPayloadType(neteq, webrtc::NetEqDecoder::kDecoderPCM16Bwb,
+                      FLAGS_pcm16b_wb);
+  RegisterPayloadType(neteq, webrtc::NetEqDecoder::kDecoderPCM16Bswb32kHz,
                       FLAGS_pcm16b_swb32);
-  RegisterPayloadType(neteq, webrtc::kDecoderPCM16Bswb48kHz,
+  RegisterPayloadType(neteq, webrtc::NetEqDecoder::kDecoderPCM16Bswb48kHz,
                       FLAGS_pcm16b_swb48);
-  RegisterPayloadType(neteq, webrtc::kDecoderG722, FLAGS_g722);
-  RegisterPayloadType(neteq, webrtc::kDecoderAVT, FLAGS_avt);
-  RegisterPayloadType(neteq, webrtc::kDecoderRED, FLAGS_red);
-  RegisterPayloadType(neteq, webrtc::kDecoderCNGnb, FLAGS_cn_nb);
-  RegisterPayloadType(neteq, webrtc::kDecoderCNGwb, FLAGS_cn_wb);
-  RegisterPayloadType(neteq, webrtc::kDecoderCNGswb32kHz, FLAGS_cn_swb32);
-  RegisterPayloadType(neteq, webrtc::kDecoderCNGswb48kHz, FLAGS_cn_swb48);
+  RegisterPayloadType(neteq, webrtc::NetEqDecoder::kDecoderG722, FLAGS_g722);
+  RegisterPayloadType(neteq, webrtc::NetEqDecoder::kDecoderAVT, FLAGS_avt);
+  RegisterPayloadType(neteq, webrtc::NetEqDecoder::kDecoderRED, FLAGS_red);
+  RegisterPayloadType(neteq, webrtc::NetEqDecoder::kDecoderCNGnb, FLAGS_cn_nb);
+  RegisterPayloadType(neteq, webrtc::NetEqDecoder::kDecoderCNGwb, FLAGS_cn_wb);
+  RegisterPayloadType(neteq, webrtc::NetEqDecoder::kDecoderCNGswb32kHz,
+                      FLAGS_cn_swb32);
+  RegisterPayloadType(neteq, webrtc::NetEqDecoder::kDecoderCNGswb48kHz,
+                      FLAGS_cn_swb48);
 }
 
 void PrintCodecMappingEntry(webrtc::NetEqDecoder codec, google::int32 flag) {
   std::cout << CodecName(codec) << ": " << flag << std::endl;
 }
 
 void PrintCodecMapping() {
-  PrintCodecMappingEntry(webrtc::kDecoderPCMu, FLAGS_pcmu);
-  PrintCodecMappingEntry(webrtc::kDecoderPCMa, FLAGS_pcma);
-  PrintCodecMappingEntry(webrtc::kDecoderILBC, FLAGS_ilbc);
-  PrintCodecMappingEntry(webrtc::kDecoderISAC, FLAGS_isac);
-  PrintCodecMappingEntry(webrtc::kDecoderISACswb, FLAGS_isac_swb);
-  PrintCodecMappingEntry(webrtc::kDecoderOpus, FLAGS_opus);
-  PrintCodecMappingEntry(webrtc::kDecoderPCM16B, FLAGS_pcm16b);
-  PrintCodecMappingEntry(webrtc::kDecoderPCM16Bwb, FLAGS_pcm16b_wb);
-  PrintCodecMappingEntry(webrtc::kDecoderPCM16Bswb32kHz, FLAGS_pcm16b_swb32);
-  PrintCodecMappingEntry(webrtc::kDecoderPCM16Bswb48kHz, FLAGS_pcm16b_swb48);
-  PrintCodecMappingEntry(webrtc::kDecoderG722, FLAGS_g722);
-  PrintCodecMappingEntry(webrtc::kDecoderAVT, FLAGS_avt);
-  PrintCodecMappingEntry(webrtc::kDecoderRED, FLAGS_red);
-  PrintCodecMappingEntry(webrtc::kDecoderCNGnb, FLAGS_cn_nb);
-  PrintCodecMappingEntry(webrtc::kDecoderCNGwb, FLAGS_cn_wb);
-  PrintCodecMappingEntry(webrtc::kDecoderCNGswb32kHz, FLAGS_cn_swb32);
-  PrintCodecMappingEntry(webrtc::kDecoderCNGswb48kHz, FLAGS_cn_swb48);
+  PrintCodecMappingEntry(webrtc::NetEqDecoder::kDecoderPCMu, FLAGS_pcmu);
+  PrintCodecMappingEntry(webrtc::NetEqDecoder::kDecoderPCMa, FLAGS_pcma);
+  PrintCodecMappingEntry(webrtc::NetEqDecoder::kDecoderILBC, FLAGS_ilbc);
+  PrintCodecMappingEntry(webrtc::NetEqDecoder::kDecoderISAC, FLAGS_isac);
+  PrintCodecMappingEntry(webrtc::NetEqDecoder::kDecoderISACswb, FLAGS_isac_swb);
+  PrintCodecMappingEntry(webrtc::NetEqDecoder::kDecoderOpus, FLAGS_opus);
+  PrintCodecMappingEntry(webrtc::NetEqDecoder::kDecoderPCM16B, FLAGS_pcm16b);
+  PrintCodecMappingEntry(webrtc::NetEqDecoder::kDecoderPCM16Bwb,
+                         FLAGS_pcm16b_wb);
+  PrintCodecMappingEntry(webrtc::NetEqDecoder::kDecoderPCM16Bswb32kHz,
+                         FLAGS_pcm16b_swb32);
+  PrintCodecMappingEntry(webrtc::NetEqDecoder::kDecoderPCM16Bswb48kHz,
+                         FLAGS_pcm16b_swb48);
+  PrintCodecMappingEntry(webrtc::NetEqDecoder::kDecoderG722, FLAGS_g722);
+  PrintCodecMappingEntry(webrtc::NetEqDecoder::kDecoderAVT, FLAGS_avt);
+  PrintCodecMappingEntry(webrtc::NetEqDecoder::kDecoderRED, FLAGS_red);
+  PrintCodecMappingEntry(webrtc::NetEqDecoder::kDecoderCNGnb, FLAGS_cn_nb);
+  PrintCodecMappingEntry(webrtc::NetEqDecoder::kDecoderCNGwb, FLAGS_cn_wb);
+  PrintCodecMappingEntry(webrtc::NetEqDecoder::kDecoderCNGswb32kHz,
+                         FLAGS_cn_swb32);
+  PrintCodecMappingEntry(webrtc::NetEqDecoder::kDecoderCNGswb48kHz,
+                         FLAGS_cn_swb48);
 }
 
 bool IsComfortNoise(uint8_t payload_type) {
   return payload_type == FLAGS_cn_nb || payload_type == FLAGS_cn_wb ||
       payload_type == FLAGS_cn_swb32 || payload_type == FLAGS_cn_swb48;
 }
 
 int CodecSampleRate(uint8_t payload_type) {
   if (payload_type == FLAGS_pcmu || payload_type == FLAGS_pcma ||
       payload_type == FLAGS_ilbc || payload_type == FLAGS_pcm16b ||
@@ skipping 376 matching lines @@
     }
   }
   printf("Simulation done\n");
   printf("Produced %i ms of audio\n",
          static_cast<int>(time_now_ms - start_time_ms));
 
   delete neteq;
   webrtc::Trace::ReturnTrace();
   return 0;
 }