Moved MixerAudioSource and removed audio_mixer_defines.h.

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.
  */
 
@@ skipping 46 matching lines @@
 
     return energy_ > other.energy_;
   }
 
   AudioSourceWithMixStatus* audio_source_ = nullptr;
   AudioFrame* audio_frame_ = nullptr;
   bool muted_ = true;
   uint32_t energy_ = 0;
 };
 
-// Remixes a frame between stereo and mono.
-void RemixFrame(AudioFrame* frame, size_t number_of_channels) {
-  RTC_DCHECK(number_of_channels == 1 || number_of_channels == 2);
-  if (frame->num_channels_ == 1 && number_of_channels == 2) {
-    AudioFrameOperations::MonoToStereo(frame);
-  } else if (frame->num_channels_ == 2 && number_of_channels == 1) {
-    AudioFrameOperations::StereoToMono(frame);
-  }
-}
 
 void Ramp(const std::vector<SourceFrame>& mixed_sources_and_frames) {
   for (const auto& source_frame : mixed_sources_and_frames) {
     // Ramp in previously unmixed.
     if (!source_frame.audio_source_->WasMixed()) {
       NewMixerRampIn(source_frame.audio_frame_);
     }
 
     const bool is_mixed = source_frame.audio_source_->IsMixed();
     // Ramp out currently unmixed.
@@ skipping 38 matching lines @@
       // This is only meaningful if the limiter will be used.
       *frame >>= 1;
     }
     RTC_DCHECK_EQ(frame->num_channels_, mixed_audio->num_channels_);
     *mixed_audio += *frame;
   }
   return 0;
 }
 
 MixerAudioSourceList::const_iterator FindSourceInList(
-    MixerAudioSource const* audio_source,
+    AudioMixerImpl::Source const* audio_source,
     MixerAudioSourceList const* audio_source_list) {
   return std::find_if(audio_source_list->begin(), audio_source_list->end(),
                       [audio_source](const AudioSourceWithMixStatus& p) {
                         return p.audio_source() == audio_source;
                       });
 }
 
 MixerAudioSourceList::iterator FindSourceInList(
-    MixerAudioSource const* audio_source,
+    AudioMixerImpl::Source const* audio_source,
     MixerAudioSourceList* audio_source_list) {
   return std::find_if(audio_source_list->begin(), audio_source_list->end(),
                       [audio_source](const AudioSourceWithMixStatus& p) {
                         return p.audio_source() == audio_source;
                       });
 }
 
 }  // namespace
 
 std::unique_ptr<AudioMixer> AudioMixer::Create(int id) {
@@ skipping 69 matching lines @@
     rtc::CritScope lock(&crit_);
     mix_list = GetNonAnonymousAudio();
     anonymous_mix_list = GetAnonymousAudio();
     num_mixed_audio_sources = num_mixed_audio_sources_;
   }
 
   mix_list.insert(mix_list.begin(), anonymous_mix_list.begin(),
                   anonymous_mix_list.end());
 
   for (const auto& frame : mix_list) {
-    RemixFrame(frame, number_of_channels);
+    RemixFrame(number_of_channels, frame);
   }
 
   audio_frame_for_mixing->UpdateFrame(
       -1, time_stamp_, NULL, 0, OutputFrequency(), AudioFrame::kNormalSpeech,
       AudioFrame::kVadPassive, number_of_channels);
 
   time_stamp_ += static_cast<uint32_t>(sample_size_);
 
   use_limiter_ = num_mixed_audio_sources > 1;
 
@@ skipping 21 matching lines @@
   sample_size_ = (output_frequency_ * kFrameDurationInMs) / 1000;
 
   return 0;
 }
 
 AudioMixer::Frequency AudioMixerImpl::OutputFrequency() const {
   RTC_DCHECK_RUN_ON(&thread_checker_);
   return output_frequency_;
 }
 
-int32_t AudioMixerImpl::SetMixabilityStatus(MixerAudioSource* audio_source,
+int32_t AudioMixerImpl::SetMixabilityStatus(Source* 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);
   }
   {
     rtc::CritScope lock(&crit_);
     const bool is_mixed = FindSourceInList(audio_source, &audio_source_list_) !=
                           audio_source_list_.end();
@@ skipping 19 matching lines @@
     size_t num_mixed_non_anonymous = audio_source_list_.size();
     if (num_mixed_non_anonymous > kMaximumAmountOfMixedAudioSources) {
       num_mixed_non_anonymous = kMaximumAmountOfMixedAudioSources;
     }
     num_mixed_audio_sources_ =
         num_mixed_non_anonymous + additional_audio_source_list_.size();
   }
   return 0;
 }
 
-bool AudioMixerImpl::MixabilityStatus(
-    const MixerAudioSource& audio_source) const {
+bool AudioMixerImpl::MixabilityStatus(const Source& audio_source) const {
   rtc::CritScope lock(&crit_);
   return FindSourceInList(&audio_source, &audio_source_list_) !=
          audio_source_list_.end();
 }
 
-int32_t AudioMixerImpl::SetAnonymousMixabilityStatus(
-    MixerAudioSource* audio_source,
-    bool anonymous) {
+int32_t AudioMixerImpl::SetAnonymousMixabilityStatus(Source* audio_source,
+                                                     bool anonymous) {
   rtc::CritScope lock(&crit_);
   if (FindSourceInList(audio_source, &additional_audio_source_list_) !=
       additional_audio_source_list_.end()) {
     if (anonymous) {
       return 0;
     }
     if (!RemoveAudioSourceFromList(audio_source,
                                    &additional_audio_source_list_)) {
       WEBRTC_TRACE(kTraceError, kTraceAudioMixerServer, id_,
                    "unable to remove audio_source from anonymous list");
@@ skipping 14 matching lines @@
     // Setting anonymous status is only possible if MixerAudioSource is
     // already registered.
     return -1;
   }
   return AddAudioSourceToList(audio_source, &additional_audio_source_list_)
              ? 0
              : -1;
 }
 
 bool AudioMixerImpl::AnonymousMixabilityStatus(
-    const MixerAudioSource& audio_source) const {
+    const Source& audio_source) const {
   rtc::CritScope lock(&crit_);
   return FindSourceInList(&audio_source, &additional_audio_source_list_) !=
          additional_audio_source_list_.end();
 }
 
 AudioFrameList AudioMixerImpl::GetNonAnonymousAudio() {
   RTC_DCHECK_RUN_ON(&thread_checker_);
   WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, id_,
                "GetNonAnonymousAudio()");
   AudioFrameList result;
   std::vector<SourceFrame> audio_source_mixing_data_list;
   std::vector<SourceFrame> ramp_list;
 
   // Get audio source audio and put it in the struct vector.
   for (auto& source_and_status : audio_source_list_) {
     auto audio_frame_with_info =
-        source_and_status.audio_source()->GetAudioFrameWithMuted(
+        source_and_status.audio_source()->GetAudioFrameWithInfo(
             id_, static_cast<int>(OutputFrequency()));
 
     const auto audio_frame_info = audio_frame_with_info.audio_frame_info;
     AudioFrame* audio_source_audio_frame = audio_frame_with_info.audio_frame;
 
-    if (audio_frame_info == MixerAudioSource::AudioFrameInfo::kError) {
+    if (audio_frame_info == Source::AudioFrameInfo::kError) {
       WEBRTC_TRACE(kTraceWarning, kTraceAudioMixerServer, id_,
                    "failed to GetAudioFrameWithMuted() from source");
       continue;
     }
     audio_source_mixing_data_list.emplace_back(
         &source_and_status, audio_source_audio_frame,
-        audio_frame_info == MixerAudioSource::AudioFrameInfo::kMuted);
+        audio_frame_info == Source::AudioFrameInfo::kMuted);
   }
 
   // Sort frames by sorting function.
   std::sort(audio_source_mixing_data_list.begin(),
             audio_source_mixing_data_list.end(),
             std::mem_fn(&SourceFrame::ShouldMixBefore));
 
   int max_audio_frame_counter = kMaximumAmountOfMixedAudioSources;
 
   // Go through list in order and put unmuted frames in result list.
@@ skipping 19 matching lines @@
 }
 
 AudioFrameList AudioMixerImpl::GetAnonymousAudio() {
   RTC_DCHECK_RUN_ON(&thread_checker_);
   WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, id_,
                "GetAnonymousAudio()");
   std::vector<SourceFrame> ramp_list;
   AudioFrameList result;
   for (auto& source_and_status : additional_audio_source_list_) {
     const auto audio_frame_with_info =
-        source_and_status.audio_source()->GetAudioFrameWithMuted(
+        source_and_status.audio_source()->GetAudioFrameWithInfo(
             id_, OutputFrequency());
     const auto ret = audio_frame_with_info.audio_frame_info;
     AudioFrame* audio_frame = audio_frame_with_info.audio_frame;
-    if (ret == MixerAudioSource::AudioFrameInfo::kError) {
+    if (ret == Source::AudioFrameInfo::kError) {
       WEBRTC_TRACE(kTraceWarning, kTraceAudioMixerServer, id_,
                    "failed to GetAudioFrameWithMuted() from audio_source");
       continue;
     }
-    if (ret != MixerAudioSource::AudioFrameInfo::kMuted) {
+    if (ret != Source::AudioFrameInfo::kMuted) {
       result.push_back(audio_frame);
       ramp_list.emplace_back(&source_and_status, audio_frame, false, 0);
       source_and_status.SetIsMixed(true);
     }
   }
   Ramp(ramp_list);
   return result;
 }
 
 bool AudioMixerImpl::AddAudioSourceToList(
-    MixerAudioSource* audio_source,
+    Source* audio_source,
     MixerAudioSourceList* audio_source_list) const {
   WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, id_,
                "AddAudioSourceToList(audio_source, audio_source_list)");
   audio_source_list->emplace_back(audio_source);
   return true;
 }
 
 bool AudioMixerImpl::RemoveAudioSourceFromList(
-    MixerAudioSource* audio_source,
+    Source* audio_source,
     MixerAudioSourceList* audio_source_list) const {
   WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, id_,
                "RemoveAudioSourceFromList(audio_source, audio_source_list)");
   const auto iter = FindSourceInList(audio_source, audio_source_list);
   if (iter != audio_source_list->end()) {
     audio_source_list->erase(iter);
     return true;
   } else {
     return false;
   }
@@ skipping 39 matching lines @@
 
 int AudioMixerImpl::GetOutputAudioLevelFullRange() {
   RTC_DCHECK_RUN_ON(&thread_checker_);
   const int level = audio_level_.LevelFullRange();
   WEBRTC_TRACE(kTraceStateInfo, kTraceAudioMixerServer, id_,
                "GetAudioOutputLevelFullRange() => level=%d", level);
   return level;
 }
 
 bool AudioMixerImpl::GetAudioSourceMixabilityStatusForTest(
-    MixerAudioSource* audio_source) {
+    AudioMixerImpl::Source* audio_source) {
   RTC_DCHECK_RUN_ON(&thread_checker_);
   rtc::CritScope lock(&crit_);
 
   const auto non_anonymous_iter =
       FindSourceInList(audio_source, &audio_source_list_);
   if (non_anonymous_iter != audio_source_list_.end()) {
     return non_anonymous_iter->IsMixed();
   }
 
   const auto anonymous_iter =
       FindSourceInList(audio_source, &additional_audio_source_list_);
   if (anonymous_iter != audio_source_list_.end()) {
     return anonymous_iter->IsMixed();
   }
 
   LOG(LS_ERROR) << "Audio source unknown";
   return false;
 }
 }  // namespace webrtc