Multi frequency DTMF support - receiver side

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 98 matching lines @@
     google::RegisterFlagValidator(&FLAGS_pcm16b_wb, &ValidatePayloadType);
 DEFINE_int32(pcm16b_swb32, 95, "RTP payload type for PCM16b-swb32 (32 kHz)");
 const bool pcm16b_swb32_dummy =
     google::RegisterFlagValidator(&FLAGS_pcm16b_swb32, &ValidatePayloadType);
 DEFINE_int32(pcm16b_swb48, 96, "RTP payload type for PCM16b-swb48 (48 kHz)");
 const bool pcm16b_swb48_dummy =
     google::RegisterFlagValidator(&FLAGS_pcm16b_swb48, &ValidatePayloadType);
 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);
 DEFINE_int32(cn_nb, 13, "RTP payload type for comfort noise (8 kHz)");
 const bool cn_nb_dummy =
     google::RegisterFlagValidator(&FLAGS_cn_nb, &ValidatePayloadType);
 DEFINE_int32(cn_wb, 98, "RTP payload type for comfort noise (16 kHz)");
 const bool cn_wb_dummy =
     google::RegisterFlagValidator(&FLAGS_cn_wb, &ValidatePayloadType);
 DEFINE_int32(cn_swb32, 99, "RTP payload type for comfort noise (32 kHz)");
@@ skipping 39 matching lines @@
     case NetEqDecoder::kDecoderPCM16Bwb:
       return "PCM16b-wb (16 kHz)";
     case NetEqDecoder::kDecoderPCM16Bswb32kHz:
       return "PCM16b-swb32 (32 kHz)";
     case NetEqDecoder::kDecoderPCM16Bswb48kHz:
       return "PCM16b-swb48 (48 kHz)";
     case NetEqDecoder::kDecoderG722:
       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:
       return "comfort noise (16 kHz)";
     case NetEqDecoder::kDecoderCNGswb32kHz:
       return "comfort noise (32 kHz)";
     case NetEqDecoder::kDecoderCNGswb48kHz:
       return "comfort noise (48 kHz)";
     default:
       FATAL();
@@ skipping 12 matching lines @@
   PrintCodecMappingEntry(NetEqDecoder::kDecoderISAC, FLAGS_isac);
   PrintCodecMappingEntry(NetEqDecoder::kDecoderISACswb, FLAGS_isac_swb);
   PrintCodecMappingEntry(NetEqDecoder::kDecoderOpus, FLAGS_opus);
   PrintCodecMappingEntry(NetEqDecoder::kDecoderPCM16B, FLAGS_pcm16b);
   PrintCodecMappingEntry(NetEqDecoder::kDecoderPCM16Bwb, FLAGS_pcm16b_wb);
   PrintCodecMappingEntry(NetEqDecoder::kDecoderPCM16Bswb32kHz,
                          FLAGS_pcm16b_swb32);
   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);
   PrintCodecMappingEntry(NetEqDecoder::kDecoderCNGswb32kHz, FLAGS_cn_swb32);
   PrintCodecMappingEntry(NetEqDecoder::kDecoderCNGswb48kHz, 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 ||
-      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;
 }
 
 // Class to let through only the packets with a given SSRC. Should be used as an
 // outer layer on another NetEqInput object.
 class FilterSsrcInput : public NetEqInput {
  public:
   FilterSsrcInput(std::unique_ptr<NetEqInput> source, uint32_t ssrc)
       : source_(std::move(source)), ssrc_(ssrc) {
@@ skipping 120 matching lines @@
        std::make_pair(NetEqDecoder::kDecoderISACswb, "isac-swb")},
       {FLAGS_opus, std::make_pair(NetEqDecoder::kDecoderOpus, "opus")},
       {FLAGS_pcm16b, std::make_pair(NetEqDecoder::kDecoderPCM16B, "pcm16-nb")},
       {FLAGS_pcm16b_wb,
        std::make_pair(NetEqDecoder::kDecoderPCM16Bwb, "pcm16-wb")},
       {FLAGS_pcm16b_swb32,
        std::make_pair(NetEqDecoder::kDecoderPCM16Bswb32kHz, "pcm16-swb32")},
       {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")},
       {FLAGS_cn_swb32,
        std::make_pair(NetEqDecoder::kDecoderCNGswb32kHz, "cng-swb32")},
       {FLAGS_cn_swb48,
        std::make_pair(NetEqDecoder::kDecoderCNGswb48kHz, "cng-swb48")}};
 
   // Check if a replacement audio file was provided.
   std::unique_ptr<AudioDecoder> replacement_decoder;
@@ skipping 11 matching lines @@
       std::set<uint8_t> b;
       for (auto& x : a) {
         b.insert(static_cast<uint8_t>(x));
       }
       return b;
     };
 
     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));
 
     replacement_decoder.reset(new FakeDecodeFromFile(
         std::unique_ptr<InputAudioFile>(
             new InputAudioFile(FLAGS_replacement_audio_file)),
         48000, false));
     NetEqTest::ExternalDecoderInfo ext_dec_info = {
         replacement_decoder.get(), NetEqDecoder::kDecoderArbitrary,
         "replacement codec"};
@@ skipping 31 matching lines @@
   return 0;
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace webrtc
 
 int main(int argc, char* argv[]) {
   webrtc::test::RunTest(argc, argv);
 }