Add support for midstream audio configuration changes.

media/base/audio_converter.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // AudioConverter implementation.  Uses MultiChannelSincResampler for resampling
 // audio, ChannelMixer for channel mixing, and AudioPullFifo for buffering.
 //
 // Delay estimates are provided to InputCallbacks based on the frame delay
 // information reported via the resampler and FIFO units.
 
@@ skipping 10 matching lines @@
 #include "media/base/vector_math.h"
 
 namespace media {
 
 AudioConverter::AudioConverter(const AudioParameters& input_params,
                                const AudioParameters& output_params,
                                bool disable_fifo)
     : chunk_size_(output_params.frames_per_buffer()),
       downmix_early_(false),
       resampler_frame_delay_(0),
-      input_channel_count_(input_params.channels()) {
+      input_channel_count_(input_params.channels()),
+      io_sample_rate_ratio_(input_params.sample_rate() /
+                           static_cast<double>(output_params.sample_rate())) {
   CHECK(input_params.IsValid());
   CHECK(output_params.IsValid());
 
   // Handle different input and output channel layouts.
   if (input_params.channel_layout() != output_params.channel_layout()) {
     DVLOG(1) << "Remixing channel layout from " << input_params.channel_layout()
              << " to " << output_params.channel_layout() << "; from "
              << input_params.channels() << " channels to "
              << output_params.channels() << " channels.";
     channel_mixer_.reset(new ChannelMixer(input_params, output_params));
 
     // Pare off data as early as we can for efficiency.
     downmix_early_ = input_params.channels() > output_params.channels();
   }
 
   // Only resample if necessary since it's expensive.
   if (input_params.sample_rate() != output_params.sample_rate()) {
     DVLOG(1) << "Resampling from " << input_params.sample_rate() << " to "
              << output_params.sample_rate();
-    const double io_sample_rate_ratio = input_params.sample_rate() /
-        static_cast<double>(output_params.sample_rate());
     const int request_size = disable_fifo ? SincResampler::kDefaultRequestSize :
         input_params.frames_per_buffer();
     resampler_.reset(new MultiChannelResampler(
         downmix_early_ ? output_params.channels() :
             input_params.channels(),
-        io_sample_rate_ratio, request_size, base::Bind(
+        io_sample_rate_ratio_, request_size, base::Bind(
             &AudioConverter::ProvideInput, base::Unretained(this))));
   }
 
   input_frame_duration_ = base::TimeDelta::FromMicroseconds(
       base::Time::kMicrosecondsPerSecond /
       static_cast<double>(input_params.sample_rate()));
   output_frame_duration_ = base::TimeDelta::FromMicroseconds(
       base::Time::kMicrosecondsPerSecond /
       static_cast<double>(output_params.sample_rate()));
 
@@ skipping 39 matching lines @@
   if (resampler_)
     resampler_->Flush();
 }
 
 int AudioConverter::ChunkSize() const {
   if (!resampler_)
     return chunk_size_;
   return resampler_->ChunkSize();
 }
 
+int AudioConverter::RequestSize() const {
+  if (resampler_)
+    return audio_fifo_ ? chunk_size_
+                       : SincResampler::kDefaultRequestSize;
+  return chunk_size_;
+}
+
 void AudioConverter::ConvertWithDelay(const base::TimeDelta& initial_delay,
                                       AudioBus* dest) {
   initial_delay_ = initial_delay;
 
   if (transform_inputs_.empty()) {
     dest->Zero();
     return;
   }
 
   // Determine if channel mixing should be done and if it should be done before
@@ skipping 112 matching lines @@
   else
     SourceCallback(0, dest);
 }
 
 void AudioConverter::CreateUnmixedAudioIfNecessary(int frames) {
   if (!unmixed_audio_ || unmixed_audio_->frames() != frames)
     unmixed_audio_ = AudioBus::Create(input_channel_count_, frames);
 }
 
 }  // namespace media