Integrate VDA with WebRTC.

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/rtc_video_decoder_factory.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_local_audio_track.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/WebMediaConstraints.h"
@@ skipping 168 matching lines @@
   WebKit::WebMediaStream* description_;
   MediaStreamDependencyFactory::MediaSourcesCreatedCallback ready_callback_;
   bool live_;
   typedef std::vector<scoped_refptr<webrtc::MediaSourceInterface> >
       ObservedSources;
   ObservedSources sources_;
 };
 
 MediaStreamDependencyFactory::MediaStreamDependencyFactory(
     VideoCaptureImplManager* vc_manager,
+    const scoped_refptr<media::GpuVideoDecoder::Factories>& gpu_factories,
     P2PSocketDispatcher* p2p_socket_dispatcher)
     : network_manager_(NULL),
       vc_manager_(vc_manager),
+      gpu_factories_(gpu_factories),
       p2p_socket_dispatcher_(p2p_socket_dispatcher),
       signaling_thread_(NULL),
       worker_thread_(NULL),
-      chrome_worker_thread_("Chrome_libJingle_WorkerThread") {
+      chrome_worker_thread_("Chrome_libJingle_WorkerThread"),
+      decoder_worker_thread_("DecoderWorkerThread") {
 }
 
 MediaStreamDependencyFactory::~MediaStreamDependencyFactory() {
   CleanupPeerConnectionFactory();
 }
 
 WebKit::WebRTCPeerConnectionHandler*
 MediaStreamDependencyFactory::CreateRTCPeerConnectionHandler(
     WebKit::WebRTCPeerConnectionHandlerClient* client) {
   // Save histogram data so we can see how much PeerConnetion is used.
@@ skipping 232 matching lines @@
   return type == WebKit::WebMediaStreamSource::TypeAudio ?
       native_stream->RemoveTrack(native_stream->FindAudioTrack(track_id)) :
       native_stream->RemoveTrack(native_stream->FindVideoTrack(track_id));
 }
 
 bool MediaStreamDependencyFactory::CreatePeerConnectionFactory() {
   DVLOG(1) << "MediaStreamDependencyFactory::CreatePeerConnectionFactory()";
   if (!pc_factory_) {
     DCHECK(!audio_device_);
     audio_device_ = new WebRtcAudioDeviceImpl();
+
+    scoped_ptr<RTCVideoDecoderFactory> decoder_factory;
+    if (gpu_factories_ != NULL && decoder_worker_thread_.IsRunning()) {
+      decoder_factory.reset(new RTCVideoDecoderFactory(
+              decoder_worker_thread_.message_loop_proxy(), gpu_factories_));

[Ami GONE FROM CHROMIUM, 2013/05/14 22:57:24]

Does this mean that the same gpu_factories will be used for every
mediastream-backed <video> tag in a given renderer process?  That's broken: a
given gpu_factories_ object can only be used with a single <video> tag (e.g.
look at its impl use of waitableevents).

[wuchengli, 2013/05/15 15:30:46]

I'm not sure which waitableevents are you talking about. Can you give me the URL
of the source?

Do you mean we need to cretae a gpu_factories_ every time
CreatePeerConnectionFactory is called?

[wuchengli, 2013/05/20 14:32:15]

I was thinking to move the creation of gpu_factories to
RTCVideoDecoderFactory::CreateVideoDecoder. CreateVideoDecoder is called on
WebRTC decoding thread. So it will need to post the task back to main renderer
thread to create the gpu_factories. Do you think that's the right place?

I tried to implement this today. But the main renderer thread does not run the
task at all. I'm still trying to figure out why.

What method or data structure can map to one mediastream-backed <video> tag?
Does one WebMediaPlayerMS mean one mediastream-backed <video> tag?
https://code.google.com/p/chromium/codesearch#chromium/src/content/renderer/r...

+    }
+
     scoped_refptr<webrtc::PeerConnectionFactoryInterface> factory(
         webrtc::CreatePeerConnectionFactory(worker_thread_,
                                             signaling_thread_,
-                                            audio_device_));
+                                            audio_device_,
+                                            decoder_factory.release()));
     if (factory)
       pc_factory_ = factory;
     else
       audio_device_ = NULL;
   }
   return pc_factory_.get() != NULL;
 }
 
 bool MediaStreamDependencyFactory::PeerConnectionFactoryCreated() {
   return pc_factory_.get() != NULL;
@@ skipping 219 matching lines @@
     base::WaitableEvent event(true, false);
     chrome_worker_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
         &MediaStreamDependencyFactory::InitializeWorkerThread,
         base::Unretained(this),
         &worker_thread_,
         &event));
     event.Wait();
     DCHECK(worker_thread_);
   }
 
+  if (gpu_factories_ != NULL && !decoder_worker_thread_.IsRunning()) {
+    if (!decoder_worker_thread_.Start()) {
+      LOG(ERROR) << "Could not start decoder worker thread";
+    }
+  }
+
   if (!network_manager_) {
     base::WaitableEvent event(true, false);
     chrome_worker_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
         &MediaStreamDependencyFactory::CreateIpcNetworkManagerOnWorkerThread,
         base::Unretained(this),
         &event));
     event.Wait();
   }
 
   if (!socket_factory_) {
@@ skipping 32 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