Reduce jitter from uneven SincResampler buffer size requests.

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 38 matching lines @@
       // since we'll mix into the AudioBus from the output stream.
       unmixed_audio_ = AudioBus::Create(
           input_params.channels(), output_params.frames_per_buffer());
     }
   }
 
   // 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();
-    double io_sample_rate_ratio = input_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, 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()));
 
-  if (disable_fifo)
+  // The resampler can be configured to work with a specific request size, so a
+  // FIFO is not necessary when resampling.
+  if (disable_fifo || resampler_)
     return;
 
-  // Since the resampler / output device may want a different buffer size than
-  // the caller asked for, we need to use a FIFO to ensure that both sides
-  // read in chunk sizes they're configured for.
-  if (resampler_.get() ||
-      input_params.frames_per_buffer() != output_params.frames_per_buffer()) {
+  // Since the output device may want a different buffer size than the caller
+  // asked for, we need to use a FIFO to ensure that both sides read in chunk
+  // sizes they're configured for.
+  if (input_params.frames_per_buffer() != output_params.frames_per_buffer()) {
     DVLOG(1) << "Rebuffering from " << input_params.frames_per_buffer()
              << " to " << output_params.frames_per_buffer();
     audio_fifo_.reset(new AudioPullFifo(
         downmix_early_ ? output_params.channels() :
             input_params.channels(),
         input_params.frames_per_buffer(), base::Bind(
             &AudioConverter::SourceCallback,
             base::Unretained(this))));
   }
 }
@@ skipping 41 matching lines @@
   AudioBus* temp_dest = needs_mixing ? unmixed_audio_.get() : dest;
   DCHECK(temp_dest);
 
   // Figure out which method to call based on whether we're resampling and
   // rebuffering, just resampling, or just mixing.  We want to avoid any extra
   // steps when possible since we may be converting audio data in real time.
   if (!resampler_ && !audio_fifo_) {
     SourceCallback(0, temp_dest);
   } else {
     if (resampler_)
-      resampler_->Resample(temp_dest, temp_dest->frames());
+      resampler_->Resample(temp_dest->frames(), temp_dest);
     else
       ProvideInput(0, temp_dest);
   }
 
   // Finally upmix the channels if we didn't do so earlier.
   if (needs_mixing) {
     DCHECK_EQ(temp_dest->frames(), dest->frames());
     channel_mixer_->Transform(temp_dest, dest);
   }
 }
@@ skipping 80 matching lines @@
 
 void AudioConverter::ProvideInput(int resampler_frame_delay, AudioBus* dest) {
   resampler_frame_delay_ = resampler_frame_delay;
   if (audio_fifo_)
     audio_fifo_->Consume(dest, dest->frames());
   else
     SourceCallback(0, dest);
 }
 
 }  // namespace media