src/content/renderer/media/media_stream_renderer_factory.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/renderer/media/media_stream_renderer_factory.h"
   6
   7 #include "base/strings/utf_string_conversions.h"
   8 #include "content/renderer/media/media_stream.h"
   9 #include "content/renderer/media/media_stream_video_track.h"
  10 #include "content/renderer/media/rtc_video_renderer.h"
  11 #include "content/renderer/media/webrtc/peer_connection_dependency_factory.h"
  12 #include "content/renderer/media/webrtc_audio_renderer.h"
  13 #include "content/renderer/media/webrtc_local_audio_renderer.h"
  14 #include "content/renderer/render_thread_impl.h"
  15 #include "media/base/audio_hardware_config.h"
  16 #include "third_party/WebKit/public/platform/WebMediaStream.h"
  17 #include "third_party/WebKit/public/platform/WebURL.h"
  18 #include "third_party/WebKit/public/web/WebMediaStreamRegistry.h"
  19 #include "third_party/libjingle/source/talk/app/webrtc/mediastreaminterface.h"
  20
  21 namespace content {
  22
  23 namespace {
  24
  25 PeerConnectionDependencyFactory* GetPeerConnectionDependencyFactory() {
  26   return RenderThreadImpl::current()->GetPeerConnectionDependencyFactory();
  27 }
  28
  29 void GetDefaultOutputDeviceParams(
  30     int* output_sample_rate, int* output_buffer_size) {
  31   // Fetch the default audio output hardware config.
  32   media::AudioHardwareConfig* hardware_config =
  33       RenderThreadImpl::current()->GetAudioHardwareConfig();
  34   *output_sample_rate = hardware_config->GetOutputSampleRate();
  35   *output_buffer_size = hardware_config->GetOutputBufferSize();
  36 }
  37
  38
  39 // Returns a valid session id if a single capture device is currently open
  40 // (and then the matching session_id), otherwise -1.
  41 // This is used to pass on a session id to a webrtc audio renderer (either
  42 // local or remote), so that audio will be rendered to a matching output
  43 // device, should one exist.
  44 // Note that if there are more than one open capture devices the function
  45 // will not be able to pick an appropriate device and return false.
  46 bool GetAuthorizedDeviceInfoForAudioRenderer(
  47     int* session_id,
  48     int* output_sample_rate,
  49     int* output_frames_per_buffer) {
  50   WebRtcAudioDeviceImpl* audio_device =
  51       GetPeerConnectionDependencyFactory()->GetWebRtcAudioDevice();
  52   if (!audio_device)
  53     return false;
  54
  55   return audio_device->GetAuthorizedDeviceInfoForAudioRenderer(
  56       session_id, output_sample_rate, output_frames_per_buffer);
  57 }
  58
  59 scoped_refptr<WebRtcAudioRenderer> CreateRemoteAudioRenderer(
  60     webrtc::MediaStreamInterface* stream,
  61     int routing_id,
  62     int render_frame_id) {
  63   if (stream->GetAudioTracks().empty())
  64     return NULL;
  65
  66   DVLOG(1) << "MediaStreamRendererFactory::CreateRemoteAudioRenderer label:"
  67            << stream->label();
  68
  69   // TODO(tommi): Change the default value of session_id to be
  70   // StreamDeviceInfo::kNoId.  Also update AudioOutputDevice etc.
  71   int session_id = 0, sample_rate = 0, buffer_size = 0;
  72   if (!GetAuthorizedDeviceInfoForAudioRenderer(&session_id,
  73                                                &sample_rate,
  74                                                &buffer_size)) {
  75     GetDefaultOutputDeviceParams(&sample_rate, &buffer_size);
  76   }
  77
  78   return new WebRtcAudioRenderer(
  79       GetPeerConnectionDependencyFactory()->GetWebRtcSignalingThread(),
  80       stream, routing_id, render_frame_id,  session_id,
  81       sample_rate, buffer_size);
  82 }
  83
  84
  85 scoped_refptr<WebRtcLocalAudioRenderer> CreateLocalAudioRenderer(
  86     const blink::WebMediaStreamTrack& audio_track,
  87     int routing_id,
  88     int render_frame_id) {
  89   DVLOG(1) << "MediaStreamRendererFactory::CreateLocalAudioRenderer";
  90
  91   int session_id = 0, sample_rate = 0, buffer_size = 0;
  92   if (!GetAuthorizedDeviceInfoForAudioRenderer(&session_id,
  93                                                &sample_rate,
  94                                                &buffer_size)) {
  95     GetDefaultOutputDeviceParams(&sample_rate, &buffer_size);
  96   }
  97
  98   // Create a new WebRtcLocalAudioRenderer instance and connect it to the
  99   // existing WebRtcAudioCapturer so that the renderer can use it as source.
 100   return new WebRtcLocalAudioRenderer(
 101       audio_track,
 102       routing_id,
 103       render_frame_id,
 104       session_id,
 105       buffer_size);
 106 }
 107
 108 }  // namespace
 109
 110
 111 MediaStreamRendererFactory::MediaStreamRendererFactory() {
 112 }
 113
 114 MediaStreamRendererFactory::~MediaStreamRendererFactory() {
 115 }
 116
 117 scoped_refptr<VideoFrameProvider>
 118 MediaStreamRendererFactory::GetVideoFrameProvider(
 119     const GURL& url,
 120     const base::Closure& error_cb,
 121     const VideoFrameProvider::RepaintCB& repaint_cb) {
 122   blink::WebMediaStream web_stream =
 123       blink::WebMediaStreamRegistry::lookupMediaStreamDescriptor(url);
 124   DCHECK(!web_stream.isNull());
 125
 126   DVLOG(1) << "MediaStreamRendererFactory::GetVideoFrameProvider stream:"
 127            << base::UTF16ToUTF8(web_stream.id());
 128
 129   blink::WebVector<blink::WebMediaStreamTrack> video_tracks;
 130   web_stream.videoTracks(video_tracks);
 131   if (video_tracks.isEmpty() ||
 132       !MediaStreamVideoTrack::GetTrack(video_tracks[0])) {
 133     return NULL;
 134   }
 135
 136   return new RTCVideoRenderer(video_tracks[0], error_cb, repaint_cb);
 137 }
 138
 139 scoped_refptr<MediaStreamAudioRenderer>
 140 MediaStreamRendererFactory::GetAudioRenderer(
 141     const GURL& url, int render_view_id, int render_frame_id) {
 142   blink::WebMediaStream web_stream =
 143       blink::WebMediaStreamRegistry::lookupMediaStreamDescriptor(url);
 144
 145   if (web_stream.isNull() || !web_stream.extraData())
 146     return NULL;  // This is not a valid stream.
 147
 148   DVLOG(1) << "MediaStreamRendererFactory::GetAudioRenderer stream:"
 149            << base::UTF16ToUTF8(web_stream.id());
 150
 151   MediaStream* native_stream = MediaStream::GetMediaStream(web_stream);
 152
 153   // TODO(tommi): MediaStreams do not have a 'local or not' concept.
 154   // Tracks _might_, but even so, we need to fix the data flow so that
 155   // it works the same way for all track implementations, local, remote or what
 156   // have you.
 157   // In this function, we should simply create a renderer object that receives
 158   // and mixes audio from all the tracks that belong to the media stream.
 159   // We need to remove the |is_local| property from MediaStreamExtraData since
 160   // this concept is peerconnection specific (is a previously recorded stream
 161   // local or remote?).
 162   if (native_stream->is_local()) {
 163     // Create the local audio renderer if the stream contains audio tracks.
 164     blink::WebVector<blink::WebMediaStreamTrack> audio_tracks;
 165     web_stream.audioTracks(audio_tracks);
 166     if (audio_tracks.isEmpty())
 167       return NULL;
 168
 169     // TODO(xians): Add support for the case where the media stream contains
 170     // multiple audio tracks.
 171     return CreateLocalAudioRenderer(audio_tracks[0], render_view_id,
 172                                     render_frame_id);
 173   }
 174
 175   webrtc::MediaStreamInterface* stream =
 176       MediaStream::GetAdapter(web_stream);
 177   if (stream->GetAudioTracks().empty())
 178     return NULL;
 179
 180   // This is a remote WebRTC media stream.
 181   WebRtcAudioDeviceImpl* audio_device =
 182       GetPeerConnectionDependencyFactory()->GetWebRtcAudioDevice();
 183
 184   // Share the existing renderer if any, otherwise create a new one.
 185   scoped_refptr<WebRtcAudioRenderer> renderer(audio_device->renderer());
 186   if (!renderer.get()) {
 187     renderer = CreateRemoteAudioRenderer(stream, render_view_id,
 188                                          render_frame_id);
 189
 190     if (renderer.get() && !audio_device->SetAudioRenderer(renderer.get()))
 191       renderer = NULL;
 192   }
 193
 194   return renderer.get() ?
 195       renderer->CreateSharedAudioRendererProxy(stream) : NULL;
 196 }
 197
 198 }  // namespace content