Remove VoEExternalMedia interface.

webrtc/voice_engine/transmit_mixer.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.
  */
 
 #include "webrtc/voice_engine/transmit_mixer.h"
 
 #include <memory>
 
 #include "webrtc/audio/utility/audio_frame_operations.h"
 #include "webrtc/base/format_macros.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/system_wrappers/include/event_wrapper.h"
 #include "webrtc/system_wrappers/include/trace.h"
 #include "webrtc/voice_engine/channel.h"
 #include "webrtc/voice_engine/channel_manager.h"
-#include "webrtc/voice_engine/include/voe_external_media.h"
 #include "webrtc/voice_engine/statistics.h"
 #include "webrtc/voice_engine/utility.h"
 #include "webrtc/voice_engine/voe_base_impl.h"
 
 namespace webrtc {
 namespace voe {
 
 // TODO(ajm): The thread safety of this is dubious...
 void
 TransmitMixer::OnPeriodicProcess()
@@ skipping 159 matching lines @@
     _fileCallRecording(false),
     _audioLevel(),
 #if WEBRTC_VOICE_ENGINE_TYPING_DETECTION
     _typingNoiseWarningPending(false),
     _typingNoiseDetected(false),
 #endif
     _saturationWarning(false),
     _instanceId(instanceId),
     _mixFileWithMicrophone(false),
     _captureLevel(0),
-    external_postproc_ptr_(NULL),
-    external_preproc_ptr_(NULL),
     _mute(false),
     stereo_codec_(false),
     swap_stereo_channels_(false)
 {
     WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::TransmitMixer() - ctor");
 }
 
 TransmitMixer::~TransmitMixer()
 {
     WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::~TransmitMixer() - dtor");
     _monitorModule.DeRegisterObserver();
     if (_processThreadPtr)
     {
         _processThreadPtr->DeRegisterModule(&_monitorModule);
     }
-    DeRegisterExternalMediaProcessing(kRecordingAllChannelsMixed);
-    DeRegisterExternalMediaProcessing(kRecordingPreprocessing);
     {
         rtc::CritScope cs(&_critSect);
         if (file_recorder_) {
           file_recorder_->RegisterModuleFileCallback(NULL);
           file_recorder_->StopRecording();
         }
         if (file_call_recorder_) {
           file_call_recorder_->RegisterModuleFileCallback(NULL);
           file_call_recorder_->StopRecording();
         }
@@ skipping 83 matching lines @@
                  "clockDrift=%d, currentMicLevel=%u)",
                  nSamples, nChannels, samplesPerSec, totalDelayMS, clockDrift,
                  currentMicLevel);
 
     // --- Resample input audio and create/store the initial audio frame
     GenerateAudioFrame(static_cast<const int16_t*>(audioSamples),
                        nSamples,
                        nChannels,
                        samplesPerSec);
 
-    {
-      rtc::CritScope cs(&_callbackCritSect);
-      if (external_preproc_ptr_) {
-        external_preproc_ptr_->Process(-1, kRecordingPreprocessing,
-                                       _audioFrame.data_,
-                                       _audioFrame.samples_per_channel_,
-                                       _audioFrame.sample_rate_hz_,
-                                       _audioFrame.num_channels_ == 2);
-      }
-    }
-
     // --- Near-end audio processing.
     ProcessAudio(totalDelayMS, clockDrift, currentMicLevel, keyPressed);
 
     if (swap_stereo_channels_ && stereo_codec_)
       // Only bother swapping if we're using a stereo codec.
       AudioFrameOperations::SwapStereoChannels(&_audioFrame);
 
     // --- Annoying typing detection (utilizes the APM/VAD decision)
 #if WEBRTC_VOICE_ENGINE_TYPING_DETECTION
     TypingDetection(keyPressed);
@@ skipping 12 matching lines @@
     bool file_recording = false;
     {
         rtc::CritScope cs(&_critSect);
         file_recording =  _fileRecording;
     }
     if (file_recording)
     {
         RecordAudioToFile(_audioFrame.sample_rate_hz_);
     }
 
-    {
-      rtc::CritScope cs(&_callbackCritSect);
-      if (external_postproc_ptr_) {
-        external_postproc_ptr_->Process(-1, kRecordingAllChannelsMixed,
-                                        _audioFrame.data_,
-                                        _audioFrame.samples_per_channel_,
-                                        _audioFrame.sample_rate_hz_,
-                                        _audioFrame.num_channels_ == 2);
-      }
-    }
-
     // --- Measure audio level of speech after all processing.
     _audioLevel.ComputeLevel(_audioFrame);
     return 0;
 }
 
 int32_t
 TransmitMixer::DemuxAndMix()
 {
     WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::DemuxAndMix()");
@@ skipping 565 matching lines @@
 
     return 0;
 }
 
 void
 TransmitMixer::SetMixWithMicStatus(bool mix)
 {
     _mixFileWithMicrophone = mix;
 }
 
-int TransmitMixer::RegisterExternalMediaProcessing(
-    VoEMediaProcess* object,
-    ProcessingTypes type) {
-  WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
-               "TransmitMixer::RegisterExternalMediaProcessing()");
-
-  rtc::CritScope cs(&_callbackCritSect);
-  if (!object) {
-    return -1;
-  }
-
-  // Store the callback object according to the processing type.
-  if (type == kRecordingAllChannelsMixed) {
-    external_postproc_ptr_ = object;
-  } else if (type == kRecordingPreprocessing) {
-    external_preproc_ptr_ = object;
-  } else {
-    return -1;
-  }
-  return 0;
-}
-
-int TransmitMixer::DeRegisterExternalMediaProcessing(ProcessingTypes type) {
-  WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
-               "TransmitMixer::DeRegisterExternalMediaProcessing()");
-
-  rtc::CritScope cs(&_callbackCritSect);
-  if (type == kRecordingAllChannelsMixed) {
-    external_postproc_ptr_ = NULL;
-  } else if (type == kRecordingPreprocessing) {
-    external_preproc_ptr_ = NULL;
-  } else {
-    return -1;
-  }
-  return 0;
-}
-
 int
 TransmitMixer::SetMute(bool enable)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::SetMute(enable=%d)", enable);
     _mute = enable;
     return 0;
 }
 
 bool
@@ skipping 173 matching lines @@
     // If there is already a warning pending, do not change the state.
     // Otherwise set a warning pending if last callback was for noise detected.
     if (!_typingNoiseWarningPending && _typingNoiseDetected) {
       _typingNoiseWarningPending = true;
       _typingNoiseDetected = false;
     }
   }
 }
 #endif
 
-int TransmitMixer::GetMixingFrequency()
-{
-    assert(_audioFrame.sample_rate_hz_ != 0);
-    return _audioFrame.sample_rate_hz_;
-}
-
 #if WEBRTC_VOICE_ENGINE_TYPING_DETECTION
 int TransmitMixer::TimeSinceLastTyping(int &seconds)
 {
     // We check in VoEAudioProcessingImpl that this is only called when
     // typing detection is active.
     seconds = _typingDetection.TimeSinceLastDetectionInSeconds();
     return 0;
 }
 #endif
 
@@ skipping 17 matching lines @@
 void TransmitMixer::EnableStereoChannelSwapping(bool enable) {
   swap_stereo_channels_ = enable;
 }
 
 bool TransmitMixer::IsStereoChannelSwappingEnabled() {
   return swap_stereo_channels_;
 }
 
 }  // namespace voe
 }  // namespace webrtc