decklink: Add decklink plugin

Source and sink elements for BlackMagic DeckLink SDI cards.

12 files changed, 4166 insertions, 1 deletions

diff --git a/sys/Makefile.am b/sys/Makefile.am
index e2e29d835..ee8a377fa 100644
--- a/sys/Makefile.am
+++ b/sys/Makefile.am
@@ -22,6 +22,12 @@ endif
 # CDROM_DIR=
 # endif
 
+if USE_DECKLINK
+DECKLINK_DIR=decklink
+else
+DECKLINK_DIR=
+endif
+
 if USE_DIRECTDRAW
 DIRECTDRAW_DIR=directdraw
 else
@@ -97,7 +103,7 @@ endif
 
 SUBDIRS = $(ACM_DIR) $(APPLE_MEDIA_DIR) $(DIRECTDRAW_DIR) $(DIRECTSOUND_DIR) $(DVB_DIR) $(FBDEV_DIR) $(LINSYS_DIR) $(OSX_VIDEO_DIR) $(QT_DIR) $(SHM_DIR) $(VCD_DIR) $(VDPAU_DIR) $(WININET_DIR)
 
-DIST_SUBDIRS = acmenc acmmp3dec applemedia directdraw directsound dvb linsys fbdev dshowdecwrapper dshowsrcwrapper dshowvideosink \
+DIST_SUBDIRS = acmenc acmmp3dec applemedia decklink directdraw directsound dvb linsys fbdev dshowdecwrapper dshowsrcwrapper dshowvideosink \
 		osxvideo qtwrapper shm vcd vdpau wasapi wininet winks winscreencap
 
 include $(top_srcdir)/common/parallel-subdirs.mak
diff --git a/sys/decklink/DeckLinkAPI.h b/sys/decklink/DeckLinkAPI.h
new file mode 100644
index 000000000..19eb07e9c
--- /dev/null
+++ b/sys/decklink/DeckLinkAPI.h
@@ -0,0 +1,1095 @@
+/* -LICENSE-START-
+** Copyright (c) 2009 Blackmagic Design
+**
+** Permission is hereby granted, free of charge, to any person or organization
+** obtaining a copy of the software and accompanying documentation covered by
+** this license (the "Software") to use, reproduce, display, distribute,
+** execute, and transmit the Software, and to prepare derivative works of the
+** Software, and to permit third-parties to whom the Software is furnished to
+** do so, all subject to the following:
+** 
+** The copyright notices in the Software and this entire statement, including
+** the above license grant, this restriction and the following disclaimer,
+** must be included in all copies of the Software, in whole or in part, and
+** all derivative works of the Software, unless such copies or derivative
+** works are solely in the form of machine-executable object code generated by
+** a source language processor.
+** 
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+** SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+** FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+** ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+** DEALINGS IN THE SOFTWARE.
+** -LICENSE-END-
+*/
+
+/* DeckLinkAPI.h */
+		
+#ifndef __DeckLink_API_h__
+#define __DeckLink_API_h__
+		
+#include <stdint.h>
+#include "LinuxCOM.h"
+
+#define BLACKMAGIC_DECKLINK_API_MAGIC	1
+
+// Type Declarations
+
+typedef int64_t BMDTimeValue;
+typedef int64_t BMDTimeScale;
+typedef uint32_t BMDTimecodeBCD;
+typedef uint32_t BMDTimecodeUserBits;
+
+
+// Interface ID Declarations
+
+#define IID_IDeckLinkVideoOutputCallback                 /* 20AA5225-1958-47CB-820B-80A8D521A6EE */ (REFIID){0x20,0xAA,0x52,0x25,0x19,0x58,0x47,0xCB,0x82,0x0B,0x80,0xA8,0xD5,0x21,0xA6,0xEE}
+#define IID_IDeckLinkInputCallback                       /* DD04E5EC-7415-42AB-AE4A-E80C4DFC044A */ (REFIID){0xDD,0x04,0xE5,0xEC,0x74,0x15,0x42,0xAB,0xAE,0x4A,0xE8,0x0C,0x4D,0xFC,0x04,0x4A}
+#define IID_IDeckLinkMemoryAllocator                     /* B36EB6E7-9D29-4AA8-92EF-843B87A289E8 */ (REFIID){0xB3,0x6E,0xB6,0xE7,0x9D,0x29,0x4A,0xA8,0x92,0xEF,0x84,0x3B,0x87,0xA2,0x89,0xE8}
+#define IID_IDeckLinkAudioOutputCallback                 /* 403C681B-7F46-4A12-B993-2BB127084EE6 */ (REFIID){0x40,0x3C,0x68,0x1B,0x7F,0x46,0x4A,0x12,0xB9,0x93,0x2B,0xB1,0x27,0x08,0x4E,0xE6}
+#define IID_IDeckLinkIterator                            /* 74E936FC-CC28-4A67-81A0-1E94E52D4E69 */ (REFIID){0x74,0xE9,0x36,0xFC,0xCC,0x28,0x4A,0x67,0x81,0xA0,0x1E,0x94,0xE5,0x2D,0x4E,0x69}
+#define IID_IDeckLinkAPIInformation                      /* 7BEA3C68-730D-4322-AF34-8A7152B532A4 */ (REFIID){0x7B,0xEA,0x3C,0x68,0x73,0x0D,0x43,0x22,0xAF,0x34,0x8A,0x71,0x52,0xB5,0x32,0xA4}
+#define IID_IDeckLinkDisplayModeIterator                 /* 9C88499F-F601-4021-B80B-032E4EB41C35 */ (REFIID){0x9C,0x88,0x49,0x9F,0xF6,0x01,0x40,0x21,0xB8,0x0B,0x03,0x2E,0x4E,0xB4,0x1C,0x35}
+#define IID_IDeckLinkDisplayMode                         /* 3EB2C1AB-0A3D-4523-A3AD-F40D7FB14E78 */ (REFIID){0x3E,0xB2,0xC1,0xAB,0x0A,0x3D,0x45,0x23,0xA3,0xAD,0xF4,0x0D,0x7F,0xB1,0x4E,0x78}
+#define IID_IDeckLink                                    /* 62BFF75D-6569-4E55-8D4D-66AA03829ABC */ (REFIID){0x62,0xBF,0xF7,0x5D,0x65,0x69,0x4E,0x55,0x8D,0x4D,0x66,0xAA,0x03,0x82,0x9A,0xBC}
+#define IID_IDeckLinkOutput                              /* A3EF0963-0862-44ED-92A9-EE89ABF431C7 */ (REFIID){0xA3,0xEF,0x09,0x63,0x08,0x62,0x44,0xED,0x92,0xA9,0xEE,0x89,0xAB,0xF4,0x31,0xC7}
+#define IID_IDeckLinkInput                               /* 6D40EF78-28B9-4E21-990D-95BB7750A04F */ (REFIID){0x6D,0x40,0xEF,0x78,0x28,0xB9,0x4E,0x21,0x99,0x0D,0x95,0xBB,0x77,0x50,0xA0,0x4F}
+#define IID_IDeckLinkTimecode                            /* BC6CFBD3-8317-4325-AC1C-1216391E9340 */ (REFIID){0xBC,0x6C,0xFB,0xD3,0x83,0x17,0x43,0x25,0xAC,0x1C,0x12,0x16,0x39,0x1E,0x93,0x40}
+#define IID_IDeckLinkVideoFrame                          /* 3F716FE0-F023-4111-BE5D-EF4414C05B17 */ (REFIID){0x3F,0x71,0x6F,0xE0,0xF0,0x23,0x41,0x11,0xBE,0x5D,0xEF,0x44,0x14,0xC0,0x5B,0x17}
+#define IID_IDeckLinkMutableVideoFrame                   /* 69E2639F-40DA-4E19-B6F2-20ACE815C390 */ (REFIID){0x69,0xE2,0x63,0x9F,0x40,0xDA,0x4E,0x19,0xB6,0xF2,0x20,0xAC,0xE8,0x15,0xC3,0x90}
+#define IID_IDeckLinkVideoFrame3DExtensions              /* DA0F7E4A-EDC7-48A8-9CDD-2DB51C729CD7 */ (REFIID){0xDA,0x0F,0x7E,0x4A,0xED,0xC7,0x48,0xA8,0x9C,0xDD,0x2D,0xB5,0x1C,0x72,0x9C,0xD7}
+#define IID_IDeckLinkVideoInputFrame                     /* 05CFE374-537C-4094-9A57-680525118F44 */ (REFIID){0x05,0xCF,0xE3,0x74,0x53,0x7C,0x40,0x94,0x9A,0x57,0x68,0x05,0x25,0x11,0x8F,0x44}
+#define IID_IDeckLinkVideoFrameAncillary                 /* 732E723C-D1A4-4E29-9E8E-4A88797A0004 */ (REFIID){0x73,0x2E,0x72,0x3C,0xD1,0xA4,0x4E,0x29,0x9E,0x8E,0x4A,0x88,0x79,0x7A,0x00,0x04}
+#define IID_IDeckLinkAudioInputPacket                    /* E43D5870-2894-11DE-8C30-0800200C9A66 */ (REFIID){0xE4,0x3D,0x58,0x70,0x28,0x94,0x11,0xDE,0x8C,0x30,0x08,0x00,0x20,0x0C,0x9A,0x66}
+#define IID_IDeckLinkScreenPreviewCallback               /* B1D3F49A-85FE-4C5D-95C8-0B5D5DCCD438 */ (REFIID){0xB1,0xD3,0xF4,0x9A,0x85,0xFE,0x4C,0x5D,0x95,0xC8,0x0B,0x5D,0x5D,0xCC,0xD4,0x38}
+#define IID_IDeckLinkGLScreenPreviewHelper               /* 504E2209-CAC7-4C1A-9FB4-C5BB6274D22F */ (REFIID){0x50,0x4E,0x22,0x09,0xCA,0xC7,0x4C,0x1A,0x9F,0xB4,0xC5,0xBB,0x62,0x74,0xD2,0x2F}
+#define IID_IDeckLinkConfiguration                       /* C679A35B-610C-4D09-B748-1D0478100FC0 */ (REFIID){0xC6,0x79,0xA3,0x5B,0x61,0x0C,0x4D,0x09,0xB7,0x48,0x1D,0x04,0x78,0x10,0x0F,0xC0}
+#define IID_IDeckLinkAttributes                          /* ABC11843-D966-44CB-96E2-A1CB5D3135C4 */ (REFIID){0xAB,0xC1,0x18,0x43,0xD9,0x66,0x44,0xCB,0x96,0xE2,0xA1,0xCB,0x5D,0x31,0x35,0xC4}
+#define IID_IDeckLinkKeyer                               /* 89AFCAF5-65F8-421E-98F7-96FE5F5BFBA3 */ (REFIID){0x89,0xAF,0xCA,0xF5,0x65,0xF8,0x42,0x1E,0x98,0xF7,0x96,0xFE,0x5F,0x5B,0xFB,0xA3}
+#define IID_IDeckLinkVideoConversion                     /* 3BBCB8A2-DA2C-42D9-B5D8-88083644E99A */ (REFIID){0x3B,0xBC,0xB8,0xA2,0xDA,0x2C,0x42,0xD9,0xB5,0xD8,0x88,0x08,0x36,0x44,0xE9,0x9A}
+#define IID_IDeckLinkDeckControlStatusCallback           /* E5F693C1-4283-4716-B18F-C1431521955B */ (REFIID){0xE5,0xF6,0x93,0xC1,0x42,0x83,0x47,0x16,0xB1,0x8F,0xC1,0x43,0x15,0x21,0x95,0x5B}
+#define IID_IDeckLinkDeckControl                         /* A4D81043-0619-42B7-8ED6-602D29041DF7 */ (REFIID){0xA4,0xD8,0x10,0x43,0x06,0x19,0x42,0xB7,0x8E,0xD6,0x60,0x2D,0x29,0x04,0x1D,0xF7}
+
+
+/* Enum BMDDisplayMode - Video display modes */
+
+typedef uint32_t BMDDisplayMode;
+enum _BMDDisplayMode {
+
+    /* SD Modes */
+
+    bmdModeNTSC                                        = /* 'ntsc' */ 0x6E747363,
+    bmdModeNTSC2398                                    = /* 'nt23' */ 0x6E743233,	// 3:2 pulldown
+    bmdModePAL                                         = /* 'pal ' */ 0x70616C20,
+    bmdModeNTSCp                                       = /* 'ntsp' */ 0x6E747370,
+    bmdModePALp                                        = /* 'palp' */ 0x70616C70,
+
+    /* HD 1080 Modes */
+
+    bmdModeHD1080p2398                                 = /* '23ps' */ 0x32337073,
+    bmdModeHD1080p24                                   = /* '24ps' */ 0x32347073,
+    bmdModeHD1080p25                                   = /* 'Hp25' */ 0x48703235,
+    bmdModeHD1080p2997                                 = /* 'Hp29' */ 0x48703239,
+    bmdModeHD1080p30                                   = /* 'Hp30' */ 0x48703330,
+    bmdModeHD1080i50                                   = /* 'Hi50' */ 0x48693530,
+    bmdModeHD1080i5994                                 = /* 'Hi59' */ 0x48693539,
+    bmdModeHD1080i6000                                 = /* 'Hi60' */ 0x48693630,	// N.B. This _really_ is 60.00 Hz.
+    bmdModeHD1080p50                                   = /* 'Hp50' */ 0x48703530,
+    bmdModeHD1080p5994                                 = /* 'Hp59' */ 0x48703539,
+    bmdModeHD1080p6000                                 = /* 'Hp60' */ 0x48703630,	// N.B. This _really_ is 60.00 Hz.
+
+    /* HD 720 Modes */
+
+    bmdModeHD720p50                                    = /* 'hp50' */ 0x68703530,
+    bmdModeHD720p5994                                  = /* 'hp59' */ 0x68703539,
+    bmdModeHD720p60                                    = /* 'hp60' */ 0x68703630,
+
+    /* 2k Modes */
+
+    bmdMode2k2398                                      = /* '2k23' */ 0x326B3233,
+    bmdMode2k24                                        = /* '2k24' */ 0x326B3234,
+    bmdMode2k25                                        = /* '2k25' */ 0x326B3235
+};
+
+
+/* Enum BMDFieldDominance - Video field dominance */
+
+typedef uint32_t BMDFieldDominance;
+enum _BMDFieldDominance {
+    bmdUnknownFieldDominance                           = 0,
+    bmdLowerFieldFirst                                 = /* 'lowr' */ 0x6C6F7772,
+    bmdUpperFieldFirst                                 = /* 'uppr' */ 0x75707072,
+    bmdProgressiveFrame                                = /* 'prog' */ 0x70726F67,
+    bmdProgressiveSegmentedFrame                       = /* 'psf ' */ 0x70736620
+};
+
+
+/* Enum BMDPixelFormat - Video pixel formats supported for output/input */
+
+typedef uint32_t BMDPixelFormat;
+enum _BMDPixelFormat {
+    bmdFormat8BitYUV                                   = /* '2vuy' */ 0x32767579,
+    bmdFormat10BitYUV                                  = /* 'v210' */ 0x76323130,
+    bmdFormat8BitARGB                                  = 32,
+    bmdFormat8BitBGRA                                  = /* 'BGRA' */ 0x42475241,
+    bmdFormat10BitRGB                                  = /* 'r210' */ 0x72323130	// Big-endian RGB 10-bit per component with SMPTE video levels (64-960). Packed as 2:10:10:10
+};
+
+
+/* Enum BMDDisplayModeFlags - Flags to describe the characteristics of an IDeckLinkDisplayMode. */
+
+typedef uint32_t BMDDisplayModeFlags;
+enum _BMDDisplayModeFlags {
+    bmdDisplayModeSupports3D                           = 1 << 0,
+    bmdDisplayModeColorspaceRec601                     = 1 << 1,
+    bmdDisplayModeColorspaceRec709                     = 1 << 2
+};
+
+
+/* Enum BMDVideoOutputFlags - Flags to control the output of ancillary data along with video. */
+
+typedef uint32_t BMDVideoOutputFlags;
+enum _BMDVideoOutputFlags {
+    bmdVideoOutputFlagDefault                          = 0,
+    bmdVideoOutputVANC                                 = 1 << 0,
+    bmdVideoOutputVITC                                 = 1 << 1,
+    bmdVideoOutputRP188                                = 1 << 2,
+    bmdVideoOutputDualStream3D                         = 1 << 4
+};
+
+
+/* Enum BMDFrameFlags - Frame flags */
+
+typedef uint32_t BMDFrameFlags;
+enum _BMDFrameFlags {
+    bmdFrameFlagDefault                                = 0,
+    bmdFrameFlagFlipVertical                           = 1 << 0,
+
+    /* Flags that are applicable only to instances of IDeckLinkVideoInputFrame */
+
+    bmdFrameHasNoInputSource                           = 1 << 31
+};
+
+
+/* Enum BMDVideoInputFlags - Flags applicable to video input */
+
+typedef uint32_t BMDVideoInputFlags;
+enum _BMDVideoInputFlags {
+    bmdVideoInputFlagDefault                           = 0,
+    bmdVideoInputEnableFormatDetection                 = 1 << 0,
+    bmdVideoInputDualStream3D                          = 1 << 1
+};
+
+
+/* Enum BMDVideoInputFormatChangedEvents - Bitmask passed to the VideoInputFormatChanged notification to identify the properties of the input signal that have changed */
+
+typedef uint32_t BMDVideoInputFormatChangedEvents;
+enum _BMDVideoInputFormatChangedEvents {
+    bmdVideoInputDisplayModeChanged                    = 1 << 0,
+    bmdVideoInputFieldDominanceChanged                 = 1 << 1,
+    bmdVideoInputColorspaceChanged                     = 1 << 2
+};
+
+
+/* Enum BMDDetectedVideoInputFormatFlags - Flags passed to the VideoInputFormatChanged notification to describe the detected video input signal */
+
+typedef uint32_t BMDDetectedVideoInputFormatFlags;
+enum _BMDDetectedVideoInputFormatFlags {
+    bmdDetectedVideoInputYCbCr422                      = 1 << 0,
+    bmdDetectedVideoInputRGB444                        = 1 << 1
+};
+
+
+/* Enum BMDOutputFrameCompletionResult - Frame Completion Callback */
+
+typedef uint32_t BMDOutputFrameCompletionResult;
+enum _BMDOutputFrameCompletionResult {
+    bmdOutputFrameCompleted,                          
+    bmdOutputFrameDisplayedLate,                      
+    bmdOutputFrameDropped,                            
+    bmdOutputFrameFlushed                             
+};
+
+
+/* Enum BMDReferenceStatus - GenLock input status */
+
+typedef uint32_t BMDReferenceStatus;
+enum _BMDReferenceStatus {
+    bmdReferenceNotSupportedByHardware                 = 1 << 0,
+    bmdReferenceLocked                                 = 1 << 1
+};
+
+
+/* Enum BMDAudioSampleRate - Audio sample rates supported for output/input */
+
+typedef uint32_t BMDAudioSampleRate;
+enum _BMDAudioSampleRate {
+    bmdAudioSampleRate48kHz                            = 48000
+};
+
+
+/* Enum BMDAudioSampleType - Audio sample sizes supported for output/input */
+
+typedef uint32_t BMDAudioSampleType;
+enum _BMDAudioSampleType {
+    bmdAudioSampleType16bitInteger                     = 16,
+    bmdAudioSampleType32bitInteger                     = 32
+};
+
+
+/* Enum BMDAudioOutputStreamType - Audio output stream type */
+
+typedef uint32_t BMDAudioOutputStreamType;
+enum _BMDAudioOutputStreamType {
+    bmdAudioOutputStreamContinuous,                   
+    bmdAudioOutputStreamContinuousDontResample,       
+    bmdAudioOutputStreamTimestamped                   
+};
+
+
+/* Enum BMDDisplayModeSupport - Output mode supported flags */
+
+typedef uint32_t BMDDisplayModeSupport;
+enum _BMDDisplayModeSupport {
+    bmdDisplayModeNotSupported                         = 0,
+    bmdDisplayModeSupported,                          
+    bmdDisplayModeSupportedWithConversion             
+};
+
+
+/* Enum BMDTimecodeFormat - Timecode formats for frame metadata */
+
+typedef uint32_t BMDTimecodeFormat;
+enum _BMDTimecodeFormat {
+    bmdTimecodeRP188                                   = /* 'rp18' */ 0x72703138,
+    bmdTimecodeVITC                                    = /* 'vitc' */ 0x76697463,
+    bmdTimecodeSerial                                  = /* 'seri' */ 0x73657269
+};
+
+
+/* Enum BMDTimecodeFlags - Timecode flags */
+
+typedef uint32_t BMDTimecodeFlags;
+enum _BMDTimecodeFlags {
+    bmdTimecodeFlagDefault                             = 0,
+    bmdTimecodeIsDropFrame                             = 1 << 0
+};
+
+
+/* Enum BMDVideoConnection - Video connection types */
+
+typedef uint32_t BMDVideoConnection;
+enum _BMDVideoConnection {
+    bmdVideoConnectionSDI                              = 1 << 0,
+    bmdVideoConnectionHDMI                             = 1 << 1,
+    bmdVideoConnectionOpticalSDI                       = 1 << 2,
+    bmdVideoConnectionComponent                        = 1 << 3,
+    bmdVideoConnectionComposite                        = 1 << 4,
+    bmdVideoConnectionSVideo                           = 1 << 5
+};
+
+
+/* Enum BMDAnalogVideoFlags - Analog video display flags */
+
+typedef uint32_t BMDAnalogVideoFlags;
+enum _BMDAnalogVideoFlags {
+    bmdAnalogVideoFlagCompositeSetup75                 = 1 << 0,
+    bmdAnalogVideoFlagComponentBetacamLevels           = 1 << 1
+};
+
+
+/* Enum BMDAudioConnection - Audio connection types */
+
+typedef uint32_t BMDAudioConnection;
+enum _BMDAudioConnection {
+    bmdAudioConnectionEmbedded                         = /* 'embd' */ 0x656D6264,
+    bmdAudioConnectionAESEBU                           = /* 'aes ' */ 0x61657320,
+    bmdAudioConnectionAnalog                           = /* 'anlg' */ 0x616E6C67
+};
+
+
+/* Enum BMDAudioOutputAnalogAESSwitch - Audio output Analog/AESEBU switch */
+
+typedef uint32_t BMDAudioOutputAnalogAESSwitch;
+enum _BMDAudioOutputAnalogAESSwitch {
+    bmdAudioOutputSwitchAESEBU                         = /* 'aes ' */ 0x61657320,
+    bmdAudioOutputSwitchAnalog                         = /* 'anlg' */ 0x616E6C67
+};
+
+
+/* Enum BMDVideoOutputConversionMode - Video/audio conversion mode */
+
+typedef uint32_t BMDVideoOutputConversionMode;
+enum _BMDVideoOutputConversionMode {
+    bmdNoVideoOutputConversion                         = /* 'none' */ 0x6E6F6E65,
+    bmdVideoOutputLetterboxDownconversion              = /* 'ltbx' */ 0x6C746278,
+    bmdVideoOutputAnamorphicDownconversion             = /* 'amph' */ 0x616D7068,
+    bmdVideoOutputHD720toHD1080Conversion              = /* '720c' */ 0x37323063,
+    bmdVideoOutputHardwareLetterboxDownconversion      = /* 'HWlb' */ 0x48576C62,
+    bmdVideoOutputHardwareAnamorphicDownconversion     = /* 'HWam' */ 0x4857616D,
+    bmdVideoOutputHardwareCenterCutDownconversion      = /* 'HWcc' */ 0x48576363,
+    bmdVideoOutputHardware720p1080pCrossconversion     = /* 'xcap' */ 0x78636170,
+    bmdVideoOutputHardwareAnamorphic720pUpconversion   = /* 'ua7p' */ 0x75613770,
+    bmdVideoOutputHardwareAnamorphic1080iUpconversion  = /* 'ua1i' */ 0x75613169,
+    bmdVideoOutputHardwareAnamorphic149To720pUpconversion = /* 'u47p' */ 0x75343770,
+    bmdVideoOutputHardwareAnamorphic149To1080iUpconversion = /* 'u41i' */ 0x75343169,
+    bmdVideoOutputHardwarePillarbox720pUpconversion    = /* 'up7p' */ 0x75703770,
+    bmdVideoOutputHardwarePillarbox1080iUpconversion   = /* 'up1i' */ 0x75703169
+};
+
+
+/* Enum BMDVideoInputConversionMode - Video input conversion mode */
+
+typedef uint32_t BMDVideoInputConversionMode;
+enum _BMDVideoInputConversionMode {
+    bmdNoVideoInputConversion                          = /* 'none' */ 0x6E6F6E65,
+    bmdVideoInputLetterboxDownconversionFromHD1080     = /* '10lb' */ 0x31306C62,
+    bmdVideoInputAnamorphicDownconversionFromHD1080    = /* '10am' */ 0x3130616D,
+    bmdVideoInputLetterboxDownconversionFromHD720      = /* '72lb' */ 0x37326C62,
+    bmdVideoInputAnamorphicDownconversionFromHD720     = /* '72am' */ 0x3732616D,
+    bmdVideoInputLetterboxUpconversion                 = /* 'lbup' */ 0x6C627570,
+    bmdVideoInputAnamorphicUpconversion                = /* 'amup' */ 0x616D7570
+};
+
+
+/* Enum BMDVideo3DPackingFormat - Video 3D packing format */
+
+typedef uint32_t BMDVideo3DPackingFormat;
+enum _BMDVideo3DPackingFormat {
+    bmdVideo3DPackingSidebySideHalf                    = /* 'sbsh' */ 0x73627368,
+    bmdVideo3DPackingLinebyLine                        = /* 'lbyl' */ 0x6C62796C,
+    bmdVideo3DPackingTopAndBottom                      = /* 'tabo' */ 0x7461626F,
+    bmdVideo3DPackingFramePacking                      = /* 'frpk' */ 0x6672706B,
+    bmdVideo3DPackingLeftOnly                          = /* 'left' */ 0x6C656674,
+    bmdVideo3DPackingRightOnly                         = /* 'righ' */ 0x72696768
+};
+
+
+/* Enum BMDDeckLinkConfigurationID - DeckLink Configuration ID */
+
+typedef uint32_t BMDDeckLinkConfigurationID;
+enum _BMDDeckLinkConfigurationID {
+
+    /* Video Input/Output Flags */
+
+    bmdDeckLinkConfigUse1080pNotPsF                    = /* 'fpro' */ 0x6670726F,
+
+    /* Video Input/Output Integers */
+
+    bmdDeckLinkConfigHDMI3DPackingFormat               = /* '3dpf' */ 0x33647066,
+
+    /* Audio Input/Output Flags */
+
+    bmdDeckLinkConfigAnalogAudioConsumerLevels         = /* 'aacl' */ 0x6161636C,
+
+    /* Video output flags */
+
+    bmdDeckLinkConfigFieldFlickerRemoval               = /* 'fdfr' */ 0x66646672,
+    bmdDeckLinkConfigHD1080p24ToHD1080i5994Conversion  = /* 'to59' */ 0x746F3539,
+    bmdDeckLinkConfig444SDIVideoOutput                 = /* '444o' */ 0x3434346F,
+    bmdDeckLinkConfig3GBpsVideoOutput                  = /* '3gbs' */ 0x33676273,
+    bmdDeckLinkConfigBlackVideoOutputDuringCapture     = /* 'bvoc' */ 0x62766F63,
+    bmdDeckLinkConfigLowLatencyVideoOutput             = /* 'llvo' */ 0x6C6C766F,
+
+    /* Video Output Integers */
+
+    bmdDeckLinkConfigVideoOutputConnection             = /* 'vocn' */ 0x766F636E,
+    bmdDeckLinkConfigVideoOutputConversionMode         = /* 'vocm' */ 0x766F636D,
+    bmdDeckLinkConfigAnalogVideoOutputFlags            = /* 'avof' */ 0x61766F66,
+    bmdDeckLinkConfigReferenceInputTimingOffset        = /* 'glot' */ 0x676C6F74,
+
+    /* Video Input Integers */
+
+    bmdDeckLinkConfigVideoInputConnection              = /* 'vicn' */ 0x7669636E,
+    bmdDeckLinkConfigAnalogVideoInputFlags             = /* 'avif' */ 0x61766966,
+    bmdDeckLinkConfigVideoInputConversionMode          = /* 'vicm' */ 0x7669636D,
+    bmdDeckLinkConfig32PulldownSequenceInitialTimecodeFrame = /* 'pdif' */ 0x70646966,
+    bmdDeckLinkConfigVANCSourceLine1Mapping            = /* 'vsl1' */ 0x76736C31,
+    bmdDeckLinkConfigVANCSourceLine2Mapping            = /* 'vsl2' */ 0x76736C32,
+    bmdDeckLinkConfigVANCSourceLine3Mapping            = /* 'vsl3' */ 0x76736C33,
+
+    /* Audio Input Integers */
+
+    bmdDeckLinkConfigAudioInputConnection              = /* 'aicn' */ 0x6169636E,
+
+    /* Audio Input Floats */
+
+    bmdDeckLinkConfigAnalogAudioInputScaleChannel1     = /* 'ais1' */ 0x61697331,
+    bmdDeckLinkConfigAnalogAudioInputScaleChannel2     = /* 'ais2' */ 0x61697332,
+    bmdDeckLinkConfigAnalogAudioInputScaleChannel3     = /* 'ais3' */ 0x61697333,
+    bmdDeckLinkConfigAnalogAudioInputScaleChannel4     = /* 'ais4' */ 0x61697334,
+    bmdDeckLinkConfigDigitalAudioInputScale            = /* 'dais' */ 0x64616973,
+
+    /* Audio Output Integers */
+
+    bmdDeckLinkConfigAudioOutputAESAnalogSwitch        = /* 'aoaa' */ 0x616F6161,
+
+    /* Audio Output Floats */
+
+    bmdDeckLinkConfigAnalogAudioOutputScaleChannel1    = /* 'aos1' */ 0x616F7331,
+    bmdDeckLinkConfigAnalogAudioOutputScaleChannel2    = /* 'aos2' */ 0x616F7332,
+    bmdDeckLinkConfigAnalogAudioOutputScaleChannel3    = /* 'aos3' */ 0x616F7333,
+    bmdDeckLinkConfigAnalogAudioOutputScaleChannel4    = /* 'aos4' */ 0x616F7334,
+    bmdDeckLinkConfigDigitalAudioOutputScale           = /* 'daos' */ 0x64616F73
+};
+
+
+/* Enum BMDDeckLinkAttributeID - DeckLink Attribute ID */
+
+typedef uint32_t BMDDeckLinkAttributeID;
+enum _BMDDeckLinkAttributeID {
+
+    /* Flags */
+
+    BMDDeckLinkSupportsInternalKeying                  = /* 'keyi' */ 0x6B657969,
+    BMDDeckLinkSupportsExternalKeying                  = /* 'keye' */ 0x6B657965,
+    BMDDeckLinkSupportsHDKeying                        = /* 'keyh' */ 0x6B657968,
+    BMDDeckLinkSupportsInputFormatDetection            = /* 'infd' */ 0x696E6664,
+    BMDDeckLinkHasReferenceInput                       = /* 'hrin' */ 0x6872696E,
+    BMDDeckLinkHasSerialPort                           = /* 'hspt' */ 0x68737074,
+
+    /* Integers */
+
+    BMDDeckLinkMaximumAudioChannels                    = /* 'mach' */ 0x6D616368,
+    BMDDeckLinkNumberOfSubDevices                      = /* 'nsbd' */ 0x6E736264,
+    BMDDeckLinkSubDeviceIndex                          = /* 'subi' */ 0x73756269,
+    BMDDeckLinkVideoOutputConnections                  = /* 'vocn' */ 0x766F636E,
+    BMDDeckLinkVideoInputConnections                   = /* 'vicn' */ 0x7669636E,
+
+    /* Strings */
+
+    BMDDeckLinkSerialPortDeviceName                    = /* 'slpn' */ 0x736C706E
+};
+
+
+/* Enum BMDDeckLinkAPIInformationID - DeckLinkAPI information ID */
+
+typedef uint32_t BMDDeckLinkAPIInformationID;
+enum _BMDDeckLinkAPIInformationID {
+    BMDDeckLinkAPIVersion                              = /* 'vers' */ 0x76657273
+};
+
+
+/* Enum BMDDeckControlMode - DeckControl mode */
+
+typedef uint32_t BMDDeckControlMode;
+enum _BMDDeckControlMode {
+    bmdDeckControlNotOpened                            = /* 'ntop' */ 0x6E746F70,
+    bmdDeckControlVTRControlMode                       = /* 'vtrc' */ 0x76747263,
+    bmdDeckControlExportMode                           = /* 'expm' */ 0x6578706D,
+    bmdDeckControlCaptureMode                          = /* 'capm' */ 0x6361706D
+};
+
+
+/* Enum BMDDeckControlEvent - DeckControl event */
+
+typedef uint32_t BMDDeckControlEvent;
+enum _BMDDeckControlEvent {
+    bmdDeckControlAbortedEvent                         = /* 'abte' */ 0x61627465,	// This event is triggered when a capture or edit-to-tape operation is aborted.
+
+    /* Export-To-Tape events */
+
+    bmdDeckControlPrepareForExportEvent                = /* 'pfee' */ 0x70666565,	// This event is triggered a few frames before reaching the in-point. IDeckLinkInput::StartScheduledPlayback() should be called at this point.
+    bmdDeckControlExportCompleteEvent                  = /* 'exce' */ 0x65786365,	// This event is triggered a few frames after reaching the out-point. At this point, it is safe to stop playback.
+
+    /* Capture events */
+
+    bmdDeckControlPrepareForCaptureEvent               = /* 'pfce' */ 0x70666365,	// This event is triggered a few frames before reaching the in-point. The serial timecode attached to IDeckLinkVideoInputFrames is now valid.
+    bmdDeckControlCaptureCompleteEvent                 = /* 'ccev' */ 0x63636576	// This event is triggered a few frames after reaching the out-point.
+};
+
+
+/* Enum BMDDeckControlVTRControlState - VTR Control state */
+
+typedef uint32_t BMDDeckControlVTRControlState;
+enum _BMDDeckControlVTRControlState {
+    bmdDeckControlNotInVTRControlMode                  = /* 'nvcm' */ 0x6E76636D,
+    bmdDeckControlVTRControlPlaying                    = /* 'vtrp' */ 0x76747270,
+    bmdDeckControlVTRControlRecording                  = /* 'vtrr' */ 0x76747272,
+    bmdDeckControlVTRControlStill                      = /* 'vtra' */ 0x76747261,
+    bmdDeckControlVTRControlSeeking                    = /* 'vtrs' */ 0x76747273,
+    bmdDeckControlVTRControlStopped                    = /* 'vtro' */ 0x7674726F
+};
+
+
+/* Enum BMDDeckControlStatusFlags - Deck Control status flags */
+
+typedef uint32_t BMDDeckControlStatusFlags;
+enum _BMDDeckControlStatusFlags {
+    bmdDeckControlStatusDeckConnected                  = 1 << 0,
+    bmdDeckControlStatusRemoteMode                     = 1 << 1,
+    bmdDeckControlStatusRecordInhibited                = 1 << 2,
+    bmdDeckControlStatusCassetteOut                    = 1 << 3
+};
+
+
+/* Enum BMDDeckControlExportModeOpsFlags - Export mode flags */
+
+typedef uint32_t BMDDeckControlExportModeOpsFlags;
+enum _BMDDeckControlExportModeOpsFlags {
+    bmdDeckControlExportModeInsertVideo                = 1 << 0,
+    bmdDeckControlExportModeInsertAudio1               = 1 << 1,
+    bmdDeckControlExportModeInsertAudio2               = 1 << 2,
+    bmdDeckControlExportModeInsertAudio3               = 1 << 3,
+    bmdDeckControlExportModeInsertAudio4               = 1 << 4,
+    bmdDeckControlExportModeInsertAudio5               = 1 << 5,
+    bmdDeckControlExportModeInsertAudio6               = 1 << 6,
+    bmdDeckControlExportModeInsertAudio7               = 1 << 7,
+    bmdDeckControlExportModeInsertAudio8               = 1 << 8,
+    bmdDeckControlExportModeInsertAudio9               = 1 << 9,
+    bmdDeckControlExportModeInsertAudio10              = 1 << 10,
+    bmdDeckControlExportModeInsertAudio11              = 1 << 11,
+    bmdDeckControlExportModeInsertAudio12              = 1 << 12,
+    bmdDeckControlExportModeInsertTimeCode             = 1 << 13,
+    bmdDeckControlExportModeInsertAssemble             = 1 << 14,
+    bmdDeckControlExportModeInsertPreview              = 1 << 15,
+    bmdDeckControlUseManualExport                      = 1 << 16
+};
+
+
+/* Enum BMDDeckControlError - Deck Control error */
+
+typedef uint32_t BMDDeckControlError;
+enum _BMDDeckControlError {
+    bmdDeckControlNoError                              = /* 'noer' */ 0x6E6F6572,
+    bmdDeckControlModeError                            = /* 'moer' */ 0x6D6F6572,
+    bmdDeckControlMissedInPointError                   = /* 'mier' */ 0x6D696572,
+    bmdDeckControlDeckTimeoutError                     = /* 'dter' */ 0x64746572,
+    bmdDeckControlCommandFailedError                   = /* 'cfer' */ 0x63666572,
+    bmdDeckControlDeviceAlreadyOpenedError             = /* 'dalo' */ 0x64616C6F,
+    bmdDeckControlFailedToOpenDeviceError              = /* 'fder' */ 0x66646572,
+    bmdDeckControlInLocalModeError                     = /* 'lmer' */ 0x6C6D6572,
+    bmdDeckControlEndOfTapeError                       = /* 'eter' */ 0x65746572,
+    bmdDeckControlUserAbortError                       = /* 'uaer' */ 0x75616572,
+    bmdDeckControlNoTapeInDeckError                    = /* 'nter' */ 0x6E746572,
+    bmdDeckControlNoVideoFromCardError                 = /* 'nvfc' */ 0x6E766663,
+    bmdDeckControlNoCommunicationError                 = /* 'ncom' */ 0x6E636F6D,
+    bmdDeckControlUnknownError                         = /* 'uner' */ 0x756E6572
+};
+
+
+/* Enum BMD3DPreviewFormat - Linked Frame preview format */
+
+typedef uint32_t BMD3DPreviewFormat;
+enum _BMD3DPreviewFormat {
+    bmd3DPreviewFormatDefault                          = /* 'defa' */ 0x64656661,
+    bmd3DPreviewFormatLeftOnly                         = /* 'left' */ 0x6C656674,
+    bmd3DPreviewFormatRightOnly                        = /* 'righ' */ 0x72696768,
+    bmd3DPreviewFormatSideBySide                       = /* 'side' */ 0x73696465,
+    bmd3DPreviewFormatTopBottom                        = /* 'topb' */ 0x746F7062
+};
+
+
+#if defined(__cplusplus)
+
+// Forward Declarations
+
+class IDeckLinkVideoOutputCallback;
+class IDeckLinkInputCallback;
+class IDeckLinkMemoryAllocator;
+class IDeckLinkAudioOutputCallback;
+class IDeckLinkIterator;
+class IDeckLinkAPIInformation;
+class IDeckLinkDisplayModeIterator;
+class IDeckLinkDisplayMode;
+class IDeckLink;
+class IDeckLinkOutput;
+class IDeckLinkInput;
+class IDeckLinkTimecode;
+class IDeckLinkVideoFrame;
+class IDeckLinkMutableVideoFrame;
+class IDeckLinkVideoFrame3DExtensions;
+class IDeckLinkVideoInputFrame;
+class IDeckLinkVideoFrameAncillary;
+class IDeckLinkAudioInputPacket;
+class IDeckLinkScreenPreviewCallback;
+class IDeckLinkGLScreenPreviewHelper;
+class IDeckLinkConfiguration;
+class IDeckLinkAttributes;
+class IDeckLinkKeyer;
+class IDeckLinkVideoConversion;
+class IDeckLinkDeckControlStatusCallback;
+class IDeckLinkDeckControl;
+
+
+/* Interface IDeckLinkVideoOutputCallback - Frame completion callback. */
+
+class IDeckLinkVideoOutputCallback : public IUnknown
+{
+public:
+    virtual HRESULT ScheduledFrameCompleted (/* in */ IDeckLinkVideoFrame *completedFrame, /* in */ BMDOutputFrameCompletionResult result) = 0;
+    virtual HRESULT ScheduledPlaybackHasStopped (void) = 0;
+
+protected:
+    virtual ~IDeckLinkVideoOutputCallback () {}; // call Release method to drop reference count
+};
+
+
+/* Interface IDeckLinkInputCallback - Frame arrival callback. */
+
+class IDeckLinkInputCallback : public IUnknown
+{
+public:
+    virtual HRESULT VideoInputFormatChanged (/* in */ BMDVideoInputFormatChangedEvents notificationEvents, /* in */ IDeckLinkDisplayMode *newDisplayMode, /* in */ BMDDetectedVideoInputFormatFlags detectedSignalFlags) = 0;
+    virtual HRESULT VideoInputFrameArrived (/* in */ IDeckLinkVideoInputFrame* videoFrame, /* in */ IDeckLinkAudioInputPacket* audioPacket) = 0;
+
+protected:
+    virtual ~IDeckLinkInputCallback () {}; // call Release method to drop reference count
+};
+
+
+/* Interface IDeckLinkMemoryAllocator - Memory allocator for video frames. */
+
+class IDeckLinkMemoryAllocator : public IUnknown
+{
+public:
+    virtual HRESULT AllocateBuffer (/* in */ uint32_t bufferSize, /* out */ void **allocatedBuffer) = 0;
+    virtual HRESULT ReleaseBuffer (/* in */ void *buffer) = 0;
+
+    virtual HRESULT Commit (void) = 0;
+    virtual HRESULT Decommit (void) = 0;
+};
+
+
+/* Interface IDeckLinkAudioOutputCallback - Optional callback to allow audio samples to be pulled as required. */
+
+class IDeckLinkAudioOutputCallback : public IUnknown
+{
+public:
+    virtual HRESULT RenderAudioSamples (/* in */ bool preroll) = 0;
+};
+
+
+/* Interface IDeckLinkIterator - enumerates installed DeckLink hardware */
+
+class IDeckLinkIterator : public IUnknown
+{
+public:
+    virtual HRESULT Next (/* out */ IDeckLink **deckLinkInstance) = 0;
+};
+
+
+/* Interface IDeckLinkAPIInformation - DeckLinkAPI attribute interface */
+
+class IDeckLinkAPIInformation : public IUnknown
+{
+public:
+    virtual HRESULT GetFlag (/* in */ BMDDeckLinkAPIInformationID cfgID, /* out */ bool *value) = 0;
+    virtual HRESULT GetInt (/* in */ BMDDeckLinkAPIInformationID cfgID, /* out */ int64_t *value) = 0;
+    virtual HRESULT GetFloat (/* in */ BMDDeckLinkAPIInformationID cfgID, /* out */ double *value) = 0;
+    virtual HRESULT GetString (/* in */ BMDDeckLinkAPIInformationID cfgID, /* out */ const char **value) = 0;
+
+protected:
+    virtual ~IDeckLinkAPIInformation () {}; // call Release method to drop reference count
+};
+
+
+/* Interface IDeckLinkDisplayModeIterator - enumerates over supported input/output display modes. */
+
+class IDeckLinkDisplayModeIterator : public IUnknown
+{
+public:
+    virtual HRESULT Next (/* out */ IDeckLinkDisplayMode **deckLinkDisplayMode) = 0;
+
+protected:
+    virtual ~IDeckLinkDisplayModeIterator () {}; // call Release method to drop reference count
+};
+
+
+/* Interface IDeckLinkDisplayMode - represents a display mode */
+
+class IDeckLinkDisplayMode : public IUnknown
+{
+public:
+    virtual HRESULT GetName (/* out */ const char **name) = 0;
+    virtual BMDDisplayMode GetDisplayMode (void) = 0;
+    virtual long GetWidth (void) = 0;
+    virtual long GetHeight (void) = 0;
+    virtual HRESULT GetFrameRate (/* out */ BMDTimeValue *frameDuration, /* out */ BMDTimeScale *timeScale) = 0;
+    virtual BMDFieldDominance GetFieldDominance (void) = 0;
+    virtual BMDDisplayModeFlags GetFlags (void) = 0;
+
+protected:
+    virtual ~IDeckLinkDisplayMode () {}; // call Release method to drop reference count
+};
+
+
+/* Interface IDeckLink - represents a DeckLink device */
+
+class IDeckLink : public IUnknown
+{
+public:
+    virtual HRESULT GetModelName (/* out */ const char **modelName) = 0;
+};
+
+
+/* Interface IDeckLinkOutput - Created by QueryInterface from IDeckLink. */
+
+class IDeckLinkOutput : public IUnknown
+{
+public:
+    virtual HRESULT DoesSupportVideoMode (/* in */ BMDDisplayMode displayMode, /* in */ BMDPixelFormat pixelFormat, /* in */ BMDVideoOutputFlags flags, /* out */ BMDDisplayModeSupport *result, /* out */ IDeckLinkDisplayMode **resultDisplayMode) = 0;
+    virtual HRESULT GetDisplayModeIterator (/* out */ IDeckLinkDisplayModeIterator **iterator) = 0;
+
+    virtual HRESULT SetScreenPreviewCallback (/* in */ IDeckLinkScreenPreviewCallback *previewCallback) = 0;
+
+    /* Video Output */
+
+    virtual HRESULT EnableVideoOutput (/* in */ BMDDisplayMode displayMode, /* in */ BMDVideoOutputFlags flags) = 0;
+    virtual HRESULT DisableVideoOutput (void) = 0;
+
+    virtual HRESULT SetVideoOutputFrameMemoryAllocator (/* in */ IDeckLinkMemoryAllocator *theAllocator) = 0;
+    virtual HRESULT CreateVideoFrame (/* in */ int32_t width, /* in */ int32_t height, /* in */ int32_t rowBytes, /* in */ BMDPixelFormat pixelFormat, /* in */ BMDFrameFlags flags, /* out */ IDeckLinkMutableVideoFrame **outFrame) = 0;
+    virtual HRESULT CreateAncillaryData (/* in */ BMDPixelFormat pixelFormat, /* out */ IDeckLinkVideoFrameAncillary **outBuffer) = 0;
+
+    virtual HRESULT DisplayVideoFrameSync (/* in */ IDeckLinkVideoFrame *theFrame) = 0;
+    virtual HRESULT ScheduleVideoFrame (/* in */ IDeckLinkVideoFrame *theFrame, /* in */ BMDTimeValue displayTime, /* in */ BMDTimeValue displayDuration, /* in */ BMDTimeScale timeScale) = 0;
+    virtual HRESULT SetScheduledFrameCompletionCallback (/* in */ IDeckLinkVideoOutputCallback *theCallback) = 0;
+    virtual HRESULT GetBufferedVideoFrameCount (/* out */ uint32_t *bufferedFrameCount) = 0;
+
+    /* Audio Output */
+
+    virtual HRESULT EnableAudioOutput (/* in */ BMDAudioSampleRate sampleRate, /* in */ BMDAudioSampleType sampleType, /* in */ uint32_t channelCount, /* in */ BMDAudioOutputStreamType streamType) = 0;
+    virtual HRESULT DisableAudioOutput (void) = 0;
+
+    virtual HRESULT WriteAudioSamplesSync (/* in */ void *buffer, /* in */ uint32_t sampleFrameCount, /* out */ uint32_t *sampleFramesWritten) = 0;
+
+    virtual HRESULT BeginAudioPreroll (void) = 0;
+    virtual HRESULT EndAudioPreroll (void) = 0;
+    virtual HRESULT ScheduleAudioSamples (/* in */ void *buffer, /* in */ uint32_t sampleFrameCount, /* in */ BMDTimeValue streamTime, /* in */ BMDTimeScale timeScale, /* out */ uint32_t *sampleFramesWritten) = 0;
+
+    virtual HRESULT GetBufferedAudioSampleFrameCount (/* out */ uint32_t *bufferedSampleFrameCount) = 0;
+    virtual HRESULT FlushBufferedAudioSamples (void) = 0;
+
+    virtual HRESULT SetAudioCallback (/* in */ IDeckLinkAudioOutputCallback *theCallback) = 0;
+
+    /* Output Control */
+
+    virtual HRESULT StartScheduledPlayback (/* in */ BMDTimeValue playbackStartTime, /* in */ BMDTimeScale timeScale, /* in */ double playbackSpeed) = 0;
+    virtual HRESULT StopScheduledPlayback (/* in */ BMDTimeValue stopPlaybackAtTime, /* out */ BMDTimeValue *actualStopTime, /* in */ BMDTimeScale timeScale) = 0;
+    virtual HRESULT IsScheduledPlaybackRunning (/* out */ bool *active) = 0;
+    virtual HRESULT GetScheduledStreamTime (/* in */ BMDTimeScale desiredTimeScale, /* out */ BMDTimeValue *streamTime, /* out */ double *playbackSpeed) = 0;
+    virtual HRESULT GetReferenceStatus (/* out */ BMDReferenceStatus *referenceStatus) = 0;
+
+    /* Hardware Timing */
+
+    virtual HRESULT GetHardwareReferenceClock (/* in */ BMDTimeScale desiredTimeScale, /* out */ BMDTimeValue *hardwareTime, /* out */ BMDTimeValue *timeInFrame, /* out */ BMDTimeValue *ticksPerFrame) = 0;
+
+protected:
+    virtual ~IDeckLinkOutput () {}; // call Release method to drop reference count
+};
+
+
+/* Interface IDeckLinkInput - Created by QueryInterface from IDeckLink. */
+
+class IDeckLinkInput : public IUnknown
+{
+public:
+    virtual HRESULT DoesSupportVideoMode (/* in */ BMDDisplayMode displayMode, /* in */ BMDPixelFormat pixelFormat, /* in */ BMDVideoInputFlags flags, /* out */ BMDDisplayModeSupport *result, /* out */ IDeckLinkDisplayMode **resultDisplayMode) = 0;
+    virtual HRESULT GetDisplayModeIterator (/* out */ IDeckLinkDisplayModeIterator **iterator) = 0;
+
+    virtual HRESULT SetScreenPreviewCallback (/* in */ IDeckLinkScreenPreviewCallback *previewCallback) = 0;
+
+    /* Video Input */
+
+    virtual HRESULT EnableVideoInput (/* in */ BMDDisplayMode displayMode, /* in */ BMDPixelFormat pixelFormat, /* in */ BMDVideoInputFlags flags) = 0;
+    virtual HRESULT DisableVideoInput (void) = 0;
+    virtual HRESULT GetAvailableVideoFrameCount (/* out */ uint32_t *availableFrameCount) = 0;
+
+    /* Audio Input */
+
+    virtual HRESULT EnableAudioInput (/* in */ BMDAudioSampleRate sampleRate, /* in */ BMDAudioSampleType sampleType, /* in */ uint32_t channelCount) = 0;
+    virtual HRESULT DisableAudioInput (void) = 0;
+    virtual HRESULT GetAvailableAudioSampleFrameCount (/* out */ uint32_t *availableSampleFrameCount) = 0;
+
+    /* Input Control */
+
+    virtual HRESULT StartStreams (void) = 0;
+    virtual HRESULT StopStreams (void) = 0;
+    virtual HRESULT PauseStreams (void) = 0;
+    virtual HRESULT FlushStreams (void) = 0;
+    virtual HRESULT SetCallback (/* in */ IDeckLinkInputCallback *theCallback) = 0;
+
+    /* Hardware Timing */
+
+    virtual HRESULT GetHardwareReferenceClock (/* in */ BMDTimeScale desiredTimeScale, /* out */ BMDTimeValue *hardwareTime, /* out */ BMDTimeValue *timeInFrame, /* out */ BMDTimeValue *ticksPerFrame) = 0;
+
+protected:
+    virtual ~IDeckLinkInput () {}; // call Release method to drop reference count
+};
+
+
+/* Interface IDeckLinkTimecode - Used for video frame timecode representation. */
+
+class IDeckLinkTimecode : public IUnknown
+{
+public:
+    virtual BMDTimecodeBCD GetBCD (void) = 0;
+    virtual HRESULT GetComponents (/* out */ uint8_t *hours, /* out */ uint8_t *minutes, /* out */ uint8_t *seconds, /* out */ uint8_t *frames) = 0;
+    virtual HRESULT GetString (/* out */ const char **timecode) = 0;
+    virtual BMDTimecodeFlags GetFlags (void) = 0;
+    virtual HRESULT GetTimecodeUserBits (/* out */ BMDTimecodeUserBits *userBits) = 0;
+
+protected:
+    virtual ~IDeckLinkTimecode () {}; // call Release method to drop reference count
+};
+
+
+/* Interface IDeckLinkVideoFrame - Interface to encapsulate a video frame; can be caller-implemented. */
+
+class IDeckLinkVideoFrame : public IUnknown
+{
+public:
+    virtual long GetWidth (void) = 0;
+    virtual long GetHeight (void) = 0;
+    virtual long GetRowBytes (void) = 0;
+    virtual BMDPixelFormat GetPixelFormat (void) = 0;
+    virtual BMDFrameFlags GetFlags (void) = 0;
+    virtual HRESULT GetBytes (/* out */ void **buffer) = 0;
+
+    virtual HRESULT GetTimecode (/* in */ BMDTimecodeFormat format, /* out */ IDeckLinkTimecode **timecode) = 0;
+    virtual HRESULT GetAncillaryData (/* out */ IDeckLinkVideoFrameAncillary **ancillary) = 0;
+
+protected:
+    virtual ~IDeckLinkVideoFrame () {}; // call Release method to drop reference count
+};
+
+
+/* Interface IDeckLinkMutableVideoFrame - Created by IDeckLinkOutput::CreateVideoFrame. */
+
+class IDeckLinkMutableVideoFrame : public IDeckLinkVideoFrame
+{
+public:
+    virtual HRESULT SetFlags (/* in */ BMDFrameFlags newFlags) = 0;
+
+    virtual HRESULT SetTimecode (/* in */ BMDTimecodeFormat format, /* in */ IDeckLinkTimecode *timecode) = 0;
+    virtual HRESULT SetTimecodeFromComponents (/* in */ BMDTimecodeFormat format, /* in */ uint8_t hours, /* in */ uint8_t minutes, /* in */ uint8_t seconds, /* in */ uint8_t frames, /* in */ BMDTimecodeFlags flags) = 0;
+    virtual HRESULT SetAncillaryData (/* in */ IDeckLinkVideoFrameAncillary *ancillary) = 0;
+    virtual HRESULT SetTimecodeUserBits (/* in */ BMDTimecodeFormat format, /* in */ BMDTimecodeUserBits userBits) = 0;
+
+protected:
+    virtual ~IDeckLinkMutableVideoFrame () {}; // call Release method to drop reference count
+};
+
+
+/* Interface IDeckLinkVideoFrame3DExtensions - Optional interface implemented on IDeckLinkVideoFrame to support 3D frames */
+
+class IDeckLinkVideoFrame3DExtensions : public IUnknown
+{
+public:
+    virtual BMDVideo3DPackingFormat Get3DPackingFormat (void) = 0;
+    virtual HRESULT GetFrameForRightEye (/* out */ IDeckLinkVideoFrame* *rightEyeFrame) = 0;
+
+protected:
+    virtual ~IDeckLinkVideoFrame3DExtensions () {}; // call Release method to drop reference count
+};
+
+
+/* Interface IDeckLinkVideoInputFrame - Provided by the IDeckLinkVideoInput frame arrival callback. */
+
+class IDeckLinkVideoInputFrame : public IDeckLinkVideoFrame
+{
+public:
+    virtual HRESULT GetStreamTime (/* out */ BMDTimeValue *frameTime, /* out */ BMDTimeValue *frameDuration, /* in */ BMDTimeScale timeScale) = 0;
+    virtual HRESULT GetHardwareReferenceTimestamp (/* in */ BMDTimeScale timeScale, /* out */ BMDTimeValue *frameTime, /* out */ BMDTimeValue *frameDuration) = 0;
+
+protected:
+    virtual ~IDeckLinkVideoInputFrame () {}; // call Release method to drop reference count
+};
+
+
+/* Interface IDeckLinkVideoFrameAncillary - Obtained through QueryInterface() on an IDeckLinkVideoFrame object. */
+
+class IDeckLinkVideoFrameAncillary : public IUnknown
+{
+public:
+
+    virtual HRESULT GetBufferForVerticalBlankingLine (/* in */ uint32_t lineNumber, /* out */ void **buffer) = 0;
+    virtual BMDPixelFormat GetPixelFormat (void) = 0;
+    virtual BMDDisplayMode GetDisplayMode (void) = 0;
+
+protected:
+    virtual ~IDeckLinkVideoFrameAncillary () {}; // call Release method to drop reference count
+};
+
+
+/* Interface IDeckLinkAudioInputPacket - Provided by the IDeckLinkInput callback. */
+
+class IDeckLinkAudioInputPacket : public IUnknown
+{
+public:
+    virtual long GetSampleFrameCount (void) = 0;
+    virtual HRESULT GetBytes (/* out */ void **buffer) = 0;
+    virtual HRESULT GetPacketTime (/* out */ BMDTimeValue *packetTime, /* in */ BMDTimeScale timeScale) = 0;
+
+protected:
+    virtual ~IDeckLinkAudioInputPacket () {}; // call Release method to drop reference count
+};
+
+
+/* Interface IDeckLinkScreenPreviewCallback - Screen preview callback */
+
+class IDeckLinkScreenPreviewCallback : public IUnknown
+{
+public:
+    virtual HRESULT DrawFrame (/* in */ IDeckLinkVideoFrame *theFrame) = 0;
+
+protected:
+    virtual ~IDeckLinkScreenPreviewCallback () {}; // call Release method to drop reference count
+};
+
+
+/* Interface IDeckLinkGLScreenPreviewHelper - Created with CoCreateInstance(). */
+
+class IDeckLinkGLScreenPreviewHelper : public IUnknown
+{
+public:
+
+    /* Methods must be called with OpenGL context set */
+
+    virtual HRESULT InitializeGL (void) = 0;
+    virtual HRESULT PaintGL (void) = 0;
+    virtual HRESULT SetFrame (/* in */ IDeckLinkVideoFrame *theFrame) = 0;
+    virtual HRESULT Set3DPreviewFormat (/* in */ BMD3DPreviewFormat previewFormat) = 0;
+
+protected:
+    virtual ~IDeckLinkGLScreenPreviewHelper () {}; // call Release method to drop reference count
+};
+
+
+/* Interface IDeckLinkConfiguration - DeckLink Configuration interface */
+
+class IDeckLinkConfiguration : public IUnknown
+{
+public:
+    virtual HRESULT SetFlag (/* in */ BMDDeckLinkConfigurationID cfgID, /* in */ bool value) = 0;
+    virtual HRESULT GetFlag (/* in */ BMDDeckLinkConfigurationID cfgID, /* out */ bool *value) = 0;
+    virtual HRESULT SetInt (/* in */ BMDDeckLinkConfigurationID cfgID, /* in */ int64_t value) = 0;
+    virtual HRESULT GetInt (/* in */ BMDDeckLinkConfigurationID cfgID, /* out */ int64_t *value) = 0;
+    virtual HRESULT SetFloat (/* in */ BMDDeckLinkConfigurationID cfgID, /* in */ double value) = 0;
+    virtual HRESULT GetFloat (/* in */ BMDDeckLinkConfigurationID cfgID, /* out */ double *value) = 0;
+    virtual HRESULT SetString (/* in */ BMDDeckLinkConfigurationID cfgID, /* in */ const char *value) = 0;
+    virtual HRESULT GetString (/* in */ BMDDeckLinkConfigurationID cfgID, /* out */ const char **value) = 0;
+    virtual HRESULT WriteConfigurationToPreferences (void) = 0;
+
+protected:
+    virtual ~IDeckLinkConfiguration () {}; // call Release method to drop reference count
+};
+
+
+/* Interface IDeckLinkAttributes - DeckLink Attribute interface */
+
+class IDeckLinkAttributes : public IUnknown
+{
+public:
+    virtual HRESULT GetFlag (/* in */ BMDDeckLinkAttributeID cfgID, /* out */ bool *value) = 0;
+    virtual HRESULT GetInt (/* in */ BMDDeckLinkAttributeID cfgID, /* out */ int64_t *value) = 0;
+    virtual HRESULT GetFloat (/* in */ BMDDeckLinkAttributeID cfgID, /* out */ double *value) = 0;
+    virtual HRESULT GetString (/* in */ BMDDeckLinkAttributeID cfgID, /* out */ const char **value) = 0;
+
+protected:
+    virtual ~IDeckLinkAttributes () {}; // call Release method to drop reference count
+};
+
+
+/* Interface IDeckLinkKeyer - DeckLink Keyer interface */
+
+class IDeckLinkKeyer : public IUnknown
+{
+public:
+    virtual HRESULT Enable (/* in */ bool isExternal) = 0;
+    virtual HRESULT SetLevel (/* in */ uint8_t level) = 0;
+    virtual HRESULT RampUp (/* in */ uint32_t numberOfFrames) = 0;
+    virtual HRESULT RampDown (/* in */ uint32_t numberOfFrames) = 0;
+    virtual HRESULT Disable (void) = 0;
+
+protected:
+    virtual ~IDeckLinkKeyer () {}; // call Release method to drop reference count
+};
+
+
+/* Interface IDeckLinkVideoConversion - Created with CoCreateInstance(). */
+
+class IDeckLinkVideoConversion : public IUnknown
+{
+public:
+    virtual HRESULT ConvertFrame (/* in */ IDeckLinkVideoFrame* srcFrame, /* in */ IDeckLinkVideoFrame* dstFrame) = 0;
+
+protected:
+    virtual ~IDeckLinkVideoConversion () {}; // call Release method to drop reference count
+};
+
+
+/* Interface IDeckLinkDeckControlStatusCallback - Deck control state change callback. */
+
+class IDeckLinkDeckControlStatusCallback : public IUnknown
+{
+public:
+    virtual HRESULT TimecodeUpdate (/* in */ BMDTimecodeBCD currentTimecode) = 0;
+    virtual HRESULT VTRControlStateChanged (/* in */ BMDDeckControlVTRControlState newState, /* in */ BMDDeckControlError error) = 0;
+    virtual HRESULT DeckControlEventReceived (/* in */ BMDDeckControlEvent event, /* in */ BMDDeckControlError error) = 0;
+    virtual HRESULT DeckControlStatusChanged (/* in */ BMDDeckControlStatusFlags flags, /* in */ uint32_t mask) = 0;
+
+protected:
+    virtual ~IDeckLinkDeckControlStatusCallback () {}; // call Release method to drop reference count
+};
+
+
+/* Interface IDeckLinkDeckControl - Deck Control main interface */
+
+class IDeckLinkDeckControl : public IUnknown
+{
+public:
+    virtual HRESULT Open (/* in */ BMDTimeScale timeScale, /* in */ BMDTimeValue timeValue, /* in */ bool timecodeIsDropFrame, /* out */ BMDDeckControlError *error) = 0;
+    virtual HRESULT Close (/* in */ bool standbyOn) = 0;
+    virtual HRESULT GetCurrentState (/* out */ BMDDeckControlMode *mode, /* out */ BMDDeckControlVTRControlState *vtrControlState, /* out */ BMDDeckControlStatusFlags *flags) = 0;
+    virtual HRESULT SetStandby (/* in */ bool standbyOn) = 0;
+    virtual HRESULT Play (/* out */ BMDDeckControlError *error) = 0;
+    virtual HRESULT Stop (/* out */ BMDDeckControlError *error) = 0;
+    virtual HRESULT TogglePlayStop (/* out */ BMDDeckControlError *error) = 0;
+    virtual HRESULT Eject (/* out */ BMDDeckControlError *error) = 0;
+    virtual HRESULT GoToTimecode (/* in */ BMDTimecodeBCD timecode, /* out */ BMDDeckControlError *error) = 0;
+    virtual HRESULT FastForward (/* in */ bool viewTape, /* out */ BMDDeckControlError *error) = 0;
+    virtual HRESULT Rewind (/* in */ bool viewTape, /* out */ BMDDeckControlError *error) = 0;
+    virtual HRESULT StepForward (/* out */ BMDDeckControlError *error) = 0;
+    virtual HRESULT StepBack (/* out */ BMDDeckControlError *error) = 0;
+    virtual HRESULT Jog (/* in */ double rate, /* out */ BMDDeckControlError *error) = 0;
+    virtual HRESULT Shuttle (/* in */ double rate, /* out */ BMDDeckControlError *error) = 0;
+    virtual HRESULT GetTimecodeString (/* out */ const char **currentTimeCode, /* out */ BMDDeckControlError *error) = 0;
+    virtual HRESULT GetTimecode (/* out */ IDeckLinkTimecode **currentTimecode, /* out */ BMDDeckControlError *error) = 0;
+    virtual HRESULT GetTimecodeBCD (/* out */ BMDTimecodeBCD *currentTimecode, /* out */ BMDDeckControlError *error) = 0;
+    virtual HRESULT SetPreroll (/* in */ uint32_t prerollSeconds) = 0;
+    virtual HRESULT GetPreroll (/* out */ uint32_t *prerollSeconds) = 0;
+    virtual HRESULT SetExportOffset (/* in */ int32_t exportOffsetFields) = 0;
+    virtual HRESULT GetExportOffset (/* out */ int32_t *exportOffsetFields) = 0;
+    virtual HRESULT GetManualExportOffset (/* out */ int32_t *deckManualExportOffsetFields) = 0;
+    virtual HRESULT SetCaptureOffset (/* in */ int32_t captureOffsetFields) = 0;
+    virtual HRESULT GetCaptureOffset (/* out */ int32_t *captureOffsetFields) = 0;
+    virtual HRESULT StartExport (/* in */ BMDTimecodeBCD inTimecode, /* in */ BMDTimecodeBCD outTimecode, /* in */ BMDDeckControlExportModeOpsFlags exportModeOps, /* out */ BMDDeckControlError *error) = 0;
+    virtual HRESULT StartCapture (/* in */ bool useVITC, /* in */ BMDTimecodeBCD inTimecode, /* in */ BMDTimecodeBCD outTimecode, /* out */ BMDDeckControlError *error) = 0;
+    virtual HRESULT GetDeviceID (/* out */ uint16_t *deviceId, /* out */ BMDDeckControlError *error) = 0;
+    virtual HRESULT Abort (void) = 0;
+    virtual HRESULT CrashRecordStart (/* out */ BMDDeckControlError *error) = 0;
+    virtual HRESULT CrashRecordStop (/* out */ BMDDeckControlError *error) = 0;
+    virtual HRESULT SetCallback (/* in */ IDeckLinkDeckControlStatusCallback *callback) = 0;
+
+protected:
+    virtual ~IDeckLinkDeckControl () {}; // call Release method to drop reference count
+};
+
+
+/* Functions */
+
+extern "C" {
+
+    IDeckLinkIterator* CreateDeckLinkIteratorInstance (void);
+    IDeckLinkGLScreenPreviewHelper* CreateOpenGLScreenPreviewHelper (void);
+    IDeckLinkVideoConversion* CreateVideoConversionInstance (void);
+
+};
+
+
+#endif      // defined(__cplusplus)
+#endif      // __DeckLink_API_h__
diff --git a/sys/decklink/DeckLinkAPIDispatch.cpp b/sys/decklink/DeckLinkAPIDispatch.cpp
new file mode 100644
index 000000000..72607782d
--- /dev/null
+++ b/sys/decklink/DeckLinkAPIDispatch.cpp
@@ -0,0 +1,110 @@
+/* -LICENSE-START-
+** Copyright (c) 2009 Blackmagic Design
+**
+** Permission is hereby granted, free of charge, to any person or organization
+** obtaining a copy of the software and accompanying documentation covered by
+** this license (the "Software") to use, reproduce, display, distribute,
+** execute, and transmit the Software, and to prepare derivative works of the
+** Software, and to permit third-parties to whom the Software is furnished to
+** do so, all subject to the following:
+** 
+** The copyright notices in the Software and this entire statement, including
+** the above license grant, this restriction and the following disclaimer,
+** must be included in all copies of the Software, in whole or in part, and
+** all derivative works of the Software, unless such copies or derivative
+** works are solely in the form of machine-executable object code generated by
+** a source language processor.
+** 
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+** SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+** FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+** ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+** DEALINGS IN THE SOFTWARE.
+** -LICENSE-END-
+**/
+
+#include <stdio.h>
+#include <pthread.h>
+#include <dlfcn.h>
+
+#include "DeckLinkAPI.h"
+
+#define kDeckLinkAPI_Name "libDeckLinkAPI.so"
+#define KDeckLinkPreviewAPI_Name "libDeckLinkPreviewAPI.so"
+
+typedef IDeckLinkIterator* (*CreateIteratorFunc)(void);
+typedef IDeckLinkGLScreenPreviewHelper* (*CreateOpenGLScreenPreviewHelperFunc)(void);
+typedef IDeckLinkVideoConversion* (*CreateVideoConversionInstanceFunc)(void);
+
+static pthread_once_t					gDeckLinkOnceControl = PTHREAD_ONCE_INIT;
+static pthread_once_t					gPreviewOnceControl = PTHREAD_ONCE_INIT;
+
+static CreateIteratorFunc					gCreateIteratorFunc = NULL;
+static CreateOpenGLScreenPreviewHelperFunc	gCreateOpenGLPreviewFunc = NULL;
+static CreateVideoConversionInstanceFunc	gCreateVideoConversionFunc	= NULL;
+
+static
+void	InitDeckLinkAPI (void)
+{
+	void *libraryHandle;
+	
+	libraryHandle = dlopen(kDeckLinkAPI_Name, RTLD_NOW|RTLD_GLOBAL);
+	if (!libraryHandle)
+	{
+		fprintf(stderr, "%s\n", dlerror());
+		return;
+	}
+	gCreateIteratorFunc = (CreateIteratorFunc)dlsym(libraryHandle, "CreateDeckLinkIteratorInstance_0001");
+	if (!gCreateIteratorFunc)
+		fprintf(stderr, "%s\n", dlerror());
+	gCreateVideoConversionFunc = (CreateVideoConversionInstanceFunc)dlsym(libraryHandle, "CreateVideoConversionInstance_0001");
+	if (!gCreateVideoConversionFunc)
+		fprintf(stderr, "%s\n", dlerror());
+}
+
+static
+void	InitDeckLinkPreviewAPI (void)
+{
+	void *libraryHandle;
+	
+	libraryHandle = dlopen(KDeckLinkPreviewAPI_Name, RTLD_NOW|RTLD_GLOBAL);
+	if (!libraryHandle)
+	{
+		fprintf(stderr, "%s\n", dlerror());
+		return;
+	}
+	gCreateOpenGLPreviewFunc = (CreateOpenGLScreenPreviewHelperFunc)dlsym(libraryHandle, "CreateOpenGLScreenPreviewHelper_0001");
+	if (!gCreateOpenGLPreviewFunc)
+		fprintf(stderr, "%s\n", dlerror());
+}
+
+IDeckLinkIterator*		CreateDeckLinkIteratorInstance (void)
+{
+	pthread_once(&gDeckLinkOnceControl, InitDeckLinkAPI);
+	
+	if (gCreateIteratorFunc == NULL)
+		return NULL;
+	return gCreateIteratorFunc();
+}
+
+IDeckLinkGLScreenPreviewHelper*		CreateOpenGLScreenPreviewHelper (void)
+{
+	pthread_once(&gDeckLinkOnceControl, InitDeckLinkAPI);
+	pthread_once(&gPreviewOnceControl, InitDeckLinkPreviewAPI);
+	
+	if (gCreateOpenGLPreviewFunc == NULL)
+		return NULL;
+	return gCreateOpenGLPreviewFunc();
+}
+
+IDeckLinkVideoConversion* CreateVideoConversionInstance (void)
+{
+	pthread_once(&gDeckLinkOnceControl, InitDeckLinkAPI);
+	
+	if (gCreateVideoConversionFunc == NULL)
+		return NULL;
+	return gCreateVideoConversionFunc();
+}
+
diff --git a/sys/decklink/LinuxCOM.h b/sys/decklink/LinuxCOM.h
new file mode 100644
index 000000000..2b13697d2
--- /dev/null
+++ b/sys/decklink/LinuxCOM.h
@@ -0,0 +1,99 @@
+/* -LICENSE-START-
+** Copyright (c) 2009 Blackmagic Design
+**
+** Permission is hereby granted, free of charge, to any person or organization
+** obtaining a copy of the software and accompanying documentation covered by
+** this license (the "Software") to use, reproduce, display, distribute,
+** execute, and transmit the Software, and to prepare derivative works of the
+** Software, and to permit third-parties to whom the Software is furnished to
+** do so, all subject to the following:
+** 
+** The copyright notices in the Software and this entire statement, including
+** the above license grant, this restriction and the following disclaimer,
+** must be included in all copies of the Software, in whole or in part, and
+** all derivative works of the Software, unless such copies or derivative
+** works are solely in the form of machine-executable object code generated by
+** a source language processor.
+** 
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+** SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+** FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+** ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+** DEALINGS IN THE SOFTWARE.
+** -LICENSE-END-
+*/
+
+#ifndef __LINUX_COM_H_
+#define __LINUX_COM_H_
+
+struct REFIID
+{	
+	unsigned char byte0;
+	unsigned char byte1;
+	unsigned char byte2;
+	unsigned char byte3;
+	unsigned char byte4;
+	unsigned char byte5;
+	unsigned char byte6;
+	unsigned char byte7;
+	unsigned char byte8;
+	unsigned char byte9;
+	unsigned char byte10;
+	unsigned char byte11;
+	unsigned char byte12;
+	unsigned char byte13;
+	unsigned char byte14;
+	unsigned char byte15;
+};
+
+typedef REFIID CFUUIDBytes;
+#define CFUUIDGetUUIDBytes(x)	x
+
+typedef int HRESULT;
+typedef unsigned long ULONG;
+typedef void *LPVOID;
+
+#define SUCCEEDED(Status) ((HRESULT)(Status) >= 0)
+#define FAILED(Status) ((HRESULT)(Status)<0)
+
+#define IS_ERROR(Status) ((unsigned long)(Status) >> 31 == SEVERITY_ERROR)
+#define HRESULT_CODE(hr) ((hr) & 0xFFFF)
+#define HRESULT_FACILITY(hr) (((hr) >> 16) & 0x1fff)
+#define HRESULT_SEVERITY(hr) (((hr) >> 31) & 0x1)
+#define SEVERITY_SUCCESS 0
+#define SEVERITY_ERROR 1
+
+#define MAKE_HRESULT(sev,fac,code) ((HRESULT) (((unsigned long)(sev)<<31) | ((unsigned long)(fac)<<16) | ((unsigned long)(code))) )
+
+#define S_OK ((HRESULT)0x00000000L)
+#define S_FALSE ((HRESULT)0x00000001L)
+#define E_UNEXPECTED ((HRESULT)0x8000FFFFL)
+#define E_NOTIMPL ((HRESULT)0x80000001L)
+#define E_OUTOFMEMORY ((HRESULT)0x80000002L)
+#define E_INVALIDARG ((HRESULT)0x80000003L)
+#define E_NOINTERFACE ((HRESULT)0x80000004L)
+#define E_POINTER ((HRESULT)0x80000005L)
+#define E_HANDLE ((HRESULT)0x80000006L)
+#define E_ABORT ((HRESULT)0x80000007L)
+#define E_FAIL ((HRESULT)0x80000008L)
+#define E_ACCESSDENIED ((HRESULT)0x80000009L)
+
+#define STDMETHODCALLTYPE
+
+#define IID_IUnknown		(REFIID){0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}
+#define IUnknownUUID		IID_IUnknown
+
+#ifdef __cplusplus
+class IUnknown
+{
+    public:
+    	virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, LPVOID *ppv) = 0;
+    	virtual ULONG STDMETHODCALLTYPE AddRef(void) = 0;
+    	virtual ULONG STDMETHODCALLTYPE Release(void) = 0;
+};
+#endif
+
+#endif 
+
diff --git a/sys/decklink/Makefile.am b/sys/decklink/Makefile.am
new file mode 100644
index 000000000..60ec13441
--- /dev/null
+++ b/sys/decklink/Makefile.am
@@ -0,0 +1,25 @@
+plugin_LTLIBRARIES = libgstdecklink.la
+
+libgstdecklink_la_CPPFLAGS = \
+	$(GST_PLUGINS_BAD_CXXFLAGS) \
+	$(GST_PLUGINS_BASE_CXXFLAGS) \
+	$(GST_CXXFLAGS) \
+	$(DECKLINK_CXXFLAGS)
+libgstdecklink_la_LIBADD = \
+	$(GST_PLUGINS_BASE_LIBS) -lgstvideo-$(GST_MAJORMINOR) \
+	$(GST_BASE_LIBS) \
+	$(GST_LIBS) \
+	$(DECKLINK_LIBS)
+libgstdecklink_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS) $(LIBM)
+libgstdecklink_la_LIBTOOLFLAGS = --tag=disable-static
+
+libgstdecklink_la_SOURCES = \
+	gstdecklinksrc.cpp \
+	gstdecklinksrc.h \
+	gstdecklinksink.cpp \
+	gstdecklinksink.h \
+	gstdecklink.cpp \
+	capture.cpp \
+	capture.h \
+	DeckLinkAPIDispatch.cpp
+
diff --git a/sys/decklink/capture.cpp b/sys/decklink/capture.cpp
new file mode 100644
index 000000000..20bd660c9
--- /dev/null
+++ b/sys/decklink/capture.cpp
@@ -0,0 +1,430 @@
+/* -LICENSE-START-
+** Copyright (c) 2009 Blackmagic Design
+**
+** Permission is hereby granted, free of charge, to any person or organization
+** obtaining a copy of the software and accompanying documentation covered by
+** this license (the "Software") to use, reproduce, display, distribute,
+** execute, and transmit the Software, and to prepare derivative works of the
+** Software, and to permit third-parties to whom the Software is furnished to
+** do so, all subject to the following:
+** 
+** The copyright notices in the Software and this entire statement, including
+** the above license grant, this restriction and the following disclaimer,
+** must be included in all copies of the Software, in whole or in part, and
+** all derivative works of the Software, unless such copies or derivative
+** works are solely in the form of machine-executable object code generated by
+** a source language processor.
+** 
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+** SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+** FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+** ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+** DEALINGS IN THE SOFTWARE.
+** -LICENSE-END-
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include "gstdecklinksrc.h"
+
+#include "DeckLinkAPI.h"
+#include "capture.h"
+
+
+int videoOutputFile = -1;
+int audioOutputFile = -1;
+
+IDeckLink *deckLink;
+IDeckLinkInput *deckLinkInput;
+IDeckLinkDisplayModeIterator *displayModeIterator;
+
+static BMDTimecodeFormat g_timecodeFormat = 0;
+
+DeckLinkCaptureDelegate::DeckLinkCaptureDelegate ():m_refCount (0)
+{
+  pthread_mutex_init (&m_mutex, NULL);
+}
+
+DeckLinkCaptureDelegate::~DeckLinkCaptureDelegate ()
+{
+  pthread_mutex_destroy (&m_mutex);
+}
+
+ULONG
+DeckLinkCaptureDelegate::AddRef (void)
+{
+  pthread_mutex_lock (&m_mutex);
+  m_refCount++;
+  pthread_mutex_unlock (&m_mutex);
+
+  return (ULONG) m_refCount;
+}
+
+ULONG
+DeckLinkCaptureDelegate::Release (void)
+{
+  pthread_mutex_lock (&m_mutex);
+  m_refCount--;
+  pthread_mutex_unlock (&m_mutex);
+
+  if (m_refCount == 0) {
+    delete this;
+    return 0;
+  }
+
+  return (ULONG) m_refCount;
+}
+
+HRESULT
+DeckLinkCaptureDelegate::VideoInputFrameArrived (IDeckLinkVideoInputFrame *
+    videoFrame, IDeckLinkAudioInputPacket * audioFrame)
+{
+  GstDecklinkSrc *decklinksrc = GST_DECKLINK_SRC (priv);
+
+  // Handle Video Frame
+  if (videoFrame) {
+    if (videoFrame->GetFlags () & bmdFrameHasNoInputSource) {
+      GST_DEBUG("Frame received - No input signal detected");
+    } else {
+      const char *timecodeString = NULL;
+      if (g_timecodeFormat != 0) {
+        IDeckLinkTimecode *timecode;
+        if (videoFrame->GetTimecode (g_timecodeFormat, &timecode) == S_OK) {
+          timecode->GetString (&timecodeString);
+        }
+      }
+
+      GST_DEBUG("Frame received [%s] - %s - Size: %li bytes",
+          timecodeString != NULL ? timecodeString : "No timecode",
+          "Valid Frame",
+          videoFrame->GetRowBytes () * videoFrame->GetHeight ());
+
+      if (timecodeString)
+        free ((void *) timecodeString);
+
+      g_mutex_lock (decklinksrc->mutex);
+      if (decklinksrc->video_frame != NULL) {
+        decklinksrc->dropped_frames++;
+      } else {
+        videoFrame->AddRef();
+        decklinksrc->video_frame = videoFrame;
+        if (audioFrame) {
+          audioFrame->AddRef();
+          decklinksrc->audio_frame = audioFrame;
+        }
+      }
+      g_cond_signal (decklinksrc->cond);
+      g_mutex_unlock (decklinksrc->mutex);
+    }
+  }
+  return S_OK;
+}
+
+HRESULT
+DeckLinkCaptureDelegate::
+VideoInputFormatChanged (BMDVideoInputFormatChangedEvents events,
+    IDeckLinkDisplayMode * mode, BMDDetectedVideoInputFormatFlags)
+{
+  GST_ERROR("moo");
+  return S_OK;
+}
+
+#ifdef unused
+int
+usage (int status)
+{
+  HRESULT result;
+  IDeckLinkDisplayMode *displayMode;
+  int displayModeCount = 0;
+
+  fprintf (stderr,
+      "Usage: Capture -m <mode id> [OPTIONS]\n" "\n" "    -m <mode id>:\n");
+
+  while (displayModeIterator->Next (&displayMode) == S_OK) {
+    char *displayModeString = NULL;
+
+    result = displayMode->GetName ((const char **) &displayModeString);
+    if (result == S_OK) {
+      BMDTimeValue frameRateDuration, frameRateScale;
+      displayMode->GetFrameRate (&frameRateDuration, &frameRateScale);
+
+      fprintf (stderr, "        %2d:  %-20s \t %li x %li \t %g FPS\n",
+          displayModeCount, displayModeString, displayMode->GetWidth (),
+          displayMode->GetHeight (),
+          (double) frameRateScale / (double) frameRateDuration);
+
+      free (displayModeString);
+      displayModeCount++;
+    }
+    // Release the IDeckLinkDisplayMode object to prevent a leak
+    displayMode->Release ();
+  }
+
+  fprintf (stderr,
+      "    -p <pixelformat>\n"
+      "         0:  8 bit YUV (4:2:2) (default)\n"
+      "         1:  10 bit YUV (4:2:2)\n"
+      "         2:  10 bit RGB (4:4:4)\n"
+      "    -t <format>          Print timecode\n"
+      "     rp188:  RP 188\n"
+      "      vitc:  VITC\n"
+      "    serial:  Serial Timecode\n"
+      "    -f <filename>        Filename raw video will be written to\n"
+      "    -a <filename>        Filename raw audio will be written to\n"
+      "    -c <channels>        Audio Channels (2, 8 or 16 - default is 2)\n"
+      "    -s <depth>           Audio Sample Depth (16 or 32 - default is 16)\n"
+      "    -n <frames>          Number of frames to capture (default is unlimited)\n"
+      "    -3                   Capture Stereoscopic 3D (Requires 3D Hardware support)\n"
+      "\n"
+      "Capture video and/or audio to a file. Raw video and/or audio can be viewed with mplayer eg:\n"
+      "\n"
+      "    Capture -m2 -n 50 -f video.raw -a audio.raw\n"
+      "    mplayer video.raw -demuxer rawvideo -rawvideo pal:uyvy -audiofile audio.raw -audio-demuxer 20 -rawaudio rate=48000\n");
+
+  exit (status);
+}
+
+int
+main (int argc, char *argv[])
+{
+  IDeckLinkIterator *deckLinkIterator = CreateDeckLinkIteratorInstance ();
+  DeckLinkCaptureDelegate *delegate;
+  IDeckLinkDisplayMode *displayMode;
+  BMDVideoInputFlags inputFlags = 0;
+  BMDDisplayMode selectedDisplayMode = bmdModeNTSC;
+  BMDPixelFormat pixelFormat = bmdFormat8BitYUV;
+  int displayModeCount = 0;
+  int exitStatus = 1;
+  int ch;
+  bool foundDisplayMode = false;
+  HRESULT result;
+
+  pthread_mutex_init (&sleepMutex, NULL);
+  pthread_cond_init (&sleepCond, NULL);
+
+  if (!deckLinkIterator) {
+    fprintf (stderr,
+        "This application requires the DeckLink drivers installed.\n");
+    goto bail;
+  }
+
+  /* Connect to the first DeckLink instance */
+  result = deckLinkIterator->Next (&deckLink);
+  if (result != S_OK) {
+    fprintf (stderr, "No DeckLink PCI cards found.\n");
+    goto bail;
+  }
+
+  if (deckLink->QueryInterface (IID_IDeckLinkInput,
+          (void **) &deckLinkInput) != S_OK)
+    goto bail;
+
+  delegate = new DeckLinkCaptureDelegate ();
+  deckLinkInput->SetCallback (delegate);
+
+  // Obtain an IDeckLinkDisplayModeIterator to enumerate the display modes supported on output
+  result = deckLinkInput->GetDisplayModeIterator (&displayModeIterator);
+  if (result != S_OK) {
+    fprintf (stderr,
+        "Could not obtain the video output display mode iterator - result = %08x\n",
+        result);
+    goto bail;
+  }
+  // Parse command line options
+  while ((ch = getopt (argc, argv, "?h3c:s:f:a:m:n:p:t:")) != -1) {
+    switch (ch) {
+      case 'm':
+        g_videoModeIndex = atoi (optarg);
+        break;
+      case 'c':
+        g_audioChannels = atoi (optarg);
+        if (g_audioChannels != 2 &&
+            g_audioChannels != 8 && g_audioChannels != 16) {
+          fprintf (stderr,
+              "Invalid argument: Audio Channels must be either 2, 8 or 16\n");
+          goto bail;
+        }
+        break;
+      case 's':
+        g_audioSampleDepth = atoi (optarg);
+        if (g_audioSampleDepth != 16 && g_audioSampleDepth != 32) {
+          fprintf (stderr,
+              "Invalid argument: Audio Sample Depth must be either 16 bits or 32 bits\n");
+          goto bail;
+        }
+        break;
+      case 'f':
+        g_videoOutputFile = optarg;
+        break;
+      case 'a':
+        g_audioOutputFile = optarg;
+        break;
+      case 'n':
+        g_maxFrames = atoi (optarg);
+        break;
+      case '3':
+        inputFlags |= bmdVideoInputDualStream3D;
+        break;
+      case 'p':
+        switch (atoi (optarg)) {
+          case 0:
+            pixelFormat = bmdFormat8BitYUV;
+            break;
+          case 1:
+            pixelFormat = bmdFormat10BitYUV;
+            break;
+          case 2:
+            pixelFormat = bmdFormat10BitRGB;
+            break;
+          default:
+            fprintf (stderr, "Invalid argument: Pixel format %d is not valid",
+                atoi (optarg));
+            goto bail;
+        }
+        break;
+      case 't':
+        if (!strcmp (optarg, "rp188"))
+          g_timecodeFormat = bmdTimecodeRP188;
+        else if (!strcmp (optarg, "vitc"))
+          g_timecodeFormat = bmdTimecodeVITC;
+        else if (!strcmp (optarg, "serial"))
+          g_timecodeFormat = bmdTimecodeSerial;
+        else {
+          fprintf (stderr,
+              "Invalid argument: Timecode format \"%s\" is invalid\n", optarg);
+          goto bail;
+        }
+        break;
+      case '?':
+      case 'h':
+        usage (0);
+    }
+  }
+
+  if (g_videoModeIndex < 0) {
+    fprintf (stderr, "No video mode specified\n");
+    usage (0);
+  }
+
+  if (g_videoOutputFile != NULL) {
+    videoOutputFile =
+        open (g_videoOutputFile, O_WRONLY | O_CREAT | O_TRUNC, 0664);
+    if (videoOutputFile < 0) {
+      fprintf (stderr, "Could not open video output file \"%s\"\n",
+          g_videoOutputFile);
+      goto bail;
+    }
+  }
+  if (g_audioOutputFile != NULL) {
+    audioOutputFile =
+        open (g_audioOutputFile, O_WRONLY | O_CREAT | O_TRUNC, 0664);
+    if (audioOutputFile < 0) {
+      fprintf (stderr, "Could not open audio output file \"%s\"\n",
+          g_audioOutputFile);
+      goto bail;
+    }
+  }
+
+  while (displayModeIterator->Next (&displayMode) == S_OK) {
+    if (g_videoModeIndex == displayModeCount) {
+      BMDDisplayModeSupport result;
+      const char *displayModeName;
+
+      foundDisplayMode = true;
+      displayMode->GetName (&displayModeName);
+      selectedDisplayMode = displayMode->GetDisplayMode ();
+
+      deckLinkInput->DoesSupportVideoMode (selectedDisplayMode, pixelFormat,
+          bmdVideoInputFlagDefault, &result, NULL);
+
+      if (result == bmdDisplayModeNotSupported) {
+        fprintf (stderr,
+            "The display mode %s is not supported with the selected pixel format\n",
+            displayModeName);
+        goto bail;
+      }
+
+      if (inputFlags & bmdVideoInputDualStream3D) {
+        if (!(displayMode->GetFlags () & bmdDisplayModeSupports3D)) {
+          fprintf (stderr, "The display mode %s is not supported with 3D\n",
+              displayModeName);
+          goto bail;
+        }
+      }
+
+      break;
+    }
+    displayModeCount++;
+    displayMode->Release ();
+  }
+
+  if (!foundDisplayMode) {
+    fprintf (stderr, "Invalid mode %d specified\n", g_videoModeIndex);
+    goto bail;
+  }
+
+  result =
+      deckLinkInput->EnableVideoInput (selectedDisplayMode, pixelFormat,
+      inputFlags);
+  if (result != S_OK) {
+    fprintf (stderr,
+        "Failed to enable video input. Is another application using the card?\n");
+    goto bail;
+  }
+
+  result =
+      deckLinkInput->EnableAudioInput (bmdAudioSampleRate48kHz,
+      g_audioSampleDepth, g_audioChannels);
+  if (result != S_OK) {
+    goto bail;
+  }
+
+  result = deckLinkInput->StartStreams ();
+  if (result != S_OK) {
+    goto bail;
+  }
+  // All Okay.
+  exitStatus = 0;
+
+  // Block main thread until signal occurs
+  pthread_mutex_lock (&sleepMutex);
+  pthread_cond_wait (&sleepCond, &sleepMutex);
+  pthread_mutex_unlock (&sleepMutex);
+  fprintf (stderr, "Stopping Capture\n");
+
+bail:
+
+  if (videoOutputFile)
+    close (videoOutputFile);
+  if (audioOutputFile)
+    close (audioOutputFile);
+
+  if (displayModeIterator != NULL) {
+    displayModeIterator->Release ();
+    displayModeIterator = NULL;
+  }
+
+  if (deckLinkInput != NULL) {
+    deckLinkInput->Release ();
+    deckLinkInput = NULL;
+  }
+
+  if (deckLink != NULL) {
+    deckLink->Release ();
+    deckLink = NULL;
+  }
+
+  if (deckLinkIterator != NULL)
+    deckLinkIterator->Release ();
+
+  return exitStatus;
+}
+#endif
+
diff --git a/sys/decklink/capture.h b/sys/decklink/capture.h
new file mode 100644
index 000000000..3c1ab4695
--- /dev/null
+++ b/sys/decklink/capture.h
@@ -0,0 +1,25 @@
+#ifndef __CAPTURE_H__
+#define __CAPTURE_H__
+
+#include "DeckLinkAPI.h"
+
+class DeckLinkCaptureDelegate : public IDeckLinkInputCallback
+{
+  public:
+    DeckLinkCaptureDelegate();
+    ~DeckLinkCaptureDelegate();
+
+    virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, LPVOID *ppv) { return E_NOINTERFACE; }
+    virtual ULONG STDMETHODCALLTYPE AddRef(void);
+    virtual ULONG STDMETHODCALLTYPE  Release(void);
+    virtual HRESULT STDMETHODCALLTYPE VideoInputFormatChanged(BMDVideoInputFormatChangedEvents, IDeckLinkDisplayMode*, BMDDetectedVideoInputFormatFlags);
+    virtual HRESULT STDMETHODCALLTYPE VideoInputFrameArrived(IDeckLinkVideoInputFrame*, IDeckLinkAudioInputPacket*);
+
+    void *priv;
+
+  private:
+    ULONG				m_refCount;
+    pthread_mutex_t		m_mutex;
+};
+
+#endif
diff --git a/sys/decklink/gstdecklink.cpp b/sys/decklink/gstdecklink.cpp
new file mode 100644
index 000000000..4d4ed445a
--- /dev/null
+++ b/sys/decklink/gstdecklink.cpp
@@ -0,0 +1,44 @@
+/* GStreamer
+ * Copyright (C) 2011 David Schleef <ds@schleef.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Suite 500,
+ * Boston, MA 02110-1335, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <gst/gst.h>
+#include "gstdecklinksrc.h"
+#include "gstdecklinksink.h"
+
+static gboolean
+plugin_init (GstPlugin * plugin)
+{
+
+  gst_element_register (plugin, "decklinksrc", GST_RANK_NONE,
+      gst_decklink_src_get_type ());
+  gst_element_register (plugin, "decklinksink", GST_RANK_NONE,
+      gst_decklink_sink_get_type ());
+
+  return TRUE;
+}
+
+GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
+    GST_VERSION_MINOR,
+    "decklink",
+    "Blackmagic Decklink plugin",
+    plugin_init, VERSION, "LGPL", PACKAGE_NAME, GST_PACKAGE_ORIGIN)
diff --git a/sys/decklink/gstdecklinksink.cpp b/sys/decklink/gstdecklinksink.cpp
new file mode 100644
index 000000000..9fc39e40b
--- /dev/null
+++ b/sys/decklink/gstdecklinksink.cpp
@@ -0,0 +1,1059 @@
+/* GStreamer
+ * Copyright (C) 2011 David Schleef <ds@entropywave.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Suite 500,
+ * Boston, MA 02110-1335, USA.
+ */
+/**
+ * SECTION:element-gstdecklinksink
+ *
+ * The decklinksink element is a sink element for BlackMagic DeckLink
+ * cards.
+ *
+ * <refsect2>
+ * <title>Example launch line</title>
+ * |[
+ * gst-launch -v videotestsrc ! decklinksink
+ * ]|
+ * </refsect2>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <gst/gst.h>
+#include <gst/gst.h>
+#include "gstdecklinksink.h"
+#include <string.h>
+
+GST_DEBUG_CATEGORY_STATIC (gst_decklink_sink_debug_category);
+#define GST_CAT_DEFAULT gst_decklink_sink_debug_category
+
+/* prototypes */
+
+
+static void gst_decklink_sink_set_property (GObject * object,
+    guint property_id, const GValue * value, GParamSpec * pspec);
+static void gst_decklink_sink_get_property (GObject * object,
+    guint property_id, GValue * value, GParamSpec * pspec);
+static void gst_decklink_sink_dispose (GObject * object);
+static void gst_decklink_sink_finalize (GObject * object);
+
+static GstStateChangeReturn
+gst_decklink_sink_change_state (GstElement * element,
+    GstStateChange transition);
+static GstClock *gst_decklink_sink_provide_clock (GstElement * element);
+static gboolean gst_decklink_sink_set_clock (GstElement * element,
+    GstClock * clock);
+static GstIndex *gst_decklink_sink_get_index (GstElement * element);
+static void gst_decklink_sink_set_index (GstElement * element,
+    GstIndex * index);
+static gboolean gst_decklink_sink_send_event (GstElement * element,
+    GstEvent * event);
+static gboolean gst_decklink_sink_query (GstElement * element,
+    GstQuery * query);
+
+static GstCaps *gst_decklink_sink_videosink_getcaps (GstPad * pad);
+static gboolean gst_decklink_sink_videosink_setcaps (GstPad * pad, GstCaps * caps);
+static gboolean gst_decklink_sink_videosink_acceptcaps (GstPad * pad,
+    GstCaps * caps);
+static gboolean gst_decklink_sink_videosink_activate (GstPad * pad);
+static gboolean gst_decklink_sink_videosink_activatepush (GstPad * pad,
+    gboolean active);
+static gboolean gst_decklink_sink_videosink_activatepull (GstPad * pad,
+    gboolean active);
+static GstPadLinkReturn gst_decklink_sink_videosink_link (GstPad * pad,
+    GstPad * peer);
+static GstFlowReturn gst_decklink_sink_videosink_chain (GstPad * pad,
+    GstBuffer * buffer);
+static GstFlowReturn gst_decklink_sink_videosink_chainlist (GstPad * pad,
+    GstBufferList * bufferlist);
+static gboolean gst_decklink_sink_videosink_event (GstPad * pad, GstEvent * event);
+static gboolean gst_decklink_sink_videosink_query (GstPad * pad, GstQuery * query);
+static GstFlowReturn gst_decklink_sink_videosink_bufferalloc (GstPad * pad,
+    guint64 offset, guint size, GstCaps * caps, GstBuffer ** buf);
+static GstIterator *gst_decklink_sink_videosink_iterintlink (GstPad * pad);
+
+
+static GstCaps *gst_decklink_sink_audiosink_getcaps (GstPad * pad);
+static gboolean gst_decklink_sink_audiosink_setcaps (GstPad * pad, GstCaps * caps);
+static gboolean gst_decklink_sink_audiosink_acceptcaps (GstPad * pad,
+    GstCaps * caps);
+static gboolean gst_decklink_sink_audiosink_activate (GstPad * pad);
+static gboolean gst_decklink_sink_audiosink_activatepush (GstPad * pad,
+    gboolean active);
+static gboolean gst_decklink_sink_audiosink_activatepull (GstPad * pad,
+    gboolean active);
+static GstPadLinkReturn gst_decklink_sink_audiosink_link (GstPad * pad,
+    GstPad * peer);
+static GstFlowReturn gst_decklink_sink_audiosink_chain (GstPad * pad,
+    GstBuffer * buffer);
+static GstFlowReturn gst_decklink_sink_audiosink_chainlist (GstPad * pad,
+    GstBufferList * bufferlist);
+static gboolean gst_decklink_sink_audiosink_event (GstPad * pad, GstEvent * event);
+static gboolean gst_decklink_sink_audiosink_query (GstPad * pad, GstQuery * query);
+static GstFlowReturn gst_decklink_sink_audiosink_bufferalloc (GstPad * pad,
+    guint64 offset, guint size, GstCaps * caps, GstBuffer ** buf);
+static GstIterator *gst_decklink_sink_audiosink_iterintlink (GstPad * pad);
+
+
+enum
+{
+  PROP_0
+};
+
+/* pad templates */
+
+#define MODE(w,h,n,d,i) \
+  "video/x-raw-yuv,format=(fourcc)UYVY,width=" #w ",height=" #h \
+  ",framerate=" #n "/" #d ",interlaced=" #i
+
+static GstStaticPadTemplate gst_decklink_sink_videosink_template =
+GST_STATIC_PAD_TEMPLATE ("videosink",
+    GST_PAD_SINK,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS (
+      MODE(720,486,30000,1001,true)
+    ));
+#if 0
+      MODE(720,486,24000,1001,true) ";"
+      MODE(720,576,25,1,true) ";"
+      MODE(1920,1080,24000,1001,false) ";"
+      MODE(1920,1080,24,1,false) ";"
+      MODE(1920,1080,25,1,false) ";"
+      MODE(1920,1080,30000,1001,false) ";"
+      MODE(1920,1080,30,1,false) ";"
+      MODE(1920,1080,25,1,true) ";"
+      MODE(1920,1080,30000,1001,true) ";"
+      MODE(1920,1080,30,1,true) ";"
+      MODE(1280,720,50,1,true) ";"
+      MODE(1280,720,60000,1001,true) ";"
+      MODE(1280,720,60,1,true)
+#endif
+
+static GstStaticPadTemplate gst_decklink_sink_audiosink_template =
+GST_STATIC_PAD_TEMPLATE ("audiosink",
+    GST_PAD_SINK,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS ("audio/x-raw-int,width=16,depth=16,channels=2,rate=48000")
+    );
+
+typedef struct _DecklinkMode DecklinkMode;
+struct _DecklinkMode {
+  BMDDisplayMode mode;
+  int width;
+  int height;
+  int fps_n;
+  int fps_d;
+  gboolean interlaced;
+};
+
+static DecklinkMode modes[] = {
+  { bmdModeNTSC, 720,486,30000,1001,true },
+  { bmdModeNTSC2398, 720,486,24000,1001,true },
+  { bmdModePAL, 720,576,25,1,true },
+  { bmdModeHD1080p2398, 1920,1080,24000,1001,false },
+  { bmdModeHD1080p24, 1920,1080,24,1,false },
+  { bmdModeHD1080p25, 1920,1080,25,1,false },
+  { bmdModeHD1080p2997, 1920,1080,30000,1001,false },
+  { bmdModeHD1080p30, 1920,1080,30,1,false },
+  { bmdModeHD1080i50, 1920,1080,25,1,true },
+  { bmdModeHD1080i5994, 1920,1080,30000,1001,true },
+  { bmdModeHD1080i6000, 1920,1080,30,1,true },
+  { bmdModeHD720p50, 1280,720,50,1,true },
+  { bmdModeHD720p5994, 1280,720,60000,1001,true },
+  { bmdModeHD720p60, 1280,720,60,1,true }
+};
+
+
+/* class initialization */
+
+#define DEBUG_INIT(bla) \
+  GST_DEBUG_CATEGORY_INIT (gst_decklink_sink_debug_category, "decklinksink", 0, \
+      "debug category for decklinksink element");
+
+GST_BOILERPLATE_FULL (GstDecklinkSink, gst_decklink_sink, GstElement,
+    GST_TYPE_ELEMENT, DEBUG_INIT);
+
+static void
+gst_decklink_sink_base_init (gpointer g_class)
+{
+  GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
+
+  gst_element_class_add_pad_template (element_class,
+      gst_static_pad_template_get (&gst_decklink_sink_videosink_template));
+  gst_element_class_add_pad_template (element_class,
+      gst_static_pad_template_get (&gst_decklink_sink_audiosink_template));
+
+  gst_element_class_set_details_simple (element_class, "Decklink Sink",
+      "Video/Sink", "Decklink Sink", "David Schleef <ds@entropywave.com>");
+}
+
+static void
+gst_decklink_sink_class_init (GstDecklinkSinkClass * klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+  GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
+
+  gobject_class->set_property = gst_decklink_sink_set_property;
+  gobject_class->get_property = gst_decklink_sink_get_property;
+  gobject_class->dispose = gst_decklink_sink_dispose;
+  gobject_class->finalize = gst_decklink_sink_finalize;
+  element_class->change_state =
+      GST_DEBUG_FUNCPTR (gst_decklink_sink_change_state);
+  element_class->provide_clock =
+      GST_DEBUG_FUNCPTR (gst_decklink_sink_provide_clock);
+  element_class->set_clock = GST_DEBUG_FUNCPTR (gst_decklink_sink_set_clock);
+  element_class->get_index = GST_DEBUG_FUNCPTR (gst_decklink_sink_get_index);
+  element_class->set_index = GST_DEBUG_FUNCPTR (gst_decklink_sink_set_index);
+  element_class->send_event = GST_DEBUG_FUNCPTR (gst_decklink_sink_send_event);
+  element_class->query = GST_DEBUG_FUNCPTR (gst_decklink_sink_query);
+
+}
+
+static void
+gst_decklink_sink_init (GstDecklinkSink * decklinksink,
+    GstDecklinkSinkClass * decklinksink_class)
+{
+
+  decklinksink->videosinkpad =
+      gst_pad_new_from_static_template (&gst_decklink_sink_videosink_template,
+      "sink");
+  gst_pad_set_getcaps_function (decklinksink->videosinkpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_sink_videosink_getcaps));
+  gst_pad_set_setcaps_function (decklinksink->videosinkpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_sink_videosink_setcaps));
+  gst_pad_set_acceptcaps_function (decklinksink->videosinkpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_sink_videosink_acceptcaps));
+  gst_pad_set_activate_function (decklinksink->videosinkpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_sink_videosink_activate));
+  gst_pad_set_activatepush_function (decklinksink->videosinkpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_sink_videosink_activatepush));
+  gst_pad_set_activatepull_function (decklinksink->videosinkpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_sink_videosink_activatepull));
+  gst_pad_set_link_function (decklinksink->videosinkpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_sink_videosink_link));
+  gst_pad_set_chain_function (decklinksink->videosinkpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_sink_videosink_chain));
+  gst_pad_set_chain_list_function (decklinksink->videosinkpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_sink_videosink_chainlist));
+  gst_pad_set_event_function (decklinksink->videosinkpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_sink_videosink_event));
+  gst_pad_set_query_function (decklinksink->videosinkpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_sink_videosink_query));
+  gst_pad_set_bufferalloc_function (decklinksink->videosinkpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_sink_videosink_bufferalloc));
+  gst_pad_set_iterate_internal_links_function (decklinksink->videosinkpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_sink_videosink_iterintlink));
+  gst_element_add_pad (GST_ELEMENT (decklinksink), decklinksink->videosinkpad);
+
+
+
+  decklinksink->audiosinkpad =
+      gst_pad_new_from_static_template (&gst_decklink_sink_audiosink_template,
+      "audiosink");
+  gst_pad_set_getcaps_function (decklinksink->audiosinkpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_sink_audiosink_getcaps));
+  gst_pad_set_setcaps_function (decklinksink->audiosinkpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_sink_audiosink_setcaps));
+  gst_pad_set_acceptcaps_function (decklinksink->audiosinkpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_sink_audiosink_acceptcaps));
+  gst_pad_set_activate_function (decklinksink->audiosinkpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_sink_audiosink_activate));
+  gst_pad_set_activatepush_function (decklinksink->audiosinkpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_sink_audiosink_activatepush));
+  gst_pad_set_activatepull_function (decklinksink->audiosinkpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_sink_audiosink_activatepull));
+  gst_pad_set_link_function (decklinksink->audiosinkpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_sink_audiosink_link));
+  gst_pad_set_chain_function (decklinksink->audiosinkpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_sink_audiosink_chain));
+  gst_pad_set_chain_list_function (decklinksink->audiosinkpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_sink_audiosink_chainlist));
+  gst_pad_set_event_function (decklinksink->audiosinkpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_sink_audiosink_event));
+  gst_pad_set_query_function (decklinksink->audiosinkpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_sink_audiosink_query));
+  gst_pad_set_bufferalloc_function (decklinksink->audiosinkpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_sink_audiosink_bufferalloc));
+  gst_pad_set_iterate_internal_links_function (decklinksink->audiosinkpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_sink_audiosink_iterintlink));
+  gst_element_add_pad (GST_ELEMENT (decklinksink), decklinksink->audiosinkpad);
+
+
+  decklinksink->cond = g_cond_new();
+  decklinksink->mutex = g_mutex_new();
+
+  decklinksink->mode = 0;
+
+  decklinksink->width = modes[decklinksink->mode].width;
+  decklinksink->height = modes[decklinksink->mode].height;
+  decklinksink->fps_n = modes[decklinksink->mode].fps_n;
+  decklinksink->fps_d = modes[decklinksink->mode].fps_d;
+  decklinksink->interlaced = modes[decklinksink->mode].interlaced;
+  decklinksink->bmd_mode = modes[decklinksink->mode].mode;
+
+  decklinksink->callback = new Output;
+  decklinksink->callback->decklinksink = decklinksink;
+}
+
+void
+gst_decklink_sink_set_property (GObject * object, guint property_id,
+    const GValue * value, GParamSpec * pspec)
+{
+  GstDecklinkSink *decklinksink;
+
+  g_return_if_fail (GST_IS_DECKLINK_SINK (object));
+  decklinksink = GST_DECKLINK_SINK (object);
+
+  switch (property_id) {
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
+}
+
+void
+gst_decklink_sink_get_property (GObject * object, guint property_id,
+    GValue * value, GParamSpec * pspec)
+{
+  GstDecklinkSink *decklinksink;
+
+  g_return_if_fail (GST_IS_DECKLINK_SINK (object));
+  decklinksink = GST_DECKLINK_SINK (object);
+
+  switch (property_id) {
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
+}
+
+void
+gst_decklink_sink_dispose (GObject * object)
+{
+  GstDecklinkSink *decklinksink;
+
+  g_return_if_fail (GST_IS_DECKLINK_SINK (object));
+  decklinksink = GST_DECKLINK_SINK (object);
+
+  /* clean up as possible.  may be called multiple times */
+
+  G_OBJECT_CLASS (parent_class)->dispose (object);
+}
+
+void
+gst_decklink_sink_finalize (GObject * object)
+{
+  GstDecklinkSink *decklinksink;
+
+  g_return_if_fail (GST_IS_DECKLINK_SINK (object));
+  decklinksink = GST_DECKLINK_SINK (object);
+
+  /* clean up object here */
+  g_cond_free (decklinksink->cond);
+  g_mutex_free (decklinksink->mutex);
+
+  delete decklinksink->callback;
+
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static gboolean
+gst_decklink_sink_start (GstDecklinkSink *decklinksink)
+{
+  IDeckLinkIterator *iterator;
+  HRESULT ret;
+  IDeckLinkDisplayModeIterator *mode_iterator;
+  IDeckLinkDisplayMode *mode;
+  BMDTimeValue fps_n;
+  BMDTimeScale fps_d;
+
+  iterator = CreateDeckLinkIteratorInstance ();
+  if (iterator == NULL) {
+    GST_ERROR("no driver");
+    return FALSE;
+  }
+
+  ret = iterator->Next (&decklinksink->decklink);
+  if (ret != S_OK) {
+    GST_ERROR("no card");
+    return FALSE;
+  }
+
+  ret = decklinksink->decklink->QueryInterface (IID_IDeckLinkOutput,
+      (void **)&decklinksink->output);
+  if (ret != S_OK) {
+    GST_ERROR ("no output");
+    return FALSE;
+  }
+
+  decklinksink->output->SetAudioCallback (decklinksink->callback);
+
+  ret = decklinksink->output->GetDisplayModeIterator (&mode_iterator);
+  if (ret != S_OK) {
+    GST_ERROR ("failed to get display mode iterator");
+    return FALSE;
+  }
+
+  while (mode_iterator->Next (&mode) == S_OK) {
+    break;
+  }
+  if (!mode) {
+    GST_ERROR ("bad mode");
+    return FALSE;
+  }
+
+  decklinksink->width = mode->GetWidth ();
+  decklinksink->height = mode->GetHeight ();
+  mode->GetFrameRate (&fps_n, &fps_d);
+  decklinksink->fps_n = fps_n;
+  decklinksink->fps_d = fps_d;
+
+  decklinksink->display_mode = mode->GetDisplayMode ();
+
+  ret = decklinksink->output->EnableVideoOutput (decklinksink->display_mode,
+      bmdVideoOutputFlagDefault);
+  if (ret != S_OK) {
+    GST_ERROR ("failed to enable video output");
+    return FALSE;
+  }
+  //decklinksink->video_enabled = TRUE;
+
+  decklinksink->output->SetScheduledFrameCompletionCallback (decklinksink->callback);
+
+  if (0) {
+    ret = decklinksink->output->EnableAudioOutput (bmdAudioSampleRate48kHz,
+        16, 2, bmdAudioOutputStreamContinuous);
+    if (ret != S_OK) {
+      GST_ERROR ("failed to enable audio output");
+      return FALSE;
+    }
+  }
+
+  decklinksink->num_frames = 0;
+
+  return TRUE;
+}
+
+static gboolean
+gst_decklink_sink_force_stop (GstDecklinkSink *decklinksink)
+{
+  g_mutex_lock (decklinksink->mutex);
+  decklinksink->stop = TRUE;
+  g_cond_signal (decklinksink->cond);
+  g_mutex_unlock (decklinksink->mutex);
+
+  return TRUE;
+}
+
+static gboolean
+gst_decklink_sink_stop (GstDecklinkSink *decklinksink)
+{
+  decklinksink->output->StopScheduledPlayback (0, NULL, 0);
+  decklinksink->output->DisableAudioOutput ();
+  decklinksink->output->DisableVideoOutput ();
+
+  return TRUE;
+}
+
+static GstStateChangeReturn
+gst_decklink_sink_change_state (GstElement * element, GstStateChange transition)
+{
+  GstDecklinkSink *decklinksink;
+  GstStateChangeReturn ret;
+
+  g_return_val_if_fail (GST_IS_DECKLINK_SINK (element),
+      GST_STATE_CHANGE_FAILURE);
+  decklinksink = GST_DECKLINK_SINK (element);
+
+  switch (transition) {
+    case GST_STATE_CHANGE_NULL_TO_READY:
+      if (!gst_decklink_sink_start (decklinksink)) {
+        ret = GST_STATE_CHANGE_FAILURE;
+        goto out;
+      }
+      break;
+    case GST_STATE_CHANGE_READY_TO_PAUSED:
+      break;
+    case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
+      break;
+    default:
+      break;
+  }
+
+  ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
+
+  switch (transition) {
+    case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
+      gst_decklink_sink_force_stop (decklinksink);
+      break;
+    case GST_STATE_CHANGE_PAUSED_TO_READY:
+      break;
+    case GST_STATE_CHANGE_READY_TO_NULL:
+      gst_decklink_sink_stop (decklinksink);
+      break;
+    default:
+      break;
+  }
+
+out:
+  return ret;
+}
+
+static GstClock *
+gst_decklink_sink_provide_clock (GstElement * element)
+{
+
+  return NULL;
+}
+
+static gboolean
+gst_decklink_sink_set_clock (GstElement * element, GstClock * clock)
+{
+
+  return TRUE;
+}
+
+static GstIndex *
+gst_decklink_sink_get_index (GstElement * element)
+{
+
+  return NULL;
+}
+
+static void
+gst_decklink_sink_set_index (GstElement * element, GstIndex * index)
+{
+
+}
+
+static gboolean
+gst_decklink_sink_send_event (GstElement * element, GstEvent * event)
+{
+
+  return TRUE;
+}
+
+static gboolean
+gst_decklink_sink_query (GstElement * element, GstQuery * query)
+{
+
+  return FALSE;
+}
+
+static GstCaps *
+gst_decklink_sink_videosink_getcaps (GstPad * pad)
+{
+  GstDecklinkSink *decklinksink;
+  GstCaps *caps;
+
+  decklinksink = GST_DECKLINK_SINK (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksink, "getcaps");
+
+  caps = gst_caps_copy (gst_pad_get_pad_template_caps (pad));
+
+  gst_object_unref (decklinksink);
+  return caps;
+}
+
+static gboolean
+gst_decklink_sink_videosink_setcaps (GstPad * pad, GstCaps * caps)
+{
+  GstDecklinkSink *decklinksink;
+
+  decklinksink = GST_DECKLINK_SINK (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksink, "setcaps");
+
+
+  gst_object_unref (decklinksink);
+  return TRUE;
+}
+
+static gboolean
+gst_decklink_sink_videosink_acceptcaps (GstPad * pad, GstCaps * caps)
+{
+  GstDecklinkSink *decklinksink;
+
+  decklinksink = GST_DECKLINK_SINK (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksink, "acceptcaps");
+
+
+  gst_object_unref (decklinksink);
+  return TRUE;
+}
+
+static gboolean
+gst_decklink_sink_videosink_activate (GstPad * pad)
+{
+  GstDecklinkSink *decklinksink;
+  gboolean ret;
+
+  decklinksink = GST_DECKLINK_SINK (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksink, "activate");
+
+  if (gst_pad_check_pull_range (pad)) {
+    GST_DEBUG_OBJECT (pad, "activating pull");
+    ret = gst_pad_activate_pull (pad, TRUE);
+  } else {
+    GST_DEBUG_OBJECT (pad, "activating push");
+    ret = gst_pad_activate_push (pad, TRUE);
+  }
+
+  gst_object_unref (decklinksink);
+  return ret;
+}
+
+static gboolean
+gst_decklink_sink_videosink_activatepush (GstPad * pad, gboolean active)
+{
+  GstDecklinkSink *decklinksink;
+
+  decklinksink = GST_DECKLINK_SINK (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksink, "activatepush");
+
+
+  gst_object_unref (decklinksink);
+  return TRUE;
+}
+
+static gboolean
+gst_decklink_sink_videosink_activatepull (GstPad * pad, gboolean active)
+{
+  GstDecklinkSink *decklinksink;
+
+  decklinksink = GST_DECKLINK_SINK (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksink, "activatepull");
+
+
+  gst_object_unref (decklinksink);
+  return TRUE;
+}
+
+static GstPadLinkReturn
+gst_decklink_sink_videosink_link (GstPad * pad, GstPad * peer)
+{
+  GstDecklinkSink *decklinksink;
+
+  decklinksink = GST_DECKLINK_SINK (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksink, "link");
+
+
+  gst_object_unref (decklinksink);
+  return GST_PAD_LINK_OK;
+}
+
+static GstFlowReturn
+gst_decklink_sink_videosink_chain (GstPad * pad, GstBuffer * buffer)
+{
+  GstDecklinkSink *decklinksink;
+  IDeckLinkMutableVideoFrame *frame;
+  void *data;
+  GstFlowReturn ret;
+
+  decklinksink = GST_DECKLINK_SINK (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksink, "chain");
+
+#if 0
+  if (!decklinksink->video_enabled) {
+    HRESULT ret;
+    ret = decklinksink->output->EnableVideoOutput (decklinksink->display_mode,
+        bmdVideoOutputFlagDefault);
+    if (ret != S_OK) {
+      GST_ERROR ("failed to enable video output");
+      //return FALSE;
+    }
+    decklinksink->video_enabled = TRUE;
+  }
+#endif
+
+  decklinksink->output->CreateVideoFrame (decklinksink->width,
+      decklinksink->height, decklinksink->width * 2, bmdFormat8BitYUV,
+      bmdFrameFlagDefault, &frame);
+
+  frame->GetBytes (&data);
+  memcpy (data, GST_BUFFER_DATA (buffer), GST_BUFFER_SIZE (buffer));
+  gst_buffer_unref (buffer);
+
+  g_mutex_lock (decklinksink->mutex);
+  while (decklinksink->queued_frames > 2 && !decklinksink->stop) {
+    g_cond_wait (decklinksink->cond, decklinksink->mutex);
+  }
+  if (!decklinksink->stop) {
+    decklinksink->queued_frames++;
+  }
+  g_mutex_unlock (decklinksink->mutex);
+
+  if (!decklinksink->stop) {
+    decklinksink->output->ScheduleVideoFrame (frame,
+        decklinksink->num_frames * decklinksink->fps_n,
+        decklinksink->fps_n, decklinksink->fps_d);
+    decklinksink->num_frames++;
+
+    if (!decklinksink->sched_started) {
+      decklinksink->output->StartScheduledPlayback (0, 100, 1.0);
+      decklinksink->sched_started = TRUE;
+    }
+
+    ret = GST_FLOW_OK;
+  } else {
+    ret = GST_FLOW_WRONG_STATE;
+  }
+
+  frame->Release ();
+
+  gst_object_unref (decklinksink);
+  return ret;
+}
+
+static GstFlowReturn
+gst_decklink_sink_videosink_chainlist (GstPad * pad, GstBufferList * bufferlist)
+{
+  GstDecklinkSink *decklinksink;
+
+  decklinksink = GST_DECKLINK_SINK (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksink, "chainlist");
+
+
+  gst_object_unref (decklinksink);
+  return GST_FLOW_OK;
+}
+
+static gboolean
+gst_decklink_sink_videosink_event (GstPad * pad, GstEvent * event)
+{
+  gboolean res;
+  GstDecklinkSink *decklinksink;
+
+  decklinksink = GST_DECKLINK_SINK (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksink, "event");
+
+  switch (GST_EVENT_TYPE (event)) {
+    default:
+      res = gst_pad_event_default (pad, event);
+      break;
+  }
+
+  gst_object_unref (decklinksink);
+  return res;
+}
+
+static gboolean
+gst_decklink_sink_videosink_query (GstPad * pad, GstQuery * query)
+{
+  gboolean res;
+  GstDecklinkSink *decklinksink;
+
+  decklinksink = GST_DECKLINK_SINK (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksink, "query");
+
+  switch (GST_QUERY_TYPE (query)) {
+    default:
+      res = gst_pad_query_default (pad, query);
+      break;
+  }
+
+  gst_object_unref (decklinksink);
+  return res;
+}
+
+static GstFlowReturn
+gst_decklink_sink_videosink_bufferalloc (GstPad * pad, guint64 offset, guint size,
+    GstCaps * caps, GstBuffer ** buf)
+{
+  GstDecklinkSink *decklinksink;
+
+  decklinksink = GST_DECKLINK_SINK (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksink, "bufferalloc");
+
+
+  *buf = gst_buffer_new_and_alloc (size);
+  gst_buffer_set_caps (*buf, caps);
+
+  gst_object_unref (decklinksink);
+  return GST_FLOW_OK;
+}
+
+static GstIterator *
+gst_decklink_sink_videosink_iterintlink (GstPad * pad)
+{
+  GstDecklinkSink *decklinksink;
+  GstIterator *iter;
+
+  decklinksink = GST_DECKLINK_SINK (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksink, "iterintlink");
+
+  iter = gst_pad_iterate_internal_links_default (pad);
+
+  gst_object_unref (decklinksink);
+  return iter;
+}
+
+
+static GstCaps *
+gst_decklink_sink_audiosink_getcaps (GstPad * pad)
+{
+  GstDecklinkSink *decklinksink;
+  GstCaps *caps;
+
+  decklinksink = GST_DECKLINK_SINK (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksink, "getcaps");
+
+  caps = gst_caps_copy (gst_pad_get_pad_template_caps (pad));
+
+  gst_object_unref (decklinksink);
+  return caps;
+}
+
+static gboolean
+gst_decklink_sink_audiosink_setcaps (GstPad * pad, GstCaps * caps)
+{
+  GstDecklinkSink *decklinksink;
+
+  decklinksink = GST_DECKLINK_SINK (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksink, "setcaps");
+
+
+  gst_object_unref (decklinksink);
+  return TRUE;
+}
+
+static gboolean
+gst_decklink_sink_audiosink_acceptcaps (GstPad * pad, GstCaps * caps)
+{
+  GstDecklinkSink *decklinksink;
+
+  decklinksink = GST_DECKLINK_SINK (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksink, "acceptcaps");
+
+
+  gst_object_unref (decklinksink);
+  return TRUE;
+}
+
+static gboolean
+gst_decklink_sink_audiosink_activate (GstPad * pad)
+{
+  GstDecklinkSink *decklinksink;
+  gboolean ret;
+
+  decklinksink = GST_DECKLINK_SINK (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksink, "activate");
+
+  if (gst_pad_check_pull_range (pad)) {
+    GST_DEBUG_OBJECT (pad, "activating pull");
+    ret = gst_pad_activate_pull (pad, TRUE);
+  } else {
+    GST_DEBUG_OBJECT (pad, "activating push");
+    ret = gst_pad_activate_push (pad, TRUE);
+  }
+
+  gst_object_unref (decklinksink);
+  return ret;
+}
+
+static gboolean
+gst_decklink_sink_audiosink_activatepush (GstPad * pad, gboolean active)
+{
+  GstDecklinkSink *decklinksink;
+
+  decklinksink = GST_DECKLINK_SINK (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksink, "activatepush");
+
+
+  gst_object_unref (decklinksink);
+  return TRUE;
+}
+
+static gboolean
+gst_decklink_sink_audiosink_activatepull (GstPad * pad, gboolean active)
+{
+  GstDecklinkSink *decklinksink;
+
+  decklinksink = GST_DECKLINK_SINK (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksink, "activatepull");
+
+
+  gst_object_unref (decklinksink);
+  return TRUE;
+}
+
+static GstPadLinkReturn
+gst_decklink_sink_audiosink_link (GstPad * pad, GstPad * peer)
+{
+  GstDecklinkSink *decklinksink;
+
+  decklinksink = GST_DECKLINK_SINK (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksink, "link");
+
+
+  gst_object_unref (decklinksink);
+  return GST_PAD_LINK_OK;
+}
+
+static GstFlowReturn
+gst_decklink_sink_audiosink_chain (GstPad * pad, GstBuffer * buffer)
+{
+  GstDecklinkSink *decklinksink;
+
+  decklinksink = GST_DECKLINK_SINK (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksink, "chain");
+
+
+  gst_object_unref (decklinksink);
+  return GST_FLOW_OK;
+}
+
+static GstFlowReturn
+gst_decklink_sink_audiosink_chainlist (GstPad * pad, GstBufferList * bufferlist)
+{
+  GstDecklinkSink *decklinksink;
+
+  decklinksink = GST_DECKLINK_SINK (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksink, "chainlist");
+
+
+  gst_object_unref (decklinksink);
+  return GST_FLOW_OK;
+}
+
+static gboolean
+gst_decklink_sink_audiosink_event (GstPad * pad, GstEvent * event)
+{
+  gboolean res;
+  GstDecklinkSink *decklinksink;
+
+  decklinksink = GST_DECKLINK_SINK (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksink, "event");
+
+  switch (GST_EVENT_TYPE (event)) {
+    default:
+      res = gst_pad_event_default (pad, event);
+      break;
+  }
+
+  gst_object_unref (decklinksink);
+  return res;
+}
+
+static gboolean
+gst_decklink_sink_audiosink_query (GstPad * pad, GstQuery * query)
+{
+  gboolean res;
+  GstDecklinkSink *decklinksink;
+
+  decklinksink = GST_DECKLINK_SINK (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksink, "query");
+
+  switch (GST_QUERY_TYPE (query)) {
+    default:
+      res = gst_pad_query_default (pad, query);
+      break;
+  }
+
+  gst_object_unref (decklinksink);
+  return res;
+}
+
+static GstFlowReturn
+gst_decklink_sink_audiosink_bufferalloc (GstPad * pad, guint64 offset, guint size,
+    GstCaps * caps, GstBuffer ** buf)
+{
+  GstDecklinkSink *decklinksink;
+
+  decklinksink = GST_DECKLINK_SINK (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksink, "bufferalloc");
+
+
+  *buf = gst_buffer_new_and_alloc (size);
+  gst_buffer_set_caps (*buf, caps);
+
+  gst_object_unref (decklinksink);
+  return GST_FLOW_OK;
+}
+
+static GstIterator *
+gst_decklink_sink_audiosink_iterintlink (GstPad * pad)
+{
+  GstDecklinkSink *decklinksink;
+  GstIterator *iter;
+
+  decklinksink = GST_DECKLINK_SINK (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksink, "iterintlink");
+
+  iter = gst_pad_iterate_internal_links_default (pad);
+
+  gst_object_unref (decklinksink);
+  return iter;
+}
+
+
+
+HRESULT
+Output::ScheduledFrameCompleted (IDeckLinkVideoFrame * completedFrame,
+    BMDOutputFrameCompletionResult result)
+{   
+  GST_DEBUG("ScheduledFrameCompleted");
+
+  g_mutex_lock (decklinksink->mutex);
+  g_cond_signal (decklinksink->cond);
+  decklinksink->queued_frames--;
+  g_mutex_unlock (decklinksink->mutex);
+
+  return S_OK;
+}
+
+HRESULT
+Output::ScheduledPlaybackHasStopped ()
+{
+  GST_ERROR("ScheduledPlaybackHasStopped");
+  return S_OK;
+}
+
+HRESULT
+Output::RenderAudioSamples (bool preroll)
+{
+  GST_ERROR("RenderAudioSamples");
+  
+  return S_OK;
+}
+
diff --git a/sys/decklink/gstdecklinksink.h b/sys/decklink/gstdecklinksink.h
new file mode 100644
index 000000000..2f0d1d799
--- /dev/null
+++ b/sys/decklink/gstdecklinksink.h
@@ -0,0 +1,92 @@
+/* GStreamer
+ * Copyright (C) 2011 David Schleef <ds@schleef.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef _GST_DECKLINK_SINK_H_
+#define _GST_DECKLINK_SINK_H_
+
+#include <gst/gst.h>
+#include "DeckLinkAPI.h"
+
+G_BEGIN_DECLS
+
+#define GST_TYPE_DECKLINK_SINK   (gst_decklink_sink_get_type())
+#define GST_DECKLINK_SINK(obj)   (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_DECKLINK_SINK,GstDecklinkSink))
+#define GST_DECKLINK_SINK_CLASS(klass)   (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_DECKLINK_SINK,GstDecklinkSinkClass))
+#define GST_IS_DECKLINK_SINK(obj)   (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_DECKLINK_SINK))
+#define GST_IS_DECKLINK_SINK_CLASS(obj)   (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_DECKLINK_SINK))
+
+typedef struct _GstDecklinkSink GstDecklinkSink;
+typedef struct _GstDecklinkSinkClass GstDecklinkSinkClass;
+
+class Output : public IDeckLinkVideoOutputCallback,
+public IDeckLinkAudioOutputCallback
+{
+  public:
+    GstDecklinkSink *decklinksink;
+
+    virtual HRESULT STDMETHODCALLTYPE QueryInterface (REFIID iid, LPVOID *ppv)        {return E_NOINTERFACE;}
+    virtual ULONG STDMETHODCALLTYPE AddRef () {return 1;}
+    virtual ULONG STDMETHODCALLTYPE Release () {return 1;}
+    virtual HRESULT STDMETHODCALLTYPE ScheduledFrameCompleted (IDeckLinkVideoFrame* completedFrame, BMDOutputFrameCompletionResult result);
+    virtual HRESULT STDMETHODCALLTYPE ScheduledPlaybackHasStopped ();
+    virtual HRESULT STDMETHODCALLTYPE RenderAudioSamples (bool preroll);
+};
+
+struct _GstDecklinkSink
+{
+  GstElement base_decklinksink;
+
+  GstPad *videosinkpad;
+  GstPad *audiosinkpad;
+
+  GMutex *mutex;
+  GCond *cond;
+  int queued_frames;
+  gboolean stop;
+
+  IDeckLink *decklink;
+  IDeckLinkOutput *output;
+  Output *callback;
+  BMDDisplayMode display_mode;
+  gboolean video_enabled;
+  gboolean sched_started;
+
+  int num_frames;
+  int fps_n;
+  int fps_d;
+  int width;
+  int height;
+  gboolean interlaced;
+  BMDDisplayMode bmd_mode;
+
+  /* properties */
+  int mode;
+
+};
+
+struct _GstDecklinkSinkClass
+{
+  GstElementClass base_decklinksink_class;
+};
+
+GType gst_decklink_sink_get_type (void);
+
+G_END_DECLS
+
+#endif
diff --git a/sys/decklink/gstdecklinksrc.cpp b/sys/decklink/gstdecklinksrc.cpp
new file mode 100644
index 000000000..9f7846052
--- /dev/null
+++ b/sys/decklink/gstdecklinksrc.cpp
@@ -0,0 +1,1096 @@
+/* GStreamer
+ * Copyright (C) 2011 David Schleef <ds@schleef.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Suite 500,
+ * Boston, MA 02110-1335, USA.
+ */
+/**
+ * SECTION:element-gstdecklinksrc
+ *
+ * The decklinksrc element is a source element for Blackmagic
+ * Decklink cards.
+ *
+ * <refsect2>
+ * <title>Example launch line</title>
+ * |[
+ * gst-launch -v decklinksrc ! xvimagesink
+ * ]|
+ * 
+ * </refsect2>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <gst/gst.h>
+#include "gstdecklinksrc.h"
+#include "capture.h"
+#include <string.h>
+
+GST_DEBUG_CATEGORY_STATIC (gst_decklink_src_debug_category);
+#define GST_CAT_DEFAULT gst_decklink_src_debug_category
+
+/* prototypes */
+
+
+static void gst_decklink_src_set_property (GObject * object,
+    guint property_id, const GValue * value, GParamSpec * pspec);
+static void gst_decklink_src_get_property (GObject * object,
+    guint property_id, GValue * value, GParamSpec * pspec);
+static void gst_decklink_src_dispose (GObject * object);
+static void gst_decklink_src_finalize (GObject * object);
+
+static GstPad *gst_decklink_src_request_new_pad (GstElement * element,
+    GstPadTemplate * templ, const gchar * name);
+static void gst_decklink_src_release_pad (GstElement * element, GstPad * pad);
+static GstStateChangeReturn
+gst_decklink_src_change_state (GstElement * element, GstStateChange transition);
+static GstClock *gst_decklink_src_provide_clock (GstElement * element);
+static gboolean gst_decklink_src_set_clock (GstElement * element,
+    GstClock * clock);
+static GstIndex *gst_decklink_src_get_index (GstElement * element);
+static void gst_decklink_src_set_index (GstElement * element, GstIndex * index);
+static gboolean gst_decklink_src_send_event (GstElement * element,
+    GstEvent * event);
+static gboolean gst_decklink_src_query (GstElement * element, GstQuery * query);
+
+static GstCaps *gst_decklink_src_audio_src_getcaps (GstPad * pad);
+static gboolean gst_decklink_src_audio_src_setcaps (GstPad * pad, GstCaps * caps);
+static gboolean gst_decklink_src_audio_src_acceptcaps (GstPad * pad, GstCaps * caps);
+static void gst_decklink_src_audio_src_fixatecaps (GstPad * pad, GstCaps * caps);
+static gboolean gst_decklink_src_audio_src_activate (GstPad * pad);
+static gboolean gst_decklink_src_audio_src_activatepush (GstPad * pad,
+    gboolean active);
+static gboolean gst_decklink_src_audio_src_activatepull (GstPad * pad,
+    gboolean active);
+static GstPadLinkReturn gst_decklink_src_audio_src_link (GstPad * pad, GstPad * peer);
+static GstFlowReturn gst_decklink_src_audio_src_getrange (GstPad * pad,
+    guint64 offset, guint length, GstBuffer ** buffer);
+static gboolean gst_decklink_src_audio_src_event (GstPad * pad, GstEvent * event);
+static gboolean gst_decklink_src_audio_src_query (GstPad * pad, GstQuery * query);
+static GstIterator *gst_decklink_src_audio_src_iterintlink (GstPad * pad);
+
+
+static GstCaps *gst_decklink_src_video_src_getcaps (GstPad * pad);
+static gboolean gst_decklink_src_video_src_setcaps (GstPad * pad, GstCaps * caps);
+static gboolean gst_decklink_src_video_src_acceptcaps (GstPad * pad, GstCaps * caps);
+static void gst_decklink_src_video_src_fixatecaps (GstPad * pad, GstCaps * caps);
+static gboolean gst_decklink_src_video_src_activate (GstPad * pad);
+static gboolean gst_decklink_src_video_src_activatepush (GstPad * pad,
+    gboolean active);
+static gboolean gst_decklink_src_video_src_activatepull (GstPad * pad,
+    gboolean active);
+static GstPadLinkReturn gst_decklink_src_video_src_link (GstPad * pad, GstPad * peer);
+static GstFlowReturn gst_decklink_src_video_src_getrange (GstPad * pad,
+    guint64 offset, guint length, GstBuffer ** buffer);
+static gboolean gst_decklink_src_video_src_event (GstPad * pad, GstEvent * event);
+static gboolean gst_decklink_src_video_src_query (GstPad * pad, GstQuery * query);
+static GstIterator *gst_decklink_src_video_src_iterintlink (GstPad * pad);
+
+static void gst_decklink_src_task (void *priv);
+
+enum
+{
+  PROP_0
+};
+
+/* pad templates */
+
+static GstStaticPadTemplate gst_decklink_src_audio_src_template =
+GST_STATIC_PAD_TEMPLATE ("audiosrc",
+    GST_PAD_SRC,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS ("audio/x-raw-int,width=16,depth=16,channels=2,rate=48000")
+    );
+
+#define MODE(w,h,n,d,i) \
+  "video/x-raw-yuv,format=(fourcc)UYVY,width=" #w ",height=" #h \
+  ",framerate=" #n "/" #d ",interlaced=" #i
+
+static GstStaticPadTemplate gst_decklink_src_video_src_template =
+GST_STATIC_PAD_TEMPLATE ("videosrc",
+    GST_PAD_SRC,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS (
+      MODE(720,486,30000,1001,true) ";"
+      MODE(720,486,24000,1001,true) ";"
+      MODE(720,576,25,1,true) ";"
+      MODE(1920,1080,24000,1001,false) ";"
+      MODE(1920,1080,24,1,false) ";"
+      MODE(1920,1080,25,1,false) ";"
+      MODE(1920,1080,30000,1001,false) ";"
+      MODE(1920,1080,30,1,false) ";"
+      MODE(1920,1080,25,1,true) ";"
+      MODE(1920,1080,30000,1001,true) ";"
+      MODE(1920,1080,30,1,true) ";"
+      MODE(1280,720,50,1,true) ";"
+      MODE(1280,720,60000,1001,true) ";"
+      MODE(1280,720,60,1,true)
+    ));
+
+typedef struct _DecklinkMode DecklinkMode;
+struct _DecklinkMode {
+  BMDDisplayMode mode;
+  int width;
+  int height;
+  int fps_n;
+  int fps_d;
+  gboolean interlaced;
+};
+
+static DecklinkMode modes[] = {
+  { bmdModeNTSC, 720,486,30000,1001,true },
+  { bmdModeNTSC2398, 720,486,24000,1001,true },
+  { bmdModePAL, 720,576,25,1,true },
+  { bmdModeHD1080p2398, 1920,1080,24000,1001,false },
+  { bmdModeHD1080p24, 1920,1080,24,1,false },
+  { bmdModeHD1080p25, 1920,1080,25,1,false },
+  { bmdModeHD1080p2997, 1920,1080,30000,1001,false },
+  { bmdModeHD1080p30, 1920,1080,30,1,false },
+  { bmdModeHD1080i50, 1920,1080,25,1,true },
+  { bmdModeHD1080i5994, 1920,1080,30000,1001,true },
+  { bmdModeHD1080i6000, 1920,1080,30,1,true },
+  { bmdModeHD720p50, 1280,720,50,1,true },
+  { bmdModeHD720p5994, 1280,720,60000,1001,true },
+  { bmdModeHD720p60, 1280,720,60,1,true }
+};
+
+
+/* class initialization */
+
+#define DEBUG_INIT(bla) \
+  GST_DEBUG_CATEGORY_INIT (gst_decklink_src_debug_category, "decklinksrc", 0, \
+      "debug category for decklinksrc element");
+
+GST_BOILERPLATE_FULL (GstDecklinkSrc, gst_decklink_src, GstElement,
+    GST_TYPE_ELEMENT, DEBUG_INIT);
+
+static void
+gst_decklink_src_base_init (gpointer g_class)
+{
+  GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
+
+  gst_element_class_add_pad_template (element_class,
+      gst_static_pad_template_get (&gst_decklink_src_audio_src_template));
+  gst_element_class_add_pad_template (element_class,
+      gst_static_pad_template_get (&gst_decklink_src_video_src_template));
+
+  gst_element_class_set_details_simple (element_class, "Decklink source",
+      "Source/Video", "DeckLink Source", "David Schleef <ds@entropywave.com>");
+}
+
+static void
+gst_decklink_src_class_init (GstDecklinkSrcClass * klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+  GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
+
+  gobject_class->set_property = gst_decklink_src_set_property;
+  gobject_class->get_property = gst_decklink_src_get_property;
+  gobject_class->dispose = gst_decklink_src_dispose;
+  gobject_class->finalize = gst_decklink_src_finalize;
+  element_class->request_new_pad =
+      GST_DEBUG_FUNCPTR (gst_decklink_src_request_new_pad);
+  element_class->release_pad = GST_DEBUG_FUNCPTR (gst_decklink_src_release_pad);
+  element_class->change_state =
+      GST_DEBUG_FUNCPTR (gst_decklink_src_change_state);
+  element_class->provide_clock =
+      GST_DEBUG_FUNCPTR (gst_decklink_src_provide_clock);
+  element_class->set_clock = GST_DEBUG_FUNCPTR (gst_decklink_src_set_clock);
+  element_class->get_index = GST_DEBUG_FUNCPTR (gst_decklink_src_get_index);
+  element_class->set_index = GST_DEBUG_FUNCPTR (gst_decklink_src_set_index);
+  element_class->send_event = GST_DEBUG_FUNCPTR (gst_decklink_src_send_event);
+  element_class->query = GST_DEBUG_FUNCPTR (gst_decklink_src_query);
+
+}
+
+static void
+gst_decklink_src_init (GstDecklinkSrc * decklinksrc,
+    GstDecklinkSrcClass * decklinksrc_class)
+{
+  g_static_rec_mutex_init (&decklinksrc->task_mutex);
+  decklinksrc->task = gst_task_create (gst_decklink_src_task, decklinksrc);
+  gst_task_set_lock (decklinksrc->task, &decklinksrc->task_mutex);
+
+  decklinksrc->audiosrcpad =
+      gst_pad_new_from_static_template (&gst_decklink_src_audio_src_template, "audiosrc");
+  gst_pad_set_getcaps_function (decklinksrc->audiosrcpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_src_audio_src_getcaps));
+  gst_pad_set_setcaps_function (decklinksrc->audiosrcpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_src_audio_src_setcaps));
+  gst_pad_set_acceptcaps_function (decklinksrc->audiosrcpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_src_audio_src_acceptcaps));
+  gst_pad_set_fixatecaps_function (decklinksrc->audiosrcpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_src_audio_src_fixatecaps));
+  gst_pad_set_activate_function (decklinksrc->audiosrcpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_src_audio_src_activate));
+  gst_pad_set_activatepush_function (decklinksrc->audiosrcpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_src_audio_src_activatepush));
+  gst_pad_set_activatepull_function (decklinksrc->audiosrcpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_src_audio_src_activatepull));
+  gst_pad_set_link_function (decklinksrc->audiosrcpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_src_audio_src_link));
+  gst_pad_set_getrange_function (decklinksrc->audiosrcpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_src_audio_src_getrange));
+  gst_pad_set_event_function (decklinksrc->audiosrcpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_src_audio_src_event));
+  gst_pad_set_query_function (decklinksrc->audiosrcpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_src_audio_src_query));
+  gst_pad_set_iterate_internal_links_function (decklinksrc->audiosrcpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_src_audio_src_iterintlink));
+  gst_element_add_pad (GST_ELEMENT (decklinksrc), decklinksrc->audiosrcpad);
+
+
+
+  decklinksrc->videosrcpad =
+      gst_pad_new_from_static_template (&gst_decklink_src_video_src_template, "videosrc");
+  gst_pad_set_getcaps_function (decklinksrc->videosrcpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_src_video_src_getcaps));
+  gst_pad_set_setcaps_function (decklinksrc->videosrcpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_src_video_src_setcaps));
+  gst_pad_set_acceptcaps_function (decklinksrc->videosrcpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_src_video_src_acceptcaps));
+  gst_pad_set_fixatecaps_function (decklinksrc->videosrcpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_src_video_src_fixatecaps));
+  gst_pad_set_activate_function (decklinksrc->videosrcpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_src_video_src_activate));
+  gst_pad_set_activatepush_function (decklinksrc->videosrcpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_src_video_src_activatepush));
+  gst_pad_set_activatepull_function (decklinksrc->videosrcpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_src_video_src_activatepull));
+  gst_pad_set_link_function (decklinksrc->videosrcpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_src_video_src_link));
+  gst_pad_set_getrange_function (decklinksrc->videosrcpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_src_video_src_getrange));
+  gst_pad_set_event_function (decklinksrc->videosrcpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_src_video_src_event));
+  gst_pad_set_query_function (decklinksrc->videosrcpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_src_video_src_query));
+  gst_pad_set_iterate_internal_links_function (decklinksrc->videosrcpad,
+      GST_DEBUG_FUNCPTR (gst_decklink_src_video_src_iterintlink));
+  gst_element_add_pad (GST_ELEMENT (decklinksrc), decklinksrc->videosrcpad);
+
+
+  decklinksrc->cond = g_cond_new();
+  decklinksrc->mutex = g_mutex_new();
+
+  decklinksrc->copy_data = TRUE;
+  decklinksrc->mode = 0;
+
+  decklinksrc->width = modes[decklinksrc->mode].width;
+  decklinksrc->height = modes[decklinksrc->mode].height;
+  decklinksrc->fps_n = modes[decklinksrc->mode].fps_n;
+  decklinksrc->fps_d = modes[decklinksrc->mode].fps_d;
+  decklinksrc->interlaced = modes[decklinksrc->mode].interlaced;
+  decklinksrc->bmd_mode = modes[decklinksrc->mode].mode;
+
+}
+
+void
+gst_decklink_src_set_property (GObject * object, guint property_id,
+    const GValue * value, GParamSpec * pspec)
+{
+  GstDecklinkSrc *decklinksrc;
+
+  g_return_if_fail (GST_IS_DECKLINK_SRC (object));
+  decklinksrc = GST_DECKLINK_SRC (object);
+
+  switch (property_id) {
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
+}
+
+void
+gst_decklink_src_get_property (GObject * object, guint property_id,
+    GValue * value, GParamSpec * pspec)
+{
+  GstDecklinkSrc *decklinksrc;
+
+  g_return_if_fail (GST_IS_DECKLINK_SRC (object));
+  decklinksrc = GST_DECKLINK_SRC (object);
+
+  switch (property_id) {
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
+}
+
+void
+gst_decklink_src_dispose (GObject * object)
+{
+  GstDecklinkSrc *decklinksrc;
+
+  g_return_if_fail (GST_IS_DECKLINK_SRC (object));
+  decklinksrc = GST_DECKLINK_SRC (object);
+
+  /* clean up as possible.  may be called multiple times */
+
+  G_OBJECT_CLASS (parent_class)->dispose (object);
+}
+
+void
+gst_decklink_src_finalize (GObject * object)
+{
+  GstDecklinkSrc *decklinksrc;
+
+  g_return_if_fail (GST_IS_DECKLINK_SRC (object));
+  decklinksrc = GST_DECKLINK_SRC (object);
+
+  /* clean up object here */
+
+  g_cond_free (decklinksrc->cond);
+  g_mutex_free (decklinksrc->mutex);
+  gst_task_set_lock (decklinksrc->task, NULL);
+  g_object_unref (decklinksrc->task);
+  if (decklinksrc->audio_caps) {
+    gst_caps_unref (decklinksrc->audio_caps);
+  }
+  if (decklinksrc->video_caps) {
+    gst_caps_unref (decklinksrc->video_caps);
+  }
+
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+
+
+static GstPad *
+gst_decklink_src_request_new_pad (GstElement * element, GstPadTemplate * templ,
+    const gchar * name)
+{
+
+  return NULL;
+}
+
+static void
+gst_decklink_src_release_pad (GstElement * element, GstPad * pad)
+{
+
+}
+
+static gboolean
+gst_decklink_src_start (GstElement * element)
+{
+  GstDecklinkSrc *decklinksrc = GST_DECKLINK_SRC (element);
+  IDeckLinkIterator *iterator;
+  DeckLinkCaptureDelegate *delegate;
+  IDeckLinkDisplayModeIterator *mode_iterator;
+  IDeckLinkDisplayMode *mode;
+  int i;
+  int sample_depth;
+  int channels;
+  BMDVideoInputFlags input_flags;
+  BMDDisplayMode selected_mode;
+  BMDPixelFormat pixel_format;
+  HRESULT ret;
+
+  GST_DEBUG_OBJECT (decklinksrc, "start");
+
+  iterator = CreateDeckLinkIteratorInstance ();
+  if (iterator == NULL) {
+    GST_ERROR("no driver");
+    return FALSE;
+  }
+
+  ret = iterator->Next (&decklinksrc->decklink);
+  if (ret != S_OK) {
+    GST_ERROR("no card");
+    return FALSE;
+  }
+
+  ret = decklinksrc->decklink->QueryInterface (IID_IDeckLinkInput,
+      (void **) &decklinksrc->input);
+  if (ret != S_OK) {
+    GST_ERROR ("query interface failed");
+    return FALSE;
+  }
+
+  delegate = new DeckLinkCaptureDelegate ();
+  delegate->priv = decklinksrc;
+  decklinksrc->input->SetCallback (delegate);
+
+  ret = decklinksrc->input->GetDisplayModeIterator (&mode_iterator);
+  if (ret != S_OK) {
+    GST_ERROR("failed to get display mode iterator");
+    return FALSE;
+  }
+
+  i = 0;
+  while (mode_iterator->Next (&mode) == S_OK) {
+    const char *mode_name;
+
+    mode->GetName (&mode_name);
+
+    GST_ERROR("%d: mode name: %s", i, mode_name);
+
+    mode->Release ();
+    i++;
+  }
+
+  pixel_format = bmdFormat8BitYUV;
+  selected_mode = decklinksrc->bmd_mode;
+  input_flags = 0;
+  ret = decklinksrc->input->EnableVideoInput (selected_mode, pixel_format,
+      input_flags);
+  if (ret != S_OK){
+    GST_ERROR("enable video input failed");
+    return FALSE;
+  }
+
+  sample_depth = 16;
+  channels = 2;
+  ret = decklinksrc->input->EnableAudioInput (bmdAudioSampleRate48kHz, sample_depth,
+      channels);
+  if (ret != S_OK){
+    GST_ERROR("enable video input failed");
+    return FALSE;
+  }
+
+  ret = decklinksrc->input->StartStreams ();
+  if (ret != S_OK) {
+    GST_ERROR("start streams failed");
+    return FALSE;
+  }
+
+  g_static_rec_mutex_lock (&decklinksrc->task_mutex);
+  gst_task_start (decklinksrc->task);
+  g_static_rec_mutex_unlock (&decklinksrc->task_mutex);
+
+  return TRUE;
+}
+
+static gboolean
+gst_decklink_src_stop (GstElement * element)
+{
+  GstDecklinkSrc *decklinksrc = GST_DECKLINK_SRC (element);
+
+  gst_task_stop (decklinksrc->task);
+
+  g_mutex_lock (decklinksrc->mutex);
+  decklinksrc->stop = TRUE;
+  g_cond_signal (decklinksrc->cond);
+  g_mutex_unlock (decklinksrc->mutex);
+
+  gst_task_join (decklinksrc->task);
+
+  return TRUE;
+}
+
+static GstStateChangeReturn
+gst_decklink_src_change_state (GstElement * element, GstStateChange transition)
+{
+  GstDecklinkSrc *decklinksrc;
+  GstStateChangeReturn ret;
+  gboolean no_preroll = FALSE;
+
+  g_return_val_if_fail (GST_IS_DECKLINK_SRC (element),
+      GST_STATE_CHANGE_FAILURE);
+  decklinksrc = GST_DECKLINK_SRC (element);
+
+  switch (transition) {
+    case GST_STATE_CHANGE_NULL_TO_READY:
+      if (!gst_decklink_src_start (element)) {
+        ret = GST_STATE_CHANGE_FAILURE;
+        goto out;
+      }
+      break;
+    case GST_STATE_CHANGE_READY_TO_PAUSED:
+      no_preroll = TRUE;
+      break;
+    case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
+      break;
+    default:
+      break;
+  }
+
+  ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
+
+  switch (transition) {
+    case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
+      no_preroll = TRUE;
+      break;
+    case GST_STATE_CHANGE_PAUSED_TO_READY:
+      break;
+    case GST_STATE_CHANGE_READY_TO_NULL:
+      gst_decklink_src_stop (element);
+      break;
+    default:
+      break;
+  }
+
+  if (no_preroll && ret == GST_STATE_CHANGE_SUCCESS)
+    ret = GST_STATE_CHANGE_NO_PREROLL;
+
+out:
+  return ret;
+}
+
+static GstClock *
+gst_decklink_src_provide_clock (GstElement * element)
+{
+
+  return NULL;
+}
+
+static gboolean
+gst_decklink_src_set_clock (GstElement * element, GstClock * clock)
+{
+
+  return TRUE;
+}
+
+static GstIndex *
+gst_decklink_src_get_index (GstElement * element)
+{
+
+  return NULL;
+}
+
+static void
+gst_decklink_src_set_index (GstElement * element, GstIndex * index)
+{
+
+}
+
+static gboolean
+gst_decklink_src_send_event (GstElement * element, GstEvent * event)
+{
+
+  return TRUE;
+}
+
+static gboolean
+gst_decklink_src_query (GstElement * element, GstQuery * query)
+{
+
+  return FALSE;
+}
+
+static GstCaps *
+gst_decklink_src_audio_src_getcaps (GstPad * pad)
+{
+  GstDecklinkSrc *decklinksrc;
+  GstCaps *caps;
+
+  decklinksrc = GST_DECKLINK_SRC (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksrc, "getcaps");
+
+  caps = gst_caps_copy (gst_pad_get_pad_template_caps (pad));
+
+  gst_object_unref (decklinksrc);
+  return caps;
+}
+
+static gboolean
+gst_decklink_src_audio_src_setcaps (GstPad * pad, GstCaps * caps)
+{
+  GstDecklinkSrc *decklinksrc;
+
+  decklinksrc = GST_DECKLINK_SRC (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksrc, "setcaps");
+
+
+  gst_object_unref (decklinksrc);
+  return TRUE;
+}
+
+static gboolean
+gst_decklink_src_audio_src_acceptcaps (GstPad * pad, GstCaps * caps)
+{
+  GstDecklinkSrc *decklinksrc;
+
+  decklinksrc = GST_DECKLINK_SRC (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksrc, "acceptcaps");
+
+
+  gst_object_unref (decklinksrc);
+  return TRUE;
+}
+
+static void
+gst_decklink_src_audio_src_fixatecaps (GstPad * pad, GstCaps * caps)
+{
+  GstDecklinkSrc *decklinksrc;
+
+  decklinksrc = GST_DECKLINK_SRC (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksrc, "fixatecaps");
+
+
+  gst_object_unref (decklinksrc);
+}
+
+static gboolean
+gst_decklink_src_audio_src_activate (GstPad * pad)
+{
+  GstDecklinkSrc *decklinksrc;
+  gboolean ret;
+
+  decklinksrc = GST_DECKLINK_SRC (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksrc, "activate");
+
+  if (gst_pad_check_pull_range (pad)) {
+    GST_DEBUG_OBJECT (pad, "activating pull");
+    ret = gst_pad_activate_pull (pad, TRUE);
+  } else {
+    GST_DEBUG_OBJECT (pad, "activating push");
+    ret = gst_pad_activate_push (pad, TRUE);
+  }
+
+  gst_object_unref (decklinksrc);
+  return ret;
+}
+
+static gboolean
+gst_decklink_src_audio_src_activatepush (GstPad * pad, gboolean active)
+{
+  GstDecklinkSrc *decklinksrc;
+
+  decklinksrc = GST_DECKLINK_SRC (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksrc, "activatepush");
+
+
+  gst_object_unref (decklinksrc);
+  return TRUE;
+}
+
+static gboolean
+gst_decklink_src_audio_src_activatepull (GstPad * pad, gboolean active)
+{
+  GstDecklinkSrc *decklinksrc;
+
+  decklinksrc = GST_DECKLINK_SRC (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksrc, "activatepull");
+
+
+  gst_object_unref (decklinksrc);
+  return TRUE;
+}
+
+static GstPadLinkReturn
+gst_decklink_src_audio_src_link (GstPad * pad, GstPad * peer)
+{
+  GstDecklinkSrc *decklinksrc;
+
+  decklinksrc = GST_DECKLINK_SRC (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksrc, "link");
+
+
+  gst_object_unref (decklinksrc);
+  return GST_PAD_LINK_OK;
+}
+
+static GstFlowReturn
+gst_decklink_src_audio_src_getrange (GstPad * pad, guint64 offset, guint length,
+    GstBuffer ** buffer)
+{
+  GstDecklinkSrc *decklinksrc;
+
+  decklinksrc = GST_DECKLINK_SRC (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksrc, "getrange");
+
+
+  gst_object_unref (decklinksrc);
+  return GST_FLOW_OK;
+}
+
+static gboolean
+gst_decklink_src_audio_src_event (GstPad * pad, GstEvent * event)
+{
+  gboolean res;
+  GstDecklinkSrc *decklinksrc;
+
+  decklinksrc = GST_DECKLINK_SRC (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksrc, "event");
+
+  switch (GST_EVENT_TYPE (event)) {
+    default:
+      res = gst_pad_event_default (pad, event);
+      break;
+  }
+
+  gst_object_unref (decklinksrc);
+  return res;
+}
+
+static gboolean
+gst_decklink_src_audio_src_query (GstPad * pad, GstQuery * query)
+{
+  gboolean res;
+  GstDecklinkSrc *decklinksrc;
+
+  decklinksrc = GST_DECKLINK_SRC (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksrc, "query");
+
+  switch (GST_QUERY_TYPE (query)) {
+    default:
+      res = gst_pad_query_default (pad, query);
+      break;
+  }
+
+  gst_object_unref (decklinksrc);
+  return res;
+}
+
+static GstIterator *
+gst_decklink_src_audio_src_iterintlink (GstPad * pad)
+{
+  GstDecklinkSrc *decklinksrc;
+  GstIterator *iter;
+
+  decklinksrc = GST_DECKLINK_SRC (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksrc, "iterintlink");
+
+  iter = gst_pad_iterate_internal_links_default (pad);
+
+  gst_object_unref (decklinksrc);
+  return iter;
+}
+
+
+static GstCaps *
+gst_decklink_src_video_src_getcaps (GstPad * pad)
+{
+  GstDecklinkSrc *decklinksrc;
+  GstCaps *caps;
+
+  decklinksrc = GST_DECKLINK_SRC (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksrc, "getcaps");
+
+  caps = gst_caps_copy (gst_pad_get_pad_template_caps (pad));
+
+  gst_object_unref (decklinksrc);
+  return caps;
+}
+
+static gboolean
+gst_decklink_src_video_src_setcaps (GstPad * pad, GstCaps * caps)
+{
+  GstDecklinkSrc *decklinksrc;
+
+  decklinksrc = GST_DECKLINK_SRC (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksrc, "setcaps");
+
+
+  gst_object_unref (decklinksrc);
+  return TRUE;
+}
+
+static gboolean
+gst_decklink_src_video_src_acceptcaps (GstPad * pad, GstCaps * caps)
+{
+  GstDecklinkSrc *decklinksrc;
+
+  decklinksrc = GST_DECKLINK_SRC (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksrc, "acceptcaps");
+
+
+  gst_object_unref (decklinksrc);
+  return TRUE;
+}
+
+static void
+gst_decklink_src_video_src_fixatecaps (GstPad * pad, GstCaps * caps)
+{
+  GstDecklinkSrc *decklinksrc;
+
+  decklinksrc = GST_DECKLINK_SRC (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksrc, "fixatecaps");
+
+
+  gst_object_unref (decklinksrc);
+}
+
+static gboolean
+gst_decklink_src_video_src_activate (GstPad * pad)
+{
+  GstDecklinkSrc *decklinksrc;
+  gboolean ret;
+
+  decklinksrc = GST_DECKLINK_SRC (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksrc, "activate");
+
+  if (gst_pad_check_pull_range (pad)) {
+    GST_DEBUG_OBJECT (pad, "activating pull");
+    ret = gst_pad_activate_pull (pad, TRUE);
+  } else {
+    GST_DEBUG_OBJECT (pad, "activating push");
+    ret = gst_pad_activate_push (pad, TRUE);
+  }
+
+  gst_object_unref (decklinksrc);
+  return ret;
+}
+
+static gboolean
+gst_decklink_src_video_src_activatepush (GstPad * pad, gboolean active)
+{
+  GstDecklinkSrc *decklinksrc;
+
+  decklinksrc = GST_DECKLINK_SRC (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksrc, "activatepush");
+
+
+  gst_object_unref (decklinksrc);
+  return TRUE;
+}
+
+static gboolean
+gst_decklink_src_video_src_activatepull (GstPad * pad, gboolean active)
+{
+  GstDecklinkSrc *decklinksrc;
+
+  decklinksrc = GST_DECKLINK_SRC (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksrc, "activatepull");
+
+
+  gst_object_unref (decklinksrc);
+  return TRUE;
+}
+
+static GstPadLinkReturn
+gst_decklink_src_video_src_link (GstPad * pad, GstPad * peer)
+{
+  GstDecklinkSrc *decklinksrc;
+
+  decklinksrc = GST_DECKLINK_SRC (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksrc, "link");
+
+
+  gst_object_unref (decklinksrc);
+  return GST_PAD_LINK_OK;
+}
+
+static GstFlowReturn
+gst_decklink_src_video_src_getrange (GstPad * pad, guint64 offset, guint length,
+    GstBuffer ** buffer)
+{
+  GstDecklinkSrc *decklinksrc;
+
+  decklinksrc = GST_DECKLINK_SRC (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksrc, "getrange");
+
+
+  gst_object_unref (decklinksrc);
+  return GST_FLOW_OK;
+}
+
+static gboolean
+gst_decklink_src_video_src_event (GstPad * pad, GstEvent * event)
+{
+  gboolean res;
+  GstDecklinkSrc *decklinksrc;
+
+  decklinksrc = GST_DECKLINK_SRC (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksrc, "event");
+
+  switch (GST_EVENT_TYPE (event)) {
+    default:
+      res = gst_pad_event_default (pad, event);
+      break;
+  }
+
+  gst_object_unref (decklinksrc);
+  return res;
+}
+
+static gboolean
+gst_decklink_src_video_src_query (GstPad * pad, GstQuery * query)
+{
+  gboolean res;
+  GstDecklinkSrc *decklinksrc;
+
+  decklinksrc = GST_DECKLINK_SRC (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksrc, "query");
+
+  switch (GST_QUERY_TYPE (query)) {
+    default:
+      res = gst_pad_query_default (pad, query);
+      break;
+  }
+
+  gst_object_unref (decklinksrc);
+  return res;
+}
+
+static GstIterator *
+gst_decklink_src_video_src_iterintlink (GstPad * pad)
+{
+  GstDecklinkSrc *decklinksrc;
+  GstIterator *iter;
+
+  decklinksrc = GST_DECKLINK_SRC (gst_pad_get_parent (pad));
+
+  GST_DEBUG_OBJECT (decklinksrc, "iterintlink");
+
+  iter = gst_pad_iterate_internal_links_default (pad);
+
+  gst_object_unref (decklinksrc);
+  return iter;
+}
+
+
+static void
+video_frame_free (void *data)
+{
+  IDeckLinkVideoInputFrame *video_frame = (IDeckLinkVideoInputFrame *)data;
+
+  video_frame->Release ();
+}
+
+static void
+gst_decklink_src_task (void *priv)
+{
+  GstDecklinkSrc *decklinksrc = GST_DECKLINK_SRC (priv);
+  GstBuffer *buffer;
+  GstBuffer *audio_buffer;
+  IDeckLinkVideoInputFrame *video_frame;
+  IDeckLinkAudioInputPacket *audio_frame;
+  int dropped_frames;
+  void *data;
+  int n_samples;
+  GstFlowReturn ret;
+
+  GST_DEBUG_OBJECT (decklinksrc, "task");
+
+  g_mutex_lock (decklinksrc->mutex);
+  while (decklinksrc->video_frame == NULL && !decklinksrc->stop) {
+    g_cond_wait (decklinksrc->cond, decklinksrc->mutex);
+  }
+  video_frame = decklinksrc->video_frame;
+  audio_frame = decklinksrc->audio_frame;
+  dropped_frames = decklinksrc->dropped_frames;
+  decklinksrc->video_frame = NULL;
+  decklinksrc->audio_frame = NULL;
+  g_mutex_unlock (decklinksrc->mutex);
+
+  if (decklinksrc->stop) {
+    GST_ERROR("stopping task");
+    return;
+  }
+
+  if (dropped_frames > 0) {
+    GST_ELEMENT_ERROR(decklinksrc, RESOURCE, READ, (NULL), (NULL));
+    /* ERROR */
+    return;
+  }
+
+  video_frame->GetBytes (&data);
+  if (decklinksrc->copy_data) {
+    buffer = gst_buffer_new_and_alloc (decklinksrc->width * decklinksrc->height * 2);
+
+    memcpy (GST_BUFFER_DATA (buffer), data, decklinksrc->width * decklinksrc->height * 2);
+
+    video_frame->Release ();
+  } else {
+    buffer = gst_buffer_new ();
+    GST_BUFFER_SIZE (buffer) = decklinksrc->width * decklinksrc->height * 2;
+
+    GST_BUFFER_DATA (buffer) = (guint8 *)data;
+
+    GST_BUFFER_FREE_FUNC (buffer) = video_frame_free;
+    GST_BUFFER_MALLOCDATA (buffer) = (guint8 *)video_frame;
+  }
+
+  GST_BUFFER_TIMESTAMP (buffer) =
+    gst_util_uint64_scale_int (decklinksrc->num_frames * GST_SECOND,
+        decklinksrc->fps_d, decklinksrc->fps_n);
+  GST_BUFFER_DURATION (buffer) =
+    gst_util_uint64_scale_int ((decklinksrc->num_frames + 1) * GST_SECOND,
+        decklinksrc->fps_d, decklinksrc->fps_n) -
+    GST_BUFFER_TIMESTAMP (buffer);
+  GST_BUFFER_OFFSET (buffer) = decklinksrc->num_frames;
+  if (decklinksrc->num_frames == 0) {
+    GST_BUFFER_FLAG_SET(buffer, GST_BUFFER_FLAG_DISCONT);
+  }
+  decklinksrc->num_frames ++;
+
+  if (decklinksrc->video_caps == NULL) {
+    decklinksrc->video_caps = gst_caps_new_simple ("video/x-raw-yuv",
+        "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC('U','Y','V','Y'),
+        "width", G_TYPE_INT, decklinksrc->width,
+        "height", G_TYPE_INT, decklinksrc->height,
+        "framerate", GST_TYPE_FRACTION,
+        decklinksrc->fps_n, decklinksrc->fps_d,
+        "interlaced", G_TYPE_BOOLEAN, decklinksrc->interlaced,
+        NULL);
+  }
+  gst_buffer_set_caps (buffer, decklinksrc->video_caps);
+
+  ret = gst_pad_push (decklinksrc->videosrcpad, buffer);
+  if (ret != GST_FLOW_OK) {
+    GST_ELEMENT_ERROR(decklinksrc, CORE, NEGOTIATION, (NULL), (NULL));
+  }
+
+
+  n_samples = audio_frame->GetSampleFrameCount();
+  audio_frame->GetBytes (&data);
+  audio_buffer = gst_buffer_new_and_alloc (n_samples * 2 * 2);
+  memcpy (GST_BUFFER_DATA (audio_buffer), data, n_samples * 2 * 2);
+  audio_frame->Release ();
+
+  GST_BUFFER_TIMESTAMP (audio_buffer) =
+    gst_util_uint64_scale_int (decklinksrc->num_audio_samples * GST_SECOND,
+        1, 48000);
+  GST_BUFFER_DURATION (audio_buffer) =
+    gst_util_uint64_scale_int ((decklinksrc->num_audio_samples + n_samples) * GST_SECOND,
+        1, 48000) - GST_BUFFER_TIMESTAMP (audio_buffer);
+  decklinksrc->num_audio_samples += n_samples;
+
+  if (decklinksrc->audio_caps == NULL) {
+    decklinksrc->audio_caps = gst_caps_new_simple ("audio/x-raw-int",
+        "endianness", G_TYPE_INT, LITTLE_ENDIAN,
+        "signed", G_TYPE_BOOLEAN, TRUE,
+        "depth", G_TYPE_INT, 16,
+        "width", G_TYPE_INT, 16,
+        "channels", G_TYPE_INT, 2,
+        "rate", G_TYPE_INT, 48000,
+        NULL);
+  }
+  gst_buffer_set_caps (audio_buffer, decklinksrc->audio_caps);
+
+  ret = gst_pad_push (decklinksrc->audiosrcpad, audio_buffer);
+  if (ret != GST_FLOW_OK) {
+    GST_ELEMENT_ERROR(decklinksrc, CORE, NEGOTIATION, (NULL), (NULL));
+  }
+}
+
+
diff --git a/sys/decklink/gstdecklinksrc.h b/sys/decklink/gstdecklinksrc.h
new file mode 100644
index 000000000..1200dc2b9
--- /dev/null
+++ b/sys/decklink/gstdecklinksrc.h
@@ -0,0 +1,84 @@
+/* GStreamer
+ * Copyright (C) 2011 David Schleef <ds@schleef.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef _GST_DECKLINK_SRC_H_
+#define _GST_DECKLINK_SRC_H_
+
+#include <gst/gst.h>
+#include "DeckLinkAPI.h"
+
+G_BEGIN_DECLS
+
+#define GST_TYPE_DECKLINK_SRC   (gst_decklink_src_get_type())
+#define GST_DECKLINK_SRC(obj)   (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_DECKLINK_SRC,GstDecklinkSrc))
+#define GST_DECKLINK_SRC_CLASS(klass)   (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_DECKLINK_SRC,GstDecklinkSrcClass))
+#define GST_IS_DECKLINK_SRC(obj)   (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_DECKLINK_SRC))
+#define GST_IS_DECKLINK_SRC_CLASS(obj)   (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_DECKLINK_SRC))
+
+typedef struct _GstDecklinkSrc GstDecklinkSrc;
+typedef struct _GstDecklinkSrcClass GstDecklinkSrcClass;
+
+struct _GstDecklinkSrc
+{
+  GstElement base_decklinksrc;
+
+  GstPad *audiosrcpad;
+  GstPad *videosrcpad;
+
+  GstCaps *audio_caps;
+
+  IDeckLink *decklink;
+  IDeckLinkInput *input;
+
+  GMutex *mutex;
+  GCond *cond;
+  int dropped_frames;
+  gboolean stop;
+  IDeckLinkVideoInputFrame *video_frame;
+  IDeckLinkAudioInputPacket * audio_frame;
+
+  GstTask *task;
+  GStaticRecMutex task_mutex;
+
+  int num_audio_samples;
+
+  GstCaps *video_caps;
+  int num_frames;
+  int fps_n;
+  int fps_d;
+  int width;
+  int height;
+  gboolean interlaced;
+  BMDDisplayMode bmd_mode;
+
+  /* properties */
+  gboolean copy_data;
+  int mode;
+};
+
+struct _GstDecklinkSrcClass
+{
+  GstElementClass base_decklinksrc_class;
+};
+
+GType gst_decklink_src_get_type (void);
+
+G_END_DECLS
+
+#endif