Implicit audio output device selection for getUserMedia.

content/renderer/media/webrtc_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_audio_renderer.h"
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "content/renderer/media/audio_device_factory.h"
 #include "content/renderer/media/webrtc_audio_device_impl.h"
-#include "content/renderer/render_thread_impl.h"
 #include "media/audio/audio_output_device.h"
 #include "media/audio/audio_parameters.h"
 #include "media/audio/sample_rates.h"
-#include "media/base/audio_hardware_config.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #include "media/audio/win/core_audio_util_win.h"
 #endif
 
 namespace content {
 
 namespace {
 
@@ skipping 56 matching lines @@
     UMA_HISTOGRAM_ENUMERATION("WebRTC.AudioOutputFramesPerBuffer",
                               afpb, kUnexpectedAudioBufferSize);
   } else {
     // Report unexpected sample rates using a unique histogram name.
     UMA_HISTOGRAM_COUNTS("WebRTC.AudioOutputFramesPerBufferUnexpected", param);
   }
 }
 
 }  // namespace
 
-WebRtcAudioRenderer::WebRtcAudioRenderer(int source_render_view_id)
+WebRtcAudioRenderer::WebRtcAudioRenderer(int source_render_view_id,
+                                         int session_id,
+                                         int sample_rate,
+                                         int frames_per_buffer)
     : state_(UNINITIALIZED),
       source_render_view_id_(source_render_view_id),
+      session_id_(session_id),
       source_(NULL),
       play_ref_count_(0),
       audio_delay_milliseconds_(0),
-      fifo_delay_milliseconds_(0) {
+      fifo_delay_milliseconds_(0),
+      sample_rate_(sample_rate),
+      frames_per_buffer_(frames_per_buffer) {
 }
 
 WebRtcAudioRenderer::~WebRtcAudioRenderer() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(state_, UNINITIALIZED);
   buffer_.reset();
 }
 
 bool WebRtcAudioRenderer::Initialize(WebRtcAudioRendererSource* source) {
   DVLOG(1) << "WebRtcAudioRenderer::Initialize()";
   DCHECK(thread_checker_.CalledOnValidThread());
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, UNINITIALIZED);
   DCHECK(source);
   DCHECK(!sink_.get());
   DCHECK(!source_);
 
   // Use stereo output on all platforms exept Android.
   media::ChannelLayout channel_layout = media::CHANNEL_LAYOUT_STEREO;
 #if defined(OS_ANDROID)
   DVLOG(1) << "Using mono audio output for Android";
   channel_layout = media::CHANNEL_LAYOUT_MONO;
 #endif
-  // Ask the renderer for the default audio output hardware sample-rate.
-  media::AudioHardwareConfig* hardware_config =
-      RenderThreadImpl::current()->GetAudioHardwareConfig();
-  int sample_rate = hardware_config->GetOutputSampleRate();
+
+  // TODO(tommi,henrika): Maybe we should just change |sample_rate_| to be
+  // immutable and change its value instead of using a temporary?
+  int sample_rate = sample_rate_;
   DVLOG(1) << "Audio output hardware sample rate: " << sample_rate;
 
   // WebRTC does not yet support higher rates than 96000 on the client side
   // and 48000 is the preferred sample rate. Therefore, if 192000 is detected,
   // we change the rate to 48000 instead. The consequence is that the native
   // layer will be opened up at 192kHz but WebRTC will provide data at 48kHz
   // which will then be resampled by the audio converted on the browser side
   // to match the native audio layer.
   if (sample_rate == 192000) {
     DVLOG(1) << "Resampling from 48000 to 192000 is required";
@@ skipping 34 matching lines @@
   // We strive to open up using native parameters to achieve best possible
   // performance and to ensure that no FIFO is needed on the browser side to
   // match the client request. Any mismatch between the source and the sink is
   // taken care of in this class instead using a pull FIFO.
 
   media::AudioParameters sink_params;
 
 #if defined(OS_ANDROID)
   buffer_size = kDefaultOutputBufferSize;
 #else
-  buffer_size = hardware_config->GetOutputBufferSize();
+  buffer_size = frames_per_buffer_;
 #endif
 
   sink_params.Reset(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
                     channel_layout, channels, 0, sample_rate, 16, buffer_size);
 
   // Create a FIFO if re-buffering is required to match the source input with
   // the sink request. The source acts as provider here and the sink as
   // consumer.
   fifo_delay_milliseconds_ = 0;
   if (source_params.frames_per_buffer() != sink_params.frames_per_buffer()) {
     DVLOG(1) << "Rebuffering from " << source_params.frames_per_buffer()
              << " to " << sink_params.frames_per_buffer();
     audio_fifo_.reset(new media::AudioPullFifo(
         source_params.channels(),
         source_params.frames_per_buffer(),
         base::Bind(
             &WebRtcAudioRenderer::SourceCallback,
             base::Unretained(this))));
 
     if (sink_params.frames_per_buffer() > source_params.frames_per_buffer()) {
       int frame_duration_milliseconds = base::Time::kMillisecondsPerSecond /
           static_cast<double>(source_params.sample_rate());
       fifo_delay_milliseconds_ = (sink_params.frames_per_buffer() -
         source_params.frames_per_buffer()) * frame_duration_milliseconds;
     }
   }
 
-
   // Allocate local audio buffers based on the parameters above.
   // It is assumed that each audio sample contains 16 bits and each
   // audio frame contains one or two audio samples depending on the
   // number of channels.
   buffer_.reset(
       new int16[source_params.frames_per_buffer() * source_params.channels()]);
 
   source_ = source;
   source->SetRenderFormat(source_params);
 
   // Configure the audio rendering client and start rendering.
   sink_ = AudioDeviceFactory::NewOutputDevice(source_render_view_id_);
-  sink_->Initialize(sink_params, this);
+
+  // TODO(tommi): Rename InitializeUnifiedStream to rather reflect association
+  // with a session.
+  DCHECK_GE(session_id_, 0);
+  sink_->InitializeUnifiedStream(sink_params, this, session_id_);
+
   sink_->Start();
 
   // User must call Play() before any audio can be heard.
   state_ = PAUSED;
 
   UMA_HISTOGRAM_ENUMERATION("WebRTC.AudioOutputChannelLayout",
                             source_params.channel_layout(),
                             media::CHANNEL_LAYOUT_MAX);
   UMA_HISTOGRAM_ENUMERATION("WebRTC.AudioOutputFramesPerBuffer",
                             source_params.frames_per_buffer(),
@@ skipping 117 matching lines @@
   }
 
   // De-interleave each channel and convert to 32-bit floating-point
   // with nominal range -1.0 -> +1.0 to match the callback format.
   audio_bus->FromInterleaved(buffer_.get(),
                              audio_bus->frames(),
                              sizeof(buffer_[0]));
 }
 
 }  // namespace content