Reland 10952007: Pass through small buffer sizes without FIFO on Linux

media/audio/audio_output_resampler.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.
 
 #include "media/audio/audio_output_resampler.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
@@ skipping 85 matching lines @@
   Initialize();
   // Record UMA statistics for the hardware configuration.
   RecordStats(output_params_);
 }
 
 AudioOutputResampler::~AudioOutputResampler() {}
 
 void AudioOutputResampler::Initialize() {
   io_ratio_ = 1;
 
+  if (params_.frames_per_buffer() != output_params_.frames_per_buffer()) {

[DaleCurtis, 2012/09/17 23:54:45]

I don't understand what you're trying to do here. You seem to be trying to
autodetect if the selected buffer size matches some magic pattern (which WebRTC
is using). Then choosing another buffer size based on another magic computation.

Can you elaborate on what you're doing here? Chris and I had previously
discussed just passing through the input buffersize if it's < 2048.

[no longer working on chromium, 2012/09/18 09:37:30]

The idea is simple. Basically, we should allow the clients to set the buffer
size they want, but in the unit of ms.
For example, if the clients want to use 882 samples for sample rate 22050, which
is 40ms data. But the OS native sample rate is 44100, then we should set the
output_params_ buffer size to 1764 (40ms data). By doing this, we don't need to
force the clients to use a buffer size that does not fit their needs.

So that this resampler will only kick in when the clients sample rate is
different from the native sample rate.

This is not purely for webrtc, other clients like PPAPI, preferably they should
use a big buffer size(like html5 does) to achieve low complexity and more
reliable performance.

And I think I have already mentioned it in another thread,
GetAudioHardwareBufferSize() is mainly for webaudio, it is not a generic
"preferred" buffer size for all the clients.

Passing through the input buffersize if it's < 2048 is a workaround to this
webrtc linux issue, it is OK for me if we don't have other better solution for
now, but it does not resolve all the problems.

+    double in_buffer_s = static_cast<double>(params_.frames_per_buffer()) /
+        static_cast<double>(params_.sample_rate());
+    double out_buffer_s =
+        static_cast<double>(output_params_.frames_per_buffer()) /
+            static_cast<double>(output_params_.sample_rate());
+    if (in_buffer_s != out_buffer_s) {
+      int out_buffer_size = in_buffer_s * output_params_.sample_rate();

[no longer working on chromium, 2012/09/17 21:56:28]

I will add + 0.5 to do the correct truncation here.

+      output_params_.Reset(output_params_.format(),
+                           output_params_.channel_layout(),
+                           output_params_.sample_rate(),
+                           output_params_.bits_per_sample(),
+                           out_buffer_size);
+    }
+  }
+
   // TODO(dalecurtis): Add channel remixing.  http://crbug.com/138762
   DCHECK_EQ(params_.channels(), output_params_.channels());
   // Only resample or rebuffer if the input parameters don't match the output
   // parameters to avoid any unnecessary work.
   if (params_.channels() != output_params_.channels() ||
       params_.sample_rate() != output_params_.sample_rate() ||
-      params_.bits_per_sample() != output_params_.bits_per_sample() ||
-      params_.frames_per_buffer() != output_params_.frames_per_buffer()) {
+      params_.bits_per_sample() != output_params_.bits_per_sample()) {
     // Only resample if necessary since it's expensive.
     if (params_.sample_rate() != output_params_.sample_rate()) {
       DVLOG(1) << "Resampling from " << params_.sample_rate() << " to "
                << output_params_.sample_rate();
       double io_sample_rate_ratio = params_.sample_rate() /
           static_cast<double>(output_params_.sample_rate());
       // Include the I/O resampling ratio in our global I/O ratio.
       io_ratio_ *= io_sample_rate_ratio;
       resampler_.reset(new MultiChannelResampler(
           output_params_.channels(), io_sample_rate_ratio, base::Bind(
               &AudioOutputResampler::ProvideInput, base::Unretained(this))));
     }
 
     // Include bits per channel differences.
     io_ratio_ *= static_cast<double>(params_.bits_per_sample()) /
         output_params_.bits_per_sample();
 
     // Include channel count differences.
     io_ratio_ *= static_cast<double>(params_.channels()) /
         output_params_.channels();
 
     // 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 (params_.sample_rate() != output_params_.sample_rate() ||
-        params_.frames_per_buffer() != output_params_.frames_per_buffer()) {
+    if (params_.sample_rate() != output_params_.sample_rate()) {
       DVLOG(1) << "Rebuffering from " << params_.frames_per_buffer()
                << " to " << output_params_.frames_per_buffer();
       audio_fifo_.reset(new AudioPullFifo(
           params_.channels(), params_.frames_per_buffer(), base::Bind(
               &AudioOutputResampler::SourceCallback_Locked,
               base::Unretained(this))));
     }
 
     DVLOG(1) << "I/O ratio is " << io_ratio_;
   } else {
@@ skipping 166 matching lines @@
     source_callback_->OnError(stream, code);
 }
 
 void AudioOutputResampler::WaitTillDataReady() {
   base::AutoLock auto_lock(source_lock_);
   if (source_callback_ && !outstanding_audio_bytes_)
     source_callback_->WaitTillDataReady();
 }
 
 }  // namespace media