Enable renderer side mixing behind a flag.

content/renderer/media/audio_renderer_mixer_manager.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/audio_renderer_mixer_manager.h"
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "content/renderer/media/audio_device_factory.h"
+#include "media/audio/audio_util.h"
+#include "media/base/audio_renderer_mixer.h"
+#include "media/base/audio_renderer_mixer_input.h"
+
+namespace content {
+
+AudioRendererMixerManager::AudioRendererMixerManager() {}
+
+AudioRendererMixerManager::~AudioRendererMixerManager() {
+  DCHECK(mixers_.empty());
+}
+
+media::AudioParameters AudioRendererMixerManager::GetAudioHardwareParameters(
+    const media::AudioParameters& params) {
+  // Create output parameters based on the audio hardware configuration for
+  // passing on to the output sink.  Force to 16-bit output for now since we
+  // know that works well for WebAudio and WebRTC.
+  // TODO(dalecurtis): Set format and buffer size in AudioRendererImpl once
+  // renderer side mixing is no longer behind a flag.
+  // TODO(dalecurtis): Ideally we shouldn't be calling the GetAudioHardware*
+  // methods directly, but pulling them from an AudioManager instance.  For unit
+  // tests we would setup a fake AudioManager with a fake hardware config.  See
+  // http://crbug.com/137326.
+  return media::AudioParameters(
+      media::AudioParameters::AUDIO_PCM_LOW_LATENCY, params.channel_layout(),
+      media::GetAudioHardwareSampleRate(), 16,
+      media::GetAudioHardwareBufferSize());

[scherkus (not reviewing), 2012/07/16 20:52:59]

Two things:
  - This is kinda ugly
  - I just remembered you can't reliably call these methods inside the sandbox
anyway and should be using content/renderer/media/audio_hardware.cc

Reason why it works on linux because those methods return hardcoded numbers. I'd
expect this to fail on Mac/Windows where it calls OS APIs to get the actual
values.

Of course this presents some issues:
  - audio_hardware methods need to be called on the render thread
  - as discussed GetMixer/RemoveMixer is called on the pipeline thread
  - we could call them in the ctor...
  - ...but they are synchronous IPCs that really shouldn't be called during
RenderThreadImpl::Init()

How about this:
  - Modifying ARMM's ctor to accept a sample rate + buffer size parameter
  - Lazily create an ARMM by changing
RenderThreadImpl::audio_renderer_mixer_manager() into
GetAudioRendererMixerManager() that will call the audio_hardware methods +
create the ARMM

That will solve both the testing issue (you can pass in whatever you want) as
well as the sandboxing issue

WDYT?

[DaleCurtis, 2012/07/16 22:25:59]

SGTM. Done!

+}
+
+media::AudioRendererMixerInput* AudioRendererMixerManager::CreateInput() {
+  return new media::AudioRendererMixerInput(
+      base::Bind(
+          &AudioRendererMixerManager::GetMixer, base::Unretained(this)),
+      base::Bind(
+          &AudioRendererMixerManager::RemoveMixer, base::Unretained(this)));
+}
+
+media::AudioRendererMixer* AudioRendererMixerManager::GetMixer(
+    const media::AudioParameters& params) {
+  base::AutoLock auto_lock(mixers_lock_);
+
+  AudioRendererMixerMap::iterator it = mixers_.find(params);
+  if (it != mixers_.end()) {
+    it->second.ref_count++;
+    return it->second.mixer;
+  }
+
+  media::AudioRendererMixer* mixer = new media::AudioRendererMixer(
+      params, GetAudioHardwareParameters(params), AudioDeviceFactory::Create());
+
+  AudioRendererMixerReference mixer_reference = { mixer, 1 };
+  mixers_[params] = mixer_reference;
+  return mixer;
+}
+
+void AudioRendererMixerManager::RemoveMixer(
+    const media::AudioParameters& params) {
+  base::AutoLock auto_lock(mixers_lock_);
+
+  AudioRendererMixerMap::iterator it = mixers_.find(params);
+  DCHECK(it != mixers_.end());
+
+  // Only remove the mixer if AudioRendererMixerManager is the last owner.
+  it->second.ref_count--;
+  if (it->second.ref_count == 0) {
+    delete it->second.mixer;
+    mixers_.erase(it);
+  }
+}
+
+}  // namespace content