Implicit audio output device selection for getUserMedia.

content/renderer/media/webrtc_local_audio_renderer.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/webrtc_local_audio_renderer.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/synchronization/lock.h"
 #include "content/renderer/media/audio_device_factory.h"
 #include "content/renderer/media/webrtc_audio_capturer.h"
-#include "content/renderer/render_thread_impl.h"
 #include "media/audio/audio_output_device.h"
 #include "media/base/audio_bus.h"
 #include "media/base/audio_fifo.h"
-#include "media/base/audio_hardware_config.h"
 
 namespace content {
 
 // media::AudioRendererSink::RenderCallback implementation
 int WebRtcLocalAudioRenderer::Render(
     media::AudioBus* audio_bus, int audio_delay_milliseconds) {
   base::AutoLock auto_lock(thread_lock_);
 
   if (!playing_) {
     audio_bus->Zero();
@@ skipping 61 matching lines @@
 }
 
 void WebRtcLocalAudioRenderer::SetCaptureFormat(
     const media::AudioParameters& params) {
   audio_params_ = params;
 }
 
 // WebRtcLocalAudioRenderer::WebRtcLocalAudioRenderer implementation.
 WebRtcLocalAudioRenderer::WebRtcLocalAudioRenderer(
     WebRtcLocalAudioTrack* audio_track,
-    int source_render_view_id)
+    int source_render_view_id,
+    int session_id,
+    int sample_rate,
+    int frames_per_buffer)
     : audio_track_(audio_track),
       source_render_view_id_(source_render_view_id),
-      playing_(false) {
+      session_id_(session_id),
+      playing_(false),
+      sample_rate_(sample_rate),
+      frames_per_buffer_(frames_per_buffer) {
   DCHECK(audio_track);
   DVLOG(1) << "WebRtcLocalAudioRenderer::WebRtcLocalAudioRenderer()";
 }
 
 WebRtcLocalAudioRenderer::~WebRtcLocalAudioRenderer() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!sink_.get());
   DVLOG(1) << "WebRtcLocalAudioRenderer::~WebRtcLocalAudioRenderer()";
 }
 
@@ skipping 13 matching lines @@
   // that we start to build up latency and that can be more difficult to
   // detect. Tests have shown that the FIFO never contains more than 2 or 3
   // audio frames but I have selected a max size of ten buffers just
   // in case since these tests were performed on a 16 core, 64GB Win 7
   // machine. We could also add some sort of error notifier in this area if
   // the FIFO overflows.
   DCHECK(!loopback_fifo_);
   loopback_fifo_.reset(new media::AudioFifo(
       audio_params_.channels(), 10 * audio_params_.frames_per_buffer()));
 
-#if defined(OS_ANDROID)
-  media::AudioHardwareConfig* hardware_config =
-      RenderThreadImpl::current()->GetAudioHardwareConfig();
-#endif
-
   media::AudioParameters sink_params(audio_params_.format(),
                                      audio_params_.channel_layout(),
                                      audio_params_.sample_rate(),
                                      audio_params_.bits_per_sample(),
 #if defined(OS_ANDROID)
   // On Android, input and output are using same sampling rate. In order to
   // achieve low latency mode, we need use buffer size suggested by
   // AudioManager for the sink paramters which will be used to decide
   // buffer size for shared memory buffer.
-                                     hardware_config->GetOutputBufferSize()
+                                     frames_per_buffer_
 #else
                                      2 * audio_params_.frames_per_buffer()
 #endif
                                     );
+
   sink_ = AudioDeviceFactory::NewOutputDevice(source_render_view_id_);
 
   // TODO(henrika): we could utilize the unified audio here instead and do
   // sink_->InitializeIO(sink_params, 2, callback_.get());
   // It would then be possible to avoid using the WebRtcAudioCapturer.
-  sink_->Initialize(sink_params, this);
+  sink_->InitializeUnifiedStream(sink_params, this, session_id_);
 
   // Start the capturer and local rendering. Note that, the capturer is owned
   // by the WebRTC ADM and might already bee running.
   sink_->Start();
 
   last_render_time_ = base::Time::Now();
   playing_ = false;
 }
 
 void WebRtcLocalAudioRenderer::Stop() {
@@ skipping 69 matching lines @@
   if (!sink_.get())
     return base::TimeDelta();
   return total_render_time();
 }
 
 bool WebRtcLocalAudioRenderer::IsLocalRenderer() const {
   return true;
 }
 
 }  // namespace content