Ensures that WebRTC works for device selection using a different sample rate than default

content/renderer/media/media_stream_dependency_factory.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_dependency_factory.h"
 
 #include <vector>
 
 #include "base/synchronization/waitable_event.h"
 #include "base/utf_string_conversions.h"
 #include "content/renderer/media/media_stream_source_extra_data.h"
 #include "content/renderer/media/rtc_media_constraints.h"
 #include "content/renderer/media/rtc_peer_connection_handler.h"
 #include "content/renderer/media/rtc_video_capturer.h"
 #include "content/renderer/media/video_capture_impl_manager.h"
+#include "content/renderer/media/webaudio_capturer_source.h"
 #include "content/renderer/media/webrtc_audio_device_impl.h"
 #include "content/renderer/media/webrtc_uma_histograms.h"
 #include "content/renderer/p2p/ipc_network_manager.h"
 #include "content/renderer/p2p/ipc_socket_factory.h"
 #include "content/renderer/p2p/port_allocator.h"
 #include "jingle/glue/thread_wrapper.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebMediaStreamComponent.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebMediaStreamDescriptor.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebMediaStreamSource.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
@@ skipping 157 matching lines @@
     return NULL;
 
   return new RTCPeerConnectionHandler(client, this);
 }
 
 void MediaStreamDependencyFactory::CreateNativeMediaSources(
     const WebKit::WebMediaConstraints& audio_constraints,
     const WebKit::WebMediaConstraints& video_constraints,
     WebKit::WebMediaStreamDescriptor* description,
     const MediaSourcesCreatedCallback& sources_created) {
+  DVLOG(1) << "MediaStreamDependencyFactory::CreateNativeMediaSources()";
   if (!EnsurePeerConnectionFactory()) {
     sources_created.Run(description, false);
     return;
   }
 
   // |source_observer| clean up itself when it has completed
   // source_observer->StartObservering.
   SourceStateObserver* source_observer =
       new SourceStateObserver(description, sources_created);
 
-  // TODO(perkj): Implement local audio sources.
-
   // Create local video sources.
   RTCMediaConstraints native_video_constraints(video_constraints);
   WebKit::WebVector<WebKit::WebMediaStreamComponent> video_components;
   description->videoSources(video_components);
   for (size_t i = 0; i < video_components.size(); ++i) {
     const WebKit::WebMediaStreamSource& source = video_components[i].source();
     MediaStreamSourceExtraData* source_data =
         static_cast<MediaStreamSourceExtraData*>(source.extraData());
     if (!source_data) {
       // TODO(perkj): Implement support for sources from remote MediaStreams.
       NOTIMPLEMENTED();
       continue;
     }
     const bool is_screencast = (source_data->device_info().device.type ==
         content::MEDIA_TAB_VIDEO_CAPTURE);
     source_data->SetVideoSource(
         CreateVideoSource(source_data->device_info().session_id,
                           is_screencast,
                           &native_video_constraints));
     source_observer->AddSource(source_data->video_source());
   }
+
+  // Do additional source initialization if the audio source is a valid
+  // microphone.
+  WebKit::WebVector<WebKit::WebMediaStreamComponent> audio_components;
+  description->audioSources(audio_components);
+  for (size_t i = 0; i < audio_components.size(); ++i) {
+    const WebKit::WebMediaStreamSource& source = audio_components[i].source();
+    MediaStreamSourceExtraData* source_data =
+        static_cast<MediaStreamSourceExtraData*>(source.extraData());
+    if (!source_data) {
+      // TODO(henrika): Implement support for sources from remote MediaStreams.
+      NOTIMPLEMENTED();
+      continue;
+    }
+
+    const StreamDeviceInfo device_info = source_data->device_info();
+    if (device_info.device.type == content::MEDIA_DEVICE_AUDIO_CAPTURE) {
+      if (!InitializeAudioSource(device_info)) {
+        DLOG(WARNING) << "Unsupported audio source";
+        sources_created.Run(description, false);
+        return;
+      }
+    }
+  }
+
   source_observer->StartObservering();
 }
 
 void MediaStreamDependencyFactory::CreateNativeLocalMediaStream(
     WebKit::WebMediaStreamDescriptor* description) {
+  DVLOG(1) << "MediaStreamDependencyFactory::CreateNativeLocalMediaStream()";
   if (!EnsurePeerConnectionFactory()) {
       DVLOG(1) << "EnsurePeerConnectionFactory() failed!";
       return;
   }
 
   std::string label = UTF16ToUTF8(description->label());
   scoped_refptr<webrtc::LocalMediaStreamInterface> native_stream =
       CreateLocalMediaStream(label);
 
-  WebRtcAudioCapturer* capturer =
-      GetWebRtcAudioDevice() ? GetWebRtcAudioDevice()->capturer() : 0;
-  if (!capturer)
-      DVLOG(1) << "CreateNativeLocalMediaStream: missing WebRtcAudioCapturer.";
-
   // Add audio tracks.
   WebKit::WebVector<WebKit::WebMediaStreamComponent> audio_components;
   description->audioSources(audio_components);
 
   for (size_t i = 0; i < audio_components.size(); ++i) {
     WebKit::WebMediaStreamSource source = audio_components[i].source();
 
     // See if we're adding a WebAudio MediaStream.
     if (source.requiresAudioConsumer()) {
-      if (!webaudio_capturer_source_.get() && capturer) {
-        DCHECK(GetWebRtcAudioDevice());
+      // TODO(crogers, xians): In reality we should be able to send a unique
+      // audio stream to each PeerConnection separately.  But currently WebRTC
+      // is only able to handle a global audio stream sent to ALL peers.
 
-        // TODO(crogers, xians): In reality we should be able to send a unique
-        // audio stream to each PeerConnection separately.  But currently WebRTC
-        // is only able to handle a global audio stream sent to ALL peers.
-
-        // For lifetime, we're relying on the fact that
-        // |webaudio_capturer_source_| will live longer than any
-        // MediaStreamSource, since we're never calling removeAudioConsumer().
-        webaudio_capturer_source_ = new WebAudioCapturerSource(capturer);
-        source.addAudioConsumer(webaudio_capturer_source_.get());
-
+      // TODO(henrika): refactor and utilize audio constraints.
+      if (CreateWebAudioSource(&source)) {
         scoped_refptr<webrtc::LocalAudioTrackInterface> audio_track(
-            CreateLocalAudioTrack(label + "a0", NULL));
+            CreateLocalAudioTrack(UTF16ToUTF8(audio_components[i].id()), NULL));
         native_stream->AddTrack(audio_track);
         audio_track->set_enabled(audio_components[i].isEnabled());
       } else {
-        // TODO(crogers): this is very likely to be less important, but
-        // in theory we should be able to "connect" multiple WebAudio
-        // MediaStreams to a single peer, mixing their results.
-        // Instead we just ignore additional ones after the first.
-        LOG(WARNING)
-            << "Multiple MediaStreamAudioDestinationNodes not yet supported!";
+        DLOG(WARNING) << "Failed to create WebAudio source";
       }
     } else {
         MediaStreamSourceExtraData* source_data =
             static_cast<MediaStreamSourceExtraData*>(source.extraData());
 
         if (!source_data) {
           // TODO(perkj): Implement support for sources from
           // remote MediaStreams.
           NOTIMPLEMENTED();
           continue;
         }
 
         // TODO(perkj): Refactor the creation of audio tracks to use a proper
         // interface for receiving audio input data. Currently NULL is passed
         // since the |audio_device| is the wrong class and is unused.
         scoped_refptr<webrtc::LocalAudioTrackInterface> audio_track(
             CreateLocalAudioTrack(UTF16ToUTF8(source.id()), NULL));
         native_stream->AddTrack(audio_track);
         audio_track->set_enabled(audio_components[i].isEnabled());
-        // TODO(xians): This set the source of all audio tracks to the same
-        // microphone. Implement support for setting the source per audio track
-        // instead.
-        SetAudioDeviceSessionId(source_data->device_info().session_id);
     }
   }
 
   // Add video tracks.
   WebKit::WebVector<WebKit::WebMediaStreamComponent> video_components;
   description->videoSources(video_components);
   for (size_t i = 0; i < video_components.size(); ++i) {
     const WebKit::WebMediaStreamSource& source = video_components[i].source();
     MediaStreamSourceExtraData* source_data =
         static_cast<MediaStreamSourceExtraData*>(source.extraData());
@@ skipping 19 matching lines @@
     WebKit::WebMediaStreamDescriptor* description,
     const MediaStreamExtraData::StreamStopCallback& stream_stop) {
   CreateNativeLocalMediaStream(description);
 
   MediaStreamExtraData* extra_data =
      static_cast<MediaStreamExtraData*>(description->extraData());
   extra_data->SetLocalStreamStopCallback(stream_stop);
 }
 
 bool MediaStreamDependencyFactory::CreatePeerConnectionFactory() {
+  DVLOG(1) << "MediaStreamDependencyFactory::CreatePeerConnectionFactory()";
   if (!pc_factory_.get()) {
     DCHECK(!audio_device_);
     audio_device_ = new WebRtcAudioDeviceImpl();
     scoped_refptr<webrtc::PeerConnectionFactoryInterface> factory(
         webrtc::CreatePeerConnectionFactory(worker_thread_,
                                             signaling_thread_,
                                             audio_device_));
     if (factory.get())
       pc_factory_ = factory;
     else
@@ skipping 37 matching lines @@
     const webrtc::MediaConstraintsInterface* constraints) {
   RtcVideoCapturer* capturer = new RtcVideoCapturer(
       video_session_id, vc_manager_.get(), is_screencast);
 
   // The video source takes ownership of |capturer|.
   scoped_refptr<webrtc::VideoSourceInterface> source =
       pc_factory_->CreateVideoSource(capturer, constraints).get();
   return source;
 }
 
+bool MediaStreamDependencyFactory::InitializeAudioSource(
+  const StreamDeviceInfo& device_info) {
+  DVLOG(1) << "MediaStreamDependencyFactory::InitializeAudioSource()";
+  const MediaStreamDevice device = device_info.device;
+
+  // Initialize the source using audio parameters for the selected
+  // capture device.
+  WebRtcAudioCapturer* capturer = GetWebRtcAudioDevice()->capturer();
+  // TODO(henrika): refactor \content\public\common\media_stream_request.h
+  // to allow dependency of media::ChannelLayout and avoid static_cast.
+  if (!capturer->Initialize(
+          static_cast<media::ChannelLayout>(device.channel_layout),
+          device.sample_rate))
+    return false;
+
+  // Specify which capture device to use. The acquired session id is used
+  // for identification.
+  // TODO(henrika): the current design does not support a uniqe source
+  // for each audio track.
+  if (device_info.session_id <= 0)
+    return false;
+
+  capturer->SetDevice(device_info.session_id);
+  return true;
+}
+
+bool MediaStreamDependencyFactory::CreateWebAudioSource(
+    WebKit::WebMediaStreamSource* source) {
+  DVLOG(1) << "MediaStreamDependencyFactory::CreateWebAudioSource()";
+  DCHECK(GetWebRtcAudioDevice());
+
+  // WebAudio needs the WebRtcAudioCapturer to be able to send its data
+  // over a PeerConnection. The microphone source is not utilized in this
+  // case; instead the WebRtcAudioCapturer is driving.
+  WebRtcAudioCapturer* capturer = GetWebRtcAudioDevice()->capturer();
+  if (!capturer)
+    return false;
+
+  // TODO(henrika): life-time handling is not perfect here; there is room
+  // for improvements.
+  scoped_refptr<WebAudioCapturerSource>
+      webaudio_capturer_source(new WebAudioCapturerSource(capturer));
+  source->setExtraData(new content::MediaStreamSourceExtraData(
+      webaudio_capturer_source));
+  source->addAudioConsumer(webaudio_capturer_source);
+
+  return true;
+}
+
 scoped_refptr<webrtc::VideoTrackInterface>
 MediaStreamDependencyFactory::CreateLocalVideoTrack(
     const std::string& label,
     webrtc::VideoSourceInterface* source) {
   return pc_factory_->CreateVideoTrack(label, source).get();
 }
 
 scoped_refptr<webrtc::LocalAudioTrackInterface>
 MediaStreamDependencyFactory::CreateLocalAudioTrack(
     const std::string& label,
@@ skipping 12 matching lines @@
     int sdp_mline_index,
     const std::string& sdp) {
   return webrtc::CreateIceCandidate(sdp_mid, sdp_mline_index, sdp);
 }
 
 WebRtcAudioDeviceImpl*
 MediaStreamDependencyFactory::GetWebRtcAudioDevice() {
   return audio_device_;
 }
 
-void MediaStreamDependencyFactory::SetAudioDeviceSessionId(int session_id) {
-  audio_device_->SetSessionId(session_id);
-}
-
 void MediaStreamDependencyFactory::InitializeWorkerThread(
     talk_base::Thread** thread,
     base::WaitableEvent* event) {
   jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
   jingle_glue::JingleThreadWrapper::current()->set_send_allowed(true);
   *thread = jingle_glue::JingleThreadWrapper::current();
   event->Signal();
 }
 
 void MediaStreamDependencyFactory::CreateIpcNetworkManagerOnWorkerThread(
@@ skipping 78 matching lines @@
       // processed before returning. We wait for the above task to finish before
       // letting the the function continue to avoid any potential race issues.
       chrome_worker_thread_.Stop();
     } else {
       NOTREACHED() << "Worker thread not running.";
     }
   }
 }
 
 }  // namespace content