Removals and renamings in the new audio mixer.

webrtc/modules/audio_mixer/audio_mixer_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 "webrtc/modules/audio_mixer/new_audio_conference_mixer_impl.h"
+#include "webrtc/modules/audio_mixer/audio_mixer_impl.h"
 
 #include <algorithm>
 #include <functional>
 
 #include "webrtc/modules/audio_mixer/audio_frame_manipulator.h"
 #include "webrtc/modules/audio_mixer/audio_mixer_defines.h"
 #include "webrtc/modules/audio_processing/include/audio_processing.h"
 #include "webrtc/modules/utility/include/audio_frame_operations.h"
 #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/include/trace.h"
@@ skipping 90 matching lines @@
 
 int32_t NewMixHistory::SetIsMixed(const bool mixed) {
   is_mixed_ = mixed;
   return 0;
 }
 
 void NewMixHistory::ResetMixedStatus() {
   is_mixed_ = false;
 }
 
-NewAudioConferenceMixer* NewAudioConferenceMixer::Create(int id) {
-  NewAudioConferenceMixerImpl* mixer = new NewAudioConferenceMixerImpl(id);
+std::unique_ptr<AudioMixer> AudioMixer::Create(int id) {
+  AudioMixerImpl* mixer = new AudioMixerImpl(id);
   if (!mixer->Init()) {
     delete mixer;
     return NULL;
   }
-  return mixer;
+  return std::unique_ptr<AudioMixer>(mixer);
 }
 
-NewAudioConferenceMixerImpl::NewAudioConferenceMixerImpl(int id)
+AudioMixerImpl::AudioMixerImpl(int id)
     : id_(id),
       output_frequency_(kDefaultFrequency),
       sample_size_(0),
       audio_source_list_(),
       additional_audio_source_list_(),
       num_mixed_audio_sources_(0),
       use_limiter_(true),
       time_stamp_(0) {
   thread_checker_.DetachFromThread();
 }
 
-NewAudioConferenceMixerImpl::~NewAudioConferenceMixerImpl() {}
+AudioMixerImpl::~AudioMixerImpl() {}
 
-bool NewAudioConferenceMixerImpl::Init() {
+bool AudioMixerImpl::Init() {
   crit_.reset(CriticalSectionWrapper::CreateCriticalSection());
   if (crit_.get() == NULL)
     return false;
 
   cb_crit_.reset(CriticalSectionWrapper::CreateCriticalSection());
   if (cb_crit_.get() == NULL)
     return false;
 
   Config config;
   config.Set<ExperimentalAgc>(new ExperimentalAgc(false));
@@ skipping 20 matching lines @@
 
   if (limiter_->gain_control()->enable_limiter(true) != limiter_->kNoError)
     return false;
 
   if (limiter_->gain_control()->Enable(true) != limiter_->kNoError)
     return false;
 
   return true;
 }
 
-void NewAudioConferenceMixerImpl::Mix(int sample_rate,
-                                      size_t number_of_channels,
-                                      AudioFrame* audio_frame_for_mixing) {
+void AudioMixerImpl::Mix(int sample_rate,
+                         size_t number_of_channels,
+                         AudioFrame* audio_frame_for_mixing) {
   RTC_DCHECK(number_of_channels == 1 || number_of_channels == 2);
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   AudioFrameList mixList;
   AudioFrameList additionalFramesList;
   std::map<int, MixerAudioSource*> mixedAudioSourcesMap;
   {
     CriticalSectionScoped cs(cb_crit_.get());
     Frequency mixing_frequency;
 
     switch (sample_rate) {
@@ skipping 54 matching lines @@
       LimitMixedAudio(audio_frame_for_mixing);
     }
   }
 
   // Pass the final result to the level indicator.
   audio_level_.ComputeLevel(*audio_frame_for_mixing);
 
   return;
 }
 
-int32_t NewAudioConferenceMixerImpl::SetOutputFrequency(
-    const Frequency& frequency) {
+int32_t AudioMixerImpl::SetOutputFrequency(const Frequency& frequency) {
   CriticalSectionScoped cs(crit_.get());
 
   output_frequency_ = frequency;
   sample_size_ =
-      static_cast<size_t>((output_frequency_ * kProcessPeriodicityInMs) / 1000);
+      static_cast<size_t>((output_frequency_ * kFrameDurationInMs) / 1000);
 
   return 0;
 }
 
-NewAudioConferenceMixer::Frequency
-NewAudioConferenceMixerImpl::OutputFrequency() const {
+AudioMixer::Frequency AudioMixerImpl::OutputFrequency() const {
   CriticalSectionScoped cs(crit_.get());
   return output_frequency_;
 }
 
-int32_t NewAudioConferenceMixerImpl::SetMixabilityStatus(
-    MixerAudioSource* audio_source,
-    bool mixable) {
+int32_t AudioMixerImpl::SetMixabilityStatus(MixerAudioSource* audio_source,
+                                            bool mixable) {
   if (!mixable) {
     // Anonymous audio sources are in a separate list. Make sure that the
     // audio source is in the _audioSourceList if it is being mixed.
     SetAnonymousMixabilityStatus(audio_source, false);
   }
   size_t numMixedAudioSources;
   {
     CriticalSectionScoped cs(cb_crit_.get());
     const bool isMixed = IsAudioSourceInList(*audio_source, audio_source_list_);
     // API must be called with a new state.
@@ skipping 23 matching lines @@
         numMixedNonAnonymous + additional_audio_source_list_.size();
   }
   // A MixerAudioSource was added or removed. Make sure the scratch
   // buffer is updated if necessary.
   // Note: The scratch buffer may only be updated in Process().
   CriticalSectionScoped cs(crit_.get());
   num_mixed_audio_sources_ = numMixedAudioSources;
   return 0;
 }
 
-bool NewAudioConferenceMixerImpl::MixabilityStatus(
+bool AudioMixerImpl::MixabilityStatus(
     const MixerAudioSource& audio_source) const {
   CriticalSectionScoped cs(cb_crit_.get());
   return IsAudioSourceInList(audio_source, audio_source_list_);
 }
 
-int32_t NewAudioConferenceMixerImpl::SetAnonymousMixabilityStatus(
+int32_t AudioMixerImpl::SetAnonymousMixabilityStatus(
     MixerAudioSource* audio_source,
     bool anonymous) {
   CriticalSectionScoped cs(cb_crit_.get());
   if (IsAudioSourceInList(*audio_source, additional_audio_source_list_)) {
     if (anonymous) {
       return 0;
     }
     if (!RemoveAudioSourceFromList(audio_source,
                                    &additional_audio_source_list_)) {
       WEBRTC_TRACE(kTraceError, kTraceAudioMixerServer, id_,
@@ skipping 14 matching lines @@
         "audio_source must be registered before turning it into anonymous");
     // Setting anonymous status is only possible if MixerAudioSource is
     // already registered.
     return -1;
   }
   return AddAudioSourceToList(audio_source, &additional_audio_source_list_)
              ? 0
              : -1;
 }
 
-bool NewAudioConferenceMixerImpl::AnonymousMixabilityStatus(
+bool AudioMixerImpl::AnonymousMixabilityStatus(
     const MixerAudioSource& audio_source) const {
   CriticalSectionScoped cs(cb_crit_.get());
   return IsAudioSourceInList(audio_source, additional_audio_source_list_);
 }
 
-AudioFrameList NewAudioConferenceMixerImpl::UpdateToMix(
-    size_t maxAudioFrameCounter) const {
+AudioFrameList AudioMixerImpl::UpdateToMix(size_t maxAudioFrameCounter) const {
   AudioFrameList result;
   std::vector<SourceFrame> audioSourceMixingDataList;
 
   // Get audio source audio and put it in the struct vector.
   for (MixerAudioSource* audio_source : audio_source_list_) {
     auto audio_frame_with_info = audio_source->GetAudioFrameWithMuted(
         id_, static_cast<int>(output_frequency_));
 
     auto audio_frame_info = audio_frame_with_info.audio_frame_info;
     AudioFrame* audio_source_audio_frame = audio_frame_with_info.audio_frame;
@@ skipping 36 matching lines @@
     if (p.was_mixed_before_ && !is_mixed) {
       NewMixerRampOut(p.audio_frame_);
       result.emplace_back(p.audio_frame_, false);
     }
 
     p.audio_source_->_mixHistory->SetIsMixed(is_mixed);
   }
   return result;
 }
 
-void NewAudioConferenceMixerImpl::GetAdditionalAudio(
+void AudioMixerImpl::GetAdditionalAudio(
     AudioFrameList* additionalFramesList) const {
   WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, id_,
                "GetAdditionalAudio(additionalFramesList)");
   // The GetAudioFrameWithMuted() callback may result in the audio source being
   // removed from additionalAudioFramesList_. If that happens it will
   // invalidate any iterators. Create a copy of the audio sources list such
   // that the list of participants can be traversed safely.
   MixerAudioSourceList additionalAudioSourceList;
   additionalAudioSourceList.insert(additionalAudioSourceList.begin(),
                                    additional_audio_source_list_.begin(),
@@ skipping 13 matching lines @@
     }
     if (audio_frame->samples_per_channel_ == 0) {
       // Empty frame. Don't use it.
       continue;
     }
     additionalFramesList->push_back(FrameAndMuteInfo(
         audio_frame, ret == MixerAudioSource::AudioFrameInfo::kMuted));
   }
 }
 
-bool NewAudioConferenceMixerImpl::IsAudioSourceInList(
+bool AudioMixerImpl::IsAudioSourceInList(
     const MixerAudioSource& audio_source,
     const MixerAudioSourceList& audioSourceList) const {
   WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, id_,
                "IsAudioSourceInList(audio_source,audioSourceList)");
   return std::find(audioSourceList.begin(), audioSourceList.end(),
                    &audio_source) != audioSourceList.end();
 }
 
-bool NewAudioConferenceMixerImpl::AddAudioSourceToList(
+bool AudioMixerImpl::AddAudioSourceToList(
     MixerAudioSource* audio_source,
     MixerAudioSourceList* audioSourceList) const {
   WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, id_,
                "AddAudioSourceToList(audio_source, audioSourceList)");
   audioSourceList->push_back(audio_source);
   // Make sure that the mixed status is correct for new MixerAudioSource.
   audio_source->_mixHistory->ResetMixedStatus();
   return true;
 }
 
-bool NewAudioConferenceMixerImpl::RemoveAudioSourceFromList(
+bool AudioMixerImpl::RemoveAudioSourceFromList(
     MixerAudioSource* audio_source,
     MixerAudioSourceList* audioSourceList) const {
   WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, id_,
                "RemoveAudioSourceFromList(audio_source, audioSourceList)");
   auto iter =
       std::find(audioSourceList->begin(), audioSourceList->end(), audio_source);
   if (iter != audioSourceList->end()) {
     audioSourceList->erase(iter);
     // AudioSource is no longer mixed, reset to default.
     audio_source->_mixHistory->ResetMixedStatus();
     return true;
   } else {
     return false;
   }
 }
 
-int32_t NewAudioConferenceMixerImpl::MixFromList(
-    AudioFrame* mixedAudio,
-    const AudioFrameList& audioFrameList,
-    int32_t id,
-    bool use_limiter) {
+int32_t AudioMixerImpl::MixFromList(AudioFrame* mixedAudio,
+                                    const AudioFrameList& audioFrameList,
+                                    int32_t id,
+                                    bool use_limiter) {
   WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, id,
                "MixFromList(mixedAudio, audioFrameList)");
   if (audioFrameList.empty())
     return 0;
 
   uint32_t position = 0;
 
   if (audioFrameList.size() == 1) {
     mixedAudio->timestamp_ = audioFrameList.front().frame->timestamp_;
     mixedAudio->elapsed_time_ms_ =
@@ skipping 11 matching lines @@
       MixFrames(mixedAudio, iter->frame, use_limiter);
     }
 
     position++;
   }
 
   return 0;
 }
 
 // TODO(andrew): consolidate this function with MixFromList.
-int32_t NewAudioConferenceMixerImpl::MixAnonomouslyFromList(
+int32_t AudioMixerImpl::MixAnonomouslyFromList(
     AudioFrame* mixedAudio,
     const AudioFrameList& audioFrameList) const {
   WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, id_,
                "MixAnonomouslyFromList(mixedAudio, audioFrameList)");
 
   if (audioFrameList.empty())
     return 0;
 
   for (AudioFrameList::const_iterator iter = audioFrameList.begin();
        iter != audioFrameList.end(); ++iter) {
     if (!iter->muted) {
       MixFrames(mixedAudio, iter->frame, use_limiter_);
     }
   }
   return 0;
 }
 
-bool NewAudioConferenceMixerImpl::LimitMixedAudio(
-    AudioFrame* mixedAudio) const {
+bool AudioMixerImpl::LimitMixedAudio(AudioFrame* mixedAudio) const {
   if (!use_limiter_) {
     return true;
   }
 
   // Smoothly limit the mixed frame.
   const int error = limiter_->ProcessStream(mixedAudio);
 
   // And now we can safely restore the level. This procedure results in
   // some loss of resolution, deemed acceptable.
   //
   // It's possible to apply the gain in the AGC (with a target level of 0 dbFS
   // and compression gain of 6 dB). However, in the transition frame when this
   // is enabled (moving from one to two audio sources) it has the potential to
   // create discontinuities in the mixed frame.
   //
   // Instead we double the frame (with addition since left-shifting a
   // negative value is undefined).
   *mixedAudio += *mixedAudio;
 
   if (error != limiter_->kNoError) {
     WEBRTC_TRACE(kTraceError, kTraceAudioMixerServer, id_,
                  "Error from AudioProcessing: %d", error);
     RTC_NOTREACHED();
     return false;
   }
   return true;
 }
 
-int NewAudioConferenceMixerImpl::GetOutputAudioLevel() {
+int AudioMixerImpl::GetOutputAudioLevel() {
   const int level = audio_level_.Level();
   WEBRTC_TRACE(kTraceStateInfo, kTraceAudioMixerServer, id_,
                "GetAudioOutputLevel() => level=%d", level);
   return level;
 }
 
-int NewAudioConferenceMixerImpl::GetOutputAudioLevelFullRange() {
+int AudioMixerImpl::GetOutputAudioLevelFullRange() {
   const int level = audio_level_.LevelFullRange();
   WEBRTC_TRACE(kTraceStateInfo, kTraceAudioMixerServer, id_,
                "GetAudioOutputLevelFullRange() => level=%d", level);
   return level;
 }
 }  // namespace webrtc