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 10 matching lines @@
 
 namespace media {
 
 // Mac specific limits for minimum and maximum frame rate.
 const float kMinFrameRate = 1.0f;
 const float kMaxFrameRate = 30.0f;
 
 // In device identifiers, the USB VID and PID are stored in 4 bytes each.
 const size_t kVidPidSize = 4;
 
-const struct Resolution {
-  const int width;
-  const int height;
-} kQVGA = { 320, 240 },
-  kVGA = { 640, 480 },
-  kHD = { 1280, 720 };
-
-const struct Resolution* const kWellSupportedResolutions[] = {
-  &kQVGA,
-  &kVGA,
-  &kHD,
-};
+static const gfx::Size kQVGA(320, 240),

[tommi (sloooow) - chröme, 2014/09/09 20:11:10]

Do these require static initialization? (i.e. code that executes as part of
global initialization)
If so, the cl is going to get reverted after landing (we have perf bots that
catch that and turn red)

[magjed_chromium, 2014/09/10 18:34:21]

Ok, cool. I don't think it's possible to remove the constructors from global
initialization without using C++11 features (list initialization or constexpr),
so I reverted this.

+                       kVGA(640, 480),
+                       kHD(1280, 720);
 
 // Rescaling the image to fix the pixel aspect ratio runs the risk of making
 // the aspect ratio worse, if QTKit selects a new source mode with a different
 // shape. This constant ensures that we don't take this risk if the current
 // aspect ratio is tolerable.
 const float kMaxPixelAspectRatio = 1.15;
 
 // The following constants are extracted from the specification "Universal
 // Serial Bus Device Class Definition for Video Devices", Rev. 1.1 June 1, 2005.
 // http://www.usb.org/developers/devclass_docs/USB_Video_Class_1_1.zip
@@ skipping 12 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) {
-  int min_diff = kint32max;
-  int matched_width = *width;
-  int matched_height = *height;
-  int desired_res_area = *width * *height;
-  for (size_t i = 0; i < arraysize(kWellSupportedResolutions); ++i) {
-    int area = kWellSupportedResolutions[i]->width *
-               kWellSupportedResolutions[i]->height;
-    int diff = std::abs(desired_res_area - area);
-    if (diff < min_diff) {
-      min_diff = diff;
-      matched_width = kWellSupportedResolutions[i]->width;
-      matched_height = 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) {
   // Create a plug-in, i.e. a user-side controller to manipulate USB device.
   IOCFPlugInInterface** plugin;
@@ skipping 234 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.
-  if (!AVFoundationGlue::IsAVFoundationSupported())
-    GetBestMatchSupportedResolution(&width, &height);
+  gfx::Size resolution = params.requested_format.frame_size;
+  if (!AVFoundationGlue::IsAVFoundationSupported()) {
+    // We only care about resolution in this case. Therefore, set fps to 0 and
+    // pixel format to unknown
+    static const VideoCaptureFormat kWellSupportedResolutions[] = {
+        VideoCaptureFormat(kQVGA, 0, PIXEL_FORMAT_UNKNOWN),
+        VideoCaptureFormat(kVGA, 0, PIXEL_FORMAT_UNKNOWN),
+        VideoCaptureFormat(kHD, 0, PIXEL_FORMAT_UNKNOWN)};
+    // Get the most closely matched format using CompareVideoFormat
+    const VideoCaptureFormat& best_match =
+        *std::min_element(
+            kWellSupportedResolutions,
+            kWellSupportedResolutions + arraysize(kWellSupportedResolutions),
+            CompareVideoFormat(
+                VideoCaptureFormat(resolution, 0, PIXEL_FORMAT_UNKNOWN)));
+    resolution = best_match.frame_size;
+  }
 
   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 48 matching lines @@
 void VideoCaptureDeviceMac::ReceiveFrame(
     const uint8* video_frame,
     int video_frame_length,
     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/AVFoundation.
   if (!final_resolution_selected_) {
     DCHECK(!AVFoundationGlue::IsAVFoundationSupported());
-    if (capture_format_.frame_size.width() > kVGA.width ||
-        capture_format_.frame_size.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_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
         // |capture_format_|.
         DCHECK(frame_format.frame_rate == 0);
         DVLOG(1) << "Switching to VGA because the default resolution is " <<
             frame_format.frame_size.ToString();
         change_to_vga = true;
       }
 
       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)
-        capture_format_.frame_size.SetSize(kVGA.width, kVGA.height);
+        capture_format_.frame_size = kVGA;
     }
 
     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 = capture_format_.frame_size.width();
@@ skipping 56 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