A simple copy of the old mixer to a new directory. I also plan to run 'git cl format'. In another C…

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/voice_engine/output_mixer.h"
+#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
-OutputMixer::NewMixedAudio(int32_t id,
+AudioMixer::NewMixedAudio(int32_t id,
                            const AudioFrame& generalAudioFrame,
                            const AudioFrame** uniqueAudioFrames,
                            uint32_t size)
 {
     WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,-1),
-                 "OutputMixer::NewMixedAudio(id=%d, size=%u)", id, size);
+                 "AudioMixer::NewMixedAudio(id=%d, size=%u)", id, size);
 
     _audioFrame.CopyFrom(generalAudioFrame);
     _audioFrame.id_ = id;
 }
 
-void OutputMixer::PlayNotification(int32_t id, uint32_t durationMs)
+void AudioMixer::PlayNotification(int32_t id, uint32_t durationMs)
 {
     WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,-1),
-                 "OutputMixer::PlayNotification(id=%d, durationMs=%d)",
+                 "AudioMixer::PlayNotification(id=%d, durationMs=%d)",
                  id, durationMs);
     // Not implement yet
 }
 
-void OutputMixer::RecordNotification(int32_t id,
+void AudioMixer::RecordNotification(int32_t id,
                                      uint32_t durationMs)
 {
     WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,-1),
-                 "OutputMixer::RecordNotification(id=%d, durationMs=%d)",
+                 "AudioMixer::RecordNotification(id=%d, durationMs=%d)",
                  id, durationMs);
 
     // Not implement yet
 }
 
-void OutputMixer::PlayFileEnded(int32_t id)
+void AudioMixer::PlayFileEnded(int32_t id)
 {
     WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,-1),
-                 "OutputMixer::PlayFileEnded(id=%d)", id);
+                 "AudioMixer::PlayFileEnded(id=%d)", id);
 
     // not needed
 }
 
-void OutputMixer::RecordFileEnded(int32_t id)
+void AudioMixer::RecordFileEnded(int32_t id)
 {
     WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,-1),
-                 "OutputMixer::RecordFileEnded(id=%d)", id);
+                 "AudioMixer::RecordFileEnded(id=%d)", id);
     assert(id == _instanceId);
 
     rtc::CritScope cs(&_fileCritSect);
     _outputFileRecording = false;
     WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId,-1),
-                 "OutputMixer::RecordFileEnded() =>"
+                 "AudioMixer::RecordFileEnded() =>"
                  "output file recorder module is shutdown");
 }
 
 int32_t
-OutputMixer::Create(OutputMixer*& mixer, uint32_t instanceId)
+AudioMixer::Create(AudioMixer*& mixer, uint32_t instanceId)
 {
     WEBRTC_TRACE(kTraceMemory, kTraceVoice, instanceId,
-                 "OutputMixer::Create(instanceId=%d)", instanceId);
-    mixer = new OutputMixer(instanceId);
+                 "AudioMixer::Create(instanceId=%d)", instanceId);
+    mixer = new AudioMixer(instanceId);
     if (mixer == NULL)
     {
         WEBRTC_TRACE(kTraceMemory, kTraceVoice, instanceId,
-                     "OutputMixer::Create() unable to allocate memory for"
+                     "AudioMixer::Create() unable to allocate memory for"
                      "mixer");
         return -1;
     }
     return 0;
 }
 
-OutputMixer::OutputMixer(uint32_t instanceId) :
-    _mixerModule(*AudioConferenceMixer::Create(instanceId)),
+AudioMixer::AudioMixer(uint32_t instanceId) :
+    _mixerModule(*NewAudioConferenceMixer::Create(instanceId)),
     _audioLevel(),
     _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),
-                 "OutputMixer::OutputMixer() - ctor");
+                 "AudioMixer::AudioMixer() - ctor");
 
     if (_mixerModule.RegisterMixedStreamCallback(this) == -1)
     {
         WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId,-1),
-                     "OutputMixer::OutputMixer() failed to register mixer"
+                     "AudioMixer::AudioMixer() failed to register mixer"
                      "callbacks");
     }
 }
 
 void
-OutputMixer::Destroy(OutputMixer*& mixer)
+AudioMixer::Destroy(AudioMixer*& mixer)
 {
     if (mixer)
     {
         delete mixer;
         mixer = NULL;
     }
 }
 
-OutputMixer::~OutputMixer()
+AudioMixer::~AudioMixer()
 {
     WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId,-1),
-                 "OutputMixer::~OutputMixer() - dtor");
+                 "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
-OutputMixer::SetEngineInformation(voe::Statistics& engineStatistics)
+AudioMixer::SetEngineInformation(voe::Statistics& engineStatistics)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,-1),
-                 "OutputMixer::SetEngineInformation()");
+                 "AudioMixer::SetEngineInformation()");
     _engineStatisticsPtr = &engineStatistics;
     return 0;
 }
 
 int32_t
-OutputMixer::SetAudioProcessingModule(AudioProcessing* audioProcessingModule)
+AudioMixer::SetAudioProcessingModule(AudioProcessing* audioProcessingModule)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,-1),
-                 "OutputMixer::SetAudioProcessingModule("
+                 "AudioMixer::SetAudioProcessingModule("
                  "audioProcessingModule=0x%x)", audioProcessingModule);
     _audioProcessingModulePtr = audioProcessingModule;
     return 0;
 }
 
-int OutputMixer::RegisterExternalMediaProcessing(
+int AudioMixer::RegisterExternalMediaProcessing(
     VoEMediaProcess& proccess_object)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,-1),
-               "OutputMixer::RegisterExternalMediaProcessing()");
+               "AudioMixer::RegisterExternalMediaProcessing()");
 
     rtc::CritScope cs(&_callbackCritSect);
     _externalMediaCallbackPtr = &proccess_object;
     _externalMedia = true;
 
     return 0;
 }
 
-int OutputMixer::DeRegisterExternalMediaProcessing()
+int AudioMixer::DeRegisterExternalMediaProcessing()
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,-1),
-                 "OutputMixer::DeRegisterExternalMediaProcessing()");
+                 "AudioMixer::DeRegisterExternalMediaProcessing()");
 
     rtc::CritScope cs(&_callbackCritSect);
     _externalMedia = false;
     _externalMediaCallbackPtr = NULL;
 
     return 0;
 }
 
 int32_t
-OutputMixer::SetMixabilityStatus(MixerParticipant& participant,
+AudioMixer::SetMixabilityStatus(MixerAudioSource& participant,
                                  bool mixable)

[ivoc, 2016/07/01 07:56:26]

Formatting seems off (nr of spaces)

 {
     return _mixerModule.SetMixabilityStatus(&participant, mixable);
 }
 
 int32_t
-OutputMixer::SetAnonymousMixabilityStatus(MixerParticipant& participant,
+AudioMixer::SetAnonymousMixabilityStatus(MixerAudioSource& participant,
                                           bool mixable)

[ivoc, 2016/07/01 07:56:26]

And here.

 {
     return _mixerModule.SetAnonymousMixabilityStatus(&participant, mixable);
 }
 
 int32_t
-OutputMixer::MixActiveChannels()
+AudioMixer::MixActiveChannels()
 {
     _mixerModule.Process();
     return 0;
 }
 
 int
-OutputMixer::GetSpeechOutputLevel(uint32_t& level)
+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;
 }
 
 int
-OutputMixer::GetSpeechOutputLevelFullRange(uint32_t& level)
+AudioMixer::GetSpeechOutputLevelFullRange(uint32_t& level)
 {
     int16_t currentLevel = _audioLevel.LevelFullRange();
     level = static_cast<uint32_t> (currentLevel);
     WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId,-1),
                  "GetSpeechOutputLevelFullRange() => level=%u", level);
     return 0;
 }
 
 int
-OutputMixer::SetOutputVolumePan(float left, float right)
+AudioMixer::SetOutputVolumePan(float left, float right)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,-1),
-                 "OutputMixer::SetOutputVolumePan()");
+                 "AudioMixer::SetOutputVolumePan()");
     _panLeft = left;
     _panRight = right;
     return 0;
 }
 
 int
-OutputMixer::GetOutputVolumePan(float& left, float& right)
+AudioMixer::GetOutputVolumePan(float& left, float& right)
 {
     left = _panLeft;
     right = _panRight;
     WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId,-1),
                  "GetOutputVolumePan() => left=%2.1f, right=%2.1f",
                  left, right);
     return 0;
 }
 
-int OutputMixer::StartRecordingPlayout(const char* fileName,
+int AudioMixer::StartRecordingPlayout(const char* fileName,
                                        const CodecInst* codecInst)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,-1),
-                 "OutputMixer::StartRecordingPlayout(fileName=%s)", fileName);
+                 "AudioMixer::StartRecordingPlayout(fileName=%s)", fileName);
 
     if (_outputFileRecording)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId,-1),
                      "StartRecordingPlayout() is already recording");
         return 0;
     }
 
     FileFormats format;
     const uint32_t notificationTime(0);
@@ skipping 56 matching lines @@
         FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
         _outputFileRecorderPtr = NULL;
         return -1;
     }
     _outputFileRecorderPtr->RegisterModuleFileCallback(this);
     _outputFileRecording = true;
 
     return 0;
 }
 
-int OutputMixer::StartRecordingPlayout(OutStream* stream,
+int AudioMixer::StartRecordingPlayout(OutStream* stream,
                                        const CodecInst* codecInst)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,-1),
-                 "OutputMixer::StartRecordingPlayout()");
+                 "AudioMixer::StartRecordingPlayout()");
 
     if (_outputFileRecording)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId,-1),
                      "StartRecordingPlayout() is already recording");
         return 0;
     }
 
     FileFormats format;
     const uint32_t notificationTime(0);
@@ skipping 54 matching lines @@
         _outputFileRecorderPtr = NULL;
         return -1;
     }
 
     _outputFileRecorderPtr->RegisterModuleFileCallback(this);
     _outputFileRecording = true;
 
     return 0;
 }
 
-int OutputMixer::StopRecordingPlayout()
+int AudioMixer::StopRecordingPlayout()
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,-1),
-                 "OutputMixer::StopRecordingPlayout()");
+                 "AudioMixer::StopRecordingPlayout()");
 
     if (!_outputFileRecording)
     {
         WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId,-1),
                      "StopRecordingPlayout() file isnot recording");
         return -1;
     }
 
     rtc::CritScope cs(&_fileCritSect);
 
     if (_outputFileRecorderPtr->StopRecording() != 0)
     {
         _engineStatisticsPtr->SetLastError(
             VE_STOP_RECORDING_FAILED, kTraceError,
             "StopRecording(), could not stop recording");
         return -1;
     }
     _outputFileRecorderPtr->RegisterModuleFileCallback(NULL);
     FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
     _outputFileRecorderPtr = NULL;
     _outputFileRecording = false;
 
     return 0;
 }
 
-int OutputMixer::GetMixedAudio(int sample_rate_hz,
+int AudioMixer::GetMixedAudio(int sample_rate_hz,
                                size_t num_channels,
                                AudioFrame* frame) {
   WEBRTC_TRACE(
       kTraceStream, kTraceVoice, VoEId(_instanceId,-1),
-      "OutputMixer::GetMixedAudio(sample_rate_hz=%d, num_channels=%" PRIuS ")",
+      "AudioMixer::GetMixedAudio(sample_rate_hz=%d, num_channels=%" PRIuS ")",
       sample_rate_hz, num_channels);
 
   // --- Record playout if enabled
   {
     rtc::CritScope cs(&_fileCritSect);
     if (_outputFileRecording && _outputFileRecorderPtr)
       _outputFileRecorderPtr->RecordAudioToFile(_audioFrame);
   }
 
   frame->num_channels_ = num_channels;
   frame->sample_rate_hz_ = sample_rate_hz;
   // TODO(andrew): Ideally the downmixing would occur much earlier, in
   // AudioCodingModule.
   RemixAndResample(_audioFrame, &resampler_, frame);
   return 0;
 }
 
 int32_t
-OutputMixer::DoOperationsOnCombinedSignal(bool feed_data_to_apm)
+AudioMixer::DoOperationsOnCombinedSignal(bool feed_data_to_apm)
 {
     if (_audioFrame.sample_rate_hz_ != _mixingFrequencyHz)
     {
         WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,-1),
-                     "OutputMixer::DoOperationsOnCombinedSignal() => "
+                     "AudioMixer::DoOperationsOnCombinedSignal() => "
                      "mixing frequency = %d", _audioFrame.sample_rate_hz_);
         _mixingFrequencyHz = _audioFrame.sample_rate_hz_;
     }
 
     // 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);
@@ skipping 35 matching lines @@
         }
     }
 
     // --- Measure audio level (0-9) for the combined signal
     _audioLevel.ComputeLevel(_audioFrame);
 
     return 0;
 }
 }  // namespace voe
 }  // namespace webrtc