Made MixerAudioSource a pure interface.

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/audio_mixer_impl.h"
 
 #include <algorithm>
 #include <functional>
 #include <utility>
 
+#include "webrtc/base/logging.h"
 #include "webrtc/modules/audio_mixer/audio_frame_manipulator.h"
 #include "webrtc/modules/utility/include/audio_frame_operations.h"
 #include "webrtc/system_wrappers/include/trace.h"
 
 namespace webrtc {
 namespace {
 
 class SourceFrame {
  public:
-  SourceFrame(MixerAudioSource* p, AudioFrame* a, bool m, bool was_mixed_before)
-      : audio_source_(p),
-        audio_frame_(a),
-        muted_(m),
-        was_mixed_before_(was_mixed_before) {
+  SourceFrame(AudioSourceWithMixStatus* audio_source,
+              AudioFrame* audio_frame,
+              bool muted)
+      : audio_source_(audio_source), audio_frame_(audio_frame), muted_(muted) {
     if (!muted_) {
-      energy_ = NewMixerCalculateEnergy(*a);
+      energy_ = AudioMixerCalculateEnergy(*audio_frame);
     }
   }
 
-  SourceFrame(MixerAudioSource* p,
-              AudioFrame* a,
-              bool m,
-              bool was_mixed_before,
+  SourceFrame(AudioSourceWithMixStatus* audio_source,
+              AudioFrame* audio_frame,
+              bool muted,
               uint32_t energy)
-      : audio_source_(p),
-        audio_frame_(a),
-        muted_(m),
-        energy_(energy),
-        was_mixed_before_(was_mixed_before) {}
+      : audio_source_(audio_source),
+        audio_frame_(audio_frame),
+        muted_(muted),
+        energy_(energy) {}
 
-  // a.shouldMixBefore(b) is used to select mixer participants.
-  bool shouldMixBefore(const SourceFrame& other) const {
+  // a.ShouldMixBefore(b) is used to select mixer sources.
+  bool ShouldMixBefore(const SourceFrame& other) const {
     if (muted_ != other.muted_) {
       return other.muted_;
     }
 
     const auto our_activity = audio_frame_->vad_activity_;
     const auto other_activity = other.audio_frame_->vad_activity_;
 
     if (our_activity != other_activity) {
       return our_activity == AudioFrame::kVadActive;
     }
 
     return energy_ > other.energy_;
   }
 
-  MixerAudioSource* audio_source_;
-  AudioFrame* audio_frame_;
-  bool muted_;
-  uint32_t energy_;
-  bool was_mixed_before_;
+  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.was_mixed_before_) {
+    if (!source_frame.audio_source_->WasMixed()) {
       NewMixerRampIn(source_frame.audio_frame_);
     }
 
     const bool is_mixed = source_frame.audio_source_->IsMixed();
     // Ramp out currently unmixed.
-    if (source_frame.was_mixed_before_ && !is_mixed) {
+    if (source_frame.audio_source_->WasMixed() && !is_mixed) {
       NewMixerRampOut(source_frame.audio_frame_);
     }
   }
 }
 
 // Mix the AudioFrames stored in audioFrameList into mixed_audio.
 int32_t MixFromList(AudioFrame* mixed_audio,
                     const AudioFrameList& audio_frame_list,
                     int32_t id,
                     bool use_limiter) {
@@ skipping 26 matching lines @@
       // Divide by two to avoid saturation in the mixing.
       // 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,
+    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,
+    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) {
   return AudioMixerImpl::Create(id);
 }
 
 AudioMixerImpl::AudioMixerImpl(int id, std::unique_ptr<AudioProcessing> limiter)
     : id_(id),
       audio_source_list_(),
       additional_audio_source_list_(),
       num_mixed_audio_sources_(0),
       use_limiter_(true),
       time_stamp_(0),
       limiter_(std::move(limiter)) {
   SetOutputFrequency(kDefaultFrequency);
   thread_checker_.DetachFromThread();
 }
 
 AudioMixerImpl::~AudioMixerImpl() {}
 
-std::unique_ptr<AudioMixer> AudioMixerImpl::Create(int id) {
+std::unique_ptr<AudioMixerImpl> AudioMixerImpl::Create(int id) {
   Config config;
   config.Set<ExperimentalAgc>(new ExperimentalAgc(false));
   std::unique_ptr<AudioProcessing> limiter(AudioProcessing::Create(config));
   if (!limiter.get())
     return nullptr;
 
   if (limiter->gain_control()->set_mode(GainControl::kFixedDigital) !=
       limiter->kNoError)
     return nullptr;
 
   // We smoothly limit the mixed frame to -7 dbFS. -6 would correspond to the
   // divide-by-2 but -7 is used instead to give a bit of headroom since the
   // AGC is not a hard limiter.
   if (limiter->gain_control()->set_target_level_dbfs(7) != limiter->kNoError)
     return nullptr;
 
   if (limiter->gain_control()->set_compression_gain_db(0) != limiter->kNoError)
     return nullptr;
 
   if (limiter->gain_control()->enable_limiter(true) != limiter->kNoError)
     return nullptr;
 
   if (limiter->gain_control()->Enable(true) != limiter->kNoError)
     return nullptr;
 
-  return std::unique_ptr<AudioMixer>(
+  return std::unique_ptr<AudioMixerImpl>(
       new AudioMixerImpl(id, std::move(limiter)));
 }
 
 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_RUN_ON(&thread_checker_);
 
   if (sample_rate != kNbInHz && sample_rate != kWbInHz &&
@@ skipping 66 matching lines @@
 
 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);
   }
   {
     rtc::CritScope lock(&crit_);
-    const bool is_mixed =
-        IsAudioSourceInList(*audio_source, audio_source_list_);
+    const bool is_mixed = FindSourceInList(audio_source, &audio_source_list_) !=
+                          audio_source_list_.end();
     // API must be called with a new state.
     if (!(mixable ^ is_mixed)) {
       WEBRTC_TRACE(kTraceWarning, kTraceAudioMixerServer, id_,
                    "Mixable is aready %s", is_mixed ? "ON" : "off");
       return -1;
     }
     bool success = false;
     if (mixable) {
       success = AddAudioSourceToList(audio_source, &audio_source_list_);
     } else {
@@ skipping 12 matching lines @@
     }
     num_mixed_audio_sources_ =
         num_mixed_non_anonymous + additional_audio_source_list_.size();
   }
   return 0;
 }
 
 bool AudioMixerImpl::MixabilityStatus(
     const MixerAudioSource& audio_source) const {
   rtc::CritScope lock(&crit_);
-  return IsAudioSourceInList(audio_source, audio_source_list_);
+  return FindSourceInList(&audio_source, &audio_source_list_) !=
+         audio_source_list_.end();
 }
 
 int32_t AudioMixerImpl::SetAnonymousMixabilityStatus(
     MixerAudioSource* audio_source,
     bool anonymous) {
   rtc::CritScope lock(&crit_);
-  if (IsAudioSourceInList(*audio_source, additional_audio_source_list_)) {
+  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");
       RTC_NOTREACHED();
       return -1;
     }
@@ skipping 13 matching lines @@
     return -1;
   }
   return AddAudioSourceToList(audio_source, &additional_audio_source_list_)
              ? 0
              : -1;
 }
 
 bool AudioMixerImpl::AnonymousMixabilityStatus(
     const MixerAudioSource& audio_source) const {
   rtc::CritScope lock(&crit_);
-  return IsAudioSourceInList(audio_source, additional_audio_source_list_);
+  return FindSourceInList(&audio_source, &additional_audio_source_list_) !=
+         additional_audio_source_list_.end();
 }
 
-AudioFrameList AudioMixerImpl::GetNonAnonymousAudio() const {
+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* const audio_source : audio_source_list_) {
-    auto audio_frame_with_info = audio_source->GetAudioFrameWithMuted(
-        id_, static_cast<int>(OutputFrequency()));
+  for (auto& source_and_status : audio_source_list_) {
+    auto audio_frame_with_info =
+        source_and_status.audio_source()->GetAudioFrameWithMuted(
+            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) {
       WEBRTC_TRACE(kTraceWarning, kTraceAudioMixerServer, id_,
-                   "failed to GetAudioFrameWithMuted() from participant");
+                   "failed to GetAudioFrameWithMuted() from source");
       continue;
     }
     audio_source_mixing_data_list.emplace_back(
-        audio_source, audio_source_audio_frame,
-        audio_frame_info == MixerAudioSource::AudioFrameInfo::kMuted,
-        audio_source->WasMixed());
+        &source_and_status, audio_source_audio_frame,
+        audio_frame_info == MixerAudioSource::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));
+            std::mem_fn(&SourceFrame::ShouldMixBefore));
 
   int max_audio_frame_counter = kMaximumAmountOfMixedAudioSources;
 
   // Go through list in order and put unmuted frames in result list.
-  for (const SourceFrame& p : audio_source_mixing_data_list) {
+  for (const auto& p : audio_source_mixing_data_list) {
     // Filter muted.
     if (p.muted_) {
       p.audio_source_->SetIsMixed(false);
       continue;
     }
 
     // Add frame to result vector for mixing.
     bool is_mixed = false;
     if (max_audio_frame_counter > 0) {
       --max_audio_frame_counter;
       result.push_back(p.audio_frame_);
-      ramp_list.emplace_back(p.audio_source_, p.audio_frame_, false,
-                             p.was_mixed_before_, -1);
+      ramp_list.emplace_back(p.audio_source_, p.audio_frame_, false, -1);
       is_mixed = true;
     }
     p.audio_source_->SetIsMixed(is_mixed);
   }
   Ramp(ramp_list);
   return result;
 }
 
-AudioFrameList AudioMixerImpl::GetAnonymousAudio() const {
+AudioFrameList AudioMixerImpl::GetAnonymousAudio() {
   RTC_DCHECK_RUN_ON(&thread_checker_);
   WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, id_,
                "GetAnonymousAudio()");
-  // 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.
   std::vector<SourceFrame> ramp_list;
-  MixerAudioSourceList additional_audio_sources_list;
   AudioFrameList result;
-  additional_audio_sources_list.insert(additional_audio_sources_list.begin(),
-                                       additional_audio_source_list_.begin(),
-                                       additional_audio_source_list_.end());
-
-  for (const auto& audio_source : additional_audio_sources_list) {
+  for (auto& source_and_status : additional_audio_source_list_) {
     const auto audio_frame_with_info =
-        audio_source->GetAudioFrameWithMuted(id_, OutputFrequency());
+        source_and_status.audio_source()->GetAudioFrameWithMuted(
+            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) {
       WEBRTC_TRACE(kTraceWarning, kTraceAudioMixerServer, id_,
                    "failed to GetAudioFrameWithMuted() from audio_source");
       continue;
     }
     if (ret != MixerAudioSource::AudioFrameInfo::kMuted) {
       result.push_back(audio_frame);
-      ramp_list.emplace_back(audio_source, audio_frame, false,
-                             audio_source->IsMixed(), 0);
-      audio_source->SetIsMixed(true);
+      ramp_list.emplace_back(&source_and_status, audio_frame, false, 0);
+      source_and_status.SetIsMixed(true);
     }
   }
   Ramp(ramp_list);
   return result;
 }
 
-bool AudioMixerImpl::IsAudioSourceInList(
-    const MixerAudioSource& audio_source,
-    const MixerAudioSourceList& audio_source_list) const {
-  WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, id_,
-               "IsAudioSourceInList(audio_source,audio_source_list)");
-  return std::find(audio_source_list.begin(), audio_source_list.end(),
-                   &audio_source) != audio_source_list.end();
-}
-
 bool AudioMixerImpl::AddAudioSourceToList(
     MixerAudioSource* audio_source,
     MixerAudioSourceList* audio_source_list) const {
   WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, id_,
                "AddAudioSourceToList(audio_source, audio_source_list)");
-  audio_source_list->push_back(audio_source);
-  // Make sure that the mixed status is correct for new MixerAudioSource.
-  audio_source->ResetMixedStatus();
+  audio_source_list->emplace_back(audio_source);
   return true;
 }
 
 bool AudioMixerImpl::RemoveAudioSourceFromList(
     MixerAudioSource* audio_source,
     MixerAudioSourceList* audio_source_list) const {
   WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, id_,
                "RemoveAudioSourceFromList(audio_source, audio_source_list)");
-  const auto iter = std::find(audio_source_list->begin(),
-                              audio_source_list->end(), audio_source);
+  const auto iter = FindSourceInList(audio_source, audio_source_list);
   if (iter != audio_source_list->end()) {
     audio_source_list->erase(iter);
-    // AudioSource is no longer mixed, reset to default.
-    audio_source->ResetMixedStatus();
     return true;
   } else {
     return false;
   }
 }
 
 bool AudioMixerImpl::LimitMixedAudio(AudioFrame* mixed_audio) const {
   RTC_DCHECK_RUN_ON(&thread_checker_);
   if (!use_limiter_) {
     return true;
@@ skipping 31 matching lines @@
   return level;
 }
 
 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) {
+  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_T_F(LS_ERROR) << "Audio source unknown";
+  return false;
+}
 }  // namespace webrtc