Home | History | Annotate | Download | only in media 
      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_
    191