Always wait for DataReady() on Windows WaveOut.

media/audio/audio_output_resampler.cc

Index: media/audio/audio_output_resampler.cc
diff --git a/media/audio/audio_output_resampler.cc b/media/audio/audio_output_resampler.cc
index baad88a0f7d427157651872dbb5de2f31d5788b0..17f43c23abc36bdf095c4ee767c83f608825fbf8 100644
--- a/media/audio/audio_output_resampler.cc
+++ b/media/audio/audio_output_resampler.cc
@@ -11,6 +11,7 @@
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/time.h"
+#include "build/build_config.h"
 #include "media/audio/audio_io.h"
 #include "media/audio/audio_output_dispatcher_impl.h"
 #include "media/audio/audio_output_proxy.h"
@@ -20,6 +21,10 @@
 #include "media/base/limits.h"
 #include "media/base/media_switches.h"
 
+#if defined(OS_WIN)
+#include "media/audio/win/core_audio_util_win.h"
+#endif
+
 namespace media {
 
 class OnMoreDataConverter
@@ -72,6 +77,10 @@ class OnMoreDataConverter
   // parameters.
   AudioConverter audio_converter_;
 
+  // If we're using WaveOut on Windows' we always have to wait for DataReady()
+  // before calling |source_callback_|.
+  bool waveout_wait_hack_;
+
   DISALLOW_COPY_AND_ASSIGN(OnMoreDataConverter);
 };
 
@@ -278,10 +287,17 @@ OnMoreDataConverter::OnMoreDataConverter(const AudioParameters& input_params,
     : source_callback_(NULL),
       source_bus_(NULL),
       input_bytes_per_second_(input_params.GetBytesPerSecond()),
-      audio_converter_(input_params, output_params, false) {
+      audio_converter_(input_params, output_params, false),
+      waveout_wait_hack_(false) {
   io_ratio_ =
       static_cast<double>(input_params.GetBytesPerSecond()) /
       output_params.GetBytesPerSecond();
+
+#if defined(OS_WIN)
+  waveout_wait_hack_ =
+      output_params.format() == AudioParameters::AUDIO_PCM_LINEAR ||
+      !CoreAudioUtil::IsSupported();
+#endif
 }
 
 OnMoreDataConverter::~OnMoreDataConverter() {}
@@ -340,6 +356,9 @@ double OnMoreDataConverter::ProvideInput(AudioBus* dest,
       io_ratio_ * (current_buffers_state_.total_bytes() +
                    buffer_delay.InSecondsF() * input_bytes_per_second_);
 
+  if (waveout_wait_hack_)
+    source_callback_->WaitTillDataReady();

[Chris Rogers, 2012/11/22 00:39:46]

I'm really not too crazy about this, although I understand the problem you're
seeing.  If I'm not mistaken, it's that the client buffer size is 2048, but the
hardware buffer size is larger (4096), and is calling back twice?  If so, can we
at least have a TODO that we should be able to fix this if we FIFO on the
renderer-side and prevent the client buffer-size from being smaller than the
hardware buffer-size.  This seems like a better long-term solution because that
would handle the case for small client buffer sizes for all platforms.

[DaleCurtis, 2012/11/22 00:53:58]

Yes that's the problem.  A FIFO won't help w/o accounting for resampling and
would be difficult to implement for all of our render clients.

Instead we just need to ensure that every client provide a multiple of the
hw_buffer_size scaled by input sample rate / hw sample rate.  That way every hw
stream request results in at most one renderer side request.  I've added a
comment and linked to a bug for this.

Making that change should be easier than trying to implement a FIFO as well.  We
can discuss more on the bug.

+
   // Retrieve data from the original callback.
   int frames = source_callback_->OnMoreIOData(
       source_bus_, dest, new_buffers_state);