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

content/renderer/media/renderer_webaudiodevice_impl.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 "content/renderer/media/renderer_webaudiodevice_impl.h"
 
+#include "base/command_line.h"
 #include "base/logging.h"
 #include "content/renderer/media/audio_device_factory.h"
+#include "content/public/common/content_switches.h"
+
+#include <math.h>
 
 using content::AudioDeviceFactory;
 using WebKit::WebAudioDevice;
 using WebKit::WebVector;
 
 RendererWebAudioDeviceImpl::RendererWebAudioDeviceImpl(
     const media::AudioParameters& params,
     WebAudioDevice::RenderCallback* callback)
     : is_running_(false),
       client_callback_(callback) {
   audio_device_ = AudioDeviceFactory::NewOutputDevice();
-  audio_device_->Initialize(params, this);
+
+  // TODO(crogers): remove once we properly handle input device selection.

[tommi (sloooow) - chröme, 2012/09/07 09:58:19]

file a bug for tracking?

[Chris Rogers, 2012/09/07 20:34:01]

Done.

+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kEnableWebAudioInput)) {
+    audio_device_->InitializeIO(params, 2, this);

[tommi (sloooow) - chröme, 2012/09/07 09:58:19]

won't hardcoding this at 2 be problematic for non-stereo devices? e.g. a mono
mic?

[Chris Rogers, 2012/09/07 20:34:01]

The Mac-backend will automatically handle this case, and I need to work with
Henrik to make sure we do something reasonable here as wel on Windowsl.  I
actually have a USB guitar cable (USB at one end and 1/4" guitar on the other :)
which is mono.  So I'm on this one :)

I added this bug# to the TODO:
https://code.google.com/p/chromium/issues/detail?id=147326

+  } else {
+    audio_device_->Initialize(params, this);
+  }
 }
 
 RendererWebAudioDeviceImpl::~RendererWebAudioDeviceImpl() {
   stop();
 }
 
 void RendererWebAudioDeviceImpl::start() {
   if (!is_running_) {
     audio_device_->Start();
     is_running_ = true;
   }
 }
 
 void RendererWebAudioDeviceImpl::stop() {
   if (is_running_) {
     audio_device_->Stop();
     is_running_ = false;
   }
 }
 
 double RendererWebAudioDeviceImpl::sampleRate() {
   return 44100.0;
 }
 
 int RendererWebAudioDeviceImpl::Render(media::AudioBus* audio_bus,
                                        int audio_delay_milliseconds) {
-  // Make the client callback to get rendered audio.
+  RenderIO(NULL, audio_bus, audio_delay_milliseconds);
+  return audio_bus->frames();
+}
+
+void RendererWebAudioDeviceImpl::RenderIO(media::AudioBus* audio_input_bus,
+                                          media::AudioBus* audio_bus,
+                                          int audio_delay_milliseconds) {
+  // Make the client callback for an I/O cycle.
   DCHECK(client_callback_);
   if (client_callback_) {
-    // Wrap the pointers using WebVector.
+    // Wrap the inputs pointers using WebVector.
+    size_t input_channels =
+        audio_input_bus ? static_cast<size_t>(audio_input_bus->channels()) : 0;
+    WebVector<float*> web_audio_input_data(input_channels);
+    for (size_t i = 0; i < input_channels; ++i)
+      web_audio_input_data[i] = audio_input_bus->channel(i);
+
+    // Wrap the output pointers using WebVector.
     WebVector<float*> web_audio_data(
         static_cast<size_t>(audio_bus->channels()));
     for (int i = 0; i < audio_bus->channels(); ++i)
       web_audio_data[i] = audio_bus->channel(i);
 
-    client_callback_->render(web_audio_data, audio_bus->frames());
+    client_callback_->render(web_audio_input_data,
+                             web_audio_data,
+                             audio_bus->frames());
   }
-  return audio_bus->frames();
 }
 
 void RendererWebAudioDeviceImpl::OnRenderError() {
   // TODO(crogers): implement error handling.
 }