Removed callback between old AudioConferenceMixer and OutputMixer. The audio frame with mixed audio…

webrtc/modules/audio_mixer/audio_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/modules/audio_mixer/audio_mixer.h"
 
 #include "webrtc/base/format_macros.h"
 #include "webrtc/modules/audio_processing/include/audio_processing.h"
 #include "webrtc/modules/utility/include/audio_frame_operations.h"
 #include "webrtc/system_wrappers/include/file_wrapper.h"
 #include "webrtc/system_wrappers/include/trace.h"
 #include "webrtc/voice_engine/include/voe_external_media.h"
 #include "webrtc/voice_engine/statistics.h"
 #include "webrtc/voice_engine/utility.h"
 
 namespace webrtc {
 namespace voe {
 
-void AudioMixer::NewMixedAudio(int32_t id,
-                               const AudioFrame& generalAudioFrame,
-                               const AudioFrame** uniqueAudioFrames,
-                               uint32_t size) {
-  WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, -1),
-               "AudioMixer::NewMixedAudio(id=%d, size=%u)", id, size);
-
-  _audioFrame.CopyFrom(generalAudioFrame);
-  _audioFrame.id_ = id;
-}
-
 void AudioMixer::PlayNotification(int32_t id, uint32_t durationMs) {
   WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, -1),
                "AudioMixer::PlayNotification(id=%d, durationMs=%d)", id,
                durationMs);
   // Not implement yet
 }
 
 void AudioMixer::RecordNotification(int32_t id, uint32_t durationMs) {
   WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, -1),
                "AudioMixer::RecordNotification(id=%d, durationMs=%d)", id,
                durationMs);
 
   // Not implement yet
 }
 
 void AudioMixer::PlayFileEnded(int32_t id) {
   WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, -1),
                "AudioMixer::PlayFileEnded(id=%d)", id);
 
   // not needed
 }
 
 void AudioMixer::RecordFileEnded(int32_t id) {
   WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, -1),
                "AudioMixer::RecordFileEnded(id=%d)", id);
-  assert(id == _instanceId);
+  RTC_DCHECK_EQ(id, _instanceId);
 
   rtc::CritScope cs(&_fileCritSect);
   _outputFileRecording = false;
   WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId, -1),
                "AudioMixer::RecordFileEnded() =>"
                "output file recorder module is shutdown");
 }
 
 int32_t AudioMixer::Create(AudioMixer*& mixer, uint32_t instanceId) {
   WEBRTC_TRACE(kTraceMemory, kTraceVoice, instanceId,
@@ skipping 14 matching lines @@
       _instanceId(instanceId),
       _externalMediaCallbackPtr(NULL),
       _externalMedia(false),
       _panLeft(1.0f),
       _panRight(1.0f),
       _mixingFrequencyHz(8000),
       _outputFileRecorderPtr(NULL),
       _outputFileRecording(false) {
   WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId, -1),
                "AudioMixer::AudioMixer() - ctor");
-
-  if (_mixerModule.RegisterMixedStreamCallback(this) == -1) {
-    WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId, -1),
-                 "AudioMixer::AudioMixer() failed to register mixer"
-                 "callbacks");
-  }
 }
 
 void AudioMixer::Destroy(AudioMixer*& mixer) {
   if (mixer) {
     delete mixer;
     mixer = NULL;
   }
 }
 
 AudioMixer::~AudioMixer() {
   WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId, -1),
                "AudioMixer::~AudioMixer() - dtor");
   if (_externalMedia) {
     DeRegisterExternalMediaProcessing();
   }
   {
     rtc::CritScope cs(&_fileCritSect);
     if (_outputFileRecorderPtr) {
       _outputFileRecorderPtr->RegisterModuleFileCallback(NULL);
       _outputFileRecorderPtr->StopRecording();
       FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
       _outputFileRecorderPtr = NULL;
     }
   }
-  _mixerModule.UnRegisterMixedStreamCallback();
   delete &_mixerModule;
 }
 
 int32_t AudioMixer::SetEngineInformation(voe::Statistics& engineStatistics) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
                "AudioMixer::SetEngineInformation()");
   _engineStatisticsPtr = &engineStatistics;
   return 0;
 }
 
@@ skipping 23 matching lines @@
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
                "AudioMixer::DeRegisterExternalMediaProcessing()");
 
   rtc::CritScope cs(&_callbackCritSect);
   _externalMedia = false;
   _externalMediaCallbackPtr = NULL;
 
   return 0;
 }
 
-int32_t AudioMixer::SetMixabilityStatus(MixerAudioSource& participant,
+int32_t AudioMixer::SetMixabilityStatus(MixerAudioSource& audio_source,
                                         bool mixable) {
-  return _mixerModule.SetMixabilityStatus(&participant, mixable);
+  return _mixerModule.SetMixabilityStatus(&audio_source, mixable);
 }
 
-int32_t AudioMixer::SetAnonymousMixabilityStatus(MixerAudioSource& participant,
+int32_t AudioMixer::SetAnonymousMixabilityStatus(MixerAudioSource& audio_source,
                                                  bool mixable) {
-  return _mixerModule.SetAnonymousMixabilityStatus(&participant, mixable);
+  return _mixerModule.SetAnonymousMixabilityStatus(&audio_source, mixable);
 }
 
 int32_t AudioMixer::MixActiveChannels() {
-  _mixerModule.Process();
+  _mixerModule.Mix(&_audioFrame);
   return 0;
 }
 
 int AudioMixer::GetSpeechOutputLevel(uint32_t& level) {
   int8_t currentLevel = _audioLevel.Level();
   level = static_cast<uint32_t>(currentLevel);
   WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId, -1),
                "GetSpeechOutputLevel() => level=%u", level);
   return 0;
 }
@@ skipping 215 matching lines @@
   }
 
   // Scale left and/or right channel(s) if balance is active
   if (_panLeft != 1.0 || _panRight != 1.0) {
     if (_audioFrame.num_channels_ == 1) {
       AudioFrameOperations::MonoToStereo(&_audioFrame);
     } else {
       // Pure stereo mode (we are receiving a stereo signal).
     }
 
-    assert(_audioFrame.num_channels_ == 2);
+    RTC_DCHECK_EQ(_audioFrame.num_channels_, static_cast<size_t>(2));
     AudioFrameOperations::Scale(_panLeft, _panRight, _audioFrame);
   }
 
   // --- Far-end Voice Quality Enhancement (AudioProcessing Module)
   if (feed_data_to_apm) {
     if (_audioProcessingModulePtr->ProcessReverseStream(&_audioFrame) != 0) {
       WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
                    "AudioProcessingModule::ProcessReverseStream() => error");
       RTC_DCHECK(false);
     }
@@ skipping 14 matching lines @@
     }
   }
 
   // --- Measure audio level (0-9) for the combined signal
   _audioLevel.ComputeLevel(_audioFrame);
 
   return 0;
 }
 }  // namespace voe
 }  // namespace webrtc