Mac VideoCapture: Support for Blackmagic DeckLink device & capabilities enumeration, using SDK.

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/base/mac/avfoundation_glue.h"
 #import "media/video/capture/mac/video_capture_device_avfoundation_mac.h"
 #include "media/video/capture/mac/video_capture_device_mac.h"
+#import "media/video/capture/mac/video_capture_device_decklink_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 {
@@ skipping 124 matching lines @@
                                  options:NSCaseInsensitiveSearch].length != 0) {
             DVLOG(1) << "Enumerated blacklisted " << [device_name UTF8String];
             VideoCaptureDevice::Name name(
                 "QTKit " + std::string([device_name UTF8String]),
                 [key UTF8String], VideoCaptureDevice::Name::QTKIT);
             device_names->push_back(name);
           }
         }
       }
     }
+
+    // Also retrieve Blackmagic devices, if present, via DeckLink SDK API.
+    VideoCaptureDeviceDeckLinkMac::EnumerateDevices(device_names);
   } else {
     // We should not enumerate QTKit devices in Device Thread;
     NOTREACHED();
   }
 }
 
 void VideoCaptureDeviceFactoryMac::EnumerateDeviceNames(const base::Callback<
     void(scoped_ptr<media::VideoCaptureDevice::Names>)>& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (AVFoundationGlue::IsAVFoundationSupported()) {
     scoped_ptr<VideoCaptureDevice::Names> device_names(
         new VideoCaptureDevice::Names());
     GetDeviceNames(device_names.get());
     callback.Run(device_names.Pass());
   } else {
     DVLOG(1) << "Enumerating video capture devices using QTKit";
     base::PostTaskAndReplyWithResult(
         ui_task_runner_.get(),
         FROM_HERE,
         base::Bind(&EnumerateDevicesUsingQTKit),
         base::Bind(&RunDevicesEnumeratedCallback, callback));
   }
 }
 
 void VideoCaptureDeviceFactoryMac::GetDeviceSupportedFormats(
     const VideoCaptureDevice::Name& device,
     VideoCaptureFormats* supported_formats) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (device.capture_api_type() == VideoCaptureDevice::Name::AVFOUNDATION) {
+  switch (device.capture_api_type()) {
+  case VideoCaptureDevice::Name::AVFOUNDATION:
     DVLOG(1) << "Enumerating video capture capabilities, AVFoundation";
     [VideoCaptureDeviceAVFoundation getDevice:device
                              supportedFormats:supported_formats];
-  } else {
+    break;
+  case VideoCaptureDevice::Name::QTKIT:
     // 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;
         }
       }
     }
+    break;
+  case VideoCaptureDevice::Name::DECKLINK:
+    DVLOG(1) << "Enumerating video capture capabilities " << device.name();
+    VideoCaptureDeviceDeckLinkMac::EnumerateDeviceCapabilities(
+        device, supported_formats);
+    break;
+  default:
+    NOTREACHED();
   }
 }
 
 }  // namespace media