Multi frequency DTMF support - receiver side

webrtc/media/engine/webrtcvoiceengine.cc

 /*
  *  Copyright (c) 2004 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 378 matching lines @@
     return false;
   }
 
   static const AudioCodec* GetPreferredCodec(
       const std::vector<AudioCodec>& codecs,
       webrtc::CodecInst* out) {
     RTC_DCHECK(out);
     // Select the preferred send codec (the first non-telephone-event/CN codec).
     for (const AudioCodec& codec : codecs) {
       if (IsCodec(codec, kDtmfCodecName) || IsCodec(codec, kCnCodecName)) {
-        // Skip telephone-event/CN codec, which will be handled later.
+        // Skip telephone-event/CN codecs - they will be handled later.
         continue;
       }
 
       // We'll use the first codec in the list to actually send audio data.
       // Be sure to use the payload type requested by the remote side.
       // Ignore codecs we don't know about. The negotiation step should prevent
       // this, but double-check to be sure.
       if (!ToCodecInst(codec, out)) {
         LOG(LS_WARNING) << "Unknown codec " << ToString(codec);
         continue;
       }
       return &codec;
     }
     return nullptr;
   }
 
  private:
   static const int kMaxNumPacketSize = 6;
   struct CodecPref {
     const char* name;
     int clockrate;
     size_t channels;
     int payload_type;
     bool is_multi_rate;
     int packet_sizes_ms[kMaxNumPacketSize];
     int max_bitrate_bps;
   };
   // Note: keep the supported packet sizes in ascending order.
-  static const CodecPref kCodecPrefs[11];
+  static const CodecPref kCodecPrefs[14];
 
   static int SelectPacketSize(const CodecPref& codec_pref, int ptime_ms) {
     int selected_packet_size_ms = codec_pref.packet_sizes_ms[0];
     for (int packet_size_ms : codec_pref.packet_sizes_ms) {
       if (packet_size_ms && packet_size_ms <= ptime_ms) {
         selected_packet_size_ms = packet_size_ms;
       }
     }
     return selected_packet_size_ms;
   }
 
   // Changes RTP timestamp rate of G722. This is due to the "bug" in the RFC
   // which says that G722 should be advertised as 8 kHz although it is a 16 kHz
   // codec.
   static void MaybeFixupG722(webrtc::CodecInst* voe_codec, int new_plfreq) {
     if (IsCodec(*voe_codec, kG722CodecName)) {
       // If the ASSERT triggers, the codec definition in WebRTC VoiceEngine
       // has changed, and this special case is no longer needed.
       RTC_DCHECK(voe_codec->plfreq != new_plfreq);
       voe_codec->plfreq = new_plfreq;
     }
   }
 };
 
-const WebRtcVoiceCodecs::CodecPref WebRtcVoiceCodecs::kCodecPrefs[11] = {
+const WebRtcVoiceCodecs::CodecPref WebRtcVoiceCodecs::kCodecPrefs[14] = {
     {kOpusCodecName, 48000, 2, 111, true, {10, 20, 40, 60}, kOpusMaxBitrate},
     {kIsacCodecName, 16000, 1, 103, true, {30, 60}, kIsacMaxBitrate},
     {kIsacCodecName, 32000, 1, 104, true, {30}, kIsacMaxBitrate},
     // G722 should be advertised as 8000 Hz because of the RFC "bug".
     {kG722CodecName, 8000, 1, 9, false, {10, 20, 30, 40, 50, 60}},
     {kIlbcCodecName, 8000, 1, 102, false, {20, 30, 40, 60}},
     {kPcmuCodecName, 8000, 1, 0, false, {10, 20, 30, 40, 50, 60}},
     {kPcmaCodecName, 8000, 1, 8, false, {10, 20, 30, 40, 50, 60}},
     {kCnCodecName, 32000, 1, 106, false, {}},
     {kCnCodecName, 16000, 1, 105, false, {}},
     {kCnCodecName, 8000, 1, 13, false, {}},
+    {kDtmfCodecName, 48000, 1, 123, false, {}},
+    {kDtmfCodecName, 32000, 1, 124, false, {}},
+    {kDtmfCodecName, 16000, 1, 125, false, {}},
     {kDtmfCodecName, 8000, 1, 126, false, {}}
 };
 } // namespace {
 
 bool SendCodecSpec::operator==(const SendCodecSpec& rhs) const {
   if (nack_enabled != rhs.nack_enabled) {
     return false;
   }
   if (transport_cc_enabled != rhs.transport_cc_enabled) {
     return false;
@@ skipping 608 matching lines @@
   RTC_DCHECK(adm_);
   return adm_;
 }
 
 AudioCodecs WebRtcVoiceEngine::CollectRecvCodecs() const {
   PayloadTypeMapper mapper;
   AudioCodecs out;
   const std::vector<webrtc::AudioCodecSpec>& specs =
       decoder_factory_->GetSupportedDecoders();
 
-  // Only generate CN payload types for these clockrates
+  // Only generate CN payload types for these clockrates:
   std::map<int, bool, std::greater<int>> generate_cn = {{ 8000,  false },
                                                         { 16000, false },
                                                         { 32000, false }};
+  // Only generate telephone-event payload types for these clockrates:
+  std::map<int, bool, std::greater<int>> generate_dtmf = {{ 8000,  false },
+                                                          { 16000, false },
+                                                          { 32000, false },
+                                                          { 48000, false }};
 
   auto map_format = [&mapper, &out] (const webrtc::SdpAudioFormat& format) {
     rtc::Optional<AudioCodec> opt_codec = mapper.ToAudioCodec(format);
     if (!opt_codec) {
       LOG(LS_ERROR) << "Unable to assign payload type to format: " << format;
       return false;
     }
 
     auto& codec = *opt_codec;
     if (IsCodec(codec, kOpusCodecName)) {
       // TODO(ossu): Set this specifically for Opus for now, until we have a
       // better way of dealing with rtcp-fb parameters.
       codec.AddFeedbackParam(
           FeedbackParam(kRtcpFbParamTransportCc, kParamValueEmpty));
     }
     out.push_back(codec);
     return true;
   };
 
   for (const auto& spec : specs) {
-    if (map_format(spec.format) && spec.allow_comfort_noise) {
-      // Generate a CN entry if the decoder allows it and we support the
-      // clockrate.
-      auto cn = generate_cn.find(spec.format.clockrate_hz);
-      if (cn != generate_cn.end()) {
-        cn->second = true;
+    if (map_format(spec.format)) {
+      if (spec.allow_comfort_noise) {
+        // Generate a CN entry if the decoder allows it and we support the
+        // clockrate.
+        auto cn = generate_cn.find(spec.format.clockrate_hz);
+        if (cn != generate_cn.end()) {
+          cn->second = true;
+        }
+      }
+
+      // Generate a telephone-event entry if we support the clockrate.
+      auto dtmf = generate_dtmf.find(spec.format.clockrate_hz);
+      if (dtmf != generate_dtmf.end()) {
+        dtmf->second = true;
       }
     }
   }
 
-  // Add CN codecs after "proper" audio codecs
+  // Add CN codecs after "proper" audio codecs.
   for (const auto& cn : generate_cn) {
     if (cn.second) {
       map_format({kCnCodecName, cn.first, 1});
     }
   }
 
-  // Add telephone-event codec last
-  map_format({kDtmfCodecName, 8000, 1});
+  // Add telephone-event codecs last.
+  for (const auto& dtmf : generate_dtmf) {
+    if (dtmf.second) {
+      map_format({kDtmfCodecName, dtmf.first, 1});
+    }
+  }
 
   return out;
 }
 
 class WebRtcVoiceMediaChannel::WebRtcAudioSendStream
     : public AudioSource::Sink {
  public:
   WebRtcAudioSendStream(int ch,
                         webrtc::AudioTransport* voe_audio_transport,
                         uint32_t ssrc,
@@ skipping 1515 matching lines @@
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   const auto it = send_streams_.find(ssrc);
   if (it != send_streams_.end()) {
     return it->second->channel();
   }
   return -1;
 }
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE