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

Index: webrtc/modules/audio_mixer/audio_mixer.cc
diff --git a/webrtc/voice_engine/output_mixer.cc b/webrtc/modules/audio_mixer/audio_mixer.cc
similarity index 82%
copy from webrtc/voice_engine/output_mixer.cc
copy to webrtc/modules/audio_mixer/audio_mixer.cc
index 05e6f84ec9cb8dc36ddab7464248431fc2c02ccf..9800e5da1f9811110e1f19d36cbd27bb2d9f97cf 100644
--- a/webrtc/voice_engine/output_mixer.cc
+++ b/webrtc/modules/audio_mixer/audio_mixer.cc
@@ -8,7 +8,7 @@
  *  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"
@@ -23,75 +23,75 @@ 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),
@@ -103,18 +103,18 @@ OutputMixer::OutputMixer(uint32_t instanceId) :
     _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)
     {
@@ -123,10 +123,10 @@ OutputMixer::Destroy(OutputMixer*& mixer)
     }
 }
 
-OutputMixer::~OutputMixer()
+AudioMixer::~AudioMixer()
 {
     WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId,-1),
-                 "OutputMixer::~OutputMixer() - dtor");
+                 "AudioMixer::~AudioMixer() - dtor");
     if (_externalMedia)
     {
         DeRegisterExternalMediaProcessing();
@@ -146,29 +146,29 @@ OutputMixer::~OutputMixer()
 }
 
 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;
@@ -177,10 +177,10 @@ int OutputMixer::RegisterExternalMediaProcessing(
     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;
@@ -190,28 +190,28 @@ int OutputMixer::DeRegisterExternalMediaProcessing()
 }
 
 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);
@@ -221,7 +221,7 @@ OutputMixer::GetSpeechOutputLevel(uint32_t& level)
 }
 
 int
-OutputMixer::GetSpeechOutputLevelFullRange(uint32_t& level)
+AudioMixer::GetSpeechOutputLevelFullRange(uint32_t& level)
 {
     int16_t currentLevel = _audioLevel.LevelFullRange();
     level = static_cast<uint32_t> (currentLevel);
@@ -231,17 +231,17 @@ OutputMixer::GetSpeechOutputLevelFullRange(uint32_t& level)
 }
 
 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;
@@ -251,11 +251,11 @@ OutputMixer::GetOutputVolumePan(float& left, float& 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)
     {
@@ -332,11 +332,11 @@ int OutputMixer::StartRecordingPlayout(const char* fileName,
     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)
     {
@@ -411,10 +411,10 @@ int OutputMixer::StartRecordingPlayout(OutStream* stream,
     return 0;
 }
 
-int OutputMixer::StopRecordingPlayout()
+int AudioMixer::StopRecordingPlayout()
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,-1),
-                 "OutputMixer::StopRecordingPlayout()");
+                 "AudioMixer::StopRecordingPlayout()");
 
     if (!_outputFileRecording)
     {
@@ -440,12 +440,12 @@ int OutputMixer::StopRecordingPlayout()
     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
@@ -464,12 +464,12 @@ int OutputMixer::GetMixedAudio(int sample_rate_hz,
 }
 
 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_;
     }