Allow audio system to handle synchronized low-latency audio I/O

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/compiler_specific.h"
 #include "base/message_loop.h"
@@ skipping 109 matching lines @@
 void AudioOutputResampler::CloseStream(AudioOutputProxy* stream_proxy) {
   Reset();
   dispatcher_->CloseStream(stream_proxy);
 }
 
 void AudioOutputResampler::Shutdown() {
   Reset();
   dispatcher_->Shutdown();
 }
 
-int AudioOutputResampler::OnMoreData(AudioBus* audio_bus,
+int AudioOutputResampler::OnMoreData(AudioBus* dest,
                                      AudioBuffersState buffers_state) {
+  return OnMoreIOData(NULL, dest, buffers_state);
+}
+
+int AudioOutputResampler::OnMoreIOData(AudioBus* source,
+                                       AudioBus* dest,
+                                       AudioBuffersState buffers_state) {
   base::AutoLock auto_lock(source_lock_);
   // While we waited for |source_lock_| the callback might have been cleared.
   if (!source_callback_) {
-    audio_bus->Zero();
-    return audio_bus->frames();
+    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(audio_bus);
-    return audio_bus->frames();
+    SourceCallback_Locked(dest);
+    return dest->frames();
   }
 
   if (resampler_.get())
-    resampler_->Resample(audio_bus, audio_bus->frames());
+    resampler_->Resample(dest, dest->frames());
   else
-    ProvideInput(audio_bus);
+    ProvideInput(dest);
 
   // Calculate how much data is left in the internal FIFO and resampler buffers.
-  outstanding_audio_bytes_ -= audio_bus->frames() * output_bytes_per_frame_;
+  outstanding_audio_bytes_ -= dest->frames() * output_bytes_per_frame_;
   // 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 audio_bus->frames();
+  return dest->frames();
 }
 
 void AudioOutputResampler::SourceCallback_Locked(AudioBus* audio_bus) {
   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_ *
@@ skipping 20 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