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 64 namespace content { 65 class VideoCaptureBufferPool; 66 67 class CONTENT_EXPORT VideoCaptureController { 68 public: 69 VideoCaptureController(); 70 virtual ~VideoCaptureController(); 71 72 base::WeakPtr<VideoCaptureController> GetWeakPtr(); 73 74 // Return a new VideoCaptureDeviceClient to forward capture events to this 75 // instance. 76 scoped_ptr<media::VideoCaptureDevice::Client> NewDeviceClient(); 77 78 // Start video capturing and try to use the resolution specified in |params|. 79 // Buffers will be shared to the client as necessary. The client will continue 80 // to receive frames from the device until RemoveClient() is called. 81 void AddClient(const VideoCaptureControllerID& id, 82 VideoCaptureControllerEventHandler* event_handler, 83 base::ProcessHandle render_process, 84 media::VideoCaptureSessionId session_id, 85 const media::VideoCaptureParams& params); 86 87 // Stop video capture. This will take back all buffers held by by 88 // |event_handler|, and |event_handler| shouldn't use those buffers any more. 89 // Returns the session_id of the stopped client, or 90 // kInvalidMediaCaptureSessionId if the indicated client was not registered. 91 int RemoveClient(const VideoCaptureControllerID& id, 92 VideoCaptureControllerEventHandler* event_handler); 93 94 int GetClientCount(); 95 96 // API called directly by VideoCaptureManager in case the device is 97 // prematurely closed. 98 void StopSession(int session_id); 99 100 // Return a buffer with id |buffer_id| previously given in 101 // VideoCaptureControllerEventHandler::OnBufferReady. In the case that the 102 // buffer was backed by a texture, |sync_point| will be waited on before 103 // destroying or recycling the texture, to synchronize with texture users in 104 // the renderer process. 105 void ReturnBuffer(const VideoCaptureControllerID& id, 106 VideoCaptureControllerEventHandler* event_handler, 107 int buffer_id, 108 const std::vector<uint32>& sync_points); 109 110 const media::VideoCaptureFormat& GetVideoCaptureFormat() const; 111 112 private: 113 class VideoCaptureDeviceClient; 114 115 struct ControllerClient; 116 typedef std::list<ControllerClient*> ControllerClients; 117 118 // Worker functions on IO thread. Called by the VideoCaptureDeviceClient. 119 void DoIncomingCapturedVideoFrameOnIOThread( 120 const scoped_refptr<media::VideoCaptureDevice::Client::Buffer>& buffer, 121 const media::VideoCaptureFormat& format, 122 const scoped_refptr<media::VideoFrame>& frame, 123 base::TimeTicks timestamp); 124 void DoErrorOnIOThread(); 125 void DoDeviceStoppedOnIOThread(); 126 void DoBufferDestroyedOnIOThread(int buffer_id_to_drop); 127 128 // Find a client of |id| and |handler| in |clients|. 129 ControllerClient* FindClient( 130 const VideoCaptureControllerID& id, 131 VideoCaptureControllerEventHandler* handler, 132 const ControllerClients& clients); 133 134 // Find a client of |session_id| in |clients|. 135 ControllerClient* FindClient( 136 int session_id, 137 const ControllerClients& clients); 138 139 // The pool of shared-memory buffers used for capturing. 140 const scoped_refptr<VideoCaptureBufferPool> buffer_pool_; 141 142 // All clients served by this controller. 143 ControllerClients controller_clients_; 144 145 // Takes on only the states 'STARTED' and 'ERROR'. 'ERROR' is an absorbing 146 // state which stops the flow of data to clients. 147 VideoCaptureState state_; 148 149 media::VideoCaptureFormat video_capture_format_; 150 151 base::WeakPtrFactory<VideoCaptureController> weak_ptr_factory_; 152 153 DISALLOW_COPY_AND_ASSIGN(VideoCaptureController); 154 }; 155 156 } // namespace content 157 158 #endif // CONTENT_BROWSER_RENDERER_HOST_MEDIA_VIDEO_CAPTURE_CONTROLLER_H_ 159