content/renderer/media/video_capture_impl.h

   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 // VideoCaptureImpl represents a capture device in renderer process. It provides
   6 // interfaces for clients to Start/Stop capture. It also communicates to clients
   7 // when buffer is ready, state of capture device is changed.
   8
   9 // VideoCaptureImpl is also a delegate of VideoCaptureMessageFilter which relays
  10 // operation of a capture device to the browser process and receives responses
  11 // from browser process.
  12 //
  13 // VideoCaptureImpl is an IO thread only object. See the comments in
  14 // video_capture_impl_manager.cc for the lifetime of this object.
  15 // All methods must be called on the IO thread.
  16 //
  17 // This is an internal class used by VideoCaptureImplManager only. Do not access
  18 // this directly.
  19
  20 #ifndef CONTENT_RENDERER_MEDIA_VIDEO_CAPTURE_IMPL_H_
  21 #define CONTENT_RENDERER_MEDIA_VIDEO_CAPTURE_IMPL_H_
  22
  23 #include <list>
  24 #include <map>
  25
  26 #include "base/memory/weak_ptr.h"
  27 #include "base/threading/thread_checker.h"
  28 #include "content/common/content_export.h"
  29 #include "content/common/media/video_capture.h"
  30 #include "content/public/renderer/media_stream_video_sink.h"
  31 #include "content/renderer/media/video_capture_message_filter.h"
  32 #include "media/video/capture/video_capture_types.h"
  33
  34 namespace base {
  35 class MessageLoopProxy;
  36 }  // namespace base
  37
  38 namespace gpu {
  39 struct MailboxHolder;
  40 }  // namespace gpu
  41
  42 namespace media {
  43 class VideoFrame;
  44 }  // namespace media
  45
  46 namespace content {
  47
  48 class CONTENT_EXPORT VideoCaptureImpl
  49     : public VideoCaptureMessageFilter::Delegate {
  50  public:
  51   virtual ~VideoCaptureImpl();
  52
  53   VideoCaptureImpl(media::VideoCaptureSessionId session_id,
  54                    VideoCaptureMessageFilter* filter);
  55
  56   // Start listening to IPC messages.
  57   void Init();
  58
  59   // Stop listening to IPC messages.
  60   void DeInit();
  61
  62   // Stop/resume delivering video frames to clients, based on flag |suspend|.
  63   void SuspendCapture(bool suspend);
  64
  65   // Start capturing using the provided parameters.
  66   // |client_id| must be unique to this object in the render process. It is
  67   // used later to stop receiving video frames.
  68   // |state_update_cb| will be called when state changes.
  69   // |deliver_frame_cb| will be called when a frame is ready.
  70   void StartCapture(
  71       int client_id,
  72       const media::VideoCaptureParams& params,
  73       const VideoCaptureStateUpdateCB& state_update_cb,
  74       const VideoCaptureDeliverFrameCB& deliver_frame_cb);
  75
  76   // Stop capturing. |client_id| is the identifier used to call StartCapture.
  77   void StopCapture(int client_id);
  78
  79   // Get capturing formats supported by this device.
  80   // |callback| will be invoked with the results.
  81   void GetDeviceSupportedFormats(
  82       const VideoCaptureDeviceFormatsCB& callback);
  83
  84   // Get capturing formats currently in use by this device.
  85   // |callback| will be invoked with the results.
  86   void GetDeviceFormatsInUse(
  87       const VideoCaptureDeviceFormatsCB& callback);
  88
  89   media::VideoCaptureSessionId session_id() const { return session_id_; }
  90
  91  private:
  92   friend class VideoCaptureImplTest;
  93   friend class MockVideoCaptureImpl;
  94
  95   // Carries a shared memory for transferring video frames from browser to
  96   // renderer.
  97   class ClientBuffer;
  98
  99   // Contains information for a video capture client. Including parameters
 100   // for capturing and callbacks to the client.
 101   struct ClientInfo {
 102     ClientInfo();
 103     ~ClientInfo();
 104     media::VideoCaptureParams params;
 105     VideoCaptureStateUpdateCB state_update_cb;
 106     VideoCaptureDeliverFrameCB deliver_frame_cb;
 107   };
 108   typedef std::map<int, ClientInfo> ClientInfoMap;
 109
 110   // VideoCaptureMessageFilter::Delegate interface.
 111   virtual void OnBufferCreated(base::SharedMemoryHandle handle,
 112                                int length,
 113                                int buffer_id) OVERRIDE;
 114   virtual void OnBufferDestroyed(int buffer_id) OVERRIDE;
 115   virtual void OnBufferReceived(int buffer_id,
 116                                 const media::VideoCaptureFormat& format,
 117                                 base::TimeTicks) OVERRIDE;
 118   virtual void OnMailboxBufferReceived(int buffer_id,
 119                                        const gpu::MailboxHolder& mailbox_holder,
 120                                        const media::VideoCaptureFormat& format,
 121                                        base::TimeTicks timestamp) OVERRIDE;
 122   virtual void OnStateChanged(VideoCaptureState state) OVERRIDE;
 123   virtual void OnDeviceSupportedFormatsEnumerated(
 124       const media::VideoCaptureFormats& supported_formats) OVERRIDE;
 125   virtual void OnDeviceFormatsInUseReceived(
 126       const media::VideoCaptureFormats& formats_in_use) OVERRIDE;
 127   virtual void OnDelegateAdded(int32 device_id) OVERRIDE;
 128
 129   // Sends an IPC message to browser process when all clients are done with the
 130   // buffer.
 131   void OnClientBufferFinished(int buffer_id,
 132                               const scoped_refptr<ClientBuffer>& buffer,
 133                               const std::vector<uint32>& release_sync_points);
 134
 135   void StopDevice();
 136   void RestartCapture();
 137   void StartCaptureInternal();
 138
 139   virtual void Send(IPC::Message* message);
 140
 141   // Helpers.
 142   bool RemoveClient(int client_id, ClientInfoMap* clients);
 143
 144   const scoped_refptr<VideoCaptureMessageFilter> message_filter_;
 145   int device_id_;
 146   const int session_id_;
 147
 148   // Vector of callbacks to be notified of device format enumerations, used only
 149   // on IO Thread.
 150   std::vector<VideoCaptureDeviceFormatsCB> device_formats_cb_queue_;
 151   // Vector of callbacks to be notified of a device's in use capture format(s),
 152   // used only on IO Thread.
 153   std::vector<VideoCaptureDeviceFormatsCB> device_formats_in_use_cb_queue_;
 154
 155   // Buffers available for sending to the client.
 156   typedef std::map<int32, scoped_refptr<ClientBuffer> > ClientBufferMap;
 157   ClientBufferMap client_buffers_;
 158
 159   ClientInfoMap clients_;
 160   ClientInfoMap clients_pending_on_filter_;
 161   ClientInfoMap clients_pending_on_restart_;
 162
 163   // Member params_ represents the video format requested by the
 164   // client to this class via StartCapture().
 165   media::VideoCaptureParams params_;
 166
 167   // The device's video capture format sent from browser process side.
 168   media::VideoCaptureFormat last_frame_format_;
 169
 170   // The device's first captured frame timestamp sent from browser process side.
 171   base::TimeTicks first_frame_timestamp_;
 172
 173   bool suspended_;
 174   VideoCaptureState state_;
 175
 176   // |weak_factory_| and |thread_checker_| are bound to the IO thread.
 177   base::ThreadChecker thread_checker_;
 178
 179   // WeakPtrFactory pointing back to |this| object, for use with
 180   // media::VideoFrames constructed in OnBufferReceived() from buffers cached
 181   // in |client_buffers_|.
 182   // NOTE: Weak pointers must be invalidated before all other member variables.
 183   base::WeakPtrFactory<VideoCaptureImpl> weak_factory_;
 184
 185   DISALLOW_COPY_AND_ASSIGN(VideoCaptureImpl);
 186 };
 187
 188 }  // namespace content
 189
 190 #endif  // CONTENT_RENDERER_MEDIA_VIDEO_CAPTURE_IMPL_H_