Injectable output rate calculater for AudioMixer.

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 <iterator>
 #include <utility>
 
 #include "webrtc/audio/utility/audio_frame_operations.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/modules/audio_mixer/audio_frame_manipulator.h"
+#include "webrtc/modules/audio_mixer/default_output_rate_calculator.h"
 
 namespace webrtc {
 namespace {
 
 struct SourceFrame {
   SourceFrame(AudioMixerImpl::SourceStatus* source_status,
               AudioFrame* audio_frame,
               bool muted)
       : source_status(source_status), audio_frame(audio_frame), muted(muted) {
     RTC_DCHECK(source_status);
@@ skipping 100 matching lines @@
 AudioMixerImpl::SourceStatusList::iterator FindSourceInList(
     AudioMixerImpl::Source const* audio_source,
     AudioMixerImpl::SourceStatusList* audio_source_list) {
   return std::find_if(
       audio_source_list->begin(), audio_source_list->end(),
       [audio_source](const std::unique_ptr<AudioMixerImpl::SourceStatus>& p) {
         return p->audio_source == audio_source;
       });
 }
 
-// Rounds the maximal audio source frequency up to an APM-native
-// frequency.
-int CalculateMixingFrequency(
-    const AudioMixerImpl::SourceStatusList& audio_source_list) {
-  if (audio_source_list.empty()) {
-    return AudioMixerImpl::kDefaultFrequency;
-  }
-  using NativeRate = AudioProcessing::NativeRate;
-  int maximal_frequency = 0;
-  for (const auto& source_status : audio_source_list) {
-    const int source_needed_frequency =
-        source_status->audio_source->PreferredSampleRate();
-    RTC_DCHECK_LE(NativeRate::kSampleRate8kHz, source_needed_frequency);
-    RTC_DCHECK_LE(source_needed_frequency, NativeRate::kSampleRate48kHz);
-    maximal_frequency = std::max(maximal_frequency, source_needed_frequency);
-  }
-
-  static constexpr NativeRate native_rates[] = {
-      NativeRate::kSampleRate8kHz, NativeRate::kSampleRate16kHz,
-      NativeRate::kSampleRate32kHz, NativeRate::kSampleRate48kHz};
-  const auto rounded_up_index = std::lower_bound(
-      std::begin(native_rates), std::end(native_rates), maximal_frequency);
-  RTC_DCHECK(rounded_up_index != std::end(native_rates));
-  return *rounded_up_index;
-}
-
-}  // namespace
-
-AudioMixerImpl::AudioMixerImpl(std::unique_ptr<AudioProcessing> limiter)
-    : audio_source_list_(),
-      use_limiter_(true),
-      time_stamp_(0),
-      limiter_(std::move(limiter)) {
-  SetOutputFrequency(kDefaultFrequency);
-}
-
-AudioMixerImpl::~AudioMixerImpl() {}
-
-rtc::scoped_refptr<AudioMixerImpl> AudioMixerImpl::Create() {
+std::unique_ptr<AudioProcessing> CreateLimiter() {
   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;
@@ skipping 11 matching lines @@
     return nullptr;
   }
 
   if (limiter->gain_control()->enable_limiter(true) != limiter->kNoError) {
     return nullptr;
   }
 
   if (limiter->gain_control()->Enable(true) != limiter->kNoError) {
     return nullptr;
   }
+  return limiter;
+}
 
+}  // namespace
+
+AudioMixerImpl::AudioMixerImpl(
+    std::unique_ptr<AudioProcessing> limiter,
+    std::unique_ptr<OutputRateCalculator> output_rate_calculator)
+    : output_rate_calculator_(std::move(output_rate_calculator)),
+      output_frequency_(0),
+      sample_size_(0),
+      audio_source_list_(),
+      use_limiter_(true),
+      time_stamp_(0),
+      limiter_(std::move(limiter)) {}
+
+AudioMixerImpl::~AudioMixerImpl() {}
+
+rtc::scoped_refptr<AudioMixerImpl> AudioMixerImpl::Create() {
+  return CreateWithOutputRateCalculator(
+      std::unique_ptr<DefaultOutputRateCalculator>(
+          new DefaultOutputRateCalculator()));
+}
+
+rtc::scoped_refptr<AudioMixerImpl>
+AudioMixerImpl::CreateWithOutputRateCalculator(
+    std::unique_ptr<OutputRateCalculator> output_rate_calculator) {
   return rtc::scoped_refptr<AudioMixerImpl>(
-      new rtc::RefCountedObject<AudioMixerImpl>(std::move(limiter)));
+      new rtc::RefCountedObject<AudioMixerImpl>(
+          CreateLimiter(), std::move(output_rate_calculator)));
 }
 
 void AudioMixerImpl::Mix(size_t number_of_channels,
                          AudioFrame* audio_frame_for_mixing) {
   RTC_DCHECK(number_of_channels == 1 || number_of_channels == 2);
   RTC_DCHECK_RUNS_SERIALIZED(&race_checker_);
 
-  const int sample_rate = [&]() {
-    rtc::CritScope lock(&crit_);
-    return CalculateMixingFrequency(audio_source_list_);
-  }();
-
-  if (OutputFrequency() != sample_rate) {
-    SetOutputFrequency(sample_rate);
-  }
+  CalculateOutputFrequency();
 
   AudioFrameList mix_list;
   {
     rtc::CritScope lock(&crit_);
     mix_list = GetAudioFromSources();
 
     for (const auto& frame : mix_list) {
       RemixFrame(number_of_channels, frame);
     }
 
@@ skipping 14 matching lines @@
     audio_frame_for_mixing->samples_per_channel_ = sample_size_;
     AudioFrameOperations::Mute(audio_frame_for_mixing);
   } else {
     // Only call the limiter if we have something to mix.
     LimitMixedAudio(audio_frame_for_mixing);
   }
 
   return;
 }
 
-void AudioMixerImpl::SetOutputFrequency(int frequency) {
+void AudioMixerImpl::CalculateOutputFrequency() {
   RTC_DCHECK_RUNS_SERIALIZED(&race_checker_);
-  output_frequency_ = frequency;
+  rtc::CritScope lock(&crit_);
+
+  std::vector<int> preferred_rates;
+  std::transform(audio_source_list_.begin(), audio_source_list_.end(),
+                 std::back_inserter(preferred_rates),
+                 [&](std::unique_ptr<SourceStatus>& a) {
+                   return a->audio_source->PreferredSampleRate();
+                 });
+
+  output_frequency_ =
+      output_rate_calculator_->CalculateOutputRate(preferred_rates);
   sample_size_ = (output_frequency_ * kFrameDurationInMs) / 1000;
 }
 
 int AudioMixerImpl::OutputFrequency() const {
   RTC_DCHECK_RUNS_SERIALIZED(&race_checker_);
   return output_frequency_;
 }
 
 bool AudioMixerImpl::AddSource(Source* audio_source) {
   RTC_DCHECK(audio_source);
@@ skipping 99 matching lines @@
 
   const auto iter = FindSourceInList(audio_source, &audio_source_list_);
   if (iter != audio_source_list_.end()) {
     return (*iter)->is_mixed;
   }
 
   LOG(LS_ERROR) << "Audio source unknown";
   return false;
 }
 }  // namespace webrtc