Merge 169553

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_pull_fifo.h"
 #include "media/base/channel_mixer.h"
 #include "media/base/limits.h"
 #include "media/base/media_switches.h"
 #include "media/base/multi_channel_resampler.h"
 
+#if defined(OS_WIN)
+#include "media/audio/win/core_audio_util_win.h"
+#endif
+
 namespace media {
 
 class OnMoreDataResampler : public AudioOutputStream::AudioSourceCallback {
  public:
   OnMoreDataResampler(double io_ratio,
                       const AudioParameters& input_params,
                       const AudioParameters& output_params);
   virtual ~OnMoreDataResampler();
 
   // AudioSourceCallback interface.
@@ skipping 53 matching lines @@
   scoped_ptr<ChannelMixer> channel_mixer_;
   scoped_ptr<AudioBus> unmixed_audio_;
 
   int output_bytes_per_frame_;
   int input_bytes_per_frame_;
 
   // Since resampling is expensive, figure out if we should downmix channels
   // before resampling.
   bool downmix_early_;
 
-  DISALLOW_COPY_AND_ASSIGN(OnMoreDataResampler);
+  // 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(),
       CHANNEL_LAYOUT_MAX);
@@ skipping 221 matching lines @@
 }
 
 OnMoreDataResampler::OnMoreDataResampler(
     double io_ratio, const AudioParameters& input_params,
     const AudioParameters& output_params)
     : io_ratio_(io_ratio),
       source_callback_(NULL),
       outstanding_audio_bytes_(0),
       output_bytes_per_frame_(output_params.GetBytesPerFrame()),
       input_bytes_per_frame_(input_params.GetBytesPerFrame()),
-      downmix_early_(false) {
+      downmix_early_(false),
+      waveout_wait_hack_(false) {
   // 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.channel_layout(), output_params.channel_layout()));
 
     // Pare off data as early as we can for efficiency.
@@ skipping 33 matching lines @@
       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(
             &OnMoreDataResampler::SourceCallback_Locked,
             base::Unretained(this))));
   }
+
+  // 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
 }
 
 OnMoreDataResampler::~OnMoreDataResampler() {}
 
 void OnMoreDataResampler::Start(
     AudioOutputStream::AudioSourceCallback* callback) {
   base::AutoLock auto_lock(source_lock_);
   DCHECK(!source_callback_);
   source_callback_ = callback;
 }
@@ skipping 71 matching lines @@
   // Adjust playback delay to include the state of the internal buffers used by
   // the resampler and/or the FIFO.  Since the sample rate and bits per channel
   // may be different, we need to scale this value appropriately.
   AudioBuffersState new_buffers_state;
   new_buffers_state.pending_bytes = io_ratio_ *
       (current_buffers_state_.total_bytes() + outstanding_audio_bytes_);
 
   bool needs_downmix = channel_mixer_ && downmix_early_;
   AudioBus* temp_dest = needs_downmix ? unmixed_audio_.get() : dest;
 
+  if (waveout_wait_hack_)
+    source_callback_->WaitTillDataReady();
+
   // Retrieve data from the original callback.  Zero any unfilled frames.
   int frames = source_callback_->OnMoreIOData(
       source, temp_dest, new_buffers_state);
   if (frames < temp_dest->frames())
     temp_dest->ZeroFramesPartial(frames, temp_dest->frames() - frames);
 
   // Scale the number of frames we got back in terms of input bytes to output
   // bytes accordingly.
   outstanding_audio_bytes_ +=
       (temp_dest->frames() * input_bytes_per_frame_) / io_ratio_;
@@ skipping 14 matching lines @@
     source_callback_->OnError(stream, code);
 }
 
 void OnMoreDataResampler::WaitTillDataReady() {
   base::AutoLock auto_lock(source_lock_);
   if (source_callback_ && !outstanding_audio_bytes_)
     source_callback_->WaitTillDataReady();
 }
 
 }  // namespace media