Mac AVFoundation: use QTKit for cameras not working with AVF (Blackmagic).

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/message_loop/message_loop_proxy.h"
 #include "base/time/time.h"
 #import "media/video/capture/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"
 
 namespace media {
 
 const int kMinFrameRate = 1;
 const int kMaxFrameRate = 30;
 
-// In QT device identifiers, the USB VID and PID are stored in 4 bytes each.
+// In device identifiers, the USB VID and PID are stored in 4 bytes each.
 const size_t kVidPidSize = 4;
 
-struct Resolution {
-  int width;
-  int height;
-};
+// Some devices are not correctly supported in AVFoundation, f.i. Blackmagic,
+// see http://crbug.com/347371. The devices are identified by USB Vendor ID and
+// by a characteristic substring of the name, usually the vendor's name.
+const struct NameAndVid {
+  const char* vid;
+  const char* name;
+} kBlacklistedCameras[] = { { "a82c", "Blackmagic" } };
 
-const Resolution kQVGA = { 320, 240 },
-                 kVGA = { 640, 480 },
-                 kHD = { 1280, 720 };
+const struct Resolution {
+  const int width;
+  const int height;
+} kQVGA = { 320, 240 },
+  kVGA = { 640, 480 },
+  kHD = { 1280, 720 };
 
-const Resolution* const kWellSupportedResolutions[] = {
-   &kQVGA,
-   &kVGA,
-   &kHD,
+const struct Resolution* const kWellSupportedResolutions[] = {
+    &kQVGA,

[Robert Sesek, 2014/04/08 20:16:05]

nit: should only be indented 2 spaces

[mcasas, 2014/04/09 10:41:29]

Done.

+    &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
+// shape. This constant ensures that we don't take this risk if the current
 // aspect ratio is tolerable.
 const float kMaxPixelAspectRatio = 1.15;
 
 // 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;
 }
 
 void VideoCaptureDevice::GetDeviceNames(Names* device_names) {
   // Loop through all available devices and add to |device_names|.
   device_names->clear();
 
   NSDictionary* capture_devices;
+  bool is_blacklisted_device = FALSE;

[Robert Sesek, 2014/04/08 20:16:05]

nit: lowercase false

[mcasas, 2014/04/09 10:41:29]

Done.

   if (AVFoundationGlue::IsAVFoundationSupported()) {
     DVLOG(1) << "Enumerating video capture devices using AVFoundation";
     capture_devices = [VideoCaptureDeviceAVFoundation deviceNames];
+    std::string device_vid;
+    for (NSString* key in capture_devices) {
+      Name name([[capture_devices valueForKey:key] UTF8String],
+                [key UTF8String], Name::AVFOUNDATION);

[Robert Sesek, 2014/04/08 20:16:05]

nit: only indent 4 spaces from the previous line

[mcasas, 2014/04/09 10:41:29]

Done.

+      device_names->push_back(name);

[Robert Sesek, 2014/04/08 20:16:05]

Why include blacklisted devices in the list?

[mcasas, 2014/04/09 10:41:29]

They might still work with AVFoundation in some
cases, i.e. Blackmagic works in 480p, 240p, but 
not in 720p. Do you think it'd cause confusion?
The QTKit ones have "QTKit" prefix.

+      device_vid = name.GetModel().substr(0, kVidPidSize);
+      // Compare the USB VendorID of the device to the blacklisted ones.
+      for (size_t i = 0; i < arraysize(kBlacklistedCameras); ++i) {
+        is_blacklisted_device |= (device_vid == kBlacklistedCameras[i].vid);
+        if (is_blacklisted_device)
+          continue;
+      }
+    }
   } else {
     DVLOG(1) << "Enumerating video capture devices using QTKit";
     capture_devices = [VideoCaptureDeviceQTKit deviceNames];
+    for (NSString* key in capture_devices) {
+      Name name([[capture_devices valueForKey:key] UTF8String],
+                [key UTF8String], Name::QTKIT);

[Robert Sesek, 2014/04/08 20:16:05]

nit: only indent 4 spaces from the previous line

[mcasas, 2014/04/09 10:41:29]

Done.

+      device_names->push_back(name);
+    }
   }
-  for (NSString* key in capture_devices) {
-    Name name([[capture_devices valueForKey:key] UTF8String],
-              [key UTF8String]);
-    device_names->push_back(name);
+
+  if (is_blacklisted_device) {
+    // Walk the QTKit device list and add those devices with a blacklisted name
+    // to the |device_names|, with a "QTKit" prefix to distinguish them from the
+    // AVFoundation ones.
+    capture_devices = [VideoCaptureDeviceQTKit deviceNames];
+    NSString* device_name;
+    for (NSString* key in capture_devices) {
+      device_name = [capture_devices valueForKey:key];
+      for (size_t i = 0; i < arraysize(kBlacklistedCameras); ++i) {
+        if ([device_name rangeOfString:@(kBlacklistedCameras[i].name)
+                               options:NSCaseInsensitiveSearch].length != 0) {
+          DVLOG(1) << "Enumerated blacklisted " << [device_name UTF8String];
+          Name name("QTKit " + std::string([device_name UTF8String]),
+                    [key UTF8String], Name::QTKIT);

[Robert Sesek, 2014/04/08 20:16:05]

nit: indent

[mcasas, 2014/04/09 10:41:29]

Done.

+          device_names->push_back(name);
+        }
+      }
+    }
   }
 }
 
 // static
 void VideoCaptureDevice::GetDeviceSupportedFormats(const Name& device,
     VideoCaptureFormats* formats) {
-  if (AVFoundationGlue::IsAVFoundationSupported()) {
+  if (device.capture_api_type() == Name::AVFOUNDATION) {
     DVLOG(1) << "Enumerating video capture capabilities, AVFoundation";
     [VideoCaptureDeviceAVFoundation getDevice:device
                              supportedFormats:formats];
   } else {
     NOTIMPLEMENTED();
   }
 }
 
 const std::string VideoCaptureDevice::Name::GetModel() const {
   // Both PID and VID are 4 characters.
@@ skipping 113 matching lines @@
   Names device_names;
   GetDeviceNames(&device_names);
   Names::iterator it = device_names.begin();
   for (; it != device_names.end(); ++it) {
     if (it->id() == device_name_.id())
       break;
   }
   if (it == device_names.end())
     return false;
 
-  if (AVFoundationGlue::IsAVFoundationSupported()) {
+  DCHECK_NE(it->capture_api_type(), Name::API_TYPE_UNKNOWN);
+  if (it->capture_api_type() == Name::AVFOUNDATION) {
     capture_device_ =
         [[VideoCaptureDeviceAVFoundation alloc] initWithFrameReceiver:this];
   } else {
     capture_device_ =
         [[VideoCaptureDeviceQTKit alloc] initWithFrameReceiver:this];
   }
 
   if (!capture_device_)
     return false;
 
@@ skipping 101 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