Multi frequency DTMF support - receiver side

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

Index: webrtc/modules/audio_coding/neteq/tools/neteq_rtpplay.cc
diff --git a/webrtc/modules/audio_coding/neteq/tools/neteq_rtpplay.cc b/webrtc/modules/audio_coding/neteq/tools/neteq_rtpplay.cc
index f22459332aa7667e79e815e30b6959aa04313448..4e26ff6693baf8b8c7dd896ac04ee28102ae75cb 100644
--- a/webrtc/modules/audio_coding/neteq/tools/neteq_rtpplay.cc
+++ b/webrtc/modules/audio_coding/neteq/tools/neteq_rtpplay.cc
@@ -116,9 +116,18 @@ const bool pcm16b_swb48_dummy =
 DEFINE_int32(g722, 9, "RTP payload type for G.722");
 const bool g722_dummy =
     google::RegisterFlagValidator(&FLAGS_g722, &ValidatePayloadType);
-DEFINE_int32(avt, 106, "RTP payload type for AVT/DTMF");
-const bool avt_dummy =
-    google::RegisterFlagValidator(&FLAGS_avt, &ValidatePayloadType);
+DEFINE_int32(avt_nb, 106, "RTP payload type for AVT/DTMF (8 kHz)");
+const bool avt_nb_dummy =
+    google::RegisterFlagValidator(&FLAGS_avt_nb, &ValidatePayloadType);
+DEFINE_int32(avt_wb, 114, "RTP payload type for AVT/DTMF (16 kHz)");   // TODO:
+const bool avt_wb_dummy =
+    google::RegisterFlagValidator(&FLAGS_avt_wb, &ValidatePayloadType);
+DEFINE_int32(avt_swb32, 115, "RTP payload type for AVT/DTMF (32 kHz)");   // TODO:
+const bool avt_swb32_dummy =
+    google::RegisterFlagValidator(&FLAGS_avt_swb32, &ValidatePayloadType);
+DEFINE_int32(avt_swb48, 116, "RTP payload type for AVT/DTMF (48 kHz)");   // TODO:
+const bool avt_swb48_dummy =
+    google::RegisterFlagValidator(&FLAGS_avt_swb48, &ValidatePayloadType);
 DEFINE_int32(red, 117, "RTP payload type for redundant audio (RED)");
 const bool red_dummy =
     google::RegisterFlagValidator(&FLAGS_red, &ValidatePayloadType);
@@ -178,8 +187,14 @@ std::string CodecName(NetEqDecoder codec) {
       return "G.722";
     case NetEqDecoder::kDecoderRED:
       return "redundant audio (RED)";
-    case NetEqDecoder::kDecoderAVT:
-      return "AVT/DTMF";
+    case NetEqDecoder::kDecoderAVT8kHz:
+      return "AVT/DTMF (8 kHz)";
+    case NetEqDecoder::kDecoderAVT16kHz:
+      return "AVT/DTMF (16 kHz)";
+    case NetEqDecoder::kDecoderAVT32kHz:
+      return "AVT/DTMF (32 kHz)";
+    case NetEqDecoder::kDecoderAVT48kHz:
+      return "AVT/DTMF (48 kHz)";
     case NetEqDecoder::kDecoderCNGnb:
       return "comfort noise (8 kHz)";
     case NetEqDecoder::kDecoderCNGwb:
@@ -212,7 +227,10 @@ void PrintCodecMapping() {
   PrintCodecMappingEntry(NetEqDecoder::kDecoderPCM16Bswb48kHz,
                          FLAGS_pcm16b_swb48);
   PrintCodecMappingEntry(NetEqDecoder::kDecoderG722, FLAGS_g722);
-  PrintCodecMappingEntry(NetEqDecoder::kDecoderAVT, FLAGS_avt);
+  PrintCodecMappingEntry(NetEqDecoder::kDecoderAVT8kHz, FLAGS_avt_nb);
+  PrintCodecMappingEntry(NetEqDecoder::kDecoderAVT16kHz, FLAGS_avt_wb);
+  PrintCodecMappingEntry(NetEqDecoder::kDecoderAVT32kHz, FLAGS_avt_swb32);
+  PrintCodecMappingEntry(NetEqDecoder::kDecoderAVT48kHz, FLAGS_avt_swb48);
   PrintCodecMappingEntry(NetEqDecoder::kDecoderRED, FLAGS_red);
   PrintCodecMappingEntry(NetEqDecoder::kDecoderCNGnb, FLAGS_cn_nb);
   PrintCodecMappingEntry(NetEqDecoder::kDecoderCNGwb, FLAGS_cn_wb);
@@ -223,18 +241,19 @@ void PrintCodecMapping() {
 int CodecSampleRate(uint8_t payload_type) {
   if (payload_type == FLAGS_pcmu || payload_type == FLAGS_pcma ||
       payload_type == FLAGS_ilbc || payload_type == FLAGS_pcm16b ||
-      payload_type == FLAGS_cn_nb)
+      payload_type == FLAGS_cn_nb || payload_type == FLAGS_avt_nb)
     return 8000;
   if (payload_type == FLAGS_isac || payload_type == FLAGS_pcm16b_wb ||
-      payload_type == FLAGS_g722 || payload_type == FLAGS_cn_wb)
+      payload_type == FLAGS_g722 || payload_type == FLAGS_cn_wb ||
+      payload_type == FLAGS_avt_wb)
     return 16000;
   if (payload_type == FLAGS_isac_swb || payload_type == FLAGS_pcm16b_swb32 ||
-      payload_type == FLAGS_cn_swb32)
+      payload_type == FLAGS_cn_swb32 || payload_type == FLAGS_avt_swb32)
     return 32000;
   if (payload_type == FLAGS_opus || payload_type == FLAGS_pcm16b_swb48 ||
-      payload_type == FLAGS_cn_swb48)
+      payload_type == FLAGS_cn_swb48 || payload_type == FLAGS_avt_swb48)
     return 48000;
-  if (payload_type == FLAGS_avt || payload_type == FLAGS_red)

[ossu, 2016/10/04 09:26:57]

Why could this be 0 before but not anymore?

[the sun, 2016/10/08 22:06:51]

It couldn't. Previously, a WAVE file with SR=0 would be produced if the stream
only contained DTMF.

[ossu, 2016/10/10 23:26:34]

Acknowledged.

+  if (payload_type == FLAGS_red)
     return 0;
   return -1;
 }
@@ -375,7 +394,12 @@ int RunTest(int argc, char* argv[]) {
       {FLAGS_pcm16b_swb48,
        std::make_pair(NetEqDecoder::kDecoderPCM16Bswb48kHz, "pcm16-swb48")},
       {FLAGS_g722, std::make_pair(NetEqDecoder::kDecoderG722, "g722")},
-      {FLAGS_avt, std::make_pair(NetEqDecoder::kDecoderAVT, "avt")},
+      {FLAGS_avt_nb, std::make_pair(NetEqDecoder::kDecoderAVT8kHz, "avt-nb")},
+      {FLAGS_avt_wb, std::make_pair(NetEqDecoder::kDecoderAVT16kHz, "avt-wb")},
+      {FLAGS_avt_swb32,
+       std::make_pair(NetEqDecoder::kDecoderAVT32kHz, "avt-swb32")},
+      {FLAGS_avt_swb48,
+       std::make_pair(NetEqDecoder::kDecoderAVT48kHz, "avt-swb48")},
       {FLAGS_red, std::make_pair(NetEqDecoder::kDecoderRED, "red")},
       {FLAGS_cn_nb, std::make_pair(NetEqDecoder::kDecoderCNGnb, "cng-nb")},
       {FLAGS_cn_wb, std::make_pair(NetEqDecoder::kDecoderCNGwb, "cng-wb")},
@@ -407,7 +431,9 @@ int RunTest(int argc, char* argv[]) {
     std::set<uint8_t> cn_types = std_set_int32_to_uint8(
         {FLAGS_cn_nb, FLAGS_cn_wb, FLAGS_cn_swb32, FLAGS_cn_swb48});
     std::set<uint8_t> forbidden_types =
-        std_set_int32_to_uint8({FLAGS_g722, FLAGS_red, FLAGS_avt});
+        std_set_int32_to_uint8({FLAGS_g722, FLAGS_red, FLAGS_avt_nb,
+                                FLAGS_avt_wb, FLAGS_avt_swb32,
+                                FLAGS_avt_swb48});
     input.reset(new NetEqReplacementInput(std::move(input), replacement_pt,
                                           cn_types, forbidden_types));