Mac Video Capture: Support for Blackmagic DeckLink SDK video capture.

media/video/capture/mac/video_capture_device_decklink_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_decklink_mac.h"
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
+#include "base/synchronization/lock.h"
 #include "base/strings/sys_string_conversions.h"
 #include "third_party/decklink/mac/include/DeckLinkAPI.h"
 
 namespace {
 
 // DeckLink SDK uses ScopedComPtr-style APIs. Chrome ScopedComPtr is only
 // available for Windows builds. This is a verbatim knock-off of the needed
 // parts of base::win::ScopedComPtr<> for ref counting.
 template <class T>
 class ScopedDeckLinkPtr : public scoped_refptr<T> {
- public:
+ private:
   using scoped_refptr<T>::ptr_;
 
+ public:
   T** Receive() {
     DCHECK(!ptr_) << "Object leak. Pointer must be NULL";
     return &ptr_;
   }
 
   void** ReceiveVoid() {
     return reinterpret_cast<void**>(Receive());
   }
 
   void Release() {
     if (ptr_ != NULL) {
       ptr_->Release();
       ptr_ = NULL;
     }
   }
 };
 
+// This class is used to interact directly with DeckLink SDK for video capture.
+// Implements the reference counted interface IUnknown. Has a weak reference to
+// VideoCaptureDeviceDeckLinkMac for sending captured frames, error messages and
+// logs.
+class DeckLinkCaptureDelegate : public IDeckLinkInputCallback {
+ public:
+  DeckLinkCaptureDelegate(const media::VideoCaptureDevice::Name& device_name,
+                          media::VideoCaptureDeviceDeckLinkMac* frame_receiver);
+  virtual ~DeckLinkCaptureDelegate();
+
+  void AllocateAndStart(const media::VideoCaptureParams& params);
+  void StopAndDeAllocate();
+
+  // Remove the VideoCaptureDeviceDeckLinkMac's weak reference.
+  void ResetVideoCaptureDeviceReference();
+
+ private:
+  // IDeckLinkInputCallback interface implementation.
+  virtual HRESULT VideoInputFormatChanged (

[Robert Sesek, 2014/09/24 17:06:14]

nit: extra space before (

[mcasas, 2014/09/24 19:39:56]

Done.

+      BMDVideoInputFormatChangedEvents notification_events,
+      IDeckLinkDisplayMode *new_display_mode,
+      BMDDetectedVideoInputFormatFlags detected_signal_flags) OVERRIDE;
+  virtual HRESULT VideoInputFrameArrived (

[Robert Sesek, 2014/09/24 17:06:14]

same

[mcasas, 2014/09/24 19:39:56]

Done.

+      IDeckLinkVideoInputFrame* video_frame,
+      IDeckLinkAudioInputPacket* audio_packet) OVERRIDE;
+
+  // IUnknown interface implementation.
+  virtual HRESULT QueryInterface (REFIID iid, void** ppv) OVERRIDE;

[Robert Sesek, 2014/09/24 17:06:14]

same

[mcasas, 2014/09/24 19:39:57]

Done.

+  virtual ULONG AddRef() OVERRIDE;
+  virtual ULONG Release() OVERRIDE;
+
+  // Forwarder to VideoCaptureDeviceDeckLinkMac::SendErrorString().
+  void SendErrorString(const std::string& reason);
+
+  // Forwarder to VideoCaptureDeviceDeckLinkMac::SendLogString().
+  void SendLogString(const std::string& message);
+
+  const media::VideoCaptureDevice::Name device_name_;
+
+  // Protects concurrent setting and using of |frame_receiver_|.
+  base::Lock lock_;
+  // Weak reference to the captured frames client, used also for error messages
+  // and logging. Initialized on construction and used until cleared by calling
+  // ResetVideoCaptureDeviceReference().
+  media::VideoCaptureDeviceDeckLinkMac* frame_receiver_;
+
+  // This is used to control the video capturing device input interface.
+  ScopedDeckLinkPtr<IDeckLinkInput> decklink_input_;
+  // |decklink_| represents a physical device attached to the host.
+  ScopedDeckLinkPtr<IDeckLink> decklink_;
+  // Internal counter for IUnknown interface implementation.

[Robert Sesek, 2014/09/24 17:06:14]

Is it really necessary to roll your own reference counting?

[mcasas, 2014/09/24 19:39:56]

The DeckLink SDK forces whoever implements IDeckLinkInputCallback
to be referenced counted using a Com-like syntax, so I'm afraid this
is needed. 

[Robert Sesek, 2014/09/29 21:08:51]

Can you really not find any other way to not use parts of //base to do this?
There's a reason that base::'s implementation is largely in the "subtle"
namespace.

AIUI, the return values of AddRef() and Release() are meant only for testing
purposes. So, for example, they could merely return the result of HasOneRef()
and then you could use the the base refcounting implementation.

[mcasas, 2014/09/30 14:18:49]

I made DeckLinkCaptureDelegate derive from base::RefCountedThreadSafe<>
and use its methods to implement the IUnknown AddRef()/Release(). Please 
double check if that's an improvement.

+  int32_t ref_count_;
+
+  base::ThreadChecker thread_checker_;
+
+  friend class scoped_refptr<DeckLinkCaptureDelegate>;
+
+  DISALLOW_COPY_AND_ASSIGN(DeckLinkCaptureDelegate);
+};
+
+static float GetDisplayModeFrameRate(
+    const ScopedDeckLinkPtr<IDeckLinkDisplayMode>& display_mode) {
+  BMDTimeValue time_value, time_scale;
+  float display_mode_frame_rate = 0.0f;
+  if (display_mode->GetFrameRate(&time_value, &time_scale) == S_OK &&
+      time_value > 0) {
+    display_mode_frame_rate = static_cast<float>(time_scale) / time_value;
+  }
+  // Interlaced formats are going to be marked as double the frame rate,
+  // which follows the general naming convention.
+  if (display_mode->GetFieldDominance() == bmdLowerFieldFirst ||
+      display_mode->GetFieldDominance() == bmdUpperFieldFirst) {
+    display_mode_frame_rate *= 2.0f;
+  }
+  return display_mode_frame_rate;
+}
+
+DeckLinkCaptureDelegate::DeckLinkCaptureDelegate(
+    const media::VideoCaptureDevice::Name& device_name,
+    media::VideoCaptureDeviceDeckLinkMac* frame_receiver)
+    : device_name_(device_name),
+      frame_receiver_(frame_receiver) {
+}
+
+DeckLinkCaptureDelegate::~DeckLinkCaptureDelegate() {}
+
+void DeckLinkCaptureDelegate::AllocateAndStart(
+    const media::VideoCaptureParams& params) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  scoped_refptr<IDeckLinkIterator> decklink_iter(
+      CreateDeckLinkIteratorInstance());
+  DLOG_IF(ERROR, !decklink_iter.get()) << "Error creating DeckLink iterator";
+  if (!decklink_iter.get())
+    return;
+
+  while (decklink_iter->Next(decklink_.Receive()) == S_OK) {
+    CFStringRef device_model_name = NULL;
+    if ((decklink_->GetModelName(&device_model_name) == S_OK) ||
+        (device_name_.id() == base::SysCFStringRefToUTF8(device_model_name))) {
+      break;
+    }
+    decklink_.Release();
+  }
+  if (!decklink_.get()) {
+    SendErrorString("Device id not found in the system");
+    return;
+  }
+
+  if (decklink_->QueryInterface(IID_IDeckLinkInput,
+          decklink_input_.ReceiveVoid()) != S_OK) {
+    SendErrorString("Error querying input interface.");
+    return;
+  }
+
+  ScopedDeckLinkPtr<IDeckLinkDisplayModeIterator> display_mode_iter;
+  if (decklink_input_->GetDisplayModeIterator(display_mode_iter.Receive()) !=
+      S_OK) {
+    SendErrorString("Error creating Display Mode Iterator");
+    return;
+  }
+
+  ScopedDeckLinkPtr<IDeckLinkDisplayMode> chosen_display_mode;
+  ScopedDeckLinkPtr<IDeckLinkDisplayMode> display_mode;
+  float min_diff = FLT_MAX;
+  while (display_mode_iter->Next(display_mode.Receive()) == S_OK) {
+    const float diff = labs(display_mode->GetWidth() -
+        params.requested_format.frame_size.width()) +
+        labs(params.requested_format.frame_size.height() -
+        display_mode->GetHeight()) + fabs(params.requested_format.frame_rate -
+        GetDisplayModeFrameRate(display_mode));
+    if (diff < min_diff) {
+      chosen_display_mode = display_mode;
+      min_diff = diff;
+    }
+    display_mode.Release();
+  }
+  if (!chosen_display_mode.get()) {
+    SendErrorString("Could not find a display mode");
+    return;
+  }
+#if !defined(NDEBUG)
+  DVLOG(1) << "Requested format: " << params.requested_format.ToString();
+  CFStringRef format_name = NULL;
+  if (chosen_display_mode->GetName(&format_name) == S_OK)
+    DVLOG(1) << "Chosen format: " << base::SysCFStringRefToUTF8(format_name);
+#endif
+
+  // Enable video input. Configure for no input video format change detection,
+  // this in turn will disable calls to VideoInputFormatChanged().
+  if (decklink_input_->EnableVideoInput(chosen_display_mode->GetDisplayMode(),
+          bmdFormat8BitYUV, bmdVideoInputFlagDefault) != S_OK) {
+    SendErrorString("Could not select the video format we like.");
+    return;
+  }
+
+  decklink_input_->SetCallback(this);
+  if (decklink_input_->StartStreams() != S_OK)
+    SendErrorString("Could not start capturing");
+}
+
+void DeckLinkCaptureDelegate::StopAndDeAllocate() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!decklink_input_.get())
+    return;
+  if (decklink_input_->StopStreams() != S_OK)
+    SendLogString("Problem stopping capture.");
+  decklink_input_->SetCallback(NULL);
+  decklink_input_->DisableVideoInput();
+  ResetVideoCaptureDeviceReference();
+}
+
+HRESULT DeckLinkCaptureDelegate::VideoInputFormatChanged (

[Robert Sesek, 2014/09/24 17:06:14]

nit: space before (

[mcasas, 2014/09/24 19:39:56]

Done.

+    BMDVideoInputFormatChangedEvents notification_events,
+    IDeckLinkDisplayMode *new_display_mode,
+    BMDDetectedVideoInputFormatFlags detected_signal_flags) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  return S_OK;
+}
+
+HRESULT DeckLinkCaptureDelegate::VideoInputFrameArrived (

[Robert Sesek, 2014/09/24 17:06:14]

same

[mcasas, 2014/09/24 19:39:56]

Done.

+    IDeckLinkVideoInputFrame* video_frame,
+    IDeckLinkAudioInputPacket* /* audio_packet */) {
+  // Capture frames are manipulated as an IDeckLinkVideoFrame.
+  uint8* video_data = NULL;
+  video_frame->GetBytes(reinterpret_cast<void**>(&video_data));
+
+  media::VideoPixelFormat pixel_format = media::PIXEL_FORMAT_UNKNOWN;
+  switch (video_frame->GetPixelFormat()) {
+    case bmdFormat8BitYUV:  // A.k.a. '2vuy';
+      pixel_format = media::PIXEL_FORMAT_UYVY;
+      break;
+    case bmdFormat8BitARGB:
+      pixel_format = media::PIXEL_FORMAT_ARGB;
+      break;
+    default:
+      SendErrorString("Unsupported pixel format");
+      break;
+  }
+
+  const media::VideoCaptureFormat capture_format(
+      gfx::Size(video_frame->GetWidth(), video_frame->GetHeight()),
+      0.0f,  // Frame rate is not needed for captured data callback.
+      pixel_format);
+  base::AutoLock lock(lock_);
+  if (frame_receiver_) {
+    frame_receiver_->OnIncomingCapturedData(
+        video_data,
+        video_frame->GetRowBytes() * video_frame->GetHeight(),
+        capture_format,
+        0,  // Rotation.
+        base::TimeTicks::Now());
+  }
+  return S_OK;
+}
+
+HRESULT DeckLinkCaptureDelegate::QueryInterface(REFIID iid, void** ppv) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  CFUUIDBytes iunknown = CFUUIDGetUUIDBytes(IUnknownUUID);
+  if (memcmp(&iid, &iunknown, sizeof(REFIID)) == 0 ||
+      memcmp(&iid, &IID_IDeckLinkInputCallback, sizeof(REFIID)) == 0) {
+    *ppv = static_cast<IDeckLinkInputCallback*>(this);
+    AddRef();
+    return S_OK;
+  }
+  return E_NOINTERFACE;
+}
+
+ULONG DeckLinkCaptureDelegate::AddRef(void) {

[Robert Sesek, 2014/09/24 17:06:14]

no (void)

[mcasas, 2014/09/24 19:39:57]

Done.

+  DCHECK(thread_checker_.CalledOnValidThread());
+  return OSAtomicIncrement32(&ref_count_);
+}
+
+ULONG DeckLinkCaptureDelegate::Release(void) {

[Robert Sesek, 2014/09/24 17:06:14]

no (void)

[mcasas, 2014/09/24 19:39:56]

Done.

+  DCHECK(thread_checker_.CalledOnValidThread());
+  int32_t newRefValue = OSAtomicDecrement32(&ref_count_);

[Robert Sesek, 2014/09/24 17:06:14]

naming: under_score

[mcasas, 2014/09/24 19:39:56]

Done.

+  if (newRefValue == 0)
+    delete this;
+  return newRefValue;
+}
+
+void DeckLinkCaptureDelegate::SendErrorString(const std::string& reason) {
+  base::AutoLock lock(lock_);
+  if (frame_receiver_)
+    frame_receiver_->SendErrorString(reason);
+}
+
+void DeckLinkCaptureDelegate::SendLogString(const std::string& message) {
+  base::AutoLock lock(lock_);
+  if (frame_receiver_)
+    frame_receiver_->SendLogString(message);
+}
+
+void DeckLinkCaptureDelegate::ResetVideoCaptureDeviceReference() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  base::AutoLock lock(lock_);
+  frame_receiver_ = NULL;
+}
+
 }  // namespace
 
 namespace media {
 
-std::string JoinDeviceNameAndFormat(CFStringRef name, CFStringRef format) {
+static std::string JoinDeviceNameAndFormat(CFStringRef name,
+                                           CFStringRef format) {
   return base::SysCFStringRefToUTF8(name) + " - " +
       base::SysCFStringRefToUTF8(format);
 }
 
 //static
 void VideoCaptureDeviceDeckLinkMac::EnumerateDevices(
     VideoCaptureDevice::Names* device_names) {
   scoped_refptr<IDeckLinkIterator> decklink_iter(
       CreateDeckLinkIteratorInstance());
   // At this point, not being able to create a DeckLink iterator means that
-  // there are no Blackmagic devices in the system but this isn't an error.
+  // there are no Blackmagic DeckLink devices in the system, don't print error.
   DVLOG_IF(1, !decklink_iter.get()) << "Could not create DeckLink iterator";
   if (!decklink_iter.get())
     return;
 
   ScopedDeckLinkPtr<IDeckLink> decklink;
   while (decklink_iter->Next(decklink.Receive()) == S_OK) {
     ScopedDeckLinkPtr<IDeckLink> decklink_local;
     decklink_local.swap(decklink);
 
     CFStringRef device_model_name = NULL;
@@ skipping 74 matching lines @@
     while (display_mode_iter->Next(display_mode.Receive()) == S_OK) {
       CFStringRef format_name = NULL;
       if (display_mode->GetName(&format_name) == S_OK && device.id() !=
           JoinDeviceNameAndFormat(device_model_name, format_name)) {
         display_mode.Release();
         continue;
       }
 
       // IDeckLinkDisplayMode does not have information on pixel format, this
       // is only available on capture.
-      media::VideoPixelFormat pixel_format = media::PIXEL_FORMAT_UNKNOWN;
-      BMDTimeValue time_value, time_scale;
-      float frame_rate = 0.0f;
-      if (display_mode->GetFrameRate(&time_value, &time_scale) == S_OK &&
-          time_value > 0) {
-        frame_rate = static_cast<float>(time_scale) / time_value;
-      }
-      media::VideoCaptureFormat format(
+      const media::VideoCaptureFormat format(
           gfx::Size(display_mode->GetWidth(), display_mode->GetHeight()),
-          frame_rate,
-          pixel_format);
+          GetDisplayModeFrameRate(display_mode),
+          PIXEL_FORMAT_UNKNOWN);
       supported_formats->push_back(format);
       DVLOG(2) << device.name() << " " << format.ToString();
       display_mode.Release();
     }
     return;
   }
 }
 
 VideoCaptureDeviceDeckLinkMac::VideoCaptureDeviceDeckLinkMac(
-    const Name& device_name) {}
+    const Name& device_name)
+    : decklink_capture_delegate_(
+          new DeckLinkCaptureDelegate(device_name, this)) {
+}
 
-VideoCaptureDeviceDeckLinkMac::~VideoCaptureDeviceDeckLinkMac() {}
+VideoCaptureDeviceDeckLinkMac::~VideoCaptureDeviceDeckLinkMac() {
+  decklink_capture_delegate_->ResetVideoCaptureDeviceReference();
+}
+
+void VideoCaptureDeviceDeckLinkMac::OnIncomingCapturedData(
+    const uint8* data,
+    int length,
+    const VideoCaptureFormat& frame_format,
+    int rotation,  // Clockwise.
+    base::TimeTicks timestamp) {
+  base::AutoLock lock(lock_);
+  if (client_) {
+    client_->OnIncomingCapturedData(data, length, frame_format, rotation,
+        timestamp);
+  }
+}
+
+void VideoCaptureDeviceDeckLinkMac::SendErrorString(const std::string& reason) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  base::AutoLock lock(lock_);
+  if (client_)
+    client_->OnError(reason);
+}
+
+void VideoCaptureDeviceDeckLinkMac::SendLogString(const std::string& message) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  base::AutoLock lock(lock_);
+  if (client_)
+    client_->OnLog(message);
+}
 
 void VideoCaptureDeviceDeckLinkMac::AllocateAndStart(
-    const VideoCaptureParams& params,
-    scoped_ptr<VideoCaptureDevice::Client> client) {
-  NOTIMPLEMENTED();
+      const VideoCaptureParams& params,
+      scoped_ptr<VideoCaptureDevice::Client> client) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  client_ = client.Pass();
+  if (decklink_capture_delegate_.get())
+    decklink_capture_delegate_->AllocateAndStart(params);
 }
 
 void VideoCaptureDeviceDeckLinkMac::StopAndDeAllocate() {
-  NOTIMPLEMENTED();
+  if (decklink_capture_delegate_.get())
+    decklink_capture_delegate_->StopAndDeAllocate();
 }
 
 } // namespace media