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 551 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 = -1, sample_rate = 0, buffer_size = 0;
+  if (!GetAuthorizedInputDeviceSessionIdForAudioRenderer(&session_id,
+                                                         &sample_rate,
+                                                         &buffer_size)) {
+    // Fetch the default audio output hardware config.
+    media::AudioHardwareConfig* hardware_config =
+        RenderThreadImpl::current()->GetAudioHardwareConfig();
+    sample_rate = hardware_config->GetOutputSampleRate();
+    buffer_size = hardware_config->GetOutputBufferSize();
+    // Use session_id of 0 to indicate no association with the capture device

[Jói, 2013/09/06 14:49:26]

Above you use a guard of -1, which is correct?

[tommi (sloooow) - chröme, 2013/09/06 16:56:54]

I changed it to 0 for consistency with what's used in AudioOutputDevice:
https://code.google.com/p/chromium/codesearch#chromium/src/media/audio/audio_...

+    // (i.e. use the default device).
+    session_id = 0;
+  }
+
+  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 = -1, sample_rate = 0, buffer_size = 0;

[Jói, 2013/09/06 14:49:26]

Same code, DRY.

[tommi (sloooow) - chröme, 2013/09/06 16:56:54]

Done.

+  if (!GetAuthorizedInputDeviceSessionIdForAudioRenderer(&session_id,
+                                                         &sample_rate,
+                                                         &buffer_size)) {
+    // Fetch the default audio output hardware config.
+    media::AudioHardwareConfig* hardware_config =
+        RenderThreadImpl::current()->GetAudioHardwareConfig();
+    sample_rate = hardware_config->GetOutputSampleRate();
+    buffer_size = hardware_config->GetOutputBufferSize();
+    // Use session_id of 0 to indicate no association with the capture device
+    // (i.e. use the default device).
+    session_id = 0;
+  }
+
   // 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::GetAuthorizedInputDeviceSessionIdForAudioRenderer(

[no longer working on chromium, 2013/09/06 15:17:37]

The name does not completely fit to its functionalities, you are getting the
device related info like session_id, sample_rate, and buffer size. I will
suggest renaming it to GetAurhorizedDeviceInfoForAudioRenderer

[tommi (sloooow) - chröme, 2013/09/06 16:56:54]

Done (fixed typo).

+    int* session_id,
+    int* output_sample_rate,
+    int* output_frames_per_buffer) {
+  DCHECK(CalledOnValidThread());
+
+  const StreamDeviceInfo* device_info = NULL;
+  WebKit::WebString device_id;
+  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 (!device_id.isEmpty() && !device_id.equals(source.deviceId())) {
+        DLOG(WARNING)

[Jói, 2013/09/06 14:49:26]

Not sure this is "bad" enough to demand a warning; maybe INFO?

[tommi (sloooow) - chröme, 2013/09/06 16:56:54]

Yeah, that's why I picked DLOG so that while debugging we would notice it
(likely only webrtc engs would run into this), but changed it to DVLOG(1).

+            << "Multiple capture devices are open so we can't pick a "
+            "session for a matching output device.";
+        return false;
+      }
+
+      device_id = source.deviceId();

[no longer working on chromium, 2013/09/06 15:17:37]

this should be the session_id

[tommi (sloooow) - chröme, 2013/09/06 16:56:54]

Renamed the variable.  Also added a todo to store the session_id in the
MediaStreamSourceExtraData struct.

+      content::MediaStreamSourceExtraData* extra_data =
+          static_cast<content::MediaStreamSourceExtraData*>(source.extraData());
+      device_info = &extra_data->device_info();
+    }
+  }
+
+  if (device_id.isEmpty() || !device_info)
+    return false;
+
+  base::StringToInt(UTF16ToUTF8(device_id), 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