Remove voe::OutputMixer and AudioConferenceMixer.

voice_engine/voe_base_impl.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 "voice_engine/voe_base_impl.h"
 
 #include "api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "common_audio/signal_processing/include/signal_processing_library.h"
 #include "modules/audio_coding/include/audio_coding_module.h"
 #include "modules/audio_device/audio_device_impl.h"
 #include "modules/audio_processing/include/audio_processing.h"
 #include "rtc_base/format_macros.h"
 #include "rtc_base/location.h"
 #include "rtc_base/logging.h"
-#include "system_wrappers/include/file_wrapper.h"
 #include "voice_engine/channel.h"
 #include "voice_engine/include/voe_errors.h"
-#include "voice_engine/output_mixer.h"
 #include "voice_engine/transmit_mixer.h"
-#include "voice_engine/utility.h"
 #include "voice_engine/voice_engine_impl.h"
 
 namespace webrtc {
 
 VoEBase* VoEBase::GetInterface(VoiceEngine* voiceEngine) {
   if (nullptr == voiceEngine) {
     return nullptr;
   }
   VoiceEngineImpl* s = static_cast<VoiceEngineImpl*>(voiceEngine);
   s->AddRef();
@@ skipping 96 matching lines @@
   if (new_voe_mic_level != voe_mic_level) {
     // Return the new volume if AGC has changed the volume.
     return static_cast<int>((new_voe_mic_level * max_volume +
                              static_cast<int>(kMaxVolumeLevel / 2)) /
                             kMaxVolumeLevel);
   }
 
   return 0;
 }
 
 int32_t VoEBaseImpl::NeedMorePlayData(const size_t nSamples,

[hlundin-webrtc, 2017/09/22 09:17:44]

Mark as deprecated?

[the sun, 2017/09/22 10:49:00]

Done.

                                       const size_t nBytesPerSample,
                                       const size_t nChannels,
                                       const uint32_t samplesPerSec,
                                       void* audioSamples,
                                       size_t& nSamplesOut,
                                       int64_t* elapsed_time_ms,
                                       int64_t* ntp_time_ms) {
-  GetPlayoutData(static_cast<int>(samplesPerSec), nChannels, nSamples, true,
-                 audioSamples, elapsed_time_ms, ntp_time_ms);
-  nSamplesOut = audioFrame_.samples_per_channel_;
+  RTC_NOTREACHED();
   return 0;
 }
 
 void VoEBaseImpl::PushCaptureData(int voe_channel, const void* audio_data,
                                   int bits_per_sample, int sample_rate,
                                   size_t number_of_channels,
                                   size_t number_of_frames) {
   voe::ChannelOwner ch = shared_->channel_manager().GetChannel(voe_channel);
   voe::Channel* channel = ch.channel();
   if (!channel)
     return;
   if (channel->Sending()) {
     // Send the audio to each channel directly without using the APM in the
     // transmit mixer.
     channel->ProcessAndEncodeAudio(static_cast<const int16_t*>(audio_data),
                                    sample_rate, number_of_frames,
                                    number_of_channels);
   }
 }
 
 void VoEBaseImpl::PullRenderData(int bits_per_sample,

[hlundin-webrtc, 2017/09/22 09:17:45]

Mark as deprecated?

[the sun, 2017/09/22 10:49:00]

Done.

                                  int sample_rate,
                                  size_t number_of_channels,
                                  size_t number_of_frames,
                                  void* audio_data, int64_t* elapsed_time_ms,
                                  int64_t* ntp_time_ms) {
-  assert(bits_per_sample == 16);
-  assert(number_of_frames == static_cast<size_t>(sample_rate / 100));
-
-  GetPlayoutData(sample_rate, number_of_channels, number_of_frames, false,
-                 audio_data, elapsed_time_ms, ntp_time_ms);
+  RTC_NOTREACHED();
 }
 
 int VoEBaseImpl::RegisterVoiceEngineObserver(VoiceEngineObserver& observer) {
   rtc::CritScope cs(&callbackCritSect_);
   if (voiceEngineObserverPtr_) {
     shared_->SetLastError(
         VE_INVALID_OPERATION, kTraceError,
         "RegisterVoiceEngineObserver() observer already enabled");
     return -1;
   }
@@ skipping 216 matching lines @@
 
   ChannelConfig config_copy(config);
   config_copy.acm_config.decoder_factory = decoder_factory_;
   voe::ChannelOwner channel_owner =
       shared_->channel_manager().CreateChannel(config_copy);
   return InitializeChannel(&channel_owner);
 }
 
 int VoEBaseImpl::InitializeChannel(voe::ChannelOwner* channel_owner) {
   if (channel_owner->channel()->SetEngineInformation(
-          shared_->statistics(), *shared_->output_mixer(),
+          shared_->statistics(),
           *shared_->process_thread(), *shared_->audio_device(),
           voiceEngineObserverPtr_, &callbackCritSect_,
           shared_->encoder_queue()) != 0) {
     shared_->SetLastError(
         VE_CHANNEL_NOT_CREATED, kTraceError,
         "CreateChannel() failed to associate engine and channel."
         " Destroying channel.");
     shared_->channel_manager().DestroyChannel(
         channel_owner->channel()->ChannelId());
     return -1;
@@ skipping 214 matching lines @@
       shared_->SetLastError(VE_AUDIO_DEVICE_MODULE_ERROR, kTraceError,
                             "TerminateInternal() failed to terminate the ADM");
     }
     shared_->set_audio_device(nullptr);
   }
 
   shared_->set_audio_processing(nullptr);
 
   return shared_->statistics().SetUnInitialized();
 }
-
-void VoEBaseImpl::GetPlayoutData(int sample_rate, size_t number_of_channels,
-                                 size_t number_of_frames, bool feed_data_to_apm,
-                                 void* audio_data, int64_t* elapsed_time_ms,
-                                 int64_t* ntp_time_ms) {
-  assert(shared_->output_mixer() != nullptr);
-
-  // TODO(andrew): if the device is running in mono, we should tell the mixer
-  // here so that it will only request mono from AudioCodingModule.
-  // Perform mixing of all active participants (channel-based mixing)
-  shared_->output_mixer()->MixActiveChannels();
-
-  // Additional operations on the combined signal
-  shared_->output_mixer()->DoOperationsOnCombinedSignal(feed_data_to_apm);
-
-  // Retrieve the final output mix (resampled to match the ADM)
-  shared_->output_mixer()->GetMixedAudio(sample_rate, number_of_channels,
-                                         &audioFrame_);
-
-  assert(number_of_frames == audioFrame_.samples_per_channel_);
-  assert(sample_rate == audioFrame_.sample_rate_hz_);
-
-  // Deliver audio (PCM) samples to the ADM
-  memcpy(audio_data, audioFrame_.data(),
-         sizeof(int16_t) * number_of_frames * number_of_channels);
-
-  *elapsed_time_ms = audioFrame_.elapsed_time_ms_;
-  *ntp_time_ms = audioFrame_.ntp_time_ms_;
-}
-
 }  // namespace webrtc