Reland: Reorganize media::VideoCapture* types

media/video/capture/mac/video_capture_device_mac.mm

 // 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 "media/video/capture/mac/video_capture_device_mac.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/time/time.h"
@@ skipping 116 matching lines @@
       weak_this_(weak_factory_.GetWeakPtr()),
       capture_device_(nil) {
 }
 
 VideoCaptureDeviceMac::~VideoCaptureDeviceMac() {
   DCHECK_EQ(loop_proxy_, base::MessageLoopProxy::current());
   [capture_device_ release];
 }
 
 void VideoCaptureDeviceMac::AllocateAndStart(
-    const VideoCaptureCapability& capture_format,
+    const VideoCaptureParams& params,
     scoped_ptr<VideoCaptureDevice::Client> client) {
   DCHECK_EQ(loop_proxy_, base::MessageLoopProxy::current());
   if (state_ != kIdle) {
     return;
   }
-  int width = capture_format.width;
-  int height = capture_format.height;
-  int frame_rate = capture_format.frame_rate;
+  int width = params.requested_format.frame_size.width();
+  int height = params.requested_format.frame_size.height();
+  int frame_rate = params.requested_format.frame_rate;
 
   // The OS API can scale captured frame to any size requested, which would lead
   // to undesired aspect ratio change. Try to open the camera with a natively
   // supported format and let the client crop/pad the captured frames.
   GetBestMatchSupportedResolution(&width, &height);
 
   client_ = client.Pass();
   NSString* deviceId =
       [NSString stringWithUTF8String:device_name_.id().c_str()];
 
   [capture_device_ setFrameReceiver:this];
 
   if (![capture_device_ setCaptureDevice:deviceId]) {
     SetErrorState("Could not open capture device.");
     return;
   }
   if (frame_rate < kMinFrameRate)
     frame_rate = kMinFrameRate;
   else if (frame_rate > kMaxFrameRate)
     frame_rate = kMaxFrameRate;
 
-  current_settings_.color = PIXEL_FORMAT_UYVY;
-  current_settings_.width = width;
-  current_settings_.height = height;
-  current_settings_.frame_rate = frame_rate;
+  capture_format_.frame_size.SetSize(width, height);
+  capture_format_.frame_rate = frame_rate;
+  capture_format_.pixel_format = PIXEL_FORMAT_UYVY;
 
   if (width <= kVGA.width || height <= kVGA.height) {
     // If the resolution is VGA or QVGA, set the capture resolution to the
     // target size. Essentially all supported cameras offer at least VGA.
     if (!UpdateCaptureResolution())
       return;
   }
   // For higher resolutions, we first open at the default resolution to find
   // out if the request is larger than the camera's native resolution.
 
@@ skipping 38 matching lines @@
   if (!capture_device_)
     return false;
 
   state_ = kIdle;
   return true;
 }
 
 void VideoCaptureDeviceMac::ReceiveFrame(
     const uint8* video_frame,
     int video_frame_length,
-    const VideoCaptureCapability& frame_info,
+    const VideoCaptureFormat& frame_format,
     int aspect_numerator,
     int aspect_denominator) {
   // This method is safe to call from a device capture thread,
   // i.e. any thread controlled by QTKit.
 
   if (!sent_frame_info_) {
     // Final resolution has not yet been selected.
-    if (current_settings_.width > kVGA.width ||
-        current_settings_.height > kVGA.height) {
+    if (capture_format_.frame_size.width() > kVGA.width ||
+        capture_format_.frame_size.height() > kVGA.height) {
       // We are requesting HD.  Make sure that the picture is good, otherwise
       // drop down to VGA.
       bool change_to_vga = false;
-      if (frame_info.width < current_settings_.width ||
-          frame_info.height < current_settings_.height) {
+      if (frame_format.frame_size.width() <
+          capture_format_.frame_size.width() ||
+          frame_format.frame_size.height() <
+          capture_format_.frame_size.height()) {
         // These are the default capture settings, not yet configured to match
-        // |current_settings_|.
-        DCHECK(frame_info.frame_rate == 0);
+        // |capture_format_|.
+        DCHECK(frame_format.frame_rate == 0);
         DVLOG(1) << "Switching to VGA because the default resolution is " <<
-            frame_info.width << "x" << frame_info.height;
+            frame_format.frame_size.ToString();
         change_to_vga = true;
       }
 
-      if (frame_info.width == current_settings_.width &&
-          frame_info.height == current_settings_.height &&
+      if (capture_format_.frame_size == frame_format.frame_size &&
           aspect_numerator != aspect_denominator) {
         DVLOG(1) << "Switching to VGA because HD has nonsquare pixel " <<
             "aspect ratio " << aspect_numerator << ":" << aspect_denominator;
         change_to_vga = true;
       }
 
       if (change_to_vga) {
-        current_settings_.width = kVGA.width;
-        current_settings_.height = kVGA.height;
+        capture_format_.frame_size.SetSize(kVGA.width, kVGA.height);
       }
     }
 
-    if (current_settings_.width == frame_info.width &&
-        current_settings_.height == frame_info.height &&
+    if (capture_format_.frame_size == frame_format.frame_size &&
         !tried_to_square_pixels_ &&
         (aspect_numerator > kMaxPixelAspectRatio * aspect_denominator ||
          aspect_denominator > kMaxPixelAspectRatio * aspect_numerator)) {
       // The requested size results in non-square PAR.
       // Shrink the frame to 1:1 PAR (assuming QTKit selects the same input
       // mode, which is not guaranteed).
-      int new_width = current_settings_.width;
-      int new_height = current_settings_.height;
+      int new_width = capture_format_.frame_size.width();
+      int new_height = capture_format_.frame_size.height();
       if (aspect_numerator < aspect_denominator) {
         new_width = (new_width * aspect_numerator) / aspect_denominator;
       } else {
         new_height = (new_height * aspect_denominator) / aspect_numerator;
       }
-      current_settings_.width = new_width;
-      current_settings_.height = new_height;
+      capture_format_.frame_size.SetSize(new_width, new_height);
       tried_to_square_pixels_ = true;
     }
 
-    if (current_settings_.width == frame_info.width &&
-        current_settings_.height == frame_info.height) {
+    if (capture_format_.frame_size == frame_format.frame_size) {
       sent_frame_info_ = true;
     } else {
       UpdateCaptureResolution();
       // OnFrameInfo has not yet been called.  OnIncomingCapturedFrame must
       // not be called until after OnFrameInfo, so we return early.
       return;
     }
   }
 
-  DCHECK(current_settings_.width == frame_info.width &&
-         current_settings_.height == frame_info.height);
+  DCHECK_EQ(capture_format_.frame_size.width(),
+            frame_format.frame_size.width());
+  DCHECK_EQ(capture_format_.frame_size.height(),
+            frame_format.frame_size.height());
 
   client_->OnIncomingCapturedFrame(video_frame,
                                    video_frame_length,
                                    base::Time::Now(),
                                    0,
                                    false,
                                    false,
-                                   current_settings_);
+                                   capture_format_);
 }
 
 void VideoCaptureDeviceMac::ReceiveError(const std::string& reason) {
   loop_proxy_->PostTask(FROM_HERE,
       base::Bind(&VideoCaptureDeviceMac::SetErrorState, weak_this_,
           reason));
 }
 
 void VideoCaptureDeviceMac::SetErrorState(const std::string& reason) {
   DCHECK_EQ(loop_proxy_, base::MessageLoopProxy::current());
   DLOG(ERROR) << reason;
   state_ = kError;
   client_->OnError();
 }
 
 bool VideoCaptureDeviceMac::UpdateCaptureResolution() {
- if (![capture_device_ setCaptureHeight:current_settings_.height
-                                  width:current_settings_.width
-                              frameRate:current_settings_.frame_rate]) {
+ if (![capture_device_ setCaptureHeight:capture_format_.frame_size.height()
+                                  width:capture_format_.frame_size.width()
+                              frameRate:capture_format_.frame_rate]) {
    ReceiveError("Could not configure capture device.");
    return false;
  }
  return true;
 }
 
 } // namespace media