Reorganize media::VideoCapture* types

content/browser/renderer_host/media/video_capture_controller.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // found in the LICENSE file.
 
 #include "content/browser/renderer_host/media/video_capture_controller.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/stl_util.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "media/base/yuv_convert.h"
 
 #if !defined(AVOID_LIBYUV_FOR_ANDROID_WEBVIEW)
 #include "third_party/libyuv/include/libyuv.h"
 #endif
 
-using media::VideoCaptureCapability;
+using media::VideoCaptureFormat;
 
 namespace content {
 
 namespace {
 
 // The number of buffers that VideoCaptureBufferPool should allocate.
 const int kNoOfBuffers = 3;
 
 class PoolBuffer : public media::VideoCaptureDevice::Client::Buffer {
  public:
@@ skipping 72 matching lines @@
   // VideoCaptureDevice::Client implementation.
   virtual scoped_refptr<Buffer> ReserveOutputBuffer(
       media::VideoFrame::Format format,
       const gfx::Size& size) OVERRIDE;
   virtual void OnIncomingCapturedFrame(const uint8* data,
                                        int length,
                                        base::Time timestamp,
                                        int rotation,
                                        bool flip_vert,
                                        bool flip_horiz,
-                                       const VideoCaptureCapability& frame_info)
+                                       const VideoCaptureFormat& frame_format)
       OVERRIDE;
   virtual void OnIncomingCapturedBuffer(const scoped_refptr<Buffer>& buffer,
                                         media::VideoFrame::Format format,
                                         const gfx::Size& dimensions,
                                         base::Time timestamp,
                                         int frame_rate) OVERRIDE;
   virtual void OnError() OVERRIDE;
 
  private:
   scoped_refptr<Buffer> DoReserveOutputBuffer(media::VideoFrame::Format format,
@@ skipping 34 matching lines @@
   return result.Pass();
 }
 
 void VideoCaptureController::AddClient(
     const VideoCaptureControllerID& id,
     VideoCaptureControllerEventHandler* event_handler,
     base::ProcessHandle render_process,
     const media::VideoCaptureParams& params) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DVLOG(1) << "VideoCaptureController::AddClient, id " << id.device_id
-           << ", (" << params.requested_format.width
-           << ", " << params.requested_format.height
+           << ", " << params.requested_format.frame_size.ToString()
            << ", " << params.requested_format.frame_rate
            << ", " << params.session_id
            << ")";
 
   // Signal error in case device is already in error state.
   if (state_ == VIDEO_CAPTURE_STATE_ERROR) {
     event_handler->OnError(id);
     return;
   }
 
@@ skipping 74 matching lines @@
   return DoReserveOutputBuffer(format, size, 0);
 }
 
 void VideoCaptureController::VideoCaptureDeviceClient::OnIncomingCapturedFrame(
     const uint8* data,
     int length,
     base::Time timestamp,
     int rotation,
     bool flip_vert,
     bool flip_horiz,
-    const VideoCaptureCapability& frame_info) {
+    const VideoCaptureFormat& frame_format) {
   TRACE_EVENT0("video", "VideoCaptureController::OnIncomingCapturedFrame");
 
-  if (!frame_info.IsValid())
+  if (!frame_format.IsValid())
     return;
 
   // Chopped pixels in width/height in case video capture device has odd
   // numbers for width/height.
   int chopped_width = 0;
   int chopped_height = 0;
-  int new_width = frame_info.width;
-  int new_height = frame_info.height;
+  int new_width = frame_format.frame_size.width();
+  int new_height = frame_format.frame_size.height();
 
-  if (frame_info.width & 1) {
+  if (new_width & 1) {
     --new_width;
     chopped_width = 1;
   }
-  if (frame_info.height & 1) {
+  if (new_height & 1) {
     --new_height;
     chopped_height = 1;
   }
 
   const gfx::Size dimensions(new_width, new_height);
   scoped_refptr<Buffer> buffer =
       DoReserveOutputBuffer(media::VideoFrame::I420, dimensions, rotation);
 
   if (!buffer)
     return;
@@ skipping 20 matching lines @@
   // new_vertical_flip = horizontal_flip XOR vertical_flip
   int new_rotation_angle = (rotation + 180 * flip_vert) % 360;
   libyuv::RotationMode rotation_mode = libyuv::kRotate0;
   if (new_rotation_angle == 90)
     rotation_mode = libyuv::kRotate90;
   else if (new_rotation_angle == 180)
     rotation_mode = libyuv::kRotate180;
   else if (new_rotation_angle == 270)
     rotation_mode = libyuv::kRotate270;
 
-  switch (frame_info.color) {
+  switch (frame_format.pixel_format) {
     case media::PIXEL_FORMAT_UNKNOWN:  // Color format not set.
       break;
     case media::PIXEL_FORMAT_I420:
       DCHECK(!chopped_width && !chopped_height);
       origin_colorspace = libyuv::FOURCC_I420;
       break;
     case media::PIXEL_FORMAT_YV12:
       DCHECK(!chopped_width && !chopped_height);
       origin_colorspace = libyuv::FOURCC_YV12;
       break;
@@ skipping 19 matching lines @@
       origin_colorspace = libyuv::FOURCC_MJPG;
       break;
     default:
       NOTREACHED();
   }
 
   int need_convert_rgb24_on_win = false;
 #if defined(OS_WIN)
   // kRGB24 on Windows start at the bottom line and has a negative stride. This
   // is not supported by libyuv, so the media API is used instead.
-  if (frame_info.color == media::PIXEL_FORMAT_RGB24) {
+  if (frame_format.pixel_format == media::PIXEL_FORMAT_RGB24) {
     // Rotation and flipping is not supported in kRGB24 and OS_WIN case.
     DCHECK(!rotation && !flip_vert && !flip_horiz);
     need_convert_rgb24_on_win = true;
   }
 #endif
   if (need_convert_rgb24_on_win) {
     int rgb_stride = -3 * (new_width + chopped_width);
     const uint8* rgb_src = data + 3 * (new_width + chopped_width) *
                                       (new_height - 1 + chopped_height);
     media::ConvertRGB24ToYUV(rgb_src,
@@ skipping 49 matching lines @@
   NOTREACHED();
 #endif  // if !defined(AVOID_LIBYUV_FOR_ANDROID_WEBVIEW)
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(
           &VideoCaptureController::DoIncomingCapturedI420BufferOnIOThread,
           controller_,
           buffer,
           dimensions,
-          frame_info.frame_rate,
+          frame_format.frame_rate,
           timestamp));
 }
 
 void VideoCaptureController::VideoCaptureDeviceClient::OnIncomingCapturedBuffer(
     const scoped_refptr<Buffer>& buffer,
     media::VideoFrame::Format format,
     const gfx::Size& dimensions,
     base::Time timestamp,
     int frame_rate) {
   // The capture pipeline expects I420 for now.
@@ skipping 71 matching lines @@
 }
 
 void VideoCaptureController::DoIncomingCapturedI420BufferOnIOThread(
     scoped_refptr<media::VideoCaptureDevice::Client::Buffer> buffer,
     const gfx::Size& dimensions,
     int frame_rate,
     base::Time timestamp) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK_NE(buffer->id(), VideoCaptureBufferPool::kInvalidId);
 
-  media::VideoCaptureFormat frame_format(
-      dimensions.width(),
-      dimensions.height(),
-      frame_rate,
-      media::VariableResolutionVideoCaptureDevice);
+  VideoCaptureFormat frame_format(
+      dimensions, frame_rate, media::PIXEL_FORMAT_I420);
 
   int count = 0;
   if (state_ == VIDEO_CAPTURE_STATE_STARTED) {
     for (ControllerClients::iterator client_it = controller_clients_.begin();
          client_it != controller_clients_.end(); ++client_it) {
       ControllerClient* client = *client_it;
       if (client->session_closed)
         continue;
 
       bool is_new_buffer = client->known_buffers.insert(buffer->id()).second;
@@ skipping 75 matching lines @@
   }
   return NULL;
 }
 
 int VideoCaptureController::GetClientCount() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return controller_clients_.size();
 }
 
 }  // namespace content