Video capture: Refactor GetBestMatchedFormat from Win to OS independent

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 <IOKit/IOCFPlugIn.h>
 #include <IOKit/usb/IOUSBLib.h>
 #include <IOKit/usb/USBSpec.h>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/mac/scoped_ioobject.h"
 #include "base/mac/scoped_ioplugininterface.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #import "media/base/mac/avfoundation_glue.h"
 #import "media/video/capture/mac/platform_video_capturing_mac.h"
 #import "media/video/capture/mac/video_capture_device_avfoundation_mac.h"
 #import "media/video/capture/mac/video_capture_device_qtkit_mac.h"
+#include "ui/gfx/size.h"
 
 @implementation DeviceNameAndTransportType
 
 - (id)initWithName:(NSString*)deviceName transportType:(int32_t)transportType {
   if (self = [super init]) {
     deviceName_.reset([deviceName copy]);
     transportType_ = transportType;
   }
   return self;
 }
@@ skipping 54 matching lines @@
 const int k60Hz = 2;
 const int kPuPowerLineFrequencyControlCommandSize = 1;
 
 // Addition to the IOUSB family of structures, with subtype and unit ID.
 typedef struct IOUSBInterfaceDescriptor {
   IOUSBDescriptorHeader header;
   UInt8 bDescriptorSubType;
   UInt8 bUnitID;
 } IOUSBInterfaceDescriptor;
 
-// TODO(ronghuawu): Replace this with CapabilityList::GetBestMatchedCapability.
-void GetBestMatchSupportedResolution(int* width, int* height) {
+static void GetBestMatchSupportedResolution(gfx::Size* resolution) {
   int min_diff = kint32max;
-  int matched_width = *width;
-  int matched_height = *height;
-  int desired_res_area = *width * *height;
+  const int desired_area = resolution->GetArea();
   for (size_t i = 0; i < arraysize(kWellSupportedResolutions); ++i) {

[mcasas, 2014/10/13 08:18:45]

nit: range-based for loop...? ;)

-    int area = kWellSupportedResolutions[i]->width *
-               kWellSupportedResolutions[i]->height;
-    int diff = std::abs(desired_res_area - area);
+    const int area = kWellSupportedResolutions[i]->width *
+                     kWellSupportedResolutions[i]->height;
+    const int diff = std::abs(desired_area - area);
     if (diff < min_diff) {
       min_diff = diff;
-      matched_width = kWellSupportedResolutions[i]->width;
-      matched_height = kWellSupportedResolutions[i]->height;
+      resolution->SetSize(kWellSupportedResolutions[i]->width,
+                          kWellSupportedResolutions[i]->height);
     }
   }
-  *width = matched_width;
-  *height = matched_height;
 }
 
 // Tries to create a user-side device interface for a given USB device. Returns
 // true if interface was found and passes it back in |device_interface|. The
 // caller should release |device_interface|.
 static bool FindDeviceInterfaceInUsbDevice(
     const int vendor_id,
     const int product_id,
     const io_service_t usb_device,
     IOUSBDeviceInterface*** device_interface) {
@@ skipping 238 matching lines @@
   [capture_device_ release];
 }
 
 void VideoCaptureDeviceMac::AllocateAndStart(
     const VideoCaptureParams& params,
     scoped_ptr<VideoCaptureDevice::Client> client) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   if (state_ != kIdle) {
     return;
   }
-  int width = params.requested_format.frame_size.width();
-  int height = params.requested_format.frame_size.height();
-  float frame_rate = params.requested_format.frame_rate;
 
   // QTKit API can scale captured frame to any size requested, which would lead
   // to undesired aspect ratio changes. Try to open the camera with a known
   // supported format and let the client crop/pad the captured frames.
+  gfx::Size resolution = params.requested_format.frame_size;
   if (!AVFoundationGlue::IsAVFoundationSupported())
-    GetBestMatchSupportedResolution(&width, &height);
+    GetBestMatchSupportedResolution(&resolution);
 
   client_ = client.Pass();
   if (device_name_.capture_api_type() == Name::AVFOUNDATION)
     LogMessage("Using AVFoundation for device: " + device_name_.name());
   else
     LogMessage("Using QTKit for device: " + device_name_.name());
   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;
 
-  capture_format_.frame_size.SetSize(width, height);
-  capture_format_.frame_rate = frame_rate;
+  capture_format_.frame_size = resolution;
+  capture_format_.frame_rate =
+      std::max(kMinFrameRate,
+               std::min(params.requested_format.frame_rate, kMaxFrameRate));
   capture_format_.pixel_format = PIXEL_FORMAT_UYVY;
 
   // QTKit: Set the capture resolution only if this is VGA or smaller, otherwise
   // leave it unconfigured and start capturing: QTKit will produce frames at the
   // native resolution, allowing us to identify cameras whose native resolution
   // is too low for HD. This additional information comes at a cost in startup
   // latency, because the webcam will need to be reopened if its default
   // resolution is not HD or VGA.
   // AVfoundation is configured for all resolutions.
-  if (AVFoundationGlue::IsAVFoundationSupported() || width <= kVGA.width ||
-      height <= kVGA.height) {
+  if (AVFoundationGlue::IsAVFoundationSupported() ||
+      resolution.width() <= kVGA.width || resolution.height() <= kVGA.height) {
     if (!UpdateCaptureResolution())
       return;
   }
 
   // Try setting the power line frequency removal (anti-flicker). The built-in
   // cameras are normally suspended so the configuration must happen right
   // before starting capture and during configuration.
   const std::string& device_model = device_name_.GetModel();
   if (device_model.length() > 2 * kVidPidSize) {
     std::string vendor_id = device_model.substr(0, kVidPidSize);
@@ skipping 150 matching lines @@
   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