Remove deprecated QTKit Video Capture Support

media/capture/video/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/capture/video/mac/video_capture_device_mac.h"
 
 #include <IOKit/IOCFPlugIn.h>
 #include <IOKit/usb/IOUSBLib.h>
 #include <IOKit/usb/USBSpec.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/mac/scoped_ioobject.h"
 #include "base/mac/scoped_ioplugininterface.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #import "media/base/mac/avfoundation_glue.h"
 #include "media/base/timestamp_constants.h"
 #import "media/capture/video/mac/platform_video_capturing_mac.h"
 #import "media/capture/video/mac/video_capture_device_avfoundation_mac.h"
-#import "media/capture/video/mac/video_capture_device_qtkit_mac.h"
 #include "ui/gfx/geometry/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 11 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,
-};
-
-// 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
 // CS_INTERFACE: Sec. A.4 "Video Class-Specific Descriptor Types".
 const int kVcCsInterface = 0x24;
 // VC_PROCESSING_UNIT: Sec. A.5 "Video Class-Specific VC Interface Descriptor
 // Subtypes".
 const int kVcProcessingUnit = 0x5;
 // SET_CUR: Sec. A.8 "Video Class-Specific Request Codes".
 const int kVcRequestCodeSetCur = 0x1;
 // PU_POWER_LINE_FREQUENCY_CONTROL: Sec. A.9.5 "Processing Unit Control
 // Selectors".
 const int kPuPowerLineFrequencyControl = 0x5;
 // Sec. 4.2.2.3.5 Power Line Frequency Control.
 const int k50Hz = 1;
 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;
 
-static void GetBestMatchSupportedResolution(gfx::Size* resolution) {
-  int min_diff = std::numeric_limits<int32_t>::max();
-  const int desired_area = resolution->GetArea();
-  for (size_t i = 0; i < arraysize(kWellSupportedResolutions); ++i) {
-    const int area = kWellSupportedResolutions[i]->width *
-                     kWellSupportedResolutions[i]->height;
-    const int diff = std::abs(desired_area - area);
-    if (diff < min_diff) {
-      min_diff = diff;
-      resolution->SetSize(kWellSupportedResolutions[i]->width,
-                          kWellSupportedResolutions[i]->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 plugin, i.e. a user-side controller to manipulate USB device.
   IOCFPlugInInterface** plugin;
@@ skipping 211 matching lines @@
   const size_t vid_location = unique_id_.size() - 2 * kVidPidSize;
   std::string id_vendor = unique_id_.substr(vid_location, kVidPidSize);
   const size_t pid_location = unique_id_.size() - kVidPidSize;
   std::string id_product = unique_id_.substr(pid_location, kVidPidSize);
 
   return id_vendor + ":" + id_product;
 }
 
 VideoCaptureDeviceMac::VideoCaptureDeviceMac(const Name& device_name)
     : device_name_(device_name),
-      tried_to_square_pixels_(false),
       task_runner_(base::ThreadTaskRunnerHandle::Get()),
       state_(kNotInitialized),
       capture_device_(nil),
       first_timestamp_(media::kNoTimestamp()),
       weak_factory_(this) {
-  // Avoid reconfiguring AVFoundation or blacklisted devices.
-  final_resolution_selected_ = AVFoundationGlue::IsAVFoundationSupported() ||
-                               device_name.is_blacklisted();
 }
 
 VideoCaptureDeviceMac::~VideoCaptureDeviceMac() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   [capture_device_ release];
 }
 
 void VideoCaptureDeviceMac::AllocateAndStart(
     const VideoCaptureParams& params,
     scoped_ptr<VideoCaptureDevice::Client> client) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   if (state_ != kIdle) {
     return;
   }
 
-  // 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(&resolution);
-
   client_ = std::move(client);
   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(FROM_HERE, "Could not open capture device.");
     return;
   }
 
-  capture_format_.frame_size = resolution;
+  capture_format_.frame_size = params.requested_format.frame_size;
   capture_format_.frame_rate =
       std::max(kMinFrameRate,
                std::min(params.requested_format.frame_rate, kMaxFrameRate));
-  // Leave the pixel format selection to AVFoundation/QTKit. The pixel format
+  // Leave the pixel format selection to AVFoundation. The pixel format
   // will be passed to |ReceiveFrame|.
   capture_format_.pixel_format = PIXEL_FORMAT_UNKNOWN;
 
-  // 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() ||
-      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);
     std::string model_id = device_model.substr(kVidPidSize + 1);
     int vendor_id_as_int, model_id_as_int;
     if (base::HexStringToInt(base::StringPiece(vendor_id), &vendor_id_as_int) &&
@@ skipping 12 matching lines @@
 }
 
 void VideoCaptureDeviceMac::StopAndDeAllocate() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(state_ == kCapturing || state_ == kError) << state_;
 
   [capture_device_ setCaptureDevice:nil];
   [capture_device_ setFrameReceiver:nil];
   client_.reset();
   state_ = kIdle;
-  tried_to_square_pixels_ = false;
 }
 
 bool VideoCaptureDeviceMac::Init(
     VideoCaptureDevice::Name::CaptureApiType capture_api_type) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kNotInitialized);
 
   if (capture_api_type == Name::AVFOUNDATION) {
     capture_device_ =
         [[VideoCaptureDeviceAVFoundation alloc] initWithFrameReceiver:this];
-  } else {
-    capture_device_ =
-        [[VideoCaptureDeviceQTKit alloc] initWithFrameReceiver:this];
   }
 
   if (!capture_device_)
     return false;
 
   state_ = kIdle;
   return true;
 }
 
 void VideoCaptureDeviceMac::ReceiveFrame(const uint8_t* video_frame,
                                          int video_frame_length,
                                          const VideoCaptureFormat& frame_format,
                                          int aspect_numerator,
                                          int aspect_denominator,
                                          base::TimeDelta timestamp) {
   // 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) {
-      // 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);
-    }
-
-    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();
-      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;
-      capture_format_.frame_size.SetSize(new_width, new_height);
-      tried_to_square_pixels_ = true;
-    }
-
-    if (capture_format_.frame_size == frame_format.frame_size) {
-      final_resolution_selected_ = true;
-    } else {
-      UpdateCaptureResolution();
-      // Let the resolution update sink through QTKit and wait for next frame.
-      return;
-    }
-  }
-
-  // QTKit capture source can change resolution if someone else reconfigures the
-  // camera, and that is fine: http://crbug.com/353620. In AVFoundation, this
-  // should not happen, it should resize internally.
-  if (!AVFoundationGlue::IsAVFoundationSupported()) {
-    capture_format_.frame_size = frame_format.frame_size;
-  } else if (capture_format_.frame_size != frame_format.frame_size) {
+  // controlled by AVFoundation.
+  if (capture_format_.frame_size != frame_format.frame_size) {
     ReceiveError(FROM_HERE,
                  "Captured resolution " + frame_format.frame_size.ToString() +
                      ", and expected " + capture_format_.frame_size.ToString());
     return;
   }
 
   base::TimeTicks aligned_timestamp;
   if (timestamp == media::kNoTimestamp()) {
     aligned_timestamp = base::TimeTicks::Now();
   } else {
@@ skipping 33 matching lines @@
   if (![capture_device_ setCaptureHeight:capture_format_.frame_size.height()
                                    width:capture_format_.frame_size.width()
                                frameRate:capture_format_.frame_rate]) {
     ReceiveError(FROM_HERE, "Could not configure capture device.");
     return false;
   }
   return true;
 }
 
 }  // namespace media