Consolidate duplicated frame / capability structures in video_capture_types.h

content/browser/renderer_host/media/video_capture_controller.cc

 // 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.
 
 #include "content/browser/renderer_host/media/video_capture_controller.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
@@ skipping 86 matching lines @@
 
 void VideoCaptureController::StartCapture(
     const VideoCaptureControllerID& id,
     VideoCaptureControllerEventHandler* event_handler,
     base::ProcessHandle render_process,
     const media::VideoCaptureParams& params) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DVLOG(1) << "VideoCaptureController::StartCapture, id " << id.device_id
            << ", (" << params.width
            << ", " << params.height
-           << ", " << params.frame_per_second
+           << ", " << params.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;
   }
 
   // Do nothing if this client has called StartCapture before.
@@ skipping 179 matching lines @@
   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) {
-    case media::VideoCaptureCapability::kColorUnknown:  // Color format not set.
+    case media::PIXEL_FORMAT_UNKNOWN:  // Color format not set.
       break;
-    case media::VideoCaptureCapability::kI420:
+    case media::PIXEL_FORMAT_I420:
       DCHECK(!chopped_width_ && !chopped_height_);
       origin_colorspace = libyuv::FOURCC_I420;
       break;
-    case media::VideoCaptureCapability::kYV12:
+    case media::PIXEL_FORMAT_YV12:
       DCHECK(!chopped_width_ && !chopped_height_);
       origin_colorspace = libyuv::FOURCC_YV12;
       break;
-    case media::VideoCaptureCapability::kNV21:
+    case media::PIXEL_FORMAT_NV21:
       DCHECK(!chopped_width_ && !chopped_height_);
       origin_colorspace = libyuv::FOURCC_NV12;
       break;
-    case media::VideoCaptureCapability::kYUY2:
+    case media::PIXEL_FORMAT_YUY2:
       DCHECK(!chopped_width_ && !chopped_height_);
       origin_colorspace = libyuv::FOURCC_YUY2;
       break;
-    case media::VideoCaptureCapability::kRGB24:
+    case media::PIXEL_FORMAT_RGB24:
       origin_colorspace = libyuv::FOURCC_RAW;
       break;
-    case media::VideoCaptureCapability::kARGB:
+    case media::PIXEL_FORMAT_ARGB:
       origin_colorspace = libyuv::FOURCC_ARGB;
       break;
-    case media::VideoCaptureCapability::kMJPEG:
+    case media::PIXEL_FORMAT_MJPEG:
       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::VideoCaptureCapability::kRGB24) {
+  if (frame_info_.color == 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 * (frame_info_.width + chopped_width_);
     const uint8* rgb_src =
         data + 3 * (frame_info_.width + chopped_width_) *
                    (frame_info_.height - 1 + chopped_height_);
@@ skipping 34 matching lines @@
                  timestamp));
 }
 #else
 void VideoCaptureController::OnIncomingCapturedFrame(
     const uint8* data,
     int length,
     base::Time timestamp,
     int rotation,
     bool flip_vert,
     bool flip_horiz) {
-  DCHECK(frame_info_.color == media::VideoCaptureCapability::kI420 ||
-         frame_info_.color == media::VideoCaptureCapability::kYV12 ||
+  DCHECK(frame_info_.color == media::PIXEL_FORMAT_I420 ||
+         frame_info_.color == media::PIXEL_FORMAT_YV12 ||
          (rotation == 0 && !flip_vert && !flip_horiz));
 
   TRACE_EVENT0("video", "VideoCaptureController::OnIncomingCapturedFrame");
 
   scoped_refptr<media::VideoFrame> dst;
   {
     base::AutoLock lock(buffer_pool_lock_);
     if (!buffer_pool_.get())
       return;
     dst = buffer_pool_->ReserveI420VideoFrame(gfx::Size(frame_info_.width,
                                                         frame_info_.height),
                                               rotation);
   }
 
   if (!dst.get())
     return;
 
   uint8* yplane = dst->data(media::VideoFrame::kYPlane);
   uint8* uplane = dst->data(media::VideoFrame::kUPlane);
   uint8* vplane = dst->data(media::VideoFrame::kVPlane);
 
   // Do color conversion from the camera format to I420.
   switch (frame_info_.color) {
-    case media::VideoCaptureCapability::kColorUnknown:  // Color format not set.
+    case media::PIXEL_FORMAT_UNKNOWN:  // Color format not set.
       break;
-    case media::VideoCaptureCapability::kI420:
+    case media::PIXEL_FORMAT_I420:
       DCHECK(!chopped_width_ && !chopped_height_);
       RotatePackedYV12Frame(
           data, yplane, uplane, vplane, frame_info_.width, frame_info_.height,
           rotation, flip_vert, flip_horiz);
       break;
-    case media::VideoCaptureCapability::kYV12:
+    case media::PIXEL_FORMAT_YV12:
       DCHECK(!chopped_width_ && !chopped_height_);
       RotatePackedYV12Frame(
           data, yplane, vplane, uplane, frame_info_.width, frame_info_.height,
           rotation, flip_vert, flip_horiz);
       break;
-    case media::VideoCaptureCapability::kNV21:
+    case media::PIXEL_FORMAT_NV21:
       DCHECK(!chopped_width_ && !chopped_height_);
       media::ConvertNV21ToYUV(data, yplane, uplane, vplane, frame_info_.width,
                               frame_info_.height);
       break;
-    case media::VideoCaptureCapability::kYUY2:
+    case media::PIXEL_FORMAT_YUY2:
       DCHECK(!chopped_width_ && !chopped_height_);
       if (frame_info_.width * frame_info_.height * 2 != length) {
         // If |length| of |data| does not match the expected width and height
         // we can't convert the frame to I420. YUY2 is 2 bytes per pixel.
         break;
       }
+
       media::ConvertYUY2ToYUV(data, yplane, uplane, vplane, frame_info_.width,
                               frame_info_.height);
       break;
-    case media::VideoCaptureCapability::kRGB24: {
+    case media::PIXEL_FORMAT_RGB24: {
       int ystride = frame_info_.width;
       int uvstride = frame_info_.width / 2;
       int rgb_stride = 3 * (frame_info_.width + chopped_width_);
       const uint8* rgb_src = data;
       media::ConvertRGB24ToYUV(rgb_src, yplane, uplane, vplane,
                                frame_info_.width, frame_info_.height,
                                rgb_stride, ystride, uvstride);
       break;
     }
-    case media::VideoCaptureCapability::kARGB:
+    case media::PIXEL_FORMAT_ARGB:
       media::ConvertRGB32ToYUV(data, yplane, uplane, vplane, frame_info_.width,
                                frame_info_.height,
                                (frame_info_.width + chopped_width_) * 4,
                                frame_info_.width, frame_info_.width / 2);
       break;
     default:
       NOTREACHED();
   }
 
   BrowserThread::PostTask(BrowserThread::IO,
@@ skipping 366 matching lines @@
     controller_clients_.push_back((*client_it));
     pending_clients_.erase(client_it++);
   }
   // Request the manager to start the actual capture.
   video_capture_manager_->Start(current_params_, this);
   state_ = VIDEO_CAPTURE_STATE_STARTED;
   device_in_use_ = true;
 }
 
 }  // namespace content