Implicit audio output device selection for getUserMedia.

content/renderer/media/media_stream_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/media_stream_impl.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/public/common/desktop_media_id.h"
 #include "content/renderer/media/media_stream_audio_renderer.h"
 #include "content/renderer/media/media_stream_dependency_factory.h"
 #include "content/renderer/media/media_stream_dispatcher.h"
 #include "content/renderer/media/media_stream_extra_data.h"
 #include "content/renderer/media/media_stream_source_extra_data.h"
 #include "content/renderer/media/rtc_video_renderer.h"
 #include "content/renderer/media/webrtc_audio_capturer.h"
 #include "content/renderer/media/webrtc_audio_renderer.h"
 #include "content/renderer/media/webrtc_local_audio_renderer.h"
 #include "content/renderer/media/webrtc_uma_histograms.h"
+#include "content/renderer/render_thread_impl.h"
+#include "media/base/audio_hardware_config.h"
 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebMediaStreamRegistry.h"
 
 namespace content {
 namespace {
@@ skipping 79 matching lines @@
 
 webrtc::MediaStreamInterface* GetNativeMediaStream(
     const WebKit::WebMediaStream& web_stream) {
   content::MediaStreamExtraData* extra_data =
       static_cast<content::MediaStreamExtraData*>(web_stream.extraData());
   if (!extra_data)
     return NULL;
   return extra_data->stream().get();
 }
 
+void GetDefaultOutputDeviceParams(
+    int* output_sample_rate, int* output_buffer_size) {
+  // Fetch the default audio output hardware config.
+  media::AudioHardwareConfig* hardware_config =
+      RenderThreadImpl::current()->GetAudioHardwareConfig();
+  *output_sample_rate = hardware_config->GetOutputSampleRate();
+  *output_buffer_size = hardware_config->GetOutputBufferSize();
+}
+
 }  // namespace
 
 MediaStreamImpl::MediaStreamImpl(
     RenderView* render_view,
     MediaStreamDispatcher* media_stream_dispatcher,
     MediaStreamDependencyFactory* dependency_factory)
     : RenderViewObserver(render_view),
       dependency_factory_(dependency_factory),
       media_stream_dispatcher_(media_stream_dispatcher) {
 }
@@ skipping 452 matching lines @@
 }
 
 scoped_refptr<WebRtcAudioRenderer> MediaStreamImpl::CreateRemoteAudioRenderer(
     webrtc::MediaStreamInterface* stream) {
   if (stream->GetAudioTracks().empty())
     return NULL;
 
   DVLOG(1) << "MediaStreamImpl::CreateRemoteAudioRenderer label:"
            << stream->label();
 
-  return new WebRtcAudioRenderer(RenderViewObserver::routing_id());
+  int session_id = 0, sample_rate = 0, buffer_size = 0;
+  if (!GetAuthorizedDeviceInfoForAudioRenderer(&session_id,
+                                               &sample_rate,
+                                               &buffer_size)) {
+    GetDefaultOutputDeviceParams(&sample_rate, &buffer_size);
+  }
+
+  return new WebRtcAudioRenderer(RenderViewObserver::routing_id(),
+      session_id, sample_rate, buffer_size);
 }
 
 scoped_refptr<WebRtcLocalAudioRenderer>
 MediaStreamImpl::CreateLocalAudioRenderer(
     webrtc::MediaStreamInterface* stream) {
   if (stream->GetAudioTracks().empty())
     return NULL;
 
   DVLOG(1) << "MediaStreamImpl::CreateLocalAudioRenderer label:"
            << stream->label();
 
   webrtc::AudioTrackVector audio_tracks = stream->GetAudioTracks();
   DCHECK_EQ(audio_tracks.size(), 1u);
   webrtc::AudioTrackInterface* audio_track = audio_tracks[0];
   DVLOG(1) << "audio_track.kind   : " << audio_track->kind()
            << "audio_track.id     : " << audio_track->id()
            << "audio_track.enabled: " << audio_track->enabled();
 
+  int session_id = 0, sample_rate = 0, buffer_size = 0;
+  if (!GetAuthorizedDeviceInfoForAudioRenderer(&session_id,
+                                               &sample_rate,
+                                               &buffer_size)) {
+    GetDefaultOutputDeviceParams(&sample_rate, &buffer_size);
+  }
+
   // Create a new WebRtcLocalAudioRenderer instance and connect it to the
   // existing WebRtcAudioCapturer so that the renderer can use it as source.
   return new WebRtcLocalAudioRenderer(
       static_cast<WebRtcLocalAudioTrack*>(audio_track),
-      RenderViewObserver::routing_id());
+      RenderViewObserver::routing_id(),
+      session_id,
+      sample_rate,
+      buffer_size);
 }
 
 void MediaStreamImpl::StopLocalAudioTrack(
     const WebKit::WebMediaStream& web_stream) {
   MediaStreamExtraData* extra_data = static_cast<MediaStreamExtraData*>(
       web_stream.extraData());
   if (extra_data && extra_data->is_local() && extra_data->stream().get() &&
       !extra_data->stream()->GetAudioTracks().empty()) {
     webrtc::AudioTrackVector audio_tracks =
         extra_data->stream()->GetAudioTracks();
     for (size_t i = 0; i < audio_tracks.size(); ++i) {
       WebRtcLocalAudioTrack* audio_track = static_cast<WebRtcLocalAudioTrack*>(
           audio_tracks[i].get());
       // Remove the WebRtcAudioDevice as the sink to the local audio track.
       audio_track->RemoveSink(dependency_factory_->GetWebRtcAudioDevice());
       // Stop the audio track. This will unhook the audio track from the
       // capturer and will shutdown the source of the capturer if it is the
       // last audio track connecting to the capturer.
       audio_track->Stop();
     }
   }
 }
 
+bool MediaStreamImpl::GetAuthorizedDeviceInfoForAudioRenderer(
+    int* session_id,
+    int* output_sample_rate,
+    int* output_frames_per_buffer) {
+  DCHECK(CalledOnValidThread());
+
+  const StreamDeviceInfo* device_info = NULL;
+  WebKit::WebString session_id_str;
+  UserMediaRequests::iterator it = user_media_requests_.begin();
+  for (; it != user_media_requests_.end(); ++it) {
+    UserMediaRequestInfo* request = (*it);
+    for (size_t i = 0; i < request->audio_sources.size(); ++i) {
+      const WebKit::WebMediaStreamSource& source = request->audio_sources[i];
+      if (source.readyState() == WebKit::WebMediaStreamSource::ReadyStateEnded)
+        continue;
+
+      if (!session_id_str.isEmpty() &&
+          !session_id_str.equals(source.deviceId())) {
+        DVLOG(1) << "Multiple capture devices are open so we can't pick a "
+                    "session for a matching output device.";
+        return false;
+      }
+
+      // TODO(tommi): Storing the session id in the deviceId field doesn't
+      // feel right.  Move it over to MediaStreamSourceExtraData?
+      session_id_str = source.deviceId();
+      content::MediaStreamSourceExtraData* extra_data =
+          static_cast<content::MediaStreamSourceExtraData*>(source.extraData());
+      device_info = &extra_data->device_info();
+    }
+  }
+
+  if (session_id_str.isEmpty() || !device_info)
+    return false;
+
+  base::StringToInt(UTF16ToUTF8(session_id_str), session_id);
+  *output_sample_rate = device_info->device.matched_output.sample_rate;
+  *output_frames_per_buffer =
+      device_info->device.matched_output.frames_per_buffer;
+
+  return true;
+}
+
 MediaStreamSourceExtraData::MediaStreamSourceExtraData(
     const StreamDeviceInfo& device_info,
     const WebKit::WebMediaStreamSource& webkit_source)
     : device_info_(device_info),
       webkit_source_(webkit_source) {
 }
 
 MediaStreamSourceExtraData::MediaStreamSourceExtraData(
     media::AudioCapturerSource* source)
     : audio_source_(source)  {
@@ skipping 45 matching lines @@
   }
 
   for (size_t i = 0; i < video_sources.size(); ++i) {
     video_sources[i].setReadyState(
             WebKit::WebMediaStreamSource::ReadyStateEnded);
     video_sources[i].setExtraData(NULL);
   }
 }
 
 }  // namespace content