Always wait for DataReady() on Windows WaveOut.

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"
 #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"
 #include "media/audio/audio_util.h"
 #include "media/audio/sample_rates.h"
 #include "media/base/audio_converter.h"
 #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
     : public AudioOutputStream::AudioSourceCallback,
       public AudioConverter::InputCallback {
  public:
   OnMoreDataConverter(const AudioParameters& input_params,
                       const AudioParameters& output_params);
   virtual ~OnMoreDataConverter();
 
@@ skipping 32 matching lines @@
   // Last AudioBuffersState object received via OnMoreData(), used to correct
   // playback delay by ProvideInput() and passed on to |source_callback_|.
   AudioBuffersState current_buffers_state_;
 
   const int input_bytes_per_second_;
 
   // Handles resampling, buffering, and channel mixing between input and output
   // 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);
 };
 
 // Record UMA statistics for hardware output configuration.
 static void RecordStats(const AudioParameters& output_params) {
   UMA_HISTOGRAM_ENUMERATION(
       "Media.HardwareAudioBitsPerChannel", output_params.bits_per_sample(),
       limits::kMaxBitsPerSample);
   UMA_HISTOGRAM_ENUMERATION(
       "Media.HardwareAudioChannelLayout", output_params.channel_layout(),
@@ skipping 186 matching lines @@
 
   dispatcher_->Shutdown();
   DCHECK(callbacks_.empty());
 }
 
 OnMoreDataConverter::OnMoreDataConverter(const AudioParameters& input_params,
                                          const AudioParameters& output_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();
+
+  // TODO(dalecurtis): We should require all render side clients to use a
+  // buffer size that's a multiple of the hardware buffer size scaled by the
+  // request_sample_rate / hw_sample_rate.  Doing so ensures each hardware
+  // request for audio data results in only a single render side callback and
+  // would allow us to remove this hack.  See http://crbug.com/162207.
+#if defined(OS_WIN)
+  waveout_wait_hack_ =
+      output_params.format() == AudioParameters::AUDIO_PCM_LINEAR ||
+      !CoreAudioUtil::IsSupported();
+#endif
 }
 
 OnMoreDataConverter::~OnMoreDataConverter() {}
 
 void OnMoreDataConverter::Start(
     AudioOutputStream::AudioSourceCallback* callback) {
   base::AutoLock auto_lock(source_lock_);
   DCHECK(!source_callback_);
   source_callback_ = callback;
 
@@ skipping 38 matching lines @@
   source_lock_.AssertAcquired();
 
   // Adjust playback delay to include |buffer_delay|.
   // TODO(dalecurtis): Stop passing bytes around, it doesn't make sense since
   // AudioBus is just float data.  Use TimeDelta instead.
   AudioBuffersState new_buffers_state;
   new_buffers_state.pending_bytes =
       io_ratio_ * (current_buffers_state_.total_bytes() +
                    buffer_delay.InSecondsF() * input_bytes_per_second_);
 
+  if (waveout_wait_hack_)
+    source_callback_->WaitTillDataReady();
+
   // Retrieve data from the original callback.
   int frames = source_callback_->OnMoreIOData(
       source_bus_, dest, new_buffers_state);
 
   // |source_bus_| should only be provided once.
   // TODO(dalecurtis, crogers): This is not a complete fix.  If ProvideInput()
   // is called multiple times, we need to do something more clever here.
   source_bus_ = NULL;
 
   // Zero any unfilled frames if anything was filled, otherwise we'll just
@@ skipping 11 matching lines @@
     source_callback_->OnError(stream, code);
 }
 
 void OnMoreDataConverter::WaitTillDataReady() {
   base::AutoLock auto_lock(source_lock_);
   if (source_callback_)
     source_callback_->WaitTillDataReady();
 }
 
 }  // namespace media