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

media/video/capture/mac/video_capture_device_decklink_mac.h

 // 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.
 
 // Implementation of VideoCaptureDevice class for Blackmagic video capture
 // devices by using the DeckLink SDK.
 
 #ifndef MEDIA_VIDEO_CAPTURE_VIDEO_CAPTURE_DEVICE_DECKLINK_MAC_H_
 #define MEDIA_VIDEO_CAPTURE_VIDEO_CAPTURE_DEVICE_DECKLINK_MAC_H_
 
 #include "media/video/capture/video_capture_device.h"
 
 #import <Foundation/Foundation.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:
+  using scoped_refptr<T>::ptr_;

[tommi (sloooow) - chröme, 2014/09/05 09:24:21]

why do you need this?

[mcasas, 2014/09/09 11:05:00]

Subtemplating a template is a bit special, meaning that
I need to explicitly state which |ptr_| I'm manipulating,
because it depends on the template parameter.

Explained in all its glory in [1].

[1] http://www.parashift.com/c++-faq-lite/nondependent-name-lookup-members.html

[tommi (sloooow) - chröme, 2014/09/22 20:26:38]

Ah, sorry, I was actually more thinking why you're making it public :)

However, even so, I don't think you need this since it's clear that it comes
from scoped_ptr (I didn't need this for example when I wrote ScopedComPtr).

+
+  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;
+    }
+  }
+};
+
+}  // namespace
+
+
 namespace media {
 
 // Extension of VideoCaptureDevice to create and manipulate Blackmagic devices
 // via DeckLink SDK.
-class MEDIA_EXPORT VideoCaptureDeviceDeckLinkMac : public VideoCaptureDevice {
+class MEDIA_EXPORT VideoCaptureDeviceDeckLinkMac :
+    public VideoCaptureDevice,
+    public IDeckLinkInputCallback  {
  public:
   // Gets the names of all DeckLink video capture devices connected to this
   // computer, as enumerated by the DeckLink SDK.
   static void EnumerateDevices(VideoCaptureDevice::Names* device_names);
 
   // Gets the supported formats of a particular device attached to the system,
   // identified by |device|. Formats are retrieved from the DeckLink SDK.
   static void EnumerateDeviceCapabilities(
       const VideoCaptureDevice::Name& device,
       VideoCaptureFormats* supported_formats);
 
   explicit VideoCaptureDeviceDeckLinkMac(const Name& device_name);
   virtual ~VideoCaptureDeviceDeckLinkMac();
 
   // VideoCaptureDevice implementation.
   virtual void AllocateAndStart(
       const VideoCaptureParams& params,
       scoped_ptr<VideoCaptureDevice::Client> client) OVERRIDE;
   virtual void StopAndDeAllocate() OVERRIDE;
 
+  // IDeckLinkInputCallback interface implementation.

[tommi (sloooow) - chröme, 2014/09/05 09:24:20]

should this be private/protected? (same for the VideoCaptureDevice
implementation)

[mcasas, 2014/09/09 11:05:00]

Had a second look at the inheritance qualifiers and at the
methods and privatised/protectesised as much as possible.

+  virtual HRESULT VideoInputFormatChanged (
+      BMDVideoInputFormatChangedEvents notification_events,
+      IDeckLinkDisplayMode *new_display_mode,
+      BMDDetectedVideoInputFormatFlags detected_signal_flags) OVERRIDE;
+  virtual HRESULT VideoInputFrameArrived (
+      IDeckLinkVideoInputFrame* video_frame,
+      IDeckLinkAudioInputPacket* audio_packet) OVERRIDE;
+
+  // IUnknown interface implementation.
+  virtual HRESULT QueryInterface (REFIID iid, LPVOID *ppv) OVERRIDE;

[tommi (sloooow) - chröme, 2014/09/05 09:24:21]

Since this implements reference counting and VideoCaptureDeviceDeckLinkMac is
not really reference counted, I think we should implement this interface in a
separate class and hold on to an instance of that class in
VideoCaptureDeviceDeckLinkMac.

[mcasas, 2014/09/09 11:05:00]

I created a DeckLinkCaptureDelegate class that holds all DeckLink specifics
and moved it to the .mm file. Capture callbacks happen in a DeckLink
thread, so had to add an AutoLock here and there.

DeckLinkCaptureDelegate holds a weak reference to
VideoCaptureDeviceDeckLinkMac to send frames to it.

DLCaptureDelegate is reference-counted by the DeckLink SDK
via its IUnknown interface, and VCDDeckLinkMac ref counts it.

+  virtual ULONG AddRef() OVERRIDE;
+  virtual ULONG Release() OVERRIDE;
+
+  // Forwarder to VideoCaptureDevice::Client::OnError().
+  void SetErrorState(const std::string& reason);
+
+  // Forwarder to VideoCaptureDevice::Client::OnLog().
+  void LogMessage(const std::string& message);
+
  private:
+  scoped_ptr<VideoCaptureDevice::Client> client_;
+
+  // This is used to control the video capturing device input interface.
+  ScopedDeckLinkPtr<IDeckLinkInput> decklink_input_;

[tommi (sloooow) - chröme, 2014/09/05 09:24:20]

is this a circular dependency to an object that also has a pointer to |this|?

[mcasas, 2014/09/09 11:05:00]

Yes, should I turn it into a weak pointer?

+  // |decklink_| represents a physical device attached to the host.
+  ScopedDeckLinkPtr<IDeckLink> decklink_;
+
+  // Internal counter for IUnknown interface implementation.
+  int32_t ref_count_;

[tommi (sloooow) - chröme, 2014/09/05 09:24:20]

see comment above - I think this should be in a separate class.

[mcasas, 2014/09/09 11:05:00]

Acknowledged.

+  const Name device_name_;
+
   DISALLOW_COPY_AND_ASSIGN(VideoCaptureDeviceDeckLinkMac);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_VIDEO_CAPTURE_VIDEO_CAPTURE_DEVICE_DECKLINK_MAC_H_