Relanding https://codereview.webrtc.org/1715883002/ in pieces.

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();
@@ skipping 699 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 1383 matching lines @@
   if (_rtpRtcpModule->SendTelephoneEventOutband(
       event, duration_ms, kTelephoneEventAttenuationdB) != 0) {
     _engineStatisticsPtr->SetLastError(
         VE_SEND_DTMF_FAILED, kTraceWarning,
         "SendTelephoneEventOutband() failed to send event");
     return -1;
   }
   return 0;
 }
 
-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()");
   if (type > 127) {
     _engineStatisticsPtr->SetLastError(
         VE_INVALID_ARGUMENT, kTraceError,
         "SetSendTelephoneEventPayloadType() invalid type");
     return -1;
   }
   CodecInst codec = {};
   codec.plfreq = 8000;
   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