Add Mac OS X synchronized audio I/O back-end

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 241 matching lines @@
   if (!source_callback_) {
     dest->Zero();
     return dest->frames();
   }
 
   current_buffers_state_ = buffers_state;
 
   if (!resampler_.get() && !audio_fifo_.get()) {
     // We have no internal buffers, so clear any outstanding audio data.
     outstanding_audio_bytes_ = 0;
-    SourceCallback_Locked(dest);
+    SourceIOCallback_Locked(source, dest);
     return dest->frames();
   }
 
   if (resampler_.get())
     resampler_->Resample(dest, dest->frames());
   else
     ProvideInput(dest);
 
   // Calculate how much data is left in the internal FIFO and resampler buffers.
   outstanding_audio_bytes_ -=
       dest->frames() * output_params_.GetBytesPerFrame();
 
   // Due to rounding errors while multiplying against |io_ratio_|,
   // |outstanding_audio_bytes_| might (rarely) slip below zero.
   if (outstanding_audio_bytes_ < 0) {
     DLOG(ERROR) << "Outstanding audio bytes went negative! Value: "
                 << outstanding_audio_bytes_;
     outstanding_audio_bytes_ = 0;
   }
 
   // Always return the full number of frames requested, ProvideInput() will pad
   // with silence if it wasn't able to acquire enough data.
   return dest->frames();
 }
 
-void AudioOutputResampler::SourceCallback_Locked(AudioBus* audio_bus) {
+void AudioOutputResampler::SourceCallback_Locked(AudioBus* dest) {
+  SourceIOCallback_Locked(NULL, dest);

[DaleCurtis, 2012/09/17 21:17:36]

As mentioned on chat, I feel like this is just asking for an accidental NULL ptr
dereference later when something hits the FIFO/resampler.

[Chris Rogers, 2012/09/17 22:00:42]

How?

+}
+
+void AudioOutputResampler::SourceIOCallback_Locked(
+    AudioBus* source, AudioBus* dest) {
   source_lock_.AssertAcquired();
 
   // 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_);
 
   // Retrieve data from the original callback.  Zero any unfilled frames.
-  int frames = source_callback_->OnMoreData(audio_bus, new_buffers_state);
-  if (frames < audio_bus->frames())
-    audio_bus->ZeroFramesPartial(frames, audio_bus->frames() - frames);
+  int frames = source_callback_->OnMoreIOData(source, dest, new_buffers_state);
+  if (frames < dest->frames())
+    dest->ZeroFramesPartial(frames, dest->frames() - frames);
 
   // Scale the number of frames we got back in terms of input bytes to output
   // bytes accordingly.
   outstanding_audio_bytes_ +=
-      (audio_bus->frames() * params_.GetBytesPerFrame()) / io_ratio_;
+      (dest->frames() * params_.GetBytesPerFrame()) / io_ratio_;
 }
 
 void AudioOutputResampler::ProvideInput(AudioBus* audio_bus) {
   audio_fifo_->Consume(audio_bus, audio_bus->frames());
 }
 
 void AudioOutputResampler::OnError(AudioOutputStream* stream, int code) {
   base::AutoLock auto_lock(source_lock_);
   if (source_callback_)
     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