Video Capture Pepper API

content/renderer/pepper_plugin_delegate_impl.cc

 // Copyright (c) 2011 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/pepper_plugin_delegate_impl.h"
 
 #include <cmath>
 #include <queue>
 
 #include "base/callback.h"
@@ skipping 15 matching lines @@
 #include "content/common/pepper_file_messages.h"
 #include "content/common/pepper_plugin_registry.h"
 #include "content/common/pepper_messages.h"
 #include "content/common/view_messages.h"
 #include "content/renderer/content_renderer_client.h"
 #include "content/renderer/gpu/command_buffer_proxy.h"
 #include "content/renderer/gpu/gpu_channel_host.h"
 #include "content/renderer/gpu/renderer_gl_context.h"
 #include "content/renderer/gpu/webgraphicscontext3d_command_buffer_impl.h"
 #include "content/renderer/media/audio_message_filter.h"
+#include "content/renderer/media/video_capture_impl_manager.h"
 #include "content/renderer/p2p/p2p_transport_impl.h"
 #include "content/renderer/pepper_platform_context_3d_impl.h"
 #include "content/renderer/pepper_platform_video_decoder_impl.h"
 #include "content/renderer/render_thread.h"
 #include "content/renderer/render_view.h"
 #include "content/renderer/render_widget_fullscreen_pepper.h"
 #include "content/renderer/webplugin_delegate_proxy.h"
 #include "ipc/ipc_channel_handle.h"
+#include "media/video/capture/video_capture_proxy.h"
 #include "ppapi/c/dev/pp_video_dev.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/private/ppb_flash.h"
 #include "ppapi/c/private/ppb_flash_net_connector.h"
 #include "ppapi/proxy/host_dispatcher.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/shared_impl/ppapi_preferences.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFileChooserCompletion.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFileChooserParams.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPluginContainer.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebScreenInfo.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "ui/gfx/size.h"
 #include "ui/gfx/surface/transport_dib.h"
 #include "webkit/fileapi/file_system_callback_dispatcher.h"
 #include "webkit/glue/context_menu.h"
 #include "webkit/plugins/npapi/webplugin.h"
 #include "webkit/plugins/ppapi/file_path.h"
 #include "webkit/plugins/ppapi/ppb_file_io_impl.h"
 #include "webkit/plugins/ppapi/plugin_module.h"
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 #include "webkit/plugins/ppapi/ppb_broker_impl.h"
 #include "webkit/plugins/ppapi/ppb_flash_impl.h"
 #include "webkit/plugins/ppapi/ppb_flash_net_connector_impl.h"
 
 using WebKit::WebView;
 
 namespace {
 
-const int32 kDefaultCommandBufferSize = 1024 * 1024;
-
 int32_t PlatformFileToInt(base::PlatformFile handle) {
 #if defined(OS_WIN)
   return static_cast<int32_t>(reinterpret_cast<intptr_t>(handle));
 #elif defined(OS_POSIX)
   return handle;
 #else
   #error Not implemented.
 #endif
 }
 
@@ skipping 264 matching lines @@
     pp::proxy::HostDispatcher::SetForInstance(instance, dispatcher_.get());
   }
   virtual void RemoveInstance(PP_Instance instance) {
     pp::proxy::HostDispatcher::RemoveForInstance(instance);
   }
 
  private:
   scoped_ptr<pp::proxy::HostDispatcher> dispatcher_;
 };
 
+class PlatformVideoCaptureImpl
+    : public webkit::ppapi::PluginDelegate::PlatformVideoCapture {
+ public:
+  PlatformVideoCaptureImpl(media::VideoCapture::EventHandler* handler)
+      : handler_proxy_(new media::VideoCaptureHandlerProxy(
+            handler, base::MessageLoopProxy::CreateForCurrentThread())) {
+    VideoCaptureImplManager* manager =
+        RenderThread::current()->video_capture_impl_manager();
+    video_capture_ = manager->AddDevice(1, handler_proxy_.get());

[wjia(left Chromium), 2011/08/02 16:22:28]

Is there any plan on device management for pepper?

[piman, 2011/08/03 00:44:41]

Yes, I wanted to look at that at some point. Added a todo. Very likely we'll
need an API to enumerate them (and query caps ?), and change the current API to
allow specifying a particular device.

[wjia(left Chromium), 2011/08/03 02:40:00]

Device enumeration is done in media stream which has not been checked into
chromium yet. 

+  }
+
+  // Overrides from media::VideoCapture::EventHandler
+  virtual ~PlatformVideoCaptureImpl() OVERRIDE {
+    VideoCaptureImplManager* manager =
+        RenderThread::current()->video_capture_impl_manager();
+    manager->RemoveDevice(1, handler_proxy_.get());
+  }
+
+  virtual void StartCapture(
+      EventHandler* handler,
+      const VideoCaptureCapability& capability) OVERRIDE {
+    DCHECK(handler == handler_proxy_->proxied());
+    video_capture_->StartCapture(handler_proxy_.get(), capability);
+  }
+
+  virtual void StopCapture(EventHandler* handler) OVERRIDE {
+    DCHECK(handler == handler_proxy_->proxied());
+    video_capture_->StopCapture(handler_proxy_.get());
+  }
+
+  virtual void FeedBuffer(scoped_refptr<VideoFrameBuffer> buffer) OVERRIDE {
+    video_capture_->FeedBuffer(buffer);
+  }
+
+  virtual bool CaptureStarted() OVERRIDE {
+    return handler_proxy_->state().started;
+  }
+
+  virtual int CaptureWidth() OVERRIDE {
+    return handler_proxy_->state().width;
+  }
+
+  virtual int CaptureHeight() OVERRIDE {
+    return handler_proxy_->state().height;
+  }
+
+  virtual int CaptureFrameRate() OVERRIDE {
+    return handler_proxy_->state().frame_rate;
+  }
+
+ private:
+  scoped_ptr<media::VideoCaptureHandlerProxy> handler_proxy_;
+  media::VideoCapture* video_capture_;
+};
+
 }  // namespace
 
 bool DispatcherWrapper::Init(
     RenderView* render_view,
     base::ProcessHandle plugin_process_handle,
     const IPC::ChannelHandle& channel_handle,
     PP_Module pp_module,
     pp::proxy::Dispatcher::GetInterfaceFunc local_get_interface) {
   dispatcher_.reset(new pp::proxy::HostDispatcher(
       plugin_process_handle, pp_module, local_get_interface));
@@ skipping 456 matching lines @@
   RendererGLContext* parent_context = context->context();
   if (!parent_context)
     return NULL;
 
   return new PlatformContext3DImpl(parent_context);
 #else
   return NULL;
 #endif
 }
 
+webkit::ppapi::PluginDelegate::PlatformVideoCapture*
+PepperPluginDelegateImpl::CreateVideoCapture(
+      media::VideoCapture::EventHandler* handler) {
+  return new PlatformVideoCaptureImpl(handler);
+}
+
 webkit::ppapi::PluginDelegate::PlatformVideoDecoder*
 PepperPluginDelegateImpl::CreateVideoDecoder(
     media::VideoDecodeAccelerator::Client* client,
     int32 command_buffer_route_id) {
   return new PlatformVideoDecoderImpl(client, command_buffer_route_id);
 }
 
 void PepperPluginDelegateImpl::NumberOfFindResultsChanged(int identifier,
                                                           int total,
                                                           bool final_result) {
@@ skipping 499 matching lines @@
   if (!base::SharedMemory::IsHandleValid(handle)) {
     DLOG(WARNING) << "Browser failed to allocate shared memory";
     return NULL;
   }
   return new base::SharedMemory(handle, false);
 }
 
 ppapi::Preferences PepperPluginDelegateImpl::GetPreferences() {
   return ppapi::Preferences(render_view_->webkit_preferences());
 }