video_capture_controller.h revision 1320f92c476a1ad9d19dba2a48c72b75566198e9
1// Copyright (c) 2012 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// VideoCaptureController is the glue between a VideoCaptureDevice and all 6// VideoCaptureHosts that have connected to it. A controller exists on behalf of 7// one (and only one) VideoCaptureDevice; both are owned by the 8// VideoCaptureManager. 9// 10// The VideoCaptureController is responsible for: 11// 12// * Allocating and keeping track of shared memory buffers, and filling them 13// with I420 video frames for IPC communication between VideoCaptureHost (in 14// the browser process) and VideoCaptureMessageFilter (in the renderer 15// process). 16// * Broadcasting the events from a single VideoCaptureDevice, fanning them 17// out to multiple clients. 18// * Keeping track of the clients on behalf of the VideoCaptureManager, making 19// it possible for the Manager to delete the Controller and its Device when 20// there are no clients left. 21// 22// A helper class, VCC::VideoCaptureDeviceClient, is responsible for: 23// 24// * Conveying events from the device thread (where VideoCaptureDevices live) 25// the IO thread (where the VideoCaptureController lives). 26// * Performing some image transformations on the output of the Device; 27// specifically, colorspace conversion and rotation. 28// 29// Interactions between VideoCaptureController and other classes: 30// 31// * VideoCaptureController indirectly observes a VideoCaptureDevice 32// by means of its proxy, VideoCaptureDeviceClient, which implements 33// the VideoCaptureDevice::Client interface. The proxy forwards 34// observed events to the VideoCaptureController on the IO thread. 35// * A VideoCaptureController interacts with its clients (VideoCaptureHosts) 36// via the VideoCaptureControllerEventHandler interface. 37// * Conversely, a VideoCaptureControllerEventHandler (typically, 38// VideoCaptureHost) will interact directly with VideoCaptureController to 39// return leased buffers by means of the ReturnBuffer() public method of 40// VCC. 41// * VideoCaptureManager (which owns the VCC) interacts directly with 42// VideoCaptureController through its public methods, to add and remove 43// clients. 44// 45// VideoCaptureController is not thread safe and operates on the IO thread only. 46 47#ifndef CONTENT_BROWSER_RENDERER_HOST_MEDIA_VIDEO_CAPTURE_CONTROLLER_H_ 48#define CONTENT_BROWSER_RENDERER_HOST_MEDIA_VIDEO_CAPTURE_CONTROLLER_H_ 49 50#include <list> 51 52#include "base/compiler_specific.h" 53#include "base/memory/ref_counted.h" 54#include "base/memory/scoped_ptr.h" 55#include "base/memory/weak_ptr.h" 56#include "base/process/process.h" 57#include "content/browser/renderer_host/media/video_capture_buffer_pool.h" 58#include "content/browser/renderer_host/media/video_capture_controller_event_handler.h" 59#include "content/common/content_export.h" 60#include "content/common/media/video_capture.h" 61#include "media/video/capture/video_capture_device.h" 62#include "media/video/capture/video_capture_types.h" 63 64namespace content { 65class VideoCaptureBufferPool; 66 67class CONTENT_EXPORT VideoCaptureController { 68 public: 69 // |max_buffers| is the maximum number of video frame buffers in-flight at any 70 // one time. This value should be based on the logical capacity of the 71 // capture pipeline, and not on hardware performance. For example, tab 72 // capture requires more buffers than webcam capture because the pipeline is 73 // longer (it includes read-backs pending in the GPU pipeline). 74 explicit VideoCaptureController(int max_buffers); 75 virtual ~VideoCaptureController(); 76 77 base::WeakPtr<VideoCaptureController> GetWeakPtr(); 78 79 // Return a new VideoCaptureDeviceClient to forward capture events to this 80 // instance. 81 scoped_ptr<media::VideoCaptureDevice::Client> NewDeviceClient(); 82 83 // Start video capturing and try to use the resolution specified in |params|. 84 // Buffers will be shared to the client as necessary. The client will continue 85 // to receive frames from the device until RemoveClient() is called. 86 void AddClient(const VideoCaptureControllerID& id, 87 VideoCaptureControllerEventHandler* event_handler, 88 base::ProcessHandle render_process, 89 media::VideoCaptureSessionId session_id, 90 const media::VideoCaptureParams& params); 91 92 // Stop video capture. This will take back all buffers held by by 93 // |event_handler|, and |event_handler| shouldn't use those buffers any more. 94 // Returns the session_id of the stopped client, or 95 // kInvalidMediaCaptureSessionId if the indicated client was not registered. 96 int RemoveClient(const VideoCaptureControllerID& id, 97 VideoCaptureControllerEventHandler* event_handler); 98 99 int GetClientCount(); 100 101 // API called directly by VideoCaptureManager in case the device is 102 // prematurely closed. 103 void StopSession(int session_id); 104 105 // Return a buffer with id |buffer_id| previously given in 106 // VideoCaptureControllerEventHandler::OnBufferReady. In the case that the 107 // buffer was backed by a texture, |sync_point| will be waited on before 108 // destroying or recycling the texture, to synchronize with texture users in 109 // the renderer process. 110 void ReturnBuffer(const VideoCaptureControllerID& id, 111 VideoCaptureControllerEventHandler* event_handler, 112 int buffer_id, 113 uint32 sync_point); 114 115 const media::VideoCaptureFormat& GetVideoCaptureFormat() const; 116 117 private: 118 class VideoCaptureDeviceClient; 119 120 struct ControllerClient; 121 typedef std::list<ControllerClient*> ControllerClients; 122 123 // Worker functions on IO thread. Called by the VideoCaptureDeviceClient. 124 void DoIncomingCapturedVideoFrameOnIOThread( 125 const scoped_refptr<media::VideoCaptureDevice::Client::Buffer>& buffer, 126 const media::VideoCaptureFormat& format, 127 const scoped_refptr<media::VideoFrame>& frame, 128 base::TimeTicks timestamp); 129 void DoErrorOnIOThread(); 130 void DoDeviceStoppedOnIOThread(); 131 void DoBufferDestroyedOnIOThread(int buffer_id_to_drop); 132 133 // Find a client of |id| and |handler| in |clients|. 134 ControllerClient* FindClient( 135 const VideoCaptureControllerID& id, 136 VideoCaptureControllerEventHandler* handler, 137 const ControllerClients& clients); 138 139 // Find a client of |session_id| in |clients|. 140 ControllerClient* FindClient( 141 int session_id, 142 const ControllerClients& clients); 143 144 // The pool of shared-memory buffers used for capturing. 145 const scoped_refptr<VideoCaptureBufferPool> buffer_pool_; 146 147 // All clients served by this controller. 148 ControllerClients controller_clients_; 149 150 // Takes on only the states 'STARTED' and 'ERROR'. 'ERROR' is an absorbing 151 // state which stops the flow of data to clients. 152 VideoCaptureState state_; 153 154 // True if the controller has received a video frame from the device. 155 bool frame_received_; 156 157 media::VideoCaptureFormat video_capture_format_; 158 159 base::WeakPtrFactory<VideoCaptureController> weak_ptr_factory_; 160 161 DISALLOW_COPY_AND_ASSIGN(VideoCaptureController); 162}; 163 164} // namespace content 165 166#endif // CONTENT_BROWSER_RENDERER_HOST_MEDIA_VIDEO_CAPTURE_CONTROLLER_H_ 167