Mac QTKit Video Capture: Force BlackMagic cameras to be opened in HD

media/video/capture/mac/video_capture_device_factory_mac.mm

 // Copyright 2014 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_factory_mac.h"
 
 #import <IOKit/audio/IOAudioTypes.h>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/strings/string_util.h"
 #include "base/task_runner_util.h"
 #import "media/video/capture/mac/avfoundation_glue.h"
 #include "media/video/capture/mac/video_capture_device_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 {
 
 // Some devices are not correctly supported in AVFoundation, f.i. Blackmagic,
 // see http://crbug.com/347371. The devices are identified by a characteristic
 // trailing substring of uniqueId and by (part of) the vendor's name.
+// Blackmagic cameras are known to crash if VGA is requested , see
+// http://crbug.com/396812; for them HD is the only supported resolution.
 const struct NameAndVid {
   const char* unique_id_signature;
   const char* name;
-} kBlacklistedCameras[] = { { "-01FDA82C8A9C", "Blackmagic" } };
+  const int capture_width;
+  const int capture_height;
+  const float capture_frame_rate;
+} kBlacklistedCameras[] = {
+  { "-01FDA82C8A9C", "Blackmagic", 1280, 720, 60.0f } };
 
 static scoped_ptr<media::VideoCaptureDevice::Names>
 EnumerateDevicesUsingQTKit() {
   scoped_ptr<VideoCaptureDevice::Names> device_names(
         new VideoCaptureDevice::Names());
   NSMutableDictionary* capture_devices =
       [[[NSMutableDictionary alloc] init] autorelease];
   [VideoCaptureDeviceQTKit getDeviceNames:capture_devices];
   for (NSString* key in capture_devices) {
     VideoCaptureDevice::Name name(
         [[[capture_devices valueForKey:key] deviceName] UTF8String],
         [key UTF8String], VideoCaptureDevice::Name::QTKIT);
+    for (size_t i = 0; i < arraysize(kBlacklistedCameras); ++i) {
+      if (name.id().find(kBlacklistedCameras[i].name) != std::string::npos) {

[vrk (LEFT CHROMIUM), 2014/08/14 02:50:54]

Does case sensitivity matter?

[mcasas, 2014/08/14 07:36:06]

ATM I've have always seen "Blackmagic" as part of the name, so nothing
hints to the need for case insensitivity. 

As a side note on Blackmagic, if using AVFoundation (beyond the scope
of this CL), name.id() would always return :
 21881B92-C9F3-42BD-B238-01FDA82C8A9C
for all and any Blackmagics plugged in the system, which prevents from
using more than one device from that brand simultaneously! [1] :(


[1] http://forum.blackmagicdesign.com/viewtopic.php?f=11&t=16092

+        DVLOG(2) << "Found blacklisted camera: " << name.id();
+        name.set_is_blacklisted(true);
+        break;
+      }
+    }
     device_names->push_back(name);
   }
   return device_names.Pass();
 }
 
 static void RunDevicesEnumeratedCallback(
     const base::Callback<void(scoped_ptr<media::VideoCaptureDevice::Names>)>&
         callback,
     scoped_ptr<media::VideoCaptureDevice::Names> device_names) {
   callback.Run(device_names.Pass());
@@ skipping 119 matching lines @@
 
 void VideoCaptureDeviceFactoryMac::GetDeviceSupportedFormats(
     const VideoCaptureDevice::Name& device,
     VideoCaptureFormats* supported_formats) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (device.capture_api_type() == VideoCaptureDevice::Name::AVFOUNDATION) {
     DVLOG(1) << "Enumerating video capture capabilities, AVFoundation";
     [VideoCaptureDeviceAVFoundation getDevice:device
                              supportedFormats:supported_formats];
   } else {
-    NOTIMPLEMENTED();
+    // Blacklisted cameras provide their own supported format(s), otherwise no
+    // such information is provided for QTKit.
+    if (device.is_blacklisted()) {
+      for (size_t i = 0; i < arraysize(kBlacklistedCameras); ++i) {
+        if (device.id().find(kBlacklistedCameras[i].name) !=
+            std::string::npos) {
+          supported_formats->push_back(media::VideoCaptureFormat(
+              gfx::Size(kBlacklistedCameras[i].capture_width,
+                        kBlacklistedCameras[i].capture_height),
+              kBlacklistedCameras[i].capture_frame_rate,
+              media::PIXEL_FORMAT_UYVY));
+          break;
+        }
+      }
+    }
   }
 }
 
 }  // namespace media