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.
5 // VideoCaptureManager is used to open/close, start/stop, enumerate available
6 // video capture devices, and manage VideoCaptureController's.
7 // All functions are expected to be called from Browser::IO thread. Some helper
8 // functions (*OnDeviceThread) will dispatch operations to the device thread.
9 // VideoCaptureManager will open OS dependent instances of VideoCaptureDevice.
10 // A device can only be opened once.
12 #ifndef CONTENT_BROWSER_RENDERER_HOST_MEDIA_VIDEO_CAPTURE_MANAGER_H_
13 #define CONTENT_BROWSER_RENDERER_HOST_MEDIA_VIDEO_CAPTURE_MANAGER_H_
19 #include "base/memory/ref_counted.h"
20 #include "base/memory/weak_ptr.h"
21 #include "base/process/process_handle.h"
22 #include "content/browser/renderer_host/media/media_stream_provider.h"
23 #include "content/browser/renderer_host/media/video_capture_controller_event_handler.h"
24 #include "content/common/content_export.h"
25 #include "content/common/media/media_stream_options.h"
26 #include "media/video/capture/video_capture_device.h"
27 #include "media/video/capture/video_capture_types.h"
30 class VideoCaptureController;
31 class VideoCaptureControllerEventHandler;
33 // VideoCaptureManager opens/closes and start/stops video capture devices.
34 class CONTENT_EXPORT VideoCaptureManager : public MediaStreamProvider {
36 // Callback used to signal the completion of a controller lookup.
37 typedef base::Callback<
38 void(const base::WeakPtr<VideoCaptureController>&)> DoneCB;
40 VideoCaptureManager();
42 // Implements MediaStreamProvider.
43 virtual void Register(MediaStreamProviderListener* listener,
44 base::MessageLoopProxy* device_thread_loop) OVERRIDE;
46 virtual void Unregister() OVERRIDE;
48 virtual void EnumerateDevices(MediaStreamType stream_type) OVERRIDE;
50 virtual int Open(const StreamDeviceInfo& device) OVERRIDE;
52 virtual void Close(int capture_session_id) OVERRIDE;
54 // Used by unit test to make sure a fake device is used instead of a real
55 // video capture device. Due to timing requirements, the function must be
56 // called before EnumerateDevices and Open.
59 // Called by VideoCaptureHost to locate a capture device for |capture_params|,
60 // adding the Host as a client of the device's controller if successful. The
61 // value of |capture_params.session_id| controls which device is selected;
62 // this value should be a session id previously returned by Open().
64 // If the device is not already started (i.e., no other client is currently
65 // capturing from this device), this call will cause a VideoCaptureController
66 // and VideoCaptureDevice to be created, possibly asynchronously.
68 // On success, the controller is returned via calling |done_cb|, indicating
69 // that the client was successfully added. A NULL controller is passed to
70 // the callback on failure.
71 void StartCaptureForClient(const media::VideoCaptureParams& capture_params,
72 base::ProcessHandle client_render_process,
73 VideoCaptureControllerID client_id,
74 VideoCaptureControllerEventHandler* client_handler,
75 const DoneCB& done_cb);
77 // Called by VideoCaptureHost to remove |client_handler|. If this is the last
78 // client of the device, the |controller| and its VideoCaptureDevice may be
79 // destroyed. The client must not access |controller| after calling this
81 void StopCaptureForClient(VideoCaptureController* controller,
82 VideoCaptureControllerID client_id,
83 VideoCaptureControllerEventHandler* client_handler);
86 virtual ~VideoCaptureManager();
89 // Check to see if |entry| has no clients left on its controller. If so,
90 // remove it from the list of devices, and delete it asynchronously. |entry|
91 // may be freed by this function.
92 void DestroyDeviceEntryIfNoClients(DeviceEntry* entry);
94 // Helpers to report an event to our Listener.
95 void OnOpened(MediaStreamType type, int capture_session_id);
96 void OnClosed(MediaStreamType type, int capture_session_id);
97 void OnDevicesEnumerated(MediaStreamType stream_type,
98 const media::VideoCaptureDevice::Names& names);
100 // Find a DeviceEntry by its device ID and type, if it is already opened.
101 DeviceEntry* GetDeviceEntryForMediaStreamDevice(
102 const MediaStreamDevice& device_info);
104 // Find a DeviceEntry entry for the indicated session, creating a fresh one
105 // if necessary. Returns NULL if the session id is invalid.
106 DeviceEntry* GetOrCreateDeviceEntry(int capture_session_id);
108 // Find the DeviceEntry that owns a particular controller pointer.
109 DeviceEntry* GetDeviceEntryForController(
110 const VideoCaptureController* controller);
112 bool IsOnDeviceThread() const;
114 // Queries and returns the available device IDs.
115 media::VideoCaptureDevice::Names GetAvailableDevicesOnDeviceThread(
116 MediaStreamType stream_type);
118 // Create and Start a new VideoCaptureDevice, storing the result in
119 // |entry->video_capture_device|. Ownership of |client| passes to
121 void DoStartDeviceOnDeviceThread(
123 const media::VideoCaptureCapability& capture_params,
124 scoped_ptr<media::VideoCaptureDevice::Client> client);
126 // Stop and destroy the VideoCaptureDevice held in
127 // |entry->video_capture_device|.
128 void DoStopDeviceOnDeviceThread(DeviceEntry* entry);
130 // The message loop of media stream device thread, where VCD's live.
131 scoped_refptr<base::MessageLoopProxy> device_loop_;
133 // Only accessed on Browser::IO thread.
134 MediaStreamProviderListener* listener_;
135 int new_capture_session_id_;
137 // An entry is kept in this map for every session that has been created via
138 // the Open() entry point. The keys are session_id's. This map is used to
139 // determine which device to use when StartCaptureForClient() occurs. Used
140 // only on the IO thread.
141 std::map<int, MediaStreamDevice> sessions_;
143 // An entry, kept in a map, that owns a VideoCaptureDevice and its associated
144 // VideoCaptureController. VideoCaptureManager owns all VideoCaptureDevices
145 // and VideoCaptureControllers and is responsible for deleting the instances
146 // when they are not used any longer.
148 // The set of currently started VideoCaptureDevice and VideoCaptureController
149 // objects is only accessed from IO thread, though the DeviceEntry instances
150 // themselves may visit to the device thread for device creation and
153 DeviceEntry(MediaStreamType stream_type,
154 const std::string& id,
155 scoped_ptr<VideoCaptureController> controller);
158 const MediaStreamType stream_type;
159 const std::string id;
161 // The controller. Only used from the IO thread.
162 scoped_ptr<VideoCaptureController> video_capture_controller;
164 // The capture device. Only used from the device thread.
165 scoped_ptr<media::VideoCaptureDevice> video_capture_device;
167 typedef std::set<DeviceEntry*> DeviceEntries;
168 DeviceEntries devices_;
170 // Set to true if using fake video capture devices for testing, false by
171 // default. This is only used for the MEDIA_DEVICE_VIDEO_CAPTURE device type.
172 bool use_fake_device_;
174 // We cache the enumerated video capture devices in
175 // GetAvailableDevicesOnDeviceThread() and then later look up the requested ID
176 // when a device is created in DoStartDeviceOnDeviceThread(). Used only on the
178 media::VideoCaptureDevice::Names video_capture_devices_;
180 DISALLOW_COPY_AND_ASSIGN(VideoCaptureManager);
183 } // namespace content
185 #endif // CONTENT_BROWSER_RENDERER_HOST_MEDIA_VIDEO_CAPTURE_MANAGER_H_