Hook up EncodedVideoSource on the browser side

content/browser/renderer_host/media/video_capture_controller.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // VideoCaptureController is the glue between VideoCaptureHost,
 // VideoCaptureManager and VideoCaptureDevice.
 // It provides functions for VideoCaptureHost to start a VideoCaptureDevice and
 // is responsible for keeping track of shared DIBs and filling them with I420
 // video frames for IPC communication between VideoCaptureHost and
 // VideoCaptureMessageFilter.
@@ skipping 12 matching lines @@
 #include "base/memory/ref_counted.h"
 #include "base/process.h"
 #include "base/synchronization/lock.h"
 #include "content/browser/renderer_host/media/video_capture_buffer_pool.h"
 #include "content/browser/renderer_host/media/video_capture_controller_event_handler.h"
 #include "content/common/content_export.h"
 #include "content/common/media/video_capture.h"
 #include "media/video/capture/video_capture.h"
 #include "media/video/capture/video_capture_device.h"
 #include "media/video/capture/video_capture_types.h"
+#include "media/video/video_encode_types.h"
 
 namespace content {
 class VideoCaptureManager;
 class VideoCaptureBufferPool;
 
 class CONTENT_EXPORT VideoCaptureController
     : public base::RefCountedThreadSafe<VideoCaptureController>,
       public media::VideoCaptureDevice::EventHandler {
  public:
   VideoCaptureController(VideoCaptureManager* video_capture_manager);
@@ skipping 17 matching lines @@
   // API called directly by VideoCaptureManager in case the device is
   // prematurely closed.
   void StopSession(int session_id);
 
   // Return a buffer previously given in
   // VideoCaptureControllerEventHandler::OnBufferReady.
   void ReturnBuffer(const VideoCaptureControllerID& id,
                     VideoCaptureControllerEventHandler* event_handler,
                     int buffer_id);
 
+  // Attempt to configure the encoding parameters for an encoded bitstream.
+  // Fails silently if the capture device does not support encoding.
+  void TryConfigureEncodedBitstream(
+      const media::RuntimeVideoEncodingParameters& params);
+
   // Implement media::VideoCaptureDevice::EventHandler.
-  virtual scoped_refptr<media::VideoFrame> ReserveOutputBuffer() OVERRIDE;
+  virtual scoped_refptr<media::VideoFrame> ReserveOutputVideoFrame() OVERRIDE;
+  virtual scoped_refptr<media::EncodedBitstreamBuffer>
+      ReserveOutputEncodedBitstreamBuffer() OVERRIDE;
   virtual void OnIncomingCapturedFrame(const uint8* data,
                                        int length,
                                        base::Time timestamp,
                                        int rotation,
                                        bool flip_vert,
                                        bool flip_horiz) OVERRIDE;
   virtual void OnIncomingCapturedVideoFrame(
       const scoped_refptr<media::VideoFrame>& frame,
       base::Time timestamp) OVERRIDE;
+  virtual void OnIncomingCapturedEncodedBitstreamBuffer(
+      const scoped_refptr<media::EncodedBitstreamBuffer>& buffer,
+      size_t data_size,
+      base::Time timestamp) OVERRIDE;
   virtual void OnError() OVERRIDE;
   virtual void OnFrameInfo(
       const media::VideoCaptureCapability& info) OVERRIDE;
+  virtual void OnEncodedFrameInfo(
+      const media::VideoEncodingParameters& info) OVERRIDE;
+  virtual void OnBitstreamConfigChanged(
+      const media::RuntimeVideoEncodingParameters& params) OVERRIDE;
 
   // Reserve a media::VideoFrame in I420 format from a buffer pool.
   static scoped_refptr<media::VideoFrame> ReserveI420VideoFrame(
       VideoCaptureBufferPool* buffer_pool, const gfx::Size& size);
 
+  // Reserve a media::EncodedBitstreaBuffer from a buffer pool.
+  static scoped_refptr<media::EncodedBitstreamBuffer>
+      ReserveEncodedBitstreamBuffer(VideoCaptureBufferPool* buffer_pool);
+
  protected:
   virtual ~VideoCaptureController();
 
  private:
   friend class base::RefCountedThreadSafe<VideoCaptureController>;
 
   struct ControllerClient;
   typedef std::list<ControllerClient*> ControllerClients;
 
   // Callback when manager has stopped device.
   void OnDeviceStopped();
 
   // Worker functions on IO thread.
-  void DoIncomingCapturedFrameOnIOThread(
-      const scoped_refptr<media::VideoFrame>& captured_frame,
+  void DoIncomingCapturedVideoFrameOnIOThread(
+      const scoped_refptr<media::VideoFrame>& frame,
       base::Time timestamp);
-  void DoFrameInfoOnIOThread();
+  void DoIncomingCapturedEncodedBitstreamBufferOnIOThread(
+      const scoped_refptr<media::EncodedBitstreamBuffer>& buffer,
+      size_t data_size,
+      base::Time timestamp);
+  void DoIncomingCapturedSharedMemoryOnIOThread(
+      base::SharedMemoryHandle reserved_handle,
+      size_t data_size,
+      base::Time timestamp);
+  void DoFrameInfoOnIOThread(bool encoded);
+  void DoBitstreamConfigChangedOnIOThread(
+      const media::RuntimeVideoEncodingParameters& params);
   void DoErrorOnIOThread();
   void DoDeviceStoppedOnIOThread();
 
   // Send frame info and init buffers to |client|.
   void SendFrameInfoAndBuffers(ControllerClient* client);
 
   // Find a client of |id| and |handler| in |clients|.
   ControllerClient* FindClient(
       const VideoCaptureControllerID& id,
       VideoCaptureControllerEventHandler* handler,
@@ skipping 20 matching lines @@
 
   // All clients waiting for service.
   ControllerClients pending_clients_;
 
   // The parameter that currently used for the capturing.
   media::VideoCaptureParams current_params_;
 
   // It's modified on caller thread, assuming there is only one OnFrameInfo()
   // call per StartCapture().
   media::VideoCaptureCapability frame_info_;
+  media::VideoEncodingParameters encoded_frame_info_;
 
   // Chopped pixels in width/height in case video capture device has odd numbers
   // for width/height.
   int chopped_width_;
   int chopped_height_;
 
   // It's accessed only on IO thread.
   bool frame_info_available_;
+  bool encoded_frame_info_available_;
 
   VideoCaptureManager* video_capture_manager_;
 
   bool device_in_use_;
   VideoCaptureState state_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(VideoCaptureController);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_MEDIA_VIDEO_CAPTURE_CONTROLLER_H_