Revert of - Clean up unused voice engine DTMF code.

webrtc/voice_engine/channel.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 22 matching lines @@
 #include "webrtc/modules/utility/include/process_thread.h"
 #include "webrtc/system_wrappers/include/trace.h"
 #include "webrtc/voice_engine/include/voe_base.h"
 #include "webrtc/voice_engine/include/voe_external_media.h"
 #include "webrtc/voice_engine/include/voe_rtp_rtcp.h"
 #include "webrtc/voice_engine/output_mixer.h"
 #include "webrtc/voice_engine/statistics.h"
 #include "webrtc/voice_engine/transmit_mixer.h"
 #include "webrtc/voice_engine/utility.h"
 
+#if defined(_WIN32)
+#include <Qos.h>
+#endif
+
 namespace webrtc {
 namespace voe {
 
-const int kTelephoneEventAttenuationdB = 10;
-
 class TransportFeedbackProxy : public TransportFeedbackObserver {
  public:
   TransportFeedbackProxy() : feedback_observer_(nullptr) {
     pacer_thread_.DetachFromThread();
     network_thread_.DetachFromThread();
   }
 
   void SetTransportFeedbackObserver(
       TransportFeedbackObserver* feedback_observer) {
     RTC_DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 296 matching lines @@
 }
 
 void Channel::OnPlayTelephoneEvent(uint8_t event,
                                    uint16_t lengthMs,
                                    uint8_t volume) {
   WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::OnPlayTelephoneEvent(event=%u, lengthMs=%u,"
                " volume=%u)",
                event, lengthMs, volume);
 
-  if (event > 15) {
+  if (!_playOutbandDtmfEvent || (event > 15)) {
     // Ignore callback since feedback is disabled or event is not a
     // Dtmf tone event.
     return;
   }
 
   assert(_outputMixerPtr != NULL);
 
   // Start playing out the Dtmf tone (if playout is enabled).
   // Reduce length of tone with 80ms to the reduce risk of echo.
   _outputMixerPtr->PlayDtmfTone(event, lengthMs - 80, volume);
@@ skipping 377 matching lines @@
       _externalTransport(false),
       _inputFilePlayerPtr(NULL),
       _outputFilePlayerPtr(NULL),
       _outputFileRecorderPtr(NULL),
       // Avoid conflict with other channels by adding 1024 - 1026,
       // won't use as much as 1024 channels.
       _inputFilePlayerId(VoEModuleId(instanceId, channelId) + 1024),
       _outputFilePlayerId(VoEModuleId(instanceId, channelId) + 1025),
       _outputFileRecorderId(VoEModuleId(instanceId, channelId) + 1026),
       _outputFileRecording(false),
+      _inbandDtmfQueue(VoEModuleId(instanceId, channelId)),
+      _inbandDtmfGenerator(VoEModuleId(instanceId, channelId)),
       _outputExternalMedia(false),
       _inputExternalMediaCallbackPtr(NULL),
       _outputExternalMediaCallbackPtr(NULL),
       _timeStamp(0),  // This is just an offset, RTP module will add it's own
                       // random offset
+      _sendTelephoneEventPayloadType(106),
       ntp_estimator_(Clock::GetRealTimeClock()),
       jitter_buffer_playout_timestamp_(0),
       playout_timestamp_rtp_(0),
       playout_timestamp_rtcp_(0),
       playout_delay_ms_(0),
       _numberOfDiscardedPackets(0),
       send_sequence_number_(0),
       rtp_ts_wraparound_handler_(new rtc::TimestampWrapAroundHandler()),
       capture_start_rtp_time_stamp_(-1),
       capture_start_ntp_time_ms_(-1),
       _engineStatisticsPtr(NULL),
       _outputMixerPtr(NULL),
       _transmitMixerPtr(NULL),
       _moduleProcessThreadPtr(NULL),
       _audioDeviceModulePtr(NULL),
       _voiceEngineObserverPtr(NULL),
       _callbackCritSectPtr(NULL),
       _transportPtr(NULL),
       _rxVadObserverPtr(NULL),
       _oldVadDecision(-1),
       _sendFrameType(0),
       _externalMixing(false),
       _mixFileWithMicrophone(false),
       _mute(false),
       _panLeft(1.0f),
       _panRight(1.0f),
       _outputGain(1.0f),
+      _playOutbandDtmfEvent(false),
+      _playInbandDtmfEvent(false),
       _lastLocalTimeStamp(0),
       _lastPayloadType(0),
       _includeAudioLevelIndication(false),
       _outputSpeechType(AudioFrame::kNormalSpeech),
       _average_jitter_buffer_delay_us(0),
       _previousTimestamp(0),
       _recPacketDelayMs(20),
       _RxVadDetection(false),
       _rxAgcIsEnabled(false),
       _rxNsIsEnabled(false),
@@ skipping 12 matching lines @@
   if (config.Get<NetEqCapacityConfig>().enabled) {
     // Clamping the buffer capacity at 20 packets. While going lower will
     // probably work, it makes little sense.
     acm_config.neteq_config.max_packets_in_buffer =
         std::max(20, config.Get<NetEqCapacityConfig>().capacity);
   }
   acm_config.neteq_config.enable_fast_accelerate =
       config.Get<NetEqFastAccelerate>().enabled;
   audio_coding_.reset(AudioCodingModule::Create(acm_config));
 
+  _inbandDtmfQueue.ResetDtmf();
+  _inbandDtmfGenerator.Init();
   _outputAudioLevel.Clear();
 
   RtpRtcp::Configuration configuration;
   configuration.audio = true;
   configuration.outgoing_transport = this;
   configuration.audio_messages = this;
   configuration.receive_statistics = rtp_receive_statistics_.get();
   configuration.bandwidth_callback = rtcp_observer_.get();
   if (pacing_enabled_) {
     configuration.paced_sender = rtp_packet_sender_proxy_.get();
@@ skipping 1360 matching lines @@
   _outputGain = scaling;
   return 0;
 }
 
 int Channel::GetChannelOutputVolumeScaling(float& scaling) const {
   rtc::CritScope cs(&volume_settings_critsect_);
   scaling = _outputGain;
   return 0;
 }
 
-int Channel::SendTelephoneEventOutband(int event, int duration_ms) {
+int Channel::SendTelephoneEventOutband(unsigned char eventCode,
+                                       int lengthMs,
+                                       int attenuationDb,
+                                       bool playDtmfEvent) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
-               "Channel::SendTelephoneEventOutband(...)");
-  RTC_DCHECK_LE(0, event);
-  RTC_DCHECK_GE(255, event);
-  RTC_DCHECK_LE(0, duration_ms);
-  RTC_DCHECK_GE(65535, duration_ms);
+               "Channel::SendTelephoneEventOutband(..., playDtmfEvent=%d)",
+               playDtmfEvent);
   if (!Sending()) {
     return -1;
   }
-  if (_rtpRtcpModule->SendTelephoneEventOutband(
-      event, duration_ms, kTelephoneEventAttenuationdB) != 0) {
+
+  _playOutbandDtmfEvent = playDtmfEvent;
+
+  if (_rtpRtcpModule->SendTelephoneEventOutband(eventCode, lengthMs,
+                                                attenuationDb) != 0) {
     _engineStatisticsPtr->SetLastError(
         VE_SEND_DTMF_FAILED, kTraceWarning,
         "SendTelephoneEventOutband() failed to send event");
     return -1;
   }
   return 0;
 }
 
-int Channel::SetSendTelephoneEventPayloadType(int payload_type) {
+int Channel::SendTelephoneEventInband(unsigned char eventCode,
+                                      int lengthMs,
+                                      int attenuationDb,
+                                      bool playDtmfEvent) {
+  WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
+               "Channel::SendTelephoneEventInband(..., playDtmfEvent=%d)",
+               playDtmfEvent);
+
+  _playInbandDtmfEvent = playDtmfEvent;
+  _inbandDtmfQueue.AddDtmf(eventCode, lengthMs, attenuationDb);
+
+  return 0;
+}
+
+int Channel::SetSendTelephoneEventPayloadType(unsigned char type) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::SetSendTelephoneEventPayloadType()");
-  RTC_DCHECK_LE(0, payload_type);
-  RTC_DCHECK_GE(127, payload_type);
-  CodecInst codec = {0};
+  if (type > 127) {
+    _engineStatisticsPtr->SetLastError(
+        VE_INVALID_ARGUMENT, kTraceError,
+        "SetSendTelephoneEventPayloadType() invalid type");
+    return -1;
+  }
+  CodecInst codec = {};
   codec.plfreq = 8000;
-  codec.pltype = payload_type;
+  codec.pltype = type;
   memcpy(codec.plname, "telephone-event", 16);
   if (_rtpRtcpModule->RegisterSendPayload(codec) != 0) {
     _rtpRtcpModule->DeRegisterSendPayload(codec.pltype);
     if (_rtpRtcpModule->RegisterSendPayload(codec) != 0) {
       _engineStatisticsPtr->SetLastError(
           VE_RTP_RTCP_MODULE_ERROR, kTraceError,
           "SetSendTelephoneEventPayloadType() failed to register send"
           "payload type");
       return -1;
     }
   }
+  _sendTelephoneEventPayloadType = type;
   return 0;
 }
 
+int Channel::GetSendTelephoneEventPayloadType(unsigned char& type) {
+  type = _sendTelephoneEventPayloadType;
+  return 0;
+}
+
 int Channel::UpdateRxVadDetection(AudioFrame& audioFrame) {
   WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::UpdateRxVadDetection()");
 
   int vadDecision = 1;
 
   vadDecision = (audioFrame.vad_activity_ == AudioFrame::kVadActive) ? 1 : 0;
 
   if ((vadDecision != _oldVadDecision) && _rxVadObserverPtr) {
     OnRxVadDetected(vadDecision);
@@ skipping 726 matching lines @@
     rtc::CritScope cs(&_callbackCritSect);
     const bool isStereo = (_audioFrame.num_channels_ == 2);
     if (_inputExternalMediaCallbackPtr) {
       _inputExternalMediaCallbackPtr->Process(
           _channelId, kRecordingPerChannel, (int16_t*)_audioFrame.data_,
           _audioFrame.samples_per_channel_, _audioFrame.sample_rate_hz_,
           isStereo);
     }
   }
 
+  InsertInbandDtmfTone();
+
   if (_includeAudioLevelIndication) {
     size_t length =
         _audioFrame.samples_per_channel_ * _audioFrame.num_channels_;
     if (is_muted) {
       rms_level_.ProcessMuted(length);
     } else {
       rms_level_.Process(_audioFrame.data_, length);
     }
   }
 
@@ skipping 299 matching lines @@
                  "Channel::MixAudioWithFile() samples_per_channel_(%" PRIuS
                  ") != "
                  "fileSamples(%" PRIuS ")",
                  audioFrame.samples_per_channel_, fileSamples);
     return -1;
   }
 
   return 0;
 }
 
+int Channel::InsertInbandDtmfTone() {
+  // Check if we should start a new tone.
+  if (_inbandDtmfQueue.PendingDtmf() && !_inbandDtmfGenerator.IsAddingTone() &&
+      _inbandDtmfGenerator.DelaySinceLastTone() >
+          kMinTelephoneEventSeparationMs) {
+    int8_t eventCode(0);
+    uint16_t lengthMs(0);
+    uint8_t attenuationDb(0);
+
+    eventCode = _inbandDtmfQueue.NextDtmf(&lengthMs, &attenuationDb);
+    _inbandDtmfGenerator.AddTone(eventCode, lengthMs, attenuationDb);
+    if (_playInbandDtmfEvent) {
+      // Add tone to output mixer using a reduced length to minimize
+      // risk of echo.
+      _outputMixerPtr->PlayDtmfTone(eventCode, lengthMs - 80, attenuationDb);
+    }
+  }
+
+  if (_inbandDtmfGenerator.IsAddingTone()) {
+    uint16_t frequency(0);
+    _inbandDtmfGenerator.GetSampleRate(frequency);
+
+    if (frequency != _audioFrame.sample_rate_hz_) {
+      // Update sample rate of Dtmf tone since the mixing frequency
+      // has changed.
+      _inbandDtmfGenerator.SetSampleRate(
+          (uint16_t)(_audioFrame.sample_rate_hz_));
+      // Reset the tone to be added taking the new sample rate into
+      // account.
+      _inbandDtmfGenerator.ResetTone();
+    }
+
+    int16_t toneBuffer[320];
+    uint16_t toneSamples(0);
+    // Get 10ms tone segment and set time since last tone to zero
+    if (_inbandDtmfGenerator.Get10msTone(toneBuffer, toneSamples) == -1) {
+      WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, _channelId),
+                   "Channel::EncodeAndSend() inserting Dtmf failed");
+      return -1;
+    }
+
+    // Replace mixed audio with DTMF tone.
+    for (size_t sample = 0; sample < _audioFrame.samples_per_channel_;
+         sample++) {
+      for (size_t channel = 0; channel < _audioFrame.num_channels_; channel++) {
+        const size_t index = sample * _audioFrame.num_channels_ + channel;
+        _audioFrame.data_[index] = toneBuffer[sample];
+      }
+    }
+
+    assert(_audioFrame.samples_per_channel_ == toneSamples);
+  } else {
+    // Add 10ms to "delay-since-last-tone" counter
+    _inbandDtmfGenerator.UpdateDelaySinceLastTone();
+  }
+  return 0;
+}
+
 void Channel::UpdatePlayoutTimestamp(bool rtcp) {
   uint32_t playout_timestamp = 0;
 
   if (audio_coding_->PlayoutTimestamp(&playout_timestamp) == -1) {
     // This can happen if this channel has not been received any RTP packet. In
     // this case, NetEq is not capable of computing playout timestamp.
     return;
   }
 
   uint16_t delay_ms = 0;
@@ skipping 228 matching lines @@
   int64_t min_rtt = 0;
   if (_rtpRtcpModule->RTT(remoteSSRC, &rtt, &avg_rtt, &min_rtt, &max_rtt) !=
       0) {
     return 0;
   }
   return rtt;
 }
 
 }  // namespace voe
 }  // namespace webrtc