diff options
31 files changed, 19505 insertions, 11 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt index 15ee8349f39..e7a0f7ad177 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -229,6 +229,7 @@ option(WITH_BULLET "Enable Bullet (Physics Engine)" ON) option(WITH_SYSTEM_BULLET "Use the systems bullet library (currently unsupported due to missing features in upstream!)" ) mark_as_advanced(WITH_SYSTEM_BULLET) option(WITH_GAMEENGINE "Enable Game Engine" ${_init_GAMEENGINE}) +option(WITH_GAMEENGINE_DECKLINK "Support BlackMagicDesign DeckLink cards in the Game Engine" ON) option(WITH_PLAYER "Build Player" OFF) option(WITH_OPENCOLORIO "Enable OpenColorIO color management" ${_init_OPENCOLORIO}) diff --git a/build_files/cmake/macros.cmake b/build_files/cmake/macros.cmake index 3aa938b63d7..d29f086069a 100644 --- a/build_files/cmake/macros.cmake +++ b/build_files/cmake/macros.cmake @@ -685,6 +685,14 @@ function(SETUP_BLENDER_SORTED_LIBS) list_insert_after(BLENDER_SORTED_LIBS "ge_logic_ngnetwork" "extern_bullet") endif() + if(WITH_GAMEENGINE_DECKLINK) + list(APPEND BLENDER_SORTED_LIBS bf_intern_decklink) + endif() + + if(WIN32) + list(APPEND BLENDER_SORTED_LIBS bf_intern_gpudirect) + endif() + if(WITH_OPENSUBDIV) list(APPEND BLENDER_SORTED_LIBS bf_intern_opensubdiv) endif() diff --git a/doc/python_api/examples/bge.texture.2.py b/doc/python_api/examples/bge.texture.2.py new file mode 100644 index 00000000000..96619007fba --- /dev/null +++ b/doc/python_api/examples/bge.texture.2.py @@ -0,0 +1,237 @@ +""" +Video Capture with DeckLink ++++++++++++++++++++++++++++ +Video frames captured with DeckLink cards have pixel formats that are generally not directly +usable by OpenGL, they must be processed by a shader. The three shaders presented here should +cover all common video capture cases. + +This file reflects the current video transfer method implemented in the Decklink module: +whenever possible the video images are transferred as float texture because this is more +compatible with GPUs. Of course, only the pixel formats that have a correspondant GL format +can be transferred as float. Look for fg_shaders in this file for an exhaustive list. + +Other pixel formats will be transferred as 32 bits integer red-channel texture but this +won't work with certain GPU (Intel GMA); the corresponding shaders are not shown here. +However, it should not be necessary to use any of them as the list below covers all practical +cases of video capture with all types of Decklink product. + +In other words, only use one of the pixel format below and you will be fine. Note that depending +on the video stream, only certain pixel formats will be allowed (others will throw an exception). +For example, to capture a PAL video stream, you must use one of the YUV formats. + +To find which pixel format is suitable for a particular video stream, use the 'Media Express' +utility that comes with the Decklink software : if you see the video in the 'Log and Capture' +Window, you have selected the right pixel format and you can use the same in Blender. + +Notes: * these shaders only decode the RGB channel and set the alpha channel to a fixed +value (look for color.a = ). It's up to you to add postprocessing to the color. + * these shaders are compatible with 2D and 3D video stream +""" +import bge +from bge import logic +from bge import texture as vt + +# The default vertex shader, because we need one +# +VertexShader = """ +#version 130 + void main() + { + gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; + gl_TexCoord[0] = gl_MultiTexCoord0; + } + +""" + +# For use with RGB video stream: the pixel is directly usable +# +FragmentShader_R10l = """ + #version 130 + uniform sampler2D tex; + // stereo = 1.0 if 2D image, =0.5 if 3D (left eye below, right eye above) + uniform float stereo; + // eye = 0.0 for the left eye, 0.5 for the right eye + uniform float eye; + + void main(void) + { + vec4 color; + float tx, ty; + tx = gl_TexCoord[0].x; + ty = eye+gl_TexCoord[0].y*stereo; + color = texture(tex, vec2(tx,ty)); + color.a = 0.7; + gl_FragColor = color; + } +""" + +# For use with YUV video stream +# +FragmentShader_2vuy = """ + #version 130 + uniform sampler2D tex; + // stereo = 1.0 if 2D image, =0.5 if 3D (left eye below, right eye above) + uniform float stereo; + // eye = 0.0 for the left eye, 0.5 for the right eye + uniform float eye; + + void main(void) + { + vec4 color; + float tx, ty, width, Y, Cb, Cr; + int px; + tx = gl_TexCoord[0].x; + ty = eye+gl_TexCoord[0].y*stereo; + width = float(textureSize(tex, 0).x); + color = texture(tex, vec2(tx, ty)); + px = int(floor(fract(tx*width)*2.0)); + switch (px) { + case 0: + Y = color.g; + break; + case 1: + Y = color.a; + break; + } + Y = (Y - 0.0625) * 1.168949772; + Cb = (color.b - 0.0625) * 1.142857143 - 0.5; + Cr = (color.r - 0.0625) * 1.142857143 - 0.5; + color.r = Y + 1.5748 * Cr; + color.g = Y - 0.1873 * Cb - 0.4681 * Cr; + color.b = Y + 1.8556 * Cb; + color.a = 0.7; + gl_FragColor = color; + } +""" + +# For use with high resolution YUV +# +FragmentShader_v210 = """ + #version 130 + uniform sampler2D tex; + // stereo = 1.0 if 2D image, =0.5 if 3D (left eye below, right eye above) + uniform float stereo; + // eye = 0.0 for the left eye, 0.5 for the right eye + uniform float eye; + + void main(void) + { + vec4 color, color1, color2, color3; + int px; + float tx, ty, width, sx, dx, bx, Y, Cb, Cr; + tx = gl_TexCoord[0].x; + ty = eye+gl_TexCoord[0].y*stereo; + width = float(textureSize(tex, 0).x); + // to sample macro pixels (6 pixels in 4 words) + sx = tx*width*0.25+0.01; + // index of display pixel in the macro pixel 0..5 + px = int(floor(fract(sx)*6.0)); + // increment as we sample the macro pixel + dx = 1.0/width; + // base x coord of macro pixel + bx = (floor(sx)+0.01)*dx*4.0; + color = texture(tex, vec2(bx, ty)); + color1 = texture(tex, vec2(bx+dx, ty)); + color2 = texture(tex, vec2(bx+dx*2.0, ty)); + color3 = texture(tex, vec2(bx+dx*3.0, ty)); + switch (px) { + case 0: + case 1: + Cb = color.b; + Cr = color.r; + break; + case 2: + case 3: + Cb = color1.g; + Cr = color2.b; + break; + default: + Cb = color2.r; + Cr = color3.g; + break; + } + switch (px) { + case 0: + Y = color.g; + break; + case 1: + Y = color1.b; + break; + case 2: + Y = color1.r; + break; + case 3: + Y = color2.g; + break; + case 4: + Y = color3.b; + break; + default: + Y = color3.r; + break; + } + Y = (Y - 0.0625) * 1.168949772; + Cb = (Cb - 0.0625) * 1.142857143 - 0.5; + Cr = (Cr - 0.0625) * 1.142857143 - 0.5; + color.r = Y + 1.5748 * Cr; + color.g = Y - 0.1873 * Cb - 0.4681 * Cr; + color.b = Y + 1.8556 * Cb; + color.a = 0.7; + gl_FragColor = color; + } +""" + +# The exhausitve list of pixel formats that are transferred as float texture +# Only use those for greater efficiency and compatiblity. +# +fg_shaders = { + '2vuy' :FragmentShader_2vuy, + '8BitYUV' :FragmentShader_2vuy, + 'v210' :FragmentShader_v210, + '10BitYUV' :FragmentShader_v210, + '8BitBGRA' :FragmentShader_R10l, + 'BGRA' :FragmentShader_R10l, + '8BitARGB' :FragmentShader_R10l, + '10BitRGBXLE':FragmentShader_R10l, + 'R10l' :FragmentShader_R10l + } + + +# +# Helper function to attach a pixel shader to the material that receives the video frame. +# + +def config_video(obj, format, pixel, is3D=False, mat=0, card=0): + if pixel not in fg_shaders: + raise('Unsuported shader') + shader = obj.meshes[0].materials[mat].getShader() + if shader is not None and not shader.isValid(): + shader.setSource(VertexShader, fg_shaders[pixel], True) + shader.setSampler('tex', 0) + shader.setUniformEyef("eye") + shader.setUniform1f("stereo", 0.5 if is3D else 1.0) + tex = vt.Texture(obj, mat) + tex.source = vt.VideoDeckLink(format + "/" + pixel + ("/3D" if is3D else ""), card) + print("frame rate: ", tex.source.framerate) + tex.source.play() + obj["video"] = tex + +# +# Attach this function to an object that has a material with texture +# and call it once to initialize the object +# +def init(cont): + # config_video(cont.owner, 'HD720p5994', '8BitBGRA') + # config_video(cont.owner, 'HD720p5994', '8BitYUV') + # config_video(cont.owner, 'pal ', '10BitYUV') + config_video(cont.owner, 'pal ', '8BitYUV') + + +# +# To be called on every frame +# +def play(cont): + obj = cont.owner + video = obj.get("video") + if video is not None: + video.refresh(True) diff --git a/doc/python_api/rst/bge.texture.rst b/doc/python_api/rst/bge.texture.rst index e226d2f90c0..9d6166b2502 100644 --- a/doc/python_api/rst/bge.texture.rst +++ b/doc/python_api/rst/bge.texture.rst @@ -49,8 +49,15 @@ When the texture object is deleted, the new texture is deleted and the old textu .. literalinclude:: ../examples/bge.texture.1.py :lines: 8- - - + + +.. include:: ../examples/bge.texture.2.py + :start-line: 1 + :end-line: 6 + +.. literalinclude:: ../examples/bge.texture.2.py + :lines: 8- + ************* Video classes ************* @@ -189,7 +196,6 @@ Video classes :return: see `FFmpeg Video and Image Status`_. :rtype: int - ************* Image classes ************* @@ -256,7 +262,7 @@ Image classes .. method:: refresh(buffer=None, format="RGBA") Refresh image, get its status and optionally copy the frame to an external buffer. - + :arg buffer: An optional object that implements the buffer protocol. If specified, the image is copied to the buffer, which must be big enough or an exception is thrown. :type buffer: any buffer type @@ -576,12 +582,12 @@ Image classes :type: bool -.. class:: ImageRender(scene, camera, fbo=None) +.. class:: ImageRender(scene, camera) Image source from render. The render is done on a custom framebuffer object if fbo is specified, otherwise on the default framebuffer. - + :arg scene: Scene in which the image has to be taken. :type scene: :class:`~bge.types.KX_Scene` :arg camera: Camera from which the image has to be taken. @@ -631,7 +637,7 @@ Image classes .. attribute:: image Image data. (readonly) - + :type: :class:`~bgl.Buffer` or None .. attribute:: scale @@ -807,7 +813,184 @@ Image classes :type: bool - +.. class:: VideoDeckLink(format, capture=0) + + Image source from an external video stream captured with a DeckLink video card from + Black Magic Design. + Before this source can be used, a DeckLink hardware device must be installed, it can be a PCIe card + or a USB device, and the 'Desktop Video' software package (version 10.4 or above must be installed) + on the host as described in the DeckLink documentation. + If in addition you have a recent nVideo Quadro card, you can benefit from the 'GPUDirect' technology + to push the captured video frame very efficiently to the GPU. For this you need to install the + 'DeckLink SDK' version 10.4 or above and copy the 'dvp.dll' runtime library to Blender's + installation directory or to any other place where Blender can load a DLL from. + + :arg format: string describing the video format to be captured. + :type format: str + :arg capture: Card number from which the input video must be captured. + :type capture: int + + The format argument must be written as ``<displayMode>/<pixelFormat>[/3D][:<cacheSize>]`` where ``<displayMode>`` + describes the frame size and rate and <pixelFormat> the encoding of the pixels. + The optional ``/3D`` suffix is to be used if the video stream is stereo with a left and right eye feed. + The optional ``:<cacheSize>`` suffix determines the number of the video frames kept in cache, by default 8. + Some DeckLink cards won't work below a certain cache size. + The default value 8 should be sufficient for all cards. + You may try to reduce the cache size to reduce the memory footprint. For example the The 4K Extreme is known + to work with 3 frames only, the Extreme 2 needs 4 frames and the Intensity Shuttle needs 6 frames, etc. + Reducing the cache size may be useful when Decklink is used in conjunction with GPUDirect: + all frames must be locked in memory in that case and that puts a lot of pressure on memory. + If you reduce the cache size too much, + you'll get no error but no video feed either. + + The valid ``<displayMode>`` values are copied from the ``BMDDisplayMode`` enum in the DeckLink API + without the 'bmdMode' prefix. In case a mode that is not in this list is added in a later version + of the SDK, it is also possible to specify the 4 letters of the internal code for that mode. + You will find the internal code in the ``DeckLinkAPIModes.h`` file that is part of the SDK. + Here is for reference the full list of supported display modes with their equivalent internal code: + + Internal Codes + - NTSC 'ntsc' + - NTSC2398 'nt23' + - PAL 'pal ' + - NTSCp 'ntsp' + - PALp 'palp' + HD 1080 Modes + - HD1080p2398 '23ps' + - HD1080p24 '24ps' + - HD1080p25 'Hp25' + - HD1080p2997 'Hp29' + - HD1080p30 'Hp30' + - HD1080i50 'Hi50' + - HD1080i5994 'Hi59' + - HD1080i6000 'Hi60' + - HD1080p50 'Hp50' + - HD1080p5994 'Hp59' + - HD1080p6000 'Hp60' + HD 720 Modes + - HD720p50 'hp50' + - HD720p5994 'hp59' + - HD720p60 'hp60' + 2k Modes + - 2k2398 '2k23' + - 2k24 '2k24' + - 2k25 '2k25' + 4k Modes + - 4K2160p2398 '4k23' + - 4K2160p24 '4k24' + - 4K2160p25 '4k25' + - 4K2160p2997 '4k29' + - 4K2160p30 '4k30' + - 4K2160p50 '4k50' + - 4K2160p5994 '4k59' + - 4K2160p60 '4k60' + + Most of names are self explanatory. If necessary refer to the DeckLink API documentation for more information. + + Similarly, <pixelFormat> is copied from the BMDPixelFormat enum. + + Here is for reference the full list of supported pixel format and their equivalent internal code: + + Pixel Formats + - 8BitYUV '2vuy' + - 10BitYUV 'v210' + - 8BitARGB * no equivalent code * + - 8BitBGRA 'BGRA' + - 10BitRGB 'r210' + - 12BitRGB 'R12B' + - 12BitRGBLE 'R12L' + - 10BitRGBXLE 'R10l' + - 10BitRGBX 'R10b' + + Refer to the DeckLink SDK documentation for a full description of these pixel format. + It is important to understand them as the decoding of the pixels is NOT done in VideoTexture + for performance reason. Instead a specific shader must be used to decode the pixel in the GPU. + Only the '8BitARGB', '8BitBGRA' and '10BitRGBXLE' pixel formats are mapped directly to OpenGL RGB float textures. + The '8BitYUV' and '10BitYUV' pixel formats are mapped to openGL RGB float texture but require a shader to decode. + The other pixel formats are sent as a ``GL_RED_INTEGER`` texture (i.e. a texture with only the + red channel coded as an unsigned 32 bit integer) and are not recommended for use. + + Example: ``HD1080p24/10BitYUV/3D:4`` is equivalent to ``24ps/v210/3D:4`` + and represents a full HD stereo feed at 24 frame per second and 4 frames cache size. + + Although video format auto detection is possible with certain DeckLink devices, the corresponding + API is NOT implemented in the BGE. Therefore it is important to specify the format string that + matches exactly the video feed. If the format is wrong, no frame will be captured. + It should be noted that the pixel format that you need to specify is not necessarily the actual + format in the video feed. For example, the 4K Extreme card delivers 8bit RGBs pixels in the + '10BitRGBXLE' format. Use the 'Media Express' application included in 'Desktop Video' to discover + which pixel format works for a particular video stream. + + .. attribute:: status + + Status of the capture: 1=ready to use, 2=capturing, 3=stopped + + :type: int + + .. attribute:: framerate + + Capture frame rate as computed from the video format. + + :type: float + + .. attribute:: valid + + Tells if the image attribute can be used to retrieve the image. + Always False in this implementation (the image is not available at python level) + + :type: bool + + .. attribute:: image + + The image data. Always None in this implementation. + + :type: :class:`~bgl.Buffer` or None + + .. attribute:: size + + The size of the frame in pixel. + Stereo frames have double the height of the video frame, i.e. 3D is delivered to the GPU + as a single image in top-bottom order, left eye on top. + + :type: (int,int) + + .. attribute:: scale + + Not used in this object. + + :type: bool + + .. attribute:: flip + + Not used in this object. + + :type: bool + + .. attribute:: filter + + Not used in this object. + + .. method:: play() + + Kick-off the capture after creation of the object. + + :return: True if the capture could be started, False otherwise. + :rtype: bool + + .. method:: pause() + + Temporary stops the capture. Use play() to restart it. + + :return: True if the capture could be paused, False otherwise. + :rtype: bool + + .. method:: stop() + + Stops the capture. + + :return: True if the capture could be stopped, False otherwise. + :rtype: bool + *************** Texture classes *************** @@ -859,6 +1042,7 @@ Texture classes :type: one of... * :class:`VideoFFmpeg` + * :class:`VideoDeckLink` * :class:`ImageFFmpeg` * :class:`ImageBuff` * :class:`ImageMirror` @@ -866,7 +1050,129 @@ Texture classes * :class:`ImageRender` * :class:`ImageViewport` - +.. class:: DeckLink(cardIdx=0, format="") + + Certain DeckLink devices can be used to playback video: the host sends video frames regularly + for immediate or scheduled playback. The video feed is outputted on HDMI or SDI interfaces. + This class supports the immediate playback mode: it has a source attribute that is assigned + one of the source object in the bge.texture module. Refreshing the DeckLink object causes + the image source to be computed and sent to the DeckLink device for immediate transmission + on the output interfaces. Keying is supported: it allows to composite the frame with an + input video feed that transits through the DeckLink card. + + :arg cardIdx: Number of the card to be used for output (0=first card). + It should be noted that DeckLink devices are usually half duplex: + they can either be used for capture or playback but not both at the same time. + :type cardIdx: int + :arg format: String representing the display mode of the output feed. + :type format: str + + The default value of the format argument is reserved for auto detection but it is currently + not supported (it will generate a runtime error) and thus the video format must be explicitly + specified. If keying is the goal (see keying attributes), the format must match exactly the + input video feed, otherwise it can be any format supported by the device (there will be a + runtime error if not). + The format of the string is ``<displayMode>[/3D]``. + + Refer to :class:`VideoDeckLink` to get the list of acceptable ``<displayMode>``. + The optional ``/3D`` suffix is used to create a stereo 3D feed. + In that case the 'right' attribute must also be set to specify the image source for the right eye. + + Note: The pixel format is not specified here because it is always BGRA. The alpha channel is + used in keying to mix the source with the input video feed, otherwise it is not used. + If a conversion is needed to match the native video format, it is done inside the DeckLink driver + or device. + + .. attribute:: source + + This attribute must be set to one of the image source. If the image size does not fit exactly + the frame size, the extend attribute determines what to do. + + For best performance, the source image should match exactly the size of the output frame. + A further optimization is achieved if the image source object is ImageViewport or ImageRender + set for whole viewport, flip disabled and no filter: the GL frame buffer is copied directly + to the image buffer and directly from there to the DeckLink card (hence no buffer to buffer + copy inside VideoTexture). + + :type: one of... + - :class:`VideoFFmpeg` + - :class:`VideoDeckLink` + - :class:`ImageFFmpeg` + - :class:`ImageBuff` + - :class:`ImageMirror` + - :class:`ImageMix` + - :class:`ImageRender` + - :class:`ImageViewport` + + .. attribute:: right + + If the video format is stereo 3D, this attribute should be set to an image source object + that will produce the right eye images. If the goal is to render the BGE scene in 3D, + it can be achieved with 2 cameras, one for each eye, used by 2 ImageRender with an offscreen + render buffer that is just the size of the video frame. + + :type: one of... + - :class:`VideoFFmpeg` + - :class:`VideoDeckLink` + - :class:`ImageFFmpeg` + - :class:`ImageBuff` + - :class:`ImageMirror` + - :class:`ImageMix` + - :class:`ImageRender` + - :class:`ImageViewport` + + .. attribute:: keying + + Specify if keying is enabled. False (default): the output frame is sent unmodified on + the output interface (in that case no input video is required). True: the output frame + is mixed with the input video, using the alpha channel to blend the two images and the + combination is sent on the output interface. + + :type: bool + + .. attribute:: level + + If keying is enabled, sets the keying level from 0 to 255. This value is a global alpha value + that multiplies the alpha channel of the image source. Use 255 (the default) to keep the alpha + channel unmodified, 0 to make the output frame totally transparent. + + :type: int + + .. attribute:: extend + + Determines how the image source should be mapped if the size does not fit the video frame size. + * False (the default): map the image pixel by pixel. + If the image size is smaller than the frame size, extra space around the image is filled with + 0-alpha black. If it is larger, the image is cropped to fit the frame size. + * True: the image is scaled by the nearest neighbor algorithm to fit the frame size. + The scaling is fast but poor quality. For best results, always adjust the image source to + match the size of the output video. + + :type: bool + + .. method:: close() + + Close the DeckLink device and release all resources. After calling this method, + the object cannot be reactivated, it must be destroyed and a new DeckLink object + created from fresh to restart the output. + + .. method:: refresh(refresh_source,ts) + + This method must be called frequently to update the output frame in the DeckLink device. + + :arg refresh_source: True if the source objects image buffer should be invalidated after being + used to compute the output frame. This triggers the recomputing of the + source image on next refresh, which is normally the desired effect. + False if the image source buffer should stay valid and reused on next refresh. + Note that the DeckLink device stores the output frame and replays until a + new frame is sent from the host. Thus, it is not necessary to refresh the + DeckLink object if it is known that the image source has not changed. + :type refresh_source: bool + :arg ts: The timestamp value passed to the image source object to compute the image. + If unspecified, the BGE clock is used. + :type ts: float + + ************** Filter classes ************** diff --git a/intern/CMakeLists.txt b/intern/CMakeLists.txt index 43e5b6bff3e..9a5476772ab 100644 --- a/intern/CMakeLists.txt +++ b/intern/CMakeLists.txt @@ -34,6 +34,10 @@ add_subdirectory(mikktspace) add_subdirectory(glew-mx) add_subdirectory(eigen) +if (WITH_GAMEENGINE_DECKLINK) + add_subdirectory(decklink) +endif() + if(WITH_AUDASPACE) add_subdirectory(audaspace) endif() @@ -79,8 +83,10 @@ if(WITH_OPENSUBDIV) endif() # only windows needs utf16 converter +# gpudirect is a runtime interface to the nVidia's DVP driver, only for windows if(WIN32) add_subdirectory(utfconv) + add_subdirectory(gpudirect) endif() if(WITH_OPENVDB) diff --git a/intern/decklink/CMakeLists.txt b/intern/decklink/CMakeLists.txt new file mode 100644 index 00000000000..fbef65cdba4 --- /dev/null +++ b/intern/decklink/CMakeLists.txt @@ -0,0 +1,58 @@ +# ***** BEGIN GPL LICENSE BLOCK ***** +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. +# +# This program 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 General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software Foundation, +# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +# +# The Original Code is Copyright (C) 2015, Blender Foundation +# All rights reserved. +# +# The Original Code is: all of this file. +# +# Contributor(s): Blender Foundation. +# +# ***** END GPL LICENSE BLOCK ***** + +set(INC +) + +set(INC_SYS +) + +set(SRC + DeckLinkAPI.cpp + DeckLinkAPI.h +) + +if (WIN32) + list(APPEND SRC + win/DeckLinkAPI_h.h + win/DeckLinkAPI_i.c + ) +endif() + +if (UNIX AND NOT APPLE) + list(APPEND SRC + linux/DeckLinkAPI.h + linux/DeckLinkAPIConfiguration.h + linux/DeckLinkAPIDeckControl.h + linux/DeckLinkAPIDiscovery.h + linux/DeckLinkAPIDispatch.cpp + linux/DeckLinkAPIModes.h + linux/DeckLinkAPIVersion.h + linux/DeckLinkAPITypes.h + linux/LinuxCOM.h + ) +endif() + +blender_add_lib(bf_intern_decklink "${SRC}" "${INC}" "${INC_SYS}") diff --git a/intern/decklink/DeckLinkAPI.cpp b/intern/decklink/DeckLinkAPI.cpp new file mode 100644 index 00000000000..73a1264176b --- /dev/null +++ b/intern/decklink/DeckLinkAPI.cpp @@ -0,0 +1,50 @@ +/* + * ***** BEGIN GPL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * +* The Original Code is Copyright (C) 2015, Blender Foundation +* All rights reserved. +* +* The Original Code is: all of this file. +* +* Contributor(s): Blender Foundation. + * + * ***** END GPL LICENSE BLOCK ***** + */ + +/** \file decklink/DeckLinkAPI.cpp +* \ingroup decklink +*/ + +#include "DeckLinkAPI.h" + +#ifdef WIN32 +IDeckLinkIterator* BMD_CreateDeckLinkIterator(void) +{ + HRESULT result; + IDeckLinkIterator* pDLIterator = NULL; + + result = CoCreateInstance(CLSID_CDeckLinkIterator, NULL, CLSCTX_ALL, IID_IDeckLinkIterator, (void**)&pDLIterator); + if (FAILED(result)) + return NULL; + return pDLIterator; +} +#else +IDeckLinkIterator* BMD_CreateDeckLinkIterator(void) +{ + return CreateDeckLinkIteratorInstance(); +} +#endif // WIN32 diff --git a/intern/decklink/DeckLinkAPI.h b/intern/decklink/DeckLinkAPI.h new file mode 100644 index 00000000000..f6d2b79f53e --- /dev/null +++ b/intern/decklink/DeckLinkAPI.h @@ -0,0 +1,56 @@ +/* + * ***** BEGIN GPL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * +* The Original Code is Copyright (C) 2015, Blender Foundation +* All rights reserved. +* +* The Original Code is: all of this file. +* +* Contributor(s): Blender Foundation. + * + * ***** END GPL LICENSE BLOCK ***** + */ + +/** \file decklink/DeckLinkAPI.h +* \ingroup decklink +*/ + +#ifndef __DECKLINKAPI_H__ +#define __DECKLINKAPI_H__ + +/* Include the OS specific Declink headers */ + +#ifdef WIN32 +# include <windows.h> +# include <objbase.h> +# include <comutil.h> +# include "win/DeckLinkAPI_h.h" + typedef unsigned int dl_size_t; +#elif defined(__APPLE__) +# error "Decklink not supported in OSX" +#else +# include "linux/DeckLinkAPI.h" + /* Windows COM API uses BOOL, linux uses bool */ +# define BOOL bool + typedef uint32_t dl_size_t; +#endif + + +/* OS independent function to get the device iterator */ +IDeckLinkIterator* BMD_CreateDeckLinkIterator(void); + +#endif /* __DECKLINKAPI_H__ */ diff --git a/intern/decklink/linux/DeckLinkAPI.h b/intern/decklink/linux/DeckLinkAPI.h new file mode 100644 index 00000000000..08bfba39994 --- /dev/null +++ b/intern/decklink/linux/DeckLinkAPI.h @@ -0,0 +1,767 @@ +/* -LICENSE-START- +** Copyright (c) 2014 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 BMD_DECKLINKAPI_H +#define BMD_DECKLINKAPI_H + + +#ifndef BMD_CONST + #if defined(_MSC_VER) + #define BMD_CONST __declspec(selectany) static const + #else + #define BMD_CONST static const + #endif +#endif + +/* DeckLink API */ + +#include <stdint.h> +#include "LinuxCOM.h" + +#include "DeckLinkAPITypes.h" +#include "DeckLinkAPIModes.h" +#include "DeckLinkAPIDiscovery.h" +#include "DeckLinkAPIConfiguration.h" +#include "DeckLinkAPIDeckControl.h" + +#define BLACKMAGIC_DECKLINK_API_MAGIC 1 + +// Type Declarations + + +// Interface ID Declarations + +BMD_CONST REFIID IID_IDeckLinkVideoOutputCallback = /* 20AA5225-1958-47CB-820B-80A8D521A6EE */ {0x20,0xAA,0x52,0x25,0x19,0x58,0x47,0xCB,0x82,0x0B,0x80,0xA8,0xD5,0x21,0xA6,0xEE}; +BMD_CONST REFIID IID_IDeckLinkInputCallback = /* DD04E5EC-7415-42AB-AE4A-E80C4DFC044A */ {0xDD,0x04,0xE5,0xEC,0x74,0x15,0x42,0xAB,0xAE,0x4A,0xE8,0x0C,0x4D,0xFC,0x04,0x4A}; +BMD_CONST REFIID IID_IDeckLinkMemoryAllocator = /* B36EB6E7-9D29-4AA8-92EF-843B87A289E8 */ {0xB3,0x6E,0xB6,0xE7,0x9D,0x29,0x4A,0xA8,0x92,0xEF,0x84,0x3B,0x87,0xA2,0x89,0xE8}; +BMD_CONST REFIID IID_IDeckLinkAudioOutputCallback = /* 403C681B-7F46-4A12-B993-2BB127084EE6 */ {0x40,0x3C,0x68,0x1B,0x7F,0x46,0x4A,0x12,0xB9,0x93,0x2B,0xB1,0x27,0x08,0x4E,0xE6}; +BMD_CONST REFIID IID_IDeckLinkIterator = /* 50FB36CD-3063-4B73-BDBB-958087F2D8BA */ {0x50,0xFB,0x36,0xCD,0x30,0x63,0x4B,0x73,0xBD,0xBB,0x95,0x80,0x87,0xF2,0xD8,0xBA}; +BMD_CONST REFIID IID_IDeckLinkAPIInformation = /* 7BEA3C68-730D-4322-AF34-8A7152B532A4 */ {0x7B,0xEA,0x3C,0x68,0x73,0x0D,0x43,0x22,0xAF,0x34,0x8A,0x71,0x52,0xB5,0x32,0xA4}; +BMD_CONST REFIID IID_IDeckLinkOutput = /* CC5C8A6E-3F2F-4B3A-87EA-FD78AF300564 */ {0xCC,0x5C,0x8A,0x6E,0x3F,0x2F,0x4B,0x3A,0x87,0xEA,0xFD,0x78,0xAF,0x30,0x05,0x64}; +BMD_CONST REFIID IID_IDeckLinkInput = /* AF22762B-DFAC-4846-AA79-FA8883560995 */ {0xAF,0x22,0x76,0x2B,0xDF,0xAC,0x48,0x46,0xAA,0x79,0xFA,0x88,0x83,0x56,0x09,0x95}; +BMD_CONST REFIID IID_IDeckLinkVideoFrame = /* 3F716FE0-F023-4111-BE5D-EF4414C05B17 */ {0x3F,0x71,0x6F,0xE0,0xF0,0x23,0x41,0x11,0xBE,0x5D,0xEF,0x44,0x14,0xC0,0x5B,0x17}; +BMD_CONST REFIID IID_IDeckLinkMutableVideoFrame = /* 69E2639F-40DA-4E19-B6F2-20ACE815C390 */ {0x69,0xE2,0x63,0x9F,0x40,0xDA,0x4E,0x19,0xB6,0xF2,0x20,0xAC,0xE8,0x15,0xC3,0x90}; +BMD_CONST REFIID IID_IDeckLinkVideoFrame3DExtensions = /* DA0F7E4A-EDC7-48A8-9CDD-2DB51C729CD7 */ {0xDA,0x0F,0x7E,0x4A,0xED,0xC7,0x48,0xA8,0x9C,0xDD,0x2D,0xB5,0x1C,0x72,0x9C,0xD7}; +BMD_CONST REFIID IID_IDeckLinkVideoInputFrame = /* 05CFE374-537C-4094-9A57-680525118F44 */ {0x05,0xCF,0xE3,0x74,0x53,0x7C,0x40,0x94,0x9A,0x57,0x68,0x05,0x25,0x11,0x8F,0x44}; +BMD_CONST REFIID IID_IDeckLinkVideoFrameAncillary = /* 732E723C-D1A4-4E29-9E8E-4A88797A0004 */ {0x73,0x2E,0x72,0x3C,0xD1,0xA4,0x4E,0x29,0x9E,0x8E,0x4A,0x88,0x79,0x7A,0x00,0x04}; +BMD_CONST REFIID IID_IDeckLinkAudioInputPacket = /* E43D5870-2894-11DE-8C30-0800200C9A66 */ {0xE4,0x3D,0x58,0x70,0x28,0x94,0x11,0xDE,0x8C,0x30,0x08,0x00,0x20,0x0C,0x9A,0x66}; +BMD_CONST REFIID IID_IDeckLinkScreenPreviewCallback = /* B1D3F49A-85FE-4C5D-95C8-0B5D5DCCD438 */ {0xB1,0xD3,0xF4,0x9A,0x85,0xFE,0x4C,0x5D,0x95,0xC8,0x0B,0x5D,0x5D,0xCC,0xD4,0x38}; +BMD_CONST REFIID IID_IDeckLinkGLScreenPreviewHelper = /* 504E2209-CAC7-4C1A-9FB4-C5BB6274D22F */ {0x50,0x4E,0x22,0x09,0xCA,0xC7,0x4C,0x1A,0x9F,0xB4,0xC5,0xBB,0x62,0x74,0xD2,0x2F}; +BMD_CONST REFIID IID_IDeckLinkNotificationCallback = /* B002A1EC-070D-4288-8289-BD5D36E5FF0D */ {0xB0,0x02,0xA1,0xEC,0x07,0x0D,0x42,0x88,0x82,0x89,0xBD,0x5D,0x36,0xE5,0xFF,0x0D}; +BMD_CONST REFIID IID_IDeckLinkNotification = /* 0A1FB207-E215-441B-9B19-6FA1575946C5 */ {0x0A,0x1F,0xB2,0x07,0xE2,0x15,0x44,0x1B,0x9B,0x19,0x6F,0xA1,0x57,0x59,0x46,0xC5}; +BMD_CONST REFIID IID_IDeckLinkAttributes = /* ABC11843-D966-44CB-96E2-A1CB5D3135C4 */ {0xAB,0xC1,0x18,0x43,0xD9,0x66,0x44,0xCB,0x96,0xE2,0xA1,0xCB,0x5D,0x31,0x35,0xC4}; +BMD_CONST REFIID IID_IDeckLinkKeyer = /* 89AFCAF5-65F8-421E-98F7-96FE5F5BFBA3 */ {0x89,0xAF,0xCA,0xF5,0x65,0xF8,0x42,0x1E,0x98,0xF7,0x96,0xFE,0x5F,0x5B,0xFB,0xA3}; +BMD_CONST REFIID IID_IDeckLinkVideoConversion = /* 3BBCB8A2-DA2C-42D9-B5D8-88083644E99A */ {0x3B,0xBC,0xB8,0xA2,0xDA,0x2C,0x42,0xD9,0xB5,0xD8,0x88,0x08,0x36,0x44,0xE9,0x9A}; +BMD_CONST REFIID IID_IDeckLinkDeviceNotificationCallback = /* 4997053B-0ADF-4CC8-AC70-7A50C4BE728F */ {0x49,0x97,0x05,0x3B,0x0A,0xDF,0x4C,0xC8,0xAC,0x70,0x7A,0x50,0xC4,0xBE,0x72,0x8F}; +BMD_CONST REFIID IID_IDeckLinkDiscovery = /* CDBF631C-BC76-45FA-B44D-C55059BC6101 */ {0xCD,0xBF,0x63,0x1C,0xBC,0x76,0x45,0xFA,0xB4,0x4D,0xC5,0x50,0x59,0xBC,0x61,0x01}; + +/* 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, + bmdDetectedVideoInputDualStream3D = 1 << 2 +}; + +/* Enum BMDDeckLinkCapturePassthroughMode - Enumerates whether the video output is electrically connected to the video input or if the clean switching mode is enabled */ + +typedef uint32_t BMDDeckLinkCapturePassthroughMode; +enum _BMDDeckLinkCapturePassthroughMode { + bmdDeckLinkCapturePassthroughModeDirect = /* 'pdir' */ 0x70646972, + bmdDeckLinkCapturePassthroughModeCleanSwitch = /* 'pcln' */ 0x70636C6E +}; + +/* 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 { + bmdTimecodeRP188VITC1 = /* 'rpv1' */ 0x72707631, // RP188 timecode where DBB1 equals VITC1 (line 9) + bmdTimecodeRP188VITC2 = /* 'rp12' */ 0x72703132, // RP188 timecode where DBB1 equals VITC2 (line 9 for progressive or line 571 for interlaced/PsF) + bmdTimecodeRP188LTC = /* 'rplt' */ 0x72706C74, // RP188 timecode where DBB1 equals LTC (line 10) + bmdTimecodeRP188Any = /* 'rp18' */ 0x72703138, // For capture: return the first valid timecode in {VITC1, LTC ,VITC2} - For playback: set the timecode as VITC1 + bmdTimecodeVITC = /* 'vitc' */ 0x76697463, + bmdTimecodeVITCField2 = /* 'vit2' */ 0x76697432, + bmdTimecodeSerial = /* 'seri' */ 0x73657269 +}; + +/* Enum BMDAnalogVideoFlags - Analog video display flags */ + +typedef uint32_t BMDAnalogVideoFlags; +enum _BMDAnalogVideoFlags { + bmdAnalogVideoFlagCompositeSetup75 = 1 << 0, + bmdAnalogVideoFlagComponentBetacamLevels = 1 << 1 +}; + +/* 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 BMDIdleVideoOutputOperation - Video output operation when not playing video */ + +typedef uint32_t BMDIdleVideoOutputOperation; +enum _BMDIdleVideoOutputOperation { + bmdIdleVideoOutputBlack = /* 'blac' */ 0x626C6163, + bmdIdleVideoOutputLastFrame = /* 'lafa' */ 0x6C616661, + bmdIdleVideoOutputDesktop = /* 'desk' */ 0x6465736B +}; + +/* 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, + BMDDeckLinkHasAnalogVideoOutputGain = /* 'avog' */ 0x61766F67, + BMDDeckLinkCanOnlyAdjustOverallVideoOutputGain = /* 'ovog' */ 0x6F766F67, + BMDDeckLinkHasVideoInputAntiAliasingFilter = /* 'aafl' */ 0x6161666C, + BMDDeckLinkHasBypass = /* 'byps' */ 0x62797073, + BMDDeckLinkSupportsDesktopDisplay = /* 'extd' */ 0x65787464, + BMDDeckLinkSupportsClockTimingAdjustment = /* 'ctad' */ 0x63746164, + BMDDeckLinkSupportsFullDuplex = /* 'fdup' */ 0x66647570, + BMDDeckLinkSupportsFullFrameReferenceInputTimingOffset = /* 'frin' */ 0x6672696E, + BMDDeckLinkSupportsSMPTELevelAOutput = /* 'lvla' */ 0x6C766C61, + BMDDeckLinkSupportsDualLinkSDI = /* 'sdls' */ 0x73646C73, + BMDDeckLinkSupportsIdleOutput = /* 'idou' */ 0x69646F75, + + /* Integers */ + + BMDDeckLinkMaximumAudioChannels = /* 'mach' */ 0x6D616368, + BMDDeckLinkMaximumAnalogAudioChannels = /* 'aach' */ 0x61616368, + BMDDeckLinkNumberOfSubDevices = /* 'nsbd' */ 0x6E736264, + BMDDeckLinkSubDeviceIndex = /* 'subi' */ 0x73756269, + BMDDeckLinkPersistentID = /* 'peid' */ 0x70656964, + BMDDeckLinkTopologicalID = /* 'toid' */ 0x746F6964, + BMDDeckLinkVideoOutputConnections = /* 'vocn' */ 0x766F636E, + BMDDeckLinkVideoInputConnections = /* 'vicn' */ 0x7669636E, + BMDDeckLinkAudioOutputConnections = /* 'aocn' */ 0x616F636E, + BMDDeckLinkAudioInputConnections = /* 'aicn' */ 0x6169636E, + BMDDeckLinkDeviceBusyState = /* 'dbst' */ 0x64627374, + BMDDeckLinkVideoIOSupport = /* 'vios' */ 0x76696F73, // Returns a BMDVideoIOSupport bit field + + /* Floats */ + + BMDDeckLinkVideoInputGainMinimum = /* 'vigm' */ 0x7669676D, + BMDDeckLinkVideoInputGainMaximum = /* 'vigx' */ 0x76696778, + BMDDeckLinkVideoOutputGainMinimum = /* 'vogm' */ 0x766F676D, + BMDDeckLinkVideoOutputGainMaximum = /* 'vogx' */ 0x766F6778, + + /* Strings */ + + BMDDeckLinkSerialPortDeviceName = /* 'slpn' */ 0x736C706E +}; + +/* Enum BMDDeckLinkAPIInformationID - DeckLinkAPI information ID */ + +typedef uint32_t BMDDeckLinkAPIInformationID; +enum _BMDDeckLinkAPIInformationID { + BMDDeckLinkAPIVersion = /* 'vers' */ 0x76657273 +}; + +/* Enum BMDDeviceBusyState - Current device busy state */ + +typedef uint32_t BMDDeviceBusyState; +enum _BMDDeviceBusyState { + bmdDeviceCaptureBusy = 1 << 0, + bmdDevicePlaybackBusy = 1 << 1, + bmdDeviceSerialPortBusy = 1 << 2 +}; + +/* Enum BMDVideoIOSupport - Device video input/output support */ + +typedef uint32_t BMDVideoIOSupport; +enum _BMDVideoIOSupport { + bmdDeviceSupportsCapture = 1 << 0, + bmdDeviceSupportsPlayback = 1 << 1 +}; + +/* 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 +}; + +/* Enum BMDNotifications - Events that can be subscribed through IDeckLinkNotification */ + +typedef uint32_t BMDNotifications; +enum _BMDNotifications { + bmdPreferencesChanged = /* 'pref' */ 0x70726566 +}; + +#if defined(__cplusplus) + +// Forward Declarations + +class IDeckLinkVideoOutputCallback; +class IDeckLinkInputCallback; +class IDeckLinkMemoryAllocator; +class IDeckLinkAudioOutputCallback; +class IDeckLinkIterator; +class IDeckLinkAPIInformation; +class IDeckLinkOutput; +class IDeckLinkInput; +class IDeckLinkVideoFrame; +class IDeckLinkMutableVideoFrame; +class IDeckLinkVideoFrame3DExtensions; +class IDeckLinkVideoInputFrame; +class IDeckLinkVideoFrameAncillary; +class IDeckLinkAudioInputPacket; +class IDeckLinkScreenPreviewCallback; +class IDeckLinkGLScreenPreviewHelper; +class IDeckLinkNotificationCallback; +class IDeckLinkNotification; +class IDeckLinkAttributes; +class IDeckLinkKeyer; +class IDeckLinkVideoConversion; +class IDeckLinkDeviceNotificationCallback; +class IDeckLinkDiscovery; + +/* 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 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; + virtual HRESULT GetFrameCompletionReferenceTimestamp (/* in */ IDeckLinkVideoFrame *theFrame, /* in */ BMDTimeScale desiredTimeScale, /* out */ BMDTimeValue *frameCompletionTimestamp) = 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; + virtual HRESULT SetVideoInputFrameMemoryAllocator (/* in */ IDeckLinkMemoryAllocator *theAllocator) = 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 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 IDeckLinkNotificationCallback - DeckLink Notification Callback Interface */ + +class IDeckLinkNotificationCallback : public IUnknown +{ +public: + virtual HRESULT Notify (/* in */ BMDNotifications topic, /* in */ uint64_t param1, /* in */ uint64_t param2) = 0; +}; + +/* Interface IDeckLinkNotification - DeckLink Notification interface */ + +class IDeckLinkNotification : public IUnknown +{ +public: + virtual HRESULT Subscribe (/* in */ BMDNotifications topic, /* in */ IDeckLinkNotificationCallback *theCallback) = 0; + virtual HRESULT Unsubscribe (/* in */ BMDNotifications topic, /* in */ IDeckLinkNotificationCallback *theCallback) = 0; +}; + +/* 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 IDeckLinkDeviceNotificationCallback - DeckLink device arrival/removal notification callbacks */ + +class IDeckLinkDeviceNotificationCallback : public IUnknown +{ +public: + virtual HRESULT DeckLinkDeviceArrived (/* in */ IDeckLink* deckLinkDevice) = 0; + virtual HRESULT DeckLinkDeviceRemoved (/* in */ IDeckLink* deckLinkDevice) = 0; + +protected: + virtual ~IDeckLinkDeviceNotificationCallback () {} // call Release method to drop reference count +}; + +/* Interface IDeckLinkDiscovery - DeckLink device discovery */ + +class IDeckLinkDiscovery : public IUnknown +{ +public: + virtual HRESULT InstallDeviceNotifications (/* in */ IDeckLinkDeviceNotificationCallback* deviceNotificationCallback) = 0; + virtual HRESULT UninstallDeviceNotifications (void) = 0; + +protected: + virtual ~IDeckLinkDiscovery () {} // call Release method to drop reference count +}; + +/* Functions */ + +extern "C" { + + IDeckLinkIterator* CreateDeckLinkIteratorInstance (void); + IDeckLinkDiscovery* CreateDeckLinkDiscoveryInstance (void); + IDeckLinkAPIInformation* CreateDeckLinkAPIInformationInstance (void); + IDeckLinkGLScreenPreviewHelper* CreateOpenGLScreenPreviewHelper (void); + IDeckLinkVideoConversion* CreateVideoConversionInstance (void); + bool IsDeckLinkAPIPresent (void); +} + + +#endif // defined(__cplusplus) +#endif /* defined(BMD_DECKLINKAPI_H) */ diff --git a/intern/decklink/linux/DeckLinkAPIConfiguration.h b/intern/decklink/linux/DeckLinkAPIConfiguration.h new file mode 100644 index 00000000000..9d5bc9a9e1b --- /dev/null +++ b/intern/decklink/linux/DeckLinkAPIConfiguration.h @@ -0,0 +1,192 @@ +/* -LICENSE-START- +** Copyright (c) 2014 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 BMD_DECKLINKAPICONFIGURATION_H +#define BMD_DECKLINKAPICONFIGURATION_H + + +#ifndef BMD_CONST + #if defined(_MSC_VER) + #define BMD_CONST __declspec(selectany) static const + #else + #define BMD_CONST static const + #endif +#endif + +// Type Declarations + + +// Interface ID Declarations + +BMD_CONST REFIID IID_IDeckLinkConfiguration = /* 1E69FCF6-4203-4936-8076-2A9F4CFD50CB */ {0x1E,0x69,0xFC,0xF6,0x42,0x03,0x49,0x36,0x80,0x76,0x2A,0x9F,0x4C,0xFD,0x50,0xCB}; + +/* Enum BMDDeckLinkConfigurationID - DeckLink Configuration ID */ + +typedef uint32_t BMDDeckLinkConfigurationID; +enum _BMDDeckLinkConfigurationID { + + /* Serial port Flags */ + + bmdDeckLinkConfigSwapSerialRxTx = /* 'ssrt' */ 0x73737274, + + /* Video Input/Output Flags */ + + bmdDeckLinkConfigUse1080pNotPsF = /* 'fpro' */ 0x6670726F, + + /* Video Input/Output Integers */ + + bmdDeckLinkConfigHDMI3DPackingFormat = /* '3dpf' */ 0x33647066, + bmdDeckLinkConfigBypass = /* 'byps' */ 0x62797073, + bmdDeckLinkConfigClockTimingAdjustment = /* 'ctad' */ 0x63746164, + + /* Audio Input/Output Flags */ + + bmdDeckLinkConfigAnalogAudioConsumerLevels = /* 'aacl' */ 0x6161636C, + + /* Video output flags */ + + bmdDeckLinkConfigFieldFlickerRemoval = /* 'fdfr' */ 0x66646672, + bmdDeckLinkConfigHD1080p24ToHD1080i5994Conversion = /* 'to59' */ 0x746F3539, + bmdDeckLinkConfig444SDIVideoOutput = /* '444o' */ 0x3434346F, + bmdDeckLinkConfigSingleLinkVideoOutput = /* 'sglo' */ 0x73676C6F, + bmdDeckLinkConfigBlackVideoOutputDuringCapture = /* 'bvoc' */ 0x62766F63, + bmdDeckLinkConfigLowLatencyVideoOutput = /* 'llvo' */ 0x6C6C766F, + bmdDeckLinkConfigDownConversionOnAllAnalogOutput = /* 'caao' */ 0x6361616F, + bmdDeckLinkConfigSMPTELevelAOutput = /* 'smta' */ 0x736D7461, + + /* Video Output Integers */ + + bmdDeckLinkConfigVideoOutputConnection = /* 'vocn' */ 0x766F636E, + bmdDeckLinkConfigVideoOutputConversionMode = /* 'vocm' */ 0x766F636D, + bmdDeckLinkConfigAnalogVideoOutputFlags = /* 'avof' */ 0x61766F66, + bmdDeckLinkConfigReferenceInputTimingOffset = /* 'glot' */ 0x676C6F74, + bmdDeckLinkConfigVideoOutputIdleOperation = /* 'voio' */ 0x766F696F, + bmdDeckLinkConfigDefaultVideoOutputMode = /* 'dvom' */ 0x64766F6D, + bmdDeckLinkConfigDefaultVideoOutputModeFlags = /* 'dvof' */ 0x64766F66, + + /* Video Output Floats */ + + bmdDeckLinkConfigVideoOutputComponentLumaGain = /* 'oclg' */ 0x6F636C67, + bmdDeckLinkConfigVideoOutputComponentChromaBlueGain = /* 'occb' */ 0x6F636362, + bmdDeckLinkConfigVideoOutputComponentChromaRedGain = /* 'occr' */ 0x6F636372, + bmdDeckLinkConfigVideoOutputCompositeLumaGain = /* 'oilg' */ 0x6F696C67, + bmdDeckLinkConfigVideoOutputCompositeChromaGain = /* 'oicg' */ 0x6F696367, + bmdDeckLinkConfigVideoOutputSVideoLumaGain = /* 'oslg' */ 0x6F736C67, + bmdDeckLinkConfigVideoOutputSVideoChromaGain = /* 'oscg' */ 0x6F736367, + + /* Video Input Flags */ + + bmdDeckLinkConfigVideoInputScanning = /* 'visc' */ 0x76697363, // Applicable to H264 Pro Recorder only + bmdDeckLinkConfigUseDedicatedLTCInput = /* 'dltc' */ 0x646C7463, // Use timecode from LTC input instead of SDI stream + + /* Video Input Integers */ + + bmdDeckLinkConfigVideoInputConnection = /* 'vicn' */ 0x7669636E, + bmdDeckLinkConfigAnalogVideoInputFlags = /* 'avif' */ 0x61766966, + bmdDeckLinkConfigVideoInputConversionMode = /* 'vicm' */ 0x7669636D, + bmdDeckLinkConfig32PulldownSequenceInitialTimecodeFrame = /* 'pdif' */ 0x70646966, + bmdDeckLinkConfigVANCSourceLine1Mapping = /* 'vsl1' */ 0x76736C31, + bmdDeckLinkConfigVANCSourceLine2Mapping = /* 'vsl2' */ 0x76736C32, + bmdDeckLinkConfigVANCSourceLine3Mapping = /* 'vsl3' */ 0x76736C33, + bmdDeckLinkConfigCapturePassThroughMode = /* 'cptm' */ 0x6370746D, + + /* Video Input Floats */ + + bmdDeckLinkConfigVideoInputComponentLumaGain = /* 'iclg' */ 0x69636C67, + bmdDeckLinkConfigVideoInputComponentChromaBlueGain = /* 'iccb' */ 0x69636362, + bmdDeckLinkConfigVideoInputComponentChromaRedGain = /* 'iccr' */ 0x69636372, + bmdDeckLinkConfigVideoInputCompositeLumaGain = /* 'iilg' */ 0x69696C67, + bmdDeckLinkConfigVideoInputCompositeChromaGain = /* 'iicg' */ 0x69696367, + bmdDeckLinkConfigVideoInputSVideoLumaGain = /* 'islg' */ 0x69736C67, + bmdDeckLinkConfigVideoInputSVideoChromaGain = /* 'iscg' */ 0x69736367, + + /* 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, + + /* Device Information Strings */ + + bmdDeckLinkConfigDeviceInformationLabel = /* 'dila' */ 0x64696C61, + bmdDeckLinkConfigDeviceInformationSerialNumber = /* 'disn' */ 0x6469736E, + bmdDeckLinkConfigDeviceInformationCompany = /* 'dico' */ 0x6469636F, + bmdDeckLinkConfigDeviceInformationPhone = /* 'diph' */ 0x64697068, + bmdDeckLinkConfigDeviceInformationEmail = /* 'diem' */ 0x6469656D, + bmdDeckLinkConfigDeviceInformationDate = /* 'dida' */ 0x64696461 +}; + +// Forward Declarations + +class IDeckLinkConfiguration; + +/* 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 +}; + +/* Functions */ + +extern "C" { + + +} + + +#endif /* defined(BMD_DECKLINKAPICONFIGURATION_H) */ diff --git a/intern/decklink/linux/DeckLinkAPIDeckControl.h b/intern/decklink/linux/DeckLinkAPIDeckControl.h new file mode 100644 index 00000000000..b83d013129e --- /dev/null +++ b/intern/decklink/linux/DeckLinkAPIDeckControl.h @@ -0,0 +1,215 @@ +/* -LICENSE-START- +** Copyright (c) 2014 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 BMD_DECKLINKAPIDECKCONTROL_H +#define BMD_DECKLINKAPIDECKCONTROL_H + + +#ifndef BMD_CONST + #if defined(_MSC_VER) + #define BMD_CONST __declspec(selectany) static const + #else + #define BMD_CONST static const + #endif +#endif + +// Type Declarations + + +// Interface ID Declarations + +BMD_CONST REFIID IID_IDeckLinkDeckControlStatusCallback = /* 53436FFB-B434-4906-BADC-AE3060FFE8EF */ {0x53,0x43,0x6F,0xFB,0xB4,0x34,0x49,0x06,0xBA,0xDC,0xAE,0x30,0x60,0xFF,0xE8,0xEF}; +BMD_CONST REFIID IID_IDeckLinkDeckControl = /* 8E1C3ACE-19C7-4E00-8B92-D80431D958BE */ {0x8E,0x1C,0x3A,0xCE,0x19,0xC7,0x4E,0x00,0x8B,0x92,0xD8,0x04,0x31,0xD9,0x58,0xBE}; + +/* 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, + bmdDeckControlVTRControlShuttleForward = /* 'vtsf' */ 0x76747366, + bmdDeckControlVTRControlShuttleReverse = /* 'vtsr' */ 0x76747372, + bmdDeckControlVTRControlJogForward = /* 'vtjf' */ 0x76746A66, + bmdDeckControlVTRControlJogReverse = /* 'vtjr' */ 0x76746A72, + 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, + bmdDeckControlBufferTooSmallError = /* 'btsm' */ 0x6274736D, + bmdDeckControlBadChecksumError = /* 'chks' */ 0x63686B73, + bmdDeckControlUnknownError = /* 'uner' */ 0x756E6572 +}; + +// Forward Declarations + +class IDeckLinkDeckControlStatusCallback; +class IDeckLinkDeckControl; + +/* 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 SendCommand (/* in */ uint8_t *inBuffer, /* in */ uint32_t inBufferSize, /* out */ uint8_t *outBuffer, /* out */ uint32_t *outDataSize, /* in */ uint32_t outBufferSize, /* out */ BMDDeckControlError *error) = 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" { + + +} + + +#endif /* defined(BMD_DECKLINKAPIDECKCONTROL_H) */ diff --git a/intern/decklink/linux/DeckLinkAPIDiscovery.h b/intern/decklink/linux/DeckLinkAPIDiscovery.h new file mode 100644 index 00000000000..424d9d54b39 --- /dev/null +++ b/intern/decklink/linux/DeckLinkAPIDiscovery.h @@ -0,0 +1,71 @@ +/* -LICENSE-START- +** Copyright (c) 2014 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 BMD_DECKLINKAPIDISCOVERY_H +#define BMD_DECKLINKAPIDISCOVERY_H + + +#ifndef BMD_CONST + #if defined(_MSC_VER) + #define BMD_CONST __declspec(selectany) static const + #else + #define BMD_CONST static const + #endif +#endif + +// Type Declarations + + +// Interface ID Declarations + +BMD_CONST REFIID IID_IDeckLink = /* C418FBDD-0587-48ED-8FE5-640F0A14AF91 */ {0xC4,0x18,0xFB,0xDD,0x05,0x87,0x48,0xED,0x8F,0xE5,0x64,0x0F,0x0A,0x14,0xAF,0x91}; + +// Forward Declarations + +class IDeckLink; + +/* Interface IDeckLink - represents a DeckLink device */ + +class IDeckLink : public IUnknown +{ +public: + virtual HRESULT GetModelName (/* out */ const char **modelName) = 0; + virtual HRESULT GetDisplayName (/* out */ const char **displayName) = 0; + +protected: + virtual ~IDeckLink () {} // call Release method to drop reference count +}; + +/* Functions */ + +extern "C" { + + +} + + +#endif /* defined(BMD_DECKLINKAPIDISCOVERY_H) */ diff --git a/intern/decklink/linux/DeckLinkAPIDispatch.cpp b/intern/decklink/linux/DeckLinkAPIDispatch.cpp new file mode 100644 index 00000000000..3cf53f109ac --- /dev/null +++ b/intern/decklink/linux/DeckLinkAPIDispatch.cpp @@ -0,0 +1,148 @@ +/* -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 <stdlib.h> +#include <stdio.h> +#include <pthread.h> +#include <dlfcn.h> +#include <ctype.h> + +#include "DeckLinkAPI.h" + +#define kDeckLinkAPI_Name "libDeckLinkAPI.so" +#define KDeckLinkPreviewAPI_Name "libDeckLinkPreviewAPI.so" + +typedef IDeckLinkIterator* (*CreateIteratorFunc)(void); +typedef IDeckLinkAPIInformation* (*CreateAPIInformationFunc)(void); +typedef IDeckLinkGLScreenPreviewHelper* (*CreateOpenGLScreenPreviewHelperFunc)(void); +typedef IDeckLinkVideoConversion* (*CreateVideoConversionInstanceFunc)(void); +typedef IDeckLinkDiscovery* (*CreateDeckLinkDiscoveryInstanceFunc)(void); + +static pthread_once_t gDeckLinkOnceControl = PTHREAD_ONCE_INIT; +static pthread_once_t gPreviewOnceControl = PTHREAD_ONCE_INIT; + +static bool gLoadedDeckLinkAPI = false; + +static CreateIteratorFunc gCreateIteratorFunc = NULL; +static CreateAPIInformationFunc gCreateAPIInformationFunc = NULL; +static CreateOpenGLScreenPreviewHelperFunc gCreateOpenGLPreviewFunc = NULL; +static CreateVideoConversionInstanceFunc gCreateVideoConversionFunc = NULL; +static CreateDeckLinkDiscoveryInstanceFunc gCreateDeckLinkDiscoveryFunc = NULL; + +static void InitDeckLinkAPI (void) +{ + void *libraryHandle; + + libraryHandle = dlopen(kDeckLinkAPI_Name, RTLD_NOW|RTLD_GLOBAL); + if (!libraryHandle) + { + fprintf(stderr, "%s\n", dlerror()); + return; + } + + gLoadedDeckLinkAPI = true; + + gCreateIteratorFunc = (CreateIteratorFunc)dlsym(libraryHandle, "CreateDeckLinkIteratorInstance_0002"); + if (!gCreateIteratorFunc) + fprintf(stderr, "%s\n", dlerror()); + gCreateAPIInformationFunc = (CreateAPIInformationFunc)dlsym(libraryHandle, "CreateDeckLinkAPIInformationInstance_0001"); + if (!gCreateAPIInformationFunc) + fprintf(stderr, "%s\n", dlerror()); + gCreateVideoConversionFunc = (CreateVideoConversionInstanceFunc)dlsym(libraryHandle, "CreateVideoConversionInstance_0001"); + if (!gCreateVideoConversionFunc) + fprintf(stderr, "%s\n", dlerror()); + gCreateDeckLinkDiscoveryFunc = (CreateDeckLinkDiscoveryInstanceFunc)dlsym(libraryHandle, "CreateDeckLinkDiscoveryInstance_0001"); + if (!gCreateDeckLinkDiscoveryFunc) + 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()); +} + +bool IsDeckLinkAPIPresent (void) +{ + // If the DeckLink API dynamic library was successfully loaded, return this knowledge to the caller + return gLoadedDeckLinkAPI; +} + +IDeckLinkIterator* CreateDeckLinkIteratorInstance (void) +{ + pthread_once(&gDeckLinkOnceControl, InitDeckLinkAPI); + + if (gCreateIteratorFunc == NULL) + return NULL; + return gCreateIteratorFunc(); +} + +IDeckLinkAPIInformation* CreateDeckLinkAPIInformationInstance (void) +{ + pthread_once(&gDeckLinkOnceControl, InitDeckLinkAPI); + + if (gCreateAPIInformationFunc == NULL) + return NULL; + return gCreateAPIInformationFunc(); +} + +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(); +} + +IDeckLinkDiscovery* CreateDeckLinkDiscoveryInstance (void) +{ + pthread_once(&gDeckLinkOnceControl, InitDeckLinkAPI); + + if (gCreateDeckLinkDiscoveryFunc == NULL) + return NULL; + return gCreateDeckLinkDiscoveryFunc(); +} diff --git a/intern/decklink/linux/DeckLinkAPIModes.h b/intern/decklink/linux/DeckLinkAPIModes.h new file mode 100644 index 00000000000..394d68c3078 --- /dev/null +++ b/intern/decklink/linux/DeckLinkAPIModes.h @@ -0,0 +1,191 @@ +/* -LICENSE-START- +** Copyright (c) 2014 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 BMD_DECKLINKAPIMODES_H +#define BMD_DECKLINKAPIMODES_H + + +#ifndef BMD_CONST + #if defined(_MSC_VER) + #define BMD_CONST __declspec(selectany) static const + #else + #define BMD_CONST static const + #endif +#endif + +// Type Declarations + + +// Interface ID Declarations + +BMD_CONST REFIID IID_IDeckLinkDisplayModeIterator = /* 9C88499F-F601-4021-B80B-032E4EB41C35 */ {0x9C,0x88,0x49,0x9F,0xF6,0x01,0x40,0x21,0xB8,0x0B,0x03,0x2E,0x4E,0xB4,0x1C,0x35}; +BMD_CONST REFIID IID_IDeckLinkDisplayMode = /* 3EB2C1AB-0A3D-4523-A3AD-F40D7FB14E78 */ {0x3E,0xB2,0xC1,0xAB,0x0A,0x3D,0x45,0x23,0xA3,0xAD,0xF4,0x0D,0x7F,0xB1,0x4E,0x78}; + +/* 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, + + /* DCI Modes (output only) */ + + bmdMode2kDCI2398 = /* '2d23' */ 0x32643233, + bmdMode2kDCI24 = /* '2d24' */ 0x32643234, + bmdMode2kDCI25 = /* '2d25' */ 0x32643235, + + /* 4k Modes */ + + bmdMode4K2160p2398 = /* '4k23' */ 0x346B3233, + bmdMode4K2160p24 = /* '4k24' */ 0x346B3234, + bmdMode4K2160p25 = /* '4k25' */ 0x346B3235, + bmdMode4K2160p2997 = /* '4k29' */ 0x346B3239, + bmdMode4K2160p30 = /* '4k30' */ 0x346B3330, + bmdMode4K2160p50 = /* '4k50' */ 0x346B3530, + bmdMode4K2160p5994 = /* '4k59' */ 0x346B3539, + bmdMode4K2160p60 = /* '4k60' */ 0x346B3630, + + /* DCI Modes (output only) */ + + bmdMode4kDCI2398 = /* '4d23' */ 0x34643233, + bmdMode4kDCI24 = /* '4d24' */ 0x34643234, + bmdMode4kDCI25 = /* '4d25' */ 0x34643235, + + /* Special Modes */ + + bmdModeUnknown = /* 'iunk' */ 0x69756E6B +}; + +/* 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 + bmdFormat12BitRGB = /* 'R12B' */ 0x52313242, // Big-endian RGB 12-bit per component with full range (0-4095). Packed as 12-bit per component + bmdFormat12BitRGBLE = /* 'R12L' */ 0x5231324C, // Little-endian RGB 12-bit per component with full range (0-4095). Packed as 12-bit per component + bmdFormat10BitRGBXLE = /* 'R10l' */ 0x5231306C, // Little-endian 10-bit RGB with SMPTE video levels (64-940) + bmdFormat10BitRGBX = /* 'R10b' */ 0x52313062 // Big-endian 10-bit RGB with SMPTE video levels (64-940) +}; + +/* 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 +}; + +// Forward Declarations + +class IDeckLinkDisplayModeIterator; +class IDeckLinkDisplayMode; + +/* 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 +}; + +/* Functions */ + +extern "C" { + + +} + + +#endif /* defined(BMD_DECKLINKAPIMODES_H) */ diff --git a/intern/decklink/linux/DeckLinkAPITypes.h b/intern/decklink/linux/DeckLinkAPITypes.h new file mode 100644 index 00000000000..55e015f2a3c --- /dev/null +++ b/intern/decklink/linux/DeckLinkAPITypes.h @@ -0,0 +1,110 @@ +/* -LICENSE-START- +** Copyright (c) 2014 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 BMD_DECKLINKAPITYPES_H +#define BMD_DECKLINKAPITYPES_H + + +#ifndef BMD_CONST + #if defined(_MSC_VER) + #define BMD_CONST __declspec(selectany) static const + #else + #define BMD_CONST static const + #endif +#endif + +// Type Declarations + +typedef int64_t BMDTimeValue; +typedef int64_t BMDTimeScale; +typedef uint32_t BMDTimecodeBCD; +typedef uint32_t BMDTimecodeUserBits; + +// Interface ID Declarations + +BMD_CONST REFIID IID_IDeckLinkTimecode = /* BC6CFBD3-8317-4325-AC1C-1216391E9340 */ {0xBC,0x6C,0xFB,0xD3,0x83,0x17,0x43,0x25,0xAC,0x1C,0x12,0x16,0x39,0x1E,0x93,0x40}; + +/* Enum BMDTimecodeFlags - Timecode flags */ + +typedef uint32_t BMDTimecodeFlags; +enum _BMDTimecodeFlags { + bmdTimecodeFlagDefault = 0, + bmdTimecodeIsDropFrame = 1 << 0, + bmdTimecodeFieldMark = 1 << 1 +}; + +/* 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 BMDAudioConnection - Audio connection types */ + +typedef uint32_t BMDAudioConnection; +enum _BMDAudioConnection { + bmdAudioConnectionEmbedded = 1 << 0, + bmdAudioConnectionAESEBU = 1 << 1, + bmdAudioConnectionAnalog = 1 << 2, + bmdAudioConnectionAnalogXLR = 1 << 3, + bmdAudioConnectionAnalogRCA = 1 << 4 +}; + +// Forward Declarations + +class IDeckLinkTimecode; + +/* 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 +}; + +/* Functions */ + +extern "C" { + + +} + + +#endif /* defined(BMD_DECKLINKAPITYPES_H) */ diff --git a/intern/decklink/linux/DeckLinkAPIVersion.h b/intern/decklink/linux/DeckLinkAPIVersion.h new file mode 100644 index 00000000000..cfcc701c427 --- /dev/null +++ b/intern/decklink/linux/DeckLinkAPIVersion.h @@ -0,0 +1,37 @@ +/* -LICENSE-START- + * ** Copyright (c) 2014 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- + * */ + +/* DeckLinkAPIVersion.h */ + +#ifndef __DeckLink_API_Version_h__ +#define __DeckLink_API_Version_h__ + +#define BLACKMAGIC_DECKLINK_API_VERSION 0x0a040000 +#define BLACKMAGIC_DECKLINK_API_VERSION_STRING "10.4" + +#endif // __DeckLink_API_Version_h__ + diff --git a/intern/decklink/linux/LinuxCOM.h b/intern/decklink/linux/LinuxCOM.h new file mode 100644 index 00000000000..ee783bbd58f --- /dev/null +++ b/intern/decklink/linux/LinuxCOM.h @@ -0,0 +1,100 @@ +/* -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 + +#define _HRESULT_DEFINED +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/intern/decklink/win/DeckLinkAPI_h.h b/intern/decklink/win/DeckLinkAPI_h.h new file mode 100644 index 00000000000..1bd80b6dc95 --- /dev/null +++ b/intern/decklink/win/DeckLinkAPI_h.h @@ -0,0 +1,13323 @@ + + +/* this ALWAYS GENERATED file contains the definitions for the interfaces */ + + + /* File created by MIDL compiler version 8.00.0603 */ +/* at Mon Apr 13 20:57:05 2015 + */ +/* Compiler settings for ..\..\include\DeckLinkAPI.idl: + Oicf, W1, Zp8, env=Win64 (32b run), target_arch=AMD64 8.00.0603 + protocol : dce , ms_ext, c_ext, robust + error checks: allocation ref bounds_check enum stub_data + VC __declspec() decoration level: + __declspec(uuid()), __declspec(selectany), __declspec(novtable) + DECLSPEC_UUID(), MIDL_INTERFACE() +*/ +/* @@MIDL_FILE_HEADING( ) */ + +#pragma warning( disable: 4049 ) /* more than 64k source lines */ + + +/* verify that the <rpcndr.h> version is high enough to compile this file*/ +#ifndef __REQUIRED_RPCNDR_H_VERSION__ +#define __REQUIRED_RPCNDR_H_VERSION__ 475 +#endif + +#include "rpc.h" +#include "rpcndr.h" + +#ifndef __RPCNDR_H_VERSION__ +#error this stub requires an updated version of <rpcndr.h> +#endif // __RPCNDR_H_VERSION__ + + +#ifndef __DeckLinkAPI_h_h__ +#define __DeckLinkAPI_h_h__ + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#pragma once +#endif + +/* Forward Declarations */ + +#ifndef __IDeckLinkTimecode_FWD_DEFINED__ +#define __IDeckLinkTimecode_FWD_DEFINED__ +typedef interface IDeckLinkTimecode IDeckLinkTimecode; + +#endif /* __IDeckLinkTimecode_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkDisplayModeIterator_FWD_DEFINED__ +#define __IDeckLinkDisplayModeIterator_FWD_DEFINED__ +typedef interface IDeckLinkDisplayModeIterator IDeckLinkDisplayModeIterator; + +#endif /* __IDeckLinkDisplayModeIterator_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkDisplayMode_FWD_DEFINED__ +#define __IDeckLinkDisplayMode_FWD_DEFINED__ +typedef interface IDeckLinkDisplayMode IDeckLinkDisplayMode; + +#endif /* __IDeckLinkDisplayMode_FWD_DEFINED__ */ + + +#ifndef __IDeckLink_FWD_DEFINED__ +#define __IDeckLink_FWD_DEFINED__ +typedef interface IDeckLink IDeckLink; + +#endif /* __IDeckLink_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkConfiguration_FWD_DEFINED__ +#define __IDeckLinkConfiguration_FWD_DEFINED__ +typedef interface IDeckLinkConfiguration IDeckLinkConfiguration; + +#endif /* __IDeckLinkConfiguration_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkDeckControlStatusCallback_FWD_DEFINED__ +#define __IDeckLinkDeckControlStatusCallback_FWD_DEFINED__ +typedef interface IDeckLinkDeckControlStatusCallback IDeckLinkDeckControlStatusCallback; + +#endif /* __IDeckLinkDeckControlStatusCallback_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkDeckControl_FWD_DEFINED__ +#define __IDeckLinkDeckControl_FWD_DEFINED__ +typedef interface IDeckLinkDeckControl IDeckLinkDeckControl; + +#endif /* __IDeckLinkDeckControl_FWD_DEFINED__ */ + + +#ifndef __IBMDStreamingDeviceNotificationCallback_FWD_DEFINED__ +#define __IBMDStreamingDeviceNotificationCallback_FWD_DEFINED__ +typedef interface IBMDStreamingDeviceNotificationCallback IBMDStreamingDeviceNotificationCallback; + +#endif /* __IBMDStreamingDeviceNotificationCallback_FWD_DEFINED__ */ + + +#ifndef __IBMDStreamingH264InputCallback_FWD_DEFINED__ +#define __IBMDStreamingH264InputCallback_FWD_DEFINED__ +typedef interface IBMDStreamingH264InputCallback IBMDStreamingH264InputCallback; + +#endif /* __IBMDStreamingH264InputCallback_FWD_DEFINED__ */ + + +#ifndef __IBMDStreamingDiscovery_FWD_DEFINED__ +#define __IBMDStreamingDiscovery_FWD_DEFINED__ +typedef interface IBMDStreamingDiscovery IBMDStreamingDiscovery; + +#endif /* __IBMDStreamingDiscovery_FWD_DEFINED__ */ + + +#ifndef __IBMDStreamingVideoEncodingMode_FWD_DEFINED__ +#define __IBMDStreamingVideoEncodingMode_FWD_DEFINED__ +typedef interface IBMDStreamingVideoEncodingMode IBMDStreamingVideoEncodingMode; + +#endif /* __IBMDStreamingVideoEncodingMode_FWD_DEFINED__ */ + + +#ifndef __IBMDStreamingMutableVideoEncodingMode_FWD_DEFINED__ +#define __IBMDStreamingMutableVideoEncodingMode_FWD_DEFINED__ +typedef interface IBMDStreamingMutableVideoEncodingMode IBMDStreamingMutableVideoEncodingMode; + +#endif /* __IBMDStreamingMutableVideoEncodingMode_FWD_DEFINED__ */ + + +#ifndef __IBMDStreamingVideoEncodingModePresetIterator_FWD_DEFINED__ +#define __IBMDStreamingVideoEncodingModePresetIterator_FWD_DEFINED__ +typedef interface IBMDStreamingVideoEncodingModePresetIterator IBMDStreamingVideoEncodingModePresetIterator; + +#endif /* __IBMDStreamingVideoEncodingModePresetIterator_FWD_DEFINED__ */ + + +#ifndef __IBMDStreamingDeviceInput_FWD_DEFINED__ +#define __IBMDStreamingDeviceInput_FWD_DEFINED__ +typedef interface IBMDStreamingDeviceInput IBMDStreamingDeviceInput; + +#endif /* __IBMDStreamingDeviceInput_FWD_DEFINED__ */ + + +#ifndef __IBMDStreamingH264NALPacket_FWD_DEFINED__ +#define __IBMDStreamingH264NALPacket_FWD_DEFINED__ +typedef interface IBMDStreamingH264NALPacket IBMDStreamingH264NALPacket; + +#endif /* __IBMDStreamingH264NALPacket_FWD_DEFINED__ */ + + +#ifndef __IBMDStreamingAudioPacket_FWD_DEFINED__ +#define __IBMDStreamingAudioPacket_FWD_DEFINED__ +typedef interface IBMDStreamingAudioPacket IBMDStreamingAudioPacket; + +#endif /* __IBMDStreamingAudioPacket_FWD_DEFINED__ */ + + +#ifndef __IBMDStreamingMPEG2TSPacket_FWD_DEFINED__ +#define __IBMDStreamingMPEG2TSPacket_FWD_DEFINED__ +typedef interface IBMDStreamingMPEG2TSPacket IBMDStreamingMPEG2TSPacket; + +#endif /* __IBMDStreamingMPEG2TSPacket_FWD_DEFINED__ */ + + +#ifndef __IBMDStreamingH264NALParser_FWD_DEFINED__ +#define __IBMDStreamingH264NALParser_FWD_DEFINED__ +typedef interface IBMDStreamingH264NALParser IBMDStreamingH264NALParser; + +#endif /* __IBMDStreamingH264NALParser_FWD_DEFINED__ */ + + +#ifndef __CBMDStreamingDiscovery_FWD_DEFINED__ +#define __CBMDStreamingDiscovery_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class CBMDStreamingDiscovery CBMDStreamingDiscovery; +#else +typedef struct CBMDStreamingDiscovery CBMDStreamingDiscovery; +#endif /* __cplusplus */ + +#endif /* __CBMDStreamingDiscovery_FWD_DEFINED__ */ + + +#ifndef __CBMDStreamingH264NALParser_FWD_DEFINED__ +#define __CBMDStreamingH264NALParser_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class CBMDStreamingH264NALParser CBMDStreamingH264NALParser; +#else +typedef struct CBMDStreamingH264NALParser CBMDStreamingH264NALParser; +#endif /* __cplusplus */ + +#endif /* __CBMDStreamingH264NALParser_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkVideoOutputCallback_FWD_DEFINED__ +#define __IDeckLinkVideoOutputCallback_FWD_DEFINED__ +typedef interface IDeckLinkVideoOutputCallback IDeckLinkVideoOutputCallback; + +#endif /* __IDeckLinkVideoOutputCallback_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkInputCallback_FWD_DEFINED__ +#define __IDeckLinkInputCallback_FWD_DEFINED__ +typedef interface IDeckLinkInputCallback IDeckLinkInputCallback; + +#endif /* __IDeckLinkInputCallback_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkMemoryAllocator_FWD_DEFINED__ +#define __IDeckLinkMemoryAllocator_FWD_DEFINED__ +typedef interface IDeckLinkMemoryAllocator IDeckLinkMemoryAllocator; + +#endif /* __IDeckLinkMemoryAllocator_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkAudioOutputCallback_FWD_DEFINED__ +#define __IDeckLinkAudioOutputCallback_FWD_DEFINED__ +typedef interface IDeckLinkAudioOutputCallback IDeckLinkAudioOutputCallback; + +#endif /* __IDeckLinkAudioOutputCallback_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkIterator_FWD_DEFINED__ +#define __IDeckLinkIterator_FWD_DEFINED__ +typedef interface IDeckLinkIterator IDeckLinkIterator; + +#endif /* __IDeckLinkIterator_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkAPIInformation_FWD_DEFINED__ +#define __IDeckLinkAPIInformation_FWD_DEFINED__ +typedef interface IDeckLinkAPIInformation IDeckLinkAPIInformation; + +#endif /* __IDeckLinkAPIInformation_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkOutput_FWD_DEFINED__ +#define __IDeckLinkOutput_FWD_DEFINED__ +typedef interface IDeckLinkOutput IDeckLinkOutput; + +#endif /* __IDeckLinkOutput_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkInput_FWD_DEFINED__ +#define __IDeckLinkInput_FWD_DEFINED__ +typedef interface IDeckLinkInput IDeckLinkInput; + +#endif /* __IDeckLinkInput_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkVideoFrame_FWD_DEFINED__ +#define __IDeckLinkVideoFrame_FWD_DEFINED__ +typedef interface IDeckLinkVideoFrame IDeckLinkVideoFrame; + +#endif /* __IDeckLinkVideoFrame_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkMutableVideoFrame_FWD_DEFINED__ +#define __IDeckLinkMutableVideoFrame_FWD_DEFINED__ +typedef interface IDeckLinkMutableVideoFrame IDeckLinkMutableVideoFrame; + +#endif /* __IDeckLinkMutableVideoFrame_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkVideoFrame3DExtensions_FWD_DEFINED__ +#define __IDeckLinkVideoFrame3DExtensions_FWD_DEFINED__ +typedef interface IDeckLinkVideoFrame3DExtensions IDeckLinkVideoFrame3DExtensions; + +#endif /* __IDeckLinkVideoFrame3DExtensions_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkVideoInputFrame_FWD_DEFINED__ +#define __IDeckLinkVideoInputFrame_FWD_DEFINED__ +typedef interface IDeckLinkVideoInputFrame IDeckLinkVideoInputFrame; + +#endif /* __IDeckLinkVideoInputFrame_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkVideoFrameAncillary_FWD_DEFINED__ +#define __IDeckLinkVideoFrameAncillary_FWD_DEFINED__ +typedef interface IDeckLinkVideoFrameAncillary IDeckLinkVideoFrameAncillary; + +#endif /* __IDeckLinkVideoFrameAncillary_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkAudioInputPacket_FWD_DEFINED__ +#define __IDeckLinkAudioInputPacket_FWD_DEFINED__ +typedef interface IDeckLinkAudioInputPacket IDeckLinkAudioInputPacket; + +#endif /* __IDeckLinkAudioInputPacket_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkScreenPreviewCallback_FWD_DEFINED__ +#define __IDeckLinkScreenPreviewCallback_FWD_DEFINED__ +typedef interface IDeckLinkScreenPreviewCallback IDeckLinkScreenPreviewCallback; + +#endif /* __IDeckLinkScreenPreviewCallback_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkGLScreenPreviewHelper_FWD_DEFINED__ +#define __IDeckLinkGLScreenPreviewHelper_FWD_DEFINED__ +typedef interface IDeckLinkGLScreenPreviewHelper IDeckLinkGLScreenPreviewHelper; + +#endif /* __IDeckLinkGLScreenPreviewHelper_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkDX9ScreenPreviewHelper_FWD_DEFINED__ +#define __IDeckLinkDX9ScreenPreviewHelper_FWD_DEFINED__ +typedef interface IDeckLinkDX9ScreenPreviewHelper IDeckLinkDX9ScreenPreviewHelper; + +#endif /* __IDeckLinkDX9ScreenPreviewHelper_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkNotificationCallback_FWD_DEFINED__ +#define __IDeckLinkNotificationCallback_FWD_DEFINED__ +typedef interface IDeckLinkNotificationCallback IDeckLinkNotificationCallback; + +#endif /* __IDeckLinkNotificationCallback_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkNotification_FWD_DEFINED__ +#define __IDeckLinkNotification_FWD_DEFINED__ +typedef interface IDeckLinkNotification IDeckLinkNotification; + +#endif /* __IDeckLinkNotification_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkAttributes_FWD_DEFINED__ +#define __IDeckLinkAttributes_FWD_DEFINED__ +typedef interface IDeckLinkAttributes IDeckLinkAttributes; + +#endif /* __IDeckLinkAttributes_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkKeyer_FWD_DEFINED__ +#define __IDeckLinkKeyer_FWD_DEFINED__ +typedef interface IDeckLinkKeyer IDeckLinkKeyer; + +#endif /* __IDeckLinkKeyer_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkVideoConversion_FWD_DEFINED__ +#define __IDeckLinkVideoConversion_FWD_DEFINED__ +typedef interface IDeckLinkVideoConversion IDeckLinkVideoConversion; + +#endif /* __IDeckLinkVideoConversion_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkDeviceNotificationCallback_FWD_DEFINED__ +#define __IDeckLinkDeviceNotificationCallback_FWD_DEFINED__ +typedef interface IDeckLinkDeviceNotificationCallback IDeckLinkDeviceNotificationCallback; + +#endif /* __IDeckLinkDeviceNotificationCallback_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkDiscovery_FWD_DEFINED__ +#define __IDeckLinkDiscovery_FWD_DEFINED__ +typedef interface IDeckLinkDiscovery IDeckLinkDiscovery; + +#endif /* __IDeckLinkDiscovery_FWD_DEFINED__ */ + + +#ifndef __CDeckLinkIterator_FWD_DEFINED__ +#define __CDeckLinkIterator_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class CDeckLinkIterator CDeckLinkIterator; +#else +typedef struct CDeckLinkIterator CDeckLinkIterator; +#endif /* __cplusplus */ + +#endif /* __CDeckLinkIterator_FWD_DEFINED__ */ + + +#ifndef __CDeckLinkAPIInformation_FWD_DEFINED__ +#define __CDeckLinkAPIInformation_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class CDeckLinkAPIInformation CDeckLinkAPIInformation; +#else +typedef struct CDeckLinkAPIInformation CDeckLinkAPIInformation; +#endif /* __cplusplus */ + +#endif /* __CDeckLinkAPIInformation_FWD_DEFINED__ */ + + +#ifndef __CDeckLinkGLScreenPreviewHelper_FWD_DEFINED__ +#define __CDeckLinkGLScreenPreviewHelper_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class CDeckLinkGLScreenPreviewHelper CDeckLinkGLScreenPreviewHelper; +#else +typedef struct CDeckLinkGLScreenPreviewHelper CDeckLinkGLScreenPreviewHelper; +#endif /* __cplusplus */ + +#endif /* __CDeckLinkGLScreenPreviewHelper_FWD_DEFINED__ */ + + +#ifndef __CDeckLinkDX9ScreenPreviewHelper_FWD_DEFINED__ +#define __CDeckLinkDX9ScreenPreviewHelper_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class CDeckLinkDX9ScreenPreviewHelper CDeckLinkDX9ScreenPreviewHelper; +#else +typedef struct CDeckLinkDX9ScreenPreviewHelper CDeckLinkDX9ScreenPreviewHelper; +#endif /* __cplusplus */ + +#endif /* __CDeckLinkDX9ScreenPreviewHelper_FWD_DEFINED__ */ + + +#ifndef __CDeckLinkVideoConversion_FWD_DEFINED__ +#define __CDeckLinkVideoConversion_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class CDeckLinkVideoConversion CDeckLinkVideoConversion; +#else +typedef struct CDeckLinkVideoConversion CDeckLinkVideoConversion; +#endif /* __cplusplus */ + +#endif /* __CDeckLinkVideoConversion_FWD_DEFINED__ */ + + +#ifndef __CDeckLinkDiscovery_FWD_DEFINED__ +#define __CDeckLinkDiscovery_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class CDeckLinkDiscovery CDeckLinkDiscovery; +#else +typedef struct CDeckLinkDiscovery CDeckLinkDiscovery; +#endif /* __cplusplus */ + +#endif /* __CDeckLinkDiscovery_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkConfiguration_v10_2_FWD_DEFINED__ +#define __IDeckLinkConfiguration_v10_2_FWD_DEFINED__ +typedef interface IDeckLinkConfiguration_v10_2 IDeckLinkConfiguration_v10_2; + +#endif /* __IDeckLinkConfiguration_v10_2_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkOutput_v9_9_FWD_DEFINED__ +#define __IDeckLinkOutput_v9_9_FWD_DEFINED__ +typedef interface IDeckLinkOutput_v9_9 IDeckLinkOutput_v9_9; + +#endif /* __IDeckLinkOutput_v9_9_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkInput_v9_2_FWD_DEFINED__ +#define __IDeckLinkInput_v9_2_FWD_DEFINED__ +typedef interface IDeckLinkInput_v9_2 IDeckLinkInput_v9_2; + +#endif /* __IDeckLinkInput_v9_2_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkDeckControlStatusCallback_v8_1_FWD_DEFINED__ +#define __IDeckLinkDeckControlStatusCallback_v8_1_FWD_DEFINED__ +typedef interface IDeckLinkDeckControlStatusCallback_v8_1 IDeckLinkDeckControlStatusCallback_v8_1; + +#endif /* __IDeckLinkDeckControlStatusCallback_v8_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkDeckControl_v8_1_FWD_DEFINED__ +#define __IDeckLinkDeckControl_v8_1_FWD_DEFINED__ +typedef interface IDeckLinkDeckControl_v8_1 IDeckLinkDeckControl_v8_1; + +#endif /* __IDeckLinkDeckControl_v8_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLink_v8_0_FWD_DEFINED__ +#define __IDeckLink_v8_0_FWD_DEFINED__ +typedef interface IDeckLink_v8_0 IDeckLink_v8_0; + +#endif /* __IDeckLink_v8_0_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkIterator_v8_0_FWD_DEFINED__ +#define __IDeckLinkIterator_v8_0_FWD_DEFINED__ +typedef interface IDeckLinkIterator_v8_0 IDeckLinkIterator_v8_0; + +#endif /* __IDeckLinkIterator_v8_0_FWD_DEFINED__ */ + + +#ifndef __CDeckLinkIterator_v8_0_FWD_DEFINED__ +#define __CDeckLinkIterator_v8_0_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class CDeckLinkIterator_v8_0 CDeckLinkIterator_v8_0; +#else +typedef struct CDeckLinkIterator_v8_0 CDeckLinkIterator_v8_0; +#endif /* __cplusplus */ + +#endif /* __CDeckLinkIterator_v8_0_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkDeckControl_v7_9_FWD_DEFINED__ +#define __IDeckLinkDeckControl_v7_9_FWD_DEFINED__ +typedef interface IDeckLinkDeckControl_v7_9 IDeckLinkDeckControl_v7_9; + +#endif /* __IDeckLinkDeckControl_v7_9_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkDisplayModeIterator_v7_6_FWD_DEFINED__ +#define __IDeckLinkDisplayModeIterator_v7_6_FWD_DEFINED__ +typedef interface IDeckLinkDisplayModeIterator_v7_6 IDeckLinkDisplayModeIterator_v7_6; + +#endif /* __IDeckLinkDisplayModeIterator_v7_6_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkDisplayMode_v7_6_FWD_DEFINED__ +#define __IDeckLinkDisplayMode_v7_6_FWD_DEFINED__ +typedef interface IDeckLinkDisplayMode_v7_6 IDeckLinkDisplayMode_v7_6; + +#endif /* __IDeckLinkDisplayMode_v7_6_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkOutput_v7_6_FWD_DEFINED__ +#define __IDeckLinkOutput_v7_6_FWD_DEFINED__ +typedef interface IDeckLinkOutput_v7_6 IDeckLinkOutput_v7_6; + +#endif /* __IDeckLinkOutput_v7_6_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkInput_v7_6_FWD_DEFINED__ +#define __IDeckLinkInput_v7_6_FWD_DEFINED__ +typedef interface IDeckLinkInput_v7_6 IDeckLinkInput_v7_6; + +#endif /* __IDeckLinkInput_v7_6_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkTimecode_v7_6_FWD_DEFINED__ +#define __IDeckLinkTimecode_v7_6_FWD_DEFINED__ +typedef interface IDeckLinkTimecode_v7_6 IDeckLinkTimecode_v7_6; + +#endif /* __IDeckLinkTimecode_v7_6_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkVideoFrame_v7_6_FWD_DEFINED__ +#define __IDeckLinkVideoFrame_v7_6_FWD_DEFINED__ +typedef interface IDeckLinkVideoFrame_v7_6 IDeckLinkVideoFrame_v7_6; + +#endif /* __IDeckLinkVideoFrame_v7_6_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkMutableVideoFrame_v7_6_FWD_DEFINED__ +#define __IDeckLinkMutableVideoFrame_v7_6_FWD_DEFINED__ +typedef interface IDeckLinkMutableVideoFrame_v7_6 IDeckLinkMutableVideoFrame_v7_6; + +#endif /* __IDeckLinkMutableVideoFrame_v7_6_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkVideoInputFrame_v7_6_FWD_DEFINED__ +#define __IDeckLinkVideoInputFrame_v7_6_FWD_DEFINED__ +typedef interface IDeckLinkVideoInputFrame_v7_6 IDeckLinkVideoInputFrame_v7_6; + +#endif /* __IDeckLinkVideoInputFrame_v7_6_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkScreenPreviewCallback_v7_6_FWD_DEFINED__ +#define __IDeckLinkScreenPreviewCallback_v7_6_FWD_DEFINED__ +typedef interface IDeckLinkScreenPreviewCallback_v7_6 IDeckLinkScreenPreviewCallback_v7_6; + +#endif /* __IDeckLinkScreenPreviewCallback_v7_6_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkGLScreenPreviewHelper_v7_6_FWD_DEFINED__ +#define __IDeckLinkGLScreenPreviewHelper_v7_6_FWD_DEFINED__ +typedef interface IDeckLinkGLScreenPreviewHelper_v7_6 IDeckLinkGLScreenPreviewHelper_v7_6; + +#endif /* __IDeckLinkGLScreenPreviewHelper_v7_6_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkVideoConversion_v7_6_FWD_DEFINED__ +#define __IDeckLinkVideoConversion_v7_6_FWD_DEFINED__ +typedef interface IDeckLinkVideoConversion_v7_6 IDeckLinkVideoConversion_v7_6; + +#endif /* __IDeckLinkVideoConversion_v7_6_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkConfiguration_v7_6_FWD_DEFINED__ +#define __IDeckLinkConfiguration_v7_6_FWD_DEFINED__ +typedef interface IDeckLinkConfiguration_v7_6 IDeckLinkConfiguration_v7_6; + +#endif /* __IDeckLinkConfiguration_v7_6_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkVideoOutputCallback_v7_6_FWD_DEFINED__ +#define __IDeckLinkVideoOutputCallback_v7_6_FWD_DEFINED__ +typedef interface IDeckLinkVideoOutputCallback_v7_6 IDeckLinkVideoOutputCallback_v7_6; + +#endif /* __IDeckLinkVideoOutputCallback_v7_6_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkInputCallback_v7_6_FWD_DEFINED__ +#define __IDeckLinkInputCallback_v7_6_FWD_DEFINED__ +typedef interface IDeckLinkInputCallback_v7_6 IDeckLinkInputCallback_v7_6; + +#endif /* __IDeckLinkInputCallback_v7_6_FWD_DEFINED__ */ + + +#ifndef __CDeckLinkGLScreenPreviewHelper_v7_6_FWD_DEFINED__ +#define __CDeckLinkGLScreenPreviewHelper_v7_6_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class CDeckLinkGLScreenPreviewHelper_v7_6 CDeckLinkGLScreenPreviewHelper_v7_6; +#else +typedef struct CDeckLinkGLScreenPreviewHelper_v7_6 CDeckLinkGLScreenPreviewHelper_v7_6; +#endif /* __cplusplus */ + +#endif /* __CDeckLinkGLScreenPreviewHelper_v7_6_FWD_DEFINED__ */ + + +#ifndef __CDeckLinkVideoConversion_v7_6_FWD_DEFINED__ +#define __CDeckLinkVideoConversion_v7_6_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class CDeckLinkVideoConversion_v7_6 CDeckLinkVideoConversion_v7_6; +#else +typedef struct CDeckLinkVideoConversion_v7_6 CDeckLinkVideoConversion_v7_6; +#endif /* __cplusplus */ + +#endif /* __CDeckLinkVideoConversion_v7_6_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkInputCallback_v7_3_FWD_DEFINED__ +#define __IDeckLinkInputCallback_v7_3_FWD_DEFINED__ +typedef interface IDeckLinkInputCallback_v7_3 IDeckLinkInputCallback_v7_3; + +#endif /* __IDeckLinkInputCallback_v7_3_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkOutput_v7_3_FWD_DEFINED__ +#define __IDeckLinkOutput_v7_3_FWD_DEFINED__ +typedef interface IDeckLinkOutput_v7_3 IDeckLinkOutput_v7_3; + +#endif /* __IDeckLinkOutput_v7_3_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkInput_v7_3_FWD_DEFINED__ +#define __IDeckLinkInput_v7_3_FWD_DEFINED__ +typedef interface IDeckLinkInput_v7_3 IDeckLinkInput_v7_3; + +#endif /* __IDeckLinkInput_v7_3_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkVideoInputFrame_v7_3_FWD_DEFINED__ +#define __IDeckLinkVideoInputFrame_v7_3_FWD_DEFINED__ +typedef interface IDeckLinkVideoInputFrame_v7_3 IDeckLinkVideoInputFrame_v7_3; + +#endif /* __IDeckLinkVideoInputFrame_v7_3_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkDisplayModeIterator_v7_1_FWD_DEFINED__ +#define __IDeckLinkDisplayModeIterator_v7_1_FWD_DEFINED__ +typedef interface IDeckLinkDisplayModeIterator_v7_1 IDeckLinkDisplayModeIterator_v7_1; + +#endif /* __IDeckLinkDisplayModeIterator_v7_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkDisplayMode_v7_1_FWD_DEFINED__ +#define __IDeckLinkDisplayMode_v7_1_FWD_DEFINED__ +typedef interface IDeckLinkDisplayMode_v7_1 IDeckLinkDisplayMode_v7_1; + +#endif /* __IDeckLinkDisplayMode_v7_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkVideoFrame_v7_1_FWD_DEFINED__ +#define __IDeckLinkVideoFrame_v7_1_FWD_DEFINED__ +typedef interface IDeckLinkVideoFrame_v7_1 IDeckLinkVideoFrame_v7_1; + +#endif /* __IDeckLinkVideoFrame_v7_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkVideoInputFrame_v7_1_FWD_DEFINED__ +#define __IDeckLinkVideoInputFrame_v7_1_FWD_DEFINED__ +typedef interface IDeckLinkVideoInputFrame_v7_1 IDeckLinkVideoInputFrame_v7_1; + +#endif /* __IDeckLinkVideoInputFrame_v7_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkAudioInputPacket_v7_1_FWD_DEFINED__ +#define __IDeckLinkAudioInputPacket_v7_1_FWD_DEFINED__ +typedef interface IDeckLinkAudioInputPacket_v7_1 IDeckLinkAudioInputPacket_v7_1; + +#endif /* __IDeckLinkAudioInputPacket_v7_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkVideoOutputCallback_v7_1_FWD_DEFINED__ +#define __IDeckLinkVideoOutputCallback_v7_1_FWD_DEFINED__ +typedef interface IDeckLinkVideoOutputCallback_v7_1 IDeckLinkVideoOutputCallback_v7_1; + +#endif /* __IDeckLinkVideoOutputCallback_v7_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkInputCallback_v7_1_FWD_DEFINED__ +#define __IDeckLinkInputCallback_v7_1_FWD_DEFINED__ +typedef interface IDeckLinkInputCallback_v7_1 IDeckLinkInputCallback_v7_1; + +#endif /* __IDeckLinkInputCallback_v7_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkOutput_v7_1_FWD_DEFINED__ +#define __IDeckLinkOutput_v7_1_FWD_DEFINED__ +typedef interface IDeckLinkOutput_v7_1 IDeckLinkOutput_v7_1; + +#endif /* __IDeckLinkOutput_v7_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkInput_v7_1_FWD_DEFINED__ +#define __IDeckLinkInput_v7_1_FWD_DEFINED__ +typedef interface IDeckLinkInput_v7_1 IDeckLinkInput_v7_1; + +#endif /* __IDeckLinkInput_v7_1_FWD_DEFINED__ */ + + +/* header files for imported files */ +#include "unknwn.h" + +#ifdef __cplusplus +extern "C"{ +#endif + + + +#ifndef __DeckLinkAPI_LIBRARY_DEFINED__ +#define __DeckLinkAPI_LIBRARY_DEFINED__ + +/* library DeckLinkAPI */ +/* [helpstring][version][uuid] */ + +typedef LONGLONG BMDTimeValue; + +typedef LONGLONG BMDTimeScale; + +typedef unsigned int BMDTimecodeBCD; + +typedef unsigned int BMDTimecodeUserBits; + +typedef unsigned int BMDTimecodeFlags; +#if 0 +typedef enum _BMDTimecodeFlags BMDTimecodeFlags; + +#endif +/* [v1_enum] */ +enum _BMDTimecodeFlags + { + bmdTimecodeFlagDefault = 0, + bmdTimecodeIsDropFrame = ( 1 << 0 ) , + bmdTimecodeFieldMark = ( 1 << 1 ) + } ; +typedef /* [v1_enum] */ +enum _BMDVideoConnection + { + bmdVideoConnectionSDI = ( 1 << 0 ) , + bmdVideoConnectionHDMI = ( 1 << 1 ) , + bmdVideoConnectionOpticalSDI = ( 1 << 2 ) , + bmdVideoConnectionComponent = ( 1 << 3 ) , + bmdVideoConnectionComposite = ( 1 << 4 ) , + bmdVideoConnectionSVideo = ( 1 << 5 ) + } BMDVideoConnection; + +typedef /* [v1_enum] */ +enum _BMDAudioConnection + { + bmdAudioConnectionEmbedded = ( 1 << 0 ) , + bmdAudioConnectionAESEBU = ( 1 << 1 ) , + bmdAudioConnectionAnalog = ( 1 << 2 ) , + bmdAudioConnectionAnalogXLR = ( 1 << 3 ) , + bmdAudioConnectionAnalogRCA = ( 1 << 4 ) + } BMDAudioConnection; + + +typedef unsigned int BMDDisplayModeFlags; +#if 0 +typedef enum _BMDDisplayModeFlags BMDDisplayModeFlags; + +#endif +typedef /* [v1_enum] */ +enum _BMDDisplayMode + { + bmdModeNTSC = 0x6e747363, + bmdModeNTSC2398 = 0x6e743233, + bmdModePAL = 0x70616c20, + bmdModeNTSCp = 0x6e747370, + bmdModePALp = 0x70616c70, + bmdModeHD1080p2398 = 0x32337073, + bmdModeHD1080p24 = 0x32347073, + bmdModeHD1080p25 = 0x48703235, + bmdModeHD1080p2997 = 0x48703239, + bmdModeHD1080p30 = 0x48703330, + bmdModeHD1080i50 = 0x48693530, + bmdModeHD1080i5994 = 0x48693539, + bmdModeHD1080i6000 = 0x48693630, + bmdModeHD1080p50 = 0x48703530, + bmdModeHD1080p5994 = 0x48703539, + bmdModeHD1080p6000 = 0x48703630, + bmdModeHD720p50 = 0x68703530, + bmdModeHD720p5994 = 0x68703539, + bmdModeHD720p60 = 0x68703630, + bmdMode2k2398 = 0x326b3233, + bmdMode2k24 = 0x326b3234, + bmdMode2k25 = 0x326b3235, + bmdMode2kDCI2398 = 0x32643233, + bmdMode2kDCI24 = 0x32643234, + bmdMode2kDCI25 = 0x32643235, + bmdMode4K2160p2398 = 0x346b3233, + bmdMode4K2160p24 = 0x346b3234, + bmdMode4K2160p25 = 0x346b3235, + bmdMode4K2160p2997 = 0x346b3239, + bmdMode4K2160p30 = 0x346b3330, + bmdMode4K2160p50 = 0x346b3530, + bmdMode4K2160p5994 = 0x346b3539, + bmdMode4K2160p60 = 0x346b3630, + bmdMode4kDCI2398 = 0x34643233, + bmdMode4kDCI24 = 0x34643234, + bmdMode4kDCI25 = 0x34643235, + bmdModeUnknown = 0x69756e6b + } BMDDisplayMode; + +typedef /* [v1_enum] */ +enum _BMDFieldDominance + { + bmdUnknownFieldDominance = 0, + bmdLowerFieldFirst = 0x6c6f7772, + bmdUpperFieldFirst = 0x75707072, + bmdProgressiveFrame = 0x70726f67, + bmdProgressiveSegmentedFrame = 0x70736620 + } BMDFieldDominance; + +typedef /* [v1_enum] */ +enum _BMDPixelFormat + { + bmdFormat8BitYUV = 0x32767579, + bmdFormat10BitYUV = 0x76323130, + bmdFormat8BitARGB = 32, + bmdFormat8BitBGRA = 0x42475241, + bmdFormat10BitRGB = 0x72323130, + bmdFormat12BitRGB = 0x52313242, + bmdFormat12BitRGBLE = 0x5231324c, + bmdFormat10BitRGBXLE = 0x5231306c, + bmdFormat10BitRGBX = 0x52313062 + } BMDPixelFormat; + +/* [v1_enum] */ +enum _BMDDisplayModeFlags + { + bmdDisplayModeSupports3D = ( 1 << 0 ) , + bmdDisplayModeColorspaceRec601 = ( 1 << 1 ) , + bmdDisplayModeColorspaceRec709 = ( 1 << 2 ) + } ; + + +#if 0 +#endif + +#if 0 +#endif +typedef /* [v1_enum] */ +enum _BMDDeckLinkConfigurationID + { + bmdDeckLinkConfigSwapSerialRxTx = 0x73737274, + bmdDeckLinkConfigUse1080pNotPsF = 0x6670726f, + bmdDeckLinkConfigHDMI3DPackingFormat = 0x33647066, + bmdDeckLinkConfigBypass = 0x62797073, + bmdDeckLinkConfigClockTimingAdjustment = 0x63746164, + bmdDeckLinkConfigAnalogAudioConsumerLevels = 0x6161636c, + bmdDeckLinkConfigFieldFlickerRemoval = 0x66646672, + bmdDeckLinkConfigHD1080p24ToHD1080i5994Conversion = 0x746f3539, + bmdDeckLinkConfig444SDIVideoOutput = 0x3434346f, + bmdDeckLinkConfigSingleLinkVideoOutput = 0x73676c6f, + bmdDeckLinkConfigBlackVideoOutputDuringCapture = 0x62766f63, + bmdDeckLinkConfigLowLatencyVideoOutput = 0x6c6c766f, + bmdDeckLinkConfigDownConversionOnAllAnalogOutput = 0x6361616f, + bmdDeckLinkConfigSMPTELevelAOutput = 0x736d7461, + bmdDeckLinkConfigVideoOutputConnection = 0x766f636e, + bmdDeckLinkConfigVideoOutputConversionMode = 0x766f636d, + bmdDeckLinkConfigAnalogVideoOutputFlags = 0x61766f66, + bmdDeckLinkConfigReferenceInputTimingOffset = 0x676c6f74, + bmdDeckLinkConfigVideoOutputIdleOperation = 0x766f696f, + bmdDeckLinkConfigDefaultVideoOutputMode = 0x64766f6d, + bmdDeckLinkConfigDefaultVideoOutputModeFlags = 0x64766f66, + bmdDeckLinkConfigVideoOutputComponentLumaGain = 0x6f636c67, + bmdDeckLinkConfigVideoOutputComponentChromaBlueGain = 0x6f636362, + bmdDeckLinkConfigVideoOutputComponentChromaRedGain = 0x6f636372, + bmdDeckLinkConfigVideoOutputCompositeLumaGain = 0x6f696c67, + bmdDeckLinkConfigVideoOutputCompositeChromaGain = 0x6f696367, + bmdDeckLinkConfigVideoOutputSVideoLumaGain = 0x6f736c67, + bmdDeckLinkConfigVideoOutputSVideoChromaGain = 0x6f736367, + bmdDeckLinkConfigVideoInputScanning = 0x76697363, + bmdDeckLinkConfigUseDedicatedLTCInput = 0x646c7463, + bmdDeckLinkConfigVideoInputConnection = 0x7669636e, + bmdDeckLinkConfigAnalogVideoInputFlags = 0x61766966, + bmdDeckLinkConfigVideoInputConversionMode = 0x7669636d, + bmdDeckLinkConfig32PulldownSequenceInitialTimecodeFrame = 0x70646966, + bmdDeckLinkConfigVANCSourceLine1Mapping = 0x76736c31, + bmdDeckLinkConfigVANCSourceLine2Mapping = 0x76736c32, + bmdDeckLinkConfigVANCSourceLine3Mapping = 0x76736c33, + bmdDeckLinkConfigCapturePassThroughMode = 0x6370746d, + bmdDeckLinkConfigVideoInputComponentLumaGain = 0x69636c67, + bmdDeckLinkConfigVideoInputComponentChromaBlueGain = 0x69636362, + bmdDeckLinkConfigVideoInputComponentChromaRedGain = 0x69636372, + bmdDeckLinkConfigVideoInputCompositeLumaGain = 0x69696c67, + bmdDeckLinkConfigVideoInputCompositeChromaGain = 0x69696367, + bmdDeckLinkConfigVideoInputSVideoLumaGain = 0x69736c67, + bmdDeckLinkConfigVideoInputSVideoChromaGain = 0x69736367, + bmdDeckLinkConfigAudioInputConnection = 0x6169636e, + bmdDeckLinkConfigAnalogAudioInputScaleChannel1 = 0x61697331, + bmdDeckLinkConfigAnalogAudioInputScaleChannel2 = 0x61697332, + bmdDeckLinkConfigAnalogAudioInputScaleChannel3 = 0x61697333, + bmdDeckLinkConfigAnalogAudioInputScaleChannel4 = 0x61697334, + bmdDeckLinkConfigDigitalAudioInputScale = 0x64616973, + bmdDeckLinkConfigAudioOutputAESAnalogSwitch = 0x616f6161, + bmdDeckLinkConfigAnalogAudioOutputScaleChannel1 = 0x616f7331, + bmdDeckLinkConfigAnalogAudioOutputScaleChannel2 = 0x616f7332, + bmdDeckLinkConfigAnalogAudioOutputScaleChannel3 = 0x616f7333, + bmdDeckLinkConfigAnalogAudioOutputScaleChannel4 = 0x616f7334, + bmdDeckLinkConfigDigitalAudioOutputScale = 0x64616f73, + bmdDeckLinkConfigDeviceInformationLabel = 0x64696c61, + bmdDeckLinkConfigDeviceInformationSerialNumber = 0x6469736e, + bmdDeckLinkConfigDeviceInformationCompany = 0x6469636f, + bmdDeckLinkConfigDeviceInformationPhone = 0x64697068, + bmdDeckLinkConfigDeviceInformationEmail = 0x6469656d, + bmdDeckLinkConfigDeviceInformationDate = 0x64696461 + } BMDDeckLinkConfigurationID; + + +typedef unsigned int BMDDeckControlStatusFlags; +typedef unsigned int BMDDeckControlExportModeOpsFlags; +#if 0 +typedef enum _BMDDeckControlStatusFlags BMDDeckControlStatusFlags; + +typedef enum _BMDDeckControlExportModeOpsFlags BMDDeckControlExportModeOpsFlags; + +#endif +typedef /* [v1_enum] */ +enum _BMDDeckControlMode + { + bmdDeckControlNotOpened = 0x6e746f70, + bmdDeckControlVTRControlMode = 0x76747263, + bmdDeckControlExportMode = 0x6578706d, + bmdDeckControlCaptureMode = 0x6361706d + } BMDDeckControlMode; + +typedef /* [v1_enum] */ +enum _BMDDeckControlEvent + { + bmdDeckControlAbortedEvent = 0x61627465, + bmdDeckControlPrepareForExportEvent = 0x70666565, + bmdDeckControlExportCompleteEvent = 0x65786365, + bmdDeckControlPrepareForCaptureEvent = 0x70666365, + bmdDeckControlCaptureCompleteEvent = 0x63636576 + } BMDDeckControlEvent; + +typedef /* [v1_enum] */ +enum _BMDDeckControlVTRControlState + { + bmdDeckControlNotInVTRControlMode = 0x6e76636d, + bmdDeckControlVTRControlPlaying = 0x76747270, + bmdDeckControlVTRControlRecording = 0x76747272, + bmdDeckControlVTRControlStill = 0x76747261, + bmdDeckControlVTRControlShuttleForward = 0x76747366, + bmdDeckControlVTRControlShuttleReverse = 0x76747372, + bmdDeckControlVTRControlJogForward = 0x76746a66, + bmdDeckControlVTRControlJogReverse = 0x76746a72, + bmdDeckControlVTRControlStopped = 0x7674726f + } BMDDeckControlVTRControlState; + +/* [v1_enum] */ +enum _BMDDeckControlStatusFlags + { + bmdDeckControlStatusDeckConnected = ( 1 << 0 ) , + bmdDeckControlStatusRemoteMode = ( 1 << 1 ) , + bmdDeckControlStatusRecordInhibited = ( 1 << 2 ) , + bmdDeckControlStatusCassetteOut = ( 1 << 3 ) + } ; +/* [v1_enum] */ +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 ) + } ; +typedef /* [v1_enum] */ +enum _BMDDeckControlError + { + bmdDeckControlNoError = 0x6e6f6572, + bmdDeckControlModeError = 0x6d6f6572, + bmdDeckControlMissedInPointError = 0x6d696572, + bmdDeckControlDeckTimeoutError = 0x64746572, + bmdDeckControlCommandFailedError = 0x63666572, + bmdDeckControlDeviceAlreadyOpenedError = 0x64616c6f, + bmdDeckControlFailedToOpenDeviceError = 0x66646572, + bmdDeckControlInLocalModeError = 0x6c6d6572, + bmdDeckControlEndOfTapeError = 0x65746572, + bmdDeckControlUserAbortError = 0x75616572, + bmdDeckControlNoTapeInDeckError = 0x6e746572, + bmdDeckControlNoVideoFromCardError = 0x6e766663, + bmdDeckControlNoCommunicationError = 0x6e636f6d, + bmdDeckControlBufferTooSmallError = 0x6274736d, + bmdDeckControlBadChecksumError = 0x63686b73, + bmdDeckControlUnknownError = 0x756e6572 + } BMDDeckControlError; + + + +#if 0 +#endif +typedef /* [v1_enum] */ +enum _BMDStreamingDeviceMode + { + bmdStreamingDeviceIdle = 0x69646c65, + bmdStreamingDeviceEncoding = 0x656e636f, + bmdStreamingDeviceStopping = 0x73746f70, + bmdStreamingDeviceUnknown = 0x6d756e6b + } BMDStreamingDeviceMode; + +typedef /* [v1_enum] */ +enum _BMDStreamingEncodingFrameRate + { + bmdStreamingEncodedFrameRate50i = 0x65353069, + bmdStreamingEncodedFrameRate5994i = 0x65353969, + bmdStreamingEncodedFrameRate60i = 0x65363069, + bmdStreamingEncodedFrameRate2398p = 0x65323370, + bmdStreamingEncodedFrameRate24p = 0x65323470, + bmdStreamingEncodedFrameRate25p = 0x65323570, + bmdStreamingEncodedFrameRate2997p = 0x65323970, + bmdStreamingEncodedFrameRate30p = 0x65333070, + bmdStreamingEncodedFrameRate50p = 0x65353070, + bmdStreamingEncodedFrameRate5994p = 0x65353970, + bmdStreamingEncodedFrameRate60p = 0x65363070 + } BMDStreamingEncodingFrameRate; + +typedef /* [v1_enum] */ +enum _BMDStreamingEncodingSupport + { + bmdStreamingEncodingModeNotSupported = 0, + bmdStreamingEncodingModeSupported = ( bmdStreamingEncodingModeNotSupported + 1 ) , + bmdStreamingEncodingModeSupportedWithChanges = ( bmdStreamingEncodingModeSupported + 1 ) + } BMDStreamingEncodingSupport; + +typedef /* [v1_enum] */ +enum _BMDStreamingVideoCodec + { + bmdStreamingVideoCodecH264 = 0x48323634 + } BMDStreamingVideoCodec; + +typedef /* [v1_enum] */ +enum _BMDStreamingH264Profile + { + bmdStreamingH264ProfileHigh = 0x68696768, + bmdStreamingH264ProfileMain = 0x6d61696e, + bmdStreamingH264ProfileBaseline = 0x62617365 + } BMDStreamingH264Profile; + +typedef /* [v1_enum] */ +enum _BMDStreamingH264Level + { + bmdStreamingH264Level12 = 0x6c763132, + bmdStreamingH264Level13 = 0x6c763133, + bmdStreamingH264Level2 = 0x6c763220, + bmdStreamingH264Level21 = 0x6c763231, + bmdStreamingH264Level22 = 0x6c763232, + bmdStreamingH264Level3 = 0x6c763320, + bmdStreamingH264Level31 = 0x6c763331, + bmdStreamingH264Level32 = 0x6c763332, + bmdStreamingH264Level4 = 0x6c763420, + bmdStreamingH264Level41 = 0x6c763431, + bmdStreamingH264Level42 = 0x6c763432 + } BMDStreamingH264Level; + +typedef /* [v1_enum] */ +enum _BMDStreamingH264EntropyCoding + { + bmdStreamingH264EntropyCodingCAVLC = 0x45564c43, + bmdStreamingH264EntropyCodingCABAC = 0x45424143 + } BMDStreamingH264EntropyCoding; + +typedef /* [v1_enum] */ +enum _BMDStreamingAudioCodec + { + bmdStreamingAudioCodecAAC = 0x41414320 + } BMDStreamingAudioCodec; + +typedef /* [v1_enum] */ +enum _BMDStreamingEncodingModePropertyID + { + bmdStreamingEncodingPropertyVideoFrameRate = 0x76667274, + bmdStreamingEncodingPropertyVideoBitRateKbps = 0x76627274, + bmdStreamingEncodingPropertyH264Profile = 0x68707266, + bmdStreamingEncodingPropertyH264Level = 0x686c766c, + bmdStreamingEncodingPropertyH264EntropyCoding = 0x68656e74, + bmdStreamingEncodingPropertyH264HasBFrames = 0x68426672, + bmdStreamingEncodingPropertyAudioCodec = 0x61636463, + bmdStreamingEncodingPropertyAudioSampleRate = 0x61737274, + bmdStreamingEncodingPropertyAudioChannelCount = 0x61636863, + bmdStreamingEncodingPropertyAudioBitRateKbps = 0x61627274 + } BMDStreamingEncodingModePropertyID; + + + + + + + + + + + + +typedef unsigned int BMDFrameFlags; +typedef unsigned int BMDVideoInputFlags; +typedef unsigned int BMDVideoInputFormatChangedEvents; +typedef unsigned int BMDDetectedVideoInputFormatFlags; +typedef unsigned int BMDDeckLinkCapturePassthroughMode; +typedef unsigned int BMDAnalogVideoFlags; +typedef unsigned int BMDDeviceBusyState; +#if 0 +typedef enum _BMDFrameFlags BMDFrameFlags; + +typedef enum _BMDVideoInputFlags BMDVideoInputFlags; + +typedef enum _BMDVideoInputFormatChangedEvents BMDVideoInputFormatChangedEvents; + +typedef enum _BMDDetectedVideoInputFormatFlags BMDDetectedVideoInputFormatFlags; + +typedef enum _BMDDeckLinkCapturePassthroughMode BMDDeckLinkCapturePassthroughMode; + +typedef enum _BMDAnalogVideoFlags BMDAnalogVideoFlags; + +typedef enum _BMDDeviceBusyState BMDDeviceBusyState; + +#endif +typedef /* [v1_enum] */ +enum _BMDVideoOutputFlags + { + bmdVideoOutputFlagDefault = 0, + bmdVideoOutputVANC = ( 1 << 0 ) , + bmdVideoOutputVITC = ( 1 << 1 ) , + bmdVideoOutputRP188 = ( 1 << 2 ) , + bmdVideoOutputDualStream3D = ( 1 << 4 ) + } BMDVideoOutputFlags; + +/* [v1_enum] */ +enum _BMDFrameFlags + { + bmdFrameFlagDefault = 0, + bmdFrameFlagFlipVertical = ( 1 << 0 ) , + bmdFrameHasNoInputSource = ( 1 << 31 ) + } ; +/* [v1_enum] */ +enum _BMDVideoInputFlags + { + bmdVideoInputFlagDefault = 0, + bmdVideoInputEnableFormatDetection = ( 1 << 0 ) , + bmdVideoInputDualStream3D = ( 1 << 1 ) + } ; +/* [v1_enum] */ +enum _BMDVideoInputFormatChangedEvents + { + bmdVideoInputDisplayModeChanged = ( 1 << 0 ) , + bmdVideoInputFieldDominanceChanged = ( 1 << 1 ) , + bmdVideoInputColorspaceChanged = ( 1 << 2 ) + } ; +/* [v1_enum] */ +enum _BMDDetectedVideoInputFormatFlags + { + bmdDetectedVideoInputYCbCr422 = ( 1 << 0 ) , + bmdDetectedVideoInputRGB444 = ( 1 << 1 ) , + bmdDetectedVideoInputDualStream3D = ( 1 << 2 ) + } ; +/* [v1_enum] */ +enum _BMDDeckLinkCapturePassthroughMode + { + bmdDeckLinkCapturePassthroughModeDirect = 0x70646972, + bmdDeckLinkCapturePassthroughModeCleanSwitch = 0x70636c6e + } ; +typedef /* [v1_enum] */ +enum _BMDOutputFrameCompletionResult + { + bmdOutputFrameCompleted = 0, + bmdOutputFrameDisplayedLate = ( bmdOutputFrameCompleted + 1 ) , + bmdOutputFrameDropped = ( bmdOutputFrameDisplayedLate + 1 ) , + bmdOutputFrameFlushed = ( bmdOutputFrameDropped + 1 ) + } BMDOutputFrameCompletionResult; + +typedef /* [v1_enum] */ +enum _BMDReferenceStatus + { + bmdReferenceNotSupportedByHardware = ( 1 << 0 ) , + bmdReferenceLocked = ( 1 << 1 ) + } BMDReferenceStatus; + +typedef /* [v1_enum] */ +enum _BMDAudioSampleRate + { + bmdAudioSampleRate48kHz = 48000 + } BMDAudioSampleRate; + +typedef /* [v1_enum] */ +enum _BMDAudioSampleType + { + bmdAudioSampleType16bitInteger = 16, + bmdAudioSampleType32bitInteger = 32 + } BMDAudioSampleType; + +typedef /* [v1_enum] */ +enum _BMDAudioOutputStreamType + { + bmdAudioOutputStreamContinuous = 0, + bmdAudioOutputStreamContinuousDontResample = ( bmdAudioOutputStreamContinuous + 1 ) , + bmdAudioOutputStreamTimestamped = ( bmdAudioOutputStreamContinuousDontResample + 1 ) + } BMDAudioOutputStreamType; + +typedef /* [v1_enum] */ +enum _BMDDisplayModeSupport + { + bmdDisplayModeNotSupported = 0, + bmdDisplayModeSupported = ( bmdDisplayModeNotSupported + 1 ) , + bmdDisplayModeSupportedWithConversion = ( bmdDisplayModeSupported + 1 ) + } BMDDisplayModeSupport; + +typedef /* [v1_enum] */ +enum _BMDTimecodeFormat + { + bmdTimecodeRP188VITC1 = 0x72707631, + bmdTimecodeRP188VITC2 = 0x72703132, + bmdTimecodeRP188LTC = 0x72706c74, + bmdTimecodeRP188Any = 0x72703138, + bmdTimecodeVITC = 0x76697463, + bmdTimecodeVITCField2 = 0x76697432, + bmdTimecodeSerial = 0x73657269 + } BMDTimecodeFormat; + +/* [v1_enum] */ +enum _BMDAnalogVideoFlags + { + bmdAnalogVideoFlagCompositeSetup75 = ( 1 << 0 ) , + bmdAnalogVideoFlagComponentBetacamLevels = ( 1 << 1 ) + } ; +typedef /* [v1_enum] */ +enum _BMDAudioOutputAnalogAESSwitch + { + bmdAudioOutputSwitchAESEBU = 0x61657320, + bmdAudioOutputSwitchAnalog = 0x616e6c67 + } BMDAudioOutputAnalogAESSwitch; + +typedef /* [v1_enum] */ +enum _BMDVideoOutputConversionMode + { + bmdNoVideoOutputConversion = 0x6e6f6e65, + bmdVideoOutputLetterboxDownconversion = 0x6c746278, + bmdVideoOutputAnamorphicDownconversion = 0x616d7068, + bmdVideoOutputHD720toHD1080Conversion = 0x37323063, + bmdVideoOutputHardwareLetterboxDownconversion = 0x48576c62, + bmdVideoOutputHardwareAnamorphicDownconversion = 0x4857616d, + bmdVideoOutputHardwareCenterCutDownconversion = 0x48576363, + bmdVideoOutputHardware720p1080pCrossconversion = 0x78636170, + bmdVideoOutputHardwareAnamorphic720pUpconversion = 0x75613770, + bmdVideoOutputHardwareAnamorphic1080iUpconversion = 0x75613169, + bmdVideoOutputHardwareAnamorphic149To720pUpconversion = 0x75343770, + bmdVideoOutputHardwareAnamorphic149To1080iUpconversion = 0x75343169, + bmdVideoOutputHardwarePillarbox720pUpconversion = 0x75703770, + bmdVideoOutputHardwarePillarbox1080iUpconversion = 0x75703169 + } BMDVideoOutputConversionMode; + +typedef /* [v1_enum] */ +enum _BMDVideoInputConversionMode + { + bmdNoVideoInputConversion = 0x6e6f6e65, + bmdVideoInputLetterboxDownconversionFromHD1080 = 0x31306c62, + bmdVideoInputAnamorphicDownconversionFromHD1080 = 0x3130616d, + bmdVideoInputLetterboxDownconversionFromHD720 = 0x37326c62, + bmdVideoInputAnamorphicDownconversionFromHD720 = 0x3732616d, + bmdVideoInputLetterboxUpconversion = 0x6c627570, + bmdVideoInputAnamorphicUpconversion = 0x616d7570 + } BMDVideoInputConversionMode; + +typedef /* [v1_enum] */ +enum _BMDVideo3DPackingFormat + { + bmdVideo3DPackingSidebySideHalf = 0x73627368, + bmdVideo3DPackingLinebyLine = 0x6c62796c, + bmdVideo3DPackingTopAndBottom = 0x7461626f, + bmdVideo3DPackingFramePacking = 0x6672706b, + bmdVideo3DPackingLeftOnly = 0x6c656674, + bmdVideo3DPackingRightOnly = 0x72696768 + } BMDVideo3DPackingFormat; + +typedef /* [v1_enum] */ +enum _BMDIdleVideoOutputOperation + { + bmdIdleVideoOutputBlack = 0x626c6163, + bmdIdleVideoOutputLastFrame = 0x6c616661, + bmdIdleVideoOutputDesktop = 0x6465736b + } BMDIdleVideoOutputOperation; + +typedef /* [v1_enum] */ +enum _BMDDeckLinkAttributeID + { + BMDDeckLinkSupportsInternalKeying = 0x6b657969, + BMDDeckLinkSupportsExternalKeying = 0x6b657965, + BMDDeckLinkSupportsHDKeying = 0x6b657968, + BMDDeckLinkSupportsInputFormatDetection = 0x696e6664, + BMDDeckLinkHasReferenceInput = 0x6872696e, + BMDDeckLinkHasSerialPort = 0x68737074, + BMDDeckLinkHasAnalogVideoOutputGain = 0x61766f67, + BMDDeckLinkCanOnlyAdjustOverallVideoOutputGain = 0x6f766f67, + BMDDeckLinkHasVideoInputAntiAliasingFilter = 0x6161666c, + BMDDeckLinkHasBypass = 0x62797073, + BMDDeckLinkSupportsDesktopDisplay = 0x65787464, + BMDDeckLinkSupportsClockTimingAdjustment = 0x63746164, + BMDDeckLinkSupportsFullDuplex = 0x66647570, + BMDDeckLinkSupportsFullFrameReferenceInputTimingOffset = 0x6672696e, + BMDDeckLinkSupportsSMPTELevelAOutput = 0x6c766c61, + BMDDeckLinkSupportsDualLinkSDI = 0x73646c73, + BMDDeckLinkSupportsIdleOutput = 0x69646f75, + BMDDeckLinkMaximumAudioChannels = 0x6d616368, + BMDDeckLinkMaximumAnalogAudioChannels = 0x61616368, + BMDDeckLinkNumberOfSubDevices = 0x6e736264, + BMDDeckLinkSubDeviceIndex = 0x73756269, + BMDDeckLinkPersistentID = 0x70656964, + BMDDeckLinkTopologicalID = 0x746f6964, + BMDDeckLinkVideoOutputConnections = 0x766f636e, + BMDDeckLinkVideoInputConnections = 0x7669636e, + BMDDeckLinkAudioOutputConnections = 0x616f636e, + BMDDeckLinkAudioInputConnections = 0x6169636e, + BMDDeckLinkDeviceBusyState = 0x64627374, + BMDDeckLinkVideoIOSupport = 0x76696f73, + BMDDeckLinkVideoInputGainMinimum = 0x7669676d, + BMDDeckLinkVideoInputGainMaximum = 0x76696778, + BMDDeckLinkVideoOutputGainMinimum = 0x766f676d, + BMDDeckLinkVideoOutputGainMaximum = 0x766f6778, + BMDDeckLinkSerialPortDeviceName = 0x736c706e + } BMDDeckLinkAttributeID; + +typedef /* [v1_enum] */ +enum _BMDDeckLinkAPIInformationID + { + BMDDeckLinkAPIVersion = 0x76657273 + } BMDDeckLinkAPIInformationID; + +/* [v1_enum] */ +enum _BMDDeviceBusyState + { + bmdDeviceCaptureBusy = ( 1 << 0 ) , + bmdDevicePlaybackBusy = ( 1 << 1 ) , + bmdDeviceSerialPortBusy = ( 1 << 2 ) + } ; +typedef /* [v1_enum] */ +enum _BMDVideoIOSupport + { + bmdDeviceSupportsCapture = ( 1 << 0 ) , + bmdDeviceSupportsPlayback = ( 1 << 1 ) + } BMDVideoIOSupport; + +typedef /* [v1_enum] */ +enum _BMD3DPreviewFormat + { + bmd3DPreviewFormatDefault = 0x64656661, + bmd3DPreviewFormatLeftOnly = 0x6c656674, + bmd3DPreviewFormatRightOnly = 0x72696768, + bmd3DPreviewFormatSideBySide = 0x73696465, + bmd3DPreviewFormatTopBottom = 0x746f7062 + } BMD3DPreviewFormat; + +typedef /* [v1_enum] */ +enum _BMDNotifications + { + bmdPreferencesChanged = 0x70726566 + } BMDNotifications; + + + + + + + + + + + + + + + + + + + + + + + + + +typedef /* [v1_enum] */ +enum _BMDDeckLinkConfigurationID_v10_2 + { + bmdDeckLinkConfig3GBpsVideoOutput_v10_2 = 0x33676273 + } BMDDeckLinkConfigurationID_v10_2; + +typedef /* [v1_enum] */ +enum _BMDAudioConnection_v10_2 + { + bmdAudioConnectionEmbedded_v10_2 = 0x656d6264, + bmdAudioConnectionAESEBU_v10_2 = 0x61657320, + bmdAudioConnectionAnalog_v10_2 = 0x616e6c67, + bmdAudioConnectionAnalogXLR_v10_2 = 0x61786c72, + bmdAudioConnectionAnalogRCA_v10_2 = 0x61726361 + } BMDAudioConnection_v10_2; + + +typedef /* [v1_enum] */ +enum _BMDDeckControlVTRControlState_v8_1 + { + bmdDeckControlNotInVTRControlMode_v8_1 = 0x6e76636d, + bmdDeckControlVTRControlPlaying_v8_1 = 0x76747270, + bmdDeckControlVTRControlRecording_v8_1 = 0x76747272, + bmdDeckControlVTRControlStill_v8_1 = 0x76747261, + bmdDeckControlVTRControlSeeking_v8_1 = 0x76747273, + bmdDeckControlVTRControlStopped_v8_1 = 0x7674726f + } BMDDeckControlVTRControlState_v8_1; + + + +typedef /* [v1_enum] */ +enum _BMDVideoConnection_v7_6 + { + bmdVideoConnectionSDI_v7_6 = 0x73646920, + bmdVideoConnectionHDMI_v7_6 = 0x68646d69, + bmdVideoConnectionOpticalSDI_v7_6 = 0x6f707469, + bmdVideoConnectionComponent_v7_6 = 0x63706e74, + bmdVideoConnectionComposite_v7_6 = 0x636d7374, + bmdVideoConnectionSVideo_v7_6 = 0x73766964 + } BMDVideoConnection_v7_6; + + + + + + + + + + + + + + + + + + + + + + + +EXTERN_C const IID LIBID_DeckLinkAPI; + +#ifndef __IDeckLinkTimecode_INTERFACE_DEFINED__ +#define __IDeckLinkTimecode_INTERFACE_DEFINED__ + +/* interface IDeckLinkTimecode */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkTimecode; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("BC6CFBD3-8317-4325-AC1C-1216391E9340") + IDeckLinkTimecode : public IUnknown + { + public: + virtual BMDTimecodeBCD STDMETHODCALLTYPE GetBCD( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetComponents( + /* [out] */ unsigned char *hours, + /* [out] */ unsigned char *minutes, + /* [out] */ unsigned char *seconds, + /* [out] */ unsigned char *frames) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetString( + /* [out] */ BSTR *timecode) = 0; + + virtual BMDTimecodeFlags STDMETHODCALLTYPE GetFlags( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTimecodeUserBits( + /* [out] */ BMDTimecodeUserBits *userBits) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkTimecodeVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkTimecode * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkTimecode * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkTimecode * This); + + BMDTimecodeBCD ( STDMETHODCALLTYPE *GetBCD )( + IDeckLinkTimecode * This); + + HRESULT ( STDMETHODCALLTYPE *GetComponents )( + IDeckLinkTimecode * This, + /* [out] */ unsigned char *hours, + /* [out] */ unsigned char *minutes, + /* [out] */ unsigned char *seconds, + /* [out] */ unsigned char *frames); + + HRESULT ( STDMETHODCALLTYPE *GetString )( + IDeckLinkTimecode * This, + /* [out] */ BSTR *timecode); + + BMDTimecodeFlags ( STDMETHODCALLTYPE *GetFlags )( + IDeckLinkTimecode * This); + + HRESULT ( STDMETHODCALLTYPE *GetTimecodeUserBits )( + IDeckLinkTimecode * This, + /* [out] */ BMDTimecodeUserBits *userBits); + + END_INTERFACE + } IDeckLinkTimecodeVtbl; + + interface IDeckLinkTimecode + { + CONST_VTBL struct IDeckLinkTimecodeVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkTimecode_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkTimecode_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkTimecode_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkTimecode_GetBCD(This) \ + ( (This)->lpVtbl -> GetBCD(This) ) + +#define IDeckLinkTimecode_GetComponents(This,hours,minutes,seconds,frames) \ + ( (This)->lpVtbl -> GetComponents(This,hours,minutes,seconds,frames) ) + +#define IDeckLinkTimecode_GetString(This,timecode) \ + ( (This)->lpVtbl -> GetString(This,timecode) ) + +#define IDeckLinkTimecode_GetFlags(This) \ + ( (This)->lpVtbl -> GetFlags(This) ) + +#define IDeckLinkTimecode_GetTimecodeUserBits(This,userBits) \ + ( (This)->lpVtbl -> GetTimecodeUserBits(This,userBits) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkTimecode_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkDisplayModeIterator_INTERFACE_DEFINED__ +#define __IDeckLinkDisplayModeIterator_INTERFACE_DEFINED__ + +/* interface IDeckLinkDisplayModeIterator */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkDisplayModeIterator; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("9C88499F-F601-4021-B80B-032E4EB41C35") + IDeckLinkDisplayModeIterator : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Next( + /* [out] */ IDeckLinkDisplayMode **deckLinkDisplayMode) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkDisplayModeIteratorVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkDisplayModeIterator * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkDisplayModeIterator * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkDisplayModeIterator * This); + + HRESULT ( STDMETHODCALLTYPE *Next )( + IDeckLinkDisplayModeIterator * This, + /* [out] */ IDeckLinkDisplayMode **deckLinkDisplayMode); + + END_INTERFACE + } IDeckLinkDisplayModeIteratorVtbl; + + interface IDeckLinkDisplayModeIterator + { + CONST_VTBL struct IDeckLinkDisplayModeIteratorVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkDisplayModeIterator_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkDisplayModeIterator_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkDisplayModeIterator_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkDisplayModeIterator_Next(This,deckLinkDisplayMode) \ + ( (This)->lpVtbl -> Next(This,deckLinkDisplayMode) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkDisplayModeIterator_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkDisplayMode_INTERFACE_DEFINED__ +#define __IDeckLinkDisplayMode_INTERFACE_DEFINED__ + +/* interface IDeckLinkDisplayMode */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkDisplayMode; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("3EB2C1AB-0A3D-4523-A3AD-F40D7FB14E78") + IDeckLinkDisplayMode : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetName( + /* [out] */ BSTR *name) = 0; + + virtual BMDDisplayMode STDMETHODCALLTYPE GetDisplayMode( void) = 0; + + virtual long STDMETHODCALLTYPE GetWidth( void) = 0; + + virtual long STDMETHODCALLTYPE GetHeight( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFrameRate( + /* [out] */ BMDTimeValue *frameDuration, + /* [out] */ BMDTimeScale *timeScale) = 0; + + virtual BMDFieldDominance STDMETHODCALLTYPE GetFieldDominance( void) = 0; + + virtual BMDDisplayModeFlags STDMETHODCALLTYPE GetFlags( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkDisplayModeVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkDisplayMode * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkDisplayMode * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkDisplayMode * This); + + HRESULT ( STDMETHODCALLTYPE *GetName )( + IDeckLinkDisplayMode * This, + /* [out] */ BSTR *name); + + BMDDisplayMode ( STDMETHODCALLTYPE *GetDisplayMode )( + IDeckLinkDisplayMode * This); + + long ( STDMETHODCALLTYPE *GetWidth )( + IDeckLinkDisplayMode * This); + + long ( STDMETHODCALLTYPE *GetHeight )( + IDeckLinkDisplayMode * This); + + HRESULT ( STDMETHODCALLTYPE *GetFrameRate )( + IDeckLinkDisplayMode * This, + /* [out] */ BMDTimeValue *frameDuration, + /* [out] */ BMDTimeScale *timeScale); + + BMDFieldDominance ( STDMETHODCALLTYPE *GetFieldDominance )( + IDeckLinkDisplayMode * This); + + BMDDisplayModeFlags ( STDMETHODCALLTYPE *GetFlags )( + IDeckLinkDisplayMode * This); + + END_INTERFACE + } IDeckLinkDisplayModeVtbl; + + interface IDeckLinkDisplayMode + { + CONST_VTBL struct IDeckLinkDisplayModeVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkDisplayMode_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkDisplayMode_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkDisplayMode_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkDisplayMode_GetName(This,name) \ + ( (This)->lpVtbl -> GetName(This,name) ) + +#define IDeckLinkDisplayMode_GetDisplayMode(This) \ + ( (This)->lpVtbl -> GetDisplayMode(This) ) + +#define IDeckLinkDisplayMode_GetWidth(This) \ + ( (This)->lpVtbl -> GetWidth(This) ) + +#define IDeckLinkDisplayMode_GetHeight(This) \ + ( (This)->lpVtbl -> GetHeight(This) ) + +#define IDeckLinkDisplayMode_GetFrameRate(This,frameDuration,timeScale) \ + ( (This)->lpVtbl -> GetFrameRate(This,frameDuration,timeScale) ) + +#define IDeckLinkDisplayMode_GetFieldDominance(This) \ + ( (This)->lpVtbl -> GetFieldDominance(This) ) + +#define IDeckLinkDisplayMode_GetFlags(This) \ + ( (This)->lpVtbl -> GetFlags(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkDisplayMode_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLink_INTERFACE_DEFINED__ +#define __IDeckLink_INTERFACE_DEFINED__ + +/* interface IDeckLink */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLink; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("C418FBDD-0587-48ED-8FE5-640F0A14AF91") + IDeckLink : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetModelName( + /* [out] */ BSTR *modelName) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayName( + /* [out] */ BSTR *displayName) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLink * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLink * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLink * This); + + HRESULT ( STDMETHODCALLTYPE *GetModelName )( + IDeckLink * This, + /* [out] */ BSTR *modelName); + + HRESULT ( STDMETHODCALLTYPE *GetDisplayName )( + IDeckLink * This, + /* [out] */ BSTR *displayName); + + END_INTERFACE + } IDeckLinkVtbl; + + interface IDeckLink + { + CONST_VTBL struct IDeckLinkVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLink_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLink_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLink_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLink_GetModelName(This,modelName) \ + ( (This)->lpVtbl -> GetModelName(This,modelName) ) + +#define IDeckLink_GetDisplayName(This,displayName) \ + ( (This)->lpVtbl -> GetDisplayName(This,displayName) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLink_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkConfiguration_INTERFACE_DEFINED__ +#define __IDeckLinkConfiguration_INTERFACE_DEFINED__ + +/* interface IDeckLinkConfiguration */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkConfiguration; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("1E69FCF6-4203-4936-8076-2A9F4CFD50CB") + IDeckLinkConfiguration : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetFlag( + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ BOOL value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFlag( + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ BOOL *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetInt( + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ LONGLONG value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInt( + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ LONGLONG *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetFloat( + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ double value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFloat( + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ double *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetString( + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ BSTR value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetString( + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ BSTR *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE WriteConfigurationToPreferences( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkConfigurationVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkConfiguration * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkConfiguration * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkConfiguration * This); + + HRESULT ( STDMETHODCALLTYPE *SetFlag )( + IDeckLinkConfiguration * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ BOOL value); + + HRESULT ( STDMETHODCALLTYPE *GetFlag )( + IDeckLinkConfiguration * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ BOOL *value); + + HRESULT ( STDMETHODCALLTYPE *SetInt )( + IDeckLinkConfiguration * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ LONGLONG value); + + HRESULT ( STDMETHODCALLTYPE *GetInt )( + IDeckLinkConfiguration * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ LONGLONG *value); + + HRESULT ( STDMETHODCALLTYPE *SetFloat )( + IDeckLinkConfiguration * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ double value); + + HRESULT ( STDMETHODCALLTYPE *GetFloat )( + IDeckLinkConfiguration * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ double *value); + + HRESULT ( STDMETHODCALLTYPE *SetString )( + IDeckLinkConfiguration * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ BSTR value); + + HRESULT ( STDMETHODCALLTYPE *GetString )( + IDeckLinkConfiguration * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ BSTR *value); + + HRESULT ( STDMETHODCALLTYPE *WriteConfigurationToPreferences )( + IDeckLinkConfiguration * This); + + END_INTERFACE + } IDeckLinkConfigurationVtbl; + + interface IDeckLinkConfiguration + { + CONST_VTBL struct IDeckLinkConfigurationVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkConfiguration_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkConfiguration_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkConfiguration_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkConfiguration_SetFlag(This,cfgID,value) \ + ( (This)->lpVtbl -> SetFlag(This,cfgID,value) ) + +#define IDeckLinkConfiguration_GetFlag(This,cfgID,value) \ + ( (This)->lpVtbl -> GetFlag(This,cfgID,value) ) + +#define IDeckLinkConfiguration_SetInt(This,cfgID,value) \ + ( (This)->lpVtbl -> SetInt(This,cfgID,value) ) + +#define IDeckLinkConfiguration_GetInt(This,cfgID,value) \ + ( (This)->lpVtbl -> GetInt(This,cfgID,value) ) + +#define IDeckLinkConfiguration_SetFloat(This,cfgID,value) \ + ( (This)->lpVtbl -> SetFloat(This,cfgID,value) ) + +#define IDeckLinkConfiguration_GetFloat(This,cfgID,value) \ + ( (This)->lpVtbl -> GetFloat(This,cfgID,value) ) + +#define IDeckLinkConfiguration_SetString(This,cfgID,value) \ + ( (This)->lpVtbl -> SetString(This,cfgID,value) ) + +#define IDeckLinkConfiguration_GetString(This,cfgID,value) \ + ( (This)->lpVtbl -> GetString(This,cfgID,value) ) + +#define IDeckLinkConfiguration_WriteConfigurationToPreferences(This) \ + ( (This)->lpVtbl -> WriteConfigurationToPreferences(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkConfiguration_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkDeckControlStatusCallback_INTERFACE_DEFINED__ +#define __IDeckLinkDeckControlStatusCallback_INTERFACE_DEFINED__ + +/* interface IDeckLinkDeckControlStatusCallback */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkDeckControlStatusCallback; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("53436FFB-B434-4906-BADC-AE3060FFE8EF") + IDeckLinkDeckControlStatusCallback : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE TimecodeUpdate( + /* [in] */ BMDTimecodeBCD currentTimecode) = 0; + + virtual HRESULT STDMETHODCALLTYPE VTRControlStateChanged( + /* [in] */ BMDDeckControlVTRControlState newState, + /* [in] */ BMDDeckControlError error) = 0; + + virtual HRESULT STDMETHODCALLTYPE DeckControlEventReceived( + /* [in] */ BMDDeckControlEvent event, + /* [in] */ BMDDeckControlError error) = 0; + + virtual HRESULT STDMETHODCALLTYPE DeckControlStatusChanged( + /* [in] */ BMDDeckControlStatusFlags flags, + /* [in] */ unsigned int mask) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkDeckControlStatusCallbackVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkDeckControlStatusCallback * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkDeckControlStatusCallback * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkDeckControlStatusCallback * This); + + HRESULT ( STDMETHODCALLTYPE *TimecodeUpdate )( + IDeckLinkDeckControlStatusCallback * This, + /* [in] */ BMDTimecodeBCD currentTimecode); + + HRESULT ( STDMETHODCALLTYPE *VTRControlStateChanged )( + IDeckLinkDeckControlStatusCallback * This, + /* [in] */ BMDDeckControlVTRControlState newState, + /* [in] */ BMDDeckControlError error); + + HRESULT ( STDMETHODCALLTYPE *DeckControlEventReceived )( + IDeckLinkDeckControlStatusCallback * This, + /* [in] */ BMDDeckControlEvent event, + /* [in] */ BMDDeckControlError error); + + HRESULT ( STDMETHODCALLTYPE *DeckControlStatusChanged )( + IDeckLinkDeckControlStatusCallback * This, + /* [in] */ BMDDeckControlStatusFlags flags, + /* [in] */ unsigned int mask); + + END_INTERFACE + } IDeckLinkDeckControlStatusCallbackVtbl; + + interface IDeckLinkDeckControlStatusCallback + { + CONST_VTBL struct IDeckLinkDeckControlStatusCallbackVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkDeckControlStatusCallback_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkDeckControlStatusCallback_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkDeckControlStatusCallback_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkDeckControlStatusCallback_TimecodeUpdate(This,currentTimecode) \ + ( (This)->lpVtbl -> TimecodeUpdate(This,currentTimecode) ) + +#define IDeckLinkDeckControlStatusCallback_VTRControlStateChanged(This,newState,error) \ + ( (This)->lpVtbl -> VTRControlStateChanged(This,newState,error) ) + +#define IDeckLinkDeckControlStatusCallback_DeckControlEventReceived(This,event,error) \ + ( (This)->lpVtbl -> DeckControlEventReceived(This,event,error) ) + +#define IDeckLinkDeckControlStatusCallback_DeckControlStatusChanged(This,flags,mask) \ + ( (This)->lpVtbl -> DeckControlStatusChanged(This,flags,mask) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkDeckControlStatusCallback_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkDeckControl_INTERFACE_DEFINED__ +#define __IDeckLinkDeckControl_INTERFACE_DEFINED__ + +/* interface IDeckLinkDeckControl */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkDeckControl; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("8E1C3ACE-19C7-4E00-8B92-D80431D958BE") + IDeckLinkDeckControl : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Open( + /* [in] */ BMDTimeScale timeScale, + /* [in] */ BMDTimeValue timeValue, + /* [in] */ BOOL timecodeIsDropFrame, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE Close( + /* [in] */ BOOL standbyOn) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCurrentState( + /* [out] */ BMDDeckControlMode *mode, + /* [out] */ BMDDeckControlVTRControlState *vtrControlState, + /* [out] */ BMDDeckControlStatusFlags *flags) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetStandby( + /* [in] */ BOOL standbyOn) = 0; + + virtual HRESULT STDMETHODCALLTYPE SendCommand( + /* [in] */ unsigned char *inBuffer, + /* [in] */ unsigned int inBufferSize, + /* [out] */ unsigned char *outBuffer, + /* [out] */ unsigned int *outDataSize, + /* [in] */ unsigned int outBufferSize, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE Play( + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE Stop( + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE TogglePlayStop( + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE Eject( + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE GoToTimecode( + /* [in] */ BMDTimecodeBCD timecode, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE FastForward( + /* [in] */ BOOL viewTape, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE Rewind( + /* [in] */ BOOL viewTape, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE StepForward( + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE StepBack( + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE Jog( + /* [in] */ double rate, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE Shuttle( + /* [in] */ double rate, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTimecodeString( + /* [out] */ BSTR *currentTimeCode, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTimecode( + /* [out] */ IDeckLinkTimecode **currentTimecode, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTimecodeBCD( + /* [out] */ BMDTimecodeBCD *currentTimecode, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetPreroll( + /* [in] */ unsigned int prerollSeconds) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPreroll( + /* [out] */ unsigned int *prerollSeconds) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetExportOffset( + /* [in] */ int exportOffsetFields) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetExportOffset( + /* [out] */ int *exportOffsetFields) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetManualExportOffset( + /* [out] */ int *deckManualExportOffsetFields) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetCaptureOffset( + /* [in] */ int captureOffsetFields) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCaptureOffset( + /* [out] */ int *captureOffsetFields) = 0; + + virtual HRESULT STDMETHODCALLTYPE StartExport( + /* [in] */ BMDTimecodeBCD inTimecode, + /* [in] */ BMDTimecodeBCD outTimecode, + /* [in] */ BMDDeckControlExportModeOpsFlags exportModeOps, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE StartCapture( + /* [in] */ BOOL useVITC, + /* [in] */ BMDTimecodeBCD inTimecode, + /* [in] */ BMDTimecodeBCD outTimecode, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDeviceID( + /* [out] */ unsigned short *deviceId, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE Abort( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE CrashRecordStart( + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE CrashRecordStop( + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetCallback( + /* [in] */ IDeckLinkDeckControlStatusCallback *callback) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkDeckControlVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkDeckControl * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkDeckControl * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkDeckControl * This); + + HRESULT ( STDMETHODCALLTYPE *Open )( + IDeckLinkDeckControl * This, + /* [in] */ BMDTimeScale timeScale, + /* [in] */ BMDTimeValue timeValue, + /* [in] */ BOOL timecodeIsDropFrame, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *Close )( + IDeckLinkDeckControl * This, + /* [in] */ BOOL standbyOn); + + HRESULT ( STDMETHODCALLTYPE *GetCurrentState )( + IDeckLinkDeckControl * This, + /* [out] */ BMDDeckControlMode *mode, + /* [out] */ BMDDeckControlVTRControlState *vtrControlState, + /* [out] */ BMDDeckControlStatusFlags *flags); + + HRESULT ( STDMETHODCALLTYPE *SetStandby )( + IDeckLinkDeckControl * This, + /* [in] */ BOOL standbyOn); + + HRESULT ( STDMETHODCALLTYPE *SendCommand )( + IDeckLinkDeckControl * This, + /* [in] */ unsigned char *inBuffer, + /* [in] */ unsigned int inBufferSize, + /* [out] */ unsigned char *outBuffer, + /* [out] */ unsigned int *outDataSize, + /* [in] */ unsigned int outBufferSize, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *Play )( + IDeckLinkDeckControl * This, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *Stop )( + IDeckLinkDeckControl * This, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *TogglePlayStop )( + IDeckLinkDeckControl * This, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *Eject )( + IDeckLinkDeckControl * This, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *GoToTimecode )( + IDeckLinkDeckControl * This, + /* [in] */ BMDTimecodeBCD timecode, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *FastForward )( + IDeckLinkDeckControl * This, + /* [in] */ BOOL viewTape, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *Rewind )( + IDeckLinkDeckControl * This, + /* [in] */ BOOL viewTape, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *StepForward )( + IDeckLinkDeckControl * This, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *StepBack )( + IDeckLinkDeckControl * This, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *Jog )( + IDeckLinkDeckControl * This, + /* [in] */ double rate, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *Shuttle )( + IDeckLinkDeckControl * This, + /* [in] */ double rate, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *GetTimecodeString )( + IDeckLinkDeckControl * This, + /* [out] */ BSTR *currentTimeCode, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *GetTimecode )( + IDeckLinkDeckControl * This, + /* [out] */ IDeckLinkTimecode **currentTimecode, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *GetTimecodeBCD )( + IDeckLinkDeckControl * This, + /* [out] */ BMDTimecodeBCD *currentTimecode, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *SetPreroll )( + IDeckLinkDeckControl * This, + /* [in] */ unsigned int prerollSeconds); + + HRESULT ( STDMETHODCALLTYPE *GetPreroll )( + IDeckLinkDeckControl * This, + /* [out] */ unsigned int *prerollSeconds); + + HRESULT ( STDMETHODCALLTYPE *SetExportOffset )( + IDeckLinkDeckControl * This, + /* [in] */ int exportOffsetFields); + + HRESULT ( STDMETHODCALLTYPE *GetExportOffset )( + IDeckLinkDeckControl * This, + /* [out] */ int *exportOffsetFields); + + HRESULT ( STDMETHODCALLTYPE *GetManualExportOffset )( + IDeckLinkDeckControl * This, + /* [out] */ int *deckManualExportOffsetFields); + + HRESULT ( STDMETHODCALLTYPE *SetCaptureOffset )( + IDeckLinkDeckControl * This, + /* [in] */ int captureOffsetFields); + + HRESULT ( STDMETHODCALLTYPE *GetCaptureOffset )( + IDeckLinkDeckControl * This, + /* [out] */ int *captureOffsetFields); + + HRESULT ( STDMETHODCALLTYPE *StartExport )( + IDeckLinkDeckControl * This, + /* [in] */ BMDTimecodeBCD inTimecode, + /* [in] */ BMDTimecodeBCD outTimecode, + /* [in] */ BMDDeckControlExportModeOpsFlags exportModeOps, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *StartCapture )( + IDeckLinkDeckControl * This, + /* [in] */ BOOL useVITC, + /* [in] */ BMDTimecodeBCD inTimecode, + /* [in] */ BMDTimecodeBCD outTimecode, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *GetDeviceID )( + IDeckLinkDeckControl * This, + /* [out] */ unsigned short *deviceId, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *Abort )( + IDeckLinkDeckControl * This); + + HRESULT ( STDMETHODCALLTYPE *CrashRecordStart )( + IDeckLinkDeckControl * This, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *CrashRecordStop )( + IDeckLinkDeckControl * This, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *SetCallback )( + IDeckLinkDeckControl * This, + /* [in] */ IDeckLinkDeckControlStatusCallback *callback); + + END_INTERFACE + } IDeckLinkDeckControlVtbl; + + interface IDeckLinkDeckControl + { + CONST_VTBL struct IDeckLinkDeckControlVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkDeckControl_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkDeckControl_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkDeckControl_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkDeckControl_Open(This,timeScale,timeValue,timecodeIsDropFrame,error) \ + ( (This)->lpVtbl -> Open(This,timeScale,timeValue,timecodeIsDropFrame,error) ) + +#define IDeckLinkDeckControl_Close(This,standbyOn) \ + ( (This)->lpVtbl -> Close(This,standbyOn) ) + +#define IDeckLinkDeckControl_GetCurrentState(This,mode,vtrControlState,flags) \ + ( (This)->lpVtbl -> GetCurrentState(This,mode,vtrControlState,flags) ) + +#define IDeckLinkDeckControl_SetStandby(This,standbyOn) \ + ( (This)->lpVtbl -> SetStandby(This,standbyOn) ) + +#define IDeckLinkDeckControl_SendCommand(This,inBuffer,inBufferSize,outBuffer,outDataSize,outBufferSize,error) \ + ( (This)->lpVtbl -> SendCommand(This,inBuffer,inBufferSize,outBuffer,outDataSize,outBufferSize,error) ) + +#define IDeckLinkDeckControl_Play(This,error) \ + ( (This)->lpVtbl -> Play(This,error) ) + +#define IDeckLinkDeckControl_Stop(This,error) \ + ( (This)->lpVtbl -> Stop(This,error) ) + +#define IDeckLinkDeckControl_TogglePlayStop(This,error) \ + ( (This)->lpVtbl -> TogglePlayStop(This,error) ) + +#define IDeckLinkDeckControl_Eject(This,error) \ + ( (This)->lpVtbl -> Eject(This,error) ) + +#define IDeckLinkDeckControl_GoToTimecode(This,timecode,error) \ + ( (This)->lpVtbl -> GoToTimecode(This,timecode,error) ) + +#define IDeckLinkDeckControl_FastForward(This,viewTape,error) \ + ( (This)->lpVtbl -> FastForward(This,viewTape,error) ) + +#define IDeckLinkDeckControl_Rewind(This,viewTape,error) \ + ( (This)->lpVtbl -> Rewind(This,viewTape,error) ) + +#define IDeckLinkDeckControl_StepForward(This,error) \ + ( (This)->lpVtbl -> StepForward(This,error) ) + +#define IDeckLinkDeckControl_StepBack(This,error) \ + ( (This)->lpVtbl -> StepBack(This,error) ) + +#define IDeckLinkDeckControl_Jog(This,rate,error) \ + ( (This)->lpVtbl -> Jog(This,rate,error) ) + +#define IDeckLinkDeckControl_Shuttle(This,rate,error) \ + ( (This)->lpVtbl -> Shuttle(This,rate,error) ) + +#define IDeckLinkDeckControl_GetTimecodeString(This,currentTimeCode,error) \ + ( (This)->lpVtbl -> GetTimecodeString(This,currentTimeCode,error) ) + +#define IDeckLinkDeckControl_GetTimecode(This,currentTimecode,error) \ + ( (This)->lpVtbl -> GetTimecode(This,currentTimecode,error) ) + +#define IDeckLinkDeckControl_GetTimecodeBCD(This,currentTimecode,error) \ + ( (This)->lpVtbl -> GetTimecodeBCD(This,currentTimecode,error) ) + +#define IDeckLinkDeckControl_SetPreroll(This,prerollSeconds) \ + ( (This)->lpVtbl -> SetPreroll(This,prerollSeconds) ) + +#define IDeckLinkDeckControl_GetPreroll(This,prerollSeconds) \ + ( (This)->lpVtbl -> GetPreroll(This,prerollSeconds) ) + +#define IDeckLinkDeckControl_SetExportOffset(This,exportOffsetFields) \ + ( (This)->lpVtbl -> SetExportOffset(This,exportOffsetFields) ) + +#define IDeckLinkDeckControl_GetExportOffset(This,exportOffsetFields) \ + ( (This)->lpVtbl -> GetExportOffset(This,exportOffsetFields) ) + +#define IDeckLinkDeckControl_GetManualExportOffset(This,deckManualExportOffsetFields) \ + ( (This)->lpVtbl -> GetManualExportOffset(This,deckManualExportOffsetFields) ) + +#define IDeckLinkDeckControl_SetCaptureOffset(This,captureOffsetFields) \ + ( (This)->lpVtbl -> SetCaptureOffset(This,captureOffsetFields) ) + +#define IDeckLinkDeckControl_GetCaptureOffset(This,captureOffsetFields) \ + ( (This)->lpVtbl -> GetCaptureOffset(This,captureOffsetFields) ) + +#define IDeckLinkDeckControl_StartExport(This,inTimecode,outTimecode,exportModeOps,error) \ + ( (This)->lpVtbl -> StartExport(This,inTimecode,outTimecode,exportModeOps,error) ) + +#define IDeckLinkDeckControl_StartCapture(This,useVITC,inTimecode,outTimecode,error) \ + ( (This)->lpVtbl -> StartCapture(This,useVITC,inTimecode,outTimecode,error) ) + +#define IDeckLinkDeckControl_GetDeviceID(This,deviceId,error) \ + ( (This)->lpVtbl -> GetDeviceID(This,deviceId,error) ) + +#define IDeckLinkDeckControl_Abort(This) \ + ( (This)->lpVtbl -> Abort(This) ) + +#define IDeckLinkDeckControl_CrashRecordStart(This,error) \ + ( (This)->lpVtbl -> CrashRecordStart(This,error) ) + +#define IDeckLinkDeckControl_CrashRecordStop(This,error) \ + ( (This)->lpVtbl -> CrashRecordStop(This,error) ) + +#define IDeckLinkDeckControl_SetCallback(This,callback) \ + ( (This)->lpVtbl -> SetCallback(This,callback) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkDeckControl_INTERFACE_DEFINED__ */ + + +#ifndef __IBMDStreamingDeviceNotificationCallback_INTERFACE_DEFINED__ +#define __IBMDStreamingDeviceNotificationCallback_INTERFACE_DEFINED__ + +/* interface IBMDStreamingDeviceNotificationCallback */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IBMDStreamingDeviceNotificationCallback; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("F9531D64-3305-4B29-A387-7F74BB0D0E84") + IBMDStreamingDeviceNotificationCallback : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE StreamingDeviceArrived( + /* [in] */ IDeckLink *device) = 0; + + virtual HRESULT STDMETHODCALLTYPE StreamingDeviceRemoved( + /* [in] */ IDeckLink *device) = 0; + + virtual HRESULT STDMETHODCALLTYPE StreamingDeviceModeChanged( + /* [in] */ IDeckLink *device, + /* [in] */ BMDStreamingDeviceMode mode) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IBMDStreamingDeviceNotificationCallbackVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IBMDStreamingDeviceNotificationCallback * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IBMDStreamingDeviceNotificationCallback * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IBMDStreamingDeviceNotificationCallback * This); + + HRESULT ( STDMETHODCALLTYPE *StreamingDeviceArrived )( + IBMDStreamingDeviceNotificationCallback * This, + /* [in] */ IDeckLink *device); + + HRESULT ( STDMETHODCALLTYPE *StreamingDeviceRemoved )( + IBMDStreamingDeviceNotificationCallback * This, + /* [in] */ IDeckLink *device); + + HRESULT ( STDMETHODCALLTYPE *StreamingDeviceModeChanged )( + IBMDStreamingDeviceNotificationCallback * This, + /* [in] */ IDeckLink *device, + /* [in] */ BMDStreamingDeviceMode mode); + + END_INTERFACE + } IBMDStreamingDeviceNotificationCallbackVtbl; + + interface IBMDStreamingDeviceNotificationCallback + { + CONST_VTBL struct IBMDStreamingDeviceNotificationCallbackVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IBMDStreamingDeviceNotificationCallback_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IBMDStreamingDeviceNotificationCallback_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IBMDStreamingDeviceNotificationCallback_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IBMDStreamingDeviceNotificationCallback_StreamingDeviceArrived(This,device) \ + ( (This)->lpVtbl -> StreamingDeviceArrived(This,device) ) + +#define IBMDStreamingDeviceNotificationCallback_StreamingDeviceRemoved(This,device) \ + ( (This)->lpVtbl -> StreamingDeviceRemoved(This,device) ) + +#define IBMDStreamingDeviceNotificationCallback_StreamingDeviceModeChanged(This,device,mode) \ + ( (This)->lpVtbl -> StreamingDeviceModeChanged(This,device,mode) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IBMDStreamingDeviceNotificationCallback_INTERFACE_DEFINED__ */ + + +#ifndef __IBMDStreamingH264InputCallback_INTERFACE_DEFINED__ +#define __IBMDStreamingH264InputCallback_INTERFACE_DEFINED__ + +/* interface IBMDStreamingH264InputCallback */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IBMDStreamingH264InputCallback; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("823C475F-55AE-46F9-890C-537CC5CEDCCA") + IBMDStreamingH264InputCallback : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE H264NALPacketArrived( + /* [in] */ IBMDStreamingH264NALPacket *nalPacket) = 0; + + virtual HRESULT STDMETHODCALLTYPE H264AudioPacketArrived( + /* [in] */ IBMDStreamingAudioPacket *audioPacket) = 0; + + virtual HRESULT STDMETHODCALLTYPE MPEG2TSPacketArrived( + /* [in] */ IBMDStreamingMPEG2TSPacket *tsPacket) = 0; + + virtual HRESULT STDMETHODCALLTYPE H264VideoInputConnectorScanningChanged( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE H264VideoInputConnectorChanged( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE H264VideoInputModeChanged( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IBMDStreamingH264InputCallbackVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IBMDStreamingH264InputCallback * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IBMDStreamingH264InputCallback * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IBMDStreamingH264InputCallback * This); + + HRESULT ( STDMETHODCALLTYPE *H264NALPacketArrived )( + IBMDStreamingH264InputCallback * This, + /* [in] */ IBMDStreamingH264NALPacket *nalPacket); + + HRESULT ( STDMETHODCALLTYPE *H264AudioPacketArrived )( + IBMDStreamingH264InputCallback * This, + /* [in] */ IBMDStreamingAudioPacket *audioPacket); + + HRESULT ( STDMETHODCALLTYPE *MPEG2TSPacketArrived )( + IBMDStreamingH264InputCallback * This, + /* [in] */ IBMDStreamingMPEG2TSPacket *tsPacket); + + HRESULT ( STDMETHODCALLTYPE *H264VideoInputConnectorScanningChanged )( + IBMDStreamingH264InputCallback * This); + + HRESULT ( STDMETHODCALLTYPE *H264VideoInputConnectorChanged )( + IBMDStreamingH264InputCallback * This); + + HRESULT ( STDMETHODCALLTYPE *H264VideoInputModeChanged )( + IBMDStreamingH264InputCallback * This); + + END_INTERFACE + } IBMDStreamingH264InputCallbackVtbl; + + interface IBMDStreamingH264InputCallback + { + CONST_VTBL struct IBMDStreamingH264InputCallbackVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IBMDStreamingH264InputCallback_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IBMDStreamingH264InputCallback_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IBMDStreamingH264InputCallback_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IBMDStreamingH264InputCallback_H264NALPacketArrived(This,nalPacket) \ + ( (This)->lpVtbl -> H264NALPacketArrived(This,nalPacket) ) + +#define IBMDStreamingH264InputCallback_H264AudioPacketArrived(This,audioPacket) \ + ( (This)->lpVtbl -> H264AudioPacketArrived(This,audioPacket) ) + +#define IBMDStreamingH264InputCallback_MPEG2TSPacketArrived(This,tsPacket) \ + ( (This)->lpVtbl -> MPEG2TSPacketArrived(This,tsPacket) ) + +#define IBMDStreamingH264InputCallback_H264VideoInputConnectorScanningChanged(This) \ + ( (This)->lpVtbl -> H264VideoInputConnectorScanningChanged(This) ) + +#define IBMDStreamingH264InputCallback_H264VideoInputConnectorChanged(This) \ + ( (This)->lpVtbl -> H264VideoInputConnectorChanged(This) ) + +#define IBMDStreamingH264InputCallback_H264VideoInputModeChanged(This) \ + ( (This)->lpVtbl -> H264VideoInputModeChanged(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IBMDStreamingH264InputCallback_INTERFACE_DEFINED__ */ + + +#ifndef __IBMDStreamingDiscovery_INTERFACE_DEFINED__ +#define __IBMDStreamingDiscovery_INTERFACE_DEFINED__ + +/* interface IBMDStreamingDiscovery */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IBMDStreamingDiscovery; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("2C837444-F989-4D87-901A-47C8A36D096D") + IBMDStreamingDiscovery : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE InstallDeviceNotifications( + /* [in] */ IBMDStreamingDeviceNotificationCallback *theCallback) = 0; + + virtual HRESULT STDMETHODCALLTYPE UninstallDeviceNotifications( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IBMDStreamingDiscoveryVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IBMDStreamingDiscovery * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IBMDStreamingDiscovery * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IBMDStreamingDiscovery * This); + + HRESULT ( STDMETHODCALLTYPE *InstallDeviceNotifications )( + IBMDStreamingDiscovery * This, + /* [in] */ IBMDStreamingDeviceNotificationCallback *theCallback); + + HRESULT ( STDMETHODCALLTYPE *UninstallDeviceNotifications )( + IBMDStreamingDiscovery * This); + + END_INTERFACE + } IBMDStreamingDiscoveryVtbl; + + interface IBMDStreamingDiscovery + { + CONST_VTBL struct IBMDStreamingDiscoveryVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IBMDStreamingDiscovery_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IBMDStreamingDiscovery_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IBMDStreamingDiscovery_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IBMDStreamingDiscovery_InstallDeviceNotifications(This,theCallback) \ + ( (This)->lpVtbl -> InstallDeviceNotifications(This,theCallback) ) + +#define IBMDStreamingDiscovery_UninstallDeviceNotifications(This) \ + ( (This)->lpVtbl -> UninstallDeviceNotifications(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IBMDStreamingDiscovery_INTERFACE_DEFINED__ */ + + +#ifndef __IBMDStreamingVideoEncodingMode_INTERFACE_DEFINED__ +#define __IBMDStreamingVideoEncodingMode_INTERFACE_DEFINED__ + +/* interface IBMDStreamingVideoEncodingMode */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IBMDStreamingVideoEncodingMode; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("1AB8035B-CD13-458D-B6DF-5E8F7C2141D9") + IBMDStreamingVideoEncodingMode : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetName( + /* [out] */ BSTR *name) = 0; + + virtual unsigned int STDMETHODCALLTYPE GetPresetID( void) = 0; + + virtual unsigned int STDMETHODCALLTYPE GetSourcePositionX( void) = 0; + + virtual unsigned int STDMETHODCALLTYPE GetSourcePositionY( void) = 0; + + virtual unsigned int STDMETHODCALLTYPE GetSourceWidth( void) = 0; + + virtual unsigned int STDMETHODCALLTYPE GetSourceHeight( void) = 0; + + virtual unsigned int STDMETHODCALLTYPE GetDestWidth( void) = 0; + + virtual unsigned int STDMETHODCALLTYPE GetDestHeight( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFlag( + /* [in] */ BMDStreamingEncodingModePropertyID cfgID, + /* [out] */ BOOL *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInt( + /* [in] */ BMDStreamingEncodingModePropertyID cfgID, + /* [out] */ LONGLONG *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFloat( + /* [in] */ BMDStreamingEncodingModePropertyID cfgID, + /* [out] */ double *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetString( + /* [in] */ BMDStreamingEncodingModePropertyID cfgID, + /* [out] */ BSTR *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateMutableVideoEncodingMode( + /* [out] */ IBMDStreamingMutableVideoEncodingMode **newEncodingMode) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IBMDStreamingVideoEncodingModeVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IBMDStreamingVideoEncodingMode * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IBMDStreamingVideoEncodingMode * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IBMDStreamingVideoEncodingMode * This); + + HRESULT ( STDMETHODCALLTYPE *GetName )( + IBMDStreamingVideoEncodingMode * This, + /* [out] */ BSTR *name); + + unsigned int ( STDMETHODCALLTYPE *GetPresetID )( + IBMDStreamingVideoEncodingMode * This); + + unsigned int ( STDMETHODCALLTYPE *GetSourcePositionX )( + IBMDStreamingVideoEncodingMode * This); + + unsigned int ( STDMETHODCALLTYPE *GetSourcePositionY )( + IBMDStreamingVideoEncodingMode * This); + + unsigned int ( STDMETHODCALLTYPE *GetSourceWidth )( + IBMDStreamingVideoEncodingMode * This); + + unsigned int ( STDMETHODCALLTYPE *GetSourceHeight )( + IBMDStreamingVideoEncodingMode * This); + + unsigned int ( STDMETHODCALLTYPE *GetDestWidth )( + IBMDStreamingVideoEncodingMode * This); + + unsigned int ( STDMETHODCALLTYPE *GetDestHeight )( + IBMDStreamingVideoEncodingMode * This); + + HRESULT ( STDMETHODCALLTYPE *GetFlag )( + IBMDStreamingVideoEncodingMode * This, + /* [in] */ BMDStreamingEncodingModePropertyID cfgID, + /* [out] */ BOOL *value); + + HRESULT ( STDMETHODCALLTYPE *GetInt )( + IBMDStreamingVideoEncodingMode * This, + /* [in] */ BMDStreamingEncodingModePropertyID cfgID, + /* [out] */ LONGLONG *value); + + HRESULT ( STDMETHODCALLTYPE *GetFloat )( + IBMDStreamingVideoEncodingMode * This, + /* [in] */ BMDStreamingEncodingModePropertyID cfgID, + /* [out] */ double *value); + + HRESULT ( STDMETHODCALLTYPE *GetString )( + IBMDStreamingVideoEncodingMode * This, + /* [in] */ BMDStreamingEncodingModePropertyID cfgID, + /* [out] */ BSTR *value); + + HRESULT ( STDMETHODCALLTYPE *CreateMutableVideoEncodingMode )( + IBMDStreamingVideoEncodingMode * This, + /* [out] */ IBMDStreamingMutableVideoEncodingMode **newEncodingMode); + + END_INTERFACE + } IBMDStreamingVideoEncodingModeVtbl; + + interface IBMDStreamingVideoEncodingMode + { + CONST_VTBL struct IBMDStreamingVideoEncodingModeVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IBMDStreamingVideoEncodingMode_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IBMDStreamingVideoEncodingMode_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IBMDStreamingVideoEncodingMode_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IBMDStreamingVideoEncodingMode_GetName(This,name) \ + ( (This)->lpVtbl -> GetName(This,name) ) + +#define IBMDStreamingVideoEncodingMode_GetPresetID(This) \ + ( (This)->lpVtbl -> GetPresetID(This) ) + +#define IBMDStreamingVideoEncodingMode_GetSourcePositionX(This) \ + ( (This)->lpVtbl -> GetSourcePositionX(This) ) + +#define IBMDStreamingVideoEncodingMode_GetSourcePositionY(This) \ + ( (This)->lpVtbl -> GetSourcePositionY(This) ) + +#define IBMDStreamingVideoEncodingMode_GetSourceWidth(This) \ + ( (This)->lpVtbl -> GetSourceWidth(This) ) + +#define IBMDStreamingVideoEncodingMode_GetSourceHeight(This) \ + ( (This)->lpVtbl -> GetSourceHeight(This) ) + +#define IBMDStreamingVideoEncodingMode_GetDestWidth(This) \ + ( (This)->lpVtbl -> GetDestWidth(This) ) + +#define IBMDStreamingVideoEncodingMode_GetDestHeight(This) \ + ( (This)->lpVtbl -> GetDestHeight(This) ) + +#define IBMDStreamingVideoEncodingMode_GetFlag(This,cfgID,value) \ + ( (This)->lpVtbl -> GetFlag(This,cfgID,value) ) + +#define IBMDStreamingVideoEncodingMode_GetInt(This,cfgID,value) \ + ( (This)->lpVtbl -> GetInt(This,cfgID,value) ) + +#define IBMDStreamingVideoEncodingMode_GetFloat(This,cfgID,value) \ + ( (This)->lpVtbl -> GetFloat(This,cfgID,value) ) + +#define IBMDStreamingVideoEncodingMode_GetString(This,cfgID,value) \ + ( (This)->lpVtbl -> GetString(This,cfgID,value) ) + +#define IBMDStreamingVideoEncodingMode_CreateMutableVideoEncodingMode(This,newEncodingMode) \ + ( (This)->lpVtbl -> CreateMutableVideoEncodingMode(This,newEncodingMode) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IBMDStreamingVideoEncodingMode_INTERFACE_DEFINED__ */ + + +#ifndef __IBMDStreamingMutableVideoEncodingMode_INTERFACE_DEFINED__ +#define __IBMDStreamingMutableVideoEncodingMode_INTERFACE_DEFINED__ + +/* interface IBMDStreamingMutableVideoEncodingMode */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IBMDStreamingMutableVideoEncodingMode; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("19BF7D90-1E0A-400D-B2C6-FFC4E78AD49D") + IBMDStreamingMutableVideoEncodingMode : public IBMDStreamingVideoEncodingMode + { + public: + virtual HRESULT STDMETHODCALLTYPE SetSourceRect( + /* [in] */ unsigned int posX, + /* [in] */ unsigned int posY, + /* [in] */ unsigned int width, + /* [in] */ unsigned int height) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetDestSize( + /* [in] */ unsigned int width, + /* [in] */ unsigned int height) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetFlag( + /* [in] */ BMDStreamingEncodingModePropertyID cfgID, + /* [in] */ BOOL value) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetInt( + /* [in] */ BMDStreamingEncodingModePropertyID cfgID, + /* [in] */ LONGLONG value) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetFloat( + /* [in] */ BMDStreamingEncodingModePropertyID cfgID, + /* [in] */ double value) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetString( + /* [in] */ BMDStreamingEncodingModePropertyID cfgID, + /* [in] */ BSTR value) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IBMDStreamingMutableVideoEncodingModeVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IBMDStreamingMutableVideoEncodingMode * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IBMDStreamingMutableVideoEncodingMode * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IBMDStreamingMutableVideoEncodingMode * This); + + HRESULT ( STDMETHODCALLTYPE *GetName )( + IBMDStreamingMutableVideoEncodingMode * This, + /* [out] */ BSTR *name); + + unsigned int ( STDMETHODCALLTYPE *GetPresetID )( + IBMDStreamingMutableVideoEncodingMode * This); + + unsigned int ( STDMETHODCALLTYPE *GetSourcePositionX )( + IBMDStreamingMutableVideoEncodingMode * This); + + unsigned int ( STDMETHODCALLTYPE *GetSourcePositionY )( + IBMDStreamingMutableVideoEncodingMode * This); + + unsigned int ( STDMETHODCALLTYPE *GetSourceWidth )( + IBMDStreamingMutableVideoEncodingMode * This); + + unsigned int ( STDMETHODCALLTYPE *GetSourceHeight )( + IBMDStreamingMutableVideoEncodingMode * This); + + unsigned int ( STDMETHODCALLTYPE *GetDestWidth )( + IBMDStreamingMutableVideoEncodingMode * This); + + unsigned int ( STDMETHODCALLTYPE *GetDestHeight )( + IBMDStreamingMutableVideoEncodingMode * This); + + HRESULT ( STDMETHODCALLTYPE *GetFlag )( + IBMDStreamingMutableVideoEncodingMode * This, + /* [in] */ BMDStreamingEncodingModePropertyID cfgID, + /* [out] */ BOOL *value); + + HRESULT ( STDMETHODCALLTYPE *GetInt )( + IBMDStreamingMutableVideoEncodingMode * This, + /* [in] */ BMDStreamingEncodingModePropertyID cfgID, + /* [out] */ LONGLONG *value); + + HRESULT ( STDMETHODCALLTYPE *GetFloat )( + IBMDStreamingMutableVideoEncodingMode * This, + /* [in] */ BMDStreamingEncodingModePropertyID cfgID, + /* [out] */ double *value); + + HRESULT ( STDMETHODCALLTYPE *GetString )( + IBMDStreamingMutableVideoEncodingMode * This, + /* [in] */ BMDStreamingEncodingModePropertyID cfgID, + /* [out] */ BSTR *value); + + HRESULT ( STDMETHODCALLTYPE *CreateMutableVideoEncodingMode )( + IBMDStreamingMutableVideoEncodingMode * This, + /* [out] */ IBMDStreamingMutableVideoEncodingMode **newEncodingMode); + + HRESULT ( STDMETHODCALLTYPE *SetSourceRect )( + IBMDStreamingMutableVideoEncodingMode * This, + /* [in] */ unsigned int posX, + /* [in] */ unsigned int posY, + /* [in] */ unsigned int width, + /* [in] */ unsigned int height); + + HRESULT ( STDMETHODCALLTYPE *SetDestSize )( + IBMDStreamingMutableVideoEncodingMode * This, + /* [in] */ unsigned int width, + /* [in] */ unsigned int height); + + HRESULT ( STDMETHODCALLTYPE *SetFlag )( + IBMDStreamingMutableVideoEncodingMode * This, + /* [in] */ BMDStreamingEncodingModePropertyID cfgID, + /* [in] */ BOOL value); + + HRESULT ( STDMETHODCALLTYPE *SetInt )( + IBMDStreamingMutableVideoEncodingMode * This, + /* [in] */ BMDStreamingEncodingModePropertyID cfgID, + /* [in] */ LONGLONG value); + + HRESULT ( STDMETHODCALLTYPE *SetFloat )( + IBMDStreamingMutableVideoEncodingMode * This, + /* [in] */ BMDStreamingEncodingModePropertyID cfgID, + /* [in] */ double value); + + HRESULT ( STDMETHODCALLTYPE *SetString )( + IBMDStreamingMutableVideoEncodingMode * This, + /* [in] */ BMDStreamingEncodingModePropertyID cfgID, + /* [in] */ BSTR value); + + END_INTERFACE + } IBMDStreamingMutableVideoEncodingModeVtbl; + + interface IBMDStreamingMutableVideoEncodingMode + { + CONST_VTBL struct IBMDStreamingMutableVideoEncodingModeVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IBMDStreamingMutableVideoEncodingMode_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IBMDStreamingMutableVideoEncodingMode_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IBMDStreamingMutableVideoEncodingMode_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IBMDStreamingMutableVideoEncodingMode_GetName(This,name) \ + ( (This)->lpVtbl -> GetName(This,name) ) + +#define IBMDStreamingMutableVideoEncodingMode_GetPresetID(This) \ + ( (This)->lpVtbl -> GetPresetID(This) ) + +#define IBMDStreamingMutableVideoEncodingMode_GetSourcePositionX(This) \ + ( (This)->lpVtbl -> GetSourcePositionX(This) ) + +#define IBMDStreamingMutableVideoEncodingMode_GetSourcePositionY(This) \ + ( (This)->lpVtbl -> GetSourcePositionY(This) ) + +#define IBMDStreamingMutableVideoEncodingMode_GetSourceWidth(This) \ + ( (This)->lpVtbl -> GetSourceWidth(This) ) + +#define IBMDStreamingMutableVideoEncodingMode_GetSourceHeight(This) \ + ( (This)->lpVtbl -> GetSourceHeight(This) ) + +#define IBMDStreamingMutableVideoEncodingMode_GetDestWidth(This) \ + ( (This)->lpVtbl -> GetDestWidth(This) ) + +#define IBMDStreamingMutableVideoEncodingMode_GetDestHeight(This) \ + ( (This)->lpVtbl -> GetDestHeight(This) ) + +#define IBMDStreamingMutableVideoEncodingMode_GetFlag(This,cfgID,value) \ + ( (This)->lpVtbl -> GetFlag(This,cfgID,value) ) + +#define IBMDStreamingMutableVideoEncodingMode_GetInt(This,cfgID,value) \ + ( (This)->lpVtbl -> GetInt(This,cfgID,value) ) + +#define IBMDStreamingMutableVideoEncodingMode_GetFloat(This,cfgID,value) \ + ( (This)->lpVtbl -> GetFloat(This,cfgID,value) ) + +#define IBMDStreamingMutableVideoEncodingMode_GetString(This,cfgID,value) \ + ( (This)->lpVtbl -> GetString(This,cfgID,value) ) + +#define IBMDStreamingMutableVideoEncodingMode_CreateMutableVideoEncodingMode(This,newEncodingMode) \ + ( (This)->lpVtbl -> CreateMutableVideoEncodingMode(This,newEncodingMode) ) + + +#define IBMDStreamingMutableVideoEncodingMode_SetSourceRect(This,posX,posY,width,height) \ + ( (This)->lpVtbl -> SetSourceRect(This,posX,posY,width,height) ) + +#define IBMDStreamingMutableVideoEncodingMode_SetDestSize(This,width,height) \ + ( (This)->lpVtbl -> SetDestSize(This,width,height) ) + +#define IBMDStreamingMutableVideoEncodingMode_SetFlag(This,cfgID,value) \ + ( (This)->lpVtbl -> SetFlag(This,cfgID,value) ) + +#define IBMDStreamingMutableVideoEncodingMode_SetInt(This,cfgID,value) \ + ( (This)->lpVtbl -> SetInt(This,cfgID,value) ) + +#define IBMDStreamingMutableVideoEncodingMode_SetFloat(This,cfgID,value) \ + ( (This)->lpVtbl -> SetFloat(This,cfgID,value) ) + +#define IBMDStreamingMutableVideoEncodingMode_SetString(This,cfgID,value) \ + ( (This)->lpVtbl -> SetString(This,cfgID,value) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IBMDStreamingMutableVideoEncodingMode_INTERFACE_DEFINED__ */ + + +#ifndef __IBMDStreamingVideoEncodingModePresetIterator_INTERFACE_DEFINED__ +#define __IBMDStreamingVideoEncodingModePresetIterator_INTERFACE_DEFINED__ + +/* interface IBMDStreamingVideoEncodingModePresetIterator */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IBMDStreamingVideoEncodingModePresetIterator; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("7AC731A3-C950-4AD0-804A-8377AA51C6C4") + IBMDStreamingVideoEncodingModePresetIterator : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Next( + /* [out] */ IBMDStreamingVideoEncodingMode **videoEncodingMode) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IBMDStreamingVideoEncodingModePresetIteratorVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IBMDStreamingVideoEncodingModePresetIterator * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IBMDStreamingVideoEncodingModePresetIterator * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IBMDStreamingVideoEncodingModePresetIterator * This); + + HRESULT ( STDMETHODCALLTYPE *Next )( + IBMDStreamingVideoEncodingModePresetIterator * This, + /* [out] */ IBMDStreamingVideoEncodingMode **videoEncodingMode); + + END_INTERFACE + } IBMDStreamingVideoEncodingModePresetIteratorVtbl; + + interface IBMDStreamingVideoEncodingModePresetIterator + { + CONST_VTBL struct IBMDStreamingVideoEncodingModePresetIteratorVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IBMDStreamingVideoEncodingModePresetIterator_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IBMDStreamingVideoEncodingModePresetIterator_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IBMDStreamingVideoEncodingModePresetIterator_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IBMDStreamingVideoEncodingModePresetIterator_Next(This,videoEncodingMode) \ + ( (This)->lpVtbl -> Next(This,videoEncodingMode) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IBMDStreamingVideoEncodingModePresetIterator_INTERFACE_DEFINED__ */ + + +#ifndef __IBMDStreamingDeviceInput_INTERFACE_DEFINED__ +#define __IBMDStreamingDeviceInput_INTERFACE_DEFINED__ + +/* interface IBMDStreamingDeviceInput */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IBMDStreamingDeviceInput; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("24B6B6EC-1727-44BB-9818-34FF086ACF98") + IBMDStreamingDeviceInput : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE DoesSupportVideoInputMode( + /* [in] */ BMDDisplayMode inputMode, + /* [out] */ BOOL *result) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetVideoInputModeIterator( + /* [out] */ IDeckLinkDisplayModeIterator **iterator) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetVideoInputMode( + /* [in] */ BMDDisplayMode inputMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCurrentDetectedVideoInputMode( + /* [out] */ BMDDisplayMode *detectedMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetVideoEncodingMode( + /* [out] */ IBMDStreamingVideoEncodingMode **encodingMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetVideoEncodingModePresetIterator( + /* [in] */ BMDDisplayMode inputMode, + /* [out] */ IBMDStreamingVideoEncodingModePresetIterator **iterator) = 0; + + virtual HRESULT STDMETHODCALLTYPE DoesSupportVideoEncodingMode( + /* [in] */ BMDDisplayMode inputMode, + /* [in] */ IBMDStreamingVideoEncodingMode *encodingMode, + /* [out] */ BMDStreamingEncodingSupport *result, + /* [out] */ IBMDStreamingVideoEncodingMode **changedEncodingMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetVideoEncodingMode( + /* [in] */ IBMDStreamingVideoEncodingMode *encodingMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE StartCapture( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE StopCapture( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetCallback( + /* [in] */ IUnknown *theCallback) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IBMDStreamingDeviceInputVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IBMDStreamingDeviceInput * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IBMDStreamingDeviceInput * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IBMDStreamingDeviceInput * This); + + HRESULT ( STDMETHODCALLTYPE *DoesSupportVideoInputMode )( + IBMDStreamingDeviceInput * This, + /* [in] */ BMDDisplayMode inputMode, + /* [out] */ BOOL *result); + + HRESULT ( STDMETHODCALLTYPE *GetVideoInputModeIterator )( + IBMDStreamingDeviceInput * This, + /* [out] */ IDeckLinkDisplayModeIterator **iterator); + + HRESULT ( STDMETHODCALLTYPE *SetVideoInputMode )( + IBMDStreamingDeviceInput * This, + /* [in] */ BMDDisplayMode inputMode); + + HRESULT ( STDMETHODCALLTYPE *GetCurrentDetectedVideoInputMode )( + IBMDStreamingDeviceInput * This, + /* [out] */ BMDDisplayMode *detectedMode); + + HRESULT ( STDMETHODCALLTYPE *GetVideoEncodingMode )( + IBMDStreamingDeviceInput * This, + /* [out] */ IBMDStreamingVideoEncodingMode **encodingMode); + + HRESULT ( STDMETHODCALLTYPE *GetVideoEncodingModePresetIterator )( + IBMDStreamingDeviceInput * This, + /* [in] */ BMDDisplayMode inputMode, + /* [out] */ IBMDStreamingVideoEncodingModePresetIterator **iterator); + + HRESULT ( STDMETHODCALLTYPE *DoesSupportVideoEncodingMode )( + IBMDStreamingDeviceInput * This, + /* [in] */ BMDDisplayMode inputMode, + /* [in] */ IBMDStreamingVideoEncodingMode *encodingMode, + /* [out] */ BMDStreamingEncodingSupport *result, + /* [out] */ IBMDStreamingVideoEncodingMode **changedEncodingMode); + + HRESULT ( STDMETHODCALLTYPE *SetVideoEncodingMode )( + IBMDStreamingDeviceInput * This, + /* [in] */ IBMDStreamingVideoEncodingMode *encodingMode); + + HRESULT ( STDMETHODCALLTYPE *StartCapture )( + IBMDStreamingDeviceInput * This); + + HRESULT ( STDMETHODCALLTYPE *StopCapture )( + IBMDStreamingDeviceInput * This); + + HRESULT ( STDMETHODCALLTYPE *SetCallback )( + IBMDStreamingDeviceInput * This, + /* [in] */ IUnknown *theCallback); + + END_INTERFACE + } IBMDStreamingDeviceInputVtbl; + + interface IBMDStreamingDeviceInput + { + CONST_VTBL struct IBMDStreamingDeviceInputVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IBMDStreamingDeviceInput_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IBMDStreamingDeviceInput_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IBMDStreamingDeviceInput_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IBMDStreamingDeviceInput_DoesSupportVideoInputMode(This,inputMode,result) \ + ( (This)->lpVtbl -> DoesSupportVideoInputMode(This,inputMode,result) ) + +#define IBMDStreamingDeviceInput_GetVideoInputModeIterator(This,iterator) \ + ( (This)->lpVtbl -> GetVideoInputModeIterator(This,iterator) ) + +#define IBMDStreamingDeviceInput_SetVideoInputMode(This,inputMode) \ + ( (This)->lpVtbl -> SetVideoInputMode(This,inputMode) ) + +#define IBMDStreamingDeviceInput_GetCurrentDetectedVideoInputMode(This,detectedMode) \ + ( (This)->lpVtbl -> GetCurrentDetectedVideoInputMode(This,detectedMode) ) + +#define IBMDStreamingDeviceInput_GetVideoEncodingMode(This,encodingMode) \ + ( (This)->lpVtbl -> GetVideoEncodingMode(This,encodingMode) ) + +#define IBMDStreamingDeviceInput_GetVideoEncodingModePresetIterator(This,inputMode,iterator) \ + ( (This)->lpVtbl -> GetVideoEncodingModePresetIterator(This,inputMode,iterator) ) + +#define IBMDStreamingDeviceInput_DoesSupportVideoEncodingMode(This,inputMode,encodingMode,result,changedEncodingMode) \ + ( (This)->lpVtbl -> DoesSupportVideoEncodingMode(This,inputMode,encodingMode,result,changedEncodingMode) ) + +#define IBMDStreamingDeviceInput_SetVideoEncodingMode(This,encodingMode) \ + ( (This)->lpVtbl -> SetVideoEncodingMode(This,encodingMode) ) + +#define IBMDStreamingDeviceInput_StartCapture(This) \ + ( (This)->lpVtbl -> StartCapture(This) ) + +#define IBMDStreamingDeviceInput_StopCapture(This) \ + ( (This)->lpVtbl -> StopCapture(This) ) + +#define IBMDStreamingDeviceInput_SetCallback(This,theCallback) \ + ( (This)->lpVtbl -> SetCallback(This,theCallback) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IBMDStreamingDeviceInput_INTERFACE_DEFINED__ */ + + +#ifndef __IBMDStreamingH264NALPacket_INTERFACE_DEFINED__ +#define __IBMDStreamingH264NALPacket_INTERFACE_DEFINED__ + +/* interface IBMDStreamingH264NALPacket */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IBMDStreamingH264NALPacket; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("E260E955-14BE-4395-9775-9F02CC0A9D89") + IBMDStreamingH264NALPacket : public IUnknown + { + public: + virtual long STDMETHODCALLTYPE GetPayloadSize( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBytes( + /* [out] */ void **buffer) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBytesWithSizePrefix( + /* [out] */ void **buffer) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayTime( + /* [in] */ ULONGLONG requestedTimeScale, + /* [out] */ ULONGLONG *displayTime) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPacketIndex( + /* [out] */ unsigned int *packetIndex) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IBMDStreamingH264NALPacketVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IBMDStreamingH264NALPacket * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IBMDStreamingH264NALPacket * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IBMDStreamingH264NALPacket * This); + + long ( STDMETHODCALLTYPE *GetPayloadSize )( + IBMDStreamingH264NALPacket * This); + + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IBMDStreamingH264NALPacket * This, + /* [out] */ void **buffer); + + HRESULT ( STDMETHODCALLTYPE *GetBytesWithSizePrefix )( + IBMDStreamingH264NALPacket * This, + /* [out] */ void **buffer); + + HRESULT ( STDMETHODCALLTYPE *GetDisplayTime )( + IBMDStreamingH264NALPacket * This, + /* [in] */ ULONGLONG requestedTimeScale, + /* [out] */ ULONGLONG *displayTime); + + HRESULT ( STDMETHODCALLTYPE *GetPacketIndex )( + IBMDStreamingH264NALPacket * This, + /* [out] */ unsigned int *packetIndex); + + END_INTERFACE + } IBMDStreamingH264NALPacketVtbl; + + interface IBMDStreamingH264NALPacket + { + CONST_VTBL struct IBMDStreamingH264NALPacketVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IBMDStreamingH264NALPacket_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IBMDStreamingH264NALPacket_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IBMDStreamingH264NALPacket_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IBMDStreamingH264NALPacket_GetPayloadSize(This) \ + ( (This)->lpVtbl -> GetPayloadSize(This) ) + +#define IBMDStreamingH264NALPacket_GetBytes(This,buffer) \ + ( (This)->lpVtbl -> GetBytes(This,buffer) ) + +#define IBMDStreamingH264NALPacket_GetBytesWithSizePrefix(This,buffer) \ + ( (This)->lpVtbl -> GetBytesWithSizePrefix(This,buffer) ) + +#define IBMDStreamingH264NALPacket_GetDisplayTime(This,requestedTimeScale,displayTime) \ + ( (This)->lpVtbl -> GetDisplayTime(This,requestedTimeScale,displayTime) ) + +#define IBMDStreamingH264NALPacket_GetPacketIndex(This,packetIndex) \ + ( (This)->lpVtbl -> GetPacketIndex(This,packetIndex) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IBMDStreamingH264NALPacket_INTERFACE_DEFINED__ */ + + +#ifndef __IBMDStreamingAudioPacket_INTERFACE_DEFINED__ +#define __IBMDStreamingAudioPacket_INTERFACE_DEFINED__ + +/* interface IBMDStreamingAudioPacket */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IBMDStreamingAudioPacket; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("D9EB5902-1AD2-43F4-9E2C-3CFA50B5EE19") + IBMDStreamingAudioPacket : public IUnknown + { + public: + virtual BMDStreamingAudioCodec STDMETHODCALLTYPE GetCodec( void) = 0; + + virtual long STDMETHODCALLTYPE GetPayloadSize( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBytes( + /* [out] */ void **buffer) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPlayTime( + /* [in] */ ULONGLONG requestedTimeScale, + /* [out] */ ULONGLONG *playTime) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPacketIndex( + /* [out] */ unsigned int *packetIndex) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IBMDStreamingAudioPacketVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IBMDStreamingAudioPacket * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IBMDStreamingAudioPacket * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IBMDStreamingAudioPacket * This); + + BMDStreamingAudioCodec ( STDMETHODCALLTYPE *GetCodec )( + IBMDStreamingAudioPacket * This); + + long ( STDMETHODCALLTYPE *GetPayloadSize )( + IBMDStreamingAudioPacket * This); + + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IBMDStreamingAudioPacket * This, + /* [out] */ void **buffer); + + HRESULT ( STDMETHODCALLTYPE *GetPlayTime )( + IBMDStreamingAudioPacket * This, + /* [in] */ ULONGLONG requestedTimeScale, + /* [out] */ ULONGLONG *playTime); + + HRESULT ( STDMETHODCALLTYPE *GetPacketIndex )( + IBMDStreamingAudioPacket * This, + /* [out] */ unsigned int *packetIndex); + + END_INTERFACE + } IBMDStreamingAudioPacketVtbl; + + interface IBMDStreamingAudioPacket + { + CONST_VTBL struct IBMDStreamingAudioPacketVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IBMDStreamingAudioPacket_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IBMDStreamingAudioPacket_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IBMDStreamingAudioPacket_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IBMDStreamingAudioPacket_GetCodec(This) \ + ( (This)->lpVtbl -> GetCodec(This) ) + +#define IBMDStreamingAudioPacket_GetPayloadSize(This) \ + ( (This)->lpVtbl -> GetPayloadSize(This) ) + +#define IBMDStreamingAudioPacket_GetBytes(This,buffer) \ + ( (This)->lpVtbl -> GetBytes(This,buffer) ) + +#define IBMDStreamingAudioPacket_GetPlayTime(This,requestedTimeScale,playTime) \ + ( (This)->lpVtbl -> GetPlayTime(This,requestedTimeScale,playTime) ) + +#define IBMDStreamingAudioPacket_GetPacketIndex(This,packetIndex) \ + ( (This)->lpVtbl -> GetPacketIndex(This,packetIndex) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IBMDStreamingAudioPacket_INTERFACE_DEFINED__ */ + + +#ifndef __IBMDStreamingMPEG2TSPacket_INTERFACE_DEFINED__ +#define __IBMDStreamingMPEG2TSPacket_INTERFACE_DEFINED__ + +/* interface IBMDStreamingMPEG2TSPacket */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IBMDStreamingMPEG2TSPacket; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("91810D1C-4FB3-4AAA-AE56-FA301D3DFA4C") + IBMDStreamingMPEG2TSPacket : public IUnknown + { + public: + virtual long STDMETHODCALLTYPE GetPayloadSize( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBytes( + /* [out] */ void **buffer) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IBMDStreamingMPEG2TSPacketVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IBMDStreamingMPEG2TSPacket * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IBMDStreamingMPEG2TSPacket * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IBMDStreamingMPEG2TSPacket * This); + + long ( STDMETHODCALLTYPE *GetPayloadSize )( + IBMDStreamingMPEG2TSPacket * This); + + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IBMDStreamingMPEG2TSPacket * This, + /* [out] */ void **buffer); + + END_INTERFACE + } IBMDStreamingMPEG2TSPacketVtbl; + + interface IBMDStreamingMPEG2TSPacket + { + CONST_VTBL struct IBMDStreamingMPEG2TSPacketVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IBMDStreamingMPEG2TSPacket_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IBMDStreamingMPEG2TSPacket_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IBMDStreamingMPEG2TSPacket_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IBMDStreamingMPEG2TSPacket_GetPayloadSize(This) \ + ( (This)->lpVtbl -> GetPayloadSize(This) ) + +#define IBMDStreamingMPEG2TSPacket_GetBytes(This,buffer) \ + ( (This)->lpVtbl -> GetBytes(This,buffer) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IBMDStreamingMPEG2TSPacket_INTERFACE_DEFINED__ */ + + +#ifndef __IBMDStreamingH264NALParser_INTERFACE_DEFINED__ +#define __IBMDStreamingH264NALParser_INTERFACE_DEFINED__ + +/* interface IBMDStreamingH264NALParser */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IBMDStreamingH264NALParser; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("5867F18C-5BFA-4CCC-B2A7-9DFD140417D2") + IBMDStreamingH264NALParser : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE IsNALSequenceParameterSet( + /* [in] */ IBMDStreamingH264NALPacket *nal) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsNALPictureParameterSet( + /* [in] */ IBMDStreamingH264NALPacket *nal) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetProfileAndLevelFromSPS( + /* [in] */ IBMDStreamingH264NALPacket *nal, + /* [out] */ unsigned int *profileIdc, + /* [out] */ unsigned int *profileCompatability, + /* [out] */ unsigned int *levelIdc) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IBMDStreamingH264NALParserVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IBMDStreamingH264NALParser * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IBMDStreamingH264NALParser * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IBMDStreamingH264NALParser * This); + + HRESULT ( STDMETHODCALLTYPE *IsNALSequenceParameterSet )( + IBMDStreamingH264NALParser * This, + /* [in] */ IBMDStreamingH264NALPacket *nal); + + HRESULT ( STDMETHODCALLTYPE *IsNALPictureParameterSet )( + IBMDStreamingH264NALParser * This, + /* [in] */ IBMDStreamingH264NALPacket *nal); + + HRESULT ( STDMETHODCALLTYPE *GetProfileAndLevelFromSPS )( + IBMDStreamingH264NALParser * This, + /* [in] */ IBMDStreamingH264NALPacket *nal, + /* [out] */ unsigned int *profileIdc, + /* [out] */ unsigned int *profileCompatability, + /* [out] */ unsigned int *levelIdc); + + END_INTERFACE + } IBMDStreamingH264NALParserVtbl; + + interface IBMDStreamingH264NALParser + { + CONST_VTBL struct IBMDStreamingH264NALParserVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IBMDStreamingH264NALParser_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IBMDStreamingH264NALParser_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IBMDStreamingH264NALParser_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IBMDStreamingH264NALParser_IsNALSequenceParameterSet(This,nal) \ + ( (This)->lpVtbl -> IsNALSequenceParameterSet(This,nal) ) + +#define IBMDStreamingH264NALParser_IsNALPictureParameterSet(This,nal) \ + ( (This)->lpVtbl -> IsNALPictureParameterSet(This,nal) ) + +#define IBMDStreamingH264NALParser_GetProfileAndLevelFromSPS(This,nal,profileIdc,profileCompatability,levelIdc) \ + ( (This)->lpVtbl -> GetProfileAndLevelFromSPS(This,nal,profileIdc,profileCompatability,levelIdc) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IBMDStreamingH264NALParser_INTERFACE_DEFINED__ */ + + +EXTERN_C const CLSID CLSID_CBMDStreamingDiscovery; + +#ifdef __cplusplus + +class DECLSPEC_UUID("0CAA31F6-8A26-40B0-86A4-BF58DCCA710C") +CBMDStreamingDiscovery; +#endif + +EXTERN_C const CLSID CLSID_CBMDStreamingH264NALParser; + +#ifdef __cplusplus + +class DECLSPEC_UUID("7753EFBD-951C-407C-97A5-23C737B73B52") +CBMDStreamingH264NALParser; +#endif + +#ifndef __IDeckLinkVideoOutputCallback_INTERFACE_DEFINED__ +#define __IDeckLinkVideoOutputCallback_INTERFACE_DEFINED__ + +/* interface IDeckLinkVideoOutputCallback */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkVideoOutputCallback; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("20AA5225-1958-47CB-820B-80A8D521A6EE") + IDeckLinkVideoOutputCallback : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE ScheduledFrameCompleted( + /* [in] */ IDeckLinkVideoFrame *completedFrame, + /* [in] */ BMDOutputFrameCompletionResult result) = 0; + + virtual HRESULT STDMETHODCALLTYPE ScheduledPlaybackHasStopped( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkVideoOutputCallbackVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoOutputCallback * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoOutputCallback * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoOutputCallback * This); + + HRESULT ( STDMETHODCALLTYPE *ScheduledFrameCompleted )( + IDeckLinkVideoOutputCallback * This, + /* [in] */ IDeckLinkVideoFrame *completedFrame, + /* [in] */ BMDOutputFrameCompletionResult result); + + HRESULT ( STDMETHODCALLTYPE *ScheduledPlaybackHasStopped )( + IDeckLinkVideoOutputCallback * This); + + END_INTERFACE + } IDeckLinkVideoOutputCallbackVtbl; + + interface IDeckLinkVideoOutputCallback + { + CONST_VTBL struct IDeckLinkVideoOutputCallbackVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkVideoOutputCallback_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkVideoOutputCallback_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkVideoOutputCallback_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkVideoOutputCallback_ScheduledFrameCompleted(This,completedFrame,result) \ + ( (This)->lpVtbl -> ScheduledFrameCompleted(This,completedFrame,result) ) + +#define IDeckLinkVideoOutputCallback_ScheduledPlaybackHasStopped(This) \ + ( (This)->lpVtbl -> ScheduledPlaybackHasStopped(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkVideoOutputCallback_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkInputCallback_INTERFACE_DEFINED__ +#define __IDeckLinkInputCallback_INTERFACE_DEFINED__ + +/* interface IDeckLinkInputCallback */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkInputCallback; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("DD04E5EC-7415-42AB-AE4A-E80C4DFC044A") + IDeckLinkInputCallback : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE VideoInputFormatChanged( + /* [in] */ BMDVideoInputFormatChangedEvents notificationEvents, + /* [in] */ IDeckLinkDisplayMode *newDisplayMode, + /* [in] */ BMDDetectedVideoInputFormatFlags detectedSignalFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE VideoInputFrameArrived( + /* [in] */ IDeckLinkVideoInputFrame *videoFrame, + /* [in] */ IDeckLinkAudioInputPacket *audioPacket) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkInputCallbackVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkInputCallback * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkInputCallback * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkInputCallback * This); + + HRESULT ( STDMETHODCALLTYPE *VideoInputFormatChanged )( + IDeckLinkInputCallback * This, + /* [in] */ BMDVideoInputFormatChangedEvents notificationEvents, + /* [in] */ IDeckLinkDisplayMode *newDisplayMode, + /* [in] */ BMDDetectedVideoInputFormatFlags detectedSignalFlags); + + HRESULT ( STDMETHODCALLTYPE *VideoInputFrameArrived )( + IDeckLinkInputCallback * This, + /* [in] */ IDeckLinkVideoInputFrame *videoFrame, + /* [in] */ IDeckLinkAudioInputPacket *audioPacket); + + END_INTERFACE + } IDeckLinkInputCallbackVtbl; + + interface IDeckLinkInputCallback + { + CONST_VTBL struct IDeckLinkInputCallbackVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkInputCallback_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkInputCallback_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkInputCallback_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkInputCallback_VideoInputFormatChanged(This,notificationEvents,newDisplayMode,detectedSignalFlags) \ + ( (This)->lpVtbl -> VideoInputFormatChanged(This,notificationEvents,newDisplayMode,detectedSignalFlags) ) + +#define IDeckLinkInputCallback_VideoInputFrameArrived(This,videoFrame,audioPacket) \ + ( (This)->lpVtbl -> VideoInputFrameArrived(This,videoFrame,audioPacket) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkInputCallback_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkMemoryAllocator_INTERFACE_DEFINED__ +#define __IDeckLinkMemoryAllocator_INTERFACE_DEFINED__ + +/* interface IDeckLinkMemoryAllocator */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkMemoryAllocator; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("B36EB6E7-9D29-4AA8-92EF-843B87A289E8") + IDeckLinkMemoryAllocator : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE AllocateBuffer( + /* [in] */ unsigned int bufferSize, + /* [out] */ void **allocatedBuffer) = 0; + + virtual HRESULT STDMETHODCALLTYPE ReleaseBuffer( + /* [in] */ void *buffer) = 0; + + virtual HRESULT STDMETHODCALLTYPE Commit( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Decommit( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkMemoryAllocatorVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkMemoryAllocator * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkMemoryAllocator * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkMemoryAllocator * This); + + HRESULT ( STDMETHODCALLTYPE *AllocateBuffer )( + IDeckLinkMemoryAllocator * This, + /* [in] */ unsigned int bufferSize, + /* [out] */ void **allocatedBuffer); + + HRESULT ( STDMETHODCALLTYPE *ReleaseBuffer )( + IDeckLinkMemoryAllocator * This, + /* [in] */ void *buffer); + + HRESULT ( STDMETHODCALLTYPE *Commit )( + IDeckLinkMemoryAllocator * This); + + HRESULT ( STDMETHODCALLTYPE *Decommit )( + IDeckLinkMemoryAllocator * This); + + END_INTERFACE + } IDeckLinkMemoryAllocatorVtbl; + + interface IDeckLinkMemoryAllocator + { + CONST_VTBL struct IDeckLinkMemoryAllocatorVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkMemoryAllocator_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkMemoryAllocator_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkMemoryAllocator_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkMemoryAllocator_AllocateBuffer(This,bufferSize,allocatedBuffer) \ + ( (This)->lpVtbl -> AllocateBuffer(This,bufferSize,allocatedBuffer) ) + +#define IDeckLinkMemoryAllocator_ReleaseBuffer(This,buffer) \ + ( (This)->lpVtbl -> ReleaseBuffer(This,buffer) ) + +#define IDeckLinkMemoryAllocator_Commit(This) \ + ( (This)->lpVtbl -> Commit(This) ) + +#define IDeckLinkMemoryAllocator_Decommit(This) \ + ( (This)->lpVtbl -> Decommit(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkMemoryAllocator_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkAudioOutputCallback_INTERFACE_DEFINED__ +#define __IDeckLinkAudioOutputCallback_INTERFACE_DEFINED__ + +/* interface IDeckLinkAudioOutputCallback */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkAudioOutputCallback; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("403C681B-7F46-4A12-B993-2BB127084EE6") + IDeckLinkAudioOutputCallback : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE RenderAudioSamples( + /* [in] */ BOOL preroll) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkAudioOutputCallbackVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkAudioOutputCallback * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkAudioOutputCallback * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkAudioOutputCallback * This); + + HRESULT ( STDMETHODCALLTYPE *RenderAudioSamples )( + IDeckLinkAudioOutputCallback * This, + /* [in] */ BOOL preroll); + + END_INTERFACE + } IDeckLinkAudioOutputCallbackVtbl; + + interface IDeckLinkAudioOutputCallback + { + CONST_VTBL struct IDeckLinkAudioOutputCallbackVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkAudioOutputCallback_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkAudioOutputCallback_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkAudioOutputCallback_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkAudioOutputCallback_RenderAudioSamples(This,preroll) \ + ( (This)->lpVtbl -> RenderAudioSamples(This,preroll) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkAudioOutputCallback_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkIterator_INTERFACE_DEFINED__ +#define __IDeckLinkIterator_INTERFACE_DEFINED__ + +/* interface IDeckLinkIterator */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkIterator; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("50FB36CD-3063-4B73-BDBB-958087F2D8BA") + IDeckLinkIterator : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Next( + /* [out] */ IDeckLink **deckLinkInstance) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkIteratorVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkIterator * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkIterator * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkIterator * This); + + HRESULT ( STDMETHODCALLTYPE *Next )( + IDeckLinkIterator * This, + /* [out] */ IDeckLink **deckLinkInstance); + + END_INTERFACE + } IDeckLinkIteratorVtbl; + + interface IDeckLinkIterator + { + CONST_VTBL struct IDeckLinkIteratorVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkIterator_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkIterator_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkIterator_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkIterator_Next(This,deckLinkInstance) \ + ( (This)->lpVtbl -> Next(This,deckLinkInstance) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkIterator_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkAPIInformation_INTERFACE_DEFINED__ +#define __IDeckLinkAPIInformation_INTERFACE_DEFINED__ + +/* interface IDeckLinkAPIInformation */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkAPIInformation; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("7BEA3C68-730D-4322-AF34-8A7152B532A4") + IDeckLinkAPIInformation : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetFlag( + /* [in] */ BMDDeckLinkAPIInformationID cfgID, + /* [out] */ BOOL *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInt( + /* [in] */ BMDDeckLinkAPIInformationID cfgID, + /* [out] */ LONGLONG *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFloat( + /* [in] */ BMDDeckLinkAPIInformationID cfgID, + /* [out] */ double *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetString( + /* [in] */ BMDDeckLinkAPIInformationID cfgID, + /* [out] */ BSTR *value) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkAPIInformationVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkAPIInformation * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkAPIInformation * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkAPIInformation * This); + + HRESULT ( STDMETHODCALLTYPE *GetFlag )( + IDeckLinkAPIInformation * This, + /* [in] */ BMDDeckLinkAPIInformationID cfgID, + /* [out] */ BOOL *value); + + HRESULT ( STDMETHODCALLTYPE *GetInt )( + IDeckLinkAPIInformation * This, + /* [in] */ BMDDeckLinkAPIInformationID cfgID, + /* [out] */ LONGLONG *value); + + HRESULT ( STDMETHODCALLTYPE *GetFloat )( + IDeckLinkAPIInformation * This, + /* [in] */ BMDDeckLinkAPIInformationID cfgID, + /* [out] */ double *value); + + HRESULT ( STDMETHODCALLTYPE *GetString )( + IDeckLinkAPIInformation * This, + /* [in] */ BMDDeckLinkAPIInformationID cfgID, + /* [out] */ BSTR *value); + + END_INTERFACE + } IDeckLinkAPIInformationVtbl; + + interface IDeckLinkAPIInformation + { + CONST_VTBL struct IDeckLinkAPIInformationVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkAPIInformation_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkAPIInformation_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkAPIInformation_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkAPIInformation_GetFlag(This,cfgID,value) \ + ( (This)->lpVtbl -> GetFlag(This,cfgID,value) ) + +#define IDeckLinkAPIInformation_GetInt(This,cfgID,value) \ + ( (This)->lpVtbl -> GetInt(This,cfgID,value) ) + +#define IDeckLinkAPIInformation_GetFloat(This,cfgID,value) \ + ( (This)->lpVtbl -> GetFloat(This,cfgID,value) ) + +#define IDeckLinkAPIInformation_GetString(This,cfgID,value) \ + ( (This)->lpVtbl -> GetString(This,cfgID,value) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkAPIInformation_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkOutput_INTERFACE_DEFINED__ +#define __IDeckLinkOutput_INTERFACE_DEFINED__ + +/* interface IDeckLinkOutput */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkOutput; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("CC5C8A6E-3F2F-4B3A-87EA-FD78AF300564") + IDeckLinkOutput : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE DoesSupportVideoMode( + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDVideoOutputFlags flags, + /* [out] */ BMDDisplayModeSupport *result, + /* [out] */ IDeckLinkDisplayMode **resultDisplayMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayModeIterator( + /* [out] */ IDeckLinkDisplayModeIterator **iterator) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetScreenPreviewCallback( + /* [in] */ IDeckLinkScreenPreviewCallback *previewCallback) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableVideoOutput( + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDVideoOutputFlags flags) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisableVideoOutput( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetVideoOutputFrameMemoryAllocator( + /* [in] */ IDeckLinkMemoryAllocator *theAllocator) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateVideoFrame( + /* [in] */ int width, + /* [in] */ int height, + /* [in] */ int rowBytes, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDFrameFlags flags, + /* [out] */ IDeckLinkMutableVideoFrame **outFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateAncillaryData( + /* [in] */ BMDPixelFormat pixelFormat, + /* [out] */ IDeckLinkVideoFrameAncillary **outBuffer) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisplayVideoFrameSync( + /* [in] */ IDeckLinkVideoFrame *theFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE ScheduleVideoFrame( + /* [in] */ IDeckLinkVideoFrame *theFrame, + /* [in] */ BMDTimeValue displayTime, + /* [in] */ BMDTimeValue displayDuration, + /* [in] */ BMDTimeScale timeScale) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetScheduledFrameCompletionCallback( + /* [in] */ IDeckLinkVideoOutputCallback *theCallback) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBufferedVideoFrameCount( + /* [out] */ unsigned int *bufferedFrameCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableAudioOutput( + /* [in] */ BMDAudioSampleRate sampleRate, + /* [in] */ BMDAudioSampleType sampleType, + /* [in] */ unsigned int channelCount, + /* [in] */ BMDAudioOutputStreamType streamType) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisableAudioOutput( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE WriteAudioSamplesSync( + /* [in] */ void *buffer, + /* [in] */ unsigned int sampleFrameCount, + /* [out] */ unsigned int *sampleFramesWritten) = 0; + + virtual HRESULT STDMETHODCALLTYPE BeginAudioPreroll( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE EndAudioPreroll( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE ScheduleAudioSamples( + /* [in] */ void *buffer, + /* [in] */ unsigned int sampleFrameCount, + /* [in] */ BMDTimeValue streamTime, + /* [in] */ BMDTimeScale timeScale, + /* [out] */ unsigned int *sampleFramesWritten) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBufferedAudioSampleFrameCount( + /* [out] */ unsigned int *bufferedSampleFrameCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE FlushBufferedAudioSamples( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetAudioCallback( + /* [in] */ IDeckLinkAudioOutputCallback *theCallback) = 0; + + virtual HRESULT STDMETHODCALLTYPE StartScheduledPlayback( + /* [in] */ BMDTimeValue playbackStartTime, + /* [in] */ BMDTimeScale timeScale, + /* [in] */ double playbackSpeed) = 0; + + virtual HRESULT STDMETHODCALLTYPE StopScheduledPlayback( + /* [in] */ BMDTimeValue stopPlaybackAtTime, + /* [out] */ BMDTimeValue *actualStopTime, + /* [in] */ BMDTimeScale timeScale) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsScheduledPlaybackRunning( + /* [out] */ BOOL *active) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetScheduledStreamTime( + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *streamTime, + /* [out] */ double *playbackSpeed) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetReferenceStatus( + /* [out] */ BMDReferenceStatus *referenceStatus) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetHardwareReferenceClock( + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *hardwareTime, + /* [out] */ BMDTimeValue *timeInFrame, + /* [out] */ BMDTimeValue *ticksPerFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFrameCompletionReferenceTimestamp( + /* [in] */ IDeckLinkVideoFrame *theFrame, + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *frameCompletionTimestamp) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkOutputVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkOutput * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkOutput * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkOutput * This); + + HRESULT ( STDMETHODCALLTYPE *DoesSupportVideoMode )( + IDeckLinkOutput * This, + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDVideoOutputFlags flags, + /* [out] */ BMDDisplayModeSupport *result, + /* [out] */ IDeckLinkDisplayMode **resultDisplayMode); + + HRESULT ( STDMETHODCALLTYPE *GetDisplayModeIterator )( + IDeckLinkOutput * This, + /* [out] */ IDeckLinkDisplayModeIterator **iterator); + + HRESULT ( STDMETHODCALLTYPE *SetScreenPreviewCallback )( + IDeckLinkOutput * This, + /* [in] */ IDeckLinkScreenPreviewCallback *previewCallback); + + HRESULT ( STDMETHODCALLTYPE *EnableVideoOutput )( + IDeckLinkOutput * This, + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDVideoOutputFlags flags); + + HRESULT ( STDMETHODCALLTYPE *DisableVideoOutput )( + IDeckLinkOutput * This); + + HRESULT ( STDMETHODCALLTYPE *SetVideoOutputFrameMemoryAllocator )( + IDeckLinkOutput * This, + /* [in] */ IDeckLinkMemoryAllocator *theAllocator); + + HRESULT ( STDMETHODCALLTYPE *CreateVideoFrame )( + IDeckLinkOutput * This, + /* [in] */ int width, + /* [in] */ int height, + /* [in] */ int rowBytes, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDFrameFlags flags, + /* [out] */ IDeckLinkMutableVideoFrame **outFrame); + + HRESULT ( STDMETHODCALLTYPE *CreateAncillaryData )( + IDeckLinkOutput * This, + /* [in] */ BMDPixelFormat pixelFormat, + /* [out] */ IDeckLinkVideoFrameAncillary **outBuffer); + + HRESULT ( STDMETHODCALLTYPE *DisplayVideoFrameSync )( + IDeckLinkOutput * This, + /* [in] */ IDeckLinkVideoFrame *theFrame); + + HRESULT ( STDMETHODCALLTYPE *ScheduleVideoFrame )( + IDeckLinkOutput * This, + /* [in] */ IDeckLinkVideoFrame *theFrame, + /* [in] */ BMDTimeValue displayTime, + /* [in] */ BMDTimeValue displayDuration, + /* [in] */ BMDTimeScale timeScale); + + HRESULT ( STDMETHODCALLTYPE *SetScheduledFrameCompletionCallback )( + IDeckLinkOutput * This, + /* [in] */ IDeckLinkVideoOutputCallback *theCallback); + + HRESULT ( STDMETHODCALLTYPE *GetBufferedVideoFrameCount )( + IDeckLinkOutput * This, + /* [out] */ unsigned int *bufferedFrameCount); + + HRESULT ( STDMETHODCALLTYPE *EnableAudioOutput )( + IDeckLinkOutput * This, + /* [in] */ BMDAudioSampleRate sampleRate, + /* [in] */ BMDAudioSampleType sampleType, + /* [in] */ unsigned int channelCount, + /* [in] */ BMDAudioOutputStreamType streamType); + + HRESULT ( STDMETHODCALLTYPE *DisableAudioOutput )( + IDeckLinkOutput * This); + + HRESULT ( STDMETHODCALLTYPE *WriteAudioSamplesSync )( + IDeckLinkOutput * This, + /* [in] */ void *buffer, + /* [in] */ unsigned int sampleFrameCount, + /* [out] */ unsigned int *sampleFramesWritten); + + HRESULT ( STDMETHODCALLTYPE *BeginAudioPreroll )( + IDeckLinkOutput * This); + + HRESULT ( STDMETHODCALLTYPE *EndAudioPreroll )( + IDeckLinkOutput * This); + + HRESULT ( STDMETHODCALLTYPE *ScheduleAudioSamples )( + IDeckLinkOutput * This, + /* [in] */ void *buffer, + /* [in] */ unsigned int sampleFrameCount, + /* [in] */ BMDTimeValue streamTime, + /* [in] */ BMDTimeScale timeScale, + /* [out] */ unsigned int *sampleFramesWritten); + + HRESULT ( STDMETHODCALLTYPE *GetBufferedAudioSampleFrameCount )( + IDeckLinkOutput * This, + /* [out] */ unsigned int *bufferedSampleFrameCount); + + HRESULT ( STDMETHODCALLTYPE *FlushBufferedAudioSamples )( + IDeckLinkOutput * This); + + HRESULT ( STDMETHODCALLTYPE *SetAudioCallback )( + IDeckLinkOutput * This, + /* [in] */ IDeckLinkAudioOutputCallback *theCallback); + + HRESULT ( STDMETHODCALLTYPE *StartScheduledPlayback )( + IDeckLinkOutput * This, + /* [in] */ BMDTimeValue playbackStartTime, + /* [in] */ BMDTimeScale timeScale, + /* [in] */ double playbackSpeed); + + HRESULT ( STDMETHODCALLTYPE *StopScheduledPlayback )( + IDeckLinkOutput * This, + /* [in] */ BMDTimeValue stopPlaybackAtTime, + /* [out] */ BMDTimeValue *actualStopTime, + /* [in] */ BMDTimeScale timeScale); + + HRESULT ( STDMETHODCALLTYPE *IsScheduledPlaybackRunning )( + IDeckLinkOutput * This, + /* [out] */ BOOL *active); + + HRESULT ( STDMETHODCALLTYPE *GetScheduledStreamTime )( + IDeckLinkOutput * This, + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *streamTime, + /* [out] */ double *playbackSpeed); + + HRESULT ( STDMETHODCALLTYPE *GetReferenceStatus )( + IDeckLinkOutput * This, + /* [out] */ BMDReferenceStatus *referenceStatus); + + HRESULT ( STDMETHODCALLTYPE *GetHardwareReferenceClock )( + IDeckLinkOutput * This, + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *hardwareTime, + /* [out] */ BMDTimeValue *timeInFrame, + /* [out] */ BMDTimeValue *ticksPerFrame); + + HRESULT ( STDMETHODCALLTYPE *GetFrameCompletionReferenceTimestamp )( + IDeckLinkOutput * This, + /* [in] */ IDeckLinkVideoFrame *theFrame, + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *frameCompletionTimestamp); + + END_INTERFACE + } IDeckLinkOutputVtbl; + + interface IDeckLinkOutput + { + CONST_VTBL struct IDeckLinkOutputVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkOutput_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkOutput_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkOutput_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkOutput_DoesSupportVideoMode(This,displayMode,pixelFormat,flags,result,resultDisplayMode) \ + ( (This)->lpVtbl -> DoesSupportVideoMode(This,displayMode,pixelFormat,flags,result,resultDisplayMode) ) + +#define IDeckLinkOutput_GetDisplayModeIterator(This,iterator) \ + ( (This)->lpVtbl -> GetDisplayModeIterator(This,iterator) ) + +#define IDeckLinkOutput_SetScreenPreviewCallback(This,previewCallback) \ + ( (This)->lpVtbl -> SetScreenPreviewCallback(This,previewCallback) ) + +#define IDeckLinkOutput_EnableVideoOutput(This,displayMode,flags) \ + ( (This)->lpVtbl -> EnableVideoOutput(This,displayMode,flags) ) + +#define IDeckLinkOutput_DisableVideoOutput(This) \ + ( (This)->lpVtbl -> DisableVideoOutput(This) ) + +#define IDeckLinkOutput_SetVideoOutputFrameMemoryAllocator(This,theAllocator) \ + ( (This)->lpVtbl -> SetVideoOutputFrameMemoryAllocator(This,theAllocator) ) + +#define IDeckLinkOutput_CreateVideoFrame(This,width,height,rowBytes,pixelFormat,flags,outFrame) \ + ( (This)->lpVtbl -> CreateVideoFrame(This,width,height,rowBytes,pixelFormat,flags,outFrame) ) + +#define IDeckLinkOutput_CreateAncillaryData(This,pixelFormat,outBuffer) \ + ( (This)->lpVtbl -> CreateAncillaryData(This,pixelFormat,outBuffer) ) + +#define IDeckLinkOutput_DisplayVideoFrameSync(This,theFrame) \ + ( (This)->lpVtbl -> DisplayVideoFrameSync(This,theFrame) ) + +#define IDeckLinkOutput_ScheduleVideoFrame(This,theFrame,displayTime,displayDuration,timeScale) \ + ( (This)->lpVtbl -> ScheduleVideoFrame(This,theFrame,displayTime,displayDuration,timeScale) ) + +#define IDeckLinkOutput_SetScheduledFrameCompletionCallback(This,theCallback) \ + ( (This)->lpVtbl -> SetScheduledFrameCompletionCallback(This,theCallback) ) + +#define IDeckLinkOutput_GetBufferedVideoFrameCount(This,bufferedFrameCount) \ + ( (This)->lpVtbl -> GetBufferedVideoFrameCount(This,bufferedFrameCount) ) + +#define IDeckLinkOutput_EnableAudioOutput(This,sampleRate,sampleType,channelCount,streamType) \ + ( (This)->lpVtbl -> EnableAudioOutput(This,sampleRate,sampleType,channelCount,streamType) ) + +#define IDeckLinkOutput_DisableAudioOutput(This) \ + ( (This)->lpVtbl -> DisableAudioOutput(This) ) + +#define IDeckLinkOutput_WriteAudioSamplesSync(This,buffer,sampleFrameCount,sampleFramesWritten) \ + ( (This)->lpVtbl -> WriteAudioSamplesSync(This,buffer,sampleFrameCount,sampleFramesWritten) ) + +#define IDeckLinkOutput_BeginAudioPreroll(This) \ + ( (This)->lpVtbl -> BeginAudioPreroll(This) ) + +#define IDeckLinkOutput_EndAudioPreroll(This) \ + ( (This)->lpVtbl -> EndAudioPreroll(This) ) + +#define IDeckLinkOutput_ScheduleAudioSamples(This,buffer,sampleFrameCount,streamTime,timeScale,sampleFramesWritten) \ + ( (This)->lpVtbl -> ScheduleAudioSamples(This,buffer,sampleFrameCount,streamTime,timeScale,sampleFramesWritten) ) + +#define IDeckLinkOutput_GetBufferedAudioSampleFrameCount(This,bufferedSampleFrameCount) \ + ( (This)->lpVtbl -> GetBufferedAudioSampleFrameCount(This,bufferedSampleFrameCount) ) + +#define IDeckLinkOutput_FlushBufferedAudioSamples(This) \ + ( (This)->lpVtbl -> FlushBufferedAudioSamples(This) ) + +#define IDeckLinkOutput_SetAudioCallback(This,theCallback) \ + ( (This)->lpVtbl -> SetAudioCallback(This,theCallback) ) + +#define IDeckLinkOutput_StartScheduledPlayback(This,playbackStartTime,timeScale,playbackSpeed) \ + ( (This)->lpVtbl -> StartScheduledPlayback(This,playbackStartTime,timeScale,playbackSpeed) ) + +#define IDeckLinkOutput_StopScheduledPlayback(This,stopPlaybackAtTime,actualStopTime,timeScale) \ + ( (This)->lpVtbl -> StopScheduledPlayback(This,stopPlaybackAtTime,actualStopTime,timeScale) ) + +#define IDeckLinkOutput_IsScheduledPlaybackRunning(This,active) \ + ( (This)->lpVtbl -> IsScheduledPlaybackRunning(This,active) ) + +#define IDeckLinkOutput_GetScheduledStreamTime(This,desiredTimeScale,streamTime,playbackSpeed) \ + ( (This)->lpVtbl -> GetScheduledStreamTime(This,desiredTimeScale,streamTime,playbackSpeed) ) + +#define IDeckLinkOutput_GetReferenceStatus(This,referenceStatus) \ + ( (This)->lpVtbl -> GetReferenceStatus(This,referenceStatus) ) + +#define IDeckLinkOutput_GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) \ + ( (This)->lpVtbl -> GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) ) + +#define IDeckLinkOutput_GetFrameCompletionReferenceTimestamp(This,theFrame,desiredTimeScale,frameCompletionTimestamp) \ + ( (This)->lpVtbl -> GetFrameCompletionReferenceTimestamp(This,theFrame,desiredTimeScale,frameCompletionTimestamp) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkOutput_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkInput_INTERFACE_DEFINED__ +#define __IDeckLinkInput_INTERFACE_DEFINED__ + +/* interface IDeckLinkInput */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkInput; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("AF22762B-DFAC-4846-AA79-FA8883560995") + IDeckLinkInput : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE DoesSupportVideoMode( + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDVideoInputFlags flags, + /* [out] */ BMDDisplayModeSupport *result, + /* [out] */ IDeckLinkDisplayMode **resultDisplayMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayModeIterator( + /* [out] */ IDeckLinkDisplayModeIterator **iterator) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetScreenPreviewCallback( + /* [in] */ IDeckLinkScreenPreviewCallback *previewCallback) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableVideoInput( + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDVideoInputFlags flags) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisableVideoInput( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAvailableVideoFrameCount( + /* [out] */ unsigned int *availableFrameCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetVideoInputFrameMemoryAllocator( + /* [in] */ IDeckLinkMemoryAllocator *theAllocator) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableAudioInput( + /* [in] */ BMDAudioSampleRate sampleRate, + /* [in] */ BMDAudioSampleType sampleType, + /* [in] */ unsigned int channelCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisableAudioInput( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAvailableAudioSampleFrameCount( + /* [out] */ unsigned int *availableSampleFrameCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE StartStreams( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE StopStreams( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE PauseStreams( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE FlushStreams( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetCallback( + /* [in] */ IDeckLinkInputCallback *theCallback) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetHardwareReferenceClock( + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *hardwareTime, + /* [out] */ BMDTimeValue *timeInFrame, + /* [out] */ BMDTimeValue *ticksPerFrame) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkInputVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkInput * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkInput * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkInput * This); + + HRESULT ( STDMETHODCALLTYPE *DoesSupportVideoMode )( + IDeckLinkInput * This, + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDVideoInputFlags flags, + /* [out] */ BMDDisplayModeSupport *result, + /* [out] */ IDeckLinkDisplayMode **resultDisplayMode); + + HRESULT ( STDMETHODCALLTYPE *GetDisplayModeIterator )( + IDeckLinkInput * This, + /* [out] */ IDeckLinkDisplayModeIterator **iterator); + + HRESULT ( STDMETHODCALLTYPE *SetScreenPreviewCallback )( + IDeckLinkInput * This, + /* [in] */ IDeckLinkScreenPreviewCallback *previewCallback); + + HRESULT ( STDMETHODCALLTYPE *EnableVideoInput )( + IDeckLinkInput * This, + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDVideoInputFlags flags); + + HRESULT ( STDMETHODCALLTYPE *DisableVideoInput )( + IDeckLinkInput * This); + + HRESULT ( STDMETHODCALLTYPE *GetAvailableVideoFrameCount )( + IDeckLinkInput * This, + /* [out] */ unsigned int *availableFrameCount); + + HRESULT ( STDMETHODCALLTYPE *SetVideoInputFrameMemoryAllocator )( + IDeckLinkInput * This, + /* [in] */ IDeckLinkMemoryAllocator *theAllocator); + + HRESULT ( STDMETHODCALLTYPE *EnableAudioInput )( + IDeckLinkInput * This, + /* [in] */ BMDAudioSampleRate sampleRate, + /* [in] */ BMDAudioSampleType sampleType, + /* [in] */ unsigned int channelCount); + + HRESULT ( STDMETHODCALLTYPE *DisableAudioInput )( + IDeckLinkInput * This); + + HRESULT ( STDMETHODCALLTYPE *GetAvailableAudioSampleFrameCount )( + IDeckLinkInput * This, + /* [out] */ unsigned int *availableSampleFrameCount); + + HRESULT ( STDMETHODCALLTYPE *StartStreams )( + IDeckLinkInput * This); + + HRESULT ( STDMETHODCALLTYPE *StopStreams )( + IDeckLinkInput * This); + + HRESULT ( STDMETHODCALLTYPE *PauseStreams )( + IDeckLinkInput * This); + + HRESULT ( STDMETHODCALLTYPE *FlushStreams )( + IDeckLinkInput * This); + + HRESULT ( STDMETHODCALLTYPE *SetCallback )( + IDeckLinkInput * This, + /* [in] */ IDeckLinkInputCallback *theCallback); + + HRESULT ( STDMETHODCALLTYPE *GetHardwareReferenceClock )( + IDeckLinkInput * This, + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *hardwareTime, + /* [out] */ BMDTimeValue *timeInFrame, + /* [out] */ BMDTimeValue *ticksPerFrame); + + END_INTERFACE + } IDeckLinkInputVtbl; + + interface IDeckLinkInput + { + CONST_VTBL struct IDeckLinkInputVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkInput_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkInput_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkInput_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkInput_DoesSupportVideoMode(This,displayMode,pixelFormat,flags,result,resultDisplayMode) \ + ( (This)->lpVtbl -> DoesSupportVideoMode(This,displayMode,pixelFormat,flags,result,resultDisplayMode) ) + +#define IDeckLinkInput_GetDisplayModeIterator(This,iterator) \ + ( (This)->lpVtbl -> GetDisplayModeIterator(This,iterator) ) + +#define IDeckLinkInput_SetScreenPreviewCallback(This,previewCallback) \ + ( (This)->lpVtbl -> SetScreenPreviewCallback(This,previewCallback) ) + +#define IDeckLinkInput_EnableVideoInput(This,displayMode,pixelFormat,flags) \ + ( (This)->lpVtbl -> EnableVideoInput(This,displayMode,pixelFormat,flags) ) + +#define IDeckLinkInput_DisableVideoInput(This) \ + ( (This)->lpVtbl -> DisableVideoInput(This) ) + +#define IDeckLinkInput_GetAvailableVideoFrameCount(This,availableFrameCount) \ + ( (This)->lpVtbl -> GetAvailableVideoFrameCount(This,availableFrameCount) ) + +#define IDeckLinkInput_SetVideoInputFrameMemoryAllocator(This,theAllocator) \ + ( (This)->lpVtbl -> SetVideoInputFrameMemoryAllocator(This,theAllocator) ) + +#define IDeckLinkInput_EnableAudioInput(This,sampleRate,sampleType,channelCount) \ + ( (This)->lpVtbl -> EnableAudioInput(This,sampleRate,sampleType,channelCount) ) + +#define IDeckLinkInput_DisableAudioInput(This) \ + ( (This)->lpVtbl -> DisableAudioInput(This) ) + +#define IDeckLinkInput_GetAvailableAudioSampleFrameCount(This,availableSampleFrameCount) \ + ( (This)->lpVtbl -> GetAvailableAudioSampleFrameCount(This,availableSampleFrameCount) ) + +#define IDeckLinkInput_StartStreams(This) \ + ( (This)->lpVtbl -> StartStreams(This) ) + +#define IDeckLinkInput_StopStreams(This) \ + ( (This)->lpVtbl -> StopStreams(This) ) + +#define IDeckLinkInput_PauseStreams(This) \ + ( (This)->lpVtbl -> PauseStreams(This) ) + +#define IDeckLinkInput_FlushStreams(This) \ + ( (This)->lpVtbl -> FlushStreams(This) ) + +#define IDeckLinkInput_SetCallback(This,theCallback) \ + ( (This)->lpVtbl -> SetCallback(This,theCallback) ) + +#define IDeckLinkInput_GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) \ + ( (This)->lpVtbl -> GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkInput_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkVideoFrame_INTERFACE_DEFINED__ +#define __IDeckLinkVideoFrame_INTERFACE_DEFINED__ + +/* interface IDeckLinkVideoFrame */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkVideoFrame; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("3F716FE0-F023-4111-BE5D-EF4414C05B17") + IDeckLinkVideoFrame : public IUnknown + { + public: + virtual long STDMETHODCALLTYPE GetWidth( void) = 0; + + virtual long STDMETHODCALLTYPE GetHeight( void) = 0; + + virtual long STDMETHODCALLTYPE GetRowBytes( void) = 0; + + virtual BMDPixelFormat STDMETHODCALLTYPE GetPixelFormat( void) = 0; + + virtual BMDFrameFlags STDMETHODCALLTYPE GetFlags( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBytes( + /* [out] */ void **buffer) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTimecode( + /* [in] */ BMDTimecodeFormat format, + /* [out] */ IDeckLinkTimecode **timecode) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAncillaryData( + /* [out] */ IDeckLinkVideoFrameAncillary **ancillary) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkVideoFrameVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoFrame * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoFrame * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoFrame * This); + + long ( STDMETHODCALLTYPE *GetWidth )( + IDeckLinkVideoFrame * This); + + long ( STDMETHODCALLTYPE *GetHeight )( + IDeckLinkVideoFrame * This); + + long ( STDMETHODCALLTYPE *GetRowBytes )( + IDeckLinkVideoFrame * This); + + BMDPixelFormat ( STDMETHODCALLTYPE *GetPixelFormat )( + IDeckLinkVideoFrame * This); + + BMDFrameFlags ( STDMETHODCALLTYPE *GetFlags )( + IDeckLinkVideoFrame * This); + + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IDeckLinkVideoFrame * This, + /* [out] */ void **buffer); + + HRESULT ( STDMETHODCALLTYPE *GetTimecode )( + IDeckLinkVideoFrame * This, + /* [in] */ BMDTimecodeFormat format, + /* [out] */ IDeckLinkTimecode **timecode); + + HRESULT ( STDMETHODCALLTYPE *GetAncillaryData )( + IDeckLinkVideoFrame * This, + /* [out] */ IDeckLinkVideoFrameAncillary **ancillary); + + END_INTERFACE + } IDeckLinkVideoFrameVtbl; + + interface IDeckLinkVideoFrame + { + CONST_VTBL struct IDeckLinkVideoFrameVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkVideoFrame_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkVideoFrame_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkVideoFrame_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkVideoFrame_GetWidth(This) \ + ( (This)->lpVtbl -> GetWidth(This) ) + +#define IDeckLinkVideoFrame_GetHeight(This) \ + ( (This)->lpVtbl -> GetHeight(This) ) + +#define IDeckLinkVideoFrame_GetRowBytes(This) \ + ( (This)->lpVtbl -> GetRowBytes(This) ) + +#define IDeckLinkVideoFrame_GetPixelFormat(This) \ + ( (This)->lpVtbl -> GetPixelFormat(This) ) + +#define IDeckLinkVideoFrame_GetFlags(This) \ + ( (This)->lpVtbl -> GetFlags(This) ) + +#define IDeckLinkVideoFrame_GetBytes(This,buffer) \ + ( (This)->lpVtbl -> GetBytes(This,buffer) ) + +#define IDeckLinkVideoFrame_GetTimecode(This,format,timecode) \ + ( (This)->lpVtbl -> GetTimecode(This,format,timecode) ) + +#define IDeckLinkVideoFrame_GetAncillaryData(This,ancillary) \ + ( (This)->lpVtbl -> GetAncillaryData(This,ancillary) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkVideoFrame_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkMutableVideoFrame_INTERFACE_DEFINED__ +#define __IDeckLinkMutableVideoFrame_INTERFACE_DEFINED__ + +/* interface IDeckLinkMutableVideoFrame */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkMutableVideoFrame; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("69E2639F-40DA-4E19-B6F2-20ACE815C390") + IDeckLinkMutableVideoFrame : public IDeckLinkVideoFrame + { + public: + virtual HRESULT STDMETHODCALLTYPE SetFlags( + /* [in] */ BMDFrameFlags newFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetTimecode( + /* [in] */ BMDTimecodeFormat format, + /* [in] */ IDeckLinkTimecode *timecode) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetTimecodeFromComponents( + /* [in] */ BMDTimecodeFormat format, + /* [in] */ unsigned char hours, + /* [in] */ unsigned char minutes, + /* [in] */ unsigned char seconds, + /* [in] */ unsigned char frames, + /* [in] */ BMDTimecodeFlags flags) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetAncillaryData( + /* [in] */ IDeckLinkVideoFrameAncillary *ancillary) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetTimecodeUserBits( + /* [in] */ BMDTimecodeFormat format, + /* [in] */ BMDTimecodeUserBits userBits) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkMutableVideoFrameVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkMutableVideoFrame * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkMutableVideoFrame * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkMutableVideoFrame * This); + + long ( STDMETHODCALLTYPE *GetWidth )( + IDeckLinkMutableVideoFrame * This); + + long ( STDMETHODCALLTYPE *GetHeight )( + IDeckLinkMutableVideoFrame * This); + + long ( STDMETHODCALLTYPE *GetRowBytes )( + IDeckLinkMutableVideoFrame * This); + + BMDPixelFormat ( STDMETHODCALLTYPE *GetPixelFormat )( + IDeckLinkMutableVideoFrame * This); + + BMDFrameFlags ( STDMETHODCALLTYPE *GetFlags )( + IDeckLinkMutableVideoFrame * This); + + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IDeckLinkMutableVideoFrame * This, + /* [out] */ void **buffer); + + HRESULT ( STDMETHODCALLTYPE *GetTimecode )( + IDeckLinkMutableVideoFrame * This, + /* [in] */ BMDTimecodeFormat format, + /* [out] */ IDeckLinkTimecode **timecode); + + HRESULT ( STDMETHODCALLTYPE *GetAncillaryData )( + IDeckLinkMutableVideoFrame * This, + /* [out] */ IDeckLinkVideoFrameAncillary **ancillary); + + HRESULT ( STDMETHODCALLTYPE *SetFlags )( + IDeckLinkMutableVideoFrame * This, + /* [in] */ BMDFrameFlags newFlags); + + HRESULT ( STDMETHODCALLTYPE *SetTimecode )( + IDeckLinkMutableVideoFrame * This, + /* [in] */ BMDTimecodeFormat format, + /* [in] */ IDeckLinkTimecode *timecode); + + HRESULT ( STDMETHODCALLTYPE *SetTimecodeFromComponents )( + IDeckLinkMutableVideoFrame * This, + /* [in] */ BMDTimecodeFormat format, + /* [in] */ unsigned char hours, + /* [in] */ unsigned char minutes, + /* [in] */ unsigned char seconds, + /* [in] */ unsigned char frames, + /* [in] */ BMDTimecodeFlags flags); + + HRESULT ( STDMETHODCALLTYPE *SetAncillaryData )( + IDeckLinkMutableVideoFrame * This, + /* [in] */ IDeckLinkVideoFrameAncillary *ancillary); + + HRESULT ( STDMETHODCALLTYPE *SetTimecodeUserBits )( + IDeckLinkMutableVideoFrame * This, + /* [in] */ BMDTimecodeFormat format, + /* [in] */ BMDTimecodeUserBits userBits); + + END_INTERFACE + } IDeckLinkMutableVideoFrameVtbl; + + interface IDeckLinkMutableVideoFrame + { + CONST_VTBL struct IDeckLinkMutableVideoFrameVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkMutableVideoFrame_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkMutableVideoFrame_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkMutableVideoFrame_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkMutableVideoFrame_GetWidth(This) \ + ( (This)->lpVtbl -> GetWidth(This) ) + +#define IDeckLinkMutableVideoFrame_GetHeight(This) \ + ( (This)->lpVtbl -> GetHeight(This) ) + +#define IDeckLinkMutableVideoFrame_GetRowBytes(This) \ + ( (This)->lpVtbl -> GetRowBytes(This) ) + +#define IDeckLinkMutableVideoFrame_GetPixelFormat(This) \ + ( (This)->lpVtbl -> GetPixelFormat(This) ) + +#define IDeckLinkMutableVideoFrame_GetFlags(This) \ + ( (This)->lpVtbl -> GetFlags(This) ) + +#define IDeckLinkMutableVideoFrame_GetBytes(This,buffer) \ + ( (This)->lpVtbl -> GetBytes(This,buffer) ) + +#define IDeckLinkMutableVideoFrame_GetTimecode(This,format,timecode) \ + ( (This)->lpVtbl -> GetTimecode(This,format,timecode) ) + +#define IDeckLinkMutableVideoFrame_GetAncillaryData(This,ancillary) \ + ( (This)->lpVtbl -> GetAncillaryData(This,ancillary) ) + + +#define IDeckLinkMutableVideoFrame_SetFlags(This,newFlags) \ + ( (This)->lpVtbl -> SetFlags(This,newFlags) ) + +#define IDeckLinkMutableVideoFrame_SetTimecode(This,format,timecode) \ + ( (This)->lpVtbl -> SetTimecode(This,format,timecode) ) + +#define IDeckLinkMutableVideoFrame_SetTimecodeFromComponents(This,format,hours,minutes,seconds,frames,flags) \ + ( (This)->lpVtbl -> SetTimecodeFromComponents(This,format,hours,minutes,seconds,frames,flags) ) + +#define IDeckLinkMutableVideoFrame_SetAncillaryData(This,ancillary) \ + ( (This)->lpVtbl -> SetAncillaryData(This,ancillary) ) + +#define IDeckLinkMutableVideoFrame_SetTimecodeUserBits(This,format,userBits) \ + ( (This)->lpVtbl -> SetTimecodeUserBits(This,format,userBits) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkMutableVideoFrame_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkVideoFrame3DExtensions_INTERFACE_DEFINED__ +#define __IDeckLinkVideoFrame3DExtensions_INTERFACE_DEFINED__ + +/* interface IDeckLinkVideoFrame3DExtensions */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkVideoFrame3DExtensions; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("DA0F7E4A-EDC7-48A8-9CDD-2DB51C729CD7") + IDeckLinkVideoFrame3DExtensions : public IUnknown + { + public: + virtual BMDVideo3DPackingFormat STDMETHODCALLTYPE Get3DPackingFormat( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFrameForRightEye( + /* [out] */ IDeckLinkVideoFrame **rightEyeFrame) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkVideoFrame3DExtensionsVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoFrame3DExtensions * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoFrame3DExtensions * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoFrame3DExtensions * This); + + BMDVideo3DPackingFormat ( STDMETHODCALLTYPE *Get3DPackingFormat )( + IDeckLinkVideoFrame3DExtensions * This); + + HRESULT ( STDMETHODCALLTYPE *GetFrameForRightEye )( + IDeckLinkVideoFrame3DExtensions * This, + /* [out] */ IDeckLinkVideoFrame **rightEyeFrame); + + END_INTERFACE + } IDeckLinkVideoFrame3DExtensionsVtbl; + + interface IDeckLinkVideoFrame3DExtensions + { + CONST_VTBL struct IDeckLinkVideoFrame3DExtensionsVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkVideoFrame3DExtensions_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkVideoFrame3DExtensions_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkVideoFrame3DExtensions_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkVideoFrame3DExtensions_Get3DPackingFormat(This) \ + ( (This)->lpVtbl -> Get3DPackingFormat(This) ) + +#define IDeckLinkVideoFrame3DExtensions_GetFrameForRightEye(This,rightEyeFrame) \ + ( (This)->lpVtbl -> GetFrameForRightEye(This,rightEyeFrame) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkVideoFrame3DExtensions_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkVideoInputFrame_INTERFACE_DEFINED__ +#define __IDeckLinkVideoInputFrame_INTERFACE_DEFINED__ + +/* interface IDeckLinkVideoInputFrame */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkVideoInputFrame; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("05CFE374-537C-4094-9A57-680525118F44") + IDeckLinkVideoInputFrame : public IDeckLinkVideoFrame + { + public: + virtual HRESULT STDMETHODCALLTYPE GetStreamTime( + /* [out] */ BMDTimeValue *frameTime, + /* [out] */ BMDTimeValue *frameDuration, + /* [in] */ BMDTimeScale timeScale) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetHardwareReferenceTimestamp( + /* [in] */ BMDTimeScale timeScale, + /* [out] */ BMDTimeValue *frameTime, + /* [out] */ BMDTimeValue *frameDuration) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkVideoInputFrameVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoInputFrame * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoInputFrame * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoInputFrame * This); + + long ( STDMETHODCALLTYPE *GetWidth )( + IDeckLinkVideoInputFrame * This); + + long ( STDMETHODCALLTYPE *GetHeight )( + IDeckLinkVideoInputFrame * This); + + long ( STDMETHODCALLTYPE *GetRowBytes )( + IDeckLinkVideoInputFrame * This); + + BMDPixelFormat ( STDMETHODCALLTYPE *GetPixelFormat )( + IDeckLinkVideoInputFrame * This); + + BMDFrameFlags ( STDMETHODCALLTYPE *GetFlags )( + IDeckLinkVideoInputFrame * This); + + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IDeckLinkVideoInputFrame * This, + /* [out] */ void **buffer); + + HRESULT ( STDMETHODCALLTYPE *GetTimecode )( + IDeckLinkVideoInputFrame * This, + /* [in] */ BMDTimecodeFormat format, + /* [out] */ IDeckLinkTimecode **timecode); + + HRESULT ( STDMETHODCALLTYPE *GetAncillaryData )( + IDeckLinkVideoInputFrame * This, + /* [out] */ IDeckLinkVideoFrameAncillary **ancillary); + + HRESULT ( STDMETHODCALLTYPE *GetStreamTime )( + IDeckLinkVideoInputFrame * This, + /* [out] */ BMDTimeValue *frameTime, + /* [out] */ BMDTimeValue *frameDuration, + /* [in] */ BMDTimeScale timeScale); + + HRESULT ( STDMETHODCALLTYPE *GetHardwareReferenceTimestamp )( + IDeckLinkVideoInputFrame * This, + /* [in] */ BMDTimeScale timeScale, + /* [out] */ BMDTimeValue *frameTime, + /* [out] */ BMDTimeValue *frameDuration); + + END_INTERFACE + } IDeckLinkVideoInputFrameVtbl; + + interface IDeckLinkVideoInputFrame + { + CONST_VTBL struct IDeckLinkVideoInputFrameVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkVideoInputFrame_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkVideoInputFrame_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkVideoInputFrame_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkVideoInputFrame_GetWidth(This) \ + ( (This)->lpVtbl -> GetWidth(This) ) + +#define IDeckLinkVideoInputFrame_GetHeight(This) \ + ( (This)->lpVtbl -> GetHeight(This) ) + +#define IDeckLinkVideoInputFrame_GetRowBytes(This) \ + ( (This)->lpVtbl -> GetRowBytes(This) ) + +#define IDeckLinkVideoInputFrame_GetPixelFormat(This) \ + ( (This)->lpVtbl -> GetPixelFormat(This) ) + +#define IDeckLinkVideoInputFrame_GetFlags(This) \ + ( (This)->lpVtbl -> GetFlags(This) ) + +#define IDeckLinkVideoInputFrame_GetBytes(This,buffer) \ + ( (This)->lpVtbl -> GetBytes(This,buffer) ) + +#define IDeckLinkVideoInputFrame_GetTimecode(This,format,timecode) \ + ( (This)->lpVtbl -> GetTimecode(This,format,timecode) ) + +#define IDeckLinkVideoInputFrame_GetAncillaryData(This,ancillary) \ + ( (This)->lpVtbl -> GetAncillaryData(This,ancillary) ) + + +#define IDeckLinkVideoInputFrame_GetStreamTime(This,frameTime,frameDuration,timeScale) \ + ( (This)->lpVtbl -> GetStreamTime(This,frameTime,frameDuration,timeScale) ) + +#define IDeckLinkVideoInputFrame_GetHardwareReferenceTimestamp(This,timeScale,frameTime,frameDuration) \ + ( (This)->lpVtbl -> GetHardwareReferenceTimestamp(This,timeScale,frameTime,frameDuration) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkVideoInputFrame_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkVideoFrameAncillary_INTERFACE_DEFINED__ +#define __IDeckLinkVideoFrameAncillary_INTERFACE_DEFINED__ + +/* interface IDeckLinkVideoFrameAncillary */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkVideoFrameAncillary; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("732E723C-D1A4-4E29-9E8E-4A88797A0004") + IDeckLinkVideoFrameAncillary : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetBufferForVerticalBlankingLine( + /* [in] */ unsigned int lineNumber, + /* [out] */ void **buffer) = 0; + + virtual BMDPixelFormat STDMETHODCALLTYPE GetPixelFormat( void) = 0; + + virtual BMDDisplayMode STDMETHODCALLTYPE GetDisplayMode( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkVideoFrameAncillaryVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoFrameAncillary * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoFrameAncillary * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoFrameAncillary * This); + + HRESULT ( STDMETHODCALLTYPE *GetBufferForVerticalBlankingLine )( + IDeckLinkVideoFrameAncillary * This, + /* [in] */ unsigned int lineNumber, + /* [out] */ void **buffer); + + BMDPixelFormat ( STDMETHODCALLTYPE *GetPixelFormat )( + IDeckLinkVideoFrameAncillary * This); + + BMDDisplayMode ( STDMETHODCALLTYPE *GetDisplayMode )( + IDeckLinkVideoFrameAncillary * This); + + END_INTERFACE + } IDeckLinkVideoFrameAncillaryVtbl; + + interface IDeckLinkVideoFrameAncillary + { + CONST_VTBL struct IDeckLinkVideoFrameAncillaryVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkVideoFrameAncillary_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkVideoFrameAncillary_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkVideoFrameAncillary_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkVideoFrameAncillary_GetBufferForVerticalBlankingLine(This,lineNumber,buffer) \ + ( (This)->lpVtbl -> GetBufferForVerticalBlankingLine(This,lineNumber,buffer) ) + +#define IDeckLinkVideoFrameAncillary_GetPixelFormat(This) \ + ( (This)->lpVtbl -> GetPixelFormat(This) ) + +#define IDeckLinkVideoFrameAncillary_GetDisplayMode(This) \ + ( (This)->lpVtbl -> GetDisplayMode(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkVideoFrameAncillary_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkAudioInputPacket_INTERFACE_DEFINED__ +#define __IDeckLinkAudioInputPacket_INTERFACE_DEFINED__ + +/* interface IDeckLinkAudioInputPacket */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkAudioInputPacket; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("E43D5870-2894-11DE-8C30-0800200C9A66") + IDeckLinkAudioInputPacket : public IUnknown + { + public: + virtual long STDMETHODCALLTYPE GetSampleFrameCount( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBytes( + /* [out] */ void **buffer) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPacketTime( + /* [out] */ BMDTimeValue *packetTime, + /* [in] */ BMDTimeScale timeScale) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkAudioInputPacketVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkAudioInputPacket * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkAudioInputPacket * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkAudioInputPacket * This); + + long ( STDMETHODCALLTYPE *GetSampleFrameCount )( + IDeckLinkAudioInputPacket * This); + + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IDeckLinkAudioInputPacket * This, + /* [out] */ void **buffer); + + HRESULT ( STDMETHODCALLTYPE *GetPacketTime )( + IDeckLinkAudioInputPacket * This, + /* [out] */ BMDTimeValue *packetTime, + /* [in] */ BMDTimeScale timeScale); + + END_INTERFACE + } IDeckLinkAudioInputPacketVtbl; + + interface IDeckLinkAudioInputPacket + { + CONST_VTBL struct IDeckLinkAudioInputPacketVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkAudioInputPacket_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkAudioInputPacket_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkAudioInputPacket_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkAudioInputPacket_GetSampleFrameCount(This) \ + ( (This)->lpVtbl -> GetSampleFrameCount(This) ) + +#define IDeckLinkAudioInputPacket_GetBytes(This,buffer) \ + ( (This)->lpVtbl -> GetBytes(This,buffer) ) + +#define IDeckLinkAudioInputPacket_GetPacketTime(This,packetTime,timeScale) \ + ( (This)->lpVtbl -> GetPacketTime(This,packetTime,timeScale) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkAudioInputPacket_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkScreenPreviewCallback_INTERFACE_DEFINED__ +#define __IDeckLinkScreenPreviewCallback_INTERFACE_DEFINED__ + +/* interface IDeckLinkScreenPreviewCallback */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkScreenPreviewCallback; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("B1D3F49A-85FE-4C5D-95C8-0B5D5DCCD438") + IDeckLinkScreenPreviewCallback : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE DrawFrame( + /* [in] */ IDeckLinkVideoFrame *theFrame) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkScreenPreviewCallbackVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkScreenPreviewCallback * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkScreenPreviewCallback * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkScreenPreviewCallback * This); + + HRESULT ( STDMETHODCALLTYPE *DrawFrame )( + IDeckLinkScreenPreviewCallback * This, + /* [in] */ IDeckLinkVideoFrame *theFrame); + + END_INTERFACE + } IDeckLinkScreenPreviewCallbackVtbl; + + interface IDeckLinkScreenPreviewCallback + { + CONST_VTBL struct IDeckLinkScreenPreviewCallbackVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkScreenPreviewCallback_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkScreenPreviewCallback_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkScreenPreviewCallback_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkScreenPreviewCallback_DrawFrame(This,theFrame) \ + ( (This)->lpVtbl -> DrawFrame(This,theFrame) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkScreenPreviewCallback_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkGLScreenPreviewHelper_INTERFACE_DEFINED__ +#define __IDeckLinkGLScreenPreviewHelper_INTERFACE_DEFINED__ + +/* interface IDeckLinkGLScreenPreviewHelper */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkGLScreenPreviewHelper; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("504E2209-CAC7-4C1A-9FB4-C5BB6274D22F") + IDeckLinkGLScreenPreviewHelper : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE InitializeGL( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE PaintGL( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetFrame( + /* [in] */ IDeckLinkVideoFrame *theFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE Set3DPreviewFormat( + /* [in] */ BMD3DPreviewFormat previewFormat) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkGLScreenPreviewHelperVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkGLScreenPreviewHelper * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkGLScreenPreviewHelper * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkGLScreenPreviewHelper * This); + + HRESULT ( STDMETHODCALLTYPE *InitializeGL )( + IDeckLinkGLScreenPreviewHelper * This); + + HRESULT ( STDMETHODCALLTYPE *PaintGL )( + IDeckLinkGLScreenPreviewHelper * This); + + HRESULT ( STDMETHODCALLTYPE *SetFrame )( + IDeckLinkGLScreenPreviewHelper * This, + /* [in] */ IDeckLinkVideoFrame *theFrame); + + HRESULT ( STDMETHODCALLTYPE *Set3DPreviewFormat )( + IDeckLinkGLScreenPreviewHelper * This, + /* [in] */ BMD3DPreviewFormat previewFormat); + + END_INTERFACE + } IDeckLinkGLScreenPreviewHelperVtbl; + + interface IDeckLinkGLScreenPreviewHelper + { + CONST_VTBL struct IDeckLinkGLScreenPreviewHelperVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkGLScreenPreviewHelper_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkGLScreenPreviewHelper_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkGLScreenPreviewHelper_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkGLScreenPreviewHelper_InitializeGL(This) \ + ( (This)->lpVtbl -> InitializeGL(This) ) + +#define IDeckLinkGLScreenPreviewHelper_PaintGL(This) \ + ( (This)->lpVtbl -> PaintGL(This) ) + +#define IDeckLinkGLScreenPreviewHelper_SetFrame(This,theFrame) \ + ( (This)->lpVtbl -> SetFrame(This,theFrame) ) + +#define IDeckLinkGLScreenPreviewHelper_Set3DPreviewFormat(This,previewFormat) \ + ( (This)->lpVtbl -> Set3DPreviewFormat(This,previewFormat) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkGLScreenPreviewHelper_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkDX9ScreenPreviewHelper_INTERFACE_DEFINED__ +#define __IDeckLinkDX9ScreenPreviewHelper_INTERFACE_DEFINED__ + +/* interface IDeckLinkDX9ScreenPreviewHelper */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkDX9ScreenPreviewHelper; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("2094B522-D1A1-40C0-9AC7-1C012218EF02") + IDeckLinkDX9ScreenPreviewHelper : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Initialize( + /* [in] */ void *device) = 0; + + virtual HRESULT STDMETHODCALLTYPE Render( + /* [in] */ RECT *rc) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetFrame( + /* [in] */ IDeckLinkVideoFrame *theFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE Set3DPreviewFormat( + /* [in] */ BMD3DPreviewFormat previewFormat) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkDX9ScreenPreviewHelperVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkDX9ScreenPreviewHelper * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkDX9ScreenPreviewHelper * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkDX9ScreenPreviewHelper * This); + + HRESULT ( STDMETHODCALLTYPE *Initialize )( + IDeckLinkDX9ScreenPreviewHelper * This, + /* [in] */ void *device); + + HRESULT ( STDMETHODCALLTYPE *Render )( + IDeckLinkDX9ScreenPreviewHelper * This, + /* [in] */ RECT *rc); + + HRESULT ( STDMETHODCALLTYPE *SetFrame )( + IDeckLinkDX9ScreenPreviewHelper * This, + /* [in] */ IDeckLinkVideoFrame *theFrame); + + HRESULT ( STDMETHODCALLTYPE *Set3DPreviewFormat )( + IDeckLinkDX9ScreenPreviewHelper * This, + /* [in] */ BMD3DPreviewFormat previewFormat); + + END_INTERFACE + } IDeckLinkDX9ScreenPreviewHelperVtbl; + + interface IDeckLinkDX9ScreenPreviewHelper + { + CONST_VTBL struct IDeckLinkDX9ScreenPreviewHelperVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkDX9ScreenPreviewHelper_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkDX9ScreenPreviewHelper_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkDX9ScreenPreviewHelper_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkDX9ScreenPreviewHelper_Initialize(This,device) \ + ( (This)->lpVtbl -> Initialize(This,device) ) + +#define IDeckLinkDX9ScreenPreviewHelper_Render(This,rc) \ + ( (This)->lpVtbl -> Render(This,rc) ) + +#define IDeckLinkDX9ScreenPreviewHelper_SetFrame(This,theFrame) \ + ( (This)->lpVtbl -> SetFrame(This,theFrame) ) + +#define IDeckLinkDX9ScreenPreviewHelper_Set3DPreviewFormat(This,previewFormat) \ + ( (This)->lpVtbl -> Set3DPreviewFormat(This,previewFormat) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkDX9ScreenPreviewHelper_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkNotificationCallback_INTERFACE_DEFINED__ +#define __IDeckLinkNotificationCallback_INTERFACE_DEFINED__ + +/* interface IDeckLinkNotificationCallback */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkNotificationCallback; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("b002a1ec-070d-4288-8289-bd5d36e5ff0d") + IDeckLinkNotificationCallback : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Notify( + /* [in] */ BMDNotifications topic, + /* [in] */ ULONGLONG param1, + /* [in] */ ULONGLONG param2) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkNotificationCallbackVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkNotificationCallback * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkNotificationCallback * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkNotificationCallback * This); + + HRESULT ( STDMETHODCALLTYPE *Notify )( + IDeckLinkNotificationCallback * This, + /* [in] */ BMDNotifications topic, + /* [in] */ ULONGLONG param1, + /* [in] */ ULONGLONG param2); + + END_INTERFACE + } IDeckLinkNotificationCallbackVtbl; + + interface IDeckLinkNotificationCallback + { + CONST_VTBL struct IDeckLinkNotificationCallbackVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkNotificationCallback_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkNotificationCallback_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkNotificationCallback_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkNotificationCallback_Notify(This,topic,param1,param2) \ + ( (This)->lpVtbl -> Notify(This,topic,param1,param2) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkNotificationCallback_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkNotification_INTERFACE_DEFINED__ +#define __IDeckLinkNotification_INTERFACE_DEFINED__ + +/* interface IDeckLinkNotification */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkNotification; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("0a1fb207-e215-441b-9b19-6fa1575946c5") + IDeckLinkNotification : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Subscribe( + /* [in] */ BMDNotifications topic, + /* [in] */ IDeckLinkNotificationCallback *theCallback) = 0; + + virtual HRESULT STDMETHODCALLTYPE Unsubscribe( + /* [in] */ BMDNotifications topic, + /* [in] */ IDeckLinkNotificationCallback *theCallback) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkNotificationVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkNotification * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkNotification * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkNotification * This); + + HRESULT ( STDMETHODCALLTYPE *Subscribe )( + IDeckLinkNotification * This, + /* [in] */ BMDNotifications topic, + /* [in] */ IDeckLinkNotificationCallback *theCallback); + + HRESULT ( STDMETHODCALLTYPE *Unsubscribe )( + IDeckLinkNotification * This, + /* [in] */ BMDNotifications topic, + /* [in] */ IDeckLinkNotificationCallback *theCallback); + + END_INTERFACE + } IDeckLinkNotificationVtbl; + + interface IDeckLinkNotification + { + CONST_VTBL struct IDeckLinkNotificationVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkNotification_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkNotification_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkNotification_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkNotification_Subscribe(This,topic,theCallback) \ + ( (This)->lpVtbl -> Subscribe(This,topic,theCallback) ) + +#define IDeckLinkNotification_Unsubscribe(This,topic,theCallback) \ + ( (This)->lpVtbl -> Unsubscribe(This,topic,theCallback) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkNotification_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkAttributes_INTERFACE_DEFINED__ +#define __IDeckLinkAttributes_INTERFACE_DEFINED__ + +/* interface IDeckLinkAttributes */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkAttributes; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("ABC11843-D966-44CB-96E2-A1CB5D3135C4") + IDeckLinkAttributes : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetFlag( + /* [in] */ BMDDeckLinkAttributeID cfgID, + /* [out] */ BOOL *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInt( + /* [in] */ BMDDeckLinkAttributeID cfgID, + /* [out] */ LONGLONG *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFloat( + /* [in] */ BMDDeckLinkAttributeID cfgID, + /* [out] */ double *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetString( + /* [in] */ BMDDeckLinkAttributeID cfgID, + /* [out] */ BSTR *value) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkAttributesVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkAttributes * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkAttributes * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkAttributes * This); + + HRESULT ( STDMETHODCALLTYPE *GetFlag )( + IDeckLinkAttributes * This, + /* [in] */ BMDDeckLinkAttributeID cfgID, + /* [out] */ BOOL *value); + + HRESULT ( STDMETHODCALLTYPE *GetInt )( + IDeckLinkAttributes * This, + /* [in] */ BMDDeckLinkAttributeID cfgID, + /* [out] */ LONGLONG *value); + + HRESULT ( STDMETHODCALLTYPE *GetFloat )( + IDeckLinkAttributes * This, + /* [in] */ BMDDeckLinkAttributeID cfgID, + /* [out] */ double *value); + + HRESULT ( STDMETHODCALLTYPE *GetString )( + IDeckLinkAttributes * This, + /* [in] */ BMDDeckLinkAttributeID cfgID, + /* [out] */ BSTR *value); + + END_INTERFACE + } IDeckLinkAttributesVtbl; + + interface IDeckLinkAttributes + { + CONST_VTBL struct IDeckLinkAttributesVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkAttributes_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkAttributes_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkAttributes_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkAttributes_GetFlag(This,cfgID,value) \ + ( (This)->lpVtbl -> GetFlag(This,cfgID,value) ) + +#define IDeckLinkAttributes_GetInt(This,cfgID,value) \ + ( (This)->lpVtbl -> GetInt(This,cfgID,value) ) + +#define IDeckLinkAttributes_GetFloat(This,cfgID,value) \ + ( (This)->lpVtbl -> GetFloat(This,cfgID,value) ) + +#define IDeckLinkAttributes_GetString(This,cfgID,value) \ + ( (This)->lpVtbl -> GetString(This,cfgID,value) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkAttributes_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkKeyer_INTERFACE_DEFINED__ +#define __IDeckLinkKeyer_INTERFACE_DEFINED__ + +/* interface IDeckLinkKeyer */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkKeyer; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("89AFCAF5-65F8-421E-98F7-96FE5F5BFBA3") + IDeckLinkKeyer : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Enable( + /* [in] */ BOOL isExternal) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetLevel( + /* [in] */ unsigned char level) = 0; + + virtual HRESULT STDMETHODCALLTYPE RampUp( + /* [in] */ unsigned int numberOfFrames) = 0; + + virtual HRESULT STDMETHODCALLTYPE RampDown( + /* [in] */ unsigned int numberOfFrames) = 0; + + virtual HRESULT STDMETHODCALLTYPE Disable( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkKeyerVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkKeyer * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkKeyer * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkKeyer * This); + + HRESULT ( STDMETHODCALLTYPE *Enable )( + IDeckLinkKeyer * This, + /* [in] */ BOOL isExternal); + + HRESULT ( STDMETHODCALLTYPE *SetLevel )( + IDeckLinkKeyer * This, + /* [in] */ unsigned char level); + + HRESULT ( STDMETHODCALLTYPE *RampUp )( + IDeckLinkKeyer * This, + /* [in] */ unsigned int numberOfFrames); + + HRESULT ( STDMETHODCALLTYPE *RampDown )( + IDeckLinkKeyer * This, + /* [in] */ unsigned int numberOfFrames); + + HRESULT ( STDMETHODCALLTYPE *Disable )( + IDeckLinkKeyer * This); + + END_INTERFACE + } IDeckLinkKeyerVtbl; + + interface IDeckLinkKeyer + { + CONST_VTBL struct IDeckLinkKeyerVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkKeyer_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkKeyer_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkKeyer_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkKeyer_Enable(This,isExternal) \ + ( (This)->lpVtbl -> Enable(This,isExternal) ) + +#define IDeckLinkKeyer_SetLevel(This,level) \ + ( (This)->lpVtbl -> SetLevel(This,level) ) + +#define IDeckLinkKeyer_RampUp(This,numberOfFrames) \ + ( (This)->lpVtbl -> RampUp(This,numberOfFrames) ) + +#define IDeckLinkKeyer_RampDown(This,numberOfFrames) \ + ( (This)->lpVtbl -> RampDown(This,numberOfFrames) ) + +#define IDeckLinkKeyer_Disable(This) \ + ( (This)->lpVtbl -> Disable(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkKeyer_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkVideoConversion_INTERFACE_DEFINED__ +#define __IDeckLinkVideoConversion_INTERFACE_DEFINED__ + +/* interface IDeckLinkVideoConversion */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkVideoConversion; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("3BBCB8A2-DA2C-42D9-B5D8-88083644E99A") + IDeckLinkVideoConversion : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE ConvertFrame( + /* [in] */ IDeckLinkVideoFrame *srcFrame, + /* [in] */ IDeckLinkVideoFrame *dstFrame) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkVideoConversionVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoConversion * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoConversion * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoConversion * This); + + HRESULT ( STDMETHODCALLTYPE *ConvertFrame )( + IDeckLinkVideoConversion * This, + /* [in] */ IDeckLinkVideoFrame *srcFrame, + /* [in] */ IDeckLinkVideoFrame *dstFrame); + + END_INTERFACE + } IDeckLinkVideoConversionVtbl; + + interface IDeckLinkVideoConversion + { + CONST_VTBL struct IDeckLinkVideoConversionVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkVideoConversion_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkVideoConversion_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkVideoConversion_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkVideoConversion_ConvertFrame(This,srcFrame,dstFrame) \ + ( (This)->lpVtbl -> ConvertFrame(This,srcFrame,dstFrame) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkVideoConversion_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkDeviceNotificationCallback_INTERFACE_DEFINED__ +#define __IDeckLinkDeviceNotificationCallback_INTERFACE_DEFINED__ + +/* interface IDeckLinkDeviceNotificationCallback */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkDeviceNotificationCallback; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("4997053B-0ADF-4CC8-AC70-7A50C4BE728F") + IDeckLinkDeviceNotificationCallback : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE DeckLinkDeviceArrived( + /* [in] */ IDeckLink *deckLinkDevice) = 0; + + virtual HRESULT STDMETHODCALLTYPE DeckLinkDeviceRemoved( + /* [in] */ IDeckLink *deckLinkDevice) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkDeviceNotificationCallbackVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkDeviceNotificationCallback * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkDeviceNotificationCallback * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkDeviceNotificationCallback * This); + + HRESULT ( STDMETHODCALLTYPE *DeckLinkDeviceArrived )( + IDeckLinkDeviceNotificationCallback * This, + /* [in] */ IDeckLink *deckLinkDevice); + + HRESULT ( STDMETHODCALLTYPE *DeckLinkDeviceRemoved )( + IDeckLinkDeviceNotificationCallback * This, + /* [in] */ IDeckLink *deckLinkDevice); + + END_INTERFACE + } IDeckLinkDeviceNotificationCallbackVtbl; + + interface IDeckLinkDeviceNotificationCallback + { + CONST_VTBL struct IDeckLinkDeviceNotificationCallbackVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkDeviceNotificationCallback_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkDeviceNotificationCallback_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkDeviceNotificationCallback_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkDeviceNotificationCallback_DeckLinkDeviceArrived(This,deckLinkDevice) \ + ( (This)->lpVtbl -> DeckLinkDeviceArrived(This,deckLinkDevice) ) + +#define IDeckLinkDeviceNotificationCallback_DeckLinkDeviceRemoved(This,deckLinkDevice) \ + ( (This)->lpVtbl -> DeckLinkDeviceRemoved(This,deckLinkDevice) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkDeviceNotificationCallback_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkDiscovery_INTERFACE_DEFINED__ +#define __IDeckLinkDiscovery_INTERFACE_DEFINED__ + +/* interface IDeckLinkDiscovery */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkDiscovery; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("CDBF631C-BC76-45FA-B44D-C55059BC6101") + IDeckLinkDiscovery : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE InstallDeviceNotifications( + /* [in] */ IDeckLinkDeviceNotificationCallback *deviceNotificationCallback) = 0; + + virtual HRESULT STDMETHODCALLTYPE UninstallDeviceNotifications( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkDiscoveryVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkDiscovery * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkDiscovery * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkDiscovery * This); + + HRESULT ( STDMETHODCALLTYPE *InstallDeviceNotifications )( + IDeckLinkDiscovery * This, + /* [in] */ IDeckLinkDeviceNotificationCallback *deviceNotificationCallback); + + HRESULT ( STDMETHODCALLTYPE *UninstallDeviceNotifications )( + IDeckLinkDiscovery * This); + + END_INTERFACE + } IDeckLinkDiscoveryVtbl; + + interface IDeckLinkDiscovery + { + CONST_VTBL struct IDeckLinkDiscoveryVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkDiscovery_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkDiscovery_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkDiscovery_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkDiscovery_InstallDeviceNotifications(This,deviceNotificationCallback) \ + ( (This)->lpVtbl -> InstallDeviceNotifications(This,deviceNotificationCallback) ) + +#define IDeckLinkDiscovery_UninstallDeviceNotifications(This) \ + ( (This)->lpVtbl -> UninstallDeviceNotifications(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkDiscovery_INTERFACE_DEFINED__ */ + + +EXTERN_C const CLSID CLSID_CDeckLinkIterator; + +#ifdef __cplusplus + +class DECLSPEC_UUID("1F2E109A-8F4F-49E4-9203-135595CB6FA5") +CDeckLinkIterator; +#endif + +EXTERN_C const CLSID CLSID_CDeckLinkAPIInformation; + +#ifdef __cplusplus + +class DECLSPEC_UUID("263CA19F-ED09-482E-9F9D-84005783A237") +CDeckLinkAPIInformation; +#endif + +EXTERN_C const CLSID CLSID_CDeckLinkGLScreenPreviewHelper; + +#ifdef __cplusplus + +class DECLSPEC_UUID("F63E77C7-B655-4A4A-9AD0-3CA85D394343") +CDeckLinkGLScreenPreviewHelper; +#endif + +EXTERN_C const CLSID CLSID_CDeckLinkDX9ScreenPreviewHelper; + +#ifdef __cplusplus + +class DECLSPEC_UUID("CC010023-E01D-4525-9D59-80C8AB3DC7A0") +CDeckLinkDX9ScreenPreviewHelper; +#endif + +EXTERN_C const CLSID CLSID_CDeckLinkVideoConversion; + +#ifdef __cplusplus + +class DECLSPEC_UUID("7DBBBB11-5B7B-467D-AEA4-CEA468FD368C") +CDeckLinkVideoConversion; +#endif + +EXTERN_C const CLSID CLSID_CDeckLinkDiscovery; + +#ifdef __cplusplus + +class DECLSPEC_UUID("1073A05C-D885-47E9-B3C6-129B3F9F648B") +CDeckLinkDiscovery; +#endif + +#ifndef __IDeckLinkConfiguration_v10_2_INTERFACE_DEFINED__ +#define __IDeckLinkConfiguration_v10_2_INTERFACE_DEFINED__ + +/* interface IDeckLinkConfiguration_v10_2 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkConfiguration_v10_2; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("C679A35B-610C-4D09-B748-1D0478100FC0") + IDeckLinkConfiguration_v10_2 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetFlag( + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ BOOL value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFlag( + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ BOOL *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetInt( + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ LONGLONG value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInt( + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ LONGLONG *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetFloat( + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ double value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFloat( + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ double *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetString( + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ BSTR value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetString( + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ BSTR *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE WriteConfigurationToPreferences( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkConfiguration_v10_2Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkConfiguration_v10_2 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkConfiguration_v10_2 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkConfiguration_v10_2 * This); + + HRESULT ( STDMETHODCALLTYPE *SetFlag )( + IDeckLinkConfiguration_v10_2 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ BOOL value); + + HRESULT ( STDMETHODCALLTYPE *GetFlag )( + IDeckLinkConfiguration_v10_2 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ BOOL *value); + + HRESULT ( STDMETHODCALLTYPE *SetInt )( + IDeckLinkConfiguration_v10_2 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ LONGLONG value); + + HRESULT ( STDMETHODCALLTYPE *GetInt )( + IDeckLinkConfiguration_v10_2 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ LONGLONG *value); + + HRESULT ( STDMETHODCALLTYPE *SetFloat )( + IDeckLinkConfiguration_v10_2 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ double value); + + HRESULT ( STDMETHODCALLTYPE *GetFloat )( + IDeckLinkConfiguration_v10_2 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ double *value); + + HRESULT ( STDMETHODCALLTYPE *SetString )( + IDeckLinkConfiguration_v10_2 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ BSTR value); + + HRESULT ( STDMETHODCALLTYPE *GetString )( + IDeckLinkConfiguration_v10_2 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ BSTR *value); + + HRESULT ( STDMETHODCALLTYPE *WriteConfigurationToPreferences )( + IDeckLinkConfiguration_v10_2 * This); + + END_INTERFACE + } IDeckLinkConfiguration_v10_2Vtbl; + + interface IDeckLinkConfiguration_v10_2 + { + CONST_VTBL struct IDeckLinkConfiguration_v10_2Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkConfiguration_v10_2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkConfiguration_v10_2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkConfiguration_v10_2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkConfiguration_v10_2_SetFlag(This,cfgID,value) \ + ( (This)->lpVtbl -> SetFlag(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v10_2_GetFlag(This,cfgID,value) \ + ( (This)->lpVtbl -> GetFlag(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v10_2_SetInt(This,cfgID,value) \ + ( (This)->lpVtbl -> SetInt(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v10_2_GetInt(This,cfgID,value) \ + ( (This)->lpVtbl -> GetInt(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v10_2_SetFloat(This,cfgID,value) \ + ( (This)->lpVtbl -> SetFloat(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v10_2_GetFloat(This,cfgID,value) \ + ( (This)->lpVtbl -> GetFloat(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v10_2_SetString(This,cfgID,value) \ + ( (This)->lpVtbl -> SetString(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v10_2_GetString(This,cfgID,value) \ + ( (This)->lpVtbl -> GetString(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v10_2_WriteConfigurationToPreferences(This) \ + ( (This)->lpVtbl -> WriteConfigurationToPreferences(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkConfiguration_v10_2_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkOutput_v9_9_INTERFACE_DEFINED__ +#define __IDeckLinkOutput_v9_9_INTERFACE_DEFINED__ + +/* interface IDeckLinkOutput_v9_9 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkOutput_v9_9; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("A3EF0963-0862-44ED-92A9-EE89ABF431C7") + IDeckLinkOutput_v9_9 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE DoesSupportVideoMode( + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDVideoOutputFlags flags, + /* [out] */ BMDDisplayModeSupport *result, + /* [out] */ IDeckLinkDisplayMode **resultDisplayMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayModeIterator( + /* [out] */ IDeckLinkDisplayModeIterator **iterator) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetScreenPreviewCallback( + /* [in] */ IDeckLinkScreenPreviewCallback *previewCallback) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableVideoOutput( + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDVideoOutputFlags flags) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisableVideoOutput( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetVideoOutputFrameMemoryAllocator( + /* [in] */ IDeckLinkMemoryAllocator *theAllocator) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateVideoFrame( + /* [in] */ int width, + /* [in] */ int height, + /* [in] */ int rowBytes, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDFrameFlags flags, + /* [out] */ IDeckLinkMutableVideoFrame **outFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateAncillaryData( + /* [in] */ BMDPixelFormat pixelFormat, + /* [out] */ IDeckLinkVideoFrameAncillary **outBuffer) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisplayVideoFrameSync( + /* [in] */ IDeckLinkVideoFrame *theFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE ScheduleVideoFrame( + /* [in] */ IDeckLinkVideoFrame *theFrame, + /* [in] */ BMDTimeValue displayTime, + /* [in] */ BMDTimeValue displayDuration, + /* [in] */ BMDTimeScale timeScale) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetScheduledFrameCompletionCallback( + /* [in] */ IDeckLinkVideoOutputCallback *theCallback) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBufferedVideoFrameCount( + /* [out] */ unsigned int *bufferedFrameCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableAudioOutput( + /* [in] */ BMDAudioSampleRate sampleRate, + /* [in] */ BMDAudioSampleType sampleType, + /* [in] */ unsigned int channelCount, + /* [in] */ BMDAudioOutputStreamType streamType) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisableAudioOutput( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE WriteAudioSamplesSync( + /* [in] */ void *buffer, + /* [in] */ unsigned int sampleFrameCount, + /* [out] */ unsigned int *sampleFramesWritten) = 0; + + virtual HRESULT STDMETHODCALLTYPE BeginAudioPreroll( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE EndAudioPreroll( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE ScheduleAudioSamples( + /* [in] */ void *buffer, + /* [in] */ unsigned int sampleFrameCount, + /* [in] */ BMDTimeValue streamTime, + /* [in] */ BMDTimeScale timeScale, + /* [out] */ unsigned int *sampleFramesWritten) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBufferedAudioSampleFrameCount( + /* [out] */ unsigned int *bufferedSampleFrameCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE FlushBufferedAudioSamples( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetAudioCallback( + /* [in] */ IDeckLinkAudioOutputCallback *theCallback) = 0; + + virtual HRESULT STDMETHODCALLTYPE StartScheduledPlayback( + /* [in] */ BMDTimeValue playbackStartTime, + /* [in] */ BMDTimeScale timeScale, + /* [in] */ double playbackSpeed) = 0; + + virtual HRESULT STDMETHODCALLTYPE StopScheduledPlayback( + /* [in] */ BMDTimeValue stopPlaybackAtTime, + /* [out] */ BMDTimeValue *actualStopTime, + /* [in] */ BMDTimeScale timeScale) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsScheduledPlaybackRunning( + /* [out] */ BOOL *active) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetScheduledStreamTime( + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *streamTime, + /* [out] */ double *playbackSpeed) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetReferenceStatus( + /* [out] */ BMDReferenceStatus *referenceStatus) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetHardwareReferenceClock( + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *hardwareTime, + /* [out] */ BMDTimeValue *timeInFrame, + /* [out] */ BMDTimeValue *ticksPerFrame) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkOutput_v9_9Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkOutput_v9_9 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkOutput_v9_9 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkOutput_v9_9 * This); + + HRESULT ( STDMETHODCALLTYPE *DoesSupportVideoMode )( + IDeckLinkOutput_v9_9 * This, + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDVideoOutputFlags flags, + /* [out] */ BMDDisplayModeSupport *result, + /* [out] */ IDeckLinkDisplayMode **resultDisplayMode); + + HRESULT ( STDMETHODCALLTYPE *GetDisplayModeIterator )( + IDeckLinkOutput_v9_9 * This, + /* [out] */ IDeckLinkDisplayModeIterator **iterator); + + HRESULT ( STDMETHODCALLTYPE *SetScreenPreviewCallback )( + IDeckLinkOutput_v9_9 * This, + /* [in] */ IDeckLinkScreenPreviewCallback *previewCallback); + + HRESULT ( STDMETHODCALLTYPE *EnableVideoOutput )( + IDeckLinkOutput_v9_9 * This, + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDVideoOutputFlags flags); + + HRESULT ( STDMETHODCALLTYPE *DisableVideoOutput )( + IDeckLinkOutput_v9_9 * This); + + HRESULT ( STDMETHODCALLTYPE *SetVideoOutputFrameMemoryAllocator )( + IDeckLinkOutput_v9_9 * This, + /* [in] */ IDeckLinkMemoryAllocator *theAllocator); + + HRESULT ( STDMETHODCALLTYPE *CreateVideoFrame )( + IDeckLinkOutput_v9_9 * This, + /* [in] */ int width, + /* [in] */ int height, + /* [in] */ int rowBytes, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDFrameFlags flags, + /* [out] */ IDeckLinkMutableVideoFrame **outFrame); + + HRESULT ( STDMETHODCALLTYPE *CreateAncillaryData )( + IDeckLinkOutput_v9_9 * This, + /* [in] */ BMDPixelFormat pixelFormat, + /* [out] */ IDeckLinkVideoFrameAncillary **outBuffer); + + HRESULT ( STDMETHODCALLTYPE *DisplayVideoFrameSync )( + IDeckLinkOutput_v9_9 * This, + /* [in] */ IDeckLinkVideoFrame *theFrame); + + HRESULT ( STDMETHODCALLTYPE *ScheduleVideoFrame )( + IDeckLinkOutput_v9_9 * This, + /* [in] */ IDeckLinkVideoFrame *theFrame, + /* [in] */ BMDTimeValue displayTime, + /* [in] */ BMDTimeValue displayDuration, + /* [in] */ BMDTimeScale timeScale); + + HRESULT ( STDMETHODCALLTYPE *SetScheduledFrameCompletionCallback )( + IDeckLinkOutput_v9_9 * This, + /* [in] */ IDeckLinkVideoOutputCallback *theCallback); + + HRESULT ( STDMETHODCALLTYPE *GetBufferedVideoFrameCount )( + IDeckLinkOutput_v9_9 * This, + /* [out] */ unsigned int *bufferedFrameCount); + + HRESULT ( STDMETHODCALLTYPE *EnableAudioOutput )( + IDeckLinkOutput_v9_9 * This, + /* [in] */ BMDAudioSampleRate sampleRate, + /* [in] */ BMDAudioSampleType sampleType, + /* [in] */ unsigned int channelCount, + /* [in] */ BMDAudioOutputStreamType streamType); + + HRESULT ( STDMETHODCALLTYPE *DisableAudioOutput )( + IDeckLinkOutput_v9_9 * This); + + HRESULT ( STDMETHODCALLTYPE *WriteAudioSamplesSync )( + IDeckLinkOutput_v9_9 * This, + /* [in] */ void *buffer, + /* [in] */ unsigned int sampleFrameCount, + /* [out] */ unsigned int *sampleFramesWritten); + + HRESULT ( STDMETHODCALLTYPE *BeginAudioPreroll )( + IDeckLinkOutput_v9_9 * This); + + HRESULT ( STDMETHODCALLTYPE *EndAudioPreroll )( + IDeckLinkOutput_v9_9 * This); + + HRESULT ( STDMETHODCALLTYPE *ScheduleAudioSamples )( + IDeckLinkOutput_v9_9 * This, + /* [in] */ void *buffer, + /* [in] */ unsigned int sampleFrameCount, + /* [in] */ BMDTimeValue streamTime, + /* [in] */ BMDTimeScale timeScale, + /* [out] */ unsigned int *sampleFramesWritten); + + HRESULT ( STDMETHODCALLTYPE *GetBufferedAudioSampleFrameCount )( + IDeckLinkOutput_v9_9 * This, + /* [out] */ unsigned int *bufferedSampleFrameCount); + + HRESULT ( STDMETHODCALLTYPE *FlushBufferedAudioSamples )( + IDeckLinkOutput_v9_9 * This); + + HRESULT ( STDMETHODCALLTYPE *SetAudioCallback )( + IDeckLinkOutput_v9_9 * This, + /* [in] */ IDeckLinkAudioOutputCallback *theCallback); + + HRESULT ( STDMETHODCALLTYPE *StartScheduledPlayback )( + IDeckLinkOutput_v9_9 * This, + /* [in] */ BMDTimeValue playbackStartTime, + /* [in] */ BMDTimeScale timeScale, + /* [in] */ double playbackSpeed); + + HRESULT ( STDMETHODCALLTYPE *StopScheduledPlayback )( + IDeckLinkOutput_v9_9 * This, + /* [in] */ BMDTimeValue stopPlaybackAtTime, + /* [out] */ BMDTimeValue *actualStopTime, + /* [in] */ BMDTimeScale timeScale); + + HRESULT ( STDMETHODCALLTYPE *IsScheduledPlaybackRunning )( + IDeckLinkOutput_v9_9 * This, + /* [out] */ BOOL *active); + + HRESULT ( STDMETHODCALLTYPE *GetScheduledStreamTime )( + IDeckLinkOutput_v9_9 * This, + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *streamTime, + /* [out] */ double *playbackSpeed); + + HRESULT ( STDMETHODCALLTYPE *GetReferenceStatus )( + IDeckLinkOutput_v9_9 * This, + /* [out] */ BMDReferenceStatus *referenceStatus); + + HRESULT ( STDMETHODCALLTYPE *GetHardwareReferenceClock )( + IDeckLinkOutput_v9_9 * This, + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *hardwareTime, + /* [out] */ BMDTimeValue *timeInFrame, + /* [out] */ BMDTimeValue *ticksPerFrame); + + END_INTERFACE + } IDeckLinkOutput_v9_9Vtbl; + + interface IDeckLinkOutput_v9_9 + { + CONST_VTBL struct IDeckLinkOutput_v9_9Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkOutput_v9_9_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkOutput_v9_9_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkOutput_v9_9_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkOutput_v9_9_DoesSupportVideoMode(This,displayMode,pixelFormat,flags,result,resultDisplayMode) \ + ( (This)->lpVtbl -> DoesSupportVideoMode(This,displayMode,pixelFormat,flags,result,resultDisplayMode) ) + +#define IDeckLinkOutput_v9_9_GetDisplayModeIterator(This,iterator) \ + ( (This)->lpVtbl -> GetDisplayModeIterator(This,iterator) ) + +#define IDeckLinkOutput_v9_9_SetScreenPreviewCallback(This,previewCallback) \ + ( (This)->lpVtbl -> SetScreenPreviewCallback(This,previewCallback) ) + +#define IDeckLinkOutput_v9_9_EnableVideoOutput(This,displayMode,flags) \ + ( (This)->lpVtbl -> EnableVideoOutput(This,displayMode,flags) ) + +#define IDeckLinkOutput_v9_9_DisableVideoOutput(This) \ + ( (This)->lpVtbl -> DisableVideoOutput(This) ) + +#define IDeckLinkOutput_v9_9_SetVideoOutputFrameMemoryAllocator(This,theAllocator) \ + ( (This)->lpVtbl -> SetVideoOutputFrameMemoryAllocator(This,theAllocator) ) + +#define IDeckLinkOutput_v9_9_CreateVideoFrame(This,width,height,rowBytes,pixelFormat,flags,outFrame) \ + ( (This)->lpVtbl -> CreateVideoFrame(This,width,height,rowBytes,pixelFormat,flags,outFrame) ) + +#define IDeckLinkOutput_v9_9_CreateAncillaryData(This,pixelFormat,outBuffer) \ + ( (This)->lpVtbl -> CreateAncillaryData(This,pixelFormat,outBuffer) ) + +#define IDeckLinkOutput_v9_9_DisplayVideoFrameSync(This,theFrame) \ + ( (This)->lpVtbl -> DisplayVideoFrameSync(This,theFrame) ) + +#define IDeckLinkOutput_v9_9_ScheduleVideoFrame(This,theFrame,displayTime,displayDuration,timeScale) \ + ( (This)->lpVtbl -> ScheduleVideoFrame(This,theFrame,displayTime,displayDuration,timeScale) ) + +#define IDeckLinkOutput_v9_9_SetScheduledFrameCompletionCallback(This,theCallback) \ + ( (This)->lpVtbl -> SetScheduledFrameCompletionCallback(This,theCallback) ) + +#define IDeckLinkOutput_v9_9_GetBufferedVideoFrameCount(This,bufferedFrameCount) \ + ( (This)->lpVtbl -> GetBufferedVideoFrameCount(This,bufferedFrameCount) ) + +#define IDeckLinkOutput_v9_9_EnableAudioOutput(This,sampleRate,sampleType,channelCount,streamType) \ + ( (This)->lpVtbl -> EnableAudioOutput(This,sampleRate,sampleType,channelCount,streamType) ) + +#define IDeckLinkOutput_v9_9_DisableAudioOutput(This) \ + ( (This)->lpVtbl -> DisableAudioOutput(This) ) + +#define IDeckLinkOutput_v9_9_WriteAudioSamplesSync(This,buffer,sampleFrameCount,sampleFramesWritten) \ + ( (This)->lpVtbl -> WriteAudioSamplesSync(This,buffer,sampleFrameCount,sampleFramesWritten) ) + +#define IDeckLinkOutput_v9_9_BeginAudioPreroll(This) \ + ( (This)->lpVtbl -> BeginAudioPreroll(This) ) + +#define IDeckLinkOutput_v9_9_EndAudioPreroll(This) \ + ( (This)->lpVtbl -> EndAudioPreroll(This) ) + +#define IDeckLinkOutput_v9_9_ScheduleAudioSamples(This,buffer,sampleFrameCount,streamTime,timeScale,sampleFramesWritten) \ + ( (This)->lpVtbl -> ScheduleAudioSamples(This,buffer,sampleFrameCount,streamTime,timeScale,sampleFramesWritten) ) + +#define IDeckLinkOutput_v9_9_GetBufferedAudioSampleFrameCount(This,bufferedSampleFrameCount) \ + ( (This)->lpVtbl -> GetBufferedAudioSampleFrameCount(This,bufferedSampleFrameCount) ) + +#define IDeckLinkOutput_v9_9_FlushBufferedAudioSamples(This) \ + ( (This)->lpVtbl -> FlushBufferedAudioSamples(This) ) + +#define IDeckLinkOutput_v9_9_SetAudioCallback(This,theCallback) \ + ( (This)->lpVtbl -> SetAudioCallback(This,theCallback) ) + +#define IDeckLinkOutput_v9_9_StartScheduledPlayback(This,playbackStartTime,timeScale,playbackSpeed) \ + ( (This)->lpVtbl -> StartScheduledPlayback(This,playbackStartTime,timeScale,playbackSpeed) ) + +#define IDeckLinkOutput_v9_9_StopScheduledPlayback(This,stopPlaybackAtTime,actualStopTime,timeScale) \ + ( (This)->lpVtbl -> StopScheduledPlayback(This,stopPlaybackAtTime,actualStopTime,timeScale) ) + +#define IDeckLinkOutput_v9_9_IsScheduledPlaybackRunning(This,active) \ + ( (This)->lpVtbl -> IsScheduledPlaybackRunning(This,active) ) + +#define IDeckLinkOutput_v9_9_GetScheduledStreamTime(This,desiredTimeScale,streamTime,playbackSpeed) \ + ( (This)->lpVtbl -> GetScheduledStreamTime(This,desiredTimeScale,streamTime,playbackSpeed) ) + +#define IDeckLinkOutput_v9_9_GetReferenceStatus(This,referenceStatus) \ + ( (This)->lpVtbl -> GetReferenceStatus(This,referenceStatus) ) + +#define IDeckLinkOutput_v9_9_GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) \ + ( (This)->lpVtbl -> GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkOutput_v9_9_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkInput_v9_2_INTERFACE_DEFINED__ +#define __IDeckLinkInput_v9_2_INTERFACE_DEFINED__ + +/* interface IDeckLinkInput_v9_2 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkInput_v9_2; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("6D40EF78-28B9-4E21-990D-95BB7750A04F") + IDeckLinkInput_v9_2 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE DoesSupportVideoMode( + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDVideoInputFlags flags, + /* [out] */ BMDDisplayModeSupport *result, + /* [out] */ IDeckLinkDisplayMode **resultDisplayMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayModeIterator( + /* [out] */ IDeckLinkDisplayModeIterator **iterator) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetScreenPreviewCallback( + /* [in] */ IDeckLinkScreenPreviewCallback *previewCallback) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableVideoInput( + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDVideoInputFlags flags) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisableVideoInput( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAvailableVideoFrameCount( + /* [out] */ unsigned int *availableFrameCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableAudioInput( + /* [in] */ BMDAudioSampleRate sampleRate, + /* [in] */ BMDAudioSampleType sampleType, + /* [in] */ unsigned int channelCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisableAudioInput( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAvailableAudioSampleFrameCount( + /* [out] */ unsigned int *availableSampleFrameCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE StartStreams( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE StopStreams( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE PauseStreams( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE FlushStreams( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetCallback( + /* [in] */ IDeckLinkInputCallback *theCallback) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetHardwareReferenceClock( + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *hardwareTime, + /* [out] */ BMDTimeValue *timeInFrame, + /* [out] */ BMDTimeValue *ticksPerFrame) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkInput_v9_2Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkInput_v9_2 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkInput_v9_2 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkInput_v9_2 * This); + + HRESULT ( STDMETHODCALLTYPE *DoesSupportVideoMode )( + IDeckLinkInput_v9_2 * This, + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDVideoInputFlags flags, + /* [out] */ BMDDisplayModeSupport *result, + /* [out] */ IDeckLinkDisplayMode **resultDisplayMode); + + HRESULT ( STDMETHODCALLTYPE *GetDisplayModeIterator )( + IDeckLinkInput_v9_2 * This, + /* [out] */ IDeckLinkDisplayModeIterator **iterator); + + HRESULT ( STDMETHODCALLTYPE *SetScreenPreviewCallback )( + IDeckLinkInput_v9_2 * This, + /* [in] */ IDeckLinkScreenPreviewCallback *previewCallback); + + HRESULT ( STDMETHODCALLTYPE *EnableVideoInput )( + IDeckLinkInput_v9_2 * This, + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDVideoInputFlags flags); + + HRESULT ( STDMETHODCALLTYPE *DisableVideoInput )( + IDeckLinkInput_v9_2 * This); + + HRESULT ( STDMETHODCALLTYPE *GetAvailableVideoFrameCount )( + IDeckLinkInput_v9_2 * This, + /* [out] */ unsigned int *availableFrameCount); + + HRESULT ( STDMETHODCALLTYPE *EnableAudioInput )( + IDeckLinkInput_v9_2 * This, + /* [in] */ BMDAudioSampleRate sampleRate, + /* [in] */ BMDAudioSampleType sampleType, + /* [in] */ unsigned int channelCount); + + HRESULT ( STDMETHODCALLTYPE *DisableAudioInput )( + IDeckLinkInput_v9_2 * This); + + HRESULT ( STDMETHODCALLTYPE *GetAvailableAudioSampleFrameCount )( + IDeckLinkInput_v9_2 * This, + /* [out] */ unsigned int *availableSampleFrameCount); + + HRESULT ( STDMETHODCALLTYPE *StartStreams )( + IDeckLinkInput_v9_2 * This); + + HRESULT ( STDMETHODCALLTYPE *StopStreams )( + IDeckLinkInput_v9_2 * This); + + HRESULT ( STDMETHODCALLTYPE *PauseStreams )( + IDeckLinkInput_v9_2 * This); + + HRESULT ( STDMETHODCALLTYPE *FlushStreams )( + IDeckLinkInput_v9_2 * This); + + HRESULT ( STDMETHODCALLTYPE *SetCallback )( + IDeckLinkInput_v9_2 * This, + /* [in] */ IDeckLinkInputCallback *theCallback); + + HRESULT ( STDMETHODCALLTYPE *GetHardwareReferenceClock )( + IDeckLinkInput_v9_2 * This, + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *hardwareTime, + /* [out] */ BMDTimeValue *timeInFrame, + /* [out] */ BMDTimeValue *ticksPerFrame); + + END_INTERFACE + } IDeckLinkInput_v9_2Vtbl; + + interface IDeckLinkInput_v9_2 + { + CONST_VTBL struct IDeckLinkInput_v9_2Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkInput_v9_2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkInput_v9_2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkInput_v9_2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkInput_v9_2_DoesSupportVideoMode(This,displayMode,pixelFormat,flags,result,resultDisplayMode) \ + ( (This)->lpVtbl -> DoesSupportVideoMode(This,displayMode,pixelFormat,flags,result,resultDisplayMode) ) + +#define IDeckLinkInput_v9_2_GetDisplayModeIterator(This,iterator) \ + ( (This)->lpVtbl -> GetDisplayModeIterator(This,iterator) ) + +#define IDeckLinkInput_v9_2_SetScreenPreviewCallback(This,previewCallback) \ + ( (This)->lpVtbl -> SetScreenPreviewCallback(This,previewCallback) ) + +#define IDeckLinkInput_v9_2_EnableVideoInput(This,displayMode,pixelFormat,flags) \ + ( (This)->lpVtbl -> EnableVideoInput(This,displayMode,pixelFormat,flags) ) + +#define IDeckLinkInput_v9_2_DisableVideoInput(This) \ + ( (This)->lpVtbl -> DisableVideoInput(This) ) + +#define IDeckLinkInput_v9_2_GetAvailableVideoFrameCount(This,availableFrameCount) \ + ( (This)->lpVtbl -> GetAvailableVideoFrameCount(This,availableFrameCount) ) + +#define IDeckLinkInput_v9_2_EnableAudioInput(This,sampleRate,sampleType,channelCount) \ + ( (This)->lpVtbl -> EnableAudioInput(This,sampleRate,sampleType,channelCount) ) + +#define IDeckLinkInput_v9_2_DisableAudioInput(This) \ + ( (This)->lpVtbl -> DisableAudioInput(This) ) + +#define IDeckLinkInput_v9_2_GetAvailableAudioSampleFrameCount(This,availableSampleFrameCount) \ + ( (This)->lpVtbl -> GetAvailableAudioSampleFrameCount(This,availableSampleFrameCount) ) + +#define IDeckLinkInput_v9_2_StartStreams(This) \ + ( (This)->lpVtbl -> StartStreams(This) ) + +#define IDeckLinkInput_v9_2_StopStreams(This) \ + ( (This)->lpVtbl -> StopStreams(This) ) + +#define IDeckLinkInput_v9_2_PauseStreams(This) \ + ( (This)->lpVtbl -> PauseStreams(This) ) + +#define IDeckLinkInput_v9_2_FlushStreams(This) \ + ( (This)->lpVtbl -> FlushStreams(This) ) + +#define IDeckLinkInput_v9_2_SetCallback(This,theCallback) \ + ( (This)->lpVtbl -> SetCallback(This,theCallback) ) + +#define IDeckLinkInput_v9_2_GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) \ + ( (This)->lpVtbl -> GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkInput_v9_2_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkDeckControlStatusCallback_v8_1_INTERFACE_DEFINED__ +#define __IDeckLinkDeckControlStatusCallback_v8_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkDeckControlStatusCallback_v8_1 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkDeckControlStatusCallback_v8_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("E5F693C1-4283-4716-B18F-C1431521955B") + IDeckLinkDeckControlStatusCallback_v8_1 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE TimecodeUpdate( + /* [in] */ BMDTimecodeBCD currentTimecode) = 0; + + virtual HRESULT STDMETHODCALLTYPE VTRControlStateChanged( + /* [in] */ BMDDeckControlVTRControlState_v8_1 newState, + /* [in] */ BMDDeckControlError error) = 0; + + virtual HRESULT STDMETHODCALLTYPE DeckControlEventReceived( + /* [in] */ BMDDeckControlEvent event, + /* [in] */ BMDDeckControlError error) = 0; + + virtual HRESULT STDMETHODCALLTYPE DeckControlStatusChanged( + /* [in] */ BMDDeckControlStatusFlags flags, + /* [in] */ unsigned int mask) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkDeckControlStatusCallback_v8_1Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkDeckControlStatusCallback_v8_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkDeckControlStatusCallback_v8_1 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkDeckControlStatusCallback_v8_1 * This); + + HRESULT ( STDMETHODCALLTYPE *TimecodeUpdate )( + IDeckLinkDeckControlStatusCallback_v8_1 * This, + /* [in] */ BMDTimecodeBCD currentTimecode); + + HRESULT ( STDMETHODCALLTYPE *VTRControlStateChanged )( + IDeckLinkDeckControlStatusCallback_v8_1 * This, + /* [in] */ BMDDeckControlVTRControlState_v8_1 newState, + /* [in] */ BMDDeckControlError error); + + HRESULT ( STDMETHODCALLTYPE *DeckControlEventReceived )( + IDeckLinkDeckControlStatusCallback_v8_1 * This, + /* [in] */ BMDDeckControlEvent event, + /* [in] */ BMDDeckControlError error); + + HRESULT ( STDMETHODCALLTYPE *DeckControlStatusChanged )( + IDeckLinkDeckControlStatusCallback_v8_1 * This, + /* [in] */ BMDDeckControlStatusFlags flags, + /* [in] */ unsigned int mask); + + END_INTERFACE + } IDeckLinkDeckControlStatusCallback_v8_1Vtbl; + + interface IDeckLinkDeckControlStatusCallback_v8_1 + { + CONST_VTBL struct IDeckLinkDeckControlStatusCallback_v8_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkDeckControlStatusCallback_v8_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkDeckControlStatusCallback_v8_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkDeckControlStatusCallback_v8_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkDeckControlStatusCallback_v8_1_TimecodeUpdate(This,currentTimecode) \ + ( (This)->lpVtbl -> TimecodeUpdate(This,currentTimecode) ) + +#define IDeckLinkDeckControlStatusCallback_v8_1_VTRControlStateChanged(This,newState,error) \ + ( (This)->lpVtbl -> VTRControlStateChanged(This,newState,error) ) + +#define IDeckLinkDeckControlStatusCallback_v8_1_DeckControlEventReceived(This,event,error) \ + ( (This)->lpVtbl -> DeckControlEventReceived(This,event,error) ) + +#define IDeckLinkDeckControlStatusCallback_v8_1_DeckControlStatusChanged(This,flags,mask) \ + ( (This)->lpVtbl -> DeckControlStatusChanged(This,flags,mask) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkDeckControlStatusCallback_v8_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkDeckControl_v8_1_INTERFACE_DEFINED__ +#define __IDeckLinkDeckControl_v8_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkDeckControl_v8_1 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkDeckControl_v8_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("522A9E39-0F3C-4742-94EE-D80DE335DA1D") + IDeckLinkDeckControl_v8_1 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Open( + /* [in] */ BMDTimeScale timeScale, + /* [in] */ BMDTimeValue timeValue, + /* [in] */ BOOL timecodeIsDropFrame, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE Close( + /* [in] */ BOOL standbyOn) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCurrentState( + /* [out] */ BMDDeckControlMode *mode, + /* [out] */ BMDDeckControlVTRControlState_v8_1 *vtrControlState, + /* [out] */ BMDDeckControlStatusFlags *flags) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetStandby( + /* [in] */ BOOL standbyOn) = 0; + + virtual HRESULT STDMETHODCALLTYPE SendCommand( + /* [in] */ unsigned char *inBuffer, + /* [in] */ unsigned int inBufferSize, + /* [out] */ unsigned char *outBuffer, + /* [out] */ unsigned int *outDataSize, + /* [in] */ unsigned int outBufferSize, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE Play( + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE Stop( + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE TogglePlayStop( + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE Eject( + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE GoToTimecode( + /* [in] */ BMDTimecodeBCD timecode, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE FastForward( + /* [in] */ BOOL viewTape, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE Rewind( + /* [in] */ BOOL viewTape, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE StepForward( + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE StepBack( + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE Jog( + /* [in] */ double rate, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE Shuttle( + /* [in] */ double rate, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTimecodeString( + /* [out] */ BSTR *currentTimeCode, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTimecode( + /* [out] */ IDeckLinkTimecode **currentTimecode, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTimecodeBCD( + /* [out] */ BMDTimecodeBCD *currentTimecode, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetPreroll( + /* [in] */ unsigned int prerollSeconds) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPreroll( + /* [out] */ unsigned int *prerollSeconds) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetExportOffset( + /* [in] */ int exportOffsetFields) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetExportOffset( + /* [out] */ int *exportOffsetFields) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetManualExportOffset( + /* [out] */ int *deckManualExportOffsetFields) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetCaptureOffset( + /* [in] */ int captureOffsetFields) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCaptureOffset( + /* [out] */ int *captureOffsetFields) = 0; + + virtual HRESULT STDMETHODCALLTYPE StartExport( + /* [in] */ BMDTimecodeBCD inTimecode, + /* [in] */ BMDTimecodeBCD outTimecode, + /* [in] */ BMDDeckControlExportModeOpsFlags exportModeOps, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE StartCapture( + /* [in] */ BOOL useVITC, + /* [in] */ BMDTimecodeBCD inTimecode, + /* [in] */ BMDTimecodeBCD outTimecode, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDeviceID( + /* [out] */ unsigned short *deviceId, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE Abort( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE CrashRecordStart( + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE CrashRecordStop( + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetCallback( + /* [in] */ IDeckLinkDeckControlStatusCallback_v8_1 *callback) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkDeckControl_v8_1Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkDeckControl_v8_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkDeckControl_v8_1 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkDeckControl_v8_1 * This); + + HRESULT ( STDMETHODCALLTYPE *Open )( + IDeckLinkDeckControl_v8_1 * This, + /* [in] */ BMDTimeScale timeScale, + /* [in] */ BMDTimeValue timeValue, + /* [in] */ BOOL timecodeIsDropFrame, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *Close )( + IDeckLinkDeckControl_v8_1 * This, + /* [in] */ BOOL standbyOn); + + HRESULT ( STDMETHODCALLTYPE *GetCurrentState )( + IDeckLinkDeckControl_v8_1 * This, + /* [out] */ BMDDeckControlMode *mode, + /* [out] */ BMDDeckControlVTRControlState_v8_1 *vtrControlState, + /* [out] */ BMDDeckControlStatusFlags *flags); + + HRESULT ( STDMETHODCALLTYPE *SetStandby )( + IDeckLinkDeckControl_v8_1 * This, + /* [in] */ BOOL standbyOn); + + HRESULT ( STDMETHODCALLTYPE *SendCommand )( + IDeckLinkDeckControl_v8_1 * This, + /* [in] */ unsigned char *inBuffer, + /* [in] */ unsigned int inBufferSize, + /* [out] */ unsigned char *outBuffer, + /* [out] */ unsigned int *outDataSize, + /* [in] */ unsigned int outBufferSize, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *Play )( + IDeckLinkDeckControl_v8_1 * This, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *Stop )( + IDeckLinkDeckControl_v8_1 * This, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *TogglePlayStop )( + IDeckLinkDeckControl_v8_1 * This, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *Eject )( + IDeckLinkDeckControl_v8_1 * This, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *GoToTimecode )( + IDeckLinkDeckControl_v8_1 * This, + /* [in] */ BMDTimecodeBCD timecode, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *FastForward )( + IDeckLinkDeckControl_v8_1 * This, + /* [in] */ BOOL viewTape, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *Rewind )( + IDeckLinkDeckControl_v8_1 * This, + /* [in] */ BOOL viewTape, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *StepForward )( + IDeckLinkDeckControl_v8_1 * This, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *StepBack )( + IDeckLinkDeckControl_v8_1 * This, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *Jog )( + IDeckLinkDeckControl_v8_1 * This, + /* [in] */ double rate, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *Shuttle )( + IDeckLinkDeckControl_v8_1 * This, + /* [in] */ double rate, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *GetTimecodeString )( + IDeckLinkDeckControl_v8_1 * This, + /* [out] */ BSTR *currentTimeCode, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *GetTimecode )( + IDeckLinkDeckControl_v8_1 * This, + /* [out] */ IDeckLinkTimecode **currentTimecode, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *GetTimecodeBCD )( + IDeckLinkDeckControl_v8_1 * This, + /* [out] */ BMDTimecodeBCD *currentTimecode, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *SetPreroll )( + IDeckLinkDeckControl_v8_1 * This, + /* [in] */ unsigned int prerollSeconds); + + HRESULT ( STDMETHODCALLTYPE *GetPreroll )( + IDeckLinkDeckControl_v8_1 * This, + /* [out] */ unsigned int *prerollSeconds); + + HRESULT ( STDMETHODCALLTYPE *SetExportOffset )( + IDeckLinkDeckControl_v8_1 * This, + /* [in] */ int exportOffsetFields); + + HRESULT ( STDMETHODCALLTYPE *GetExportOffset )( + IDeckLinkDeckControl_v8_1 * This, + /* [out] */ int *exportOffsetFields); + + HRESULT ( STDMETHODCALLTYPE *GetManualExportOffset )( + IDeckLinkDeckControl_v8_1 * This, + /* [out] */ int *deckManualExportOffsetFields); + + HRESULT ( STDMETHODCALLTYPE *SetCaptureOffset )( + IDeckLinkDeckControl_v8_1 * This, + /* [in] */ int captureOffsetFields); + + HRESULT ( STDMETHODCALLTYPE *GetCaptureOffset )( + IDeckLinkDeckControl_v8_1 * This, + /* [out] */ int *captureOffsetFields); + + HRESULT ( STDMETHODCALLTYPE *StartExport )( + IDeckLinkDeckControl_v8_1 * This, + /* [in] */ BMDTimecodeBCD inTimecode, + /* [in] */ BMDTimecodeBCD outTimecode, + /* [in] */ BMDDeckControlExportModeOpsFlags exportModeOps, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *StartCapture )( + IDeckLinkDeckControl_v8_1 * This, + /* [in] */ BOOL useVITC, + /* [in] */ BMDTimecodeBCD inTimecode, + /* [in] */ BMDTimecodeBCD outTimecode, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *GetDeviceID )( + IDeckLinkDeckControl_v8_1 * This, + /* [out] */ unsigned short *deviceId, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *Abort )( + IDeckLinkDeckControl_v8_1 * This); + + HRESULT ( STDMETHODCALLTYPE *CrashRecordStart )( + IDeckLinkDeckControl_v8_1 * This, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *CrashRecordStop )( + IDeckLinkDeckControl_v8_1 * This, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *SetCallback )( + IDeckLinkDeckControl_v8_1 * This, + /* [in] */ IDeckLinkDeckControlStatusCallback_v8_1 *callback); + + END_INTERFACE + } IDeckLinkDeckControl_v8_1Vtbl; + + interface IDeckLinkDeckControl_v8_1 + { + CONST_VTBL struct IDeckLinkDeckControl_v8_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkDeckControl_v8_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkDeckControl_v8_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkDeckControl_v8_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkDeckControl_v8_1_Open(This,timeScale,timeValue,timecodeIsDropFrame,error) \ + ( (This)->lpVtbl -> Open(This,timeScale,timeValue,timecodeIsDropFrame,error) ) + +#define IDeckLinkDeckControl_v8_1_Close(This,standbyOn) \ + ( (This)->lpVtbl -> Close(This,standbyOn) ) + +#define IDeckLinkDeckControl_v8_1_GetCurrentState(This,mode,vtrControlState,flags) \ + ( (This)->lpVtbl -> GetCurrentState(This,mode,vtrControlState,flags) ) + +#define IDeckLinkDeckControl_v8_1_SetStandby(This,standbyOn) \ + ( (This)->lpVtbl -> SetStandby(This,standbyOn) ) + +#define IDeckLinkDeckControl_v8_1_SendCommand(This,inBuffer,inBufferSize,outBuffer,outDataSize,outBufferSize,error) \ + ( (This)->lpVtbl -> SendCommand(This,inBuffer,inBufferSize,outBuffer,outDataSize,outBufferSize,error) ) + +#define IDeckLinkDeckControl_v8_1_Play(This,error) \ + ( (This)->lpVtbl -> Play(This,error) ) + +#define IDeckLinkDeckControl_v8_1_Stop(This,error) \ + ( (This)->lpVtbl -> Stop(This,error) ) + +#define IDeckLinkDeckControl_v8_1_TogglePlayStop(This,error) \ + ( (This)->lpVtbl -> TogglePlayStop(This,error) ) + +#define IDeckLinkDeckControl_v8_1_Eject(This,error) \ + ( (This)->lpVtbl -> Eject(This,error) ) + +#define IDeckLinkDeckControl_v8_1_GoToTimecode(This,timecode,error) \ + ( (This)->lpVtbl -> GoToTimecode(This,timecode,error) ) + +#define IDeckLinkDeckControl_v8_1_FastForward(This,viewTape,error) \ + ( (This)->lpVtbl -> FastForward(This,viewTape,error) ) + +#define IDeckLinkDeckControl_v8_1_Rewind(This,viewTape,error) \ + ( (This)->lpVtbl -> Rewind(This,viewTape,error) ) + +#define IDeckLinkDeckControl_v8_1_StepForward(This,error) \ + ( (This)->lpVtbl -> StepForward(This,error) ) + +#define IDeckLinkDeckControl_v8_1_StepBack(This,error) \ + ( (This)->lpVtbl -> StepBack(This,error) ) + +#define IDeckLinkDeckControl_v8_1_Jog(This,rate,error) \ + ( (This)->lpVtbl -> Jog(This,rate,error) ) + +#define IDeckLinkDeckControl_v8_1_Shuttle(This,rate,error) \ + ( (This)->lpVtbl -> Shuttle(This,rate,error) ) + +#define IDeckLinkDeckControl_v8_1_GetTimecodeString(This,currentTimeCode,error) \ + ( (This)->lpVtbl -> GetTimecodeString(This,currentTimeCode,error) ) + +#define IDeckLinkDeckControl_v8_1_GetTimecode(This,currentTimecode,error) \ + ( (This)->lpVtbl -> GetTimecode(This,currentTimecode,error) ) + +#define IDeckLinkDeckControl_v8_1_GetTimecodeBCD(This,currentTimecode,error) \ + ( (This)->lpVtbl -> GetTimecodeBCD(This,currentTimecode,error) ) + +#define IDeckLinkDeckControl_v8_1_SetPreroll(This,prerollSeconds) \ + ( (This)->lpVtbl -> SetPreroll(This,prerollSeconds) ) + +#define IDeckLinkDeckControl_v8_1_GetPreroll(This,prerollSeconds) \ + ( (This)->lpVtbl -> GetPreroll(This,prerollSeconds) ) + +#define IDeckLinkDeckControl_v8_1_SetExportOffset(This,exportOffsetFields) \ + ( (This)->lpVtbl -> SetExportOffset(This,exportOffsetFields) ) + +#define IDeckLinkDeckControl_v8_1_GetExportOffset(This,exportOffsetFields) \ + ( (This)->lpVtbl -> GetExportOffset(This,exportOffsetFields) ) + +#define IDeckLinkDeckControl_v8_1_GetManualExportOffset(This,deckManualExportOffsetFields) \ + ( (This)->lpVtbl -> GetManualExportOffset(This,deckManualExportOffsetFields) ) + +#define IDeckLinkDeckControl_v8_1_SetCaptureOffset(This,captureOffsetFields) \ + ( (This)->lpVtbl -> SetCaptureOffset(This,captureOffsetFields) ) + +#define IDeckLinkDeckControl_v8_1_GetCaptureOffset(This,captureOffsetFields) \ + ( (This)->lpVtbl -> GetCaptureOffset(This,captureOffsetFields) ) + +#define IDeckLinkDeckControl_v8_1_StartExport(This,inTimecode,outTimecode,exportModeOps,error) \ + ( (This)->lpVtbl -> StartExport(This,inTimecode,outTimecode,exportModeOps,error) ) + +#define IDeckLinkDeckControl_v8_1_StartCapture(This,useVITC,inTimecode,outTimecode,error) \ + ( (This)->lpVtbl -> StartCapture(This,useVITC,inTimecode,outTimecode,error) ) + +#define IDeckLinkDeckControl_v8_1_GetDeviceID(This,deviceId,error) \ + ( (This)->lpVtbl -> GetDeviceID(This,deviceId,error) ) + +#define IDeckLinkDeckControl_v8_1_Abort(This) \ + ( (This)->lpVtbl -> Abort(This) ) + +#define IDeckLinkDeckControl_v8_1_CrashRecordStart(This,error) \ + ( (This)->lpVtbl -> CrashRecordStart(This,error) ) + +#define IDeckLinkDeckControl_v8_1_CrashRecordStop(This,error) \ + ( (This)->lpVtbl -> CrashRecordStop(This,error) ) + +#define IDeckLinkDeckControl_v8_1_SetCallback(This,callback) \ + ( (This)->lpVtbl -> SetCallback(This,callback) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkDeckControl_v8_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLink_v8_0_INTERFACE_DEFINED__ +#define __IDeckLink_v8_0_INTERFACE_DEFINED__ + +/* interface IDeckLink_v8_0 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLink_v8_0; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("62BFF75D-6569-4E55-8D4D-66AA03829ABC") + IDeckLink_v8_0 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetModelName( + /* [out] */ BSTR *modelName) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLink_v8_0Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLink_v8_0 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLink_v8_0 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLink_v8_0 * This); + + HRESULT ( STDMETHODCALLTYPE *GetModelName )( + IDeckLink_v8_0 * This, + /* [out] */ BSTR *modelName); + + END_INTERFACE + } IDeckLink_v8_0Vtbl; + + interface IDeckLink_v8_0 + { + CONST_VTBL struct IDeckLink_v8_0Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLink_v8_0_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLink_v8_0_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLink_v8_0_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLink_v8_0_GetModelName(This,modelName) \ + ( (This)->lpVtbl -> GetModelName(This,modelName) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLink_v8_0_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkIterator_v8_0_INTERFACE_DEFINED__ +#define __IDeckLinkIterator_v8_0_INTERFACE_DEFINED__ + +/* interface IDeckLinkIterator_v8_0 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkIterator_v8_0; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("74E936FC-CC28-4A67-81A0-1E94E52D4E69") + IDeckLinkIterator_v8_0 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Next( + /* [out] */ IDeckLink_v8_0 **deckLinkInstance) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkIterator_v8_0Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkIterator_v8_0 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkIterator_v8_0 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkIterator_v8_0 * This); + + HRESULT ( STDMETHODCALLTYPE *Next )( + IDeckLinkIterator_v8_0 * This, + /* [out] */ IDeckLink_v8_0 **deckLinkInstance); + + END_INTERFACE + } IDeckLinkIterator_v8_0Vtbl; + + interface IDeckLinkIterator_v8_0 + { + CONST_VTBL struct IDeckLinkIterator_v8_0Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkIterator_v8_0_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkIterator_v8_0_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkIterator_v8_0_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkIterator_v8_0_Next(This,deckLinkInstance) \ + ( (This)->lpVtbl -> Next(This,deckLinkInstance) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkIterator_v8_0_INTERFACE_DEFINED__ */ + + +EXTERN_C const CLSID CLSID_CDeckLinkIterator_v8_0; + +#ifdef __cplusplus + +class DECLSPEC_UUID("D9EDA3B3-2887-41FA-B724-017CF1EB1D37") +CDeckLinkIterator_v8_0; +#endif + +#ifndef __IDeckLinkDeckControl_v7_9_INTERFACE_DEFINED__ +#define __IDeckLinkDeckControl_v7_9_INTERFACE_DEFINED__ + +/* interface IDeckLinkDeckControl_v7_9 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkDeckControl_v7_9; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("A4D81043-0619-42B7-8ED6-602D29041DF7") + IDeckLinkDeckControl_v7_9 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Open( + /* [in] */ BMDTimeScale timeScale, + /* [in] */ BMDTimeValue timeValue, + /* [in] */ BOOL timecodeIsDropFrame, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE Close( + /* [in] */ BOOL standbyOn) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCurrentState( + /* [out] */ BMDDeckControlMode *mode, + /* [out] */ BMDDeckControlVTRControlState *vtrControlState, + /* [out] */ BMDDeckControlStatusFlags *flags) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetStandby( + /* [in] */ BOOL standbyOn) = 0; + + virtual HRESULT STDMETHODCALLTYPE Play( + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE Stop( + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE TogglePlayStop( + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE Eject( + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE GoToTimecode( + /* [in] */ BMDTimecodeBCD timecode, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE FastForward( + /* [in] */ BOOL viewTape, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE Rewind( + /* [in] */ BOOL viewTape, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE StepForward( + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE StepBack( + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE Jog( + /* [in] */ double rate, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE Shuttle( + /* [in] */ double rate, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTimecodeString( + /* [out] */ BSTR *currentTimeCode, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTimecode( + /* [out] */ IDeckLinkTimecode **currentTimecode, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTimecodeBCD( + /* [out] */ BMDTimecodeBCD *currentTimecode, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetPreroll( + /* [in] */ unsigned int prerollSeconds) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPreroll( + /* [out] */ unsigned int *prerollSeconds) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetExportOffset( + /* [in] */ int exportOffsetFields) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetExportOffset( + /* [out] */ int *exportOffsetFields) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetManualExportOffset( + /* [out] */ int *deckManualExportOffsetFields) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetCaptureOffset( + /* [in] */ int captureOffsetFields) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCaptureOffset( + /* [out] */ int *captureOffsetFields) = 0; + + virtual HRESULT STDMETHODCALLTYPE StartExport( + /* [in] */ BMDTimecodeBCD inTimecode, + /* [in] */ BMDTimecodeBCD outTimecode, + /* [in] */ BMDDeckControlExportModeOpsFlags exportModeOps, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE StartCapture( + /* [in] */ BOOL useVITC, + /* [in] */ BMDTimecodeBCD inTimecode, + /* [in] */ BMDTimecodeBCD outTimecode, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDeviceID( + /* [out] */ unsigned short *deviceId, + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE Abort( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE CrashRecordStart( + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE CrashRecordStop( + /* [out] */ BMDDeckControlError *error) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetCallback( + /* [in] */ IDeckLinkDeckControlStatusCallback *callback) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkDeckControl_v7_9Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkDeckControl_v7_9 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkDeckControl_v7_9 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkDeckControl_v7_9 * This); + + HRESULT ( STDMETHODCALLTYPE *Open )( + IDeckLinkDeckControl_v7_9 * This, + /* [in] */ BMDTimeScale timeScale, + /* [in] */ BMDTimeValue timeValue, + /* [in] */ BOOL timecodeIsDropFrame, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *Close )( + IDeckLinkDeckControl_v7_9 * This, + /* [in] */ BOOL standbyOn); + + HRESULT ( STDMETHODCALLTYPE *GetCurrentState )( + IDeckLinkDeckControl_v7_9 * This, + /* [out] */ BMDDeckControlMode *mode, + /* [out] */ BMDDeckControlVTRControlState *vtrControlState, + /* [out] */ BMDDeckControlStatusFlags *flags); + + HRESULT ( STDMETHODCALLTYPE *SetStandby )( + IDeckLinkDeckControl_v7_9 * This, + /* [in] */ BOOL standbyOn); + + HRESULT ( STDMETHODCALLTYPE *Play )( + IDeckLinkDeckControl_v7_9 * This, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *Stop )( + IDeckLinkDeckControl_v7_9 * This, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *TogglePlayStop )( + IDeckLinkDeckControl_v7_9 * This, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *Eject )( + IDeckLinkDeckControl_v7_9 * This, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *GoToTimecode )( + IDeckLinkDeckControl_v7_9 * This, + /* [in] */ BMDTimecodeBCD timecode, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *FastForward )( + IDeckLinkDeckControl_v7_9 * This, + /* [in] */ BOOL viewTape, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *Rewind )( + IDeckLinkDeckControl_v7_9 * This, + /* [in] */ BOOL viewTape, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *StepForward )( + IDeckLinkDeckControl_v7_9 * This, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *StepBack )( + IDeckLinkDeckControl_v7_9 * This, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *Jog )( + IDeckLinkDeckControl_v7_9 * This, + /* [in] */ double rate, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *Shuttle )( + IDeckLinkDeckControl_v7_9 * This, + /* [in] */ double rate, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *GetTimecodeString )( + IDeckLinkDeckControl_v7_9 * This, + /* [out] */ BSTR *currentTimeCode, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *GetTimecode )( + IDeckLinkDeckControl_v7_9 * This, + /* [out] */ IDeckLinkTimecode **currentTimecode, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *GetTimecodeBCD )( + IDeckLinkDeckControl_v7_9 * This, + /* [out] */ BMDTimecodeBCD *currentTimecode, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *SetPreroll )( + IDeckLinkDeckControl_v7_9 * This, + /* [in] */ unsigned int prerollSeconds); + + HRESULT ( STDMETHODCALLTYPE *GetPreroll )( + IDeckLinkDeckControl_v7_9 * This, + /* [out] */ unsigned int *prerollSeconds); + + HRESULT ( STDMETHODCALLTYPE *SetExportOffset )( + IDeckLinkDeckControl_v7_9 * This, + /* [in] */ int exportOffsetFields); + + HRESULT ( STDMETHODCALLTYPE *GetExportOffset )( + IDeckLinkDeckControl_v7_9 * This, + /* [out] */ int *exportOffsetFields); + + HRESULT ( STDMETHODCALLTYPE *GetManualExportOffset )( + IDeckLinkDeckControl_v7_9 * This, + /* [out] */ int *deckManualExportOffsetFields); + + HRESULT ( STDMETHODCALLTYPE *SetCaptureOffset )( + IDeckLinkDeckControl_v7_9 * This, + /* [in] */ int captureOffsetFields); + + HRESULT ( STDMETHODCALLTYPE *GetCaptureOffset )( + IDeckLinkDeckControl_v7_9 * This, + /* [out] */ int *captureOffsetFields); + + HRESULT ( STDMETHODCALLTYPE *StartExport )( + IDeckLinkDeckControl_v7_9 * This, + /* [in] */ BMDTimecodeBCD inTimecode, + /* [in] */ BMDTimecodeBCD outTimecode, + /* [in] */ BMDDeckControlExportModeOpsFlags exportModeOps, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *StartCapture )( + IDeckLinkDeckControl_v7_9 * This, + /* [in] */ BOOL useVITC, + /* [in] */ BMDTimecodeBCD inTimecode, + /* [in] */ BMDTimecodeBCD outTimecode, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *GetDeviceID )( + IDeckLinkDeckControl_v7_9 * This, + /* [out] */ unsigned short *deviceId, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *Abort )( + IDeckLinkDeckControl_v7_9 * This); + + HRESULT ( STDMETHODCALLTYPE *CrashRecordStart )( + IDeckLinkDeckControl_v7_9 * This, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *CrashRecordStop )( + IDeckLinkDeckControl_v7_9 * This, + /* [out] */ BMDDeckControlError *error); + + HRESULT ( STDMETHODCALLTYPE *SetCallback )( + IDeckLinkDeckControl_v7_9 * This, + /* [in] */ IDeckLinkDeckControlStatusCallback *callback); + + END_INTERFACE + } IDeckLinkDeckControl_v7_9Vtbl; + + interface IDeckLinkDeckControl_v7_9 + { + CONST_VTBL struct IDeckLinkDeckControl_v7_9Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkDeckControl_v7_9_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkDeckControl_v7_9_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkDeckControl_v7_9_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkDeckControl_v7_9_Open(This,timeScale,timeValue,timecodeIsDropFrame,error) \ + ( (This)->lpVtbl -> Open(This,timeScale,timeValue,timecodeIsDropFrame,error) ) + +#define IDeckLinkDeckControl_v7_9_Close(This,standbyOn) \ + ( (This)->lpVtbl -> Close(This,standbyOn) ) + +#define IDeckLinkDeckControl_v7_9_GetCurrentState(This,mode,vtrControlState,flags) \ + ( (This)->lpVtbl -> GetCurrentState(This,mode,vtrControlState,flags) ) + +#define IDeckLinkDeckControl_v7_9_SetStandby(This,standbyOn) \ + ( (This)->lpVtbl -> SetStandby(This,standbyOn) ) + +#define IDeckLinkDeckControl_v7_9_Play(This,error) \ + ( (This)->lpVtbl -> Play(This,error) ) + +#define IDeckLinkDeckControl_v7_9_Stop(This,error) \ + ( (This)->lpVtbl -> Stop(This,error) ) + +#define IDeckLinkDeckControl_v7_9_TogglePlayStop(This,error) \ + ( (This)->lpVtbl -> TogglePlayStop(This,error) ) + +#define IDeckLinkDeckControl_v7_9_Eject(This,error) \ + ( (This)->lpVtbl -> Eject(This,error) ) + +#define IDeckLinkDeckControl_v7_9_GoToTimecode(This,timecode,error) \ + ( (This)->lpVtbl -> GoToTimecode(This,timecode,error) ) + +#define IDeckLinkDeckControl_v7_9_FastForward(This,viewTape,error) \ + ( (This)->lpVtbl -> FastForward(This,viewTape,error) ) + +#define IDeckLinkDeckControl_v7_9_Rewind(This,viewTape,error) \ + ( (This)->lpVtbl -> Rewind(This,viewTape,error) ) + +#define IDeckLinkDeckControl_v7_9_StepForward(This,error) \ + ( (This)->lpVtbl -> StepForward(This,error) ) + +#define IDeckLinkDeckControl_v7_9_StepBack(This,error) \ + ( (This)->lpVtbl -> StepBack(This,error) ) + +#define IDeckLinkDeckControl_v7_9_Jog(This,rate,error) \ + ( (This)->lpVtbl -> Jog(This,rate,error) ) + +#define IDeckLinkDeckControl_v7_9_Shuttle(This,rate,error) \ + ( (This)->lpVtbl -> Shuttle(This,rate,error) ) + +#define IDeckLinkDeckControl_v7_9_GetTimecodeString(This,currentTimeCode,error) \ + ( (This)->lpVtbl -> GetTimecodeString(This,currentTimeCode,error) ) + +#define IDeckLinkDeckControl_v7_9_GetTimecode(This,currentTimecode,error) \ + ( (This)->lpVtbl -> GetTimecode(This,currentTimecode,error) ) + +#define IDeckLinkDeckControl_v7_9_GetTimecodeBCD(This,currentTimecode,error) \ + ( (This)->lpVtbl -> GetTimecodeBCD(This,currentTimecode,error) ) + +#define IDeckLinkDeckControl_v7_9_SetPreroll(This,prerollSeconds) \ + ( (This)->lpVtbl -> SetPreroll(This,prerollSeconds) ) + +#define IDeckLinkDeckControl_v7_9_GetPreroll(This,prerollSeconds) \ + ( (This)->lpVtbl -> GetPreroll(This,prerollSeconds) ) + +#define IDeckLinkDeckControl_v7_9_SetExportOffset(This,exportOffsetFields) \ + ( (This)->lpVtbl -> SetExportOffset(This,exportOffsetFields) ) + +#define IDeckLinkDeckControl_v7_9_GetExportOffset(This,exportOffsetFields) \ + ( (This)->lpVtbl -> GetExportOffset(This,exportOffsetFields) ) + +#define IDeckLinkDeckControl_v7_9_GetManualExportOffset(This,deckManualExportOffsetFields) \ + ( (This)->lpVtbl -> GetManualExportOffset(This,deckManualExportOffsetFields) ) + +#define IDeckLinkDeckControl_v7_9_SetCaptureOffset(This,captureOffsetFields) \ + ( (This)->lpVtbl -> SetCaptureOffset(This,captureOffsetFields) ) + +#define IDeckLinkDeckControl_v7_9_GetCaptureOffset(This,captureOffsetFields) \ + ( (This)->lpVtbl -> GetCaptureOffset(This,captureOffsetFields) ) + +#define IDeckLinkDeckControl_v7_9_StartExport(This,inTimecode,outTimecode,exportModeOps,error) \ + ( (This)->lpVtbl -> StartExport(This,inTimecode,outTimecode,exportModeOps,error) ) + +#define IDeckLinkDeckControl_v7_9_StartCapture(This,useVITC,inTimecode,outTimecode,error) \ + ( (This)->lpVtbl -> StartCapture(This,useVITC,inTimecode,outTimecode,error) ) + +#define IDeckLinkDeckControl_v7_9_GetDeviceID(This,deviceId,error) \ + ( (This)->lpVtbl -> GetDeviceID(This,deviceId,error) ) + +#define IDeckLinkDeckControl_v7_9_Abort(This) \ + ( (This)->lpVtbl -> Abort(This) ) + +#define IDeckLinkDeckControl_v7_9_CrashRecordStart(This,error) \ + ( (This)->lpVtbl -> CrashRecordStart(This,error) ) + +#define IDeckLinkDeckControl_v7_9_CrashRecordStop(This,error) \ + ( (This)->lpVtbl -> CrashRecordStop(This,error) ) + +#define IDeckLinkDeckControl_v7_9_SetCallback(This,callback) \ + ( (This)->lpVtbl -> SetCallback(This,callback) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkDeckControl_v7_9_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkDisplayModeIterator_v7_6_INTERFACE_DEFINED__ +#define __IDeckLinkDisplayModeIterator_v7_6_INTERFACE_DEFINED__ + +/* interface IDeckLinkDisplayModeIterator_v7_6 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkDisplayModeIterator_v7_6; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("455D741F-1779-4800-86F5-0B5D13D79751") + IDeckLinkDisplayModeIterator_v7_6 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Next( + /* [out] */ IDeckLinkDisplayMode_v7_6 **deckLinkDisplayMode) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkDisplayModeIterator_v7_6Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkDisplayModeIterator_v7_6 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkDisplayModeIterator_v7_6 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkDisplayModeIterator_v7_6 * This); + + HRESULT ( STDMETHODCALLTYPE *Next )( + IDeckLinkDisplayModeIterator_v7_6 * This, + /* [out] */ IDeckLinkDisplayMode_v7_6 **deckLinkDisplayMode); + + END_INTERFACE + } IDeckLinkDisplayModeIterator_v7_6Vtbl; + + interface IDeckLinkDisplayModeIterator_v7_6 + { + CONST_VTBL struct IDeckLinkDisplayModeIterator_v7_6Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkDisplayModeIterator_v7_6_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkDisplayModeIterator_v7_6_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkDisplayModeIterator_v7_6_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkDisplayModeIterator_v7_6_Next(This,deckLinkDisplayMode) \ + ( (This)->lpVtbl -> Next(This,deckLinkDisplayMode) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkDisplayModeIterator_v7_6_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkDisplayMode_v7_6_INTERFACE_DEFINED__ +#define __IDeckLinkDisplayMode_v7_6_INTERFACE_DEFINED__ + +/* interface IDeckLinkDisplayMode_v7_6 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkDisplayMode_v7_6; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("87451E84-2B7E-439E-A629-4393EA4A8550") + IDeckLinkDisplayMode_v7_6 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetName( + /* [out] */ BSTR *name) = 0; + + virtual BMDDisplayMode STDMETHODCALLTYPE GetDisplayMode( void) = 0; + + virtual long STDMETHODCALLTYPE GetWidth( void) = 0; + + virtual long STDMETHODCALLTYPE GetHeight( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFrameRate( + /* [out] */ BMDTimeValue *frameDuration, + /* [out] */ BMDTimeScale *timeScale) = 0; + + virtual BMDFieldDominance STDMETHODCALLTYPE GetFieldDominance( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkDisplayMode_v7_6Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkDisplayMode_v7_6 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkDisplayMode_v7_6 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkDisplayMode_v7_6 * This); + + HRESULT ( STDMETHODCALLTYPE *GetName )( + IDeckLinkDisplayMode_v7_6 * This, + /* [out] */ BSTR *name); + + BMDDisplayMode ( STDMETHODCALLTYPE *GetDisplayMode )( + IDeckLinkDisplayMode_v7_6 * This); + + long ( STDMETHODCALLTYPE *GetWidth )( + IDeckLinkDisplayMode_v7_6 * This); + + long ( STDMETHODCALLTYPE *GetHeight )( + IDeckLinkDisplayMode_v7_6 * This); + + HRESULT ( STDMETHODCALLTYPE *GetFrameRate )( + IDeckLinkDisplayMode_v7_6 * This, + /* [out] */ BMDTimeValue *frameDuration, + /* [out] */ BMDTimeScale *timeScale); + + BMDFieldDominance ( STDMETHODCALLTYPE *GetFieldDominance )( + IDeckLinkDisplayMode_v7_6 * This); + + END_INTERFACE + } IDeckLinkDisplayMode_v7_6Vtbl; + + interface IDeckLinkDisplayMode_v7_6 + { + CONST_VTBL struct IDeckLinkDisplayMode_v7_6Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkDisplayMode_v7_6_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkDisplayMode_v7_6_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkDisplayMode_v7_6_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkDisplayMode_v7_6_GetName(This,name) \ + ( (This)->lpVtbl -> GetName(This,name) ) + +#define IDeckLinkDisplayMode_v7_6_GetDisplayMode(This) \ + ( (This)->lpVtbl -> GetDisplayMode(This) ) + +#define IDeckLinkDisplayMode_v7_6_GetWidth(This) \ + ( (This)->lpVtbl -> GetWidth(This) ) + +#define IDeckLinkDisplayMode_v7_6_GetHeight(This) \ + ( (This)->lpVtbl -> GetHeight(This) ) + +#define IDeckLinkDisplayMode_v7_6_GetFrameRate(This,frameDuration,timeScale) \ + ( (This)->lpVtbl -> GetFrameRate(This,frameDuration,timeScale) ) + +#define IDeckLinkDisplayMode_v7_6_GetFieldDominance(This) \ + ( (This)->lpVtbl -> GetFieldDominance(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkDisplayMode_v7_6_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkOutput_v7_6_INTERFACE_DEFINED__ +#define __IDeckLinkOutput_v7_6_INTERFACE_DEFINED__ + +/* interface IDeckLinkOutput_v7_6 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkOutput_v7_6; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("29228142-EB8C-4141-A621-F74026450955") + IDeckLinkOutput_v7_6 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE DoesSupportVideoMode( + BMDDisplayMode displayMode, + BMDPixelFormat pixelFormat, + /* [out] */ BMDDisplayModeSupport *result) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayModeIterator( + /* [out] */ IDeckLinkDisplayModeIterator_v7_6 **iterator) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetScreenPreviewCallback( + /* [in] */ IDeckLinkScreenPreviewCallback_v7_6 *previewCallback) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableVideoOutput( + BMDDisplayMode displayMode, + BMDVideoOutputFlags flags) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisableVideoOutput( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetVideoOutputFrameMemoryAllocator( + /* [in] */ IDeckLinkMemoryAllocator *theAllocator) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateVideoFrame( + int width, + int height, + int rowBytes, + BMDPixelFormat pixelFormat, + BMDFrameFlags flags, + /* [out] */ IDeckLinkMutableVideoFrame_v7_6 **outFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateAncillaryData( + BMDPixelFormat pixelFormat, + /* [out] */ IDeckLinkVideoFrameAncillary **outBuffer) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisplayVideoFrameSync( + /* [in] */ IDeckLinkVideoFrame_v7_6 *theFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE ScheduleVideoFrame( + /* [in] */ IDeckLinkVideoFrame_v7_6 *theFrame, + BMDTimeValue displayTime, + BMDTimeValue displayDuration, + BMDTimeScale timeScale) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetScheduledFrameCompletionCallback( + /* [in] */ IDeckLinkVideoOutputCallback_v7_6 *theCallback) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBufferedVideoFrameCount( + /* [out] */ unsigned int *bufferedFrameCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableAudioOutput( + BMDAudioSampleRate sampleRate, + BMDAudioSampleType sampleType, + unsigned int channelCount, + BMDAudioOutputStreamType streamType) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisableAudioOutput( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE WriteAudioSamplesSync( + /* [in] */ void *buffer, + unsigned int sampleFrameCount, + /* [out] */ unsigned int *sampleFramesWritten) = 0; + + virtual HRESULT STDMETHODCALLTYPE BeginAudioPreroll( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE EndAudioPreroll( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE ScheduleAudioSamples( + /* [in] */ void *buffer, + unsigned int sampleFrameCount, + BMDTimeValue streamTime, + BMDTimeScale timeScale, + /* [out] */ unsigned int *sampleFramesWritten) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBufferedAudioSampleFrameCount( + /* [out] */ unsigned int *bufferedSampleFrameCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE FlushBufferedAudioSamples( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetAudioCallback( + /* [in] */ IDeckLinkAudioOutputCallback *theCallback) = 0; + + virtual HRESULT STDMETHODCALLTYPE StartScheduledPlayback( + BMDTimeValue playbackStartTime, + BMDTimeScale timeScale, + double playbackSpeed) = 0; + + virtual HRESULT STDMETHODCALLTYPE StopScheduledPlayback( + BMDTimeValue stopPlaybackAtTime, + /* [out] */ BMDTimeValue *actualStopTime, + BMDTimeScale timeScale) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsScheduledPlaybackRunning( + /* [out] */ BOOL *active) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetScheduledStreamTime( + BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *streamTime, + /* [out] */ double *playbackSpeed) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetHardwareReferenceClock( + BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *hardwareTime, + /* [out] */ BMDTimeValue *timeInFrame, + /* [out] */ BMDTimeValue *ticksPerFrame) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkOutput_v7_6Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkOutput_v7_6 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkOutput_v7_6 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkOutput_v7_6 * This); + + HRESULT ( STDMETHODCALLTYPE *DoesSupportVideoMode )( + IDeckLinkOutput_v7_6 * This, + BMDDisplayMode displayMode, + BMDPixelFormat pixelFormat, + /* [out] */ BMDDisplayModeSupport *result); + + HRESULT ( STDMETHODCALLTYPE *GetDisplayModeIterator )( + IDeckLinkOutput_v7_6 * This, + /* [out] */ IDeckLinkDisplayModeIterator_v7_6 **iterator); + + HRESULT ( STDMETHODCALLTYPE *SetScreenPreviewCallback )( + IDeckLinkOutput_v7_6 * This, + /* [in] */ IDeckLinkScreenPreviewCallback_v7_6 *previewCallback); + + HRESULT ( STDMETHODCALLTYPE *EnableVideoOutput )( + IDeckLinkOutput_v7_6 * This, + BMDDisplayMode displayMode, + BMDVideoOutputFlags flags); + + HRESULT ( STDMETHODCALLTYPE *DisableVideoOutput )( + IDeckLinkOutput_v7_6 * This); + + HRESULT ( STDMETHODCALLTYPE *SetVideoOutputFrameMemoryAllocator )( + IDeckLinkOutput_v7_6 * This, + /* [in] */ IDeckLinkMemoryAllocator *theAllocator); + + HRESULT ( STDMETHODCALLTYPE *CreateVideoFrame )( + IDeckLinkOutput_v7_6 * This, + int width, + int height, + int rowBytes, + BMDPixelFormat pixelFormat, + BMDFrameFlags flags, + /* [out] */ IDeckLinkMutableVideoFrame_v7_6 **outFrame); + + HRESULT ( STDMETHODCALLTYPE *CreateAncillaryData )( + IDeckLinkOutput_v7_6 * This, + BMDPixelFormat pixelFormat, + /* [out] */ IDeckLinkVideoFrameAncillary **outBuffer); + + HRESULT ( STDMETHODCALLTYPE *DisplayVideoFrameSync )( + IDeckLinkOutput_v7_6 * This, + /* [in] */ IDeckLinkVideoFrame_v7_6 *theFrame); + + HRESULT ( STDMETHODCALLTYPE *ScheduleVideoFrame )( + IDeckLinkOutput_v7_6 * This, + /* [in] */ IDeckLinkVideoFrame_v7_6 *theFrame, + BMDTimeValue displayTime, + BMDTimeValue displayDuration, + BMDTimeScale timeScale); + + HRESULT ( STDMETHODCALLTYPE *SetScheduledFrameCompletionCallback )( + IDeckLinkOutput_v7_6 * This, + /* [in] */ IDeckLinkVideoOutputCallback_v7_6 *theCallback); + + HRESULT ( STDMETHODCALLTYPE *GetBufferedVideoFrameCount )( + IDeckLinkOutput_v7_6 * This, + /* [out] */ unsigned int *bufferedFrameCount); + + HRESULT ( STDMETHODCALLTYPE *EnableAudioOutput )( + IDeckLinkOutput_v7_6 * This, + BMDAudioSampleRate sampleRate, + BMDAudioSampleType sampleType, + unsigned int channelCount, + BMDAudioOutputStreamType streamType); + + HRESULT ( STDMETHODCALLTYPE *DisableAudioOutput )( + IDeckLinkOutput_v7_6 * This); + + HRESULT ( STDMETHODCALLTYPE *WriteAudioSamplesSync )( + IDeckLinkOutput_v7_6 * This, + /* [in] */ void *buffer, + unsigned int sampleFrameCount, + /* [out] */ unsigned int *sampleFramesWritten); + + HRESULT ( STDMETHODCALLTYPE *BeginAudioPreroll )( + IDeckLinkOutput_v7_6 * This); + + HRESULT ( STDMETHODCALLTYPE *EndAudioPreroll )( + IDeckLinkOutput_v7_6 * This); + + HRESULT ( STDMETHODCALLTYPE *ScheduleAudioSamples )( + IDeckLinkOutput_v7_6 * This, + /* [in] */ void *buffer, + unsigned int sampleFrameCount, + BMDTimeValue streamTime, + BMDTimeScale timeScale, + /* [out] */ unsigned int *sampleFramesWritten); + + HRESULT ( STDMETHODCALLTYPE *GetBufferedAudioSampleFrameCount )( + IDeckLinkOutput_v7_6 * This, + /* [out] */ unsigned int *bufferedSampleFrameCount); + + HRESULT ( STDMETHODCALLTYPE *FlushBufferedAudioSamples )( + IDeckLinkOutput_v7_6 * This); + + HRESULT ( STDMETHODCALLTYPE *SetAudioCallback )( + IDeckLinkOutput_v7_6 * This, + /* [in] */ IDeckLinkAudioOutputCallback *theCallback); + + HRESULT ( STDMETHODCALLTYPE *StartScheduledPlayback )( + IDeckLinkOutput_v7_6 * This, + BMDTimeValue playbackStartTime, + BMDTimeScale timeScale, + double playbackSpeed); + + HRESULT ( STDMETHODCALLTYPE *StopScheduledPlayback )( + IDeckLinkOutput_v7_6 * This, + BMDTimeValue stopPlaybackAtTime, + /* [out] */ BMDTimeValue *actualStopTime, + BMDTimeScale timeScale); + + HRESULT ( STDMETHODCALLTYPE *IsScheduledPlaybackRunning )( + IDeckLinkOutput_v7_6 * This, + /* [out] */ BOOL *active); + + HRESULT ( STDMETHODCALLTYPE *GetScheduledStreamTime )( + IDeckLinkOutput_v7_6 * This, + BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *streamTime, + /* [out] */ double *playbackSpeed); + + HRESULT ( STDMETHODCALLTYPE *GetHardwareReferenceClock )( + IDeckLinkOutput_v7_6 * This, + BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *hardwareTime, + /* [out] */ BMDTimeValue *timeInFrame, + /* [out] */ BMDTimeValue *ticksPerFrame); + + END_INTERFACE + } IDeckLinkOutput_v7_6Vtbl; + + interface IDeckLinkOutput_v7_6 + { + CONST_VTBL struct IDeckLinkOutput_v7_6Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkOutput_v7_6_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkOutput_v7_6_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkOutput_v7_6_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkOutput_v7_6_DoesSupportVideoMode(This,displayMode,pixelFormat,result) \ + ( (This)->lpVtbl -> DoesSupportVideoMode(This,displayMode,pixelFormat,result) ) + +#define IDeckLinkOutput_v7_6_GetDisplayModeIterator(This,iterator) \ + ( (This)->lpVtbl -> GetDisplayModeIterator(This,iterator) ) + +#define IDeckLinkOutput_v7_6_SetScreenPreviewCallback(This,previewCallback) \ + ( (This)->lpVtbl -> SetScreenPreviewCallback(This,previewCallback) ) + +#define IDeckLinkOutput_v7_6_EnableVideoOutput(This,displayMode,flags) \ + ( (This)->lpVtbl -> EnableVideoOutput(This,displayMode,flags) ) + +#define IDeckLinkOutput_v7_6_DisableVideoOutput(This) \ + ( (This)->lpVtbl -> DisableVideoOutput(This) ) + +#define IDeckLinkOutput_v7_6_SetVideoOutputFrameMemoryAllocator(This,theAllocator) \ + ( (This)->lpVtbl -> SetVideoOutputFrameMemoryAllocator(This,theAllocator) ) + +#define IDeckLinkOutput_v7_6_CreateVideoFrame(This,width,height,rowBytes,pixelFormat,flags,outFrame) \ + ( (This)->lpVtbl -> CreateVideoFrame(This,width,height,rowBytes,pixelFormat,flags,outFrame) ) + +#define IDeckLinkOutput_v7_6_CreateAncillaryData(This,pixelFormat,outBuffer) \ + ( (This)->lpVtbl -> CreateAncillaryData(This,pixelFormat,outBuffer) ) + +#define IDeckLinkOutput_v7_6_DisplayVideoFrameSync(This,theFrame) \ + ( (This)->lpVtbl -> DisplayVideoFrameSync(This,theFrame) ) + +#define IDeckLinkOutput_v7_6_ScheduleVideoFrame(This,theFrame,displayTime,displayDuration,timeScale) \ + ( (This)->lpVtbl -> ScheduleVideoFrame(This,theFrame,displayTime,displayDuration,timeScale) ) + +#define IDeckLinkOutput_v7_6_SetScheduledFrameCompletionCallback(This,theCallback) \ + ( (This)->lpVtbl -> SetScheduledFrameCompletionCallback(This,theCallback) ) + +#define IDeckLinkOutput_v7_6_GetBufferedVideoFrameCount(This,bufferedFrameCount) \ + ( (This)->lpVtbl -> GetBufferedVideoFrameCount(This,bufferedFrameCount) ) + +#define IDeckLinkOutput_v7_6_EnableAudioOutput(This,sampleRate,sampleType,channelCount,streamType) \ + ( (This)->lpVtbl -> EnableAudioOutput(This,sampleRate,sampleType,channelCount,streamType) ) + +#define IDeckLinkOutput_v7_6_DisableAudioOutput(This) \ + ( (This)->lpVtbl -> DisableAudioOutput(This) ) + +#define IDeckLinkOutput_v7_6_WriteAudioSamplesSync(This,buffer,sampleFrameCount,sampleFramesWritten) \ + ( (This)->lpVtbl -> WriteAudioSamplesSync(This,buffer,sampleFrameCount,sampleFramesWritten) ) + +#define IDeckLinkOutput_v7_6_BeginAudioPreroll(This) \ + ( (This)->lpVtbl -> BeginAudioPreroll(This) ) + +#define IDeckLinkOutput_v7_6_EndAudioPreroll(This) \ + ( (This)->lpVtbl -> EndAudioPreroll(This) ) + +#define IDeckLinkOutput_v7_6_ScheduleAudioSamples(This,buffer,sampleFrameCount,streamTime,timeScale,sampleFramesWritten) \ + ( (This)->lpVtbl -> ScheduleAudioSamples(This,buffer,sampleFrameCount,streamTime,timeScale,sampleFramesWritten) ) + +#define IDeckLinkOutput_v7_6_GetBufferedAudioSampleFrameCount(This,bufferedSampleFrameCount) \ + ( (This)->lpVtbl -> GetBufferedAudioSampleFrameCount(This,bufferedSampleFrameCount) ) + +#define IDeckLinkOutput_v7_6_FlushBufferedAudioSamples(This) \ + ( (This)->lpVtbl -> FlushBufferedAudioSamples(This) ) + +#define IDeckLinkOutput_v7_6_SetAudioCallback(This,theCallback) \ + ( (This)->lpVtbl -> SetAudioCallback(This,theCallback) ) + +#define IDeckLinkOutput_v7_6_StartScheduledPlayback(This,playbackStartTime,timeScale,playbackSpeed) \ + ( (This)->lpVtbl -> StartScheduledPlayback(This,playbackStartTime,timeScale,playbackSpeed) ) + +#define IDeckLinkOutput_v7_6_StopScheduledPlayback(This,stopPlaybackAtTime,actualStopTime,timeScale) \ + ( (This)->lpVtbl -> StopScheduledPlayback(This,stopPlaybackAtTime,actualStopTime,timeScale) ) + +#define IDeckLinkOutput_v7_6_IsScheduledPlaybackRunning(This,active) \ + ( (This)->lpVtbl -> IsScheduledPlaybackRunning(This,active) ) + +#define IDeckLinkOutput_v7_6_GetScheduledStreamTime(This,desiredTimeScale,streamTime,playbackSpeed) \ + ( (This)->lpVtbl -> GetScheduledStreamTime(This,desiredTimeScale,streamTime,playbackSpeed) ) + +#define IDeckLinkOutput_v7_6_GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) \ + ( (This)->lpVtbl -> GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkOutput_v7_6_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkInput_v7_6_INTERFACE_DEFINED__ +#define __IDeckLinkInput_v7_6_INTERFACE_DEFINED__ + +/* interface IDeckLinkInput_v7_6 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkInput_v7_6; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("300C135A-9F43-48E2-9906-6D7911D93CF1") + IDeckLinkInput_v7_6 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE DoesSupportVideoMode( + BMDDisplayMode displayMode, + BMDPixelFormat pixelFormat, + /* [out] */ BMDDisplayModeSupport *result) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayModeIterator( + /* [out] */ IDeckLinkDisplayModeIterator_v7_6 **iterator) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetScreenPreviewCallback( + /* [in] */ IDeckLinkScreenPreviewCallback_v7_6 *previewCallback) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableVideoInput( + BMDDisplayMode displayMode, + BMDPixelFormat pixelFormat, + BMDVideoInputFlags flags) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisableVideoInput( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAvailableVideoFrameCount( + /* [out] */ unsigned int *availableFrameCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableAudioInput( + BMDAudioSampleRate sampleRate, + BMDAudioSampleType sampleType, + unsigned int channelCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisableAudioInput( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAvailableAudioSampleFrameCount( + /* [out] */ unsigned int *availableSampleFrameCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE StartStreams( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE StopStreams( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE PauseStreams( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE FlushStreams( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetCallback( + /* [in] */ IDeckLinkInputCallback_v7_6 *theCallback) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetHardwareReferenceClock( + BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *hardwareTime, + /* [out] */ BMDTimeValue *timeInFrame, + /* [out] */ BMDTimeValue *ticksPerFrame) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkInput_v7_6Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkInput_v7_6 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkInput_v7_6 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkInput_v7_6 * This); + + HRESULT ( STDMETHODCALLTYPE *DoesSupportVideoMode )( + IDeckLinkInput_v7_6 * This, + BMDDisplayMode displayMode, + BMDPixelFormat pixelFormat, + /* [out] */ BMDDisplayModeSupport *result); + + HRESULT ( STDMETHODCALLTYPE *GetDisplayModeIterator )( + IDeckLinkInput_v7_6 * This, + /* [out] */ IDeckLinkDisplayModeIterator_v7_6 **iterator); + + HRESULT ( STDMETHODCALLTYPE *SetScreenPreviewCallback )( + IDeckLinkInput_v7_6 * This, + /* [in] */ IDeckLinkScreenPreviewCallback_v7_6 *previewCallback); + + HRESULT ( STDMETHODCALLTYPE *EnableVideoInput )( + IDeckLinkInput_v7_6 * This, + BMDDisplayMode displayMode, + BMDPixelFormat pixelFormat, + BMDVideoInputFlags flags); + + HRESULT ( STDMETHODCALLTYPE *DisableVideoInput )( + IDeckLinkInput_v7_6 * This); + + HRESULT ( STDMETHODCALLTYPE *GetAvailableVideoFrameCount )( + IDeckLinkInput_v7_6 * This, + /* [out] */ unsigned int *availableFrameCount); + + HRESULT ( STDMETHODCALLTYPE *EnableAudioInput )( + IDeckLinkInput_v7_6 * This, + BMDAudioSampleRate sampleRate, + BMDAudioSampleType sampleType, + unsigned int channelCount); + + HRESULT ( STDMETHODCALLTYPE *DisableAudioInput )( + IDeckLinkInput_v7_6 * This); + + HRESULT ( STDMETHODCALLTYPE *GetAvailableAudioSampleFrameCount )( + IDeckLinkInput_v7_6 * This, + /* [out] */ unsigned int *availableSampleFrameCount); + + HRESULT ( STDMETHODCALLTYPE *StartStreams )( + IDeckLinkInput_v7_6 * This); + + HRESULT ( STDMETHODCALLTYPE *StopStreams )( + IDeckLinkInput_v7_6 * This); + + HRESULT ( STDMETHODCALLTYPE *PauseStreams )( + IDeckLinkInput_v7_6 * This); + + HRESULT ( STDMETHODCALLTYPE *FlushStreams )( + IDeckLinkInput_v7_6 * This); + + HRESULT ( STDMETHODCALLTYPE *SetCallback )( + IDeckLinkInput_v7_6 * This, + /* [in] */ IDeckLinkInputCallback_v7_6 *theCallback); + + HRESULT ( STDMETHODCALLTYPE *GetHardwareReferenceClock )( + IDeckLinkInput_v7_6 * This, + BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *hardwareTime, + /* [out] */ BMDTimeValue *timeInFrame, + /* [out] */ BMDTimeValue *ticksPerFrame); + + END_INTERFACE + } IDeckLinkInput_v7_6Vtbl; + + interface IDeckLinkInput_v7_6 + { + CONST_VTBL struct IDeckLinkInput_v7_6Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkInput_v7_6_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkInput_v7_6_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkInput_v7_6_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkInput_v7_6_DoesSupportVideoMode(This,displayMode,pixelFormat,result) \ + ( (This)->lpVtbl -> DoesSupportVideoMode(This,displayMode,pixelFormat,result) ) + +#define IDeckLinkInput_v7_6_GetDisplayModeIterator(This,iterator) \ + ( (This)->lpVtbl -> GetDisplayModeIterator(This,iterator) ) + +#define IDeckLinkInput_v7_6_SetScreenPreviewCallback(This,previewCallback) \ + ( (This)->lpVtbl -> SetScreenPreviewCallback(This,previewCallback) ) + +#define IDeckLinkInput_v7_6_EnableVideoInput(This,displayMode,pixelFormat,flags) \ + ( (This)->lpVtbl -> EnableVideoInput(This,displayMode,pixelFormat,flags) ) + +#define IDeckLinkInput_v7_6_DisableVideoInput(This) \ + ( (This)->lpVtbl -> DisableVideoInput(This) ) + +#define IDeckLinkInput_v7_6_GetAvailableVideoFrameCount(This,availableFrameCount) \ + ( (This)->lpVtbl -> GetAvailableVideoFrameCount(This,availableFrameCount) ) + +#define IDeckLinkInput_v7_6_EnableAudioInput(This,sampleRate,sampleType,channelCount) \ + ( (This)->lpVtbl -> EnableAudioInput(This,sampleRate,sampleType,channelCount) ) + +#define IDeckLinkInput_v7_6_DisableAudioInput(This) \ + ( (This)->lpVtbl -> DisableAudioInput(This) ) + +#define IDeckLinkInput_v7_6_GetAvailableAudioSampleFrameCount(This,availableSampleFrameCount) \ + ( (This)->lpVtbl -> GetAvailableAudioSampleFrameCount(This,availableSampleFrameCount) ) + +#define IDeckLinkInput_v7_6_StartStreams(This) \ + ( (This)->lpVtbl -> StartStreams(This) ) + +#define IDeckLinkInput_v7_6_StopStreams(This) \ + ( (This)->lpVtbl -> StopStreams(This) ) + +#define IDeckLinkInput_v7_6_PauseStreams(This) \ + ( (This)->lpVtbl -> PauseStreams(This) ) + +#define IDeckLinkInput_v7_6_FlushStreams(This) \ + ( (This)->lpVtbl -> FlushStreams(This) ) + +#define IDeckLinkInput_v7_6_SetCallback(This,theCallback) \ + ( (This)->lpVtbl -> SetCallback(This,theCallback) ) + +#define IDeckLinkInput_v7_6_GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) \ + ( (This)->lpVtbl -> GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkInput_v7_6_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkTimecode_v7_6_INTERFACE_DEFINED__ +#define __IDeckLinkTimecode_v7_6_INTERFACE_DEFINED__ + +/* interface IDeckLinkTimecode_v7_6 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkTimecode_v7_6; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("EFB9BCA6-A521-44F7-BD69-2332F24D9EE6") + IDeckLinkTimecode_v7_6 : public IUnknown + { + public: + virtual BMDTimecodeBCD STDMETHODCALLTYPE GetBCD( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetComponents( + /* [out] */ unsigned char *hours, + /* [out] */ unsigned char *minutes, + /* [out] */ unsigned char *seconds, + /* [out] */ unsigned char *frames) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetString( + /* [out] */ BSTR *timecode) = 0; + + virtual BMDTimecodeFlags STDMETHODCALLTYPE GetFlags( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkTimecode_v7_6Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkTimecode_v7_6 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkTimecode_v7_6 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkTimecode_v7_6 * This); + + BMDTimecodeBCD ( STDMETHODCALLTYPE *GetBCD )( + IDeckLinkTimecode_v7_6 * This); + + HRESULT ( STDMETHODCALLTYPE *GetComponents )( + IDeckLinkTimecode_v7_6 * This, + /* [out] */ unsigned char *hours, + /* [out] */ unsigned char *minutes, + /* [out] */ unsigned char *seconds, + /* [out] */ unsigned char *frames); + + HRESULT ( STDMETHODCALLTYPE *GetString )( + IDeckLinkTimecode_v7_6 * This, + /* [out] */ BSTR *timecode); + + BMDTimecodeFlags ( STDMETHODCALLTYPE *GetFlags )( + IDeckLinkTimecode_v7_6 * This); + + END_INTERFACE + } IDeckLinkTimecode_v7_6Vtbl; + + interface IDeckLinkTimecode_v7_6 + { + CONST_VTBL struct IDeckLinkTimecode_v7_6Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkTimecode_v7_6_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkTimecode_v7_6_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkTimecode_v7_6_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkTimecode_v7_6_GetBCD(This) \ + ( (This)->lpVtbl -> GetBCD(This) ) + +#define IDeckLinkTimecode_v7_6_GetComponents(This,hours,minutes,seconds,frames) \ + ( (This)->lpVtbl -> GetComponents(This,hours,minutes,seconds,frames) ) + +#define IDeckLinkTimecode_v7_6_GetString(This,timecode) \ + ( (This)->lpVtbl -> GetString(This,timecode) ) + +#define IDeckLinkTimecode_v7_6_GetFlags(This) \ + ( (This)->lpVtbl -> GetFlags(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkTimecode_v7_6_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkVideoFrame_v7_6_INTERFACE_DEFINED__ +#define __IDeckLinkVideoFrame_v7_6_INTERFACE_DEFINED__ + +/* interface IDeckLinkVideoFrame_v7_6 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkVideoFrame_v7_6; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("A8D8238E-6B18-4196-99E1-5AF717B83D32") + IDeckLinkVideoFrame_v7_6 : public IUnknown + { + public: + virtual long STDMETHODCALLTYPE GetWidth( void) = 0; + + virtual long STDMETHODCALLTYPE GetHeight( void) = 0; + + virtual long STDMETHODCALLTYPE GetRowBytes( void) = 0; + + virtual BMDPixelFormat STDMETHODCALLTYPE GetPixelFormat( void) = 0; + + virtual BMDFrameFlags STDMETHODCALLTYPE GetFlags( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBytes( + /* [out] */ void **buffer) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTimecode( + BMDTimecodeFormat format, + /* [out] */ IDeckLinkTimecode_v7_6 **timecode) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAncillaryData( + /* [out] */ IDeckLinkVideoFrameAncillary **ancillary) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkVideoFrame_v7_6Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoFrame_v7_6 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoFrame_v7_6 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoFrame_v7_6 * This); + + long ( STDMETHODCALLTYPE *GetWidth )( + IDeckLinkVideoFrame_v7_6 * This); + + long ( STDMETHODCALLTYPE *GetHeight )( + IDeckLinkVideoFrame_v7_6 * This); + + long ( STDMETHODCALLTYPE *GetRowBytes )( + IDeckLinkVideoFrame_v7_6 * This); + + BMDPixelFormat ( STDMETHODCALLTYPE *GetPixelFormat )( + IDeckLinkVideoFrame_v7_6 * This); + + BMDFrameFlags ( STDMETHODCALLTYPE *GetFlags )( + IDeckLinkVideoFrame_v7_6 * This); + + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IDeckLinkVideoFrame_v7_6 * This, + /* [out] */ void **buffer); + + HRESULT ( STDMETHODCALLTYPE *GetTimecode )( + IDeckLinkVideoFrame_v7_6 * This, + BMDTimecodeFormat format, + /* [out] */ IDeckLinkTimecode_v7_6 **timecode); + + HRESULT ( STDMETHODCALLTYPE *GetAncillaryData )( + IDeckLinkVideoFrame_v7_6 * This, + /* [out] */ IDeckLinkVideoFrameAncillary **ancillary); + + END_INTERFACE + } IDeckLinkVideoFrame_v7_6Vtbl; + + interface IDeckLinkVideoFrame_v7_6 + { + CONST_VTBL struct IDeckLinkVideoFrame_v7_6Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkVideoFrame_v7_6_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkVideoFrame_v7_6_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkVideoFrame_v7_6_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkVideoFrame_v7_6_GetWidth(This) \ + ( (This)->lpVtbl -> GetWidth(This) ) + +#define IDeckLinkVideoFrame_v7_6_GetHeight(This) \ + ( (This)->lpVtbl -> GetHeight(This) ) + +#define IDeckLinkVideoFrame_v7_6_GetRowBytes(This) \ + ( (This)->lpVtbl -> GetRowBytes(This) ) + +#define IDeckLinkVideoFrame_v7_6_GetPixelFormat(This) \ + ( (This)->lpVtbl -> GetPixelFormat(This) ) + +#define IDeckLinkVideoFrame_v7_6_GetFlags(This) \ + ( (This)->lpVtbl -> GetFlags(This) ) + +#define IDeckLinkVideoFrame_v7_6_GetBytes(This,buffer) \ + ( (This)->lpVtbl -> GetBytes(This,buffer) ) + +#define IDeckLinkVideoFrame_v7_6_GetTimecode(This,format,timecode) \ + ( (This)->lpVtbl -> GetTimecode(This,format,timecode) ) + +#define IDeckLinkVideoFrame_v7_6_GetAncillaryData(This,ancillary) \ + ( (This)->lpVtbl -> GetAncillaryData(This,ancillary) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkVideoFrame_v7_6_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkMutableVideoFrame_v7_6_INTERFACE_DEFINED__ +#define __IDeckLinkMutableVideoFrame_v7_6_INTERFACE_DEFINED__ + +/* interface IDeckLinkMutableVideoFrame_v7_6 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkMutableVideoFrame_v7_6; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("46FCEE00-B4E6-43D0-91C0-023A7FCEB34F") + IDeckLinkMutableVideoFrame_v7_6 : public IDeckLinkVideoFrame_v7_6 + { + public: + virtual HRESULT STDMETHODCALLTYPE SetFlags( + BMDFrameFlags newFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetTimecode( + BMDTimecodeFormat format, + /* [in] */ IDeckLinkTimecode_v7_6 *timecode) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetTimecodeFromComponents( + BMDTimecodeFormat format, + unsigned char hours, + unsigned char minutes, + unsigned char seconds, + unsigned char frames, + BMDTimecodeFlags flags) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetAncillaryData( + /* [in] */ IDeckLinkVideoFrameAncillary *ancillary) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkMutableVideoFrame_v7_6Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkMutableVideoFrame_v7_6 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkMutableVideoFrame_v7_6 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkMutableVideoFrame_v7_6 * This); + + long ( STDMETHODCALLTYPE *GetWidth )( + IDeckLinkMutableVideoFrame_v7_6 * This); + + long ( STDMETHODCALLTYPE *GetHeight )( + IDeckLinkMutableVideoFrame_v7_6 * This); + + long ( STDMETHODCALLTYPE *GetRowBytes )( + IDeckLinkMutableVideoFrame_v7_6 * This); + + BMDPixelFormat ( STDMETHODCALLTYPE *GetPixelFormat )( + IDeckLinkMutableVideoFrame_v7_6 * This); + + BMDFrameFlags ( STDMETHODCALLTYPE *GetFlags )( + IDeckLinkMutableVideoFrame_v7_6 * This); + + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IDeckLinkMutableVideoFrame_v7_6 * This, + /* [out] */ void **buffer); + + HRESULT ( STDMETHODCALLTYPE *GetTimecode )( + IDeckLinkMutableVideoFrame_v7_6 * This, + BMDTimecodeFormat format, + /* [out] */ IDeckLinkTimecode_v7_6 **timecode); + + HRESULT ( STDMETHODCALLTYPE *GetAncillaryData )( + IDeckLinkMutableVideoFrame_v7_6 * This, + /* [out] */ IDeckLinkVideoFrameAncillary **ancillary); + + HRESULT ( STDMETHODCALLTYPE *SetFlags )( + IDeckLinkMutableVideoFrame_v7_6 * This, + BMDFrameFlags newFlags); + + HRESULT ( STDMETHODCALLTYPE *SetTimecode )( + IDeckLinkMutableVideoFrame_v7_6 * This, + BMDTimecodeFormat format, + /* [in] */ IDeckLinkTimecode_v7_6 *timecode); + + HRESULT ( STDMETHODCALLTYPE *SetTimecodeFromComponents )( + IDeckLinkMutableVideoFrame_v7_6 * This, + BMDTimecodeFormat format, + unsigned char hours, + unsigned char minutes, + unsigned char seconds, + unsigned char frames, + BMDTimecodeFlags flags); + + HRESULT ( STDMETHODCALLTYPE *SetAncillaryData )( + IDeckLinkMutableVideoFrame_v7_6 * This, + /* [in] */ IDeckLinkVideoFrameAncillary *ancillary); + + END_INTERFACE + } IDeckLinkMutableVideoFrame_v7_6Vtbl; + + interface IDeckLinkMutableVideoFrame_v7_6 + { + CONST_VTBL struct IDeckLinkMutableVideoFrame_v7_6Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkMutableVideoFrame_v7_6_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkMutableVideoFrame_v7_6_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkMutableVideoFrame_v7_6_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkMutableVideoFrame_v7_6_GetWidth(This) \ + ( (This)->lpVtbl -> GetWidth(This) ) + +#define IDeckLinkMutableVideoFrame_v7_6_GetHeight(This) \ + ( (This)->lpVtbl -> GetHeight(This) ) + +#define IDeckLinkMutableVideoFrame_v7_6_GetRowBytes(This) \ + ( (This)->lpVtbl -> GetRowBytes(This) ) + +#define IDeckLinkMutableVideoFrame_v7_6_GetPixelFormat(This) \ + ( (This)->lpVtbl -> GetPixelFormat(This) ) + +#define IDeckLinkMutableVideoFrame_v7_6_GetFlags(This) \ + ( (This)->lpVtbl -> GetFlags(This) ) + +#define IDeckLinkMutableVideoFrame_v7_6_GetBytes(This,buffer) \ + ( (This)->lpVtbl -> GetBytes(This,buffer) ) + +#define IDeckLinkMutableVideoFrame_v7_6_GetTimecode(This,format,timecode) \ + ( (This)->lpVtbl -> GetTimecode(This,format,timecode) ) + +#define IDeckLinkMutableVideoFrame_v7_6_GetAncillaryData(This,ancillary) \ + ( (This)->lpVtbl -> GetAncillaryData(This,ancillary) ) + + +#define IDeckLinkMutableVideoFrame_v7_6_SetFlags(This,newFlags) \ + ( (This)->lpVtbl -> SetFlags(This,newFlags) ) + +#define IDeckLinkMutableVideoFrame_v7_6_SetTimecode(This,format,timecode) \ + ( (This)->lpVtbl -> SetTimecode(This,format,timecode) ) + +#define IDeckLinkMutableVideoFrame_v7_6_SetTimecodeFromComponents(This,format,hours,minutes,seconds,frames,flags) \ + ( (This)->lpVtbl -> SetTimecodeFromComponents(This,format,hours,minutes,seconds,frames,flags) ) + +#define IDeckLinkMutableVideoFrame_v7_6_SetAncillaryData(This,ancillary) \ + ( (This)->lpVtbl -> SetAncillaryData(This,ancillary) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkMutableVideoFrame_v7_6_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkVideoInputFrame_v7_6_INTERFACE_DEFINED__ +#define __IDeckLinkVideoInputFrame_v7_6_INTERFACE_DEFINED__ + +/* interface IDeckLinkVideoInputFrame_v7_6 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkVideoInputFrame_v7_6; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("9A74FA41-AE9F-47AC-8CF4-01F42DD59965") + IDeckLinkVideoInputFrame_v7_6 : public IDeckLinkVideoFrame_v7_6 + { + public: + virtual HRESULT STDMETHODCALLTYPE GetStreamTime( + /* [out] */ BMDTimeValue *frameTime, + /* [out] */ BMDTimeValue *frameDuration, + BMDTimeScale timeScale) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetHardwareReferenceTimestamp( + BMDTimeScale timeScale, + /* [out] */ BMDTimeValue *frameTime, + /* [out] */ BMDTimeValue *frameDuration) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkVideoInputFrame_v7_6Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoInputFrame_v7_6 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoInputFrame_v7_6 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoInputFrame_v7_6 * This); + + long ( STDMETHODCALLTYPE *GetWidth )( + IDeckLinkVideoInputFrame_v7_6 * This); + + long ( STDMETHODCALLTYPE *GetHeight )( + IDeckLinkVideoInputFrame_v7_6 * This); + + long ( STDMETHODCALLTYPE *GetRowBytes )( + IDeckLinkVideoInputFrame_v7_6 * This); + + BMDPixelFormat ( STDMETHODCALLTYPE *GetPixelFormat )( + IDeckLinkVideoInputFrame_v7_6 * This); + + BMDFrameFlags ( STDMETHODCALLTYPE *GetFlags )( + IDeckLinkVideoInputFrame_v7_6 * This); + + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IDeckLinkVideoInputFrame_v7_6 * This, + /* [out] */ void **buffer); + + HRESULT ( STDMETHODCALLTYPE *GetTimecode )( + IDeckLinkVideoInputFrame_v7_6 * This, + BMDTimecodeFormat format, + /* [out] */ IDeckLinkTimecode_v7_6 **timecode); + + HRESULT ( STDMETHODCALLTYPE *GetAncillaryData )( + IDeckLinkVideoInputFrame_v7_6 * This, + /* [out] */ IDeckLinkVideoFrameAncillary **ancillary); + + HRESULT ( STDMETHODCALLTYPE *GetStreamTime )( + IDeckLinkVideoInputFrame_v7_6 * This, + /* [out] */ BMDTimeValue *frameTime, + /* [out] */ BMDTimeValue *frameDuration, + BMDTimeScale timeScale); + + HRESULT ( STDMETHODCALLTYPE *GetHardwareReferenceTimestamp )( + IDeckLinkVideoInputFrame_v7_6 * This, + BMDTimeScale timeScale, + /* [out] */ BMDTimeValue *frameTime, + /* [out] */ BMDTimeValue *frameDuration); + + END_INTERFACE + } IDeckLinkVideoInputFrame_v7_6Vtbl; + + interface IDeckLinkVideoInputFrame_v7_6 + { + CONST_VTBL struct IDeckLinkVideoInputFrame_v7_6Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkVideoInputFrame_v7_6_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkVideoInputFrame_v7_6_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkVideoInputFrame_v7_6_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkVideoInputFrame_v7_6_GetWidth(This) \ + ( (This)->lpVtbl -> GetWidth(This) ) + +#define IDeckLinkVideoInputFrame_v7_6_GetHeight(This) \ + ( (This)->lpVtbl -> GetHeight(This) ) + +#define IDeckLinkVideoInputFrame_v7_6_GetRowBytes(This) \ + ( (This)->lpVtbl -> GetRowBytes(This) ) + +#define IDeckLinkVideoInputFrame_v7_6_GetPixelFormat(This) \ + ( (This)->lpVtbl -> GetPixelFormat(This) ) + +#define IDeckLinkVideoInputFrame_v7_6_GetFlags(This) \ + ( (This)->lpVtbl -> GetFlags(This) ) + +#define IDeckLinkVideoInputFrame_v7_6_GetBytes(This,buffer) \ + ( (This)->lpVtbl -> GetBytes(This,buffer) ) + +#define IDeckLinkVideoInputFrame_v7_6_GetTimecode(This,format,timecode) \ + ( (This)->lpVtbl -> GetTimecode(This,format,timecode) ) + +#define IDeckLinkVideoInputFrame_v7_6_GetAncillaryData(This,ancillary) \ + ( (This)->lpVtbl -> GetAncillaryData(This,ancillary) ) + + +#define IDeckLinkVideoInputFrame_v7_6_GetStreamTime(This,frameTime,frameDuration,timeScale) \ + ( (This)->lpVtbl -> GetStreamTime(This,frameTime,frameDuration,timeScale) ) + +#define IDeckLinkVideoInputFrame_v7_6_GetHardwareReferenceTimestamp(This,timeScale,frameTime,frameDuration) \ + ( (This)->lpVtbl -> GetHardwareReferenceTimestamp(This,timeScale,frameTime,frameDuration) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkVideoInputFrame_v7_6_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkScreenPreviewCallback_v7_6_INTERFACE_DEFINED__ +#define __IDeckLinkScreenPreviewCallback_v7_6_INTERFACE_DEFINED__ + +/* interface IDeckLinkScreenPreviewCallback_v7_6 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkScreenPreviewCallback_v7_6; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("373F499D-4B4D-4518-AD22-6354E5A5825E") + IDeckLinkScreenPreviewCallback_v7_6 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE DrawFrame( + /* [in] */ IDeckLinkVideoFrame_v7_6 *theFrame) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkScreenPreviewCallback_v7_6Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkScreenPreviewCallback_v7_6 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkScreenPreviewCallback_v7_6 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkScreenPreviewCallback_v7_6 * This); + + HRESULT ( STDMETHODCALLTYPE *DrawFrame )( + IDeckLinkScreenPreviewCallback_v7_6 * This, + /* [in] */ IDeckLinkVideoFrame_v7_6 *theFrame); + + END_INTERFACE + } IDeckLinkScreenPreviewCallback_v7_6Vtbl; + + interface IDeckLinkScreenPreviewCallback_v7_6 + { + CONST_VTBL struct IDeckLinkScreenPreviewCallback_v7_6Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkScreenPreviewCallback_v7_6_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkScreenPreviewCallback_v7_6_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkScreenPreviewCallback_v7_6_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkScreenPreviewCallback_v7_6_DrawFrame(This,theFrame) \ + ( (This)->lpVtbl -> DrawFrame(This,theFrame) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkScreenPreviewCallback_v7_6_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkGLScreenPreviewHelper_v7_6_INTERFACE_DEFINED__ +#define __IDeckLinkGLScreenPreviewHelper_v7_6_INTERFACE_DEFINED__ + +/* interface IDeckLinkGLScreenPreviewHelper_v7_6 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkGLScreenPreviewHelper_v7_6; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("BA575CD9-A15E-497B-B2C2-F9AFE7BE4EBA") + IDeckLinkGLScreenPreviewHelper_v7_6 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE InitializeGL( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE PaintGL( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetFrame( + /* [in] */ IDeckLinkVideoFrame_v7_6 *theFrame) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkGLScreenPreviewHelper_v7_6Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkGLScreenPreviewHelper_v7_6 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkGLScreenPreviewHelper_v7_6 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkGLScreenPreviewHelper_v7_6 * This); + + HRESULT ( STDMETHODCALLTYPE *InitializeGL )( + IDeckLinkGLScreenPreviewHelper_v7_6 * This); + + HRESULT ( STDMETHODCALLTYPE *PaintGL )( + IDeckLinkGLScreenPreviewHelper_v7_6 * This); + + HRESULT ( STDMETHODCALLTYPE *SetFrame )( + IDeckLinkGLScreenPreviewHelper_v7_6 * This, + /* [in] */ IDeckLinkVideoFrame_v7_6 *theFrame); + + END_INTERFACE + } IDeckLinkGLScreenPreviewHelper_v7_6Vtbl; + + interface IDeckLinkGLScreenPreviewHelper_v7_6 + { + CONST_VTBL struct IDeckLinkGLScreenPreviewHelper_v7_6Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkGLScreenPreviewHelper_v7_6_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkGLScreenPreviewHelper_v7_6_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkGLScreenPreviewHelper_v7_6_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkGLScreenPreviewHelper_v7_6_InitializeGL(This) \ + ( (This)->lpVtbl -> InitializeGL(This) ) + +#define IDeckLinkGLScreenPreviewHelper_v7_6_PaintGL(This) \ + ( (This)->lpVtbl -> PaintGL(This) ) + +#define IDeckLinkGLScreenPreviewHelper_v7_6_SetFrame(This,theFrame) \ + ( (This)->lpVtbl -> SetFrame(This,theFrame) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkGLScreenPreviewHelper_v7_6_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkVideoConversion_v7_6_INTERFACE_DEFINED__ +#define __IDeckLinkVideoConversion_v7_6_INTERFACE_DEFINED__ + +/* interface IDeckLinkVideoConversion_v7_6 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkVideoConversion_v7_6; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("3EB504C9-F97D-40FE-A158-D407D48CB53B") + IDeckLinkVideoConversion_v7_6 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE ConvertFrame( + /* [in] */ IDeckLinkVideoFrame_v7_6 *srcFrame, + /* [in] */ IDeckLinkVideoFrame_v7_6 *dstFrame) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkVideoConversion_v7_6Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoConversion_v7_6 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoConversion_v7_6 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoConversion_v7_6 * This); + + HRESULT ( STDMETHODCALLTYPE *ConvertFrame )( + IDeckLinkVideoConversion_v7_6 * This, + /* [in] */ IDeckLinkVideoFrame_v7_6 *srcFrame, + /* [in] */ IDeckLinkVideoFrame_v7_6 *dstFrame); + + END_INTERFACE + } IDeckLinkVideoConversion_v7_6Vtbl; + + interface IDeckLinkVideoConversion_v7_6 + { + CONST_VTBL struct IDeckLinkVideoConversion_v7_6Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkVideoConversion_v7_6_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkVideoConversion_v7_6_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkVideoConversion_v7_6_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkVideoConversion_v7_6_ConvertFrame(This,srcFrame,dstFrame) \ + ( (This)->lpVtbl -> ConvertFrame(This,srcFrame,dstFrame) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkVideoConversion_v7_6_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkConfiguration_v7_6_INTERFACE_DEFINED__ +#define __IDeckLinkConfiguration_v7_6_INTERFACE_DEFINED__ + +/* interface IDeckLinkConfiguration_v7_6 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkConfiguration_v7_6; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("B8EAD569-B764-47F0-A73F-AE40DF6CBF10") + IDeckLinkConfiguration_v7_6 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetConfigurationValidator( + /* [out] */ IDeckLinkConfiguration_v7_6 **configObject) = 0; + + virtual HRESULT STDMETHODCALLTYPE WriteConfigurationToPreferences( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetVideoOutputFormat( + /* [in] */ BMDVideoConnection_v7_6 videoOutputConnection) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsVideoOutputActive( + /* [in] */ BMDVideoConnection_v7_6 videoOutputConnection, + /* [out] */ BOOL *active) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetAnalogVideoOutputFlags( + /* [in] */ BMDAnalogVideoFlags analogVideoFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAnalogVideoOutputFlags( + /* [out] */ BMDAnalogVideoFlags *analogVideoFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableFieldFlickerRemovalWhenPaused( + /* [in] */ BOOL enable) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsEnabledFieldFlickerRemovalWhenPaused( + /* [out] */ BOOL *enabled) = 0; + + virtual HRESULT STDMETHODCALLTYPE Set444And3GBpsVideoOutput( + /* [in] */ BOOL enable444VideoOutput, + /* [in] */ BOOL enable3GbsOutput) = 0; + + virtual HRESULT STDMETHODCALLTYPE Get444And3GBpsVideoOutput( + /* [out] */ BOOL *is444VideoOutputEnabled, + /* [out] */ BOOL *threeGbsOutputEnabled) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetVideoOutputConversionMode( + /* [in] */ BMDVideoOutputConversionMode conversionMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetVideoOutputConversionMode( + /* [out] */ BMDVideoOutputConversionMode *conversionMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE Set_HD1080p24_to_HD1080i5994_Conversion( + /* [in] */ BOOL enable) = 0; + + virtual HRESULT STDMETHODCALLTYPE Get_HD1080p24_to_HD1080i5994_Conversion( + /* [out] */ BOOL *enabled) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetVideoInputFormat( + /* [in] */ BMDVideoConnection_v7_6 videoInputFormat) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetVideoInputFormat( + /* [out] */ BMDVideoConnection_v7_6 *videoInputFormat) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetAnalogVideoInputFlags( + /* [in] */ BMDAnalogVideoFlags analogVideoFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAnalogVideoInputFlags( + /* [out] */ BMDAnalogVideoFlags *analogVideoFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetVideoInputConversionMode( + /* [in] */ BMDVideoInputConversionMode conversionMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetVideoInputConversionMode( + /* [out] */ BMDVideoInputConversionMode *conversionMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetBlackVideoOutputDuringCapture( + /* [in] */ BOOL blackOutInCapture) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBlackVideoOutputDuringCapture( + /* [out] */ BOOL *blackOutInCapture) = 0; + + virtual HRESULT STDMETHODCALLTYPE Set32PulldownSequenceInitialTimecodeFrame( + /* [in] */ unsigned int aFrameTimecode) = 0; + + virtual HRESULT STDMETHODCALLTYPE Get32PulldownSequenceInitialTimecodeFrame( + /* [out] */ unsigned int *aFrameTimecode) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetVancSourceLineMapping( + /* [in] */ unsigned int activeLine1VANCsource, + /* [in] */ unsigned int activeLine2VANCsource, + /* [in] */ unsigned int activeLine3VANCsource) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetVancSourceLineMapping( + /* [out] */ unsigned int *activeLine1VANCsource, + /* [out] */ unsigned int *activeLine2VANCsource, + /* [out] */ unsigned int *activeLine3VANCsource) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetAudioInputFormat( + /* [in] */ BMDAudioConnection_v10_2 audioInputFormat) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAudioInputFormat( + /* [out] */ BMDAudioConnection_v10_2 *audioInputFormat) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkConfiguration_v7_6Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkConfiguration_v7_6 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkConfiguration_v7_6 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkConfiguration_v7_6 * This); + + HRESULT ( STDMETHODCALLTYPE *GetConfigurationValidator )( + IDeckLinkConfiguration_v7_6 * This, + /* [out] */ IDeckLinkConfiguration_v7_6 **configObject); + + HRESULT ( STDMETHODCALLTYPE *WriteConfigurationToPreferences )( + IDeckLinkConfiguration_v7_6 * This); + + HRESULT ( STDMETHODCALLTYPE *SetVideoOutputFormat )( + IDeckLinkConfiguration_v7_6 * This, + /* [in] */ BMDVideoConnection_v7_6 videoOutputConnection); + + HRESULT ( STDMETHODCALLTYPE *IsVideoOutputActive )( + IDeckLinkConfiguration_v7_6 * This, + /* [in] */ BMDVideoConnection_v7_6 videoOutputConnection, + /* [out] */ BOOL *active); + + HRESULT ( STDMETHODCALLTYPE *SetAnalogVideoOutputFlags )( + IDeckLinkConfiguration_v7_6 * This, + /* [in] */ BMDAnalogVideoFlags analogVideoFlags); + + HRESULT ( STDMETHODCALLTYPE *GetAnalogVideoOutputFlags )( + IDeckLinkConfiguration_v7_6 * This, + /* [out] */ BMDAnalogVideoFlags *analogVideoFlags); + + HRESULT ( STDMETHODCALLTYPE *EnableFieldFlickerRemovalWhenPaused )( + IDeckLinkConfiguration_v7_6 * This, + /* [in] */ BOOL enable); + + HRESULT ( STDMETHODCALLTYPE *IsEnabledFieldFlickerRemovalWhenPaused )( + IDeckLinkConfiguration_v7_6 * This, + /* [out] */ BOOL *enabled); + + HRESULT ( STDMETHODCALLTYPE *Set444And3GBpsVideoOutput )( + IDeckLinkConfiguration_v7_6 * This, + /* [in] */ BOOL enable444VideoOutput, + /* [in] */ BOOL enable3GbsOutput); + + HRESULT ( STDMETHODCALLTYPE *Get444And3GBpsVideoOutput )( + IDeckLinkConfiguration_v7_6 * This, + /* [out] */ BOOL *is444VideoOutputEnabled, + /* [out] */ BOOL *threeGbsOutputEnabled); + + HRESULT ( STDMETHODCALLTYPE *SetVideoOutputConversionMode )( + IDeckLinkConfiguration_v7_6 * This, + /* [in] */ BMDVideoOutputConversionMode conversionMode); + + HRESULT ( STDMETHODCALLTYPE *GetVideoOutputConversionMode )( + IDeckLinkConfiguration_v7_6 * This, + /* [out] */ BMDVideoOutputConversionMode *conversionMode); + + HRESULT ( STDMETHODCALLTYPE *Set_HD1080p24_to_HD1080i5994_Conversion )( + IDeckLinkConfiguration_v7_6 * This, + /* [in] */ BOOL enable); + + HRESULT ( STDMETHODCALLTYPE *Get_HD1080p24_to_HD1080i5994_Conversion )( + IDeckLinkConfiguration_v7_6 * This, + /* [out] */ BOOL *enabled); + + HRESULT ( STDMETHODCALLTYPE *SetVideoInputFormat )( + IDeckLinkConfiguration_v7_6 * This, + /* [in] */ BMDVideoConnection_v7_6 videoInputFormat); + + HRESULT ( STDMETHODCALLTYPE *GetVideoInputFormat )( + IDeckLinkConfiguration_v7_6 * This, + /* [out] */ BMDVideoConnection_v7_6 *videoInputFormat); + + HRESULT ( STDMETHODCALLTYPE *SetAnalogVideoInputFlags )( + IDeckLinkConfiguration_v7_6 * This, + /* [in] */ BMDAnalogVideoFlags analogVideoFlags); + + HRESULT ( STDMETHODCALLTYPE *GetAnalogVideoInputFlags )( + IDeckLinkConfiguration_v7_6 * This, + /* [out] */ BMDAnalogVideoFlags *analogVideoFlags); + + HRESULT ( STDMETHODCALLTYPE *SetVideoInputConversionMode )( + IDeckLinkConfiguration_v7_6 * This, + /* [in] */ BMDVideoInputConversionMode conversionMode); + + HRESULT ( STDMETHODCALLTYPE *GetVideoInputConversionMode )( + IDeckLinkConfiguration_v7_6 * This, + /* [out] */ BMDVideoInputConversionMode *conversionMode); + + HRESULT ( STDMETHODCALLTYPE *SetBlackVideoOutputDuringCapture )( + IDeckLinkConfiguration_v7_6 * This, + /* [in] */ BOOL blackOutInCapture); + + HRESULT ( STDMETHODCALLTYPE *GetBlackVideoOutputDuringCapture )( + IDeckLinkConfiguration_v7_6 * This, + /* [out] */ BOOL *blackOutInCapture); + + HRESULT ( STDMETHODCALLTYPE *Set32PulldownSequenceInitialTimecodeFrame )( + IDeckLinkConfiguration_v7_6 * This, + /* [in] */ unsigned int aFrameTimecode); + + HRESULT ( STDMETHODCALLTYPE *Get32PulldownSequenceInitialTimecodeFrame )( + IDeckLinkConfiguration_v7_6 * This, + /* [out] */ unsigned int *aFrameTimecode); + + HRESULT ( STDMETHODCALLTYPE *SetVancSourceLineMapping )( + IDeckLinkConfiguration_v7_6 * This, + /* [in] */ unsigned int activeLine1VANCsource, + /* [in] */ unsigned int activeLine2VANCsource, + /* [in] */ unsigned int activeLine3VANCsource); + + HRESULT ( STDMETHODCALLTYPE *GetVancSourceLineMapping )( + IDeckLinkConfiguration_v7_6 * This, + /* [out] */ unsigned int *activeLine1VANCsource, + /* [out] */ unsigned int *activeLine2VANCsource, + /* [out] */ unsigned int *activeLine3VANCsource); + + HRESULT ( STDMETHODCALLTYPE *SetAudioInputFormat )( + IDeckLinkConfiguration_v7_6 * This, + /* [in] */ BMDAudioConnection_v10_2 audioInputFormat); + + HRESULT ( STDMETHODCALLTYPE *GetAudioInputFormat )( + IDeckLinkConfiguration_v7_6 * This, + /* [out] */ BMDAudioConnection_v10_2 *audioInputFormat); + + END_INTERFACE + } IDeckLinkConfiguration_v7_6Vtbl; + + interface IDeckLinkConfiguration_v7_6 + { + CONST_VTBL struct IDeckLinkConfiguration_v7_6Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkConfiguration_v7_6_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkConfiguration_v7_6_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkConfiguration_v7_6_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkConfiguration_v7_6_GetConfigurationValidator(This,configObject) \ + ( (This)->lpVtbl -> GetConfigurationValidator(This,configObject) ) + +#define IDeckLinkConfiguration_v7_6_WriteConfigurationToPreferences(This) \ + ( (This)->lpVtbl -> WriteConfigurationToPreferences(This) ) + +#define IDeckLinkConfiguration_v7_6_SetVideoOutputFormat(This,videoOutputConnection) \ + ( (This)->lpVtbl -> SetVideoOutputFormat(This,videoOutputConnection) ) + +#define IDeckLinkConfiguration_v7_6_IsVideoOutputActive(This,videoOutputConnection,active) \ + ( (This)->lpVtbl -> IsVideoOutputActive(This,videoOutputConnection,active) ) + +#define IDeckLinkConfiguration_v7_6_SetAnalogVideoOutputFlags(This,analogVideoFlags) \ + ( (This)->lpVtbl -> SetAnalogVideoOutputFlags(This,analogVideoFlags) ) + +#define IDeckLinkConfiguration_v7_6_GetAnalogVideoOutputFlags(This,analogVideoFlags) \ + ( (This)->lpVtbl -> GetAnalogVideoOutputFlags(This,analogVideoFlags) ) + +#define IDeckLinkConfiguration_v7_6_EnableFieldFlickerRemovalWhenPaused(This,enable) \ + ( (This)->lpVtbl -> EnableFieldFlickerRemovalWhenPaused(This,enable) ) + +#define IDeckLinkConfiguration_v7_6_IsEnabledFieldFlickerRemovalWhenPaused(This,enabled) \ + ( (This)->lpVtbl -> IsEnabledFieldFlickerRemovalWhenPaused(This,enabled) ) + +#define IDeckLinkConfiguration_v7_6_Set444And3GBpsVideoOutput(This,enable444VideoOutput,enable3GbsOutput) \ + ( (This)->lpVtbl -> Set444And3GBpsVideoOutput(This,enable444VideoOutput,enable3GbsOutput) ) + +#define IDeckLinkConfiguration_v7_6_Get444And3GBpsVideoOutput(This,is444VideoOutputEnabled,threeGbsOutputEnabled) \ + ( (This)->lpVtbl -> Get444And3GBpsVideoOutput(This,is444VideoOutputEnabled,threeGbsOutputEnabled) ) + +#define IDeckLinkConfiguration_v7_6_SetVideoOutputConversionMode(This,conversionMode) \ + ( (This)->lpVtbl -> SetVideoOutputConversionMode(This,conversionMode) ) + +#define IDeckLinkConfiguration_v7_6_GetVideoOutputConversionMode(This,conversionMode) \ + ( (This)->lpVtbl -> GetVideoOutputConversionMode(This,conversionMode) ) + +#define IDeckLinkConfiguration_v7_6_Set_HD1080p24_to_HD1080i5994_Conversion(This,enable) \ + ( (This)->lpVtbl -> Set_HD1080p24_to_HD1080i5994_Conversion(This,enable) ) + +#define IDeckLinkConfiguration_v7_6_Get_HD1080p24_to_HD1080i5994_Conversion(This,enabled) \ + ( (This)->lpVtbl -> Get_HD1080p24_to_HD1080i5994_Conversion(This,enabled) ) + +#define IDeckLinkConfiguration_v7_6_SetVideoInputFormat(This,videoInputFormat) \ + ( (This)->lpVtbl -> SetVideoInputFormat(This,videoInputFormat) ) + +#define IDeckLinkConfiguration_v7_6_GetVideoInputFormat(This,videoInputFormat) \ + ( (This)->lpVtbl -> GetVideoInputFormat(This,videoInputFormat) ) + +#define IDeckLinkConfiguration_v7_6_SetAnalogVideoInputFlags(This,analogVideoFlags) \ + ( (This)->lpVtbl -> SetAnalogVideoInputFlags(This,analogVideoFlags) ) + +#define IDeckLinkConfiguration_v7_6_GetAnalogVideoInputFlags(This,analogVideoFlags) \ + ( (This)->lpVtbl -> GetAnalogVideoInputFlags(This,analogVideoFlags) ) + +#define IDeckLinkConfiguration_v7_6_SetVideoInputConversionMode(This,conversionMode) \ + ( (This)->lpVtbl -> SetVideoInputConversionMode(This,conversionMode) ) + +#define IDeckLinkConfiguration_v7_6_GetVideoInputConversionMode(This,conversionMode) \ + ( (This)->lpVtbl -> GetVideoInputConversionMode(This,conversionMode) ) + +#define IDeckLinkConfiguration_v7_6_SetBlackVideoOutputDuringCapture(This,blackOutInCapture) \ + ( (This)->lpVtbl -> SetBlackVideoOutputDuringCapture(This,blackOutInCapture) ) + +#define IDeckLinkConfiguration_v7_6_GetBlackVideoOutputDuringCapture(This,blackOutInCapture) \ + ( (This)->lpVtbl -> GetBlackVideoOutputDuringCapture(This,blackOutInCapture) ) + +#define IDeckLinkConfiguration_v7_6_Set32PulldownSequenceInitialTimecodeFrame(This,aFrameTimecode) \ + ( (This)->lpVtbl -> Set32PulldownSequenceInitialTimecodeFrame(This,aFrameTimecode) ) + +#define IDeckLinkConfiguration_v7_6_Get32PulldownSequenceInitialTimecodeFrame(This,aFrameTimecode) \ + ( (This)->lpVtbl -> Get32PulldownSequenceInitialTimecodeFrame(This,aFrameTimecode) ) + +#define IDeckLinkConfiguration_v7_6_SetVancSourceLineMapping(This,activeLine1VANCsource,activeLine2VANCsource,activeLine3VANCsource) \ + ( (This)->lpVtbl -> SetVancSourceLineMapping(This,activeLine1VANCsource,activeLine2VANCsource,activeLine3VANCsource) ) + +#define IDeckLinkConfiguration_v7_6_GetVancSourceLineMapping(This,activeLine1VANCsource,activeLine2VANCsource,activeLine3VANCsource) \ + ( (This)->lpVtbl -> GetVancSourceLineMapping(This,activeLine1VANCsource,activeLine2VANCsource,activeLine3VANCsource) ) + +#define IDeckLinkConfiguration_v7_6_SetAudioInputFormat(This,audioInputFormat) \ + ( (This)->lpVtbl -> SetAudioInputFormat(This,audioInputFormat) ) + +#define IDeckLinkConfiguration_v7_6_GetAudioInputFormat(This,audioInputFormat) \ + ( (This)->lpVtbl -> GetAudioInputFormat(This,audioInputFormat) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkConfiguration_v7_6_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkVideoOutputCallback_v7_6_INTERFACE_DEFINED__ +#define __IDeckLinkVideoOutputCallback_v7_6_INTERFACE_DEFINED__ + +/* interface IDeckLinkVideoOutputCallback_v7_6 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkVideoOutputCallback_v7_6; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("E763A626-4A3C-49D1-BF13-E7AD3692AE52") + IDeckLinkVideoOutputCallback_v7_6 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE ScheduledFrameCompleted( + /* [in] */ IDeckLinkVideoFrame_v7_6 *completedFrame, + /* [in] */ BMDOutputFrameCompletionResult result) = 0; + + virtual HRESULT STDMETHODCALLTYPE ScheduledPlaybackHasStopped( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkVideoOutputCallback_v7_6Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoOutputCallback_v7_6 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoOutputCallback_v7_6 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoOutputCallback_v7_6 * This); + + HRESULT ( STDMETHODCALLTYPE *ScheduledFrameCompleted )( + IDeckLinkVideoOutputCallback_v7_6 * This, + /* [in] */ IDeckLinkVideoFrame_v7_6 *completedFrame, + /* [in] */ BMDOutputFrameCompletionResult result); + + HRESULT ( STDMETHODCALLTYPE *ScheduledPlaybackHasStopped )( + IDeckLinkVideoOutputCallback_v7_6 * This); + + END_INTERFACE + } IDeckLinkVideoOutputCallback_v7_6Vtbl; + + interface IDeckLinkVideoOutputCallback_v7_6 + { + CONST_VTBL struct IDeckLinkVideoOutputCallback_v7_6Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkVideoOutputCallback_v7_6_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkVideoOutputCallback_v7_6_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkVideoOutputCallback_v7_6_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkVideoOutputCallback_v7_6_ScheduledFrameCompleted(This,completedFrame,result) \ + ( (This)->lpVtbl -> ScheduledFrameCompleted(This,completedFrame,result) ) + +#define IDeckLinkVideoOutputCallback_v7_6_ScheduledPlaybackHasStopped(This) \ + ( (This)->lpVtbl -> ScheduledPlaybackHasStopped(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkVideoOutputCallback_v7_6_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkInputCallback_v7_6_INTERFACE_DEFINED__ +#define __IDeckLinkInputCallback_v7_6_INTERFACE_DEFINED__ + +/* interface IDeckLinkInputCallback_v7_6 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkInputCallback_v7_6; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("31D28EE7-88B6-4CB1-897A-CDBF79A26414") + IDeckLinkInputCallback_v7_6 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE VideoInputFormatChanged( + /* [in] */ BMDVideoInputFormatChangedEvents notificationEvents, + /* [in] */ IDeckLinkDisplayMode_v7_6 *newDisplayMode, + /* [in] */ BMDDetectedVideoInputFormatFlags detectedSignalFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE VideoInputFrameArrived( + /* [in] */ IDeckLinkVideoInputFrame_v7_6 *videoFrame, + /* [in] */ IDeckLinkAudioInputPacket *audioPacket) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkInputCallback_v7_6Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkInputCallback_v7_6 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkInputCallback_v7_6 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkInputCallback_v7_6 * This); + + HRESULT ( STDMETHODCALLTYPE *VideoInputFormatChanged )( + IDeckLinkInputCallback_v7_6 * This, + /* [in] */ BMDVideoInputFormatChangedEvents notificationEvents, + /* [in] */ IDeckLinkDisplayMode_v7_6 *newDisplayMode, + /* [in] */ BMDDetectedVideoInputFormatFlags detectedSignalFlags); + + HRESULT ( STDMETHODCALLTYPE *VideoInputFrameArrived )( + IDeckLinkInputCallback_v7_6 * This, + /* [in] */ IDeckLinkVideoInputFrame_v7_6 *videoFrame, + /* [in] */ IDeckLinkAudioInputPacket *audioPacket); + + END_INTERFACE + } IDeckLinkInputCallback_v7_6Vtbl; + + interface IDeckLinkInputCallback_v7_6 + { + CONST_VTBL struct IDeckLinkInputCallback_v7_6Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkInputCallback_v7_6_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkInputCallback_v7_6_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkInputCallback_v7_6_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkInputCallback_v7_6_VideoInputFormatChanged(This,notificationEvents,newDisplayMode,detectedSignalFlags) \ + ( (This)->lpVtbl -> VideoInputFormatChanged(This,notificationEvents,newDisplayMode,detectedSignalFlags) ) + +#define IDeckLinkInputCallback_v7_6_VideoInputFrameArrived(This,videoFrame,audioPacket) \ + ( (This)->lpVtbl -> VideoInputFrameArrived(This,videoFrame,audioPacket) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkInputCallback_v7_6_INTERFACE_DEFINED__ */ + + +EXTERN_C const CLSID CLSID_CDeckLinkGLScreenPreviewHelper_v7_6; + +#ifdef __cplusplus + +class DECLSPEC_UUID("D398CEE7-4434-4CA3-9BA6-5AE34556B905") +CDeckLinkGLScreenPreviewHelper_v7_6; +#endif + +EXTERN_C const CLSID CLSID_CDeckLinkVideoConversion_v7_6; + +#ifdef __cplusplus + +class DECLSPEC_UUID("FFA84F77-73BE-4FB7-B03E-B5E44B9F759B") +CDeckLinkVideoConversion_v7_6; +#endif + +#ifndef __IDeckLinkInputCallback_v7_3_INTERFACE_DEFINED__ +#define __IDeckLinkInputCallback_v7_3_INTERFACE_DEFINED__ + +/* interface IDeckLinkInputCallback_v7_3 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkInputCallback_v7_3; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("FD6F311D-4D00-444B-9ED4-1F25B5730AD0") + IDeckLinkInputCallback_v7_3 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE VideoInputFormatChanged( + /* [in] */ BMDVideoInputFormatChangedEvents notificationEvents, + /* [in] */ IDeckLinkDisplayMode_v7_6 *newDisplayMode, + /* [in] */ BMDDetectedVideoInputFormatFlags detectedSignalFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE VideoInputFrameArrived( + /* [in] */ IDeckLinkVideoInputFrame_v7_3 *videoFrame, + /* [in] */ IDeckLinkAudioInputPacket *audioPacket) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkInputCallback_v7_3Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkInputCallback_v7_3 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkInputCallback_v7_3 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkInputCallback_v7_3 * This); + + HRESULT ( STDMETHODCALLTYPE *VideoInputFormatChanged )( + IDeckLinkInputCallback_v7_3 * This, + /* [in] */ BMDVideoInputFormatChangedEvents notificationEvents, + /* [in] */ IDeckLinkDisplayMode_v7_6 *newDisplayMode, + /* [in] */ BMDDetectedVideoInputFormatFlags detectedSignalFlags); + + HRESULT ( STDMETHODCALLTYPE *VideoInputFrameArrived )( + IDeckLinkInputCallback_v7_3 * This, + /* [in] */ IDeckLinkVideoInputFrame_v7_3 *videoFrame, + /* [in] */ IDeckLinkAudioInputPacket *audioPacket); + + END_INTERFACE + } IDeckLinkInputCallback_v7_3Vtbl; + + interface IDeckLinkInputCallback_v7_3 + { + CONST_VTBL struct IDeckLinkInputCallback_v7_3Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkInputCallback_v7_3_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkInputCallback_v7_3_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkInputCallback_v7_3_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkInputCallback_v7_3_VideoInputFormatChanged(This,notificationEvents,newDisplayMode,detectedSignalFlags) \ + ( (This)->lpVtbl -> VideoInputFormatChanged(This,notificationEvents,newDisplayMode,detectedSignalFlags) ) + +#define IDeckLinkInputCallback_v7_3_VideoInputFrameArrived(This,videoFrame,audioPacket) \ + ( (This)->lpVtbl -> VideoInputFrameArrived(This,videoFrame,audioPacket) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkInputCallback_v7_3_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkOutput_v7_3_INTERFACE_DEFINED__ +#define __IDeckLinkOutput_v7_3_INTERFACE_DEFINED__ + +/* interface IDeckLinkOutput_v7_3 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkOutput_v7_3; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("271C65E3-C323-4344-A30F-D908BCB20AA3") + IDeckLinkOutput_v7_3 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE DoesSupportVideoMode( + BMDDisplayMode displayMode, + BMDPixelFormat pixelFormat, + /* [out] */ BMDDisplayModeSupport *result) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayModeIterator( + /* [out] */ IDeckLinkDisplayModeIterator_v7_6 **iterator) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetScreenPreviewCallback( + /* [in] */ IDeckLinkScreenPreviewCallback *previewCallback) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableVideoOutput( + BMDDisplayMode displayMode, + BMDVideoOutputFlags flags) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisableVideoOutput( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetVideoOutputFrameMemoryAllocator( + /* [in] */ IDeckLinkMemoryAllocator *theAllocator) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateVideoFrame( + int width, + int height, + int rowBytes, + BMDPixelFormat pixelFormat, + BMDFrameFlags flags, + /* [out] */ IDeckLinkMutableVideoFrame_v7_6 **outFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateAncillaryData( + BMDPixelFormat pixelFormat, + /* [out] */ IDeckLinkVideoFrameAncillary **outBuffer) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisplayVideoFrameSync( + /* [in] */ IDeckLinkVideoFrame_v7_6 *theFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE ScheduleVideoFrame( + /* [in] */ IDeckLinkVideoFrame_v7_6 *theFrame, + BMDTimeValue displayTime, + BMDTimeValue displayDuration, + BMDTimeScale timeScale) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetScheduledFrameCompletionCallback( + /* [in] */ IDeckLinkVideoOutputCallback *theCallback) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBufferedVideoFrameCount( + /* [out] */ unsigned int *bufferedFrameCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableAudioOutput( + BMDAudioSampleRate sampleRate, + BMDAudioSampleType sampleType, + unsigned int channelCount, + BMDAudioOutputStreamType streamType) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisableAudioOutput( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE WriteAudioSamplesSync( + /* [in] */ void *buffer, + unsigned int sampleFrameCount, + /* [out] */ unsigned int *sampleFramesWritten) = 0; + + virtual HRESULT STDMETHODCALLTYPE BeginAudioPreroll( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE EndAudioPreroll( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE ScheduleAudioSamples( + /* [in] */ void *buffer, + unsigned int sampleFrameCount, + BMDTimeValue streamTime, + BMDTimeScale timeScale, + /* [out] */ unsigned int *sampleFramesWritten) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBufferedAudioSampleFrameCount( + /* [out] */ unsigned int *bufferedSampleFrameCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE FlushBufferedAudioSamples( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetAudioCallback( + /* [in] */ IDeckLinkAudioOutputCallback *theCallback) = 0; + + virtual HRESULT STDMETHODCALLTYPE StartScheduledPlayback( + BMDTimeValue playbackStartTime, + BMDTimeScale timeScale, + double playbackSpeed) = 0; + + virtual HRESULT STDMETHODCALLTYPE StopScheduledPlayback( + BMDTimeValue stopPlaybackAtTime, + /* [out] */ BMDTimeValue *actualStopTime, + BMDTimeScale timeScale) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsScheduledPlaybackRunning( + /* [out] */ BOOL *active) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetHardwareReferenceClock( + BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *elapsedTimeSinceSchedulerBegan) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkOutput_v7_3Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkOutput_v7_3 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkOutput_v7_3 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkOutput_v7_3 * This); + + HRESULT ( STDMETHODCALLTYPE *DoesSupportVideoMode )( + IDeckLinkOutput_v7_3 * This, + BMDDisplayMode displayMode, + BMDPixelFormat pixelFormat, + /* [out] */ BMDDisplayModeSupport *result); + + HRESULT ( STDMETHODCALLTYPE *GetDisplayModeIterator )( + IDeckLinkOutput_v7_3 * This, + /* [out] */ IDeckLinkDisplayModeIterator_v7_6 **iterator); + + HRESULT ( STDMETHODCALLTYPE *SetScreenPreviewCallback )( + IDeckLinkOutput_v7_3 * This, + /* [in] */ IDeckLinkScreenPreviewCallback *previewCallback); + + HRESULT ( STDMETHODCALLTYPE *EnableVideoOutput )( + IDeckLinkOutput_v7_3 * This, + BMDDisplayMode displayMode, + BMDVideoOutputFlags flags); + + HRESULT ( STDMETHODCALLTYPE *DisableVideoOutput )( + IDeckLinkOutput_v7_3 * This); + + HRESULT ( STDMETHODCALLTYPE *SetVideoOutputFrameMemoryAllocator )( + IDeckLinkOutput_v7_3 * This, + /* [in] */ IDeckLinkMemoryAllocator *theAllocator); + + HRESULT ( STDMETHODCALLTYPE *CreateVideoFrame )( + IDeckLinkOutput_v7_3 * This, + int width, + int height, + int rowBytes, + BMDPixelFormat pixelFormat, + BMDFrameFlags flags, + /* [out] */ IDeckLinkMutableVideoFrame_v7_6 **outFrame); + + HRESULT ( STDMETHODCALLTYPE *CreateAncillaryData )( + IDeckLinkOutput_v7_3 * This, + BMDPixelFormat pixelFormat, + /* [out] */ IDeckLinkVideoFrameAncillary **outBuffer); + + HRESULT ( STDMETHODCALLTYPE *DisplayVideoFrameSync )( + IDeckLinkOutput_v7_3 * This, + /* [in] */ IDeckLinkVideoFrame_v7_6 *theFrame); + + HRESULT ( STDMETHODCALLTYPE *ScheduleVideoFrame )( + IDeckLinkOutput_v7_3 * This, + /* [in] */ IDeckLinkVideoFrame_v7_6 *theFrame, + BMDTimeValue displayTime, + BMDTimeValue displayDuration, + BMDTimeScale timeScale); + + HRESULT ( STDMETHODCALLTYPE *SetScheduledFrameCompletionCallback )( + IDeckLinkOutput_v7_3 * This, + /* [in] */ IDeckLinkVideoOutputCallback *theCallback); + + HRESULT ( STDMETHODCALLTYPE *GetBufferedVideoFrameCount )( + IDeckLinkOutput_v7_3 * This, + /* [out] */ unsigned int *bufferedFrameCount); + + HRESULT ( STDMETHODCALLTYPE *EnableAudioOutput )( + IDeckLinkOutput_v7_3 * This, + BMDAudioSampleRate sampleRate, + BMDAudioSampleType sampleType, + unsigned int channelCount, + BMDAudioOutputStreamType streamType); + + HRESULT ( STDMETHODCALLTYPE *DisableAudioOutput )( + IDeckLinkOutput_v7_3 * This); + + HRESULT ( STDMETHODCALLTYPE *WriteAudioSamplesSync )( + IDeckLinkOutput_v7_3 * This, + /* [in] */ void *buffer, + unsigned int sampleFrameCount, + /* [out] */ unsigned int *sampleFramesWritten); + + HRESULT ( STDMETHODCALLTYPE *BeginAudioPreroll )( + IDeckLinkOutput_v7_3 * This); + + HRESULT ( STDMETHODCALLTYPE *EndAudioPreroll )( + IDeckLinkOutput_v7_3 * This); + + HRESULT ( STDMETHODCALLTYPE *ScheduleAudioSamples )( + IDeckLinkOutput_v7_3 * This, + /* [in] */ void *buffer, + unsigned int sampleFrameCount, + BMDTimeValue streamTime, + BMDTimeScale timeScale, + /* [out] */ unsigned int *sampleFramesWritten); + + HRESULT ( STDMETHODCALLTYPE *GetBufferedAudioSampleFrameCount )( + IDeckLinkOutput_v7_3 * This, + /* [out] */ unsigned int *bufferedSampleFrameCount); + + HRESULT ( STDMETHODCALLTYPE *FlushBufferedAudioSamples )( + IDeckLinkOutput_v7_3 * This); + + HRESULT ( STDMETHODCALLTYPE *SetAudioCallback )( + IDeckLinkOutput_v7_3 * This, + /* [in] */ IDeckLinkAudioOutputCallback *theCallback); + + HRESULT ( STDMETHODCALLTYPE *StartScheduledPlayback )( + IDeckLinkOutput_v7_3 * This, + BMDTimeValue playbackStartTime, + BMDTimeScale timeScale, + double playbackSpeed); + + HRESULT ( STDMETHODCALLTYPE *StopScheduledPlayback )( + IDeckLinkOutput_v7_3 * This, + BMDTimeValue stopPlaybackAtTime, + /* [out] */ BMDTimeValue *actualStopTime, + BMDTimeScale timeScale); + + HRESULT ( STDMETHODCALLTYPE *IsScheduledPlaybackRunning )( + IDeckLinkOutput_v7_3 * This, + /* [out] */ BOOL *active); + + HRESULT ( STDMETHODCALLTYPE *GetHardwareReferenceClock )( + IDeckLinkOutput_v7_3 * This, + BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *elapsedTimeSinceSchedulerBegan); + + END_INTERFACE + } IDeckLinkOutput_v7_3Vtbl; + + interface IDeckLinkOutput_v7_3 + { + CONST_VTBL struct IDeckLinkOutput_v7_3Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkOutput_v7_3_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkOutput_v7_3_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkOutput_v7_3_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkOutput_v7_3_DoesSupportVideoMode(This,displayMode,pixelFormat,result) \ + ( (This)->lpVtbl -> DoesSupportVideoMode(This,displayMode,pixelFormat,result) ) + +#define IDeckLinkOutput_v7_3_GetDisplayModeIterator(This,iterator) \ + ( (This)->lpVtbl -> GetDisplayModeIterator(This,iterator) ) + +#define IDeckLinkOutput_v7_3_SetScreenPreviewCallback(This,previewCallback) \ + ( (This)->lpVtbl -> SetScreenPreviewCallback(This,previewCallback) ) + +#define IDeckLinkOutput_v7_3_EnableVideoOutput(This,displayMode,flags) \ + ( (This)->lpVtbl -> EnableVideoOutput(This,displayMode,flags) ) + +#define IDeckLinkOutput_v7_3_DisableVideoOutput(This) \ + ( (This)->lpVtbl -> DisableVideoOutput(This) ) + +#define IDeckLinkOutput_v7_3_SetVideoOutputFrameMemoryAllocator(This,theAllocator) \ + ( (This)->lpVtbl -> SetVideoOutputFrameMemoryAllocator(This,theAllocator) ) + +#define IDeckLinkOutput_v7_3_CreateVideoFrame(This,width,height,rowBytes,pixelFormat,flags,outFrame) \ + ( (This)->lpVtbl -> CreateVideoFrame(This,width,height,rowBytes,pixelFormat,flags,outFrame) ) + +#define IDeckLinkOutput_v7_3_CreateAncillaryData(This,pixelFormat,outBuffer) \ + ( (This)->lpVtbl -> CreateAncillaryData(This,pixelFormat,outBuffer) ) + +#define IDeckLinkOutput_v7_3_DisplayVideoFrameSync(This,theFrame) \ + ( (This)->lpVtbl -> DisplayVideoFrameSync(This,theFrame) ) + +#define IDeckLinkOutput_v7_3_ScheduleVideoFrame(This,theFrame,displayTime,displayDuration,timeScale) \ + ( (This)->lpVtbl -> ScheduleVideoFrame(This,theFrame,displayTime,displayDuration,timeScale) ) + +#define IDeckLinkOutput_v7_3_SetScheduledFrameCompletionCallback(This,theCallback) \ + ( (This)->lpVtbl -> SetScheduledFrameCompletionCallback(This,theCallback) ) + +#define IDeckLinkOutput_v7_3_GetBufferedVideoFrameCount(This,bufferedFrameCount) \ + ( (This)->lpVtbl -> GetBufferedVideoFrameCount(This,bufferedFrameCount) ) + +#define IDeckLinkOutput_v7_3_EnableAudioOutput(This,sampleRate,sampleType,channelCount,streamType) \ + ( (This)->lpVtbl -> EnableAudioOutput(This,sampleRate,sampleType,channelCount,streamType) ) + +#define IDeckLinkOutput_v7_3_DisableAudioOutput(This) \ + ( (This)->lpVtbl -> DisableAudioOutput(This) ) + +#define IDeckLinkOutput_v7_3_WriteAudioSamplesSync(This,buffer,sampleFrameCount,sampleFramesWritten) \ + ( (This)->lpVtbl -> WriteAudioSamplesSync(This,buffer,sampleFrameCount,sampleFramesWritten) ) + +#define IDeckLinkOutput_v7_3_BeginAudioPreroll(This) \ + ( (This)->lpVtbl -> BeginAudioPreroll(This) ) + +#define IDeckLinkOutput_v7_3_EndAudioPreroll(This) \ + ( (This)->lpVtbl -> EndAudioPreroll(This) ) + +#define IDeckLinkOutput_v7_3_ScheduleAudioSamples(This,buffer,sampleFrameCount,streamTime,timeScale,sampleFramesWritten) \ + ( (This)->lpVtbl -> ScheduleAudioSamples(This,buffer,sampleFrameCount,streamTime,timeScale,sampleFramesWritten) ) + +#define IDeckLinkOutput_v7_3_GetBufferedAudioSampleFrameCount(This,bufferedSampleFrameCount) \ + ( (This)->lpVtbl -> GetBufferedAudioSampleFrameCount(This,bufferedSampleFrameCount) ) + +#define IDeckLinkOutput_v7_3_FlushBufferedAudioSamples(This) \ + ( (This)->lpVtbl -> FlushBufferedAudioSamples(This) ) + +#define IDeckLinkOutput_v7_3_SetAudioCallback(This,theCallback) \ + ( (This)->lpVtbl -> SetAudioCallback(This,theCallback) ) + +#define IDeckLinkOutput_v7_3_StartScheduledPlayback(This,playbackStartTime,timeScale,playbackSpeed) \ + ( (This)->lpVtbl -> StartScheduledPlayback(This,playbackStartTime,timeScale,playbackSpeed) ) + +#define IDeckLinkOutput_v7_3_StopScheduledPlayback(This,stopPlaybackAtTime,actualStopTime,timeScale) \ + ( (This)->lpVtbl -> StopScheduledPlayback(This,stopPlaybackAtTime,actualStopTime,timeScale) ) + +#define IDeckLinkOutput_v7_3_IsScheduledPlaybackRunning(This,active) \ + ( (This)->lpVtbl -> IsScheduledPlaybackRunning(This,active) ) + +#define IDeckLinkOutput_v7_3_GetHardwareReferenceClock(This,desiredTimeScale,elapsedTimeSinceSchedulerBegan) \ + ( (This)->lpVtbl -> GetHardwareReferenceClock(This,desiredTimeScale,elapsedTimeSinceSchedulerBegan) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkOutput_v7_3_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkInput_v7_3_INTERFACE_DEFINED__ +#define __IDeckLinkInput_v7_3_INTERFACE_DEFINED__ + +/* interface IDeckLinkInput_v7_3 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkInput_v7_3; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("4973F012-9925-458C-871C-18774CDBBECB") + IDeckLinkInput_v7_3 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE DoesSupportVideoMode( + BMDDisplayMode displayMode, + BMDPixelFormat pixelFormat, + /* [out] */ BMDDisplayModeSupport *result) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayModeIterator( + /* [out] */ IDeckLinkDisplayModeIterator_v7_6 **iterator) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetScreenPreviewCallback( + /* [in] */ IDeckLinkScreenPreviewCallback *previewCallback) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableVideoInput( + BMDDisplayMode displayMode, + BMDPixelFormat pixelFormat, + BMDVideoInputFlags flags) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisableVideoInput( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAvailableVideoFrameCount( + /* [out] */ unsigned int *availableFrameCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableAudioInput( + BMDAudioSampleRate sampleRate, + BMDAudioSampleType sampleType, + unsigned int channelCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisableAudioInput( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAvailableAudioSampleFrameCount( + /* [out] */ unsigned int *availableSampleFrameCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE StartStreams( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE StopStreams( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE PauseStreams( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE FlushStreams( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetCallback( + /* [in] */ IDeckLinkInputCallback_v7_3 *theCallback) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkInput_v7_3Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkInput_v7_3 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkInput_v7_3 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkInput_v7_3 * This); + + HRESULT ( STDMETHODCALLTYPE *DoesSupportVideoMode )( + IDeckLinkInput_v7_3 * This, + BMDDisplayMode displayMode, + BMDPixelFormat pixelFormat, + /* [out] */ BMDDisplayModeSupport *result); + + HRESULT ( STDMETHODCALLTYPE *GetDisplayModeIterator )( + IDeckLinkInput_v7_3 * This, + /* [out] */ IDeckLinkDisplayModeIterator_v7_6 **iterator); + + HRESULT ( STDMETHODCALLTYPE *SetScreenPreviewCallback )( + IDeckLinkInput_v7_3 * This, + /* [in] */ IDeckLinkScreenPreviewCallback *previewCallback); + + HRESULT ( STDMETHODCALLTYPE *EnableVideoInput )( + IDeckLinkInput_v7_3 * This, + BMDDisplayMode displayMode, + BMDPixelFormat pixelFormat, + BMDVideoInputFlags flags); + + HRESULT ( STDMETHODCALLTYPE *DisableVideoInput )( + IDeckLinkInput_v7_3 * This); + + HRESULT ( STDMETHODCALLTYPE *GetAvailableVideoFrameCount )( + IDeckLinkInput_v7_3 * This, + /* [out] */ unsigned int *availableFrameCount); + + HRESULT ( STDMETHODCALLTYPE *EnableAudioInput )( + IDeckLinkInput_v7_3 * This, + BMDAudioSampleRate sampleRate, + BMDAudioSampleType sampleType, + unsigned int channelCount); + + HRESULT ( STDMETHODCALLTYPE *DisableAudioInput )( + IDeckLinkInput_v7_3 * This); + + HRESULT ( STDMETHODCALLTYPE *GetAvailableAudioSampleFrameCount )( + IDeckLinkInput_v7_3 * This, + /* [out] */ unsigned int *availableSampleFrameCount); + + HRESULT ( STDMETHODCALLTYPE *StartStreams )( + IDeckLinkInput_v7_3 * This); + + HRESULT ( STDMETHODCALLTYPE *StopStreams )( + IDeckLinkInput_v7_3 * This); + + HRESULT ( STDMETHODCALLTYPE *PauseStreams )( + IDeckLinkInput_v7_3 * This); + + HRESULT ( STDMETHODCALLTYPE *FlushStreams )( + IDeckLinkInput_v7_3 * This); + + HRESULT ( STDMETHODCALLTYPE *SetCallback )( + IDeckLinkInput_v7_3 * This, + /* [in] */ IDeckLinkInputCallback_v7_3 *theCallback); + + END_INTERFACE + } IDeckLinkInput_v7_3Vtbl; + + interface IDeckLinkInput_v7_3 + { + CONST_VTBL struct IDeckLinkInput_v7_3Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkInput_v7_3_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkInput_v7_3_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkInput_v7_3_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkInput_v7_3_DoesSupportVideoMode(This,displayMode,pixelFormat,result) \ + ( (This)->lpVtbl -> DoesSupportVideoMode(This,displayMode,pixelFormat,result) ) + +#define IDeckLinkInput_v7_3_GetDisplayModeIterator(This,iterator) \ + ( (This)->lpVtbl -> GetDisplayModeIterator(This,iterator) ) + +#define IDeckLinkInput_v7_3_SetScreenPreviewCallback(This,previewCallback) \ + ( (This)->lpVtbl -> SetScreenPreviewCallback(This,previewCallback) ) + +#define IDeckLinkInput_v7_3_EnableVideoInput(This,displayMode,pixelFormat,flags) \ + ( (This)->lpVtbl -> EnableVideoInput(This,displayMode,pixelFormat,flags) ) + +#define IDeckLinkInput_v7_3_DisableVideoInput(This) \ + ( (This)->lpVtbl -> DisableVideoInput(This) ) + +#define IDeckLinkInput_v7_3_GetAvailableVideoFrameCount(This,availableFrameCount) \ + ( (This)->lpVtbl -> GetAvailableVideoFrameCount(This,availableFrameCount) ) + +#define IDeckLinkInput_v7_3_EnableAudioInput(This,sampleRate,sampleType,channelCount) \ + ( (This)->lpVtbl -> EnableAudioInput(This,sampleRate,sampleType,channelCount) ) + +#define IDeckLinkInput_v7_3_DisableAudioInput(This) \ + ( (This)->lpVtbl -> DisableAudioInput(This) ) + +#define IDeckLinkInput_v7_3_GetAvailableAudioSampleFrameCount(This,availableSampleFrameCount) \ + ( (This)->lpVtbl -> GetAvailableAudioSampleFrameCount(This,availableSampleFrameCount) ) + +#define IDeckLinkInput_v7_3_StartStreams(This) \ + ( (This)->lpVtbl -> StartStreams(This) ) + +#define IDeckLinkInput_v7_3_StopStreams(This) \ + ( (This)->lpVtbl -> StopStreams(This) ) + +#define IDeckLinkInput_v7_3_PauseStreams(This) \ + ( (This)->lpVtbl -> PauseStreams(This) ) + +#define IDeckLinkInput_v7_3_FlushStreams(This) \ + ( (This)->lpVtbl -> FlushStreams(This) ) + +#define IDeckLinkInput_v7_3_SetCallback(This,theCallback) \ + ( (This)->lpVtbl -> SetCallback(This,theCallback) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkInput_v7_3_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkVideoInputFrame_v7_3_INTERFACE_DEFINED__ +#define __IDeckLinkVideoInputFrame_v7_3_INTERFACE_DEFINED__ + +/* interface IDeckLinkVideoInputFrame_v7_3 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkVideoInputFrame_v7_3; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("CF317790-2894-11DE-8C30-0800200C9A66") + IDeckLinkVideoInputFrame_v7_3 : public IDeckLinkVideoFrame_v7_6 + { + public: + virtual HRESULT STDMETHODCALLTYPE GetStreamTime( + /* [out] */ BMDTimeValue *frameTime, + /* [out] */ BMDTimeValue *frameDuration, + BMDTimeScale timeScale) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkVideoInputFrame_v7_3Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoInputFrame_v7_3 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoInputFrame_v7_3 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoInputFrame_v7_3 * This); + + long ( STDMETHODCALLTYPE *GetWidth )( + IDeckLinkVideoInputFrame_v7_3 * This); + + long ( STDMETHODCALLTYPE *GetHeight )( + IDeckLinkVideoInputFrame_v7_3 * This); + + long ( STDMETHODCALLTYPE *GetRowBytes )( + IDeckLinkVideoInputFrame_v7_3 * This); + + BMDPixelFormat ( STDMETHODCALLTYPE *GetPixelFormat )( + IDeckLinkVideoInputFrame_v7_3 * This); + + BMDFrameFlags ( STDMETHODCALLTYPE *GetFlags )( + IDeckLinkVideoInputFrame_v7_3 * This); + + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IDeckLinkVideoInputFrame_v7_3 * This, + /* [out] */ void **buffer); + + HRESULT ( STDMETHODCALLTYPE *GetTimecode )( + IDeckLinkVideoInputFrame_v7_3 * This, + BMDTimecodeFormat format, + /* [out] */ IDeckLinkTimecode_v7_6 **timecode); + + HRESULT ( STDMETHODCALLTYPE *GetAncillaryData )( + IDeckLinkVideoInputFrame_v7_3 * This, + /* [out] */ IDeckLinkVideoFrameAncillary **ancillary); + + HRESULT ( STDMETHODCALLTYPE *GetStreamTime )( + IDeckLinkVideoInputFrame_v7_3 * This, + /* [out] */ BMDTimeValue *frameTime, + /* [out] */ BMDTimeValue *frameDuration, + BMDTimeScale timeScale); + + END_INTERFACE + } IDeckLinkVideoInputFrame_v7_3Vtbl; + + interface IDeckLinkVideoInputFrame_v7_3 + { + CONST_VTBL struct IDeckLinkVideoInputFrame_v7_3Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkVideoInputFrame_v7_3_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkVideoInputFrame_v7_3_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkVideoInputFrame_v7_3_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkVideoInputFrame_v7_3_GetWidth(This) \ + ( (This)->lpVtbl -> GetWidth(This) ) + +#define IDeckLinkVideoInputFrame_v7_3_GetHeight(This) \ + ( (This)->lpVtbl -> GetHeight(This) ) + +#define IDeckLinkVideoInputFrame_v7_3_GetRowBytes(This) \ + ( (This)->lpVtbl -> GetRowBytes(This) ) + +#define IDeckLinkVideoInputFrame_v7_3_GetPixelFormat(This) \ + ( (This)->lpVtbl -> GetPixelFormat(This) ) + +#define IDeckLinkVideoInputFrame_v7_3_GetFlags(This) \ + ( (This)->lpVtbl -> GetFlags(This) ) + +#define IDeckLinkVideoInputFrame_v7_3_GetBytes(This,buffer) \ + ( (This)->lpVtbl -> GetBytes(This,buffer) ) + +#define IDeckLinkVideoInputFrame_v7_3_GetTimecode(This,format,timecode) \ + ( (This)->lpVtbl -> GetTimecode(This,format,timecode) ) + +#define IDeckLinkVideoInputFrame_v7_3_GetAncillaryData(This,ancillary) \ + ( (This)->lpVtbl -> GetAncillaryData(This,ancillary) ) + + +#define IDeckLinkVideoInputFrame_v7_3_GetStreamTime(This,frameTime,frameDuration,timeScale) \ + ( (This)->lpVtbl -> GetStreamTime(This,frameTime,frameDuration,timeScale) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkVideoInputFrame_v7_3_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkDisplayModeIterator_v7_1_INTERFACE_DEFINED__ +#define __IDeckLinkDisplayModeIterator_v7_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkDisplayModeIterator_v7_1 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkDisplayModeIterator_v7_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("B28131B6-59AC-4857-B5AC-CD75D5883E2F") + IDeckLinkDisplayModeIterator_v7_1 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Next( + /* [out] */ IDeckLinkDisplayMode_v7_1 **deckLinkDisplayMode) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkDisplayModeIterator_v7_1Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkDisplayModeIterator_v7_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkDisplayModeIterator_v7_1 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkDisplayModeIterator_v7_1 * This); + + HRESULT ( STDMETHODCALLTYPE *Next )( + IDeckLinkDisplayModeIterator_v7_1 * This, + /* [out] */ IDeckLinkDisplayMode_v7_1 **deckLinkDisplayMode); + + END_INTERFACE + } IDeckLinkDisplayModeIterator_v7_1Vtbl; + + interface IDeckLinkDisplayModeIterator_v7_1 + { + CONST_VTBL struct IDeckLinkDisplayModeIterator_v7_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkDisplayModeIterator_v7_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkDisplayModeIterator_v7_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkDisplayModeIterator_v7_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkDisplayModeIterator_v7_1_Next(This,deckLinkDisplayMode) \ + ( (This)->lpVtbl -> Next(This,deckLinkDisplayMode) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkDisplayModeIterator_v7_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkDisplayMode_v7_1_INTERFACE_DEFINED__ +#define __IDeckLinkDisplayMode_v7_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkDisplayMode_v7_1 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkDisplayMode_v7_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("AF0CD6D5-8376-435E-8433-54F9DD530AC3") + IDeckLinkDisplayMode_v7_1 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetName( + /* [out] */ BSTR *name) = 0; + + virtual BMDDisplayMode STDMETHODCALLTYPE GetDisplayMode( void) = 0; + + virtual long STDMETHODCALLTYPE GetWidth( void) = 0; + + virtual long STDMETHODCALLTYPE GetHeight( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFrameRate( + /* [out] */ BMDTimeValue *frameDuration, + /* [out] */ BMDTimeScale *timeScale) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkDisplayMode_v7_1Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkDisplayMode_v7_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkDisplayMode_v7_1 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkDisplayMode_v7_1 * This); + + HRESULT ( STDMETHODCALLTYPE *GetName )( + IDeckLinkDisplayMode_v7_1 * This, + /* [out] */ BSTR *name); + + BMDDisplayMode ( STDMETHODCALLTYPE *GetDisplayMode )( + IDeckLinkDisplayMode_v7_1 * This); + + long ( STDMETHODCALLTYPE *GetWidth )( + IDeckLinkDisplayMode_v7_1 * This); + + long ( STDMETHODCALLTYPE *GetHeight )( + IDeckLinkDisplayMode_v7_1 * This); + + HRESULT ( STDMETHODCALLTYPE *GetFrameRate )( + IDeckLinkDisplayMode_v7_1 * This, + /* [out] */ BMDTimeValue *frameDuration, + /* [out] */ BMDTimeScale *timeScale); + + END_INTERFACE + } IDeckLinkDisplayMode_v7_1Vtbl; + + interface IDeckLinkDisplayMode_v7_1 + { + CONST_VTBL struct IDeckLinkDisplayMode_v7_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkDisplayMode_v7_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkDisplayMode_v7_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkDisplayMode_v7_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkDisplayMode_v7_1_GetName(This,name) \ + ( (This)->lpVtbl -> GetName(This,name) ) + +#define IDeckLinkDisplayMode_v7_1_GetDisplayMode(This) \ + ( (This)->lpVtbl -> GetDisplayMode(This) ) + +#define IDeckLinkDisplayMode_v7_1_GetWidth(This) \ + ( (This)->lpVtbl -> GetWidth(This) ) + +#define IDeckLinkDisplayMode_v7_1_GetHeight(This) \ + ( (This)->lpVtbl -> GetHeight(This) ) + +#define IDeckLinkDisplayMode_v7_1_GetFrameRate(This,frameDuration,timeScale) \ + ( (This)->lpVtbl -> GetFrameRate(This,frameDuration,timeScale) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkDisplayMode_v7_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkVideoFrame_v7_1_INTERFACE_DEFINED__ +#define __IDeckLinkVideoFrame_v7_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkVideoFrame_v7_1 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkVideoFrame_v7_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("333F3A10-8C2D-43CF-B79D-46560FEEA1CE") + IDeckLinkVideoFrame_v7_1 : public IUnknown + { + public: + virtual long STDMETHODCALLTYPE GetWidth( void) = 0; + + virtual long STDMETHODCALLTYPE GetHeight( void) = 0; + + virtual long STDMETHODCALLTYPE GetRowBytes( void) = 0; + + virtual BMDPixelFormat STDMETHODCALLTYPE GetPixelFormat( void) = 0; + + virtual BMDFrameFlags STDMETHODCALLTYPE GetFlags( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBytes( + void **buffer) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkVideoFrame_v7_1Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoFrame_v7_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoFrame_v7_1 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoFrame_v7_1 * This); + + long ( STDMETHODCALLTYPE *GetWidth )( + IDeckLinkVideoFrame_v7_1 * This); + + long ( STDMETHODCALLTYPE *GetHeight )( + IDeckLinkVideoFrame_v7_1 * This); + + long ( STDMETHODCALLTYPE *GetRowBytes )( + IDeckLinkVideoFrame_v7_1 * This); + + BMDPixelFormat ( STDMETHODCALLTYPE *GetPixelFormat )( + IDeckLinkVideoFrame_v7_1 * This); + + BMDFrameFlags ( STDMETHODCALLTYPE *GetFlags )( + IDeckLinkVideoFrame_v7_1 * This); + + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IDeckLinkVideoFrame_v7_1 * This, + void **buffer); + + END_INTERFACE + } IDeckLinkVideoFrame_v7_1Vtbl; + + interface IDeckLinkVideoFrame_v7_1 + { + CONST_VTBL struct IDeckLinkVideoFrame_v7_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkVideoFrame_v7_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkVideoFrame_v7_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkVideoFrame_v7_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkVideoFrame_v7_1_GetWidth(This) \ + ( (This)->lpVtbl -> GetWidth(This) ) + +#define IDeckLinkVideoFrame_v7_1_GetHeight(This) \ + ( (This)->lpVtbl -> GetHeight(This) ) + +#define IDeckLinkVideoFrame_v7_1_GetRowBytes(This) \ + ( (This)->lpVtbl -> GetRowBytes(This) ) + +#define IDeckLinkVideoFrame_v7_1_GetPixelFormat(This) \ + ( (This)->lpVtbl -> GetPixelFormat(This) ) + +#define IDeckLinkVideoFrame_v7_1_GetFlags(This) \ + ( (This)->lpVtbl -> GetFlags(This) ) + +#define IDeckLinkVideoFrame_v7_1_GetBytes(This,buffer) \ + ( (This)->lpVtbl -> GetBytes(This,buffer) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkVideoFrame_v7_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkVideoInputFrame_v7_1_INTERFACE_DEFINED__ +#define __IDeckLinkVideoInputFrame_v7_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkVideoInputFrame_v7_1 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkVideoInputFrame_v7_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("C8B41D95-8848-40EE-9B37-6E3417FB114B") + IDeckLinkVideoInputFrame_v7_1 : public IDeckLinkVideoFrame_v7_1 + { + public: + virtual HRESULT STDMETHODCALLTYPE GetFrameTime( + BMDTimeValue *frameTime, + BMDTimeValue *frameDuration, + BMDTimeScale timeScale) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkVideoInputFrame_v7_1Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoInputFrame_v7_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoInputFrame_v7_1 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoInputFrame_v7_1 * This); + + long ( STDMETHODCALLTYPE *GetWidth )( + IDeckLinkVideoInputFrame_v7_1 * This); + + long ( STDMETHODCALLTYPE *GetHeight )( + IDeckLinkVideoInputFrame_v7_1 * This); + + long ( STDMETHODCALLTYPE *GetRowBytes )( + IDeckLinkVideoInputFrame_v7_1 * This); + + BMDPixelFormat ( STDMETHODCALLTYPE *GetPixelFormat )( + IDeckLinkVideoInputFrame_v7_1 * This); + + BMDFrameFlags ( STDMETHODCALLTYPE *GetFlags )( + IDeckLinkVideoInputFrame_v7_1 * This); + + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IDeckLinkVideoInputFrame_v7_1 * This, + void **buffer); + + HRESULT ( STDMETHODCALLTYPE *GetFrameTime )( + IDeckLinkVideoInputFrame_v7_1 * This, + BMDTimeValue *frameTime, + BMDTimeValue *frameDuration, + BMDTimeScale timeScale); + + END_INTERFACE + } IDeckLinkVideoInputFrame_v7_1Vtbl; + + interface IDeckLinkVideoInputFrame_v7_1 + { + CONST_VTBL struct IDeckLinkVideoInputFrame_v7_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkVideoInputFrame_v7_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkVideoInputFrame_v7_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkVideoInputFrame_v7_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkVideoInputFrame_v7_1_GetWidth(This) \ + ( (This)->lpVtbl -> GetWidth(This) ) + +#define IDeckLinkVideoInputFrame_v7_1_GetHeight(This) \ + ( (This)->lpVtbl -> GetHeight(This) ) + +#define IDeckLinkVideoInputFrame_v7_1_GetRowBytes(This) \ + ( (This)->lpVtbl -> GetRowBytes(This) ) + +#define IDeckLinkVideoInputFrame_v7_1_GetPixelFormat(This) \ + ( (This)->lpVtbl -> GetPixelFormat(This) ) + +#define IDeckLinkVideoInputFrame_v7_1_GetFlags(This) \ + ( (This)->lpVtbl -> GetFlags(This) ) + +#define IDeckLinkVideoInputFrame_v7_1_GetBytes(This,buffer) \ + ( (This)->lpVtbl -> GetBytes(This,buffer) ) + + +#define IDeckLinkVideoInputFrame_v7_1_GetFrameTime(This,frameTime,frameDuration,timeScale) \ + ( (This)->lpVtbl -> GetFrameTime(This,frameTime,frameDuration,timeScale) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkVideoInputFrame_v7_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkAudioInputPacket_v7_1_INTERFACE_DEFINED__ +#define __IDeckLinkAudioInputPacket_v7_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkAudioInputPacket_v7_1 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkAudioInputPacket_v7_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("C86DE4F6-A29F-42E3-AB3A-1363E29F0788") + IDeckLinkAudioInputPacket_v7_1 : public IUnknown + { + public: + virtual long STDMETHODCALLTYPE GetSampleCount( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBytes( + void **buffer) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAudioPacketTime( + BMDTimeValue *packetTime, + BMDTimeScale timeScale) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkAudioInputPacket_v7_1Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkAudioInputPacket_v7_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkAudioInputPacket_v7_1 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkAudioInputPacket_v7_1 * This); + + long ( STDMETHODCALLTYPE *GetSampleCount )( + IDeckLinkAudioInputPacket_v7_1 * This); + + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IDeckLinkAudioInputPacket_v7_1 * This, + void **buffer); + + HRESULT ( STDMETHODCALLTYPE *GetAudioPacketTime )( + IDeckLinkAudioInputPacket_v7_1 * This, + BMDTimeValue *packetTime, + BMDTimeScale timeScale); + + END_INTERFACE + } IDeckLinkAudioInputPacket_v7_1Vtbl; + + interface IDeckLinkAudioInputPacket_v7_1 + { + CONST_VTBL struct IDeckLinkAudioInputPacket_v7_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkAudioInputPacket_v7_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkAudioInputPacket_v7_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkAudioInputPacket_v7_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkAudioInputPacket_v7_1_GetSampleCount(This) \ + ( (This)->lpVtbl -> GetSampleCount(This) ) + +#define IDeckLinkAudioInputPacket_v7_1_GetBytes(This,buffer) \ + ( (This)->lpVtbl -> GetBytes(This,buffer) ) + +#define IDeckLinkAudioInputPacket_v7_1_GetAudioPacketTime(This,packetTime,timeScale) \ + ( (This)->lpVtbl -> GetAudioPacketTime(This,packetTime,timeScale) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkAudioInputPacket_v7_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkVideoOutputCallback_v7_1_INTERFACE_DEFINED__ +#define __IDeckLinkVideoOutputCallback_v7_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkVideoOutputCallback_v7_1 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkVideoOutputCallback_v7_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("EBD01AFA-E4B0-49C6-A01D-EDB9D1B55FD9") + IDeckLinkVideoOutputCallback_v7_1 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE ScheduledFrameCompleted( + /* [in] */ IDeckLinkVideoFrame_v7_1 *completedFrame, + /* [in] */ BMDOutputFrameCompletionResult result) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkVideoOutputCallback_v7_1Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoOutputCallback_v7_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoOutputCallback_v7_1 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoOutputCallback_v7_1 * This); + + HRESULT ( STDMETHODCALLTYPE *ScheduledFrameCompleted )( + IDeckLinkVideoOutputCallback_v7_1 * This, + /* [in] */ IDeckLinkVideoFrame_v7_1 *completedFrame, + /* [in] */ BMDOutputFrameCompletionResult result); + + END_INTERFACE + } IDeckLinkVideoOutputCallback_v7_1Vtbl; + + interface IDeckLinkVideoOutputCallback_v7_1 + { + CONST_VTBL struct IDeckLinkVideoOutputCallback_v7_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkVideoOutputCallback_v7_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkVideoOutputCallback_v7_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkVideoOutputCallback_v7_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkVideoOutputCallback_v7_1_ScheduledFrameCompleted(This,completedFrame,result) \ + ( (This)->lpVtbl -> ScheduledFrameCompleted(This,completedFrame,result) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkVideoOutputCallback_v7_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkInputCallback_v7_1_INTERFACE_DEFINED__ +#define __IDeckLinkInputCallback_v7_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkInputCallback_v7_1 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkInputCallback_v7_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("7F94F328-5ED4-4E9F-9729-76A86BDC99CC") + IDeckLinkInputCallback_v7_1 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE VideoInputFrameArrived( + /* [in] */ IDeckLinkVideoInputFrame_v7_1 *videoFrame, + /* [in] */ IDeckLinkAudioInputPacket_v7_1 *audioPacket) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkInputCallback_v7_1Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkInputCallback_v7_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkInputCallback_v7_1 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkInputCallback_v7_1 * This); + + HRESULT ( STDMETHODCALLTYPE *VideoInputFrameArrived )( + IDeckLinkInputCallback_v7_1 * This, + /* [in] */ IDeckLinkVideoInputFrame_v7_1 *videoFrame, + /* [in] */ IDeckLinkAudioInputPacket_v7_1 *audioPacket); + + END_INTERFACE + } IDeckLinkInputCallback_v7_1Vtbl; + + interface IDeckLinkInputCallback_v7_1 + { + CONST_VTBL struct IDeckLinkInputCallback_v7_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkInputCallback_v7_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkInputCallback_v7_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkInputCallback_v7_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkInputCallback_v7_1_VideoInputFrameArrived(This,videoFrame,audioPacket) \ + ( (This)->lpVtbl -> VideoInputFrameArrived(This,videoFrame,audioPacket) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkInputCallback_v7_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkOutput_v7_1_INTERFACE_DEFINED__ +#define __IDeckLinkOutput_v7_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkOutput_v7_1 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkOutput_v7_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("AE5B3E9B-4E1E-4535-B6E8-480FF52F6CE5") + IDeckLinkOutput_v7_1 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE DoesSupportVideoMode( + BMDDisplayMode displayMode, + BMDPixelFormat pixelFormat, + /* [out] */ BMDDisplayModeSupport *result) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayModeIterator( + /* [out] */ IDeckLinkDisplayModeIterator_v7_1 **iterator) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableVideoOutput( + BMDDisplayMode displayMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisableVideoOutput( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetVideoOutputFrameMemoryAllocator( + /* [in] */ IDeckLinkMemoryAllocator *theAllocator) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateVideoFrame( + int width, + int height, + int rowBytes, + BMDPixelFormat pixelFormat, + BMDFrameFlags flags, + IDeckLinkVideoFrame_v7_1 **outFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateVideoFrameFromBuffer( + void *buffer, + int width, + int height, + int rowBytes, + BMDPixelFormat pixelFormat, + BMDFrameFlags flags, + IDeckLinkVideoFrame_v7_1 **outFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisplayVideoFrameSync( + IDeckLinkVideoFrame_v7_1 *theFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE ScheduleVideoFrame( + IDeckLinkVideoFrame_v7_1 *theFrame, + BMDTimeValue displayTime, + BMDTimeValue displayDuration, + BMDTimeScale timeScale) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetScheduledFrameCompletionCallback( + /* [in] */ IDeckLinkVideoOutputCallback_v7_1 *theCallback) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableAudioOutput( + BMDAudioSampleRate sampleRate, + BMDAudioSampleType sampleType, + unsigned int channelCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisableAudioOutput( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE WriteAudioSamplesSync( + void *buffer, + unsigned int sampleFrameCount, + /* [out] */ unsigned int *sampleFramesWritten) = 0; + + virtual HRESULT STDMETHODCALLTYPE BeginAudioPreroll( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE EndAudioPreroll( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE ScheduleAudioSamples( + void *buffer, + unsigned int sampleFrameCount, + BMDTimeValue streamTime, + BMDTimeScale timeScale, + /* [out] */ unsigned int *sampleFramesWritten) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBufferedAudioSampleFrameCount( + /* [out] */ unsigned int *bufferedSampleCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE FlushBufferedAudioSamples( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetAudioCallback( + /* [in] */ IDeckLinkAudioOutputCallback *theCallback) = 0; + + virtual HRESULT STDMETHODCALLTYPE StartScheduledPlayback( + BMDTimeValue playbackStartTime, + BMDTimeScale timeScale, + double playbackSpeed) = 0; + + virtual HRESULT STDMETHODCALLTYPE StopScheduledPlayback( + BMDTimeValue stopPlaybackAtTime, + BMDTimeValue *actualStopTime, + BMDTimeScale timeScale) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetHardwareReferenceClock( + BMDTimeScale desiredTimeScale, + BMDTimeValue *elapsedTimeSinceSchedulerBegan) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkOutput_v7_1Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkOutput_v7_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkOutput_v7_1 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkOutput_v7_1 * This); + + HRESULT ( STDMETHODCALLTYPE *DoesSupportVideoMode )( + IDeckLinkOutput_v7_1 * This, + BMDDisplayMode displayMode, + BMDPixelFormat pixelFormat, + /* [out] */ BMDDisplayModeSupport *result); + + HRESULT ( STDMETHODCALLTYPE *GetDisplayModeIterator )( + IDeckLinkOutput_v7_1 * This, + /* [out] */ IDeckLinkDisplayModeIterator_v7_1 **iterator); + + HRESULT ( STDMETHODCALLTYPE *EnableVideoOutput )( + IDeckLinkOutput_v7_1 * This, + BMDDisplayMode displayMode); + + HRESULT ( STDMETHODCALLTYPE *DisableVideoOutput )( + IDeckLinkOutput_v7_1 * This); + + HRESULT ( STDMETHODCALLTYPE *SetVideoOutputFrameMemoryAllocator )( + IDeckLinkOutput_v7_1 * This, + /* [in] */ IDeckLinkMemoryAllocator *theAllocator); + + HRESULT ( STDMETHODCALLTYPE *CreateVideoFrame )( + IDeckLinkOutput_v7_1 * This, + int width, + int height, + int rowBytes, + BMDPixelFormat pixelFormat, + BMDFrameFlags flags, + IDeckLinkVideoFrame_v7_1 **outFrame); + + HRESULT ( STDMETHODCALLTYPE *CreateVideoFrameFromBuffer )( + IDeckLinkOutput_v7_1 * This, + void *buffer, + int width, + int height, + int rowBytes, + BMDPixelFormat pixelFormat, + BMDFrameFlags flags, + IDeckLinkVideoFrame_v7_1 **outFrame); + + HRESULT ( STDMETHODCALLTYPE *DisplayVideoFrameSync )( + IDeckLinkOutput_v7_1 * This, + IDeckLinkVideoFrame_v7_1 *theFrame); + + HRESULT ( STDMETHODCALLTYPE *ScheduleVideoFrame )( + IDeckLinkOutput_v7_1 * This, + IDeckLinkVideoFrame_v7_1 *theFrame, + BMDTimeValue displayTime, + BMDTimeValue displayDuration, + BMDTimeScale timeScale); + + HRESULT ( STDMETHODCALLTYPE *SetScheduledFrameCompletionCallback )( + IDeckLinkOutput_v7_1 * This, + /* [in] */ IDeckLinkVideoOutputCallback_v7_1 *theCallback); + + HRESULT ( STDMETHODCALLTYPE *EnableAudioOutput )( + IDeckLinkOutput_v7_1 * This, + BMDAudioSampleRate sampleRate, + BMDAudioSampleType sampleType, + unsigned int channelCount); + + HRESULT ( STDMETHODCALLTYPE *DisableAudioOutput )( + IDeckLinkOutput_v7_1 * This); + + HRESULT ( STDMETHODCALLTYPE *WriteAudioSamplesSync )( + IDeckLinkOutput_v7_1 * This, + void *buffer, + unsigned int sampleFrameCount, + /* [out] */ unsigned int *sampleFramesWritten); + + HRESULT ( STDMETHODCALLTYPE *BeginAudioPreroll )( + IDeckLinkOutput_v7_1 * This); + + HRESULT ( STDMETHODCALLTYPE *EndAudioPreroll )( + IDeckLinkOutput_v7_1 * This); + + HRESULT ( STDMETHODCALLTYPE *ScheduleAudioSamples )( + IDeckLinkOutput_v7_1 * This, + void *buffer, + unsigned int sampleFrameCount, + BMDTimeValue streamTime, + BMDTimeScale timeScale, + /* [out] */ unsigned int *sampleFramesWritten); + + HRESULT ( STDMETHODCALLTYPE *GetBufferedAudioSampleFrameCount )( + IDeckLinkOutput_v7_1 * This, + /* [out] */ unsigned int *bufferedSampleCount); + + HRESULT ( STDMETHODCALLTYPE *FlushBufferedAudioSamples )( + IDeckLinkOutput_v7_1 * This); + + HRESULT ( STDMETHODCALLTYPE *SetAudioCallback )( + IDeckLinkOutput_v7_1 * This, + /* [in] */ IDeckLinkAudioOutputCallback *theCallback); + + HRESULT ( STDMETHODCALLTYPE *StartScheduledPlayback )( + IDeckLinkOutput_v7_1 * This, + BMDTimeValue playbackStartTime, + BMDTimeScale timeScale, + double playbackSpeed); + + HRESULT ( STDMETHODCALLTYPE *StopScheduledPlayback )( + IDeckLinkOutput_v7_1 * This, + BMDTimeValue stopPlaybackAtTime, + BMDTimeValue *actualStopTime, + BMDTimeScale timeScale); + + HRESULT ( STDMETHODCALLTYPE *GetHardwareReferenceClock )( + IDeckLinkOutput_v7_1 * This, + BMDTimeScale desiredTimeScale, + BMDTimeValue *elapsedTimeSinceSchedulerBegan); + + END_INTERFACE + } IDeckLinkOutput_v7_1Vtbl; + + interface IDeckLinkOutput_v7_1 + { + CONST_VTBL struct IDeckLinkOutput_v7_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkOutput_v7_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkOutput_v7_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkOutput_v7_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkOutput_v7_1_DoesSupportVideoMode(This,displayMode,pixelFormat,result) \ + ( (This)->lpVtbl -> DoesSupportVideoMode(This,displayMode,pixelFormat,result) ) + +#define IDeckLinkOutput_v7_1_GetDisplayModeIterator(This,iterator) \ + ( (This)->lpVtbl -> GetDisplayModeIterator(This,iterator) ) + +#define IDeckLinkOutput_v7_1_EnableVideoOutput(This,displayMode) \ + ( (This)->lpVtbl -> EnableVideoOutput(This,displayMode) ) + +#define IDeckLinkOutput_v7_1_DisableVideoOutput(This) \ + ( (This)->lpVtbl -> DisableVideoOutput(This) ) + +#define IDeckLinkOutput_v7_1_SetVideoOutputFrameMemoryAllocator(This,theAllocator) \ + ( (This)->lpVtbl -> SetVideoOutputFrameMemoryAllocator(This,theAllocator) ) + +#define IDeckLinkOutput_v7_1_CreateVideoFrame(This,width,height,rowBytes,pixelFormat,flags,outFrame) \ + ( (This)->lpVtbl -> CreateVideoFrame(This,width,height,rowBytes,pixelFormat,flags,outFrame) ) + +#define IDeckLinkOutput_v7_1_CreateVideoFrameFromBuffer(This,buffer,width,height,rowBytes,pixelFormat,flags,outFrame) \ + ( (This)->lpVtbl -> CreateVideoFrameFromBuffer(This,buffer,width,height,rowBytes,pixelFormat,flags,outFrame) ) + +#define IDeckLinkOutput_v7_1_DisplayVideoFrameSync(This,theFrame) \ + ( (This)->lpVtbl -> DisplayVideoFrameSync(This,theFrame) ) + +#define IDeckLinkOutput_v7_1_ScheduleVideoFrame(This,theFrame,displayTime,displayDuration,timeScale) \ + ( (This)->lpVtbl -> ScheduleVideoFrame(This,theFrame,displayTime,displayDuration,timeScale) ) + +#define IDeckLinkOutput_v7_1_SetScheduledFrameCompletionCallback(This,theCallback) \ + ( (This)->lpVtbl -> SetScheduledFrameCompletionCallback(This,theCallback) ) + +#define IDeckLinkOutput_v7_1_EnableAudioOutput(This,sampleRate,sampleType,channelCount) \ + ( (This)->lpVtbl -> EnableAudioOutput(This,sampleRate,sampleType,channelCount) ) + +#define IDeckLinkOutput_v7_1_DisableAudioOutput(This) \ + ( (This)->lpVtbl -> DisableAudioOutput(This) ) + +#define IDeckLinkOutput_v7_1_WriteAudioSamplesSync(This,buffer,sampleFrameCount,sampleFramesWritten) \ + ( (This)->lpVtbl -> WriteAudioSamplesSync(This,buffer,sampleFrameCount,sampleFramesWritten) ) + +#define IDeckLinkOutput_v7_1_BeginAudioPreroll(This) \ + ( (This)->lpVtbl -> BeginAudioPreroll(This) ) + +#define IDeckLinkOutput_v7_1_EndAudioPreroll(This) \ + ( (This)->lpVtbl -> EndAudioPreroll(This) ) + +#define IDeckLinkOutput_v7_1_ScheduleAudioSamples(This,buffer,sampleFrameCount,streamTime,timeScale,sampleFramesWritten) \ + ( (This)->lpVtbl -> ScheduleAudioSamples(This,buffer,sampleFrameCount,streamTime,timeScale,sampleFramesWritten) ) + +#define IDeckLinkOutput_v7_1_GetBufferedAudioSampleFrameCount(This,bufferedSampleCount) \ + ( (This)->lpVtbl -> GetBufferedAudioSampleFrameCount(This,bufferedSampleCount) ) + +#define IDeckLinkOutput_v7_1_FlushBufferedAudioSamples(This) \ + ( (This)->lpVtbl -> FlushBufferedAudioSamples(This) ) + +#define IDeckLinkOutput_v7_1_SetAudioCallback(This,theCallback) \ + ( (This)->lpVtbl -> SetAudioCallback(This,theCallback) ) + +#define IDeckLinkOutput_v7_1_StartScheduledPlayback(This,playbackStartTime,timeScale,playbackSpeed) \ + ( (This)->lpVtbl -> StartScheduledPlayback(This,playbackStartTime,timeScale,playbackSpeed) ) + +#define IDeckLinkOutput_v7_1_StopScheduledPlayback(This,stopPlaybackAtTime,actualStopTime,timeScale) \ + ( (This)->lpVtbl -> StopScheduledPlayback(This,stopPlaybackAtTime,actualStopTime,timeScale) ) + +#define IDeckLinkOutput_v7_1_GetHardwareReferenceClock(This,desiredTimeScale,elapsedTimeSinceSchedulerBegan) \ + ( (This)->lpVtbl -> GetHardwareReferenceClock(This,desiredTimeScale,elapsedTimeSinceSchedulerBegan) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkOutput_v7_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkInput_v7_1_INTERFACE_DEFINED__ +#define __IDeckLinkInput_v7_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkInput_v7_1 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkInput_v7_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("2B54EDEF-5B32-429F-BA11-BB990596EACD") + IDeckLinkInput_v7_1 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE DoesSupportVideoMode( + BMDDisplayMode displayMode, + BMDPixelFormat pixelFormat, + /* [out] */ BMDDisplayModeSupport *result) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayModeIterator( + /* [out] */ IDeckLinkDisplayModeIterator_v7_1 **iterator) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableVideoInput( + BMDDisplayMode displayMode, + BMDPixelFormat pixelFormat, + BMDVideoInputFlags flags) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisableVideoInput( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableAudioInput( + BMDAudioSampleRate sampleRate, + BMDAudioSampleType sampleType, + unsigned int channelCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisableAudioInput( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE ReadAudioSamples( + void *buffer, + unsigned int sampleFrameCount, + /* [out] */ unsigned int *sampleFramesRead, + /* [out] */ BMDTimeValue *audioPacketTime, + BMDTimeScale timeScale) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBufferedAudioSampleFrameCount( + /* [out] */ unsigned int *bufferedSampleCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE StartStreams( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE StopStreams( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE PauseStreams( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetCallback( + /* [in] */ IDeckLinkInputCallback_v7_1 *theCallback) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkInput_v7_1Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkInput_v7_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkInput_v7_1 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkInput_v7_1 * This); + + HRESULT ( STDMETHODCALLTYPE *DoesSupportVideoMode )( + IDeckLinkInput_v7_1 * This, + BMDDisplayMode displayMode, + BMDPixelFormat pixelFormat, + /* [out] */ BMDDisplayModeSupport *result); + + HRESULT ( STDMETHODCALLTYPE *GetDisplayModeIterator )( + IDeckLinkInput_v7_1 * This, + /* [out] */ IDeckLinkDisplayModeIterator_v7_1 **iterator); + + HRESULT ( STDMETHODCALLTYPE *EnableVideoInput )( + IDeckLinkInput_v7_1 * This, + BMDDisplayMode displayMode, + BMDPixelFormat pixelFormat, + BMDVideoInputFlags flags); + + HRESULT ( STDMETHODCALLTYPE *DisableVideoInput )( + IDeckLinkInput_v7_1 * This); + + HRESULT ( STDMETHODCALLTYPE *EnableAudioInput )( + IDeckLinkInput_v7_1 * This, + BMDAudioSampleRate sampleRate, + BMDAudioSampleType sampleType, + unsigned int channelCount); + + HRESULT ( STDMETHODCALLTYPE *DisableAudioInput )( + IDeckLinkInput_v7_1 * This); + + HRESULT ( STDMETHODCALLTYPE *ReadAudioSamples )( + IDeckLinkInput_v7_1 * This, + void *buffer, + unsigned int sampleFrameCount, + /* [out] */ unsigned int *sampleFramesRead, + /* [out] */ BMDTimeValue *audioPacketTime, + BMDTimeScale timeScale); + + HRESULT ( STDMETHODCALLTYPE *GetBufferedAudioSampleFrameCount )( + IDeckLinkInput_v7_1 * This, + /* [out] */ unsigned int *bufferedSampleCount); + + HRESULT ( STDMETHODCALLTYPE *StartStreams )( + IDeckLinkInput_v7_1 * This); + + HRESULT ( STDMETHODCALLTYPE *StopStreams )( + IDeckLinkInput_v7_1 * This); + + HRESULT ( STDMETHODCALLTYPE *PauseStreams )( + IDeckLinkInput_v7_1 * This); + + HRESULT ( STDMETHODCALLTYPE *SetCallback )( + IDeckLinkInput_v7_1 * This, + /* [in] */ IDeckLinkInputCallback_v7_1 *theCallback); + + END_INTERFACE + } IDeckLinkInput_v7_1Vtbl; + + interface IDeckLinkInput_v7_1 + { + CONST_VTBL struct IDeckLinkInput_v7_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkInput_v7_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkInput_v7_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkInput_v7_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkInput_v7_1_DoesSupportVideoMode(This,displayMode,pixelFormat,result) \ + ( (This)->lpVtbl -> DoesSupportVideoMode(This,displayMode,pixelFormat,result) ) + +#define IDeckLinkInput_v7_1_GetDisplayModeIterator(This,iterator) \ + ( (This)->lpVtbl -> GetDisplayModeIterator(This,iterator) ) + +#define IDeckLinkInput_v7_1_EnableVideoInput(This,displayMode,pixelFormat,flags) \ + ( (This)->lpVtbl -> EnableVideoInput(This,displayMode,pixelFormat,flags) ) + +#define IDeckLinkInput_v7_1_DisableVideoInput(This) \ + ( (This)->lpVtbl -> DisableVideoInput(This) ) + +#define IDeckLinkInput_v7_1_EnableAudioInput(This,sampleRate,sampleType,channelCount) \ + ( (This)->lpVtbl -> EnableAudioInput(This,sampleRate,sampleType,channelCount) ) + +#define IDeckLinkInput_v7_1_DisableAudioInput(This) \ + ( (This)->lpVtbl -> DisableAudioInput(This) ) + +#define IDeckLinkInput_v7_1_ReadAudioSamples(This,buffer,sampleFrameCount,sampleFramesRead,audioPacketTime,timeScale) \ + ( (This)->lpVtbl -> ReadAudioSamples(This,buffer,sampleFrameCount,sampleFramesRead,audioPacketTime,timeScale) ) + +#define IDeckLinkInput_v7_1_GetBufferedAudioSampleFrameCount(This,bufferedSampleCount) \ + ( (This)->lpVtbl -> GetBufferedAudioSampleFrameCount(This,bufferedSampleCount) ) + +#define IDeckLinkInput_v7_1_StartStreams(This) \ + ( (This)->lpVtbl -> StartStreams(This) ) + +#define IDeckLinkInput_v7_1_StopStreams(This) \ + ( (This)->lpVtbl -> StopStreams(This) ) + +#define IDeckLinkInput_v7_1_PauseStreams(This) \ + ( (This)->lpVtbl -> PauseStreams(This) ) + +#define IDeckLinkInput_v7_1_SetCallback(This,theCallback) \ + ( (This)->lpVtbl -> SetCallback(This,theCallback) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkInput_v7_1_INTERFACE_DEFINED__ */ + +#endif /* __DeckLinkAPI_LIBRARY_DEFINED__ */ + +/* Additional Prototypes for ALL interfaces */ + +/* end of Additional Prototypes */ + +#ifdef __cplusplus +} +#endif + +#endif + + diff --git a/intern/decklink/win/DeckLinkAPI_i.c b/intern/decklink/win/DeckLinkAPI_i.c new file mode 100644 index 00000000000..a13d486aae8 --- /dev/null +++ b/intern/decklink/win/DeckLinkAPI_i.c @@ -0,0 +1,343 @@ + + +/* this ALWAYS GENERATED file contains the IIDs and CLSIDs */ + +/* link this file in with the server and any clients */ + + + /* File created by MIDL compiler version 8.00.0603 */ +/* at Mon Apr 13 20:57:05 2015 + */ +/* Compiler settings for ..\..\include\DeckLinkAPI.idl: + Oicf, W1, Zp8, env=Win64 (32b run), target_arch=AMD64 8.00.0603 + protocol : dce , ms_ext, c_ext, robust + error checks: allocation ref bounds_check enum stub_data + VC __declspec() decoration level: + __declspec(uuid()), __declspec(selectany), __declspec(novtable) + DECLSPEC_UUID(), MIDL_INTERFACE() +*/ +/* @@MIDL_FILE_HEADING( ) */ + +#pragma warning( disable: 4049 ) /* more than 64k source lines */ + + +#ifdef __cplusplus +extern "C"{ +#endif + + +#include <rpc.h> +#include <rpcndr.h> + +#ifdef _MIDL_USE_GUIDDEF_ + +#ifndef INITGUID +#define INITGUID +#include <guiddef.h> +#undef INITGUID +#else +#include <guiddef.h> +#endif + +#define MIDL_DEFINE_GUID(type,name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) \ + DEFINE_GUID(name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) + +#else // !_MIDL_USE_GUIDDEF_ + +#ifndef __IID_DEFINED__ +#define __IID_DEFINED__ + +typedef struct _IID +{ + unsigned long x; + unsigned short s1; + unsigned short s2; + unsigned char c[8]; +} IID; + +#endif // __IID_DEFINED__ + +#ifndef CLSID_DEFINED +#define CLSID_DEFINED +typedef IID CLSID; +#endif // CLSID_DEFINED + +#define MIDL_DEFINE_GUID(type,name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) \ + const type name = {l,w1,w2,{b1,b2,b3,b4,b5,b6,b7,b8}} + +#endif !_MIDL_USE_GUIDDEF_ + +MIDL_DEFINE_GUID(IID, LIBID_DeckLinkAPI,0xD864517A,0xEDD5,0x466D,0x86,0x7D,0xC8,0x19,0xF1,0xC0,0x52,0xBB); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkTimecode,0xBC6CFBD3,0x8317,0x4325,0xAC,0x1C,0x12,0x16,0x39,0x1E,0x93,0x40); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkDisplayModeIterator,0x9C88499F,0xF601,0x4021,0xB8,0x0B,0x03,0x2E,0x4E,0xB4,0x1C,0x35); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkDisplayMode,0x3EB2C1AB,0x0A3D,0x4523,0xA3,0xAD,0xF4,0x0D,0x7F,0xB1,0x4E,0x78); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLink,0xC418FBDD,0x0587,0x48ED,0x8F,0xE5,0x64,0x0F,0x0A,0x14,0xAF,0x91); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkConfiguration,0x1E69FCF6,0x4203,0x4936,0x80,0x76,0x2A,0x9F,0x4C,0xFD,0x50,0xCB); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkDeckControlStatusCallback,0x53436FFB,0xB434,0x4906,0xBA,0xDC,0xAE,0x30,0x60,0xFF,0xE8,0xEF); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkDeckControl,0x8E1C3ACE,0x19C7,0x4E00,0x8B,0x92,0xD8,0x04,0x31,0xD9,0x58,0xBE); + + +MIDL_DEFINE_GUID(IID, IID_IBMDStreamingDeviceNotificationCallback,0xF9531D64,0x3305,0x4B29,0xA3,0x87,0x7F,0x74,0xBB,0x0D,0x0E,0x84); + + +MIDL_DEFINE_GUID(IID, IID_IBMDStreamingH264InputCallback,0x823C475F,0x55AE,0x46F9,0x89,0x0C,0x53,0x7C,0xC5,0xCE,0xDC,0xCA); + + +MIDL_DEFINE_GUID(IID, IID_IBMDStreamingDiscovery,0x2C837444,0xF989,0x4D87,0x90,0x1A,0x47,0xC8,0xA3,0x6D,0x09,0x6D); + + +MIDL_DEFINE_GUID(IID, IID_IBMDStreamingVideoEncodingMode,0x1AB8035B,0xCD13,0x458D,0xB6,0xDF,0x5E,0x8F,0x7C,0x21,0x41,0xD9); + + +MIDL_DEFINE_GUID(IID, IID_IBMDStreamingMutableVideoEncodingMode,0x19BF7D90,0x1E0A,0x400D,0xB2,0xC6,0xFF,0xC4,0xE7,0x8A,0xD4,0x9D); + + +MIDL_DEFINE_GUID(IID, IID_IBMDStreamingVideoEncodingModePresetIterator,0x7AC731A3,0xC950,0x4AD0,0x80,0x4A,0x83,0x77,0xAA,0x51,0xC6,0xC4); + + +MIDL_DEFINE_GUID(IID, IID_IBMDStreamingDeviceInput,0x24B6B6EC,0x1727,0x44BB,0x98,0x18,0x34,0xFF,0x08,0x6A,0xCF,0x98); + + +MIDL_DEFINE_GUID(IID, IID_IBMDStreamingH264NALPacket,0xE260E955,0x14BE,0x4395,0x97,0x75,0x9F,0x02,0xCC,0x0A,0x9D,0x89); + + +MIDL_DEFINE_GUID(IID, IID_IBMDStreamingAudioPacket,0xD9EB5902,0x1AD2,0x43F4,0x9E,0x2C,0x3C,0xFA,0x50,0xB5,0xEE,0x19); + + +MIDL_DEFINE_GUID(IID, IID_IBMDStreamingMPEG2TSPacket,0x91810D1C,0x4FB3,0x4AAA,0xAE,0x56,0xFA,0x30,0x1D,0x3D,0xFA,0x4C); + + +MIDL_DEFINE_GUID(IID, IID_IBMDStreamingH264NALParser,0x5867F18C,0x5BFA,0x4CCC,0xB2,0xA7,0x9D,0xFD,0x14,0x04,0x17,0xD2); + + +MIDL_DEFINE_GUID(CLSID, CLSID_CBMDStreamingDiscovery,0x0CAA31F6,0x8A26,0x40B0,0x86,0xA4,0xBF,0x58,0xDC,0xCA,0x71,0x0C); + + +MIDL_DEFINE_GUID(CLSID, CLSID_CBMDStreamingH264NALParser,0x7753EFBD,0x951C,0x407C,0x97,0xA5,0x23,0xC7,0x37,0xB7,0x3B,0x52); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoOutputCallback,0x20AA5225,0x1958,0x47CB,0x82,0x0B,0x80,0xA8,0xD5,0x21,0xA6,0xEE); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkInputCallback,0xDD04E5EC,0x7415,0x42AB,0xAE,0x4A,0xE8,0x0C,0x4D,0xFC,0x04,0x4A); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkMemoryAllocator,0xB36EB6E7,0x9D29,0x4AA8,0x92,0xEF,0x84,0x3B,0x87,0xA2,0x89,0xE8); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkAudioOutputCallback,0x403C681B,0x7F46,0x4A12,0xB9,0x93,0x2B,0xB1,0x27,0x08,0x4E,0xE6); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkIterator,0x50FB36CD,0x3063,0x4B73,0xBD,0xBB,0x95,0x80,0x87,0xF2,0xD8,0xBA); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkAPIInformation,0x7BEA3C68,0x730D,0x4322,0xAF,0x34,0x8A,0x71,0x52,0xB5,0x32,0xA4); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkOutput,0xCC5C8A6E,0x3F2F,0x4B3A,0x87,0xEA,0xFD,0x78,0xAF,0x30,0x05,0x64); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkInput,0xAF22762B,0xDFAC,0x4846,0xAA,0x79,0xFA,0x88,0x83,0x56,0x09,0x95); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoFrame,0x3F716FE0,0xF023,0x4111,0xBE,0x5D,0xEF,0x44,0x14,0xC0,0x5B,0x17); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkMutableVideoFrame,0x69E2639F,0x40DA,0x4E19,0xB6,0xF2,0x20,0xAC,0xE8,0x15,0xC3,0x90); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoFrame3DExtensions,0xDA0F7E4A,0xEDC7,0x48A8,0x9C,0xDD,0x2D,0xB5,0x1C,0x72,0x9C,0xD7); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoInputFrame,0x05CFE374,0x537C,0x4094,0x9A,0x57,0x68,0x05,0x25,0x11,0x8F,0x44); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoFrameAncillary,0x732E723C,0xD1A4,0x4E29,0x9E,0x8E,0x4A,0x88,0x79,0x7A,0x00,0x04); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkAudioInputPacket,0xE43D5870,0x2894,0x11DE,0x8C,0x30,0x08,0x00,0x20,0x0C,0x9A,0x66); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkScreenPreviewCallback,0xB1D3F49A,0x85FE,0x4C5D,0x95,0xC8,0x0B,0x5D,0x5D,0xCC,0xD4,0x38); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkGLScreenPreviewHelper,0x504E2209,0xCAC7,0x4C1A,0x9F,0xB4,0xC5,0xBB,0x62,0x74,0xD2,0x2F); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkDX9ScreenPreviewHelper,0x2094B522,0xD1A1,0x40C0,0x9A,0xC7,0x1C,0x01,0x22,0x18,0xEF,0x02); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkNotificationCallback,0xb002a1ec,0x070d,0x4288,0x82,0x89,0xbd,0x5d,0x36,0xe5,0xff,0x0d); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkNotification,0x0a1fb207,0xe215,0x441b,0x9b,0x19,0x6f,0xa1,0x57,0x59,0x46,0xc5); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkAttributes,0xABC11843,0xD966,0x44CB,0x96,0xE2,0xA1,0xCB,0x5D,0x31,0x35,0xC4); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkKeyer,0x89AFCAF5,0x65F8,0x421E,0x98,0xF7,0x96,0xFE,0x5F,0x5B,0xFB,0xA3); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoConversion,0x3BBCB8A2,0xDA2C,0x42D9,0xB5,0xD8,0x88,0x08,0x36,0x44,0xE9,0x9A); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkDeviceNotificationCallback,0x4997053B,0x0ADF,0x4CC8,0xAC,0x70,0x7A,0x50,0xC4,0xBE,0x72,0x8F); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkDiscovery,0xCDBF631C,0xBC76,0x45FA,0xB4,0x4D,0xC5,0x50,0x59,0xBC,0x61,0x01); + + +MIDL_DEFINE_GUID(CLSID, CLSID_CDeckLinkIterator,0x1F2E109A,0x8F4F,0x49E4,0x92,0x03,0x13,0x55,0x95,0xCB,0x6F,0xA5); + + +MIDL_DEFINE_GUID(CLSID, CLSID_CDeckLinkAPIInformation,0x263CA19F,0xED09,0x482E,0x9F,0x9D,0x84,0x00,0x57,0x83,0xA2,0x37); + + +MIDL_DEFINE_GUID(CLSID, CLSID_CDeckLinkGLScreenPreviewHelper,0xF63E77C7,0xB655,0x4A4A,0x9A,0xD0,0x3C,0xA8,0x5D,0x39,0x43,0x43); + + +MIDL_DEFINE_GUID(CLSID, CLSID_CDeckLinkDX9ScreenPreviewHelper,0xCC010023,0xE01D,0x4525,0x9D,0x59,0x80,0xC8,0xAB,0x3D,0xC7,0xA0); + + +MIDL_DEFINE_GUID(CLSID, CLSID_CDeckLinkVideoConversion,0x7DBBBB11,0x5B7B,0x467D,0xAE,0xA4,0xCE,0xA4,0x68,0xFD,0x36,0x8C); + + +MIDL_DEFINE_GUID(CLSID, CLSID_CDeckLinkDiscovery,0x1073A05C,0xD885,0x47E9,0xB3,0xC6,0x12,0x9B,0x3F,0x9F,0x64,0x8B); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkConfiguration_v10_2,0xC679A35B,0x610C,0x4D09,0xB7,0x48,0x1D,0x04,0x78,0x10,0x0F,0xC0); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkOutput_v9_9,0xA3EF0963,0x0862,0x44ED,0x92,0xA9,0xEE,0x89,0xAB,0xF4,0x31,0xC7); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkInput_v9_2,0x6D40EF78,0x28B9,0x4E21,0x99,0x0D,0x95,0xBB,0x77,0x50,0xA0,0x4F); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkDeckControlStatusCallback_v8_1,0xE5F693C1,0x4283,0x4716,0xB1,0x8F,0xC1,0x43,0x15,0x21,0x95,0x5B); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkDeckControl_v8_1,0x522A9E39,0x0F3C,0x4742,0x94,0xEE,0xD8,0x0D,0xE3,0x35,0xDA,0x1D); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLink_v8_0,0x62BFF75D,0x6569,0x4E55,0x8D,0x4D,0x66,0xAA,0x03,0x82,0x9A,0xBC); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkIterator_v8_0,0x74E936FC,0xCC28,0x4A67,0x81,0xA0,0x1E,0x94,0xE5,0x2D,0x4E,0x69); + + +MIDL_DEFINE_GUID(CLSID, CLSID_CDeckLinkIterator_v8_0,0xD9EDA3B3,0x2887,0x41FA,0xB7,0x24,0x01,0x7C,0xF1,0xEB,0x1D,0x37); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkDeckControl_v7_9,0xA4D81043,0x0619,0x42B7,0x8E,0xD6,0x60,0x2D,0x29,0x04,0x1D,0xF7); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkDisplayModeIterator_v7_6,0x455D741F,0x1779,0x4800,0x86,0xF5,0x0B,0x5D,0x13,0xD7,0x97,0x51); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkDisplayMode_v7_6,0x87451E84,0x2B7E,0x439E,0xA6,0x29,0x43,0x93,0xEA,0x4A,0x85,0x50); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkOutput_v7_6,0x29228142,0xEB8C,0x4141,0xA6,0x21,0xF7,0x40,0x26,0x45,0x09,0x55); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkInput_v7_6,0x300C135A,0x9F43,0x48E2,0x99,0x06,0x6D,0x79,0x11,0xD9,0x3C,0xF1); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkTimecode_v7_6,0xEFB9BCA6,0xA521,0x44F7,0xBD,0x69,0x23,0x32,0xF2,0x4D,0x9E,0xE6); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoFrame_v7_6,0xA8D8238E,0x6B18,0x4196,0x99,0xE1,0x5A,0xF7,0x17,0xB8,0x3D,0x32); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkMutableVideoFrame_v7_6,0x46FCEE00,0xB4E6,0x43D0,0x91,0xC0,0x02,0x3A,0x7F,0xCE,0xB3,0x4F); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoInputFrame_v7_6,0x9A74FA41,0xAE9F,0x47AC,0x8C,0xF4,0x01,0xF4,0x2D,0xD5,0x99,0x65); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkScreenPreviewCallback_v7_6,0x373F499D,0x4B4D,0x4518,0xAD,0x22,0x63,0x54,0xE5,0xA5,0x82,0x5E); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkGLScreenPreviewHelper_v7_6,0xBA575CD9,0xA15E,0x497B,0xB2,0xC2,0xF9,0xAF,0xE7,0xBE,0x4E,0xBA); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoConversion_v7_6,0x3EB504C9,0xF97D,0x40FE,0xA1,0x58,0xD4,0x07,0xD4,0x8C,0xB5,0x3B); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkConfiguration_v7_6,0xB8EAD569,0xB764,0x47F0,0xA7,0x3F,0xAE,0x40,0xDF,0x6C,0xBF,0x10); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoOutputCallback_v7_6,0xE763A626,0x4A3C,0x49D1,0xBF,0x13,0xE7,0xAD,0x36,0x92,0xAE,0x52); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkInputCallback_v7_6,0x31D28EE7,0x88B6,0x4CB1,0x89,0x7A,0xCD,0xBF,0x79,0xA2,0x64,0x14); + + +MIDL_DEFINE_GUID(CLSID, CLSID_CDeckLinkGLScreenPreviewHelper_v7_6,0xD398CEE7,0x4434,0x4CA3,0x9B,0xA6,0x5A,0xE3,0x45,0x56,0xB9,0x05); + + +MIDL_DEFINE_GUID(CLSID, CLSID_CDeckLinkVideoConversion_v7_6,0xFFA84F77,0x73BE,0x4FB7,0xB0,0x3E,0xB5,0xE4,0x4B,0x9F,0x75,0x9B); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkInputCallback_v7_3,0xFD6F311D,0x4D00,0x444B,0x9E,0xD4,0x1F,0x25,0xB5,0x73,0x0A,0xD0); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkOutput_v7_3,0x271C65E3,0xC323,0x4344,0xA3,0x0F,0xD9,0x08,0xBC,0xB2,0x0A,0xA3); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkInput_v7_3,0x4973F012,0x9925,0x458C,0x87,0x1C,0x18,0x77,0x4C,0xDB,0xBE,0xCB); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoInputFrame_v7_3,0xCF317790,0x2894,0x11DE,0x8C,0x30,0x08,0x00,0x20,0x0C,0x9A,0x66); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkDisplayModeIterator_v7_1,0xB28131B6,0x59AC,0x4857,0xB5,0xAC,0xCD,0x75,0xD5,0x88,0x3E,0x2F); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkDisplayMode_v7_1,0xAF0CD6D5,0x8376,0x435E,0x84,0x33,0x54,0xF9,0xDD,0x53,0x0A,0xC3); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoFrame_v7_1,0x333F3A10,0x8C2D,0x43CF,0xB7,0x9D,0x46,0x56,0x0F,0xEE,0xA1,0xCE); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoInputFrame_v7_1,0xC8B41D95,0x8848,0x40EE,0x9B,0x37,0x6E,0x34,0x17,0xFB,0x11,0x4B); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkAudioInputPacket_v7_1,0xC86DE4F6,0xA29F,0x42E3,0xAB,0x3A,0x13,0x63,0xE2,0x9F,0x07,0x88); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoOutputCallback_v7_1,0xEBD01AFA,0xE4B0,0x49C6,0xA0,0x1D,0xED,0xB9,0xD1,0xB5,0x5F,0xD9); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkInputCallback_v7_1,0x7F94F328,0x5ED4,0x4E9F,0x97,0x29,0x76,0xA8,0x6B,0xDC,0x99,0xCC); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkOutput_v7_1,0xAE5B3E9B,0x4E1E,0x4535,0xB6,0xE8,0x48,0x0F,0xF5,0x2F,0x6C,0xE5); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkInput_v7_1,0x2B54EDEF,0x5B32,0x429F,0xBA,0x11,0xBB,0x99,0x05,0x96,0xEA,0xCD); + +#undef MIDL_DEFINE_GUID + +#ifdef __cplusplus +} +#endif + + + diff --git a/intern/gpudirect/CMakeLists.txt b/intern/gpudirect/CMakeLists.txt new file mode 100644 index 00000000000..88c09a663b8 --- /dev/null +++ b/intern/gpudirect/CMakeLists.txt @@ -0,0 +1,41 @@ +# ***** BEGIN GPL LICENSE BLOCK ***** +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. +# +# This program 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 General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software Foundation, +# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +# +# The Original Code is Copyright (C) 2015, Blender Foundation +# All rights reserved. +# +# The Original Code is: all of this file. +# +# Contributor(s): Blender Foundation. +# +# ***** END GPL LICENSE BLOCK ***** + +set(INC + . + # XXX, bad level include! + ../../source/blender/blenlib +) + +set(INC_SYS + ${GLEW_INCLUDE_PATH} +) + +set(SRC + dvpapi.cpp + dvpapi.h +) + +blender_add_lib(bf_intern_gpudirect "${SRC}" "${INC}" "${INC_SYS}") diff --git a/intern/gpudirect/dvpapi.cpp b/intern/gpudirect/dvpapi.cpp new file mode 100644 index 00000000000..8ae5cdbf17b --- /dev/null +++ b/intern/gpudirect/dvpapi.cpp @@ -0,0 +1,147 @@ +/* +* ***** BEGIN GPL LICENSE BLOCK ***** +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* as published by the Free Software Foundation; either version 2 +* of the License, or (at your option) any later version. +* +* This program 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 General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software Foundation, +* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +* +* The Original Code is Copyright (C) 2015, Blender Foundation +* All rights reserved. +* +* The Original Code is: all of this file. +* +* Contributor(s): Blender Foundation. +* +* ***** END GPL LICENSE BLOCK ***** +*/ + +/** \file gpudirect/dvpapi.c +* \ingroup gpudirect +*/ + +#ifdef WIN32 + +#include <stdlib.h> +#include "dvpapi.h" + +extern "C" { +#include "BLI_dynlib.h" +} + +#define KDVPAPI_Name "dvp.dll" + +typedef DVPStatus (DVPAPIENTRY * PFNDVPINITGLCONTEXT) (uint32_t flags); +typedef DVPStatus (DVPAPIENTRY * PFNDVPCLOSEGLCONTEXT) (void); +typedef DVPStatus (DVPAPIENTRY * PFNDVPGETLIBRARYVERSION)(uint32_t *major, uint32_t *minor); + +static uint32_t __dvpMajorVersion = 0; +static uint32_t __dvpMinorVersion = 0; +static PFNDVPGETLIBRARYVERSION __dvpGetLibrayVersion = NULL; +static PFNDVPINITGLCONTEXT __dvpInitGLContext = NULL; +static PFNDVPCLOSEGLCONTEXT __dvpCloseGLContext = NULL; +PFNDVPBEGIN __dvpBegin = NULL; +PFNDVPEND __dvpEnd = NULL; +PFNDVPCREATEBUFFER __dvpCreateBuffer = NULL; +PFNDVPDESTROYBUFFER __dvpDestroyBuffer = NULL; +PFNDVPFREEBUFFER __dvpFreeBuffer = NULL; +PFNDVPMEMCPYLINED __dvpMemcpyLined = NULL; +PFNDVPMEMCPY __dvpMemcpy = NULL; +PFNDVPIMPORTSYNCOBJECT __dvpImportSyncObject = NULL; +PFNDVPFREESYNCOBJECT __dvpFreeSyncObject = NULL; +PFNDVPMAPBUFFERENDAPI __dvpMapBufferEndAPI = NULL; +PFNDVPMAPBUFFERWAITDVP __dvpMapBufferWaitDVP = NULL; +PFNDVPMAPBUFFERENDDVP __dvpMapBufferEndDVP = NULL; +PFNDVPMAPBUFFERWAITAPI __dvpMapBufferWaitAPI = NULL; +PFNDVPBINDTOGLCTX __dvpBindToGLCtx = NULL; +PFNDVPGETREQUIREDCONSTANTSGLCTX __dvpGetRequiredConstantsGLCtx = NULL; +PFNDVPCREATEGPUTEXTUREGL __dvpCreateGPUTextureGL = NULL; +PFNDVPUNBINDFROMGLCTX __dvpUnbindFromGLCtx = NULL; + +static DynamicLibrary *__dvpLibrary = NULL; + +DVPStatus dvpGetLibrayVersion(uint32_t *major, uint32_t *minor) +{ + if (!__dvpLibrary) + return DVP_STATUS_ERROR; + *major = __dvpMajorVersion; + *minor = __dvpMinorVersion; + return DVP_STATUS_OK; +} + +DVPStatus dvpInitGLContext(uint32_t flags) +{ + DVPStatus status; + if (!__dvpLibrary) { + __dvpLibrary = BLI_dynlib_open(KDVPAPI_Name); + if (!__dvpLibrary) { + return DVP_STATUS_ERROR; + } +// "?dvpInitGLContext@@YA?AW4DVPStatus@@I@Z"; + __dvpInitGLContext = (PFNDVPINITGLCONTEXT)BLI_dynlib_find_symbol(__dvpLibrary, "?dvpInitGLContext@@YA?AW4DVPStatus@@I@Z"); + __dvpCloseGLContext = (PFNDVPCLOSEGLCONTEXT)BLI_dynlib_find_symbol(__dvpLibrary, "?dvpCloseGLContext@@YA?AW4DVPStatus@@XZ"); + __dvpGetLibrayVersion = (PFNDVPGETLIBRARYVERSION)BLI_dynlib_find_symbol(__dvpLibrary, "?dvpGetLibrayVersion@@YA?AW4DVPStatus@@PEAI0@Z"); + __dvpBegin = (PFNDVPBEGIN)BLI_dynlib_find_symbol(__dvpLibrary, "?dvpBegin@@YA?AW4DVPStatus@@XZ"); + __dvpEnd = (PFNDVPEND)BLI_dynlib_find_symbol(__dvpLibrary, "?dvpEnd@@YA?AW4DVPStatus@@XZ"); + __dvpCreateBuffer = (PFNDVPCREATEBUFFER)BLI_dynlib_find_symbol(__dvpLibrary, "?dvpCreateBuffer@@YA?AW4DVPStatus@@PEAUDVPSysmemBufferDescRec@@PEA_K@Z"); + __dvpDestroyBuffer = (PFNDVPDESTROYBUFFER)BLI_dynlib_find_symbol(__dvpLibrary, "?dvpDestroyBuffer@@YA?AW4DVPStatus@@_K@Z"); + __dvpFreeBuffer = (PFNDVPFREEBUFFER)BLI_dynlib_find_symbol(__dvpLibrary, "?dvpFreeBuffer@@YA?AW4DVPStatus@@_K@Z"); + __dvpMemcpyLined = (PFNDVPMEMCPYLINED)BLI_dynlib_find_symbol(__dvpLibrary, "?dvpMemcpyLined@@YA?AW4DVPStatus@@_K0I000III@Z"); + __dvpMemcpy = (PFNDVPMEMCPY)BLI_dynlib_find_symbol(__dvpLibrary, "?dvpMemcpy2D@@YA?AW4DVPStatus@@_K0I000IIIII@Z"); + __dvpImportSyncObject = (PFNDVPIMPORTSYNCOBJECT)BLI_dynlib_find_symbol(__dvpLibrary, "?dvpImportSyncObject@@YA?AW4DVPStatus@@PEAUDVPSyncObjectDescRec@@PEA_K@Z"); + __dvpFreeSyncObject = (PFNDVPFREESYNCOBJECT)BLI_dynlib_find_symbol(__dvpLibrary, "?dvpFreeSyncObject@@YA?AW4DVPStatus@@_K@Z"); + __dvpMapBufferEndAPI = (PFNDVPMAPBUFFERENDAPI)BLI_dynlib_find_symbol(__dvpLibrary, "?dvpMapBufferEndAPI@@YA?AW4DVPStatus@@_K@Z"); + __dvpMapBufferWaitDVP = (PFNDVPMAPBUFFERWAITDVP)BLI_dynlib_find_symbol(__dvpLibrary, "?dvpMapBufferWaitDVP@@YA?AW4DVPStatus@@_K@Z"); + __dvpMapBufferEndDVP = (PFNDVPMAPBUFFERENDDVP)BLI_dynlib_find_symbol(__dvpLibrary, "?dvpMapBufferEndDVP@@YA?AW4DVPStatus@@_K@Z"); + __dvpMapBufferWaitAPI = (PFNDVPMAPBUFFERWAITAPI)BLI_dynlib_find_symbol(__dvpLibrary, "?dvpMapBufferWaitAPI@@YA?AW4DVPStatus@@_K@Z"); + __dvpBindToGLCtx = (PFNDVPBINDTOGLCTX)BLI_dynlib_find_symbol(__dvpLibrary, "?dvpBindToGLCtx@@YA?AW4DVPStatus@@_K@Z"); + __dvpGetRequiredConstantsGLCtx = (PFNDVPGETREQUIREDCONSTANTSGLCTX)BLI_dynlib_find_symbol(__dvpLibrary, "?dvpGetRequiredConstantsGLCtx@@YA?AW4DVPStatus@@PEAI00000@Z"); + __dvpCreateGPUTextureGL = (PFNDVPCREATEGPUTEXTUREGL)BLI_dynlib_find_symbol(__dvpLibrary, "?dvpCreateGPUTextureGL@@YA?AW4DVPStatus@@IPEA_K@Z"); + __dvpUnbindFromGLCtx = (PFNDVPUNBINDFROMGLCTX)BLI_dynlib_find_symbol(__dvpLibrary, "?dvpUnbindFromGLCtx@@YA?AW4DVPStatus@@_K@Z"); + if (!__dvpInitGLContext || + !__dvpCloseGLContext || + !__dvpGetLibrayVersion || + !__dvpBegin || + !__dvpEnd || + !__dvpCreateBuffer || + !__dvpDestroyBuffer || + !__dvpFreeBuffer || + !__dvpMemcpyLined || + !__dvpMemcpy || + !__dvpImportSyncObject || + !__dvpFreeSyncObject || + !__dvpMapBufferEndAPI || + !__dvpMapBufferWaitDVP || + !__dvpMapBufferEndDVP || + !__dvpMapBufferWaitAPI || + !__dvpBindToGLCtx || + !__dvpGetRequiredConstantsGLCtx || + !__dvpCreateGPUTextureGL || + !__dvpUnbindFromGLCtx) + { + return DVP_STATUS_ERROR; + } + // check that the library version is what we want + if ((status = __dvpGetLibrayVersion(&__dvpMajorVersion, &__dvpMinorVersion)) != DVP_STATUS_OK) + return status; + if (__dvpMajorVersion != DVP_MAJOR_VERSION || __dvpMinorVersion < DVP_MINOR_VERSION) + return DVP_STATUS_ERROR; + } + return (!__dvpInitGLContext) ? DVP_STATUS_ERROR : __dvpInitGLContext(flags); +} + +DVPStatus dvpCloseGLContext(void) +{ + return (!__dvpCloseGLContext) ? DVP_STATUS_ERROR : __dvpCloseGLContext(); +} + +#endif // WIN32 diff --git a/intern/gpudirect/dvpapi.h b/intern/gpudirect/dvpapi.h new file mode 100644 index 00000000000..4cc259f0fe8 --- /dev/null +++ b/intern/gpudirect/dvpapi.h @@ -0,0 +1,667 @@ +/* +* ***** BEGIN GPL LICENSE BLOCK ***** +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* as published by the Free Software Foundation; either version 2 +* of the License, or (at your option) any later version. +* +* This program 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 General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software Foundation, +* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +* +* The Original Code is Copyright (C) 2015, Blender Foundation +* All rights reserved. +* +* The Original Code is: all of this file. +* +* Contributor(s): Blender Foundation. +* +* ***** END GPL LICENSE BLOCK ***** +*/ + +/** \file gpudirect/dvpapi.h +* \ingroup gpudirect +*/ + +#ifndef __DVPAPI_H__ +#define __DVPAPI_H__ + +#ifdef WIN32 + +#include <stdlib.h> +#include <stdint.h> + +#include "GL/glew.h" + +#if defined(__GNUC__) && __GNUC__>=4 +# define DVPAPI extern __attribute__ ((visibility("default"))) +#elif defined(__SUNPRO_C) || defined(__SUNPRO_CC) +# define DVPAPI extern __global +#else +# define DVPAPI extern +#endif + +#define DVPAPIENTRY +#define DVP_MAJOR_VERSION 1 +#define DVP_MINOR_VERSION 63 + +typedef uint64_t DVPBufferHandle; +typedef uint64_t DVPSyncObjectHandle; + +typedef enum { + DVP_STATUS_OK = 0, + DVP_STATUS_INVALID_PARAMETER = 1, + DVP_STATUS_UNSUPPORTED = 2, + DVP_STATUS_END_ENUMERATION = 3, + DVP_STATUS_INVALID_DEVICE = 4, + DVP_STATUS_OUT_OF_MEMORY = 5, + DVP_STATUS_INVALID_OPERATION = 6, + DVP_STATUS_TIMEOUT = 7, + DVP_STATUS_INVALID_CONTEXT = 8, + DVP_STATUS_INVALID_RESOURCE_TYPE = 9, + DVP_STATUS_INVALID_FORMAT_OR_TYPE = 10, + DVP_STATUS_DEVICE_UNINITIALIZED = 11, + DVP_STATUS_UNSIGNALED = 12, + DVP_STATUS_SYNC_ERROR = 13, + DVP_STATUS_SYNC_STILL_BOUND = 14, + DVP_STATUS_ERROR = -1, +} DVPStatus; + +// Pixel component formats stored in the system memory buffer +// analogous to those defined in the OpenGL API, except for +// DVP_BUFFER and the DVP_CUDA_* types. DVP_BUFFER provides +// an unspecified format type to allow for general interpretation +// of the bytes at a later stage (in GPU shader). Note that not +// all paths will achieve optimal speeds due to lack of HW support +// for the transformation. The CUDA types are to be used when +// copying to/from a system memory buffer from-to a CUDA array, as the +// CUDA array implies a memory layout that matches the array. +typedef enum { + DVP_BUFFER, // Buffer treated as a raw buffer + // and copied directly into GPU buffer + // without any interpretation of the + // stored bytes. + DVP_DEPTH_COMPONENT, + DVP_RGBA, + DVP_BGRA, + DVP_RED, + DVP_GREEN, + DVP_BLUE, + DVP_ALPHA, + DVP_RGB, + DVP_BGR, + DVP_LUMINANCE, + DVP_LUMINANCE_ALPHA, + DVP_CUDA_1_CHANNEL, + DVP_CUDA_2_CHANNELS, + DVP_CUDA_4_CHANNELS, + DVP_RGBA_INTEGER, + DVP_BGRA_INTEGER, + DVP_RED_INTEGER, + DVP_GREEN_INTEGER, + DVP_BLUE_INTEGER, + DVP_ALPHA_INTEGER, + DVP_RGB_INTEGER, + DVP_BGR_INTEGER, + DVP_LUMINANCE_INTEGER, + DVP_LUMINANCE_ALPHA_INTEGER, +} DVPBufferFormats; + +// Possible pixel component storage types for system memory buffers +typedef enum { + DVP_UNSIGNED_BYTE, + DVP_BYTE, + DVP_UNSIGNED_SHORT, + DVP_SHORT, + DVP_UNSIGNED_INT, + DVP_INT, + DVP_FLOAT, + DVP_HALF_FLOAT, + DVP_UNSIGNED_BYTE_3_3_2, + DVP_UNSIGNED_BYTE_2_3_3_REV, + DVP_UNSIGNED_SHORT_5_6_5, + DVP_UNSIGNED_SHORT_5_6_5_REV, + DVP_UNSIGNED_SHORT_4_4_4_4, + DVP_UNSIGNED_SHORT_4_4_4_4_REV, + DVP_UNSIGNED_SHORT_5_5_5_1, + DVP_UNSIGNED_SHORT_1_5_5_5_REV, + DVP_UNSIGNED_INT_8_8_8_8, + DVP_UNSIGNED_INT_8_8_8_8_REV, + DVP_UNSIGNED_INT_10_10_10_2, + DVP_UNSIGNED_INT_2_10_10_10_REV, +} DVPBufferTypes; + +// System memory descriptor describing the size and storage formats +// of the buffer +typedef struct DVPSysmemBufferDescRec { + uint32_t width; // Buffer Width + uint32_t height; // Buffer Height + uint32_t stride; // Stride + uint32_t size; // Specifies the surface size if + // format == DVP_BUFFER + DVPBufferFormats format; // see enum above + DVPBufferTypes type; // see enum above + void *bufAddr; // Buffer memory address +} DVPSysmemBufferDesc; + +// Flags specified at sync object creation: +// ---------------------------------------- +// Tells the implementation to use events wherever +// possible instead of software spin loops. Note if HW +// wait operations are supported by the implementation +// then events will not be used in the dvpMemcpy* +// functions. In such a case, events may still be used +// in dvpSyncObjClientWait* functions. +#define DVP_SYNC_OBJECT_FLAGS_USE_EVENTS 0x00000001 + +typedef struct DVPSyncObjectDescRec { + uint32_t *sem; // Location to write semaphore value + uint32_t flags; // See above DVP_SYNC_OBJECT_FLAGS_* bits + DVPStatus (*externalClientWaitFunc) (DVPSyncObjectHandle sync, + uint32_t value, + bool GEQ, // If true then the function should wait for the sync value to be + // greater than or equal to the value parameter. Otherwise just a + // straight forward equality comparison should be performed. + uint64_t timeout); + // If non-null, externalClientWaitFunc allows the DVP library + // to call the application to wait for a sync object to be + // released. This allows the application to create events, + // which can be triggered on device interrupts instead of + // using spin loops inside the DVP library. Upon succeeding + // the function must return DVP_STATUS_OK, non-zero for failure + // and DVP_STATUS_TIMEOUT on timeout. The externalClientWaitFunc should + // not alter the current GL or CUDA context state +} DVPSyncObjectDesc; + +// Time used when event timeouts should be ignored +#define DVP_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFFull + +typedef DVPStatus (DVPAPIENTRY * PFNDVPBEGIN) (void); +typedef DVPStatus (DVPAPIENTRY * PFNDVPEND) (void); +typedef DVPStatus (DVPAPIENTRY * PFNDVPCREATEBUFFER)(DVPSysmemBufferDesc *desc, DVPBufferHandle *hBuf); +typedef DVPStatus (DVPAPIENTRY * PFNDVPDESTROYBUFFER)(DVPBufferHandle hBuf); +typedef DVPStatus (DVPAPIENTRY * PFNDVPFREEBUFFER)(DVPBufferHandle gpuBufferHandle); +typedef DVPStatus (DVPAPIENTRY * PFNDVPMEMCPYLINED)(DVPBufferHandle srcBuffer, + DVPSyncObjectHandle srcSync, + uint32_t srcAcquireValue, + uint64_t timeout, + DVPBufferHandle dstBuffer, + DVPSyncObjectHandle dstSync, + uint32_t dstReleaseValue, + uint32_t startingLine, + uint32_t numberOfLines); +typedef DVPStatus (DVPAPIENTRY * PFNDVPMEMCPY)(DVPBufferHandle srcBuffer, + DVPSyncObjectHandle srcSync, + uint32_t srcAcquireValue, + uint64_t timeout, + DVPBufferHandle dstBuffer, + DVPSyncObjectHandle dstSync, + uint32_t dstReleaseValue, + uint32_t srcOffset, + uint32_t dstOffset, + uint32_t count); +typedef DVPStatus (DVPAPIENTRY * PFNDVPIMPORTSYNCOBJECT)(DVPSyncObjectDesc *desc, + DVPSyncObjectHandle *syncObject); +typedef DVPStatus (DVPAPIENTRY * PFNDVPFREESYNCOBJECT)(DVPSyncObjectHandle syncObject); +typedef DVPStatus (DVPAPIENTRY * PFNDVPGETREQUIREDCONSTANTSGLCTX)(uint32_t *bufferAddrAlignment, + uint32_t *bufferGPUStrideAlignment, + uint32_t *semaphoreAddrAlignment, + uint32_t *semaphoreAllocSize, + uint32_t *semaphorePayloadOffset, + uint32_t *semaphorePayloadSize); +typedef DVPStatus (DVPAPIENTRY * PFNDVPBINDTOGLCTX)(DVPBufferHandle hBuf); +typedef DVPStatus (DVPAPIENTRY * PFNDVPUNBINDFROMGLCTX)(DVPBufferHandle hBuf); +typedef DVPStatus (DVPAPIENTRY * PFNDVPMAPBUFFERENDAPI)(DVPBufferHandle gpuBufferHandle); +typedef DVPStatus (DVPAPIENTRY * PFNDVPMAPBUFFERWAITDVP)(DVPBufferHandle gpuBufferHandle); +typedef DVPStatus (DVPAPIENTRY * PFNDVPMAPBUFFERENDDVP)(DVPBufferHandle gpuBufferHandle); +typedef DVPStatus (DVPAPIENTRY * PFNDVPMAPBUFFERWAITAPI)(DVPBufferHandle gpuBufferHandle); +typedef DVPStatus (DVPAPIENTRY * PFNDVPCREATEGPUTEXTUREGL)(GLuint texID, + DVPBufferHandle *bufferHandle); + +// Flags supplied to the dvpInit* functions: +// +// DVP_DEVICE_FLAGS_SHARE_APP_CONTEXT is only supported for OpenGL +// contexts and is the only supported flag for CUDA. It allows for +// certain cases to be optimized by sharing the context +// of the application for the DVP operations. This removes the +// need to do certain synchronizations. See issue 5 for parallel +// issues. When used, the app's GL context must be current for all calls +// to the DVP library. +// the DVP library. +#define DVP_DEVICE_FLAGS_SHARE_APP_CONTEXT 0x000000001 + +//------------------------------------------------------------------------ +// Function: dvpInitGLContext +// +// To be called before any DVP resources are allocated. +// This call allows for specification of flags that may +// change the way DVP operations are performed. See above +// for the list of flags. +// +// The OpenGL context must be current at time of call. +// +// Parameters: flags[IN] - Buffer description structure +// +// Returns: DVP_STATUS_OK +// DVP_STATUS_INVALID_PARAMETER +// DVP_STATUS_ERROR +//------------------------------------------------------------------------ +extern DVPStatus dvpInitGLContext(uint32_t flags); + +//------------------------------------------------------------------------ +// Function: dvpCloseGLContext +// +// Function to be called when app closes to allow freeing +// of any DVP library allocated resources. +// +// The OpenGL context must be current at time of call. +// +// Parameters: none +// +// Returns: DVP_STATUS_OK +// DVP_STATUS_INVALID_PARAMETER +// DVP_STATUS_ERROR +//------------------------------------------------------------------------ +extern DVPStatus dvpCloseGLContext(); + +//------------------------------------------------------------------------ +// Function: dvpGetLibrayVersion +// +// Description: Returns the current version of the library +// +// Parameters: major[OUT] - returned major version +// minor[OUT] - returned minor version +// +// Returns: DVP_STATUS_OK +//------------------------------------------------------------------------ +extern DVPStatus dvpGetLibrayVersion(uint32_t *major, uint32_t *minor); + +//------------------------------------------------------------------------ +// Function: dvpBegin +// +// Description: dvpBegin must be called before any combination of DVP +// function calls dvpMemCpy*, dvpMapBufferWaitDVP, +// dvpSyncObjClientWait*, and dvpMapBufferEndDVP. After +// the last of these functions has been called is dvpEnd +// must be called. This allows for more efficient batched +// DVP operations. +// +// Parameters: none +// +// Returns: DVP_STATUS_OK +// DVP_STATUS_ERROR +//------------------------------------------------------------------------ +#define dvpBegin DVPAPI_GET_FUN(__dvpBegin) + +//------------------------------------------------------------------------ +// Function: dvpEnd +// +// Description: dvpEnd signals the end of a batch of DVP function calls +// that began with dvpBegin +// +// Parameters: none +// +// Returns: DVP_STATUS_OK +// DVP_STATUS_ERROR +//------------------------------------------------------------------------ +#define dvpEnd DVPAPI_GET_FUN(__dvpEnd) + + +//------------------------------------------------------------------------ +// Function: dvpCreateBuffer +// +// Description: Create a DVP buffer using system memory, wrapping a user +// passed pointer. The pointer must be aligned +// to values returned by dvpGetRequiredAlignments* +// +// Parameters: desc[IN] - Buffer description structure +// hBuf[OUT] - DVP Buffer handle +// +// Returns: DVP_STATUS_OK +// DVP_STATUS_INVALID_PARAMETER +// DVP_STATUS_ERROR +//------------------------------------------------------------------------ +#define dvpCreateBuffer DVPAPI_GET_FUN(__dvpCreateBuffer) + + +//------------------------------------------------------------------------ +// Function: dvpDestroyBuffer +// +// Description: Destroy a previously created DVP buffer. +// +// Parameters: hBuf[IN] - DVP Buffer handle +// +// Returns: DVP_STATUS_OK +// DVP_STATUS_INVALID_PARAMETER +// DVP_STATUS_ERROR +//------------------------------------------------------------------------ +#define dvpDestroyBuffer DVPAPI_GET_FUN(__dvpDestroyBuffer) + +//------------------------------------------------------------------------ +// Function: dvpFreeBuffer +// +// Description: dvpFreeBuffer frees the DVP buffer reference +// +// Parameters: gpuBufferHandle[IN] - DVP Buffer handle +// +// Returns: DVP_STATUS_OK +// DVP_STATUS_INVALID_PARAMETER +// DVP_STATUS_ERROR +//------------------------------------------------------------------------ +#define dvpFreeBuffer DVPAPI_GET_FUN(__dvpFreeBuffer) + +//------------------------------------------------------------------------ +// Function: dvpMemcpyLined +// +// Description: dvpMemcpyLined provides buffer copies between a +// DVP sysmem buffer and a graphics API texture (as opposed to +// a buffer type). Other buffer types (such +// as graphics API buffers) return DVP_STATUS_INVALID_PARAMETER. +// +// In addition, see "dvpMemcpy* general comments" above. +// +// Parameters: srcBuffer[IN] - src buffer handle +// srcSync[IN] - sync to acquire on before transfer +// srcAcquireValue[IN] - value to acquire on before transfer +// timeout[IN] - time out value in nanoseconds. +// dstBuffer[IN] - src buffer handle +// dstSync[IN] - sync to release on transfer completion +// dstReleaseValue[IN] - value to release on completion +// startingLine[IN] - starting line of buffer +// numberOfLines[IN] - number of lines to copy +// +// Returns: DVP_STATUS_OK +// DVP_STATUS_INVALID_PARAMETER +// DVP_STATUS_ERROR +// +// GL state effected: The following GL state may be altered by this +// function (not relevant if no GL source or destination +// is used): +// -GL_PACK_SKIP_ROWS, GL_PACK_SKIP_PIXELS, +// GL_PACK_ROW_LENGTH +// -The buffer bound to GL_PIXEL_PACK_BUFFER +// -The current bound framebuffer (GL_FRAMEBUFFER_EXT) +// -GL_UNPACK_SKIP_ROWS, GL_UNPACK_SKIP_PIXELS, +// GL_UNPACK_ROW_LENGTH +// -The buffer bound to GL_PIXEL_UNPACK_BUFFER +// -The texture bound to GL_TEXTURE_2D +//------------------------------------------------------------------------ +#define dvpMemcpyLined DVPAPI_GET_FUN(__dvpMemcpyLined) + + +//------------------------------------------------------------------------ +// Function: dvpMemcpy +// +// Description: dvpMemcpy provides buffer copies between a +// DVP sysmem buffer and a graphics API pure buffer (as +// opposed to a texture type). Other buffer types (such +// as graphics API textures) return +// DVP_STATUS_INVALID_PARAMETER. +// +// The start address of the srcBuffer is given by srcOffset +// and the dstBuffer start address is given by dstOffset. +// +// In addition, see "dvpMemcpy* general comments" above. +// +// Parameters: srcBuffer[IN] - src buffer handle +// srcSync[IN] - sync to acquire on before transfer +// srcAcquireValue[IN] - value to acquire on before transfer +// timeout[IN] - time out value in nanoseconds. +// dstBuffer[IN] - src buffer handle +// dstSync[IN] - sync to release on completion +// dstReleaseValue[IN] - value to release on completion +// uint32_t srcOffset[IN] - byte offset of srcBuffer +// uint32_t dstOffset[IN] - byte offset of dstBuffer +// uint32_t count[IN] - number of bytes to copy +// +// Returns: DVP_STATUS_OK +// DVP_STATUS_INVALID_PARAMETER +// DVP_STATUS_ERROR +// +// GL state effected: The following GL state may be altered by this +// function (not relevant if no GL source or destination +// is used): +// - The buffer bound to GL_COPY_WRITE_BUFFER +// - The buffer bound to GL_COPY_READ_BUFFER +// +//------------------------------------------------------------------------ +#define dvpMemcpy DVPAPI_GET_FUN(__dvpMemcpy) + +//------------------------------------------------------------------------ +// Function: dvpImportSyncObject +// +// Description: dvpImportSyncObject creates a DVPSyncObject from the +// DVPSyncObjectDesc. Note that a sync object is not +// supported for copy operations targeting different APIs. +// This means, for example, it is illegal to call dvpMemCpy* +// for source or target GL texture with sync object A and +// then later use that same sync object in dvpMemCpy* +// operation for a source or target CUDA buffer. The same +// semaphore memory can still be used for two different sync +// objects. +// +// Parameters: desc[IN] - data describing the sync object +// syncObject[OUT] - handle to sync object +// +// Returns: DVP_STATUS_OK +// DVP_STATUS_INVALID_PARAMETER +// DVP_STATUS_ERROR +//------------------------------------------------------------------------ +#define dvpImportSyncObject DVPAPI_GET_FUN(__dvpImportSyncObject) + +//------------------------------------------------------------------------ +// Function: dvpFreeSyncObject +// +// Description: dvpFreeSyncObject waits for any outstanding releases on +// this sync object before freeing the resources allocated for +// the specified sync object. The application must make sure +// any outstanding acquire operations have already been +// completed. +// +// If OpenGL is being used and the app's GL context is being +// shared (via the DVP_DEVICE_FLAGS_SHARE_APP_CONTEXT flag), +// then dvpFreeSyncObject needs to be called while each context, +// on which the sync object was used, is current. If +// DVP_DEVICE_FLAGS_SHARE_APP_CONTEXT is used and there are out +// standing contexts from which this sync object must be free'd +// then dvpFreeSyncObject will return DVP_STATUS_SYNC_STILL_BOUND. +// +// Parameters: syncObject[IN] - handle to sync object to be free'd +// +// Returns: DVP_STATUS_OK +// DVP_STATUS_INVALID_PARAMETER +// DVP_STATUS_ERROR +// DVP_STATUS_SYNC_STILL_BOUND +//------------------------------------------------------------------------ +#define dvpFreeSyncObject DVPAPI_GET_FUN(__dvpFreeSyncObject) + + +//------------------------------------------------------------------------ +// Function: dvpMapBufferEndAPI +// +// Description: Tells DVP to setup a signal for this buffer in the +// callers API context or device. The signal follows all +// previous API operations up to this point and, thus, +// allows subsequent DVP calls to know when then this buffer +// is ready for use within the DVP library. This function +// would be followed by a call to dvpMapBufferWaitDVP to +// synchronize rendering in the API stream and the DVP +// stream. +// +// If OpenGL or CUDA is used, the OpenGL/CUDA context +// must be current at time of call. +// +// The use of dvpMapBufferEndAPI is NOT recommended for +// CUDA synchronisation, as it is more optimal to use a +// applcation CUDA stream in conjunction with +// dvpMapBufferEndCUDAStream. This allows the driver to +// do optimisations, such as parllelise the copy operations +// and compute. +// +// This must be called outside the dvpBegin/dvpEnd pair. In +// addition, this call is not thread safe and must be called +// from or fenced against the rendering thread associated with +// the context or device. +// +// Parameters: gpuBufferHandle[IN] - buffer to track +// +// Returns: DVP_STATUS_OK +// DVP_STATUS_INVALID_PARAMETER +// DVP_STATUS_ERROR +// DVP_STATUS_UNSIGNALED - returned if the API is +// unable to place a signal in the API context queue +//------------------------------------------------------------------------ +#define dvpMapBufferEndAPI DVPAPI_GET_FUN(__dvpMapBufferEndAPI) + +//------------------------------------------------------------------------ +// Function: dvpMapBufferEndAPI +// +// Description: Tells DVP to setup a signal for this buffer in the +// callers API context or device. The signal follows all +// previous API operations up to this point and, thus, +// allows subsequent DVP calls to know when then this buffer +// is ready for use within the DVP library. This function +// would be followed by a call to dvpMapBufferWaitDVP to +// synchronize rendering in the API stream and the DVP +// stream. +// +// If OpenGL or CUDA is used, the OpenGL/CUDA context +// must be current at time of call. +// +// The use of dvpMapBufferEndAPI is NOT recommended for +// CUDA synchronisation, as it is more optimal to use a +// applcation CUDA stream in conjunction with +// dvpMapBufferEndCUDAStream. This allows the driver to +// do optimisations, such as parllelise the copy operations +// and compute. +// +// This must be called outside the dvpBegin/dvpEnd pair. In +// addition, this call is not thread safe and must be called +// from or fenced against the rendering thread associated with +// the context or device. +// +// Parameters: gpuBufferHandle[IN] - buffer to track +// +// Returns: DVP_STATUS_OK +// DVP_STATUS_INVALID_PARAMETER +// DVP_STATUS_ERROR +// DVP_STATUS_UNSIGNALED - returned if the API is +// unable to place a signal in the API context queue +//------------------------------------------------------------------------ +#define dvpMapBufferEndAPI DVPAPI_GET_FUN(__dvpMapBufferEndAPI) + +//------------------------------------------------------------------------ +// Function: dvpMapBufferWaitDVP +// +// Description: Tells DVP to make the DVP stream wait for a previous +// signal triggered by a dvpMapBufferEndAPI call. +// +// This must be called inside the dvpBegin/dvpEnd pair. +// +// Parameters: gpuBufferHandle[IN] - buffer to track +// +// Returns: DVP_STATUS_OK +// DVP_STATUS_INVALID_PARAMETER +// DVP_STATUS_ERROR +//------------------------------------------------------------------------ +#define dvpMapBufferWaitDVP DVPAPI_GET_FUN(__dvpMapBufferWaitDVP) + +//------------------------------------------------------------------------ +// Function: dvpMapBufferEndDVP +// +// Description: Tells DVP to setup a signal for this buffer after +// DVP operations are complete. The signal allows +// the API to know when then this buffer is +// ready for use within a API stream. This function would +// be followed by a call to dvpMapBufferWaitAPI to +// synchronize copies in the DVP stream and the API +// rendering stream. +// +// This must be called inside the dvpBegin/dvpEnd pair. +// +// Parameters: gpuBufferHandle[IN] - buffer to track +// +// Returns: DVP_STATUS_OK +// DVP_STATUS_INVALID_PARAMETER +// DVP_STATUS_ERROR +//------------------------------------------------------------------------ +#define dvpMapBufferEndDVP DVPAPI_GET_FUN(__dvpMapBufferEndDVP) + +//------------------------------------------------------------------------ +// Function: dvpMapBufferWaitAPI +// +// Description: Tells DVP to make the current API context or device to +// wait for a previous signal triggered by a +// dvpMapBufferEndDVP call. +// +// The use of dvpMapBufferWaitCUDAStream is NOT recommended for +// CUDA synchronisation, as it is more optimal to use a +// applcation CUDA stream in conjunction with +// dvpMapBufferEndCUDAStream. This allows the driver to +// do optimisations, such as parllelise the copy operations +// and compute. +// +// If OpenGL or CUDA is used, the OpenGL/CUDA context +// must be current at time of call. +// +// This must be called outside the dvpBegin/dvpEnd pair. In +// addition, this call is not thread safe and must be called +// from or fenced against the rendering thread associated with +// the context or device. +// +// Parameters: gpuBufferHandle[IN] - buffer to track +// +// Returns: DVP_STATUS_OK +// DVP_STATUS_INVALID_PARAMETER +// DVP_STATUS_ERROR +//------------------------------------------------------------------------ +#define dvpMapBufferWaitAPI DVPAPI_GET_FUN(__dvpMapBufferWaitAPI) + +//------------------------------------------------------------------------ +// If the multiple GL contexts used in the application access the same +// sysmem buffers, then application must create those GL contexts with +// display list shared. +//------------------------------------------------------------------------ +#define dvpBindToGLCtx DVPAPI_GET_FUN(__dvpBindToGLCtx) +#define dvpGetRequiredConstantsGLCtx DVPAPI_GET_FUN(__dvpGetRequiredConstantsGLCtx) +#define dvpCreateGPUTextureGL DVPAPI_GET_FUN(__dvpCreateGPUTextureGL) +#define dvpUnbindFromGLCtx DVPAPI_GET_FUN(__dvpUnbindFromGLCtx) + + +DVPAPI PFNDVPBEGIN __dvpBegin; +DVPAPI PFNDVPEND __dvpEnd; +DVPAPI PFNDVPCREATEBUFFER __dvpCreateBuffer; +DVPAPI PFNDVPDESTROYBUFFER __dvpDestroyBuffer; +DVPAPI PFNDVPFREEBUFFER __dvpFreeBuffer; +DVPAPI PFNDVPMEMCPYLINED __dvpMemcpyLined; +DVPAPI PFNDVPMEMCPY __dvpMemcpy; +DVPAPI PFNDVPIMPORTSYNCOBJECT __dvpImportSyncObject; +DVPAPI PFNDVPFREESYNCOBJECT __dvpFreeSyncObject; +DVPAPI PFNDVPMAPBUFFERENDAPI __dvpMapBufferEndAPI; +DVPAPI PFNDVPMAPBUFFERWAITDVP __dvpMapBufferWaitDVP; +DVPAPI PFNDVPMAPBUFFERENDDVP __dvpMapBufferEndDVP; +DVPAPI PFNDVPMAPBUFFERWAITAPI __dvpMapBufferWaitAPI; + + +//------------------------------------------------------------------------ +// If the multiple GL contexts used in the application access the same +// sysmem buffers, then application must create those GL contexts with +// display list shared. +//------------------------------------------------------------------------ +DVPAPI PFNDVPBINDTOGLCTX __dvpBindToGLCtx; +DVPAPI PFNDVPGETREQUIREDCONSTANTSGLCTX __dvpGetRequiredConstantsGLCtx; +DVPAPI PFNDVPCREATEGPUTEXTUREGL __dvpCreateGPUTextureGL; +DVPAPI PFNDVPUNBINDFROMGLCTX __dvpUnbindFromGLCtx; + +#define DVPAPI_GET_FUN(x) x + +#endif // WIN32 + +#endif // __DVPAPI_H__ + diff --git a/source/blenderplayer/CMakeLists.txt b/source/blenderplayer/CMakeLists.txt index 6f32d50c2fe..206007b8d8b 100644 --- a/source/blenderplayer/CMakeLists.txt +++ b/source/blenderplayer/CMakeLists.txt @@ -215,6 +215,14 @@ endif() list(APPEND BLENDER_SORTED_LIBS bf_intern_locale) endif() + if(WITH_GAMEENGINE_DECKLINK) + list(APPEND BLENDER_SORTED_LIBS bf_intern_decklink) + endif() + + if(WIN32) + list(APPEND BLENDER_SORTED_LIBS bf_intern_gpudirect) + endif() + if(WITH_OPENSUBDIV) list(APPEND BLENDER_SORTED_LIBS bf_intern_opensubdiv) endif() diff --git a/source/gameengine/VideoTexture/CMakeLists.txt b/source/gameengine/VideoTexture/CMakeLists.txt index 4be9a9abe5c..1eb09b02e05 100644 --- a/source/gameengine/VideoTexture/CMakeLists.txt +++ b/source/gameengine/VideoTexture/CMakeLists.txt @@ -45,6 +45,9 @@ set(INC ../../../intern/glew-mx ../../../intern/guardedalloc ../../../intern/string + ../../../intern/decklink + ../../../intern/gpudirect + ../../../intern/atomic ) set(INC_SYS @@ -68,8 +71,10 @@ set(SRC ImageViewport.cpp PyTypeList.cpp Texture.cpp + DeckLink.cpp VideoBase.cpp VideoFFmpeg.cpp + VideoDeckLink.cpp blendVideoTex.cpp BlendType.h @@ -87,8 +92,10 @@ set(SRC ImageViewport.h PyTypeList.h Texture.h + DeckLink.h VideoBase.h VideoFFmpeg.h + VideoDeckLink.h ) if(WITH_CODEC_FFMPEG) @@ -100,7 +107,13 @@ if(WITH_CODEC_FFMPEG) remove_strict_flags_file( VideoFFmpeg.cpp + VideoDeckLink + DeckLink ) endif() +if(WITH_GAMEENGINE_DECKLINK) + add_definitions(-DWITH_GAMEENGINE_DECKLINK) +endif() + blender_add_lib(ge_videotex "${SRC}" "${INC}" "${INC_SYS}") diff --git a/source/gameengine/VideoTexture/Common.h b/source/gameengine/VideoTexture/Common.h index 90f7e66452a..22ea177addc 100644 --- a/source/gameengine/VideoTexture/Common.h +++ b/source/gameengine/VideoTexture/Common.h @@ -36,7 +36,8 @@ #define NULL 0 #endif -#ifndef HRESULT +#ifndef _HRESULT_DEFINED +#define _HRESULT_DEFINED #define HRESULT long #endif diff --git a/source/gameengine/VideoTexture/DeckLink.cpp b/source/gameengine/VideoTexture/DeckLink.cpp new file mode 100644 index 00000000000..0506756ef2d --- /dev/null +++ b/source/gameengine/VideoTexture/DeckLink.cpp @@ -0,0 +1,813 @@ +/* + * ***** BEGIN GPL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * +* The Original Code is Copyright (C) 2015, Blender Foundation +* All rights reserved. +* +* The Original Code is: all of this file. +* +* Contributor(s): Blender Foundation. + * + * ***** END GPL LICENSE BLOCK ***** + */ + +/** \file gameengine/VideoTexture/Texture.cpp + * \ingroup bgevideotex + */ + +#ifdef WITH_GAMEENGINE_DECKLINK + +// implementation + +// FFmpeg defines its own version of stdint.h on Windows. +// Decklink needs FFmpeg, so it uses its version of stdint.h +// this is necessary for INT64_C macro +#ifndef __STDC_CONSTANT_MACROS +#define __STDC_CONSTANT_MACROS +#endif +// this is necessary for UINTPTR_MAX (used by atomic-ops) +#ifndef __STDC_LIMIT_MACROS +#define __STDC_LIMIT_MACROS +#endif + +#include "atomic_ops.h" + +#include "EXP_PyObjectPlus.h" +#include "KX_KetsjiEngine.h" +#include "KX_PythonInit.h" +#include "DeckLink.h" + +#include <memory.h> + +// macro for exception handling and logging +#define CATCH_EXCP catch (Exception & exp) \ +{ exp.report(); return NULL; } + +static struct +{ + const char *name; + BMDDisplayMode mode; +} sModeStringTab[] = { + { "NTSC", bmdModeNTSC }, + { "NTSC2398", bmdModeNTSC2398 }, + { "PAL", bmdModePAL }, + { "NTSCp", bmdModeNTSCp }, + { "PALp", bmdModePALp }, + + /* HD 1080 Modes */ + + { "HD1080p2398", bmdModeHD1080p2398 }, + { "HD1080p24", bmdModeHD1080p24 }, + { "HD1080p25", bmdModeHD1080p25 }, + { "HD1080p2997", bmdModeHD1080p2997 }, + { "HD1080p30", bmdModeHD1080p30 }, + { "HD1080i50", bmdModeHD1080i50 }, + { "HD1080i5994", bmdModeHD1080i5994 }, + { "HD1080i6000", bmdModeHD1080i6000 }, + { "HD1080p50", bmdModeHD1080p50 }, + { "HD1080p5994", bmdModeHD1080p5994 }, + { "HD1080p6000", bmdModeHD1080p6000 }, + + /* HD 720 Modes */ + + { "HD720p50", bmdModeHD720p50 }, + { "HD720p5994", bmdModeHD720p5994 }, + { "HD720p60", bmdModeHD720p60 }, + + /* 2k Modes */ + + { "2k2398", bmdMode2k2398 }, + { "2k24", bmdMode2k24 }, + { "2k25", bmdMode2k25 }, + + /* DCI Modes (output only) */ + + { "2kDCI2398", bmdMode2kDCI2398 }, + { "2kDCI24", bmdMode2kDCI24 }, + { "2kDCI25", bmdMode2kDCI25 }, + + /* 4k Modes */ + + { "4K2160p2398", bmdMode4K2160p2398 }, + { "4K2160p24", bmdMode4K2160p24 }, + { "4K2160p25", bmdMode4K2160p25 }, + { "4K2160p2997", bmdMode4K2160p2997 }, + { "4K2160p30", bmdMode4K2160p30 }, + { "4K2160p50", bmdMode4K2160p50 }, + { "4K2160p5994", bmdMode4K2160p5994 }, + { "4K2160p60", bmdMode4K2160p60 }, + // sentinel + { NULL } +}; + +static struct +{ + const char *name; + BMDPixelFormat format; +} sFormatStringTab[] = { + { "8BitYUV", bmdFormat8BitYUV }, + { "10BitYUV", bmdFormat10BitYUV }, + { "8BitARGB", bmdFormat8BitARGB }, + { "8BitBGRA", bmdFormat8BitBGRA }, + { "10BitRGB", bmdFormat10BitRGB }, + { "12BitRGB", bmdFormat12BitRGB }, + { "12BitRGBLE", bmdFormat12BitRGBLE }, + { "10BitRGBXLE", bmdFormat10BitRGBXLE }, + { "10BitRGBX", bmdFormat10BitRGBX }, + // sentinel + { NULL } +}; + +ExceptionID DeckLinkBadDisplayMode, DeckLinkBadPixelFormat; +ExpDesc DeckLinkBadDisplayModeDesc(DeckLinkBadDisplayMode, "Invalid or unsupported display mode"); +ExpDesc DeckLinkBadPixelFormatDesc(DeckLinkBadPixelFormat, "Invalid or unsupported pixel format"); + +HRESULT decklink_ReadDisplayMode(const char *format, size_t len, BMDDisplayMode *displayMode) +{ + int i; + + if (len == 0) + len = strlen(format); + for (i = 0; sModeStringTab[i].name != NULL; i++) { + if (strlen(sModeStringTab[i].name) == len && + !strncmp(sModeStringTab[i].name, format, len)) + { + *displayMode = sModeStringTab[i].mode; + return S_OK; + } + } + if (len != 4) + THRWEXCP(DeckLinkBadDisplayMode, S_OK); + // assume the user entered directly the mode value as a 4 char string + *displayMode = (BMDDisplayMode)((((uint32_t)format[0]) << 24) + (((uint32_t)format[1]) << 16) + (((uint32_t)format[2]) << 8) + ((uint32_t)format[3])); + return S_OK; +} + +HRESULT decklink_ReadPixelFormat(const char *format, size_t len, BMDPixelFormat *pixelFormat) +{ + int i; + + if (!len) + len = strlen(format); + for (i = 0; sFormatStringTab[i].name != NULL; i++) { + if (strlen(sFormatStringTab[i].name) == len && + !strncmp(sFormatStringTab[i].name, format, len)) + { + *pixelFormat = sFormatStringTab[i].format; + return S_OK; + } + } + if (len != 4) + THRWEXCP(DeckLinkBadPixelFormat, S_OK); + // assume the user entered directly the mode value as a 4 char string + *pixelFormat = (BMDPixelFormat)((((uint32_t)format[0]) << 24) + (((uint32_t)format[1]) << 16) + (((uint32_t)format[2]) << 8) + ((uint32_t)format[3])); + return S_OK; +} + +class DeckLink3DFrameWrapper : public IDeckLinkVideoFrame, IDeckLinkVideoFrame3DExtensions +{ +public: + // IUnknown + virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, LPVOID *ppv) + { + if (!memcmp(&iid, &IID_IDeckLinkVideoFrame3DExtensions, sizeof(iid))) { + if (mpRightEye) { + *ppv = (IDeckLinkVideoFrame3DExtensions*)this; + return S_OK; + } + } + return E_NOTIMPL; + } + virtual ULONG STDMETHODCALLTYPE AddRef(void) { return 1U; } + virtual ULONG STDMETHODCALLTYPE Release(void) { return 1U; } + // IDeckLinkVideoFrame + virtual long STDMETHODCALLTYPE GetWidth(void) { return mpLeftEye->GetWidth(); } + virtual long STDMETHODCALLTYPE GetHeight(void) { return mpLeftEye->GetHeight(); } + virtual long STDMETHODCALLTYPE GetRowBytes(void) { return mpLeftEye->GetRowBytes(); } + virtual BMDPixelFormat STDMETHODCALLTYPE GetPixelFormat(void) { return mpLeftEye->GetPixelFormat(); } + virtual BMDFrameFlags STDMETHODCALLTYPE GetFlags(void) { return mpLeftEye->GetFlags(); } + virtual HRESULT STDMETHODCALLTYPE GetBytes(void **buffer) { return mpLeftEye->GetBytes(buffer); } + virtual HRESULT STDMETHODCALLTYPE GetTimecode(BMDTimecodeFormat format,IDeckLinkTimecode **timecode) + { return mpLeftEye->GetTimecode(format, timecode); } + virtual HRESULT STDMETHODCALLTYPE GetAncillaryData(IDeckLinkVideoFrameAncillary **ancillary) + { return mpLeftEye->GetAncillaryData(ancillary); } + // IDeckLinkVideoFrame3DExtensions + virtual BMDVideo3DPackingFormat STDMETHODCALLTYPE Get3DPackingFormat(void) + { + return bmdVideo3DPackingLeftOnly; + } + virtual HRESULT STDMETHODCALLTYPE GetFrameForRightEye( + /* [out] */ IDeckLinkVideoFrame **rightEyeFrame) + { + mpRightEye->AddRef(); + *rightEyeFrame = mpRightEye; + return S_OK; + } + // Constructor + DeckLink3DFrameWrapper(IDeckLinkVideoFrame *leftEye, IDeckLinkVideoFrame *rightEye) + { + mpLeftEye = leftEye; + mpRightEye = rightEye; + } + // no need for a destructor, it's just a wrapper +private: + IDeckLinkVideoFrame *mpLeftEye; + IDeckLinkVideoFrame *mpRightEye; +}; + +static void decklink_Reset(DeckLink *self) +{ + self->m_lastClock = 0.0; + self->mDLOutput = NULL; + self->mUse3D = false; + self->mDisplayMode = bmdModeUnknown; + self->mKeyingSupported = false; + self->mHDKeyingSupported = false; + self->mSize[0] = 0; + self->mSize[1] = 0; + self->mFrameSize = 0; + self->mLeftFrame = NULL; + self->mRightFrame = NULL; + self->mKeyer = NULL; + self->mUseKeying = false; + self->mKeyingLevel = 255; + self->mUseExtend = false; +} + +#ifdef __BIG_ENDIAN__ +#define CONV_PIXEL(i) ((((i)>>16)&0xFF00)+(((i)&0xFF00)<<16)+((i)&0xFF00FF)) +#else +#define CONV_PIXEL(i) ((((i)&0xFF)<<16)+(((i)>>16)&0xFF)+((i)&0xFF00FF00)) +#endif + +// adapt the pixel format and picture size from VideoTexture (RGBA) to DeckLink (BGRA) +static void decklink_ConvImage(uint32_t *dest, const short *destSize, const uint32_t *source, const short *srcSize, bool extend) +{ + short w, h, x, y; + const uint32_t *s; + uint32_t *d, p; + bool sameSize = (destSize[0] == srcSize[0] && destSize[1] == srcSize[1]); + + if (sameSize || !extend) { + // here we convert pixel by pixel + w = (destSize[0] < srcSize[0]) ? destSize[0] : srcSize[0]; + h = (destSize[1] < srcSize[1]) ? destSize[1] : srcSize[1]; + for (y = 0; y < h; ++y) { + s = source + y*srcSize[0]; + d = dest + y*destSize[0]; + for (x = 0; x < w; ++x, ++s, ++d) { + *d = CONV_PIXEL(*s); + } + } + } + else { + // here we scale + // interpolation accumulator + int accHeight = srcSize[1] >> 1; + d = dest; + s = source; + // process image rows + for (y = 0; y < srcSize[1]; ++y) { + // increase height accum + accHeight += destSize[1]; + // if pixel row has to be drawn + if (accHeight >= srcSize[1]) { + // decrease accum + accHeight -= srcSize[1]; + // width accum + int accWidth = srcSize[0] >> 1; + // process row + for (x = 0; x < srcSize[0]; ++x, ++s) { + // increase width accum + accWidth += destSize[0]; + // convert pixel + p = CONV_PIXEL(*s); + // if pixel has to be drown one or more times + while (accWidth >= srcSize[0]) { + // decrease accum + accWidth -= srcSize[0]; + *d++ = p; + } + } + // if there should be more identical lines + while (accHeight >= srcSize[1]) { + accHeight -= srcSize[1]; + // copy previous line + memcpy(d, d - destSize[0], 4 * destSize[0]); + d += destSize[0]; + } + } + else { + // if we skip a source line + s += srcSize[0]; + } + } + } +} + +// DeckLink object allocation +static PyObject *DeckLink_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + // allocate object + DeckLink * self = reinterpret_cast<DeckLink*>(type->tp_alloc(type, 0)); + // initialize object structure + decklink_Reset(self); + // m_leftEye is a python object, it's handled by python + self->m_leftEye = NULL; + self->m_rightEye = NULL; + // return allocated object + return reinterpret_cast<PyObject*>(self); +} + + +// forward declaration +PyObject *DeckLink_close(DeckLink *self); +int DeckLink_setSource(DeckLink *self, PyObject *value, void *closure); + + +// DeckLink object deallocation +static void DeckLink_dealloc(DeckLink *self) +{ + // release renderer + Py_XDECREF(self->m_leftEye); + // close decklink + PyObject *ret = DeckLink_close(self); + Py_DECREF(ret); + // release object + Py_TYPE((PyObject *)self)->tp_free((PyObject *)self); +} + + +ExceptionID AutoDetectionNotAvail, DeckLinkOpenCard, DeckLinkBadFormat, DeckLinkInternalError; +ExpDesc AutoDetectionNotAvailDesc(AutoDetectionNotAvail, "Auto detection not yet available"); +ExpDesc DeckLinkOpenCardDesc(DeckLinkOpenCard, "Cannot open card for output"); +ExpDesc DeckLinkBadFormatDesc(DeckLinkBadFormat, "Invalid or unsupported output format, use <mode>[/3D]"); +ExpDesc DeckLinkInternalErrorDesc(DeckLinkInternalError, "DeckLink API internal error, please report"); + +// DeckLink object initialization +static int DeckLink_init(DeckLink *self, PyObject *args, PyObject *kwds) +{ + IDeckLinkIterator* pIterator; + IDeckLinkAttributes* pAttributes; + IDeckLinkDisplayModeIterator* pDisplayModeIterator; + IDeckLinkDisplayMode* pDisplayMode; + IDeckLink* pDL; + char* p3D; + BOOL flag; + size_t len; + int i; + uint32_t displayFlags; + BMDVideoOutputFlags outputFlags; + BMDDisplayModeSupport support; + uint32_t* bytes; + + + // material ID + short cardIdx = 0; + // texture ID + char *format = NULL; + + static const char *kwlist[] = {"cardIdx", "format", NULL}; + // get parameters + if (!PyArg_ParseTupleAndKeywords(args, kwds, "|hs", + const_cast<char**>(kwlist), &cardIdx, &format)) + return -1; + + try { + if (format == NULL) { + THRWEXCP(AutoDetectionNotAvail, S_OK); + } + + if ((p3D = strchr(format, '/')) != NULL && strcmp(p3D, "/3D")) + THRWEXCP(DeckLinkBadFormat, S_OK); + self->mUse3D = (p3D) ? true : false; + // read the mode + len = (p3D) ? (size_t)(p3D - format) : strlen(format); + // throws if bad mode + decklink_ReadDisplayMode(format, len, &self->mDisplayMode); + + pIterator = BMD_CreateDeckLinkIterator(); + pDL = NULL; + if (pIterator) { + i = 0; + while (pIterator->Next(&pDL) == S_OK) { + if (i == cardIdx) { + break; + } + i++; + pDL->Release(); + pDL = NULL; + } + pIterator->Release(); + } + + if (!pDL) { + THRWEXCP(DeckLinkOpenCard, S_OK); + } + // detect the capabilities + if (pDL->QueryInterface(IID_IDeckLinkAttributes, (void**)&pAttributes) == S_OK) { + if (pAttributes->GetFlag(BMDDeckLinkSupportsInternalKeying, &flag) == S_OK && flag) { + self->mKeyingSupported = true; + if (pAttributes->GetFlag(BMDDeckLinkSupportsHDKeying, &flag) == S_OK && flag) { + self->mHDKeyingSupported = true; + } + } + pAttributes->Release(); + } + + if (pDL->QueryInterface(IID_IDeckLinkOutput, (void**)&self->mDLOutput) != S_OK) { + self->mDLOutput = NULL; + } + if (self->mKeyingSupported) { + pDL->QueryInterface(IID_IDeckLinkKeyer, (void **)&self->mKeyer); + } + // we don't need the device anymore, release to avoid leaking + pDL->Release(); + + if (!self->mDLOutput) + THRWEXCP(DeckLinkOpenCard, S_OK); + + if (self->mDLOutput->GetDisplayModeIterator(&pDisplayModeIterator) != S_OK) + THRWEXCP(DeckLinkInternalError, S_OK); + + displayFlags = (self->mUse3D) ? bmdDisplayModeSupports3D : 0; + outputFlags = (self->mUse3D) ? bmdVideoOutputDualStream3D : bmdVideoOutputFlagDefault; + pDisplayMode = NULL; + i = 0; + while (pDisplayModeIterator->Next(&pDisplayMode) == S_OK) { + if (pDisplayMode->GetDisplayMode() == self->mDisplayMode + && (pDisplayMode->GetFlags() & displayFlags) == displayFlags) { + if (self->mDLOutput->DoesSupportVideoMode(self->mDisplayMode, bmdFormat8BitBGRA, outputFlags, &support, NULL) != S_OK || + support == bmdDisplayModeNotSupported) + { + printf("Warning: DeckLink card %d reports no BGRA support, proceed anyway\n", cardIdx); + } + break; + } + pDisplayMode->Release(); + pDisplayMode = NULL; + i++; + } + pDisplayModeIterator->Release(); + + if (!pDisplayMode) + THRWEXCP(DeckLinkBadFormat, S_OK); + self->mSize[0] = pDisplayMode->GetWidth(); + self->mSize[1] = pDisplayMode->GetHeight(); + self->mFrameSize = 4*self->mSize[0]*self->mSize[1]; + pDisplayMode->Release(); + if (self->mDLOutput->EnableVideoOutput(self->mDisplayMode, outputFlags) != S_OK) + // this shouldn't fail + THRWEXCP(DeckLinkOpenCard, S_OK); + + if (self->mDLOutput->CreateVideoFrame(self->mSize[0], self->mSize[1], self->mSize[0] * 4, bmdFormat8BitBGRA, bmdFrameFlagFlipVertical, &self->mLeftFrame) != S_OK) + THRWEXCP(DeckLinkInternalError, S_OK); + // clear alpha channel in the frame buffer + self->mLeftFrame->GetBytes((void **)&bytes); + memset(bytes, 0, self->mFrameSize); + if (self->mUse3D) { + if (self->mDLOutput->CreateVideoFrame(self->mSize[0], self->mSize[1], self->mSize[0] * 4, bmdFormat8BitBGRA, bmdFrameFlagFlipVertical, &self->mRightFrame) != S_OK) + THRWEXCP(DeckLinkInternalError, S_OK); + // clear alpha channel in the frame buffer + self->mRightFrame->GetBytes((void **)&bytes); + memset(bytes, 0, self->mFrameSize); + } + } + catch (Exception & exp) + { + printf("DeckLink: exception when opening card %d: %s\n", cardIdx, exp.what()); + exp.report(); + // normally, the object should be deallocated + return -1; + } + // initialization succeeded + return 0; +} + + +// close added decklink +PyObject *DeckLink_close(DeckLink * self) +{ + if (self->mLeftFrame) + self->mLeftFrame->Release(); + if (self->mRightFrame) + self->mRightFrame->Release(); + if (self->mKeyer) + self->mKeyer->Release(); + if (self->mDLOutput) + self->mDLOutput->Release(); + decklink_Reset(self); + Py_RETURN_NONE; +} + + +// refresh decklink key frame +static PyObject *DeckLink_refresh(DeckLink *self, PyObject *args) +{ + // get parameter - refresh source + PyObject *param; + double ts = -1.0; + + if (!PyArg_ParseTuple(args, "O|d:refresh", ¶m, &ts) || !PyBool_Check(param)) { + // report error + PyErr_SetString(PyExc_TypeError, "The value must be a bool"); + return NULL; + } + // some trick here: we are in the business of loading a key frame in decklink, + // no use to do it if we are still in the same rendering frame. + // We find this out by looking at the engine current clock time + KX_KetsjiEngine* engine = KX_GetActiveEngine(); + if (engine->GetClockTime() != self->m_lastClock) + { + self->m_lastClock = engine->GetClockTime(); + // set source refresh + bool refreshSource = (param == Py_True); + uint32_t *leftEye = NULL; + uint32_t *rightEye = NULL; + // try to process key frame from source + try { + // check if optimization is possible + if (self->m_leftEye != NULL) { + ImageBase *leftImage = self->m_leftEye->m_image; + short * srcSize = leftImage->getSize(); + self->mLeftFrame->GetBytes((void **)&leftEye); + if (srcSize[0] == self->mSize[0] && srcSize[1] == self->mSize[1]) + { + // buffer has same size, can load directly + if (!leftImage->loadImage(leftEye, self->mFrameSize, GL_BGRA, ts)) + leftEye = NULL; + } + else { + // scaling is required, go the hard way + unsigned int *src = leftImage->getImage(0, ts); + if (src != NULL) + decklink_ConvImage(leftEye, self->mSize, src, srcSize, self->mUseExtend); + else + leftEye = NULL; + } + } + if (leftEye) { + if (self->mUse3D && self->m_rightEye != NULL) { + ImageBase *rightImage = self->m_rightEye->m_image; + short * srcSize = rightImage->getSize(); + self->mRightFrame->GetBytes((void **)&rightEye); + if (srcSize[0] == self->mSize[0] && srcSize[1] == self->mSize[1]) + { + // buffer has same size, can load directly + rightImage->loadImage(rightEye, self->mFrameSize, GL_BGRA, ts); + } + else { + // scaling is required, go the hard way + unsigned int *src = rightImage->getImage(0, ts); + if (src != NULL) + decklink_ConvImage(rightEye, self->mSize, src, srcSize, self->mUseExtend); + } + } + if (self->mUse3D) { + DeckLink3DFrameWrapper frame3D( + (IDeckLinkVideoFrame*)self->mLeftFrame, + (IDeckLinkVideoFrame*)self->mRightFrame); + self->mDLOutput->DisplayVideoFrameSync(&frame3D); + } + else { + self->mDLOutput->DisplayVideoFrameSync((IDeckLinkVideoFrame*)self->mLeftFrame); + } + } + // refresh texture source, if required + if (refreshSource) { + if (self->m_leftEye) + self->m_leftEye->m_image->refresh(); + if (self->m_rightEye) + self->m_rightEye->m_image->refresh(); + } + } + CATCH_EXCP; + } + Py_RETURN_NONE; +} + +// get source object +static PyObject *DeckLink_getSource(DeckLink *self, PyObject *value, void *closure) +{ + // if source exists + if (self->m_leftEye != NULL) { + Py_INCREF(self->m_leftEye); + return reinterpret_cast<PyObject*>(self->m_leftEye); + } + // otherwise return None + Py_RETURN_NONE; +} + + +// set source object +int DeckLink_setSource(DeckLink *self, PyObject *value, void *closure) +{ + // check new value + if (value == NULL || !pyImageTypes.in(Py_TYPE(value))) { + // report value error + PyErr_SetString(PyExc_TypeError, "Invalid type of value"); + return -1; + } + // increase ref count for new value + Py_INCREF(value); + // release previous + Py_XDECREF(self->m_leftEye); + // set new value + self->m_leftEye = reinterpret_cast<PyImage*>(value); + // return success + return 0; +} + +// get source object +static PyObject *DeckLink_getRight(DeckLink *self, PyObject *value, void *closure) +{ + // if source exists + if (self->m_rightEye != NULL) + { + Py_INCREF(self->m_rightEye); + return reinterpret_cast<PyObject*>(self->m_rightEye); + } + // otherwise return None + Py_RETURN_NONE; +} + + +// set source object +static int DeckLink_setRight(DeckLink *self, PyObject *value, void *closure) +{ + // check new value + if (value == NULL || !pyImageTypes.in(Py_TYPE(value))) + { + // report value error + PyErr_SetString(PyExc_TypeError, "Invalid type of value"); + return -1; + } + // increase ref count for new value + Py_INCREF(value); + // release previous + Py_XDECREF(self->m_rightEye); + // set new value + self->m_rightEye = reinterpret_cast<PyImage*>(value); + // return success + return 0; +} + + +static PyObject *DeckLink_getKeying(DeckLink *self, PyObject *value, void *closure) +{ + if (self->mUseKeying) Py_RETURN_TRUE; + else Py_RETURN_FALSE; +} + +static int DeckLink_setKeying(DeckLink *self, PyObject *value, void *closure) +{ + if (value == NULL || !PyBool_Check(value)) + { + PyErr_SetString(PyExc_TypeError, "The value must be a bool"); + return -1; + } + if (self->mKeyer != NULL) + { + if (value == Py_True) + { + if (self->mKeyer->Enable(false) != S_OK) + { + PyErr_SetString(PyExc_RuntimeError, "Error enabling keyer"); + return -1; + } + self->mUseKeying = true; + self->mKeyer->SetLevel(self->mKeyingLevel); + } + else + { + self->mKeyer->Disable(); + self->mUseKeying = false; + } + } + // success + return 0; +} + +static PyObject *DeckLink_getLevel(DeckLink *self, PyObject *value, void *closure) +{ + return Py_BuildValue("h", self->mKeyingLevel); +} + +static int DeckLink_setLevel(DeckLink *self, PyObject *value, void *closure) +{ + long level; + if (value == NULL || !PyLong_Check(value)) { + PyErr_SetString(PyExc_TypeError, "The value must be an integer from 0 to 255"); + return -1; + } + level = PyLong_AsLong(value); + if (level > 255) + level = 255; + else if (level < 0) + level = 0; + self->mKeyingLevel = (uint8_t)level; + if (self->mUseKeying) { + if (self->mKeyer->SetLevel(self->mKeyingLevel) != S_OK) { + PyErr_SetString(PyExc_RuntimeError, "Error changin level of keyer"); + return -1; + } + } + // success + return 0; +} + +static PyObject *DeckLink_getExtend(DeckLink *self, PyObject *value, void *closure) +{ + if (self->mUseExtend) Py_RETURN_TRUE; + else Py_RETURN_FALSE; +} + +static int DeckLink_setExtend(DeckLink *self, PyObject *value, void *closure) +{ + if (value == NULL || !PyBool_Check(value)) + { + PyErr_SetString(PyExc_TypeError, "The value must be a bool"); + return -1; + } + self->mUseExtend = (value == Py_True); + return 0; +} + +// class DeckLink methods +static PyMethodDef decklinkMethods[] = +{ + { "close", (PyCFunction)DeckLink_close, METH_NOARGS, "Close dynamic decklink and restore original"}, + { "refresh", (PyCFunction)DeckLink_refresh, METH_VARARGS, "Refresh decklink from source"}, + {NULL} /* Sentinel */ +}; + +// class DeckLink attributes +static PyGetSetDef decklinkGetSets[] = +{ + { (char*)"source", (getter)DeckLink_getSource, (setter)DeckLink_setSource, (char*)"source of decklink (left eye)", NULL}, + { (char*)"right", (getter)DeckLink_getRight, (setter)DeckLink_setRight, (char*)"source of decklink (right eye)", NULL }, + { (char*)"keying", (getter)DeckLink_getKeying, (setter)DeckLink_setKeying, (char*)"whether keying is enabled (frame is alpha-composited with passthrough output)", NULL }, + { (char*)"level", (getter)DeckLink_getLevel, (setter)DeckLink_setLevel, (char*)"change the level of keying (overall alpha level of key frame, 0 to 255)", NULL }, + { (char*)"extend", (getter)DeckLink_getExtend, (setter)DeckLink_setExtend, (char*)"whether image should stretched to fit frame", NULL }, + { NULL } +}; + + +// class DeckLink declaration +PyTypeObject DeckLinkType = +{ + PyVarObject_HEAD_INIT(NULL, 0) + "VideoTexture.DeckLink", /*tp_name*/ + sizeof(DeckLink), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + (destructor)DeckLink_dealloc,/*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash */ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + &imageBufferProcs, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT, /*tp_flags*/ + "DeckLink objects", /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + decklinkMethods, /* tp_methods */ + 0, /* tp_members */ + decklinkGetSets, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)DeckLink_init, /* tp_init */ + 0, /* tp_alloc */ + DeckLink_new, /* tp_new */ +}; + +#endif /* WITH_GAMEENGINE_DECKLINK */ diff --git a/source/gameengine/VideoTexture/DeckLink.h b/source/gameengine/VideoTexture/DeckLink.h new file mode 100644 index 00000000000..1c96af7b4bc --- /dev/null +++ b/source/gameengine/VideoTexture/DeckLink.h @@ -0,0 +1,86 @@ +/* + * ***** BEGIN GPL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * +* The Original Code is Copyright (C) 2015, Blender Foundation +* All rights reserved. +* +* The Original Code is: all of this file. +* +* Contributor(s): Blender Foundation. + * + * ***** END GPL LICENSE BLOCK ***** + */ + +/** \file VideoTexture/DeckLink.h + * \ingroup bgevideotex + */ + +#ifndef __DECKLINK_H__ +#define __DECKLINK_H__ + +#ifdef WITH_GAMEENGINE_DECKLINK + +#include "EXP_PyObjectPlus.h" +#include <structmember.h> + +#include "DNA_image_types.h" + +#include "DeckLinkAPI.h" + +#include "ImageBase.h" +#include "BlendType.h" +#include "Exception.h" + + +// type DeckLink declaration +struct DeckLink +{ + PyObject_HEAD + + // last refresh + double m_lastClock; + // decklink card to which we output + IDeckLinkOutput * mDLOutput; + IDeckLinkKeyer * mKeyer; + IDeckLinkMutableVideoFrame *mLeftFrame; + IDeckLinkMutableVideoFrame *mRightFrame; + bool mUse3D; + bool mUseKeying; + bool mUseExtend; + bool mKeyingSupported; + bool mHDKeyingSupported; + uint8_t mKeyingLevel; + BMDDisplayMode mDisplayMode; + short mSize[2]; + uint32_t mFrameSize; + + // image source + PyImage * m_leftEye; + PyImage * m_rightEye; +}; + + +// DeckLink type description +extern PyTypeObject DeckLinkType; + +// helper function +HRESULT decklink_ReadDisplayMode(const char *format, size_t len, BMDDisplayMode *displayMode); +HRESULT decklink_ReadPixelFormat(const char *format, size_t len, BMDPixelFormat *displayMode); + +#endif /* WITH_GAMEENGINE_DECKLINK */ + +#endif /* __DECKLINK_H__ */ diff --git a/source/gameengine/VideoTexture/Exception.cpp b/source/gameengine/VideoTexture/Exception.cpp index 322b7f9aef3..9f82987ea62 100644 --- a/source/gameengine/VideoTexture/Exception.cpp +++ b/source/gameengine/VideoTexture/Exception.cpp @@ -225,7 +225,7 @@ void registerAllExceptions(void) SourceVideoEmptyDesc.registerDesc(); SourceVideoCreationDesc.registerDesc(); OffScreenInvalidDesc.registerDesc(); -#ifdef WITH_DECKLINK +#ifdef WITH_GAMEENGINE_DECKLINK AutoDetectionNotAvailDesc.registerDesc(); DeckLinkBadDisplayModeDesc.registerDesc(); DeckLinkBadPixelFormatDesc.registerDesc(); diff --git a/source/gameengine/VideoTexture/VideoDeckLink.cpp b/source/gameengine/VideoTexture/VideoDeckLink.cpp new file mode 100644 index 00000000000..c8d3c28c551 --- /dev/null +++ b/source/gameengine/VideoTexture/VideoDeckLink.cpp @@ -0,0 +1,1228 @@ +/* + * ***** BEGIN GPL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * +* The Original Code is Copyright (C) 2015, Blender Foundation +* All rights reserved. +* +* The Original Code is: all of this file. +* +* Contributor(s): Blender Foundation. + * + * ***** END GPL LICENSE BLOCK ***** + */ + +/** \file gameengine/VideoTexture/VideoDeckLink.cpp + * \ingroup bgevideotex + */ + +#ifdef WITH_GAMEENGINE_DECKLINK + +// FFmpeg defines its own version of stdint.h on Windows. +// Decklink needs FFmpeg, so it uses its version of stdint.h +// this is necessary for INT64_C macro +#ifndef __STDC_CONSTANT_MACROS +#define __STDC_CONSTANT_MACROS +#endif +// this is necessary for UINTPTR_MAX (used by atomic-ops) +#ifndef __STDC_LIMIT_MACROS +#define __STDC_LIMIT_MACROS +#ifdef __STDC_LIMIT_MACROS /* else it may be unused */ +#endif +#endif +#include <stdint.h> +#include <string.h> +#ifndef WIN32 +#include <sys/time.h> +#include <sys/resource.h> +#include <sys/mman.h> +#endif + +#include "atomic_ops.h" + +#include "MEM_guardedalloc.h" +#include "PIL_time.h" +#include "VideoDeckLink.h" +#include "DeckLink.h" +#include "Exception.h" +#include "KX_KetsjiEngine.h" +#include "KX_PythonInit.h" + +extern ExceptionID DeckLinkInternalError; +ExceptionID SourceVideoOnlyCapture, VideoDeckLinkBadFormat, VideoDeckLinkOpenCard, VideoDeckLinkDvpInternalError, VideoDeckLinkPinMemoryError; +ExpDesc SourceVideoOnlyCaptureDesc(SourceVideoOnlyCapture, "This video source only allows live capture"); +ExpDesc VideoDeckLinkBadFormatDesc(VideoDeckLinkBadFormat, "Invalid or unsupported capture format, should be <mode>/<pixel>[/3D]"); +ExpDesc VideoDeckLinkOpenCardDesc(VideoDeckLinkOpenCard, "Cannot open capture card, check if driver installed"); +ExpDesc VideoDeckLinkDvpInternalErrorDesc(VideoDeckLinkDvpInternalError, "DVP API internal error, please report"); +ExpDesc VideoDeckLinkPinMemoryErrorDesc(VideoDeckLinkPinMemoryError, "Error pinning memory"); + + +#ifdef WIN32 +//////////////////////////////////////////// +// SynInfo +// +// Sets up a semaphore which is shared between the GPU and CPU and used to +// synchronise access to DVP buffers. +#define DVP_CHECK(cmd) if ((cmd) != DVP_STATUS_OK) THRWEXCP(VideoDeckLinkDvpInternalError, S_OK) + +struct SyncInfo +{ + SyncInfo(uint32_t semaphoreAllocSize, uint32_t semaphoreAddrAlignment) + { + mSemUnaligned = (uint32_t*)malloc(semaphoreAllocSize + semaphoreAddrAlignment - 1); + + // Apply alignment constraints + uint64_t val = (uint64_t)mSemUnaligned; + val += semaphoreAddrAlignment - 1; + val &= ~((uint64_t)semaphoreAddrAlignment - 1); + mSem = (uint32_t*)val; + + // Initialise + mSem[0] = 0; + mReleaseValue = 0; + mAcquireValue = 0; + + // Setup DVP sync object and import it + DVPSyncObjectDesc syncObjectDesc; + syncObjectDesc.externalClientWaitFunc = NULL; + syncObjectDesc.sem = (uint32_t*)mSem; + + DVP_CHECK(dvpImportSyncObject(&syncObjectDesc, &mDvpSync)); + + } + ~SyncInfo() + { + dvpFreeSyncObject(mDvpSync); + free((void*)mSemUnaligned); + } + + volatile uint32_t* mSem; + volatile uint32_t* mSemUnaligned; + volatile uint32_t mReleaseValue; + volatile uint32_t mAcquireValue; + DVPSyncObjectHandle mDvpSync; +}; + +//////////////////////////////////////////// +// TextureTransferDvp: transfer with GPUDirect +//////////////////////////////////////////// + +class TextureTransferDvp : public TextureTransfer +{ +public: + TextureTransferDvp(DVPBufferHandle dvpTextureHandle, TextureDesc *pDesc, void *address, uint32_t allocatedSize) + { + DVPSysmemBufferDesc sysMemBuffersDesc; + + mExtSync = NULL; + mGpuSync = NULL; + mDvpSysMemHandle = 0; + mDvpTextureHandle = 0; + mTextureHeight = 0; + mAllocatedSize = 0; + mBuffer = NULL; + + if (!_PinBuffer(address, allocatedSize)) + THRWEXCP(VideoDeckLinkPinMemoryError, S_OK); + mAllocatedSize = allocatedSize; + mBuffer = address; + + try { + if (!mBufferAddrAlignment) { + DVP_CHECK(dvpGetRequiredConstantsGLCtx(&mBufferAddrAlignment, &mBufferGpuStrideAlignment, + &mSemaphoreAddrAlignment, &mSemaphoreAllocSize, + &mSemaphorePayloadOffset, &mSemaphorePayloadSize)); + } + mExtSync = new SyncInfo(mSemaphoreAllocSize, mSemaphoreAddrAlignment); + mGpuSync = new SyncInfo(mSemaphoreAllocSize, mSemaphoreAddrAlignment); + sysMemBuffersDesc.width = pDesc->width; + sysMemBuffersDesc.height = pDesc->height; + sysMemBuffersDesc.stride = pDesc->stride; + switch (pDesc->format) { + case GL_RED_INTEGER: + sysMemBuffersDesc.format = DVP_RED_INTEGER; + break; + default: + sysMemBuffersDesc.format = DVP_BGRA; + break; + } + switch (pDesc->type) { + case GL_UNSIGNED_BYTE: + sysMemBuffersDesc.type = DVP_UNSIGNED_BYTE; + break; + case GL_UNSIGNED_INT_2_10_10_10_REV: + sysMemBuffersDesc.type = DVP_UNSIGNED_INT_2_10_10_10_REV; + break; + case GL_UNSIGNED_INT_8_8_8_8: + sysMemBuffersDesc.type = DVP_UNSIGNED_INT_8_8_8_8; + break; + case GL_UNSIGNED_INT_10_10_10_2: + sysMemBuffersDesc.type = DVP_UNSIGNED_INT_10_10_10_2; + break; + default: + sysMemBuffersDesc.type = DVP_UNSIGNED_INT; + break; + } + sysMemBuffersDesc.size = pDesc->width * pDesc->height * 4; + sysMemBuffersDesc.bufAddr = mBuffer; + DVP_CHECK(dvpCreateBuffer(&sysMemBuffersDesc, &mDvpSysMemHandle)); + DVP_CHECK(dvpBindToGLCtx(mDvpSysMemHandle)); + mDvpTextureHandle = dvpTextureHandle; + mTextureHeight = pDesc->height; + } + catch (Exception &) { + clean(); + throw; + } + } + ~TextureTransferDvp() + { + clean(); + } + + virtual void PerformTransfer() + { + // perform the transfer + // tell DVP that the old texture buffer will no longer be used + dvpMapBufferEndAPI(mDvpTextureHandle); + // do we need this? + mGpuSync->mReleaseValue++; + dvpBegin(); + // Copy from system memory to GPU texture + dvpMapBufferWaitDVP(mDvpTextureHandle); + dvpMemcpyLined(mDvpSysMemHandle, mExtSync->mDvpSync, mExtSync->mAcquireValue, DVP_TIMEOUT_IGNORED, + mDvpTextureHandle, mGpuSync->mDvpSync, mGpuSync->mReleaseValue, 0, mTextureHeight); + dvpMapBufferEndDVP(mDvpTextureHandle); + dvpEnd(); + dvpMapBufferWaitAPI(mDvpTextureHandle); + // the transfer is now complete and the texture is ready for use + } + +private: + static uint32_t mBufferAddrAlignment; + static uint32_t mBufferGpuStrideAlignment; + static uint32_t mSemaphoreAddrAlignment; + static uint32_t mSemaphoreAllocSize; + static uint32_t mSemaphorePayloadOffset; + static uint32_t mSemaphorePayloadSize; + + void clean() + { + if (mDvpSysMemHandle) { + dvpUnbindFromGLCtx(mDvpSysMemHandle); + dvpDestroyBuffer(mDvpSysMemHandle); + } + if (mExtSync) + delete mExtSync; + if (mGpuSync) + delete mGpuSync; + if (mBuffer) + _UnpinBuffer(mBuffer, mAllocatedSize); + } + SyncInfo* mExtSync; + SyncInfo* mGpuSync; + DVPBufferHandle mDvpSysMemHandle; + DVPBufferHandle mDvpTextureHandle; + uint32_t mTextureHeight; + uint32_t mAllocatedSize; + void* mBuffer; +}; + +uint32_t TextureTransferDvp::mBufferAddrAlignment; +uint32_t TextureTransferDvp::mBufferGpuStrideAlignment; +uint32_t TextureTransferDvp::mSemaphoreAddrAlignment; +uint32_t TextureTransferDvp::mSemaphoreAllocSize; +uint32_t TextureTransferDvp::mSemaphorePayloadOffset; +uint32_t TextureTransferDvp::mSemaphorePayloadSize; + +#endif + +//////////////////////////////////////////// +// TextureTransferOGL: transfer using standard OGL buffers +//////////////////////////////////////////// + +class TextureTransferOGL : public TextureTransfer +{ +public: + TextureTransferOGL(GLuint texId, TextureDesc *pDesc, void *address) + { + memcpy(&mDesc, pDesc, sizeof(mDesc)); + mTexId = texId; + mBuffer = address; + + // as we cache transfer object, we will create one texture to hold the buffer + glGenBuffers(1, &mUnpinnedTextureBuffer); + // create a storage for it + glBindBuffer(GL_PIXEL_UNPACK_BUFFER, mUnpinnedTextureBuffer); + glBufferData(GL_PIXEL_UNPACK_BUFFER, pDesc->size, NULL, GL_DYNAMIC_DRAW); + glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0); + } + ~TextureTransferOGL() + { + glDeleteBuffers(1, &mUnpinnedTextureBuffer); + } + + virtual void PerformTransfer() + { + glBindBuffer(GL_PIXEL_UNPACK_BUFFER, mUnpinnedTextureBuffer); + glBufferSubData(GL_PIXEL_UNPACK_BUFFER, 0, mDesc.size, mBuffer); + glBindTexture(GL_TEXTURE_2D, mTexId); + // NULL for last arg indicates use current GL_PIXEL_UNPACK_BUFFER target as texture data + glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, mDesc.width, mDesc.height, mDesc.format, mDesc.type, NULL); + glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0); + } +private: + // intermediate texture to receive the buffer + GLuint mUnpinnedTextureBuffer; + // target texture to receive the image + GLuint mTexId; + // buffer + void *mBuffer; + // characteristic of the image + TextureDesc mDesc; +}; + +//////////////////////////////////////////// +// TextureTransferPMB: transfer using pinned memory buffer +//////////////////////////////////////////// + +class TextureTransferPMD : public TextureTransfer +{ +public: + TextureTransferPMD(GLuint texId, TextureDesc *pDesc, void *address, uint32_t allocatedSize) + { + memcpy(&mDesc, pDesc, sizeof(mDesc)); + mTexId = texId; + mBuffer = address; + mAllocatedSize = allocatedSize; + + _PinBuffer(address, allocatedSize); + + // as we cache transfer object, we will create one texture to hold the buffer + glGenBuffers(1, &mPinnedTextureBuffer); + // create a storage for it + glBindBuffer(GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD, mPinnedTextureBuffer); + glBufferData(GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD, pDesc->size, address, GL_STREAM_DRAW); + glBindBuffer(GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD, 0); + } + ~TextureTransferPMD() + { + glDeleteBuffers(1, &mPinnedTextureBuffer); + if (mBuffer) + _UnpinBuffer(mBuffer, mAllocatedSize); + } + + virtual void PerformTransfer() + { + glBindBuffer(GL_PIXEL_UNPACK_BUFFER, mPinnedTextureBuffer); + glBindTexture(GL_TEXTURE_2D, mTexId); + // NULL for last arg indicates use current GL_PIXEL_UNPACK_BUFFER target as texture data + glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, mDesc.width, mDesc.height, mDesc.format, mDesc.type, NULL); + // wait for the trasnfer to complete + GLsync fence = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0); + glClientWaitSync(fence, GL_SYNC_FLUSH_COMMANDS_BIT, 40 * 1000 * 1000); // timeout in nanosec + glDeleteSync(fence); + glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0); + } +private: + // intermediate texture to receive the buffer + GLuint mPinnedTextureBuffer; + // target texture to receive the image + GLuint mTexId; + // buffer + void *mBuffer; + // the allocated size + uint32_t mAllocatedSize; + // characteristic of the image + TextureDesc mDesc; +}; + +bool TextureTransfer::_PinBuffer(void *address, uint32_t size) +{ +#ifdef WIN32 + return VirtualLock(address, size); +#elif defined(_POSIX_MEMLOCK_RANGE) + return !mlock(address, size); +#endif +} + +void TextureTransfer::_UnpinBuffer(void* address, uint32_t size) +{ +#ifdef WIN32 + VirtualUnlock(address, size); +#elif defined(_POSIX_MEMLOCK_RANGE) + munlock(address, size); +#endif +} + + + +//////////////////////////////////////////// +// PinnedMemoryAllocator +//////////////////////////////////////////// + + +// static members +bool PinnedMemoryAllocator::mGPUDirectInitialized = false; +bool PinnedMemoryAllocator::mHasDvp = false; +bool PinnedMemoryAllocator::mHasAMDPinnedMemory = false; +size_t PinnedMemoryAllocator::mReservedProcessMemory = 0; + +bool PinnedMemoryAllocator::ReserveMemory(size_t size) +{ +#ifdef WIN32 + // Increase the process working set size to allow pinning of memory. + if (size <= mReservedProcessMemory) + return true; + SIZE_T dwMin = 0, dwMax = 0; + HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_SET_QUOTA, FALSE, GetCurrentProcessId()); + if (!hProcess) + return false; + + // Retrieve the working set size of the process. + if (!dwMin && !GetProcessWorkingSetSize(hProcess, &dwMin, &dwMax)) + return false; + + BOOL res = SetProcessWorkingSetSize(hProcess, (size - mReservedProcessMemory) + dwMin, (size - mReservedProcessMemory) + dwMax); + if (!res) + return false; + mReservedProcessMemory = size; + CloseHandle(hProcess); + return true; +#else + struct rlimit rlim; + if (getrlimit(RLIMIT_MEMLOCK, &rlim) == 0) { + if (rlim.rlim_cur < size) { + if (rlim.rlim_max < size) + rlim.rlim_max = size; + rlim.rlim_cur = size; + return !setrlimit(RLIMIT_MEMLOCK, &rlim); + } + } + return false; +#endif +} + +PinnedMemoryAllocator::PinnedMemoryAllocator(unsigned cacheSize, size_t memSize) : +mRefCount(1U), +#ifdef WIN32 +mDvpCaptureTextureHandle(0), +#endif +mTexId(0), +mBufferCacheSize(cacheSize) +{ + pthread_mutex_init(&mMutex, NULL); + // do it once + if (!mGPUDirectInitialized) { +#ifdef WIN32 + // In windows, AMD_pinned_memory option is not available, + // we must use special DVP API only available for Quadro cards + const char* renderer = (const char *)glGetString(GL_RENDERER); + mHasDvp = (strstr(renderer, "Quadro") != NULL); + + if (mHasDvp) { + // In case the DLL is not in place, don't fail, just fallback on OpenGL + if (dvpInitGLContext(DVP_DEVICE_FLAGS_SHARE_APP_CONTEXT) != DVP_STATUS_OK) { + printf("Warning: Could not initialize DVP context, fallback on OpenGL transfer.\nInstall dvp.dll to take advantage of nVidia GPUDirect.\n"); + mHasDvp = false; + } + } +#endif + if (GLEW_AMD_pinned_memory) + mHasAMDPinnedMemory = true; + + mGPUDirectInitialized = true; + } + if (mHasDvp || mHasAMDPinnedMemory) { + ReserveMemory(memSize); + } +} + +PinnedMemoryAllocator::~PinnedMemoryAllocator() +{ + void *address; + // first clean the cache if not already done + while (!mBufferCache.empty()) { + address = mBufferCache.back(); + mBufferCache.pop_back(); + _ReleaseBuffer(address); + } + // clean preallocated buffers + while (!mAllocatedSize.empty()) { + address = mAllocatedSize.begin()->first; + _ReleaseBuffer(address); + } + +#ifdef WIN32 + if (mDvpCaptureTextureHandle) + dvpDestroyBuffer(mDvpCaptureTextureHandle); +#endif +} + +void PinnedMemoryAllocator::TransferBuffer(void* address, TextureDesc* texDesc, GLuint texId) +{ + uint32_t allocatedSize = 0; + TextureTransfer *pTransfer = NULL; + + Lock(); + if (mAllocatedSize.count(address) > 0) + allocatedSize = mAllocatedSize[address]; + Unlock(); + if (!allocatedSize) + // internal error!! + return; + if (mTexId != texId) + { + // first time we try to send data to the GPU, allocate a buffer for the texture + glBindTexture(GL_TEXTURE_2D, texId); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); + glTexImage2D(GL_TEXTURE_2D, 0, texDesc->internalFormat, texDesc->width, texDesc->height, 0, texDesc->format, texDesc->type, NULL); + glBindTexture(GL_TEXTURE_2D, 0); + mTexId = texId; + } +#ifdef WIN32 + if (mHasDvp) + { + if (!mDvpCaptureTextureHandle) + { + // bind DVP to the OGL texture + DVP_CHECK(dvpCreateGPUTextureGL(texId, &mDvpCaptureTextureHandle)); + } + } +#endif + Lock(); + if (mPinnedBuffer.count(address) > 0) + { + pTransfer = mPinnedBuffer[address]; + } + Unlock(); + if (!pTransfer) + { +#ifdef WIN32 + if (mHasDvp) + pTransfer = new TextureTransferDvp(mDvpCaptureTextureHandle, texDesc, address, allocatedSize); + else +#endif + if (mHasAMDPinnedMemory) { + pTransfer = new TextureTransferPMD(texId, texDesc, address, allocatedSize); + } + else { + pTransfer = new TextureTransferOGL(texId, texDesc, address); + } + if (pTransfer) + { + Lock(); + mPinnedBuffer[address] = pTransfer; + Unlock(); + } + } + if (pTransfer) + pTransfer->PerformTransfer(); +} + +// IUnknown methods +HRESULT STDMETHODCALLTYPE PinnedMemoryAllocator::QueryInterface(REFIID /*iid*/, LPVOID* /*ppv*/) +{ + return E_NOTIMPL; +} + +ULONG STDMETHODCALLTYPE PinnedMemoryAllocator::AddRef(void) +{ + return atomic_add_uint32(&mRefCount, 1U); +} + +ULONG STDMETHODCALLTYPE PinnedMemoryAllocator::Release(void) +{ + uint32_t newCount = atomic_sub_uint32(&mRefCount, 1U); + if (newCount == 0) + delete this; + return (ULONG)newCount; +} + +// IDeckLinkMemoryAllocator methods +HRESULT STDMETHODCALLTYPE PinnedMemoryAllocator::AllocateBuffer(dl_size_t bufferSize, void* *allocatedBuffer) +{ + Lock(); + if (mBufferCache.empty()) + { + // Allocate memory on a page boundary + // Note: aligned alloc exist in Blender but only for small alignment, use direct allocation then. + // Note: the DeckLink API tries to allocate up to 65 buffer in advance, we will limit this to 3 + // because we don't need any caching + if (mAllocatedSize.size() >= mBufferCacheSize) + *allocatedBuffer = NULL; + else { +#ifdef WIN32 + *allocatedBuffer = VirtualAlloc(NULL, bufferSize, MEM_COMMIT | MEM_RESERVE | MEM_WRITE_WATCH, PAGE_READWRITE); +#else + if (posix_memalign(allocatedBuffer, 4096, bufferSize) != 0) + *allocatedBuffer = NULL; +#endif + mAllocatedSize[*allocatedBuffer] = bufferSize; + } + } + else { + // Re-use most recently ReleaseBuffer'd address + *allocatedBuffer = mBufferCache.back(); + mBufferCache.pop_back(); + } + Unlock(); + return (*allocatedBuffer) ? S_OK : E_OUTOFMEMORY; +} + +HRESULT STDMETHODCALLTYPE PinnedMemoryAllocator::ReleaseBuffer(void* buffer) +{ + HRESULT result = S_OK; + Lock(); + if (mBufferCache.size() < mBufferCacheSize) { + mBufferCache.push_back(buffer); + } + else { + result = _ReleaseBuffer(buffer); + } + Unlock(); + return result; +} + + +HRESULT PinnedMemoryAllocator::_ReleaseBuffer(void* buffer) +{ + TextureTransfer *pTransfer; + if (mAllocatedSize.count(buffer) == 0) { + // Internal error!! + return S_OK; + } + else { + // No room left in cache, so un-pin (if it was pinned) and free this buffer + if (mPinnedBuffer.count(buffer) > 0) { + pTransfer = mPinnedBuffer[buffer]; + mPinnedBuffer.erase(buffer); + delete pTransfer; + } +#ifdef WIN32 + VirtualFree(buffer, 0, MEM_RELEASE); +#else + free(buffer); +#endif + mAllocatedSize.erase(buffer); + } + return S_OK; +} + +HRESULT STDMETHODCALLTYPE PinnedMemoryAllocator::Commit() +{ + return S_OK; +} + +HRESULT STDMETHODCALLTYPE PinnedMemoryAllocator::Decommit() +{ + void *buffer; + Lock(); + while (!mBufferCache.empty()) { + // Cleanup any frames allocated and pinned in AllocateBuffer() but not freed in ReleaseBuffer() + buffer = mBufferCache.back(); + mBufferCache.pop_back(); + _ReleaseBuffer(buffer); + } + Unlock(); + return S_OK; +} + + +//////////////////////////////////////////// +// Capture Delegate Class +//////////////////////////////////////////// + +CaptureDelegate::CaptureDelegate(VideoDeckLink* pOwner) : mpOwner(pOwner) +{ +} + +HRESULT CaptureDelegate::VideoInputFrameArrived(IDeckLinkVideoInputFrame* inputFrame, IDeckLinkAudioInputPacket* /*audioPacket*/) +{ + if (!inputFrame) { + // It's possible to receive a NULL inputFrame, but a valid audioPacket. Ignore audio-only frame. + return S_OK; + } + if ((inputFrame->GetFlags() & bmdFrameHasNoInputSource) == bmdFrameHasNoInputSource) { + // let's not bother transferring frames if there is no source + return S_OK; + } + mpOwner->VideoFrameArrived(inputFrame); + return S_OK; +} + +HRESULT CaptureDelegate::VideoInputFormatChanged(BMDVideoInputFormatChangedEvents notificationEvents, IDeckLinkDisplayMode *newDisplayMode, BMDDetectedVideoInputFormatFlags detectedSignalFlags) +{ + return S_OK; +} + + + + +// macro for exception handling and logging +#define CATCH_EXCP catch (Exception & exp) \ +{ exp.report(); m_status = SourceError; } + +// class VideoDeckLink + + +// constructor +VideoDeckLink::VideoDeckLink (HRESULT * hRslt) : VideoBase(), +mDLInput(NULL), +mUse3D(false), +mFrameWidth(0), +mFrameHeight(0), +mpAllocator(NULL), +mpCaptureDelegate(NULL), +mpCacheFrame(NULL), +mClosing(false) +{ + mDisplayMode = (BMDDisplayMode)0; + mPixelFormat = (BMDPixelFormat)0; + pthread_mutex_init(&mCacheMutex, NULL); +} + +// destructor +VideoDeckLink::~VideoDeckLink () +{ + LockCache(); + mClosing = true; + if (mpCacheFrame) + { + mpCacheFrame->Release(); + mpCacheFrame = NULL; + } + UnlockCache(); + if (mDLInput != NULL) + { + // Cleanup for Capture + mDLInput->StopStreams(); + mDLInput->SetCallback(NULL); + mDLInput->DisableVideoInput(); + mDLInput->DisableAudioInput(); + mDLInput->FlushStreams(); + if (mDLInput->Release() != 0) { + printf("Reference count not NULL on DeckLink device when closing it, please report!\n"); + } + mDLInput = NULL; + } + + if (mpAllocator) + { + // if the device was properly cleared, this should be 0 + if (mpAllocator->Release() != 0) { + printf("Reference count not NULL on Allocator when closing it, please report!\n"); + } + mpAllocator = NULL; + } + if (mpCaptureDelegate) + { + delete mpCaptureDelegate; + mpCaptureDelegate = NULL; + } +} + +void VideoDeckLink::refresh(void) +{ + m_avail = false; +} + +// release components +bool VideoDeckLink::release() +{ + // release + return true; +} + +// open video file +void VideoDeckLink::openFile (char *filename) +{ + // only live capture on this device + THRWEXCP(SourceVideoOnlyCapture, S_OK); +} + + +// open video capture device +void VideoDeckLink::openCam (char *format, short camIdx) +{ + IDeckLinkDisplayModeIterator* pDLDisplayModeIterator; + BMDDisplayModeSupport modeSupport; + IDeckLinkDisplayMode* pDLDisplayMode; + IDeckLinkIterator* pIterator; + BMDTimeValue frameDuration; + BMDTimeScale frameTimescale; + IDeckLink* pDL; + uint32_t displayFlags, inputFlags; + char *pPixel, *p3D, *pEnd, *pSize; + size_t len; + int i, modeIdx, cacheSize; + + // format is constructed as <displayMode>/<pixelFormat>[/3D][:<cacheSize>] + // <displayMode> takes the form of BMDDisplayMode identifier minus the 'bmdMode' prefix. + // This implementation understands all the modes defined in SDK 10.3.1 but you can alternatively + // use the 4 characters internal representation of the mode (e.g. 'HD1080p24' == '24ps') + // <pixelFormat> takes the form of BMDPixelFormat identifier minus the 'bmdFormat' prefix. + // This implementation understand all the formats defined in SDK 10.32.1 but you can alternatively + // use the 4 characters internal representation of the format (e.g. '10BitRGB' == 'r210') + // Not all combinations of mode and pixel format are possible and it also depends on the card! + // Use /3D postfix if you are capturing a 3D stream with frame packing + // Example: To capture FullHD 1920x1080@24Hz with 3D packing and 4:4:4 10 bits RGB pixel format, use + // "HD1080p24/10BitRGB/3D" (same as "24ps/r210/3D") + // (this will be the normal capture format for FullHD on the DeckLink 4k extreme) + + if ((pSize = strchr(format, ':')) != NULL) { + cacheSize = strtol(pSize+1, &pEnd, 10); + } + else { + cacheSize = 8; + pSize = format + strlen(format); + } + if ((pPixel = strchr(format, '/')) == NULL || + ((p3D = strchr(pPixel + 1, '/')) != NULL && strncmp(p3D, "/3D", pSize-p3D))) + THRWEXCP(VideoDeckLinkBadFormat, S_OK); + mUse3D = (p3D) ? true : false; + // to simplify pixel format parsing + if (!p3D) + p3D = pSize; + + // read the mode + len = (size_t)(pPixel - format); + // accept integer display mode + + try { + // throws if bad mode + decklink_ReadDisplayMode(format, len, &mDisplayMode); + // found a valid mode, remember that we do not look for an index + modeIdx = -1; + } + catch (Exception &) { + // accept also purely numerical mode as a mode index + modeIdx = strtol(format, &pEnd, 10); + if (pEnd != pPixel || modeIdx < 0) + // not a pure number, give up + throw; + } + + // skip / + pPixel++; + len = (size_t)(p3D - pPixel); + // throws if bad format + decklink_ReadPixelFormat(pPixel, len, &mPixelFormat); + + // Caution: DeckLink API used from this point, make sure entity are released before throwing + // open the card + pIterator = BMD_CreateDeckLinkIterator(); + if (pIterator) { + i = 0; + while (pIterator->Next(&pDL) == S_OK) { + if (i == camIdx) { + if (pDL->QueryInterface(IID_IDeckLinkInput, (void**)&mDLInput) != S_OK) + mDLInput = NULL; + pDL->Release(); + break; + } + i++; + pDL->Release(); + } + pIterator->Release(); + } + if (!mDLInput) + THRWEXCP(VideoDeckLinkOpenCard, S_OK); + + + // check if display mode and pixel format are supported + if (mDLInput->GetDisplayModeIterator(&pDLDisplayModeIterator) != S_OK) + THRWEXCP(DeckLinkInternalError, S_OK); + + pDLDisplayMode = NULL; + displayFlags = (mUse3D) ? bmdDisplayModeSupports3D : 0; + inputFlags = (mUse3D) ? bmdVideoInputDualStream3D : bmdVideoInputFlagDefault; + while (pDLDisplayModeIterator->Next(&pDLDisplayMode) == S_OK) + { + if (modeIdx == 0 || pDLDisplayMode->GetDisplayMode() == mDisplayMode) { + // in case we get here because of modeIdx, make sure we have mDisplayMode set + mDisplayMode = pDLDisplayMode->GetDisplayMode(); + if ((pDLDisplayMode->GetFlags() & displayFlags) == displayFlags && + mDLInput->DoesSupportVideoMode(mDisplayMode, mPixelFormat, inputFlags, &modeSupport, NULL) == S_OK && + modeSupport == bmdDisplayModeSupported) + { + break; + } + } + pDLDisplayMode->Release(); + pDLDisplayMode = NULL; + if (modeIdx-- == 0) { + // reached the correct mode index but it does not meet the pixel format, give up + break; + } + } + pDLDisplayModeIterator->Release(); + + if (pDLDisplayMode == NULL) + THRWEXCP(VideoDeckLinkBadFormat, S_OK); + + mFrameWidth = pDLDisplayMode->GetWidth(); + mFrameHeight = pDLDisplayMode->GetHeight(); + mTextureDesc.height = (mUse3D) ? 2 * mFrameHeight : mFrameHeight; + pDLDisplayMode->GetFrameRate(&frameDuration, &frameTimescale); + pDLDisplayMode->Release(); + // for information, in case the application wants to know + m_size[0] = mFrameWidth; + m_size[1] = mTextureDesc.height; + m_frameRate = (float)frameTimescale / (float)frameDuration; + + switch (mPixelFormat) + { + case bmdFormat8BitYUV: + // 2 pixels per word + mTextureDesc.stride = mFrameWidth * 2; + mTextureDesc.width = mFrameWidth / 2; + mTextureDesc.internalFormat = GL_RGBA; + mTextureDesc.format = GL_BGRA; + mTextureDesc.type = GL_UNSIGNED_BYTE; + break; + case bmdFormat10BitYUV: + // 6 pixels in 4 words, rounded to 48 pixels + mTextureDesc.stride = ((mFrameWidth + 47) / 48) * 128; + mTextureDesc.width = mTextureDesc.stride/4; + mTextureDesc.internalFormat = GL_RGB10_A2; + mTextureDesc.format = GL_BGRA; + mTextureDesc.type = GL_UNSIGNED_INT_2_10_10_10_REV; + break; + case bmdFormat8BitARGB: + mTextureDesc.stride = mFrameWidth * 4; + mTextureDesc.width = mFrameWidth; + mTextureDesc.internalFormat = GL_RGBA; + mTextureDesc.format = GL_BGRA; + mTextureDesc.type = GL_UNSIGNED_INT_8_8_8_8; + break; + case bmdFormat8BitBGRA: + mTextureDesc.stride = mFrameWidth * 4; + mTextureDesc.width = mFrameWidth; + mTextureDesc.internalFormat = GL_RGBA; + mTextureDesc.format = GL_BGRA; + mTextureDesc.type = GL_UNSIGNED_BYTE; + break; + case bmdFormat10BitRGBXLE: + // 1 pixel per word, rounded to 64 pixels + mTextureDesc.stride = ((mFrameWidth + 63) / 64) * 256; + mTextureDesc.width = mTextureDesc.stride/4; + mTextureDesc.internalFormat = GL_RGB10_A2; + mTextureDesc.format = GL_RGBA; + mTextureDesc.type = GL_UNSIGNED_INT_10_10_10_2; + break; + case bmdFormat10BitRGBX: + case bmdFormat10BitRGB: + // 1 pixel per word, rounded to 64 pixels + mTextureDesc.stride = ((mFrameWidth + 63) / 64) * 256; + mTextureDesc.width = mTextureDesc.stride/4; + mTextureDesc.internalFormat = GL_R32UI; + mTextureDesc.format = GL_RED_INTEGER; + mTextureDesc.type = GL_UNSIGNED_INT; + break; + case bmdFormat12BitRGB: + case bmdFormat12BitRGBLE: + // 8 pixels in 9 word + mTextureDesc.stride = (mFrameWidth * 36) / 8; + mTextureDesc.width = mTextureDesc.stride/4; + mTextureDesc.internalFormat = GL_R32UI; + mTextureDesc.format = GL_RED_INTEGER; + mTextureDesc.type = GL_UNSIGNED_INT; + break; + default: + // for unknown pixel format, this will be resolved when a frame arrives + mTextureDesc.format = GL_RED_INTEGER; + mTextureDesc.type = GL_UNSIGNED_INT; + break; + } + // reserve memory for cache frame + 1 to accomodate for pixel format that we don't know yet + // note: we can't use stride as it is not yet known if the pixel format is unknown + // use instead the frame width as in worst case it's not much different (e.g. HD720/10BITYUV: 1296 pixels versus 1280) + // note: some pixel format take more than 4 bytes take that into account (9/8 versus 1) + mpAllocator = new PinnedMemoryAllocator(cacheSize, mFrameWidth*mTextureDesc.height * 4 * (1+cacheSize*9/8)); + + if (mDLInput->SetVideoInputFrameMemoryAllocator(mpAllocator) != S_OK) + THRWEXCP(DeckLinkInternalError, S_OK); + + mpCaptureDelegate = new CaptureDelegate(this); + if (mDLInput->SetCallback(mpCaptureDelegate) != S_OK) + THRWEXCP(DeckLinkInternalError, S_OK); + + if (mDLInput->EnableVideoInput(mDisplayMode, mPixelFormat, ((mUse3D) ? bmdVideoInputDualStream3D : bmdVideoInputFlagDefault)) != S_OK) + // this shouldn't failed, we tested above + THRWEXCP(DeckLinkInternalError, S_OK); + + // just in case it is needed to capture from certain cards, we don't check error because we don't need audio + mDLInput->EnableAudioInput(bmdAudioSampleRate48kHz, bmdAudioSampleType16bitInteger, 2); + + // open base class + VideoBase::openCam(format, camIdx); + + // ready to capture, will start when application calls play() +} + +// play video +bool VideoDeckLink::play (void) +{ + try + { + // if object is able to play + if (VideoBase::play()) + { + mDLInput->FlushStreams(); + return (mDLInput->StartStreams() == S_OK); + } + } + CATCH_EXCP; + return false; +} + + +// pause video +bool VideoDeckLink::pause (void) +{ + try + { + if (VideoBase::pause()) + { + mDLInput->PauseStreams(); + return true; + } + } + CATCH_EXCP; + return false; +} + +// stop video +bool VideoDeckLink::stop (void) +{ + try + { + VideoBase::stop(); + mDLInput->StopStreams(); + return true; + } + CATCH_EXCP; + return false; +} + + +// set video range +void VideoDeckLink::setRange (double start, double stop) +{ +} + +// set framerate +void VideoDeckLink::setFrameRate (float rate) +{ +} + + +// image calculation +// send cache frame directly to GPU +void VideoDeckLink::calcImage (unsigned int texId, double ts) +{ + IDeckLinkVideoInputFrame* pFrame; + LockCache(); + pFrame = mpCacheFrame; + mpCacheFrame = NULL; + UnlockCache(); + if (pFrame) { + // BUG: the dvpBindToGLCtx function fails the first time it is used, don't know why. + // This causes an exception to be thrown. + // This should be fixed but in the meantime we will catch the exception because + // it is crucial that we release the frame to keep the reference count right on the DeckLink device + try { + uint32_t rowSize = pFrame->GetRowBytes(); + uint32_t textureSize = rowSize * pFrame->GetHeight(); + void* videoPixels = NULL; + void* rightEyePixels = NULL; + if (!mTextureDesc.stride) { + // we could not compute the texture size earlier (unknown pixel size) + // let's do it now + mTextureDesc.stride = rowSize; + mTextureDesc.width = mTextureDesc.stride / 4; + } + if (mTextureDesc.stride != rowSize) { + // unexpected frame size, ignore + // TBD: print a warning + } + else { + pFrame->GetBytes(&videoPixels); + if (mUse3D) { + IDeckLinkVideoFrame3DExtensions *if3DExtensions = NULL; + IDeckLinkVideoFrame *rightEyeFrame = NULL; + if (pFrame->QueryInterface(IID_IDeckLinkVideoFrame3DExtensions, (void **)&if3DExtensions) == S_OK && + if3DExtensions->GetFrameForRightEye(&rightEyeFrame) == S_OK) { + rightEyeFrame->GetBytes(&rightEyePixels); + textureSize += ((uint64_t)rightEyePixels - (uint64_t)videoPixels); + } + if (rightEyeFrame) + rightEyeFrame->Release(); + if (if3DExtensions) + if3DExtensions->Release(); + } + mTextureDesc.size = mTextureDesc.width * mTextureDesc.height * 4; + if (mTextureDesc.size == textureSize) { + // this means that both left and right frame are contiguous and that there is no padding + // do the transfer + mpAllocator->TransferBuffer(videoPixels, &mTextureDesc, texId); + } + } + } + catch (Exception &) { + pFrame->Release(); + throw; + } + // this will trigger PinnedMemoryAllocator::RealaseBuffer + pFrame->Release(); + } + // currently we don't pass the image to the application + m_avail = false; +} + +// A frame is available from the board +// Called from an internal thread, just pass the frame to the main thread +void VideoDeckLink::VideoFrameArrived(IDeckLinkVideoInputFrame* inputFrame) +{ + IDeckLinkVideoInputFrame* pOldFrame = NULL; + LockCache(); + if (!mClosing) + { + pOldFrame = mpCacheFrame; + mpCacheFrame = inputFrame; + inputFrame->AddRef(); + } + UnlockCache(); + // old frame no longer needed, just release it + if (pOldFrame) + pOldFrame->Release(); +} + +// python methods + +// object initialization +static int VideoDeckLink_init(PyObject *pySelf, PyObject *args, PyObject *kwds) +{ + static const char *kwlist[] = { "format", "capture", NULL }; + PyImage *self = reinterpret_cast<PyImage*>(pySelf); + // see openCam for a description of format + char * format = NULL; + // capture device number, i.e. DeckLink card number, default first one + short capt = 0; + + if (!GLEW_VERSION_1_5) { + PyErr_SetString(PyExc_RuntimeError, "VideoDeckLink requires at least OpenGL 1.5"); + return -1; + } + // get parameters + if (!PyArg_ParseTupleAndKeywords(args, kwds, "s|h", + const_cast<char**>(kwlist), &format, &capt)) + return -1; + + try { + // create video object + Video_init<VideoDeckLink>(self); + + // open video source, control comes back to VideoDeckLink::openCam + Video_open(getVideo(self), format, capt); + } + catch (Exception & exp) { + exp.report(); + return -1; + } + // initialization succeded + return 0; +} + +// methods structure +static PyMethodDef videoMethods[] = +{ // methods from VideoBase class + {"play", (PyCFunction)Video_play, METH_NOARGS, "Play (restart) video"}, + {"pause", (PyCFunction)Video_pause, METH_NOARGS, "pause video"}, + {"stop", (PyCFunction)Video_stop, METH_NOARGS, "stop video (play will replay it from start)"}, + {"refresh", (PyCFunction)Video_refresh, METH_VARARGS, "Refresh video - get its status"}, + {NULL} +}; +// attributes structure +static PyGetSetDef videoGetSets[] = +{ // methods from VideoBase class + {(char*)"status", (getter)Video_getStatus, NULL, (char*)"video status", NULL}, + {(char*)"framerate", (getter)Video_getFrameRate, NULL, (char*)"frame rate", NULL}, + // attributes from ImageBase class + {(char*)"valid", (getter)Image_valid, NULL, (char*)"bool to tell if an image is available", NULL}, + {(char*)"image", (getter)Image_getImage, NULL, (char*)"image data", NULL}, + {(char*)"size", (getter)Image_getSize, NULL, (char*)"image size", NULL}, + {(char*)"scale", (getter)Image_getScale, (setter)Image_setScale, (char*)"fast scale of image (near neighbor)", NULL}, + {(char*)"flip", (getter)Image_getFlip, (setter)Image_setFlip, (char*)"flip image vertically", NULL}, + {(char*)"filter", (getter)Image_getFilter, (setter)Image_setFilter, (char*)"pixel filter", NULL}, + {NULL} +}; + +// python type declaration +PyTypeObject VideoDeckLinkType = +{ + PyVarObject_HEAD_INIT(NULL, 0) + "VideoTexture.VideoDeckLink", /*tp_name*/ + sizeof(PyImage), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + (destructor)Image_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash */ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + &imageBufferProcs, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT, /*tp_flags*/ + "DeckLink video source", /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + videoMethods, /* tp_methods */ + 0, /* tp_members */ + videoGetSets, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)VideoDeckLink_init, /* tp_init */ + 0, /* tp_alloc */ + Image_allocNew, /* tp_new */ +}; + + + +//////////////////////////////////////////// +// DeckLink Capture Delegate Class +//////////////////////////////////////////// + +#endif // WITH_GAMEENGINE_DECKLINK + diff --git a/source/gameengine/VideoTexture/VideoDeckLink.h b/source/gameengine/VideoTexture/VideoDeckLink.h new file mode 100644 index 00000000000..be81f63d93c --- /dev/null +++ b/source/gameengine/VideoTexture/VideoDeckLink.h @@ -0,0 +1,256 @@ +/* + * ***** BEGIN GPL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * +* The Original Code is Copyright (C) 2015, Blender Foundation +* All rights reserved. +* +* The Original Code is: all of this file. +* +* Contributor(s): Blender Foundation. + * + * ***** END GPL LICENSE BLOCK ***** + */ + +/** \file VideoDeckLink.h + * \ingroup bgevideotex + */ + +#ifndef __VIDEODECKLINK_H__ +#define __VIDEODECKLINK_H__ + +#ifdef WITH_GAMEENGINE_DECKLINK + +/* this needs to be parsed with __cplusplus defined before included through DeckLink_compat.h */ +#if defined(__FreeBSD__) +# include <inttypes.h> +#endif +#include <map> +#include <set> + +extern "C" { +#include <pthread.h> +#include "DNA_listBase.h" +#include "BLI_threads.h" +#include "BLI_blenlib.h" +} +#include "GL/glew.h" +#ifdef WIN32 +#include "dvpapi.h" +#endif +#include "DeckLinkAPI.h" +#include "VideoBase.h" + +class PinnedMemoryAllocator; + +struct TextureDesc +{ + uint32_t width; + uint32_t height; + uint32_t stride; + uint32_t size; + GLenum internalFormat; + GLenum format; + GLenum type; + TextureDesc() + { + width = 0; + height = 0; + stride = 0; + size = 0; + internalFormat = 0; + format = 0; + type = 0; + } +}; + +class CaptureDelegate; + +// type VideoDeckLink declaration +class VideoDeckLink : public VideoBase +{ + friend class CaptureDelegate; +public: + /// constructor + VideoDeckLink (HRESULT * hRslt); + /// destructor + virtual ~VideoDeckLink (); + + /// open video/image file + virtual void openFile(char *file); + /// open video capture device + virtual void openCam(char *driver, short camIdx); + + /// release video source + virtual bool release (void); + /// overwrite base refresh to handle fixed image + virtual void refresh(void); + /// play video + virtual bool play (void); + /// pause video + virtual bool pause (void); + /// stop video + virtual bool stop (void); + /// set play range + virtual void setRange (double start, double stop); + /// set frame rate + virtual void setFrameRate (float rate); + +protected: + // format and codec information + /// image calculation + virtual void calcImage (unsigned int texId, double ts); + +private: + void VideoFrameArrived(IDeckLinkVideoInputFrame* inputFrame); + void LockCache() + { + pthread_mutex_lock(&mCacheMutex); + } + void UnlockCache() + { + pthread_mutex_unlock(&mCacheMutex); + } + + IDeckLinkInput* mDLInput; + BMDDisplayMode mDisplayMode; + BMDPixelFormat mPixelFormat; + bool mUse3D; + uint32_t mFrameWidth; + uint32_t mFrameHeight; + TextureDesc mTextureDesc; + PinnedMemoryAllocator* mpAllocator; + CaptureDelegate* mpCaptureDelegate; + + // cache frame in transit between the callback thread and the main BGE thread + // keep only one frame in cache because we just want to keep up with real time + pthread_mutex_t mCacheMutex; + IDeckLinkVideoInputFrame* mpCacheFrame; + bool mClosing; + +}; + +inline VideoDeckLink *getDeckLink(PyImage *self) +{ + return static_cast<VideoDeckLink*>(self->m_image); +} + +//////////////////////////////////////////// +// TextureTransfer : Abstract class to perform a transfer to GPU memory using fast transfer if available +//////////////////////////////////////////// +class TextureTransfer +{ +public: + TextureTransfer() {} + virtual ~TextureTransfer() { } + + virtual void PerformTransfer() = 0; +protected: + static bool _PinBuffer(void *address, uint32_t size); + static void _UnpinBuffer(void* address, uint32_t size); +}; + +//////////////////////////////////////////// +// PinnedMemoryAllocator +//////////////////////////////////////////// + +// PinnedMemoryAllocator implements the IDeckLinkMemoryAllocator interface and can be used instead of the +// built-in frame allocator, by setting with SetVideoInputFrameMemoryAllocator() or SetVideoOutputFrameMemoryAllocator(). +// +// For this sample application a custom frame memory allocator is used to ensure each address +// of frame memory is aligned on a 4kB boundary required by the OpenGL pinned memory extension. +// If the pinned memory extension is not available, this allocator will still be used and +// demonstrates how to cache frame allocations for efficiency. +// +// The frame cache delays the releasing of buffers until the cache fills up, thereby avoiding an +// allocate plus pin operation for every frame, followed by an unpin and deallocate on every frame. + + +class PinnedMemoryAllocator : public IDeckLinkMemoryAllocator +{ +public: + PinnedMemoryAllocator(unsigned cacheSize, size_t memSize); + virtual ~PinnedMemoryAllocator(); + + void TransferBuffer(void* address, TextureDesc* texDesc, GLuint texId); + + // IUnknown methods + virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, LPVOID *ppv); + virtual ULONG STDMETHODCALLTYPE AddRef(void); + virtual ULONG STDMETHODCALLTYPE Release(void); + + // IDeckLinkMemoryAllocator methods + virtual HRESULT STDMETHODCALLTYPE AllocateBuffer(dl_size_t bufferSize, void* *allocatedBuffer); + virtual HRESULT STDMETHODCALLTYPE ReleaseBuffer(void* buffer); + virtual HRESULT STDMETHODCALLTYPE Commit(); + virtual HRESULT STDMETHODCALLTYPE Decommit(); + +private: + static bool mGPUDirectInitialized; + static bool mHasDvp; + static bool mHasAMDPinnedMemory; + static size_t mReservedProcessMemory; + static bool ReserveMemory(size_t size); + + void Lock() + { + pthread_mutex_lock(&mMutex); + } + void Unlock() + { + pthread_mutex_unlock(&mMutex); + } + HRESULT _ReleaseBuffer(void* buffer); + + uint32_t mRefCount; + // protect the cache and the allocated map, + // not the pinnedBuffer map as it is only used from main thread + pthread_mutex_t mMutex; + std::map<void*, uint32_t> mAllocatedSize; + std::vector<void*> mBufferCache; + std::map<void *, TextureTransfer*> mPinnedBuffer; +#ifdef WIN32 + DVPBufferHandle mDvpCaptureTextureHandle; +#endif + // target texture in GPU + GLuint mTexId; + uint32_t mBufferCacheSize; +}; + +//////////////////////////////////////////// +// Capture Delegate Class +//////////////////////////////////////////// + +class CaptureDelegate : public IDeckLinkInputCallback +{ + VideoDeckLink* mpOwner; + +public: + CaptureDelegate(VideoDeckLink* pOwner); + + // IUnknown needs only a dummy implementation + 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 VideoInputFrameArrived(IDeckLinkVideoInputFrame *videoFrame, IDeckLinkAudioInputPacket *audioPacket); + virtual HRESULT STDMETHODCALLTYPE VideoInputFormatChanged(BMDVideoInputFormatChangedEvents notificationEvents, IDeckLinkDisplayMode *newDisplayMode, BMDDetectedVideoInputFormatFlags detectedSignalFlags); +}; + + +#endif /* WITH_GAMEENGINE_DECKLINK */ + +#endif /* __VIDEODECKLINK_H__ */ diff --git a/source/gameengine/VideoTexture/blendVideoTex.cpp b/source/gameengine/VideoTexture/blendVideoTex.cpp index a62ffee3137..9b046d46412 100644 --- a/source/gameengine/VideoTexture/blendVideoTex.cpp +++ b/source/gameengine/VideoTexture/blendVideoTex.cpp @@ -128,6 +128,10 @@ static PyMethodDef moduleMethods[] = extern PyTypeObject VideoFFmpegType; extern PyTypeObject ImageFFmpegType; #endif +#ifdef WITH_GAMEENGINE_DECKLINK +extern PyTypeObject VideoDeckLinkType; +extern PyTypeObject DeckLinkType; +#endif extern PyTypeObject FilterBlueScreenType; extern PyTypeObject FilterGrayType; extern PyTypeObject FilterColorType; @@ -145,6 +149,9 @@ static void registerAllTypes(void) pyImageTypes.add(&VideoFFmpegType, "VideoFFmpeg"); pyImageTypes.add(&ImageFFmpegType, "ImageFFmpeg"); #endif +#ifdef WITH_GAMEENGINE_DECKLINK + pyImageTypes.add(&VideoDeckLinkType, "VideoDeckLink"); +#endif pyImageTypes.add(&ImageBuffType, "ImageBuff"); pyImageTypes.add(&ImageMixType, "ImageMix"); pyImageTypes.add(&ImageRenderType, "ImageRender"); @@ -194,6 +201,10 @@ PyMODINIT_FUNC initVideoTexturePythonBinding(void) return NULL; if (PyType_Ready(&TextureType) < 0) return NULL; +#ifdef WITH_GAMEENGINE_DECKLINK + if (PyType_Ready(&DeckLinkType) < 0) + return NULL; +#endif m = PyModule_Create(&VideoTexture_module_def); PyDict_SetItemString(PySys_GetObject("modules"), VideoTexture_module_def.m_name, m); @@ -207,6 +218,10 @@ PyMODINIT_FUNC initVideoTexturePythonBinding(void) Py_INCREF(&TextureType); PyModule_AddObject(m, "Texture", (PyObject *)&TextureType); +#ifdef WITH_GAMEENGINE_DECKLINK + Py_INCREF(&DeckLinkType); + PyModule_AddObject(m, "DeckLink", (PyObject *)&DeckLinkType); +#endif PyModule_AddIntConstant(m, "SOURCE_ERROR", SourceError); PyModule_AddIntConstant(m, "SOURCE_EMPTY", SourceEmpty); PyModule_AddIntConstant(m, "SOURCE_READY", SourceReady); |