From 1d4eb7a34c660367189497eb1486208dfc661edb Mon Sep 17 00:00:00 2001 From: Aiden Date: Mon, 18 May 2026 14:57:25 +1000 Subject: [PATCH] Folder fixes --- .vscode/launch.json | 85 +- .vscode/tasks.json | 92 +- CMakeLists.txt | 1204 +- src/platform/NativeHandles.h | 42 + src/platform/NativeSockets.h | 42 + src/render/GLExtensions.cpp | 212 + src/render/GLExtensions.h | 201 + src/render/Std140Buffer.h | 48 + src/runtime/RuntimeJson.cpp | 674 + src/runtime/RuntimeJson.h | 65 + src/runtime/RuntimeParameterUtils.cpp | 196 + src/runtime/RuntimeParameterUtils.h | 10 + src/shader/ShaderCompiler.cpp | 326 + src/shader/ShaderCompiler.h | 34 + src/shader/ShaderPackageRegistry.cpp | 818 + src/shader/ShaderPackageRegistry.h | 25 + src/shader/ShaderTypes.h | 159 + src/stdafx.h | 13 + src/video/DeckLinkAPI_h.h | 20433 +++++++++++++++++++++ src/video/DeckLinkAPI_i.c | 486 + src/video/DeckLinkDisplayMode.cpp | 146 + src/video/DeckLinkDisplayMode.h | 47 + src/video/DeckLinkFrameTransfer.cpp | 100 + src/video/DeckLinkFrameTransfer.h | 49 + src/video/DeckLinkSession.cpp | 933 + src/video/DeckLinkSession.h | 102 + src/video/DeckLinkVideoIOFormat.cpp | 28 + src/video/DeckLinkVideoIOFormat.h | 7 + src/video/OutputProductionController.cpp | 89 + src/video/OutputProductionController.h | 46 + src/video/RenderCadenceController.cpp | 102 + src/video/RenderCadenceController.h | 68 + src/video/RenderOutputQueue.cpp | 93 + src/video/RenderOutputQueue.h | 52 + src/video/SystemOutputFramePool.cpp | 260 + src/video/SystemOutputFramePool.h | 94 + src/video/VideoBackend.cpp | 1095 ++ src/video/VideoBackend.h | 161 + src/video/VideoBackendLifecycle.cpp | 123 + src/video/VideoBackendLifecycle.h | 43 + src/video/VideoIOFormat.cpp | 170 + src/video/VideoIOFormat.h | 39 + src/video/VideoIOTypes.h | 164 + src/video/VideoPlayoutPolicy.h | 37 + src/video/VideoPlayoutScheduler.cpp | 108 + src/video/VideoPlayoutScheduler.h | 36 + tests/CMakeLists.txt | 97 + 47 files changed, 28243 insertions(+), 1211 deletions(-) create mode 100644 src/platform/NativeHandles.h create mode 100644 src/platform/NativeSockets.h create mode 100644 src/render/GLExtensions.cpp create mode 100644 src/render/GLExtensions.h create mode 100644 src/render/Std140Buffer.h create mode 100644 src/runtime/RuntimeJson.cpp create mode 100644 src/runtime/RuntimeJson.h create mode 100644 src/runtime/RuntimeParameterUtils.cpp create mode 100644 src/runtime/RuntimeParameterUtils.h create mode 100644 src/shader/ShaderCompiler.cpp create mode 100644 src/shader/ShaderCompiler.h create mode 100644 src/shader/ShaderPackageRegistry.cpp create mode 100644 src/shader/ShaderPackageRegistry.h create mode 100644 src/shader/ShaderTypes.h create mode 100644 src/stdafx.h create mode 100644 src/video/DeckLinkAPI_h.h create mode 100644 src/video/DeckLinkAPI_i.c create mode 100644 src/video/DeckLinkDisplayMode.cpp create mode 100644 src/video/DeckLinkDisplayMode.h create mode 100644 src/video/DeckLinkFrameTransfer.cpp create mode 100644 src/video/DeckLinkFrameTransfer.h create mode 100644 src/video/DeckLinkSession.cpp create mode 100644 src/video/DeckLinkSession.h create mode 100644 src/video/DeckLinkVideoIOFormat.cpp create mode 100644 src/video/DeckLinkVideoIOFormat.h create mode 100644 src/video/OutputProductionController.cpp create mode 100644 src/video/OutputProductionController.h create mode 100644 src/video/RenderCadenceController.cpp create mode 100644 src/video/RenderCadenceController.h create mode 100644 src/video/RenderOutputQueue.cpp create mode 100644 src/video/RenderOutputQueue.h create mode 100644 src/video/SystemOutputFramePool.cpp create mode 100644 src/video/SystemOutputFramePool.h create mode 100644 src/video/VideoBackend.cpp create mode 100644 src/video/VideoBackend.h create mode 100644 src/video/VideoBackendLifecycle.cpp create mode 100644 src/video/VideoBackendLifecycle.h create mode 100644 src/video/VideoIOFormat.cpp create mode 100644 src/video/VideoIOFormat.h create mode 100644 src/video/VideoIOTypes.h create mode 100644 src/video/VideoPlayoutPolicy.h create mode 100644 src/video/VideoPlayoutScheduler.cpp create mode 100644 src/video/VideoPlayoutScheduler.h create mode 100644 tests/CMakeLists.txt diff --git a/.vscode/launch.json b/.vscode/launch.json index 57ffa35..2bc8179 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -1,89 +1,6 @@ { "version": "0.2.0", "configurations": [ - { - "name": "Debug LoopThroughWithOpenGLCompositing", - "type": "cppvsdbg", - "request": "launch", - "program": "${workspaceFolder}\\build\\vs2022-x64-debug\\Debug\\LoopThroughWithOpenGLCompositing.exe", - "args": [], - "stopAtEntry": false, - "cwd": "${workspaceFolder}\\build\\vs2022-x64-debug\\Debug", - "environment": [ - { - "name": "VST_DISABLE_INPUT_CAPTURE", - "value": "1" - } - ], - "console": "internalConsole", - "symbolSearchPath": "${workspaceFolder}\\build\\vs2022-x64-debug\\Debug", - "requireExactSource": true, - "logging": { - "moduleLoad": true - }, - "preLaunchTask": "Build LoopThroughWithOpenGLCompositing Debug x64" - }, - { - "name": "Debug LoopThroughWithOpenGLCompositing - sync readback experiment", - "type": "cppvsdbg", - "request": "launch", - "program": "${workspaceFolder}\\build\\vs2022-x64-debug\\Debug\\LoopThroughWithOpenGLCompositing.exe", - "args": [], - "stopAtEntry": false, - "cwd": "${workspaceFolder}\\build\\vs2022-x64-debug\\Debug", - "environment": [ - { - "name": "VST_OUTPUT_READBACK_MODE", - "value": "sync" - } - ], - "console": "internalConsole", - "symbolSearchPath": "${workspaceFolder}\\build\\vs2022-x64-debug\\Debug", - "requireExactSource": true, - "logging": { - "moduleLoad": true - }, - "preLaunchTask": "Build LoopThroughWithOpenGLCompositing Debug x64" - }, - { - "name": "Debug LoopThroughWithOpenGLCompositing - cached output experiment", - "type": "cppvsdbg", - "request": "launch", - "program": "${workspaceFolder}\\build\\vs2022-x64-debug\\Debug\\LoopThroughWithOpenGLCompositing.exe", - "args": [], - "stopAtEntry": false, - "cwd": "${workspaceFolder}\\build\\vs2022-x64-debug\\Debug", - "environment": [ - { - "name": "VST_OUTPUT_READBACK_MODE", - "value": "cached_only" - } - ], - "console": "internalConsole", - "symbolSearchPath": "${workspaceFolder}\\build\\vs2022-x64-debug\\Debug", - "requireExactSource": true, - "logging": { - "moduleLoad": true - }, - "preLaunchTask": "Build LoopThroughWithOpenGLCompositing Debug x64" - }, - { - "name": "Debug DeckLinkRenderCadenceProbe", - "type": "cppvsdbg", - "request": "launch", - "program": "${workspaceFolder}\\build\\vs2022-x64-debug\\Debug\\DeckLinkRenderCadenceProbe.exe", - "args": [], - "stopAtEntry": false, - "cwd": "${workspaceFolder}\\build\\vs2022-x64-debug\\Debug", - "environment": [], - "console": "externalTerminal", - "symbolSearchPath": "${workspaceFolder}\\build\\vs2022-x64-debug\\Debug", - "requireExactSource": true, - "logging": { - "moduleLoad": true - }, - "preLaunchTask": "Build DeckLinkRenderCadenceProbe Debug x64" - }, { "name": "Debug RenderCadenceCompositor", "type": "cppvsdbg", @@ -91,7 +8,7 @@ "program": "${workspaceFolder}\\build\\vs2022-x64-debug\\Debug\\RenderCadenceCompositor.exe", "args": [], "stopAtEntry": false, - "cwd": "${workspaceFolder}\\build\\vs2022-x64-debug\\Debug", + "cwd": "${workspaceFolder}", "environment": [], "console": "externalTerminal", "symbolSearchPath": "${workspaceFolder}\\build\\vs2022-x64-debug\\Debug", diff --git a/.vscode/tasks.json b/.vscode/tasks.json index 01a2058..02b10e2 100644 --- a/.vscode/tasks.json +++ b/.vscode/tasks.json @@ -2,60 +2,19 @@ "version": "2.0.0", "tasks": [ { - "label": "Build LoopThroughWithOpenGLCompositing Debug x64", + "label": "Configure Debug x64", "type": "process", - "command": "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\Common7\\IDE\\CommonExtensions\\Microsoft\\CMake\\CMake\\bin\\cmake.exe", + "command": "cmake", "args": [ - "--build", - "${workspaceFolder}\\build\\vs2022-x64-debug", - "--config", - "Debug", - "--target", - "LoopThroughWithOpenGLCompositing", - "--parallel" + "--preset", + "vs2022-x64-debug" ], - "group": { - "kind": "build", - "isDefault": true - }, - "problemMatcher": "$msCompile" - }, - { - "label": "Build LoopThroughWithOpenGLCompositing Release x64", - "type": "process", - "command": "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\Common7\\IDE\\CommonExtensions\\Microsoft\\CMake\\CMake\\bin\\cmake.exe", - "args": [ - "--build", - "${workspaceFolder}\\build\\vs2022-x64-release", - "--config", - "Release", - "--target", - "LoopThroughWithOpenGLCompositing", - "--parallel" - ], - "group": "build", - "problemMatcher": "$msCompile" - }, - { - "label": "Build DeckLinkRenderCadenceProbe Debug x64", - "type": "process", - "command": "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\Common7\\IDE\\CommonExtensions\\Microsoft\\CMake\\CMake\\bin\\cmake.exe", - "args": [ - "--build", - "${workspaceFolder}\\build\\vs2022-x64-debug", - "--config", - "Debug", - "--target", - "DeckLinkRenderCadenceProbe", - "--parallel" - ], - "group": "build", "problemMatcher": "$msCompile" }, { "label": "Build RenderCadenceCompositor Debug x64", "type": "process", - "command": "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\Common7\\IDE\\CommonExtensions\\Microsoft\\CMake\\CMake\\bin\\cmake.exe", + "command": "cmake", "args": [ "--build", "${workspaceFolder}\\build\\vs2022-x64-debug", @@ -65,13 +24,50 @@ "RenderCadenceCompositor", "--parallel" ], + "group": { + "kind": "build", + "isDefault": true + }, + "dependsOn": "Configure Debug x64", + "problemMatcher": "$msCompile" + }, + { + "label": "Build RenderCadenceCompositor Release x64", + "type": "process", + "command": "cmake", + "args": [ + "--build", + "${workspaceFolder}\\build\\vs2022-x64-release", + "--config", + "Release", + "--target", + "RenderCadenceCompositor", + "--parallel" + ], "group": "build", "problemMatcher": "$msCompile" }, { - "label": "Clean LoopThroughWithOpenGLCompositing Debug x64", + "label": "Run Native Tests Debug x64", "type": "process", - "command": "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\Common7\\IDE\\CommonExtensions\\Microsoft\\CMake\\CMake\\bin\\cmake.exe", + "command": "cmake", + "args": [ + "--build", + "${workspaceFolder}\\build\\vs2022-x64-debug", + "--config", + "Debug", + "--target", + "RUN_TESTS", + "--parallel" + ], + "group": "test", + "dependsOn": "Configure Debug x64", + "problemMatcher": "$msCompile" + }, + { + "label": "Clean Debug x64", + "type": "process", + "command": "cmake", "args": [ "--build", "${workspaceFolder}\\build\\vs2022-x64-debug", diff --git a/CMakeLists.txt b/CMakeLists.txt index 74cf985..b86208e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,1101 +1,149 @@ cmake_minimum_required(VERSION 3.24) -project(video_shader LANGUAGES C CXX RC) +project(video_shader LANGUAGES C CXX) + +include(CTest) set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_EXTENSIONS OFF) -set(APP_DIR "${CMAKE_CURRENT_SOURCE_DIR}/apps/LoopThroughWithOpenGLCompositing") +set(SRC_DIR "${CMAKE_CURRENT_SOURCE_DIR}/src") +set(TEST_DIR "${CMAKE_CURRENT_SOURCE_DIR}/tests") set(SLANG_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/3rdParty/slang-2026.8-windows-x86_64" CACHE PATH "Path to a Slang binary release containing bin/slangc.exe") -if(NOT EXISTS "${APP_DIR}/LoopThroughWithOpenGLCompositing.cpp") - message(FATAL_ERROR "Imported app sources were not found under ${APP_DIR}") -endif() +set(VIDEO_SHADER_INCLUDE_DIRS + "${SRC_DIR}" + "${SRC_DIR}/app" + "${SRC_DIR}/control" + "${SRC_DIR}/control/http" + "${SRC_DIR}/frames" + "${SRC_DIR}/json" + "${SRC_DIR}/logging" + "${SRC_DIR}/platform" + "${SRC_DIR}/render" + "${SRC_DIR}/render/readback" + "${SRC_DIR}/render/runtime" + "${SRC_DIR}/runtime" + "${SRC_DIR}/shader" + "${SRC_DIR}/telemetry" + "${SRC_DIR}/video" +) + +function(video_shader_target_defaults target) + target_include_directories(${target} PRIVATE ${VIDEO_SHADER_INCLUDE_DIRS}) + target_compile_definitions(${target} PRIVATE _UNICODE UNICODE) + if(MSVC) + target_compile_options(${target} PRIVATE /W3) + endif() +endfunction() + +function(video_shader_files_exist out_var) + set(missing_files) + foreach(file IN LISTS ARGN) + if(NOT EXISTS "${file}") + list(APPEND missing_files "${file}") + endif() + endforeach() + set(${out_var} "${missing_files}" PARENT_SCOPE) +endfunction() + +function(add_video_shader_test name) + add_executable(${name} ${ARGN}) + video_shader_target_defaults(${name}) + add_test(NAME ${name} COMMAND ${name}) +endfunction() set(SLANG_RUNTIME_FILES "${SLANG_ROOT}/bin/slangc.exe" "${SLANG_ROOT}/bin/slang-compiler.dll" "${SLANG_ROOT}/bin/slang-glslang.dll" ) +set(SLANG_LICENSE_FILE "${SLANG_ROOT}/LICENSE") -foreach(SLANG_RUNTIME_FILE IN LISTS SLANG_RUNTIME_FILES) - if(NOT EXISTS "${SLANG_RUNTIME_FILE}") - message(FATAL_ERROR "Required Slang runtime file not found: ${SLANG_RUNTIME_FILE}") +set(RENDER_CADENCE_APP_REQUIRED_FILES + "${SRC_DIR}/RenderCadenceCompositor.cpp" + "${SRC_DIR}/video/DeckLinkAPI_i.c" + "${SRC_DIR}/video/DeckLinkAPI_h.h" + "${SRC_DIR}/video/DeckLinkDisplayMode.cpp" + "${SRC_DIR}/video/DeckLinkDisplayMode.h" + "${SRC_DIR}/video/DeckLinkSession.cpp" + "${SRC_DIR}/video/DeckLinkSession.h" + "${SRC_DIR}/video/DeckLinkVideoIOFormat.cpp" + "${SRC_DIR}/video/DeckLinkVideoIOFormat.h" + "${SRC_DIR}/video/VideoIOFormat.cpp" + "${SRC_DIR}/video/VideoIOFormat.h" + "${SRC_DIR}/video/VideoIOTypes.h" + "${SRC_DIR}/render/GLExtensions.cpp" + "${SRC_DIR}/render/GLExtensions.h" + "${SRC_DIR}/render/Std140Buffer.h" + "${SRC_DIR}/runtime/RuntimeJson.cpp" + "${SRC_DIR}/runtime/RuntimeJson.h" + "${SRC_DIR}/runtime/RuntimeParameterUtils.cpp" + "${SRC_DIR}/runtime/RuntimeParameterUtils.h" + "${SRC_DIR}/shader/ShaderCompiler.cpp" + "${SRC_DIR}/shader/ShaderCompiler.h" + "${SRC_DIR}/shader/ShaderPackageRegistry.cpp" + "${SRC_DIR}/shader/ShaderPackageRegistry.h" + "${SRC_DIR}/shader/ShaderTypes.h" +) + +video_shader_files_exist(RENDER_CADENCE_APP_MISSING_FILES ${RENDER_CADENCE_APP_REQUIRED_FILES}) +if(RENDER_CADENCE_APP_MISSING_FILES) + message(STATUS "RenderCadenceCompositor target skipped; source reorganization has not provided these legacy shared files:") + foreach(missing_file IN LISTS RENDER_CADENCE_APP_MISSING_FILES) + message(STATUS " ${missing_file}") + endforeach() +else() + file(GLOB_RECURSE RENDER_CADENCE_APP_SOURCES CONFIGURE_DEPENDS + "${SRC_DIR}/*.c" + "${SRC_DIR}/*.cpp" + "${SRC_DIR}/*.h" + ) + list(REMOVE_ITEM RENDER_CADENCE_APP_SOURCES + "${SRC_DIR}/video/VideoBackend.cpp" + "${SRC_DIR}/video/VideoBackend.h" + ) + + add_executable(RenderCadenceCompositor ${RENDER_CADENCE_APP_SOURCES}) + video_shader_target_defaults(RenderCadenceCompositor) + target_link_libraries(RenderCadenceCompositor PRIVATE + opengl32 + Ole32 + Ws2_32 + ) + source_group(TREE "${SRC_DIR}" FILES ${RENDER_CADENCE_APP_SOURCES}) +endif() + +if(BUILD_TESTING) + add_subdirectory(tests) +endif() + +if(TARGET RenderCadenceCompositor) + install(TARGETS RenderCadenceCompositor + RUNTIME DESTINATION "." + ) +endif() + +foreach(slang_runtime_file IN LISTS SLANG_RUNTIME_FILES) + if(EXISTS "${slang_runtime_file}") + install(FILES "${slang_runtime_file}" + DESTINATION "3rdParty/slang/bin" + ) + else() + message(STATUS "Slang runtime file not found and will not be installed: ${slang_runtime_file}") endif() endforeach() -set(SLANG_LICENSE_FILE "${SLANG_ROOT}/LICENSE") -if(NOT EXISTS "${SLANG_LICENSE_FILE}") - message(FATAL_ERROR "Slang license file not found: ${SLANG_LICENSE_FILE}") +if(EXISTS "${SLANG_LICENSE_FILE}") + install(FILES "${SLANG_LICENSE_FILE}" + DESTINATION "third_party_notices" + RENAME "SLANG_LICENSE.txt" + ) +else() + message(STATUS "Slang license file not found and will not be installed: ${SLANG_LICENSE_FILE}") endif() -set(APP_SOURCES - "${APP_DIR}/videoio/decklink/DeckLinkAPI_i.c" - "${APP_DIR}/control/ControlServer.cpp" - "${APP_DIR}/control/ControlServer.h" - "${APP_DIR}/control/ControlServices.cpp" - "${APP_DIR}/control/ControlServices.h" - "${APP_DIR}/control/OscServer.cpp" - "${APP_DIR}/control/OscServer.h" - "${APP_DIR}/control/RuntimeControlBridge.cpp" - "${APP_DIR}/control/RuntimeControlBridge.h" - "${APP_DIR}/control/RuntimeServiceLiveBridge.cpp" - "${APP_DIR}/control/RuntimeServiceLiveBridge.h" - "${APP_DIR}/control/RuntimeServices.cpp" - "${APP_DIR}/control/RuntimeServices.h" - "${APP_DIR}/videoio/decklink/DeckLinkAPI_h.h" - "${APP_DIR}/videoio/decklink/DeckLinkDisplayMode.cpp" - "${APP_DIR}/videoio/decklink/DeckLinkDisplayMode.h" - "${APP_DIR}/videoio/decklink/DeckLinkFrameTransfer.cpp" - "${APP_DIR}/videoio/decklink/DeckLinkFrameTransfer.h" - "${APP_DIR}/videoio/decklink/DeckLinkSession.cpp" - "${APP_DIR}/videoio/decklink/DeckLinkSession.h" - "${APP_DIR}/videoio/decklink/DeckLinkVideoIOFormat.cpp" - "${APP_DIR}/videoio/decklink/DeckLinkVideoIOFormat.h" - "${APP_DIR}/gl/renderer/GLExtensions.cpp" - "${APP_DIR}/gl/renderer/GLExtensions.h" - "${APP_DIR}/gl/shader/GlobalParamsBuffer.cpp" - "${APP_DIR}/gl/shader/GlobalParamsBuffer.h" - "${APP_DIR}/gl/renderer/GlRenderConstants.h" - "${APP_DIR}/gl/renderer/GlScopedObjects.h" - "${APP_DIR}/gl/shader/GlShaderSources.cpp" - "${APP_DIR}/gl/shader/GlShaderSources.h" - "${APP_DIR}/gl/composite/OpenGLComposite.cpp" - "${APP_DIR}/gl/composite/OpenGLComposite.h" - "${APP_DIR}/gl/composite/OpenGLCompositeRuntimeControls.cpp" - "${APP_DIR}/gl/threading/RenderCommandQueue.cpp" - "${APP_DIR}/gl/threading/RenderCommandQueue.h" - "${APP_DIR}/gl/RenderEngine.cpp" - "${APP_DIR}/gl/RenderEngine.h" - "${APP_DIR}/gl/frame/RenderFrameState.h" - "${APP_DIR}/gl/frame/RenderFrameStateResolver.cpp" - "${APP_DIR}/gl/frame/RenderFrameStateResolver.h" - "${APP_DIR}/gl/frame/RuntimeUpdateController.cpp" - "${APP_DIR}/gl/frame/RuntimeUpdateController.h" - "${APP_DIR}/gl/pipeline/OpenGLRenderPass.cpp" - "${APP_DIR}/gl/pipeline/OpenGLRenderPass.h" - "${APP_DIR}/gl/pipeline/OpenGLRenderPipeline.cpp" - "${APP_DIR}/gl/pipeline/OpenGLRenderPipeline.h" - "${APP_DIR}/gl/pipeline/RenderPassDescriptor.h" - "${APP_DIR}/gl/pipeline/ShaderFeedbackBuffers.cpp" - "${APP_DIR}/gl/pipeline/ShaderFeedbackBuffers.h" - "${APP_DIR}/gl/renderer/OpenGLRenderer.cpp" - "${APP_DIR}/gl/renderer/OpenGLRenderer.h" - "${APP_DIR}/gl/renderer/RenderTargetPool.cpp" - "${APP_DIR}/gl/renderer/RenderTargetPool.h" - "${APP_DIR}/gl/pipeline/OpenGLVideoIOBridge.cpp" - "${APP_DIR}/gl/pipeline/OpenGLVideoIOBridge.h" - "${APP_DIR}/gl/shader/OpenGLShaderPrograms.cpp" - "${APP_DIR}/gl/shader/OpenGLShaderPrograms.h" - "${APP_DIR}/gl/pipeline/PngScreenshotWriter.cpp" - "${APP_DIR}/gl/pipeline/PngScreenshotWriter.h" - "${APP_DIR}/gl/shader/ShaderProgramCompiler.cpp" - "${APP_DIR}/gl/shader/ShaderProgramCompiler.h" - "${APP_DIR}/gl/shader/ShaderBuildQueue.cpp" - "${APP_DIR}/gl/shader/ShaderBuildQueue.h" - "${APP_DIR}/gl/shader/ShaderTextureBindings.cpp" - "${APP_DIR}/gl/shader/ShaderTextureBindings.h" - "${APP_DIR}/gl/shader/Std140Buffer.h" - "${APP_DIR}/gl/shader/TextRasterizer.cpp" - "${APP_DIR}/gl/shader/TextRasterizer.h" - "${APP_DIR}/gl/shader/TextureAssetLoader.cpp" - "${APP_DIR}/gl/shader/TextureAssetLoader.h" - "${APP_DIR}/gl/pipeline/TemporalHistoryBuffers.cpp" - "${APP_DIR}/gl/pipeline/TemporalHistoryBuffers.h" - "${APP_DIR}/LoopThroughWithOpenGLCompositing.cpp" - "${APP_DIR}/LoopThroughWithOpenGLCompositing.h" - "${APP_DIR}/LoopThroughWithOpenGLCompositing.rc" - "${APP_DIR}/platform/NativeHandles.h" - "${APP_DIR}/platform/NativeSockets.h" - "${APP_DIR}/resource.h" - "${APP_DIR}/runtime/coordination/RuntimeCoordinator.cpp" - "${APP_DIR}/runtime/coordination/RuntimeCoordinator.h" - "${APP_DIR}/runtime/events/RuntimeEventCoalescingQueue.h" - "${APP_DIR}/runtime/events/RuntimeEventDispatcher.h" - "${APP_DIR}/runtime/events/RuntimeEvent.h" - "${APP_DIR}/runtime/events/RuntimeEventPayloads.h" - "${APP_DIR}/runtime/events/RuntimeEventQueue.h" - "${APP_DIR}/runtime/events/RuntimeEventType.h" - "${APP_DIR}/runtime/live/CommittedLiveState.cpp" - "${APP_DIR}/runtime/live/CommittedLiveState.h" - "${APP_DIR}/runtime/live/RenderStateComposer.cpp" - "${APP_DIR}/runtime/live/RenderStateComposer.h" - "${APP_DIR}/runtime/live/RuntimeStateLayerModel.cpp" - "${APP_DIR}/runtime/live/RuntimeStateLayerModel.h" - "${APP_DIR}/runtime/live/RuntimeLiveState.cpp" - "${APP_DIR}/runtime/live/RuntimeLiveState.h" - "${APP_DIR}/runtime/persistence/PersistenceRequest.h" - "${APP_DIR}/runtime/persistence/PersistenceWriter.cpp" - "${APP_DIR}/runtime/persistence/PersistenceWriter.h" - "${APP_DIR}/runtime/presentation/RuntimeStateJson.cpp" - "${APP_DIR}/runtime/presentation/RuntimeStateJson.h" - "${APP_DIR}/runtime/presentation/RuntimeStatePresenter.cpp" - "${APP_DIR}/runtime/presentation/RuntimeStatePresenter.h" - "${APP_DIR}/runtime/snapshot/RenderSnapshotBuilder.cpp" - "${APP_DIR}/runtime/snapshot/RenderSnapshotBuilder.h" - "${APP_DIR}/runtime/snapshot/RuntimeSnapshotProvider.cpp" - "${APP_DIR}/runtime/snapshot/RuntimeSnapshotProvider.h" - "${APP_DIR}/runtime/store/LayerStackStore.cpp" - "${APP_DIR}/runtime/store/LayerStackStore.h" - "${APP_DIR}/runtime/store/RuntimeConfigStore.cpp" - "${APP_DIR}/runtime/store/RuntimeConfigStore.h" - "${APP_DIR}/runtime/store/RuntimeStore.cpp" - "${APP_DIR}/runtime/store/RuntimeStore.h" - "${APP_DIR}/runtime/store/RuntimeStoreReadModels.h" - "${APP_DIR}/runtime/store/ShaderPackageCatalog.cpp" - "${APP_DIR}/runtime/store/ShaderPackageCatalog.h" - "${APP_DIR}/runtime/support/RuntimeJson.cpp" - "${APP_DIR}/runtime/support/RuntimeJson.h" - "${APP_DIR}/runtime/support/RuntimeParameterUtils.cpp" - "${APP_DIR}/runtime/support/RuntimeParameterUtils.h" - "${APP_DIR}/runtime/telemetry/HealthTelemetry.cpp" - "${APP_DIR}/runtime/telemetry/HealthTelemetry.h" - "${APP_DIR}/runtime/telemetry/RuntimeClock.cpp" - "${APP_DIR}/runtime/telemetry/RuntimeClock.h" - "${APP_DIR}/shader/ShaderCompiler.cpp" - "${APP_DIR}/shader/ShaderCompiler.h" - "${APP_DIR}/shader/ShaderPackageRegistry.cpp" - "${APP_DIR}/shader/ShaderPackageRegistry.h" - "${APP_DIR}/shader/ShaderTypes.h" - "${APP_DIR}/stdafx.cpp" - "${APP_DIR}/stdafx.h" - "${APP_DIR}/targetver.h" - "${APP_DIR}/videoio/VideoIOFormat.cpp" - "${APP_DIR}/videoio/VideoIOFormat.h" - "${APP_DIR}/videoio/VideoBackend.cpp" - "${APP_DIR}/videoio/VideoBackend.h" - "${APP_DIR}/videoio/VideoBackendLifecycle.cpp" - "${APP_DIR}/videoio/VideoBackendLifecycle.h" - "${APP_DIR}/videoio/VideoIOTypes.h" - "${APP_DIR}/videoio/OutputProductionController.cpp" - "${APP_DIR}/videoio/OutputProductionController.h" - "${APP_DIR}/videoio/RenderCadenceController.cpp" - "${APP_DIR}/videoio/RenderCadenceController.h" - "${APP_DIR}/videoio/RenderOutputQueue.cpp" - "${APP_DIR}/videoio/RenderOutputQueue.h" - "${APP_DIR}/videoio/SystemOutputFramePool.cpp" - "${APP_DIR}/videoio/SystemOutputFramePool.h" - "${APP_DIR}/videoio/VideoPlayoutPolicy.h" - "${APP_DIR}/videoio/VideoPlayoutScheduler.cpp" - "${APP_DIR}/videoio/VideoPlayoutScheduler.h" -) - -add_executable(LoopThroughWithOpenGLCompositing WIN32 ${APP_SOURCES}) - -target_include_directories(LoopThroughWithOpenGLCompositing PRIVATE - "${APP_DIR}" - "${APP_DIR}/control" - "${APP_DIR}/gl" - "${APP_DIR}/gl/composite" - "${APP_DIR}/gl/frame" - "${APP_DIR}/gl/pipeline" - "${APP_DIR}/gl/renderer" - "${APP_DIR}/gl/shader" - "${APP_DIR}/gl/threading" - "${APP_DIR}/platform" - "${APP_DIR}/runtime" - "${APP_DIR}/runtime/coordination" - "${APP_DIR}/runtime/events" - "${APP_DIR}/runtime/live" - "${APP_DIR}/runtime/persistence" - "${APP_DIR}/runtime/presentation" - "${APP_DIR}/runtime/snapshot" - "${APP_DIR}/runtime/store" - "${APP_DIR}/runtime/support" - "${APP_DIR}/runtime/telemetry" - "${APP_DIR}/shader" - "${APP_DIR}/videoio" - "${APP_DIR}/videoio/decklink" -) - -target_link_libraries(LoopThroughWithOpenGLCompositing PRIVATE - opengl32 - glu32 - Ws2_32 - Crypt32 - Advapi32 - Gdiplus - Ole32 - Windowscodecs -) - -target_compile_definitions(LoopThroughWithOpenGLCompositing PRIVATE - _UNICODE - UNICODE -) - -if(MSVC) - target_compile_options(LoopThroughWithOpenGLCompositing PRIVATE /W3) -endif() - -set(PROBE_APP_DIR "${CMAKE_CURRENT_SOURCE_DIR}/apps/DeckLinkRenderCadenceProbe") - -add_executable(DeckLinkRenderCadenceProbe - "${APP_DIR}/videoio/decklink/DeckLinkAPI_i.c" - "${APP_DIR}/videoio/decklink/DeckLinkDisplayMode.cpp" - "${APP_DIR}/videoio/decklink/DeckLinkDisplayMode.h" - "${APP_DIR}/videoio/decklink/DeckLinkFrameTransfer.cpp" - "${APP_DIR}/videoio/decklink/DeckLinkFrameTransfer.h" - "${APP_DIR}/videoio/decklink/DeckLinkSession.cpp" - "${APP_DIR}/videoio/decklink/DeckLinkSession.h" - "${APP_DIR}/videoio/decklink/DeckLinkVideoIOFormat.cpp" - "${APP_DIR}/videoio/decklink/DeckLinkVideoIOFormat.h" - "${APP_DIR}/gl/renderer/GLExtensions.cpp" - "${APP_DIR}/gl/renderer/GLExtensions.h" - "${APP_DIR}/videoio/VideoIOFormat.cpp" - "${APP_DIR}/videoio/VideoIOFormat.h" - "${APP_DIR}/videoio/VideoIOTypes.h" - "${APP_DIR}/videoio/VideoPlayoutPolicy.h" - "${APP_DIR}/videoio/VideoPlayoutScheduler.cpp" - "${APP_DIR}/videoio/VideoPlayoutScheduler.h" - "${PROBE_APP_DIR}/DeckLinkRenderCadenceProbe.cpp" -) - -target_include_directories(DeckLinkRenderCadenceProbe PRIVATE - "${APP_DIR}" - "${APP_DIR}/gl/renderer" - "${APP_DIR}/videoio" - "${APP_DIR}/videoio/decklink" -) - -target_link_libraries(DeckLinkRenderCadenceProbe PRIVATE - opengl32 - Ole32 -) - -target_compile_definitions(DeckLinkRenderCadenceProbe PRIVATE - _UNICODE - UNICODE -) - -if(MSVC) - target_compile_options(DeckLinkRenderCadenceProbe PRIVATE /W3) -endif() - -set(RENDER_CADENCE_APP_DIR "${CMAKE_CURRENT_SOURCE_DIR}/apps/RenderCadenceCompositor") - -set(RENDER_CADENCE_APP_SOURCES - "${APP_DIR}/videoio/decklink/DeckLinkAPI_i.c" - "${APP_DIR}/videoio/decklink/DeckLinkDisplayMode.cpp" - "${APP_DIR}/videoio/decklink/DeckLinkDisplayMode.h" - "${APP_DIR}/videoio/decklink/DeckLinkFrameTransfer.cpp" - "${APP_DIR}/videoio/decklink/DeckLinkFrameTransfer.h" - "${APP_DIR}/videoio/decklink/DeckLinkSession.cpp" - "${APP_DIR}/videoio/decklink/DeckLinkSession.h" - "${APP_DIR}/videoio/decklink/DeckLinkVideoIOFormat.cpp" - "${APP_DIR}/videoio/decklink/DeckLinkVideoIOFormat.h" - "${APP_DIR}/gl/renderer/GLExtensions.cpp" - "${APP_DIR}/gl/renderer/GLExtensions.h" - "${APP_DIR}/gl/shader/Std140Buffer.h" - "${APP_DIR}/runtime/support/RuntimeJson.cpp" - "${APP_DIR}/runtime/support/RuntimeJson.h" - "${APP_DIR}/runtime/support/RuntimeParameterUtils.cpp" - "${APP_DIR}/runtime/support/RuntimeParameterUtils.h" - "${APP_DIR}/shader/ShaderCompiler.cpp" - "${APP_DIR}/shader/ShaderCompiler.h" - "${APP_DIR}/shader/ShaderPackageRegistry.cpp" - "${APP_DIR}/shader/ShaderPackageRegistry.h" - "${APP_DIR}/shader/ShaderTypes.h" - "${APP_DIR}/videoio/VideoIOFormat.cpp" - "${APP_DIR}/videoio/VideoIOFormat.h" - "${APP_DIR}/videoio/VideoIOTypes.h" - "${APP_DIR}/videoio/VideoPlayoutPolicy.h" - "${APP_DIR}/videoio/VideoPlayoutScheduler.cpp" - "${APP_DIR}/videoio/VideoPlayoutScheduler.h" - "${RENDER_CADENCE_APP_DIR}/RenderCadenceCompositor.cpp" - "${RENDER_CADENCE_APP_DIR}/app/AppConfig.cpp" - "${RENDER_CADENCE_APP_DIR}/app/AppConfig.h" - "${RENDER_CADENCE_APP_DIR}/app/AppConfigProvider.cpp" - "${RENDER_CADENCE_APP_DIR}/app/AppConfigProvider.h" - "${RENDER_CADENCE_APP_DIR}/app/RenderCadenceApp.h" - "${RENDER_CADENCE_APP_DIR}/app/RuntimeLayerController.cpp" - "${RENDER_CADENCE_APP_DIR}/app/RuntimeLayerControllerBuild.cpp" - "${RENDER_CADENCE_APP_DIR}/app/RuntimeLayerControllerControls.cpp" - "${RENDER_CADENCE_APP_DIR}/app/RuntimeLayerController.h" - "${RENDER_CADENCE_APP_DIR}/control/ControlActionResult.h" - "${RENDER_CADENCE_APP_DIR}/control/RuntimeControlCommand.cpp" - "${RENDER_CADENCE_APP_DIR}/control/RuntimeControlCommand.h" - "${RENDER_CADENCE_APP_DIR}/control/http/HttpControlServer.cpp" - "${RENDER_CADENCE_APP_DIR}/control/http/HttpControlServer.h" - "${RENDER_CADENCE_APP_DIR}/control/http/HttpControlServerRoutes.cpp" - "${RENDER_CADENCE_APP_DIR}/control/http/HttpControlServerWebSocket.cpp" - "${RENDER_CADENCE_APP_DIR}/control/RuntimeStateJson.h" - "${RENDER_CADENCE_APP_DIR}/frames/InputFrameMailbox.cpp" - "${RENDER_CADENCE_APP_DIR}/frames/InputFrameMailbox.h" - "${RENDER_CADENCE_APP_DIR}/frames/SystemFrameExchange.cpp" - "${RENDER_CADENCE_APP_DIR}/frames/SystemFrameExchange.h" - "${RENDER_CADENCE_APP_DIR}/frames/SystemFrameTypes.h" - "${RENDER_CADENCE_APP_DIR}/json/JsonWriter.cpp" - "${RENDER_CADENCE_APP_DIR}/json/JsonWriter.h" - "${RENDER_CADENCE_APP_DIR}/logging/Logger.cpp" - "${RENDER_CADENCE_APP_DIR}/logging/Logger.h" - "${RENDER_CADENCE_APP_DIR}/platform/HiddenGlWindow.cpp" - "${RENDER_CADENCE_APP_DIR}/platform/HiddenGlWindow.h" - "${RENDER_CADENCE_APP_DIR}/render/InputFrameTexture.cpp" - "${RENDER_CADENCE_APP_DIR}/render/InputFrameTexture.h" - "${RENDER_CADENCE_APP_DIR}/render/readback/Bgra8ReadbackPipeline.cpp" - "${RENDER_CADENCE_APP_DIR}/render/readback/Bgra8ReadbackPipeline.h" - "${RENDER_CADENCE_APP_DIR}/render/readback/PboReadbackRing.cpp" - "${RENDER_CADENCE_APP_DIR}/render/readback/PboReadbackRing.h" - "${RENDER_CADENCE_APP_DIR}/render/RenderCadenceClock.cpp" - "${RENDER_CADENCE_APP_DIR}/render/RenderCadenceClock.h" - "${RENDER_CADENCE_APP_DIR}/render/RenderThread.cpp" - "${RENDER_CADENCE_APP_DIR}/render/RenderThread.h" - "${RENDER_CADENCE_APP_DIR}/render/runtime/RuntimeShaderRenderer.cpp" - "${RENDER_CADENCE_APP_DIR}/render/runtime/RuntimeShaderRenderer.h" - "${RENDER_CADENCE_APP_DIR}/render/runtime/RuntimeShaderParams.cpp" - "${RENDER_CADENCE_APP_DIR}/render/runtime/RuntimeShaderParams.h" - "${RENDER_CADENCE_APP_DIR}/render/runtime/RuntimeRenderScene.cpp" - "${RENDER_CADENCE_APP_DIR}/render/runtime/RuntimeRenderScene.h" - "${RENDER_CADENCE_APP_DIR}/render/runtime/RuntimeRenderSceneRender.cpp" - "${RENDER_CADENCE_APP_DIR}/render/runtime/RuntimeShaderPrepareWorker.cpp" - "${RENDER_CADENCE_APP_DIR}/render/runtime/RuntimeShaderPrepareWorker.h" - "${RENDER_CADENCE_APP_DIR}/render/runtime/RuntimeShaderProgram.h" - "${RENDER_CADENCE_APP_DIR}/render/SimpleMotionRenderer.cpp" - "${RENDER_CADENCE_APP_DIR}/render/SimpleMotionRenderer.h" - "${RENDER_CADENCE_APP_DIR}/runtime/RuntimeLayerModel.cpp" - "${RENDER_CADENCE_APP_DIR}/runtime/RuntimeLayerModel.h" - "${RENDER_CADENCE_APP_DIR}/runtime/RuntimeShaderBridge.cpp" - "${RENDER_CADENCE_APP_DIR}/runtime/RuntimeShaderBridge.h" - "${RENDER_CADENCE_APP_DIR}/runtime/RuntimeSlangShaderCompiler.cpp" - "${RENDER_CADENCE_APP_DIR}/runtime/RuntimeSlangShaderCompiler.h" - "${RENDER_CADENCE_APP_DIR}/runtime/SupportedShaderCatalog.cpp" - "${RENDER_CADENCE_APP_DIR}/runtime/SupportedShaderCatalog.h" - "${RENDER_CADENCE_APP_DIR}/telemetry/CadenceTelemetryJson.h" - "${RENDER_CADENCE_APP_DIR}/telemetry/CadenceTelemetry.h" - "${RENDER_CADENCE_APP_DIR}/telemetry/TelemetryHealthMonitor.h" - "${RENDER_CADENCE_APP_DIR}/video/DeckLinkInput.cpp" - "${RENDER_CADENCE_APP_DIR}/video/DeckLinkInput.h" - "${RENDER_CADENCE_APP_DIR}/video/DeckLinkInputThread.h" - "${RENDER_CADENCE_APP_DIR}/video/DeckLinkOutput.cpp" - "${RENDER_CADENCE_APP_DIR}/video/DeckLinkOutput.h" - "${RENDER_CADENCE_APP_DIR}/video/DeckLinkOutputThread.h" -) - -add_executable(RenderCadenceCompositor ${RENDER_CADENCE_APP_SOURCES}) - -target_include_directories(RenderCadenceCompositor PRIVATE - "${APP_DIR}" - "${APP_DIR}/gl/renderer" - "${APP_DIR}/gl/shader" - "${APP_DIR}/platform" - "${APP_DIR}/runtime/support" - "${APP_DIR}/shader" - "${APP_DIR}/videoio" - "${APP_DIR}/videoio/decklink" - "${RENDER_CADENCE_APP_DIR}" - "${RENDER_CADENCE_APP_DIR}/app" - "${RENDER_CADENCE_APP_DIR}/control" - "${RENDER_CADENCE_APP_DIR}/control/http" - "${RENDER_CADENCE_APP_DIR}/frames" - "${RENDER_CADENCE_APP_DIR}/json" - "${RENDER_CADENCE_APP_DIR}/logging" - "${RENDER_CADENCE_APP_DIR}/platform" - "${RENDER_CADENCE_APP_DIR}/render" - "${RENDER_CADENCE_APP_DIR}/render/readback" - "${RENDER_CADENCE_APP_DIR}/render/runtime" - "${RENDER_CADENCE_APP_DIR}/runtime" - "${RENDER_CADENCE_APP_DIR}/telemetry" - "${RENDER_CADENCE_APP_DIR}/video" -) - -target_link_libraries(RenderCadenceCompositor PRIVATE - opengl32 - Ole32 - Ws2_32 -) - -target_compile_definitions(RenderCadenceCompositor PRIVATE - _UNICODE - UNICODE -) - -if(MSVC) - target_compile_options(RenderCadenceCompositor PRIVATE /W3) -endif() - -add_executable(RuntimeJsonTests - "${APP_DIR}/runtime/support/RuntimeJson.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/tests/RuntimeJsonTests.cpp" -) - -target_include_directories(RuntimeJsonTests PRIVATE - "${APP_DIR}" - "${APP_DIR}/runtime" - "${APP_DIR}/runtime/support" -) - -if(MSVC) - target_compile_options(RuntimeJsonTests PRIVATE /W3) -endif() - -enable_testing() -add_test(NAME RuntimeJsonTests COMMAND RuntimeJsonTests) - -add_executable(RuntimeClockTests - "${APP_DIR}/runtime/telemetry/RuntimeClock.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/tests/RuntimeClockTests.cpp" -) - -target_include_directories(RuntimeClockTests PRIVATE - "${APP_DIR}" - "${APP_DIR}/runtime" - "${APP_DIR}/runtime/telemetry" -) - -if(MSVC) - target_compile_options(RuntimeClockTests PRIVATE /W3) -endif() - -add_test(NAME RuntimeClockTests COMMAND RuntimeClockTests) - -add_executable(HealthTelemetryTests - "${APP_DIR}/runtime/telemetry/HealthTelemetry.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/tests/HealthTelemetryTests.cpp" -) - -target_include_directories(HealthTelemetryTests PRIVATE - "${APP_DIR}" - "${APP_DIR}/runtime" - "${APP_DIR}/runtime/telemetry" -) - -if(MSVC) - target_compile_options(HealthTelemetryTests PRIVATE /W3) -endif() - -add_test(NAME HealthTelemetryTests COMMAND HealthTelemetryTests) - -add_executable(RuntimeParameterUtilsTests - "${APP_DIR}/runtime/support/RuntimeJson.cpp" - "${APP_DIR}/runtime/support/RuntimeParameterUtils.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/tests/RuntimeParameterUtilsTests.cpp" -) - -target_include_directories(RuntimeParameterUtilsTests PRIVATE - "${APP_DIR}" - "${APP_DIR}/runtime" - "${APP_DIR}/runtime/support" - "${APP_DIR}/shader" -) - -if(MSVC) - target_compile_options(RuntimeParameterUtilsTests PRIVATE /W3) -endif() - -add_test(NAME RuntimeParameterUtilsTests COMMAND RuntimeParameterUtilsTests) - -add_executable(RuntimeEventTypeTests - "${CMAKE_CURRENT_SOURCE_DIR}/tests/RuntimeEventTypeTests.cpp" -) - -target_include_directories(RuntimeEventTypeTests PRIVATE - "${APP_DIR}" - "${APP_DIR}/runtime" - "${APP_DIR}/runtime/events" - "${APP_DIR}/runtime/persistence" -) - -if(MSVC) - target_compile_options(RuntimeEventTypeTests PRIVATE /W3) -endif() - -add_test(NAME RuntimeEventTypeTests COMMAND RuntimeEventTypeTests) - -add_executable(RuntimeLiveStateTests - "${APP_DIR}/runtime/live/RenderStateComposer.cpp" - "${APP_DIR}/runtime/live/RuntimeLiveState.cpp" - "${APP_DIR}/runtime/support/RuntimeJson.cpp" - "${APP_DIR}/runtime/support/RuntimeParameterUtils.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/tests/RuntimeLiveStateTests.cpp" -) - -target_include_directories(RuntimeLiveStateTests PRIVATE - "${APP_DIR}" - "${APP_DIR}/runtime" - "${APP_DIR}/runtime/live" - "${APP_DIR}/runtime/support" - "${APP_DIR}/shader" -) - -if(MSVC) - target_compile_options(RuntimeLiveStateTests PRIVATE /W3) -endif() - -add_test(NAME RuntimeLiveStateTests COMMAND RuntimeLiveStateTests) - -add_executable(RuntimeStateLayerModelTests - "${APP_DIR}/runtime/live/RuntimeStateLayerModel.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/tests/RuntimeStateLayerModelTests.cpp" -) - -target_include_directories(RuntimeStateLayerModelTests PRIVATE - "${APP_DIR}" - "${APP_DIR}/runtime" - "${APP_DIR}/runtime/live" -) - -if(MSVC) - target_compile_options(RuntimeStateLayerModelTests PRIVATE /W3) -endif() - -add_test(NAME RuntimeStateLayerModelTests COMMAND RuntimeStateLayerModelTests) - -add_executable(PersistenceWriterTests - "${APP_DIR}/runtime/persistence/PersistenceWriter.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/tests/PersistenceWriterTests.cpp" -) - -target_include_directories(PersistenceWriterTests PRIVATE - "${APP_DIR}" - "${APP_DIR}/runtime" - "${APP_DIR}/runtime/persistence" -) - -if(MSVC) - target_compile_options(PersistenceWriterTests PRIVATE /W3) -endif() - -add_test(NAME PersistenceWriterTests COMMAND PersistenceWriterTests) - -add_executable(RuntimeSubsystemTests - "${APP_DIR}/runtime/coordination/RuntimeCoordinator.cpp" - "${APP_DIR}/runtime/live/CommittedLiveState.cpp" - "${APP_DIR}/runtime/snapshot/RenderSnapshotBuilder.cpp" - "${APP_DIR}/runtime/persistence/PersistenceWriter.cpp" - "${APP_DIR}/runtime/store/LayerStackStore.cpp" - "${APP_DIR}/runtime/store/RuntimeConfigStore.cpp" - "${APP_DIR}/runtime/store/RuntimeStore.cpp" - "${APP_DIR}/runtime/store/ShaderPackageCatalog.cpp" - "${APP_DIR}/runtime/presentation/RuntimeStateJson.cpp" - "${APP_DIR}/runtime/presentation/RuntimeStatePresenter.cpp" - "${APP_DIR}/runtime/support/RuntimeJson.cpp" - "${APP_DIR}/runtime/support/RuntimeParameterUtils.cpp" - "${APP_DIR}/runtime/telemetry/HealthTelemetry.cpp" - "${APP_DIR}/runtime/telemetry/RuntimeClock.cpp" - "${APP_DIR}/shader/ShaderCompiler.cpp" - "${APP_DIR}/shader/ShaderPackageRegistry.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/tests/RuntimeSubsystemTests.cpp" -) - -target_include_directories(RuntimeSubsystemTests PRIVATE - "${APP_DIR}" - "${APP_DIR}/platform" - "${APP_DIR}/runtime" - "${APP_DIR}/runtime/coordination" - "${APP_DIR}/runtime/events" - "${APP_DIR}/runtime/live" - "${APP_DIR}/runtime/persistence" - "${APP_DIR}/runtime/presentation" - "${APP_DIR}/runtime/snapshot" - "${APP_DIR}/runtime/store" - "${APP_DIR}/runtime/support" - "${APP_DIR}/runtime/telemetry" - "${APP_DIR}/shader" -) - -if(MSVC) - target_compile_options(RuntimeSubsystemTests PRIVATE /W3) -endif() - -add_test(NAME RuntimeSubsystemTests COMMAND RuntimeSubsystemTests) - -add_executable(Std140BufferTests - "${CMAKE_CURRENT_SOURCE_DIR}/tests/Std140BufferTests.cpp" -) - -target_include_directories(Std140BufferTests PRIVATE - "${APP_DIR}" - "${APP_DIR}/gl" - "${APP_DIR}/gl/shader" -) - -if(MSVC) - target_compile_options(Std140BufferTests PRIVATE /W3) -endif() - -add_test(NAME Std140BufferTests COMMAND Std140BufferTests) - -add_executable(RenderCommandQueueTests - "${APP_DIR}/gl/threading/RenderCommandQueue.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/tests/RenderCommandQueueTests.cpp" -) - -target_include_directories(RenderCommandQueueTests PRIVATE - "${APP_DIR}" - "${APP_DIR}/gl" - "${APP_DIR}/gl/threading" - "${APP_DIR}/videoio" - "${APP_DIR}/videoio/decklink" -) - -if(MSVC) - target_compile_options(RenderCommandQueueTests PRIVATE /W3) -endif() - -add_test(NAME RenderCommandQueueTests COMMAND RenderCommandQueueTests) - -add_executable(ShaderPackageRegistryTests - "${APP_DIR}/runtime/support/RuntimeJson.cpp" - "${APP_DIR}/shader/ShaderPackageRegistry.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/tests/ShaderPackageRegistryTests.cpp" -) - -target_include_directories(ShaderPackageRegistryTests PRIVATE - "${APP_DIR}" - "${APP_DIR}/runtime" - "${APP_DIR}/runtime/support" - "${APP_DIR}/shader" -) - -if(MSVC) - target_compile_options(ShaderPackageRegistryTests PRIVATE /W3) -endif() - -add_test(NAME ShaderPackageRegistryTests COMMAND ShaderPackageRegistryTests) - -add_executable(ShaderSlangValidationTests - "${APP_DIR}/runtime/support/RuntimeJson.cpp" - "${APP_DIR}/shader/ShaderCompiler.cpp" - "${APP_DIR}/shader/ShaderPackageRegistry.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/tests/ShaderSlangValidationTests.cpp" -) - -target_include_directories(ShaderSlangValidationTests PRIVATE - "${APP_DIR}" - "${APP_DIR}/platform" - "${APP_DIR}/runtime" - "${APP_DIR}/runtime/support" - "${APP_DIR}/shader" -) - -if(MSVC) - target_compile_options(ShaderSlangValidationTests PRIVATE /W3) -endif() - -add_test(NAME ShaderSlangValidationTests COMMAND ShaderSlangValidationTests) -set_tests_properties(ShaderSlangValidationTests PROPERTIES - ENVIRONMENT "SLANG_ROOT=${SLANG_ROOT}" -) - -add_executable(OscServerTests - "${APP_DIR}/control/OscServer.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/tests/OscServerTests.cpp" -) - -target_include_directories(OscServerTests PRIVATE - "${APP_DIR}" - "${APP_DIR}/control" - "${APP_DIR}/platform" -) - -target_link_libraries(OscServerTests PRIVATE - Ws2_32 -) - -if(MSVC) - target_compile_options(OscServerTests PRIVATE /W3) -endif() - -add_test(NAME OscServerTests COMMAND OscServerTests) - -add_executable(VideoIOFormatTests - "${APP_DIR}/videoio/decklink/DeckLinkVideoIOFormat.cpp" - "${APP_DIR}/videoio/VideoIOFormat.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/tests/VideoIOFormatTests.cpp" -) - -target_include_directories(VideoIOFormatTests PRIVATE - "${APP_DIR}" - "${APP_DIR}/videoio" - "${APP_DIR}/videoio/decklink" -) - -if(MSVC) - target_compile_options(VideoIOFormatTests PRIVATE /W3) -endif() - -add_test(NAME VideoIOFormatTests COMMAND VideoIOFormatTests) - -add_executable(VideoPlayoutSchedulerTests - "${APP_DIR}/videoio/VideoPlayoutScheduler.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/tests/VideoPlayoutSchedulerTests.cpp" -) - -target_include_directories(VideoPlayoutSchedulerTests PRIVATE - "${APP_DIR}" - "${APP_DIR}/videoio" - "${APP_DIR}/videoio/decklink" -) - -if(MSVC) - target_compile_options(VideoPlayoutSchedulerTests PRIVATE /W3) -endif() - -add_test(NAME VideoPlayoutSchedulerTests COMMAND VideoPlayoutSchedulerTests) - -add_executable(OutputProductionControllerTests - "${APP_DIR}/videoio/OutputProductionController.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/tests/OutputProductionControllerTests.cpp" -) - -target_include_directories(OutputProductionControllerTests PRIVATE - "${APP_DIR}" - "${APP_DIR}/videoio" -) - -if(MSVC) - target_compile_options(OutputProductionControllerTests PRIVATE /W3) -endif() - -add_test(NAME OutputProductionControllerTests COMMAND OutputProductionControllerTests) - -add_executable(RenderOutputQueueTests - "${APP_DIR}/videoio/RenderOutputQueue.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/tests/RenderOutputQueueTests.cpp" -) - -target_include_directories(RenderOutputQueueTests PRIVATE - "${APP_DIR}" - "${APP_DIR}/videoio" - "${APP_DIR}/videoio/decklink" -) - -if(MSVC) - target_compile_options(RenderOutputQueueTests PRIVATE /W3) -endif() - -add_test(NAME RenderOutputQueueTests COMMAND RenderOutputQueueTests) - -add_executable(RenderCadenceControllerTests - "${APP_DIR}/videoio/RenderCadenceController.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/tests/RenderCadenceControllerTests.cpp" -) - -target_include_directories(RenderCadenceControllerTests PRIVATE - "${APP_DIR}" - "${APP_DIR}/videoio" -) - -if(MSVC) - target_compile_options(RenderCadenceControllerTests PRIVATE /W3) -endif() - -add_test(NAME RenderCadenceControllerTests COMMAND RenderCadenceControllerTests) - -add_executable(RenderCadenceCompositorFrameExchangeTests - "${APP_DIR}/videoio/VideoIOFormat.cpp" - "${RENDER_CADENCE_APP_DIR}/frames/SystemFrameExchange.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/tests/RenderCadenceCompositorFrameExchangeTests.cpp" -) - -target_include_directories(RenderCadenceCompositorFrameExchangeTests PRIVATE - "${APP_DIR}/videoio" - "${RENDER_CADENCE_APP_DIR}/frames" -) - -if(MSVC) - target_compile_options(RenderCadenceCompositorFrameExchangeTests PRIVATE /W3) -endif() - -add_test(NAME RenderCadenceCompositorFrameExchangeTests COMMAND RenderCadenceCompositorFrameExchangeTests) - -add_executable(RenderCadenceCompositorInputFrameMailboxTests - "${APP_DIR}/videoio/VideoIOFormat.cpp" - "${RENDER_CADENCE_APP_DIR}/frames/InputFrameMailbox.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/tests/RenderCadenceCompositorInputFrameMailboxTests.cpp" -) - -target_include_directories(RenderCadenceCompositorInputFrameMailboxTests PRIVATE - "${APP_DIR}/videoio" - "${RENDER_CADENCE_APP_DIR}/frames" -) - -if(MSVC) - target_compile_options(RenderCadenceCompositorInputFrameMailboxTests PRIVATE /W3) -endif() - -add_test(NAME RenderCadenceCompositorInputFrameMailboxTests COMMAND RenderCadenceCompositorInputFrameMailboxTests) - -add_executable(RenderCadenceCompositorClockTests - "${RENDER_CADENCE_APP_DIR}/render/RenderCadenceClock.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/tests/RenderCadenceCompositorClockTests.cpp" -) - -target_include_directories(RenderCadenceCompositorClockTests PRIVATE - "${RENDER_CADENCE_APP_DIR}/render" -) - -if(MSVC) - target_compile_options(RenderCadenceCompositorClockTests PRIVATE /W3) -endif() - -add_test(NAME RenderCadenceCompositorClockTests COMMAND RenderCadenceCompositorClockTests) - -add_executable(RenderCadenceCompositorTelemetryTests - "${RENDER_CADENCE_APP_DIR}/json/JsonWriter.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/tests/RenderCadenceCompositorTelemetryTests.cpp" -) - -target_include_directories(RenderCadenceCompositorTelemetryTests PRIVATE - "${RENDER_CADENCE_APP_DIR}/json" - "${RENDER_CADENCE_APP_DIR}/telemetry" -) - -if(MSVC) - target_compile_options(RenderCadenceCompositorTelemetryTests PRIVATE /W3) -endif() - -add_test(NAME RenderCadenceCompositorTelemetryTests COMMAND RenderCadenceCompositorTelemetryTests) - -add_executable(RenderCadenceCompositorRuntimeShaderParamsTests - "${RENDER_CADENCE_APP_DIR}/render/runtime/RuntimeShaderParams.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/tests/RenderCadenceCompositorRuntimeShaderParamsTests.cpp" -) - -target_include_directories(RenderCadenceCompositorRuntimeShaderParamsTests PRIVATE - "${APP_DIR}/gl/shader" - "${APP_DIR}/shader" - "${RENDER_CADENCE_APP_DIR}/render" - "${RENDER_CADENCE_APP_DIR}/render/runtime" - "${RENDER_CADENCE_APP_DIR}/runtime" -) - -if(MSVC) - target_compile_options(RenderCadenceCompositorRuntimeShaderParamsTests PRIVATE /W3) -endif() - -add_test(NAME RenderCadenceCompositorRuntimeShaderParamsTests COMMAND RenderCadenceCompositorRuntimeShaderParamsTests) - -add_executable(RenderCadenceCompositorRuntimeLayerModelTests - "${RENDER_CADENCE_APP_DIR}/runtime/RuntimeLayerModel.cpp" - "${RENDER_CADENCE_APP_DIR}/runtime/SupportedShaderCatalog.cpp" - "${APP_DIR}/shader/ShaderPackageRegistry.cpp" - "${APP_DIR}/runtime/support/RuntimeJson.cpp" - "${APP_DIR}/runtime/support/RuntimeParameterUtils.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/tests/RenderCadenceCompositorRuntimeLayerModelTests.cpp" -) - -target_include_directories(RenderCadenceCompositorRuntimeLayerModelTests PRIVATE - "${APP_DIR}" - "${APP_DIR}/runtime/support" - "${APP_DIR}/shader" - "${RENDER_CADENCE_APP_DIR}/runtime" -) - -if(MSVC) - target_compile_options(RenderCadenceCompositorRuntimeLayerModelTests PRIVATE /W3) -endif() - -add_test(NAME RenderCadenceCompositorRuntimeLayerModelTests COMMAND RenderCadenceCompositorRuntimeLayerModelTests) - -add_executable(RenderCadenceCompositorSupportedShaderCatalogTests - "${APP_DIR}/shader/ShaderPackageRegistry.cpp" - "${APP_DIR}/runtime/support/RuntimeJson.cpp" - "${RENDER_CADENCE_APP_DIR}/runtime/SupportedShaderCatalog.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/tests/RenderCadenceCompositorSupportedShaderCatalogTests.cpp" -) - -target_include_directories(RenderCadenceCompositorSupportedShaderCatalogTests PRIVATE - "${APP_DIR}" - "${APP_DIR}/runtime/support" - "${APP_DIR}/shader" - "${RENDER_CADENCE_APP_DIR}/runtime" -) - -if(MSVC) - target_compile_options(RenderCadenceCompositorSupportedShaderCatalogTests PRIVATE /W3) -endif() - -add_test(NAME RenderCadenceCompositorSupportedShaderCatalogTests COMMAND RenderCadenceCompositorSupportedShaderCatalogTests) - -add_executable(RenderCadenceCompositorLoggerTests - "${RENDER_CADENCE_APP_DIR}/logging/Logger.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/tests/RenderCadenceCompositorLoggerTests.cpp" -) - -target_include_directories(RenderCadenceCompositorLoggerTests PRIVATE - "${RENDER_CADENCE_APP_DIR}/logging" -) - -if(MSVC) - target_compile_options(RenderCadenceCompositorLoggerTests PRIVATE /W3) -endif() - -add_test(NAME RenderCadenceCompositorLoggerTests COMMAND RenderCadenceCompositorLoggerTests) - -add_executable(RenderCadenceCompositorJsonWriterTests - "${RENDER_CADENCE_APP_DIR}/json/JsonWriter.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/tests/RenderCadenceCompositorJsonWriterTests.cpp" -) - -target_include_directories(RenderCadenceCompositorJsonWriterTests PRIVATE - "${RENDER_CADENCE_APP_DIR}/json" -) - -if(MSVC) - target_compile_options(RenderCadenceCompositorJsonWriterTests PRIVATE /W3) -endif() - -add_test(NAME RenderCadenceCompositorJsonWriterTests COMMAND RenderCadenceCompositorJsonWriterTests) - -add_executable(RenderCadenceCompositorRuntimeStateJsonTests - "${APP_DIR}/runtime/support/RuntimeJson.cpp" - "${APP_DIR}/runtime/support/RuntimeParameterUtils.cpp" - "${APP_DIR}/shader/ShaderPackageRegistry.cpp" - "${RENDER_CADENCE_APP_DIR}/app/AppConfig.cpp" - "${RENDER_CADENCE_APP_DIR}/app/AppConfigProvider.cpp" - "${RENDER_CADENCE_APP_DIR}/json/JsonWriter.cpp" - "${RENDER_CADENCE_APP_DIR}/runtime/RuntimeLayerModel.cpp" - "${RENDER_CADENCE_APP_DIR}/runtime/SupportedShaderCatalog.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/tests/RenderCadenceCompositorRuntimeStateJsonTests.cpp" -) - -target_include_directories(RenderCadenceCompositorRuntimeStateJsonTests PRIVATE - "${APP_DIR}" - "${APP_DIR}/runtime/support" - "${APP_DIR}/shader" - "${APP_DIR}/videoio" - "${APP_DIR}/videoio/decklink" - "${RENDER_CADENCE_APP_DIR}/app" - "${RENDER_CADENCE_APP_DIR}/control" - "${RENDER_CADENCE_APP_DIR}/json" - "${RENDER_CADENCE_APP_DIR}/logging" - "${RENDER_CADENCE_APP_DIR}/runtime" - "${RENDER_CADENCE_APP_DIR}/telemetry" - "${RENDER_CADENCE_APP_DIR}/video" -) - -if(MSVC) - target_compile_options(RenderCadenceCompositorRuntimeStateJsonTests PRIVATE /W3) -endif() - -add_test(NAME RenderCadenceCompositorRuntimeStateJsonTests COMMAND RenderCadenceCompositorRuntimeStateJsonTests) - -add_executable(RenderCadenceCompositorHttpControlServerTests - "${APP_DIR}/runtime/support/RuntimeJson.cpp" - "${RENDER_CADENCE_APP_DIR}/control/RuntimeControlCommand.cpp" - "${RENDER_CADENCE_APP_DIR}/control/http/HttpControlServer.cpp" - "${RENDER_CADENCE_APP_DIR}/control/http/HttpControlServerRoutes.cpp" - "${RENDER_CADENCE_APP_DIR}/control/http/HttpControlServerWebSocket.cpp" - "${RENDER_CADENCE_APP_DIR}/json/JsonWriter.cpp" - "${RENDER_CADENCE_APP_DIR}/logging/Logger.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/tests/RenderCadenceCompositorHttpControlServerTests.cpp" -) - -target_include_directories(RenderCadenceCompositorHttpControlServerTests PRIVATE - "${APP_DIR}" - "${APP_DIR}/runtime/support" - "${RENDER_CADENCE_APP_DIR}/control" - "${RENDER_CADENCE_APP_DIR}/control/http" - "${RENDER_CADENCE_APP_DIR}/json" - "${RENDER_CADENCE_APP_DIR}/logging" -) - -target_link_libraries(RenderCadenceCompositorHttpControlServerTests PRIVATE - Ws2_32 -) - -if(MSVC) - target_compile_options(RenderCadenceCompositorHttpControlServerTests PRIVATE /W3) -endif() - -add_test(NAME RenderCadenceCompositorHttpControlServerTests COMMAND RenderCadenceCompositorHttpControlServerTests) - -add_executable(RenderCadenceCompositorAppConfigProviderTests - "${APP_DIR}/runtime/support/RuntimeJson.cpp" - "${RENDER_CADENCE_APP_DIR}/app/AppConfig.cpp" - "${RENDER_CADENCE_APP_DIR}/app/AppConfigProvider.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/tests/RenderCadenceCompositorAppConfigProviderTests.cpp" -) - -target_include_directories(RenderCadenceCompositorAppConfigProviderTests PRIVATE - "${APP_DIR}" - "${APP_DIR}/runtime/support" - "${RENDER_CADENCE_APP_DIR}/app" - "${RENDER_CADENCE_APP_DIR}/control" - "${RENDER_CADENCE_APP_DIR}/logging" - "${RENDER_CADENCE_APP_DIR}/telemetry" - "${RENDER_CADENCE_APP_DIR}/video" - "${APP_DIR}/videoio" - "${APP_DIR}/videoio/decklink" -) - -target_link_libraries(RenderCadenceCompositorAppConfigProviderTests PRIVATE - Ws2_32 -) - -if(MSVC) - target_compile_options(RenderCadenceCompositorAppConfigProviderTests PRIVATE /W3) -endif() - -add_test(NAME RenderCadenceCompositorAppConfigProviderTests COMMAND RenderCadenceCompositorAppConfigProviderTests) - -add_executable(SystemOutputFramePoolTests - "${APP_DIR}/videoio/SystemOutputFramePool.cpp" - "${APP_DIR}/videoio/VideoIOFormat.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/tests/SystemOutputFramePoolTests.cpp" -) - -target_include_directories(SystemOutputFramePoolTests PRIVATE - "${APP_DIR}" - "${APP_DIR}/videoio" - "${APP_DIR}/videoio/decklink" -) - -if(MSVC) - target_compile_options(SystemOutputFramePoolTests PRIVATE /W3) -endif() - -add_test(NAME SystemOutputFramePoolTests COMMAND SystemOutputFramePoolTests) - -add_executable(VideoBackendLifecycleTests - "${APP_DIR}/videoio/VideoBackendLifecycle.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/tests/VideoBackendLifecycleTests.cpp" -) - -target_include_directories(VideoBackendLifecycleTests PRIVATE - "${APP_DIR}" - "${APP_DIR}/videoio" -) - -if(MSVC) - target_compile_options(VideoBackendLifecycleTests PRIVATE /W3) -endif() - -add_test(NAME VideoBackendLifecycleTests COMMAND VideoBackendLifecycleTests) - -add_executable(VideoIODeviceFakeTests - "${APP_DIR}/videoio/VideoIOFormat.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/tests/VideoIODeviceFakeTests.cpp" -) - -target_include_directories(VideoIODeviceFakeTests PRIVATE - "${APP_DIR}" - "${APP_DIR}/videoio" - "${APP_DIR}/videoio/decklink" -) - -if(MSVC) - target_compile_options(VideoIODeviceFakeTests PRIVATE /W3) -endif() - -add_test(NAME VideoIODeviceFakeTests COMMAND VideoIODeviceFakeTests) - -install(TARGETS LoopThroughWithOpenGLCompositing - RUNTIME DESTINATION "." -) - -install(FILES ${SLANG_RUNTIME_FILES} - DESTINATION "3rdParty/slang/bin" -) - -install(FILES "${SLANG_LICENSE_FILE}" - DESTINATION "third_party_notices" - RENAME "SLANG_LICENSE.txt" -) - install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/shaders/SHADER_CONTRACT.md" DESTINATION "." ) @@ -1125,5 +173,3 @@ install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/docs/" DESTINATION "docs" OPTIONAL ) - -source_group(TREE "${APP_DIR}" FILES ${APP_SOURCES}) diff --git a/src/platform/NativeHandles.h b/src/platform/NativeHandles.h new file mode 100644 index 0000000..7a31d1d --- /dev/null +++ b/src/platform/NativeHandles.h @@ -0,0 +1,42 @@ +#pragma once + +#include + +class UniqueHandle +{ +public: + explicit UniqueHandle(HANDLE handle = NULL) : mHandle(handle) {} + ~UniqueHandle() { reset(); } + + UniqueHandle(const UniqueHandle&) = delete; + UniqueHandle& operator=(const UniqueHandle&) = delete; + + UniqueHandle(UniqueHandle&& other) noexcept : mHandle(other.release()) {} + + UniqueHandle& operator=(UniqueHandle&& other) noexcept + { + if (this != &other) + reset(other.release()); + return *this; + } + + HANDLE get() const { return mHandle; } + bool valid() const { return mHandle != NULL && mHandle != INVALID_HANDLE_VALUE; } + + HANDLE release() + { + HANDLE handle = mHandle; + mHandle = NULL; + return handle; + } + + void reset(HANDLE handle = NULL) + { + if (valid()) + CloseHandle(mHandle); + mHandle = handle; + } + +private: + HANDLE mHandle; +}; diff --git a/src/platform/NativeSockets.h b/src/platform/NativeSockets.h new file mode 100644 index 0000000..a9469a2 --- /dev/null +++ b/src/platform/NativeSockets.h @@ -0,0 +1,42 @@ +#pragma once + +#include + +class UniqueSocket +{ +public: + explicit UniqueSocket(SOCKET socket = INVALID_SOCKET) : mSocket(socket) {} + ~UniqueSocket() { reset(); } + + UniqueSocket(const UniqueSocket&) = delete; + UniqueSocket& operator=(const UniqueSocket&) = delete; + + UniqueSocket(UniqueSocket&& other) noexcept : mSocket(other.release()) {} + + UniqueSocket& operator=(UniqueSocket&& other) noexcept + { + if (this != &other) + reset(other.release()); + return *this; + } + + SOCKET get() const { return mSocket; } + bool valid() const { return mSocket != INVALID_SOCKET; } + + SOCKET release() + { + SOCKET socket = mSocket; + mSocket = INVALID_SOCKET; + return socket; + } + + void reset(SOCKET socket = INVALID_SOCKET) + { + if (valid()) + closesocket(mSocket); + mSocket = socket; + } + +private: + SOCKET mSocket; +}; diff --git a/src/render/GLExtensions.cpp b/src/render/GLExtensions.cpp new file mode 100644 index 0000000..f6569ba --- /dev/null +++ b/src/render/GLExtensions.cpp @@ -0,0 +1,212 @@ +/* -LICENSE-START- + ** Copyright (c) 2012 Blackmagic Design + ** + ** Permission is hereby granted, free of charge, to any person or organization + ** obtaining a copy of the software and accompanying documentation (the + ** "Software") to use, reproduce, display, distribute, sub-license, 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, in + ** accordance with: + ** + ** (1) if the Software is obtained from Blackmagic Design, the End User License + ** Agreement for the Software Development Kit ("EULA") available at + ** https://www.blackmagicdesign.com/EULA/DeckLinkSDK; or + ** + ** (2) if the Software is obtained from any third party, such licensing terms + ** as notified by that third party, + ** + ** and all subject to the following: + ** + ** (3) 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. + ** + ** (4) 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. + ** + ** A copy of the Software is available free of charge at + ** https://www.blackmagicdesign.com/desktopvideo_sdk under the EULA. + ** + ** -LICENSE-END- + */ +// +// GLExtensions.cpp +// LoopThroughWithOpenGLCompositing +// + +#include "GLExtensions.h" + +PFNGLGENFRAMEBUFFERSPROC glGenFramebuffers; +PFNGLGENRENDERBUFFERSPROC glGenRenderbuffers; +PFNGLBINDRENDERBUFFERPROC glBindRenderbuffer; +PFNGLRENDERBUFFERSTORAGEPROC glRenderbufferStorage; +PFNGLDELETEFRAMEBUFFERSPROC glDeleteFramebuffers; +PFNGLDELETERENDERBUFFERSPROC glDeleteRenderbuffers; +PFNGLBINDFRAMEBUFFERPROC glBindFramebuffer; +PFNGLFRAMEBUFFERTEXTURE2DPROC glFramebufferTexture2D; +PFNGLFRAMEBUFFERRENDERBUFFERPROC glFramebufferRenderbuffer; +PFNGLCHECKFRAMEBUFFERSTATUSPROC glCheckFramebufferStatus; +PFNGLBLITFRAMEBUFFERPROC glBlitFramebuffer; +PFNGLFENCESYNCPROC glFenceSync; +PFNGLCLIENTWAITSYNCPROC glClientWaitSync; +PFNGLDELETESYNCPROC glDeleteSync; +PFNGLGENBUFFERSPROC glGenBuffers; +PFNGLDELETEBUFFERSPROC glDeleteBuffers; +PFNGLBINDBUFFERPROC glBindBuffer; +PFNGLBUFFERDATAPROC glBufferData; +PFNGLMAPBUFFERPROC glMapBuffer; +PFNGLUNMAPBUFFERPROC glUnmapBuffer; +PFNGLBUFFERSUBDATAPROC glBufferSubData; +PFNGLBINDBUFFERBASEPROC glBindBufferBase; +PFNGLACTIVETEXTUREPROC glActiveTexture; +PFNGLGENVERTEXARRAYSPROC glGenVertexArrays; +PFNGLDELETEVERTEXARRAYSPROC glDeleteVertexArrays; +PFNGLBINDVERTEXARRAYPROC glBindVertexArray; +PFNGLCREATESHADERPROC glCreateShader; +PFNGLDELETESHADERPROC glDeleteShader; +PFNGLDELETEPROGRAMPROC glDeleteProgram; +PFNGLSHADERSOURCEPROC glShaderSource; +PFNGLCOMPILESHADERPROC glCompileShader; +PFNGLGETSHADERIVPROC glGetShaderiv; +PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog; +PFNGLCREATEPROGRAMPROC glCreateProgram; +PFNGLATTACHSHADERPROC glAttachShader; +PFNGLLINKPROGRAMPROC glLinkProgram; +PFNGLGETPROGRAMIVPROC glGetProgramiv; +PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog; +PFNGLUSEPROGRAMPROC glUseProgram; +PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation; +PFNGLGETUNIFORMBLOCKINDEXPROC glGetUniformBlockIndex; +PFNGLUNIFORMBLOCKBINDINGPROC glUniformBlockBinding; +PFNGLUNIFORM1IPROC glUniform1i; +PFNGLUNIFORM1FPROC glUniform1f; +PFNGLUNIFORM2FPROC glUniform2f; +PFNGLUNIFORM4FPROC glUniform4f; + +bool ResolveGLExtensions() +{ + glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC) wglGetProcAddress("glGenFramebuffers"); + if (!glGenFramebuffers) + glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC) wglGetProcAddress("glGenFramebuffersEXT"); + glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC) wglGetProcAddress("glGenRenderbuffers"); + if (!glGenRenderbuffers) + glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC) wglGetProcAddress("glGenRenderbuffersEXT"); + glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC) wglGetProcAddress("glBindRenderbuffer"); + if (!glBindRenderbuffer) + glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC) wglGetProcAddress("glBindRenderbufferEXT"); + glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC) wglGetProcAddress("glRenderbufferStorage"); + if (!glRenderbufferStorage) + glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC) wglGetProcAddress("glRenderbufferStorageEXT"); + glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC) wglGetProcAddress("glDeleteFramebuffers"); + if (!glDeleteFramebuffers) + glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC) wglGetProcAddress("glDeleteFramebuffersEXT"); + glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC) wglGetProcAddress("glDeleteRenderbuffers"); + if (!glDeleteRenderbuffers) + glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC) wglGetProcAddress("glDeleteRenderbuffersEXT"); + glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC) wglGetProcAddress("glBindFramebuffer"); + if (!glBindFramebuffer) + glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC) wglGetProcAddress("glBindFramebufferEXT"); + glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC) wglGetProcAddress("glFramebufferTexture2D"); + if (!glFramebufferTexture2D) + glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC) wglGetProcAddress("glFramebufferTexture2DEXT"); + glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC) wglGetProcAddress("glFramebufferRenderbuffer"); + if (!glFramebufferRenderbuffer) + glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC) wglGetProcAddress("glFramebufferRenderbufferEXT"); + glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC) wglGetProcAddress("glCheckFramebufferStatus"); + if (!glCheckFramebufferStatus) + glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC) wglGetProcAddress("glCheckFramebufferStatusEXT"); + glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC) wglGetProcAddress("glBlitFramebuffer"); + if (!glBlitFramebuffer) + glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC) wglGetProcAddress("glBlitFramebufferEXT"); + glFenceSync = (PFNGLFENCESYNCPROC) wglGetProcAddress("glFenceSync"); + glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC) wglGetProcAddress("glClientWaitSync"); + glDeleteSync = (PFNGLDELETESYNCPROC) wglGetProcAddress("glDeleteSync"); + glGenBuffers = (PFNGLGENBUFFERSPROC) wglGetProcAddress("glGenBuffers"); + glDeleteBuffers = (PFNGLDELETEBUFFERSPROC) wglGetProcAddress("glDeleteBuffers"); + glBindBuffer = (PFNGLBINDBUFFERPROC) wglGetProcAddress("glBindBuffer"); + glBufferData = (PFNGLBUFFERDATAPROC) wglGetProcAddress("glBufferData"); + glMapBuffer = (PFNGLMAPBUFFERPROC) wglGetProcAddress("glMapBuffer"); + glUnmapBuffer = (PFNGLUNMAPBUFFERPROC) wglGetProcAddress("glUnmapBuffer"); + glBufferSubData = (PFNGLBUFFERSUBDATAPROC) wglGetProcAddress("glBufferSubData"); + glBindBufferBase = (PFNGLBINDBUFFERBASEPROC) wglGetProcAddress("glBindBufferBase"); + glActiveTexture = (PFNGLACTIVETEXTUREPROC) wglGetProcAddress("glActiveTexture"); + glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC) wglGetProcAddress("glGenVertexArrays"); + glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC) wglGetProcAddress("glDeleteVertexArrays"); + glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC) wglGetProcAddress("glBindVertexArray"); + glCreateShader = (PFNGLCREATESHADERPROC) wglGetProcAddress("glCreateShader"); + glDeleteShader = (PFNGLDELETESHADERPROC) wglGetProcAddress("glDeleteShader"); + glDeleteProgram = (PFNGLDELETEPROGRAMPROC) wglGetProcAddress("glDeleteProgram"); + glShaderSource = (PFNGLSHADERSOURCEPROC) wglGetProcAddress("glShaderSource"); + glCompileShader = (PFNGLCOMPILESHADERPROC) wglGetProcAddress("glCompileShader"); + glGetShaderiv = (PFNGLGETSHADERIVPROC) wglGetProcAddress("glGetShaderiv"); + glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC) wglGetProcAddress("glGetShaderInfoLog"); + glCreateProgram = (PFNGLCREATEPROGRAMPROC) wglGetProcAddress("glCreateProgram"); + glAttachShader = (PFNGLATTACHSHADERPROC) wglGetProcAddress("glAttachShader"); + glLinkProgram = (PFNGLLINKPROGRAMPROC) wglGetProcAddress("glLinkProgram"); + glGetProgramiv = (PFNGLGETPROGRAMIVPROC) wglGetProcAddress("glGetProgramiv"); + glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC) wglGetProcAddress("glGetProgramInfoLog"); + glUseProgram = (PFNGLUSEPROGRAMPROC) wglGetProcAddress("glUseProgram"); + glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC) wglGetProcAddress("glGetUniformLocation"); + glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC) wglGetProcAddress("glGetUniformBlockIndex"); + glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC) wglGetProcAddress("glUniformBlockBinding"); + glUniform1i = (PFNGLUNIFORM1IPROC) wglGetProcAddress("glUniform1i"); + glUniform1f = (PFNGLUNIFORM1FPROC) wglGetProcAddress("glUniform1f"); + glUniform2f = (PFNGLUNIFORM2FPROC) wglGetProcAddress("glUniform2f"); + glUniform4f = (PFNGLUNIFORM4FPROC) wglGetProcAddress("glUniform4f"); + + return glGenFramebuffers + && glGenRenderbuffers + && glBindRenderbuffer + && glRenderbufferStorage + && glDeleteFramebuffers + && glDeleteRenderbuffers + && glBindFramebuffer + && glFramebufferTexture2D + && glFramebufferRenderbuffer + && glCheckFramebufferStatus + && glBlitFramebuffer + && glFenceSync + && glClientWaitSync + && glDeleteSync + && glGenBuffers + && glDeleteBuffers + && glBindBuffer + && glBufferData + && glMapBuffer + && glUnmapBuffer + && glBufferSubData + && glBindBufferBase + && glActiveTexture + && glGenVertexArrays + && glDeleteVertexArrays + && glBindVertexArray + && glCreateShader + && glDeleteShader + && glDeleteProgram + && glShaderSource + && glCompileShader + && glGetShaderiv + && glGetShaderInfoLog + && glCreateProgram + && glAttachShader + && glLinkProgram + && glGetProgramiv + && glGetProgramInfoLog + && glUseProgram + && glGetUniformLocation + && glGetUniformBlockIndex + && glUniformBlockBinding + && glUniform1i + && glUniform1f + && glUniform2f + && glUniform4f + ; +} diff --git a/src/render/GLExtensions.h b/src/render/GLExtensions.h new file mode 100644 index 0000000..0115f7d --- /dev/null +++ b/src/render/GLExtensions.h @@ -0,0 +1,201 @@ +/* -LICENSE-START- + ** Copyright (c) 2012 Blackmagic Design + ** + ** Permission is hereby granted, free of charge, to any person or organization + ** obtaining a copy of the software and accompanying documentation (the + ** "Software") to use, reproduce, display, distribute, sub-license, 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, in + ** accordance with: + ** + ** (1) if the Software is obtained from Blackmagic Design, the End User License + ** Agreement for the Software Development Kit ("EULA") available at + ** https://www.blackmagicdesign.com/EULA/DeckLinkSDK; or + ** + ** (2) if the Software is obtained from any third party, such licensing terms + ** as notified by that third party, + ** + ** and all subject to the following: + ** + ** (3) 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. + ** + ** (4) 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. + ** + ** A copy of the Software is available free of charge at + ** https://www.blackmagicdesign.com/desktopvideo_sdk under the EULA. + ** + ** -LICENSE-END- + */ +// +// GLExtensions.h +// LoopThroughWithOpenGLCompositing +// + +#ifndef __GLEXTENSIONS_H__ +#define __GLEXTENSIONS_H__ + +#include +#include + +#ifndef APIENTRYP +#define APIENTRYP APIENTRY * +#endif + +#define GL_BGRA 0x80E1 +#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367 +#define GL_STREAM_DRAW 0x88E0 +#define GL_STREAM_READ 0x88E1 +#define GL_STREAM_COPY 0x88E2 +#define GL_DYNAMIC_DRAW 0x88E8 +#define GL_UNIFORM_BUFFER 0x8A11 +#define GL_RGBA8 0x8058 +#define GL_RGBA16F 0x881A +#define GL_TEXTURE0 0x84C0 +#define GL_ACTIVE_TEXTURE 0x84E0 +#define GL_ARRAY_BUFFER 0x8892 +#define GL_PIXEL_PACK_BUFFER 0x88EB +#define GL_PIXEL_UNPACK_BUFFER 0x88EC +#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF +#define GL_FRAGMENT_SHADER 0x8B30 +#define GL_VERTEX_SHADER 0x8B31 +#define GL_COMPILE_STATUS 0x8B81 +#define GL_LINK_STATUS 0x8B82 +#define GL_INVALID_INDEX 0xFFFFFFFFu +#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872 +#define GL_RENDERBUFFER_EXT 0x8D41 +#define GL_FRAMEBUFFER_EXT 0x8D40 +#define GL_FRAMEBUFFER_COMPLETE_EXT 0x8CD5 +#define GL_COLOR_ATTACHMENT0_EXT 0x8CE0 +#define GL_READ_FRAMEBUFFER 0x8CA8 +#define GL_DRAW_FRAMEBUFFER 0x8CA9 +#define GL_RENDERBUFFER 0x8D41 +#define GL_FRAMEBUFFER 0x8D40 +#define GL_FRAMEBUFFER_COMPLETE 0x8CD5 +#define GL_COLOR_ATTACHMENT0 0x8CE0 +#define GL_DEPTH_COMPONENT24 0x81A6 +#define GL_CLAMP_TO_EDGE 0x812F +#define GL_DEPTH_ATTACHMENT_EXT 0x8D00 +#define GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD 0x9160 +#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117 +#define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001 +#define GL_ALREADY_SIGNALED 0x911A +#define GL_TIMEOUT_EXPIRED 0x911B +#define GL_CONDITION_SATISFIED 0x911C +#define GL_WAIT_FAILED 0x911D +#define GL_READ_ONLY 0x88B8 + +typedef struct __GLsync *GLsync; +typedef unsigned __int64 GLuint64; +typedef ptrdiff_t GLintptr; +typedef ptrdiff_t GLsizeiptr; +typedef char GLchar; + +typedef void (APIENTRYP PFNGLBINDBUFFERPROC) (GLenum target, GLuint buffer); +typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC) (GLsizei n, const GLuint *buffers); +typedef void (APIENTRYP PFNGLGENBUFFERSPROC) (GLsizei n, GLuint *buffers); +typedef void (APIENTRYP PFNGLBUFFERDATAPROC) (GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage); +typedef GLvoid* (APIENTRYP PFNGLMAPBUFFERPROC) (GLenum target, GLenum access); +typedef GLboolean (APIENTRYP PFNGLUNMAPBUFFERPROC) (GLenum target); +typedef void (APIENTRYP PFNGLATTACHSHADERPROC) (GLuint program, GLuint shader); +typedef void (APIENTRYP PFNGLCOMPILESHADERPROC) (GLuint shader); +typedef GLuint (APIENTRYP PFNGLCREATEPROGRAMPROC) (void); +typedef GLuint (APIENTRYP PFNGLCREATESHADERPROC) (GLenum type); +typedef void (APIENTRYP PFNGLDELETESHADERPROC) (GLuint shader); +typedef void (APIENTRYP PFNGLDELETEPROGRAMPROC) (GLuint program); +typedef void (APIENTRYP PFNGLGETPROGRAMIVPROC) (GLuint program, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLGETPROGRAMINFOLOGPROC) (GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +typedef void (APIENTRYP PFNGLGETSHADERIVPROC) (GLuint shader, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLGETSHADERINFOLOGPROC) (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +typedef GLint (APIENTRYP PFNGLGETUNIFORMLOCATIONPROC) (GLuint program, const GLchar *name); +typedef void (APIENTRYP PFNGLLINKPROGRAMPROC) (GLuint program); +typedef void (APIENTRYP PFNGLSHADERSOURCEPROC) (GLuint shader, GLsizei count, const GLchar* *string, const GLint *length); +typedef void (APIENTRYP PFNGLUSEPROGRAMPROC) (GLuint program); +typedef void (APIENTRYP PFNGLUNIFORM1FPROC) (GLint location, GLfloat v0); +typedef void (APIENTRYP PFNGLUNIFORM1IPROC) (GLint location, GLint v0); +typedef void (APIENTRYP PFNGLUNIFORM2FPROC) (GLint location, GLfloat v0, GLfloat v1); +typedef void (APIENTRYP PFNGLUNIFORM4FPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +typedef GLuint (APIENTRYP PFNGLGETUNIFORMBLOCKINDEXPROC) (GLuint program, const GLchar* uniformBlockName); +typedef void (APIENTRYP PFNGLUNIFORMBLOCKBINDINGPROC) (GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding); +typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC) (GLenum texture); +typedef void (APIENTRYP PFNGLBINDBUFFERBASEPROC) (GLenum target, GLuint index, GLuint buffer); +typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC) (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data); +typedef void (APIENTRYP PFNGLBINDVERTEXARRAYPROC) (GLuint array); +typedef void (APIENTRYP PFNGLDELETEVERTEXARRAYSPROC) (GLsizei n, const GLuint* arrays); +typedef void (APIENTRYP PFNGLGENVERTEXARRAYSPROC) (GLsizei n, GLuint* arrays); +typedef GLsync (APIENTRYP PFNGLFENCESYNCPROC) (GLenum condition, GLbitfield flags); +typedef void (APIENTRYP PFNGLDELETESYNCPROC) (GLsync sync); +typedef GLenum (APIENTRYP PFNGLCLIENTWAITSYNCPROC) (GLsync sync, GLbitfield flags, GLuint64 timeout); +typedef void (APIENTRYP PFNGLBINDRENDERBUFFERPROC) (GLenum target, GLuint renderbuffer); +typedef void (APIENTRYP PFNGLDELETERENDERBUFFERSPROC) (GLsizei n, const GLuint *renderbuffers); +typedef void (APIENTRYP PFNGLGENRENDERBUFFERSPROC) (GLsizei n, GLuint *renderbuffers); +typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height); +typedef void (APIENTRYP PFNGLBINDFRAMEBUFFERPROC) (GLenum target, GLuint framebuffer); +typedef void (APIENTRYP PFNGLDELETEFRAMEBUFFERSPROC) (GLsizei n, const GLuint *framebuffers); +typedef void (APIENTRYP PFNGLGENFRAMEBUFFERSPROC) (GLsizei n, GLuint *framebuffers); +typedef GLenum (APIENTRYP PFNGLCHECKFRAMEBUFFERSTATUSPROC) (GLenum target); +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE2DPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +typedef void (APIENTRYP PFNGLFRAMEBUFFERRENDERBUFFERPROC) (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +typedef void (APIENTRYP PFNGLBLITFRAMEBUFFERPROC) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); + +extern PFNGLGENFRAMEBUFFERSPROC glGenFramebuffers; +extern PFNGLGENRENDERBUFFERSPROC glGenRenderbuffers; +extern PFNGLBINDRENDERBUFFERPROC glBindRenderbuffer; +extern PFNGLRENDERBUFFERSTORAGEPROC glRenderbufferStorage; +extern PFNGLDELETEFRAMEBUFFERSPROC glDeleteFramebuffers; +extern PFNGLDELETERENDERBUFFERSPROC glDeleteRenderbuffers; +extern PFNGLBINDFRAMEBUFFERPROC glBindFramebuffer; +extern PFNGLFRAMEBUFFERTEXTURE2DPROC glFramebufferTexture2D; +extern PFNGLFRAMEBUFFERRENDERBUFFERPROC glFramebufferRenderbuffer; +extern PFNGLCHECKFRAMEBUFFERSTATUSPROC glCheckFramebufferStatus; +extern PFNGLBLITFRAMEBUFFERPROC glBlitFramebuffer; +extern PFNGLFENCESYNCPROC glFenceSync; +extern PFNGLCLIENTWAITSYNCPROC glClientWaitSync; +extern PFNGLDELETESYNCPROC glDeleteSync; +extern PFNGLGENBUFFERSPROC glGenBuffers; +extern PFNGLDELETEBUFFERSPROC glDeleteBuffers; +extern PFNGLBINDBUFFERPROC glBindBuffer; +extern PFNGLBUFFERDATAPROC glBufferData; +extern PFNGLMAPBUFFERPROC glMapBuffer; +extern PFNGLUNMAPBUFFERPROC glUnmapBuffer; +extern PFNGLBUFFERSUBDATAPROC glBufferSubData; +extern PFNGLBINDBUFFERBASEPROC glBindBufferBase; +extern PFNGLACTIVETEXTUREPROC glActiveTexture; +extern PFNGLGENVERTEXARRAYSPROC glGenVertexArrays; +extern PFNGLDELETEVERTEXARRAYSPROC glDeleteVertexArrays; +extern PFNGLBINDVERTEXARRAYPROC glBindVertexArray; +extern PFNGLCREATESHADERPROC glCreateShader; +extern PFNGLDELETESHADERPROC glDeleteShader; +extern PFNGLDELETEPROGRAMPROC glDeleteProgram; +extern PFNGLSHADERSOURCEPROC glShaderSource; +extern PFNGLCOMPILESHADERPROC glCompileShader; +extern PFNGLGETSHADERIVPROC glGetShaderiv; +extern PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog; +extern PFNGLCREATEPROGRAMPROC glCreateProgram; +extern PFNGLATTACHSHADERPROC glAttachShader; +extern PFNGLLINKPROGRAMPROC glLinkProgram; +extern PFNGLGETPROGRAMIVPROC glGetProgramiv; +extern PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog; +extern PFNGLUSEPROGRAMPROC glUseProgram; +extern PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation; +extern PFNGLGETUNIFORMBLOCKINDEXPROC glGetUniformBlockIndex; +extern PFNGLUNIFORMBLOCKBINDINGPROC glUniformBlockBinding; +extern PFNGLUNIFORM1IPROC glUniform1i; +extern PFNGLUNIFORM1FPROC glUniform1f; +extern PFNGLUNIFORM2FPROC glUniform2f; +extern PFNGLUNIFORM4FPROC glUniform4f; + +bool ResolveGLExtensions(); + +#endif // __GLEXTENSIONS_H__ + diff --git a/src/render/Std140Buffer.h b/src/render/Std140Buffer.h new file mode 100644 index 0000000..a94ac6d --- /dev/null +++ b/src/render/Std140Buffer.h @@ -0,0 +1,48 @@ +#pragma once + +#include +#include +#include + +inline std::size_t AlignStd140(std::size_t offset, std::size_t alignment) +{ + const std::size_t mask = alignment - 1; + return (offset + mask) & ~mask; +} + +template +inline void AppendStd140Value(std::vector& buffer, std::size_t alignment, const TValue& value) +{ + const std::size_t offset = AlignStd140(buffer.size(), alignment); + if (buffer.size() < offset + sizeof(TValue)) + buffer.resize(offset + sizeof(TValue), 0); + std::memcpy(buffer.data() + offset, &value, sizeof(TValue)); +} + +inline void AppendStd140Float(std::vector& buffer, float value) +{ + AppendStd140Value(buffer, 4, value); +} + +inline void AppendStd140Int(std::vector& buffer, int value) +{ + AppendStd140Value(buffer, 4, value); +} + +inline void AppendStd140Vec2(std::vector& buffer, float x, float y) +{ + const std::size_t offset = AlignStd140(buffer.size(), 8); + if (buffer.size() < offset + sizeof(float) * 2) + buffer.resize(offset + sizeof(float) * 2, 0); + float values[2] = { x, y }; + std::memcpy(buffer.data() + offset, values, sizeof(values)); +} + +inline void AppendStd140Vec4(std::vector& buffer, float x, float y, float z, float w) +{ + const std::size_t offset = AlignStd140(buffer.size(), 16); + if (buffer.size() < offset + sizeof(float) * 4) + buffer.resize(offset + sizeof(float) * 4, 0); + float values[4] = { x, y, z, w }; + std::memcpy(buffer.data() + offset, values, sizeof(values)); +} diff --git a/src/runtime/RuntimeJson.cpp b/src/runtime/RuntimeJson.cpp new file mode 100644 index 0000000..a2fdbaf --- /dev/null +++ b/src/runtime/RuntimeJson.cpp @@ -0,0 +1,674 @@ +#include "stdafx.h" +#include "RuntimeJson.h" + +#include +#include +#include +#include +#include +#include +#include + +namespace +{ +int HexDigitValue(char ch) +{ + if (ch >= '0' && ch <= '9') + return ch - '0'; + if (ch >= 'a' && ch <= 'f') + return ch - 'a' + 10; + if (ch >= 'A' && ch <= 'F') + return ch - 'A' + 10; + return -1; +} + +bool IsHighSurrogate(unsigned int codePoint) +{ + return codePoint >= 0xD800 && codePoint <= 0xDBFF; +} + +bool IsLowSurrogate(unsigned int codePoint) +{ + return codePoint >= 0xDC00 && codePoint <= 0xDFFF; +} + +void AppendUtf8(unsigned int codePoint, std::ostringstream& output) +{ + if (codePoint <= 0x7F) + { + output << static_cast(codePoint); + } + else if (codePoint <= 0x7FF) + { + output << static_cast(0xC0 | ((codePoint >> 6) & 0x1F)); + output << static_cast(0x80 | (codePoint & 0x3F)); + } + else if (codePoint <= 0xFFFF) + { + output << static_cast(0xE0 | ((codePoint >> 12) & 0x0F)); + output << static_cast(0x80 | ((codePoint >> 6) & 0x3F)); + output << static_cast(0x80 | (codePoint & 0x3F)); + } + else + { + output << static_cast(0xF0 | ((codePoint >> 18) & 0x07)); + output << static_cast(0x80 | ((codePoint >> 12) & 0x3F)); + output << static_cast(0x80 | ((codePoint >> 6) & 0x3F)); + output << static_cast(0x80 | (codePoint & 0x3F)); + } +} + +void AppendControlEscape(unsigned char ch, std::ostringstream& output) +{ + const char* digits = "0123456789ABCDEF"; + output << "\\u00" << digits[(ch >> 4) & 0x0F] << digits[ch & 0x0F]; +} + +class JsonParser +{ +public: + JsonParser(const std::string& text, std::string& error) + : mText(text), mError(error), mPosition(0) + { + } + + bool parse(JsonValue& value) + { + skipWhitespace(); + if (!parseValue(value)) + return false; + + skipWhitespace(); + if (mPosition != mText.size()) + { + setError("Unexpected trailing characters in JSON input."); + return false; + } + + return true; + } + +private: + bool parseValue(JsonValue& value) + { + if (mPosition >= mText.size()) + { + setError("Unexpected end of JSON input."); + return false; + } + + char ch = mText[mPosition]; + if (ch == '{') + return parseObject(value); + if (ch == '[') + return parseArray(value); + if (ch == '"') + { + std::string stringValue; + if (!parseString(stringValue)) + return false; + value = JsonValue(stringValue); + return true; + } + if (ch == 't') + return parseLiteral("true", JsonValue(true), value); + if (ch == 'f') + return parseLiteral("false", JsonValue(false), value); + if (ch == 'n') + return parseLiteral("null", JsonValue(), value); + if (ch == '-' || std::isdigit(static_cast(ch))) + return parseNumber(value); + + setError("Unexpected token while parsing JSON."); + return false; + } + + bool parseObject(JsonValue& value) + { + value = JsonValue::MakeObject(); + ++mPosition; + skipWhitespace(); + if (consume('}')) + return true; + + while (mPosition < mText.size()) + { + std::string key; + if (!parseString(key)) + return false; + + skipWhitespace(); + if (!consume(':')) + { + setError("Expected ':' after JSON object key."); + return false; + } + + skipWhitespace(); + JsonValue item; + if (!parseValue(item)) + return false; + + value.set(key, item); + + skipWhitespace(); + if (consume('}')) + return true; + if (!consume(',')) + { + setError("Expected ',' or '}' in JSON object."); + return false; + } + skipWhitespace(); + } + + setError("Unexpected end of JSON object."); + return false; + } + + bool parseArray(JsonValue& value) + { + value = JsonValue::MakeArray(); + ++mPosition; + skipWhitespace(); + if (consume(']')) + return true; + + while (mPosition < mText.size()) + { + JsonValue item; + if (!parseValue(item)) + return false; + + value.pushBack(item); + + skipWhitespace(); + if (consume(']')) + return true; + if (!consume(',')) + { + setError("Expected ',' or ']' in JSON array."); + return false; + } + skipWhitespace(); + } + + setError("Unexpected end of JSON array."); + return false; + } + + bool parseString(std::string& value) + { + if (!consume('"')) + { + setError("Expected string literal."); + return false; + } + + std::ostringstream result; + while (mPosition < mText.size()) + { + char ch = mText[mPosition++]; + if (ch == '"') + { + value = result.str(); + return true; + } + + if (ch == '\\') + { + if (mPosition >= mText.size()) + { + setError("Unexpected end of escaped JSON string."); + return false; + } + + char escaped = mText[mPosition++]; + switch (escaped) + { + case '"': result << '"'; break; + case '\\': result << '\\'; break; + case '/': result << '/'; break; + case 'b': result << '\b'; break; + case 'f': result << '\f'; break; + case 'n': result << '\n'; break; + case 'r': result << '\r'; break; + case 't': result << '\t'; break; + case 'u': + if (!parseUnicodeEscape(result)) + return false; + break; + default: + setError("Invalid escape sequence in JSON string."); + return false; + } + } + else + { + if (static_cast(ch) < 0x20) + { + setError("Unescaped control character in JSON string."); + return false; + } + result << ch; + } + } + + setError("Unexpected end of JSON string."); + return false; + } + + bool parseHexCodePoint(unsigned int& codePoint) + { + if (mPosition + 4 > mText.size()) + { + setError("Unexpected end of Unicode escape sequence."); + return false; + } + + codePoint = 0; + for (int i = 0; i < 4; ++i) + { + const int digit = HexDigitValue(mText[mPosition + i]); + if (digit < 0) + { + setError("Invalid Unicode escape sequence in JSON string."); + return false; + } + codePoint = (codePoint << 4) | static_cast(digit); + } + + mPosition += 4; + return true; + } + + bool parseUnicodeEscape(std::ostringstream& result) + { + unsigned int codePoint = 0; + if (!parseHexCodePoint(codePoint)) + return false; + + if (IsHighSurrogate(codePoint)) + { + if (mPosition + 2 > mText.size() || mText[mPosition] != '\\' || mText[mPosition + 1] != 'u') + { + setError("High surrogate Unicode escape must be followed by a low surrogate."); + return false; + } + + mPosition += 2; + unsigned int lowSurrogate = 0; + if (!parseHexCodePoint(lowSurrogate)) + return false; + if (!IsLowSurrogate(lowSurrogate)) + { + setError("High surrogate Unicode escape must be followed by a low surrogate."); + return false; + } + + codePoint = 0x10000 + (((codePoint - 0xD800) << 10) | (lowSurrogate - 0xDC00)); + } + else if (IsLowSurrogate(codePoint)) + { + setError("Low surrogate Unicode escape without preceding high surrogate."); + return false; + } + + AppendUtf8(codePoint, result); + return true; + } + + bool parseNumber(JsonValue& value) + { + std::size_t start = mPosition; + + if (mText[mPosition] == '-') + ++mPosition; + + if (mPosition >= mText.size()) + { + setError("Invalid JSON number."); + return false; + } + + if (mText[mPosition] == '0') + { + ++mPosition; + if (mPosition < mText.size() && std::isdigit(static_cast(mText[mPosition]))) + { + setError("JSON numbers must not contain leading zeroes."); + return false; + } + } + else if (mText[mPosition] >= '1' && mText[mPosition] <= '9') + { + while (mPosition < mText.size() && std::isdigit(static_cast(mText[mPosition]))) + ++mPosition; + } + else + { + setError("Invalid JSON number."); + return false; + } + + if (mPosition < mText.size() && mText[mPosition] == '.') + { + ++mPosition; + if (mPosition >= mText.size() || !std::isdigit(static_cast(mText[mPosition]))) + { + setError("JSON number fraction must contain at least one digit."); + return false; + } + while (mPosition < mText.size() && std::isdigit(static_cast(mText[mPosition]))) + ++mPosition; + } + + if (mPosition < mText.size() && (mText[mPosition] == 'e' || mText[mPosition] == 'E')) + { + ++mPosition; + if (mPosition < mText.size() && (mText[mPosition] == '+' || mText[mPosition] == '-')) + ++mPosition; + if (mPosition >= mText.size() || !std::isdigit(static_cast(mText[mPosition]))) + { + setError("JSON number exponent must contain at least one digit."); + return false; + } + while (mPosition < mText.size() && std::isdigit(static_cast(mText[mPosition]))) + ++mPosition; + } + + std::string token = mText.substr(start, mPosition - start); + char* endPtr = nullptr; + errno = 0; + double parsed = strtod(token.c_str(), &endPtr); + if (endPtr == token.c_str() || *endPtr != '\0' || errno == ERANGE || !std::isfinite(parsed)) + { + setError("Invalid JSON number."); + return false; + } + + value = JsonValue(parsed); + return true; + } + + bool parseLiteral(const char* literal, const JsonValue& literalValue, JsonValue& value) + { + std::size_t length = strlen(literal); + if (mText.compare(mPosition, length, literal) != 0) + { + setError("Invalid JSON literal."); + return false; + } + + mPosition += length; + value = literalValue; + return true; + } + + void skipWhitespace() + { + while (mPosition < mText.size() && std::isspace(static_cast(mText[mPosition]))) + ++mPosition; + } + + bool consume(char expected) + { + if (mPosition < mText.size() && mText[mPosition] == expected) + { + ++mPosition; + return true; + } + return false; + } + + void setError(const std::string& error) + { + if (mError.empty()) + mError = error; + } + + const std::string& mText; + std::string& mError; + std::size_t mPosition; +}; + +void SerializeJsonImpl(const JsonValue& value, std::ostringstream& output, bool pretty, int indentLevel) +{ + auto indent = [&](int level) { + if (!pretty) + return; + for (int i = 0; i < level; ++i) + output << " "; + }; + + switch (value.type()) + { + case JsonValue::Type::Null: + output << "null"; + break; + case JsonValue::Type::Boolean: + output << (value.asBoolean() ? "true" : "false"); + break; + case JsonValue::Type::Number: + { + double number = value.asNumber(); + if (std::isfinite(number)) + { + output << std::setprecision(15) << number; + } + else + { + output << "0"; + } + break; + } + case JsonValue::Type::String: + { + output << '"'; + for (char ch : value.asString()) + { + switch (ch) + { + case '"': output << "\\\""; break; + case '\\': output << "\\\\"; break; + case '\b': output << "\\b"; break; + case '\f': output << "\\f"; break; + case '\n': output << "\\n"; break; + case '\r': output << "\\r"; break; + case '\t': output << "\\t"; break; + default: + if (static_cast(ch) < 0x20) + AppendControlEscape(static_cast(ch), output); + else + output << ch; + break; + } + } + output << '"'; + break; + } + case JsonValue::Type::Array: + { + output << "["; + const std::vector& array = value.asArray(); + if (!array.empty()) + { + if (pretty) + output << "\n"; + for (std::size_t i = 0; i < array.size(); ++i) + { + indent(indentLevel + 1); + SerializeJsonImpl(array[i], output, pretty, indentLevel + 1); + if (i + 1 != array.size()) + output << ","; + if (pretty) + output << "\n"; + } + indent(indentLevel); + } + output << "]"; + break; + } + case JsonValue::Type::Object: + { + output << "{"; + const std::map& object = value.asObject(); + if (!object.empty()) + { + if (pretty) + output << "\n"; + std::size_t index = 0; + for (const auto& item : object) + { + indent(indentLevel + 1); + SerializeJsonImpl(JsonValue(item.first), output, pretty, indentLevel + 1); + output << (pretty ? ": " : ":"); + SerializeJsonImpl(item.second, output, pretty, indentLevel + 1); + if (++index != object.size()) + output << ","; + if (pretty) + output << "\n"; + } + indent(indentLevel); + } + output << "}"; + break; + } + } +} +} + +JsonValue::JsonValue() + : mType(Type::Null), mBooleanValue(false), mNumberValue(0.0) +{ +} + +JsonValue::JsonValue(bool value) + : mType(Type::Boolean), mBooleanValue(value), mNumberValue(0.0) +{ +} + +JsonValue::JsonValue(double value) + : mType(Type::Number), mBooleanValue(false), mNumberValue(value) +{ +} + +JsonValue::JsonValue(const char* value) + : mType(Type::String), mBooleanValue(false), mNumberValue(0.0), mStringValue(value ? value : "") +{ +} + +JsonValue::JsonValue(const std::string& value) + : mType(Type::String), mBooleanValue(false), mNumberValue(0.0), mStringValue(value) +{ +} + +JsonValue JsonValue::MakeArray() +{ + JsonValue value; + value.reset(Type::Array); + return value; +} + +JsonValue JsonValue::MakeObject() +{ + JsonValue value; + value.reset(Type::Object); + return value; +} + +bool JsonValue::asBoolean(bool fallback) const +{ + return mType == Type::Boolean ? mBooleanValue : fallback; +} + +double JsonValue::asNumber(double fallback) const +{ + return mType == Type::Number ? mNumberValue : fallback; +} + +const std::string& JsonValue::asString() const +{ + static const std::string emptyString; + return mType == Type::String ? mStringValue : emptyString; +} + +const std::vector& JsonValue::asArray() const +{ + static const std::vector emptyArray; + return mType == Type::Array ? mArrayValue : emptyArray; +} + +const std::map& JsonValue::asObject() const +{ + static const std::map emptyObject; + return mType == Type::Object ? mObjectValue : emptyObject; +} + +std::vector& JsonValue::array() +{ + if (mType != Type::Array) + reset(Type::Array); + return mArrayValue; +} + +std::map& JsonValue::object() +{ + if (mType != Type::Object) + reset(Type::Object); + return mObjectValue; +} + +void JsonValue::pushBack(const JsonValue& value) +{ + array().push_back(value); +} + +void JsonValue::set(const std::string& key, const JsonValue& value) +{ + object()[key] = value; +} + +const JsonValue* JsonValue::find(const std::string& key) const +{ + if (mType != Type::Object) + return nullptr; + + auto iterator = mObjectValue.find(key); + return iterator != mObjectValue.end() ? &iterator->second : nullptr; +} + +void JsonValue::reset(Type type) +{ + mType = type; + mBooleanValue = false; + mNumberValue = 0.0; + mStringValue.clear(); + mArrayValue.clear(); + mObjectValue.clear(); +} + +bool ParseJson(const std::string& text, JsonValue& value, std::string& error) +{ + error.clear(); + JsonParser parser(text, error); + return parser.parse(value); +} + +std::string SerializeJson(const JsonValue& value, bool pretty) +{ + std::ostringstream output; + SerializeJsonImpl(value, output, pretty, 0); + return output.str(); +} + +std::vector JsonArrayToNumbers(const JsonValue& value) +{ + std::vector numbers; + for (const JsonValue& item : value.asArray()) + { + if (item.isNumber()) + numbers.push_back(item.asNumber()); + } + return numbers; +} diff --git a/src/runtime/RuntimeJson.h b/src/runtime/RuntimeJson.h new file mode 100644 index 0000000..52879d9 --- /dev/null +++ b/src/runtime/RuntimeJson.h @@ -0,0 +1,65 @@ +#pragma once + +#include +#include +#include + +class JsonValue +{ +public: + enum class Type + { + Null, + Boolean, + Number, + String, + Array, + Object + }; + + JsonValue(); + explicit JsonValue(bool value); + explicit JsonValue(double value); + explicit JsonValue(const char* value); + explicit JsonValue(const std::string& value); + + static JsonValue MakeArray(); + static JsonValue MakeObject(); + + Type type() const { return mType; } + + bool isNull() const { return mType == Type::Null; } + bool isBoolean() const { return mType == Type::Boolean; } + bool isNumber() const { return mType == Type::Number; } + bool isString() const { return mType == Type::String; } + bool isArray() const { return mType == Type::Array; } + bool isObject() const { return mType == Type::Object; } + + bool asBoolean(bool fallback = false) const; + double asNumber(double fallback = 0.0) const; + const std::string& asString() const; + const std::vector& asArray() const; + const std::map& asObject() const; + + std::vector& array(); + std::map& object(); + + void pushBack(const JsonValue& value); + void set(const std::string& key, const JsonValue& value); + + const JsonValue* find(const std::string& key) const; + +private: + void reset(Type type); + + Type mType; + bool mBooleanValue; + double mNumberValue; + std::string mStringValue; + std::vector mArrayValue; + std::map mObjectValue; +}; + +bool ParseJson(const std::string& text, JsonValue& value, std::string& error); +std::string SerializeJson(const JsonValue& value, bool pretty = false); +std::vector JsonArrayToNumbers(const JsonValue& value); diff --git a/src/runtime/RuntimeParameterUtils.cpp b/src/runtime/RuntimeParameterUtils.cpp new file mode 100644 index 0000000..9e670fe --- /dev/null +++ b/src/runtime/RuntimeParameterUtils.cpp @@ -0,0 +1,196 @@ +#include "stdafx.h" +#include "RuntimeParameterUtils.h" + +#include +#include +#include +#include + +namespace +{ +std::string TrimText(const std::string& text) +{ + std::size_t start = 0; + while (start < text.size() && std::isspace(static_cast(text[start]))) + ++start; + + std::size_t end = text.size(); + while (end > start && std::isspace(static_cast(text[end - 1]))) + --end; + + return text.substr(start, end - start); +} + +bool IsFiniteNumber(double value) +{ + return std::isfinite(value) != 0; +} + +std::string NormalizeTextValue(const std::string& text, unsigned maxLength) +{ + std::string normalized; + normalized.reserve(std::min(text.size(), maxLength)); + for (unsigned char ch : text) + { + if (ch < 32 || ch > 126) + continue; + if (normalized.size() >= maxLength) + break; + normalized.push_back(static_cast(ch)); + } + return normalized; +} +} + +std::string MakeSafePresetFileStem(const std::string& presetName) +{ + std::string trimmed = TrimText(presetName); + std::string safe; + safe.reserve(trimmed.size()); + + for (unsigned char ch : trimmed) + { + if (std::isalnum(ch)) + safe.push_back(static_cast(std::tolower(ch))); + else if (ch == ' ' || ch == '-' || ch == '_') + { + if (safe.empty() || safe.back() == '-') + continue; + safe.push_back('-'); + } + } + + while (!safe.empty() && safe.back() == '-') + safe.pop_back(); + + return safe; +} + +ShaderParameterValue DefaultValueForDefinition(const ShaderParameterDefinition& definition) +{ + ShaderParameterValue value; + switch (definition.type) + { + case ShaderParameterType::Float: + value.numberValues = definition.defaultNumbers.empty() ? std::vector{ 0.0 } : definition.defaultNumbers; + break; + case ShaderParameterType::Vec2: + value.numberValues = definition.defaultNumbers.size() == 2 ? definition.defaultNumbers : std::vector{ 0.0, 0.0 }; + break; + case ShaderParameterType::Color: + value.numberValues = definition.defaultNumbers.size() == 4 ? definition.defaultNumbers : std::vector{ 1.0, 1.0, 1.0, 1.0 }; + break; + case ShaderParameterType::Boolean: + value.booleanValue = definition.defaultBoolean; + break; + case ShaderParameterType::Enum: + value.enumValue = definition.defaultEnumValue; + break; + case ShaderParameterType::Text: + value.textValue = NormalizeTextValue(definition.defaultTextValue, definition.maxLength); + break; + case ShaderParameterType::Trigger: + value.numberValues = { 0.0, -1000000.0 }; + break; + } + return value; +} + +bool NormalizeAndValidateParameterValue(const ShaderParameterDefinition& definition, const JsonValue& value, ShaderParameterValue& normalizedValue, std::string& error) +{ + normalizedValue = DefaultValueForDefinition(definition); + + switch (definition.type) + { + case ShaderParameterType::Float: + { + if (!value.isNumber()) + { + error = "Expected numeric value for float parameter '" + definition.id + "'."; + return false; + } + double number = value.asNumber(); + if (!IsFiniteNumber(number)) + { + error = "Float parameter '" + definition.id + "' must be finite."; + return false; + } + if (!definition.minNumbers.empty()) + number = std::max(number, definition.minNumbers.front()); + if (!definition.maxNumbers.empty()) + number = std::min(number, definition.maxNumbers.front()); + normalizedValue.numberValues = { number }; + return true; + } + case ShaderParameterType::Vec2: + case ShaderParameterType::Color: + { + std::vector numbers = JsonArrayToNumbers(value); + const std::size_t expectedSize = definition.type == ShaderParameterType::Vec2 ? 2 : 4; + if (numbers.size() != expectedSize) + { + error = "Expected array value of size " + std::to_string(expectedSize) + " for parameter '" + definition.id + "'."; + return false; + } + for (std::size_t index = 0; index < numbers.size(); ++index) + { + if (!IsFiniteNumber(numbers[index])) + { + error = "Parameter '" + definition.id + "' contains a non-finite value."; + return false; + } + if (index < definition.minNumbers.size()) + numbers[index] = std::max(numbers[index], definition.minNumbers[index]); + if (index < definition.maxNumbers.size()) + numbers[index] = std::min(numbers[index], definition.maxNumbers[index]); + } + normalizedValue.numberValues = numbers; + return true; + } + case ShaderParameterType::Boolean: + if (!value.isBoolean()) + { + error = "Expected boolean value for parameter '" + definition.id + "'."; + return false; + } + normalizedValue.booleanValue = value.asBoolean(); + return true; + case ShaderParameterType::Enum: + { + if (!value.isString()) + { + error = "Expected string value for enum parameter '" + definition.id + "'."; + return false; + } + const std::string selectedValue = value.asString(); + for (const ShaderParameterOption& option : definition.enumOptions) + { + if (option.value == selectedValue) + { + normalizedValue.enumValue = selectedValue; + return true; + } + } + error = "Enum parameter '" + definition.id + "' received unsupported option '" + selectedValue + "'."; + return false; + } + case ShaderParameterType::Text: + if (!value.isString()) + { + error = "Expected string value for text parameter '" + definition.id + "'."; + return false; + } + normalizedValue.textValue = NormalizeTextValue(value.asString(), definition.maxLength); + return true; + case ShaderParameterType::Trigger: + if (!value.isNumber() && !value.isBoolean()) + { + error = "Expected numeric or boolean value for trigger parameter '" + definition.id + "'."; + return false; + } + normalizedValue.numberValues = { value.isNumber() ? std::max(0.0, std::floor(value.asNumber())) : 0.0, -1000000.0 }; + return true; + } + + return false; +} diff --git a/src/runtime/RuntimeParameterUtils.h b/src/runtime/RuntimeParameterUtils.h new file mode 100644 index 0000000..d812ea2 --- /dev/null +++ b/src/runtime/RuntimeParameterUtils.h @@ -0,0 +1,10 @@ +#pragma once + +#include "RuntimeJson.h" +#include "ShaderTypes.h" + +#include + +std::string MakeSafePresetFileStem(const std::string& presetName); +ShaderParameterValue DefaultValueForDefinition(const ShaderParameterDefinition& definition); +bool NormalizeAndValidateParameterValue(const ShaderParameterDefinition& definition, const JsonValue& value, ShaderParameterValue& normalizedValue, std::string& error); diff --git a/src/shader/ShaderCompiler.cpp b/src/shader/ShaderCompiler.cpp new file mode 100644 index 0000000..2314db9 --- /dev/null +++ b/src/shader/ShaderCompiler.cpp @@ -0,0 +1,326 @@ +#include "stdafx.h" +#include "ShaderCompiler.h" + +#include "NativeHandles.h" + +#include +#include +#include +#include +#include + +namespace +{ +std::string ReplaceAll(std::string text, const std::string& from, const std::string& to) +{ + std::size_t offset = 0; + while ((offset = text.find(from, offset)) != std::string::npos) + { + text.replace(offset, from.length(), to); + offset += to.length(); + } + return text; +} + +std::string SlangCBufferTypeForParameter(ShaderParameterType type) +{ + switch (type) + { + case ShaderParameterType::Float: return "float"; + case ShaderParameterType::Vec2: return "float2"; + case ShaderParameterType::Color: return "float4"; + case ShaderParameterType::Boolean: return "bool"; + case ShaderParameterType::Enum: return "int"; + case ShaderParameterType::Text: return ""; + case ShaderParameterType::Trigger: return "int"; + } + return "float"; +} + +std::string CapitalizeIdentifier(const std::string& identifier) +{ + if (identifier.empty()) + return identifier; + std::string text = identifier; + text[0] = static_cast(std::toupper(static_cast(text[0]))); + return text; +} + +std::string BuildParameterUniforms(const std::vector& parameters) +{ + std::ostringstream source; + for (const ShaderParameterDefinition& definition : parameters) + { + if (definition.type == ShaderParameterType::Text) + continue; + if (definition.type == ShaderParameterType::Trigger) + { + source << "\tint " << definition.id << ";\n"; + source << "\tfloat " << definition.id << "Time;\n"; + continue; + } + source << "\t" << SlangCBufferTypeForParameter(definition.type) << " " << definition.id << ";\n"; + } + return source.str(); +} + +std::string BuildHistorySamplerDeclarations(const std::string& samplerPrefix, unsigned historyLength) +{ + std::ostringstream source; + for (unsigned index = 0; index < historyLength; ++index) + source << "Sampler2D " << samplerPrefix << index << ";\n"; + return source.str(); +} + +std::string BuildTextureSamplerDeclarations(const std::vector& textureAssets) +{ + std::ostringstream source; + for (const ShaderTextureAsset& textureAsset : textureAssets) + source << "Sampler2D " << textureAsset.id << ";\n"; + if (!textureAssets.empty()) + source << "\n"; + return source.str(); +} + +std::string BuildTextSamplerDeclarations(const std::vector& parameters) +{ + std::ostringstream source; + for (const ShaderParameterDefinition& definition : parameters) + { + if (definition.type != ShaderParameterType::Text) + continue; + source << "Sampler2D " << definition.id << "Texture;\n"; + } + if (source.tellp() > 0) + source << "\n"; + return source.str(); +} + +std::string BuildTextHelpers(const std::vector& parameters) +{ + std::ostringstream source; + for (const ShaderParameterDefinition& definition : parameters) + { + if (definition.type != ShaderParameterType::Text) + continue; + const std::string suffix = CapitalizeIdentifier(definition.id); + source + << "float sample" << suffix << "(float2 uv)\n" + << "{\n" + << "\tif (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0)\n" + << "\t\treturn 0.0;\n" + << "\treturn " << definition.id << "Texture.Sample(uv).r;\n" + << "}\n\n" + << "float4 draw" << suffix << "(float2 uv, float4 fillColor)\n" + << "{\n" + << "\tfloat alpha = sample" << suffix << "(uv) * fillColor.a;\n" + << "\treturn float4(fillColor.rgb * alpha, alpha);\n" + << "}\n\n"; + } + return source.str(); +} + +std::string BuildHistorySwitchCases(const std::string& samplerPrefix, unsigned historyLength) +{ + std::ostringstream source; + for (unsigned index = 0; index < historyLength; ++index) + source << "\tcase " << index << ": return " << samplerPrefix << index << ".Sample(tc);\n"; + return source.str(); +} +} + +ShaderCompiler::ShaderCompiler( + const std::filesystem::path& repoRoot, + const std::filesystem::path& wrapperPath, + const std::filesystem::path& generatedGlslPath, + const std::filesystem::path& patchedGlslPath, + unsigned maxTemporalHistoryFrames) + : mRepoRoot(repoRoot), + mWrapperPath(wrapperPath), + mGeneratedGlslPath(generatedGlslPath), + mPatchedGlslPath(patchedGlslPath), + mMaxTemporalHistoryFrames(maxTemporalHistoryFrames) +{ +} + +bool ShaderCompiler::BuildPassFragmentShaderSource(const ShaderPackage& shaderPackage, const ShaderPassDefinition& pass, std::string& fragmentShaderSource, std::string& error) const +{ + std::string wrapperSource; + if (!BuildWrapperSlangSource(shaderPackage, pass, wrapperSource, error)) + return false; + if (!WriteTextFile(mWrapperPath, wrapperSource, error)) + return false; + + if (!RunSlangCompiler(mWrapperPath, mGeneratedGlslPath, error)) + return false; + + fragmentShaderSource = ReadTextFile(mGeneratedGlslPath, error); + if (fragmentShaderSource.empty()) + return false; + + if (!PatchGeneratedGlsl(fragmentShaderSource, error)) + return false; + + if (!WriteTextFile(mPatchedGlslPath, fragmentShaderSource, error)) + return false; + + return true; +} + +bool ShaderCompiler::BuildWrapperSlangSource(const ShaderPackage& shaderPackage, const ShaderPassDefinition& pass, std::string& wrapperSource, std::string& error) const +{ + const std::filesystem::path templatePath = mRepoRoot / "runtime" / "templates" / "shader_wrapper.slang.in"; + wrapperSource = ReadTextFile(templatePath, error); + if (wrapperSource.empty()) + return false; + + wrapperSource = ReplaceAll(wrapperSource, "{{PARAMETER_UNIFORMS}}", BuildParameterUniforms(shaderPackage.parameters)); + const unsigned historySamplerCount = shaderPackage.temporal.enabled ? mMaxTemporalHistoryFrames : 0; + wrapperSource = ReplaceAll(wrapperSource, "{{SOURCE_HISTORY_SAMPLERS}}", BuildHistorySamplerDeclarations("gSourceHistory", historySamplerCount)); + wrapperSource = ReplaceAll(wrapperSource, "{{TEMPORAL_HISTORY_SAMPLERS}}", BuildHistorySamplerDeclarations("gTemporalHistory", historySamplerCount)); + wrapperSource = ReplaceAll(wrapperSource, "{{FEEDBACK_SAMPLER}}", shaderPackage.feedback.enabled ? "Sampler2D gFeedbackState;\n" : ""); + wrapperSource = ReplaceAll(wrapperSource, "{{FEEDBACK_HELPER}}", + shaderPackage.feedback.enabled + ? "float4 sampleFeedback(float2 tc)\n{\n\tif (gFeedbackAvailable <= 0)\n\t\treturn float4(0.0, 0.0, 0.0, 0.0);\n\treturn gFeedbackState.Sample(tc);\n}\n" + : "float4 sampleFeedback(float2 tc)\n{\n\treturn float4(0.0, 0.0, 0.0, 0.0);\n}\n"); + wrapperSource = ReplaceAll(wrapperSource, "{{TEXTURE_SAMPLERS}}", BuildTextureSamplerDeclarations(shaderPackage.textureAssets)); + wrapperSource = ReplaceAll(wrapperSource, "{{TEXT_SAMPLERS}}", BuildTextSamplerDeclarations(shaderPackage.parameters)); + wrapperSource = ReplaceAll(wrapperSource, "{{TEXT_HELPERS}}", BuildTextHelpers(shaderPackage.parameters)); + wrapperSource = ReplaceAll(wrapperSource, "{{SOURCE_HISTORY_SWITCH_CASES}}", BuildHistorySwitchCases("gSourceHistory", historySamplerCount)); + wrapperSource = ReplaceAll(wrapperSource, "{{TEMPORAL_HISTORY_SWITCH_CASES}}", BuildHistorySwitchCases("gTemporalHistory", historySamplerCount)); + wrapperSource = ReplaceAll(wrapperSource, "{{USER_SHADER_INCLUDE}}", pass.sourcePath.generic_string()); + wrapperSource = ReplaceAll(wrapperSource, "{{ENTRY_POINT_CALL}}", pass.entryPoint + "(context)"); + return true; +} + +bool ShaderCompiler::FindSlangCompiler(std::filesystem::path& compilerPath, std::string& error) const +{ + char slangRootBuffer[MAX_PATH] = {}; + const DWORD slangRootLength = GetEnvironmentVariableA("SLANG_ROOT", slangRootBuffer, static_cast(sizeof(slangRootBuffer))); + if (slangRootLength > 0 && slangRootLength < sizeof(slangRootBuffer)) + { + std::filesystem::path candidate = std::filesystem::path(slangRootBuffer) / "bin" / "slangc.exe"; + if (std::filesystem::exists(candidate)) + { + compilerPath = candidate; + return true; + } + } + + std::filesystem::path thirdPartyRoot = mRepoRoot / "3rdParty"; + if (!std::filesystem::exists(thirdPartyRoot)) + { + error = "3rdParty directory was not found under the repository root."; + return false; + } + + for (const auto& entry : std::filesystem::directory_iterator(thirdPartyRoot)) + { + if (!entry.is_directory()) + continue; + std::filesystem::path candidate = entry.path() / "bin" / "slangc.exe"; + if (std::filesystem::exists(candidate)) + { + compilerPath = candidate; + return true; + } + } + + error = "Could not find slangc.exe under 3rdParty."; + return false; +} + +bool ShaderCompiler::RunSlangCompiler(const std::filesystem::path& wrapperPath, const std::filesystem::path& outputPath, std::string& error) const +{ + std::filesystem::path compilerPath; + if (!FindSlangCompiler(compilerPath, error)) + return false; + + std::string commandLine = "\"" + compilerPath.string() + "\" \"" + wrapperPath.string() + + "\" -target glsl -profile glsl_430 -entry fragmentMain -stage fragment -o \"" + outputPath.string() + "\""; + + STARTUPINFOA startupInfo = {}; + PROCESS_INFORMATION processInfo = {}; + startupInfo.cb = sizeof(startupInfo); + std::vector mutableCommandLine(commandLine.begin(), commandLine.end()); + mutableCommandLine.push_back('\0'); + + if (!CreateProcessA(NULL, mutableCommandLine.data(), NULL, NULL, FALSE, CREATE_NO_WINDOW, NULL, mRepoRoot.string().c_str(), &startupInfo, &processInfo)) + { + error = "Failed to launch slangc.exe."; + return false; + } + + UniqueHandle processHandle(processInfo.hProcess); + UniqueHandle threadHandle(processInfo.hThread); + + WaitForSingleObject(processHandle.get(), INFINITE); + + DWORD exitCode = 0; + GetExitCodeProcess(processHandle.get(), &exitCode); + + if (exitCode != 0) + { + error = "slangc.exe returned a non-zero exit code while compiling the active shader package."; + return false; + } + + return true; +} + +bool ShaderCompiler::PatchGeneratedGlsl(std::string& shaderText, std::string& error) const +{ + if (shaderText.find("#version 450") == std::string::npos) + { + error = "Generated GLSL did not include the expected version header."; + return false; + } + + shaderText = ReplaceAll(shaderText, "#version 450", "#version 430 core"); + shaderText = std::regex_replace(shaderText, std::regex(R"(#extension GL_EXT_samplerless_texture_functions : require\r?\n)"), ""); + shaderText = std::regex_replace(shaderText, std::regex(R"(layout\(row_major\) uniform;\r?\n)"), ""); + shaderText = std::regex_replace(shaderText, std::regex(R"(layout\(row_major\) buffer;\r?\n)"), ""); + shaderText = std::regex_replace(shaderText, std::regex(R"(layout\(location = 0\)\s*in vec2 ([A-Za-z0-9_]+);)"), "in vec2 vTexCoord;"); + shaderText = ReplaceAll(shaderText, "input_texCoord_0", "vTexCoord"); + + std::smatch match; + std::regex outRegex(R"(layout\(location = 0\)\s*out vec4 ([A-Za-z0-9_]+);)"); + if (std::regex_search(shaderText, match, outRegex)) + { + const std::string outputName = match[1].str(); + shaderText = std::regex_replace(shaderText, outRegex, "layout(location = 0) out vec4 fragColor;"); + shaderText = ReplaceAll(shaderText, outputName + " =", "fragColor ="); + } + + return true; +} + +std::string ShaderCompiler::ReadTextFile(const std::filesystem::path& path, std::string& error) const +{ + std::ifstream input(path, std::ios::binary); + if (!input) + { + error = "Could not open file: " + path.string(); + return std::string(); + } + + std::ostringstream buffer; + buffer << input.rdbuf(); + return buffer.str(); +} + +bool ShaderCompiler::WriteTextFile(const std::filesystem::path& path, const std::string& contents, std::string& error) const +{ + std::error_code fsError; + std::filesystem::create_directories(path.parent_path(), fsError); + + std::ofstream output(path, std::ios::binary); + if (!output) + { + error = "Could not write file: " + path.string(); + return false; + } + + output << contents; + return output.good(); +} diff --git a/src/shader/ShaderCompiler.h b/src/shader/ShaderCompiler.h new file mode 100644 index 0000000..9fc8c03 --- /dev/null +++ b/src/shader/ShaderCompiler.h @@ -0,0 +1,34 @@ +#pragma once + +#include "ShaderTypes.h" + +#include +#include + +class ShaderCompiler +{ +public: + ShaderCompiler( + const std::filesystem::path& repoRoot, + const std::filesystem::path& wrapperPath, + const std::filesystem::path& generatedGlslPath, + const std::filesystem::path& patchedGlslPath, + unsigned maxTemporalHistoryFrames); + + bool BuildPassFragmentShaderSource(const ShaderPackage& shaderPackage, const ShaderPassDefinition& pass, std::string& fragmentShaderSource, std::string& error) const; + +private: + bool BuildWrapperSlangSource(const ShaderPackage& shaderPackage, const ShaderPassDefinition& pass, std::string& wrapperSource, std::string& error) const; + bool FindSlangCompiler(std::filesystem::path& compilerPath, std::string& error) const; + bool RunSlangCompiler(const std::filesystem::path& wrapperPath, const std::filesystem::path& outputPath, std::string& error) const; + bool PatchGeneratedGlsl(std::string& shaderText, std::string& error) const; + std::string ReadTextFile(const std::filesystem::path& path, std::string& error) const; + bool WriteTextFile(const std::filesystem::path& path, const std::string& contents, std::string& error) const; + +private: + std::filesystem::path mRepoRoot; + std::filesystem::path mWrapperPath; + std::filesystem::path mGeneratedGlslPath; + std::filesystem::path mPatchedGlslPath; + unsigned mMaxTemporalHistoryFrames; +}; diff --git a/src/shader/ShaderPackageRegistry.cpp b/src/shader/ShaderPackageRegistry.cpp new file mode 100644 index 0000000..59fecbe --- /dev/null +++ b/src/shader/ShaderPackageRegistry.cpp @@ -0,0 +1,818 @@ +#include "stdafx.h" +#include "ShaderPackageRegistry.h" + +#include "RuntimeJson.h" + +#include +#include +#include +#include +#include + +namespace +{ +std::string Trim(const std::string& text) +{ + std::size_t start = 0; + while (start < text.size() && std::isspace(static_cast(text[start]))) + ++start; + + std::size_t end = text.size(); + while (end > start && std::isspace(static_cast(text[end - 1]))) + --end; + + return text.substr(start, end - start); +} + +bool IsFiniteNumber(double value) +{ + return std::isfinite(value) != 0; +} + +bool ParseShaderParameterType(const std::string& typeName, ShaderParameterType& type) +{ + if (typeName == "float") + { + type = ShaderParameterType::Float; + return true; + } + if (typeName == "vec2") + { + type = ShaderParameterType::Vec2; + return true; + } + if (typeName == "color") + { + type = ShaderParameterType::Color; + return true; + } + if (typeName == "bool") + { + type = ShaderParameterType::Boolean; + return true; + } + if (typeName == "enum") + { + type = ShaderParameterType::Enum; + return true; + } + if (typeName == "text") + { + type = ShaderParameterType::Text; + return true; + } + if (typeName == "trigger") + { + type = ShaderParameterType::Trigger; + return true; + } + return false; +} + +bool ParseTemporalHistorySource(const std::string& sourceName, TemporalHistorySource& source) +{ + if (sourceName == "source") + { + source = TemporalHistorySource::Source; + return true; + } + if (sourceName == "preLayerInput") + { + source = TemporalHistorySource::PreLayerInput; + return true; + } + if (sourceName == "none") + { + source = TemporalHistorySource::None; + return true; + } + return false; +} + +std::string ReadTextFile(const std::filesystem::path& path, std::string& error) +{ + std::ifstream input(path, std::ios::binary); + if (!input) + { + error = "Could not open file: " + path.string(); + return std::string(); + } + + std::ostringstream buffer; + buffer << input.rdbuf(); + return buffer.str(); +} + +std::string ManifestPathMessage(const std::filesystem::path& manifestPath) +{ + return manifestPath.string(); +} + +bool RequireStringField(const JsonValue& object, const char* fieldName, std::string& value, const std::filesystem::path& manifestPath, std::string& error) +{ + const JsonValue* fieldValue = object.find(fieldName); + if (!fieldValue || !fieldValue->isString()) + { + error = "Shader manifest is missing required string '" + std::string(fieldName) + "' field: " + ManifestPathMessage(manifestPath); + return false; + } + + value = fieldValue->asString(); + return true; +} + +bool RequireNonEmptyStringField(const JsonValue& object, const char* fieldName, std::string& value, const std::filesystem::path& manifestPath, std::string& error) +{ + if (!RequireStringField(object, fieldName, value, manifestPath, error)) + return false; + if (Trim(value).empty()) + { + error = "Shader manifest string '" + std::string(fieldName) + "' must not be empty: " + ManifestPathMessage(manifestPath); + return false; + } + return true; +} + +bool OptionalStringField(const JsonValue& object, const char* fieldName, std::string& value, const std::string& fallback, const std::filesystem::path& manifestPath, std::string& error) +{ + const JsonValue* fieldValue = object.find(fieldName); + if (!fieldValue) + { + value = fallback; + return true; + } + if (!fieldValue->isString()) + { + error = "Shader manifest field '" + std::string(fieldName) + "' must be a string in: " + ManifestPathMessage(manifestPath); + return false; + } + value = fieldValue->asString(); + return true; +} + +bool OptionalArrayField(const JsonValue& object, const char* fieldName, const JsonValue*& value, const std::filesystem::path& manifestPath, std::string& error) +{ + value = object.find(fieldName); + if (!value) + return true; + if (!value->isArray()) + { + error = "Shader manifest '" + std::string(fieldName) + "' field must be an array in: " + ManifestPathMessage(manifestPath); + return false; + } + return true; +} + +bool OptionalObjectField(const JsonValue& object, const char* fieldName, const JsonValue*& value, const std::filesystem::path& manifestPath, std::string& error) +{ + value = object.find(fieldName); + if (!value) + return true; + if (!value->isObject()) + { + error = "Shader manifest '" + std::string(fieldName) + "' field must be an object in: " + ManifestPathMessage(manifestPath); + return false; + } + return true; +} + +bool NumberListFromJsonValue(const JsonValue& value, std::vector& numbers, const std::string& fieldName, const std::filesystem::path& manifestPath, std::string& error) +{ + if (value.isNumber()) + { + numbers.push_back(value.asNumber()); + return true; + } + if (value.isArray()) + { + numbers = JsonArrayToNumbers(value); + if (numbers.size() != value.asArray().size()) + { + error = "Shader parameter field '" + fieldName + "' must contain only numbers in: " + ManifestPathMessage(manifestPath); + return false; + } + return true; + } + + error = "Shader parameter field '" + fieldName + "' must be a number or array of numbers in: " + ManifestPathMessage(manifestPath); + return false; +} + +bool ValidateShaderIdentifier(const std::string& identifier, const std::string& fieldName, const std::filesystem::path& manifestPath, std::string& error) +{ + if (identifier.empty() || !(std::isalpha(static_cast(identifier.front())) || identifier.front() == '_')) + { + error = "Shader manifest field '" + fieldName + "' must be a valid shader identifier in: " + ManifestPathMessage(manifestPath); + return false; + } + + for (char ch : identifier) + { + const unsigned char unsignedCh = static_cast(ch); + if (!(std::isalnum(unsignedCh) || ch == '_')) + { + error = "Shader manifest field '" + fieldName + "' must be a valid shader identifier in: " + ManifestPathMessage(manifestPath); + return false; + } + } + + return true; +} + +bool ParseShaderMetadata(const JsonValue& manifestJson, ShaderPackage& shaderPackage, const std::filesystem::path& manifestPath, std::string& error) +{ + if (!RequireStringField(manifestJson, "id", shaderPackage.id, manifestPath, error) || + !RequireStringField(manifestJson, "name", shaderPackage.displayName, manifestPath, error) || + !OptionalStringField(manifestJson, "description", shaderPackage.description, "", manifestPath, error) || + !OptionalStringField(manifestJson, "category", shaderPackage.category, "", manifestPath, error) || + !OptionalStringField(manifestJson, "entryPoint", shaderPackage.entryPoint, "shadeVideo", manifestPath, error)) + { + return false; + } + + if (!ValidateShaderIdentifier(shaderPackage.entryPoint, "entryPoint", manifestPath, error)) + return false; + + shaderPackage.directoryPath = manifestPath.parent_path(); + shaderPackage.shaderPath = shaderPackage.directoryPath / "shader.slang"; + shaderPackage.manifestPath = manifestPath; + return true; +} + +bool ParsePassDefinitions(const JsonValue& manifestJson, ShaderPackage& shaderPackage, const std::filesystem::path& manifestPath, std::string& error) +{ + const JsonValue* passesValue = nullptr; + if (!OptionalArrayField(manifestJson, "passes", passesValue, manifestPath, error)) + return false; + + if (!passesValue) + { + // Existing shader packages are treated as a single implicit pass, so + // multipass support does not require manifest churn. + ShaderPassDefinition pass; + pass.id = "main"; + pass.entryPoint = shaderPackage.entryPoint; + pass.sourcePath = shaderPackage.shaderPath; + pass.outputName = "layerOutput"; + if (!std::filesystem::exists(pass.sourcePath)) + { + error = "Shader source not found for package " + shaderPackage.id + ": " + pass.sourcePath.string(); + return false; + } + pass.sourceWriteTime = std::filesystem::last_write_time(pass.sourcePath); + shaderPackage.passes.push_back(pass); + return true; + } + + if (passesValue->asArray().empty()) + { + error = "Shader manifest 'passes' field must not be empty in: " + ManifestPathMessage(manifestPath); + return false; + } + + for (const JsonValue& passJson : passesValue->asArray()) + { + if (!passJson.isObject()) + { + error = "Shader pass entry must be an object in: " + ManifestPathMessage(manifestPath); + return false; + } + + std::string passId; + std::string sourcePath; + if (!RequireNonEmptyStringField(passJson, "id", passId, manifestPath, error) || + !RequireNonEmptyStringField(passJson, "source", sourcePath, manifestPath, error)) + { + error = "Shader pass is missing required 'id' or 'source' in: " + ManifestPathMessage(manifestPath); + return false; + } + if (!ValidateShaderIdentifier(passId, "passes[].id", manifestPath, error)) + return false; + + for (const ShaderPassDefinition& existingPass : shaderPackage.passes) + { + if (existingPass.id == passId) + { + error = "Duplicate shader pass id '" + passId + "' in: " + ManifestPathMessage(manifestPath); + return false; + } + } + + ShaderPassDefinition pass; + pass.id = passId; + pass.sourcePath = shaderPackage.directoryPath / sourcePath; + if (!OptionalStringField(passJson, "entryPoint", pass.entryPoint, shaderPackage.entryPoint, manifestPath, error) || + !OptionalStringField(passJson, "output", pass.outputName, passId, manifestPath, error)) + { + return false; + } + if (!ValidateShaderIdentifier(pass.entryPoint, "passes[].entryPoint", manifestPath, error)) + return false; + + const JsonValue* inputsValue = nullptr; + if (!OptionalArrayField(passJson, "inputs", inputsValue, manifestPath, error)) + return false; + if (inputsValue) + { + for (const JsonValue& inputValue : inputsValue->asArray()) + { + if (!inputValue.isString()) + { + error = "Shader pass inputs must be strings in: " + ManifestPathMessage(manifestPath); + return false; + } + pass.inputNames.push_back(inputValue.asString()); + } + } + + // Keep source validation in the registry. Bad pass declarations then + // appear as unavailable shaders instead of failing at render time. + if (!std::filesystem::exists(pass.sourcePath)) + { + error = "Shader pass source not found for package " + shaderPackage.id + ": " + pass.sourcePath.string(); + return false; + } + pass.sourceWriteTime = std::filesystem::last_write_time(pass.sourcePath); + shaderPackage.passes.push_back(pass); + } + + shaderPackage.shaderPath = shaderPackage.passes.front().sourcePath; + return true; +} + +bool ParseTextureAssets(const JsonValue& manifestJson, ShaderPackage& shaderPackage, const std::filesystem::path& manifestPath, std::string& error) +{ + const JsonValue* texturesValue = nullptr; + if (!OptionalArrayField(manifestJson, "textures", texturesValue, manifestPath, error)) + return false; + if (!texturesValue) + return true; + + for (const JsonValue& textureJson : texturesValue->asArray()) + { + if (!textureJson.isObject()) + { + error = "Shader texture entry must be an object in: " + ManifestPathMessage(manifestPath); + return false; + } + + std::string textureId; + std::string texturePath; + if (!RequireNonEmptyStringField(textureJson, "id", textureId, manifestPath, error) || + !RequireNonEmptyStringField(textureJson, "path", texturePath, manifestPath, error)) + { + error = "Shader texture is missing required 'id' or 'path' in: " + ManifestPathMessage(manifestPath); + return false; + } + if (!ValidateShaderIdentifier(textureId, "textures[].id", manifestPath, error)) + return false; + + ShaderTextureAsset textureAsset; + textureAsset.id = textureId; + textureAsset.path = shaderPackage.directoryPath / texturePath; + if (!std::filesystem::exists(textureAsset.path)) + { + error = "Shader texture asset not found for package " + shaderPackage.id + ": " + textureAsset.path.string(); + return false; + } + + textureAsset.writeTime = std::filesystem::last_write_time(textureAsset.path); + shaderPackage.textureAssets.push_back(textureAsset); + } + + return true; +} + +bool ParseFontAssets(const JsonValue& manifestJson, ShaderPackage& shaderPackage, const std::filesystem::path& manifestPath, std::string& error) +{ + const JsonValue* fontsValue = nullptr; + if (!OptionalArrayField(manifestJson, "fonts", fontsValue, manifestPath, error)) + return false; + if (!fontsValue) + return true; + + for (const JsonValue& fontJson : fontsValue->asArray()) + { + if (!fontJson.isObject()) + { + error = "Shader font entry must be an object in: " + ManifestPathMessage(manifestPath); + return false; + } + + std::string fontId; + std::string fontPath; + if (!RequireNonEmptyStringField(fontJson, "id", fontId, manifestPath, error) || + !RequireNonEmptyStringField(fontJson, "path", fontPath, manifestPath, error)) + { + error = "Shader font is missing required 'id' or 'path' in: " + ManifestPathMessage(manifestPath); + return false; + } + if (!ValidateShaderIdentifier(fontId, "fonts[].id", manifestPath, error)) + return false; + + ShaderFontAsset fontAsset; + fontAsset.id = fontId; + fontAsset.path = shaderPackage.directoryPath / fontPath; + if (!std::filesystem::exists(fontAsset.path)) + { + error = "Shader font asset not found for package " + shaderPackage.id + ": " + fontAsset.path.string(); + return false; + } + + fontAsset.writeTime = std::filesystem::last_write_time(fontAsset.path); + shaderPackage.fontAssets.push_back(fontAsset); + } + + return true; +} + +bool ParseTemporalSettings(const JsonValue& manifestJson, ShaderPackage& shaderPackage, unsigned maxTemporalHistoryFrames, const std::filesystem::path& manifestPath, std::string& error) +{ + const JsonValue* temporalValue = nullptr; + if (!OptionalObjectField(manifestJson, "temporal", temporalValue, manifestPath, error)) + return false; + if (!temporalValue) + return true; + + const JsonValue* enabledValue = temporalValue->find("enabled"); + if (!enabledValue || !enabledValue->asBoolean(false)) + return true; + + std::string historySourceName; + if (!RequireNonEmptyStringField(*temporalValue, "historySource", historySourceName, manifestPath, error)) + { + error = "Temporal shader is missing required 'historySource' in: " + ManifestPathMessage(manifestPath); + return false; + } + + const JsonValue* historyLengthValue = temporalValue->find("historyLength"); + if (!historyLengthValue || !historyLengthValue->isNumber()) + { + error = "Temporal shader is missing required numeric 'historyLength' in: " + ManifestPathMessage(manifestPath); + return false; + } + + TemporalHistorySource historySource = TemporalHistorySource::None; + if (!ParseTemporalHistorySource(historySourceName, historySource)) + { + error = "Unsupported temporal historySource '" + historySourceName + "' in: " + ManifestPathMessage(manifestPath); + return false; + } + + const double requestedHistoryLength = historyLengthValue->asNumber(); + if (!IsFiniteNumber(requestedHistoryLength) || requestedHistoryLength <= 0.0 || std::floor(requestedHistoryLength) != requestedHistoryLength) + { + error = "Temporal shader 'historyLength' must be a positive integer in: " + ManifestPathMessage(manifestPath); + return false; + } + + shaderPackage.temporal.enabled = true; + shaderPackage.temporal.historySource = historySource; + shaderPackage.temporal.requestedHistoryLength = static_cast(requestedHistoryLength); + shaderPackage.temporal.effectiveHistoryLength = std::min(shaderPackage.temporal.requestedHistoryLength, maxTemporalHistoryFrames); + return true; +} + +bool ParseFeedbackSettings(const JsonValue& manifestJson, ShaderPackage& shaderPackage, const std::filesystem::path& manifestPath, std::string& error) +{ + const JsonValue* feedbackValue = nullptr; + if (!OptionalObjectField(manifestJson, "feedback", feedbackValue, manifestPath, error)) + return false; + if (!feedbackValue) + return true; + + const JsonValue* enabledValue = feedbackValue->find("enabled"); + if (!enabledValue || !enabledValue->asBoolean(false)) + return true; + + shaderPackage.feedback.enabled = true; + if (!OptionalStringField(*feedbackValue, "writePass", shaderPackage.feedback.writePassId, "", manifestPath, error)) + return false; + + if (shaderPackage.feedback.writePassId.empty()) + { + if (shaderPackage.passes.empty()) + { + error = "Feedback-enabled shader has no passes to target in: " + ManifestPathMessage(manifestPath); + return false; + } + shaderPackage.feedback.writePassId = shaderPackage.passes.back().id; + } + + if (!ValidateShaderIdentifier(shaderPackage.feedback.writePassId, "feedback.writePass", manifestPath, error)) + return false; + + const auto passIt = std::find_if(shaderPackage.passes.begin(), shaderPackage.passes.end(), + [&shaderPackage](const ShaderPassDefinition& pass) { return pass.id == shaderPackage.feedback.writePassId; }); + if (passIt == shaderPackage.passes.end()) + { + error = "Feedback writePass '" + shaderPackage.feedback.writePassId + "' does not match any declared pass in: " + ManifestPathMessage(manifestPath); + return false; + } + + return true; +} + +bool ParseParameterNumberField(const JsonValue& parameterJson, const char* fieldName, std::vector& values, const std::filesystem::path& manifestPath, std::string& error) +{ + if (const JsonValue* fieldValue = parameterJson.find(fieldName)) + return NumberListFromJsonValue(*fieldValue, values, fieldName, manifestPath, error); + return true; +} + +bool ParseParameterDefault(const JsonValue& parameterJson, ShaderParameterDefinition& definition, const std::filesystem::path& manifestPath, std::string& error) +{ + const JsonValue* defaultValue = parameterJson.find("default"); + if (!defaultValue) + return true; + + if (definition.type == ShaderParameterType::Boolean) + { + if (!defaultValue->isBoolean()) + { + error = "Boolean parameter default must be a boolean for: " + definition.id; + return false; + } + definition.defaultBoolean = defaultValue->asBoolean(false); + return true; + } + + if (definition.type == ShaderParameterType::Enum) + { + if (!defaultValue->isString()) + { + error = "Enum parameter default must be a string for: " + definition.id; + return false; + } + definition.defaultEnumValue = defaultValue->asString(); + return true; + } + + if (definition.type == ShaderParameterType::Text) + { + if (!defaultValue->isString()) + { + error = "Text parameter default must be a string for: " + definition.id; + return false; + } + definition.defaultTextValue = defaultValue->asString(); + return true; + } + + return NumberListFromJsonValue(*defaultValue, definition.defaultNumbers, "default", manifestPath, error); +} + +bool ParseParameterOptions(const JsonValue& parameterJson, ShaderParameterDefinition& definition, const std::filesystem::path& manifestPath, std::string& error) +{ + const JsonValue* optionsValue = nullptr; + if (!OptionalArrayField(parameterJson, "options", optionsValue, manifestPath, error) || !optionsValue) + { + error = "Enum parameter is missing 'options' in: " + ManifestPathMessage(manifestPath); + return false; + } + + for (const JsonValue& optionJson : optionsValue->asArray()) + { + if (!optionJson.isObject()) + { + error = "Enum parameter option must be an object in: " + ManifestPathMessage(manifestPath); + return false; + } + + ShaderParameterOption option; + if (!RequireStringField(optionJson, "value", option.value, manifestPath, error) || + !RequireStringField(optionJson, "label", option.label, manifestPath, error)) + { + error = "Enum parameter option is missing 'value' or 'label' in: " + ManifestPathMessage(manifestPath); + return false; + } + definition.enumOptions.push_back(option); + } + + bool defaultFound = definition.defaultEnumValue.empty(); + for (const ShaderParameterOption& option : definition.enumOptions) + { + if (option.value == definition.defaultEnumValue) + { + defaultFound = true; + break; + } + } + + if (!defaultFound) + { + error = "Enum parameter default is not present in its option list for: " + definition.id; + return false; + } + + return true; +} + +bool ParseParameterDefinition(const JsonValue& parameterJson, ShaderParameterDefinition& definition, const std::filesystem::path& manifestPath, std::string& error) +{ + if (!parameterJson.isObject()) + { + error = "Shader parameter entry must be an object in: " + ManifestPathMessage(manifestPath); + return false; + } + + std::string typeName; + if (!RequireStringField(parameterJson, "id", definition.id, manifestPath, error) || + !RequireStringField(parameterJson, "label", definition.label, manifestPath, error) || + !RequireStringField(parameterJson, "type", typeName, manifestPath, error)) + { + error = "Shader parameter is missing required fields in: " + ManifestPathMessage(manifestPath); + return false; + } + + if (!ParseShaderParameterType(typeName, definition.type)) + { + error = "Unsupported parameter type '" + typeName + "' in: " + ManifestPathMessage(manifestPath); + return false; + } + if (!ValidateShaderIdentifier(definition.id, "parameters[].id", manifestPath, error)) + return false; + + if (!OptionalStringField(parameterJson, "description", definition.description, "", manifestPath, error)) + return false; + + if (!ParseParameterDefault(parameterJson, definition, manifestPath, error) || + !ParseParameterNumberField(parameterJson, "min", definition.minNumbers, manifestPath, error) || + !ParseParameterNumberField(parameterJson, "max", definition.maxNumbers, manifestPath, error) || + !ParseParameterNumberField(parameterJson, "step", definition.stepNumbers, manifestPath, error)) + { + return false; + } + + if (definition.type == ShaderParameterType::Text) + { + if (const JsonValue* fontValue = parameterJson.find("font")) + { + if (!fontValue->isString()) + { + error = "Text parameter 'font' must be a string for: " + definition.id; + return false; + } + definition.fontId = fontValue->asString(); + if (!definition.fontId.empty() && !ValidateShaderIdentifier(definition.fontId, "parameters[].font", manifestPath, error)) + return false; + } + if (const JsonValue* maxLengthValue = parameterJson.find("maxLength")) + { + if (!maxLengthValue->isNumber() || maxLengthValue->asNumber() < 1.0 || maxLengthValue->asNumber() > 256.0) + { + error = "Text parameter 'maxLength' must be a number from 1 to 256 for: " + definition.id; + return false; + } + definition.maxLength = static_cast(maxLengthValue->asNumber()); + } + } + + if (definition.type == ShaderParameterType::Enum) + return ParseParameterOptions(parameterJson, definition, manifestPath, error); + + return true; +} + +bool ParseParameterDefinitions(const JsonValue& manifestJson, ShaderPackage& shaderPackage, const std::filesystem::path& manifestPath, std::string& error) +{ + const JsonValue* parametersValue = nullptr; + if (!OptionalArrayField(manifestJson, "parameters", parametersValue, manifestPath, error)) + return false; + if (!parametersValue) + return true; + + for (const JsonValue& parameterJson : parametersValue->asArray()) + { + ShaderParameterDefinition definition; + if (!ParseParameterDefinition(parameterJson, definition, manifestPath, error)) + return false; + shaderPackage.parameters.push_back(definition); + } + + return true; +} + +std::string UniqueUnavailableShaderId(const std::filesystem::path& manifestPath, const std::string& parsedId) +{ + const std::string fallbackId = manifestPath.parent_path().filename().string(); + const std::string baseId = parsedId.empty() ? fallbackId : parsedId; + return baseId + "@invalid:" + fallbackId; +} + +ShaderPackageStatus BuildUnavailableStatus(const std::filesystem::path& manifestPath, const ShaderPackage& partialPackage, const std::string& packageError) +{ + ShaderPackageStatus status; + status.id = UniqueUnavailableShaderId(manifestPath, partialPackage.id); + status.displayName = !partialPackage.displayName.empty() ? partialPackage.displayName : manifestPath.parent_path().filename().string(); + status.description = partialPackage.description; + status.category = !partialPackage.category.empty() ? partialPackage.category : "Unavailable"; + status.available = false; + status.error = packageError; + return status; +} + +ShaderPackageStatus BuildAvailableStatus(const ShaderPackage& shaderPackage) +{ + ShaderPackageStatus status; + status.id = shaderPackage.id; + status.displayName = shaderPackage.displayName; + status.description = shaderPackage.description; + status.category = shaderPackage.category; + status.available = true; + return status; +} +} + +ShaderPackageRegistry::ShaderPackageRegistry(unsigned maxTemporalHistoryFrames) + : mMaxTemporalHistoryFrames(maxTemporalHistoryFrames) +{ +} + +bool ShaderPackageRegistry::Scan( + const std::filesystem::path& shaderRoot, + std::map& packagesById, + std::vector& packageOrder, + std::vector& packageStatuses, + std::string& error) const +{ + packagesById.clear(); + packageOrder.clear(); + packageStatuses.clear(); + + if (!std::filesystem::exists(shaderRoot)) + { + error = "Shader library directory does not exist: " + shaderRoot.string(); + return false; + } + + for (const auto& entry : std::filesystem::directory_iterator(shaderRoot)) + { + if (!entry.is_directory()) + continue; + + std::filesystem::path manifestPath = entry.path() / "shader.json"; + if (!std::filesystem::exists(manifestPath)) + continue; + + ShaderPackage shaderPackage; + if (!ParseManifest(manifestPath, shaderPackage, error)) + { + packageStatuses.push_back(BuildUnavailableStatus(manifestPath, shaderPackage, error)); + error.clear(); + continue; + } + + if (packagesById.find(shaderPackage.id) != packagesById.end()) + { + packageStatuses.push_back(BuildUnavailableStatus(manifestPath, shaderPackage, "Duplicate shader id found: " + shaderPackage.id)); + continue; + } + + packageOrder.push_back(shaderPackage.id); + packageStatuses.push_back(BuildAvailableStatus(shaderPackage)); + packagesById[shaderPackage.id] = shaderPackage; + } + + std::sort(packageOrder.begin(), packageOrder.end()); + std::sort(packageStatuses.begin(), packageStatuses.end(), [](const ShaderPackageStatus& left, const ShaderPackageStatus& right) { + return left.displayName < right.displayName; + }); + return true; +} + +bool ShaderPackageRegistry::ParseManifest(const std::filesystem::path& manifestPath, ShaderPackage& shaderPackage, std::string& error) const +{ + const std::string manifestText = ReadTextFile(manifestPath, error); + if (manifestText.empty()) + return false; + + JsonValue manifestJson; + if (!ParseJson(manifestText, manifestJson, error)) + return false; + if (!manifestJson.isObject()) + { + error = "Shader manifest root must be an object: " + manifestPath.string(); + return false; + } + + if (!ParseShaderMetadata(manifestJson, shaderPackage, manifestPath, error)) + return false; + + if (!ParsePassDefinitions(manifestJson, shaderPackage, manifestPath, error)) + return false; + + shaderPackage.shaderWriteTime = shaderPackage.passes.front().sourceWriteTime; + for (const ShaderPassDefinition& pass : shaderPackage.passes) + { + if (pass.sourceWriteTime > shaderPackage.shaderWriteTime) + shaderPackage.shaderWriteTime = pass.sourceWriteTime; + } + shaderPackage.manifestWriteTime = std::filesystem::last_write_time(shaderPackage.manifestPath); + + return ParseTextureAssets(manifestJson, shaderPackage, manifestPath, error) && + ParseFontAssets(manifestJson, shaderPackage, manifestPath, error) && + ParseTemporalSettings(manifestJson, shaderPackage, mMaxTemporalHistoryFrames, manifestPath, error) && + ParseFeedbackSettings(manifestJson, shaderPackage, manifestPath, error) && + ParseParameterDefinitions(manifestJson, shaderPackage, manifestPath, error); +} diff --git a/src/shader/ShaderPackageRegistry.h b/src/shader/ShaderPackageRegistry.h new file mode 100644 index 0000000..fc6b864 --- /dev/null +++ b/src/shader/ShaderPackageRegistry.h @@ -0,0 +1,25 @@ +#pragma once + +#include "ShaderTypes.h" + +#include +#include +#include +#include + +class ShaderPackageRegistry +{ +public: + explicit ShaderPackageRegistry(unsigned maxTemporalHistoryFrames); + + bool Scan( + const std::filesystem::path& shaderRoot, + std::map& packagesById, + std::vector& packageOrder, + std::vector& packageStatuses, + std::string& error) const; + bool ParseManifest(const std::filesystem::path& manifestPath, ShaderPackage& shaderPackage, std::string& error) const; + +private: + unsigned mMaxTemporalHistoryFrames; +}; diff --git a/src/shader/ShaderTypes.h b/src/shader/ShaderTypes.h new file mode 100644 index 0000000..f392e3f --- /dev/null +++ b/src/shader/ShaderTypes.h @@ -0,0 +1,159 @@ +#pragma once + +#include +#include +#include +#include + +enum class ShaderParameterType +{ + Float, + Vec2, + Color, + Boolean, + Enum, + Text, + Trigger +}; + +struct ShaderParameterOption +{ + std::string value; + std::string label; +}; + +struct ShaderParameterDefinition +{ + std::string id; + std::string label; + std::string description; + ShaderParameterType type = ShaderParameterType::Float; + std::vector defaultNumbers; + std::vector minNumbers; + std::vector maxNumbers; + std::vector stepNumbers; + bool defaultBoolean = false; + std::string defaultEnumValue; + std::string defaultTextValue; + std::string fontId; + unsigned maxLength = 64; + std::vector enumOptions; +}; + +struct ShaderParameterValue +{ + std::vector numberValues; + bool booleanValue = false; + std::string enumValue; + std::string textValue; +}; + +enum class TemporalHistorySource +{ + None, + Source, + PreLayerInput +}; + +struct TemporalSettings +{ + bool enabled = false; + TemporalHistorySource historySource = TemporalHistorySource::None; + unsigned requestedHistoryLength = 0; + unsigned effectiveHistoryLength = 0; +}; + +struct FeedbackSettings +{ + bool enabled = false; + std::string writePassId; +}; + +struct ShaderTextureAsset +{ + std::string id; + std::filesystem::path path; + std::filesystem::file_time_type writeTime; +}; + +struct ShaderFontAsset +{ + std::string id; + std::filesystem::path path; + std::filesystem::file_time_type writeTime; +}; + +struct ShaderPassDefinition +{ + std::string id; + std::string entryPoint; + std::filesystem::path sourcePath; + std::filesystem::file_time_type sourceWriteTime; + std::vector inputNames; + std::string outputName; +}; + +struct ShaderPassBuildSource +{ + std::string passId; + std::string fragmentShaderSource; + std::vector inputNames; + std::string outputName; +}; + +struct ShaderPackage +{ + std::string id; + std::string displayName; + std::string description; + std::string category; + std::string entryPoint; + std::filesystem::path directoryPath; + std::filesystem::path shaderPath; + std::filesystem::path manifestPath; + std::vector passes; + std::vector parameters; + std::vector textureAssets; + std::vector fontAssets; + TemporalSettings temporal; + FeedbackSettings feedback; + std::filesystem::file_time_type shaderWriteTime; + std::filesystem::file_time_type manifestWriteTime; +}; + +struct ShaderPackageStatus +{ + std::string id; + std::string displayName; + std::string description; + std::string category; + bool available = false; + std::string error; +}; + +struct RuntimeRenderState +{ + std::string layerId; + std::string shaderId; + std::string shaderName; + std::vector parameterDefinitions; + std::map parameterValues; + std::vector textureAssets; + std::vector fontAssets; + double timeSeconds = 0.0; + double utcTimeSeconds = 0.0; + double utcOffsetSeconds = 0.0; + double startupRandom = 0.0; + double frameCount = 0.0; + double mixAmount = 1.0; + double bypass = 0.0; + unsigned inputWidth = 0; + unsigned inputHeight = 0; + unsigned outputWidth = 0; + unsigned outputHeight = 0; + bool isTemporal = false; + TemporalHistorySource temporalHistorySource = TemporalHistorySource::None; + unsigned requestedTemporalHistoryLength = 0; + unsigned effectiveTemporalHistoryLength = 0; + FeedbackSettings feedback; +}; diff --git a/src/stdafx.h b/src/stdafx.h new file mode 100644 index 0000000..ff97020 --- /dev/null +++ b/src/stdafx.h @@ -0,0 +1,13 @@ +#pragma once + +#ifndef NOMINMAX +#define NOMINMAX +#endif + +#ifndef WIN32_LEAN_AND_MEAN +#define WIN32_LEAN_AND_MEAN +#endif + +#include +#include +#include diff --git a/src/video/DeckLinkAPI_h.h b/src/video/DeckLinkAPI_h.h new file mode 100644 index 0000000..a1054c2 --- /dev/null +++ b/src/video/DeckLinkAPI_h.h @@ -0,0 +1,20433 @@ + + +/* this ALWAYS GENERATED file contains the definitions for the interfaces */ + + + /* File created by MIDL compiler version 8.01.0628 */ +/* at Tue Jan 19 14:14:07 2038 + */ +/* Compiler settings for ..\..\3rdParty\Blackmagic DeckLink SDK 16.0\Win\include\DeckLinkAPI.idl: + Oicf, W1, Zp8, env=Win64 (32b run), target_arch=AMD64 8.01.0628 + protocol : all , 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( ) */ + + + +/* verify that the version is high enough to compile this file*/ +#ifndef __REQUIRED_RPCNDR_H_VERSION__ +#define __REQUIRED_RPCNDR_H_VERSION__ 500 +#endif + +#include "rpc.h" +#include "rpcndr.h" + +#ifndef __RPCNDR_H_VERSION__ +#error this stub requires an updated version of +#endif /* __RPCNDR_H_VERSION__ */ + + +#ifndef __DeckLinkAPI_h_h__ +#define __DeckLinkAPI_h_h__ + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#pragma once +#endif + +#ifndef DECLSPEC_XFGVIRT +#if defined(_CONTROL_FLOW_GUARD_XFG) +#define DECLSPEC_XFGVIRT(base, func) __declspec(xfg_virtual(base, func)) +#else +#define DECLSPEC_XFGVIRT(base, func) +#endif +#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 __IDeckLinkEncoderConfiguration_FWD_DEFINED__ +#define __IDeckLinkEncoderConfiguration_FWD_DEFINED__ +typedef interface IDeckLinkEncoderConfiguration IDeckLinkEncoderConfiguration; + +#endif /* __IDeckLinkEncoderConfiguration_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 __IDeckLinkEncoderInputCallback_FWD_DEFINED__ +#define __IDeckLinkEncoderInputCallback_FWD_DEFINED__ +typedef interface IDeckLinkEncoderInputCallback IDeckLinkEncoderInputCallback; + +#endif /* __IDeckLinkEncoderInputCallback_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkVideoBufferAllocator_FWD_DEFINED__ +#define __IDeckLinkVideoBufferAllocator_FWD_DEFINED__ +typedef interface IDeckLinkVideoBufferAllocator IDeckLinkVideoBufferAllocator; + +#endif /* __IDeckLinkVideoBufferAllocator_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkVideoBufferAllocatorProvider_FWD_DEFINED__ +#define __IDeckLinkVideoBufferAllocatorProvider_FWD_DEFINED__ +typedef interface IDeckLinkVideoBufferAllocatorProvider IDeckLinkVideoBufferAllocatorProvider; + +#endif /* __IDeckLinkVideoBufferAllocatorProvider_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 __IDeckLinkIPFlowAttributes_FWD_DEFINED__ +#define __IDeckLinkIPFlowAttributes_FWD_DEFINED__ +typedef interface IDeckLinkIPFlowAttributes IDeckLinkIPFlowAttributes; + +#endif /* __IDeckLinkIPFlowAttributes_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkIPFlowStatus_FWD_DEFINED__ +#define __IDeckLinkIPFlowStatus_FWD_DEFINED__ +typedef interface IDeckLinkIPFlowStatus IDeckLinkIPFlowStatus; + +#endif /* __IDeckLinkIPFlowStatus_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkIPFlowSetting_FWD_DEFINED__ +#define __IDeckLinkIPFlowSetting_FWD_DEFINED__ +typedef interface IDeckLinkIPFlowSetting IDeckLinkIPFlowSetting; + +#endif /* __IDeckLinkIPFlowSetting_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkIPFlow_FWD_DEFINED__ +#define __IDeckLinkIPFlow_FWD_DEFINED__ +typedef interface IDeckLinkIPFlow IDeckLinkIPFlow; + +#endif /* __IDeckLinkIPFlow_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkIPFlowIterator_FWD_DEFINED__ +#define __IDeckLinkIPFlowIterator_FWD_DEFINED__ +typedef interface IDeckLinkIPFlowIterator IDeckLinkIPFlowIterator; + +#endif /* __IDeckLinkIPFlowIterator_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 __IDeckLinkIPExtensions_FWD_DEFINED__ +#define __IDeckLinkIPExtensions_FWD_DEFINED__ +typedef interface IDeckLinkIPExtensions IDeckLinkIPExtensions; + +#endif /* __IDeckLinkIPExtensions_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkHDMIInputEDID_FWD_DEFINED__ +#define __IDeckLinkHDMIInputEDID_FWD_DEFINED__ +typedef interface IDeckLinkHDMIInputEDID IDeckLinkHDMIInputEDID; + +#endif /* __IDeckLinkHDMIInputEDID_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkEncoderInput_FWD_DEFINED__ +#define __IDeckLinkEncoderInput_FWD_DEFINED__ +typedef interface IDeckLinkEncoderInput IDeckLinkEncoderInput; + +#endif /* __IDeckLinkEncoderInput_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkVideoBuffer_FWD_DEFINED__ +#define __IDeckLinkVideoBuffer_FWD_DEFINED__ +typedef interface IDeckLinkVideoBuffer IDeckLinkVideoBuffer; + +#endif /* __IDeckLinkVideoBuffer_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 __IDeckLinkVideoFrameMetadataExtensions_FWD_DEFINED__ +#define __IDeckLinkVideoFrameMetadataExtensions_FWD_DEFINED__ +typedef interface IDeckLinkVideoFrameMetadataExtensions IDeckLinkVideoFrameMetadataExtensions; + +#endif /* __IDeckLinkVideoFrameMetadataExtensions_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkVideoFrameMutableMetadataExtensions_FWD_DEFINED__ +#define __IDeckLinkVideoFrameMutableMetadataExtensions_FWD_DEFINED__ +typedef interface IDeckLinkVideoFrameMutableMetadataExtensions IDeckLinkVideoFrameMutableMetadataExtensions; + +#endif /* __IDeckLinkVideoFrameMutableMetadataExtensions_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkVideoInputFrame_FWD_DEFINED__ +#define __IDeckLinkVideoInputFrame_FWD_DEFINED__ +typedef interface IDeckLinkVideoInputFrame IDeckLinkVideoInputFrame; + +#endif /* __IDeckLinkVideoInputFrame_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkAncillaryPacket_FWD_DEFINED__ +#define __IDeckLinkAncillaryPacket_FWD_DEFINED__ +typedef interface IDeckLinkAncillaryPacket IDeckLinkAncillaryPacket; + +#endif /* __IDeckLinkAncillaryPacket_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkAncillaryPacketIterator_FWD_DEFINED__ +#define __IDeckLinkAncillaryPacketIterator_FWD_DEFINED__ +typedef interface IDeckLinkAncillaryPacketIterator IDeckLinkAncillaryPacketIterator; + +#endif /* __IDeckLinkAncillaryPacketIterator_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkVideoFrameAncillaryPackets_FWD_DEFINED__ +#define __IDeckLinkVideoFrameAncillaryPackets_FWD_DEFINED__ +typedef interface IDeckLinkVideoFrameAncillaryPackets IDeckLinkVideoFrameAncillaryPackets; + +#endif /* __IDeckLinkVideoFrameAncillaryPackets_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkVideoFrameAncillary_FWD_DEFINED__ +#define __IDeckLinkVideoFrameAncillary_FWD_DEFINED__ +typedef interface IDeckLinkVideoFrameAncillary IDeckLinkVideoFrameAncillary; + +#endif /* __IDeckLinkVideoFrameAncillary_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkEncoderPacket_FWD_DEFINED__ +#define __IDeckLinkEncoderPacket_FWD_DEFINED__ +typedef interface IDeckLinkEncoderPacket IDeckLinkEncoderPacket; + +#endif /* __IDeckLinkEncoderPacket_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkEncoderVideoPacket_FWD_DEFINED__ +#define __IDeckLinkEncoderVideoPacket_FWD_DEFINED__ +typedef interface IDeckLinkEncoderVideoPacket IDeckLinkEncoderVideoPacket; + +#endif /* __IDeckLinkEncoderVideoPacket_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkEncoderAudioPacket_FWD_DEFINED__ +#define __IDeckLinkEncoderAudioPacket_FWD_DEFINED__ +typedef interface IDeckLinkEncoderAudioPacket IDeckLinkEncoderAudioPacket; + +#endif /* __IDeckLinkEncoderAudioPacket_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkH265NALPacket_FWD_DEFINED__ +#define __IDeckLinkH265NALPacket_FWD_DEFINED__ +typedef interface IDeckLinkH265NALPacket IDeckLinkH265NALPacket; + +#endif /* __IDeckLinkH265NALPacket_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 __IDeckLinkWPFDX9ScreenPreviewHelper_FWD_DEFINED__ +#define __IDeckLinkWPFDX9ScreenPreviewHelper_FWD_DEFINED__ +typedef interface IDeckLinkWPFDX9ScreenPreviewHelper IDeckLinkWPFDX9ScreenPreviewHelper; + +#endif /* __IDeckLinkWPFDX9ScreenPreviewHelper_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 __IDeckLinkProfileAttributes_FWD_DEFINED__ +#define __IDeckLinkProfileAttributes_FWD_DEFINED__ +typedef interface IDeckLinkProfileAttributes IDeckLinkProfileAttributes; + +#endif /* __IDeckLinkProfileAttributes_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkProfileIterator_FWD_DEFINED__ +#define __IDeckLinkProfileIterator_FWD_DEFINED__ +typedef interface IDeckLinkProfileIterator IDeckLinkProfileIterator; + +#endif /* __IDeckLinkProfileIterator_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkProfile_FWD_DEFINED__ +#define __IDeckLinkProfile_FWD_DEFINED__ +typedef interface IDeckLinkProfile IDeckLinkProfile; + +#endif /* __IDeckLinkProfile_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkProfileCallback_FWD_DEFINED__ +#define __IDeckLinkProfileCallback_FWD_DEFINED__ +typedef interface IDeckLinkProfileCallback IDeckLinkProfileCallback; + +#endif /* __IDeckLinkProfileCallback_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkProfileManager_FWD_DEFINED__ +#define __IDeckLinkProfileManager_FWD_DEFINED__ +typedef interface IDeckLinkProfileManager IDeckLinkProfileManager; + +#endif /* __IDeckLinkProfileManager_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkStatistics_FWD_DEFINED__ +#define __IDeckLinkStatistics_FWD_DEFINED__ +typedef interface IDeckLinkStatistics IDeckLinkStatistics; + +#endif /* __IDeckLinkStatistics_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkStatus_FWD_DEFINED__ +#define __IDeckLinkStatus_FWD_DEFINED__ +typedef interface IDeckLinkStatus IDeckLinkStatus; + +#endif /* __IDeckLinkStatus_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 __CDeckLinkGL3ScreenPreviewHelper_FWD_DEFINED__ +#define __CDeckLinkGL3ScreenPreviewHelper_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class CDeckLinkGL3ScreenPreviewHelper CDeckLinkGL3ScreenPreviewHelper; +#else +typedef struct CDeckLinkGL3ScreenPreviewHelper CDeckLinkGL3ScreenPreviewHelper; +#endif /* __cplusplus */ + +#endif /* __CDeckLinkGL3ScreenPreviewHelper_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 __CDeckLinkWPFDX9ScreenPreviewHelper_FWD_DEFINED__ +#define __CDeckLinkWPFDX9ScreenPreviewHelper_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class CDeckLinkWPFDX9ScreenPreviewHelper CDeckLinkWPFDX9ScreenPreviewHelper; +#else +typedef struct CDeckLinkWPFDX9ScreenPreviewHelper CDeckLinkWPFDX9ScreenPreviewHelper; +#endif /* __cplusplus */ + +#endif /* __CDeckLinkWPFDX9ScreenPreviewHelper_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 __CDeckLinkVideoFrameAncillaryPackets_FWD_DEFINED__ +#define __CDeckLinkVideoFrameAncillaryPackets_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class CDeckLinkVideoFrameAncillaryPackets CDeckLinkVideoFrameAncillaryPackets; +#else +typedef struct CDeckLinkVideoFrameAncillaryPackets CDeckLinkVideoFrameAncillaryPackets; +#endif /* __cplusplus */ + +#endif /* __CDeckLinkVideoFrameAncillaryPackets_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkStatus_v15_3_1_FWD_DEFINED__ +#define __IDeckLinkStatus_v15_3_1_FWD_DEFINED__ +typedef interface IDeckLinkStatus_v15_3_1 IDeckLinkStatus_v15_3_1; + +#endif /* __IDeckLinkStatus_v15_3_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkConfiguration_v15_3_1_FWD_DEFINED__ +#define __IDeckLinkConfiguration_v15_3_1_FWD_DEFINED__ +typedef interface IDeckLinkConfiguration_v15_3_1 IDeckLinkConfiguration_v15_3_1; + +#endif /* __IDeckLinkConfiguration_v15_3_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkVideoBuffer_v15_3_1_FWD_DEFINED__ +#define __IDeckLinkVideoBuffer_v15_3_1_FWD_DEFINED__ +typedef interface IDeckLinkVideoBuffer_v15_3_1 IDeckLinkVideoBuffer_v15_3_1; + +#endif /* __IDeckLinkVideoBuffer_v15_3_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkVideoBufferAllocator_v15_3_1_FWD_DEFINED__ +#define __IDeckLinkVideoBufferAllocator_v15_3_1_FWD_DEFINED__ +typedef interface IDeckLinkVideoBufferAllocator_v15_3_1 IDeckLinkVideoBufferAllocator_v15_3_1; + +#endif /* __IDeckLinkVideoBufferAllocator_v15_3_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkVideoBufferAllocatorProvider_v15_3_1_FWD_DEFINED__ +#define __IDeckLinkVideoBufferAllocatorProvider_v15_3_1_FWD_DEFINED__ +typedef interface IDeckLinkVideoBufferAllocatorProvider_v15_3_1 IDeckLinkVideoBufferAllocatorProvider_v15_3_1; + +#endif /* __IDeckLinkVideoBufferAllocatorProvider_v15_3_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkInput_v15_3_1_FWD_DEFINED__ +#define __IDeckLinkInput_v15_3_1_FWD_DEFINED__ +typedef interface IDeckLinkInput_v15_3_1 IDeckLinkInput_v15_3_1; + +#endif /* __IDeckLinkInput_v15_3_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkOutput_v15_3_1_FWD_DEFINED__ +#define __IDeckLinkOutput_v15_3_1_FWD_DEFINED__ +typedef interface IDeckLinkOutput_v15_3_1 IDeckLinkOutput_v15_3_1; + +#endif /* __IDeckLinkOutput_v15_3_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkVideoConversion_v15_3_1_FWD_DEFINED__ +#define __IDeckLinkVideoConversion_v15_3_1_FWD_DEFINED__ +typedef interface IDeckLinkVideoConversion_v15_3_1 IDeckLinkVideoConversion_v15_3_1; + +#endif /* __IDeckLinkVideoConversion_v15_3_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkNotification_v15_3_1_FWD_DEFINED__ +#define __IDeckLinkNotification_v15_3_1_FWD_DEFINED__ +typedef interface IDeckLinkNotification_v15_3_1 IDeckLinkNotification_v15_3_1; + +#endif /* __IDeckLinkNotification_v15_3_1_FWD_DEFINED__ */ + + +#ifndef __CDeckLinkVideoConversion_v15_3_1_FWD_DEFINED__ +#define __CDeckLinkVideoConversion_v15_3_1_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class CDeckLinkVideoConversion_v15_3_1 CDeckLinkVideoConversion_v15_3_1; +#else +typedef struct CDeckLinkVideoConversion_v15_3_1 CDeckLinkVideoConversion_v15_3_1; +#endif /* __cplusplus */ + +#endif /* __CDeckLinkVideoConversion_v15_3_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkProfileAttributes_v15_3_1_FWD_DEFINED__ +#define __IDeckLinkProfileAttributes_v15_3_1_FWD_DEFINED__ +typedef interface IDeckLinkProfileAttributes_v15_3_1 IDeckLinkProfileAttributes_v15_3_1; + +#endif /* __IDeckLinkProfileAttributes_v15_3_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkVideoOutputCallback_v14_2_1_FWD_DEFINED__ +#define __IDeckLinkVideoOutputCallback_v14_2_1_FWD_DEFINED__ +typedef interface IDeckLinkVideoOutputCallback_v14_2_1 IDeckLinkVideoOutputCallback_v14_2_1; + +#endif /* __IDeckLinkVideoOutputCallback_v14_2_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkInputCallback_v14_2_1_FWD_DEFINED__ +#define __IDeckLinkInputCallback_v14_2_1_FWD_DEFINED__ +typedef interface IDeckLinkInputCallback_v14_2_1 IDeckLinkInputCallback_v14_2_1; + +#endif /* __IDeckLinkInputCallback_v14_2_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkMemoryAllocator_v14_2_1_FWD_DEFINED__ +#define __IDeckLinkMemoryAllocator_v14_2_1_FWD_DEFINED__ +typedef interface IDeckLinkMemoryAllocator_v14_2_1 IDeckLinkMemoryAllocator_v14_2_1; + +#endif /* __IDeckLinkMemoryAllocator_v14_2_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkOutput_v14_2_1_FWD_DEFINED__ +#define __IDeckLinkOutput_v14_2_1_FWD_DEFINED__ +typedef interface IDeckLinkOutput_v14_2_1 IDeckLinkOutput_v14_2_1; + +#endif /* __IDeckLinkOutput_v14_2_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkInput_v14_2_1_FWD_DEFINED__ +#define __IDeckLinkInput_v14_2_1_FWD_DEFINED__ +typedef interface IDeckLinkInput_v14_2_1 IDeckLinkInput_v14_2_1; + +#endif /* __IDeckLinkInput_v14_2_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkEncoderInput_v14_2_1_FWD_DEFINED__ +#define __IDeckLinkEncoderInput_v14_2_1_FWD_DEFINED__ +typedef interface IDeckLinkEncoderInput_v14_2_1 IDeckLinkEncoderInput_v14_2_1; + +#endif /* __IDeckLinkEncoderInput_v14_2_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkVideoFrame_v14_2_1_FWD_DEFINED__ +#define __IDeckLinkVideoFrame_v14_2_1_FWD_DEFINED__ +typedef interface IDeckLinkVideoFrame_v14_2_1 IDeckLinkVideoFrame_v14_2_1; + +#endif /* __IDeckLinkVideoFrame_v14_2_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkMutableVideoFrame_v14_2_1_FWD_DEFINED__ +#define __IDeckLinkMutableVideoFrame_v14_2_1_FWD_DEFINED__ +typedef interface IDeckLinkMutableVideoFrame_v14_2_1 IDeckLinkMutableVideoFrame_v14_2_1; + +#endif /* __IDeckLinkMutableVideoFrame_v14_2_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkVideoFrame3DExtensions_v14_2_1_FWD_DEFINED__ +#define __IDeckLinkVideoFrame3DExtensions_v14_2_1_FWD_DEFINED__ +typedef interface IDeckLinkVideoFrame3DExtensions_v14_2_1 IDeckLinkVideoFrame3DExtensions_v14_2_1; + +#endif /* __IDeckLinkVideoFrame3DExtensions_v14_2_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkVideoInputFrame_v14_2_1_FWD_DEFINED__ +#define __IDeckLinkVideoInputFrame_v14_2_1_FWD_DEFINED__ +typedef interface IDeckLinkVideoInputFrame_v14_2_1 IDeckLinkVideoInputFrame_v14_2_1; + +#endif /* __IDeckLinkVideoInputFrame_v14_2_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkScreenPreviewCallback_v14_2_1_FWD_DEFINED__ +#define __IDeckLinkScreenPreviewCallback_v14_2_1_FWD_DEFINED__ +typedef interface IDeckLinkScreenPreviewCallback_v14_2_1 IDeckLinkScreenPreviewCallback_v14_2_1; + +#endif /* __IDeckLinkScreenPreviewCallback_v14_2_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkGLScreenPreviewHelper_v14_2_1_FWD_DEFINED__ +#define __IDeckLinkGLScreenPreviewHelper_v14_2_1_FWD_DEFINED__ +typedef interface IDeckLinkGLScreenPreviewHelper_v14_2_1 IDeckLinkGLScreenPreviewHelper_v14_2_1; + +#endif /* __IDeckLinkGLScreenPreviewHelper_v14_2_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkDX9ScreenPreviewHelper_v14_2_1_FWD_DEFINED__ +#define __IDeckLinkDX9ScreenPreviewHelper_v14_2_1_FWD_DEFINED__ +typedef interface IDeckLinkDX9ScreenPreviewHelper_v14_2_1 IDeckLinkDX9ScreenPreviewHelper_v14_2_1; + +#endif /* __IDeckLinkDX9ScreenPreviewHelper_v14_2_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1_FWD_DEFINED__ +#define __IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1_FWD_DEFINED__ +typedef interface IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1 IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1; + +#endif /* __IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkVideoConversion_v14_2_1_FWD_DEFINED__ +#define __IDeckLinkVideoConversion_v14_2_1_FWD_DEFINED__ +typedef interface IDeckLinkVideoConversion_v14_2_1 IDeckLinkVideoConversion_v14_2_1; + +#endif /* __IDeckLinkVideoConversion_v14_2_1_FWD_DEFINED__ */ + + +#ifndef __CDeckLinkGLScreenPreviewHelper_v14_2_1_FWD_DEFINED__ +#define __CDeckLinkGLScreenPreviewHelper_v14_2_1_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class CDeckLinkGLScreenPreviewHelper_v14_2_1 CDeckLinkGLScreenPreviewHelper_v14_2_1; +#else +typedef struct CDeckLinkGLScreenPreviewHelper_v14_2_1 CDeckLinkGLScreenPreviewHelper_v14_2_1; +#endif /* __cplusplus */ + +#endif /* __CDeckLinkGLScreenPreviewHelper_v14_2_1_FWD_DEFINED__ */ + + +#ifndef __CDeckLinkGL3ScreenPreviewHelper_v14_2_1_FWD_DEFINED__ +#define __CDeckLinkGL3ScreenPreviewHelper_v14_2_1_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class CDeckLinkGL3ScreenPreviewHelper_v14_2_1 CDeckLinkGL3ScreenPreviewHelper_v14_2_1; +#else +typedef struct CDeckLinkGL3ScreenPreviewHelper_v14_2_1 CDeckLinkGL3ScreenPreviewHelper_v14_2_1; +#endif /* __cplusplus */ + +#endif /* __CDeckLinkGL3ScreenPreviewHelper_v14_2_1_FWD_DEFINED__ */ + + +#ifndef __CDeckLinkDX9ScreenPreviewHelper_v14_2_1_FWD_DEFINED__ +#define __CDeckLinkDX9ScreenPreviewHelper_v14_2_1_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class CDeckLinkDX9ScreenPreviewHelper_v14_2_1 CDeckLinkDX9ScreenPreviewHelper_v14_2_1; +#else +typedef struct CDeckLinkDX9ScreenPreviewHelper_v14_2_1 CDeckLinkDX9ScreenPreviewHelper_v14_2_1; +#endif /* __cplusplus */ + +#endif /* __CDeckLinkDX9ScreenPreviewHelper_v14_2_1_FWD_DEFINED__ */ + + +#ifndef __CDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1_FWD_DEFINED__ +#define __CDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class CDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1 CDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1; +#else +typedef struct CDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1 CDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1; +#endif /* __cplusplus */ + +#endif /* __CDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1_FWD_DEFINED__ */ + + +#ifndef __CDeckLinkVideoConversion_v14_2_1_FWD_DEFINED__ +#define __CDeckLinkVideoConversion_v14_2_1_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class CDeckLinkVideoConversion_v14_2_1 CDeckLinkVideoConversion_v14_2_1; +#else +typedef struct CDeckLinkVideoConversion_v14_2_1 CDeckLinkVideoConversion_v14_2_1; +#endif /* __cplusplus */ + +#endif /* __CDeckLinkVideoConversion_v14_2_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkInputCallback_v11_5_1_FWD_DEFINED__ +#define __IDeckLinkInputCallback_v11_5_1_FWD_DEFINED__ +typedef interface IDeckLinkInputCallback_v11_5_1 IDeckLinkInputCallback_v11_5_1; + +#endif /* __IDeckLinkInputCallback_v11_5_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkInput_v11_5_1_FWD_DEFINED__ +#define __IDeckLinkInput_v11_5_1_FWD_DEFINED__ +typedef interface IDeckLinkInput_v11_5_1 IDeckLinkInput_v11_5_1; + +#endif /* __IDeckLinkInput_v11_5_1_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkConfiguration_v10_11_FWD_DEFINED__ +#define __IDeckLinkConfiguration_v10_11_FWD_DEFINED__ +typedef interface IDeckLinkConfiguration_v10_11 IDeckLinkConfiguration_v10_11; + +#endif /* __IDeckLinkConfiguration_v10_11_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkAttributes_v10_11_FWD_DEFINED__ +#define __IDeckLinkAttributes_v10_11_FWD_DEFINED__ +typedef interface IDeckLinkAttributes_v10_11 IDeckLinkAttributes_v10_11; + +#endif /* __IDeckLinkAttributes_v10_11_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkNotification_v10_11_FWD_DEFINED__ +#define __IDeckLinkNotification_v10_11_FWD_DEFINED__ +typedef interface IDeckLinkNotification_v10_11 IDeckLinkNotification_v10_11; + +#endif /* __IDeckLinkNotification_v10_11_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkOutput_v10_11_FWD_DEFINED__ +#define __IDeckLinkOutput_v10_11_FWD_DEFINED__ +typedef interface IDeckLinkOutput_v10_11 IDeckLinkOutput_v10_11; + +#endif /* __IDeckLinkOutput_v10_11_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkInput_v10_11_FWD_DEFINED__ +#define __IDeckLinkInput_v10_11_FWD_DEFINED__ +typedef interface IDeckLinkInput_v10_11 IDeckLinkInput_v10_11; + +#endif /* __IDeckLinkInput_v10_11_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkEncoderInput_v10_11_FWD_DEFINED__ +#define __IDeckLinkEncoderInput_v10_11_FWD_DEFINED__ +typedef interface IDeckLinkEncoderInput_v10_11 IDeckLinkEncoderInput_v10_11; + +#endif /* __IDeckLinkEncoderInput_v10_11_FWD_DEFINED__ */ + + +#ifndef __CDeckLinkIterator_v10_11_FWD_DEFINED__ +#define __CDeckLinkIterator_v10_11_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class CDeckLinkIterator_v10_11 CDeckLinkIterator_v10_11; +#else +typedef struct CDeckLinkIterator_v10_11 CDeckLinkIterator_v10_11; +#endif /* __cplusplus */ + +#endif /* __CDeckLinkIterator_v10_11_FWD_DEFINED__ */ + + +#ifndef __CDeckLinkDiscovery_v10_11_FWD_DEFINED__ +#define __CDeckLinkDiscovery_v10_11_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class CDeckLinkDiscovery_v10_11 CDeckLinkDiscovery_v10_11; +#else +typedef struct CDeckLinkDiscovery_v10_11 CDeckLinkDiscovery_v10_11; +#endif /* __cplusplus */ + +#endif /* __CDeckLinkDiscovery_v10_11_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkConfiguration_v10_9_FWD_DEFINED__ +#define __IDeckLinkConfiguration_v10_9_FWD_DEFINED__ +typedef interface IDeckLinkConfiguration_v10_9 IDeckLinkConfiguration_v10_9; + +#endif /* __IDeckLinkConfiguration_v10_9_FWD_DEFINED__ */ + + +#ifndef __CBMDStreamingDiscovery_v10_8_FWD_DEFINED__ +#define __CBMDStreamingDiscovery_v10_8_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class CBMDStreamingDiscovery_v10_8 CBMDStreamingDiscovery_v10_8; +#else +typedef struct CBMDStreamingDiscovery_v10_8 CBMDStreamingDiscovery_v10_8; +#endif /* __cplusplus */ + +#endif /* __CBMDStreamingDiscovery_v10_8_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkConfiguration_v10_4_FWD_DEFINED__ +#define __IDeckLinkConfiguration_v10_4_FWD_DEFINED__ +typedef interface IDeckLinkConfiguration_v10_4 IDeckLinkConfiguration_v10_4; + +#endif /* __IDeckLinkConfiguration_v10_4_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 __IDeckLinkAncillaryPacket_v15_2_FWD_DEFINED__ +#define __IDeckLinkAncillaryPacket_v15_2_FWD_DEFINED__ +typedef interface IDeckLinkAncillaryPacket_v15_2 IDeckLinkAncillaryPacket_v15_2; + +#endif /* __IDeckLinkAncillaryPacket_v15_2_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkAncillaryPacketIterator_v15_2_FWD_DEFINED__ +#define __IDeckLinkAncillaryPacketIterator_v15_2_FWD_DEFINED__ +typedef interface IDeckLinkAncillaryPacketIterator_v15_2 IDeckLinkAncillaryPacketIterator_v15_2; + +#endif /* __IDeckLinkAncillaryPacketIterator_v15_2_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkVideoFrameAncillaryPackets_v15_2_FWD_DEFINED__ +#define __IDeckLinkVideoFrameAncillaryPackets_v15_2_FWD_DEFINED__ +typedef interface IDeckLinkVideoFrameAncillaryPackets_v15_2 IDeckLinkVideoFrameAncillaryPackets_v15_2; + +#endif /* __IDeckLinkVideoFrameAncillaryPackets_v15_2_FWD_DEFINED__ */ + + +#ifndef __CDeckLinkVideoFrameAncillaryPackets_v15_2_FWD_DEFINED__ +#define __CDeckLinkVideoFrameAncillaryPackets_v15_2_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class CDeckLinkVideoFrameAncillaryPackets_v15_2 CDeckLinkVideoFrameAncillaryPackets_v15_2; +#else +typedef struct CDeckLinkVideoFrameAncillaryPackets_v15_2 CDeckLinkVideoFrameAncillaryPackets_v15_2; +#endif /* __cplusplus */ + +#endif /* __CDeckLinkVideoFrameAncillaryPackets_v15_2_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkVideoFrameMetadataExtensions_v11_5_FWD_DEFINED__ +#define __IDeckLinkVideoFrameMetadataExtensions_v11_5_FWD_DEFINED__ +typedef interface IDeckLinkVideoFrameMetadataExtensions_v11_5 IDeckLinkVideoFrameMetadataExtensions_v11_5; + +#endif /* __IDeckLinkVideoFrameMetadataExtensions_v11_5_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkOutput_v11_4_FWD_DEFINED__ +#define __IDeckLinkOutput_v11_4_FWD_DEFINED__ +typedef interface IDeckLinkOutput_v11_4 IDeckLinkOutput_v11_4; + +#endif /* __IDeckLinkOutput_v11_4_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkInput_v11_4_FWD_DEFINED__ +#define __IDeckLinkInput_v11_4_FWD_DEFINED__ +typedef interface IDeckLinkInput_v11_4 IDeckLinkInput_v11_4; + +#endif /* __IDeckLinkInput_v11_4_FWD_DEFINED__ */ + + +#ifndef __CDeckLinkIterator_v10_8_FWD_DEFINED__ +#define __CDeckLinkIterator_v10_8_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class CDeckLinkIterator_v10_8 CDeckLinkIterator_v10_8; +#else +typedef struct CDeckLinkIterator_v10_8 CDeckLinkIterator_v10_8; +#endif /* __cplusplus */ + +#endif /* __CDeckLinkIterator_v10_8_FWD_DEFINED__ */ + + +#ifndef __CDeckLinkDiscovery_v10_8_FWD_DEFINED__ +#define __CDeckLinkDiscovery_v10_8_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class CDeckLinkDiscovery_v10_8 CDeckLinkDiscovery_v10_8; +#else +typedef struct CDeckLinkDiscovery_v10_8 CDeckLinkDiscovery_v10_8; +#endif /* __cplusplus */ + +#endif /* __CDeckLinkDiscovery_v10_8_FWD_DEFINED__ */ + + +#ifndef __IDeckLinkEncoderConfiguration_v10_5_FWD_DEFINED__ +#define __IDeckLinkEncoderConfiguration_v10_5_FWD_DEFINED__ +typedef interface IDeckLinkEncoderConfiguration_v10_5 IDeckLinkEncoderConfiguration_v10_5; + +#endif /* __IDeckLinkEncoderConfiguration_v10_5_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 LONGLONG BMDIPFlowID; + +typedef unsigned int BMDTimecodeFlags; +#if 0 +typedef enum _BMDTimecodeFlags BMDTimecodeFlags; + +#endif +/* [v1_enum] */ +enum _BMDTimecodeFlags + { + bmdTimecodeFlagDefault = 0, + bmdTimecodeIsDropFrame = ( 1 << 0 ) , + bmdTimecodeFieldMark = ( 1 << 1 ) , + bmdTimecodeColorFrame = ( 1 << 2 ) , + bmdTimecodeEmbedRecordingTrigger = ( 1 << 3 ) , + bmdTimecodeRecordingTriggered = ( 1 << 4 ) + } ; +typedef /* [v1_enum] */ +enum _BMDVideoConnection + { + bmdVideoConnectionUnspecified = 0, + bmdVideoConnectionSDI = ( 1 << 0 ) , + bmdVideoConnectionHDMI = ( 1 << 1 ) , + bmdVideoConnectionOpticalSDI = ( 1 << 2 ) , + bmdVideoConnectionComponent = ( 1 << 3 ) , + bmdVideoConnectionComposite = ( 1 << 4 ) , + bmdVideoConnectionSVideo = ( 1 << 5 ) , + bmdVideoConnectionEthernet = ( 1 << 6 ) , + bmdVideoConnectionOpticalEthernet = ( 1 << 7 ) , + bmdVideoConnectionInternal = ( 1 << 8 ) + } BMDVideoConnection; + +typedef /* [v1_enum] */ +enum _BMDAudioConnection + { + bmdAudioConnectionEmbedded = ( 1 << 0 ) , + bmdAudioConnectionAESEBU = ( 1 << 1 ) , + bmdAudioConnectionAnalog = ( 1 << 2 ) , + bmdAudioConnectionAnalogXLR = ( 1 << 3 ) , + bmdAudioConnectionAnalogRCA = ( 1 << 4 ) , + bmdAudioConnectionMicrophone = ( 1 << 5 ) , + bmdAudioConnectionHeadphones = ( 1 << 6 ) + } BMDAudioConnection; + +typedef /* [v1_enum] */ +enum _BMDDeckControlConnection + { + bmdDeckControlConnectionRS422Remote1 = ( 1 << 0 ) , + bmdDeckControlConnectionRS422Remote2 = ( 1 << 1 ) + } BMDDeckControlConnection; + + +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, + bmdModeHD1080p4795 = 0x48703437, + bmdModeHD1080p48 = 0x48703438, + bmdModeHD1080p50 = 0x48703530, + bmdModeHD1080p5994 = 0x48703539, + bmdModeHD1080p6000 = 0x48703630, + bmdModeHD1080p9590 = 0x48703935, + bmdModeHD1080p96 = 0x48703936, + bmdModeHD1080p100 = 0x48703130, + bmdModeHD1080p11988 = 0x48703131, + bmdModeHD1080p120 = 0x48703132, + bmdModeHD1080i50 = 0x48693530, + bmdModeHD1080i5994 = 0x48693539, + bmdModeHD1080i6000 = 0x48693630, + bmdModeHD720p50 = 0x68703530, + bmdModeHD720p5994 = 0x68703539, + bmdModeHD720p60 = 0x68703630, + bmdMode2k2398 = 0x326b3233, + bmdMode2k24 = 0x326b3234, + bmdMode2k25 = 0x326b3235, + bmdMode2kDCI2398 = 0x32643233, + bmdMode2kDCI24 = 0x32643234, + bmdMode2kDCI25 = 0x32643235, + bmdMode2kDCI2997 = 0x32643239, + bmdMode2kDCI30 = 0x32643330, + bmdMode2kDCI4795 = 0x32643437, + bmdMode2kDCI48 = 0x32643438, + bmdMode2kDCI50 = 0x32643530, + bmdMode2kDCI5994 = 0x32643539, + bmdMode2kDCI60 = 0x32643630, + bmdMode2kDCI9590 = 0x32643935, + bmdMode2kDCI96 = 0x32643936, + bmdMode2kDCI100 = 0x32643130, + bmdMode2kDCI11988 = 0x32643131, + bmdMode2kDCI120 = 0x32643132, + bmdMode4K2160p2398 = 0x346b3233, + bmdMode4K2160p24 = 0x346b3234, + bmdMode4K2160p25 = 0x346b3235, + bmdMode4K2160p2997 = 0x346b3239, + bmdMode4K2160p30 = 0x346b3330, + bmdMode4K2160p4795 = 0x346b3437, + bmdMode4K2160p48 = 0x346b3438, + bmdMode4K2160p50 = 0x346b3530, + bmdMode4K2160p5994 = 0x346b3539, + bmdMode4K2160p60 = 0x346b3630, + bmdMode4K2160p9590 = 0x346b3935, + bmdMode4K2160p96 = 0x346b3936, + bmdMode4K2160p100 = 0x346b3130, + bmdMode4K2160p11988 = 0x346b3131, + bmdMode4K2160p120 = 0x346b3132, + bmdMode4kDCI2398 = 0x34643233, + bmdMode4kDCI24 = 0x34643234, + bmdMode4kDCI25 = 0x34643235, + bmdMode4kDCI2997 = 0x34643239, + bmdMode4kDCI30 = 0x34643330, + bmdMode4kDCI4795 = 0x34643437, + bmdMode4kDCI48 = 0x34643438, + bmdMode4kDCI50 = 0x34643530, + bmdMode4kDCI5994 = 0x34643539, + bmdMode4kDCI60 = 0x34643630, + bmdMode4kDCI9590 = 0x34643935, + bmdMode4kDCI96 = 0x34643936, + bmdMode4kDCI100 = 0x34643130, + bmdMode4kDCI11988 = 0x34643131, + bmdMode4kDCI120 = 0x34643132, + bmdMode8K4320p2398 = 0x386b3233, + bmdMode8K4320p24 = 0x386b3234, + bmdMode8K4320p25 = 0x386b3235, + bmdMode8K4320p2997 = 0x386b3239, + bmdMode8K4320p30 = 0x386b3330, + bmdMode8K4320p4795 = 0x386b3437, + bmdMode8K4320p48 = 0x386b3438, + bmdMode8K4320p50 = 0x386b3530, + bmdMode8K4320p5994 = 0x386b3539, + bmdMode8K4320p60 = 0x386b3630, + bmdMode8kDCI2398 = 0x38643233, + bmdMode8kDCI24 = 0x38643234, + bmdMode8kDCI25 = 0x38643235, + bmdMode8kDCI2997 = 0x38643239, + bmdMode8kDCI30 = 0x38643330, + bmdMode8kDCI4795 = 0x38643437, + bmdMode8kDCI48 = 0x38643438, + bmdMode8kDCI50 = 0x38643530, + bmdMode8kDCI5994 = 0x38643539, + bmdMode8kDCI60 = 0x38643630, + bmdMode640x480p60 = 0x76676136, + bmdMode800x600p60 = 0x73766736, + bmdMode1440x900p50 = 0x77786735, + bmdMode1440x900p60 = 0x77786736, + bmdMode1440x1080p50 = 0x73786735, + bmdMode1440x1080p60 = 0x73786736, + bmdMode1600x1200p50 = 0x75786735, + bmdMode1600x1200p60 = 0x75786736, + bmdMode1920x1200p50 = 0x77757835, + bmdMode1920x1200p60 = 0x77757836, + bmdMode1920x1440p50 = 0x31393435, + bmdMode1920x1440p60 = 0x31393436, + bmdMode2560x1440p50 = 0x77716835, + bmdMode2560x1440p60 = 0x77716836, + bmdMode2560x1600p50 = 0x77717835, + bmdMode2560x1600p60 = 0x77717836, + bmdModeUnknown = 0x69756e6b + } BMDDisplayMode; + +typedef /* [v1_enum] */ +enum _BMDFieldDominance + { + bmdUnknownFieldDominance = 0, + bmdLowerFieldFirst = 0x6c6f7772, + bmdUpperFieldFirst = 0x75707072, + bmdProgressiveFrame = 0x70726f67, + bmdProgressiveSegmentedFrame = 0x70736620 + } BMDFieldDominance; + +typedef /* [v1_enum] */ +enum _BMDPixelFormat + { + bmdFormatUnspecified = 0, + bmdFormat8BitYUV = 0x32767579, + bmdFormat10BitYUV = 0x76323130, + bmdFormat10BitYUVA = 0x41793130, + bmdFormat8BitARGB = 32, + bmdFormat8BitBGRA = 0x42475241, + bmdFormat10BitRGB = 0x72323130, + bmdFormat12BitRGB = 0x52313242, + bmdFormat12BitRGBLE = 0x5231324c, + bmdFormat10BitRGBXLE = 0x5231306c, + bmdFormat10BitRGBX = 0x52313062, + bmdFormatH265 = 0x68657631, + bmdFormatDNxHR = 0x41566468 + } BMDPixelFormat; + +/* [v1_enum] */ +enum _BMDDisplayModeFlags + { + bmdDisplayModeSupports3D = ( 1 << 0 ) , + bmdDisplayModeColorspaceRec601 = ( 1 << 1 ) , + bmdDisplayModeColorspaceRec709 = ( 1 << 2 ) , + bmdDisplayModeColorspaceRec2020 = ( 1 << 3 ) + } ; + + +#if 0 +#endif + +#if 0 +#endif +typedef /* [v1_enum] */ +enum _BMDDeckLinkConfigurationID + { + bmdDeckLinkConfigSwapSerialRxTx = 0x73737274, + bmdDeckLinkConfigHDMI3DPackingFormat = 0x33647066, + bmdDeckLinkConfigBypass = 0x62797073, + bmdDeckLinkConfigClockTimingAdjustment = 0x63746164, + bmdDeckLinkConfigAudioMeterType = 0x61756d74, + bmdDeckLinkConfigAnalogAudioConsumerLevels = 0x6161636c, + bmdDeckLinkConfigSwapHDMICh3AndCh4OnInput = 0x68693334, + bmdDeckLinkConfigSwapHDMICh3AndCh4OnOutput = 0x686f3334, + bmdDeckLinkConfigAnalogAudioOutputChannelsMutedByHeadphone = 0x616d6870, + bmdDeckLinkConfigAnalogAudioOutputChannelsMutedBySpeaker = 0x616d7370, + bmdDeckLinkConfigFieldFlickerRemoval = 0x66646672, + bmdDeckLinkConfigHD1080p24ToHD1080i5994Conversion = 0x746f3539, + bmdDeckLinkConfig444SDIVideoOutput = 0x3434346f, + bmdDeckLinkConfigBlackVideoOutputDuringCapture = 0x62766f63, + bmdDeckLinkConfigLowLatencyVideoOutput = 0x6c6c766f, + bmdDeckLinkConfigDownConversionOnAllAnalogOutput = 0x6361616f, + bmdDeckLinkConfigSMPTELevelAOutput = 0x736d7461, + bmdDeckLinkConfigRec2020Output = 0x72656332, + bmdDeckLinkConfigQuadLinkSDIVideoOutputSquareDivisionSplit = 0x53445153, + bmdDeckLinkConfigOutput1080pAsPsF = 0x70667072, + bmdDeckLinkConfigOutputValidateEDIDForDolbyVision = 0x70726564, + bmdDeckLinkConfigExtendedDesktop = 0x65786474, + bmdDeckLinkConfigEthernetVideoOutputIP10 = 0x49503130, + bmdDeckLinkConfigVideoOutputConnection = 0x766f636e, + bmdDeckLinkConfigVideoOutputConversionMode = 0x766f636d, + bmdDeckLinkConfigVideoOutputConversionColorspaceDestination = 0x76636364, + bmdDeckLinkConfigVideoOutputConversionColorspaceSource = 0x76636373, + bmdDeckLinkConfigAnalogVideoOutputFlags = 0x61766f66, + bmdDeckLinkConfigReferenceInputTimingOffset = 0x676c6f74, + bmdDeckLinkConfigReferenceOutputMode = 0x676c4f6d, + bmdDeckLinkConfigVideoOutputIdleOperation = 0x766f696f, + bmdDeckLinkConfigDefaultVideoOutputMode = 0x64766f6d, + bmdDeckLinkConfigDefaultVideoOutputModeFlags = 0x64766f66, + bmdDeckLinkConfigSDIOutputLinkConfiguration = 0x736f6c63, + bmdDeckLinkConfigHDMITimecodePacking = 0x6874706b, + bmdDeckLinkConfigPlaybackGroup = 0x706c6772, + bmdDeckLinkConfigVideoOutputComponentLumaGain = 0x6f636c67, + bmdDeckLinkConfigVideoOutputComponentChromaBlueGain = 0x6f636362, + bmdDeckLinkConfigVideoOutputComponentChromaRedGain = 0x6f636372, + bmdDeckLinkConfigVideoOutputCompositeLumaGain = 0x6f696c67, + bmdDeckLinkConfigVideoOutputCompositeChromaGain = 0x6f696367, + bmdDeckLinkConfigVideoOutputSVideoLumaGain = 0x6f736c67, + bmdDeckLinkConfigVideoOutputSVideoChromaGain = 0x6f736367, + bmdDeckLinkConfigDolbyVisionCMVersion = 0x64767672, + bmdDeckLinkConfigDolbyVisionMasterMinimumNits = 0x6d6e6e74, + bmdDeckLinkConfigDolbyVisionMasterMaximumNits = 0x6d786e74, + bmdDeckLinkConfigVideoInputScanning = 0x76697363, + bmdDeckLinkConfigUseDedicatedLTCInput = 0x646c7463, + bmdDeckLinkConfigSDIInput3DPayloadOverride = 0x33646473, + bmdDeckLinkConfigCapture1080pAsPsF = 0x63667072, + bmdDeckLinkConfigVideoInputConnection = 0x7669636e, + bmdDeckLinkConfigAnalogVideoInputFlags = 0x61766966, + bmdDeckLinkConfigVideoInputConversionMode = 0x7669636d, + bmdDeckLinkConfig32PulldownSequenceInitialTimecodeFrame = 0x70646966, + bmdDeckLinkConfigVANCSourceLine1Mapping = 0x76736c31, + bmdDeckLinkConfigVANCSourceLine2Mapping = 0x76736c32, + bmdDeckLinkConfigVANCSourceLine3Mapping = 0x76736c33, + bmdDeckLinkConfigCapturePassThroughMode = 0x6370746d, + bmdDeckLinkConfigCaptureGroup = 0x63706772, + bmdDeckLinkConfigHANCInputFilter1 = 0x68696631, + bmdDeckLinkConfigHANCInputFilter2 = 0x68696632, + bmdDeckLinkConfigHANCInputFilter3 = 0x68696633, + bmdDeckLinkConfigHANCInputFilter4 = 0x68696634, + bmdDeckLinkConfigVideoInputComponentLumaGain = 0x69636c67, + bmdDeckLinkConfigVideoInputComponentChromaBlueGain = 0x69636362, + bmdDeckLinkConfigVideoInputComponentChromaRedGain = 0x69636372, + bmdDeckLinkConfigVideoInputCompositeLumaGain = 0x69696c67, + bmdDeckLinkConfigVideoInputCompositeChromaGain = 0x69696367, + bmdDeckLinkConfigVideoInputSVideoLumaGain = 0x69736c67, + bmdDeckLinkConfigVideoInputSVideoChromaGain = 0x69736367, + bmdDeckLinkConfigInternalKeyingAncillaryDataSource = 0x696b6173, + bmdDeckLinkConfigMicrophonePhantomPower = 0x6d706870, + bmdDeckLinkConfigAudioInputConnection = 0x6169636e, + bmdDeckLinkConfigAnalogAudioInputScaleChannel1 = 0x61697331, + bmdDeckLinkConfigAnalogAudioInputScaleChannel2 = 0x61697332, + bmdDeckLinkConfigAnalogAudioInputScaleChannel3 = 0x61697333, + bmdDeckLinkConfigAnalogAudioInputScaleChannel4 = 0x61697334, + bmdDeckLinkConfigDigitalAudioInputScale = 0x64616973, + bmdDeckLinkConfigMicrophoneInputGain = 0x6d696367, + bmdDeckLinkConfigAudioOutputXLRDelayFrames = 0x78646672, + bmdDeckLinkConfigAudioOutputAESAnalogSwitch = 0x616f6161, + bmdDeckLinkConfigAudioOutputXLRDelayTime = 0x78646d73, + bmdDeckLinkConfigAudioOutputXLRDelayType = 0x78647479, + bmdDeckLinkConfigAnalogAudioOutputScaleChannel1 = 0x616f7331, + bmdDeckLinkConfigAnalogAudioOutputScaleChannel2 = 0x616f7332, + bmdDeckLinkConfigAnalogAudioOutputScaleChannel3 = 0x616f7333, + bmdDeckLinkConfigAnalogAudioOutputScaleChannel4 = 0x616f7334, + bmdDeckLinkConfigDigitalAudioOutputScale = 0x64616f73, + bmdDeckLinkConfigHeadphoneVolume = 0x68766f6c, + bmdDeckLinkConfigSpeakerVolume = 0x73766f6c, + bmdDeckLinkConfigEthernetPTPFollowerOnly = 0x50545066, + bmdDeckLinkConfigEthernetPTPUseUDPEncapsulation = 0x50545055, + bmdDeckLinkConfigEthernetUseManualNMOSRegistry = 0x6e6d7270, + bmdDeckLinkConfigEthernetPTPPriority1 = 0x50545031, + bmdDeckLinkConfigEthernetPTPPriority2 = 0x50545032, + bmdDeckLinkConfigEthernetPTPDomain = 0x50545044, + bmdDeckLinkConfigEthernetPTPLogAnnounceInterval = 0x50545041, + bmdDeckLinkConfigEthernetAudioOutputChannelOrder = 0x6361636f, + bmdDeckLinkConfigEthernetNMOSRegistryAddress = 0x6e6d7265, + bmdDeckLinkConfigParamEthernetUseDHCP = 0x44484350, + bmdDeckLinkConfigParamEthernetStaticLocalIPAddress = 0x6e736970, + bmdDeckLinkConfigParamEthernetStaticSubnetMask = 0x6e73736d, + bmdDeckLinkConfigParamEthernetStaticGatewayIPAddress = 0x6e736777, + bmdDeckLinkConfigParamEthernetStaticPrimaryDNS = 0x6e737064, + bmdDeckLinkConfigParamEthernetStaticSecondaryDNS = 0x6e737364, + bmdDeckLinkConfigParamEthernetVideoOutputAddress = 0x6e6f6176, + bmdDeckLinkConfigParamEthernetAudioOutputAddress = 0x6e6f6161, + bmdDeckLinkConfigParamEthernetAncillaryOutputAddress = 0x6e6f6141, + bmdDeckLinkConfigDeviceInformationLabel = 0x64696c61, + bmdDeckLinkConfigDeviceInformationSerialNumber = 0x6469736e, + bmdDeckLinkConfigDeviceInformationCompany = 0x6469636f, + bmdDeckLinkConfigDeviceInformationPhone = 0x64697068, + bmdDeckLinkConfigDeviceInformationEmail = 0x6469656d, + bmdDeckLinkConfigDeviceInformationDate = 0x64696461, + bmdDeckLinkConfigDeckControlConnection = 0x6463636f, + bmdDeckLinkConfigDisplayLanguage = 0x6c616e67 + } BMDDeckLinkConfigurationID; + +typedef /* [v1_enum] */ +enum _BMDDeckLinkEncoderConfigurationID + { + bmdDeckLinkEncoderConfigPreferredBitDepth = 0x65706272, + bmdDeckLinkEncoderConfigFrameCodingMode = 0x6566636d, + bmdDeckLinkEncoderConfigH265TargetBitrate = 0x68746272, + bmdDeckLinkEncoderConfigDNxHRCompressionID = 0x64636964, + bmdDeckLinkEncoderConfigDNxHRLevel = 0x646c6576, + bmdDeckLinkEncoderConfigMPEG4SampleDescription = 0x73747345, + bmdDeckLinkEncoderConfigMPEG4CodecSpecificDesc = 0x65736473 + } BMDDeckLinkEncoderConfigurationID; + + + +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 BMDBufferAccessFlags; +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 BMDAudioOutputXLRDelayType; +typedef unsigned int BMDFormatFlags; +typedef unsigned int BMDDeviceBusyState; +#if 0 +typedef enum _BMDBufferAccessFlags BMDBufferAccessFlags; + +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 _BMDAudioOutputXLRDelayType BMDAudioOutputXLRDelayType; + +typedef enum _BMDFormatFlags BMDFormatFlags; + +typedef enum _BMDDeviceBusyState BMDDeviceBusyState; + +#endif +/* [v1_enum] */ +enum _BMDBufferAccessFlags + { + bmdBufferAccessReadAndWrite = ( ( 1 << 0 ) | ( 1 << 1 ) ) , + bmdBufferAccessRead = ( 1 << 0 ) , + bmdBufferAccessWrite = ( 1 << 1 ) + } ; +typedef /* [v1_enum] */ +enum _BMDVideoOutputFlags + { + bmdVideoOutputFlagDefault = 0, + bmdVideoOutputVANC = ( 1 << 0 ) , + bmdVideoOutputVITC = ( 1 << 1 ) , + bmdVideoOutputRP188 = ( 1 << 2 ) , + bmdVideoOutputDualStream3D = ( 1 << 4 ) , + bmdVideoOutputSynchronizeToPlaybackGroup = ( 1 << 6 ) , + bmdVideoOutputDolbyVision = ( 1 << 7 ) + } BMDVideoOutputFlags; + +typedef /* [v1_enum] */ +enum _BMDSupportedVideoModeFlags + { + bmdSupportedVideoModeDefault = 0, + bmdSupportedVideoModeKeying = ( 1 << 0 ) , + bmdSupportedVideoModeDualStream3D = ( 1 << 1 ) , + bmdSupportedVideoModeSDISingleLink = ( 1 << 2 ) , + bmdSupportedVideoModeSDIDualLink = ( 1 << 3 ) , + bmdSupportedVideoModeSDIQuadLink = ( 1 << 4 ) , + bmdSupportedVideoModeInAnyProfile = ( 1 << 5 ) , + bmdSupportedVideoModePsF = ( 1 << 6 ) , + bmdSupportedVideoModeDolbyVision = ( 1 << 7 ) , + bmdSupportedVideoModeEthernetIP10 = ( 1 << 8 ) + } BMDSupportedVideoModeFlags; + +typedef /* [v1_enum] */ +enum _BMDPacketType + { + bmdPacketTypeStreamInterruptedMarker = 0x73696e74, + bmdPacketTypeStreamData = 0x73646174 + } BMDPacketType; + +/* [v1_enum] */ +enum _BMDFrameFlags + { + bmdFrameFlagDefault = 0, + bmdFrameFlagFlipVertical = ( 1 << 0 ) , + bmdFrameFlagMonitorOutOnly = ( 1 << 3 ) , + bmdFrameContainsHDRMetadata = ( 1 << 1 ) , + bmdFrameContainsDolbyVisionMetadata = ( 1 << 4 ) , + bmdFrameCapturedAsPsF = ( 1 << 30 ) , + bmdFrameHasNoInputSource = ( 1 << 31 ) + } ; +/* [v1_enum] */ +enum _BMDVideoInputFlags + { + bmdVideoInputFlagDefault = 0, + bmdVideoInputEnableFormatDetection = ( 1 << 0 ) , + bmdVideoInputDualStream3D = ( 1 << 1 ) , + bmdVideoInputSynchronizeToCaptureGroup = ( 1 << 2 ) + } ; +/* [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 ) , + bmdDetectedVideoInput12BitDepth = ( 1 << 3 ) , + bmdDetectedVideoInput10BitDepth = ( 1 << 4 ) , + bmdDetectedVideoInput8BitDepth = ( 1 << 5 ) + } ; +/* [v1_enum] */ +enum _BMDDeckLinkCapturePassthroughMode + { + bmdDeckLinkCapturePassthroughModeDisabled = 0x70646973, + 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 + { + bmdReferenceUnlocked = 0, + bmdReferenceNotSupportedByHardware = ( 1 << 0 ) , + bmdReferenceLocked = ( 1 << 1 ) + } BMDReferenceStatus; + +typedef /* [v1_enum] */ +enum _BMDEthernetNMOSRegistryState + { + bmdEthernetNMOSRegistryConnecting = 0x636f6e6e, + bmdEthernetNMOSRegistryActive = 0x676f6f64, + bmdEthernetNMOSRegistryError = 0x6572726f + } BMDEthernetNMOSRegistryState; + +typedef /* [v1_enum] */ +enum _BMDAudioFormat + { + bmdAudioFormatPCM = 0x6c70636d + } BMDAudioFormat; + +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 _BMDAncillaryPacketFormat + { + bmdAncillaryPacketFormatUInt8 = 0x75693038, + bmdAncillaryPacketFormatUInt16 = 0x75693136, + bmdAncillaryPacketFormatYCbCr10 = 0x76323130 + } BMDAncillaryPacketFormat; + +typedef /* [v1_enum] */ +enum _BMDTimecodeFormat + { + bmdTimecodeRP188VITC1 = 0x72707631, + bmdTimecodeRP188VITC2 = 0x72703132, + bmdTimecodeRP188LTC = 0x72706c74, + bmdTimecodeRP188HighFrameRate = 0x72706872, + 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 + } BMDIdleVideoOutputOperation; + +typedef /* [v1_enum] */ +enum _BMDVideoEncoderFrameCodingMode + { + bmdVideoEncoderFrameCodingModeInter = 0x696e7465, + bmdVideoEncoderFrameCodingModeIntra = 0x696e7472 + } BMDVideoEncoderFrameCodingMode; + +typedef /* [v1_enum] */ +enum _BMDDNxHRLevel + { + bmdDNxHRLevelSQ = 0x646e7371, + bmdDNxHRLevelLB = 0x646e6c62, + bmdDNxHRLevelHQ = 0x646e6871, + bmdDNxHRLevelHQX = 0x64687178, + bmdDNxHRLevel444 = 0x64343434 + } BMDDNxHRLevel; + +typedef /* [v1_enum] */ +enum _BMDLinkConfiguration + { + bmdLinkConfigurationSingleLink = 0x6c63736c, + bmdLinkConfigurationDualLink = 0x6c63646c, + bmdLinkConfigurationQuadLink = 0x6c63716c + } BMDLinkConfiguration; + +typedef /* [v1_enum] */ +enum _BMDDeviceInterface + { + bmdDeviceInterfacePCI = 0x70636920, + bmdDeviceInterfaceUSB = 0x75736220, + bmdDeviceInterfaceThunderbolt = 0x7468756e + } BMDDeviceInterface; + +typedef /* [v1_enum] */ +enum _BMDColorspace + { + bmdColorspaceRec601 = 0x72363031, + bmdColorspaceRec709 = 0x72373039, + bmdColorspaceRec2020 = 0x32303230, + bmdColorspaceDolbyVisionNative = 0x446f5669, + bmdColorspaceP3D65 = 0x50334436, + bmdColorspaceUnknown = 0x4e636f6c + } BMDColorspace; + +typedef /* [v1_enum] */ +enum _BMDDynamicRange + { + bmdDynamicRangeSDR = 0, + bmdDynamicRangeHDRStaticPQ = ( 1 << 29 ) , + bmdDynamicRangeHDRStaticHLG = ( 1 << 30 ) + } BMDDynamicRange; + +typedef /* [v1_enum] */ +enum _BMDMezzanineType + { + bmdMezzanineTypeNone = 0, + bmdMezzanineTypeHDMI14OpticalSDI = 0x6d7a6131, + bmdMezzanineTypeQuadSDI = 0x6d7a3473, + bmdMezzanineTypeHDMI20OpticalSDI = 0x6d7a6132, + bmdMezzanineTypeHDMI21RS422 = 0x6d7a6872 + } BMDMezzanineType; + +typedef /* [v1_enum] */ +enum _BMDDeckLinkHDMIInputEDIDID + { + bmdDeckLinkHDMIInputEDIDDynamicRange = 0x48494479 + } BMDDeckLinkHDMIInputEDIDID; + +typedef /* [v1_enum] */ +enum _BMDDeckLinkFrameMetadataID + { + bmdDeckLinkFrameMetadataColorspace = 0x63737063, + bmdDeckLinkFrameMetadataHDRElectroOpticalTransferFunc = 0x656f7466, + bmdDeckLinkFrameMetadataRTPTimestamp = 0x72747074, + bmdDeckLinkFrameMetadataDolbyVision = 0x646f7669, + bmdDeckLinkFrameMetadataHDRDisplayPrimariesRedX = 0x68647278, + bmdDeckLinkFrameMetadataHDRDisplayPrimariesRedY = 0x68647279, + bmdDeckLinkFrameMetadataHDRDisplayPrimariesGreenX = 0x68646778, + bmdDeckLinkFrameMetadataHDRDisplayPrimariesGreenY = 0x68646779, + bmdDeckLinkFrameMetadataHDRDisplayPrimariesBlueX = 0x68646278, + bmdDeckLinkFrameMetadataHDRDisplayPrimariesBlueY = 0x68646279, + bmdDeckLinkFrameMetadataHDRWhitePointX = 0x68647778, + bmdDeckLinkFrameMetadataHDRWhitePointY = 0x68647779, + bmdDeckLinkFrameMetadataHDRMaxDisplayMasteringLuminance = 0x68646d6c, + bmdDeckLinkFrameMetadataHDRMinDisplayMasteringLuminance = 0x686d696c, + bmdDeckLinkFrameMetadataHDRMaximumContentLightLevel = 0x6d636c6c, + bmdDeckLinkFrameMetadataHDRMaximumFrameAverageLightLevel = 0x66616c6c + } BMDDeckLinkFrameMetadataID; + +typedef /* [v1_enum] */ +enum _BMDEthernetLinkState + { + bmdEthernetLinkStateDisconnected = 0x656c6473, + bmdEthernetLinkStateConnectedUnbound = 0x656c6375, + bmdEthernetLinkStateConnectedBound = 0x656c6362 + } BMDEthernetLinkState; + +typedef /* [v1_enum] */ +enum _BMDProfileID + { + bmdProfileOneSubDeviceFullDuplex = 0x31646664, + bmdProfileOneSubDeviceHalfDuplex = 0x31646864, + bmdProfileTwoSubDevicesFullDuplex = 0x32646664, + bmdProfileTwoSubDevicesHalfDuplex = 0x32646864, + bmdProfileFourSubDevicesHalfDuplex = 0x34646864 + } BMDProfileID; + +typedef /* [v1_enum] */ +enum _BMDHDMITimecodePacking + { + bmdHDMITimecodePackingIEEEOUI000085 = 0x8500, + bmdHDMITimecodePackingIEEEOUI080046 = 0x8004601, + bmdHDMITimecodePackingIEEEOUI5CF9F0 = 0x5cf9f003 + } BMDHDMITimecodePacking; + +typedef /* [v1_enum] */ +enum _BMDInternalKeyingAncillaryDataSource + { + bmdInternalKeyingUsesAncillaryDataFromInputSignal = 0x696b6169, + bmdInternalKeyingUsesAncillaryDataFromKeyFrame = 0x696b616b + } BMDInternalKeyingAncillaryDataSource; + +/* [v1_enum] */ +enum _BMDAudioOutputXLRDelayType + { + bmdAudioOutputXLRDelayTypeTime = 0x64746d73, + bmdAudioOutputXLRDelayTypeFrames = 0x64746672 + } ; +typedef /* [v1_enum] */ +enum _BMDLanguage + { + bmdLanguageEnglish = 0x656e5553, + bmdLanguageSimplifiedChinese = 0x7a68434e, + bmdLanguageJapanese = 0x6a614a50, + bmdLanguageKorean = 0x6b6f4b52, + bmdLanguageSpanish = 0x65734553, + bmdLanguageGerman = 0x64654445, + bmdLanguageFrench = 0x66724652, + bmdLanguageRussian = 0x72755255, + bmdLanguageItalian = 0x69744954, + bmdLanguagePortuguese = 0x70744252, + bmdLanguageTurkish = 0x74725452, + bmdLanguagePolish = 0x706c504c, + bmdLanguageUkrainian = 0x756b5541 + } BMDLanguage; + +typedef /* [v1_enum] */ +enum _BMDAudioMeterType + { + bmdAudioMeterTypeVUMinus18db = 0x76753138, + bmdAudioMeterTypeVUMinus20db = 0x76753230, + bmdAudioMeterTypePPMMinus18db = 0x706d3138, + bmdAudioMeterTypePPMMinus20db = 0x706d3230 + } BMDAudioMeterType; + +typedef /* [v1_enum] */ +enum _BMDDeckLinkAttributeID + { + BMDDeckLinkSupportsInternalKeying = 0x6b657969, + BMDDeckLinkSupportsExternalKeying = 0x6b657965, + BMDDeckLinkSupportsInputFormatDetection = 0x696e6664, + BMDDeckLinkHasReferenceInput = 0x6872696e, + BMDDeckLinkHasSerialPort = 0x68737074, + BMDDeckLinkHasAnalogVideoOutputGain = 0x61766f67, + BMDDeckLinkCanOnlyAdjustOverallVideoOutputGain = 0x6f766f67, + BMDDeckLinkHasVideoInputAntiAliasingFilter = 0x6161666c, + BMDDeckLinkHasBypass = 0x62797073, + BMDDeckLinkSupportsClockTimingAdjustment = 0x63746164, + BMDDeckLinkSupportsFullFrameReferenceInputTimingOffset = 0x6672696e, + BMDDeckLinkSupportsSMPTELevelAOutput = 0x6c766c61, + BMDDeckLinkSupportsAutoSwitchingPPsFOnInput = 0x61707366, + BMDDeckLinkSupportsDualLinkSDI = 0x73646c73, + BMDDeckLinkSupportsQuadLinkSDI = 0x73716c73, + BMDDeckLinkSupportsIdleOutput = 0x69646f75, + BMDDeckLinkVANCRequires10BitYUVVideoFrames = 0x76696f59, + BMDDeckLinkHasLTCTimecodeInput = 0x686c7463, + BMDDeckLinkSupportsHDRMetadata = 0x6864726d, + BMDDeckLinkSupportsColorspaceMetadata = 0x636d6574, + BMDDeckLinkSupportsHDMITimecode = 0x6874696d, + BMDDeckLinkSupportsHighFrameRateTimecode = 0x48465254, + BMDDeckLinkSupportsSynchronizeToCaptureGroup = 0x73746367, + BMDDeckLinkSupportsSynchronizeToPlaybackGroup = 0x73747067, + BMDDeckLinkHasMonitorOut = 0x666d6f6f, + BMDDeckLinkSupportsExtendedDesktop = 0x64746f70, + BMDDeckLinkHANCRequiresInputFilterConfiguration = 0x68726966, + BMDDeckLinkSupportsHANCOutput = 0x6473686f, + BMDDeckLinkSupportsHANCInput = 0x64736869, + BMDDeckLinkMaximumAudioChannels = 0x6d616368, + BMDDeckLinkMaximumHDMIAudioChannels = 0x6d686368, + BMDDeckLinkMaximumAnalogAudioInputChannels = 0x69616368, + BMDDeckLinkMaximumAnalogAudioOutputChannels = 0x61616368, + BMDDeckLinkNumberOfSubDevices = 0x6e736264, + BMDDeckLinkNumberOfEthernetConnectors = 0x6e657468, + BMDDeckLinkSubDeviceIndex = 0x73756269, + BMDDeckLinkPersistentID = 0x70656964, + BMDDeckLinkDeviceGroupID = 0x64676964, + BMDDeckLinkTopologicalID = 0x746f6964, + BMDDeckLinkVideoOutputConnections = 0x766f636e, + BMDDeckLinkVideoInputConnections = 0x7669636e, + BMDDeckLinkAudioOutputConnections = 0x616f636e, + BMDDeckLinkAudioInputConnections = 0x6169636e, + BMDDeckLinkVideoIOSupport = 0x76696f73, + BMDDeckLinkDeckControlConnections = 0x6463636e, + BMDDeckLinkDeviceInterface = 0x64627573, + BMDDeckLinkAudioInputRCAChannelCount = 0x61697263, + BMDDeckLinkAudioInputXLRChannelCount = 0x61697863, + BMDDeckLinkAudioOutputRCAChannelCount = 0x616f7263, + BMDDeckLinkAudioOutputXLRChannelCount = 0x616f7863, + BMDDeckLinkProfileID = 0x70726964, + BMDDeckLinkDuplex = 0x64757078, + BMDDeckLinkMinimumPrerollFrames = 0x6d707266, + BMDDeckLinkSupportedDynamicRange = 0x73756472, + BMDDeckLinkMezzanineType = 0x6d657a74, + BMDDeckLinkXLRDelayMsMaximum = 0x78647478, + BMDDeckLinkXLRDelayFramesMaximum = 0x78646678, + BMDDeckLinkOutputHANCUserDataWordsLimit = 0x6d686f77, + BMDDeckLinkInputHANCUserDataWordsLimit = 0x6d686977, + BMDDeckLinkVideoInputGainMinimum = 0x7669676d, + BMDDeckLinkVideoInputGainMaximum = 0x76696778, + BMDDeckLinkVideoOutputGainMinimum = 0x766f676d, + BMDDeckLinkVideoOutputGainMaximum = 0x766f6778, + BMDDeckLinkMicrophoneInputGainMinimum = 0x6d69676d, + BMDDeckLinkMicrophoneInputGainMaximum = 0x6d696778, + BMDDeckLinkSerialPortDeviceName = 0x736c706e, + BMDDeckLinkVendorName = 0x766e6472, + BMDDeckLinkDisplayName = 0x6473706e, + BMDDeckLinkModelName = 0x6d646c6e, + BMDDeckLinkDeviceHandle = 0x64657668, + BMDDeckLinkParamEthernetMACAddress = 0x704d4143 + } BMDDeckLinkAttributeID; + +typedef /* [v1_enum] */ +enum _BMDDeckLinkAPIInformationID + { + BMDDeckLinkAPIVersion = 0x76657273 + } BMDDeckLinkAPIInformationID; + +typedef /* [v1_enum] */ +enum _BMDDeckLinkStatisticID + { + bmdDeckLinkStatisticPTPLossOfLock = 0x6e6c6f6c, + bmdDeckLinkStatisticPTPDPLLMarginOfError = 0x70747065, + bmdDeckLinkStatisticDeviceTemperature = 0x53746d70, + bmdDeckLinkStatisticParamEthernetRxPackets = 0x6e747278, + bmdDeckLinkStatisticParamEthernetRxDroppedPackets = 0x6e647278, + bmdDeckLinkStatisticParamEthernetSFPDynamicInfo = 0x73667073 + } BMDDeckLinkStatisticID; + +typedef /* [v1_enum] */ +enum _BMDDeckLinkStatusID + { + bmdDeckLinkStatusDetectedVideoInputMode = 0x6476696d, + bmdDeckLinkStatusCurrentVideoInputMode = 0x6376696d, + bmdDeckLinkStatusCurrentVideoOutputMode = 0x63766f6d, + bmdDeckLinkStatusHDMIOutputActualMode = 0x6869616d, + bmdDeckLinkStatusDetectedVideoInputFormatFlags = 0x64766666, + bmdDeckLinkStatusDetectedVideoInputFieldDominance = 0x64766664, + bmdDeckLinkStatusDetectedVideoInputColorspace = 0x6473636c, + bmdDeckLinkStatusDetectedVideoInputDynamicRange = 0x64736472, + bmdDeckLinkStatusDetectedSDILinkConfiguration = 0x64736c63, + bmdDeckLinkStatusCurrentVideoInputPixelFormat = 0x63766970, + bmdDeckLinkStatusCurrentVideoInputFlags = 0x63766966, + bmdDeckLinkStatusCurrentVideoOutputFlags = 0x63766f66, + bmdDeckLinkStatusPCIExpressLinkWidth = 0x70776964, + bmdDeckLinkStatusPCIExpressLinkSpeed = 0x706c6e6b, + bmdDeckLinkStatusLastVideoOutputPixelFormat = 0x6f706978, + bmdDeckLinkStatusReferenceSignalMode = 0x7265666d, + bmdDeckLinkStatusReferenceSignalFlags = 0x72656666, + bmdDeckLinkStatusBusy = 0x62757379, + bmdDeckLinkStatusInterchangeablePanelType = 0x69637074, + bmdDeckLinkStatusHDMIOutputActualFormatFlags = 0x68696166, + bmdDeckLinkStatusHDMIOutputFRLRate = 0x68696f66, + bmdDeckLinkStatusHDMIInputFRLRate = 0x68696966, + bmdDeckLinkStatusEthernetManualNMOSRegistry = 0x6e6d6d65, + bmdDeckLinkStatusHDMIOutputTMDSLineRate = 0x68696c72, + bmdDeckLinkStatusSinkSupportsDolbyVision = 0x64767672, + bmdDeckLinkStatusVideoInputSignalLocked = 0x7669736c, + bmdDeckLinkStatusAncillaryInputSignalLocked = 0x6169736c, + bmdDeckLinkStatusReferenceSignalLocked = 0x7265666c, + bmdDeckLinkStatusEthernetPTPGrandmasterIdentity = 0x73706964, + bmdDeckLinkStatusEthernetAudioInputChannelOrder = 0x7361636f, + bmdDeckLinkStatusEthernetCurrentNMOSRegistry = 0x6e6d7265, + bmdDeckLinkStatusReceivedEDID = 0x65646964, + bmdDeckLinkStatusParamEthernetLink = 0x73656c73, + bmdDeckLinkStatusParamEthernetLinkMbps = 0x73657370, + bmdDeckLinkStatusParamEthernetLocalIPAddress = 0x73656970, + bmdDeckLinkStatusParamEthernetSubnetMask = 0x7365736d, + bmdDeckLinkStatusParamEthernetGatewayIPAddress = 0x73656777, + bmdDeckLinkStatusParamEthernetPrimaryDNS = 0x73657064, + bmdDeckLinkStatusParamEthernetSecondaryDNS = 0x73657364, + bmdDeckLinkStatusParamEthernetSFPStaticInfo = 0x73667069, + bmdDeckLinkStatusParamEthernetVideoOutputAddress = 0x736f6176, + bmdDeckLinkStatusParamEthernetAudioOutputAddress = 0x736f6161, + bmdDeckLinkStatusParamEthernetAncillaryOutputAddress = 0x736f6141 + } BMDDeckLinkStatusID; + +typedef /* [v1_enum] */ +enum _BMDDeckLinkVideoStatusFlags + { + bmdDeckLinkVideoStatusPsF = ( 1 << 0 ) , + bmdDeckLinkVideoStatusDualStream3D = ( 1 << 1 ) + } BMDDeckLinkVideoStatusFlags; + +typedef /* [v1_enum] */ +enum _BMDDuplexMode + { + bmdDuplexFull = 0x64786675, + bmdDuplexHalf = 0x64786861, + bmdDuplexSimplex = 0x64787370, + bmdDuplexInactive = 0x6478696e + } BMDDuplexMode; + +typedef /* [v1_enum] */ +enum _BMDPanelType + { + bmdPanelNotDetected = 0x6e706e6c, + bmdPanelTeranexMiniSmartPanel = 0x746d736d + } BMDPanelType; + +/* [v1_enum] */ +enum _BMDFormatFlags + { + bmdFormatRGB444 = ( 1 << 0 ) , + bmdFormatYUV444 = ( 1 << 1 ) , + bmdFormatYUV422 = ( 1 << 2 ) , + bmdFormatYUV420 = ( 1 << 3 ) , + bmdFormat8BitDepth = ( 1 << 4 ) , + bmdFormat10BitDepth = ( 1 << 5 ) , + bmdFormat12BitDepth = ( 1 << 6 ) + } ; +/* [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 _BMDAncillaryDataSpace + { + bmdAncillaryDataSpaceVANC = 0, + bmdAncillaryDataSpaceHANC = 1 + } BMDAncillaryDataSpace; + +typedef /* [v1_enum] */ +enum _BMDIPFlowDirection + { + bmdDeckLinkIPFlowDirectionOutput = 0, + bmdDeckLinkIPFlowDirectionInput = 1 + } BMDIPFlowDirection; + +typedef /* [v1_enum] */ +enum _BMDIPFlowType + { + bmdDeckLinkIPFlowTypeVideo = 0, + bmdDeckLinkIPFlowTypeAudio = 1, + bmdDeckLinkIPFlowTypeAncillary = 2 + } BMDIPFlowType; + +typedef /* [v1_enum] */ +enum _BMDDeckLinkIPFlowAttributeID + { + bmdDeckLinkIPFlowID = 0x32666169, + bmdDeckLinkIPFlowDirection = 0x32666164, + bmdDeckLinkIPFlowType = 0x32666174 + } BMDDeckLinkIPFlowAttributeID; + +typedef /* [v1_enum] */ +enum _BMDDeckLinkIPFlowStatusID + { + bmdDeckLinkIPFlowSDP = 0x32666173 + } BMDDeckLinkIPFlowStatusID; + +typedef /* [v1_enum] */ +enum _BMDDeckLinkIPFlowSettingID + { + bmdDeckLinkIPFlowPeerSDP = 0x32667073 + } BMDDeckLinkIPFlowSettingID; + +typedef /* [v1_enum] */ +enum _BMDNotifications + { + bmdPreferencesChanged = 0x70726566, + bmdStatusChanged = 0x73746174, + bmdIPFlowStatusChanged = 0x62667363, + bmdIPFlowSettingChanged = 0x62666363 + } BMDNotifications; + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +typedef /* [v1_enum] */ +enum _BMDDeckLinkStatusID_v15_3_1 + { + bmdDeckLinkStatusDeviceTemperature_v15_3_1 = 0x64746d70, + bmdDeckLinkStatusEthernetLink_v15_3_1 = 0x73656c73, + bmdDeckLinkStatusEthernetLinkMbps_v15_3_1 = 0x73657370, + bmdDeckLinkStatusEthernetLocalIPAddress_v15_3_1 = 0x73656970, + bmdDeckLinkStatusEthernetSubnetMask_v15_3_1 = 0x7365736d, + bmdDeckLinkStatusEthernetGatewayIPAddress_v15_3_1 = 0x73656777, + bmdDeckLinkStatusEthernetPrimaryDNS_v15_3_1 = 0x73657064, + bmdDeckLinkStatusEthernetSecondaryDNS_v15_3_1 = 0x73657364, + bmdDeckLinkStatusEthernetVideoOutputAddress_v15_3_1 = 0x736f6176, + bmdDeckLinkStatusEthernetAudioOutputAddress_v15_3_1 = 0x736f6161, + bmdDeckLinkStatusEthernetAncillaryOutputAddress_v15_3_1 = 0x736f6141 + } BMDDeckLinkStatusID_v15_3_1; + +typedef /* [v1_enum] */ +enum _BMDDeckLinkConfigurationID_v15_3_1 + { + bmdDeckLinkConfigEthernetUseDHCP_v15_3_1 = 0x44484350, + bmdDeckLinkConfigEthernetStaticLocalIPAddress_v15_3_1 = 0x6e736970, + bmdDeckLinkConfigEthernetStaticSubnetMask_v15_3_1 = 0x6e73736d, + bmdDeckLinkConfigEthernetStaticGatewayIPAddress_v15_3_1 = 0x6e736777, + bmdDeckLinkConfigEthernetStaticPrimaryDNS_v15_3_1 = 0x6e737064, + bmdDeckLinkConfigEthernetStaticSecondaryDNS_v15_3_1 = 0x6e737364, + bmdDeckLinkConfigEthernetVideoOutputAddress_v15_3_1 = 0x6e6f6176, + bmdDeckLinkConfigEthernetAudioOutputAddress_v15_3_1 = 0x6e6f6161, + bmdDeckLinkConfigEthernetAncillaryOutputAddress_v15_3_1 = 0x6e6f6141 + } BMDDeckLinkConfigurationID_v15_3_1; + +typedef /* [v1_enum] */ +enum _BMDDeckLinkAttributeID_v15_3_1 + { + BMDDeckLinkEthernetMACAddress_v15_3_1 = 0x654d4143 + } BMDDeckLinkAttributeID_v15_3_1; + + + + + + + + + + + + + + + + + +typedef /* [v1_enum] */ +enum _BMDDeckLinkStatusID_v11_5_1 + { + bmdDeckLinkStatusDetectedVideoInputFlags_v11_5_1 = 0x64766966 + } BMDDeckLinkStatusID_v11_5_1; + +typedef /* [v1_enum] */ +enum _BMDDisplayModeSupport_v10_11 + { + bmdDisplayModeNotSupported_v10_11 = 0, + bmdDisplayModeSupported_v10_11 = ( bmdDisplayModeNotSupported_v10_11 + 1 ) , + bmdDisplayModeSupportedWithConversion_v10_11 = ( bmdDisplayModeSupported_v10_11 + 1 ) + } BMDDisplayModeSupport_v10_11; + +typedef /* [v1_enum] */ +enum _BMDDuplexMode_v10_11 + { + bmdDuplexModeFull_v10_11 = 0x66647570, + bmdDuplexModeHalf_v10_11 = 0x68647570 + } BMDDuplexMode_v10_11; + +typedef /* [v1_enum] */ +enum _BMDDeckLinkConfigurationID_v10_11 + { + bmdDeckLinkConfigDuplexMode_v10_11 = 0x64757078 + } BMDDeckLinkConfigurationID_v10_11; + +typedef /* [v1_enum] */ +enum _BMDDeckLinkAttributeID_v10_11 + { + BMDDeckLinkSupportsDuplexModeConfiguration_v10_11 = 0x64757078, + BMDDeckLinkSupportsHDKeying_v10_11 = 0x6b657968, + BMDDeckLinkPairedDevicePersistentID_v10_11 = 0x70706964, + BMDDeckLinkSupportsFullDuplex_v10_11 = 0x66647570 + } BMDDeckLinkAttributeID_v10_11; + +typedef /* [v1_enum] */ +enum _BMDDeckLinkStatusID_v10_11 + { + bmdDeckLinkStatusDuplexMode_v10_11 = 0x64757078 + } BMDDeckLinkStatusID_v10_11; + +typedef /* [v1_enum] */ +enum _BMDDuplexStatus_v10_11 + { + bmdDuplexFullDuplex_v10_11 = 0x66647570, + bmdDuplexHalfDuplex_v10_11 = 0x68647570, + bmdDuplexSimplex_v10_11 = 0x73706c78, + bmdDuplexInactive_v10_11 = 0x696e6163 + } BMDDuplexStatus_v10_11; + + + + +typedef /* [v1_enum] */ +enum _BMDDeckLinkConfigurationID_v10_9 + { + bmdDeckLinkConfig1080pNotPsF_v10_9 = 0x6670726f + } BMDDeckLinkConfigurationID_v10_9; + + +typedef /* [v1_enum] */ +enum _BMDDeckLinkConfigurationID_v10_4 + { + bmdDeckLinkConfigSingleLinkVideoOutput_v10_4 = 0x73676c6f + } BMDDeckLinkConfigurationID_v10_4; + + +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 _BMDDeckLinkFrameMetadataID_v11_5 + { + bmdDeckLinkFrameMetadataCintelFilmType_v11_5 = 0x63667479, + bmdDeckLinkFrameMetadataCintelFilmGauge_v11_5 = 0x63666761, + bmdDeckLinkFrameMetadataCintelKeykodeLow_v11_5 = 0x636b6b6c, + bmdDeckLinkFrameMetadataCintelKeykodeHigh_v11_5 = 0x636b6b68, + bmdDeckLinkFrameMetadataCintelTile1Size_v11_5 = 0x63743173, + bmdDeckLinkFrameMetadataCintelTile2Size_v11_5 = 0x63743273, + bmdDeckLinkFrameMetadataCintelTile3Size_v11_5 = 0x63743373, + bmdDeckLinkFrameMetadataCintelTile4Size_v11_5 = 0x63743473, + bmdDeckLinkFrameMetadataCintelImageWidth_v11_5 = 0x49575078, + bmdDeckLinkFrameMetadataCintelImageHeight_v11_5 = 0x49485078, + bmdDeckLinkFrameMetadataCintelLinearMaskingRedInRed_v11_5 = 0x6d726972, + bmdDeckLinkFrameMetadataCintelLinearMaskingGreenInRed_v11_5 = 0x6d676972, + bmdDeckLinkFrameMetadataCintelLinearMaskingBlueInRed_v11_5 = 0x6d626972, + bmdDeckLinkFrameMetadataCintelLinearMaskingRedInGreen_v11_5 = 0x6d726967, + bmdDeckLinkFrameMetadataCintelLinearMaskingGreenInGreen_v11_5 = 0x6d676967, + bmdDeckLinkFrameMetadataCintelLinearMaskingBlueInGreen_v11_5 = 0x6d626967, + bmdDeckLinkFrameMetadataCintelLinearMaskingRedInBlue_v11_5 = 0x6d726962, + bmdDeckLinkFrameMetadataCintelLinearMaskingGreenInBlue_v11_5 = 0x6d676962, + bmdDeckLinkFrameMetadataCintelLinearMaskingBlueInBlue_v11_5 = 0x6d626962, + bmdDeckLinkFrameMetadataCintelLogMaskingRedInRed_v11_5 = 0x6d6c7272, + bmdDeckLinkFrameMetadataCintelLogMaskingGreenInRed_v11_5 = 0x6d6c6772, + bmdDeckLinkFrameMetadataCintelLogMaskingBlueInRed_v11_5 = 0x6d6c6272, + bmdDeckLinkFrameMetadataCintelLogMaskingRedInGreen_v11_5 = 0x6d6c7267, + bmdDeckLinkFrameMetadataCintelLogMaskingGreenInGreen_v11_5 = 0x6d6c6767, + bmdDeckLinkFrameMetadataCintelLogMaskingBlueInGreen_v11_5 = 0x6d6c6267, + bmdDeckLinkFrameMetadataCintelLogMaskingRedInBlue_v11_5 = 0x6d6c7262, + bmdDeckLinkFrameMetadataCintelLogMaskingGreenInBlue_v11_5 = 0x6d6c6762, + bmdDeckLinkFrameMetadataCintelLogMaskingBlueInBlue_v11_5 = 0x6d6c6262, + bmdDeckLinkFrameMetadataCintelFilmFrameRate_v11_5 = 0x63666672, + bmdDeckLinkFrameMetadataCintelOffsetToApplyHorizontal_v11_5 = 0x6f746168, + bmdDeckLinkFrameMetadataCintelOffsetToApplyVertical_v11_5 = 0x6f746176, + bmdDeckLinkFrameMetadataCintelGainRed_v11_5 = 0x4c665264, + bmdDeckLinkFrameMetadataCintelGainGreen_v11_5 = 0x4c664772, + bmdDeckLinkFrameMetadataCintelGainBlue_v11_5 = 0x4c66426c, + bmdDeckLinkFrameMetadataCintelLiftRed_v11_5 = 0x476e5264, + bmdDeckLinkFrameMetadataCintelLiftGreen_v11_5 = 0x476e4772, + bmdDeckLinkFrameMetadataCintelLiftBlue_v11_5 = 0x476e426c, + bmdDeckLinkFrameMetadataCintelHDRGainRed_v11_5 = 0x48475264, + bmdDeckLinkFrameMetadataCintelHDRGainGreen_v11_5 = 0x48474772, + bmdDeckLinkFrameMetadataCintelHDRGainBlue_v11_5 = 0x4847426c, + bmdDeckLinkFrameMetadataCintel16mmCropRequired_v11_5 = 0x63313663, + bmdDeckLinkFrameMetadataCintelInversionRequired_v11_5 = 0x63696e76, + bmdDeckLinkFrameMetadataCintelFlipRequired_v11_5 = 0x63666c72, + bmdDeckLinkFrameMetadataCintelFocusAssistEnabled_v11_5 = 0x63666165, + bmdDeckLinkFrameMetadataCintelKeykodeIsInterpolated_v11_5 = 0x6b6b6969 + } BMDDeckLinkFrameMetadataID_v11_5; + + +typedef /* [v1_enum] */ +enum _BMDDeckLinkAttributeID_v10_6 + { + BMDDeckLinkSupportsDesktopDisplay_v10_6 = 0x65787464 + } BMDDeckLinkAttributeID_v10_6; + +typedef /* [v1_enum] */ +enum _BMDIdleVideoOutputOperation_v10_6 + { + bmdIdleVideoOutputDesktop_v10_6 = 0x6465736b + } BMDIdleVideoOutputOperation_v10_6; + +typedef /* [v1_enum] */ +enum _BMDDeckLinkAttributeID_v10_5 + { + BMDDeckLinkDeviceBusyState_v10_5 = 0x64627374 + } BMDDeckLinkAttributeID_v10_5; + + + +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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkTimecode * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkTimecode * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkTimecode * This); + + DECLSPEC_XFGVIRT(IDeckLinkTimecode, GetBCD) + BMDTimecodeBCD ( STDMETHODCALLTYPE *GetBCD )( + IDeckLinkTimecode * This); + + DECLSPEC_XFGVIRT(IDeckLinkTimecode, GetComponents) + HRESULT ( STDMETHODCALLTYPE *GetComponents )( + IDeckLinkTimecode * This, + /* [out] */ unsigned char *hours, + /* [out] */ unsigned char *minutes, + /* [out] */ unsigned char *seconds, + /* [out] */ unsigned char *frames); + + DECLSPEC_XFGVIRT(IDeckLinkTimecode, GetString) + HRESULT ( STDMETHODCALLTYPE *GetString )( + IDeckLinkTimecode * This, + /* [out] */ BSTR *timecode); + + DECLSPEC_XFGVIRT(IDeckLinkTimecode, GetFlags) + BMDTimecodeFlags ( STDMETHODCALLTYPE *GetFlags )( + IDeckLinkTimecode * This); + + DECLSPEC_XFGVIRT(IDeckLinkTimecode, GetTimecodeUserBits) + 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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkDisplayModeIterator * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkDisplayModeIterator * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkDisplayModeIterator * This); + + DECLSPEC_XFGVIRT(IDeckLinkDisplayModeIterator, Next) + 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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkDisplayMode * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkDisplayMode * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkDisplayMode * This); + + DECLSPEC_XFGVIRT(IDeckLinkDisplayMode, GetName) + HRESULT ( STDMETHODCALLTYPE *GetName )( + IDeckLinkDisplayMode * This, + /* [out] */ BSTR *name); + + DECLSPEC_XFGVIRT(IDeckLinkDisplayMode, GetDisplayMode) + BMDDisplayMode ( STDMETHODCALLTYPE *GetDisplayMode )( + IDeckLinkDisplayMode * This); + + DECLSPEC_XFGVIRT(IDeckLinkDisplayMode, GetWidth) + long ( STDMETHODCALLTYPE *GetWidth )( + IDeckLinkDisplayMode * This); + + DECLSPEC_XFGVIRT(IDeckLinkDisplayMode, GetHeight) + long ( STDMETHODCALLTYPE *GetHeight )( + IDeckLinkDisplayMode * This); + + DECLSPEC_XFGVIRT(IDeckLinkDisplayMode, GetFrameRate) + HRESULT ( STDMETHODCALLTYPE *GetFrameRate )( + IDeckLinkDisplayMode * This, + /* [out] */ BMDTimeValue *frameDuration, + /* [out] */ BMDTimeScale *timeScale); + + DECLSPEC_XFGVIRT(IDeckLinkDisplayMode, GetFieldDominance) + BMDFieldDominance ( STDMETHODCALLTYPE *GetFieldDominance )( + IDeckLinkDisplayMode * This); + + DECLSPEC_XFGVIRT(IDeckLinkDisplayMode, GetFlags) + 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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLink * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLink * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLink * This); + + DECLSPEC_XFGVIRT(IDeckLink, GetModelName) + HRESULT ( STDMETHODCALLTYPE *GetModelName )( + IDeckLink * This, + /* [out] */ BSTR *modelName); + + DECLSPEC_XFGVIRT(IDeckLink, GetDisplayName) + 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("5a68ffd4-1c12-4ede-a6d2-45451d385fc1") + 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 SetFlagWithParam( + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ ULONGLONG param, + /* [in] */ BOOL value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFlagWithParam( + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ ULONGLONG param, + /* [out] */ BOOL *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetIntWithParam( + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ ULONGLONG param, + /* [in] */ LONGLONG value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetIntWithParam( + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ ULONGLONG param, + /* [out] */ LONGLONG *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetFloatWithParam( + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ ULONGLONG param, + /* [in] */ double value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFloatWithParam( + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ ULONGLONG param, + /* [out] */ double *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetStringWithParam( + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ ULONGLONG param, + /* [in] */ BSTR value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStringWithParam( + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ ULONGLONG param, + /* [out] */ BSTR *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE WriteConfigurationToPreferences( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkConfigurationVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkConfiguration * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkConfiguration * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkConfiguration * This); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration, SetFlag) + HRESULT ( STDMETHODCALLTYPE *SetFlag )( + IDeckLinkConfiguration * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ BOOL value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration, GetFlag) + HRESULT ( STDMETHODCALLTYPE *GetFlag )( + IDeckLinkConfiguration * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ BOOL *value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration, SetInt) + HRESULT ( STDMETHODCALLTYPE *SetInt )( + IDeckLinkConfiguration * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ LONGLONG value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration, GetInt) + HRESULT ( STDMETHODCALLTYPE *GetInt )( + IDeckLinkConfiguration * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ LONGLONG *value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration, SetFloat) + HRESULT ( STDMETHODCALLTYPE *SetFloat )( + IDeckLinkConfiguration * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ double value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration, GetFloat) + HRESULT ( STDMETHODCALLTYPE *GetFloat )( + IDeckLinkConfiguration * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ double *value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration, SetString) + HRESULT ( STDMETHODCALLTYPE *SetString )( + IDeckLinkConfiguration * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ BSTR value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration, GetString) + HRESULT ( STDMETHODCALLTYPE *GetString )( + IDeckLinkConfiguration * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ BSTR *value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration, SetFlagWithParam) + HRESULT ( STDMETHODCALLTYPE *SetFlagWithParam )( + IDeckLinkConfiguration * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ ULONGLONG param, + /* [in] */ BOOL value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration, GetFlagWithParam) + HRESULT ( STDMETHODCALLTYPE *GetFlagWithParam )( + IDeckLinkConfiguration * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ ULONGLONG param, + /* [out] */ BOOL *value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration, SetIntWithParam) + HRESULT ( STDMETHODCALLTYPE *SetIntWithParam )( + IDeckLinkConfiguration * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ ULONGLONG param, + /* [in] */ LONGLONG value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration, GetIntWithParam) + HRESULT ( STDMETHODCALLTYPE *GetIntWithParam )( + IDeckLinkConfiguration * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ ULONGLONG param, + /* [out] */ LONGLONG *value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration, SetFloatWithParam) + HRESULT ( STDMETHODCALLTYPE *SetFloatWithParam )( + IDeckLinkConfiguration * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ ULONGLONG param, + /* [in] */ double value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration, GetFloatWithParam) + HRESULT ( STDMETHODCALLTYPE *GetFloatWithParam )( + IDeckLinkConfiguration * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ ULONGLONG param, + /* [out] */ double *value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration, SetStringWithParam) + HRESULT ( STDMETHODCALLTYPE *SetStringWithParam )( + IDeckLinkConfiguration * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ ULONGLONG param, + /* [in] */ BSTR value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration, GetStringWithParam) + HRESULT ( STDMETHODCALLTYPE *GetStringWithParam )( + IDeckLinkConfiguration * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ ULONGLONG param, + /* [out] */ BSTR *value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration, WriteConfigurationToPreferences) + 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_SetFlagWithParam(This,cfgID,param,value) \ + ( (This)->lpVtbl -> SetFlagWithParam(This,cfgID,param,value) ) + +#define IDeckLinkConfiguration_GetFlagWithParam(This,cfgID,param,value) \ + ( (This)->lpVtbl -> GetFlagWithParam(This,cfgID,param,value) ) + +#define IDeckLinkConfiguration_SetIntWithParam(This,cfgID,param,value) \ + ( (This)->lpVtbl -> SetIntWithParam(This,cfgID,param,value) ) + +#define IDeckLinkConfiguration_GetIntWithParam(This,cfgID,param,value) \ + ( (This)->lpVtbl -> GetIntWithParam(This,cfgID,param,value) ) + +#define IDeckLinkConfiguration_SetFloatWithParam(This,cfgID,param,value) \ + ( (This)->lpVtbl -> SetFloatWithParam(This,cfgID,param,value) ) + +#define IDeckLinkConfiguration_GetFloatWithParam(This,cfgID,param,value) \ + ( (This)->lpVtbl -> GetFloatWithParam(This,cfgID,param,value) ) + +#define IDeckLinkConfiguration_SetStringWithParam(This,cfgID,param,value) \ + ( (This)->lpVtbl -> SetStringWithParam(This,cfgID,param,value) ) + +#define IDeckLinkConfiguration_GetStringWithParam(This,cfgID,param,value) \ + ( (This)->lpVtbl -> GetStringWithParam(This,cfgID,param,value) ) + +#define IDeckLinkConfiguration_WriteConfigurationToPreferences(This) \ + ( (This)->lpVtbl -> WriteConfigurationToPreferences(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkConfiguration_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkEncoderConfiguration_INTERFACE_DEFINED__ +#define __IDeckLinkEncoderConfiguration_INTERFACE_DEFINED__ + +/* interface IDeckLinkEncoderConfiguration */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkEncoderConfiguration; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("138050E5-C60A-4552-BF3F-0F358049327E") + IDeckLinkEncoderConfiguration : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetFlag( + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [in] */ BOOL value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFlag( + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [out] */ BOOL *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetInt( + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [in] */ LONGLONG value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInt( + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [out] */ LONGLONG *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetFloat( + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [in] */ double value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFloat( + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [out] */ double *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetString( + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [in] */ BSTR value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetString( + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [out] */ BSTR *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBytes( + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [out] */ void *buffer, + /* [out][in] */ unsigned int *bufferSize) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkEncoderConfigurationVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkEncoderConfiguration * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkEncoderConfiguration * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkEncoderConfiguration * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderConfiguration, SetFlag) + HRESULT ( STDMETHODCALLTYPE *SetFlag )( + IDeckLinkEncoderConfiguration * This, + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [in] */ BOOL value); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderConfiguration, GetFlag) + HRESULT ( STDMETHODCALLTYPE *GetFlag )( + IDeckLinkEncoderConfiguration * This, + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [out] */ BOOL *value); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderConfiguration, SetInt) + HRESULT ( STDMETHODCALLTYPE *SetInt )( + IDeckLinkEncoderConfiguration * This, + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [in] */ LONGLONG value); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderConfiguration, GetInt) + HRESULT ( STDMETHODCALLTYPE *GetInt )( + IDeckLinkEncoderConfiguration * This, + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [out] */ LONGLONG *value); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderConfiguration, SetFloat) + HRESULT ( STDMETHODCALLTYPE *SetFloat )( + IDeckLinkEncoderConfiguration * This, + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [in] */ double value); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderConfiguration, GetFloat) + HRESULT ( STDMETHODCALLTYPE *GetFloat )( + IDeckLinkEncoderConfiguration * This, + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [out] */ double *value); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderConfiguration, SetString) + HRESULT ( STDMETHODCALLTYPE *SetString )( + IDeckLinkEncoderConfiguration * This, + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [in] */ BSTR value); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderConfiguration, GetString) + HRESULT ( STDMETHODCALLTYPE *GetString )( + IDeckLinkEncoderConfiguration * This, + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [out] */ BSTR *value); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderConfiguration, GetBytes) + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IDeckLinkEncoderConfiguration * This, + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [out] */ void *buffer, + /* [out][in] */ unsigned int *bufferSize); + + END_INTERFACE + } IDeckLinkEncoderConfigurationVtbl; + + interface IDeckLinkEncoderConfiguration + { + CONST_VTBL struct IDeckLinkEncoderConfigurationVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkEncoderConfiguration_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkEncoderConfiguration_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkEncoderConfiguration_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkEncoderConfiguration_SetFlag(This,cfgID,value) \ + ( (This)->lpVtbl -> SetFlag(This,cfgID,value) ) + +#define IDeckLinkEncoderConfiguration_GetFlag(This,cfgID,value) \ + ( (This)->lpVtbl -> GetFlag(This,cfgID,value) ) + +#define IDeckLinkEncoderConfiguration_SetInt(This,cfgID,value) \ + ( (This)->lpVtbl -> SetInt(This,cfgID,value) ) + +#define IDeckLinkEncoderConfiguration_GetInt(This,cfgID,value) \ + ( (This)->lpVtbl -> GetInt(This,cfgID,value) ) + +#define IDeckLinkEncoderConfiguration_SetFloat(This,cfgID,value) \ + ( (This)->lpVtbl -> SetFloat(This,cfgID,value) ) + +#define IDeckLinkEncoderConfiguration_GetFloat(This,cfgID,value) \ + ( (This)->lpVtbl -> GetFloat(This,cfgID,value) ) + +#define IDeckLinkEncoderConfiguration_SetString(This,cfgID,value) \ + ( (This)->lpVtbl -> SetString(This,cfgID,value) ) + +#define IDeckLinkEncoderConfiguration_GetString(This,cfgID,value) \ + ( (This)->lpVtbl -> GetString(This,cfgID,value) ) + +#define IDeckLinkEncoderConfiguration_GetBytes(This,cfgID,buffer,bufferSize) \ + ( (This)->lpVtbl -> GetBytes(This,cfgID,buffer,bufferSize) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkEncoderConfiguration_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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkDeckControlStatusCallback * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkDeckControlStatusCallback * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkDeckControlStatusCallback * This); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControlStatusCallback, TimecodeUpdate) + HRESULT ( STDMETHODCALLTYPE *TimecodeUpdate )( + IDeckLinkDeckControlStatusCallback * This, + /* [in] */ BMDTimecodeBCD currentTimecode); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControlStatusCallback, VTRControlStateChanged) + HRESULT ( STDMETHODCALLTYPE *VTRControlStateChanged )( + IDeckLinkDeckControlStatusCallback * This, + /* [in] */ BMDDeckControlVTRControlState newState, + /* [in] */ BMDDeckControlError error); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControlStatusCallback, DeckControlEventReceived) + HRESULT ( STDMETHODCALLTYPE *DeckControlEventReceived )( + IDeckLinkDeckControlStatusCallback * This, + /* [in] */ BMDDeckControlEvent event, + /* [in] */ BMDDeckControlError error); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControlStatusCallback, DeckControlStatusChanged) + 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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkDeckControl * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkDeckControl * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkDeckControl * This); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, Open) + HRESULT ( STDMETHODCALLTYPE *Open )( + IDeckLinkDeckControl * This, + /* [in] */ BMDTimeScale timeScale, + /* [in] */ BMDTimeValue timeValue, + /* [in] */ BOOL timecodeIsDropFrame, + /* [out] */ BMDDeckControlError *error); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, Close) + HRESULT ( STDMETHODCALLTYPE *Close )( + IDeckLinkDeckControl * This, + /* [in] */ BOOL standbyOn); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, GetCurrentState) + HRESULT ( STDMETHODCALLTYPE *GetCurrentState )( + IDeckLinkDeckControl * This, + /* [out] */ BMDDeckControlMode *mode, + /* [out] */ BMDDeckControlVTRControlState *vtrControlState, + /* [out] */ BMDDeckControlStatusFlags *flags); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, SetStandby) + HRESULT ( STDMETHODCALLTYPE *SetStandby )( + IDeckLinkDeckControl * This, + /* [in] */ BOOL standbyOn); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, SendCommand) + 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); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, Play) + HRESULT ( STDMETHODCALLTYPE *Play )( + IDeckLinkDeckControl * This, + /* [out] */ BMDDeckControlError *error); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, Stop) + HRESULT ( STDMETHODCALLTYPE *Stop )( + IDeckLinkDeckControl * This, + /* [out] */ BMDDeckControlError *error); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, TogglePlayStop) + HRESULT ( STDMETHODCALLTYPE *TogglePlayStop )( + IDeckLinkDeckControl * This, + /* [out] */ BMDDeckControlError *error); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, Eject) + HRESULT ( STDMETHODCALLTYPE *Eject )( + IDeckLinkDeckControl * This, + /* [out] */ BMDDeckControlError *error); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, GoToTimecode) + HRESULT ( STDMETHODCALLTYPE *GoToTimecode )( + IDeckLinkDeckControl * This, + /* [in] */ BMDTimecodeBCD timecode, + /* [out] */ BMDDeckControlError *error); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, FastForward) + HRESULT ( STDMETHODCALLTYPE *FastForward )( + IDeckLinkDeckControl * This, + /* [in] */ BOOL viewTape, + /* [out] */ BMDDeckControlError *error); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, Rewind) + HRESULT ( STDMETHODCALLTYPE *Rewind )( + IDeckLinkDeckControl * This, + /* [in] */ BOOL viewTape, + /* [out] */ BMDDeckControlError *error); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, StepForward) + HRESULT ( STDMETHODCALLTYPE *StepForward )( + IDeckLinkDeckControl * This, + /* [out] */ BMDDeckControlError *error); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, StepBack) + HRESULT ( STDMETHODCALLTYPE *StepBack )( + IDeckLinkDeckControl * This, + /* [out] */ BMDDeckControlError *error); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, Jog) + HRESULT ( STDMETHODCALLTYPE *Jog )( + IDeckLinkDeckControl * This, + /* [in] */ double rate, + /* [out] */ BMDDeckControlError *error); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, Shuttle) + HRESULT ( STDMETHODCALLTYPE *Shuttle )( + IDeckLinkDeckControl * This, + /* [in] */ double rate, + /* [out] */ BMDDeckControlError *error); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, GetTimecodeString) + HRESULT ( STDMETHODCALLTYPE *GetTimecodeString )( + IDeckLinkDeckControl * This, + /* [out] */ BSTR *currentTimeCode, + /* [out] */ BMDDeckControlError *error); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, GetTimecode) + HRESULT ( STDMETHODCALLTYPE *GetTimecode )( + IDeckLinkDeckControl * This, + /* [out] */ IDeckLinkTimecode **currentTimecode, + /* [out] */ BMDDeckControlError *error); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, GetTimecodeBCD) + HRESULT ( STDMETHODCALLTYPE *GetTimecodeBCD )( + IDeckLinkDeckControl * This, + /* [out] */ BMDTimecodeBCD *currentTimecode, + /* [out] */ BMDDeckControlError *error); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, SetPreroll) + HRESULT ( STDMETHODCALLTYPE *SetPreroll )( + IDeckLinkDeckControl * This, + /* [in] */ unsigned int prerollSeconds); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, GetPreroll) + HRESULT ( STDMETHODCALLTYPE *GetPreroll )( + IDeckLinkDeckControl * This, + /* [out] */ unsigned int *prerollSeconds); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, SetExportOffset) + HRESULT ( STDMETHODCALLTYPE *SetExportOffset )( + IDeckLinkDeckControl * This, + /* [in] */ int exportOffsetFields); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, GetExportOffset) + HRESULT ( STDMETHODCALLTYPE *GetExportOffset )( + IDeckLinkDeckControl * This, + /* [out] */ int *exportOffsetFields); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, GetManualExportOffset) + HRESULT ( STDMETHODCALLTYPE *GetManualExportOffset )( + IDeckLinkDeckControl * This, + /* [out] */ int *deckManualExportOffsetFields); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, SetCaptureOffset) + HRESULT ( STDMETHODCALLTYPE *SetCaptureOffset )( + IDeckLinkDeckControl * This, + /* [in] */ int captureOffsetFields); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, GetCaptureOffset) + HRESULT ( STDMETHODCALLTYPE *GetCaptureOffset )( + IDeckLinkDeckControl * This, + /* [out] */ int *captureOffsetFields); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, StartExport) + HRESULT ( STDMETHODCALLTYPE *StartExport )( + IDeckLinkDeckControl * This, + /* [in] */ BMDTimecodeBCD inTimecode, + /* [in] */ BMDTimecodeBCD outTimecode, + /* [in] */ BMDDeckControlExportModeOpsFlags exportModeOps, + /* [out] */ BMDDeckControlError *error); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, StartCapture) + HRESULT ( STDMETHODCALLTYPE *StartCapture )( + IDeckLinkDeckControl * This, + /* [in] */ BOOL useVITC, + /* [in] */ BMDTimecodeBCD inTimecode, + /* [in] */ BMDTimecodeBCD outTimecode, + /* [out] */ BMDDeckControlError *error); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, GetDeviceID) + HRESULT ( STDMETHODCALLTYPE *GetDeviceID )( + IDeckLinkDeckControl * This, + /* [out] */ unsigned short *deviceId, + /* [out] */ BMDDeckControlError *error); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, Abort) + HRESULT ( STDMETHODCALLTYPE *Abort )( + IDeckLinkDeckControl * This); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, CrashRecordStart) + HRESULT ( STDMETHODCALLTYPE *CrashRecordStart )( + IDeckLinkDeckControl * This, + /* [out] */ BMDDeckControlError *error); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, CrashRecordStop) + HRESULT ( STDMETHODCALLTYPE *CrashRecordStop )( + IDeckLinkDeckControl * This, + /* [out] */ BMDDeckControlError *error); + + DECLSPEC_XFGVIRT(IDeckLinkDeckControl, SetCallback) + 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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IBMDStreamingDeviceNotificationCallback * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IBMDStreamingDeviceNotificationCallback * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IBMDStreamingDeviceNotificationCallback * This); + + DECLSPEC_XFGVIRT(IBMDStreamingDeviceNotificationCallback, StreamingDeviceArrived) + HRESULT ( STDMETHODCALLTYPE *StreamingDeviceArrived )( + IBMDStreamingDeviceNotificationCallback * This, + /* [in] */ IDeckLink *device); + + DECLSPEC_XFGVIRT(IBMDStreamingDeviceNotificationCallback, StreamingDeviceRemoved) + HRESULT ( STDMETHODCALLTYPE *StreamingDeviceRemoved )( + IBMDStreamingDeviceNotificationCallback * This, + /* [in] */ IDeckLink *device); + + DECLSPEC_XFGVIRT(IBMDStreamingDeviceNotificationCallback, StreamingDeviceModeChanged) + 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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IBMDStreamingH264InputCallback * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IBMDStreamingH264InputCallback * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IBMDStreamingH264InputCallback * This); + + DECLSPEC_XFGVIRT(IBMDStreamingH264InputCallback, H264NALPacketArrived) + HRESULT ( STDMETHODCALLTYPE *H264NALPacketArrived )( + IBMDStreamingH264InputCallback * This, + /* [in] */ IBMDStreamingH264NALPacket *nalPacket); + + DECLSPEC_XFGVIRT(IBMDStreamingH264InputCallback, H264AudioPacketArrived) + HRESULT ( STDMETHODCALLTYPE *H264AudioPacketArrived )( + IBMDStreamingH264InputCallback * This, + /* [in] */ IBMDStreamingAudioPacket *audioPacket); + + DECLSPEC_XFGVIRT(IBMDStreamingH264InputCallback, MPEG2TSPacketArrived) + HRESULT ( STDMETHODCALLTYPE *MPEG2TSPacketArrived )( + IBMDStreamingH264InputCallback * This, + /* [in] */ IBMDStreamingMPEG2TSPacket *tsPacket); + + DECLSPEC_XFGVIRT(IBMDStreamingH264InputCallback, H264VideoInputConnectorScanningChanged) + HRESULT ( STDMETHODCALLTYPE *H264VideoInputConnectorScanningChanged )( + IBMDStreamingH264InputCallback * This); + + DECLSPEC_XFGVIRT(IBMDStreamingH264InputCallback, H264VideoInputConnectorChanged) + HRESULT ( STDMETHODCALLTYPE *H264VideoInputConnectorChanged )( + IBMDStreamingH264InputCallback * This); + + DECLSPEC_XFGVIRT(IBMDStreamingH264InputCallback, H264VideoInputModeChanged) + 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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IBMDStreamingDiscovery * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IBMDStreamingDiscovery * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IBMDStreamingDiscovery * This); + + DECLSPEC_XFGVIRT(IBMDStreamingDiscovery, InstallDeviceNotifications) + HRESULT ( STDMETHODCALLTYPE *InstallDeviceNotifications )( + IBMDStreamingDiscovery * This, + /* [in] */ IBMDStreamingDeviceNotificationCallback *theCallback); + + DECLSPEC_XFGVIRT(IBMDStreamingDiscovery, UninstallDeviceNotifications) + 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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IBMDStreamingVideoEncodingMode * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IBMDStreamingVideoEncodingMode * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IBMDStreamingVideoEncodingMode * This); + + DECLSPEC_XFGVIRT(IBMDStreamingVideoEncodingMode, GetName) + HRESULT ( STDMETHODCALLTYPE *GetName )( + IBMDStreamingVideoEncodingMode * This, + /* [out] */ BSTR *name); + + DECLSPEC_XFGVIRT(IBMDStreamingVideoEncodingMode, GetPresetID) + unsigned int ( STDMETHODCALLTYPE *GetPresetID )( + IBMDStreamingVideoEncodingMode * This); + + DECLSPEC_XFGVIRT(IBMDStreamingVideoEncodingMode, GetSourcePositionX) + unsigned int ( STDMETHODCALLTYPE *GetSourcePositionX )( + IBMDStreamingVideoEncodingMode * This); + + DECLSPEC_XFGVIRT(IBMDStreamingVideoEncodingMode, GetSourcePositionY) + unsigned int ( STDMETHODCALLTYPE *GetSourcePositionY )( + IBMDStreamingVideoEncodingMode * This); + + DECLSPEC_XFGVIRT(IBMDStreamingVideoEncodingMode, GetSourceWidth) + unsigned int ( STDMETHODCALLTYPE *GetSourceWidth )( + IBMDStreamingVideoEncodingMode * This); + + DECLSPEC_XFGVIRT(IBMDStreamingVideoEncodingMode, GetSourceHeight) + unsigned int ( STDMETHODCALLTYPE *GetSourceHeight )( + IBMDStreamingVideoEncodingMode * This); + + DECLSPEC_XFGVIRT(IBMDStreamingVideoEncodingMode, GetDestWidth) + unsigned int ( STDMETHODCALLTYPE *GetDestWidth )( + IBMDStreamingVideoEncodingMode * This); + + DECLSPEC_XFGVIRT(IBMDStreamingVideoEncodingMode, GetDestHeight) + unsigned int ( STDMETHODCALLTYPE *GetDestHeight )( + IBMDStreamingVideoEncodingMode * This); + + DECLSPEC_XFGVIRT(IBMDStreamingVideoEncodingMode, GetFlag) + HRESULT ( STDMETHODCALLTYPE *GetFlag )( + IBMDStreamingVideoEncodingMode * This, + /* [in] */ BMDStreamingEncodingModePropertyID cfgID, + /* [out] */ BOOL *value); + + DECLSPEC_XFGVIRT(IBMDStreamingVideoEncodingMode, GetInt) + HRESULT ( STDMETHODCALLTYPE *GetInt )( + IBMDStreamingVideoEncodingMode * This, + /* [in] */ BMDStreamingEncodingModePropertyID cfgID, + /* [out] */ LONGLONG *value); + + DECLSPEC_XFGVIRT(IBMDStreamingVideoEncodingMode, GetFloat) + HRESULT ( STDMETHODCALLTYPE *GetFloat )( + IBMDStreamingVideoEncodingMode * This, + /* [in] */ BMDStreamingEncodingModePropertyID cfgID, + /* [out] */ double *value); + + DECLSPEC_XFGVIRT(IBMDStreamingVideoEncodingMode, GetString) + HRESULT ( STDMETHODCALLTYPE *GetString )( + IBMDStreamingVideoEncodingMode * This, + /* [in] */ BMDStreamingEncodingModePropertyID cfgID, + /* [out] */ BSTR *value); + + DECLSPEC_XFGVIRT(IBMDStreamingVideoEncodingMode, CreateMutableVideoEncodingMode) + 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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IBMDStreamingMutableVideoEncodingMode * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IBMDStreamingMutableVideoEncodingMode * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IBMDStreamingMutableVideoEncodingMode * This); + + DECLSPEC_XFGVIRT(IBMDStreamingVideoEncodingMode, GetName) + HRESULT ( STDMETHODCALLTYPE *GetName )( + IBMDStreamingMutableVideoEncodingMode * This, + /* [out] */ BSTR *name); + + DECLSPEC_XFGVIRT(IBMDStreamingVideoEncodingMode, GetPresetID) + unsigned int ( STDMETHODCALLTYPE *GetPresetID )( + IBMDStreamingMutableVideoEncodingMode * This); + + DECLSPEC_XFGVIRT(IBMDStreamingVideoEncodingMode, GetSourcePositionX) + unsigned int ( STDMETHODCALLTYPE *GetSourcePositionX )( + IBMDStreamingMutableVideoEncodingMode * This); + + DECLSPEC_XFGVIRT(IBMDStreamingVideoEncodingMode, GetSourcePositionY) + unsigned int ( STDMETHODCALLTYPE *GetSourcePositionY )( + IBMDStreamingMutableVideoEncodingMode * This); + + DECLSPEC_XFGVIRT(IBMDStreamingVideoEncodingMode, GetSourceWidth) + unsigned int ( STDMETHODCALLTYPE *GetSourceWidth )( + IBMDStreamingMutableVideoEncodingMode * This); + + DECLSPEC_XFGVIRT(IBMDStreamingVideoEncodingMode, GetSourceHeight) + unsigned int ( STDMETHODCALLTYPE *GetSourceHeight )( + IBMDStreamingMutableVideoEncodingMode * This); + + DECLSPEC_XFGVIRT(IBMDStreamingVideoEncodingMode, GetDestWidth) + unsigned int ( STDMETHODCALLTYPE *GetDestWidth )( + IBMDStreamingMutableVideoEncodingMode * This); + + DECLSPEC_XFGVIRT(IBMDStreamingVideoEncodingMode, GetDestHeight) + unsigned int ( STDMETHODCALLTYPE *GetDestHeight )( + IBMDStreamingMutableVideoEncodingMode * This); + + DECLSPEC_XFGVIRT(IBMDStreamingVideoEncodingMode, GetFlag) + HRESULT ( STDMETHODCALLTYPE *GetFlag )( + IBMDStreamingMutableVideoEncodingMode * This, + /* [in] */ BMDStreamingEncodingModePropertyID cfgID, + /* [out] */ BOOL *value); + + DECLSPEC_XFGVIRT(IBMDStreamingVideoEncodingMode, GetInt) + HRESULT ( STDMETHODCALLTYPE *GetInt )( + IBMDStreamingMutableVideoEncodingMode * This, + /* [in] */ BMDStreamingEncodingModePropertyID cfgID, + /* [out] */ LONGLONG *value); + + DECLSPEC_XFGVIRT(IBMDStreamingVideoEncodingMode, GetFloat) + HRESULT ( STDMETHODCALLTYPE *GetFloat )( + IBMDStreamingMutableVideoEncodingMode * This, + /* [in] */ BMDStreamingEncodingModePropertyID cfgID, + /* [out] */ double *value); + + DECLSPEC_XFGVIRT(IBMDStreamingVideoEncodingMode, GetString) + HRESULT ( STDMETHODCALLTYPE *GetString )( + IBMDStreamingMutableVideoEncodingMode * This, + /* [in] */ BMDStreamingEncodingModePropertyID cfgID, + /* [out] */ BSTR *value); + + DECLSPEC_XFGVIRT(IBMDStreamingVideoEncodingMode, CreateMutableVideoEncodingMode) + HRESULT ( STDMETHODCALLTYPE *CreateMutableVideoEncodingMode )( + IBMDStreamingMutableVideoEncodingMode * This, + /* [out] */ IBMDStreamingMutableVideoEncodingMode **newEncodingMode); + + DECLSPEC_XFGVIRT(IBMDStreamingMutableVideoEncodingMode, SetSourceRect) + HRESULT ( STDMETHODCALLTYPE *SetSourceRect )( + IBMDStreamingMutableVideoEncodingMode * This, + /* [in] */ unsigned int posX, + /* [in] */ unsigned int posY, + /* [in] */ unsigned int width, + /* [in] */ unsigned int height); + + DECLSPEC_XFGVIRT(IBMDStreamingMutableVideoEncodingMode, SetDestSize) + HRESULT ( STDMETHODCALLTYPE *SetDestSize )( + IBMDStreamingMutableVideoEncodingMode * This, + /* [in] */ unsigned int width, + /* [in] */ unsigned int height); + + DECLSPEC_XFGVIRT(IBMDStreamingMutableVideoEncodingMode, SetFlag) + HRESULT ( STDMETHODCALLTYPE *SetFlag )( + IBMDStreamingMutableVideoEncodingMode * This, + /* [in] */ BMDStreamingEncodingModePropertyID cfgID, + /* [in] */ BOOL value); + + DECLSPEC_XFGVIRT(IBMDStreamingMutableVideoEncodingMode, SetInt) + HRESULT ( STDMETHODCALLTYPE *SetInt )( + IBMDStreamingMutableVideoEncodingMode * This, + /* [in] */ BMDStreamingEncodingModePropertyID cfgID, + /* [in] */ LONGLONG value); + + DECLSPEC_XFGVIRT(IBMDStreamingMutableVideoEncodingMode, SetFloat) + HRESULT ( STDMETHODCALLTYPE *SetFloat )( + IBMDStreamingMutableVideoEncodingMode * This, + /* [in] */ BMDStreamingEncodingModePropertyID cfgID, + /* [in] */ double value); + + DECLSPEC_XFGVIRT(IBMDStreamingMutableVideoEncodingMode, SetString) + 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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IBMDStreamingVideoEncodingModePresetIterator * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IBMDStreamingVideoEncodingModePresetIterator * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IBMDStreamingVideoEncodingModePresetIterator * This); + + DECLSPEC_XFGVIRT(IBMDStreamingVideoEncodingModePresetIterator, Next) + 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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IBMDStreamingDeviceInput * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IBMDStreamingDeviceInput * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IBMDStreamingDeviceInput * This); + + DECLSPEC_XFGVIRT(IBMDStreamingDeviceInput, DoesSupportVideoInputMode) + HRESULT ( STDMETHODCALLTYPE *DoesSupportVideoInputMode )( + IBMDStreamingDeviceInput * This, + /* [in] */ BMDDisplayMode inputMode, + /* [out] */ BOOL *result); + + DECLSPEC_XFGVIRT(IBMDStreamingDeviceInput, GetVideoInputModeIterator) + HRESULT ( STDMETHODCALLTYPE *GetVideoInputModeIterator )( + IBMDStreamingDeviceInput * This, + /* [out] */ IDeckLinkDisplayModeIterator **iterator); + + DECLSPEC_XFGVIRT(IBMDStreamingDeviceInput, SetVideoInputMode) + HRESULT ( STDMETHODCALLTYPE *SetVideoInputMode )( + IBMDStreamingDeviceInput * This, + /* [in] */ BMDDisplayMode inputMode); + + DECLSPEC_XFGVIRT(IBMDStreamingDeviceInput, GetCurrentDetectedVideoInputMode) + HRESULT ( STDMETHODCALLTYPE *GetCurrentDetectedVideoInputMode )( + IBMDStreamingDeviceInput * This, + /* [out] */ BMDDisplayMode *detectedMode); + + DECLSPEC_XFGVIRT(IBMDStreamingDeviceInput, GetVideoEncodingMode) + HRESULT ( STDMETHODCALLTYPE *GetVideoEncodingMode )( + IBMDStreamingDeviceInput * This, + /* [out] */ IBMDStreamingVideoEncodingMode **encodingMode); + + DECLSPEC_XFGVIRT(IBMDStreamingDeviceInput, GetVideoEncodingModePresetIterator) + HRESULT ( STDMETHODCALLTYPE *GetVideoEncodingModePresetIterator )( + IBMDStreamingDeviceInput * This, + /* [in] */ BMDDisplayMode inputMode, + /* [out] */ IBMDStreamingVideoEncodingModePresetIterator **iterator); + + DECLSPEC_XFGVIRT(IBMDStreamingDeviceInput, DoesSupportVideoEncodingMode) + HRESULT ( STDMETHODCALLTYPE *DoesSupportVideoEncodingMode )( + IBMDStreamingDeviceInput * This, + /* [in] */ BMDDisplayMode inputMode, + /* [in] */ IBMDStreamingVideoEncodingMode *encodingMode, + /* [out] */ BMDStreamingEncodingSupport *result, + /* [out] */ IBMDStreamingVideoEncodingMode **changedEncodingMode); + + DECLSPEC_XFGVIRT(IBMDStreamingDeviceInput, SetVideoEncodingMode) + HRESULT ( STDMETHODCALLTYPE *SetVideoEncodingMode )( + IBMDStreamingDeviceInput * This, + /* [in] */ IBMDStreamingVideoEncodingMode *encodingMode); + + DECLSPEC_XFGVIRT(IBMDStreamingDeviceInput, StartCapture) + HRESULT ( STDMETHODCALLTYPE *StartCapture )( + IBMDStreamingDeviceInput * This); + + DECLSPEC_XFGVIRT(IBMDStreamingDeviceInput, StopCapture) + HRESULT ( STDMETHODCALLTYPE *StopCapture )( + IBMDStreamingDeviceInput * This); + + DECLSPEC_XFGVIRT(IBMDStreamingDeviceInput, SetCallback) + 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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IBMDStreamingH264NALPacket * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IBMDStreamingH264NALPacket * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IBMDStreamingH264NALPacket * This); + + DECLSPEC_XFGVIRT(IBMDStreamingH264NALPacket, GetPayloadSize) + long ( STDMETHODCALLTYPE *GetPayloadSize )( + IBMDStreamingH264NALPacket * This); + + DECLSPEC_XFGVIRT(IBMDStreamingH264NALPacket, GetBytes) + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IBMDStreamingH264NALPacket * This, + /* [out] */ void **buffer); + + DECLSPEC_XFGVIRT(IBMDStreamingH264NALPacket, GetBytesWithSizePrefix) + HRESULT ( STDMETHODCALLTYPE *GetBytesWithSizePrefix )( + IBMDStreamingH264NALPacket * This, + /* [out] */ void **buffer); + + DECLSPEC_XFGVIRT(IBMDStreamingH264NALPacket, GetDisplayTime) + HRESULT ( STDMETHODCALLTYPE *GetDisplayTime )( + IBMDStreamingH264NALPacket * This, + /* [in] */ ULONGLONG requestedTimeScale, + /* [out] */ ULONGLONG *displayTime); + + DECLSPEC_XFGVIRT(IBMDStreamingH264NALPacket, GetPacketIndex) + 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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IBMDStreamingAudioPacket * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IBMDStreamingAudioPacket * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IBMDStreamingAudioPacket * This); + + DECLSPEC_XFGVIRT(IBMDStreamingAudioPacket, GetCodec) + BMDStreamingAudioCodec ( STDMETHODCALLTYPE *GetCodec )( + IBMDStreamingAudioPacket * This); + + DECLSPEC_XFGVIRT(IBMDStreamingAudioPacket, GetPayloadSize) + long ( STDMETHODCALLTYPE *GetPayloadSize )( + IBMDStreamingAudioPacket * This); + + DECLSPEC_XFGVIRT(IBMDStreamingAudioPacket, GetBytes) + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IBMDStreamingAudioPacket * This, + /* [out] */ void **buffer); + + DECLSPEC_XFGVIRT(IBMDStreamingAudioPacket, GetPlayTime) + HRESULT ( STDMETHODCALLTYPE *GetPlayTime )( + IBMDStreamingAudioPacket * This, + /* [in] */ ULONGLONG requestedTimeScale, + /* [out] */ ULONGLONG *playTime); + + DECLSPEC_XFGVIRT(IBMDStreamingAudioPacket, GetPacketIndex) + 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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IBMDStreamingMPEG2TSPacket * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IBMDStreamingMPEG2TSPacket * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IBMDStreamingMPEG2TSPacket * This); + + DECLSPEC_XFGVIRT(IBMDStreamingMPEG2TSPacket, GetPayloadSize) + long ( STDMETHODCALLTYPE *GetPayloadSize )( + IBMDStreamingMPEG2TSPacket * This); + + DECLSPEC_XFGVIRT(IBMDStreamingMPEG2TSPacket, GetBytes) + 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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IBMDStreamingH264NALParser * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IBMDStreamingH264NALParser * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IBMDStreamingH264NALParser * This); + + DECLSPEC_XFGVIRT(IBMDStreamingH264NALParser, IsNALSequenceParameterSet) + HRESULT ( STDMETHODCALLTYPE *IsNALSequenceParameterSet )( + IBMDStreamingH264NALParser * This, + /* [in] */ IBMDStreamingH264NALPacket *nal); + + DECLSPEC_XFGVIRT(IBMDStreamingH264NALParser, IsNALPictureParameterSet) + HRESULT ( STDMETHODCALLTYPE *IsNALPictureParameterSet )( + IBMDStreamingH264NALParser * This, + /* [in] */ IBMDStreamingH264NALPacket *nal); + + DECLSPEC_XFGVIRT(IBMDStreamingH264NALParser, GetProfileAndLevelFromSPS) + 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("23A4EDF5-A0E5-432C-94EF-3BABB5F81C82") +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("5BE6DF26-02CE-433E-99D9-9A87C3AC171F") + 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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoOutputCallback * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoOutputCallback * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoOutputCallback * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoOutputCallback, ScheduledFrameCompleted) + HRESULT ( STDMETHODCALLTYPE *ScheduledFrameCompleted )( + IDeckLinkVideoOutputCallback * This, + /* [in] */ IDeckLinkVideoFrame *completedFrame, + /* [in] */ BMDOutputFrameCompletionResult result); + + DECLSPEC_XFGVIRT(IDeckLinkVideoOutputCallback, ScheduledPlaybackHasStopped) + 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("3A94F075-C37D-4BA8-BCC0-1D778C8F881B") + 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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkInputCallback * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkInputCallback * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkInputCallback * This); + + DECLSPEC_XFGVIRT(IDeckLinkInputCallback, VideoInputFormatChanged) + HRESULT ( STDMETHODCALLTYPE *VideoInputFormatChanged )( + IDeckLinkInputCallback * This, + /* [in] */ BMDVideoInputFormatChangedEvents notificationEvents, + /* [in] */ IDeckLinkDisplayMode *newDisplayMode, + /* [in] */ BMDDetectedVideoInputFormatFlags detectedSignalFlags); + + DECLSPEC_XFGVIRT(IDeckLinkInputCallback, VideoInputFrameArrived) + 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 __IDeckLinkEncoderInputCallback_INTERFACE_DEFINED__ +#define __IDeckLinkEncoderInputCallback_INTERFACE_DEFINED__ + +/* interface IDeckLinkEncoderInputCallback */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkEncoderInputCallback; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("ACF13E61-F4A0-4974-A6A7-59AFF6268B31") + IDeckLinkEncoderInputCallback : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE VideoInputSignalChanged( + /* [in] */ BMDVideoInputFormatChangedEvents notificationEvents, + /* [in] */ IDeckLinkDisplayMode *newDisplayMode, + /* [in] */ BMDDetectedVideoInputFormatFlags detectedSignalFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE VideoPacketArrived( + /* [in] */ IDeckLinkEncoderVideoPacket *videoPacket) = 0; + + virtual HRESULT STDMETHODCALLTYPE AudioPacketArrived( + /* [in] */ IDeckLinkEncoderAudioPacket *audioPacket) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkEncoderInputCallbackVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkEncoderInputCallback * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkEncoderInputCallback * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkEncoderInputCallback * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInputCallback, VideoInputSignalChanged) + HRESULT ( STDMETHODCALLTYPE *VideoInputSignalChanged )( + IDeckLinkEncoderInputCallback * This, + /* [in] */ BMDVideoInputFormatChangedEvents notificationEvents, + /* [in] */ IDeckLinkDisplayMode *newDisplayMode, + /* [in] */ BMDDetectedVideoInputFormatFlags detectedSignalFlags); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInputCallback, VideoPacketArrived) + HRESULT ( STDMETHODCALLTYPE *VideoPacketArrived )( + IDeckLinkEncoderInputCallback * This, + /* [in] */ IDeckLinkEncoderVideoPacket *videoPacket); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInputCallback, AudioPacketArrived) + HRESULT ( STDMETHODCALLTYPE *AudioPacketArrived )( + IDeckLinkEncoderInputCallback * This, + /* [in] */ IDeckLinkEncoderAudioPacket *audioPacket); + + END_INTERFACE + } IDeckLinkEncoderInputCallbackVtbl; + + interface IDeckLinkEncoderInputCallback + { + CONST_VTBL struct IDeckLinkEncoderInputCallbackVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkEncoderInputCallback_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkEncoderInputCallback_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkEncoderInputCallback_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkEncoderInputCallback_VideoInputSignalChanged(This,notificationEvents,newDisplayMode,detectedSignalFlags) \ + ( (This)->lpVtbl -> VideoInputSignalChanged(This,notificationEvents,newDisplayMode,detectedSignalFlags) ) + +#define IDeckLinkEncoderInputCallback_VideoPacketArrived(This,videoPacket) \ + ( (This)->lpVtbl -> VideoPacketArrived(This,videoPacket) ) + +#define IDeckLinkEncoderInputCallback_AudioPacketArrived(This,audioPacket) \ + ( (This)->lpVtbl -> AudioPacketArrived(This,audioPacket) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkEncoderInputCallback_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkVideoBufferAllocator_INTERFACE_DEFINED__ +#define __IDeckLinkVideoBufferAllocator_INTERFACE_DEFINED__ + +/* interface IDeckLinkVideoBufferAllocator */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkVideoBufferAllocator; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("F35DFA8D-9078-4622-95BB-56894054EB0F") + IDeckLinkVideoBufferAllocator : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE AllocateVideoBuffer( + /* [out] */ IDeckLinkVideoBuffer **allocatedBuffer) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkVideoBufferAllocatorVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoBufferAllocator * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoBufferAllocator * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoBufferAllocator * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoBufferAllocator, AllocateVideoBuffer) + HRESULT ( STDMETHODCALLTYPE *AllocateVideoBuffer )( + IDeckLinkVideoBufferAllocator * This, + /* [out] */ IDeckLinkVideoBuffer **allocatedBuffer); + + END_INTERFACE + } IDeckLinkVideoBufferAllocatorVtbl; + + interface IDeckLinkVideoBufferAllocator + { + CONST_VTBL struct IDeckLinkVideoBufferAllocatorVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkVideoBufferAllocator_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkVideoBufferAllocator_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkVideoBufferAllocator_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkVideoBufferAllocator_AllocateVideoBuffer(This,allocatedBuffer) \ + ( (This)->lpVtbl -> AllocateVideoBuffer(This,allocatedBuffer) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkVideoBufferAllocator_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkVideoBufferAllocatorProvider_INTERFACE_DEFINED__ +#define __IDeckLinkVideoBufferAllocatorProvider_INTERFACE_DEFINED__ + +/* interface IDeckLinkVideoBufferAllocatorProvider */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkVideoBufferAllocatorProvider; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("6DF6F20A-D8DF-45D2-8914-383CE7E6243F") + IDeckLinkVideoBufferAllocatorProvider : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetVideoBufferAllocator( + /* [in] */ unsigned int bufferSize, + /* [in] */ unsigned int width, + /* [in] */ unsigned int height, + /* [in] */ unsigned int rowBytes, + /* [in] */ BMDPixelFormat pixelFormat, + /* [out] */ IDeckLinkVideoBufferAllocator **allocator) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkVideoBufferAllocatorProviderVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoBufferAllocatorProvider * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoBufferAllocatorProvider * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoBufferAllocatorProvider * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoBufferAllocatorProvider, GetVideoBufferAllocator) + HRESULT ( STDMETHODCALLTYPE *GetVideoBufferAllocator )( + IDeckLinkVideoBufferAllocatorProvider * This, + /* [in] */ unsigned int bufferSize, + /* [in] */ unsigned int width, + /* [in] */ unsigned int height, + /* [in] */ unsigned int rowBytes, + /* [in] */ BMDPixelFormat pixelFormat, + /* [out] */ IDeckLinkVideoBufferAllocator **allocator); + + END_INTERFACE + } IDeckLinkVideoBufferAllocatorProviderVtbl; + + interface IDeckLinkVideoBufferAllocatorProvider + { + CONST_VTBL struct IDeckLinkVideoBufferAllocatorProviderVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkVideoBufferAllocatorProvider_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkVideoBufferAllocatorProvider_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkVideoBufferAllocatorProvider_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkVideoBufferAllocatorProvider_GetVideoBufferAllocator(This,bufferSize,width,height,rowBytes,pixelFormat,allocator) \ + ( (This)->lpVtbl -> GetVideoBufferAllocator(This,bufferSize,width,height,rowBytes,pixelFormat,allocator) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkVideoBufferAllocatorProvider_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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkAudioOutputCallback * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkAudioOutputCallback * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkAudioOutputCallback * This); + + DECLSPEC_XFGVIRT(IDeckLinkAudioOutputCallback, RenderAudioSamples) + 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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkIterator * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkIterator * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkIterator * This); + + DECLSPEC_XFGVIRT(IDeckLinkIterator, Next) + 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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkAPIInformation * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkAPIInformation * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkAPIInformation * This); + + DECLSPEC_XFGVIRT(IDeckLinkAPIInformation, GetFlag) + HRESULT ( STDMETHODCALLTYPE *GetFlag )( + IDeckLinkAPIInformation * This, + /* [in] */ BMDDeckLinkAPIInformationID cfgID, + /* [out] */ BOOL *value); + + DECLSPEC_XFGVIRT(IDeckLinkAPIInformation, GetInt) + HRESULT ( STDMETHODCALLTYPE *GetInt )( + IDeckLinkAPIInformation * This, + /* [in] */ BMDDeckLinkAPIInformationID cfgID, + /* [out] */ LONGLONG *value); + + DECLSPEC_XFGVIRT(IDeckLinkAPIInformation, GetFloat) + HRESULT ( STDMETHODCALLTYPE *GetFloat )( + IDeckLinkAPIInformation * This, + /* [in] */ BMDDeckLinkAPIInformationID cfgID, + /* [out] */ double *value); + + DECLSPEC_XFGVIRT(IDeckLinkAPIInformation, GetString) + 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 __IDeckLinkIPFlowAttributes_INTERFACE_DEFINED__ +#define __IDeckLinkIPFlowAttributes_INTERFACE_DEFINED__ + +/* interface IDeckLinkIPFlowAttributes */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkIPFlowAttributes; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("CDA938DA-6479-40C6-B2EC-A3579B3AEECD") + IDeckLinkIPFlowAttributes : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetInt( + /* [in] */ BMDDeckLinkIPFlowAttributeID attrID, + /* [out] */ LONGLONG *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFlag( + /* [in] */ BMDDeckLinkIPFlowAttributeID attrID, + /* [out] */ BOOL *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFloat( + /* [in] */ BMDDeckLinkIPFlowAttributeID attrID, + /* [out] */ double *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetString( + /* [in] */ BMDDeckLinkIPFlowAttributeID attrID, + /* [out] */ BSTR *value) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkIPFlowAttributesVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkIPFlowAttributes * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkIPFlowAttributes * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkIPFlowAttributes * This); + + DECLSPEC_XFGVIRT(IDeckLinkIPFlowAttributes, GetInt) + HRESULT ( STDMETHODCALLTYPE *GetInt )( + IDeckLinkIPFlowAttributes * This, + /* [in] */ BMDDeckLinkIPFlowAttributeID attrID, + /* [out] */ LONGLONG *value); + + DECLSPEC_XFGVIRT(IDeckLinkIPFlowAttributes, GetFlag) + HRESULT ( STDMETHODCALLTYPE *GetFlag )( + IDeckLinkIPFlowAttributes * This, + /* [in] */ BMDDeckLinkIPFlowAttributeID attrID, + /* [out] */ BOOL *value); + + DECLSPEC_XFGVIRT(IDeckLinkIPFlowAttributes, GetFloat) + HRESULT ( STDMETHODCALLTYPE *GetFloat )( + IDeckLinkIPFlowAttributes * This, + /* [in] */ BMDDeckLinkIPFlowAttributeID attrID, + /* [out] */ double *value); + + DECLSPEC_XFGVIRT(IDeckLinkIPFlowAttributes, GetString) + HRESULT ( STDMETHODCALLTYPE *GetString )( + IDeckLinkIPFlowAttributes * This, + /* [in] */ BMDDeckLinkIPFlowAttributeID attrID, + /* [out] */ BSTR *value); + + END_INTERFACE + } IDeckLinkIPFlowAttributesVtbl; + + interface IDeckLinkIPFlowAttributes + { + CONST_VTBL struct IDeckLinkIPFlowAttributesVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkIPFlowAttributes_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkIPFlowAttributes_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkIPFlowAttributes_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkIPFlowAttributes_GetInt(This,attrID,value) \ + ( (This)->lpVtbl -> GetInt(This,attrID,value) ) + +#define IDeckLinkIPFlowAttributes_GetFlag(This,attrID,value) \ + ( (This)->lpVtbl -> GetFlag(This,attrID,value) ) + +#define IDeckLinkIPFlowAttributes_GetFloat(This,attrID,value) \ + ( (This)->lpVtbl -> GetFloat(This,attrID,value) ) + +#define IDeckLinkIPFlowAttributes_GetString(This,attrID,value) \ + ( (This)->lpVtbl -> GetString(This,attrID,value) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkIPFlowAttributes_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkIPFlowStatus_INTERFACE_DEFINED__ +#define __IDeckLinkIPFlowStatus_INTERFACE_DEFINED__ + +/* interface IDeckLinkIPFlowStatus */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkIPFlowStatus; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("31C41656-4992-4396-BBE9-5F8406AAB5AF") + IDeckLinkIPFlowStatus : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetInt( + /* [in] */ BMDDeckLinkIPFlowStatusID statusID, + /* [out] */ LONGLONG *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFlag( + /* [in] */ BMDDeckLinkIPFlowStatusID statusID, + /* [out] */ BOOL *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFloat( + /* [in] */ BMDDeckLinkIPFlowStatusID statusID, + /* [out] */ double *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetString( + /* [in] */ BMDDeckLinkIPFlowStatusID statusID, + /* [out] */ BSTR *value) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkIPFlowStatusVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkIPFlowStatus * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkIPFlowStatus * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkIPFlowStatus * This); + + DECLSPEC_XFGVIRT(IDeckLinkIPFlowStatus, GetInt) + HRESULT ( STDMETHODCALLTYPE *GetInt )( + IDeckLinkIPFlowStatus * This, + /* [in] */ BMDDeckLinkIPFlowStatusID statusID, + /* [out] */ LONGLONG *value); + + DECLSPEC_XFGVIRT(IDeckLinkIPFlowStatus, GetFlag) + HRESULT ( STDMETHODCALLTYPE *GetFlag )( + IDeckLinkIPFlowStatus * This, + /* [in] */ BMDDeckLinkIPFlowStatusID statusID, + /* [out] */ BOOL *value); + + DECLSPEC_XFGVIRT(IDeckLinkIPFlowStatus, GetFloat) + HRESULT ( STDMETHODCALLTYPE *GetFloat )( + IDeckLinkIPFlowStatus * This, + /* [in] */ BMDDeckLinkIPFlowStatusID statusID, + /* [out] */ double *value); + + DECLSPEC_XFGVIRT(IDeckLinkIPFlowStatus, GetString) + HRESULT ( STDMETHODCALLTYPE *GetString )( + IDeckLinkIPFlowStatus * This, + /* [in] */ BMDDeckLinkIPFlowStatusID statusID, + /* [out] */ BSTR *value); + + END_INTERFACE + } IDeckLinkIPFlowStatusVtbl; + + interface IDeckLinkIPFlowStatus + { + CONST_VTBL struct IDeckLinkIPFlowStatusVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkIPFlowStatus_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkIPFlowStatus_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkIPFlowStatus_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkIPFlowStatus_GetInt(This,statusID,value) \ + ( (This)->lpVtbl -> GetInt(This,statusID,value) ) + +#define IDeckLinkIPFlowStatus_GetFlag(This,statusID,value) \ + ( (This)->lpVtbl -> GetFlag(This,statusID,value) ) + +#define IDeckLinkIPFlowStatus_GetFloat(This,statusID,value) \ + ( (This)->lpVtbl -> GetFloat(This,statusID,value) ) + +#define IDeckLinkIPFlowStatus_GetString(This,statusID,value) \ + ( (This)->lpVtbl -> GetString(This,statusID,value) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkIPFlowStatus_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkIPFlowSetting_INTERFACE_DEFINED__ +#define __IDeckLinkIPFlowSetting_INTERFACE_DEFINED__ + +/* interface IDeckLinkIPFlowSetting */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkIPFlowSetting; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("86DD9174-27D3-4032-B2AD-6067C3BB2424") + IDeckLinkIPFlowSetting : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetInt( + /* [in] */ BMDDeckLinkIPFlowSettingID settingID, + /* [out] */ LONGLONG *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFlag( + /* [in] */ BMDDeckLinkIPFlowSettingID settingID, + /* [out] */ BOOL *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFloat( + /* [in] */ BMDDeckLinkIPFlowSettingID settingID, + /* [out] */ double *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetString( + /* [in] */ BMDDeckLinkIPFlowSettingID settingID, + /* [out] */ BSTR *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetInt( + /* [in] */ BMDDeckLinkIPFlowSettingID settingID, + /* [in] */ LONGLONG value) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetFlag( + /* [in] */ BMDDeckLinkIPFlowSettingID settingID, + /* [in] */ BOOL value) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetFloat( + /* [in] */ BMDDeckLinkIPFlowSettingID settingID, + /* [in] */ double value) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetString( + /* [in] */ BMDDeckLinkIPFlowSettingID settingID, + /* [in] */ BSTR value) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkIPFlowSettingVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkIPFlowSetting * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkIPFlowSetting * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkIPFlowSetting * This); + + DECLSPEC_XFGVIRT(IDeckLinkIPFlowSetting, GetInt) + HRESULT ( STDMETHODCALLTYPE *GetInt )( + IDeckLinkIPFlowSetting * This, + /* [in] */ BMDDeckLinkIPFlowSettingID settingID, + /* [out] */ LONGLONG *value); + + DECLSPEC_XFGVIRT(IDeckLinkIPFlowSetting, GetFlag) + HRESULT ( STDMETHODCALLTYPE *GetFlag )( + IDeckLinkIPFlowSetting * This, + /* [in] */ BMDDeckLinkIPFlowSettingID settingID, + /* [out] */ BOOL *value); + + DECLSPEC_XFGVIRT(IDeckLinkIPFlowSetting, GetFloat) + HRESULT ( STDMETHODCALLTYPE *GetFloat )( + IDeckLinkIPFlowSetting * This, + /* [in] */ BMDDeckLinkIPFlowSettingID settingID, + /* [out] */ double *value); + + DECLSPEC_XFGVIRT(IDeckLinkIPFlowSetting, GetString) + HRESULT ( STDMETHODCALLTYPE *GetString )( + IDeckLinkIPFlowSetting * This, + /* [in] */ BMDDeckLinkIPFlowSettingID settingID, + /* [out] */ BSTR *value); + + DECLSPEC_XFGVIRT(IDeckLinkIPFlowSetting, SetInt) + HRESULT ( STDMETHODCALLTYPE *SetInt )( + IDeckLinkIPFlowSetting * This, + /* [in] */ BMDDeckLinkIPFlowSettingID settingID, + /* [in] */ LONGLONG value); + + DECLSPEC_XFGVIRT(IDeckLinkIPFlowSetting, SetFlag) + HRESULT ( STDMETHODCALLTYPE *SetFlag )( + IDeckLinkIPFlowSetting * This, + /* [in] */ BMDDeckLinkIPFlowSettingID settingID, + /* [in] */ BOOL value); + + DECLSPEC_XFGVIRT(IDeckLinkIPFlowSetting, SetFloat) + HRESULT ( STDMETHODCALLTYPE *SetFloat )( + IDeckLinkIPFlowSetting * This, + /* [in] */ BMDDeckLinkIPFlowSettingID settingID, + /* [in] */ double value); + + DECLSPEC_XFGVIRT(IDeckLinkIPFlowSetting, SetString) + HRESULT ( STDMETHODCALLTYPE *SetString )( + IDeckLinkIPFlowSetting * This, + /* [in] */ BMDDeckLinkIPFlowSettingID settingID, + /* [in] */ BSTR value); + + END_INTERFACE + } IDeckLinkIPFlowSettingVtbl; + + interface IDeckLinkIPFlowSetting + { + CONST_VTBL struct IDeckLinkIPFlowSettingVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkIPFlowSetting_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkIPFlowSetting_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkIPFlowSetting_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkIPFlowSetting_GetInt(This,settingID,value) \ + ( (This)->lpVtbl -> GetInt(This,settingID,value) ) + +#define IDeckLinkIPFlowSetting_GetFlag(This,settingID,value) \ + ( (This)->lpVtbl -> GetFlag(This,settingID,value) ) + +#define IDeckLinkIPFlowSetting_GetFloat(This,settingID,value) \ + ( (This)->lpVtbl -> GetFloat(This,settingID,value) ) + +#define IDeckLinkIPFlowSetting_GetString(This,settingID,value) \ + ( (This)->lpVtbl -> GetString(This,settingID,value) ) + +#define IDeckLinkIPFlowSetting_SetInt(This,settingID,value) \ + ( (This)->lpVtbl -> SetInt(This,settingID,value) ) + +#define IDeckLinkIPFlowSetting_SetFlag(This,settingID,value) \ + ( (This)->lpVtbl -> SetFlag(This,settingID,value) ) + +#define IDeckLinkIPFlowSetting_SetFloat(This,settingID,value) \ + ( (This)->lpVtbl -> SetFloat(This,settingID,value) ) + +#define IDeckLinkIPFlowSetting_SetString(This,settingID,value) \ + ( (This)->lpVtbl -> SetString(This,settingID,value) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkIPFlowSetting_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkIPFlow_INTERFACE_DEFINED__ +#define __IDeckLinkIPFlow_INTERFACE_DEFINED__ + +/* interface IDeckLinkIPFlow */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkIPFlow; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("C5FC83C7-5B8E-42A7-9A40-7C065955D4E1") + IDeckLinkIPFlow : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Enable( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Disable( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkIPFlowVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkIPFlow * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkIPFlow * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkIPFlow * This); + + DECLSPEC_XFGVIRT(IDeckLinkIPFlow, Enable) + HRESULT ( STDMETHODCALLTYPE *Enable )( + IDeckLinkIPFlow * This); + + DECLSPEC_XFGVIRT(IDeckLinkIPFlow, Disable) + HRESULT ( STDMETHODCALLTYPE *Disable )( + IDeckLinkIPFlow * This); + + END_INTERFACE + } IDeckLinkIPFlowVtbl; + + interface IDeckLinkIPFlow + { + CONST_VTBL struct IDeckLinkIPFlowVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkIPFlow_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkIPFlow_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkIPFlow_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkIPFlow_Enable(This) \ + ( (This)->lpVtbl -> Enable(This) ) + +#define IDeckLinkIPFlow_Disable(This) \ + ( (This)->lpVtbl -> Disable(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkIPFlow_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkIPFlowIterator_INTERFACE_DEFINED__ +#define __IDeckLinkIPFlowIterator_INTERFACE_DEFINED__ + +/* interface IDeckLinkIPFlowIterator */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkIPFlowIterator; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("BD296AB2-A5C5-4153-888F-AAB1FDBD8A5C") + IDeckLinkIPFlowIterator : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Next( + /* [out] */ IDeckLinkIPFlow **deckLinkIPFlowInstance) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkIPFlowIteratorVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkIPFlowIterator * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkIPFlowIterator * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkIPFlowIterator * This); + + DECLSPEC_XFGVIRT(IDeckLinkIPFlowIterator, Next) + HRESULT ( STDMETHODCALLTYPE *Next )( + IDeckLinkIPFlowIterator * This, + /* [out] */ IDeckLinkIPFlow **deckLinkIPFlowInstance); + + END_INTERFACE + } IDeckLinkIPFlowIteratorVtbl; + + interface IDeckLinkIPFlowIterator + { + CONST_VTBL struct IDeckLinkIPFlowIteratorVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkIPFlowIterator_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkIPFlowIterator_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkIPFlowIterator_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkIPFlowIterator_Next(This,deckLinkIPFlowInstance) \ + ( (This)->lpVtbl -> Next(This,deckLinkIPFlowInstance) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkIPFlowIterator_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("5F227C95-39D7-46C7-8B7D-9C81795FBBE4") + IDeckLinkOutput : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE DoesSupportVideoMode( + /* [in] */ BMDVideoConnection connection, + /* [in] */ BMDDisplayMode requestedMode, + /* [in] */ BMDPixelFormat requestedPixelFormat, + /* [in] */ BMDVideoOutputConversionMode conversionMode, + /* [in] */ BMDSupportedVideoModeFlags flags, + /* [out] */ BMDDisplayMode *actualMode, + /* [out] */ BOOL *supported) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayMode( + /* [in] */ BMDDisplayMode displayMode, + /* [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 CreateVideoFrame( + /* [in] */ int width, + /* [in] */ int height, + /* [in] */ int rowBytes, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDFrameFlags flags, + /* [out] */ IDeckLinkMutableVideoFrame **outFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateVideoFrameWithBuffer( + /* [in] */ int width, + /* [in] */ int height, + /* [in] */ int rowBytes, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDFrameFlags flags, + /* [in] */ IDeckLinkVideoBuffer *buffer, + /* [out] */ IDeckLinkMutableVideoFrame **outFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE RowBytesForPixelFormat( + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ int width, + /* [out] */ int *rowBytes) = 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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkOutput * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkOutput * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkOutput * This); + + DECLSPEC_XFGVIRT(IDeckLinkOutput, DoesSupportVideoMode) + HRESULT ( STDMETHODCALLTYPE *DoesSupportVideoMode )( + IDeckLinkOutput * This, + /* [in] */ BMDVideoConnection connection, + /* [in] */ BMDDisplayMode requestedMode, + /* [in] */ BMDPixelFormat requestedPixelFormat, + /* [in] */ BMDVideoOutputConversionMode conversionMode, + /* [in] */ BMDSupportedVideoModeFlags flags, + /* [out] */ BMDDisplayMode *actualMode, + /* [out] */ BOOL *supported); + + DECLSPEC_XFGVIRT(IDeckLinkOutput, GetDisplayMode) + HRESULT ( STDMETHODCALLTYPE *GetDisplayMode )( + IDeckLinkOutput * This, + /* [in] */ BMDDisplayMode displayMode, + /* [out] */ IDeckLinkDisplayMode **resultDisplayMode); + + DECLSPEC_XFGVIRT(IDeckLinkOutput, GetDisplayModeIterator) + HRESULT ( STDMETHODCALLTYPE *GetDisplayModeIterator )( + IDeckLinkOutput * This, + /* [out] */ IDeckLinkDisplayModeIterator **iterator); + + DECLSPEC_XFGVIRT(IDeckLinkOutput, SetScreenPreviewCallback) + HRESULT ( STDMETHODCALLTYPE *SetScreenPreviewCallback )( + IDeckLinkOutput * This, + /* [in] */ IDeckLinkScreenPreviewCallback *previewCallback); + + DECLSPEC_XFGVIRT(IDeckLinkOutput, EnableVideoOutput) + HRESULT ( STDMETHODCALLTYPE *EnableVideoOutput )( + IDeckLinkOutput * This, + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDVideoOutputFlags flags); + + DECLSPEC_XFGVIRT(IDeckLinkOutput, DisableVideoOutput) + HRESULT ( STDMETHODCALLTYPE *DisableVideoOutput )( + IDeckLinkOutput * This); + + DECLSPEC_XFGVIRT(IDeckLinkOutput, CreateVideoFrame) + HRESULT ( STDMETHODCALLTYPE *CreateVideoFrame )( + IDeckLinkOutput * This, + /* [in] */ int width, + /* [in] */ int height, + /* [in] */ int rowBytes, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDFrameFlags flags, + /* [out] */ IDeckLinkMutableVideoFrame **outFrame); + + DECLSPEC_XFGVIRT(IDeckLinkOutput, CreateVideoFrameWithBuffer) + HRESULT ( STDMETHODCALLTYPE *CreateVideoFrameWithBuffer )( + IDeckLinkOutput * This, + /* [in] */ int width, + /* [in] */ int height, + /* [in] */ int rowBytes, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDFrameFlags flags, + /* [in] */ IDeckLinkVideoBuffer *buffer, + /* [out] */ IDeckLinkMutableVideoFrame **outFrame); + + DECLSPEC_XFGVIRT(IDeckLinkOutput, RowBytesForPixelFormat) + HRESULT ( STDMETHODCALLTYPE *RowBytesForPixelFormat )( + IDeckLinkOutput * This, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ int width, + /* [out] */ int *rowBytes); + + DECLSPEC_XFGVIRT(IDeckLinkOutput, CreateAncillaryData) + HRESULT ( STDMETHODCALLTYPE *CreateAncillaryData )( + IDeckLinkOutput * This, + /* [in] */ BMDPixelFormat pixelFormat, + /* [out] */ IDeckLinkVideoFrameAncillary **outBuffer); + + DECLSPEC_XFGVIRT(IDeckLinkOutput, DisplayVideoFrameSync) + HRESULT ( STDMETHODCALLTYPE *DisplayVideoFrameSync )( + IDeckLinkOutput * This, + /* [in] */ IDeckLinkVideoFrame *theFrame); + + DECLSPEC_XFGVIRT(IDeckLinkOutput, ScheduleVideoFrame) + HRESULT ( STDMETHODCALLTYPE *ScheduleVideoFrame )( + IDeckLinkOutput * This, + /* [in] */ IDeckLinkVideoFrame *theFrame, + /* [in] */ BMDTimeValue displayTime, + /* [in] */ BMDTimeValue displayDuration, + /* [in] */ BMDTimeScale timeScale); + + DECLSPEC_XFGVIRT(IDeckLinkOutput, SetScheduledFrameCompletionCallback) + HRESULT ( STDMETHODCALLTYPE *SetScheduledFrameCompletionCallback )( + IDeckLinkOutput * This, + /* [in] */ IDeckLinkVideoOutputCallback *theCallback); + + DECLSPEC_XFGVIRT(IDeckLinkOutput, GetBufferedVideoFrameCount) + HRESULT ( STDMETHODCALLTYPE *GetBufferedVideoFrameCount )( + IDeckLinkOutput * This, + /* [out] */ unsigned int *bufferedFrameCount); + + DECLSPEC_XFGVIRT(IDeckLinkOutput, EnableAudioOutput) + HRESULT ( STDMETHODCALLTYPE *EnableAudioOutput )( + IDeckLinkOutput * This, + /* [in] */ BMDAudioSampleRate sampleRate, + /* [in] */ BMDAudioSampleType sampleType, + /* [in] */ unsigned int channelCount, + /* [in] */ BMDAudioOutputStreamType streamType); + + DECLSPEC_XFGVIRT(IDeckLinkOutput, DisableAudioOutput) + HRESULT ( STDMETHODCALLTYPE *DisableAudioOutput )( + IDeckLinkOutput * This); + + DECLSPEC_XFGVIRT(IDeckLinkOutput, WriteAudioSamplesSync) + HRESULT ( STDMETHODCALLTYPE *WriteAudioSamplesSync )( + IDeckLinkOutput * This, + /* [in] */ void *buffer, + /* [in] */ unsigned int sampleFrameCount, + /* [out] */ unsigned int *sampleFramesWritten); + + DECLSPEC_XFGVIRT(IDeckLinkOutput, BeginAudioPreroll) + HRESULT ( STDMETHODCALLTYPE *BeginAudioPreroll )( + IDeckLinkOutput * This); + + DECLSPEC_XFGVIRT(IDeckLinkOutput, EndAudioPreroll) + HRESULT ( STDMETHODCALLTYPE *EndAudioPreroll )( + IDeckLinkOutput * This); + + DECLSPEC_XFGVIRT(IDeckLinkOutput, ScheduleAudioSamples) + HRESULT ( STDMETHODCALLTYPE *ScheduleAudioSamples )( + IDeckLinkOutput * This, + /* [in] */ void *buffer, + /* [in] */ unsigned int sampleFrameCount, + /* [in] */ BMDTimeValue streamTime, + /* [in] */ BMDTimeScale timeScale, + /* [out] */ unsigned int *sampleFramesWritten); + + DECLSPEC_XFGVIRT(IDeckLinkOutput, GetBufferedAudioSampleFrameCount) + HRESULT ( STDMETHODCALLTYPE *GetBufferedAudioSampleFrameCount )( + IDeckLinkOutput * This, + /* [out] */ unsigned int *bufferedSampleFrameCount); + + DECLSPEC_XFGVIRT(IDeckLinkOutput, FlushBufferedAudioSamples) + HRESULT ( STDMETHODCALLTYPE *FlushBufferedAudioSamples )( + IDeckLinkOutput * This); + + DECLSPEC_XFGVIRT(IDeckLinkOutput, SetAudioCallback) + HRESULT ( STDMETHODCALLTYPE *SetAudioCallback )( + IDeckLinkOutput * This, + /* [in] */ IDeckLinkAudioOutputCallback *theCallback); + + DECLSPEC_XFGVIRT(IDeckLinkOutput, StartScheduledPlayback) + HRESULT ( STDMETHODCALLTYPE *StartScheduledPlayback )( + IDeckLinkOutput * This, + /* [in] */ BMDTimeValue playbackStartTime, + /* [in] */ BMDTimeScale timeScale, + /* [in] */ double playbackSpeed); + + DECLSPEC_XFGVIRT(IDeckLinkOutput, StopScheduledPlayback) + HRESULT ( STDMETHODCALLTYPE *StopScheduledPlayback )( + IDeckLinkOutput * This, + /* [in] */ BMDTimeValue stopPlaybackAtTime, + /* [out] */ BMDTimeValue *actualStopTime, + /* [in] */ BMDTimeScale timeScale); + + DECLSPEC_XFGVIRT(IDeckLinkOutput, IsScheduledPlaybackRunning) + HRESULT ( STDMETHODCALLTYPE *IsScheduledPlaybackRunning )( + IDeckLinkOutput * This, + /* [out] */ BOOL *active); + + DECLSPEC_XFGVIRT(IDeckLinkOutput, GetScheduledStreamTime) + HRESULT ( STDMETHODCALLTYPE *GetScheduledStreamTime )( + IDeckLinkOutput * This, + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *streamTime, + /* [out] */ double *playbackSpeed); + + DECLSPEC_XFGVIRT(IDeckLinkOutput, GetReferenceStatus) + HRESULT ( STDMETHODCALLTYPE *GetReferenceStatus )( + IDeckLinkOutput * This, + /* [out] */ BMDReferenceStatus *referenceStatus); + + DECLSPEC_XFGVIRT(IDeckLinkOutput, GetHardwareReferenceClock) + HRESULT ( STDMETHODCALLTYPE *GetHardwareReferenceClock )( + IDeckLinkOutput * This, + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *hardwareTime, + /* [out] */ BMDTimeValue *timeInFrame, + /* [out] */ BMDTimeValue *ticksPerFrame); + + DECLSPEC_XFGVIRT(IDeckLinkOutput, GetFrameCompletionReferenceTimestamp) + 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,connection,requestedMode,requestedPixelFormat,conversionMode,flags,actualMode,supported) \ + ( (This)->lpVtbl -> DoesSupportVideoMode(This,connection,requestedMode,requestedPixelFormat,conversionMode,flags,actualMode,supported) ) + +#define IDeckLinkOutput_GetDisplayMode(This,displayMode,resultDisplayMode) \ + ( (This)->lpVtbl -> GetDisplayMode(This,displayMode,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_CreateVideoFrame(This,width,height,rowBytes,pixelFormat,flags,outFrame) \ + ( (This)->lpVtbl -> CreateVideoFrame(This,width,height,rowBytes,pixelFormat,flags,outFrame) ) + +#define IDeckLinkOutput_CreateVideoFrameWithBuffer(This,width,height,rowBytes,pixelFormat,flags,buffer,outFrame) \ + ( (This)->lpVtbl -> CreateVideoFrameWithBuffer(This,width,height,rowBytes,pixelFormat,flags,buffer,outFrame) ) + +#define IDeckLinkOutput_RowBytesForPixelFormat(This,pixelFormat,width,rowBytes) \ + ( (This)->lpVtbl -> RowBytesForPixelFormat(This,pixelFormat,width,rowBytes) ) + +#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("6A515F8A-FBCE-4853-B0F7-2A09DB1ECA0B") + IDeckLinkInput : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE DoesSupportVideoMode( + /* [in] */ BMDVideoConnection connection, + /* [in] */ BMDDisplayMode requestedMode, + /* [in] */ BMDPixelFormat requestedPixelFormat, + /* [in] */ BMDVideoInputConversionMode conversionMode, + /* [in] */ BMDSupportedVideoModeFlags flags, + /* [out] */ BMDDisplayMode *actualMode, + /* [out] */ BOOL *supported) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayMode( + /* [in] */ BMDDisplayMode displayMode, + /* [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 EnableVideoInputWithAllocatorProvider( + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDVideoInputFlags flags, + /* [in] */ IDeckLinkVideoBufferAllocatorProvider *allocatorProvider) = 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 IDeckLinkInputVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkInput * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkInput * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkInput * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput, DoesSupportVideoMode) + HRESULT ( STDMETHODCALLTYPE *DoesSupportVideoMode )( + IDeckLinkInput * This, + /* [in] */ BMDVideoConnection connection, + /* [in] */ BMDDisplayMode requestedMode, + /* [in] */ BMDPixelFormat requestedPixelFormat, + /* [in] */ BMDVideoInputConversionMode conversionMode, + /* [in] */ BMDSupportedVideoModeFlags flags, + /* [out] */ BMDDisplayMode *actualMode, + /* [out] */ BOOL *supported); + + DECLSPEC_XFGVIRT(IDeckLinkInput, GetDisplayMode) + HRESULT ( STDMETHODCALLTYPE *GetDisplayMode )( + IDeckLinkInput * This, + /* [in] */ BMDDisplayMode displayMode, + /* [out] */ IDeckLinkDisplayMode **resultDisplayMode); + + DECLSPEC_XFGVIRT(IDeckLinkInput, GetDisplayModeIterator) + HRESULT ( STDMETHODCALLTYPE *GetDisplayModeIterator )( + IDeckLinkInput * This, + /* [out] */ IDeckLinkDisplayModeIterator **iterator); + + DECLSPEC_XFGVIRT(IDeckLinkInput, SetScreenPreviewCallback) + HRESULT ( STDMETHODCALLTYPE *SetScreenPreviewCallback )( + IDeckLinkInput * This, + /* [in] */ IDeckLinkScreenPreviewCallback *previewCallback); + + DECLSPEC_XFGVIRT(IDeckLinkInput, EnableVideoInput) + HRESULT ( STDMETHODCALLTYPE *EnableVideoInput )( + IDeckLinkInput * This, + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDVideoInputFlags flags); + + DECLSPEC_XFGVIRT(IDeckLinkInput, EnableVideoInputWithAllocatorProvider) + HRESULT ( STDMETHODCALLTYPE *EnableVideoInputWithAllocatorProvider )( + IDeckLinkInput * This, + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDVideoInputFlags flags, + /* [in] */ IDeckLinkVideoBufferAllocatorProvider *allocatorProvider); + + DECLSPEC_XFGVIRT(IDeckLinkInput, DisableVideoInput) + HRESULT ( STDMETHODCALLTYPE *DisableVideoInput )( + IDeckLinkInput * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput, GetAvailableVideoFrameCount) + HRESULT ( STDMETHODCALLTYPE *GetAvailableVideoFrameCount )( + IDeckLinkInput * This, + /* [out] */ unsigned int *availableFrameCount); + + DECLSPEC_XFGVIRT(IDeckLinkInput, EnableAudioInput) + HRESULT ( STDMETHODCALLTYPE *EnableAudioInput )( + IDeckLinkInput * This, + /* [in] */ BMDAudioSampleRate sampleRate, + /* [in] */ BMDAudioSampleType sampleType, + /* [in] */ unsigned int channelCount); + + DECLSPEC_XFGVIRT(IDeckLinkInput, DisableAudioInput) + HRESULT ( STDMETHODCALLTYPE *DisableAudioInput )( + IDeckLinkInput * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput, GetAvailableAudioSampleFrameCount) + HRESULT ( STDMETHODCALLTYPE *GetAvailableAudioSampleFrameCount )( + IDeckLinkInput * This, + /* [out] */ unsigned int *availableSampleFrameCount); + + DECLSPEC_XFGVIRT(IDeckLinkInput, StartStreams) + HRESULT ( STDMETHODCALLTYPE *StartStreams )( + IDeckLinkInput * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput, StopStreams) + HRESULT ( STDMETHODCALLTYPE *StopStreams )( + IDeckLinkInput * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput, PauseStreams) + HRESULT ( STDMETHODCALLTYPE *PauseStreams )( + IDeckLinkInput * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput, FlushStreams) + HRESULT ( STDMETHODCALLTYPE *FlushStreams )( + IDeckLinkInput * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput, SetCallback) + HRESULT ( STDMETHODCALLTYPE *SetCallback )( + IDeckLinkInput * This, + /* [in] */ IDeckLinkInputCallback *theCallback); + + DECLSPEC_XFGVIRT(IDeckLinkInput, GetHardwareReferenceClock) + 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,connection,requestedMode,requestedPixelFormat,conversionMode,flags,actualMode,supported) \ + ( (This)->lpVtbl -> DoesSupportVideoMode(This,connection,requestedMode,requestedPixelFormat,conversionMode,flags,actualMode,supported) ) + +#define IDeckLinkInput_GetDisplayMode(This,displayMode,resultDisplayMode) \ + ( (This)->lpVtbl -> GetDisplayMode(This,displayMode,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_EnableVideoInputWithAllocatorProvider(This,displayMode,pixelFormat,flags,allocatorProvider) \ + ( (This)->lpVtbl -> EnableVideoInputWithAllocatorProvider(This,displayMode,pixelFormat,flags,allocatorProvider) ) + +#define IDeckLinkInput_DisableVideoInput(This) \ + ( (This)->lpVtbl -> DisableVideoInput(This) ) + +#define IDeckLinkInput_GetAvailableVideoFrameCount(This,availableFrameCount) \ + ( (This)->lpVtbl -> GetAvailableVideoFrameCount(This,availableFrameCount) ) + +#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 __IDeckLinkIPExtensions_INTERFACE_DEFINED__ +#define __IDeckLinkIPExtensions_INTERFACE_DEFINED__ + +/* interface IDeckLinkIPExtensions */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkIPExtensions; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("46CF7903-A9FD-4D0B-8FFC-0103722AB442") + IDeckLinkIPExtensions : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetDeckLinkIPFlowIterator( + /* [out] */ IDeckLinkIPFlowIterator **iterator) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetIPFlowByID( + /* [in] */ BMDIPFlowID id, + /* [out] */ IDeckLinkIPFlow **flow) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkIPExtensionsVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkIPExtensions * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkIPExtensions * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkIPExtensions * This); + + DECLSPEC_XFGVIRT(IDeckLinkIPExtensions, GetDeckLinkIPFlowIterator) + HRESULT ( STDMETHODCALLTYPE *GetDeckLinkIPFlowIterator )( + IDeckLinkIPExtensions * This, + /* [out] */ IDeckLinkIPFlowIterator **iterator); + + DECLSPEC_XFGVIRT(IDeckLinkIPExtensions, GetIPFlowByID) + HRESULT ( STDMETHODCALLTYPE *GetIPFlowByID )( + IDeckLinkIPExtensions * This, + /* [in] */ BMDIPFlowID id, + /* [out] */ IDeckLinkIPFlow **flow); + + END_INTERFACE + } IDeckLinkIPExtensionsVtbl; + + interface IDeckLinkIPExtensions + { + CONST_VTBL struct IDeckLinkIPExtensionsVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkIPExtensions_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkIPExtensions_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkIPExtensions_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkIPExtensions_GetDeckLinkIPFlowIterator(This,iterator) \ + ( (This)->lpVtbl -> GetDeckLinkIPFlowIterator(This,iterator) ) + +#define IDeckLinkIPExtensions_GetIPFlowByID(This,id,flow) \ + ( (This)->lpVtbl -> GetIPFlowByID(This,id,flow) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkIPExtensions_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkHDMIInputEDID_INTERFACE_DEFINED__ +#define __IDeckLinkHDMIInputEDID_INTERFACE_DEFINED__ + +/* interface IDeckLinkHDMIInputEDID */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkHDMIInputEDID; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("ABBBACBC-45BC-4665-9D92-ACE6E5A97902") + IDeckLinkHDMIInputEDID : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetInt( + /* [in] */ BMDDeckLinkHDMIInputEDIDID cfgID, + /* [in] */ LONGLONG value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInt( + /* [in] */ BMDDeckLinkHDMIInputEDIDID cfgID, + /* [out] */ LONGLONG *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE WriteToEDID( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkHDMIInputEDIDVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkHDMIInputEDID * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkHDMIInputEDID * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkHDMIInputEDID * This); + + DECLSPEC_XFGVIRT(IDeckLinkHDMIInputEDID, SetInt) + HRESULT ( STDMETHODCALLTYPE *SetInt )( + IDeckLinkHDMIInputEDID * This, + /* [in] */ BMDDeckLinkHDMIInputEDIDID cfgID, + /* [in] */ LONGLONG value); + + DECLSPEC_XFGVIRT(IDeckLinkHDMIInputEDID, GetInt) + HRESULT ( STDMETHODCALLTYPE *GetInt )( + IDeckLinkHDMIInputEDID * This, + /* [in] */ BMDDeckLinkHDMIInputEDIDID cfgID, + /* [out] */ LONGLONG *value); + + DECLSPEC_XFGVIRT(IDeckLinkHDMIInputEDID, WriteToEDID) + HRESULT ( STDMETHODCALLTYPE *WriteToEDID )( + IDeckLinkHDMIInputEDID * This); + + END_INTERFACE + } IDeckLinkHDMIInputEDIDVtbl; + + interface IDeckLinkHDMIInputEDID + { + CONST_VTBL struct IDeckLinkHDMIInputEDIDVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkHDMIInputEDID_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkHDMIInputEDID_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkHDMIInputEDID_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkHDMIInputEDID_SetInt(This,cfgID,value) \ + ( (This)->lpVtbl -> SetInt(This,cfgID,value) ) + +#define IDeckLinkHDMIInputEDID_GetInt(This,cfgID,value) \ + ( (This)->lpVtbl -> GetInt(This,cfgID,value) ) + +#define IDeckLinkHDMIInputEDID_WriteToEDID(This) \ + ( (This)->lpVtbl -> WriteToEDID(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkHDMIInputEDID_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkEncoderInput_INTERFACE_DEFINED__ +#define __IDeckLinkEncoderInput_INTERFACE_DEFINED__ + +/* interface IDeckLinkEncoderInput */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkEncoderInput; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("46C1332E-6FD9-472A-8591-FE59C22192E1") + IDeckLinkEncoderInput : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE DoesSupportVideoMode( + /* [in] */ BMDVideoConnection connection, + /* [in] */ BMDDisplayMode requestedMode, + /* [in] */ BMDPixelFormat requestedCodec, + /* [in] */ unsigned int requestedCodecProfile, + /* [in] */ BMDSupportedVideoModeFlags flags, + /* [out] */ BOOL *supported) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayMode( + /* [in] */ BMDDisplayMode displayMode, + /* [out] */ IDeckLinkDisplayMode **resultDisplayMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayModeIterator( + /* [out] */ IDeckLinkDisplayModeIterator **iterator) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableVideoInput( + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDVideoInputFlags flags) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisableVideoInput( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAvailablePacketsCount( + /* [out] */ unsigned int *availablePacketsCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableAudioInput( + /* [in] */ BMDAudioFormat audioFormat, + /* [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] */ IDeckLinkEncoderInputCallback *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 IDeckLinkEncoderInputVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkEncoderInput * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkEncoderInput * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkEncoderInput * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput, DoesSupportVideoMode) + HRESULT ( STDMETHODCALLTYPE *DoesSupportVideoMode )( + IDeckLinkEncoderInput * This, + /* [in] */ BMDVideoConnection connection, + /* [in] */ BMDDisplayMode requestedMode, + /* [in] */ BMDPixelFormat requestedCodec, + /* [in] */ unsigned int requestedCodecProfile, + /* [in] */ BMDSupportedVideoModeFlags flags, + /* [out] */ BOOL *supported); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput, GetDisplayMode) + HRESULT ( STDMETHODCALLTYPE *GetDisplayMode )( + IDeckLinkEncoderInput * This, + /* [in] */ BMDDisplayMode displayMode, + /* [out] */ IDeckLinkDisplayMode **resultDisplayMode); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput, GetDisplayModeIterator) + HRESULT ( STDMETHODCALLTYPE *GetDisplayModeIterator )( + IDeckLinkEncoderInput * This, + /* [out] */ IDeckLinkDisplayModeIterator **iterator); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput, EnableVideoInput) + HRESULT ( STDMETHODCALLTYPE *EnableVideoInput )( + IDeckLinkEncoderInput * This, + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDVideoInputFlags flags); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput, DisableVideoInput) + HRESULT ( STDMETHODCALLTYPE *DisableVideoInput )( + IDeckLinkEncoderInput * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput, GetAvailablePacketsCount) + HRESULT ( STDMETHODCALLTYPE *GetAvailablePacketsCount )( + IDeckLinkEncoderInput * This, + /* [out] */ unsigned int *availablePacketsCount); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput, EnableAudioInput) + HRESULT ( STDMETHODCALLTYPE *EnableAudioInput )( + IDeckLinkEncoderInput * This, + /* [in] */ BMDAudioFormat audioFormat, + /* [in] */ BMDAudioSampleRate sampleRate, + /* [in] */ BMDAudioSampleType sampleType, + /* [in] */ unsigned int channelCount); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput, DisableAudioInput) + HRESULT ( STDMETHODCALLTYPE *DisableAudioInput )( + IDeckLinkEncoderInput * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput, GetAvailableAudioSampleFrameCount) + HRESULT ( STDMETHODCALLTYPE *GetAvailableAudioSampleFrameCount )( + IDeckLinkEncoderInput * This, + /* [out] */ unsigned int *availableSampleFrameCount); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput, StartStreams) + HRESULT ( STDMETHODCALLTYPE *StartStreams )( + IDeckLinkEncoderInput * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput, StopStreams) + HRESULT ( STDMETHODCALLTYPE *StopStreams )( + IDeckLinkEncoderInput * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput, PauseStreams) + HRESULT ( STDMETHODCALLTYPE *PauseStreams )( + IDeckLinkEncoderInput * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput, FlushStreams) + HRESULT ( STDMETHODCALLTYPE *FlushStreams )( + IDeckLinkEncoderInput * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput, SetCallback) + HRESULT ( STDMETHODCALLTYPE *SetCallback )( + IDeckLinkEncoderInput * This, + /* [in] */ IDeckLinkEncoderInputCallback *theCallback); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput, GetHardwareReferenceClock) + HRESULT ( STDMETHODCALLTYPE *GetHardwareReferenceClock )( + IDeckLinkEncoderInput * This, + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *hardwareTime, + /* [out] */ BMDTimeValue *timeInFrame, + /* [out] */ BMDTimeValue *ticksPerFrame); + + END_INTERFACE + } IDeckLinkEncoderInputVtbl; + + interface IDeckLinkEncoderInput + { + CONST_VTBL struct IDeckLinkEncoderInputVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkEncoderInput_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkEncoderInput_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkEncoderInput_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkEncoderInput_DoesSupportVideoMode(This,connection,requestedMode,requestedCodec,requestedCodecProfile,flags,supported) \ + ( (This)->lpVtbl -> DoesSupportVideoMode(This,connection,requestedMode,requestedCodec,requestedCodecProfile,flags,supported) ) + +#define IDeckLinkEncoderInput_GetDisplayMode(This,displayMode,resultDisplayMode) \ + ( (This)->lpVtbl -> GetDisplayMode(This,displayMode,resultDisplayMode) ) + +#define IDeckLinkEncoderInput_GetDisplayModeIterator(This,iterator) \ + ( (This)->lpVtbl -> GetDisplayModeIterator(This,iterator) ) + +#define IDeckLinkEncoderInput_EnableVideoInput(This,displayMode,pixelFormat,flags) \ + ( (This)->lpVtbl -> EnableVideoInput(This,displayMode,pixelFormat,flags) ) + +#define IDeckLinkEncoderInput_DisableVideoInput(This) \ + ( (This)->lpVtbl -> DisableVideoInput(This) ) + +#define IDeckLinkEncoderInput_GetAvailablePacketsCount(This,availablePacketsCount) \ + ( (This)->lpVtbl -> GetAvailablePacketsCount(This,availablePacketsCount) ) + +#define IDeckLinkEncoderInput_EnableAudioInput(This,audioFormat,sampleRate,sampleType,channelCount) \ + ( (This)->lpVtbl -> EnableAudioInput(This,audioFormat,sampleRate,sampleType,channelCount) ) + +#define IDeckLinkEncoderInput_DisableAudioInput(This) \ + ( (This)->lpVtbl -> DisableAudioInput(This) ) + +#define IDeckLinkEncoderInput_GetAvailableAudioSampleFrameCount(This,availableSampleFrameCount) \ + ( (This)->lpVtbl -> GetAvailableAudioSampleFrameCount(This,availableSampleFrameCount) ) + +#define IDeckLinkEncoderInput_StartStreams(This) \ + ( (This)->lpVtbl -> StartStreams(This) ) + +#define IDeckLinkEncoderInput_StopStreams(This) \ + ( (This)->lpVtbl -> StopStreams(This) ) + +#define IDeckLinkEncoderInput_PauseStreams(This) \ + ( (This)->lpVtbl -> PauseStreams(This) ) + +#define IDeckLinkEncoderInput_FlushStreams(This) \ + ( (This)->lpVtbl -> FlushStreams(This) ) + +#define IDeckLinkEncoderInput_SetCallback(This,theCallback) \ + ( (This)->lpVtbl -> SetCallback(This,theCallback) ) + +#define IDeckLinkEncoderInput_GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) \ + ( (This)->lpVtbl -> GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkEncoderInput_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkVideoBuffer_INTERFACE_DEFINED__ +#define __IDeckLinkVideoBuffer_INTERFACE_DEFINED__ + +/* interface IDeckLinkVideoBuffer */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkVideoBuffer; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("81F03D70-DE13-4B17-873A-C8AC9689C682") + IDeckLinkVideoBuffer : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetBytes( + /* [out] */ void **buffer) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSize( + /* [out] */ ULONGLONG *size) = 0; + + virtual HRESULT STDMETHODCALLTYPE StartAccess( + /* [in] */ BMDBufferAccessFlags flags) = 0; + + virtual HRESULT STDMETHODCALLTYPE EndAccess( + /* [in] */ BMDBufferAccessFlags flags) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkVideoBufferVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoBuffer * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoBuffer * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoBuffer * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoBuffer, GetBytes) + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IDeckLinkVideoBuffer * This, + /* [out] */ void **buffer); + + DECLSPEC_XFGVIRT(IDeckLinkVideoBuffer, GetSize) + HRESULT ( STDMETHODCALLTYPE *GetSize )( + IDeckLinkVideoBuffer * This, + /* [out] */ ULONGLONG *size); + + DECLSPEC_XFGVIRT(IDeckLinkVideoBuffer, StartAccess) + HRESULT ( STDMETHODCALLTYPE *StartAccess )( + IDeckLinkVideoBuffer * This, + /* [in] */ BMDBufferAccessFlags flags); + + DECLSPEC_XFGVIRT(IDeckLinkVideoBuffer, EndAccess) + HRESULT ( STDMETHODCALLTYPE *EndAccess )( + IDeckLinkVideoBuffer * This, + /* [in] */ BMDBufferAccessFlags flags); + + END_INTERFACE + } IDeckLinkVideoBufferVtbl; + + interface IDeckLinkVideoBuffer + { + CONST_VTBL struct IDeckLinkVideoBufferVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkVideoBuffer_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkVideoBuffer_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkVideoBuffer_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkVideoBuffer_GetBytes(This,buffer) \ + ( (This)->lpVtbl -> GetBytes(This,buffer) ) + +#define IDeckLinkVideoBuffer_GetSize(This,size) \ + ( (This)->lpVtbl -> GetSize(This,size) ) + +#define IDeckLinkVideoBuffer_StartAccess(This,flags) \ + ( (This)->lpVtbl -> StartAccess(This,flags) ) + +#define IDeckLinkVideoBuffer_EndAccess(This,flags) \ + ( (This)->lpVtbl -> EndAccess(This,flags) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkVideoBuffer_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("6502091C-615F-4F51-BAF6-45C4256DD5B0") + 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 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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoFrame * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoFrame * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoFrame * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame, GetWidth) + long ( STDMETHODCALLTYPE *GetWidth )( + IDeckLinkVideoFrame * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame, GetHeight) + long ( STDMETHODCALLTYPE *GetHeight )( + IDeckLinkVideoFrame * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame, GetRowBytes) + long ( STDMETHODCALLTYPE *GetRowBytes )( + IDeckLinkVideoFrame * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame, GetPixelFormat) + BMDPixelFormat ( STDMETHODCALLTYPE *GetPixelFormat )( + IDeckLinkVideoFrame * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame, GetFlags) + BMDFrameFlags ( STDMETHODCALLTYPE *GetFlags )( + IDeckLinkVideoFrame * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame, GetTimecode) + HRESULT ( STDMETHODCALLTYPE *GetTimecode )( + IDeckLinkVideoFrame * This, + /* [in] */ BMDTimecodeFormat format, + /* [out] */ IDeckLinkTimecode **timecode); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame, GetAncillaryData) + 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_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("CF9EB134-0374-4C5B-95FA-1EC14819FF62") + 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; + + virtual HRESULT STDMETHODCALLTYPE SetInterfaceProvider( + /* [in] */ REFIID iid, + /* [in] */ IUnknown *iface) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkMutableVideoFrameVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkMutableVideoFrame * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkMutableVideoFrame * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkMutableVideoFrame * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame, GetWidth) + long ( STDMETHODCALLTYPE *GetWidth )( + IDeckLinkMutableVideoFrame * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame, GetHeight) + long ( STDMETHODCALLTYPE *GetHeight )( + IDeckLinkMutableVideoFrame * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame, GetRowBytes) + long ( STDMETHODCALLTYPE *GetRowBytes )( + IDeckLinkMutableVideoFrame * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame, GetPixelFormat) + BMDPixelFormat ( STDMETHODCALLTYPE *GetPixelFormat )( + IDeckLinkMutableVideoFrame * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame, GetFlags) + BMDFrameFlags ( STDMETHODCALLTYPE *GetFlags )( + IDeckLinkMutableVideoFrame * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame, GetTimecode) + HRESULT ( STDMETHODCALLTYPE *GetTimecode )( + IDeckLinkMutableVideoFrame * This, + /* [in] */ BMDTimecodeFormat format, + /* [out] */ IDeckLinkTimecode **timecode); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame, GetAncillaryData) + HRESULT ( STDMETHODCALLTYPE *GetAncillaryData )( + IDeckLinkMutableVideoFrame * This, + /* [out] */ IDeckLinkVideoFrameAncillary **ancillary); + + DECLSPEC_XFGVIRT(IDeckLinkMutableVideoFrame, SetFlags) + HRESULT ( STDMETHODCALLTYPE *SetFlags )( + IDeckLinkMutableVideoFrame * This, + /* [in] */ BMDFrameFlags newFlags); + + DECLSPEC_XFGVIRT(IDeckLinkMutableVideoFrame, SetTimecode) + HRESULT ( STDMETHODCALLTYPE *SetTimecode )( + IDeckLinkMutableVideoFrame * This, + /* [in] */ BMDTimecodeFormat format, + /* [in] */ IDeckLinkTimecode *timecode); + + DECLSPEC_XFGVIRT(IDeckLinkMutableVideoFrame, SetTimecodeFromComponents) + 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); + + DECLSPEC_XFGVIRT(IDeckLinkMutableVideoFrame, SetAncillaryData) + HRESULT ( STDMETHODCALLTYPE *SetAncillaryData )( + IDeckLinkMutableVideoFrame * This, + /* [in] */ IDeckLinkVideoFrameAncillary *ancillary); + + DECLSPEC_XFGVIRT(IDeckLinkMutableVideoFrame, SetTimecodeUserBits) + HRESULT ( STDMETHODCALLTYPE *SetTimecodeUserBits )( + IDeckLinkMutableVideoFrame * This, + /* [in] */ BMDTimecodeFormat format, + /* [in] */ BMDTimecodeUserBits userBits); + + DECLSPEC_XFGVIRT(IDeckLinkMutableVideoFrame, SetInterfaceProvider) + HRESULT ( STDMETHODCALLTYPE *SetInterfaceProvider )( + IDeckLinkMutableVideoFrame * This, + /* [in] */ REFIID iid, + /* [in] */ IUnknown *iface); + + 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_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) ) + +#define IDeckLinkMutableVideoFrame_SetInterfaceProvider(This,iid,iface) \ + ( (This)->lpVtbl -> SetInterfaceProvider(This,iid,iface) ) + +#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("D4DBE9C6-B4D2-49D3-ABF2-B4E86C7391B0") + 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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoFrame3DExtensions * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoFrame3DExtensions * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoFrame3DExtensions * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame3DExtensions, Get3DPackingFormat) + BMDVideo3DPackingFormat ( STDMETHODCALLTYPE *Get3DPackingFormat )( + IDeckLinkVideoFrame3DExtensions * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame3DExtensions, GetFrameForRightEye) + 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 __IDeckLinkVideoFrameMetadataExtensions_INTERFACE_DEFINED__ +#define __IDeckLinkVideoFrameMetadataExtensions_INTERFACE_DEFINED__ + +/* interface IDeckLinkVideoFrameMetadataExtensions */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkVideoFrameMetadataExtensions; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("E232A5B7-4DB4-44C9-9152-F47C12E5F051") + IDeckLinkVideoFrameMetadataExtensions : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetInt( + /* [in] */ BMDDeckLinkFrameMetadataID metadataID, + /* [out] */ LONGLONG *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFloat( + /* [in] */ BMDDeckLinkFrameMetadataID metadataID, + /* [out] */ double *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFlag( + /* [in] */ BMDDeckLinkFrameMetadataID metadataID, + /* [out] */ BOOL *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetString( + /* [in] */ BMDDeckLinkFrameMetadataID metadataID, + /* [out] */ BSTR *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBytes( + /* [in] */ BMDDeckLinkFrameMetadataID metadataID, + /* [out] */ void *buffer, + /* [out][in] */ unsigned int *bufferSize) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkVideoFrameMetadataExtensionsVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoFrameMetadataExtensions * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoFrameMetadataExtensions * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoFrameMetadataExtensions * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrameMetadataExtensions, GetInt) + HRESULT ( STDMETHODCALLTYPE *GetInt )( + IDeckLinkVideoFrameMetadataExtensions * This, + /* [in] */ BMDDeckLinkFrameMetadataID metadataID, + /* [out] */ LONGLONG *value); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrameMetadataExtensions, GetFloat) + HRESULT ( STDMETHODCALLTYPE *GetFloat )( + IDeckLinkVideoFrameMetadataExtensions * This, + /* [in] */ BMDDeckLinkFrameMetadataID metadataID, + /* [out] */ double *value); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrameMetadataExtensions, GetFlag) + HRESULT ( STDMETHODCALLTYPE *GetFlag )( + IDeckLinkVideoFrameMetadataExtensions * This, + /* [in] */ BMDDeckLinkFrameMetadataID metadataID, + /* [out] */ BOOL *value); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrameMetadataExtensions, GetString) + HRESULT ( STDMETHODCALLTYPE *GetString )( + IDeckLinkVideoFrameMetadataExtensions * This, + /* [in] */ BMDDeckLinkFrameMetadataID metadataID, + /* [out] */ BSTR *value); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrameMetadataExtensions, GetBytes) + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IDeckLinkVideoFrameMetadataExtensions * This, + /* [in] */ BMDDeckLinkFrameMetadataID metadataID, + /* [out] */ void *buffer, + /* [out][in] */ unsigned int *bufferSize); + + END_INTERFACE + } IDeckLinkVideoFrameMetadataExtensionsVtbl; + + interface IDeckLinkVideoFrameMetadataExtensions + { + CONST_VTBL struct IDeckLinkVideoFrameMetadataExtensionsVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkVideoFrameMetadataExtensions_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkVideoFrameMetadataExtensions_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkVideoFrameMetadataExtensions_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkVideoFrameMetadataExtensions_GetInt(This,metadataID,value) \ + ( (This)->lpVtbl -> GetInt(This,metadataID,value) ) + +#define IDeckLinkVideoFrameMetadataExtensions_GetFloat(This,metadataID,value) \ + ( (This)->lpVtbl -> GetFloat(This,metadataID,value) ) + +#define IDeckLinkVideoFrameMetadataExtensions_GetFlag(This,metadataID,value) \ + ( (This)->lpVtbl -> GetFlag(This,metadataID,value) ) + +#define IDeckLinkVideoFrameMetadataExtensions_GetString(This,metadataID,value) \ + ( (This)->lpVtbl -> GetString(This,metadataID,value) ) + +#define IDeckLinkVideoFrameMetadataExtensions_GetBytes(This,metadataID,buffer,bufferSize) \ + ( (This)->lpVtbl -> GetBytes(This,metadataID,buffer,bufferSize) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkVideoFrameMetadataExtensions_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkVideoFrameMutableMetadataExtensions_INTERFACE_DEFINED__ +#define __IDeckLinkVideoFrameMutableMetadataExtensions_INTERFACE_DEFINED__ + +/* interface IDeckLinkVideoFrameMutableMetadataExtensions */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkVideoFrameMutableMetadataExtensions; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("CC198FC6-8298-4419-942D-8357EC355E58") + IDeckLinkVideoFrameMutableMetadataExtensions : public IDeckLinkVideoFrameMetadataExtensions + { + public: + virtual HRESULT STDMETHODCALLTYPE SetInt( + /* [in] */ BMDDeckLinkFrameMetadataID metadataID, + /* [in] */ LONGLONG value) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetFloat( + /* [in] */ BMDDeckLinkFrameMetadataID metadataID, + /* [in] */ double value) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetFlag( + /* [in] */ BMDDeckLinkFrameMetadataID metadataID, + /* [in] */ BOOL value) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetString( + /* [in] */ BMDDeckLinkFrameMetadataID metadataID, + /* [in] */ BSTR value) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetBytes( + /* [in] */ BMDDeckLinkFrameMetadataID metadataID, + /* [in] */ void *buffer, + /* [in] */ unsigned int bufferSize) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkVideoFrameMutableMetadataExtensionsVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoFrameMutableMetadataExtensions * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoFrameMutableMetadataExtensions * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoFrameMutableMetadataExtensions * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrameMetadataExtensions, GetInt) + HRESULT ( STDMETHODCALLTYPE *GetInt )( + IDeckLinkVideoFrameMutableMetadataExtensions * This, + /* [in] */ BMDDeckLinkFrameMetadataID metadataID, + /* [out] */ LONGLONG *value); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrameMetadataExtensions, GetFloat) + HRESULT ( STDMETHODCALLTYPE *GetFloat )( + IDeckLinkVideoFrameMutableMetadataExtensions * This, + /* [in] */ BMDDeckLinkFrameMetadataID metadataID, + /* [out] */ double *value); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrameMetadataExtensions, GetFlag) + HRESULT ( STDMETHODCALLTYPE *GetFlag )( + IDeckLinkVideoFrameMutableMetadataExtensions * This, + /* [in] */ BMDDeckLinkFrameMetadataID metadataID, + /* [out] */ BOOL *value); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrameMetadataExtensions, GetString) + HRESULT ( STDMETHODCALLTYPE *GetString )( + IDeckLinkVideoFrameMutableMetadataExtensions * This, + /* [in] */ BMDDeckLinkFrameMetadataID metadataID, + /* [out] */ BSTR *value); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrameMetadataExtensions, GetBytes) + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IDeckLinkVideoFrameMutableMetadataExtensions * This, + /* [in] */ BMDDeckLinkFrameMetadataID metadataID, + /* [out] */ void *buffer, + /* [out][in] */ unsigned int *bufferSize); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrameMutableMetadataExtensions, SetInt) + HRESULT ( STDMETHODCALLTYPE *SetInt )( + IDeckLinkVideoFrameMutableMetadataExtensions * This, + /* [in] */ BMDDeckLinkFrameMetadataID metadataID, + /* [in] */ LONGLONG value); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrameMutableMetadataExtensions, SetFloat) + HRESULT ( STDMETHODCALLTYPE *SetFloat )( + IDeckLinkVideoFrameMutableMetadataExtensions * This, + /* [in] */ BMDDeckLinkFrameMetadataID metadataID, + /* [in] */ double value); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrameMutableMetadataExtensions, SetFlag) + HRESULT ( STDMETHODCALLTYPE *SetFlag )( + IDeckLinkVideoFrameMutableMetadataExtensions * This, + /* [in] */ BMDDeckLinkFrameMetadataID metadataID, + /* [in] */ BOOL value); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrameMutableMetadataExtensions, SetString) + HRESULT ( STDMETHODCALLTYPE *SetString )( + IDeckLinkVideoFrameMutableMetadataExtensions * This, + /* [in] */ BMDDeckLinkFrameMetadataID metadataID, + /* [in] */ BSTR value); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrameMutableMetadataExtensions, SetBytes) + HRESULT ( STDMETHODCALLTYPE *SetBytes )( + IDeckLinkVideoFrameMutableMetadataExtensions * This, + /* [in] */ BMDDeckLinkFrameMetadataID metadataID, + /* [in] */ void *buffer, + /* [in] */ unsigned int bufferSize); + + END_INTERFACE + } IDeckLinkVideoFrameMutableMetadataExtensionsVtbl; + + interface IDeckLinkVideoFrameMutableMetadataExtensions + { + CONST_VTBL struct IDeckLinkVideoFrameMutableMetadataExtensionsVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkVideoFrameMutableMetadataExtensions_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkVideoFrameMutableMetadataExtensions_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkVideoFrameMutableMetadataExtensions_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkVideoFrameMutableMetadataExtensions_GetInt(This,metadataID,value) \ + ( (This)->lpVtbl -> GetInt(This,metadataID,value) ) + +#define IDeckLinkVideoFrameMutableMetadataExtensions_GetFloat(This,metadataID,value) \ + ( (This)->lpVtbl -> GetFloat(This,metadataID,value) ) + +#define IDeckLinkVideoFrameMutableMetadataExtensions_GetFlag(This,metadataID,value) \ + ( (This)->lpVtbl -> GetFlag(This,metadataID,value) ) + +#define IDeckLinkVideoFrameMutableMetadataExtensions_GetString(This,metadataID,value) \ + ( (This)->lpVtbl -> GetString(This,metadataID,value) ) + +#define IDeckLinkVideoFrameMutableMetadataExtensions_GetBytes(This,metadataID,buffer,bufferSize) \ + ( (This)->lpVtbl -> GetBytes(This,metadataID,buffer,bufferSize) ) + + +#define IDeckLinkVideoFrameMutableMetadataExtensions_SetInt(This,metadataID,value) \ + ( (This)->lpVtbl -> SetInt(This,metadataID,value) ) + +#define IDeckLinkVideoFrameMutableMetadataExtensions_SetFloat(This,metadataID,value) \ + ( (This)->lpVtbl -> SetFloat(This,metadataID,value) ) + +#define IDeckLinkVideoFrameMutableMetadataExtensions_SetFlag(This,metadataID,value) \ + ( (This)->lpVtbl -> SetFlag(This,metadataID,value) ) + +#define IDeckLinkVideoFrameMutableMetadataExtensions_SetString(This,metadataID,value) \ + ( (This)->lpVtbl -> SetString(This,metadataID,value) ) + +#define IDeckLinkVideoFrameMutableMetadataExtensions_SetBytes(This,metadataID,buffer,bufferSize) \ + ( (This)->lpVtbl -> SetBytes(This,metadataID,buffer,bufferSize) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkVideoFrameMutableMetadataExtensions_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("C9ADD3D2-BE52-488D-AB2D-7FDEF7AF0C95") + 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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoInputFrame * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoInputFrame * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoInputFrame * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame, GetWidth) + long ( STDMETHODCALLTYPE *GetWidth )( + IDeckLinkVideoInputFrame * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame, GetHeight) + long ( STDMETHODCALLTYPE *GetHeight )( + IDeckLinkVideoInputFrame * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame, GetRowBytes) + long ( STDMETHODCALLTYPE *GetRowBytes )( + IDeckLinkVideoInputFrame * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame, GetPixelFormat) + BMDPixelFormat ( STDMETHODCALLTYPE *GetPixelFormat )( + IDeckLinkVideoInputFrame * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame, GetFlags) + BMDFrameFlags ( STDMETHODCALLTYPE *GetFlags )( + IDeckLinkVideoInputFrame * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame, GetTimecode) + HRESULT ( STDMETHODCALLTYPE *GetTimecode )( + IDeckLinkVideoInputFrame * This, + /* [in] */ BMDTimecodeFormat format, + /* [out] */ IDeckLinkTimecode **timecode); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame, GetAncillaryData) + HRESULT ( STDMETHODCALLTYPE *GetAncillaryData )( + IDeckLinkVideoInputFrame * This, + /* [out] */ IDeckLinkVideoFrameAncillary **ancillary); + + DECLSPEC_XFGVIRT(IDeckLinkVideoInputFrame, GetStreamTime) + HRESULT ( STDMETHODCALLTYPE *GetStreamTime )( + IDeckLinkVideoInputFrame * This, + /* [out] */ BMDTimeValue *frameTime, + /* [out] */ BMDTimeValue *frameDuration, + /* [in] */ BMDTimeScale timeScale); + + DECLSPEC_XFGVIRT(IDeckLinkVideoInputFrame, GetHardwareReferenceTimestamp) + 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_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 __IDeckLinkAncillaryPacket_INTERFACE_DEFINED__ +#define __IDeckLinkAncillaryPacket_INTERFACE_DEFINED__ + +/* interface IDeckLinkAncillaryPacket */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkAncillaryPacket; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("F5C0D498-5CD3-4C77-9773-8EFA20BB334B") + IDeckLinkAncillaryPacket : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetBytes( + /* [in] */ BMDAncillaryPacketFormat format, + /* [out] */ const void **data, + /* [out] */ unsigned int *size) = 0; + + virtual unsigned char STDMETHODCALLTYPE GetDID( void) = 0; + + virtual unsigned char STDMETHODCALLTYPE GetSDID( void) = 0; + + virtual unsigned int STDMETHODCALLTYPE GetLineNumber( void) = 0; + + virtual unsigned char STDMETHODCALLTYPE GetDataStreamIndex( void) = 0; + + virtual BMDAncillaryDataSpace STDMETHODCALLTYPE GetDataSpace( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkAncillaryPacketVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkAncillaryPacket * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkAncillaryPacket * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkAncillaryPacket * This); + + DECLSPEC_XFGVIRT(IDeckLinkAncillaryPacket, GetBytes) + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IDeckLinkAncillaryPacket * This, + /* [in] */ BMDAncillaryPacketFormat format, + /* [out] */ const void **data, + /* [out] */ unsigned int *size); + + DECLSPEC_XFGVIRT(IDeckLinkAncillaryPacket, GetDID) + unsigned char ( STDMETHODCALLTYPE *GetDID )( + IDeckLinkAncillaryPacket * This); + + DECLSPEC_XFGVIRT(IDeckLinkAncillaryPacket, GetSDID) + unsigned char ( STDMETHODCALLTYPE *GetSDID )( + IDeckLinkAncillaryPacket * This); + + DECLSPEC_XFGVIRT(IDeckLinkAncillaryPacket, GetLineNumber) + unsigned int ( STDMETHODCALLTYPE *GetLineNumber )( + IDeckLinkAncillaryPacket * This); + + DECLSPEC_XFGVIRT(IDeckLinkAncillaryPacket, GetDataStreamIndex) + unsigned char ( STDMETHODCALLTYPE *GetDataStreamIndex )( + IDeckLinkAncillaryPacket * This); + + DECLSPEC_XFGVIRT(IDeckLinkAncillaryPacket, GetDataSpace) + BMDAncillaryDataSpace ( STDMETHODCALLTYPE *GetDataSpace )( + IDeckLinkAncillaryPacket * This); + + END_INTERFACE + } IDeckLinkAncillaryPacketVtbl; + + interface IDeckLinkAncillaryPacket + { + CONST_VTBL struct IDeckLinkAncillaryPacketVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkAncillaryPacket_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkAncillaryPacket_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkAncillaryPacket_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkAncillaryPacket_GetBytes(This,format,data,size) \ + ( (This)->lpVtbl -> GetBytes(This,format,data,size) ) + +#define IDeckLinkAncillaryPacket_GetDID(This) \ + ( (This)->lpVtbl -> GetDID(This) ) + +#define IDeckLinkAncillaryPacket_GetSDID(This) \ + ( (This)->lpVtbl -> GetSDID(This) ) + +#define IDeckLinkAncillaryPacket_GetLineNumber(This) \ + ( (This)->lpVtbl -> GetLineNumber(This) ) + +#define IDeckLinkAncillaryPacket_GetDataStreamIndex(This) \ + ( (This)->lpVtbl -> GetDataStreamIndex(This) ) + +#define IDeckLinkAncillaryPacket_GetDataSpace(This) \ + ( (This)->lpVtbl -> GetDataSpace(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkAncillaryPacket_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkAncillaryPacketIterator_INTERFACE_DEFINED__ +#define __IDeckLinkAncillaryPacketIterator_INTERFACE_DEFINED__ + +/* interface IDeckLinkAncillaryPacketIterator */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkAncillaryPacketIterator; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("10F1AA88-54BE-42F7-B9F8-EC2F5F099551") + IDeckLinkAncillaryPacketIterator : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Next( + /* [out] */ IDeckLinkAncillaryPacket **packet) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkAncillaryPacketIteratorVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkAncillaryPacketIterator * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkAncillaryPacketIterator * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkAncillaryPacketIterator * This); + + DECLSPEC_XFGVIRT(IDeckLinkAncillaryPacketIterator, Next) + HRESULT ( STDMETHODCALLTYPE *Next )( + IDeckLinkAncillaryPacketIterator * This, + /* [out] */ IDeckLinkAncillaryPacket **packet); + + END_INTERFACE + } IDeckLinkAncillaryPacketIteratorVtbl; + + interface IDeckLinkAncillaryPacketIterator + { + CONST_VTBL struct IDeckLinkAncillaryPacketIteratorVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkAncillaryPacketIterator_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkAncillaryPacketIterator_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkAncillaryPacketIterator_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkAncillaryPacketIterator_Next(This,packet) \ + ( (This)->lpVtbl -> Next(This,packet) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkAncillaryPacketIterator_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkVideoFrameAncillaryPackets_INTERFACE_DEFINED__ +#define __IDeckLinkVideoFrameAncillaryPackets_INTERFACE_DEFINED__ + +/* interface IDeckLinkVideoFrameAncillaryPackets */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkVideoFrameAncillaryPackets; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("8A72D630-8070-4D05-8A93-E60C40EE088A") + IDeckLinkVideoFrameAncillaryPackets : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetPacketIterator( + /* [out] */ IDeckLinkAncillaryPacketIterator **iterator) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFirstPacketByID( + /* [in] */ unsigned char DID, + /* [in] */ unsigned char SDID, + /* [out] */ IDeckLinkAncillaryPacket **packet) = 0; + + virtual HRESULT STDMETHODCALLTYPE AttachPacket( + /* [in] */ IDeckLinkAncillaryPacket *packet) = 0; + + virtual HRESULT STDMETHODCALLTYPE DetachPacket( + /* [in] */ IDeckLinkAncillaryPacket *packet) = 0; + + virtual HRESULT STDMETHODCALLTYPE DetachAllPackets( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkVideoFrameAncillaryPacketsVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoFrameAncillaryPackets * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoFrameAncillaryPackets * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoFrameAncillaryPackets * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrameAncillaryPackets, GetPacketIterator) + HRESULT ( STDMETHODCALLTYPE *GetPacketIterator )( + IDeckLinkVideoFrameAncillaryPackets * This, + /* [out] */ IDeckLinkAncillaryPacketIterator **iterator); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrameAncillaryPackets, GetFirstPacketByID) + HRESULT ( STDMETHODCALLTYPE *GetFirstPacketByID )( + IDeckLinkVideoFrameAncillaryPackets * This, + /* [in] */ unsigned char DID, + /* [in] */ unsigned char SDID, + /* [out] */ IDeckLinkAncillaryPacket **packet); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrameAncillaryPackets, AttachPacket) + HRESULT ( STDMETHODCALLTYPE *AttachPacket )( + IDeckLinkVideoFrameAncillaryPackets * This, + /* [in] */ IDeckLinkAncillaryPacket *packet); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrameAncillaryPackets, DetachPacket) + HRESULT ( STDMETHODCALLTYPE *DetachPacket )( + IDeckLinkVideoFrameAncillaryPackets * This, + /* [in] */ IDeckLinkAncillaryPacket *packet); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrameAncillaryPackets, DetachAllPackets) + HRESULT ( STDMETHODCALLTYPE *DetachAllPackets )( + IDeckLinkVideoFrameAncillaryPackets * This); + + END_INTERFACE + } IDeckLinkVideoFrameAncillaryPacketsVtbl; + + interface IDeckLinkVideoFrameAncillaryPackets + { + CONST_VTBL struct IDeckLinkVideoFrameAncillaryPacketsVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkVideoFrameAncillaryPackets_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkVideoFrameAncillaryPackets_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkVideoFrameAncillaryPackets_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkVideoFrameAncillaryPackets_GetPacketIterator(This,iterator) \ + ( (This)->lpVtbl -> GetPacketIterator(This,iterator) ) + +#define IDeckLinkVideoFrameAncillaryPackets_GetFirstPacketByID(This,DID,SDID,packet) \ + ( (This)->lpVtbl -> GetFirstPacketByID(This,DID,SDID,packet) ) + +#define IDeckLinkVideoFrameAncillaryPackets_AttachPacket(This,packet) \ + ( (This)->lpVtbl -> AttachPacket(This,packet) ) + +#define IDeckLinkVideoFrameAncillaryPackets_DetachPacket(This,packet) \ + ( (This)->lpVtbl -> DetachPacket(This,packet) ) + +#define IDeckLinkVideoFrameAncillaryPackets_DetachAllPackets(This) \ + ( (This)->lpVtbl -> DetachAllPackets(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkVideoFrameAncillaryPackets_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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoFrameAncillary * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoFrameAncillary * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoFrameAncillary * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrameAncillary, GetBufferForVerticalBlankingLine) + HRESULT ( STDMETHODCALLTYPE *GetBufferForVerticalBlankingLine )( + IDeckLinkVideoFrameAncillary * This, + /* [in] */ unsigned int lineNumber, + /* [out] */ void **buffer); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrameAncillary, GetPixelFormat) + BMDPixelFormat ( STDMETHODCALLTYPE *GetPixelFormat )( + IDeckLinkVideoFrameAncillary * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrameAncillary, GetDisplayMode) + 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 __IDeckLinkEncoderPacket_INTERFACE_DEFINED__ +#define __IDeckLinkEncoderPacket_INTERFACE_DEFINED__ + +/* interface IDeckLinkEncoderPacket */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkEncoderPacket; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("B693F36C-316E-4AF1-B6C2-F389A4BCA620") + IDeckLinkEncoderPacket : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetBytes( + /* [out] */ void **buffer) = 0; + + virtual long STDMETHODCALLTYPE GetSize( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStreamTime( + /* [out] */ BMDTimeValue *frameTime, + /* [in] */ BMDTimeScale timeScale) = 0; + + virtual BMDPacketType STDMETHODCALLTYPE GetPacketType( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkEncoderPacketVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkEncoderPacket * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkEncoderPacket * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkEncoderPacket * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderPacket, GetBytes) + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IDeckLinkEncoderPacket * This, + /* [out] */ void **buffer); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderPacket, GetSize) + long ( STDMETHODCALLTYPE *GetSize )( + IDeckLinkEncoderPacket * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderPacket, GetStreamTime) + HRESULT ( STDMETHODCALLTYPE *GetStreamTime )( + IDeckLinkEncoderPacket * This, + /* [out] */ BMDTimeValue *frameTime, + /* [in] */ BMDTimeScale timeScale); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderPacket, GetPacketType) + BMDPacketType ( STDMETHODCALLTYPE *GetPacketType )( + IDeckLinkEncoderPacket * This); + + END_INTERFACE + } IDeckLinkEncoderPacketVtbl; + + interface IDeckLinkEncoderPacket + { + CONST_VTBL struct IDeckLinkEncoderPacketVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkEncoderPacket_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkEncoderPacket_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkEncoderPacket_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkEncoderPacket_GetBytes(This,buffer) \ + ( (This)->lpVtbl -> GetBytes(This,buffer) ) + +#define IDeckLinkEncoderPacket_GetSize(This) \ + ( (This)->lpVtbl -> GetSize(This) ) + +#define IDeckLinkEncoderPacket_GetStreamTime(This,frameTime,timeScale) \ + ( (This)->lpVtbl -> GetStreamTime(This,frameTime,timeScale) ) + +#define IDeckLinkEncoderPacket_GetPacketType(This) \ + ( (This)->lpVtbl -> GetPacketType(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkEncoderPacket_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkEncoderVideoPacket_INTERFACE_DEFINED__ +#define __IDeckLinkEncoderVideoPacket_INTERFACE_DEFINED__ + +/* interface IDeckLinkEncoderVideoPacket */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkEncoderVideoPacket; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("4E7FD944-E8C7-4EAC-B8C0-7B77F80F5AE0") + IDeckLinkEncoderVideoPacket : public IDeckLinkEncoderPacket + { + public: + virtual BMDPixelFormat STDMETHODCALLTYPE GetPixelFormat( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetHardwareReferenceTimestamp( + /* [in] */ BMDTimeScale timeScale, + /* [out] */ BMDTimeValue *frameTime, + /* [out] */ BMDTimeValue *frameDuration) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTimecode( + /* [in] */ BMDTimecodeFormat format, + /* [out] */ IDeckLinkTimecode **timecode) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkEncoderVideoPacketVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkEncoderVideoPacket * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkEncoderVideoPacket * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkEncoderVideoPacket * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderPacket, GetBytes) + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IDeckLinkEncoderVideoPacket * This, + /* [out] */ void **buffer); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderPacket, GetSize) + long ( STDMETHODCALLTYPE *GetSize )( + IDeckLinkEncoderVideoPacket * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderPacket, GetStreamTime) + HRESULT ( STDMETHODCALLTYPE *GetStreamTime )( + IDeckLinkEncoderVideoPacket * This, + /* [out] */ BMDTimeValue *frameTime, + /* [in] */ BMDTimeScale timeScale); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderPacket, GetPacketType) + BMDPacketType ( STDMETHODCALLTYPE *GetPacketType )( + IDeckLinkEncoderVideoPacket * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderVideoPacket, GetPixelFormat) + BMDPixelFormat ( STDMETHODCALLTYPE *GetPixelFormat )( + IDeckLinkEncoderVideoPacket * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderVideoPacket, GetHardwareReferenceTimestamp) + HRESULT ( STDMETHODCALLTYPE *GetHardwareReferenceTimestamp )( + IDeckLinkEncoderVideoPacket * This, + /* [in] */ BMDTimeScale timeScale, + /* [out] */ BMDTimeValue *frameTime, + /* [out] */ BMDTimeValue *frameDuration); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderVideoPacket, GetTimecode) + HRESULT ( STDMETHODCALLTYPE *GetTimecode )( + IDeckLinkEncoderVideoPacket * This, + /* [in] */ BMDTimecodeFormat format, + /* [out] */ IDeckLinkTimecode **timecode); + + END_INTERFACE + } IDeckLinkEncoderVideoPacketVtbl; + + interface IDeckLinkEncoderVideoPacket + { + CONST_VTBL struct IDeckLinkEncoderVideoPacketVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkEncoderVideoPacket_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkEncoderVideoPacket_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkEncoderVideoPacket_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkEncoderVideoPacket_GetBytes(This,buffer) \ + ( (This)->lpVtbl -> GetBytes(This,buffer) ) + +#define IDeckLinkEncoderVideoPacket_GetSize(This) \ + ( (This)->lpVtbl -> GetSize(This) ) + +#define IDeckLinkEncoderVideoPacket_GetStreamTime(This,frameTime,timeScale) \ + ( (This)->lpVtbl -> GetStreamTime(This,frameTime,timeScale) ) + +#define IDeckLinkEncoderVideoPacket_GetPacketType(This) \ + ( (This)->lpVtbl -> GetPacketType(This) ) + + +#define IDeckLinkEncoderVideoPacket_GetPixelFormat(This) \ + ( (This)->lpVtbl -> GetPixelFormat(This) ) + +#define IDeckLinkEncoderVideoPacket_GetHardwareReferenceTimestamp(This,timeScale,frameTime,frameDuration) \ + ( (This)->lpVtbl -> GetHardwareReferenceTimestamp(This,timeScale,frameTime,frameDuration) ) + +#define IDeckLinkEncoderVideoPacket_GetTimecode(This,format,timecode) \ + ( (This)->lpVtbl -> GetTimecode(This,format,timecode) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkEncoderVideoPacket_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkEncoderAudioPacket_INTERFACE_DEFINED__ +#define __IDeckLinkEncoderAudioPacket_INTERFACE_DEFINED__ + +/* interface IDeckLinkEncoderAudioPacket */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkEncoderAudioPacket; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("49E8EDC8-693B-4E14-8EF6-12C658F5A07A") + IDeckLinkEncoderAudioPacket : public IDeckLinkEncoderPacket + { + public: + virtual BMDAudioFormat STDMETHODCALLTYPE GetAudioFormat( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkEncoderAudioPacketVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkEncoderAudioPacket * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkEncoderAudioPacket * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkEncoderAudioPacket * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderPacket, GetBytes) + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IDeckLinkEncoderAudioPacket * This, + /* [out] */ void **buffer); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderPacket, GetSize) + long ( STDMETHODCALLTYPE *GetSize )( + IDeckLinkEncoderAudioPacket * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderPacket, GetStreamTime) + HRESULT ( STDMETHODCALLTYPE *GetStreamTime )( + IDeckLinkEncoderAudioPacket * This, + /* [out] */ BMDTimeValue *frameTime, + /* [in] */ BMDTimeScale timeScale); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderPacket, GetPacketType) + BMDPacketType ( STDMETHODCALLTYPE *GetPacketType )( + IDeckLinkEncoderAudioPacket * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderAudioPacket, GetAudioFormat) + BMDAudioFormat ( STDMETHODCALLTYPE *GetAudioFormat )( + IDeckLinkEncoderAudioPacket * This); + + END_INTERFACE + } IDeckLinkEncoderAudioPacketVtbl; + + interface IDeckLinkEncoderAudioPacket + { + CONST_VTBL struct IDeckLinkEncoderAudioPacketVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkEncoderAudioPacket_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkEncoderAudioPacket_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkEncoderAudioPacket_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkEncoderAudioPacket_GetBytes(This,buffer) \ + ( (This)->lpVtbl -> GetBytes(This,buffer) ) + +#define IDeckLinkEncoderAudioPacket_GetSize(This) \ + ( (This)->lpVtbl -> GetSize(This) ) + +#define IDeckLinkEncoderAudioPacket_GetStreamTime(This,frameTime,timeScale) \ + ( (This)->lpVtbl -> GetStreamTime(This,frameTime,timeScale) ) + +#define IDeckLinkEncoderAudioPacket_GetPacketType(This) \ + ( (This)->lpVtbl -> GetPacketType(This) ) + + +#define IDeckLinkEncoderAudioPacket_GetAudioFormat(This) \ + ( (This)->lpVtbl -> GetAudioFormat(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkEncoderAudioPacket_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkH265NALPacket_INTERFACE_DEFINED__ +#define __IDeckLinkH265NALPacket_INTERFACE_DEFINED__ + +/* interface IDeckLinkH265NALPacket */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkH265NALPacket; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("639C8E0B-68D5-4BDE-A6D4-95F3AEAFF2E7") + IDeckLinkH265NALPacket : public IDeckLinkEncoderVideoPacket + { + public: + virtual HRESULT STDMETHODCALLTYPE GetUnitType( + /* [out] */ unsigned char *unitType) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBytesNoPrefix( + /* [out] */ void **buffer) = 0; + + virtual long STDMETHODCALLTYPE GetSizeNoPrefix( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkH265NALPacketVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkH265NALPacket * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkH265NALPacket * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkH265NALPacket * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderPacket, GetBytes) + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IDeckLinkH265NALPacket * This, + /* [out] */ void **buffer); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderPacket, GetSize) + long ( STDMETHODCALLTYPE *GetSize )( + IDeckLinkH265NALPacket * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderPacket, GetStreamTime) + HRESULT ( STDMETHODCALLTYPE *GetStreamTime )( + IDeckLinkH265NALPacket * This, + /* [out] */ BMDTimeValue *frameTime, + /* [in] */ BMDTimeScale timeScale); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderPacket, GetPacketType) + BMDPacketType ( STDMETHODCALLTYPE *GetPacketType )( + IDeckLinkH265NALPacket * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderVideoPacket, GetPixelFormat) + BMDPixelFormat ( STDMETHODCALLTYPE *GetPixelFormat )( + IDeckLinkH265NALPacket * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderVideoPacket, GetHardwareReferenceTimestamp) + HRESULT ( STDMETHODCALLTYPE *GetHardwareReferenceTimestamp )( + IDeckLinkH265NALPacket * This, + /* [in] */ BMDTimeScale timeScale, + /* [out] */ BMDTimeValue *frameTime, + /* [out] */ BMDTimeValue *frameDuration); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderVideoPacket, GetTimecode) + HRESULT ( STDMETHODCALLTYPE *GetTimecode )( + IDeckLinkH265NALPacket * This, + /* [in] */ BMDTimecodeFormat format, + /* [out] */ IDeckLinkTimecode **timecode); + + DECLSPEC_XFGVIRT(IDeckLinkH265NALPacket, GetUnitType) + HRESULT ( STDMETHODCALLTYPE *GetUnitType )( + IDeckLinkH265NALPacket * This, + /* [out] */ unsigned char *unitType); + + DECLSPEC_XFGVIRT(IDeckLinkH265NALPacket, GetBytesNoPrefix) + HRESULT ( STDMETHODCALLTYPE *GetBytesNoPrefix )( + IDeckLinkH265NALPacket * This, + /* [out] */ void **buffer); + + DECLSPEC_XFGVIRT(IDeckLinkH265NALPacket, GetSizeNoPrefix) + long ( STDMETHODCALLTYPE *GetSizeNoPrefix )( + IDeckLinkH265NALPacket * This); + + END_INTERFACE + } IDeckLinkH265NALPacketVtbl; + + interface IDeckLinkH265NALPacket + { + CONST_VTBL struct IDeckLinkH265NALPacketVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkH265NALPacket_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkH265NALPacket_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkH265NALPacket_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkH265NALPacket_GetBytes(This,buffer) \ + ( (This)->lpVtbl -> GetBytes(This,buffer) ) + +#define IDeckLinkH265NALPacket_GetSize(This) \ + ( (This)->lpVtbl -> GetSize(This) ) + +#define IDeckLinkH265NALPacket_GetStreamTime(This,frameTime,timeScale) \ + ( (This)->lpVtbl -> GetStreamTime(This,frameTime,timeScale) ) + +#define IDeckLinkH265NALPacket_GetPacketType(This) \ + ( (This)->lpVtbl -> GetPacketType(This) ) + + +#define IDeckLinkH265NALPacket_GetPixelFormat(This) \ + ( (This)->lpVtbl -> GetPixelFormat(This) ) + +#define IDeckLinkH265NALPacket_GetHardwareReferenceTimestamp(This,timeScale,frameTime,frameDuration) \ + ( (This)->lpVtbl -> GetHardwareReferenceTimestamp(This,timeScale,frameTime,frameDuration) ) + +#define IDeckLinkH265NALPacket_GetTimecode(This,format,timecode) \ + ( (This)->lpVtbl -> GetTimecode(This,format,timecode) ) + + +#define IDeckLinkH265NALPacket_GetUnitType(This,unitType) \ + ( (This)->lpVtbl -> GetUnitType(This,unitType) ) + +#define IDeckLinkH265NALPacket_GetBytesNoPrefix(This,buffer) \ + ( (This)->lpVtbl -> GetBytesNoPrefix(This,buffer) ) + +#define IDeckLinkH265NALPacket_GetSizeNoPrefix(This) \ + ( (This)->lpVtbl -> GetSizeNoPrefix(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkH265NALPacket_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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkAudioInputPacket * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkAudioInputPacket * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkAudioInputPacket * This); + + DECLSPEC_XFGVIRT(IDeckLinkAudioInputPacket, GetSampleFrameCount) + long ( STDMETHODCALLTYPE *GetSampleFrameCount )( + IDeckLinkAudioInputPacket * This); + + DECLSPEC_XFGVIRT(IDeckLinkAudioInputPacket, GetBytes) + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IDeckLinkAudioInputPacket * This, + /* [out] */ void **buffer); + + DECLSPEC_XFGVIRT(IDeckLinkAudioInputPacket, GetPacketTime) + 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("D4FA2345-9FBA-4497-95C3-C0C3CED3CDA8") + IDeckLinkScreenPreviewCallback : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE DrawFrame( + /* [in] */ IDeckLinkVideoFrame *theFrame) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkScreenPreviewCallbackVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkScreenPreviewCallback * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkScreenPreviewCallback * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkScreenPreviewCallback * This); + + DECLSPEC_XFGVIRT(IDeckLinkScreenPreviewCallback, DrawFrame) + 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("CEB778E2-C202-4EC8-9085-0CD285CC5522") + 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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkGLScreenPreviewHelper * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkGLScreenPreviewHelper * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkGLScreenPreviewHelper * This); + + DECLSPEC_XFGVIRT(IDeckLinkGLScreenPreviewHelper, InitializeGL) + HRESULT ( STDMETHODCALLTYPE *InitializeGL )( + IDeckLinkGLScreenPreviewHelper * This); + + DECLSPEC_XFGVIRT(IDeckLinkGLScreenPreviewHelper, PaintGL) + HRESULT ( STDMETHODCALLTYPE *PaintGL )( + IDeckLinkGLScreenPreviewHelper * This); + + DECLSPEC_XFGVIRT(IDeckLinkGLScreenPreviewHelper, SetFrame) + HRESULT ( STDMETHODCALLTYPE *SetFrame )( + IDeckLinkGLScreenPreviewHelper * This, + /* [in] */ IDeckLinkVideoFrame *theFrame); + + DECLSPEC_XFGVIRT(IDeckLinkGLScreenPreviewHelper, Set3DPreviewFormat) + 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("F2DD78CA-2921-4AC2-B5BC-BFDCC2035A1F") + 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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkDX9ScreenPreviewHelper * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkDX9ScreenPreviewHelper * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkDX9ScreenPreviewHelper * This); + + DECLSPEC_XFGVIRT(IDeckLinkDX9ScreenPreviewHelper, Initialize) + HRESULT ( STDMETHODCALLTYPE *Initialize )( + IDeckLinkDX9ScreenPreviewHelper * This, + /* [in] */ void *device); + + DECLSPEC_XFGVIRT(IDeckLinkDX9ScreenPreviewHelper, Render) + HRESULT ( STDMETHODCALLTYPE *Render )( + IDeckLinkDX9ScreenPreviewHelper * This, + /* [in] */ RECT *rc); + + DECLSPEC_XFGVIRT(IDeckLinkDX9ScreenPreviewHelper, SetFrame) + HRESULT ( STDMETHODCALLTYPE *SetFrame )( + IDeckLinkDX9ScreenPreviewHelper * This, + /* [in] */ IDeckLinkVideoFrame *theFrame); + + DECLSPEC_XFGVIRT(IDeckLinkDX9ScreenPreviewHelper, Set3DPreviewFormat) + 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 __IDeckLinkWPFDX9ScreenPreviewHelper_INTERFACE_DEFINED__ +#define __IDeckLinkWPFDX9ScreenPreviewHelper_INTERFACE_DEFINED__ + +/* interface IDeckLinkWPFDX9ScreenPreviewHelper */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkWPFDX9ScreenPreviewHelper; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("C59346CD-9326-4266-AC2D-5C190F5799EE") + IDeckLinkWPFDX9ScreenPreviewHelper : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Initialize( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Render( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetSurfaceSize( + /* [in] */ unsigned int width, + /* [in] */ unsigned int height) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetFrame( + /* [in] */ IDeckLinkVideoFrame *theFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE Set3DPreviewFormat( + /* [in] */ BMD3DPreviewFormat previewFormat) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBackBuffer( + /* [out] */ void **backBuffer) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkWPFDX9ScreenPreviewHelperVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkWPFDX9ScreenPreviewHelper * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkWPFDX9ScreenPreviewHelper * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkWPFDX9ScreenPreviewHelper * This); + + DECLSPEC_XFGVIRT(IDeckLinkWPFDX9ScreenPreviewHelper, Initialize) + HRESULT ( STDMETHODCALLTYPE *Initialize )( + IDeckLinkWPFDX9ScreenPreviewHelper * This); + + DECLSPEC_XFGVIRT(IDeckLinkWPFDX9ScreenPreviewHelper, Render) + HRESULT ( STDMETHODCALLTYPE *Render )( + IDeckLinkWPFDX9ScreenPreviewHelper * This); + + DECLSPEC_XFGVIRT(IDeckLinkWPFDX9ScreenPreviewHelper, SetSurfaceSize) + HRESULT ( STDMETHODCALLTYPE *SetSurfaceSize )( + IDeckLinkWPFDX9ScreenPreviewHelper * This, + /* [in] */ unsigned int width, + /* [in] */ unsigned int height); + + DECLSPEC_XFGVIRT(IDeckLinkWPFDX9ScreenPreviewHelper, SetFrame) + HRESULT ( STDMETHODCALLTYPE *SetFrame )( + IDeckLinkWPFDX9ScreenPreviewHelper * This, + /* [in] */ IDeckLinkVideoFrame *theFrame); + + DECLSPEC_XFGVIRT(IDeckLinkWPFDX9ScreenPreviewHelper, Set3DPreviewFormat) + HRESULT ( STDMETHODCALLTYPE *Set3DPreviewFormat )( + IDeckLinkWPFDX9ScreenPreviewHelper * This, + /* [in] */ BMD3DPreviewFormat previewFormat); + + DECLSPEC_XFGVIRT(IDeckLinkWPFDX9ScreenPreviewHelper, GetBackBuffer) + HRESULT ( STDMETHODCALLTYPE *GetBackBuffer )( + IDeckLinkWPFDX9ScreenPreviewHelper * This, + /* [out] */ void **backBuffer); + + END_INTERFACE + } IDeckLinkWPFDX9ScreenPreviewHelperVtbl; + + interface IDeckLinkWPFDX9ScreenPreviewHelper + { + CONST_VTBL struct IDeckLinkWPFDX9ScreenPreviewHelperVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkWPFDX9ScreenPreviewHelper_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkWPFDX9ScreenPreviewHelper_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkWPFDX9ScreenPreviewHelper_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkWPFDX9ScreenPreviewHelper_Initialize(This) \ + ( (This)->lpVtbl -> Initialize(This) ) + +#define IDeckLinkWPFDX9ScreenPreviewHelper_Render(This) \ + ( (This)->lpVtbl -> Render(This) ) + +#define IDeckLinkWPFDX9ScreenPreviewHelper_SetSurfaceSize(This,width,height) \ + ( (This)->lpVtbl -> SetSurfaceSize(This,width,height) ) + +#define IDeckLinkWPFDX9ScreenPreviewHelper_SetFrame(This,theFrame) \ + ( (This)->lpVtbl -> SetFrame(This,theFrame) ) + +#define IDeckLinkWPFDX9ScreenPreviewHelper_Set3DPreviewFormat(This,previewFormat) \ + ( (This)->lpVtbl -> Set3DPreviewFormat(This,previewFormat) ) + +#define IDeckLinkWPFDX9ScreenPreviewHelper_GetBackBuffer(This,backBuffer) \ + ( (This)->lpVtbl -> GetBackBuffer(This,backBuffer) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkWPFDX9ScreenPreviewHelper_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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkNotificationCallback * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkNotificationCallback * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkNotificationCallback * This); + + DECLSPEC_XFGVIRT(IDeckLinkNotificationCallback, Notify) + 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("1d70faac-fd27-4866-9de6-0939d1e4c7f1") + 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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkNotification * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkNotification * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkNotification * This); + + DECLSPEC_XFGVIRT(IDeckLinkNotification, Subscribe) + HRESULT ( STDMETHODCALLTYPE *Subscribe )( + IDeckLinkNotification * This, + /* [in] */ BMDNotifications topic, + /* [in] */ IDeckLinkNotificationCallback *theCallback); + + DECLSPEC_XFGVIRT(IDeckLinkNotification, Unsubscribe) + 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 __IDeckLinkProfileAttributes_INTERFACE_DEFINED__ +#define __IDeckLinkProfileAttributes_INTERFACE_DEFINED__ + +/* interface IDeckLinkProfileAttributes */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkProfileAttributes; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("F47551D7-AD22-47AF-BCFD-6BE88AA879D9") + IDeckLinkProfileAttributes : 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; + + virtual HRESULT STDMETHODCALLTYPE GetStringWithParam( + /* [in] */ BMDDeckLinkAttributeID cfgID, + /* [in] */ ULONGLONG param, + /* [out] */ BSTR *value) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkProfileAttributesVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkProfileAttributes * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkProfileAttributes * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkProfileAttributes * This); + + DECLSPEC_XFGVIRT(IDeckLinkProfileAttributes, GetFlag) + HRESULT ( STDMETHODCALLTYPE *GetFlag )( + IDeckLinkProfileAttributes * This, + /* [in] */ BMDDeckLinkAttributeID cfgID, + /* [out] */ BOOL *value); + + DECLSPEC_XFGVIRT(IDeckLinkProfileAttributes, GetInt) + HRESULT ( STDMETHODCALLTYPE *GetInt )( + IDeckLinkProfileAttributes * This, + /* [in] */ BMDDeckLinkAttributeID cfgID, + /* [out] */ LONGLONG *value); + + DECLSPEC_XFGVIRT(IDeckLinkProfileAttributes, GetFloat) + HRESULT ( STDMETHODCALLTYPE *GetFloat )( + IDeckLinkProfileAttributes * This, + /* [in] */ BMDDeckLinkAttributeID cfgID, + /* [out] */ double *value); + + DECLSPEC_XFGVIRT(IDeckLinkProfileAttributes, GetString) + HRESULT ( STDMETHODCALLTYPE *GetString )( + IDeckLinkProfileAttributes * This, + /* [in] */ BMDDeckLinkAttributeID cfgID, + /* [out] */ BSTR *value); + + DECLSPEC_XFGVIRT(IDeckLinkProfileAttributes, GetStringWithParam) + HRESULT ( STDMETHODCALLTYPE *GetStringWithParam )( + IDeckLinkProfileAttributes * This, + /* [in] */ BMDDeckLinkAttributeID cfgID, + /* [in] */ ULONGLONG param, + /* [out] */ BSTR *value); + + END_INTERFACE + } IDeckLinkProfileAttributesVtbl; + + interface IDeckLinkProfileAttributes + { + CONST_VTBL struct IDeckLinkProfileAttributesVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkProfileAttributes_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkProfileAttributes_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkProfileAttributes_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkProfileAttributes_GetFlag(This,cfgID,value) \ + ( (This)->lpVtbl -> GetFlag(This,cfgID,value) ) + +#define IDeckLinkProfileAttributes_GetInt(This,cfgID,value) \ + ( (This)->lpVtbl -> GetInt(This,cfgID,value) ) + +#define IDeckLinkProfileAttributes_GetFloat(This,cfgID,value) \ + ( (This)->lpVtbl -> GetFloat(This,cfgID,value) ) + +#define IDeckLinkProfileAttributes_GetString(This,cfgID,value) \ + ( (This)->lpVtbl -> GetString(This,cfgID,value) ) + +#define IDeckLinkProfileAttributes_GetStringWithParam(This,cfgID,param,value) \ + ( (This)->lpVtbl -> GetStringWithParam(This,cfgID,param,value) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkProfileAttributes_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkProfileIterator_INTERFACE_DEFINED__ +#define __IDeckLinkProfileIterator_INTERFACE_DEFINED__ + +/* interface IDeckLinkProfileIterator */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkProfileIterator; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("29E5A8C0-8BE4-46EB-93AC-31DAAB5B7BF2") + IDeckLinkProfileIterator : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Next( + /* [out] */ IDeckLinkProfile **profile) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkProfileIteratorVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkProfileIterator * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkProfileIterator * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkProfileIterator * This); + + DECLSPEC_XFGVIRT(IDeckLinkProfileIterator, Next) + HRESULT ( STDMETHODCALLTYPE *Next )( + IDeckLinkProfileIterator * This, + /* [out] */ IDeckLinkProfile **profile); + + END_INTERFACE + } IDeckLinkProfileIteratorVtbl; + + interface IDeckLinkProfileIterator + { + CONST_VTBL struct IDeckLinkProfileIteratorVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkProfileIterator_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkProfileIterator_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkProfileIterator_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkProfileIterator_Next(This,profile) \ + ( (This)->lpVtbl -> Next(This,profile) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkProfileIterator_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkProfile_INTERFACE_DEFINED__ +#define __IDeckLinkProfile_INTERFACE_DEFINED__ + +/* interface IDeckLinkProfile */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkProfile; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("16093466-674A-432B-9DA0-1AC2C5A8241C") + IDeckLinkProfile : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetDevice( + /* [out] */ IDeckLink **device) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsActive( + /* [out] */ BOOL *isActive) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetActive( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPeers( + /* [out] */ IDeckLinkProfileIterator **profileIterator) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkProfileVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkProfile * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkProfile * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkProfile * This); + + DECLSPEC_XFGVIRT(IDeckLinkProfile, GetDevice) + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + IDeckLinkProfile * This, + /* [out] */ IDeckLink **device); + + DECLSPEC_XFGVIRT(IDeckLinkProfile, IsActive) + HRESULT ( STDMETHODCALLTYPE *IsActive )( + IDeckLinkProfile * This, + /* [out] */ BOOL *isActive); + + DECLSPEC_XFGVIRT(IDeckLinkProfile, SetActive) + HRESULT ( STDMETHODCALLTYPE *SetActive )( + IDeckLinkProfile * This); + + DECLSPEC_XFGVIRT(IDeckLinkProfile, GetPeers) + HRESULT ( STDMETHODCALLTYPE *GetPeers )( + IDeckLinkProfile * This, + /* [out] */ IDeckLinkProfileIterator **profileIterator); + + END_INTERFACE + } IDeckLinkProfileVtbl; + + interface IDeckLinkProfile + { + CONST_VTBL struct IDeckLinkProfileVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkProfile_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkProfile_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkProfile_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkProfile_GetDevice(This,device) \ + ( (This)->lpVtbl -> GetDevice(This,device) ) + +#define IDeckLinkProfile_IsActive(This,isActive) \ + ( (This)->lpVtbl -> IsActive(This,isActive) ) + +#define IDeckLinkProfile_SetActive(This) \ + ( (This)->lpVtbl -> SetActive(This) ) + +#define IDeckLinkProfile_GetPeers(This,profileIterator) \ + ( (This)->lpVtbl -> GetPeers(This,profileIterator) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkProfile_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkProfileCallback_INTERFACE_DEFINED__ +#define __IDeckLinkProfileCallback_INTERFACE_DEFINED__ + +/* interface IDeckLinkProfileCallback */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkProfileCallback; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("A4F9341E-97AA-4E04-8935-15F809898CEA") + IDeckLinkProfileCallback : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE ProfileChanging( + /* [in] */ IDeckLinkProfile *profileToBeActivated, + /* [in] */ BOOL streamsWillBeForcedToStop) = 0; + + virtual HRESULT STDMETHODCALLTYPE ProfileActivated( + /* [in] */ IDeckLinkProfile *activatedProfile) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkProfileCallbackVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkProfileCallback * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkProfileCallback * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkProfileCallback * This); + + DECLSPEC_XFGVIRT(IDeckLinkProfileCallback, ProfileChanging) + HRESULT ( STDMETHODCALLTYPE *ProfileChanging )( + IDeckLinkProfileCallback * This, + /* [in] */ IDeckLinkProfile *profileToBeActivated, + /* [in] */ BOOL streamsWillBeForcedToStop); + + DECLSPEC_XFGVIRT(IDeckLinkProfileCallback, ProfileActivated) + HRESULT ( STDMETHODCALLTYPE *ProfileActivated )( + IDeckLinkProfileCallback * This, + /* [in] */ IDeckLinkProfile *activatedProfile); + + END_INTERFACE + } IDeckLinkProfileCallbackVtbl; + + interface IDeckLinkProfileCallback + { + CONST_VTBL struct IDeckLinkProfileCallbackVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkProfileCallback_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkProfileCallback_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkProfileCallback_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkProfileCallback_ProfileChanging(This,profileToBeActivated,streamsWillBeForcedToStop) \ + ( (This)->lpVtbl -> ProfileChanging(This,profileToBeActivated,streamsWillBeForcedToStop) ) + +#define IDeckLinkProfileCallback_ProfileActivated(This,activatedProfile) \ + ( (This)->lpVtbl -> ProfileActivated(This,activatedProfile) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkProfileCallback_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkProfileManager_INTERFACE_DEFINED__ +#define __IDeckLinkProfileManager_INTERFACE_DEFINED__ + +/* interface IDeckLinkProfileManager */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkProfileManager; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("30D41429-3998-4B6D-84F8-78C94A797C6E") + IDeckLinkProfileManager : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetProfiles( + /* [out] */ IDeckLinkProfileIterator **profileIterator) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetProfile( + /* [in] */ BMDProfileID profileID, + /* [out] */ IDeckLinkProfile **profile) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetCallback( + /* [in] */ IDeckLinkProfileCallback *callback) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkProfileManagerVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkProfileManager * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkProfileManager * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkProfileManager * This); + + DECLSPEC_XFGVIRT(IDeckLinkProfileManager, GetProfiles) + HRESULT ( STDMETHODCALLTYPE *GetProfiles )( + IDeckLinkProfileManager * This, + /* [out] */ IDeckLinkProfileIterator **profileIterator); + + DECLSPEC_XFGVIRT(IDeckLinkProfileManager, GetProfile) + HRESULT ( STDMETHODCALLTYPE *GetProfile )( + IDeckLinkProfileManager * This, + /* [in] */ BMDProfileID profileID, + /* [out] */ IDeckLinkProfile **profile); + + DECLSPEC_XFGVIRT(IDeckLinkProfileManager, SetCallback) + HRESULT ( STDMETHODCALLTYPE *SetCallback )( + IDeckLinkProfileManager * This, + /* [in] */ IDeckLinkProfileCallback *callback); + + END_INTERFACE + } IDeckLinkProfileManagerVtbl; + + interface IDeckLinkProfileManager + { + CONST_VTBL struct IDeckLinkProfileManagerVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkProfileManager_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkProfileManager_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkProfileManager_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkProfileManager_GetProfiles(This,profileIterator) \ + ( (This)->lpVtbl -> GetProfiles(This,profileIterator) ) + +#define IDeckLinkProfileManager_GetProfile(This,profileID,profile) \ + ( (This)->lpVtbl -> GetProfile(This,profileID,profile) ) + +#define IDeckLinkProfileManager_SetCallback(This,callback) \ + ( (This)->lpVtbl -> SetCallback(This,callback) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkProfileManager_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkStatistics_INTERFACE_DEFINED__ +#define __IDeckLinkStatistics_INTERFACE_DEFINED__ + +/* interface IDeckLinkStatistics */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkStatistics; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("21CB2ED1-4429-42BE-AAF3-22A3B1DD3AE0") + IDeckLinkStatistics : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetInt( + /* [in] */ BMDDeckLinkStatisticID statID, + /* [out] */ LONGLONG *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetIntWithParam( + /* [in] */ BMDDeckLinkStatisticID statID, + /* [in] */ ULONGLONG param, + /* [out] */ LONGLONG *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStringWithParam( + /* [in] */ BMDDeckLinkStatisticID statID, + /* [in] */ ULONGLONG param, + /* [out] */ BSTR *value) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkStatisticsVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkStatistics * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkStatistics * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkStatistics * This); + + DECLSPEC_XFGVIRT(IDeckLinkStatistics, GetInt) + HRESULT ( STDMETHODCALLTYPE *GetInt )( + IDeckLinkStatistics * This, + /* [in] */ BMDDeckLinkStatisticID statID, + /* [out] */ LONGLONG *value); + + DECLSPEC_XFGVIRT(IDeckLinkStatistics, GetIntWithParam) + HRESULT ( STDMETHODCALLTYPE *GetIntWithParam )( + IDeckLinkStatistics * This, + /* [in] */ BMDDeckLinkStatisticID statID, + /* [in] */ ULONGLONG param, + /* [out] */ LONGLONG *value); + + DECLSPEC_XFGVIRT(IDeckLinkStatistics, GetStringWithParam) + HRESULT ( STDMETHODCALLTYPE *GetStringWithParam )( + IDeckLinkStatistics * This, + /* [in] */ BMDDeckLinkStatisticID statID, + /* [in] */ ULONGLONG param, + /* [out] */ BSTR *value); + + END_INTERFACE + } IDeckLinkStatisticsVtbl; + + interface IDeckLinkStatistics + { + CONST_VTBL struct IDeckLinkStatisticsVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkStatistics_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkStatistics_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkStatistics_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkStatistics_GetInt(This,statID,value) \ + ( (This)->lpVtbl -> GetInt(This,statID,value) ) + +#define IDeckLinkStatistics_GetIntWithParam(This,statID,param,value) \ + ( (This)->lpVtbl -> GetIntWithParam(This,statID,param,value) ) + +#define IDeckLinkStatistics_GetStringWithParam(This,statID,param,value) \ + ( (This)->lpVtbl -> GetStringWithParam(This,statID,param,value) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkStatistics_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkStatus_INTERFACE_DEFINED__ +#define __IDeckLinkStatus_INTERFACE_DEFINED__ + +/* interface IDeckLinkStatus */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkStatus; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("2A04A635-ED42-41EF-9342-0E11F8CF6B5E") + IDeckLinkStatus : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetFlag( + /* [in] */ BMDDeckLinkStatusID statusID, + /* [out] */ BOOL *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInt( + /* [in] */ BMDDeckLinkStatusID statusID, + /* [out] */ LONGLONG *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFloat( + /* [in] */ BMDDeckLinkStatusID statusID, + /* [out] */ double *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetString( + /* [in] */ BMDDeckLinkStatusID statusID, + /* [out] */ BSTR *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBytes( + /* [in] */ BMDDeckLinkStatusID statusID, + /* [out] */ void *buffer, + /* [out][in] */ unsigned int *bufferSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInterface( + /* [in] */ BMDDeckLinkStatusID statusID, + /* [out] */ void **iface) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFlagWithParam( + /* [in] */ BMDDeckLinkStatusID statusID, + /* [in] */ ULONGLONG param, + /* [out] */ BOOL *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetIntWithParam( + /* [in] */ BMDDeckLinkStatusID statusID, + /* [in] */ ULONGLONG param, + /* [out] */ LONGLONG *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFloatWithParam( + /* [in] */ BMDDeckLinkStatusID statusID, + /* [in] */ ULONGLONG param, + /* [out] */ double *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStringWithParam( + /* [in] */ BMDDeckLinkStatusID statusID, + /* [in] */ ULONGLONG param, + /* [out] */ BSTR *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBytesWithParam( + /* [in] */ BMDDeckLinkStatusID statusID, + /* [in] */ ULONGLONG param, + /* [out] */ void *buffer, + /* [out][in] */ unsigned int *bufferSize) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkStatusVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkStatus * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkStatus * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkStatus * This); + + DECLSPEC_XFGVIRT(IDeckLinkStatus, GetFlag) + HRESULT ( STDMETHODCALLTYPE *GetFlag )( + IDeckLinkStatus * This, + /* [in] */ BMDDeckLinkStatusID statusID, + /* [out] */ BOOL *value); + + DECLSPEC_XFGVIRT(IDeckLinkStatus, GetInt) + HRESULT ( STDMETHODCALLTYPE *GetInt )( + IDeckLinkStatus * This, + /* [in] */ BMDDeckLinkStatusID statusID, + /* [out] */ LONGLONG *value); + + DECLSPEC_XFGVIRT(IDeckLinkStatus, GetFloat) + HRESULT ( STDMETHODCALLTYPE *GetFloat )( + IDeckLinkStatus * This, + /* [in] */ BMDDeckLinkStatusID statusID, + /* [out] */ double *value); + + DECLSPEC_XFGVIRT(IDeckLinkStatus, GetString) + HRESULT ( STDMETHODCALLTYPE *GetString )( + IDeckLinkStatus * This, + /* [in] */ BMDDeckLinkStatusID statusID, + /* [out] */ BSTR *value); + + DECLSPEC_XFGVIRT(IDeckLinkStatus, GetBytes) + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IDeckLinkStatus * This, + /* [in] */ BMDDeckLinkStatusID statusID, + /* [out] */ void *buffer, + /* [out][in] */ unsigned int *bufferSize); + + DECLSPEC_XFGVIRT(IDeckLinkStatus, GetInterface) + HRESULT ( STDMETHODCALLTYPE *GetInterface )( + IDeckLinkStatus * This, + /* [in] */ BMDDeckLinkStatusID statusID, + /* [out] */ void **iface); + + DECLSPEC_XFGVIRT(IDeckLinkStatus, GetFlagWithParam) + HRESULT ( STDMETHODCALLTYPE *GetFlagWithParam )( + IDeckLinkStatus * This, + /* [in] */ BMDDeckLinkStatusID statusID, + /* [in] */ ULONGLONG param, + /* [out] */ BOOL *value); + + DECLSPEC_XFGVIRT(IDeckLinkStatus, GetIntWithParam) + HRESULT ( STDMETHODCALLTYPE *GetIntWithParam )( + IDeckLinkStatus * This, + /* [in] */ BMDDeckLinkStatusID statusID, + /* [in] */ ULONGLONG param, + /* [out] */ LONGLONG *value); + + DECLSPEC_XFGVIRT(IDeckLinkStatus, GetFloatWithParam) + HRESULT ( STDMETHODCALLTYPE *GetFloatWithParam )( + IDeckLinkStatus * This, + /* [in] */ BMDDeckLinkStatusID statusID, + /* [in] */ ULONGLONG param, + /* [out] */ double *value); + + DECLSPEC_XFGVIRT(IDeckLinkStatus, GetStringWithParam) + HRESULT ( STDMETHODCALLTYPE *GetStringWithParam )( + IDeckLinkStatus * This, + /* [in] */ BMDDeckLinkStatusID statusID, + /* [in] */ ULONGLONG param, + /* [out] */ BSTR *value); + + DECLSPEC_XFGVIRT(IDeckLinkStatus, GetBytesWithParam) + HRESULT ( STDMETHODCALLTYPE *GetBytesWithParam )( + IDeckLinkStatus * This, + /* [in] */ BMDDeckLinkStatusID statusID, + /* [in] */ ULONGLONG param, + /* [out] */ void *buffer, + /* [out][in] */ unsigned int *bufferSize); + + END_INTERFACE + } IDeckLinkStatusVtbl; + + interface IDeckLinkStatus + { + CONST_VTBL struct IDeckLinkStatusVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkStatus_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkStatus_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkStatus_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkStatus_GetFlag(This,statusID,value) \ + ( (This)->lpVtbl -> GetFlag(This,statusID,value) ) + +#define IDeckLinkStatus_GetInt(This,statusID,value) \ + ( (This)->lpVtbl -> GetInt(This,statusID,value) ) + +#define IDeckLinkStatus_GetFloat(This,statusID,value) \ + ( (This)->lpVtbl -> GetFloat(This,statusID,value) ) + +#define IDeckLinkStatus_GetString(This,statusID,value) \ + ( (This)->lpVtbl -> GetString(This,statusID,value) ) + +#define IDeckLinkStatus_GetBytes(This,statusID,buffer,bufferSize) \ + ( (This)->lpVtbl -> GetBytes(This,statusID,buffer,bufferSize) ) + +#define IDeckLinkStatus_GetInterface(This,statusID,iface) \ + ( (This)->lpVtbl -> GetInterface(This,statusID,iface) ) + +#define IDeckLinkStatus_GetFlagWithParam(This,statusID,param,value) \ + ( (This)->lpVtbl -> GetFlagWithParam(This,statusID,param,value) ) + +#define IDeckLinkStatus_GetIntWithParam(This,statusID,param,value) \ + ( (This)->lpVtbl -> GetIntWithParam(This,statusID,param,value) ) + +#define IDeckLinkStatus_GetFloatWithParam(This,statusID,param,value) \ + ( (This)->lpVtbl -> GetFloatWithParam(This,statusID,param,value) ) + +#define IDeckLinkStatus_GetStringWithParam(This,statusID,param,value) \ + ( (This)->lpVtbl -> GetStringWithParam(This,statusID,param,value) ) + +#define IDeckLinkStatus_GetBytesWithParam(This,statusID,param,buffer,bufferSize) \ + ( (This)->lpVtbl -> GetBytesWithParam(This,statusID,param,buffer,bufferSize) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkStatus_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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkKeyer * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkKeyer * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkKeyer * This); + + DECLSPEC_XFGVIRT(IDeckLinkKeyer, Enable) + HRESULT ( STDMETHODCALLTYPE *Enable )( + IDeckLinkKeyer * This, + /* [in] */ BOOL isExternal); + + DECLSPEC_XFGVIRT(IDeckLinkKeyer, SetLevel) + HRESULT ( STDMETHODCALLTYPE *SetLevel )( + IDeckLinkKeyer * This, + /* [in] */ unsigned char level); + + DECLSPEC_XFGVIRT(IDeckLinkKeyer, RampUp) + HRESULT ( STDMETHODCALLTYPE *RampUp )( + IDeckLinkKeyer * This, + /* [in] */ unsigned int numberOfFrames); + + DECLSPEC_XFGVIRT(IDeckLinkKeyer, RampDown) + HRESULT ( STDMETHODCALLTYPE *RampDown )( + IDeckLinkKeyer * This, + /* [in] */ unsigned int numberOfFrames); + + DECLSPEC_XFGVIRT(IDeckLinkKeyer, Disable) + 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("94C536D6-C821-42F5-A600-C66629955101") + IDeckLinkVideoConversion : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE ConvertFrame( + /* [in] */ IDeckLinkVideoFrame *srcFrame, + /* [in] */ IDeckLinkVideoFrame *dstFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE ConvertNewFrame( + /* [in] */ IDeckLinkVideoFrame *srcFrame, + /* [in] */ BMDPixelFormat dstPixelFormat, + /* [in] */ BMDColorspace dstColorspace, + /* [in] */ IDeckLinkVideoBuffer *dstBuffer, + /* [out] */ IDeckLinkVideoFrame **dstFrame) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkVideoConversionVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoConversion * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoConversion * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoConversion * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoConversion, ConvertFrame) + HRESULT ( STDMETHODCALLTYPE *ConvertFrame )( + IDeckLinkVideoConversion * This, + /* [in] */ IDeckLinkVideoFrame *srcFrame, + /* [in] */ IDeckLinkVideoFrame *dstFrame); + + DECLSPEC_XFGVIRT(IDeckLinkVideoConversion, ConvertNewFrame) + HRESULT ( STDMETHODCALLTYPE *ConvertNewFrame )( + IDeckLinkVideoConversion * This, + /* [in] */ IDeckLinkVideoFrame *srcFrame, + /* [in] */ BMDPixelFormat dstPixelFormat, + /* [in] */ BMDColorspace dstColorspace, + /* [in] */ IDeckLinkVideoBuffer *dstBuffer, + /* [out] */ 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) ) + +#define IDeckLinkVideoConversion_ConvertNewFrame(This,srcFrame,dstPixelFormat,dstColorspace,dstBuffer,dstFrame) \ + ( (This)->lpVtbl -> ConvertNewFrame(This,srcFrame,dstPixelFormat,dstColorspace,dstBuffer,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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkDeviceNotificationCallback * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkDeviceNotificationCallback * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkDeviceNotificationCallback * This); + + DECLSPEC_XFGVIRT(IDeckLinkDeviceNotificationCallback, DeckLinkDeviceArrived) + HRESULT ( STDMETHODCALLTYPE *DeckLinkDeviceArrived )( + IDeckLinkDeviceNotificationCallback * This, + /* [in] */ IDeckLink *deckLinkDevice); + + DECLSPEC_XFGVIRT(IDeckLinkDeviceNotificationCallback, DeckLinkDeviceRemoved) + 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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkDiscovery * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkDiscovery * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkDiscovery * This); + + DECLSPEC_XFGVIRT(IDeckLinkDiscovery, InstallDeviceNotifications) + HRESULT ( STDMETHODCALLTYPE *InstallDeviceNotifications )( + IDeckLinkDiscovery * This, + /* [in] */ IDeckLinkDeviceNotificationCallback *deviceNotificationCallback); + + DECLSPEC_XFGVIRT(IDeckLinkDiscovery, UninstallDeviceNotifications) + 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("BA6C6F44-6DA5-4DCE-94AA-EE2D1372A676") +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("1E332DAE-0D04-49EB-B8A1-B6E00B2B6BD0") +CDeckLinkGLScreenPreviewHelper; +#endif + +EXTERN_C const CLSID CLSID_CDeckLinkGL3ScreenPreviewHelper; + +#ifdef __cplusplus + +class DECLSPEC_UUID("166804E4-15EF-4BFD-B623-B5BA921667C5") +CDeckLinkGL3ScreenPreviewHelper; +#endif + +EXTERN_C const CLSID CLSID_CDeckLinkDX9ScreenPreviewHelper; + +#ifdef __cplusplus + +class DECLSPEC_UUID("0EB111ED-ADA6-43A6-8B16-CA5D27EEA15E") +CDeckLinkDX9ScreenPreviewHelper; +#endif + +EXTERN_C const CLSID CLSID_CDeckLinkWPFDX9ScreenPreviewHelper; + +#ifdef __cplusplus + +class DECLSPEC_UUID("5E64496D-4BB2-45D5-9B63-BF1B463B18AF") +CDeckLinkWPFDX9ScreenPreviewHelper; +#endif + +EXTERN_C const CLSID CLSID_CDeckLinkVideoConversion; + +#ifdef __cplusplus + +class DECLSPEC_UUID("771AD62D-671F-4442-AC90-B070C541090A") +CDeckLinkVideoConversion; +#endif + +EXTERN_C const CLSID CLSID_CDeckLinkDiscovery; + +#ifdef __cplusplus + +class DECLSPEC_UUID("22FBFC33-8D07-495C-A5BF-DAB5EA9B82DB") +CDeckLinkDiscovery; +#endif + +EXTERN_C const CLSID CLSID_CDeckLinkVideoFrameAncillaryPackets; + +#ifdef __cplusplus + +class DECLSPEC_UUID("6F47097E-B390-4650-BCB6-C4D52FAA1643") +CDeckLinkVideoFrameAncillaryPackets; +#endif + +#ifndef __IDeckLinkStatus_v15_3_1_INTERFACE_DEFINED__ +#define __IDeckLinkStatus_v15_3_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkStatus_v15_3_1 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkStatus_v15_3_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("5F558200-4028-49BC-BEAC-DB3FA4A96E46") + IDeckLinkStatus_v15_3_1 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetFlag( + /* [in] */ BMDDeckLinkStatusID statusID, + /* [out] */ BOOL *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInt( + /* [in] */ BMDDeckLinkStatusID statusID, + /* [out] */ LONGLONG *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFloat( + /* [in] */ BMDDeckLinkStatusID statusID, + /* [out] */ double *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetString( + /* [in] */ BMDDeckLinkStatusID statusID, + /* [out] */ BSTR *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBytes( + /* [in] */ BMDDeckLinkStatusID statusID, + /* [out] */ void *buffer, + /* [out][in] */ unsigned int *bufferSize) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkStatus_v15_3_1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkStatus_v15_3_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkStatus_v15_3_1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkStatus_v15_3_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkStatus_v15_3_1, GetFlag) + HRESULT ( STDMETHODCALLTYPE *GetFlag )( + IDeckLinkStatus_v15_3_1 * This, + /* [in] */ BMDDeckLinkStatusID statusID, + /* [out] */ BOOL *value); + + DECLSPEC_XFGVIRT(IDeckLinkStatus_v15_3_1, GetInt) + HRESULT ( STDMETHODCALLTYPE *GetInt )( + IDeckLinkStatus_v15_3_1 * This, + /* [in] */ BMDDeckLinkStatusID statusID, + /* [out] */ LONGLONG *value); + + DECLSPEC_XFGVIRT(IDeckLinkStatus_v15_3_1, GetFloat) + HRESULT ( STDMETHODCALLTYPE *GetFloat )( + IDeckLinkStatus_v15_3_1 * This, + /* [in] */ BMDDeckLinkStatusID statusID, + /* [out] */ double *value); + + DECLSPEC_XFGVIRT(IDeckLinkStatus_v15_3_1, GetString) + HRESULT ( STDMETHODCALLTYPE *GetString )( + IDeckLinkStatus_v15_3_1 * This, + /* [in] */ BMDDeckLinkStatusID statusID, + /* [out] */ BSTR *value); + + DECLSPEC_XFGVIRT(IDeckLinkStatus_v15_3_1, GetBytes) + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IDeckLinkStatus_v15_3_1 * This, + /* [in] */ BMDDeckLinkStatusID statusID, + /* [out] */ void *buffer, + /* [out][in] */ unsigned int *bufferSize); + + END_INTERFACE + } IDeckLinkStatus_v15_3_1Vtbl; + + interface IDeckLinkStatus_v15_3_1 + { + CONST_VTBL struct IDeckLinkStatus_v15_3_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkStatus_v15_3_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkStatus_v15_3_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkStatus_v15_3_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkStatus_v15_3_1_GetFlag(This,statusID,value) \ + ( (This)->lpVtbl -> GetFlag(This,statusID,value) ) + +#define IDeckLinkStatus_v15_3_1_GetInt(This,statusID,value) \ + ( (This)->lpVtbl -> GetInt(This,statusID,value) ) + +#define IDeckLinkStatus_v15_3_1_GetFloat(This,statusID,value) \ + ( (This)->lpVtbl -> GetFloat(This,statusID,value) ) + +#define IDeckLinkStatus_v15_3_1_GetString(This,statusID,value) \ + ( (This)->lpVtbl -> GetString(This,statusID,value) ) + +#define IDeckLinkStatus_v15_3_1_GetBytes(This,statusID,buffer,bufferSize) \ + ( (This)->lpVtbl -> GetBytes(This,statusID,buffer,bufferSize) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkStatus_v15_3_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkConfiguration_v15_3_1_INTERFACE_DEFINED__ +#define __IDeckLinkConfiguration_v15_3_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkConfiguration_v15_3_1 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkConfiguration_v15_3_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("912F634B-2D4E-40A4-8AAB-8D80B73F1289") + IDeckLinkConfiguration_v15_3_1 : 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_v15_3_1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkConfiguration_v15_3_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkConfiguration_v15_3_1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkConfiguration_v15_3_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v15_3_1, SetFlag) + HRESULT ( STDMETHODCALLTYPE *SetFlag )( + IDeckLinkConfiguration_v15_3_1 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ BOOL value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v15_3_1, GetFlag) + HRESULT ( STDMETHODCALLTYPE *GetFlag )( + IDeckLinkConfiguration_v15_3_1 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ BOOL *value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v15_3_1, SetInt) + HRESULT ( STDMETHODCALLTYPE *SetInt )( + IDeckLinkConfiguration_v15_3_1 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ LONGLONG value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v15_3_1, GetInt) + HRESULT ( STDMETHODCALLTYPE *GetInt )( + IDeckLinkConfiguration_v15_3_1 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ LONGLONG *value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v15_3_1, SetFloat) + HRESULT ( STDMETHODCALLTYPE *SetFloat )( + IDeckLinkConfiguration_v15_3_1 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ double value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v15_3_1, GetFloat) + HRESULT ( STDMETHODCALLTYPE *GetFloat )( + IDeckLinkConfiguration_v15_3_1 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ double *value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v15_3_1, SetString) + HRESULT ( STDMETHODCALLTYPE *SetString )( + IDeckLinkConfiguration_v15_3_1 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ BSTR value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v15_3_1, GetString) + HRESULT ( STDMETHODCALLTYPE *GetString )( + IDeckLinkConfiguration_v15_3_1 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ BSTR *value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v15_3_1, WriteConfigurationToPreferences) + HRESULT ( STDMETHODCALLTYPE *WriteConfigurationToPreferences )( + IDeckLinkConfiguration_v15_3_1 * This); + + END_INTERFACE + } IDeckLinkConfiguration_v15_3_1Vtbl; + + interface IDeckLinkConfiguration_v15_3_1 + { + CONST_VTBL struct IDeckLinkConfiguration_v15_3_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkConfiguration_v15_3_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkConfiguration_v15_3_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkConfiguration_v15_3_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkConfiguration_v15_3_1_SetFlag(This,cfgID,value) \ + ( (This)->lpVtbl -> SetFlag(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v15_3_1_GetFlag(This,cfgID,value) \ + ( (This)->lpVtbl -> GetFlag(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v15_3_1_SetInt(This,cfgID,value) \ + ( (This)->lpVtbl -> SetInt(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v15_3_1_GetInt(This,cfgID,value) \ + ( (This)->lpVtbl -> GetInt(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v15_3_1_SetFloat(This,cfgID,value) \ + ( (This)->lpVtbl -> SetFloat(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v15_3_1_GetFloat(This,cfgID,value) \ + ( (This)->lpVtbl -> GetFloat(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v15_3_1_SetString(This,cfgID,value) \ + ( (This)->lpVtbl -> SetString(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v15_3_1_GetString(This,cfgID,value) \ + ( (This)->lpVtbl -> GetString(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v15_3_1_WriteConfigurationToPreferences(This) \ + ( (This)->lpVtbl -> WriteConfigurationToPreferences(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkConfiguration_v15_3_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkVideoBuffer_v15_3_1_INTERFACE_DEFINED__ +#define __IDeckLinkVideoBuffer_v15_3_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkVideoBuffer_v15_3_1 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkVideoBuffer_v15_3_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("CCB4B64A-5C86-4E02-B778-885D352709FE") + IDeckLinkVideoBuffer_v15_3_1 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetBytes( + void **buffer) = 0; + + virtual HRESULT STDMETHODCALLTYPE StartAccess( + BMDBufferAccessFlags flags) = 0; + + virtual HRESULT STDMETHODCALLTYPE EndAccess( + BMDBufferAccessFlags flags) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkVideoBuffer_v15_3_1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoBuffer_v15_3_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoBuffer_v15_3_1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoBuffer_v15_3_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoBuffer_v15_3_1, GetBytes) + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IDeckLinkVideoBuffer_v15_3_1 * This, + void **buffer); + + DECLSPEC_XFGVIRT(IDeckLinkVideoBuffer_v15_3_1, StartAccess) + HRESULT ( STDMETHODCALLTYPE *StartAccess )( + IDeckLinkVideoBuffer_v15_3_1 * This, + BMDBufferAccessFlags flags); + + DECLSPEC_XFGVIRT(IDeckLinkVideoBuffer_v15_3_1, EndAccess) + HRESULT ( STDMETHODCALLTYPE *EndAccess )( + IDeckLinkVideoBuffer_v15_3_1 * This, + BMDBufferAccessFlags flags); + + END_INTERFACE + } IDeckLinkVideoBuffer_v15_3_1Vtbl; + + interface IDeckLinkVideoBuffer_v15_3_1 + { + CONST_VTBL struct IDeckLinkVideoBuffer_v15_3_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkVideoBuffer_v15_3_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkVideoBuffer_v15_3_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkVideoBuffer_v15_3_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkVideoBuffer_v15_3_1_GetBytes(This,buffer) \ + ( (This)->lpVtbl -> GetBytes(This,buffer) ) + +#define IDeckLinkVideoBuffer_v15_3_1_StartAccess(This,flags) \ + ( (This)->lpVtbl -> StartAccess(This,flags) ) + +#define IDeckLinkVideoBuffer_v15_3_1_EndAccess(This,flags) \ + ( (This)->lpVtbl -> EndAccess(This,flags) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkVideoBuffer_v15_3_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkVideoBufferAllocator_v15_3_1_INTERFACE_DEFINED__ +#define __IDeckLinkVideoBufferAllocator_v15_3_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkVideoBufferAllocator_v15_3_1 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkVideoBufferAllocator_v15_3_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("3481A4DF-2B11-4E55-AC61-836B87985E9A") + IDeckLinkVideoBufferAllocator_v15_3_1 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE AllocateVideoBuffer( + IDeckLinkVideoBuffer_v15_3_1 **allocatedBuffer) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkVideoBufferAllocator_v15_3_1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoBufferAllocator_v15_3_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoBufferAllocator_v15_3_1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoBufferAllocator_v15_3_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoBufferAllocator_v15_3_1, AllocateVideoBuffer) + HRESULT ( STDMETHODCALLTYPE *AllocateVideoBuffer )( + IDeckLinkVideoBufferAllocator_v15_3_1 * This, + IDeckLinkVideoBuffer_v15_3_1 **allocatedBuffer); + + END_INTERFACE + } IDeckLinkVideoBufferAllocator_v15_3_1Vtbl; + + interface IDeckLinkVideoBufferAllocator_v15_3_1 + { + CONST_VTBL struct IDeckLinkVideoBufferAllocator_v15_3_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkVideoBufferAllocator_v15_3_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkVideoBufferAllocator_v15_3_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkVideoBufferAllocator_v15_3_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkVideoBufferAllocator_v15_3_1_AllocateVideoBuffer(This,allocatedBuffer) \ + ( (This)->lpVtbl -> AllocateVideoBuffer(This,allocatedBuffer) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkVideoBufferAllocator_v15_3_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkVideoBufferAllocatorProvider_v15_3_1_INTERFACE_DEFINED__ +#define __IDeckLinkVideoBufferAllocatorProvider_v15_3_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkVideoBufferAllocatorProvider_v15_3_1 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkVideoBufferAllocatorProvider_v15_3_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("08B80403-BFF2-49D0-B448-8C908B9E9FC9") + IDeckLinkVideoBufferAllocatorProvider_v15_3_1 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetVideoBufferAllocator( + unsigned int bufferSize, + unsigned int width, + unsigned int height, + unsigned int rowBytes, + BMDPixelFormat pixelFormat, + IDeckLinkVideoBufferAllocator_v15_3_1 **allocator) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkVideoBufferAllocatorProvider_v15_3_1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoBufferAllocatorProvider_v15_3_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoBufferAllocatorProvider_v15_3_1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoBufferAllocatorProvider_v15_3_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoBufferAllocatorProvider_v15_3_1, GetVideoBufferAllocator) + HRESULT ( STDMETHODCALLTYPE *GetVideoBufferAllocator )( + IDeckLinkVideoBufferAllocatorProvider_v15_3_1 * This, + unsigned int bufferSize, + unsigned int width, + unsigned int height, + unsigned int rowBytes, + BMDPixelFormat pixelFormat, + IDeckLinkVideoBufferAllocator_v15_3_1 **allocator); + + END_INTERFACE + } IDeckLinkVideoBufferAllocatorProvider_v15_3_1Vtbl; + + interface IDeckLinkVideoBufferAllocatorProvider_v15_3_1 + { + CONST_VTBL struct IDeckLinkVideoBufferAllocatorProvider_v15_3_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkVideoBufferAllocatorProvider_v15_3_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkVideoBufferAllocatorProvider_v15_3_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkVideoBufferAllocatorProvider_v15_3_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkVideoBufferAllocatorProvider_v15_3_1_GetVideoBufferAllocator(This,bufferSize,width,height,rowBytes,pixelFormat,allocator) \ + ( (This)->lpVtbl -> GetVideoBufferAllocator(This,bufferSize,width,height,rowBytes,pixelFormat,allocator) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkVideoBufferAllocatorProvider_v15_3_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkInput_v15_3_1_INTERFACE_DEFINED__ +#define __IDeckLinkInput_v15_3_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkInput_v15_3_1 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkInput_v15_3_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("4095DB82-E294-4B8C-AAA8-3B9E80C49336") + IDeckLinkInput_v15_3_1 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE DoesSupportVideoMode( + BMDVideoConnection connection, + BMDDisplayMode requestedMode, + BMDPixelFormat requestedPixelFormat, + BMDVideoInputConversionMode conversionMode, + BMDSupportedVideoModeFlags flags, + BMDDisplayMode *actualMode, + BOOL *supported) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayMode( + BMDDisplayMode displayMode, + IDeckLinkDisplayMode **resultDisplayMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayModeIterator( + IDeckLinkDisplayModeIterator **iterator) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetScreenPreviewCallback( + IDeckLinkScreenPreviewCallback *previewCallback) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableVideoInput( + BMDDisplayMode displayMode, + BMDPixelFormat pixelFormat, + BMDVideoInputFlags flags) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableVideoInputWithAllocatorProvider( + BMDDisplayMode displayMode, + BMDPixelFormat pixelFormat, + BMDVideoInputFlags flags, + IDeckLinkVideoBufferAllocatorProvider_v15_3_1 *allocatorProvider) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisableVideoInput( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAvailableVideoFrameCount( + 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( + 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( + IDeckLinkInputCallback *theCallback) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetHardwareReferenceClock( + BMDTimeScale desiredTimeScale, + BMDTimeValue *hardwareTime, + BMDTimeValue *timeInFrame, + BMDTimeValue *ticksPerFrame) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkInput_v15_3_1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkInput_v15_3_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkInput_v15_3_1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkInput_v15_3_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v15_3_1, DoesSupportVideoMode) + HRESULT ( STDMETHODCALLTYPE *DoesSupportVideoMode )( + IDeckLinkInput_v15_3_1 * This, + BMDVideoConnection connection, + BMDDisplayMode requestedMode, + BMDPixelFormat requestedPixelFormat, + BMDVideoInputConversionMode conversionMode, + BMDSupportedVideoModeFlags flags, + BMDDisplayMode *actualMode, + BOOL *supported); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v15_3_1, GetDisplayMode) + HRESULT ( STDMETHODCALLTYPE *GetDisplayMode )( + IDeckLinkInput_v15_3_1 * This, + BMDDisplayMode displayMode, + IDeckLinkDisplayMode **resultDisplayMode); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v15_3_1, GetDisplayModeIterator) + HRESULT ( STDMETHODCALLTYPE *GetDisplayModeIterator )( + IDeckLinkInput_v15_3_1 * This, + IDeckLinkDisplayModeIterator **iterator); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v15_3_1, SetScreenPreviewCallback) + HRESULT ( STDMETHODCALLTYPE *SetScreenPreviewCallback )( + IDeckLinkInput_v15_3_1 * This, + IDeckLinkScreenPreviewCallback *previewCallback); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v15_3_1, EnableVideoInput) + HRESULT ( STDMETHODCALLTYPE *EnableVideoInput )( + IDeckLinkInput_v15_3_1 * This, + BMDDisplayMode displayMode, + BMDPixelFormat pixelFormat, + BMDVideoInputFlags flags); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v15_3_1, EnableVideoInputWithAllocatorProvider) + HRESULT ( STDMETHODCALLTYPE *EnableVideoInputWithAllocatorProvider )( + IDeckLinkInput_v15_3_1 * This, + BMDDisplayMode displayMode, + BMDPixelFormat pixelFormat, + BMDVideoInputFlags flags, + IDeckLinkVideoBufferAllocatorProvider_v15_3_1 *allocatorProvider); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v15_3_1, DisableVideoInput) + HRESULT ( STDMETHODCALLTYPE *DisableVideoInput )( + IDeckLinkInput_v15_3_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v15_3_1, GetAvailableVideoFrameCount) + HRESULT ( STDMETHODCALLTYPE *GetAvailableVideoFrameCount )( + IDeckLinkInput_v15_3_1 * This, + unsigned int *availableFrameCount); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v15_3_1, EnableAudioInput) + HRESULT ( STDMETHODCALLTYPE *EnableAudioInput )( + IDeckLinkInput_v15_3_1 * This, + BMDAudioSampleRate sampleRate, + BMDAudioSampleType sampleType, + unsigned int channelCount); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v15_3_1, DisableAudioInput) + HRESULT ( STDMETHODCALLTYPE *DisableAudioInput )( + IDeckLinkInput_v15_3_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v15_3_1, GetAvailableAudioSampleFrameCount) + HRESULT ( STDMETHODCALLTYPE *GetAvailableAudioSampleFrameCount )( + IDeckLinkInput_v15_3_1 * This, + unsigned int *availableSampleFrameCount); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v15_3_1, StartStreams) + HRESULT ( STDMETHODCALLTYPE *StartStreams )( + IDeckLinkInput_v15_3_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v15_3_1, StopStreams) + HRESULT ( STDMETHODCALLTYPE *StopStreams )( + IDeckLinkInput_v15_3_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v15_3_1, PauseStreams) + HRESULT ( STDMETHODCALLTYPE *PauseStreams )( + IDeckLinkInput_v15_3_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v15_3_1, FlushStreams) + HRESULT ( STDMETHODCALLTYPE *FlushStreams )( + IDeckLinkInput_v15_3_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v15_3_1, SetCallback) + HRESULT ( STDMETHODCALLTYPE *SetCallback )( + IDeckLinkInput_v15_3_1 * This, + IDeckLinkInputCallback *theCallback); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v15_3_1, GetHardwareReferenceClock) + HRESULT ( STDMETHODCALLTYPE *GetHardwareReferenceClock )( + IDeckLinkInput_v15_3_1 * This, + BMDTimeScale desiredTimeScale, + BMDTimeValue *hardwareTime, + BMDTimeValue *timeInFrame, + BMDTimeValue *ticksPerFrame); + + END_INTERFACE + } IDeckLinkInput_v15_3_1Vtbl; + + interface IDeckLinkInput_v15_3_1 + { + CONST_VTBL struct IDeckLinkInput_v15_3_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkInput_v15_3_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkInput_v15_3_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkInput_v15_3_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkInput_v15_3_1_DoesSupportVideoMode(This,connection,requestedMode,requestedPixelFormat,conversionMode,flags,actualMode,supported) \ + ( (This)->lpVtbl -> DoesSupportVideoMode(This,connection,requestedMode,requestedPixelFormat,conversionMode,flags,actualMode,supported) ) + +#define IDeckLinkInput_v15_3_1_GetDisplayMode(This,displayMode,resultDisplayMode) \ + ( (This)->lpVtbl -> GetDisplayMode(This,displayMode,resultDisplayMode) ) + +#define IDeckLinkInput_v15_3_1_GetDisplayModeIterator(This,iterator) \ + ( (This)->lpVtbl -> GetDisplayModeIterator(This,iterator) ) + +#define IDeckLinkInput_v15_3_1_SetScreenPreviewCallback(This,previewCallback) \ + ( (This)->lpVtbl -> SetScreenPreviewCallback(This,previewCallback) ) + +#define IDeckLinkInput_v15_3_1_EnableVideoInput(This,displayMode,pixelFormat,flags) \ + ( (This)->lpVtbl -> EnableVideoInput(This,displayMode,pixelFormat,flags) ) + +#define IDeckLinkInput_v15_3_1_EnableVideoInputWithAllocatorProvider(This,displayMode,pixelFormat,flags,allocatorProvider) \ + ( (This)->lpVtbl -> EnableVideoInputWithAllocatorProvider(This,displayMode,pixelFormat,flags,allocatorProvider) ) + +#define IDeckLinkInput_v15_3_1_DisableVideoInput(This) \ + ( (This)->lpVtbl -> DisableVideoInput(This) ) + +#define IDeckLinkInput_v15_3_1_GetAvailableVideoFrameCount(This,availableFrameCount) \ + ( (This)->lpVtbl -> GetAvailableVideoFrameCount(This,availableFrameCount) ) + +#define IDeckLinkInput_v15_3_1_EnableAudioInput(This,sampleRate,sampleType,channelCount) \ + ( (This)->lpVtbl -> EnableAudioInput(This,sampleRate,sampleType,channelCount) ) + +#define IDeckLinkInput_v15_3_1_DisableAudioInput(This) \ + ( (This)->lpVtbl -> DisableAudioInput(This) ) + +#define IDeckLinkInput_v15_3_1_GetAvailableAudioSampleFrameCount(This,availableSampleFrameCount) \ + ( (This)->lpVtbl -> GetAvailableAudioSampleFrameCount(This,availableSampleFrameCount) ) + +#define IDeckLinkInput_v15_3_1_StartStreams(This) \ + ( (This)->lpVtbl -> StartStreams(This) ) + +#define IDeckLinkInput_v15_3_1_StopStreams(This) \ + ( (This)->lpVtbl -> StopStreams(This) ) + +#define IDeckLinkInput_v15_3_1_PauseStreams(This) \ + ( (This)->lpVtbl -> PauseStreams(This) ) + +#define IDeckLinkInput_v15_3_1_FlushStreams(This) \ + ( (This)->lpVtbl -> FlushStreams(This) ) + +#define IDeckLinkInput_v15_3_1_SetCallback(This,theCallback) \ + ( (This)->lpVtbl -> SetCallback(This,theCallback) ) + +#define IDeckLinkInput_v15_3_1_GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) \ + ( (This)->lpVtbl -> GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkInput_v15_3_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkOutput_v15_3_1_INTERFACE_DEFINED__ +#define __IDeckLinkOutput_v15_3_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkOutput_v15_3_1 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkOutput_v15_3_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("1A8077F1-9FE2-4533-8147-2294305E253F") + IDeckLinkOutput_v15_3_1 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE DoesSupportVideoMode( + BMDVideoConnection connection, + BMDDisplayMode requestedMode, + BMDPixelFormat requestedPixelFormat, + BMDVideoOutputConversionMode conversionMode, + BMDSupportedVideoModeFlags flags, + BMDDisplayMode *actualMode, + BOOL *supported) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayMode( + BMDDisplayMode displayMode, + IDeckLinkDisplayMode **resultDisplayMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayModeIterator( + IDeckLinkDisplayModeIterator **iterator) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetScreenPreviewCallback( + IDeckLinkScreenPreviewCallback *previewCallback) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableVideoOutput( + BMDDisplayMode displayMode, + BMDVideoOutputFlags flags) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisableVideoOutput( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateVideoFrame( + int width, + int height, + int rowBytes, + BMDPixelFormat pixelFormat, + BMDFrameFlags flags, + IDeckLinkMutableVideoFrame **outFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateVideoFrameWithBuffer( + int width, + int height, + int rowBytes, + BMDPixelFormat pixelFormat, + BMDFrameFlags flags, + IDeckLinkVideoBuffer_v15_3_1 *buffer, + IDeckLinkMutableVideoFrame **outFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE RowBytesForPixelFormat( + BMDPixelFormat pixelFormat, + int width, + int *rowBytes) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateAncillaryData( + BMDPixelFormat pixelFormat, + IDeckLinkVideoFrameAncillary **outBuffer) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisplayVideoFrameSync( + IDeckLinkVideoFrame *theFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE ScheduleVideoFrame( + IDeckLinkVideoFrame *theFrame, + BMDTimeValue displayTime, + BMDTimeValue displayDuration, + BMDTimeScale timeScale) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetScheduledFrameCompletionCallback( + IDeckLinkVideoOutputCallback *theCallback) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBufferedVideoFrameCount( + 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( + void *buffer, + unsigned int sampleFrameCount, + 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, + unsigned int *sampleFramesWritten) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBufferedAudioSampleFrameCount( + unsigned int *bufferedSampleFrameCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE FlushBufferedAudioSamples( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetAudioCallback( + 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 IsScheduledPlaybackRunning( + BOOL *active) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetScheduledStreamTime( + BMDTimeScale desiredTimeScale, + BMDTimeValue *streamTime, + double *playbackSpeed) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetReferenceStatus( + BMDReferenceStatus *referenceStatus) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetHardwareReferenceClock( + BMDTimeScale desiredTimeScale, + BMDTimeValue *hardwareTime, + BMDTimeValue *timeInFrame, + BMDTimeValue *ticksPerFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFrameCompletionReferenceTimestamp( + IDeckLinkVideoFrame *theFrame, + BMDTimeScale desiredTimeScale, + BMDTimeValue *frameCompletionTimestamp) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkOutput_v15_3_1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkOutput_v15_3_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkOutput_v15_3_1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkOutput_v15_3_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v15_3_1, DoesSupportVideoMode) + HRESULT ( STDMETHODCALLTYPE *DoesSupportVideoMode )( + IDeckLinkOutput_v15_3_1 * This, + BMDVideoConnection connection, + BMDDisplayMode requestedMode, + BMDPixelFormat requestedPixelFormat, + BMDVideoOutputConversionMode conversionMode, + BMDSupportedVideoModeFlags flags, + BMDDisplayMode *actualMode, + BOOL *supported); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v15_3_1, GetDisplayMode) + HRESULT ( STDMETHODCALLTYPE *GetDisplayMode )( + IDeckLinkOutput_v15_3_1 * This, + BMDDisplayMode displayMode, + IDeckLinkDisplayMode **resultDisplayMode); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v15_3_1, GetDisplayModeIterator) + HRESULT ( STDMETHODCALLTYPE *GetDisplayModeIterator )( + IDeckLinkOutput_v15_3_1 * This, + IDeckLinkDisplayModeIterator **iterator); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v15_3_1, SetScreenPreviewCallback) + HRESULT ( STDMETHODCALLTYPE *SetScreenPreviewCallback )( + IDeckLinkOutput_v15_3_1 * This, + IDeckLinkScreenPreviewCallback *previewCallback); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v15_3_1, EnableVideoOutput) + HRESULT ( STDMETHODCALLTYPE *EnableVideoOutput )( + IDeckLinkOutput_v15_3_1 * This, + BMDDisplayMode displayMode, + BMDVideoOutputFlags flags); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v15_3_1, DisableVideoOutput) + HRESULT ( STDMETHODCALLTYPE *DisableVideoOutput )( + IDeckLinkOutput_v15_3_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v15_3_1, CreateVideoFrame) + HRESULT ( STDMETHODCALLTYPE *CreateVideoFrame )( + IDeckLinkOutput_v15_3_1 * This, + int width, + int height, + int rowBytes, + BMDPixelFormat pixelFormat, + BMDFrameFlags flags, + IDeckLinkMutableVideoFrame **outFrame); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v15_3_1, CreateVideoFrameWithBuffer) + HRESULT ( STDMETHODCALLTYPE *CreateVideoFrameWithBuffer )( + IDeckLinkOutput_v15_3_1 * This, + int width, + int height, + int rowBytes, + BMDPixelFormat pixelFormat, + BMDFrameFlags flags, + IDeckLinkVideoBuffer_v15_3_1 *buffer, + IDeckLinkMutableVideoFrame **outFrame); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v15_3_1, RowBytesForPixelFormat) + HRESULT ( STDMETHODCALLTYPE *RowBytesForPixelFormat )( + IDeckLinkOutput_v15_3_1 * This, + BMDPixelFormat pixelFormat, + int width, + int *rowBytes); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v15_3_1, CreateAncillaryData) + HRESULT ( STDMETHODCALLTYPE *CreateAncillaryData )( + IDeckLinkOutput_v15_3_1 * This, + BMDPixelFormat pixelFormat, + IDeckLinkVideoFrameAncillary **outBuffer); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v15_3_1, DisplayVideoFrameSync) + HRESULT ( STDMETHODCALLTYPE *DisplayVideoFrameSync )( + IDeckLinkOutput_v15_3_1 * This, + IDeckLinkVideoFrame *theFrame); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v15_3_1, ScheduleVideoFrame) + HRESULT ( STDMETHODCALLTYPE *ScheduleVideoFrame )( + IDeckLinkOutput_v15_3_1 * This, + IDeckLinkVideoFrame *theFrame, + BMDTimeValue displayTime, + BMDTimeValue displayDuration, + BMDTimeScale timeScale); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v15_3_1, SetScheduledFrameCompletionCallback) + HRESULT ( STDMETHODCALLTYPE *SetScheduledFrameCompletionCallback )( + IDeckLinkOutput_v15_3_1 * This, + IDeckLinkVideoOutputCallback *theCallback); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v15_3_1, GetBufferedVideoFrameCount) + HRESULT ( STDMETHODCALLTYPE *GetBufferedVideoFrameCount )( + IDeckLinkOutput_v15_3_1 * This, + unsigned int *bufferedFrameCount); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v15_3_1, EnableAudioOutput) + HRESULT ( STDMETHODCALLTYPE *EnableAudioOutput )( + IDeckLinkOutput_v15_3_1 * This, + BMDAudioSampleRate sampleRate, + BMDAudioSampleType sampleType, + unsigned int channelCount, + BMDAudioOutputStreamType streamType); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v15_3_1, DisableAudioOutput) + HRESULT ( STDMETHODCALLTYPE *DisableAudioOutput )( + IDeckLinkOutput_v15_3_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v15_3_1, WriteAudioSamplesSync) + HRESULT ( STDMETHODCALLTYPE *WriteAudioSamplesSync )( + IDeckLinkOutput_v15_3_1 * This, + void *buffer, + unsigned int sampleFrameCount, + unsigned int *sampleFramesWritten); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v15_3_1, BeginAudioPreroll) + HRESULT ( STDMETHODCALLTYPE *BeginAudioPreroll )( + IDeckLinkOutput_v15_3_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v15_3_1, EndAudioPreroll) + HRESULT ( STDMETHODCALLTYPE *EndAudioPreroll )( + IDeckLinkOutput_v15_3_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v15_3_1, ScheduleAudioSamples) + HRESULT ( STDMETHODCALLTYPE *ScheduleAudioSamples )( + IDeckLinkOutput_v15_3_1 * This, + void *buffer, + unsigned int sampleFrameCount, + BMDTimeValue streamTime, + BMDTimeScale timeScale, + unsigned int *sampleFramesWritten); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v15_3_1, GetBufferedAudioSampleFrameCount) + HRESULT ( STDMETHODCALLTYPE *GetBufferedAudioSampleFrameCount )( + IDeckLinkOutput_v15_3_1 * This, + unsigned int *bufferedSampleFrameCount); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v15_3_1, FlushBufferedAudioSamples) + HRESULT ( STDMETHODCALLTYPE *FlushBufferedAudioSamples )( + IDeckLinkOutput_v15_3_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v15_3_1, SetAudioCallback) + HRESULT ( STDMETHODCALLTYPE *SetAudioCallback )( + IDeckLinkOutput_v15_3_1 * This, + IDeckLinkAudioOutputCallback *theCallback); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v15_3_1, StartScheduledPlayback) + HRESULT ( STDMETHODCALLTYPE *StartScheduledPlayback )( + IDeckLinkOutput_v15_3_1 * This, + BMDTimeValue playbackStartTime, + BMDTimeScale timeScale, + double playbackSpeed); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v15_3_1, StopScheduledPlayback) + HRESULT ( STDMETHODCALLTYPE *StopScheduledPlayback )( + IDeckLinkOutput_v15_3_1 * This, + BMDTimeValue stopPlaybackAtTime, + BMDTimeValue *actualStopTime, + BMDTimeScale timeScale); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v15_3_1, IsScheduledPlaybackRunning) + HRESULT ( STDMETHODCALLTYPE *IsScheduledPlaybackRunning )( + IDeckLinkOutput_v15_3_1 * This, + BOOL *active); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v15_3_1, GetScheduledStreamTime) + HRESULT ( STDMETHODCALLTYPE *GetScheduledStreamTime )( + IDeckLinkOutput_v15_3_1 * This, + BMDTimeScale desiredTimeScale, + BMDTimeValue *streamTime, + double *playbackSpeed); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v15_3_1, GetReferenceStatus) + HRESULT ( STDMETHODCALLTYPE *GetReferenceStatus )( + IDeckLinkOutput_v15_3_1 * This, + BMDReferenceStatus *referenceStatus); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v15_3_1, GetHardwareReferenceClock) + HRESULT ( STDMETHODCALLTYPE *GetHardwareReferenceClock )( + IDeckLinkOutput_v15_3_1 * This, + BMDTimeScale desiredTimeScale, + BMDTimeValue *hardwareTime, + BMDTimeValue *timeInFrame, + BMDTimeValue *ticksPerFrame); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v15_3_1, GetFrameCompletionReferenceTimestamp) + HRESULT ( STDMETHODCALLTYPE *GetFrameCompletionReferenceTimestamp )( + IDeckLinkOutput_v15_3_1 * This, + IDeckLinkVideoFrame *theFrame, + BMDTimeScale desiredTimeScale, + BMDTimeValue *frameCompletionTimestamp); + + END_INTERFACE + } IDeckLinkOutput_v15_3_1Vtbl; + + interface IDeckLinkOutput_v15_3_1 + { + CONST_VTBL struct IDeckLinkOutput_v15_3_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkOutput_v15_3_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkOutput_v15_3_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkOutput_v15_3_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkOutput_v15_3_1_DoesSupportVideoMode(This,connection,requestedMode,requestedPixelFormat,conversionMode,flags,actualMode,supported) \ + ( (This)->lpVtbl -> DoesSupportVideoMode(This,connection,requestedMode,requestedPixelFormat,conversionMode,flags,actualMode,supported) ) + +#define IDeckLinkOutput_v15_3_1_GetDisplayMode(This,displayMode,resultDisplayMode) \ + ( (This)->lpVtbl -> GetDisplayMode(This,displayMode,resultDisplayMode) ) + +#define IDeckLinkOutput_v15_3_1_GetDisplayModeIterator(This,iterator) \ + ( (This)->lpVtbl -> GetDisplayModeIterator(This,iterator) ) + +#define IDeckLinkOutput_v15_3_1_SetScreenPreviewCallback(This,previewCallback) \ + ( (This)->lpVtbl -> SetScreenPreviewCallback(This,previewCallback) ) + +#define IDeckLinkOutput_v15_3_1_EnableVideoOutput(This,displayMode,flags) \ + ( (This)->lpVtbl -> EnableVideoOutput(This,displayMode,flags) ) + +#define IDeckLinkOutput_v15_3_1_DisableVideoOutput(This) \ + ( (This)->lpVtbl -> DisableVideoOutput(This) ) + +#define IDeckLinkOutput_v15_3_1_CreateVideoFrame(This,width,height,rowBytes,pixelFormat,flags,outFrame) \ + ( (This)->lpVtbl -> CreateVideoFrame(This,width,height,rowBytes,pixelFormat,flags,outFrame) ) + +#define IDeckLinkOutput_v15_3_1_CreateVideoFrameWithBuffer(This,width,height,rowBytes,pixelFormat,flags,buffer,outFrame) \ + ( (This)->lpVtbl -> CreateVideoFrameWithBuffer(This,width,height,rowBytes,pixelFormat,flags,buffer,outFrame) ) + +#define IDeckLinkOutput_v15_3_1_RowBytesForPixelFormat(This,pixelFormat,width,rowBytes) \ + ( (This)->lpVtbl -> RowBytesForPixelFormat(This,pixelFormat,width,rowBytes) ) + +#define IDeckLinkOutput_v15_3_1_CreateAncillaryData(This,pixelFormat,outBuffer) \ + ( (This)->lpVtbl -> CreateAncillaryData(This,pixelFormat,outBuffer) ) + +#define IDeckLinkOutput_v15_3_1_DisplayVideoFrameSync(This,theFrame) \ + ( (This)->lpVtbl -> DisplayVideoFrameSync(This,theFrame) ) + +#define IDeckLinkOutput_v15_3_1_ScheduleVideoFrame(This,theFrame,displayTime,displayDuration,timeScale) \ + ( (This)->lpVtbl -> ScheduleVideoFrame(This,theFrame,displayTime,displayDuration,timeScale) ) + +#define IDeckLinkOutput_v15_3_1_SetScheduledFrameCompletionCallback(This,theCallback) \ + ( (This)->lpVtbl -> SetScheduledFrameCompletionCallback(This,theCallback) ) + +#define IDeckLinkOutput_v15_3_1_GetBufferedVideoFrameCount(This,bufferedFrameCount) \ + ( (This)->lpVtbl -> GetBufferedVideoFrameCount(This,bufferedFrameCount) ) + +#define IDeckLinkOutput_v15_3_1_EnableAudioOutput(This,sampleRate,sampleType,channelCount,streamType) \ + ( (This)->lpVtbl -> EnableAudioOutput(This,sampleRate,sampleType,channelCount,streamType) ) + +#define IDeckLinkOutput_v15_3_1_DisableAudioOutput(This) \ + ( (This)->lpVtbl -> DisableAudioOutput(This) ) + +#define IDeckLinkOutput_v15_3_1_WriteAudioSamplesSync(This,buffer,sampleFrameCount,sampleFramesWritten) \ + ( (This)->lpVtbl -> WriteAudioSamplesSync(This,buffer,sampleFrameCount,sampleFramesWritten) ) + +#define IDeckLinkOutput_v15_3_1_BeginAudioPreroll(This) \ + ( (This)->lpVtbl -> BeginAudioPreroll(This) ) + +#define IDeckLinkOutput_v15_3_1_EndAudioPreroll(This) \ + ( (This)->lpVtbl -> EndAudioPreroll(This) ) + +#define IDeckLinkOutput_v15_3_1_ScheduleAudioSamples(This,buffer,sampleFrameCount,streamTime,timeScale,sampleFramesWritten) \ + ( (This)->lpVtbl -> ScheduleAudioSamples(This,buffer,sampleFrameCount,streamTime,timeScale,sampleFramesWritten) ) + +#define IDeckLinkOutput_v15_3_1_GetBufferedAudioSampleFrameCount(This,bufferedSampleFrameCount) \ + ( (This)->lpVtbl -> GetBufferedAudioSampleFrameCount(This,bufferedSampleFrameCount) ) + +#define IDeckLinkOutput_v15_3_1_FlushBufferedAudioSamples(This) \ + ( (This)->lpVtbl -> FlushBufferedAudioSamples(This) ) + +#define IDeckLinkOutput_v15_3_1_SetAudioCallback(This,theCallback) \ + ( (This)->lpVtbl -> SetAudioCallback(This,theCallback) ) + +#define IDeckLinkOutput_v15_3_1_StartScheduledPlayback(This,playbackStartTime,timeScale,playbackSpeed) \ + ( (This)->lpVtbl -> StartScheduledPlayback(This,playbackStartTime,timeScale,playbackSpeed) ) + +#define IDeckLinkOutput_v15_3_1_StopScheduledPlayback(This,stopPlaybackAtTime,actualStopTime,timeScale) \ + ( (This)->lpVtbl -> StopScheduledPlayback(This,stopPlaybackAtTime,actualStopTime,timeScale) ) + +#define IDeckLinkOutput_v15_3_1_IsScheduledPlaybackRunning(This,active) \ + ( (This)->lpVtbl -> IsScheduledPlaybackRunning(This,active) ) + +#define IDeckLinkOutput_v15_3_1_GetScheduledStreamTime(This,desiredTimeScale,streamTime,playbackSpeed) \ + ( (This)->lpVtbl -> GetScheduledStreamTime(This,desiredTimeScale,streamTime,playbackSpeed) ) + +#define IDeckLinkOutput_v15_3_1_GetReferenceStatus(This,referenceStatus) \ + ( (This)->lpVtbl -> GetReferenceStatus(This,referenceStatus) ) + +#define IDeckLinkOutput_v15_3_1_GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) \ + ( (This)->lpVtbl -> GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) ) + +#define IDeckLinkOutput_v15_3_1_GetFrameCompletionReferenceTimestamp(This,theFrame,desiredTimeScale,frameCompletionTimestamp) \ + ( (This)->lpVtbl -> GetFrameCompletionReferenceTimestamp(This,theFrame,desiredTimeScale,frameCompletionTimestamp) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkOutput_v15_3_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkVideoConversion_v15_3_1_INTERFACE_DEFINED__ +#define __IDeckLinkVideoConversion_v15_3_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkVideoConversion_v15_3_1 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkVideoConversion_v15_3_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("A48755D9-8BD5-4727-A1E9-069FDEDBA6E9") + IDeckLinkVideoConversion_v15_3_1 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE ConvertFrame( + /* [in] */ IDeckLinkVideoFrame *srcFrame, + /* [in] */ IDeckLinkVideoFrame *dstFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE ConvertNewFrame( + /* [in] */ IDeckLinkVideoFrame *srcFrame, + /* [in] */ BMDPixelFormat dstPixelFormat, + /* [in] */ BMDColorspace dstColorspace, + /* [in] */ IDeckLinkVideoBuffer_v15_3_1 *dstBuffer, + /* [out] */ IDeckLinkVideoFrame **dstFrame) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkVideoConversion_v15_3_1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoConversion_v15_3_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoConversion_v15_3_1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoConversion_v15_3_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoConversion_v15_3_1, ConvertFrame) + HRESULT ( STDMETHODCALLTYPE *ConvertFrame )( + IDeckLinkVideoConversion_v15_3_1 * This, + /* [in] */ IDeckLinkVideoFrame *srcFrame, + /* [in] */ IDeckLinkVideoFrame *dstFrame); + + DECLSPEC_XFGVIRT(IDeckLinkVideoConversion_v15_3_1, ConvertNewFrame) + HRESULT ( STDMETHODCALLTYPE *ConvertNewFrame )( + IDeckLinkVideoConversion_v15_3_1 * This, + /* [in] */ IDeckLinkVideoFrame *srcFrame, + /* [in] */ BMDPixelFormat dstPixelFormat, + /* [in] */ BMDColorspace dstColorspace, + /* [in] */ IDeckLinkVideoBuffer_v15_3_1 *dstBuffer, + /* [out] */ IDeckLinkVideoFrame **dstFrame); + + END_INTERFACE + } IDeckLinkVideoConversion_v15_3_1Vtbl; + + interface IDeckLinkVideoConversion_v15_3_1 + { + CONST_VTBL struct IDeckLinkVideoConversion_v15_3_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkVideoConversion_v15_3_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkVideoConversion_v15_3_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkVideoConversion_v15_3_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkVideoConversion_v15_3_1_ConvertFrame(This,srcFrame,dstFrame) \ + ( (This)->lpVtbl -> ConvertFrame(This,srcFrame,dstFrame) ) + +#define IDeckLinkVideoConversion_v15_3_1_ConvertNewFrame(This,srcFrame,dstPixelFormat,dstColorspace,dstBuffer,dstFrame) \ + ( (This)->lpVtbl -> ConvertNewFrame(This,srcFrame,dstPixelFormat,dstColorspace,dstBuffer,dstFrame) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkVideoConversion_v15_3_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkNotification_v15_3_1_INTERFACE_DEFINED__ +#define __IDeckLinkNotification_v15_3_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkNotification_v15_3_1 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkNotification_v15_3_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("B85DF4C8-BDF5-47C1-8064-28162EBDD4EB") + IDeckLinkNotification_v15_3_1 : 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 IDeckLinkNotification_v15_3_1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkNotification_v15_3_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkNotification_v15_3_1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkNotification_v15_3_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkNotification_v15_3_1, Subscribe) + HRESULT ( STDMETHODCALLTYPE *Subscribe )( + IDeckLinkNotification_v15_3_1 * This, + /* [in] */ BMDNotifications topic, + /* [in] */ IDeckLinkNotificationCallback *theCallback); + + DECLSPEC_XFGVIRT(IDeckLinkNotification_v15_3_1, Unsubscribe) + HRESULT ( STDMETHODCALLTYPE *Unsubscribe )( + IDeckLinkNotification_v15_3_1 * This, + /* [in] */ BMDNotifications topic, + /* [in] */ IDeckLinkNotificationCallback *theCallback); + + END_INTERFACE + } IDeckLinkNotification_v15_3_1Vtbl; + + interface IDeckLinkNotification_v15_3_1 + { + CONST_VTBL struct IDeckLinkNotification_v15_3_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkNotification_v15_3_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkNotification_v15_3_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkNotification_v15_3_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkNotification_v15_3_1_Subscribe(This,topic,theCallback) \ + ( (This)->lpVtbl -> Subscribe(This,topic,theCallback) ) + +#define IDeckLinkNotification_v15_3_1_Unsubscribe(This,topic,theCallback) \ + ( (This)->lpVtbl -> Unsubscribe(This,topic,theCallback) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkNotification_v15_3_1_INTERFACE_DEFINED__ */ + + +EXTERN_C const CLSID CLSID_CDeckLinkVideoConversion_v15_3_1; + +#ifdef __cplusplus + +class DECLSPEC_UUID("89BA47BD-1FE2-4D76-9BFE-DE85049C4987") +CDeckLinkVideoConversion_v15_3_1; +#endif + +#ifndef __IDeckLinkProfileAttributes_v15_3_1_INTERFACE_DEFINED__ +#define __IDeckLinkProfileAttributes_v15_3_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkProfileAttributes_v15_3_1 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkProfileAttributes_v15_3_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("17D4BF8E-4911-473A-80A0-731CF6FF345B") + IDeckLinkProfileAttributes_v15_3_1 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetFlag( + /* [in] */ BMDDeckLinkAttributeID attrID, + /* [out] */ BOOL *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInt( + /* [in] */ BMDDeckLinkAttributeID attrID, + /* [out] */ LONGLONG *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFloat( + /* [in] */ BMDDeckLinkAttributeID attrID, + /* [out] */ double *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetString( + /* [in] */ BMDDeckLinkAttributeID attrID, + /* [out] */ BSTR *value) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkProfileAttributes_v15_3_1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkProfileAttributes_v15_3_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkProfileAttributes_v15_3_1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkProfileAttributes_v15_3_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkProfileAttributes_v15_3_1, GetFlag) + HRESULT ( STDMETHODCALLTYPE *GetFlag )( + IDeckLinkProfileAttributes_v15_3_1 * This, + /* [in] */ BMDDeckLinkAttributeID attrID, + /* [out] */ BOOL *value); + + DECLSPEC_XFGVIRT(IDeckLinkProfileAttributes_v15_3_1, GetInt) + HRESULT ( STDMETHODCALLTYPE *GetInt )( + IDeckLinkProfileAttributes_v15_3_1 * This, + /* [in] */ BMDDeckLinkAttributeID attrID, + /* [out] */ LONGLONG *value); + + DECLSPEC_XFGVIRT(IDeckLinkProfileAttributes_v15_3_1, GetFloat) + HRESULT ( STDMETHODCALLTYPE *GetFloat )( + IDeckLinkProfileAttributes_v15_3_1 * This, + /* [in] */ BMDDeckLinkAttributeID attrID, + /* [out] */ double *value); + + DECLSPEC_XFGVIRT(IDeckLinkProfileAttributes_v15_3_1, GetString) + HRESULT ( STDMETHODCALLTYPE *GetString )( + IDeckLinkProfileAttributes_v15_3_1 * This, + /* [in] */ BMDDeckLinkAttributeID attrID, + /* [out] */ BSTR *value); + + END_INTERFACE + } IDeckLinkProfileAttributes_v15_3_1Vtbl; + + interface IDeckLinkProfileAttributes_v15_3_1 + { + CONST_VTBL struct IDeckLinkProfileAttributes_v15_3_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkProfileAttributes_v15_3_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkProfileAttributes_v15_3_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkProfileAttributes_v15_3_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkProfileAttributes_v15_3_1_GetFlag(This,attrID,value) \ + ( (This)->lpVtbl -> GetFlag(This,attrID,value) ) + +#define IDeckLinkProfileAttributes_v15_3_1_GetInt(This,attrID,value) \ + ( (This)->lpVtbl -> GetInt(This,attrID,value) ) + +#define IDeckLinkProfileAttributes_v15_3_1_GetFloat(This,attrID,value) \ + ( (This)->lpVtbl -> GetFloat(This,attrID,value) ) + +#define IDeckLinkProfileAttributes_v15_3_1_GetString(This,attrID,value) \ + ( (This)->lpVtbl -> GetString(This,attrID,value) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkProfileAttributes_v15_3_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkVideoOutputCallback_v14_2_1_INTERFACE_DEFINED__ +#define __IDeckLinkVideoOutputCallback_v14_2_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkVideoOutputCallback_v14_2_1 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkVideoOutputCallback_v14_2_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("20AA5225-1958-47CB-820B-80A8D521A6EE") + IDeckLinkVideoOutputCallback_v14_2_1 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE ScheduledFrameCompleted( + /* [in] */ IDeckLinkVideoFrame_v14_2_1 *completedFrame, + /* [in] */ BMDOutputFrameCompletionResult result) = 0; + + virtual HRESULT STDMETHODCALLTYPE ScheduledPlaybackHasStopped( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkVideoOutputCallback_v14_2_1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoOutputCallback_v14_2_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoOutputCallback_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoOutputCallback_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoOutputCallback_v14_2_1, ScheduledFrameCompleted) + HRESULT ( STDMETHODCALLTYPE *ScheduledFrameCompleted )( + IDeckLinkVideoOutputCallback_v14_2_1 * This, + /* [in] */ IDeckLinkVideoFrame_v14_2_1 *completedFrame, + /* [in] */ BMDOutputFrameCompletionResult result); + + DECLSPEC_XFGVIRT(IDeckLinkVideoOutputCallback_v14_2_1, ScheduledPlaybackHasStopped) + HRESULT ( STDMETHODCALLTYPE *ScheduledPlaybackHasStopped )( + IDeckLinkVideoOutputCallback_v14_2_1 * This); + + END_INTERFACE + } IDeckLinkVideoOutputCallback_v14_2_1Vtbl; + + interface IDeckLinkVideoOutputCallback_v14_2_1 + { + CONST_VTBL struct IDeckLinkVideoOutputCallback_v14_2_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkVideoOutputCallback_v14_2_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkVideoOutputCallback_v14_2_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkVideoOutputCallback_v14_2_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkVideoOutputCallback_v14_2_1_ScheduledFrameCompleted(This,completedFrame,result) \ + ( (This)->lpVtbl -> ScheduledFrameCompleted(This,completedFrame,result) ) + +#define IDeckLinkVideoOutputCallback_v14_2_1_ScheduledPlaybackHasStopped(This) \ + ( (This)->lpVtbl -> ScheduledPlaybackHasStopped(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkVideoOutputCallback_v14_2_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkInputCallback_v14_2_1_INTERFACE_DEFINED__ +#define __IDeckLinkInputCallback_v14_2_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkInputCallback_v14_2_1 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkInputCallback_v14_2_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("C6FCE4C9-C4E4-4047-82FB-5D238232A902") + IDeckLinkInputCallback_v14_2_1 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE VideoInputFormatChanged( + /* [in] */ BMDVideoInputFormatChangedEvents notificationEvents, + /* [in] */ IDeckLinkDisplayMode *newDisplayMode, + /* [in] */ BMDDetectedVideoInputFormatFlags detectedSignalFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE VideoInputFrameArrived( + /* [in] */ IDeckLinkVideoInputFrame_v14_2_1 *videoFrame, + /* [in] */ IDeckLinkAudioInputPacket *audioPacket) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkInputCallback_v14_2_1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkInputCallback_v14_2_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkInputCallback_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkInputCallback_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInputCallback_v14_2_1, VideoInputFormatChanged) + HRESULT ( STDMETHODCALLTYPE *VideoInputFormatChanged )( + IDeckLinkInputCallback_v14_2_1 * This, + /* [in] */ BMDVideoInputFormatChangedEvents notificationEvents, + /* [in] */ IDeckLinkDisplayMode *newDisplayMode, + /* [in] */ BMDDetectedVideoInputFormatFlags detectedSignalFlags); + + DECLSPEC_XFGVIRT(IDeckLinkInputCallback_v14_2_1, VideoInputFrameArrived) + HRESULT ( STDMETHODCALLTYPE *VideoInputFrameArrived )( + IDeckLinkInputCallback_v14_2_1 * This, + /* [in] */ IDeckLinkVideoInputFrame_v14_2_1 *videoFrame, + /* [in] */ IDeckLinkAudioInputPacket *audioPacket); + + END_INTERFACE + } IDeckLinkInputCallback_v14_2_1Vtbl; + + interface IDeckLinkInputCallback_v14_2_1 + { + CONST_VTBL struct IDeckLinkInputCallback_v14_2_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkInputCallback_v14_2_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkInputCallback_v14_2_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkInputCallback_v14_2_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkInputCallback_v14_2_1_VideoInputFormatChanged(This,notificationEvents,newDisplayMode,detectedSignalFlags) \ + ( (This)->lpVtbl -> VideoInputFormatChanged(This,notificationEvents,newDisplayMode,detectedSignalFlags) ) + +#define IDeckLinkInputCallback_v14_2_1_VideoInputFrameArrived(This,videoFrame,audioPacket) \ + ( (This)->lpVtbl -> VideoInputFrameArrived(This,videoFrame,audioPacket) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkInputCallback_v14_2_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkMemoryAllocator_v14_2_1_INTERFACE_DEFINED__ +#define __IDeckLinkMemoryAllocator_v14_2_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkMemoryAllocator_v14_2_1 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkMemoryAllocator_v14_2_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("B36EB6E7-9D29-4AA8-92EF-843B87A289E8") + IDeckLinkMemoryAllocator_v14_2_1 : 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 IDeckLinkMemoryAllocator_v14_2_1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkMemoryAllocator_v14_2_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkMemoryAllocator_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkMemoryAllocator_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkMemoryAllocator_v14_2_1, AllocateBuffer) + HRESULT ( STDMETHODCALLTYPE *AllocateBuffer )( + IDeckLinkMemoryAllocator_v14_2_1 * This, + /* [in] */ unsigned int bufferSize, + /* [out] */ void **allocatedBuffer); + + DECLSPEC_XFGVIRT(IDeckLinkMemoryAllocator_v14_2_1, ReleaseBuffer) + HRESULT ( STDMETHODCALLTYPE *ReleaseBuffer )( + IDeckLinkMemoryAllocator_v14_2_1 * This, + /* [in] */ void *buffer); + + DECLSPEC_XFGVIRT(IDeckLinkMemoryAllocator_v14_2_1, Commit) + HRESULT ( STDMETHODCALLTYPE *Commit )( + IDeckLinkMemoryAllocator_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkMemoryAllocator_v14_2_1, Decommit) + HRESULT ( STDMETHODCALLTYPE *Decommit )( + IDeckLinkMemoryAllocator_v14_2_1 * This); + + END_INTERFACE + } IDeckLinkMemoryAllocator_v14_2_1Vtbl; + + interface IDeckLinkMemoryAllocator_v14_2_1 + { + CONST_VTBL struct IDeckLinkMemoryAllocator_v14_2_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkMemoryAllocator_v14_2_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkMemoryAllocator_v14_2_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkMemoryAllocator_v14_2_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkMemoryAllocator_v14_2_1_AllocateBuffer(This,bufferSize,allocatedBuffer) \ + ( (This)->lpVtbl -> AllocateBuffer(This,bufferSize,allocatedBuffer) ) + +#define IDeckLinkMemoryAllocator_v14_2_1_ReleaseBuffer(This,buffer) \ + ( (This)->lpVtbl -> ReleaseBuffer(This,buffer) ) + +#define IDeckLinkMemoryAllocator_v14_2_1_Commit(This) \ + ( (This)->lpVtbl -> Commit(This) ) + +#define IDeckLinkMemoryAllocator_v14_2_1_Decommit(This) \ + ( (This)->lpVtbl -> Decommit(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkMemoryAllocator_v14_2_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkOutput_v14_2_1_INTERFACE_DEFINED__ +#define __IDeckLinkOutput_v14_2_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkOutput_v14_2_1 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkOutput_v14_2_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("BE2D9020-461E-442F-84B7-E949CB953B9D") + IDeckLinkOutput_v14_2_1 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE DoesSupportVideoMode( + /* [in] */ BMDVideoConnection connection, + /* [in] */ BMDDisplayMode requestedMode, + /* [in] */ BMDPixelFormat requestedPixelFormat, + /* [in] */ BMDVideoOutputConversionMode conversionMode, + /* [in] */ BMDSupportedVideoModeFlags flags, + /* [out] */ BMDDisplayMode *actualMode, + /* [out] */ BOOL *supported) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayMode( + /* [in] */ BMDDisplayMode displayMode, + /* [out] */ IDeckLinkDisplayMode **resultDisplayMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayModeIterator( + /* [out] */ IDeckLinkDisplayModeIterator **iterator) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetScreenPreviewCallback( + /* [in] */ IDeckLinkScreenPreviewCallback_v14_2_1 *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_v14_2_1 *theAllocator) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateVideoFrame( + /* [in] */ int width, + /* [in] */ int height, + /* [in] */ int rowBytes, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDFrameFlags flags, + /* [out] */ IDeckLinkMutableVideoFrame_v14_2_1 **outFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateAncillaryData( + /* [in] */ BMDPixelFormat pixelFormat, + /* [out] */ IDeckLinkVideoFrameAncillary **outBuffer) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisplayVideoFrameSync( + /* [in] */ IDeckLinkVideoFrame_v14_2_1 *theFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE ScheduleVideoFrame( + /* [in] */ IDeckLinkVideoFrame_v14_2_1 *theFrame, + /* [in] */ BMDTimeValue displayTime, + /* [in] */ BMDTimeValue displayDuration, + /* [in] */ BMDTimeScale timeScale) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetScheduledFrameCompletionCallback( + /* [in] */ IDeckLinkVideoOutputCallback_v14_2_1 *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_v14_2_1 *theFrame, + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *frameCompletionTimestamp) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkOutput_v14_2_1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkOutput_v14_2_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkOutput_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkOutput_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v14_2_1, DoesSupportVideoMode) + HRESULT ( STDMETHODCALLTYPE *DoesSupportVideoMode )( + IDeckLinkOutput_v14_2_1 * This, + /* [in] */ BMDVideoConnection connection, + /* [in] */ BMDDisplayMode requestedMode, + /* [in] */ BMDPixelFormat requestedPixelFormat, + /* [in] */ BMDVideoOutputConversionMode conversionMode, + /* [in] */ BMDSupportedVideoModeFlags flags, + /* [out] */ BMDDisplayMode *actualMode, + /* [out] */ BOOL *supported); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v14_2_1, GetDisplayMode) + HRESULT ( STDMETHODCALLTYPE *GetDisplayMode )( + IDeckLinkOutput_v14_2_1 * This, + /* [in] */ BMDDisplayMode displayMode, + /* [out] */ IDeckLinkDisplayMode **resultDisplayMode); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v14_2_1, GetDisplayModeIterator) + HRESULT ( STDMETHODCALLTYPE *GetDisplayModeIterator )( + IDeckLinkOutput_v14_2_1 * This, + /* [out] */ IDeckLinkDisplayModeIterator **iterator); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v14_2_1, SetScreenPreviewCallback) + HRESULT ( STDMETHODCALLTYPE *SetScreenPreviewCallback )( + IDeckLinkOutput_v14_2_1 * This, + /* [in] */ IDeckLinkScreenPreviewCallback_v14_2_1 *previewCallback); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v14_2_1, EnableVideoOutput) + HRESULT ( STDMETHODCALLTYPE *EnableVideoOutput )( + IDeckLinkOutput_v14_2_1 * This, + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDVideoOutputFlags flags); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v14_2_1, DisableVideoOutput) + HRESULT ( STDMETHODCALLTYPE *DisableVideoOutput )( + IDeckLinkOutput_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v14_2_1, SetVideoOutputFrameMemoryAllocator) + HRESULT ( STDMETHODCALLTYPE *SetVideoOutputFrameMemoryAllocator )( + IDeckLinkOutput_v14_2_1 * This, + /* [in] */ IDeckLinkMemoryAllocator_v14_2_1 *theAllocator); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v14_2_1, CreateVideoFrame) + HRESULT ( STDMETHODCALLTYPE *CreateVideoFrame )( + IDeckLinkOutput_v14_2_1 * This, + /* [in] */ int width, + /* [in] */ int height, + /* [in] */ int rowBytes, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDFrameFlags flags, + /* [out] */ IDeckLinkMutableVideoFrame_v14_2_1 **outFrame); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v14_2_1, CreateAncillaryData) + HRESULT ( STDMETHODCALLTYPE *CreateAncillaryData )( + IDeckLinkOutput_v14_2_1 * This, + /* [in] */ BMDPixelFormat pixelFormat, + /* [out] */ IDeckLinkVideoFrameAncillary **outBuffer); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v14_2_1, DisplayVideoFrameSync) + HRESULT ( STDMETHODCALLTYPE *DisplayVideoFrameSync )( + IDeckLinkOutput_v14_2_1 * This, + /* [in] */ IDeckLinkVideoFrame_v14_2_1 *theFrame); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v14_2_1, ScheduleVideoFrame) + HRESULT ( STDMETHODCALLTYPE *ScheduleVideoFrame )( + IDeckLinkOutput_v14_2_1 * This, + /* [in] */ IDeckLinkVideoFrame_v14_2_1 *theFrame, + /* [in] */ BMDTimeValue displayTime, + /* [in] */ BMDTimeValue displayDuration, + /* [in] */ BMDTimeScale timeScale); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v14_2_1, SetScheduledFrameCompletionCallback) + HRESULT ( STDMETHODCALLTYPE *SetScheduledFrameCompletionCallback )( + IDeckLinkOutput_v14_2_1 * This, + /* [in] */ IDeckLinkVideoOutputCallback_v14_2_1 *theCallback); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v14_2_1, GetBufferedVideoFrameCount) + HRESULT ( STDMETHODCALLTYPE *GetBufferedVideoFrameCount )( + IDeckLinkOutput_v14_2_1 * This, + /* [out] */ unsigned int *bufferedFrameCount); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v14_2_1, EnableAudioOutput) + HRESULT ( STDMETHODCALLTYPE *EnableAudioOutput )( + IDeckLinkOutput_v14_2_1 * This, + /* [in] */ BMDAudioSampleRate sampleRate, + /* [in] */ BMDAudioSampleType sampleType, + /* [in] */ unsigned int channelCount, + /* [in] */ BMDAudioOutputStreamType streamType); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v14_2_1, DisableAudioOutput) + HRESULT ( STDMETHODCALLTYPE *DisableAudioOutput )( + IDeckLinkOutput_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v14_2_1, WriteAudioSamplesSync) + HRESULT ( STDMETHODCALLTYPE *WriteAudioSamplesSync )( + IDeckLinkOutput_v14_2_1 * This, + /* [in] */ void *buffer, + /* [in] */ unsigned int sampleFrameCount, + /* [out] */ unsigned int *sampleFramesWritten); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v14_2_1, BeginAudioPreroll) + HRESULT ( STDMETHODCALLTYPE *BeginAudioPreroll )( + IDeckLinkOutput_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v14_2_1, EndAudioPreroll) + HRESULT ( STDMETHODCALLTYPE *EndAudioPreroll )( + IDeckLinkOutput_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v14_2_1, ScheduleAudioSamples) + HRESULT ( STDMETHODCALLTYPE *ScheduleAudioSamples )( + IDeckLinkOutput_v14_2_1 * This, + /* [in] */ void *buffer, + /* [in] */ unsigned int sampleFrameCount, + /* [in] */ BMDTimeValue streamTime, + /* [in] */ BMDTimeScale timeScale, + /* [out] */ unsigned int *sampleFramesWritten); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v14_2_1, GetBufferedAudioSampleFrameCount) + HRESULT ( STDMETHODCALLTYPE *GetBufferedAudioSampleFrameCount )( + IDeckLinkOutput_v14_2_1 * This, + /* [out] */ unsigned int *bufferedSampleFrameCount); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v14_2_1, FlushBufferedAudioSamples) + HRESULT ( STDMETHODCALLTYPE *FlushBufferedAudioSamples )( + IDeckLinkOutput_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v14_2_1, SetAudioCallback) + HRESULT ( STDMETHODCALLTYPE *SetAudioCallback )( + IDeckLinkOutput_v14_2_1 * This, + /* [in] */ IDeckLinkAudioOutputCallback *theCallback); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v14_2_1, StartScheduledPlayback) + HRESULT ( STDMETHODCALLTYPE *StartScheduledPlayback )( + IDeckLinkOutput_v14_2_1 * This, + /* [in] */ BMDTimeValue playbackStartTime, + /* [in] */ BMDTimeScale timeScale, + /* [in] */ double playbackSpeed); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v14_2_1, StopScheduledPlayback) + HRESULT ( STDMETHODCALLTYPE *StopScheduledPlayback )( + IDeckLinkOutput_v14_2_1 * This, + /* [in] */ BMDTimeValue stopPlaybackAtTime, + /* [out] */ BMDTimeValue *actualStopTime, + /* [in] */ BMDTimeScale timeScale); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v14_2_1, IsScheduledPlaybackRunning) + HRESULT ( STDMETHODCALLTYPE *IsScheduledPlaybackRunning )( + IDeckLinkOutput_v14_2_1 * This, + /* [out] */ BOOL *active); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v14_2_1, GetScheduledStreamTime) + HRESULT ( STDMETHODCALLTYPE *GetScheduledStreamTime )( + IDeckLinkOutput_v14_2_1 * This, + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *streamTime, + /* [out] */ double *playbackSpeed); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v14_2_1, GetReferenceStatus) + HRESULT ( STDMETHODCALLTYPE *GetReferenceStatus )( + IDeckLinkOutput_v14_2_1 * This, + /* [out] */ BMDReferenceStatus *referenceStatus); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v14_2_1, GetHardwareReferenceClock) + HRESULT ( STDMETHODCALLTYPE *GetHardwareReferenceClock )( + IDeckLinkOutput_v14_2_1 * This, + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *hardwareTime, + /* [out] */ BMDTimeValue *timeInFrame, + /* [out] */ BMDTimeValue *ticksPerFrame); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v14_2_1, GetFrameCompletionReferenceTimestamp) + HRESULT ( STDMETHODCALLTYPE *GetFrameCompletionReferenceTimestamp )( + IDeckLinkOutput_v14_2_1 * This, + /* [in] */ IDeckLinkVideoFrame_v14_2_1 *theFrame, + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *frameCompletionTimestamp); + + END_INTERFACE + } IDeckLinkOutput_v14_2_1Vtbl; + + interface IDeckLinkOutput_v14_2_1 + { + CONST_VTBL struct IDeckLinkOutput_v14_2_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkOutput_v14_2_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkOutput_v14_2_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkOutput_v14_2_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkOutput_v14_2_1_DoesSupportVideoMode(This,connection,requestedMode,requestedPixelFormat,conversionMode,flags,actualMode,supported) \ + ( (This)->lpVtbl -> DoesSupportVideoMode(This,connection,requestedMode,requestedPixelFormat,conversionMode,flags,actualMode,supported) ) + +#define IDeckLinkOutput_v14_2_1_GetDisplayMode(This,displayMode,resultDisplayMode) \ + ( (This)->lpVtbl -> GetDisplayMode(This,displayMode,resultDisplayMode) ) + +#define IDeckLinkOutput_v14_2_1_GetDisplayModeIterator(This,iterator) \ + ( (This)->lpVtbl -> GetDisplayModeIterator(This,iterator) ) + +#define IDeckLinkOutput_v14_2_1_SetScreenPreviewCallback(This,previewCallback) \ + ( (This)->lpVtbl -> SetScreenPreviewCallback(This,previewCallback) ) + +#define IDeckLinkOutput_v14_2_1_EnableVideoOutput(This,displayMode,flags) \ + ( (This)->lpVtbl -> EnableVideoOutput(This,displayMode,flags) ) + +#define IDeckLinkOutput_v14_2_1_DisableVideoOutput(This) \ + ( (This)->lpVtbl -> DisableVideoOutput(This) ) + +#define IDeckLinkOutput_v14_2_1_SetVideoOutputFrameMemoryAllocator(This,theAllocator) \ + ( (This)->lpVtbl -> SetVideoOutputFrameMemoryAllocator(This,theAllocator) ) + +#define IDeckLinkOutput_v14_2_1_CreateVideoFrame(This,width,height,rowBytes,pixelFormat,flags,outFrame) \ + ( (This)->lpVtbl -> CreateVideoFrame(This,width,height,rowBytes,pixelFormat,flags,outFrame) ) + +#define IDeckLinkOutput_v14_2_1_CreateAncillaryData(This,pixelFormat,outBuffer) \ + ( (This)->lpVtbl -> CreateAncillaryData(This,pixelFormat,outBuffer) ) + +#define IDeckLinkOutput_v14_2_1_DisplayVideoFrameSync(This,theFrame) \ + ( (This)->lpVtbl -> DisplayVideoFrameSync(This,theFrame) ) + +#define IDeckLinkOutput_v14_2_1_ScheduleVideoFrame(This,theFrame,displayTime,displayDuration,timeScale) \ + ( (This)->lpVtbl -> ScheduleVideoFrame(This,theFrame,displayTime,displayDuration,timeScale) ) + +#define IDeckLinkOutput_v14_2_1_SetScheduledFrameCompletionCallback(This,theCallback) \ + ( (This)->lpVtbl -> SetScheduledFrameCompletionCallback(This,theCallback) ) + +#define IDeckLinkOutput_v14_2_1_GetBufferedVideoFrameCount(This,bufferedFrameCount) \ + ( (This)->lpVtbl -> GetBufferedVideoFrameCount(This,bufferedFrameCount) ) + +#define IDeckLinkOutput_v14_2_1_EnableAudioOutput(This,sampleRate,sampleType,channelCount,streamType) \ + ( (This)->lpVtbl -> EnableAudioOutput(This,sampleRate,sampleType,channelCount,streamType) ) + +#define IDeckLinkOutput_v14_2_1_DisableAudioOutput(This) \ + ( (This)->lpVtbl -> DisableAudioOutput(This) ) + +#define IDeckLinkOutput_v14_2_1_WriteAudioSamplesSync(This,buffer,sampleFrameCount,sampleFramesWritten) \ + ( (This)->lpVtbl -> WriteAudioSamplesSync(This,buffer,sampleFrameCount,sampleFramesWritten) ) + +#define IDeckLinkOutput_v14_2_1_BeginAudioPreroll(This) \ + ( (This)->lpVtbl -> BeginAudioPreroll(This) ) + +#define IDeckLinkOutput_v14_2_1_EndAudioPreroll(This) \ + ( (This)->lpVtbl -> EndAudioPreroll(This) ) + +#define IDeckLinkOutput_v14_2_1_ScheduleAudioSamples(This,buffer,sampleFrameCount,streamTime,timeScale,sampleFramesWritten) \ + ( (This)->lpVtbl -> ScheduleAudioSamples(This,buffer,sampleFrameCount,streamTime,timeScale,sampleFramesWritten) ) + +#define IDeckLinkOutput_v14_2_1_GetBufferedAudioSampleFrameCount(This,bufferedSampleFrameCount) \ + ( (This)->lpVtbl -> GetBufferedAudioSampleFrameCount(This,bufferedSampleFrameCount) ) + +#define IDeckLinkOutput_v14_2_1_FlushBufferedAudioSamples(This) \ + ( (This)->lpVtbl -> FlushBufferedAudioSamples(This) ) + +#define IDeckLinkOutput_v14_2_1_SetAudioCallback(This,theCallback) \ + ( (This)->lpVtbl -> SetAudioCallback(This,theCallback) ) + +#define IDeckLinkOutput_v14_2_1_StartScheduledPlayback(This,playbackStartTime,timeScale,playbackSpeed) \ + ( (This)->lpVtbl -> StartScheduledPlayback(This,playbackStartTime,timeScale,playbackSpeed) ) + +#define IDeckLinkOutput_v14_2_1_StopScheduledPlayback(This,stopPlaybackAtTime,actualStopTime,timeScale) \ + ( (This)->lpVtbl -> StopScheduledPlayback(This,stopPlaybackAtTime,actualStopTime,timeScale) ) + +#define IDeckLinkOutput_v14_2_1_IsScheduledPlaybackRunning(This,active) \ + ( (This)->lpVtbl -> IsScheduledPlaybackRunning(This,active) ) + +#define IDeckLinkOutput_v14_2_1_GetScheduledStreamTime(This,desiredTimeScale,streamTime,playbackSpeed) \ + ( (This)->lpVtbl -> GetScheduledStreamTime(This,desiredTimeScale,streamTime,playbackSpeed) ) + +#define IDeckLinkOutput_v14_2_1_GetReferenceStatus(This,referenceStatus) \ + ( (This)->lpVtbl -> GetReferenceStatus(This,referenceStatus) ) + +#define IDeckLinkOutput_v14_2_1_GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) \ + ( (This)->lpVtbl -> GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) ) + +#define IDeckLinkOutput_v14_2_1_GetFrameCompletionReferenceTimestamp(This,theFrame,desiredTimeScale,frameCompletionTimestamp) \ + ( (This)->lpVtbl -> GetFrameCompletionReferenceTimestamp(This,theFrame,desiredTimeScale,frameCompletionTimestamp) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkOutput_v14_2_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkInput_v14_2_1_INTERFACE_DEFINED__ +#define __IDeckLinkInput_v14_2_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkInput_v14_2_1 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkInput_v14_2_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("C21CDB6E-F414-46E4-A636-80A566E0ED37") + IDeckLinkInput_v14_2_1 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE DoesSupportVideoMode( + /* [in] */ BMDVideoConnection connection, + /* [in] */ BMDDisplayMode requestedMode, + /* [in] */ BMDPixelFormat requestedPixelFormat, + /* [in] */ BMDVideoInputConversionMode conversionMode, + /* [in] */ BMDSupportedVideoModeFlags flags, + /* [out] */ BMDDisplayMode *actualMode, + /* [out] */ BOOL *supported) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayMode( + /* [in] */ BMDDisplayMode displayMode, + /* [out] */ IDeckLinkDisplayMode **resultDisplayMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayModeIterator( + /* [out] */ IDeckLinkDisplayModeIterator **iterator) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetScreenPreviewCallback( + /* [in] */ IDeckLinkScreenPreviewCallback_v14_2_1 *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_v14_2_1 *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_v14_2_1 *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_v14_2_1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkInput_v14_2_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkInput_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkInput_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v14_2_1, DoesSupportVideoMode) + HRESULT ( STDMETHODCALLTYPE *DoesSupportVideoMode )( + IDeckLinkInput_v14_2_1 * This, + /* [in] */ BMDVideoConnection connection, + /* [in] */ BMDDisplayMode requestedMode, + /* [in] */ BMDPixelFormat requestedPixelFormat, + /* [in] */ BMDVideoInputConversionMode conversionMode, + /* [in] */ BMDSupportedVideoModeFlags flags, + /* [out] */ BMDDisplayMode *actualMode, + /* [out] */ BOOL *supported); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v14_2_1, GetDisplayMode) + HRESULT ( STDMETHODCALLTYPE *GetDisplayMode )( + IDeckLinkInput_v14_2_1 * This, + /* [in] */ BMDDisplayMode displayMode, + /* [out] */ IDeckLinkDisplayMode **resultDisplayMode); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v14_2_1, GetDisplayModeIterator) + HRESULT ( STDMETHODCALLTYPE *GetDisplayModeIterator )( + IDeckLinkInput_v14_2_1 * This, + /* [out] */ IDeckLinkDisplayModeIterator **iterator); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v14_2_1, SetScreenPreviewCallback) + HRESULT ( STDMETHODCALLTYPE *SetScreenPreviewCallback )( + IDeckLinkInput_v14_2_1 * This, + /* [in] */ IDeckLinkScreenPreviewCallback_v14_2_1 *previewCallback); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v14_2_1, EnableVideoInput) + HRESULT ( STDMETHODCALLTYPE *EnableVideoInput )( + IDeckLinkInput_v14_2_1 * This, + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDVideoInputFlags flags); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v14_2_1, DisableVideoInput) + HRESULT ( STDMETHODCALLTYPE *DisableVideoInput )( + IDeckLinkInput_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v14_2_1, GetAvailableVideoFrameCount) + HRESULT ( STDMETHODCALLTYPE *GetAvailableVideoFrameCount )( + IDeckLinkInput_v14_2_1 * This, + /* [out] */ unsigned int *availableFrameCount); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v14_2_1, SetVideoInputFrameMemoryAllocator) + HRESULT ( STDMETHODCALLTYPE *SetVideoInputFrameMemoryAllocator )( + IDeckLinkInput_v14_2_1 * This, + /* [in] */ IDeckLinkMemoryAllocator_v14_2_1 *theAllocator); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v14_2_1, EnableAudioInput) + HRESULT ( STDMETHODCALLTYPE *EnableAudioInput )( + IDeckLinkInput_v14_2_1 * This, + /* [in] */ BMDAudioSampleRate sampleRate, + /* [in] */ BMDAudioSampleType sampleType, + /* [in] */ unsigned int channelCount); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v14_2_1, DisableAudioInput) + HRESULT ( STDMETHODCALLTYPE *DisableAudioInput )( + IDeckLinkInput_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v14_2_1, GetAvailableAudioSampleFrameCount) + HRESULT ( STDMETHODCALLTYPE *GetAvailableAudioSampleFrameCount )( + IDeckLinkInput_v14_2_1 * This, + /* [out] */ unsigned int *availableSampleFrameCount); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v14_2_1, StartStreams) + HRESULT ( STDMETHODCALLTYPE *StartStreams )( + IDeckLinkInput_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v14_2_1, StopStreams) + HRESULT ( STDMETHODCALLTYPE *StopStreams )( + IDeckLinkInput_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v14_2_1, PauseStreams) + HRESULT ( STDMETHODCALLTYPE *PauseStreams )( + IDeckLinkInput_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v14_2_1, FlushStreams) + HRESULT ( STDMETHODCALLTYPE *FlushStreams )( + IDeckLinkInput_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v14_2_1, SetCallback) + HRESULT ( STDMETHODCALLTYPE *SetCallback )( + IDeckLinkInput_v14_2_1 * This, + /* [in] */ IDeckLinkInputCallback_v14_2_1 *theCallback); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v14_2_1, GetHardwareReferenceClock) + HRESULT ( STDMETHODCALLTYPE *GetHardwareReferenceClock )( + IDeckLinkInput_v14_2_1 * This, + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *hardwareTime, + /* [out] */ BMDTimeValue *timeInFrame, + /* [out] */ BMDTimeValue *ticksPerFrame); + + END_INTERFACE + } IDeckLinkInput_v14_2_1Vtbl; + + interface IDeckLinkInput_v14_2_1 + { + CONST_VTBL struct IDeckLinkInput_v14_2_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkInput_v14_2_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkInput_v14_2_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkInput_v14_2_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkInput_v14_2_1_DoesSupportVideoMode(This,connection,requestedMode,requestedPixelFormat,conversionMode,flags,actualMode,supported) \ + ( (This)->lpVtbl -> DoesSupportVideoMode(This,connection,requestedMode,requestedPixelFormat,conversionMode,flags,actualMode,supported) ) + +#define IDeckLinkInput_v14_2_1_GetDisplayMode(This,displayMode,resultDisplayMode) \ + ( (This)->lpVtbl -> GetDisplayMode(This,displayMode,resultDisplayMode) ) + +#define IDeckLinkInput_v14_2_1_GetDisplayModeIterator(This,iterator) \ + ( (This)->lpVtbl -> GetDisplayModeIterator(This,iterator) ) + +#define IDeckLinkInput_v14_2_1_SetScreenPreviewCallback(This,previewCallback) \ + ( (This)->lpVtbl -> SetScreenPreviewCallback(This,previewCallback) ) + +#define IDeckLinkInput_v14_2_1_EnableVideoInput(This,displayMode,pixelFormat,flags) \ + ( (This)->lpVtbl -> EnableVideoInput(This,displayMode,pixelFormat,flags) ) + +#define IDeckLinkInput_v14_2_1_DisableVideoInput(This) \ + ( (This)->lpVtbl -> DisableVideoInput(This) ) + +#define IDeckLinkInput_v14_2_1_GetAvailableVideoFrameCount(This,availableFrameCount) \ + ( (This)->lpVtbl -> GetAvailableVideoFrameCount(This,availableFrameCount) ) + +#define IDeckLinkInput_v14_2_1_SetVideoInputFrameMemoryAllocator(This,theAllocator) \ + ( (This)->lpVtbl -> SetVideoInputFrameMemoryAllocator(This,theAllocator) ) + +#define IDeckLinkInput_v14_2_1_EnableAudioInput(This,sampleRate,sampleType,channelCount) \ + ( (This)->lpVtbl -> EnableAudioInput(This,sampleRate,sampleType,channelCount) ) + +#define IDeckLinkInput_v14_2_1_DisableAudioInput(This) \ + ( (This)->lpVtbl -> DisableAudioInput(This) ) + +#define IDeckLinkInput_v14_2_1_GetAvailableAudioSampleFrameCount(This,availableSampleFrameCount) \ + ( (This)->lpVtbl -> GetAvailableAudioSampleFrameCount(This,availableSampleFrameCount) ) + +#define IDeckLinkInput_v14_2_1_StartStreams(This) \ + ( (This)->lpVtbl -> StartStreams(This) ) + +#define IDeckLinkInput_v14_2_1_StopStreams(This) \ + ( (This)->lpVtbl -> StopStreams(This) ) + +#define IDeckLinkInput_v14_2_1_PauseStreams(This) \ + ( (This)->lpVtbl -> PauseStreams(This) ) + +#define IDeckLinkInput_v14_2_1_FlushStreams(This) \ + ( (This)->lpVtbl -> FlushStreams(This) ) + +#define IDeckLinkInput_v14_2_1_SetCallback(This,theCallback) \ + ( (This)->lpVtbl -> SetCallback(This,theCallback) ) + +#define IDeckLinkInput_v14_2_1_GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) \ + ( (This)->lpVtbl -> GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkInput_v14_2_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkEncoderInput_v14_2_1_INTERFACE_DEFINED__ +#define __IDeckLinkEncoderInput_v14_2_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkEncoderInput_v14_2_1 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkEncoderInput_v14_2_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("F222551D-13DF-4FD8-B587-9D4F19EC12C9") + IDeckLinkEncoderInput_v14_2_1 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE DoesSupportVideoMode( + /* [in] */ BMDVideoConnection connection, + /* [in] */ BMDDisplayMode requestedMode, + /* [in] */ BMDPixelFormat requestedCodec, + /* [in] */ unsigned int requestedCodecProfile, + /* [in] */ BMDSupportedVideoModeFlags flags, + /* [out] */ BOOL *supported) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayMode( + /* [in] */ BMDDisplayMode displayMode, + /* [out] */ IDeckLinkDisplayMode **resultDisplayMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayModeIterator( + /* [out] */ IDeckLinkDisplayModeIterator **iterator) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableVideoInput( + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDVideoInputFlags flags) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisableVideoInput( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAvailablePacketsCount( + /* [out] */ unsigned int *availablePacketsCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetMemoryAllocator( + /* [in] */ IDeckLinkMemoryAllocator_v14_2_1 *theAllocator) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableAudioInput( + /* [in] */ BMDAudioFormat audioFormat, + /* [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] */ IDeckLinkEncoderInputCallback *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 IDeckLinkEncoderInput_v14_2_1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkEncoderInput_v14_2_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkEncoderInput_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkEncoderInput_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput_v14_2_1, DoesSupportVideoMode) + HRESULT ( STDMETHODCALLTYPE *DoesSupportVideoMode )( + IDeckLinkEncoderInput_v14_2_1 * This, + /* [in] */ BMDVideoConnection connection, + /* [in] */ BMDDisplayMode requestedMode, + /* [in] */ BMDPixelFormat requestedCodec, + /* [in] */ unsigned int requestedCodecProfile, + /* [in] */ BMDSupportedVideoModeFlags flags, + /* [out] */ BOOL *supported); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput_v14_2_1, GetDisplayMode) + HRESULT ( STDMETHODCALLTYPE *GetDisplayMode )( + IDeckLinkEncoderInput_v14_2_1 * This, + /* [in] */ BMDDisplayMode displayMode, + /* [out] */ IDeckLinkDisplayMode **resultDisplayMode); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput_v14_2_1, GetDisplayModeIterator) + HRESULT ( STDMETHODCALLTYPE *GetDisplayModeIterator )( + IDeckLinkEncoderInput_v14_2_1 * This, + /* [out] */ IDeckLinkDisplayModeIterator **iterator); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput_v14_2_1, EnableVideoInput) + HRESULT ( STDMETHODCALLTYPE *EnableVideoInput )( + IDeckLinkEncoderInput_v14_2_1 * This, + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDVideoInputFlags flags); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput_v14_2_1, DisableVideoInput) + HRESULT ( STDMETHODCALLTYPE *DisableVideoInput )( + IDeckLinkEncoderInput_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput_v14_2_1, GetAvailablePacketsCount) + HRESULT ( STDMETHODCALLTYPE *GetAvailablePacketsCount )( + IDeckLinkEncoderInput_v14_2_1 * This, + /* [out] */ unsigned int *availablePacketsCount); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput_v14_2_1, SetMemoryAllocator) + HRESULT ( STDMETHODCALLTYPE *SetMemoryAllocator )( + IDeckLinkEncoderInput_v14_2_1 * This, + /* [in] */ IDeckLinkMemoryAllocator_v14_2_1 *theAllocator); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput_v14_2_1, EnableAudioInput) + HRESULT ( STDMETHODCALLTYPE *EnableAudioInput )( + IDeckLinkEncoderInput_v14_2_1 * This, + /* [in] */ BMDAudioFormat audioFormat, + /* [in] */ BMDAudioSampleRate sampleRate, + /* [in] */ BMDAudioSampleType sampleType, + /* [in] */ unsigned int channelCount); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput_v14_2_1, DisableAudioInput) + HRESULT ( STDMETHODCALLTYPE *DisableAudioInput )( + IDeckLinkEncoderInput_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput_v14_2_1, GetAvailableAudioSampleFrameCount) + HRESULT ( STDMETHODCALLTYPE *GetAvailableAudioSampleFrameCount )( + IDeckLinkEncoderInput_v14_2_1 * This, + /* [out] */ unsigned int *availableSampleFrameCount); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput_v14_2_1, StartStreams) + HRESULT ( STDMETHODCALLTYPE *StartStreams )( + IDeckLinkEncoderInput_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput_v14_2_1, StopStreams) + HRESULT ( STDMETHODCALLTYPE *StopStreams )( + IDeckLinkEncoderInput_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput_v14_2_1, PauseStreams) + HRESULT ( STDMETHODCALLTYPE *PauseStreams )( + IDeckLinkEncoderInput_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput_v14_2_1, FlushStreams) + HRESULT ( STDMETHODCALLTYPE *FlushStreams )( + IDeckLinkEncoderInput_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput_v14_2_1, SetCallback) + HRESULT ( STDMETHODCALLTYPE *SetCallback )( + IDeckLinkEncoderInput_v14_2_1 * This, + /* [in] */ IDeckLinkEncoderInputCallback *theCallback); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput_v14_2_1, GetHardwareReferenceClock) + HRESULT ( STDMETHODCALLTYPE *GetHardwareReferenceClock )( + IDeckLinkEncoderInput_v14_2_1 * This, + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *hardwareTime, + /* [out] */ BMDTimeValue *timeInFrame, + /* [out] */ BMDTimeValue *ticksPerFrame); + + END_INTERFACE + } IDeckLinkEncoderInput_v14_2_1Vtbl; + + interface IDeckLinkEncoderInput_v14_2_1 + { + CONST_VTBL struct IDeckLinkEncoderInput_v14_2_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkEncoderInput_v14_2_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkEncoderInput_v14_2_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkEncoderInput_v14_2_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkEncoderInput_v14_2_1_DoesSupportVideoMode(This,connection,requestedMode,requestedCodec,requestedCodecProfile,flags,supported) \ + ( (This)->lpVtbl -> DoesSupportVideoMode(This,connection,requestedMode,requestedCodec,requestedCodecProfile,flags,supported) ) + +#define IDeckLinkEncoderInput_v14_2_1_GetDisplayMode(This,displayMode,resultDisplayMode) \ + ( (This)->lpVtbl -> GetDisplayMode(This,displayMode,resultDisplayMode) ) + +#define IDeckLinkEncoderInput_v14_2_1_GetDisplayModeIterator(This,iterator) \ + ( (This)->lpVtbl -> GetDisplayModeIterator(This,iterator) ) + +#define IDeckLinkEncoderInput_v14_2_1_EnableVideoInput(This,displayMode,pixelFormat,flags) \ + ( (This)->lpVtbl -> EnableVideoInput(This,displayMode,pixelFormat,flags) ) + +#define IDeckLinkEncoderInput_v14_2_1_DisableVideoInput(This) \ + ( (This)->lpVtbl -> DisableVideoInput(This) ) + +#define IDeckLinkEncoderInput_v14_2_1_GetAvailablePacketsCount(This,availablePacketsCount) \ + ( (This)->lpVtbl -> GetAvailablePacketsCount(This,availablePacketsCount) ) + +#define IDeckLinkEncoderInput_v14_2_1_SetMemoryAllocator(This,theAllocator) \ + ( (This)->lpVtbl -> SetMemoryAllocator(This,theAllocator) ) + +#define IDeckLinkEncoderInput_v14_2_1_EnableAudioInput(This,audioFormat,sampleRate,sampleType,channelCount) \ + ( (This)->lpVtbl -> EnableAudioInput(This,audioFormat,sampleRate,sampleType,channelCount) ) + +#define IDeckLinkEncoderInput_v14_2_1_DisableAudioInput(This) \ + ( (This)->lpVtbl -> DisableAudioInput(This) ) + +#define IDeckLinkEncoderInput_v14_2_1_GetAvailableAudioSampleFrameCount(This,availableSampleFrameCount) \ + ( (This)->lpVtbl -> GetAvailableAudioSampleFrameCount(This,availableSampleFrameCount) ) + +#define IDeckLinkEncoderInput_v14_2_1_StartStreams(This) \ + ( (This)->lpVtbl -> StartStreams(This) ) + +#define IDeckLinkEncoderInput_v14_2_1_StopStreams(This) \ + ( (This)->lpVtbl -> StopStreams(This) ) + +#define IDeckLinkEncoderInput_v14_2_1_PauseStreams(This) \ + ( (This)->lpVtbl -> PauseStreams(This) ) + +#define IDeckLinkEncoderInput_v14_2_1_FlushStreams(This) \ + ( (This)->lpVtbl -> FlushStreams(This) ) + +#define IDeckLinkEncoderInput_v14_2_1_SetCallback(This,theCallback) \ + ( (This)->lpVtbl -> SetCallback(This,theCallback) ) + +#define IDeckLinkEncoderInput_v14_2_1_GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) \ + ( (This)->lpVtbl -> GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkEncoderInput_v14_2_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkVideoFrame_v14_2_1_INTERFACE_DEFINED__ +#define __IDeckLinkVideoFrame_v14_2_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkVideoFrame_v14_2_1 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkVideoFrame_v14_2_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("3F716FE0-F023-4111-BE5D-EF4414C05B17") + IDeckLinkVideoFrame_v14_2_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( + /* [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 IDeckLinkVideoFrame_v14_2_1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoFrame_v14_2_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoFrame_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoFrame_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame_v14_2_1, GetWidth) + long ( STDMETHODCALLTYPE *GetWidth )( + IDeckLinkVideoFrame_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame_v14_2_1, GetHeight) + long ( STDMETHODCALLTYPE *GetHeight )( + IDeckLinkVideoFrame_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame_v14_2_1, GetRowBytes) + long ( STDMETHODCALLTYPE *GetRowBytes )( + IDeckLinkVideoFrame_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame_v14_2_1, GetPixelFormat) + BMDPixelFormat ( STDMETHODCALLTYPE *GetPixelFormat )( + IDeckLinkVideoFrame_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame_v14_2_1, GetFlags) + BMDFrameFlags ( STDMETHODCALLTYPE *GetFlags )( + IDeckLinkVideoFrame_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame_v14_2_1, GetBytes) + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IDeckLinkVideoFrame_v14_2_1 * This, + /* [out] */ void **buffer); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame_v14_2_1, GetTimecode) + HRESULT ( STDMETHODCALLTYPE *GetTimecode )( + IDeckLinkVideoFrame_v14_2_1 * This, + /* [in] */ BMDTimecodeFormat format, + /* [out] */ IDeckLinkTimecode **timecode); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame_v14_2_1, GetAncillaryData) + HRESULT ( STDMETHODCALLTYPE *GetAncillaryData )( + IDeckLinkVideoFrame_v14_2_1 * This, + /* [out] */ IDeckLinkVideoFrameAncillary **ancillary); + + END_INTERFACE + } IDeckLinkVideoFrame_v14_2_1Vtbl; + + interface IDeckLinkVideoFrame_v14_2_1 + { + CONST_VTBL struct IDeckLinkVideoFrame_v14_2_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkVideoFrame_v14_2_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkVideoFrame_v14_2_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkVideoFrame_v14_2_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkVideoFrame_v14_2_1_GetWidth(This) \ + ( (This)->lpVtbl -> GetWidth(This) ) + +#define IDeckLinkVideoFrame_v14_2_1_GetHeight(This) \ + ( (This)->lpVtbl -> GetHeight(This) ) + +#define IDeckLinkVideoFrame_v14_2_1_GetRowBytes(This) \ + ( (This)->lpVtbl -> GetRowBytes(This) ) + +#define IDeckLinkVideoFrame_v14_2_1_GetPixelFormat(This) \ + ( (This)->lpVtbl -> GetPixelFormat(This) ) + +#define IDeckLinkVideoFrame_v14_2_1_GetFlags(This) \ + ( (This)->lpVtbl -> GetFlags(This) ) + +#define IDeckLinkVideoFrame_v14_2_1_GetBytes(This,buffer) \ + ( (This)->lpVtbl -> GetBytes(This,buffer) ) + +#define IDeckLinkVideoFrame_v14_2_1_GetTimecode(This,format,timecode) \ + ( (This)->lpVtbl -> GetTimecode(This,format,timecode) ) + +#define IDeckLinkVideoFrame_v14_2_1_GetAncillaryData(This,ancillary) \ + ( (This)->lpVtbl -> GetAncillaryData(This,ancillary) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkVideoFrame_v14_2_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkMutableVideoFrame_v14_2_1_INTERFACE_DEFINED__ +#define __IDeckLinkMutableVideoFrame_v14_2_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkMutableVideoFrame_v14_2_1 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkMutableVideoFrame_v14_2_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("69E2639F-40DA-4E19-B6F2-20ACE815C390") + IDeckLinkMutableVideoFrame_v14_2_1 : public IDeckLinkVideoFrame_v14_2_1 + { + 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 IDeckLinkMutableVideoFrame_v14_2_1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkMutableVideoFrame_v14_2_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkMutableVideoFrame_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkMutableVideoFrame_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame_v14_2_1, GetWidth) + long ( STDMETHODCALLTYPE *GetWidth )( + IDeckLinkMutableVideoFrame_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame_v14_2_1, GetHeight) + long ( STDMETHODCALLTYPE *GetHeight )( + IDeckLinkMutableVideoFrame_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame_v14_2_1, GetRowBytes) + long ( STDMETHODCALLTYPE *GetRowBytes )( + IDeckLinkMutableVideoFrame_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame_v14_2_1, GetPixelFormat) + BMDPixelFormat ( STDMETHODCALLTYPE *GetPixelFormat )( + IDeckLinkMutableVideoFrame_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame_v14_2_1, GetFlags) + BMDFrameFlags ( STDMETHODCALLTYPE *GetFlags )( + IDeckLinkMutableVideoFrame_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame_v14_2_1, GetBytes) + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IDeckLinkMutableVideoFrame_v14_2_1 * This, + /* [out] */ void **buffer); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame_v14_2_1, GetTimecode) + HRESULT ( STDMETHODCALLTYPE *GetTimecode )( + IDeckLinkMutableVideoFrame_v14_2_1 * This, + /* [in] */ BMDTimecodeFormat format, + /* [out] */ IDeckLinkTimecode **timecode); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame_v14_2_1, GetAncillaryData) + HRESULT ( STDMETHODCALLTYPE *GetAncillaryData )( + IDeckLinkMutableVideoFrame_v14_2_1 * This, + /* [out] */ IDeckLinkVideoFrameAncillary **ancillary); + + DECLSPEC_XFGVIRT(IDeckLinkMutableVideoFrame_v14_2_1, SetFlags) + HRESULT ( STDMETHODCALLTYPE *SetFlags )( + IDeckLinkMutableVideoFrame_v14_2_1 * This, + /* [in] */ BMDFrameFlags newFlags); + + DECLSPEC_XFGVIRT(IDeckLinkMutableVideoFrame_v14_2_1, SetTimecode) + HRESULT ( STDMETHODCALLTYPE *SetTimecode )( + IDeckLinkMutableVideoFrame_v14_2_1 * This, + /* [in] */ BMDTimecodeFormat format, + /* [in] */ IDeckLinkTimecode *timecode); + + DECLSPEC_XFGVIRT(IDeckLinkMutableVideoFrame_v14_2_1, SetTimecodeFromComponents) + HRESULT ( STDMETHODCALLTYPE *SetTimecodeFromComponents )( + IDeckLinkMutableVideoFrame_v14_2_1 * This, + /* [in] */ BMDTimecodeFormat format, + /* [in] */ unsigned char hours, + /* [in] */ unsigned char minutes, + /* [in] */ unsigned char seconds, + /* [in] */ unsigned char frames, + /* [in] */ BMDTimecodeFlags flags); + + DECLSPEC_XFGVIRT(IDeckLinkMutableVideoFrame_v14_2_1, SetAncillaryData) + HRESULT ( STDMETHODCALLTYPE *SetAncillaryData )( + IDeckLinkMutableVideoFrame_v14_2_1 * This, + /* [in] */ IDeckLinkVideoFrameAncillary *ancillary); + + DECLSPEC_XFGVIRT(IDeckLinkMutableVideoFrame_v14_2_1, SetTimecodeUserBits) + HRESULT ( STDMETHODCALLTYPE *SetTimecodeUserBits )( + IDeckLinkMutableVideoFrame_v14_2_1 * This, + /* [in] */ BMDTimecodeFormat format, + /* [in] */ BMDTimecodeUserBits userBits); + + END_INTERFACE + } IDeckLinkMutableVideoFrame_v14_2_1Vtbl; + + interface IDeckLinkMutableVideoFrame_v14_2_1 + { + CONST_VTBL struct IDeckLinkMutableVideoFrame_v14_2_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkMutableVideoFrame_v14_2_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkMutableVideoFrame_v14_2_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkMutableVideoFrame_v14_2_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkMutableVideoFrame_v14_2_1_GetWidth(This) \ + ( (This)->lpVtbl -> GetWidth(This) ) + +#define IDeckLinkMutableVideoFrame_v14_2_1_GetHeight(This) \ + ( (This)->lpVtbl -> GetHeight(This) ) + +#define IDeckLinkMutableVideoFrame_v14_2_1_GetRowBytes(This) \ + ( (This)->lpVtbl -> GetRowBytes(This) ) + +#define IDeckLinkMutableVideoFrame_v14_2_1_GetPixelFormat(This) \ + ( (This)->lpVtbl -> GetPixelFormat(This) ) + +#define IDeckLinkMutableVideoFrame_v14_2_1_GetFlags(This) \ + ( (This)->lpVtbl -> GetFlags(This) ) + +#define IDeckLinkMutableVideoFrame_v14_2_1_GetBytes(This,buffer) \ + ( (This)->lpVtbl -> GetBytes(This,buffer) ) + +#define IDeckLinkMutableVideoFrame_v14_2_1_GetTimecode(This,format,timecode) \ + ( (This)->lpVtbl -> GetTimecode(This,format,timecode) ) + +#define IDeckLinkMutableVideoFrame_v14_2_1_GetAncillaryData(This,ancillary) \ + ( (This)->lpVtbl -> GetAncillaryData(This,ancillary) ) + + +#define IDeckLinkMutableVideoFrame_v14_2_1_SetFlags(This,newFlags) \ + ( (This)->lpVtbl -> SetFlags(This,newFlags) ) + +#define IDeckLinkMutableVideoFrame_v14_2_1_SetTimecode(This,format,timecode) \ + ( (This)->lpVtbl -> SetTimecode(This,format,timecode) ) + +#define IDeckLinkMutableVideoFrame_v14_2_1_SetTimecodeFromComponents(This,format,hours,minutes,seconds,frames,flags) \ + ( (This)->lpVtbl -> SetTimecodeFromComponents(This,format,hours,minutes,seconds,frames,flags) ) + +#define IDeckLinkMutableVideoFrame_v14_2_1_SetAncillaryData(This,ancillary) \ + ( (This)->lpVtbl -> SetAncillaryData(This,ancillary) ) + +#define IDeckLinkMutableVideoFrame_v14_2_1_SetTimecodeUserBits(This,format,userBits) \ + ( (This)->lpVtbl -> SetTimecodeUserBits(This,format,userBits) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkMutableVideoFrame_v14_2_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkVideoFrame3DExtensions_v14_2_1_INTERFACE_DEFINED__ +#define __IDeckLinkVideoFrame3DExtensions_v14_2_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkVideoFrame3DExtensions_v14_2_1 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkVideoFrame3DExtensions_v14_2_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("DA0F7E4A-EDC7-48A8-9CDD-2DB51C729CD7") + IDeckLinkVideoFrame3DExtensions_v14_2_1 : public IUnknown + { + public: + virtual BMDVideo3DPackingFormat STDMETHODCALLTYPE Get3DPackingFormat( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFrameForRightEye( + /* [out] */ IDeckLinkVideoFrame_v14_2_1 **rightEyeFrame) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkVideoFrame3DExtensions_v14_2_1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoFrame3DExtensions_v14_2_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoFrame3DExtensions_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoFrame3DExtensions_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame3DExtensions_v14_2_1, Get3DPackingFormat) + BMDVideo3DPackingFormat ( STDMETHODCALLTYPE *Get3DPackingFormat )( + IDeckLinkVideoFrame3DExtensions_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame3DExtensions_v14_2_1, GetFrameForRightEye) + HRESULT ( STDMETHODCALLTYPE *GetFrameForRightEye )( + IDeckLinkVideoFrame3DExtensions_v14_2_1 * This, + /* [out] */ IDeckLinkVideoFrame_v14_2_1 **rightEyeFrame); + + END_INTERFACE + } IDeckLinkVideoFrame3DExtensions_v14_2_1Vtbl; + + interface IDeckLinkVideoFrame3DExtensions_v14_2_1 + { + CONST_VTBL struct IDeckLinkVideoFrame3DExtensions_v14_2_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkVideoFrame3DExtensions_v14_2_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkVideoFrame3DExtensions_v14_2_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkVideoFrame3DExtensions_v14_2_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkVideoFrame3DExtensions_v14_2_1_Get3DPackingFormat(This) \ + ( (This)->lpVtbl -> Get3DPackingFormat(This) ) + +#define IDeckLinkVideoFrame3DExtensions_v14_2_1_GetFrameForRightEye(This,rightEyeFrame) \ + ( (This)->lpVtbl -> GetFrameForRightEye(This,rightEyeFrame) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkVideoFrame3DExtensions_v14_2_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkVideoInputFrame_v14_2_1_INTERFACE_DEFINED__ +#define __IDeckLinkVideoInputFrame_v14_2_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkVideoInputFrame_v14_2_1 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkVideoInputFrame_v14_2_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("05CFE374-537C-4094-9A57-680525118F44") + IDeckLinkVideoInputFrame_v14_2_1 : public IDeckLinkVideoFrame_v14_2_1 + { + 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 IDeckLinkVideoInputFrame_v14_2_1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoInputFrame_v14_2_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoInputFrame_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoInputFrame_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame_v14_2_1, GetWidth) + long ( STDMETHODCALLTYPE *GetWidth )( + IDeckLinkVideoInputFrame_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame_v14_2_1, GetHeight) + long ( STDMETHODCALLTYPE *GetHeight )( + IDeckLinkVideoInputFrame_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame_v14_2_1, GetRowBytes) + long ( STDMETHODCALLTYPE *GetRowBytes )( + IDeckLinkVideoInputFrame_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame_v14_2_1, GetPixelFormat) + BMDPixelFormat ( STDMETHODCALLTYPE *GetPixelFormat )( + IDeckLinkVideoInputFrame_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame_v14_2_1, GetFlags) + BMDFrameFlags ( STDMETHODCALLTYPE *GetFlags )( + IDeckLinkVideoInputFrame_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame_v14_2_1, GetBytes) + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IDeckLinkVideoInputFrame_v14_2_1 * This, + /* [out] */ void **buffer); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame_v14_2_1, GetTimecode) + HRESULT ( STDMETHODCALLTYPE *GetTimecode )( + IDeckLinkVideoInputFrame_v14_2_1 * This, + /* [in] */ BMDTimecodeFormat format, + /* [out] */ IDeckLinkTimecode **timecode); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrame_v14_2_1, GetAncillaryData) + HRESULT ( STDMETHODCALLTYPE *GetAncillaryData )( + IDeckLinkVideoInputFrame_v14_2_1 * This, + /* [out] */ IDeckLinkVideoFrameAncillary **ancillary); + + DECLSPEC_XFGVIRT(IDeckLinkVideoInputFrame_v14_2_1, GetStreamTime) + HRESULT ( STDMETHODCALLTYPE *GetStreamTime )( + IDeckLinkVideoInputFrame_v14_2_1 * This, + /* [out] */ BMDTimeValue *frameTime, + /* [out] */ BMDTimeValue *frameDuration, + /* [in] */ BMDTimeScale timeScale); + + DECLSPEC_XFGVIRT(IDeckLinkVideoInputFrame_v14_2_1, GetHardwareReferenceTimestamp) + HRESULT ( STDMETHODCALLTYPE *GetHardwareReferenceTimestamp )( + IDeckLinkVideoInputFrame_v14_2_1 * This, + /* [in] */ BMDTimeScale timeScale, + /* [out] */ BMDTimeValue *frameTime, + /* [out] */ BMDTimeValue *frameDuration); + + END_INTERFACE + } IDeckLinkVideoInputFrame_v14_2_1Vtbl; + + interface IDeckLinkVideoInputFrame_v14_2_1 + { + CONST_VTBL struct IDeckLinkVideoInputFrame_v14_2_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkVideoInputFrame_v14_2_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkVideoInputFrame_v14_2_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkVideoInputFrame_v14_2_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkVideoInputFrame_v14_2_1_GetWidth(This) \ + ( (This)->lpVtbl -> GetWidth(This) ) + +#define IDeckLinkVideoInputFrame_v14_2_1_GetHeight(This) \ + ( (This)->lpVtbl -> GetHeight(This) ) + +#define IDeckLinkVideoInputFrame_v14_2_1_GetRowBytes(This) \ + ( (This)->lpVtbl -> GetRowBytes(This) ) + +#define IDeckLinkVideoInputFrame_v14_2_1_GetPixelFormat(This) \ + ( (This)->lpVtbl -> GetPixelFormat(This) ) + +#define IDeckLinkVideoInputFrame_v14_2_1_GetFlags(This) \ + ( (This)->lpVtbl -> GetFlags(This) ) + +#define IDeckLinkVideoInputFrame_v14_2_1_GetBytes(This,buffer) \ + ( (This)->lpVtbl -> GetBytes(This,buffer) ) + +#define IDeckLinkVideoInputFrame_v14_2_1_GetTimecode(This,format,timecode) \ + ( (This)->lpVtbl -> GetTimecode(This,format,timecode) ) + +#define IDeckLinkVideoInputFrame_v14_2_1_GetAncillaryData(This,ancillary) \ + ( (This)->lpVtbl -> GetAncillaryData(This,ancillary) ) + + +#define IDeckLinkVideoInputFrame_v14_2_1_GetStreamTime(This,frameTime,frameDuration,timeScale) \ + ( (This)->lpVtbl -> GetStreamTime(This,frameTime,frameDuration,timeScale) ) + +#define IDeckLinkVideoInputFrame_v14_2_1_GetHardwareReferenceTimestamp(This,timeScale,frameTime,frameDuration) \ + ( (This)->lpVtbl -> GetHardwareReferenceTimestamp(This,timeScale,frameTime,frameDuration) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkVideoInputFrame_v14_2_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkScreenPreviewCallback_v14_2_1_INTERFACE_DEFINED__ +#define __IDeckLinkScreenPreviewCallback_v14_2_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkScreenPreviewCallback_v14_2_1 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkScreenPreviewCallback_v14_2_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("B1D3F49A-85FE-4C5D-95C8-0B5D5DCCD438") + IDeckLinkScreenPreviewCallback_v14_2_1 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE DrawFrame( + /* [in] */ IDeckLinkVideoFrame_v14_2_1 *theFrame) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkScreenPreviewCallback_v14_2_1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkScreenPreviewCallback_v14_2_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkScreenPreviewCallback_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkScreenPreviewCallback_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkScreenPreviewCallback_v14_2_1, DrawFrame) + HRESULT ( STDMETHODCALLTYPE *DrawFrame )( + IDeckLinkScreenPreviewCallback_v14_2_1 * This, + /* [in] */ IDeckLinkVideoFrame_v14_2_1 *theFrame); + + END_INTERFACE + } IDeckLinkScreenPreviewCallback_v14_2_1Vtbl; + + interface IDeckLinkScreenPreviewCallback_v14_2_1 + { + CONST_VTBL struct IDeckLinkScreenPreviewCallback_v14_2_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkScreenPreviewCallback_v14_2_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkScreenPreviewCallback_v14_2_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkScreenPreviewCallback_v14_2_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkScreenPreviewCallback_v14_2_1_DrawFrame(This,theFrame) \ + ( (This)->lpVtbl -> DrawFrame(This,theFrame) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkScreenPreviewCallback_v14_2_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkGLScreenPreviewHelper_v14_2_1_INTERFACE_DEFINED__ +#define __IDeckLinkGLScreenPreviewHelper_v14_2_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkGLScreenPreviewHelper_v14_2_1 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkGLScreenPreviewHelper_v14_2_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("504E2209-CAC7-4C1A-9FB4-C5BB6274D22F") + IDeckLinkGLScreenPreviewHelper_v14_2_1 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE InitializeGL( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE PaintGL( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetFrame( + /* [in] */ IDeckLinkVideoFrame_v14_2_1 *theFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE Set3DPreviewFormat( + /* [in] */ BMD3DPreviewFormat previewFormat) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkGLScreenPreviewHelper_v14_2_1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkGLScreenPreviewHelper_v14_2_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkGLScreenPreviewHelper_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkGLScreenPreviewHelper_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkGLScreenPreviewHelper_v14_2_1, InitializeGL) + HRESULT ( STDMETHODCALLTYPE *InitializeGL )( + IDeckLinkGLScreenPreviewHelper_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkGLScreenPreviewHelper_v14_2_1, PaintGL) + HRESULT ( STDMETHODCALLTYPE *PaintGL )( + IDeckLinkGLScreenPreviewHelper_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkGLScreenPreviewHelper_v14_2_1, SetFrame) + HRESULT ( STDMETHODCALLTYPE *SetFrame )( + IDeckLinkGLScreenPreviewHelper_v14_2_1 * This, + /* [in] */ IDeckLinkVideoFrame_v14_2_1 *theFrame); + + DECLSPEC_XFGVIRT(IDeckLinkGLScreenPreviewHelper_v14_2_1, Set3DPreviewFormat) + HRESULT ( STDMETHODCALLTYPE *Set3DPreviewFormat )( + IDeckLinkGLScreenPreviewHelper_v14_2_1 * This, + /* [in] */ BMD3DPreviewFormat previewFormat); + + END_INTERFACE + } IDeckLinkGLScreenPreviewHelper_v14_2_1Vtbl; + + interface IDeckLinkGLScreenPreviewHelper_v14_2_1 + { + CONST_VTBL struct IDeckLinkGLScreenPreviewHelper_v14_2_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkGLScreenPreviewHelper_v14_2_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkGLScreenPreviewHelper_v14_2_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkGLScreenPreviewHelper_v14_2_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkGLScreenPreviewHelper_v14_2_1_InitializeGL(This) \ + ( (This)->lpVtbl -> InitializeGL(This) ) + +#define IDeckLinkGLScreenPreviewHelper_v14_2_1_PaintGL(This) \ + ( (This)->lpVtbl -> PaintGL(This) ) + +#define IDeckLinkGLScreenPreviewHelper_v14_2_1_SetFrame(This,theFrame) \ + ( (This)->lpVtbl -> SetFrame(This,theFrame) ) + +#define IDeckLinkGLScreenPreviewHelper_v14_2_1_Set3DPreviewFormat(This,previewFormat) \ + ( (This)->lpVtbl -> Set3DPreviewFormat(This,previewFormat) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkGLScreenPreviewHelper_v14_2_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkDX9ScreenPreviewHelper_v14_2_1_INTERFACE_DEFINED__ +#define __IDeckLinkDX9ScreenPreviewHelper_v14_2_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkDX9ScreenPreviewHelper_v14_2_1 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkDX9ScreenPreviewHelper_v14_2_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("2094B522-D1A1-40C0-9AC7-1C012218EF02") + IDeckLinkDX9ScreenPreviewHelper_v14_2_1 : 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_v14_2_1 *theFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE Set3DPreviewFormat( + /* [in] */ BMD3DPreviewFormat previewFormat) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkDX9ScreenPreviewHelper_v14_2_1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkDX9ScreenPreviewHelper_v14_2_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkDX9ScreenPreviewHelper_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkDX9ScreenPreviewHelper_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkDX9ScreenPreviewHelper_v14_2_1, Initialize) + HRESULT ( STDMETHODCALLTYPE *Initialize )( + IDeckLinkDX9ScreenPreviewHelper_v14_2_1 * This, + /* [in] */ void *device); + + DECLSPEC_XFGVIRT(IDeckLinkDX9ScreenPreviewHelper_v14_2_1, Render) + HRESULT ( STDMETHODCALLTYPE *Render )( + IDeckLinkDX9ScreenPreviewHelper_v14_2_1 * This, + /* [in] */ RECT *rc); + + DECLSPEC_XFGVIRT(IDeckLinkDX9ScreenPreviewHelper_v14_2_1, SetFrame) + HRESULT ( STDMETHODCALLTYPE *SetFrame )( + IDeckLinkDX9ScreenPreviewHelper_v14_2_1 * This, + /* [in] */ IDeckLinkVideoFrame_v14_2_1 *theFrame); + + DECLSPEC_XFGVIRT(IDeckLinkDX9ScreenPreviewHelper_v14_2_1, Set3DPreviewFormat) + HRESULT ( STDMETHODCALLTYPE *Set3DPreviewFormat )( + IDeckLinkDX9ScreenPreviewHelper_v14_2_1 * This, + /* [in] */ BMD3DPreviewFormat previewFormat); + + END_INTERFACE + } IDeckLinkDX9ScreenPreviewHelper_v14_2_1Vtbl; + + interface IDeckLinkDX9ScreenPreviewHelper_v14_2_1 + { + CONST_VTBL struct IDeckLinkDX9ScreenPreviewHelper_v14_2_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkDX9ScreenPreviewHelper_v14_2_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkDX9ScreenPreviewHelper_v14_2_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkDX9ScreenPreviewHelper_v14_2_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkDX9ScreenPreviewHelper_v14_2_1_Initialize(This,device) \ + ( (This)->lpVtbl -> Initialize(This,device) ) + +#define IDeckLinkDX9ScreenPreviewHelper_v14_2_1_Render(This,rc) \ + ( (This)->lpVtbl -> Render(This,rc) ) + +#define IDeckLinkDX9ScreenPreviewHelper_v14_2_1_SetFrame(This,theFrame) \ + ( (This)->lpVtbl -> SetFrame(This,theFrame) ) + +#define IDeckLinkDX9ScreenPreviewHelper_v14_2_1_Set3DPreviewFormat(This,previewFormat) \ + ( (This)->lpVtbl -> Set3DPreviewFormat(This,previewFormat) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkDX9ScreenPreviewHelper_v14_2_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1_INTERFACE_DEFINED__ +#define __IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("AD8EC84A-7DDE-11E9-8F9E-2A86E4085A59") + IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Initialize( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Render( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetSurfaceSize( + /* [in] */ unsigned int width, + /* [in] */ unsigned int height) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetFrame( + /* [in] */ IDeckLinkVideoFrame_v14_2_1 *theFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE Set3DPreviewFormat( + /* [in] */ BMD3DPreviewFormat previewFormat) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBackBuffer( + /* [out] */ void **backBuffer) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1, Initialize) + HRESULT ( STDMETHODCALLTYPE *Initialize )( + IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1, Render) + HRESULT ( STDMETHODCALLTYPE *Render )( + IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1, SetSurfaceSize) + HRESULT ( STDMETHODCALLTYPE *SetSurfaceSize )( + IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1 * This, + /* [in] */ unsigned int width, + /* [in] */ unsigned int height); + + DECLSPEC_XFGVIRT(IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1, SetFrame) + HRESULT ( STDMETHODCALLTYPE *SetFrame )( + IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1 * This, + /* [in] */ IDeckLinkVideoFrame_v14_2_1 *theFrame); + + DECLSPEC_XFGVIRT(IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1, Set3DPreviewFormat) + HRESULT ( STDMETHODCALLTYPE *Set3DPreviewFormat )( + IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1 * This, + /* [in] */ BMD3DPreviewFormat previewFormat); + + DECLSPEC_XFGVIRT(IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1, GetBackBuffer) + HRESULT ( STDMETHODCALLTYPE *GetBackBuffer )( + IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1 * This, + /* [out] */ void **backBuffer); + + END_INTERFACE + } IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1Vtbl; + + interface IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1 + { + CONST_VTBL struct IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1_Initialize(This) \ + ( (This)->lpVtbl -> Initialize(This) ) + +#define IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1_Render(This) \ + ( (This)->lpVtbl -> Render(This) ) + +#define IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1_SetSurfaceSize(This,width,height) \ + ( (This)->lpVtbl -> SetSurfaceSize(This,width,height) ) + +#define IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1_SetFrame(This,theFrame) \ + ( (This)->lpVtbl -> SetFrame(This,theFrame) ) + +#define IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1_Set3DPreviewFormat(This,previewFormat) \ + ( (This)->lpVtbl -> Set3DPreviewFormat(This,previewFormat) ) + +#define IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1_GetBackBuffer(This,backBuffer) \ + ( (This)->lpVtbl -> GetBackBuffer(This,backBuffer) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkVideoConversion_v14_2_1_INTERFACE_DEFINED__ +#define __IDeckLinkVideoConversion_v14_2_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkVideoConversion_v14_2_1 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkVideoConversion_v14_2_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("3BBCB8A2-DA2C-42D9-B5D8-88083644E99A") + IDeckLinkVideoConversion_v14_2_1 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE ConvertFrame( + /* [in] */ IDeckLinkVideoFrame_v14_2_1 *srcFrame, + /* [in] */ IDeckLinkVideoFrame_v14_2_1 *dstFrame) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkVideoConversion_v14_2_1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoConversion_v14_2_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoConversion_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoConversion_v14_2_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoConversion_v14_2_1, ConvertFrame) + HRESULT ( STDMETHODCALLTYPE *ConvertFrame )( + IDeckLinkVideoConversion_v14_2_1 * This, + /* [in] */ IDeckLinkVideoFrame_v14_2_1 *srcFrame, + /* [in] */ IDeckLinkVideoFrame_v14_2_1 *dstFrame); + + END_INTERFACE + } IDeckLinkVideoConversion_v14_2_1Vtbl; + + interface IDeckLinkVideoConversion_v14_2_1 + { + CONST_VTBL struct IDeckLinkVideoConversion_v14_2_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkVideoConversion_v14_2_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkVideoConversion_v14_2_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkVideoConversion_v14_2_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkVideoConversion_v14_2_1_ConvertFrame(This,srcFrame,dstFrame) \ + ( (This)->lpVtbl -> ConvertFrame(This,srcFrame,dstFrame) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkVideoConversion_v14_2_1_INTERFACE_DEFINED__ */ + + +EXTERN_C const CLSID CLSID_CDeckLinkGLScreenPreviewHelper_v14_2_1; + +#ifdef __cplusplus + +class DECLSPEC_UUID("F63E77C7-B655-4A4A-9AD0-3CA85D394343") +CDeckLinkGLScreenPreviewHelper_v14_2_1; +#endif + +EXTERN_C const CLSID CLSID_CDeckLinkGL3ScreenPreviewHelper_v14_2_1; + +#ifdef __cplusplus + +class DECLSPEC_UUID("00696A71-EBC7-491F-AC02-18D3393F33F0") +CDeckLinkGL3ScreenPreviewHelper_v14_2_1; +#endif + +EXTERN_C const CLSID CLSID_CDeckLinkDX9ScreenPreviewHelper_v14_2_1; + +#ifdef __cplusplus + +class DECLSPEC_UUID("CC010023-E01D-4525-9D59-80C8AB3DC7A0") +CDeckLinkDX9ScreenPreviewHelper_v14_2_1; +#endif + +EXTERN_C const CLSID CLSID_CDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1; + +#ifdef __cplusplus + +class DECLSPEC_UUID("EF2A8478-7DDF-11E9-8F9E-2A86E4085A59") +CDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1; +#endif + +EXTERN_C const CLSID CLSID_CDeckLinkVideoConversion_v14_2_1; + +#ifdef __cplusplus + +class DECLSPEC_UUID("7DBBBB11-5B7B-467D-AEA4-CEA468FD368C") +CDeckLinkVideoConversion_v14_2_1; +#endif + +#ifndef __IDeckLinkInputCallback_v11_5_1_INTERFACE_DEFINED__ +#define __IDeckLinkInputCallback_v11_5_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkInputCallback_v11_5_1 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkInputCallback_v11_5_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("DD04E5EC-7415-42AB-AE4A-E80C4DFC044A") + IDeckLinkInputCallback_v11_5_1 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE VideoInputFormatChanged( + /* [in] */ BMDVideoInputFormatChangedEvents notificationEvents, + /* [in] */ IDeckLinkDisplayMode *newDisplayMode, + /* [in] */ BMDDetectedVideoInputFormatFlags detectedSignalFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE VideoInputFrameArrived( + /* [in] */ IDeckLinkVideoInputFrame_v14_2_1 *videoFrame, + /* [in] */ IDeckLinkAudioInputPacket *audioPacket) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkInputCallback_v11_5_1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkInputCallback_v11_5_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkInputCallback_v11_5_1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkInputCallback_v11_5_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInputCallback_v11_5_1, VideoInputFormatChanged) + HRESULT ( STDMETHODCALLTYPE *VideoInputFormatChanged )( + IDeckLinkInputCallback_v11_5_1 * This, + /* [in] */ BMDVideoInputFormatChangedEvents notificationEvents, + /* [in] */ IDeckLinkDisplayMode *newDisplayMode, + /* [in] */ BMDDetectedVideoInputFormatFlags detectedSignalFlags); + + DECLSPEC_XFGVIRT(IDeckLinkInputCallback_v11_5_1, VideoInputFrameArrived) + HRESULT ( STDMETHODCALLTYPE *VideoInputFrameArrived )( + IDeckLinkInputCallback_v11_5_1 * This, + /* [in] */ IDeckLinkVideoInputFrame_v14_2_1 *videoFrame, + /* [in] */ IDeckLinkAudioInputPacket *audioPacket); + + END_INTERFACE + } IDeckLinkInputCallback_v11_5_1Vtbl; + + interface IDeckLinkInputCallback_v11_5_1 + { + CONST_VTBL struct IDeckLinkInputCallback_v11_5_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkInputCallback_v11_5_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkInputCallback_v11_5_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkInputCallback_v11_5_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkInputCallback_v11_5_1_VideoInputFormatChanged(This,notificationEvents,newDisplayMode,detectedSignalFlags) \ + ( (This)->lpVtbl -> VideoInputFormatChanged(This,notificationEvents,newDisplayMode,detectedSignalFlags) ) + +#define IDeckLinkInputCallback_v11_5_1_VideoInputFrameArrived(This,videoFrame,audioPacket) \ + ( (This)->lpVtbl -> VideoInputFrameArrived(This,videoFrame,audioPacket) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkInputCallback_v11_5_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkInput_v11_5_1_INTERFACE_DEFINED__ +#define __IDeckLinkInput_v11_5_1_INTERFACE_DEFINED__ + +/* interface IDeckLinkInput_v11_5_1 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkInput_v11_5_1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("9434C6E4-B15D-4B1C-979E-661E3DDCB4B9") + IDeckLinkInput_v11_5_1 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE DoesSupportVideoMode( + /* [in] */ BMDVideoConnection connection, + /* [in] */ BMDDisplayMode requestedMode, + /* [in] */ BMDPixelFormat requestedPixelFormat, + /* [in] */ BMDVideoInputConversionMode conversionMode, + /* [in] */ BMDSupportedVideoModeFlags flags, + /* [out] */ BMDDisplayMode *actualMode, + /* [out] */ BOOL *supported) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayMode( + /* [in] */ BMDDisplayMode displayMode, + /* [out] */ IDeckLinkDisplayMode **resultDisplayMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayModeIterator( + /* [out] */ IDeckLinkDisplayModeIterator **iterator) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetScreenPreviewCallback( + /* [in] */ IDeckLinkScreenPreviewCallback_v14_2_1 *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_v14_2_1 *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_v11_5_1 *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_v11_5_1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkInput_v11_5_1 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkInput_v11_5_1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkInput_v11_5_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_5_1, DoesSupportVideoMode) + HRESULT ( STDMETHODCALLTYPE *DoesSupportVideoMode )( + IDeckLinkInput_v11_5_1 * This, + /* [in] */ BMDVideoConnection connection, + /* [in] */ BMDDisplayMode requestedMode, + /* [in] */ BMDPixelFormat requestedPixelFormat, + /* [in] */ BMDVideoInputConversionMode conversionMode, + /* [in] */ BMDSupportedVideoModeFlags flags, + /* [out] */ BMDDisplayMode *actualMode, + /* [out] */ BOOL *supported); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_5_1, GetDisplayMode) + HRESULT ( STDMETHODCALLTYPE *GetDisplayMode )( + IDeckLinkInput_v11_5_1 * This, + /* [in] */ BMDDisplayMode displayMode, + /* [out] */ IDeckLinkDisplayMode **resultDisplayMode); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_5_1, GetDisplayModeIterator) + HRESULT ( STDMETHODCALLTYPE *GetDisplayModeIterator )( + IDeckLinkInput_v11_5_1 * This, + /* [out] */ IDeckLinkDisplayModeIterator **iterator); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_5_1, SetScreenPreviewCallback) + HRESULT ( STDMETHODCALLTYPE *SetScreenPreviewCallback )( + IDeckLinkInput_v11_5_1 * This, + /* [in] */ IDeckLinkScreenPreviewCallback_v14_2_1 *previewCallback); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_5_1, EnableVideoInput) + HRESULT ( STDMETHODCALLTYPE *EnableVideoInput )( + IDeckLinkInput_v11_5_1 * This, + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDVideoInputFlags flags); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_5_1, DisableVideoInput) + HRESULT ( STDMETHODCALLTYPE *DisableVideoInput )( + IDeckLinkInput_v11_5_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_5_1, GetAvailableVideoFrameCount) + HRESULT ( STDMETHODCALLTYPE *GetAvailableVideoFrameCount )( + IDeckLinkInput_v11_5_1 * This, + /* [out] */ unsigned int *availableFrameCount); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_5_1, SetVideoInputFrameMemoryAllocator) + HRESULT ( STDMETHODCALLTYPE *SetVideoInputFrameMemoryAllocator )( + IDeckLinkInput_v11_5_1 * This, + /* [in] */ IDeckLinkMemoryAllocator_v14_2_1 *theAllocator); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_5_1, EnableAudioInput) + HRESULT ( STDMETHODCALLTYPE *EnableAudioInput )( + IDeckLinkInput_v11_5_1 * This, + /* [in] */ BMDAudioSampleRate sampleRate, + /* [in] */ BMDAudioSampleType sampleType, + /* [in] */ unsigned int channelCount); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_5_1, DisableAudioInput) + HRESULT ( STDMETHODCALLTYPE *DisableAudioInput )( + IDeckLinkInput_v11_5_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_5_1, GetAvailableAudioSampleFrameCount) + HRESULT ( STDMETHODCALLTYPE *GetAvailableAudioSampleFrameCount )( + IDeckLinkInput_v11_5_1 * This, + /* [out] */ unsigned int *availableSampleFrameCount); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_5_1, StartStreams) + HRESULT ( STDMETHODCALLTYPE *StartStreams )( + IDeckLinkInput_v11_5_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_5_1, StopStreams) + HRESULT ( STDMETHODCALLTYPE *StopStreams )( + IDeckLinkInput_v11_5_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_5_1, PauseStreams) + HRESULT ( STDMETHODCALLTYPE *PauseStreams )( + IDeckLinkInput_v11_5_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_5_1, FlushStreams) + HRESULT ( STDMETHODCALLTYPE *FlushStreams )( + IDeckLinkInput_v11_5_1 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_5_1, SetCallback) + HRESULT ( STDMETHODCALLTYPE *SetCallback )( + IDeckLinkInput_v11_5_1 * This, + /* [in] */ IDeckLinkInputCallback_v11_5_1 *theCallback); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_5_1, GetHardwareReferenceClock) + HRESULT ( STDMETHODCALLTYPE *GetHardwareReferenceClock )( + IDeckLinkInput_v11_5_1 * This, + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *hardwareTime, + /* [out] */ BMDTimeValue *timeInFrame, + /* [out] */ BMDTimeValue *ticksPerFrame); + + END_INTERFACE + } IDeckLinkInput_v11_5_1Vtbl; + + interface IDeckLinkInput_v11_5_1 + { + CONST_VTBL struct IDeckLinkInput_v11_5_1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkInput_v11_5_1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkInput_v11_5_1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkInput_v11_5_1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkInput_v11_5_1_DoesSupportVideoMode(This,connection,requestedMode,requestedPixelFormat,conversionMode,flags,actualMode,supported) \ + ( (This)->lpVtbl -> DoesSupportVideoMode(This,connection,requestedMode,requestedPixelFormat,conversionMode,flags,actualMode,supported) ) + +#define IDeckLinkInput_v11_5_1_GetDisplayMode(This,displayMode,resultDisplayMode) \ + ( (This)->lpVtbl -> GetDisplayMode(This,displayMode,resultDisplayMode) ) + +#define IDeckLinkInput_v11_5_1_GetDisplayModeIterator(This,iterator) \ + ( (This)->lpVtbl -> GetDisplayModeIterator(This,iterator) ) + +#define IDeckLinkInput_v11_5_1_SetScreenPreviewCallback(This,previewCallback) \ + ( (This)->lpVtbl -> SetScreenPreviewCallback(This,previewCallback) ) + +#define IDeckLinkInput_v11_5_1_EnableVideoInput(This,displayMode,pixelFormat,flags) \ + ( (This)->lpVtbl -> EnableVideoInput(This,displayMode,pixelFormat,flags) ) + +#define IDeckLinkInput_v11_5_1_DisableVideoInput(This) \ + ( (This)->lpVtbl -> DisableVideoInput(This) ) + +#define IDeckLinkInput_v11_5_1_GetAvailableVideoFrameCount(This,availableFrameCount) \ + ( (This)->lpVtbl -> GetAvailableVideoFrameCount(This,availableFrameCount) ) + +#define IDeckLinkInput_v11_5_1_SetVideoInputFrameMemoryAllocator(This,theAllocator) \ + ( (This)->lpVtbl -> SetVideoInputFrameMemoryAllocator(This,theAllocator) ) + +#define IDeckLinkInput_v11_5_1_EnableAudioInput(This,sampleRate,sampleType,channelCount) \ + ( (This)->lpVtbl -> EnableAudioInput(This,sampleRate,sampleType,channelCount) ) + +#define IDeckLinkInput_v11_5_1_DisableAudioInput(This) \ + ( (This)->lpVtbl -> DisableAudioInput(This) ) + +#define IDeckLinkInput_v11_5_1_GetAvailableAudioSampleFrameCount(This,availableSampleFrameCount) \ + ( (This)->lpVtbl -> GetAvailableAudioSampleFrameCount(This,availableSampleFrameCount) ) + +#define IDeckLinkInput_v11_5_1_StartStreams(This) \ + ( (This)->lpVtbl -> StartStreams(This) ) + +#define IDeckLinkInput_v11_5_1_StopStreams(This) \ + ( (This)->lpVtbl -> StopStreams(This) ) + +#define IDeckLinkInput_v11_5_1_PauseStreams(This) \ + ( (This)->lpVtbl -> PauseStreams(This) ) + +#define IDeckLinkInput_v11_5_1_FlushStreams(This) \ + ( (This)->lpVtbl -> FlushStreams(This) ) + +#define IDeckLinkInput_v11_5_1_SetCallback(This,theCallback) \ + ( (This)->lpVtbl -> SetCallback(This,theCallback) ) + +#define IDeckLinkInput_v11_5_1_GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) \ + ( (This)->lpVtbl -> GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkInput_v11_5_1_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkConfiguration_v10_11_INTERFACE_DEFINED__ +#define __IDeckLinkConfiguration_v10_11_INTERFACE_DEFINED__ + +/* interface IDeckLinkConfiguration_v10_11 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkConfiguration_v10_11; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("EF90380B-4AE5-4346-9077-E288E149F129") + IDeckLinkConfiguration_v10_11 : 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_11Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkConfiguration_v10_11 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkConfiguration_v10_11 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkConfiguration_v10_11 * This); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_11, SetFlag) + HRESULT ( STDMETHODCALLTYPE *SetFlag )( + IDeckLinkConfiguration_v10_11 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ BOOL value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_11, GetFlag) + HRESULT ( STDMETHODCALLTYPE *GetFlag )( + IDeckLinkConfiguration_v10_11 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ BOOL *value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_11, SetInt) + HRESULT ( STDMETHODCALLTYPE *SetInt )( + IDeckLinkConfiguration_v10_11 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ LONGLONG value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_11, GetInt) + HRESULT ( STDMETHODCALLTYPE *GetInt )( + IDeckLinkConfiguration_v10_11 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ LONGLONG *value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_11, SetFloat) + HRESULT ( STDMETHODCALLTYPE *SetFloat )( + IDeckLinkConfiguration_v10_11 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ double value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_11, GetFloat) + HRESULT ( STDMETHODCALLTYPE *GetFloat )( + IDeckLinkConfiguration_v10_11 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ double *value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_11, SetString) + HRESULT ( STDMETHODCALLTYPE *SetString )( + IDeckLinkConfiguration_v10_11 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ BSTR value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_11, GetString) + HRESULT ( STDMETHODCALLTYPE *GetString )( + IDeckLinkConfiguration_v10_11 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ BSTR *value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_11, WriteConfigurationToPreferences) + HRESULT ( STDMETHODCALLTYPE *WriteConfigurationToPreferences )( + IDeckLinkConfiguration_v10_11 * This); + + END_INTERFACE + } IDeckLinkConfiguration_v10_11Vtbl; + + interface IDeckLinkConfiguration_v10_11 + { + CONST_VTBL struct IDeckLinkConfiguration_v10_11Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkConfiguration_v10_11_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkConfiguration_v10_11_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkConfiguration_v10_11_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkConfiguration_v10_11_SetFlag(This,cfgID,value) \ + ( (This)->lpVtbl -> SetFlag(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v10_11_GetFlag(This,cfgID,value) \ + ( (This)->lpVtbl -> GetFlag(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v10_11_SetInt(This,cfgID,value) \ + ( (This)->lpVtbl -> SetInt(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v10_11_GetInt(This,cfgID,value) \ + ( (This)->lpVtbl -> GetInt(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v10_11_SetFloat(This,cfgID,value) \ + ( (This)->lpVtbl -> SetFloat(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v10_11_GetFloat(This,cfgID,value) \ + ( (This)->lpVtbl -> GetFloat(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v10_11_SetString(This,cfgID,value) \ + ( (This)->lpVtbl -> SetString(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v10_11_GetString(This,cfgID,value) \ + ( (This)->lpVtbl -> GetString(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v10_11_WriteConfigurationToPreferences(This) \ + ( (This)->lpVtbl -> WriteConfigurationToPreferences(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkConfiguration_v10_11_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkAttributes_v10_11_INTERFACE_DEFINED__ +#define __IDeckLinkAttributes_v10_11_INTERFACE_DEFINED__ + +/* interface IDeckLinkAttributes_v10_11 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkAttributes_v10_11; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("ABC11843-D966-44CB-96E2-A1CB5D3135C4") + IDeckLinkAttributes_v10_11 : 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 IDeckLinkAttributes_v10_11Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkAttributes_v10_11 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkAttributes_v10_11 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkAttributes_v10_11 * This); + + DECLSPEC_XFGVIRT(IDeckLinkAttributes_v10_11, GetFlag) + HRESULT ( STDMETHODCALLTYPE *GetFlag )( + IDeckLinkAttributes_v10_11 * This, + /* [in] */ BMDDeckLinkAttributeID cfgID, + /* [out] */ BOOL *value); + + DECLSPEC_XFGVIRT(IDeckLinkAttributes_v10_11, GetInt) + HRESULT ( STDMETHODCALLTYPE *GetInt )( + IDeckLinkAttributes_v10_11 * This, + /* [in] */ BMDDeckLinkAttributeID cfgID, + /* [out] */ LONGLONG *value); + + DECLSPEC_XFGVIRT(IDeckLinkAttributes_v10_11, GetFloat) + HRESULT ( STDMETHODCALLTYPE *GetFloat )( + IDeckLinkAttributes_v10_11 * This, + /* [in] */ BMDDeckLinkAttributeID cfgID, + /* [out] */ double *value); + + DECLSPEC_XFGVIRT(IDeckLinkAttributes_v10_11, GetString) + HRESULT ( STDMETHODCALLTYPE *GetString )( + IDeckLinkAttributes_v10_11 * This, + /* [in] */ BMDDeckLinkAttributeID cfgID, + /* [out] */ BSTR *value); + + END_INTERFACE + } IDeckLinkAttributes_v10_11Vtbl; + + interface IDeckLinkAttributes_v10_11 + { + CONST_VTBL struct IDeckLinkAttributes_v10_11Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkAttributes_v10_11_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkAttributes_v10_11_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkAttributes_v10_11_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkAttributes_v10_11_GetFlag(This,cfgID,value) \ + ( (This)->lpVtbl -> GetFlag(This,cfgID,value) ) + +#define IDeckLinkAttributes_v10_11_GetInt(This,cfgID,value) \ + ( (This)->lpVtbl -> GetInt(This,cfgID,value) ) + +#define IDeckLinkAttributes_v10_11_GetFloat(This,cfgID,value) \ + ( (This)->lpVtbl -> GetFloat(This,cfgID,value) ) + +#define IDeckLinkAttributes_v10_11_GetString(This,cfgID,value) \ + ( (This)->lpVtbl -> GetString(This,cfgID,value) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkAttributes_v10_11_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkNotification_v10_11_INTERFACE_DEFINED__ +#define __IDeckLinkNotification_v10_11_INTERFACE_DEFINED__ + +/* interface IDeckLinkNotification_v10_11 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkNotification_v10_11; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("0A1FB207-E215-441B-9B19-6FA1575946C5") + IDeckLinkNotification_v10_11 : 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 IDeckLinkNotification_v10_11Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkNotification_v10_11 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkNotification_v10_11 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkNotification_v10_11 * This); + + DECLSPEC_XFGVIRT(IDeckLinkNotification_v10_11, Subscribe) + HRESULT ( STDMETHODCALLTYPE *Subscribe )( + IDeckLinkNotification_v10_11 * This, + /* [in] */ BMDNotifications topic, + /* [in] */ IDeckLinkNotificationCallback *theCallback); + + DECLSPEC_XFGVIRT(IDeckLinkNotification_v10_11, Unsubscribe) + HRESULT ( STDMETHODCALLTYPE *Unsubscribe )( + IDeckLinkNotification_v10_11 * This, + /* [in] */ BMDNotifications topic, + /* [in] */ IDeckLinkNotificationCallback *theCallback); + + END_INTERFACE + } IDeckLinkNotification_v10_11Vtbl; + + interface IDeckLinkNotification_v10_11 + { + CONST_VTBL struct IDeckLinkNotification_v10_11Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkNotification_v10_11_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkNotification_v10_11_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkNotification_v10_11_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkNotification_v10_11_Subscribe(This,topic,theCallback) \ + ( (This)->lpVtbl -> Subscribe(This,topic,theCallback) ) + +#define IDeckLinkNotification_v10_11_Unsubscribe(This,topic,theCallback) \ + ( (This)->lpVtbl -> Unsubscribe(This,topic,theCallback) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkNotification_v10_11_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkOutput_v10_11_INTERFACE_DEFINED__ +#define __IDeckLinkOutput_v10_11_INTERFACE_DEFINED__ + +/* interface IDeckLinkOutput_v10_11 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkOutput_v10_11; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("CC5C8A6E-3F2F-4B3A-87EA-FD78AF300564") + IDeckLinkOutput_v10_11 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE DoesSupportVideoMode( + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDVideoOutputFlags flags, + /* [out] */ BMDDisplayModeSupport_v10_11 *result, + /* [out] */ IDeckLinkDisplayMode **resultDisplayMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayModeIterator( + /* [out] */ IDeckLinkDisplayModeIterator **iterator) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetScreenPreviewCallback( + /* [in] */ IDeckLinkScreenPreviewCallback_v14_2_1 *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_v14_2_1 *theAllocator) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateVideoFrame( + /* [in] */ int width, + /* [in] */ int height, + /* [in] */ int rowBytes, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDFrameFlags flags, + /* [out] */ IDeckLinkMutableVideoFrame_v14_2_1 **outFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateAncillaryData( + /* [in] */ BMDPixelFormat pixelFormat, + /* [out] */ IDeckLinkVideoFrameAncillary **outBuffer) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisplayVideoFrameSync( + /* [in] */ IDeckLinkVideoFrame_v14_2_1 *theFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE ScheduleVideoFrame( + /* [in] */ IDeckLinkVideoFrame_v14_2_1 *theFrame, + /* [in] */ BMDTimeValue displayTime, + /* [in] */ BMDTimeValue displayDuration, + /* [in] */ BMDTimeScale timeScale) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetScheduledFrameCompletionCallback( + /* [in] */ IDeckLinkVideoOutputCallback_v14_2_1 *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_v14_2_1 *theFrame, + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *frameCompletionTimestamp) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkOutput_v10_11Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkOutput_v10_11 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkOutput_v10_11 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkOutput_v10_11 * This); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v10_11, DoesSupportVideoMode) + HRESULT ( STDMETHODCALLTYPE *DoesSupportVideoMode )( + IDeckLinkOutput_v10_11 * This, + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDVideoOutputFlags flags, + /* [out] */ BMDDisplayModeSupport_v10_11 *result, + /* [out] */ IDeckLinkDisplayMode **resultDisplayMode); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v10_11, GetDisplayModeIterator) + HRESULT ( STDMETHODCALLTYPE *GetDisplayModeIterator )( + IDeckLinkOutput_v10_11 * This, + /* [out] */ IDeckLinkDisplayModeIterator **iterator); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v10_11, SetScreenPreviewCallback) + HRESULT ( STDMETHODCALLTYPE *SetScreenPreviewCallback )( + IDeckLinkOutput_v10_11 * This, + /* [in] */ IDeckLinkScreenPreviewCallback_v14_2_1 *previewCallback); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v10_11, EnableVideoOutput) + HRESULT ( STDMETHODCALLTYPE *EnableVideoOutput )( + IDeckLinkOutput_v10_11 * This, + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDVideoOutputFlags flags); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v10_11, DisableVideoOutput) + HRESULT ( STDMETHODCALLTYPE *DisableVideoOutput )( + IDeckLinkOutput_v10_11 * This); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v10_11, SetVideoOutputFrameMemoryAllocator) + HRESULT ( STDMETHODCALLTYPE *SetVideoOutputFrameMemoryAllocator )( + IDeckLinkOutput_v10_11 * This, + /* [in] */ IDeckLinkMemoryAllocator_v14_2_1 *theAllocator); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v10_11, CreateVideoFrame) + HRESULT ( STDMETHODCALLTYPE *CreateVideoFrame )( + IDeckLinkOutput_v10_11 * This, + /* [in] */ int width, + /* [in] */ int height, + /* [in] */ int rowBytes, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDFrameFlags flags, + /* [out] */ IDeckLinkMutableVideoFrame_v14_2_1 **outFrame); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v10_11, CreateAncillaryData) + HRESULT ( STDMETHODCALLTYPE *CreateAncillaryData )( + IDeckLinkOutput_v10_11 * This, + /* [in] */ BMDPixelFormat pixelFormat, + /* [out] */ IDeckLinkVideoFrameAncillary **outBuffer); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v10_11, DisplayVideoFrameSync) + HRESULT ( STDMETHODCALLTYPE *DisplayVideoFrameSync )( + IDeckLinkOutput_v10_11 * This, + /* [in] */ IDeckLinkVideoFrame_v14_2_1 *theFrame); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v10_11, ScheduleVideoFrame) + HRESULT ( STDMETHODCALLTYPE *ScheduleVideoFrame )( + IDeckLinkOutput_v10_11 * This, + /* [in] */ IDeckLinkVideoFrame_v14_2_1 *theFrame, + /* [in] */ BMDTimeValue displayTime, + /* [in] */ BMDTimeValue displayDuration, + /* [in] */ BMDTimeScale timeScale); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v10_11, SetScheduledFrameCompletionCallback) + HRESULT ( STDMETHODCALLTYPE *SetScheduledFrameCompletionCallback )( + IDeckLinkOutput_v10_11 * This, + /* [in] */ IDeckLinkVideoOutputCallback_v14_2_1 *theCallback); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v10_11, GetBufferedVideoFrameCount) + HRESULT ( STDMETHODCALLTYPE *GetBufferedVideoFrameCount )( + IDeckLinkOutput_v10_11 * This, + /* [out] */ unsigned int *bufferedFrameCount); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v10_11, EnableAudioOutput) + HRESULT ( STDMETHODCALLTYPE *EnableAudioOutput )( + IDeckLinkOutput_v10_11 * This, + /* [in] */ BMDAudioSampleRate sampleRate, + /* [in] */ BMDAudioSampleType sampleType, + /* [in] */ unsigned int channelCount, + /* [in] */ BMDAudioOutputStreamType streamType); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v10_11, DisableAudioOutput) + HRESULT ( STDMETHODCALLTYPE *DisableAudioOutput )( + IDeckLinkOutput_v10_11 * This); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v10_11, WriteAudioSamplesSync) + HRESULT ( STDMETHODCALLTYPE *WriteAudioSamplesSync )( + IDeckLinkOutput_v10_11 * This, + /* [in] */ void *buffer, + /* [in] */ unsigned int sampleFrameCount, + /* [out] */ unsigned int *sampleFramesWritten); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v10_11, BeginAudioPreroll) + HRESULT ( STDMETHODCALLTYPE *BeginAudioPreroll )( + IDeckLinkOutput_v10_11 * This); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v10_11, EndAudioPreroll) + HRESULT ( STDMETHODCALLTYPE *EndAudioPreroll )( + IDeckLinkOutput_v10_11 * This); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v10_11, ScheduleAudioSamples) + HRESULT ( STDMETHODCALLTYPE *ScheduleAudioSamples )( + IDeckLinkOutput_v10_11 * This, + /* [in] */ void *buffer, + /* [in] */ unsigned int sampleFrameCount, + /* [in] */ BMDTimeValue streamTime, + /* [in] */ BMDTimeScale timeScale, + /* [out] */ unsigned int *sampleFramesWritten); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v10_11, GetBufferedAudioSampleFrameCount) + HRESULT ( STDMETHODCALLTYPE *GetBufferedAudioSampleFrameCount )( + IDeckLinkOutput_v10_11 * This, + /* [out] */ unsigned int *bufferedSampleFrameCount); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v10_11, FlushBufferedAudioSamples) + HRESULT ( STDMETHODCALLTYPE *FlushBufferedAudioSamples )( + IDeckLinkOutput_v10_11 * This); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v10_11, SetAudioCallback) + HRESULT ( STDMETHODCALLTYPE *SetAudioCallback )( + IDeckLinkOutput_v10_11 * This, + /* [in] */ IDeckLinkAudioOutputCallback *theCallback); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v10_11, StartScheduledPlayback) + HRESULT ( STDMETHODCALLTYPE *StartScheduledPlayback )( + IDeckLinkOutput_v10_11 * This, + /* [in] */ BMDTimeValue playbackStartTime, + /* [in] */ BMDTimeScale timeScale, + /* [in] */ double playbackSpeed); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v10_11, StopScheduledPlayback) + HRESULT ( STDMETHODCALLTYPE *StopScheduledPlayback )( + IDeckLinkOutput_v10_11 * This, + /* [in] */ BMDTimeValue stopPlaybackAtTime, + /* [out] */ BMDTimeValue *actualStopTime, + /* [in] */ BMDTimeScale timeScale); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v10_11, IsScheduledPlaybackRunning) + HRESULT ( STDMETHODCALLTYPE *IsScheduledPlaybackRunning )( + IDeckLinkOutput_v10_11 * This, + /* [out] */ BOOL *active); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v10_11, GetScheduledStreamTime) + HRESULT ( STDMETHODCALLTYPE *GetScheduledStreamTime )( + IDeckLinkOutput_v10_11 * This, + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *streamTime, + /* [out] */ double *playbackSpeed); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v10_11, GetReferenceStatus) + HRESULT ( STDMETHODCALLTYPE *GetReferenceStatus )( + IDeckLinkOutput_v10_11 * This, + /* [out] */ BMDReferenceStatus *referenceStatus); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v10_11, GetHardwareReferenceClock) + HRESULT ( STDMETHODCALLTYPE *GetHardwareReferenceClock )( + IDeckLinkOutput_v10_11 * This, + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *hardwareTime, + /* [out] */ BMDTimeValue *timeInFrame, + /* [out] */ BMDTimeValue *ticksPerFrame); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v10_11, GetFrameCompletionReferenceTimestamp) + HRESULT ( STDMETHODCALLTYPE *GetFrameCompletionReferenceTimestamp )( + IDeckLinkOutput_v10_11 * This, + /* [in] */ IDeckLinkVideoFrame_v14_2_1 *theFrame, + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *frameCompletionTimestamp); + + END_INTERFACE + } IDeckLinkOutput_v10_11Vtbl; + + interface IDeckLinkOutput_v10_11 + { + CONST_VTBL struct IDeckLinkOutput_v10_11Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkOutput_v10_11_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkOutput_v10_11_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkOutput_v10_11_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkOutput_v10_11_DoesSupportVideoMode(This,displayMode,pixelFormat,flags,result,resultDisplayMode) \ + ( (This)->lpVtbl -> DoesSupportVideoMode(This,displayMode,pixelFormat,flags,result,resultDisplayMode) ) + +#define IDeckLinkOutput_v10_11_GetDisplayModeIterator(This,iterator) \ + ( (This)->lpVtbl -> GetDisplayModeIterator(This,iterator) ) + +#define IDeckLinkOutput_v10_11_SetScreenPreviewCallback(This,previewCallback) \ + ( (This)->lpVtbl -> SetScreenPreviewCallback(This,previewCallback) ) + +#define IDeckLinkOutput_v10_11_EnableVideoOutput(This,displayMode,flags) \ + ( (This)->lpVtbl -> EnableVideoOutput(This,displayMode,flags) ) + +#define IDeckLinkOutput_v10_11_DisableVideoOutput(This) \ + ( (This)->lpVtbl -> DisableVideoOutput(This) ) + +#define IDeckLinkOutput_v10_11_SetVideoOutputFrameMemoryAllocator(This,theAllocator) \ + ( (This)->lpVtbl -> SetVideoOutputFrameMemoryAllocator(This,theAllocator) ) + +#define IDeckLinkOutput_v10_11_CreateVideoFrame(This,width,height,rowBytes,pixelFormat,flags,outFrame) \ + ( (This)->lpVtbl -> CreateVideoFrame(This,width,height,rowBytes,pixelFormat,flags,outFrame) ) + +#define IDeckLinkOutput_v10_11_CreateAncillaryData(This,pixelFormat,outBuffer) \ + ( (This)->lpVtbl -> CreateAncillaryData(This,pixelFormat,outBuffer) ) + +#define IDeckLinkOutput_v10_11_DisplayVideoFrameSync(This,theFrame) \ + ( (This)->lpVtbl -> DisplayVideoFrameSync(This,theFrame) ) + +#define IDeckLinkOutput_v10_11_ScheduleVideoFrame(This,theFrame,displayTime,displayDuration,timeScale) \ + ( (This)->lpVtbl -> ScheduleVideoFrame(This,theFrame,displayTime,displayDuration,timeScale) ) + +#define IDeckLinkOutput_v10_11_SetScheduledFrameCompletionCallback(This,theCallback) \ + ( (This)->lpVtbl -> SetScheduledFrameCompletionCallback(This,theCallback) ) + +#define IDeckLinkOutput_v10_11_GetBufferedVideoFrameCount(This,bufferedFrameCount) \ + ( (This)->lpVtbl -> GetBufferedVideoFrameCount(This,bufferedFrameCount) ) + +#define IDeckLinkOutput_v10_11_EnableAudioOutput(This,sampleRate,sampleType,channelCount,streamType) \ + ( (This)->lpVtbl -> EnableAudioOutput(This,sampleRate,sampleType,channelCount,streamType) ) + +#define IDeckLinkOutput_v10_11_DisableAudioOutput(This) \ + ( (This)->lpVtbl -> DisableAudioOutput(This) ) + +#define IDeckLinkOutput_v10_11_WriteAudioSamplesSync(This,buffer,sampleFrameCount,sampleFramesWritten) \ + ( (This)->lpVtbl -> WriteAudioSamplesSync(This,buffer,sampleFrameCount,sampleFramesWritten) ) + +#define IDeckLinkOutput_v10_11_BeginAudioPreroll(This) \ + ( (This)->lpVtbl -> BeginAudioPreroll(This) ) + +#define IDeckLinkOutput_v10_11_EndAudioPreroll(This) \ + ( (This)->lpVtbl -> EndAudioPreroll(This) ) + +#define IDeckLinkOutput_v10_11_ScheduleAudioSamples(This,buffer,sampleFrameCount,streamTime,timeScale,sampleFramesWritten) \ + ( (This)->lpVtbl -> ScheduleAudioSamples(This,buffer,sampleFrameCount,streamTime,timeScale,sampleFramesWritten) ) + +#define IDeckLinkOutput_v10_11_GetBufferedAudioSampleFrameCount(This,bufferedSampleFrameCount) \ + ( (This)->lpVtbl -> GetBufferedAudioSampleFrameCount(This,bufferedSampleFrameCount) ) + +#define IDeckLinkOutput_v10_11_FlushBufferedAudioSamples(This) \ + ( (This)->lpVtbl -> FlushBufferedAudioSamples(This) ) + +#define IDeckLinkOutput_v10_11_SetAudioCallback(This,theCallback) \ + ( (This)->lpVtbl -> SetAudioCallback(This,theCallback) ) + +#define IDeckLinkOutput_v10_11_StartScheduledPlayback(This,playbackStartTime,timeScale,playbackSpeed) \ + ( (This)->lpVtbl -> StartScheduledPlayback(This,playbackStartTime,timeScale,playbackSpeed) ) + +#define IDeckLinkOutput_v10_11_StopScheduledPlayback(This,stopPlaybackAtTime,actualStopTime,timeScale) \ + ( (This)->lpVtbl -> StopScheduledPlayback(This,stopPlaybackAtTime,actualStopTime,timeScale) ) + +#define IDeckLinkOutput_v10_11_IsScheduledPlaybackRunning(This,active) \ + ( (This)->lpVtbl -> IsScheduledPlaybackRunning(This,active) ) + +#define IDeckLinkOutput_v10_11_GetScheduledStreamTime(This,desiredTimeScale,streamTime,playbackSpeed) \ + ( (This)->lpVtbl -> GetScheduledStreamTime(This,desiredTimeScale,streamTime,playbackSpeed) ) + +#define IDeckLinkOutput_v10_11_GetReferenceStatus(This,referenceStatus) \ + ( (This)->lpVtbl -> GetReferenceStatus(This,referenceStatus) ) + +#define IDeckLinkOutput_v10_11_GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) \ + ( (This)->lpVtbl -> GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) ) + +#define IDeckLinkOutput_v10_11_GetFrameCompletionReferenceTimestamp(This,theFrame,desiredTimeScale,frameCompletionTimestamp) \ + ( (This)->lpVtbl -> GetFrameCompletionReferenceTimestamp(This,theFrame,desiredTimeScale,frameCompletionTimestamp) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkOutput_v10_11_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkInput_v10_11_INTERFACE_DEFINED__ +#define __IDeckLinkInput_v10_11_INTERFACE_DEFINED__ + +/* interface IDeckLinkInput_v10_11 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkInput_v10_11; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("AF22762B-DFAC-4846-AA79-FA8883560995") + IDeckLinkInput_v10_11 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE DoesSupportVideoMode( + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDVideoInputFlags flags, + /* [out] */ BMDDisplayModeSupport_v10_11 *result, + /* [out] */ IDeckLinkDisplayMode **resultDisplayMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayModeIterator( + /* [out] */ IDeckLinkDisplayModeIterator **iterator) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetScreenPreviewCallback( + /* [in] */ IDeckLinkScreenPreviewCallback_v14_2_1 *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_v14_2_1 *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_v11_5_1 *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_v10_11Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkInput_v10_11 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkInput_v10_11 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkInput_v10_11 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v10_11, DoesSupportVideoMode) + HRESULT ( STDMETHODCALLTYPE *DoesSupportVideoMode )( + IDeckLinkInput_v10_11 * This, + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDVideoInputFlags flags, + /* [out] */ BMDDisplayModeSupport_v10_11 *result, + /* [out] */ IDeckLinkDisplayMode **resultDisplayMode); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v10_11, GetDisplayModeIterator) + HRESULT ( STDMETHODCALLTYPE *GetDisplayModeIterator )( + IDeckLinkInput_v10_11 * This, + /* [out] */ IDeckLinkDisplayModeIterator **iterator); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v10_11, SetScreenPreviewCallback) + HRESULT ( STDMETHODCALLTYPE *SetScreenPreviewCallback )( + IDeckLinkInput_v10_11 * This, + /* [in] */ IDeckLinkScreenPreviewCallback_v14_2_1 *previewCallback); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v10_11, EnableVideoInput) + HRESULT ( STDMETHODCALLTYPE *EnableVideoInput )( + IDeckLinkInput_v10_11 * This, + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDVideoInputFlags flags); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v10_11, DisableVideoInput) + HRESULT ( STDMETHODCALLTYPE *DisableVideoInput )( + IDeckLinkInput_v10_11 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v10_11, GetAvailableVideoFrameCount) + HRESULT ( STDMETHODCALLTYPE *GetAvailableVideoFrameCount )( + IDeckLinkInput_v10_11 * This, + /* [out] */ unsigned int *availableFrameCount); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v10_11, SetVideoInputFrameMemoryAllocator) + HRESULT ( STDMETHODCALLTYPE *SetVideoInputFrameMemoryAllocator )( + IDeckLinkInput_v10_11 * This, + /* [in] */ IDeckLinkMemoryAllocator_v14_2_1 *theAllocator); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v10_11, EnableAudioInput) + HRESULT ( STDMETHODCALLTYPE *EnableAudioInput )( + IDeckLinkInput_v10_11 * This, + /* [in] */ BMDAudioSampleRate sampleRate, + /* [in] */ BMDAudioSampleType sampleType, + /* [in] */ unsigned int channelCount); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v10_11, DisableAudioInput) + HRESULT ( STDMETHODCALLTYPE *DisableAudioInput )( + IDeckLinkInput_v10_11 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v10_11, GetAvailableAudioSampleFrameCount) + HRESULT ( STDMETHODCALLTYPE *GetAvailableAudioSampleFrameCount )( + IDeckLinkInput_v10_11 * This, + /* [out] */ unsigned int *availableSampleFrameCount); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v10_11, StartStreams) + HRESULT ( STDMETHODCALLTYPE *StartStreams )( + IDeckLinkInput_v10_11 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v10_11, StopStreams) + HRESULT ( STDMETHODCALLTYPE *StopStreams )( + IDeckLinkInput_v10_11 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v10_11, PauseStreams) + HRESULT ( STDMETHODCALLTYPE *PauseStreams )( + IDeckLinkInput_v10_11 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v10_11, FlushStreams) + HRESULT ( STDMETHODCALLTYPE *FlushStreams )( + IDeckLinkInput_v10_11 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v10_11, SetCallback) + HRESULT ( STDMETHODCALLTYPE *SetCallback )( + IDeckLinkInput_v10_11 * This, + /* [in] */ IDeckLinkInputCallback_v11_5_1 *theCallback); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v10_11, GetHardwareReferenceClock) + HRESULT ( STDMETHODCALLTYPE *GetHardwareReferenceClock )( + IDeckLinkInput_v10_11 * This, + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *hardwareTime, + /* [out] */ BMDTimeValue *timeInFrame, + /* [out] */ BMDTimeValue *ticksPerFrame); + + END_INTERFACE + } IDeckLinkInput_v10_11Vtbl; + + interface IDeckLinkInput_v10_11 + { + CONST_VTBL struct IDeckLinkInput_v10_11Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkInput_v10_11_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkInput_v10_11_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkInput_v10_11_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkInput_v10_11_DoesSupportVideoMode(This,displayMode,pixelFormat,flags,result,resultDisplayMode) \ + ( (This)->lpVtbl -> DoesSupportVideoMode(This,displayMode,pixelFormat,flags,result,resultDisplayMode) ) + +#define IDeckLinkInput_v10_11_GetDisplayModeIterator(This,iterator) \ + ( (This)->lpVtbl -> GetDisplayModeIterator(This,iterator) ) + +#define IDeckLinkInput_v10_11_SetScreenPreviewCallback(This,previewCallback) \ + ( (This)->lpVtbl -> SetScreenPreviewCallback(This,previewCallback) ) + +#define IDeckLinkInput_v10_11_EnableVideoInput(This,displayMode,pixelFormat,flags) \ + ( (This)->lpVtbl -> EnableVideoInput(This,displayMode,pixelFormat,flags) ) + +#define IDeckLinkInput_v10_11_DisableVideoInput(This) \ + ( (This)->lpVtbl -> DisableVideoInput(This) ) + +#define IDeckLinkInput_v10_11_GetAvailableVideoFrameCount(This,availableFrameCount) \ + ( (This)->lpVtbl -> GetAvailableVideoFrameCount(This,availableFrameCount) ) + +#define IDeckLinkInput_v10_11_SetVideoInputFrameMemoryAllocator(This,theAllocator) \ + ( (This)->lpVtbl -> SetVideoInputFrameMemoryAllocator(This,theAllocator) ) + +#define IDeckLinkInput_v10_11_EnableAudioInput(This,sampleRate,sampleType,channelCount) \ + ( (This)->lpVtbl -> EnableAudioInput(This,sampleRate,sampleType,channelCount) ) + +#define IDeckLinkInput_v10_11_DisableAudioInput(This) \ + ( (This)->lpVtbl -> DisableAudioInput(This) ) + +#define IDeckLinkInput_v10_11_GetAvailableAudioSampleFrameCount(This,availableSampleFrameCount) \ + ( (This)->lpVtbl -> GetAvailableAudioSampleFrameCount(This,availableSampleFrameCount) ) + +#define IDeckLinkInput_v10_11_StartStreams(This) \ + ( (This)->lpVtbl -> StartStreams(This) ) + +#define IDeckLinkInput_v10_11_StopStreams(This) \ + ( (This)->lpVtbl -> StopStreams(This) ) + +#define IDeckLinkInput_v10_11_PauseStreams(This) \ + ( (This)->lpVtbl -> PauseStreams(This) ) + +#define IDeckLinkInput_v10_11_FlushStreams(This) \ + ( (This)->lpVtbl -> FlushStreams(This) ) + +#define IDeckLinkInput_v10_11_SetCallback(This,theCallback) \ + ( (This)->lpVtbl -> SetCallback(This,theCallback) ) + +#define IDeckLinkInput_v10_11_GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) \ + ( (This)->lpVtbl -> GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkInput_v10_11_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkEncoderInput_v10_11_INTERFACE_DEFINED__ +#define __IDeckLinkEncoderInput_v10_11_INTERFACE_DEFINED__ + +/* interface IDeckLinkEncoderInput_v10_11 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkEncoderInput_v10_11; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("270587DA-6B7D-42E7-A1F0-6D853F581185") + IDeckLinkEncoderInput_v10_11 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE DoesSupportVideoMode( + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDVideoInputFlags flags, + /* [out] */ BMDDisplayModeSupport_v10_11 *result, + /* [out] */ IDeckLinkDisplayMode **resultDisplayMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayModeIterator( + /* [out] */ IDeckLinkDisplayModeIterator **iterator) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableVideoInput( + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDVideoInputFlags flags) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisableVideoInput( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAvailablePacketsCount( + /* [out] */ unsigned int *availablePacketsCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetMemoryAllocator( + /* [in] */ IDeckLinkMemoryAllocator_v14_2_1 *theAllocator) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableAudioInput( + /* [in] */ BMDAudioFormat audioFormat, + /* [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] */ IDeckLinkEncoderInputCallback *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 IDeckLinkEncoderInput_v10_11Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkEncoderInput_v10_11 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkEncoderInput_v10_11 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkEncoderInput_v10_11 * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput_v10_11, DoesSupportVideoMode) + HRESULT ( STDMETHODCALLTYPE *DoesSupportVideoMode )( + IDeckLinkEncoderInput_v10_11 * This, + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDVideoInputFlags flags, + /* [out] */ BMDDisplayModeSupport_v10_11 *result, + /* [out] */ IDeckLinkDisplayMode **resultDisplayMode); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput_v10_11, GetDisplayModeIterator) + HRESULT ( STDMETHODCALLTYPE *GetDisplayModeIterator )( + IDeckLinkEncoderInput_v10_11 * This, + /* [out] */ IDeckLinkDisplayModeIterator **iterator); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput_v10_11, EnableVideoInput) + HRESULT ( STDMETHODCALLTYPE *EnableVideoInput )( + IDeckLinkEncoderInput_v10_11 * This, + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDVideoInputFlags flags); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput_v10_11, DisableVideoInput) + HRESULT ( STDMETHODCALLTYPE *DisableVideoInput )( + IDeckLinkEncoderInput_v10_11 * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput_v10_11, GetAvailablePacketsCount) + HRESULT ( STDMETHODCALLTYPE *GetAvailablePacketsCount )( + IDeckLinkEncoderInput_v10_11 * This, + /* [out] */ unsigned int *availablePacketsCount); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput_v10_11, SetMemoryAllocator) + HRESULT ( STDMETHODCALLTYPE *SetMemoryAllocator )( + IDeckLinkEncoderInput_v10_11 * This, + /* [in] */ IDeckLinkMemoryAllocator_v14_2_1 *theAllocator); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput_v10_11, EnableAudioInput) + HRESULT ( STDMETHODCALLTYPE *EnableAudioInput )( + IDeckLinkEncoderInput_v10_11 * This, + /* [in] */ BMDAudioFormat audioFormat, + /* [in] */ BMDAudioSampleRate sampleRate, + /* [in] */ BMDAudioSampleType sampleType, + /* [in] */ unsigned int channelCount); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput_v10_11, DisableAudioInput) + HRESULT ( STDMETHODCALLTYPE *DisableAudioInput )( + IDeckLinkEncoderInput_v10_11 * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput_v10_11, GetAvailableAudioSampleFrameCount) + HRESULT ( STDMETHODCALLTYPE *GetAvailableAudioSampleFrameCount )( + IDeckLinkEncoderInput_v10_11 * This, + /* [out] */ unsigned int *availableSampleFrameCount); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput_v10_11, StartStreams) + HRESULT ( STDMETHODCALLTYPE *StartStreams )( + IDeckLinkEncoderInput_v10_11 * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput_v10_11, StopStreams) + HRESULT ( STDMETHODCALLTYPE *StopStreams )( + IDeckLinkEncoderInput_v10_11 * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput_v10_11, PauseStreams) + HRESULT ( STDMETHODCALLTYPE *PauseStreams )( + IDeckLinkEncoderInput_v10_11 * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput_v10_11, FlushStreams) + HRESULT ( STDMETHODCALLTYPE *FlushStreams )( + IDeckLinkEncoderInput_v10_11 * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput_v10_11, SetCallback) + HRESULT ( STDMETHODCALLTYPE *SetCallback )( + IDeckLinkEncoderInput_v10_11 * This, + /* [in] */ IDeckLinkEncoderInputCallback *theCallback); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderInput_v10_11, GetHardwareReferenceClock) + HRESULT ( STDMETHODCALLTYPE *GetHardwareReferenceClock )( + IDeckLinkEncoderInput_v10_11 * This, + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *hardwareTime, + /* [out] */ BMDTimeValue *timeInFrame, + /* [out] */ BMDTimeValue *ticksPerFrame); + + END_INTERFACE + } IDeckLinkEncoderInput_v10_11Vtbl; + + interface IDeckLinkEncoderInput_v10_11 + { + CONST_VTBL struct IDeckLinkEncoderInput_v10_11Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkEncoderInput_v10_11_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkEncoderInput_v10_11_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkEncoderInput_v10_11_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkEncoderInput_v10_11_DoesSupportVideoMode(This,displayMode,pixelFormat,flags,result,resultDisplayMode) \ + ( (This)->lpVtbl -> DoesSupportVideoMode(This,displayMode,pixelFormat,flags,result,resultDisplayMode) ) + +#define IDeckLinkEncoderInput_v10_11_GetDisplayModeIterator(This,iterator) \ + ( (This)->lpVtbl -> GetDisplayModeIterator(This,iterator) ) + +#define IDeckLinkEncoderInput_v10_11_EnableVideoInput(This,displayMode,pixelFormat,flags) \ + ( (This)->lpVtbl -> EnableVideoInput(This,displayMode,pixelFormat,flags) ) + +#define IDeckLinkEncoderInput_v10_11_DisableVideoInput(This) \ + ( (This)->lpVtbl -> DisableVideoInput(This) ) + +#define IDeckLinkEncoderInput_v10_11_GetAvailablePacketsCount(This,availablePacketsCount) \ + ( (This)->lpVtbl -> GetAvailablePacketsCount(This,availablePacketsCount) ) + +#define IDeckLinkEncoderInput_v10_11_SetMemoryAllocator(This,theAllocator) \ + ( (This)->lpVtbl -> SetMemoryAllocator(This,theAllocator) ) + +#define IDeckLinkEncoderInput_v10_11_EnableAudioInput(This,audioFormat,sampleRate,sampleType,channelCount) \ + ( (This)->lpVtbl -> EnableAudioInput(This,audioFormat,sampleRate,sampleType,channelCount) ) + +#define IDeckLinkEncoderInput_v10_11_DisableAudioInput(This) \ + ( (This)->lpVtbl -> DisableAudioInput(This) ) + +#define IDeckLinkEncoderInput_v10_11_GetAvailableAudioSampleFrameCount(This,availableSampleFrameCount) \ + ( (This)->lpVtbl -> GetAvailableAudioSampleFrameCount(This,availableSampleFrameCount) ) + +#define IDeckLinkEncoderInput_v10_11_StartStreams(This) \ + ( (This)->lpVtbl -> StartStreams(This) ) + +#define IDeckLinkEncoderInput_v10_11_StopStreams(This) \ + ( (This)->lpVtbl -> StopStreams(This) ) + +#define IDeckLinkEncoderInput_v10_11_PauseStreams(This) \ + ( (This)->lpVtbl -> PauseStreams(This) ) + +#define IDeckLinkEncoderInput_v10_11_FlushStreams(This) \ + ( (This)->lpVtbl -> FlushStreams(This) ) + +#define IDeckLinkEncoderInput_v10_11_SetCallback(This,theCallback) \ + ( (This)->lpVtbl -> SetCallback(This,theCallback) ) + +#define IDeckLinkEncoderInput_v10_11_GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) \ + ( (This)->lpVtbl -> GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkEncoderInput_v10_11_INTERFACE_DEFINED__ */ + + +EXTERN_C const CLSID CLSID_CDeckLinkIterator_v10_11; + +#ifdef __cplusplus + +class DECLSPEC_UUID("87D2693F-8D4A-45C7-B43F-10ACBA25E68F") +CDeckLinkIterator_v10_11; +#endif + +EXTERN_C const CLSID CLSID_CDeckLinkDiscovery_v10_11; + +#ifdef __cplusplus + +class DECLSPEC_UUID("652615D4-26CD-4514-B161-2FD5072ED008") +CDeckLinkDiscovery_v10_11; +#endif + +#ifndef __IDeckLinkConfiguration_v10_9_INTERFACE_DEFINED__ +#define __IDeckLinkConfiguration_v10_9_INTERFACE_DEFINED__ + +/* interface IDeckLinkConfiguration_v10_9 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkConfiguration_v10_9; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("CB71734A-FE37-4E8D-8E13-802133A1C3F2") + IDeckLinkConfiguration_v10_9 : 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_9Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkConfiguration_v10_9 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkConfiguration_v10_9 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkConfiguration_v10_9 * This); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_9, SetFlag) + HRESULT ( STDMETHODCALLTYPE *SetFlag )( + IDeckLinkConfiguration_v10_9 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ BOOL value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_9, GetFlag) + HRESULT ( STDMETHODCALLTYPE *GetFlag )( + IDeckLinkConfiguration_v10_9 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ BOOL *value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_9, SetInt) + HRESULT ( STDMETHODCALLTYPE *SetInt )( + IDeckLinkConfiguration_v10_9 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ LONGLONG value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_9, GetInt) + HRESULT ( STDMETHODCALLTYPE *GetInt )( + IDeckLinkConfiguration_v10_9 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ LONGLONG *value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_9, SetFloat) + HRESULT ( STDMETHODCALLTYPE *SetFloat )( + IDeckLinkConfiguration_v10_9 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ double value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_9, GetFloat) + HRESULT ( STDMETHODCALLTYPE *GetFloat )( + IDeckLinkConfiguration_v10_9 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ double *value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_9, SetString) + HRESULT ( STDMETHODCALLTYPE *SetString )( + IDeckLinkConfiguration_v10_9 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ BSTR value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_9, GetString) + HRESULT ( STDMETHODCALLTYPE *GetString )( + IDeckLinkConfiguration_v10_9 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ BSTR *value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_9, WriteConfigurationToPreferences) + HRESULT ( STDMETHODCALLTYPE *WriteConfigurationToPreferences )( + IDeckLinkConfiguration_v10_9 * This); + + END_INTERFACE + } IDeckLinkConfiguration_v10_9Vtbl; + + interface IDeckLinkConfiguration_v10_9 + { + CONST_VTBL struct IDeckLinkConfiguration_v10_9Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkConfiguration_v10_9_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkConfiguration_v10_9_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkConfiguration_v10_9_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkConfiguration_v10_9_SetFlag(This,cfgID,value) \ + ( (This)->lpVtbl -> SetFlag(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v10_9_GetFlag(This,cfgID,value) \ + ( (This)->lpVtbl -> GetFlag(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v10_9_SetInt(This,cfgID,value) \ + ( (This)->lpVtbl -> SetInt(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v10_9_GetInt(This,cfgID,value) \ + ( (This)->lpVtbl -> GetInt(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v10_9_SetFloat(This,cfgID,value) \ + ( (This)->lpVtbl -> SetFloat(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v10_9_GetFloat(This,cfgID,value) \ + ( (This)->lpVtbl -> GetFloat(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v10_9_SetString(This,cfgID,value) \ + ( (This)->lpVtbl -> SetString(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v10_9_GetString(This,cfgID,value) \ + ( (This)->lpVtbl -> GetString(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v10_9_WriteConfigurationToPreferences(This) \ + ( (This)->lpVtbl -> WriteConfigurationToPreferences(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkConfiguration_v10_9_INTERFACE_DEFINED__ */ + + +EXTERN_C const CLSID CLSID_CBMDStreamingDiscovery_v10_8; + +#ifdef __cplusplus + +class DECLSPEC_UUID("0CAA31F6-8A26-40B0-86A4-BF58DCCA710C") +CBMDStreamingDiscovery_v10_8; +#endif + +#ifndef __IDeckLinkConfiguration_v10_4_INTERFACE_DEFINED__ +#define __IDeckLinkConfiguration_v10_4_INTERFACE_DEFINED__ + +/* interface IDeckLinkConfiguration_v10_4 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkConfiguration_v10_4; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("1E69FCF6-4203-4936-8076-2A9F4CFD50CB") + IDeckLinkConfiguration_v10_4 : 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_4Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkConfiguration_v10_4 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkConfiguration_v10_4 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkConfiguration_v10_4 * This); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_4, SetFlag) + HRESULT ( STDMETHODCALLTYPE *SetFlag )( + IDeckLinkConfiguration_v10_4 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ BOOL value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_4, GetFlag) + HRESULT ( STDMETHODCALLTYPE *GetFlag )( + IDeckLinkConfiguration_v10_4 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ BOOL *value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_4, SetInt) + HRESULT ( STDMETHODCALLTYPE *SetInt )( + IDeckLinkConfiguration_v10_4 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ LONGLONG value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_4, GetInt) + HRESULT ( STDMETHODCALLTYPE *GetInt )( + IDeckLinkConfiguration_v10_4 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ LONGLONG *value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_4, SetFloat) + HRESULT ( STDMETHODCALLTYPE *SetFloat )( + IDeckLinkConfiguration_v10_4 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ double value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_4, GetFloat) + HRESULT ( STDMETHODCALLTYPE *GetFloat )( + IDeckLinkConfiguration_v10_4 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ double *value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_4, SetString) + HRESULT ( STDMETHODCALLTYPE *SetString )( + IDeckLinkConfiguration_v10_4 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ BSTR value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_4, GetString) + HRESULT ( STDMETHODCALLTYPE *GetString )( + IDeckLinkConfiguration_v10_4 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ BSTR *value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_4, WriteConfigurationToPreferences) + HRESULT ( STDMETHODCALLTYPE *WriteConfigurationToPreferences )( + IDeckLinkConfiguration_v10_4 * This); + + END_INTERFACE + } IDeckLinkConfiguration_v10_4Vtbl; + + interface IDeckLinkConfiguration_v10_4 + { + CONST_VTBL struct IDeckLinkConfiguration_v10_4Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkConfiguration_v10_4_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkConfiguration_v10_4_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkConfiguration_v10_4_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkConfiguration_v10_4_SetFlag(This,cfgID,value) \ + ( (This)->lpVtbl -> SetFlag(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v10_4_GetFlag(This,cfgID,value) \ + ( (This)->lpVtbl -> GetFlag(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v10_4_SetInt(This,cfgID,value) \ + ( (This)->lpVtbl -> SetInt(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v10_4_GetInt(This,cfgID,value) \ + ( (This)->lpVtbl -> GetInt(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v10_4_SetFloat(This,cfgID,value) \ + ( (This)->lpVtbl -> SetFloat(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v10_4_GetFloat(This,cfgID,value) \ + ( (This)->lpVtbl -> GetFloat(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v10_4_SetString(This,cfgID,value) \ + ( (This)->lpVtbl -> SetString(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v10_4_GetString(This,cfgID,value) \ + ( (This)->lpVtbl -> GetString(This,cfgID,value) ) + +#define IDeckLinkConfiguration_v10_4_WriteConfigurationToPreferences(This) \ + ( (This)->lpVtbl -> WriteConfigurationToPreferences(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkConfiguration_v10_4_INTERFACE_DEFINED__ */ + + +#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 + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkConfiguration_v10_2 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkConfiguration_v10_2 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkConfiguration_v10_2 * This); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_2, SetFlag) + HRESULT ( STDMETHODCALLTYPE *SetFlag )( + IDeckLinkConfiguration_v10_2 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ BOOL value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_2, GetFlag) + HRESULT ( STDMETHODCALLTYPE *GetFlag )( + IDeckLinkConfiguration_v10_2 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ BOOL *value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_2, SetInt) + HRESULT ( STDMETHODCALLTYPE *SetInt )( + IDeckLinkConfiguration_v10_2 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ LONGLONG value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_2, GetInt) + HRESULT ( STDMETHODCALLTYPE *GetInt )( + IDeckLinkConfiguration_v10_2 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ LONGLONG *value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_2, SetFloat) + HRESULT ( STDMETHODCALLTYPE *SetFloat )( + IDeckLinkConfiguration_v10_2 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ double value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_2, GetFloat) + HRESULT ( STDMETHODCALLTYPE *GetFloat )( + IDeckLinkConfiguration_v10_2 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ double *value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_2, SetString) + HRESULT ( STDMETHODCALLTYPE *SetString )( + IDeckLinkConfiguration_v10_2 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [in] */ BSTR value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_2, GetString) + HRESULT ( STDMETHODCALLTYPE *GetString )( + IDeckLinkConfiguration_v10_2 * This, + /* [in] */ BMDDeckLinkConfigurationID cfgID, + /* [out] */ BSTR *value); + + DECLSPEC_XFGVIRT(IDeckLinkConfiguration_v10_2, WriteConfigurationToPreferences) + 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 __IDeckLinkAncillaryPacket_v15_2_INTERFACE_DEFINED__ +#define __IDeckLinkAncillaryPacket_v15_2_INTERFACE_DEFINED__ + +/* interface IDeckLinkAncillaryPacket_v15_2 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkAncillaryPacket_v15_2; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("CC5BBF7E-029C-4D3B-9158-6000EF5E3670") + IDeckLinkAncillaryPacket_v15_2 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetBytes( + /* [in] */ BMDAncillaryPacketFormat format, + /* [out] */ const void **data, + /* [out] */ unsigned int *size) = 0; + + virtual unsigned char STDMETHODCALLTYPE GetDID( void) = 0; + + virtual unsigned char STDMETHODCALLTYPE GetSDID( void) = 0; + + virtual unsigned int STDMETHODCALLTYPE GetLineNumber( void) = 0; + + virtual unsigned char STDMETHODCALLTYPE GetDataStreamIndex( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkAncillaryPacket_v15_2Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkAncillaryPacket_v15_2 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkAncillaryPacket_v15_2 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkAncillaryPacket_v15_2 * This); + + DECLSPEC_XFGVIRT(IDeckLinkAncillaryPacket_v15_2, GetBytes) + HRESULT ( STDMETHODCALLTYPE *GetBytes )( + IDeckLinkAncillaryPacket_v15_2 * This, + /* [in] */ BMDAncillaryPacketFormat format, + /* [out] */ const void **data, + /* [out] */ unsigned int *size); + + DECLSPEC_XFGVIRT(IDeckLinkAncillaryPacket_v15_2, GetDID) + unsigned char ( STDMETHODCALLTYPE *GetDID )( + IDeckLinkAncillaryPacket_v15_2 * This); + + DECLSPEC_XFGVIRT(IDeckLinkAncillaryPacket_v15_2, GetSDID) + unsigned char ( STDMETHODCALLTYPE *GetSDID )( + IDeckLinkAncillaryPacket_v15_2 * This); + + DECLSPEC_XFGVIRT(IDeckLinkAncillaryPacket_v15_2, GetLineNumber) + unsigned int ( STDMETHODCALLTYPE *GetLineNumber )( + IDeckLinkAncillaryPacket_v15_2 * This); + + DECLSPEC_XFGVIRT(IDeckLinkAncillaryPacket_v15_2, GetDataStreamIndex) + unsigned char ( STDMETHODCALLTYPE *GetDataStreamIndex )( + IDeckLinkAncillaryPacket_v15_2 * This); + + END_INTERFACE + } IDeckLinkAncillaryPacket_v15_2Vtbl; + + interface IDeckLinkAncillaryPacket_v15_2 + { + CONST_VTBL struct IDeckLinkAncillaryPacket_v15_2Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkAncillaryPacket_v15_2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkAncillaryPacket_v15_2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkAncillaryPacket_v15_2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkAncillaryPacket_v15_2_GetBytes(This,format,data,size) \ + ( (This)->lpVtbl -> GetBytes(This,format,data,size) ) + +#define IDeckLinkAncillaryPacket_v15_2_GetDID(This) \ + ( (This)->lpVtbl -> GetDID(This) ) + +#define IDeckLinkAncillaryPacket_v15_2_GetSDID(This) \ + ( (This)->lpVtbl -> GetSDID(This) ) + +#define IDeckLinkAncillaryPacket_v15_2_GetLineNumber(This) \ + ( (This)->lpVtbl -> GetLineNumber(This) ) + +#define IDeckLinkAncillaryPacket_v15_2_GetDataStreamIndex(This) \ + ( (This)->lpVtbl -> GetDataStreamIndex(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkAncillaryPacket_v15_2_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkAncillaryPacketIterator_v15_2_INTERFACE_DEFINED__ +#define __IDeckLinkAncillaryPacketIterator_v15_2_INTERFACE_DEFINED__ + +/* interface IDeckLinkAncillaryPacketIterator_v15_2 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkAncillaryPacketIterator_v15_2; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("3FC8994B-88FB-4C17-968F-9AAB69D964A7") + IDeckLinkAncillaryPacketIterator_v15_2 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Next( + /* [out] */ IDeckLinkAncillaryPacket_v15_2 **packet) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkAncillaryPacketIterator_v15_2Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkAncillaryPacketIterator_v15_2 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkAncillaryPacketIterator_v15_2 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkAncillaryPacketIterator_v15_2 * This); + + DECLSPEC_XFGVIRT(IDeckLinkAncillaryPacketIterator_v15_2, Next) + HRESULT ( STDMETHODCALLTYPE *Next )( + IDeckLinkAncillaryPacketIterator_v15_2 * This, + /* [out] */ IDeckLinkAncillaryPacket_v15_2 **packet); + + END_INTERFACE + } IDeckLinkAncillaryPacketIterator_v15_2Vtbl; + + interface IDeckLinkAncillaryPacketIterator_v15_2 + { + CONST_VTBL struct IDeckLinkAncillaryPacketIterator_v15_2Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkAncillaryPacketIterator_v15_2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkAncillaryPacketIterator_v15_2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkAncillaryPacketIterator_v15_2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkAncillaryPacketIterator_v15_2_Next(This,packet) \ + ( (This)->lpVtbl -> Next(This,packet) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkAncillaryPacketIterator_v15_2_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkVideoFrameAncillaryPackets_v15_2_INTERFACE_DEFINED__ +#define __IDeckLinkVideoFrameAncillaryPackets_v15_2_INTERFACE_DEFINED__ + +/* interface IDeckLinkVideoFrameAncillaryPackets_v15_2 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkVideoFrameAncillaryPackets_v15_2; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("6C186C0F-459E-41D8-AEE2-4812D81AEE68") + IDeckLinkVideoFrameAncillaryPackets_v15_2 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetPacketIterator( + /* [out] */ IDeckLinkAncillaryPacketIterator_v15_2 **iterator) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFirstPacketByID( + /* [in] */ unsigned char DID, + /* [in] */ unsigned char SDID, + /* [out] */ IDeckLinkAncillaryPacket_v15_2 **packet) = 0; + + virtual HRESULT STDMETHODCALLTYPE AttachPacket( + /* [in] */ IDeckLinkAncillaryPacket_v15_2 *packet) = 0; + + virtual HRESULT STDMETHODCALLTYPE DetachPacket( + /* [in] */ IDeckLinkAncillaryPacket_v15_2 *packet) = 0; + + virtual HRESULT STDMETHODCALLTYPE DetachAllPackets( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkVideoFrameAncillaryPackets_v15_2Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoFrameAncillaryPackets_v15_2 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoFrameAncillaryPackets_v15_2 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoFrameAncillaryPackets_v15_2 * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrameAncillaryPackets_v15_2, GetPacketIterator) + HRESULT ( STDMETHODCALLTYPE *GetPacketIterator )( + IDeckLinkVideoFrameAncillaryPackets_v15_2 * This, + /* [out] */ IDeckLinkAncillaryPacketIterator_v15_2 **iterator); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrameAncillaryPackets_v15_2, GetFirstPacketByID) + HRESULT ( STDMETHODCALLTYPE *GetFirstPacketByID )( + IDeckLinkVideoFrameAncillaryPackets_v15_2 * This, + /* [in] */ unsigned char DID, + /* [in] */ unsigned char SDID, + /* [out] */ IDeckLinkAncillaryPacket_v15_2 **packet); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrameAncillaryPackets_v15_2, AttachPacket) + HRESULT ( STDMETHODCALLTYPE *AttachPacket )( + IDeckLinkVideoFrameAncillaryPackets_v15_2 * This, + /* [in] */ IDeckLinkAncillaryPacket_v15_2 *packet); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrameAncillaryPackets_v15_2, DetachPacket) + HRESULT ( STDMETHODCALLTYPE *DetachPacket )( + IDeckLinkVideoFrameAncillaryPackets_v15_2 * This, + /* [in] */ IDeckLinkAncillaryPacket_v15_2 *packet); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrameAncillaryPackets_v15_2, DetachAllPackets) + HRESULT ( STDMETHODCALLTYPE *DetachAllPackets )( + IDeckLinkVideoFrameAncillaryPackets_v15_2 * This); + + END_INTERFACE + } IDeckLinkVideoFrameAncillaryPackets_v15_2Vtbl; + + interface IDeckLinkVideoFrameAncillaryPackets_v15_2 + { + CONST_VTBL struct IDeckLinkVideoFrameAncillaryPackets_v15_2Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkVideoFrameAncillaryPackets_v15_2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkVideoFrameAncillaryPackets_v15_2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkVideoFrameAncillaryPackets_v15_2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkVideoFrameAncillaryPackets_v15_2_GetPacketIterator(This,iterator) \ + ( (This)->lpVtbl -> GetPacketIterator(This,iterator) ) + +#define IDeckLinkVideoFrameAncillaryPackets_v15_2_GetFirstPacketByID(This,DID,SDID,packet) \ + ( (This)->lpVtbl -> GetFirstPacketByID(This,DID,SDID,packet) ) + +#define IDeckLinkVideoFrameAncillaryPackets_v15_2_AttachPacket(This,packet) \ + ( (This)->lpVtbl -> AttachPacket(This,packet) ) + +#define IDeckLinkVideoFrameAncillaryPackets_v15_2_DetachPacket(This,packet) \ + ( (This)->lpVtbl -> DetachPacket(This,packet) ) + +#define IDeckLinkVideoFrameAncillaryPackets_v15_2_DetachAllPackets(This) \ + ( (This)->lpVtbl -> DetachAllPackets(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkVideoFrameAncillaryPackets_v15_2_INTERFACE_DEFINED__ */ + + +EXTERN_C const CLSID CLSID_CDeckLinkVideoFrameAncillaryPackets_v15_2; + +#ifdef __cplusplus + +class DECLSPEC_UUID("F891AD29-D0C2-46E9-A926-4E2D0DD8CFAD") +CDeckLinkVideoFrameAncillaryPackets_v15_2; +#endif + +#ifndef __IDeckLinkVideoFrameMetadataExtensions_v11_5_INTERFACE_DEFINED__ +#define __IDeckLinkVideoFrameMetadataExtensions_v11_5_INTERFACE_DEFINED__ + +/* interface IDeckLinkVideoFrameMetadataExtensions_v11_5 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkVideoFrameMetadataExtensions_v11_5; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("D5973DC9-6432-46D0-8F0B-2496F8A1238F") + IDeckLinkVideoFrameMetadataExtensions_v11_5 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetInt( + /* [in] */ BMDDeckLinkFrameMetadataID_v11_5 metadataID, + /* [out] */ LONGLONG *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFloat( + /* [in] */ BMDDeckLinkFrameMetadataID_v11_5 metadataID, + /* [out] */ double *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFlag( + /* [in] */ BMDDeckLinkFrameMetadataID_v11_5 metadataID, + /* [out] */ BOOL *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetString( + /* [in] */ BMDDeckLinkFrameMetadataID_v11_5 metadataID, + /* [out] */ BSTR *value) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkVideoFrameMetadataExtensions_v11_5Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkVideoFrameMetadataExtensions_v11_5 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkVideoFrameMetadataExtensions_v11_5 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkVideoFrameMetadataExtensions_v11_5 * This); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrameMetadataExtensions_v11_5, GetInt) + HRESULT ( STDMETHODCALLTYPE *GetInt )( + IDeckLinkVideoFrameMetadataExtensions_v11_5 * This, + /* [in] */ BMDDeckLinkFrameMetadataID_v11_5 metadataID, + /* [out] */ LONGLONG *value); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrameMetadataExtensions_v11_5, GetFloat) + HRESULT ( STDMETHODCALLTYPE *GetFloat )( + IDeckLinkVideoFrameMetadataExtensions_v11_5 * This, + /* [in] */ BMDDeckLinkFrameMetadataID_v11_5 metadataID, + /* [out] */ double *value); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrameMetadataExtensions_v11_5, GetFlag) + HRESULT ( STDMETHODCALLTYPE *GetFlag )( + IDeckLinkVideoFrameMetadataExtensions_v11_5 * This, + /* [in] */ BMDDeckLinkFrameMetadataID_v11_5 metadataID, + /* [out] */ BOOL *value); + + DECLSPEC_XFGVIRT(IDeckLinkVideoFrameMetadataExtensions_v11_5, GetString) + HRESULT ( STDMETHODCALLTYPE *GetString )( + IDeckLinkVideoFrameMetadataExtensions_v11_5 * This, + /* [in] */ BMDDeckLinkFrameMetadataID_v11_5 metadataID, + /* [out] */ BSTR *value); + + END_INTERFACE + } IDeckLinkVideoFrameMetadataExtensions_v11_5Vtbl; + + interface IDeckLinkVideoFrameMetadataExtensions_v11_5 + { + CONST_VTBL struct IDeckLinkVideoFrameMetadataExtensions_v11_5Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkVideoFrameMetadataExtensions_v11_5_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkVideoFrameMetadataExtensions_v11_5_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkVideoFrameMetadataExtensions_v11_5_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkVideoFrameMetadataExtensions_v11_5_GetInt(This,metadataID,value) \ + ( (This)->lpVtbl -> GetInt(This,metadataID,value) ) + +#define IDeckLinkVideoFrameMetadataExtensions_v11_5_GetFloat(This,metadataID,value) \ + ( (This)->lpVtbl -> GetFloat(This,metadataID,value) ) + +#define IDeckLinkVideoFrameMetadataExtensions_v11_5_GetFlag(This,metadataID,value) \ + ( (This)->lpVtbl -> GetFlag(This,metadataID,value) ) + +#define IDeckLinkVideoFrameMetadataExtensions_v11_5_GetString(This,metadataID,value) \ + ( (This)->lpVtbl -> GetString(This,metadataID,value) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkVideoFrameMetadataExtensions_v11_5_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkOutput_v11_4_INTERFACE_DEFINED__ +#define __IDeckLinkOutput_v11_4_INTERFACE_DEFINED__ + +/* interface IDeckLinkOutput_v11_4 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkOutput_v11_4; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("065A0F6C-C508-4D0D-B919-F5EB0EBFC96B") + IDeckLinkOutput_v11_4 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE DoesSupportVideoMode( + /* [in] */ BMDVideoConnection connection, + /* [in] */ BMDDisplayMode requestedMode, + /* [in] */ BMDPixelFormat requestedPixelFormat, + /* [in] */ BMDSupportedVideoModeFlags flags, + /* [out] */ BMDDisplayMode *actualMode, + /* [out] */ BOOL *supported) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayMode( + /* [in] */ BMDDisplayMode displayMode, + /* [out] */ IDeckLinkDisplayMode **resultDisplayMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayModeIterator( + /* [out] */ IDeckLinkDisplayModeIterator **iterator) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetScreenPreviewCallback( + /* [in] */ IDeckLinkScreenPreviewCallback_v14_2_1 *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_v14_2_1 *theAllocator) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateVideoFrame( + /* [in] */ int width, + /* [in] */ int height, + /* [in] */ int rowBytes, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDFrameFlags flags, + /* [out] */ IDeckLinkMutableVideoFrame_v14_2_1 **outFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateAncillaryData( + /* [in] */ BMDPixelFormat pixelFormat, + /* [out] */ IDeckLinkVideoFrameAncillary **outBuffer) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisplayVideoFrameSync( + /* [in] */ IDeckLinkVideoFrame_v14_2_1 *theFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE ScheduleVideoFrame( + /* [in] */ IDeckLinkVideoFrame_v14_2_1 *theFrame, + /* [in] */ BMDTimeValue displayTime, + /* [in] */ BMDTimeValue displayDuration, + /* [in] */ BMDTimeScale timeScale) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetScheduledFrameCompletionCallback( + /* [in] */ IDeckLinkVideoOutputCallback_v14_2_1 *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_v14_2_1 *theFrame, + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *frameCompletionTimestamp) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkOutput_v11_4Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkOutput_v11_4 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkOutput_v11_4 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkOutput_v11_4 * This); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v11_4, DoesSupportVideoMode) + HRESULT ( STDMETHODCALLTYPE *DoesSupportVideoMode )( + IDeckLinkOutput_v11_4 * This, + /* [in] */ BMDVideoConnection connection, + /* [in] */ BMDDisplayMode requestedMode, + /* [in] */ BMDPixelFormat requestedPixelFormat, + /* [in] */ BMDSupportedVideoModeFlags flags, + /* [out] */ BMDDisplayMode *actualMode, + /* [out] */ BOOL *supported); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v11_4, GetDisplayMode) + HRESULT ( STDMETHODCALLTYPE *GetDisplayMode )( + IDeckLinkOutput_v11_4 * This, + /* [in] */ BMDDisplayMode displayMode, + /* [out] */ IDeckLinkDisplayMode **resultDisplayMode); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v11_4, GetDisplayModeIterator) + HRESULT ( STDMETHODCALLTYPE *GetDisplayModeIterator )( + IDeckLinkOutput_v11_4 * This, + /* [out] */ IDeckLinkDisplayModeIterator **iterator); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v11_4, SetScreenPreviewCallback) + HRESULT ( STDMETHODCALLTYPE *SetScreenPreviewCallback )( + IDeckLinkOutput_v11_4 * This, + /* [in] */ IDeckLinkScreenPreviewCallback_v14_2_1 *previewCallback); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v11_4, EnableVideoOutput) + HRESULT ( STDMETHODCALLTYPE *EnableVideoOutput )( + IDeckLinkOutput_v11_4 * This, + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDVideoOutputFlags flags); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v11_4, DisableVideoOutput) + HRESULT ( STDMETHODCALLTYPE *DisableVideoOutput )( + IDeckLinkOutput_v11_4 * This); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v11_4, SetVideoOutputFrameMemoryAllocator) + HRESULT ( STDMETHODCALLTYPE *SetVideoOutputFrameMemoryAllocator )( + IDeckLinkOutput_v11_4 * This, + /* [in] */ IDeckLinkMemoryAllocator_v14_2_1 *theAllocator); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v11_4, CreateVideoFrame) + HRESULT ( STDMETHODCALLTYPE *CreateVideoFrame )( + IDeckLinkOutput_v11_4 * This, + /* [in] */ int width, + /* [in] */ int height, + /* [in] */ int rowBytes, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDFrameFlags flags, + /* [out] */ IDeckLinkMutableVideoFrame_v14_2_1 **outFrame); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v11_4, CreateAncillaryData) + HRESULT ( STDMETHODCALLTYPE *CreateAncillaryData )( + IDeckLinkOutput_v11_4 * This, + /* [in] */ BMDPixelFormat pixelFormat, + /* [out] */ IDeckLinkVideoFrameAncillary **outBuffer); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v11_4, DisplayVideoFrameSync) + HRESULT ( STDMETHODCALLTYPE *DisplayVideoFrameSync )( + IDeckLinkOutput_v11_4 * This, + /* [in] */ IDeckLinkVideoFrame_v14_2_1 *theFrame); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v11_4, ScheduleVideoFrame) + HRESULT ( STDMETHODCALLTYPE *ScheduleVideoFrame )( + IDeckLinkOutput_v11_4 * This, + /* [in] */ IDeckLinkVideoFrame_v14_2_1 *theFrame, + /* [in] */ BMDTimeValue displayTime, + /* [in] */ BMDTimeValue displayDuration, + /* [in] */ BMDTimeScale timeScale); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v11_4, SetScheduledFrameCompletionCallback) + HRESULT ( STDMETHODCALLTYPE *SetScheduledFrameCompletionCallback )( + IDeckLinkOutput_v11_4 * This, + /* [in] */ IDeckLinkVideoOutputCallback_v14_2_1 *theCallback); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v11_4, GetBufferedVideoFrameCount) + HRESULT ( STDMETHODCALLTYPE *GetBufferedVideoFrameCount )( + IDeckLinkOutput_v11_4 * This, + /* [out] */ unsigned int *bufferedFrameCount); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v11_4, EnableAudioOutput) + HRESULT ( STDMETHODCALLTYPE *EnableAudioOutput )( + IDeckLinkOutput_v11_4 * This, + /* [in] */ BMDAudioSampleRate sampleRate, + /* [in] */ BMDAudioSampleType sampleType, + /* [in] */ unsigned int channelCount, + /* [in] */ BMDAudioOutputStreamType streamType); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v11_4, DisableAudioOutput) + HRESULT ( STDMETHODCALLTYPE *DisableAudioOutput )( + IDeckLinkOutput_v11_4 * This); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v11_4, WriteAudioSamplesSync) + HRESULT ( STDMETHODCALLTYPE *WriteAudioSamplesSync )( + IDeckLinkOutput_v11_4 * This, + /* [in] */ void *buffer, + /* [in] */ unsigned int sampleFrameCount, + /* [out] */ unsigned int *sampleFramesWritten); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v11_4, BeginAudioPreroll) + HRESULT ( STDMETHODCALLTYPE *BeginAudioPreroll )( + IDeckLinkOutput_v11_4 * This); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v11_4, EndAudioPreroll) + HRESULT ( STDMETHODCALLTYPE *EndAudioPreroll )( + IDeckLinkOutput_v11_4 * This); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v11_4, ScheduleAudioSamples) + HRESULT ( STDMETHODCALLTYPE *ScheduleAudioSamples )( + IDeckLinkOutput_v11_4 * This, + /* [in] */ void *buffer, + /* [in] */ unsigned int sampleFrameCount, + /* [in] */ BMDTimeValue streamTime, + /* [in] */ BMDTimeScale timeScale, + /* [out] */ unsigned int *sampleFramesWritten); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v11_4, GetBufferedAudioSampleFrameCount) + HRESULT ( STDMETHODCALLTYPE *GetBufferedAudioSampleFrameCount )( + IDeckLinkOutput_v11_4 * This, + /* [out] */ unsigned int *bufferedSampleFrameCount); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v11_4, FlushBufferedAudioSamples) + HRESULT ( STDMETHODCALLTYPE *FlushBufferedAudioSamples )( + IDeckLinkOutput_v11_4 * This); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v11_4, SetAudioCallback) + HRESULT ( STDMETHODCALLTYPE *SetAudioCallback )( + IDeckLinkOutput_v11_4 * This, + /* [in] */ IDeckLinkAudioOutputCallback *theCallback); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v11_4, StartScheduledPlayback) + HRESULT ( STDMETHODCALLTYPE *StartScheduledPlayback )( + IDeckLinkOutput_v11_4 * This, + /* [in] */ BMDTimeValue playbackStartTime, + /* [in] */ BMDTimeScale timeScale, + /* [in] */ double playbackSpeed); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v11_4, StopScheduledPlayback) + HRESULT ( STDMETHODCALLTYPE *StopScheduledPlayback )( + IDeckLinkOutput_v11_4 * This, + /* [in] */ BMDTimeValue stopPlaybackAtTime, + /* [out] */ BMDTimeValue *actualStopTime, + /* [in] */ BMDTimeScale timeScale); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v11_4, IsScheduledPlaybackRunning) + HRESULT ( STDMETHODCALLTYPE *IsScheduledPlaybackRunning )( + IDeckLinkOutput_v11_4 * This, + /* [out] */ BOOL *active); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v11_4, GetScheduledStreamTime) + HRESULT ( STDMETHODCALLTYPE *GetScheduledStreamTime )( + IDeckLinkOutput_v11_4 * This, + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *streamTime, + /* [out] */ double *playbackSpeed); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v11_4, GetReferenceStatus) + HRESULT ( STDMETHODCALLTYPE *GetReferenceStatus )( + IDeckLinkOutput_v11_4 * This, + /* [out] */ BMDReferenceStatus *referenceStatus); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v11_4, GetHardwareReferenceClock) + HRESULT ( STDMETHODCALLTYPE *GetHardwareReferenceClock )( + IDeckLinkOutput_v11_4 * This, + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *hardwareTime, + /* [out] */ BMDTimeValue *timeInFrame, + /* [out] */ BMDTimeValue *ticksPerFrame); + + DECLSPEC_XFGVIRT(IDeckLinkOutput_v11_4, GetFrameCompletionReferenceTimestamp) + HRESULT ( STDMETHODCALLTYPE *GetFrameCompletionReferenceTimestamp )( + IDeckLinkOutput_v11_4 * This, + /* [in] */ IDeckLinkVideoFrame_v14_2_1 *theFrame, + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *frameCompletionTimestamp); + + END_INTERFACE + } IDeckLinkOutput_v11_4Vtbl; + + interface IDeckLinkOutput_v11_4 + { + CONST_VTBL struct IDeckLinkOutput_v11_4Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkOutput_v11_4_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkOutput_v11_4_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkOutput_v11_4_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkOutput_v11_4_DoesSupportVideoMode(This,connection,requestedMode,requestedPixelFormat,flags,actualMode,supported) \ + ( (This)->lpVtbl -> DoesSupportVideoMode(This,connection,requestedMode,requestedPixelFormat,flags,actualMode,supported) ) + +#define IDeckLinkOutput_v11_4_GetDisplayMode(This,displayMode,resultDisplayMode) \ + ( (This)->lpVtbl -> GetDisplayMode(This,displayMode,resultDisplayMode) ) + +#define IDeckLinkOutput_v11_4_GetDisplayModeIterator(This,iterator) \ + ( (This)->lpVtbl -> GetDisplayModeIterator(This,iterator) ) + +#define IDeckLinkOutput_v11_4_SetScreenPreviewCallback(This,previewCallback) \ + ( (This)->lpVtbl -> SetScreenPreviewCallback(This,previewCallback) ) + +#define IDeckLinkOutput_v11_4_EnableVideoOutput(This,displayMode,flags) \ + ( (This)->lpVtbl -> EnableVideoOutput(This,displayMode,flags) ) + +#define IDeckLinkOutput_v11_4_DisableVideoOutput(This) \ + ( (This)->lpVtbl -> DisableVideoOutput(This) ) + +#define IDeckLinkOutput_v11_4_SetVideoOutputFrameMemoryAllocator(This,theAllocator) \ + ( (This)->lpVtbl -> SetVideoOutputFrameMemoryAllocator(This,theAllocator) ) + +#define IDeckLinkOutput_v11_4_CreateVideoFrame(This,width,height,rowBytes,pixelFormat,flags,outFrame) \ + ( (This)->lpVtbl -> CreateVideoFrame(This,width,height,rowBytes,pixelFormat,flags,outFrame) ) + +#define IDeckLinkOutput_v11_4_CreateAncillaryData(This,pixelFormat,outBuffer) \ + ( (This)->lpVtbl -> CreateAncillaryData(This,pixelFormat,outBuffer) ) + +#define IDeckLinkOutput_v11_4_DisplayVideoFrameSync(This,theFrame) \ + ( (This)->lpVtbl -> DisplayVideoFrameSync(This,theFrame) ) + +#define IDeckLinkOutput_v11_4_ScheduleVideoFrame(This,theFrame,displayTime,displayDuration,timeScale) \ + ( (This)->lpVtbl -> ScheduleVideoFrame(This,theFrame,displayTime,displayDuration,timeScale) ) + +#define IDeckLinkOutput_v11_4_SetScheduledFrameCompletionCallback(This,theCallback) \ + ( (This)->lpVtbl -> SetScheduledFrameCompletionCallback(This,theCallback) ) + +#define IDeckLinkOutput_v11_4_GetBufferedVideoFrameCount(This,bufferedFrameCount) \ + ( (This)->lpVtbl -> GetBufferedVideoFrameCount(This,bufferedFrameCount) ) + +#define IDeckLinkOutput_v11_4_EnableAudioOutput(This,sampleRate,sampleType,channelCount,streamType) \ + ( (This)->lpVtbl -> EnableAudioOutput(This,sampleRate,sampleType,channelCount,streamType) ) + +#define IDeckLinkOutput_v11_4_DisableAudioOutput(This) \ + ( (This)->lpVtbl -> DisableAudioOutput(This) ) + +#define IDeckLinkOutput_v11_4_WriteAudioSamplesSync(This,buffer,sampleFrameCount,sampleFramesWritten) \ + ( (This)->lpVtbl -> WriteAudioSamplesSync(This,buffer,sampleFrameCount,sampleFramesWritten) ) + +#define IDeckLinkOutput_v11_4_BeginAudioPreroll(This) \ + ( (This)->lpVtbl -> BeginAudioPreroll(This) ) + +#define IDeckLinkOutput_v11_4_EndAudioPreroll(This) \ + ( (This)->lpVtbl -> EndAudioPreroll(This) ) + +#define IDeckLinkOutput_v11_4_ScheduleAudioSamples(This,buffer,sampleFrameCount,streamTime,timeScale,sampleFramesWritten) \ + ( (This)->lpVtbl -> ScheduleAudioSamples(This,buffer,sampleFrameCount,streamTime,timeScale,sampleFramesWritten) ) + +#define IDeckLinkOutput_v11_4_GetBufferedAudioSampleFrameCount(This,bufferedSampleFrameCount) \ + ( (This)->lpVtbl -> GetBufferedAudioSampleFrameCount(This,bufferedSampleFrameCount) ) + +#define IDeckLinkOutput_v11_4_FlushBufferedAudioSamples(This) \ + ( (This)->lpVtbl -> FlushBufferedAudioSamples(This) ) + +#define IDeckLinkOutput_v11_4_SetAudioCallback(This,theCallback) \ + ( (This)->lpVtbl -> SetAudioCallback(This,theCallback) ) + +#define IDeckLinkOutput_v11_4_StartScheduledPlayback(This,playbackStartTime,timeScale,playbackSpeed) \ + ( (This)->lpVtbl -> StartScheduledPlayback(This,playbackStartTime,timeScale,playbackSpeed) ) + +#define IDeckLinkOutput_v11_4_StopScheduledPlayback(This,stopPlaybackAtTime,actualStopTime,timeScale) \ + ( (This)->lpVtbl -> StopScheduledPlayback(This,stopPlaybackAtTime,actualStopTime,timeScale) ) + +#define IDeckLinkOutput_v11_4_IsScheduledPlaybackRunning(This,active) \ + ( (This)->lpVtbl -> IsScheduledPlaybackRunning(This,active) ) + +#define IDeckLinkOutput_v11_4_GetScheduledStreamTime(This,desiredTimeScale,streamTime,playbackSpeed) \ + ( (This)->lpVtbl -> GetScheduledStreamTime(This,desiredTimeScale,streamTime,playbackSpeed) ) + +#define IDeckLinkOutput_v11_4_GetReferenceStatus(This,referenceStatus) \ + ( (This)->lpVtbl -> GetReferenceStatus(This,referenceStatus) ) + +#define IDeckLinkOutput_v11_4_GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) \ + ( (This)->lpVtbl -> GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) ) + +#define IDeckLinkOutput_v11_4_GetFrameCompletionReferenceTimestamp(This,theFrame,desiredTimeScale,frameCompletionTimestamp) \ + ( (This)->lpVtbl -> GetFrameCompletionReferenceTimestamp(This,theFrame,desiredTimeScale,frameCompletionTimestamp) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkOutput_v11_4_INTERFACE_DEFINED__ */ + + +#ifndef __IDeckLinkInput_v11_4_INTERFACE_DEFINED__ +#define __IDeckLinkInput_v11_4_INTERFACE_DEFINED__ + +/* interface IDeckLinkInput_v11_4 */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkInput_v11_4; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("2A88CF76-F494-4216-A7EF-DC74EEB83882") + IDeckLinkInput_v11_4 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE DoesSupportVideoMode( + /* [in] */ BMDVideoConnection connection, + /* [in] */ BMDDisplayMode requestedMode, + /* [in] */ BMDPixelFormat requestedPixelFormat, + /* [in] */ BMDSupportedVideoModeFlags flags, + /* [out] */ BOOL *supported) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayMode( + /* [in] */ BMDDisplayMode displayMode, + /* [out] */ IDeckLinkDisplayMode **resultDisplayMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayModeIterator( + /* [out] */ IDeckLinkDisplayModeIterator **iterator) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetScreenPreviewCallback( + /* [in] */ IDeckLinkScreenPreviewCallback_v14_2_1 *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_v14_2_1 *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_v11_5_1 *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_v11_4Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkInput_v11_4 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkInput_v11_4 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkInput_v11_4 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_4, DoesSupportVideoMode) + HRESULT ( STDMETHODCALLTYPE *DoesSupportVideoMode )( + IDeckLinkInput_v11_4 * This, + /* [in] */ BMDVideoConnection connection, + /* [in] */ BMDDisplayMode requestedMode, + /* [in] */ BMDPixelFormat requestedPixelFormat, + /* [in] */ BMDSupportedVideoModeFlags flags, + /* [out] */ BOOL *supported); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_4, GetDisplayMode) + HRESULT ( STDMETHODCALLTYPE *GetDisplayMode )( + IDeckLinkInput_v11_4 * This, + /* [in] */ BMDDisplayMode displayMode, + /* [out] */ IDeckLinkDisplayMode **resultDisplayMode); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_4, GetDisplayModeIterator) + HRESULT ( STDMETHODCALLTYPE *GetDisplayModeIterator )( + IDeckLinkInput_v11_4 * This, + /* [out] */ IDeckLinkDisplayModeIterator **iterator); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_4, SetScreenPreviewCallback) + HRESULT ( STDMETHODCALLTYPE *SetScreenPreviewCallback )( + IDeckLinkInput_v11_4 * This, + /* [in] */ IDeckLinkScreenPreviewCallback_v14_2_1 *previewCallback); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_4, EnableVideoInput) + HRESULT ( STDMETHODCALLTYPE *EnableVideoInput )( + IDeckLinkInput_v11_4 * This, + /* [in] */ BMDDisplayMode displayMode, + /* [in] */ BMDPixelFormat pixelFormat, + /* [in] */ BMDVideoInputFlags flags); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_4, DisableVideoInput) + HRESULT ( STDMETHODCALLTYPE *DisableVideoInput )( + IDeckLinkInput_v11_4 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_4, GetAvailableVideoFrameCount) + HRESULT ( STDMETHODCALLTYPE *GetAvailableVideoFrameCount )( + IDeckLinkInput_v11_4 * This, + /* [out] */ unsigned int *availableFrameCount); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_4, SetVideoInputFrameMemoryAllocator) + HRESULT ( STDMETHODCALLTYPE *SetVideoInputFrameMemoryAllocator )( + IDeckLinkInput_v11_4 * This, + /* [in] */ IDeckLinkMemoryAllocator_v14_2_1 *theAllocator); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_4, EnableAudioInput) + HRESULT ( STDMETHODCALLTYPE *EnableAudioInput )( + IDeckLinkInput_v11_4 * This, + /* [in] */ BMDAudioSampleRate sampleRate, + /* [in] */ BMDAudioSampleType sampleType, + /* [in] */ unsigned int channelCount); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_4, DisableAudioInput) + HRESULT ( STDMETHODCALLTYPE *DisableAudioInput )( + IDeckLinkInput_v11_4 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_4, GetAvailableAudioSampleFrameCount) + HRESULT ( STDMETHODCALLTYPE *GetAvailableAudioSampleFrameCount )( + IDeckLinkInput_v11_4 * This, + /* [out] */ unsigned int *availableSampleFrameCount); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_4, StartStreams) + HRESULT ( STDMETHODCALLTYPE *StartStreams )( + IDeckLinkInput_v11_4 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_4, StopStreams) + HRESULT ( STDMETHODCALLTYPE *StopStreams )( + IDeckLinkInput_v11_4 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_4, PauseStreams) + HRESULT ( STDMETHODCALLTYPE *PauseStreams )( + IDeckLinkInput_v11_4 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_4, FlushStreams) + HRESULT ( STDMETHODCALLTYPE *FlushStreams )( + IDeckLinkInput_v11_4 * This); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_4, SetCallback) + HRESULT ( STDMETHODCALLTYPE *SetCallback )( + IDeckLinkInput_v11_4 * This, + /* [in] */ IDeckLinkInputCallback_v11_5_1 *theCallback); + + DECLSPEC_XFGVIRT(IDeckLinkInput_v11_4, GetHardwareReferenceClock) + HRESULT ( STDMETHODCALLTYPE *GetHardwareReferenceClock )( + IDeckLinkInput_v11_4 * This, + /* [in] */ BMDTimeScale desiredTimeScale, + /* [out] */ BMDTimeValue *hardwareTime, + /* [out] */ BMDTimeValue *timeInFrame, + /* [out] */ BMDTimeValue *ticksPerFrame); + + END_INTERFACE + } IDeckLinkInput_v11_4Vtbl; + + interface IDeckLinkInput_v11_4 + { + CONST_VTBL struct IDeckLinkInput_v11_4Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkInput_v11_4_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkInput_v11_4_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkInput_v11_4_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkInput_v11_4_DoesSupportVideoMode(This,connection,requestedMode,requestedPixelFormat,flags,supported) \ + ( (This)->lpVtbl -> DoesSupportVideoMode(This,connection,requestedMode,requestedPixelFormat,flags,supported) ) + +#define IDeckLinkInput_v11_4_GetDisplayMode(This,displayMode,resultDisplayMode) \ + ( (This)->lpVtbl -> GetDisplayMode(This,displayMode,resultDisplayMode) ) + +#define IDeckLinkInput_v11_4_GetDisplayModeIterator(This,iterator) \ + ( (This)->lpVtbl -> GetDisplayModeIterator(This,iterator) ) + +#define IDeckLinkInput_v11_4_SetScreenPreviewCallback(This,previewCallback) \ + ( (This)->lpVtbl -> SetScreenPreviewCallback(This,previewCallback) ) + +#define IDeckLinkInput_v11_4_EnableVideoInput(This,displayMode,pixelFormat,flags) \ + ( (This)->lpVtbl -> EnableVideoInput(This,displayMode,pixelFormat,flags) ) + +#define IDeckLinkInput_v11_4_DisableVideoInput(This) \ + ( (This)->lpVtbl -> DisableVideoInput(This) ) + +#define IDeckLinkInput_v11_4_GetAvailableVideoFrameCount(This,availableFrameCount) \ + ( (This)->lpVtbl -> GetAvailableVideoFrameCount(This,availableFrameCount) ) + +#define IDeckLinkInput_v11_4_SetVideoInputFrameMemoryAllocator(This,theAllocator) \ + ( (This)->lpVtbl -> SetVideoInputFrameMemoryAllocator(This,theAllocator) ) + +#define IDeckLinkInput_v11_4_EnableAudioInput(This,sampleRate,sampleType,channelCount) \ + ( (This)->lpVtbl -> EnableAudioInput(This,sampleRate,sampleType,channelCount) ) + +#define IDeckLinkInput_v11_4_DisableAudioInput(This) \ + ( (This)->lpVtbl -> DisableAudioInput(This) ) + +#define IDeckLinkInput_v11_4_GetAvailableAudioSampleFrameCount(This,availableSampleFrameCount) \ + ( (This)->lpVtbl -> GetAvailableAudioSampleFrameCount(This,availableSampleFrameCount) ) + +#define IDeckLinkInput_v11_4_StartStreams(This) \ + ( (This)->lpVtbl -> StartStreams(This) ) + +#define IDeckLinkInput_v11_4_StopStreams(This) \ + ( (This)->lpVtbl -> StopStreams(This) ) + +#define IDeckLinkInput_v11_4_PauseStreams(This) \ + ( (This)->lpVtbl -> PauseStreams(This) ) + +#define IDeckLinkInput_v11_4_FlushStreams(This) \ + ( (This)->lpVtbl -> FlushStreams(This) ) + +#define IDeckLinkInput_v11_4_SetCallback(This,theCallback) \ + ( (This)->lpVtbl -> SetCallback(This,theCallback) ) + +#define IDeckLinkInput_v11_4_GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) \ + ( (This)->lpVtbl -> GetHardwareReferenceClock(This,desiredTimeScale,hardwareTime,timeInFrame,ticksPerFrame) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkInput_v11_4_INTERFACE_DEFINED__ */ + + +EXTERN_C const CLSID CLSID_CDeckLinkIterator_v10_8; + +#ifdef __cplusplus + +class DECLSPEC_UUID("1F2E109A-8F4F-49E4-9203-135595CB6FA5") +CDeckLinkIterator_v10_8; +#endif + +EXTERN_C const CLSID CLSID_CDeckLinkDiscovery_v10_8; + +#ifdef __cplusplus + +class DECLSPEC_UUID("1073A05C-D885-47E9-B3C6-129B3F9F648B") +CDeckLinkDiscovery_v10_8; +#endif + +#ifndef __IDeckLinkEncoderConfiguration_v10_5_INTERFACE_DEFINED__ +#define __IDeckLinkEncoderConfiguration_v10_5_INTERFACE_DEFINED__ + +/* interface IDeckLinkEncoderConfiguration_v10_5 */ +/* [helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDeckLinkEncoderConfiguration_v10_5; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("67455668-0848-45DF-8D8E-350A77C9A028") + IDeckLinkEncoderConfiguration_v10_5 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetFlag( + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [in] */ BOOL value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFlag( + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [out] */ BOOL *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetInt( + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [in] */ LONGLONG value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInt( + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [out] */ LONGLONG *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetFloat( + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [in] */ double value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFloat( + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [out] */ double *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetString( + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [in] */ BSTR value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetString( + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [out] */ BSTR *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDecoderConfigurationInfo( + /* [out] */ void *buffer, + /* [in] */ long bufferSize, + /* [out] */ long *returnedSize) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDeckLinkEncoderConfiguration_v10_5Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDeckLinkEncoderConfiguration_v10_5 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDeckLinkEncoderConfiguration_v10_5 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IDeckLinkEncoderConfiguration_v10_5 * This); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderConfiguration_v10_5, SetFlag) + HRESULT ( STDMETHODCALLTYPE *SetFlag )( + IDeckLinkEncoderConfiguration_v10_5 * This, + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [in] */ BOOL value); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderConfiguration_v10_5, GetFlag) + HRESULT ( STDMETHODCALLTYPE *GetFlag )( + IDeckLinkEncoderConfiguration_v10_5 * This, + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [out] */ BOOL *value); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderConfiguration_v10_5, SetInt) + HRESULT ( STDMETHODCALLTYPE *SetInt )( + IDeckLinkEncoderConfiguration_v10_5 * This, + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [in] */ LONGLONG value); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderConfiguration_v10_5, GetInt) + HRESULT ( STDMETHODCALLTYPE *GetInt )( + IDeckLinkEncoderConfiguration_v10_5 * This, + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [out] */ LONGLONG *value); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderConfiguration_v10_5, SetFloat) + HRESULT ( STDMETHODCALLTYPE *SetFloat )( + IDeckLinkEncoderConfiguration_v10_5 * This, + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [in] */ double value); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderConfiguration_v10_5, GetFloat) + HRESULT ( STDMETHODCALLTYPE *GetFloat )( + IDeckLinkEncoderConfiguration_v10_5 * This, + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [out] */ double *value); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderConfiguration_v10_5, SetString) + HRESULT ( STDMETHODCALLTYPE *SetString )( + IDeckLinkEncoderConfiguration_v10_5 * This, + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [in] */ BSTR value); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderConfiguration_v10_5, GetString) + HRESULT ( STDMETHODCALLTYPE *GetString )( + IDeckLinkEncoderConfiguration_v10_5 * This, + /* [in] */ BMDDeckLinkEncoderConfigurationID cfgID, + /* [out] */ BSTR *value); + + DECLSPEC_XFGVIRT(IDeckLinkEncoderConfiguration_v10_5, GetDecoderConfigurationInfo) + HRESULT ( STDMETHODCALLTYPE *GetDecoderConfigurationInfo )( + IDeckLinkEncoderConfiguration_v10_5 * This, + /* [out] */ void *buffer, + /* [in] */ long bufferSize, + /* [out] */ long *returnedSize); + + END_INTERFACE + } IDeckLinkEncoderConfiguration_v10_5Vtbl; + + interface IDeckLinkEncoderConfiguration_v10_5 + { + CONST_VTBL struct IDeckLinkEncoderConfiguration_v10_5Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDeckLinkEncoderConfiguration_v10_5_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDeckLinkEncoderConfiguration_v10_5_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDeckLinkEncoderConfiguration_v10_5_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDeckLinkEncoderConfiguration_v10_5_SetFlag(This,cfgID,value) \ + ( (This)->lpVtbl -> SetFlag(This,cfgID,value) ) + +#define IDeckLinkEncoderConfiguration_v10_5_GetFlag(This,cfgID,value) \ + ( (This)->lpVtbl -> GetFlag(This,cfgID,value) ) + +#define IDeckLinkEncoderConfiguration_v10_5_SetInt(This,cfgID,value) \ + ( (This)->lpVtbl -> SetInt(This,cfgID,value) ) + +#define IDeckLinkEncoderConfiguration_v10_5_GetInt(This,cfgID,value) \ + ( (This)->lpVtbl -> GetInt(This,cfgID,value) ) + +#define IDeckLinkEncoderConfiguration_v10_5_SetFloat(This,cfgID,value) \ + ( (This)->lpVtbl -> SetFloat(This,cfgID,value) ) + +#define IDeckLinkEncoderConfiguration_v10_5_GetFloat(This,cfgID,value) \ + ( (This)->lpVtbl -> GetFloat(This,cfgID,value) ) + +#define IDeckLinkEncoderConfiguration_v10_5_SetString(This,cfgID,value) \ + ( (This)->lpVtbl -> SetString(This,cfgID,value) ) + +#define IDeckLinkEncoderConfiguration_v10_5_GetString(This,cfgID,value) \ + ( (This)->lpVtbl -> GetString(This,cfgID,value) ) + +#define IDeckLinkEncoderConfiguration_v10_5_GetDecoderConfigurationInfo(This,buffer,bufferSize,returnedSize) \ + ( (This)->lpVtbl -> GetDecoderConfigurationInfo(This,buffer,bufferSize,returnedSize) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDeckLinkEncoderConfiguration_v10_5_INTERFACE_DEFINED__ */ + +#endif /* __DeckLinkAPI_LIBRARY_DEFINED__ */ + +/* Additional Prototypes for ALL interfaces */ + +/* end of Additional Prototypes */ + +#ifdef __cplusplus +} +#endif + +#endif + + diff --git a/src/video/DeckLinkAPI_i.c b/src/video/DeckLinkAPI_i.c new file mode 100644 index 0000000..df3177a --- /dev/null +++ b/src/video/DeckLinkAPI_i.c @@ -0,0 +1,486 @@ + + +/* 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.01.0628 */ +/* at Tue Jan 19 14:14:07 2038 + */ +/* Compiler settings for ..\..\3rdParty\Blackmagic DeckLink SDK 16.0\Win\include\DeckLinkAPI.idl: + Oicf, W1, Zp8, env=Win64 (32b run), target_arch=AMD64 8.01.0628 + protocol : all , 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( ) */ + + + +#ifdef __cplusplus +extern "C"{ +#endif + + +#include +#include + +#ifdef _MIDL_USE_GUIDDEF_ + +#ifndef INITGUID +#define INITGUID +#include +#undef INITGUID +#else +#include +#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) \ + EXTERN_C __declspec(selectany) 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,0x5a68ffd4,0x1c12,0x4ede,0xa6,0xd2,0x45,0x45,0x1d,0x38,0x5f,0xc1); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkEncoderConfiguration,0x138050E5,0xC60A,0x4552,0xBF,0x3F,0x0F,0x35,0x80,0x49,0x32,0x7E); + + +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,0x23A4EDF5,0xA0E5,0x432C,0x94,0xEF,0x3B,0xAB,0xB5,0xF8,0x1C,0x82); + + +MIDL_DEFINE_GUID(CLSID, CLSID_CBMDStreamingH264NALParser,0x7753EFBD,0x951C,0x407C,0x97,0xA5,0x23,0xC7,0x37,0xB7,0x3B,0x52); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoOutputCallback,0x5BE6DF26,0x02CE,0x433E,0x99,0xD9,0x9A,0x87,0xC3,0xAC,0x17,0x1F); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkInputCallback,0x3A94F075,0xC37D,0x4BA8,0xBC,0xC0,0x1D,0x77,0x8C,0x8F,0x88,0x1B); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkEncoderInputCallback,0xACF13E61,0xF4A0,0x4974,0xA6,0xA7,0x59,0xAF,0xF6,0x26,0x8B,0x31); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoBufferAllocator,0xF35DFA8D,0x9078,0x4622,0x95,0xBB,0x56,0x89,0x40,0x54,0xEB,0x0F); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoBufferAllocatorProvider,0x6DF6F20A,0xD8DF,0x45D2,0x89,0x14,0x38,0x3C,0xE7,0xE6,0x24,0x3F); + + +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_IDeckLinkIPFlowAttributes,0xCDA938DA,0x6479,0x40C6,0xB2,0xEC,0xA3,0x57,0x9B,0x3A,0xEE,0xCD); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkIPFlowStatus,0x31C41656,0x4992,0x4396,0xBB,0xE9,0x5F,0x84,0x06,0xAA,0xB5,0xAF); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkIPFlowSetting,0x86DD9174,0x27D3,0x4032,0xB2,0xAD,0x60,0x67,0xC3,0xBB,0x24,0x24); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkIPFlow,0xC5FC83C7,0x5B8E,0x42A7,0x9A,0x40,0x7C,0x06,0x59,0x55,0xD4,0xE1); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkIPFlowIterator,0xBD296AB2,0xA5C5,0x4153,0x88,0x8F,0xAA,0xB1,0xFD,0xBD,0x8A,0x5C); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkOutput,0x5F227C95,0x39D7,0x46C7,0x8B,0x7D,0x9C,0x81,0x79,0x5F,0xBB,0xE4); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkInput,0x6A515F8A,0xFBCE,0x4853,0xB0,0xF7,0x2A,0x09,0xDB,0x1E,0xCA,0x0B); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkIPExtensions,0x46CF7903,0xA9FD,0x4D0B,0x8F,0xFC,0x01,0x03,0x72,0x2A,0xB4,0x42); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkHDMIInputEDID,0xABBBACBC,0x45BC,0x4665,0x9D,0x92,0xAC,0xE6,0xE5,0xA9,0x79,0x02); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkEncoderInput,0x46C1332E,0x6FD9,0x472A,0x85,0x91,0xFE,0x59,0xC2,0x21,0x92,0xE1); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoBuffer,0x81F03D70,0xDE13,0x4B17,0x87,0x3A,0xC8,0xAC,0x96,0x89,0xC6,0x82); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoFrame,0x6502091C,0x615F,0x4F51,0xBA,0xF6,0x45,0xC4,0x25,0x6D,0xD5,0xB0); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkMutableVideoFrame,0xCF9EB134,0x0374,0x4C5B,0x95,0xFA,0x1E,0xC1,0x48,0x19,0xFF,0x62); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoFrame3DExtensions,0xD4DBE9C6,0xB4D2,0x49D3,0xAB,0xF2,0xB4,0xE8,0x6C,0x73,0x91,0xB0); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoFrameMetadataExtensions,0xE232A5B7,0x4DB4,0x44C9,0x91,0x52,0xF4,0x7C,0x12,0xE5,0xF0,0x51); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoFrameMutableMetadataExtensions,0xCC198FC6,0x8298,0x4419,0x94,0x2D,0x83,0x57,0xEC,0x35,0x5E,0x58); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoInputFrame,0xC9ADD3D2,0xBE52,0x488D,0xAB,0x2D,0x7F,0xDE,0xF7,0xAF,0x0C,0x95); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkAncillaryPacket,0xF5C0D498,0x5CD3,0x4C77,0x97,0x73,0x8E,0xFA,0x20,0xBB,0x33,0x4B); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkAncillaryPacketIterator,0x10F1AA88,0x54BE,0x42F7,0xB9,0xF8,0xEC,0x2F,0x5F,0x09,0x95,0x51); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoFrameAncillaryPackets,0x8A72D630,0x8070,0x4D05,0x8A,0x93,0xE6,0x0C,0x40,0xEE,0x08,0x8A); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoFrameAncillary,0x732E723C,0xD1A4,0x4E29,0x9E,0x8E,0x4A,0x88,0x79,0x7A,0x00,0x04); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkEncoderPacket,0xB693F36C,0x316E,0x4AF1,0xB6,0xC2,0xF3,0x89,0xA4,0xBC,0xA6,0x20); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkEncoderVideoPacket,0x4E7FD944,0xE8C7,0x4EAC,0xB8,0xC0,0x7B,0x77,0xF8,0x0F,0x5A,0xE0); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkEncoderAudioPacket,0x49E8EDC8,0x693B,0x4E14,0x8E,0xF6,0x12,0xC6,0x58,0xF5,0xA0,0x7A); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkH265NALPacket,0x639C8E0B,0x68D5,0x4BDE,0xA6,0xD4,0x95,0xF3,0xAE,0xAF,0xF2,0xE7); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkAudioInputPacket,0xE43D5870,0x2894,0x11DE,0x8C,0x30,0x08,0x00,0x20,0x0C,0x9A,0x66); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkScreenPreviewCallback,0xD4FA2345,0x9FBA,0x4497,0x95,0xC3,0xC0,0xC3,0xCE,0xD3,0xCD,0xA8); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkGLScreenPreviewHelper,0xCEB778E2,0xC202,0x4EC8,0x90,0x85,0x0C,0xD2,0x85,0xCC,0x55,0x22); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkDX9ScreenPreviewHelper,0xF2DD78CA,0x2921,0x4AC2,0xB5,0xBC,0xBF,0xDC,0xC2,0x03,0x5A,0x1F); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkWPFDX9ScreenPreviewHelper,0xC59346CD,0x9326,0x4266,0xAC,0x2D,0x5C,0x19,0x0F,0x57,0x99,0xEE); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkNotificationCallback,0xb002a1ec,0x070d,0x4288,0x82,0x89,0xbd,0x5d,0x36,0xe5,0xff,0x0d); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkNotification,0x1d70faac,0xfd27,0x4866,0x9d,0xe6,0x09,0x39,0xd1,0xe4,0xc7,0xf1); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkProfileAttributes,0xF47551D7,0xAD22,0x47AF,0xBC,0xFD,0x6B,0xE8,0x8A,0xA8,0x79,0xD9); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkProfileIterator,0x29E5A8C0,0x8BE4,0x46EB,0x93,0xAC,0x31,0xDA,0xAB,0x5B,0x7B,0xF2); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkProfile,0x16093466,0x674A,0x432B,0x9D,0xA0,0x1A,0xC2,0xC5,0xA8,0x24,0x1C); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkProfileCallback,0xA4F9341E,0x97AA,0x4E04,0x89,0x35,0x15,0xF8,0x09,0x89,0x8C,0xEA); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkProfileManager,0x30D41429,0x3998,0x4B6D,0x84,0xF8,0x78,0xC9,0x4A,0x79,0x7C,0x6E); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkStatistics,0x21CB2ED1,0x4429,0x42BE,0xAA,0xF3,0x22,0xA3,0xB1,0xDD,0x3A,0xE0); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkStatus,0x2A04A635,0xED42,0x41EF,0x93,0x42,0x0E,0x11,0xF8,0xCF,0x6B,0x5E); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkKeyer,0x89AFCAF5,0x65F8,0x421E,0x98,0xF7,0x96,0xFE,0x5F,0x5B,0xFB,0xA3); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoConversion,0x94C536D6,0xC821,0x42F5,0xA6,0x00,0xC6,0x66,0x29,0x95,0x51,0x01); + + +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,0xBA6C6F44,0x6DA5,0x4DCE,0x94,0xAA,0xEE,0x2D,0x13,0x72,0xA6,0x76); + + +MIDL_DEFINE_GUID(CLSID, CLSID_CDeckLinkAPIInformation,0x263CA19F,0xED09,0x482E,0x9F,0x9D,0x84,0x00,0x57,0x83,0xA2,0x37); + + +MIDL_DEFINE_GUID(CLSID, CLSID_CDeckLinkGLScreenPreviewHelper,0x1E332DAE,0x0D04,0x49EB,0xB8,0xA1,0xB6,0xE0,0x0B,0x2B,0x6B,0xD0); + + +MIDL_DEFINE_GUID(CLSID, CLSID_CDeckLinkGL3ScreenPreviewHelper,0x166804E4,0x15EF,0x4BFD,0xB6,0x23,0xB5,0xBA,0x92,0x16,0x67,0xC5); + + +MIDL_DEFINE_GUID(CLSID, CLSID_CDeckLinkDX9ScreenPreviewHelper,0x0EB111ED,0xADA6,0x43A6,0x8B,0x16,0xCA,0x5D,0x27,0xEE,0xA1,0x5E); + + +MIDL_DEFINE_GUID(CLSID, CLSID_CDeckLinkWPFDX9ScreenPreviewHelper,0x5E64496D,0x4BB2,0x45D5,0x9B,0x63,0xBF,0x1B,0x46,0x3B,0x18,0xAF); + + +MIDL_DEFINE_GUID(CLSID, CLSID_CDeckLinkVideoConversion,0x771AD62D,0x671F,0x4442,0xAC,0x90,0xB0,0x70,0xC5,0x41,0x09,0x0A); + + +MIDL_DEFINE_GUID(CLSID, CLSID_CDeckLinkDiscovery,0x22FBFC33,0x8D07,0x495C,0xA5,0xBF,0xDA,0xB5,0xEA,0x9B,0x82,0xDB); + + +MIDL_DEFINE_GUID(CLSID, CLSID_CDeckLinkVideoFrameAncillaryPackets,0x6F47097E,0xB390,0x4650,0xBC,0xB6,0xC4,0xD5,0x2F,0xAA,0x16,0x43); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkStatus_v15_3_1,0x5F558200,0x4028,0x49BC,0xBE,0xAC,0xDB,0x3F,0xA4,0xA9,0x6E,0x46); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkConfiguration_v15_3_1,0x912F634B,0x2D4E,0x40A4,0x8A,0xAB,0x8D,0x80,0xB7,0x3F,0x12,0x89); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoBuffer_v15_3_1,0xCCB4B64A,0x5C86,0x4E02,0xB7,0x78,0x88,0x5D,0x35,0x27,0x09,0xFE); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoBufferAllocator_v15_3_1,0x3481A4DF,0x2B11,0x4E55,0xAC,0x61,0x83,0x6B,0x87,0x98,0x5E,0x9A); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoBufferAllocatorProvider_v15_3_1,0x08B80403,0xBFF2,0x49D0,0xB4,0x48,0x8C,0x90,0x8B,0x9E,0x9F,0xC9); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkInput_v15_3_1,0x4095DB82,0xE294,0x4B8C,0xAA,0xA8,0x3B,0x9E,0x80,0xC4,0x93,0x36); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkOutput_v15_3_1,0x1A8077F1,0x9FE2,0x4533,0x81,0x47,0x22,0x94,0x30,0x5E,0x25,0x3F); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoConversion_v15_3_1,0xA48755D9,0x8BD5,0x4727,0xA1,0xE9,0x06,0x9F,0xDE,0xDB,0xA6,0xE9); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkNotification_v15_3_1,0xB85DF4C8,0xBDF5,0x47C1,0x80,0x64,0x28,0x16,0x2E,0xBD,0xD4,0xEB); + + +MIDL_DEFINE_GUID(CLSID, CLSID_CDeckLinkVideoConversion_v15_3_1,0x89BA47BD,0x1FE2,0x4D76,0x9B,0xFE,0xDE,0x85,0x04,0x9C,0x49,0x87); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkProfileAttributes_v15_3_1,0x17D4BF8E,0x4911,0x473A,0x80,0xA0,0x73,0x1C,0xF6,0xFF,0x34,0x5B); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoOutputCallback_v14_2_1,0x20AA5225,0x1958,0x47CB,0x82,0x0B,0x80,0xA8,0xD5,0x21,0xA6,0xEE); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkInputCallback_v14_2_1,0xC6FCE4C9,0xC4E4,0x4047,0x82,0xFB,0x5D,0x23,0x82,0x32,0xA9,0x02); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkMemoryAllocator_v14_2_1,0xB36EB6E7,0x9D29,0x4AA8,0x92,0xEF,0x84,0x3B,0x87,0xA2,0x89,0xE8); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkOutput_v14_2_1,0xBE2D9020,0x461E,0x442F,0x84,0xB7,0xE9,0x49,0xCB,0x95,0x3B,0x9D); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkInput_v14_2_1,0xC21CDB6E,0xF414,0x46E4,0xA6,0x36,0x80,0xA5,0x66,0xE0,0xED,0x37); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkEncoderInput_v14_2_1,0xF222551D,0x13DF,0x4FD8,0xB5,0x87,0x9D,0x4F,0x19,0xEC,0x12,0xC9); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoFrame_v14_2_1,0x3F716FE0,0xF023,0x4111,0xBE,0x5D,0xEF,0x44,0x14,0xC0,0x5B,0x17); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkMutableVideoFrame_v14_2_1,0x69E2639F,0x40DA,0x4E19,0xB6,0xF2,0x20,0xAC,0xE8,0x15,0xC3,0x90); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoFrame3DExtensions_v14_2_1,0xDA0F7E4A,0xEDC7,0x48A8,0x9C,0xDD,0x2D,0xB5,0x1C,0x72,0x9C,0xD7); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoInputFrame_v14_2_1,0x05CFE374,0x537C,0x4094,0x9A,0x57,0x68,0x05,0x25,0x11,0x8F,0x44); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkScreenPreviewCallback_v14_2_1,0xB1D3F49A,0x85FE,0x4C5D,0x95,0xC8,0x0B,0x5D,0x5D,0xCC,0xD4,0x38); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkGLScreenPreviewHelper_v14_2_1,0x504E2209,0xCAC7,0x4C1A,0x9F,0xB4,0xC5,0xBB,0x62,0x74,0xD2,0x2F); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkDX9ScreenPreviewHelper_v14_2_1,0x2094B522,0xD1A1,0x40C0,0x9A,0xC7,0x1C,0x01,0x22,0x18,0xEF,0x02); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1,0xAD8EC84A,0x7DDE,0x11E9,0x8F,0x9E,0x2A,0x86,0xE4,0x08,0x5A,0x59); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoConversion_v14_2_1,0x3BBCB8A2,0xDA2C,0x42D9,0xB5,0xD8,0x88,0x08,0x36,0x44,0xE9,0x9A); + + +MIDL_DEFINE_GUID(CLSID, CLSID_CDeckLinkGLScreenPreviewHelper_v14_2_1,0xF63E77C7,0xB655,0x4A4A,0x9A,0xD0,0x3C,0xA8,0x5D,0x39,0x43,0x43); + + +MIDL_DEFINE_GUID(CLSID, CLSID_CDeckLinkGL3ScreenPreviewHelper_v14_2_1,0x00696A71,0xEBC7,0x491F,0xAC,0x02,0x18,0xD3,0x39,0x3F,0x33,0xF0); + + +MIDL_DEFINE_GUID(CLSID, CLSID_CDeckLinkDX9ScreenPreviewHelper_v14_2_1,0xCC010023,0xE01D,0x4525,0x9D,0x59,0x80,0xC8,0xAB,0x3D,0xC7,0xA0); + + +MIDL_DEFINE_GUID(CLSID, CLSID_CDeckLinkWPFDX9ScreenPreviewHelper_v14_2_1,0xEF2A8478,0x7DDF,0x11E9,0x8F,0x9E,0x2A,0x86,0xE4,0x08,0x5A,0x59); + + +MIDL_DEFINE_GUID(CLSID, CLSID_CDeckLinkVideoConversion_v14_2_1,0x7DBBBB11,0x5B7B,0x467D,0xAE,0xA4,0xCE,0xA4,0x68,0xFD,0x36,0x8C); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkInputCallback_v11_5_1,0xDD04E5EC,0x7415,0x42AB,0xAE,0x4A,0xE8,0x0C,0x4D,0xFC,0x04,0x4A); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkInput_v11_5_1,0x9434C6E4,0xB15D,0x4B1C,0x97,0x9E,0x66,0x1E,0x3D,0xDC,0xB4,0xB9); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkConfiguration_v10_11,0xEF90380B,0x4AE5,0x4346,0x90,0x77,0xE2,0x88,0xE1,0x49,0xF1,0x29); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkAttributes_v10_11,0xABC11843,0xD966,0x44CB,0x96,0xE2,0xA1,0xCB,0x5D,0x31,0x35,0xC4); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkNotification_v10_11,0x0A1FB207,0xE215,0x441B,0x9B,0x19,0x6F,0xA1,0x57,0x59,0x46,0xC5); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkOutput_v10_11,0xCC5C8A6E,0x3F2F,0x4B3A,0x87,0xEA,0xFD,0x78,0xAF,0x30,0x05,0x64); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkInput_v10_11,0xAF22762B,0xDFAC,0x4846,0xAA,0x79,0xFA,0x88,0x83,0x56,0x09,0x95); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkEncoderInput_v10_11,0x270587DA,0x6B7D,0x42E7,0xA1,0xF0,0x6D,0x85,0x3F,0x58,0x11,0x85); + + +MIDL_DEFINE_GUID(CLSID, CLSID_CDeckLinkIterator_v10_11,0x87D2693F,0x8D4A,0x45C7,0xB4,0x3F,0x10,0xAC,0xBA,0x25,0xE6,0x8F); + + +MIDL_DEFINE_GUID(CLSID, CLSID_CDeckLinkDiscovery_v10_11,0x652615D4,0x26CD,0x4514,0xB1,0x61,0x2F,0xD5,0x07,0x2E,0xD0,0x08); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkConfiguration_v10_9,0xCB71734A,0xFE37,0x4E8D,0x8E,0x13,0x80,0x21,0x33,0xA1,0xC3,0xF2); + + +MIDL_DEFINE_GUID(CLSID, CLSID_CBMDStreamingDiscovery_v10_8,0x0CAA31F6,0x8A26,0x40B0,0x86,0xA4,0xBF,0x58,0xDC,0xCA,0x71,0x0C); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkConfiguration_v10_4,0x1E69FCF6,0x4203,0x4936,0x80,0x76,0x2A,0x9F,0x4C,0xFD,0x50,0xCB); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkConfiguration_v10_2,0xC679A35B,0x610C,0x4D09,0xB7,0x48,0x1D,0x04,0x78,0x10,0x0F,0xC0); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkAncillaryPacket_v15_2,0xCC5BBF7E,0x029C,0x4D3B,0x91,0x58,0x60,0x00,0xEF,0x5E,0x36,0x70); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkAncillaryPacketIterator_v15_2,0x3FC8994B,0x88FB,0x4C17,0x96,0x8F,0x9A,0xAB,0x69,0xD9,0x64,0xA7); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoFrameAncillaryPackets_v15_2,0x6C186C0F,0x459E,0x41D8,0xAE,0xE2,0x48,0x12,0xD8,0x1A,0xEE,0x68); + + +MIDL_DEFINE_GUID(CLSID, CLSID_CDeckLinkVideoFrameAncillaryPackets_v15_2,0xF891AD29,0xD0C2,0x46E9,0xA9,0x26,0x4E,0x2D,0x0D,0xD8,0xCF,0xAD); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkVideoFrameMetadataExtensions_v11_5,0xD5973DC9,0x6432,0x46D0,0x8F,0x0B,0x24,0x96,0xF8,0xA1,0x23,0x8F); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkOutput_v11_4,0x065A0F6C,0xC508,0x4D0D,0xB9,0x19,0xF5,0xEB,0x0E,0xBF,0xC9,0x6B); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkInput_v11_4,0x2A88CF76,0xF494,0x4216,0xA7,0xEF,0xDC,0x74,0xEE,0xB8,0x38,0x82); + + +MIDL_DEFINE_GUID(CLSID, CLSID_CDeckLinkIterator_v10_8,0x1F2E109A,0x8F4F,0x49E4,0x92,0x03,0x13,0x55,0x95,0xCB,0x6F,0xA5); + + +MIDL_DEFINE_GUID(CLSID, CLSID_CDeckLinkDiscovery_v10_8,0x1073A05C,0xD885,0x47E9,0xB3,0xC6,0x12,0x9B,0x3F,0x9F,0x64,0x8B); + + +MIDL_DEFINE_GUID(IID, IID_IDeckLinkEncoderConfiguration_v10_5,0x67455668,0x0848,0x45DF,0x8D,0x8E,0x35,0x0A,0x77,0xC9,0xA0,0x28); + +#undef MIDL_DEFINE_GUID + +#ifdef __cplusplus +} +#endif + + + diff --git a/src/video/DeckLinkDisplayMode.cpp b/src/video/DeckLinkDisplayMode.cpp new file mode 100644 index 0000000..85bf5ea --- /dev/null +++ b/src/video/DeckLinkDisplayMode.cpp @@ -0,0 +1,146 @@ +#include "DeckLinkDisplayMode.h" + +#include + +std::string NormalizeModeToken(const std::string& value) +{ + std::string normalized; + for (unsigned char ch : value) + { + if (std::isalnum(ch)) + normalized.push_back(static_cast(std::tolower(ch))); + } + return normalized; +} + +bool ResolveConfiguredDisplayMode(const std::string& videoFormat, const std::string& frameRate, BMDDisplayMode& displayMode, std::string& displayModeName) +{ + VideoFormat videoMode; + if (!ResolveConfiguredVideoFormat(videoFormat, frameRate, videoMode)) + return false; + + displayMode = videoMode.displayMode; + displayModeName = videoMode.displayName; + return true; +} + +bool ResolveConfiguredVideoFormat(const std::string& videoFormat, const std::string& frameRate, VideoFormat& videoMode) +{ + const std::string formatToken = NormalizeModeToken(videoFormat); + const std::string frameToken = NormalizeModeToken(frameRate); + const std::string combinedToken = formatToken + frameToken; + + struct ModeOption + { + const char* token; + BMDDisplayMode mode; + const char* displayName; + }; + + static const ModeOption options[] = + { + { "720p50", bmdModeHD720p50, "720p50" }, + { "hd720p50", bmdModeHD720p50, "720p50" }, + { "720p5994", bmdModeHD720p5994, "720p59.94" }, + { "hd720p5994", bmdModeHD720p5994, "720p59.94" }, + { "720p60", bmdModeHD720p60, "720p60" }, + { "hd720p60", bmdModeHD720p60, "720p60" }, + { "1080i50", bmdModeHD1080i50, "1080i50" }, + { "hd1080i50", bmdModeHD1080i50, "1080i50" }, + { "1080i5994", bmdModeHD1080i5994, "1080i59.94" }, + { "hd1080i5994", bmdModeHD1080i5994, "1080i59.94" }, + { "1080i60", bmdModeHD1080i6000, "1080i60" }, + { "hd1080i60", bmdModeHD1080i6000, "1080i60" }, + { "1080p2398", bmdModeHD1080p2398, "1080p23.98" }, + { "hd1080p2398", bmdModeHD1080p2398, "1080p23.98" }, + { "1080p24", bmdModeHD1080p24, "1080p24" }, + { "hd1080p24", bmdModeHD1080p24, "1080p24" }, + { "1080p25", bmdModeHD1080p25, "1080p25" }, + { "hd1080p25", bmdModeHD1080p25, "1080p25" }, + { "1080p2997", bmdModeHD1080p2997, "1080p29.97" }, + { "hd1080p2997", bmdModeHD1080p2997, "1080p29.97" }, + { "1080p30", bmdModeHD1080p30, "1080p30" }, + { "hd1080p30", bmdModeHD1080p30, "1080p30" }, + { "1080p50", bmdModeHD1080p50, "1080p50" }, + { "hd1080p50", bmdModeHD1080p50, "1080p50" }, + { "1080p5994", bmdModeHD1080p5994, "1080p59.94" }, + { "hd1080p5994", bmdModeHD1080p5994, "1080p59.94" }, + { "1080p60", bmdModeHD1080p6000, "1080p60" }, + { "hd1080p60", bmdModeHD1080p6000, "1080p60" }, + { "2160p2398", bmdMode4K2160p2398, "2160p23.98" }, + { "4k2160p2398", bmdMode4K2160p2398, "2160p23.98" }, + { "2160p24", bmdMode4K2160p24, "2160p24" }, + { "4k2160p24", bmdMode4K2160p24, "2160p24" }, + { "2160p25", bmdMode4K2160p25, "2160p25" }, + { "4k2160p25", bmdMode4K2160p25, "2160p25" }, + { "2160p2997", bmdMode4K2160p2997, "2160p29.97" }, + { "4k2160p2997", bmdMode4K2160p2997, "2160p29.97" }, + { "2160p30", bmdMode4K2160p30, "2160p30" }, + { "4k2160p30", bmdMode4K2160p30, "2160p30" }, + { "2160p50", bmdMode4K2160p50, "2160p50" }, + { "4k2160p50", bmdMode4K2160p50, "2160p50" }, + { "2160p5994", bmdMode4K2160p5994, "2160p59.94" }, + { "4k2160p5994", bmdMode4K2160p5994, "2160p59.94" }, + { "2160p60", bmdMode4K2160p60, "2160p60" }, + { "4k2160p60", bmdMode4K2160p60, "2160p60" } + }; + + for (const ModeOption& option : options) + { + if (combinedToken == option.token || (frameToken.empty() && formatToken == option.token)) + { + videoMode.displayMode = option.mode; + videoMode.displayName = option.displayName; + return true; + } + } + + return false; +} + +bool ResolveConfiguredVideoFormats( + const std::string& inputVideoFormat, + const std::string& inputFrameRate, + const std::string& outputVideoFormat, + const std::string& outputFrameRate, + VideoFormatSelection& videoModes, + std::string& error) +{ + if (!ResolveConfiguredVideoFormat(inputVideoFormat, inputFrameRate, videoModes.input)) + { + error = "Unsupported DeckLink inputVideoFormat/inputFrameRate in config/runtime-host.json: " + + inputVideoFormat + " / " + inputFrameRate; + return false; + } + + if (!ResolveConfiguredVideoFormat(outputVideoFormat, outputFrameRate, videoModes.output)) + { + error = "Unsupported DeckLink outputVideoFormat/outputFrameRate in config/runtime-host.json: " + + outputVideoFormat + " / " + outputFrameRate; + return false; + } + + return true; +} + +bool FindDeckLinkDisplayMode(IDeckLinkDisplayModeIterator* iterator, BMDDisplayMode targetMode, IDeckLinkDisplayMode** foundMode) +{ + if (!iterator || !foundMode) + return false; + + *foundMode = NULL; + IDeckLinkDisplayMode* candidate = NULL; + while (iterator->Next(&candidate) == S_OK) + { + if (candidate->GetDisplayMode() == targetMode) + { + *foundMode = candidate; + return true; + } + + candidate->Release(); + candidate = NULL; + } + + return false; +} diff --git a/src/video/DeckLinkDisplayMode.h b/src/video/DeckLinkDisplayMode.h new file mode 100644 index 0000000..3be24fd --- /dev/null +++ b/src/video/DeckLinkDisplayMode.h @@ -0,0 +1,47 @@ +#pragma once + +#include "DeckLinkAPI_h.h" + +#include + +struct FrameSize +{ + unsigned width = 0; + unsigned height = 0; + + bool IsEmpty() const { return width == 0 || height == 0; } +}; + +inline bool operator==(const FrameSize& left, const FrameSize& right) +{ + return left.width == right.width && left.height == right.height; +} + +inline bool operator!=(const FrameSize& left, const FrameSize& right) +{ + return !(left == right); +} + +struct VideoFormat +{ + BMDDisplayMode displayMode = bmdModeHD1080p5994; + std::string displayName = "1080p59.94"; +}; + +struct VideoFormatSelection +{ + VideoFormat input; + VideoFormat output; +}; + +std::string NormalizeModeToken(const std::string& value); +bool ResolveConfiguredDisplayMode(const std::string& videoFormat, const std::string& frameRate, BMDDisplayMode& displayMode, std::string& displayModeName); +bool ResolveConfiguredVideoFormat(const std::string& videoFormat, const std::string& frameRate, VideoFormat& videoMode); +bool ResolveConfiguredVideoFormats( + const std::string& inputVideoFormat, + const std::string& inputFrameRate, + const std::string& outputVideoFormat, + const std::string& outputFrameRate, + VideoFormatSelection& videoModes, + std::string& error); +bool FindDeckLinkDisplayMode(IDeckLinkDisplayModeIterator* iterator, BMDDisplayMode targetMode, IDeckLinkDisplayMode** foundMode); diff --git a/src/video/DeckLinkFrameTransfer.cpp b/src/video/DeckLinkFrameTransfer.cpp new file mode 100644 index 0000000..d293c01 --- /dev/null +++ b/src/video/DeckLinkFrameTransfer.cpp @@ -0,0 +1,100 @@ +#include "DeckLinkFrameTransfer.h" + +#include "DeckLinkSession.h" + +//////////////////////////////////////////// +// DeckLink Capture Delegate Class +//////////////////////////////////////////// +CaptureDelegate::CaptureDelegate(DeckLinkSession* pOwner) : + m_pOwner(pOwner), + mRefCount(1) +{ +} + +HRESULT CaptureDelegate::QueryInterface(REFIID, LPVOID* ppv) +{ + *ppv = NULL; + return E_NOINTERFACE; +} + +ULONG CaptureDelegate::AddRef() +{ + return InterlockedIncrement(&mRefCount); +} + +ULONG CaptureDelegate::Release() +{ + int newCount = InterlockedDecrement(&mRefCount); + if (newCount == 0) + delete this; + return newCount; +} + +HRESULT CaptureDelegate::VideoInputFrameArrived(IDeckLinkVideoInputFrame* inputFrame, IDeckLinkAudioInputPacket*) +{ + if (!inputFrame) + { + // It's possible to receive a NULL inputFrame, but a valid audioPacket. Ignore audio-only frame. + return S_OK; + } + + bool hasNoInputSource = (inputFrame->GetFlags() & bmdFrameHasNoInputSource) == bmdFrameHasNoInputSource; + m_pOwner->HandleVideoInputFrame(inputFrame, hasNoInputSource); + return S_OK; +} + +HRESULT CaptureDelegate::VideoInputFormatChanged(BMDVideoInputFormatChangedEvents, IDeckLinkDisplayMode*, BMDDetectedVideoInputFormatFlags) +{ + return S_OK; +} + +//////////////////////////////////////////// +// DeckLink Playout Delegate Class +//////////////////////////////////////////// +PlayoutDelegate::PlayoutDelegate(DeckLinkSession* pOwner) : + m_pOwner(pOwner), + mRefCount(1) +{ +} + +HRESULT PlayoutDelegate::QueryInterface(REFIID, LPVOID* ppv) +{ + *ppv = NULL; + return E_NOINTERFACE; +} + +ULONG PlayoutDelegate::AddRef() +{ + return InterlockedIncrement(&mRefCount); +} + +ULONG PlayoutDelegate::Release() +{ + int newCount = InterlockedDecrement(&mRefCount); + if (newCount == 0) + delete this; + return newCount; +} + +HRESULT PlayoutDelegate::ScheduledFrameCompleted(IDeckLinkVideoFrame* completedFrame, BMDOutputFrameCompletionResult result) +{ + switch (result) + { + case bmdOutputFrameDisplayedLate: + case bmdOutputFrameDropped: + case bmdOutputFrameCompleted: + case bmdOutputFrameFlushed: + // Late/drop counts are recorded by VideoBackend; keep this callback lean. + break; + default: + OutputDebugStringA("ScheduledFrameCompleted() frame did not complete: Unknown error\n"); + } + + m_pOwner->HandlePlayoutFrameCompleted(completedFrame, result); + return S_OK; +} + +HRESULT PlayoutDelegate::ScheduledPlaybackHasStopped() +{ + return S_OK; +} diff --git a/src/video/DeckLinkFrameTransfer.h b/src/video/DeckLinkFrameTransfer.h new file mode 100644 index 0000000..de79944 --- /dev/null +++ b/src/video/DeckLinkFrameTransfer.h @@ -0,0 +1,49 @@ +#pragma once + +#include + +#include + +#include "DeckLinkAPI_h.h" + +class DeckLinkSession; + +//////////////////////////////////////////// +// Capture Delegate Class +//////////////////////////////////////////// +class CaptureDelegate : public IDeckLinkInputCallback +{ + DeckLinkSession* m_pOwner; + LONG mRefCount; + +public: + CaptureDelegate(DeckLinkSession* pOwner); + + // IUnknown needs only a dummy implementation + virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, LPVOID* ppv); + virtual ULONG STDMETHODCALLTYPE AddRef(); + virtual ULONG STDMETHODCALLTYPE Release(); + + virtual HRESULT STDMETHODCALLTYPE VideoInputFrameArrived(IDeckLinkVideoInputFrame* videoFrame, IDeckLinkAudioInputPacket* audioPacket); + virtual HRESULT STDMETHODCALLTYPE VideoInputFormatChanged(BMDVideoInputFormatChangedEvents notificationEvents, IDeckLinkDisplayMode* newDisplayMode, BMDDetectedVideoInputFormatFlags detectedSignalFlags); +}; + +//////////////////////////////////////////// +// Render Delegate Class +//////////////////////////////////////////// +class PlayoutDelegate : public IDeckLinkVideoOutputCallback +{ + DeckLinkSession* m_pOwner; + LONG mRefCount; + +public: + PlayoutDelegate(DeckLinkSession* pOwner); + + // IUnknown needs only a dummy implementation + virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, LPVOID* ppv); + virtual ULONG STDMETHODCALLTYPE AddRef(); + virtual ULONG STDMETHODCALLTYPE Release(); + + virtual HRESULT STDMETHODCALLTYPE ScheduledFrameCompleted(IDeckLinkVideoFrame* completedFrame, BMDOutputFrameCompletionResult result); + virtual HRESULT STDMETHODCALLTYPE ScheduledPlaybackHasStopped(); +}; diff --git a/src/video/DeckLinkSession.cpp b/src/video/DeckLinkSession.cpp new file mode 100644 index 0000000..20ae9da --- /dev/null +++ b/src/video/DeckLinkSession.cpp @@ -0,0 +1,933 @@ +#include "DeckLinkSession.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace +{ +constexpr int64_t kMinimumHealthyScheduleLeadFrames = 4; +constexpr int64_t kProactiveScheduleLeadFloorFrames = 1; + +class SystemMemoryDeckLinkVideoBuffer : public IDeckLinkVideoBuffer +{ +public: + SystemMemoryDeckLinkVideoBuffer(void* bytes, unsigned long long sizeBytes) : + mBytes(bytes), + mSizeBytes(sizeBytes), + mRefCount(1) + { + } + + HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, LPVOID* ppv) override + { + if (ppv == nullptr) + return E_POINTER; + if (iid == IID_IUnknown || iid == IID_IDeckLinkVideoBuffer) + { + *ppv = static_cast(this); + AddRef(); + return S_OK; + } + *ppv = nullptr; + return E_NOINTERFACE; + } + + ULONG STDMETHODCALLTYPE AddRef() override + { + return ++mRefCount; + } + + ULONG STDMETHODCALLTYPE Release() override + { + const ULONG refCount = --mRefCount; + if (refCount == 0) + delete this; + return refCount; + } + + HRESULT STDMETHODCALLTYPE GetBytes(void** buffer) override + { + if (buffer == nullptr) + return E_POINTER; + *buffer = mBytes; + return mBytes != nullptr ? S_OK : E_FAIL; + } + + HRESULT STDMETHODCALLTYPE GetSize(unsigned long long* bufferSize) override + { + if (bufferSize == nullptr) + return E_POINTER; + *bufferSize = mSizeBytes; + return S_OK; + } + + HRESULT STDMETHODCALLTYPE StartAccess(BMDBufferAccessFlags) override + { + return S_OK; + } + + HRESULT STDMETHODCALLTYPE EndAccess(BMDBufferAccessFlags) override + { + return S_OK; + } + +private: + void* mBytes = nullptr; + unsigned long long mSizeBytes = 0; + std::atomic mRefCount; +}; + +std::string BstrToUtf8(BSTR value) +{ + if (value == nullptr) + return std::string(); + + const int requiredBytes = WideCharToMultiByte(CP_UTF8, 0, value, -1, NULL, 0, NULL, NULL); + if (requiredBytes <= 1) + return std::string(); + + std::vector utf8Name(static_cast(requiredBytes), '\0'); + if (WideCharToMultiByte(CP_UTF8, 0, value, -1, utf8Name.data(), requiredBytes, NULL, NULL) <= 0) + return std::string(); + + return std::string(utf8Name.data()); +} + +bool InputSupportsFormat(IDeckLinkInput* input, BMDDisplayMode displayMode, BMDPixelFormat pixelFormat) +{ + if (input == nullptr) + return false; + + BOOL supported = FALSE; + BMDDisplayMode actualMode = bmdModeUnknown; + const HRESULT result = input->DoesSupportVideoMode( + bmdVideoConnectionUnspecified, + displayMode, + pixelFormat, + bmdNoVideoInputConversion, + bmdSupportedVideoModeDefault, + &actualMode, + &supported); + return result == S_OK && supported != FALSE; +} + +bool OutputSupportsFormat(IDeckLinkOutput* output, BMDDisplayMode displayMode, BMDPixelFormat pixelFormat) +{ + if (output == nullptr) + return false; + + BOOL supported = FALSE; + BMDDisplayMode actualMode = bmdModeUnknown; + const HRESULT result = output->DoesSupportVideoMode( + bmdVideoConnectionUnspecified, + displayMode, + pixelFormat, + bmdNoVideoOutputConversion, + bmdSupportedVideoModeDefault, + &actualMode, + &supported); + return result == S_OK && supported != FALSE; +} +} + +DeckLinkSession::~DeckLinkSession() +{ + ReleaseResources(); +} + +void DeckLinkSession::ReleaseResources() +{ + if (input != nullptr) + input->SetCallback(nullptr); + captureDelegate.Release(); + input.Release(); + + if (output != nullptr) + output->SetScheduledFrameCompletionCallback(nullptr); + + if (keyer != nullptr) + { + keyer->Disable(); + mState.externalKeyingActive = false; + } + keyer.Release(); + + playoutDelegate.Release(); + outputVideoFrameQueue.clear(); + output.Release(); +} + +bool DeckLinkSession::DiscoverDevicesAndModes(const VideoFormatSelection& videoModes, std::string& error) +{ + CComPtr deckLinkIterator; + CComPtr inputMode; + CComPtr outputMode; + + mState.inputDisplayModeName = videoModes.input.displayName; + mState.outputDisplayModeName = videoModes.output.displayName; + + HRESULT result = CoCreateInstance(CLSID_CDeckLinkIterator, nullptr, CLSCTX_ALL, IID_IDeckLinkIterator, reinterpret_cast(&deckLinkIterator)); + if (FAILED(result)) + { + error = "Please install the Blackmagic DeckLink drivers to use the features of this application."; + return false; + } + + CComPtr deckLink; + while (deckLinkIterator->Next(&deckLink) == S_OK) + { + int64_t duplexMode; + bool deviceSupportsInternalKeying = false; + bool deviceSupportsExternalKeying = false; + std::string modelName; + CComPtr deckLinkAttributes; + + if (deckLink->QueryInterface(IID_IDeckLinkProfileAttributes, (void**)&deckLinkAttributes) != S_OK) + { + printf("Could not obtain the IDeckLinkProfileAttributes interface\n"); + deckLink.Release(); + continue; + } + + result = deckLinkAttributes->GetInt(BMDDeckLinkDuplex, &duplexMode); + BOOL attributeFlag = FALSE; + if (deckLinkAttributes->GetFlag(BMDDeckLinkSupportsInternalKeying, &attributeFlag) == S_OK) + deviceSupportsInternalKeying = (attributeFlag != FALSE); + attributeFlag = FALSE; + if (deckLinkAttributes->GetFlag(BMDDeckLinkSupportsExternalKeying, &attributeFlag) == S_OK) + deviceSupportsExternalKeying = (attributeFlag != FALSE); + CComBSTR modelNameBstr; + if (deckLinkAttributes->GetString(BMDDeckLinkModelName, &modelNameBstr) == S_OK) + modelName = BstrToUtf8(modelNameBstr); + + if (result != S_OK || duplexMode == bmdDuplexInactive) + { + deckLink.Release(); + continue; + } + + bool inputUsed = false; + if (!input && deckLink->QueryInterface(IID_IDeckLinkInput, (void**)&input) == S_OK) + inputUsed = true; + + if (!output && (!inputUsed || (duplexMode == bmdDuplexFull))) + { + if (deckLink->QueryInterface(IID_IDeckLinkOutput, (void**)&output) != S_OK) + output.Release(); + else + { + mState.outputModelName = modelName; + mState.supportsInternalKeying = deviceSupportsInternalKeying; + mState.supportsExternalKeying = deviceSupportsExternalKeying; + } + } + + deckLink.Release(); + + if (output && input) + break; + } + + if (!output) + { + error = "Expected an Output DeckLink device"; + ReleaseResources(); + return false; + } + + CComPtr inputDisplayModeIterator; + if (input && input->GetDisplayModeIterator(&inputDisplayModeIterator) != S_OK) + { + error = "Cannot get input Display Mode Iterator."; + ReleaseResources(); + return false; + } + + if (input && !FindDeckLinkDisplayMode(inputDisplayModeIterator, videoModes.input.displayMode, &inputMode)) + { + error = "Cannot get specified input BMDDisplayMode for configured mode: " + videoModes.input.displayName; + ReleaseResources(); + return false; + } + inputDisplayModeIterator.Release(); + + CComPtr outputDisplayModeIterator; + if (output->GetDisplayModeIterator(&outputDisplayModeIterator) != S_OK) + { + error = "Cannot get output Display Mode Iterator."; + ReleaseResources(); + return false; + } + + if (!FindDeckLinkDisplayMode(outputDisplayModeIterator, videoModes.output.displayMode, &outputMode)) + { + error = "Cannot get specified output BMDDisplayMode for configured mode: " + videoModes.output.displayName; + ReleaseResources(); + return false; + } + + mState.outputFrameSize = { static_cast(outputMode->GetWidth()), static_cast(outputMode->GetHeight()) }; + mState.inputFrameSize = inputMode + ? FrameSize{ static_cast(inputMode->GetWidth()), static_cast(inputMode->GetHeight()) } + : mState.outputFrameSize; + if (!input) + mState.inputDisplayModeName = "No input - black frame"; + BMDTimeValue frameDuration = 0; + BMDTimeScale frameTimescale = 0; + outputMode->GetFrameRate(&frameDuration, &frameTimescale); + mScheduler.Configure(frameDuration, frameTimescale, mPlayoutPolicy); + mState.frameBudgetMilliseconds = mScheduler.FrameBudgetMilliseconds(); + + mState.inputFrameRowBytes = mState.inputFrameSize.width * 2u; + mState.outputFrameRowBytes = mState.outputFrameSize.width * 4u; + mState.captureTextureWidth = mState.inputFrameSize.width / 2u; + mState.outputPackTextureWidth = mState.outputFrameSize.width; + mState.hasInputDevice = input != nullptr; + mState.hasInputSource = false; + + return true; +} + +bool DeckLinkSession::SelectPreferredFormats(const VideoFormatSelection& videoModes, bool outputAlphaRequired, std::string& error) +{ + if (!output) + { + error = "Expected an Output DeckLink device"; + return false; + } + + mState.formatStatusMessage.clear(); + + const bool inputTenBitSupported = input != nullptr && InputSupportsFormat(input, videoModes.input.displayMode, bmdFormat10BitYUV); + mState.inputPixelFormat = input != nullptr ? ChoosePreferredVideoIOFormat(inputTenBitSupported) : VideoIOPixelFormat::Uyvy8; + if (input != nullptr && !inputTenBitSupported) + mState.formatStatusMessage += "DeckLink input does not report 10-bit YUV support for the configured mode; using 8-bit capture. "; + + const bool outputTenBitSupported = OutputSupportsFormat(output, videoModes.output.displayMode, bmdFormat10BitYUV); + const bool outputTenBitYuvaSupported = OutputSupportsFormat(output, videoModes.output.displayMode, bmdFormat10BitYUVA); + mState.outputPixelFormat = outputAlphaRequired + ? (outputTenBitYuvaSupported ? VideoIOPixelFormat::Yuva10 : VideoIOPixelFormat::Bgra8) + : (outputTenBitSupported ? VideoIOPixelFormat::V210 : VideoIOPixelFormat::Bgra8); + if (outputAlphaRequired && outputTenBitYuvaSupported) + mState.formatStatusMessage += "External keying requires alpha; using 10-bit YUVA output. "; + else if (outputAlphaRequired) + mState.formatStatusMessage += "External keying requires alpha, but DeckLink output does not report 10-bit YUVA support for the configured mode; using 8-bit BGRA output. "; + else if (!outputTenBitSupported) + mState.formatStatusMessage += "DeckLink output does not report 10-bit YUV support for the configured mode; using 8-bit BGRA output. "; + + int deckLinkOutputRowBytes = 0; + if (output->RowBytesForPixelFormat(DeckLinkPixelFormatForVideoIO(mState.outputPixelFormat), mState.outputFrameSize.width, &deckLinkOutputRowBytes) != S_OK) + { + error = "DeckLink output setup failed while calculating output row bytes."; + return false; + } + mState.outputFrameRowBytes = static_cast(deckLinkOutputRowBytes); + mState.outputPackTextureWidth = OutputIsTenBit() + ? PackedTextureWidthFromRowBytes(mState.outputFrameRowBytes) + : mState.outputFrameSize.width; + + if (InputIsTenBit()) + { + int deckLinkInputRowBytes = 0; + if (output->RowBytesForPixelFormat(bmdFormat10BitYUV, mState.inputFrameSize.width, &deckLinkInputRowBytes) == S_OK) + mState.inputFrameRowBytes = static_cast(deckLinkInputRowBytes); + else + mState.inputFrameRowBytes = MinimumV210RowBytes(mState.inputFrameSize.width); + } + else + { + mState.inputFrameRowBytes = mState.inputFrameSize.width * 2u; + } + mState.captureTextureWidth = InputIsTenBit() + ? PackedTextureWidthFromRowBytes(mState.inputFrameRowBytes) + : mState.inputFrameSize.width / 2u; + + std::ostringstream status; + status << "DeckLink formats: capture " << (input ? VideoIOPixelFormatName(mState.inputPixelFormat) : "none") + << ", output " << VideoIOPixelFormatName(mState.outputPixelFormat) << "."; + if (!mState.formatStatusMessage.empty()) + status << " " << mState.formatStatusMessage; + mState.formatStatusMessage = status.str(); + return true; +} + +bool DeckLinkSession::ConfigureInput(InputFrameCallback callback, const VideoFormat& inputVideoMode, std::string& error) +{ + mInputFrameCallback = std::move(callback); + + if (!input) + { + mState.hasInputSource = false; + mState.inputDisplayModeName = "No input - black frame"; + return true; + } + + const BMDPixelFormat deckLinkInputPixelFormat = DeckLinkPixelFormatForVideoIO(mState.inputPixelFormat); + if (input->EnableVideoInput(inputVideoMode.displayMode, deckLinkInputPixelFormat, bmdVideoInputFlagDefault) != S_OK) + { + if (mState.inputPixelFormat == VideoIOPixelFormat::V210) + { + OutputDebugStringA("DeckLink 10-bit input could not be enabled; falling back to 8-bit capture.\n"); + mState.inputPixelFormat = VideoIOPixelFormat::Uyvy8; + mState.inputFrameRowBytes = mState.inputFrameSize.width * 2u; + mState.captureTextureWidth = mState.inputFrameSize.width / 2u; + if (input->EnableVideoInput(inputVideoMode.displayMode, bmdFormat8BitYUV, bmdVideoInputFlagDefault) == S_OK) + { + std::ostringstream status; + status << "DeckLink formats: capture " << VideoIOPixelFormatName(mState.inputPixelFormat) + << ", output " << VideoIOPixelFormatName(mState.outputPixelFormat) + << ". DeckLink 10-bit input enable failed; using 8-bit capture."; + mState.formatStatusMessage = status.str(); + goto input_enabled; + } + } + + OutputDebugStringA("DeckLink input could not be enabled; continuing in output-only black-frame mode.\n"); + input.Release(); + mState.hasInputDevice = false; + mState.hasInputSource = false; + mState.inputDisplayModeName = "No input - black frame"; + return true; + } + +input_enabled: + captureDelegate.Attach(new (std::nothrow) CaptureDelegate(this)); + if (captureDelegate == nullptr) + { + error = "DeckLink input setup failed while creating the capture callback."; + return false; + } + if (input->SetCallback(captureDelegate) != S_OK) + { + error = "DeckLink input setup failed while installing the capture callback."; + return false; + } + + return true; +} + +bool DeckLinkSession::ConfigureOutput(OutputFrameCallback callback, const VideoFormat& outputVideoMode, bool externalKeyingEnabled, std::string& error) +{ + mOutputFrameCallback = std::move(callback); + + if (output->EnableVideoOutput(outputVideoMode.displayMode, bmdVideoOutputFlagDefault) != S_OK) + { + error = "DeckLink output setup failed while enabling video output."; + return false; + } + + if (output->QueryInterface(IID_IDeckLinkKeyer, (void**)&keyer) == S_OK && keyer != NULL) + mState.keyerInterfaceAvailable = true; + + if (externalKeyingEnabled) + { + if (!mState.supportsExternalKeying) + { + mState.statusMessage = "External keying was requested, but the selected DeckLink output does not report external keying support."; + } + else if (!mState.keyerInterfaceAvailable) + { + mState.statusMessage = "External keying was requested, but the selected DeckLink output does not expose the IDeckLinkKeyer interface."; + } + else if (keyer->Enable(TRUE) != S_OK || keyer->SetLevel(255) != S_OK) + { + mState.statusMessage = "External keying was requested, but enabling the DeckLink keyer failed."; + } + else + { + mState.externalKeyingActive = true; + mState.statusMessage = "External keying is active on the selected DeckLink output."; + } + } + else if (mState.supportsExternalKeying) + { + mState.statusMessage = "Selected DeckLink output supports external keying. Set enableExternalKeying to true in runtime-host.json to request it."; + } + + const VideoPlayoutPolicy policy = NormalizeVideoPlayoutPolicy(mPlayoutPolicy); + mPlayoutPolicy = policy; + for (unsigned i = 0; i < policy.outputFramePoolSize; i++) + { + CComPtr outputFrame; + + const BMDPixelFormat deckLinkOutputPixelFormat = DeckLinkPixelFormatForVideoIO(mState.outputPixelFormat); + if (output->CreateVideoFrame(mState.outputFrameSize.width, mState.outputFrameSize.height, mState.outputFrameRowBytes, deckLinkOutputPixelFormat, bmdFrameFlagFlipVertical, &outputFrame) != S_OK) + { + error = "DeckLink output setup failed while creating an output video frame."; + return false; + } + + outputVideoFrameQueue.push_back(outputFrame); + } + + playoutDelegate.Attach(new (std::nothrow) PlayoutDelegate(this)); + if (playoutDelegate == nullptr) + { + error = "DeckLink output setup failed while creating the playout callback."; + return false; + } + + if (output->SetScheduledFrameCompletionCallback(playoutDelegate) != S_OK) + { + error = "DeckLink output setup failed while installing the scheduled-frame callback."; + return false; + } + + if (!mState.formatStatusMessage.empty()) + mState.statusMessage = mState.statusMessage.empty() ? mState.formatStatusMessage : mState.formatStatusMessage + " " + mState.statusMessage; + + return true; +} + +double DeckLinkSession::FrameBudgetMilliseconds() const +{ + return mScheduler.FrameBudgetMilliseconds(); +} + +bool DeckLinkSession::AcquireNextOutputVideoFrame(CComPtr& outputVideoFrame) +{ + if (outputVideoFrameQueue.empty()) + return false; + + outputVideoFrame = outputVideoFrameQueue.front(); + outputVideoFrameQueue.pop_front(); + return outputVideoFrame != nullptr; +} + +bool DeckLinkSession::PopulateOutputFrame(IDeckLinkMutableVideoFrame* outputVideoFrame, VideoIOOutputFrame& frame) +{ + if (outputVideoFrame == nullptr) + return false; + + CComPtr outputVideoFrameBuffer; + if (outputVideoFrame->QueryInterface(IID_IDeckLinkVideoBuffer, (void**)&outputVideoFrameBuffer) != S_OK) + return false; + + if (outputVideoFrameBuffer->StartAccess(bmdBufferAccessWrite) != S_OK) + return false; + + void* pFrame = nullptr; + outputVideoFrameBuffer->GetBytes(&pFrame); + + frame.bytes = pFrame; + frame.rowBytes = outputVideoFrame->GetRowBytes(); + frame.width = mState.outputFrameSize.width; + frame.height = mState.outputFrameSize.height; + frame.pixelFormat = mState.outputPixelFormat; + outputVideoFrame->AddRef(); + frame.nativeFrame = outputVideoFrame; + frame.nativeBuffer = outputVideoFrameBuffer.Detach(); + return true; +} + +bool DeckLinkSession::ScheduleFrame(IDeckLinkMutableVideoFrame* outputVideoFrame) +{ + if (outputVideoFrame == nullptr || output == nullptr) + { + ++mState.deckLinkScheduleFailureCount; + return false; + } + + if (mScheduleRealignmentPending) + { + RealignScheduleCursorToPlayback(); + mScheduleRealignmentPending = false; + } + + UpdateScheduleLeadTelemetry(); + MaybeRealignScheduleCursorForLowLead(); + const VideoIOScheduleTime scheduleTime = mScheduler.NextScheduleTime(); + const auto scheduleStart = std::chrono::steady_clock::now(); + const HRESULT result = output->ScheduleVideoFrame(outputVideoFrame, scheduleTime.streamTime, scheduleTime.duration, scheduleTime.timeScale); + const auto scheduleEnd = std::chrono::steady_clock::now(); + mState.deckLinkScheduleCallMilliseconds = std::chrono::duration_cast>(scheduleEnd - scheduleStart).count(); + if (result != S_OK) + ++mState.deckLinkScheduleFailureCount; + RefreshBufferedVideoFrameCount(); + return result == S_OK; +} + +void DeckLinkSession::UpdateScheduleLeadTelemetry() +{ + if (output == nullptr) + { + mState.deckLinkScheduleLeadAvailable = false; + return; + } + + BMDTimeValue streamTime = 0; + double playbackSpeed = 0.0; + if (output->GetScheduledStreamTime(mScheduler.TimeScale(), &streamTime, &playbackSpeed) != S_OK || playbackSpeed <= 0.0) + { + mState.deckLinkScheduleLeadAvailable = false; + return; + } + + const uint64_t playbackFrameIndex = streamTime >= 0 && mScheduler.FrameDuration() > 0 + ? static_cast(streamTime / mScheduler.FrameDuration()) + : 0; + const uint64_t nextScheduleFrameIndex = mScheduler.ScheduledFrameIndex(); + mState.deckLinkScheduleLeadAvailable = true; + mState.deckLinkPlaybackStreamTime = streamTime; + mState.deckLinkPlaybackFrameIndex = playbackFrameIndex; + mState.deckLinkNextScheduleFrameIndex = nextScheduleFrameIndex; + mState.deckLinkScheduleLeadFrames = static_cast(nextScheduleFrameIndex) - static_cast(playbackFrameIndex); +} + +void DeckLinkSession::MaybeRealignScheduleCursorForLowLead() +{ + if (!mState.deckLinkScheduleLeadAvailable) + return; + + if (mState.deckLinkScheduleLeadFrames >= kMinimumHealthyScheduleLeadFrames) + { + mProactiveScheduleRealignmentArmed = true; + return; + } + + if (!mProactiveScheduleRealignmentArmed || mState.deckLinkScheduleLeadFrames > kProactiveScheduleLeadFloorFrames) + return; + + RealignScheduleCursorToPlayback(); + mProactiveScheduleRealignmentArmed = false; +} + +void DeckLinkSession::RealignScheduleCursorToPlayback() +{ + if (output == nullptr) + return; + + BMDTimeValue streamTime = 0; + double playbackSpeed = 0.0; + if (output->GetScheduledStreamTime(mScheduler.TimeScale(), &streamTime, &playbackSpeed) != S_OK || playbackSpeed <= 0.0) + return; + + const VideoPlayoutPolicy policy = NormalizeVideoPlayoutPolicy(mPlayoutPolicy); + mScheduler.AlignNextScheduleTimeToPlayback(streamTime, policy.targetPrerollFrames); + ++mState.deckLinkScheduleRealignmentCount; + UpdateScheduleLeadTelemetry(); +} + +bool DeckLinkSession::ScheduleSystemMemoryFrame(const VideoIOOutputFrame& frame) +{ + if (output == nullptr || frame.bytes == nullptr || frame.rowBytes <= 0 || frame.height == 0) + return false; + + CComPtr videoBuffer; + videoBuffer.Attach(new (std::nothrow) SystemMemoryDeckLinkVideoBuffer( + frame.bytes, + static_cast(frame.rowBytes) * static_cast(frame.height))); + if (videoBuffer == nullptr) + return false; + + CComPtr outputVideoFrame; + const BMDPixelFormat pixelFormat = DeckLinkPixelFormatForVideoIO(frame.pixelFormat); + if (output->CreateVideoFrameWithBuffer( + frame.width, + frame.height, + frame.rowBytes, + pixelFormat, + bmdFrameFlagFlipVertical, + videoBuffer, + &outputVideoFrame) != S_OK) + { + return false; + } + + IDeckLinkVideoFrame* scheduledFrame = outputVideoFrame; + { + std::lock_guard lock(mScheduledSystemFrameMutex); + mScheduledSystemFrameBuffers[scheduledFrame] = frame.bytes; + } + + if (ScheduleFrame(outputVideoFrame)) + return true; + + { + std::lock_guard lock(mScheduledSystemFrameMutex); + mScheduledSystemFrameBuffers.erase(scheduledFrame); + } + return false; +} + +bool DeckLinkSession::ScheduleBlackFrame(IDeckLinkMutableVideoFrame* outputVideoFrame) +{ + if (outputVideoFrame == nullptr) + return false; + + CComPtr outputVideoFrameBuffer; + if (outputVideoFrame->QueryInterface(IID_IDeckLinkVideoBuffer, (void**)&outputVideoFrameBuffer) != S_OK) + return false; + + if (outputVideoFrameBuffer->StartAccess(bmdBufferAccessWrite) != S_OK) + return false; + + void* pFrame = nullptr; + outputVideoFrameBuffer->GetBytes((void**)&pFrame); + memset(pFrame, 0, outputVideoFrame->GetRowBytes() * mState.outputFrameSize.height); + + outputVideoFrameBuffer->EndAccess(bmdBufferAccessWrite); + return ScheduleFrame(outputVideoFrame); +} + +void DeckLinkSession::RefreshBufferedVideoFrameCount() +{ + if (output == nullptr) + { + mState.actualDeckLinkBufferedFramesAvailable = false; + return; + } + + unsigned int bufferedFrameCount = 0; + if (output->GetBufferedVideoFrameCount(&bufferedFrameCount) == S_OK) + { + mState.actualDeckLinkBufferedFrames = bufferedFrameCount; + mState.actualDeckLinkBufferedFramesAvailable = true; + } + else + { + mState.actualDeckLinkBufferedFramesAvailable = false; + } +} + +bool DeckLinkSession::BeginOutputFrame(VideoIOOutputFrame& frame) +{ + CComPtr outputVideoFrame; + return AcquireNextOutputVideoFrame(outputVideoFrame) && PopulateOutputFrame(outputVideoFrame, frame); +} + +void DeckLinkSession::EndOutputFrame(VideoIOOutputFrame& frame) +{ + IDeckLinkVideoBuffer* outputVideoFrameBuffer = static_cast(frame.nativeBuffer); + if (outputVideoFrameBuffer != nullptr) + { + outputVideoFrameBuffer->EndAccess(bmdBufferAccessWrite); + outputVideoFrameBuffer->Release(); + } + frame.nativeBuffer = nullptr; + frame.bytes = nullptr; +} + +VideoPlayoutRecoveryDecision DeckLinkSession::AccountForCompletionResult(VideoIOCompletionResult completionResult, uint64_t readyQueueDepth) +{ + return mScheduler.AccountForCompletionResult(completionResult, readyQueueDepth); +} + +bool DeckLinkSession::ScheduleOutputFrame(const VideoIOOutputFrame& frame) +{ + if (frame.nativeFrame == nullptr) + return ScheduleSystemMemoryFrame(frame); + + IDeckLinkMutableVideoFrame* outputVideoFrame = static_cast(frame.nativeFrame); + const bool scheduled = ScheduleFrame(outputVideoFrame); + if (outputVideoFrame != nullptr) + outputVideoFrame->Release(); + return scheduled; +} + +bool DeckLinkSession::PrepareOutputSchedule() +{ + mScheduler.Reset(); + RefreshBufferedVideoFrameCount(); + return output != nullptr; +} + +bool DeckLinkSession::StartInputStreams() +{ + if (!input) + return true; + + if (input->StartStreams() != S_OK) + { + MessageBoxA(NULL, "Could not start the DeckLink input stream.", "DeckLink start failed", MB_OK | MB_ICONERROR); + return false; + } + return true; +} + +bool DeckLinkSession::StartScheduledPlayback() +{ + if (!output) + { + MessageBoxA(NULL, "Cannot start playout because no DeckLink output device is available.", "DeckLink start failed", MB_OK | MB_ICONERROR); + return false; + } + + if (output->StartScheduledPlayback(0, mScheduler.TimeScale(), 1.0) != S_OK) + { + MessageBoxA(NULL, "Could not start DeckLink scheduled playback.", "DeckLink start failed", MB_OK | MB_ICONERROR); + return false; + } + RefreshBufferedVideoFrameCount(); + return true; +} + +bool DeckLinkSession::Start() +{ + if (!output) + { + MessageBoxA(NULL, "Cannot start playout because no DeckLink output device is available.", "DeckLink start failed", MB_OK | MB_ICONERROR); + return false; + } + if (outputVideoFrameQueue.empty()) + { + MessageBoxA(NULL, "Cannot start playout because the output frame queue is empty.", "DeckLink start failed", MB_OK | MB_ICONERROR); + return false; + } + + const VideoPlayoutPolicy policy = NormalizeVideoPlayoutPolicy(mPlayoutPolicy); + mPlayoutPolicy = policy; + if (!PrepareOutputSchedule()) + return false; + + for (unsigned i = 0; i < policy.targetPrerollFrames; i++) + { + CComPtr outputVideoFrame; + if (!AcquireNextOutputVideoFrame(outputVideoFrame)) + { + MessageBoxA(NULL, "Could not acquire a preroll output frame.", "DeckLink start failed", MB_OK | MB_ICONERROR); + return false; + } + if (!ScheduleBlackFrame(outputVideoFrame)) + { + MessageBoxA(NULL, "Could not schedule a preroll output frame.", "DeckLink start failed", MB_OK | MB_ICONERROR); + return false; + } + } + + return StartInputStreams() && StartScheduledPlayback(); +} + +bool DeckLinkSession::Stop() +{ + if (keyer != nullptr) + { + keyer->Disable(); + mState.externalKeyingActive = false; + } + + if (input) + { + input->StopStreams(); + input->DisableVideoInput(); + } + + if (output) + { + output->StopScheduledPlayback(0, NULL, 0); + output->DisableVideoOutput(); + } + + return true; +} + +void DeckLinkSession::HandleVideoInputFrame(IDeckLinkVideoInputFrame* inputFrame, bool hasNoInputSource) +{ + mState.hasInputSource = !hasNoInputSource; + if (hasNoInputSource || mInputFrameCallback == nullptr) + { + VideoIOFrame frame; + frame.width = mState.inputFrameSize.width; + frame.height = mState.inputFrameSize.height; + frame.pixelFormat = mState.inputPixelFormat; + frame.hasNoInputSource = hasNoInputSource; + if (mInputFrameCallback) + mInputFrameCallback(frame); + return; + } + + CComPtr inputFrameBuffer; + void* videoPixels = nullptr; + if (inputFrame->QueryInterface(IID_IDeckLinkVideoBuffer, (void**)&inputFrameBuffer) != S_OK) + return; + if (inputFrameBuffer->StartAccess(bmdBufferAccessRead) != S_OK) + return; + + inputFrameBuffer->GetBytes(&videoPixels); + + VideoIOFrame frame; + frame.bytes = videoPixels; + frame.rowBytes = inputFrame->GetRowBytes(); + frame.width = static_cast(inputFrame->GetWidth()); + frame.height = static_cast(inputFrame->GetHeight()); + frame.pixelFormat = mState.inputPixelFormat; + frame.hasNoInputSource = hasNoInputSource; + mInputFrameCallback(frame); + + inputFrameBuffer->EndAccess(bmdBufferAccessRead); +} + +void DeckLinkSession::HandlePlayoutFrameCompleted(IDeckLinkVideoFrame* completedFrame, BMDOutputFrameCompletionResult completionResult) +{ + RefreshBufferedVideoFrameCount(); + + void* completedSystemBuffer = nullptr; + if (completedFrame != nullptr) + { + bool externalSystemFrame = false; + { + std::lock_guard lock(mScheduledSystemFrameMutex); + auto externalFrame = mScheduledSystemFrameBuffers.find(completedFrame); + if (externalFrame != mScheduledSystemFrameBuffers.end()) + { + completedSystemBuffer = externalFrame->second; + mScheduledSystemFrameBuffers.erase(externalFrame); + externalSystemFrame = true; + } + } + + if (!externalSystemFrame) + { + CComPtr reusableFrame; + if (completedFrame->QueryInterface(IID_IDeckLinkMutableVideoFrame, reinterpret_cast(&reusableFrame)) == S_OK && + reusableFrame != nullptr) + { + outputVideoFrameQueue.push_back(reusableFrame); + } + } + } + + if (!mOutputFrameCallback) + return; + + VideoIOCompletion completion; + completion.result = TranslateCompletionResult(completionResult); + if (completion.result == VideoIOCompletionResult::DisplayedLate || completion.result == VideoIOCompletionResult::Dropped) + { + if (mScheduleRealignmentArmed) + { + mScheduleRealignmentPending = true; + mScheduleRealignmentArmed = false; + } + } + else if (completion.result == VideoIOCompletionResult::Completed) + { + mScheduleRealignmentArmed = true; + } + completion.outputFrameBuffer = completedSystemBuffer; + mOutputFrameCallback(completion); +} + +VideoIOCompletionResult DeckLinkSession::TranslateCompletionResult(BMDOutputFrameCompletionResult completionResult) +{ + switch (completionResult) + { + case bmdOutputFrameDisplayedLate: + return VideoIOCompletionResult::DisplayedLate; + case bmdOutputFrameDropped: + return VideoIOCompletionResult::Dropped; + case bmdOutputFrameFlushed: + return VideoIOCompletionResult::Flushed; + case bmdOutputFrameCompleted: + return VideoIOCompletionResult::Completed; + default: + return VideoIOCompletionResult::Unknown; + } +} diff --git a/src/video/DeckLinkSession.h b/src/video/DeckLinkSession.h new file mode 100644 index 0000000..e1442cc --- /dev/null +++ b/src/video/DeckLinkSession.h @@ -0,0 +1,102 @@ +#pragma once + +#include "DeckLinkAPI_h.h" +#include "DeckLinkDisplayMode.h" +#include "DeckLinkFrameTransfer.h" +#include "DeckLinkVideoIOFormat.h" +#include "VideoIOFormat.h" +#include "VideoIOTypes.h" +#include "VideoPlayoutPolicy.h" +#include "VideoPlayoutScheduler.h" + +#include +#include +#include +#include +#include + +class OpenGLComposite; + +class DeckLinkSession : public VideoIODevice +{ +public: + DeckLinkSession() = default; + ~DeckLinkSession(); + + void ReleaseResources() override; + bool DiscoverDevicesAndModes(const VideoFormatSelection& videoModes, std::string& error) override; + bool SelectPreferredFormats(const VideoFormatSelection& videoModes, bool outputAlphaRequired, std::string& error) override; + bool ConfigureInput(InputFrameCallback callback, const VideoFormat& inputVideoMode, std::string& error) override; + bool ConfigureOutput(OutputFrameCallback callback, const VideoFormat& outputVideoMode, bool externalKeyingEnabled, std::string& error) override; + bool PrepareOutputSchedule() override; + bool StartInputStreams() override; + bool StartScheduledPlayback() override; + bool Start() override; + bool Stop() override; + + bool HasInputDevice() const { return mState.hasInputDevice; } + bool HasInputSource() const { return mState.hasInputSource; } + void SetInputSourceMissing(bool missing) { mState.hasInputSource = !missing; } + bool InputOutputDimensionsDiffer() const { return mState.inputFrameSize != mState.outputFrameSize; } + const FrameSize& InputFrameSize() const { return mState.inputFrameSize; } + const FrameSize& OutputFrameSize() const { return mState.outputFrameSize; } + unsigned InputFrameWidth() const { return mState.inputFrameSize.width; } + unsigned InputFrameHeight() const { return mState.inputFrameSize.height; } + unsigned OutputFrameWidth() const { return mState.outputFrameSize.width; } + unsigned OutputFrameHeight() const { return mState.outputFrameSize.height; } + VideoIOPixelFormat InputPixelFormat() const { return mState.inputPixelFormat; } + VideoIOPixelFormat OutputPixelFormat() const { return mState.outputPixelFormat; } + bool InputIsTenBit() const { return VideoIOPixelFormatIsTenBit(mState.inputPixelFormat); } + bool OutputIsTenBit() const { return VideoIOPixelFormatIsTenBit(mState.outputPixelFormat); } + unsigned InputFrameRowBytes() const { return mState.inputFrameRowBytes; } + unsigned OutputFrameRowBytes() const { return mState.outputFrameRowBytes; } + unsigned CaptureTextureWidth() const { return mState.captureTextureWidth; } + unsigned OutputPackTextureWidth() const { return mState.outputPackTextureWidth; } + const std::string& FormatStatusMessage() const { return mState.formatStatusMessage; } + const std::string& InputDisplayModeName() const { return mState.inputDisplayModeName; } + const std::string& OutputModelName() const { return mState.outputModelName; } + bool SupportsInternalKeying() const { return mState.supportsInternalKeying; } + bool SupportsExternalKeying() const { return mState.supportsExternalKeying; } + bool KeyerInterfaceAvailable() const { return mState.keyerInterfaceAvailable; } + bool ExternalKeyingActive() const { return mState.externalKeyingActive; } + const std::string& StatusMessage() const { return mState.statusMessage; } + void SetStatusMessage(const std::string& message) { mState.statusMessage = message; } + const VideoIOState& State() const override { return mState; } + VideoIOState& MutableState() override { return mState; } + double FrameBudgetMilliseconds() const; + VideoPlayoutRecoveryDecision AccountForCompletionResult(VideoIOCompletionResult completionResult, uint64_t readyQueueDepth) override; + bool BeginOutputFrame(VideoIOOutputFrame& frame) override; + void EndOutputFrame(VideoIOOutputFrame& frame) override; + bool ScheduleOutputFrame(const VideoIOOutputFrame& frame) override; + void HandleVideoInputFrame(IDeckLinkVideoInputFrame* inputFrame, bool hasNoInputSource); + void HandlePlayoutFrameCompleted(IDeckLinkVideoFrame* completedFrame, BMDOutputFrameCompletionResult completionResult); + +private: + bool AcquireNextOutputVideoFrame(CComPtr& outputVideoFrame); + bool PopulateOutputFrame(IDeckLinkMutableVideoFrame* outputVideoFrame, VideoIOOutputFrame& frame); + bool ScheduleFrame(IDeckLinkMutableVideoFrame* outputVideoFrame); + void UpdateScheduleLeadTelemetry(); + void MaybeRealignScheduleCursorForLowLead(); + void RealignScheduleCursorToPlayback(); + bool ScheduleSystemMemoryFrame(const VideoIOOutputFrame& frame); + bool ScheduleBlackFrame(IDeckLinkMutableVideoFrame* outputVideoFrame); + void RefreshBufferedVideoFrameCount(); + static VideoIOCompletionResult TranslateCompletionResult(BMDOutputFrameCompletionResult completionResult); + + CComPtr captureDelegate; + CComPtr playoutDelegate; + CComPtr input; + CComPtr output; + CComPtr keyer; + std::deque> outputVideoFrameQueue; + std::mutex mScheduledSystemFrameMutex; + std::unordered_map mScheduledSystemFrameBuffers; + VideoIOState mState; + VideoPlayoutPolicy mPlayoutPolicy; + VideoPlayoutScheduler mScheduler; + bool mScheduleRealignmentPending = false; + bool mScheduleRealignmentArmed = true; + bool mProactiveScheduleRealignmentArmed = true; + InputFrameCallback mInputFrameCallback; + OutputFrameCallback mOutputFrameCallback; +}; diff --git a/src/video/DeckLinkVideoIOFormat.cpp b/src/video/DeckLinkVideoIOFormat.cpp new file mode 100644 index 0000000..cf988bf --- /dev/null +++ b/src/video/DeckLinkVideoIOFormat.cpp @@ -0,0 +1,28 @@ +#include "DeckLinkVideoIOFormat.h" + +BMDPixelFormat DeckLinkPixelFormatForVideoIO(VideoIOPixelFormat format) +{ + switch (format) + { + case VideoIOPixelFormat::V210: + return bmdFormat10BitYUV; + case VideoIOPixelFormat::Yuva10: + return bmdFormat10BitYUVA; + case VideoIOPixelFormat::Bgra8: + return bmdFormat8BitBGRA; + case VideoIOPixelFormat::Uyvy8: + default: + return bmdFormat8BitYUV; + } +} + +VideoIOPixelFormat VideoIOPixelFormatFromDeckLink(BMDPixelFormat format) +{ + if (format == bmdFormat10BitYUV) + return VideoIOPixelFormat::V210; + if (format == bmdFormat10BitYUVA) + return VideoIOPixelFormat::Yuva10; + if (format == bmdFormat8BitBGRA) + return VideoIOPixelFormat::Bgra8; + return VideoIOPixelFormat::Uyvy8; +} diff --git a/src/video/DeckLinkVideoIOFormat.h b/src/video/DeckLinkVideoIOFormat.h new file mode 100644 index 0000000..f6106a3 --- /dev/null +++ b/src/video/DeckLinkVideoIOFormat.h @@ -0,0 +1,7 @@ +#pragma once + +#include "DeckLinkAPI_h.h" +#include "VideoIOFormat.h" + +BMDPixelFormat DeckLinkPixelFormatForVideoIO(VideoIOPixelFormat format); +VideoIOPixelFormat VideoIOPixelFormatFromDeckLink(BMDPixelFormat format); diff --git a/src/video/OutputProductionController.cpp b/src/video/OutputProductionController.cpp new file mode 100644 index 0000000..64e4148 --- /dev/null +++ b/src/video/OutputProductionController.cpp @@ -0,0 +1,89 @@ +#include "OutputProductionController.h" + +#include + +namespace +{ +std::size_t ClampReadyLimit(unsigned value, std::size_t capacity) +{ + const std::size_t requested = static_cast(value); + if (capacity == 0) + return requested; + return (std::min)(requested, capacity); +} +} + +OutputProductionController::OutputProductionController(const VideoPlayoutPolicy& policy) : + mPolicy(NormalizeVideoPlayoutPolicy(policy)) +{ +} + +void OutputProductionController::Configure(const VideoPlayoutPolicy& policy) +{ + mPolicy = NormalizeVideoPlayoutPolicy(policy); +} + +OutputProductionDecision OutputProductionController::Decide(const OutputProductionPressure& pressure) const +{ + OutputProductionDecision decision; + + const std::size_t configuredMaxReadyFrames = static_cast(mPolicy.maxReadyFrames); + const std::size_t effectiveMaxReadyFrames = pressure.readyQueueCapacity > 0 + ? (std::min)(configuredMaxReadyFrames, pressure.readyQueueCapacity) + : configuredMaxReadyFrames; + const std::size_t effectiveTargetReadyFrames = (std::min)( + ClampReadyLimit(mPolicy.targetReadyFrames, pressure.readyQueueCapacity), + effectiveMaxReadyFrames); + + decision.targetReadyFrames = effectiveTargetReadyFrames; + decision.maxReadyFrames = effectiveMaxReadyFrames; + + if (effectiveMaxReadyFrames == 0) + { + decision.action = OutputProductionAction::Throttle; + decision.reason = "no-ready-frame-capacity"; + return decision; + } + + if (pressure.readyQueueDepth >= effectiveMaxReadyFrames) + { + decision.action = OutputProductionAction::Throttle; + decision.reason = "ready-queue-full"; + return decision; + } + + if (pressure.readyQueueDepth < effectiveTargetReadyFrames) + { + decision.action = OutputProductionAction::Produce; + decision.requestedFrames = effectiveTargetReadyFrames - pressure.readyQueueDepth; + decision.reason = "ready-queue-below-target"; + return decision; + } + + if ((pressure.lateStreak > 0 || pressure.dropStreak > 0 || pressure.readyQueueUnderrunCount > 0) && + pressure.readyQueueDepth < effectiveMaxReadyFrames) + { + decision.action = OutputProductionAction::Produce; + decision.requestedFrames = 1; + decision.reason = "playout-pressure"; + return decision; + } + + decision.action = OutputProductionAction::Wait; + decision.reason = "ready-queue-at-target"; + return decision; +} + +const char* OutputProductionActionName(OutputProductionAction action) +{ + switch (action) + { + case OutputProductionAction::Produce: + return "Produce"; + case OutputProductionAction::Throttle: + return "Throttle"; + case OutputProductionAction::Wait: + default: + return "Wait"; + } +} diff --git a/src/video/OutputProductionController.h b/src/video/OutputProductionController.h new file mode 100644 index 0000000..13a016c --- /dev/null +++ b/src/video/OutputProductionController.h @@ -0,0 +1,46 @@ +#pragma once + +#include "VideoPlayoutPolicy.h" + +#include +#include +#include + +enum class OutputProductionAction +{ + Produce, + Wait, + Throttle +}; + +struct OutputProductionPressure +{ + std::size_t readyQueueDepth = 0; + std::size_t readyQueueCapacity = 0; + uint64_t readyQueueUnderrunCount = 0; + uint64_t lateStreak = 0; + uint64_t dropStreak = 0; +}; + +struct OutputProductionDecision +{ + OutputProductionAction action = OutputProductionAction::Wait; + std::size_t requestedFrames = 0; + std::size_t targetReadyFrames = 0; + std::size_t maxReadyFrames = 0; + std::string reason; +}; + +class OutputProductionController +{ +public: + explicit OutputProductionController(const VideoPlayoutPolicy& policy = VideoPlayoutPolicy()); + + void Configure(const VideoPlayoutPolicy& policy); + OutputProductionDecision Decide(const OutputProductionPressure& pressure) const; + +private: + VideoPlayoutPolicy mPolicy; +}; + +const char* OutputProductionActionName(OutputProductionAction action); diff --git a/src/video/RenderCadenceController.cpp b/src/video/RenderCadenceController.cpp new file mode 100644 index 0000000..7981a36 --- /dev/null +++ b/src/video/RenderCadenceController.cpp @@ -0,0 +1,102 @@ +#include "RenderCadenceController.h" + +#include +#include + +void RenderCadenceController::Configure(Duration targetFrameDuration, TimePoint firstRenderTime, const RenderCadencePolicy& policy) +{ + mTargetFrameDuration = IsPositive(targetFrameDuration) ? targetFrameDuration : std::chrono::milliseconds(1); + mPolicy = policy; + if (mPolicy.skipThresholdFrames < 1.0) + mPolicy.skipThresholdFrames = 1.0; + Reset(firstRenderTime); +} + +void RenderCadenceController::Reset(TimePoint firstRenderTime) +{ + mNextRenderTime = firstRenderTime; + mNextFrameIndex = 0; + mMetrics = RenderCadenceMetrics(); +} + +RenderCadenceDecision RenderCadenceController::Tick(TimePoint now) +{ + RenderCadenceDecision decision; + decision.frameIndex = mNextFrameIndex; + decision.renderTargetTime = mNextRenderTime; + decision.nextRenderTime = mNextRenderTime; + + if (now < mNextRenderTime) + { + decision.action = RenderCadenceAction::Wait; + decision.waitDuration = mNextRenderTime - now; + decision.reason = "waiting-for-next-render-tick"; + return decision; + } + + const Duration lateness = now - mNextRenderTime; + const uint64_t skippedTicks = SkippedTicksForLateness(lateness); + if (skippedTicks > 0) + { + decision.skippedTicks = skippedTicks; + decision.frameIndex = mNextFrameIndex + skippedTicks; + decision.renderTargetTime = mNextRenderTime + (mTargetFrameDuration * skippedTicks); + decision.reason = "late-skip-render-ticks"; + mMetrics.skippedTickCount += skippedTicks; + } + else + { + decision.reason = IsPositive(lateness) ? "late-render-now" : "on-time-render"; + } + + decision.action = RenderCadenceAction::Render; + decision.lateness = now > decision.renderTargetTime + ? now - decision.renderTargetTime + : Duration::zero(); + mNextFrameIndex = decision.frameIndex + 1; + mNextRenderTime = decision.renderTargetTime + mTargetFrameDuration; + decision.nextRenderTime = mNextRenderTime; + + ++mMetrics.renderedFrameCount; + mMetrics.nextFrameIndex = mNextFrameIndex; + mMetrics.lastLateness = decision.lateness; + if (IsPositive(decision.lateness)) + { + ++mMetrics.lateFrameCount; + mMetrics.maxLateness = (std::max)(mMetrics.maxLateness, decision.lateness); + } + + return decision; +} + +uint64_t RenderCadenceController::SkippedTicksForLateness(Duration lateness) const +{ + if (!mPolicy.skipLateTicks || !IsPositive(lateness) || !IsPositive(mTargetFrameDuration)) + return 0; + + const double lateFrames = static_cast(lateness.count()) / static_cast(mTargetFrameDuration.count()); + if (lateFrames < mPolicy.skipThresholdFrames) + return 0; + + const uint64_t elapsedTicks = static_cast(std::floor(lateFrames)); + if (elapsedTicks == 0) + return 0; + return (std::min)(elapsedTicks, mPolicy.maxSkippedTicksPerDecision); +} + +bool RenderCadenceController::IsPositive(Duration duration) +{ + return duration > Duration::zero(); +} + +const char* RenderCadenceActionName(RenderCadenceAction action) +{ + switch (action) + { + case RenderCadenceAction::Render: + return "Render"; + case RenderCadenceAction::Wait: + default: + return "Wait"; + } +} diff --git a/src/video/RenderCadenceController.h b/src/video/RenderCadenceController.h new file mode 100644 index 0000000..8eba0ef --- /dev/null +++ b/src/video/RenderCadenceController.h @@ -0,0 +1,68 @@ +#pragma once + +#include +#include + +enum class RenderCadenceAction +{ + Wait, + Render +}; + +struct RenderCadencePolicy +{ + bool skipLateTicks = true; + uint64_t maxSkippedTicksPerDecision = 4; + double skipThresholdFrames = 2.0; +}; + +struct RenderCadenceDecision +{ + RenderCadenceAction action = RenderCadenceAction::Wait; + uint64_t frameIndex = 0; + uint64_t skippedTicks = 0; + std::chrono::steady_clock::time_point renderTargetTime; + std::chrono::steady_clock::time_point nextRenderTime; + std::chrono::steady_clock::duration waitDuration = std::chrono::steady_clock::duration::zero(); + std::chrono::steady_clock::duration lateness = std::chrono::steady_clock::duration::zero(); + const char* reason = "waiting-for-next-render-tick"; +}; + +struct RenderCadenceMetrics +{ + uint64_t nextFrameIndex = 0; + uint64_t renderedFrameCount = 0; + uint64_t skippedTickCount = 0; + uint64_t lateFrameCount = 0; + std::chrono::steady_clock::duration lastLateness = std::chrono::steady_clock::duration::zero(); + std::chrono::steady_clock::duration maxLateness = std::chrono::steady_clock::duration::zero(); +}; + +class RenderCadenceController +{ +public: + using Clock = std::chrono::steady_clock; + using TimePoint = Clock::time_point; + using Duration = Clock::duration; + + void Configure(Duration targetFrameDuration, TimePoint firstRenderTime, const RenderCadencePolicy& policy = RenderCadencePolicy()); + void Reset(TimePoint firstRenderTime); + RenderCadenceDecision Tick(TimePoint now); + + Duration TargetFrameDuration() const { return mTargetFrameDuration; } + TimePoint NextRenderTime() const { return mNextRenderTime; } + uint64_t NextFrameIndex() const { return mNextFrameIndex; } + const RenderCadenceMetrics& Metrics() const { return mMetrics; } + +private: + uint64_t SkippedTicksForLateness(Duration lateness) const; + static bool IsPositive(Duration duration); + + Duration mTargetFrameDuration = std::chrono::milliseconds(16); + TimePoint mNextRenderTime; + uint64_t mNextFrameIndex = 0; + RenderCadencePolicy mPolicy; + RenderCadenceMetrics mMetrics; +}; + +const char* RenderCadenceActionName(RenderCadenceAction action); diff --git a/src/video/RenderOutputQueue.cpp b/src/video/RenderOutputQueue.cpp new file mode 100644 index 0000000..c68660b --- /dev/null +++ b/src/video/RenderOutputQueue.cpp @@ -0,0 +1,93 @@ +#include "RenderOutputQueue.h" + +RenderOutputQueue::RenderOutputQueue(const VideoPlayoutPolicy& policy) : + mPolicy(NormalizeVideoPlayoutPolicy(policy)) +{ +} + +void RenderOutputQueue::Configure(const VideoPlayoutPolicy& policy) +{ + std::lock_guard lock(mMutex); + mPolicy = NormalizeVideoPlayoutPolicy(policy); + while (mReadyFrames.size() > CapacityLocked()) + { + ReleaseFrame(mReadyFrames.front()); + mReadyFrames.pop_front(); + ++mDroppedCount; + } +} + +bool RenderOutputQueue::Push(RenderOutputFrame frame) +{ + std::lock_guard lock(mMutex); + if (mReadyFrames.size() >= CapacityLocked()) + { + ReleaseFrame(mReadyFrames.front()); + mReadyFrames.pop_front(); + ++mDroppedCount; + } + + mReadyFrames.push_back(frame); + ++mPushedCount; + return true; +} + +bool RenderOutputQueue::TryPop(RenderOutputFrame& frame) +{ + std::lock_guard lock(mMutex); + if (mReadyFrames.empty()) + { + ++mUnderrunCount; + return false; + } + + frame = mReadyFrames.front(); + mReadyFrames.pop_front(); + ++mPoppedCount; + return true; +} + +bool RenderOutputQueue::DropOldestFrame() +{ + std::lock_guard lock(mMutex); + if (mReadyFrames.empty()) + return false; + + ReleaseFrame(mReadyFrames.front()); + mReadyFrames.pop_front(); + ++mDroppedCount; + return true; +} + +void RenderOutputQueue::Clear() +{ + std::lock_guard lock(mMutex); + for (RenderOutputFrame& frame : mReadyFrames) + ReleaseFrame(frame); + mReadyFrames.clear(); +} + +RenderOutputQueueMetrics RenderOutputQueue::GetMetrics() const +{ + std::lock_guard lock(mMutex); + RenderOutputQueueMetrics metrics; + metrics.depth = mReadyFrames.size(); + metrics.capacity = CapacityLocked(); + metrics.pushedCount = mPushedCount; + metrics.poppedCount = mPoppedCount; + metrics.droppedCount = mDroppedCount; + metrics.underrunCount = mUnderrunCount; + return metrics; +} + +std::size_t RenderOutputQueue::CapacityLocked() const +{ + return static_cast(mPolicy.maxReadyFrames); +} + +void RenderOutputQueue::ReleaseFrame(RenderOutputFrame& frame) +{ + if (frame.releaseFrame) + frame.releaseFrame(frame.frame); + frame.releaseFrame = {}; +} diff --git a/src/video/RenderOutputQueue.h b/src/video/RenderOutputQueue.h new file mode 100644 index 0000000..0a9109a --- /dev/null +++ b/src/video/RenderOutputQueue.h @@ -0,0 +1,52 @@ +#pragma once + +#include "VideoIOTypes.h" +#include "VideoPlayoutPolicy.h" + +#include +#include +#include +#include + +struct RenderOutputFrame +{ + VideoIOOutputFrame frame; + uint64_t frameIndex = 0; + bool stale = false; + std::function releaseFrame; +}; + +struct RenderOutputQueueMetrics +{ + std::size_t depth = 0; + std::size_t capacity = 0; + uint64_t pushedCount = 0; + uint64_t poppedCount = 0; + uint64_t droppedCount = 0; + uint64_t underrunCount = 0; +}; + +class RenderOutputQueue +{ +public: + explicit RenderOutputQueue(const VideoPlayoutPolicy& policy = VideoPlayoutPolicy()); + + void Configure(const VideoPlayoutPolicy& policy); + bool Push(RenderOutputFrame frame); + bool TryPop(RenderOutputFrame& frame); + bool DropOldestFrame(); + void Clear(); + RenderOutputQueueMetrics GetMetrics() const; + +private: + std::size_t CapacityLocked() const; + static void ReleaseFrame(RenderOutputFrame& frame); + + mutable std::mutex mMutex; + VideoPlayoutPolicy mPolicy; + std::deque mReadyFrames; + uint64_t mPushedCount = 0; + uint64_t mPoppedCount = 0; + uint64_t mDroppedCount = 0; + uint64_t mUnderrunCount = 0; +}; diff --git a/src/video/SystemOutputFramePool.cpp b/src/video/SystemOutputFramePool.cpp new file mode 100644 index 0000000..8318d28 --- /dev/null +++ b/src/video/SystemOutputFramePool.cpp @@ -0,0 +1,260 @@ +#include "SystemOutputFramePool.h" + +#include + +namespace +{ +SystemOutputFramePoolConfig NormalizeConfig(SystemOutputFramePoolConfig config) +{ + if (config.rowBytes == 0) + config.rowBytes = VideoIORowBytes(config.pixelFormat, config.width); + return config; +} +} + +SystemOutputFramePool::SystemOutputFramePool(const SystemOutputFramePoolConfig& config) +{ + Configure(config); +} + +void SystemOutputFramePool::Configure(const SystemOutputFramePoolConfig& config) +{ + std::lock_guard lock(mMutex); + mConfig = NormalizeConfig(config); + mReadySlots.clear(); + mSlots.clear(); + mSlots.resize(mConfig.capacity); + + const std::size_t byteCount = FrameByteCount(); + for (StoredSlot& slot : mSlots) + { + slot.bytes.resize(byteCount); + slot.state = OutputFrameSlotState::Free; + ++slot.generation; + } + + mAcquireMissCount = 0; + mReadyUnderrunCount = 0; +} + +SystemOutputFramePoolConfig SystemOutputFramePool::Config() const +{ + std::lock_guard lock(mMutex); + return mConfig; +} + +bool SystemOutputFramePool::AcquireFreeSlot(OutputFrameSlot& slot) +{ + std::lock_guard lock(mMutex); + for (std::size_t index = 0; index < mSlots.size(); ++index) + { + if (mSlots[index].state != OutputFrameSlotState::Free) + continue; + + mSlots[index].state = OutputFrameSlotState::Rendering; + ++mSlots[index].generation; + FillOutputSlotLocked(index, slot); + return true; + } + + slot = OutputFrameSlot(); + ++mAcquireMissCount; + return false; +} + +bool SystemOutputFramePool::AcquireRenderingSlot(OutputFrameSlot& slot) +{ + return AcquireFreeSlot(slot); +} + +bool SystemOutputFramePool::PublishReadySlot(const OutputFrameSlot& slot) +{ + std::lock_guard lock(mMutex); + if (!TransitionSlotLocked(slot, OutputFrameSlotState::Rendering, OutputFrameSlotState::Completed)) + return false; + + mReadySlots.push_back(slot.index); + return true; +} + +bool SystemOutputFramePool::PublishCompletedSlot(const OutputFrameSlot& slot) +{ + return PublishReadySlot(slot); +} + +bool SystemOutputFramePool::ConsumeReadySlot(OutputFrameSlot& slot) +{ + std::lock_guard lock(mMutex); + while (!mReadySlots.empty()) + { + const std::size_t index = mReadySlots.front(); + mReadySlots.pop_front(); + if (index >= mSlots.size() || mSlots[index].state != OutputFrameSlotState::Completed) + continue; + + FillOutputSlotLocked(index, slot); + return true; + } + + slot = OutputFrameSlot(); + ++mReadyUnderrunCount; + return false; +} + +bool SystemOutputFramePool::ConsumeCompletedSlot(OutputFrameSlot& slot) +{ + return ConsumeReadySlot(slot); +} + +bool SystemOutputFramePool::MarkScheduled(const OutputFrameSlot& slot) +{ + std::lock_guard lock(mMutex); + if (!IsValidSlotLocked(slot)) + return false; + if (mSlots[slot.index].state != OutputFrameSlotState::Completed) + return false; + + RemoveReadyIndexLocked(slot.index); + mSlots[slot.index].state = OutputFrameSlotState::Scheduled; + return true; +} + +bool SystemOutputFramePool::MarkScheduledByBuffer(void* bytes) +{ + if (bytes == nullptr) + return false; + + std::lock_guard lock(mMutex); + for (std::size_t index = 0; index < mSlots.size(); ++index) + { + if (mSlots[index].bytes.empty() || mSlots[index].bytes.data() != bytes) + continue; + if (mSlots[index].state != OutputFrameSlotState::Completed) + return false; + + RemoveReadyIndexLocked(index); + mSlots[index].state = OutputFrameSlotState::Scheduled; + return true; + } + return false; +} + +bool SystemOutputFramePool::ReleaseSlot(const OutputFrameSlot& slot) +{ + std::lock_guard lock(mMutex); + if (!IsValidSlotLocked(slot) || mSlots[slot.index].state == OutputFrameSlotState::Free) + return false; + + return ReleaseSlotByIndexLocked(slot.index); +} + +bool SystemOutputFramePool::ReleaseScheduledSlot(const OutputFrameSlot& slot) +{ + std::lock_guard lock(mMutex); + return TransitionSlotLocked(slot, OutputFrameSlotState::Scheduled, OutputFrameSlotState::Free); +} + +bool SystemOutputFramePool::ReleaseSlotByBuffer(void* bytes) +{ + if (bytes == nullptr) + return false; + + std::lock_guard lock(mMutex); + for (std::size_t index = 0; index < mSlots.size(); ++index) + { + if (!mSlots[index].bytes.empty() && mSlots[index].bytes.data() == bytes) + return ReleaseSlotByIndexLocked(index); + } + return false; +} + +void SystemOutputFramePool::Clear() +{ + std::lock_guard lock(mMutex); + mReadySlots.clear(); + for (StoredSlot& slot : mSlots) + { + slot.state = OutputFrameSlotState::Free; + ++slot.generation; + } +} + +SystemOutputFramePoolMetrics SystemOutputFramePool::GetMetrics() const +{ + std::lock_guard lock(mMutex); + SystemOutputFramePoolMetrics metrics; + metrics.capacity = mSlots.size(); + metrics.readyCount = mReadySlots.size(); + metrics.acquireMissCount = mAcquireMissCount; + metrics.readyUnderrunCount = mReadyUnderrunCount; + + for (const StoredSlot& slot : mSlots) + { + switch (slot.state) + { + case OutputFrameSlotState::Free: + ++metrics.freeCount; + break; + case OutputFrameSlotState::Rendering: + ++metrics.renderingCount; + ++metrics.acquiredCount; + break; + case OutputFrameSlotState::Completed: + ++metrics.completedCount; + break; + case OutputFrameSlotState::Scheduled: + ++metrics.scheduledCount; + break; + } + } + + return metrics; +} + +bool SystemOutputFramePool::IsValidSlotLocked(const OutputFrameSlot& slot) const +{ + return slot.index < mSlots.size() && mSlots[slot.index].generation == slot.generation; +} + +bool SystemOutputFramePool::TransitionSlotLocked(const OutputFrameSlot& slot, OutputFrameSlotState expectedState, OutputFrameSlotState nextState) +{ + if (!IsValidSlotLocked(slot) || mSlots[slot.index].state != expectedState) + return false; + + mSlots[slot.index].state = nextState; + return true; +} + +void SystemOutputFramePool::FillOutputSlotLocked(std::size_t index, OutputFrameSlot& slot) +{ + StoredSlot& storedSlot = mSlots[index]; + slot.index = index; + slot.generation = storedSlot.generation; + slot.frame.bytes = storedSlot.bytes.empty() ? nullptr : storedSlot.bytes.data(); + slot.frame.rowBytes = static_cast(mConfig.rowBytes); + slot.frame.width = mConfig.width; + slot.frame.height = mConfig.height; + slot.frame.pixelFormat = mConfig.pixelFormat; + slot.frame.nativeFrame = nullptr; + slot.frame.nativeBuffer = slot.frame.bytes; +} + +void SystemOutputFramePool::RemoveReadyIndexLocked(std::size_t index) +{ + mReadySlots.erase(std::remove(mReadySlots.begin(), mReadySlots.end(), index), mReadySlots.end()); +} + +bool SystemOutputFramePool::ReleaseSlotByIndexLocked(std::size_t index) +{ + if (index >= mSlots.size() || mSlots[index].state == OutputFrameSlotState::Free) + return false; + + RemoveReadyIndexLocked(index); + mSlots[index].state = OutputFrameSlotState::Free; + return true; +} + +std::size_t SystemOutputFramePool::FrameByteCount() const +{ + return static_cast(mConfig.rowBytes) * static_cast(mConfig.height); +} diff --git a/src/video/SystemOutputFramePool.h b/src/video/SystemOutputFramePool.h new file mode 100644 index 0000000..f0ec666 --- /dev/null +++ b/src/video/SystemOutputFramePool.h @@ -0,0 +1,94 @@ +#pragma once + +#include "VideoIOTypes.h" + +#include +#include +#include +#include +#include + +enum class OutputFrameSlotState +{ + Free, + Rendering, + Completed, + Scheduled +}; + +struct SystemOutputFramePoolConfig +{ + unsigned width = 0; + unsigned height = 0; + VideoIOPixelFormat pixelFormat = VideoIOPixelFormat::Bgra8; + unsigned rowBytes = 0; + std::size_t capacity = 0; +}; + +struct OutputFrameSlot +{ + VideoIOOutputFrame frame; + std::size_t index = 0; + uint64_t generation = 0; +}; + +struct SystemOutputFramePoolMetrics +{ + std::size_t capacity = 0; + std::size_t freeCount = 0; + std::size_t renderingCount = 0; + std::size_t completedCount = 0; + std::size_t scheduledCount = 0; + std::size_t acquiredCount = 0; + std::size_t readyCount = 0; + std::size_t consumedCount = 0; + uint64_t acquireMissCount = 0; + uint64_t readyUnderrunCount = 0; +}; + +class SystemOutputFramePool +{ +public: + SystemOutputFramePool() = default; + explicit SystemOutputFramePool(const SystemOutputFramePoolConfig& config); + + void Configure(const SystemOutputFramePoolConfig& config); + SystemOutputFramePoolConfig Config() const; + + bool AcquireFreeSlot(OutputFrameSlot& slot); + bool AcquireRenderingSlot(OutputFrameSlot& slot); + bool PublishReadySlot(const OutputFrameSlot& slot); + bool PublishCompletedSlot(const OutputFrameSlot& slot); + bool ConsumeReadySlot(OutputFrameSlot& slot); + bool ConsumeCompletedSlot(OutputFrameSlot& slot); + bool MarkScheduled(const OutputFrameSlot& slot); + bool MarkScheduledByBuffer(void* bytes); + bool ReleaseSlot(const OutputFrameSlot& slot); + bool ReleaseScheduledSlot(const OutputFrameSlot& slot); + bool ReleaseSlotByBuffer(void* bytes); + void Clear(); + + SystemOutputFramePoolMetrics GetMetrics() const; + +private: + struct StoredSlot + { + std::vector bytes; + OutputFrameSlotState state = OutputFrameSlotState::Free; + uint64_t generation = 1; + }; + + bool IsValidSlotLocked(const OutputFrameSlot& slot) const; + bool TransitionSlotLocked(const OutputFrameSlot& slot, OutputFrameSlotState expectedState, OutputFrameSlotState nextState); + void FillOutputSlotLocked(std::size_t index, OutputFrameSlot& slot); + void RemoveReadyIndexLocked(std::size_t index); + bool ReleaseSlotByIndexLocked(std::size_t index); + std::size_t FrameByteCount() const; + + mutable std::mutex mMutex; + SystemOutputFramePoolConfig mConfig; + std::vector mSlots; + std::deque mReadySlots; + uint64_t mAcquireMissCount = 0; + uint64_t mReadyUnderrunCount = 0; +}; diff --git a/src/video/VideoBackend.cpp b/src/video/VideoBackend.cpp new file mode 100644 index 0000000..af03541 --- /dev/null +++ b/src/video/VideoBackend.cpp @@ -0,0 +1,1095 @@ +#include "VideoBackend.h" + +#include "DeckLinkSession.h" +#include "OpenGLVideoIOBridge.h" +#include "HealthTelemetry.h" +#include "RenderEngine.h" +#include "RuntimeEventDispatcher.h" + +#include +#include +#include +#include +#include +#include + +VideoBackend::VideoBackend(RenderEngine& renderEngine, HealthTelemetry& healthTelemetry, RuntimeEventDispatcher& runtimeEventDispatcher) : + mHealthTelemetry(healthTelemetry), + mRuntimeEventDispatcher(runtimeEventDispatcher), + mPlayoutPolicy(NormalizeVideoPlayoutPolicy(VideoPlayoutPolicy())), + mOutputProductionController(mPlayoutPolicy), + mReadyOutputQueue(mPlayoutPolicy), + mVideoIODevice(std::make_unique()), + mBridge(std::make_unique(renderEngine)), + mInputCaptureDisabled(IsEnvironmentFlagEnabled("VST_DISABLE_INPUT_CAPTURE")) +{ +} + +VideoBackend::~VideoBackend() +{ + ReleaseResources(); +} + +void VideoBackend::ReleaseResources() +{ + StopOutputCompletionWorker(); + mReadyOutputQueue.Clear(); + if (mVideoIODevice) + mVideoIODevice->ReleaseResources(); + mSystemOutputFramePool.Clear(); + if (!VideoBackendLifecycle::CanTransition(mLifecycle.State(), VideoBackendLifecycleState::Stopped)) + ApplyLifecycleFailure("Video backend resources released before lifecycle completed."); + ApplyLifecycleTransition(VideoBackendLifecycleState::Stopped, "Video backend resources released."); +} + +VideoBackendLifecycleState VideoBackend::LifecycleState() const +{ + return mLifecycle.State(); +} + +bool VideoBackend::DiscoverDevicesAndModes(const VideoFormatSelection& videoModes, std::string& error) +{ + ApplyLifecycleTransition(VideoBackendLifecycleState::Discovering, "Discovering video backend devices and modes."); + if (mVideoIODevice->DiscoverDevicesAndModes(videoModes, error)) + return ApplyLifecycleTransition(VideoBackendLifecycleState::Discovered, "Video backend devices and modes discovered."); + + ApplyLifecycleFailure(error.empty() ? "Video backend discovery failed." : error); + return false; +} + +bool VideoBackend::SelectPreferredFormats(const VideoFormatSelection& videoModes, bool outputAlphaRequired, std::string& error) +{ + ApplyLifecycleTransition(VideoBackendLifecycleState::Configuring, "Selecting preferred video backend formats."); + if (mVideoIODevice->SelectPreferredFormats(videoModes, outputAlphaRequired, error)) + return true; + + ApplyLifecycleFailure(error.empty() ? "Video backend format selection failed." : error); + return false; +} + +bool VideoBackend::ConfigureInput(const VideoFormat& inputVideoMode, std::string& error) +{ + if (mLifecycle.State() != VideoBackendLifecycleState::Configuring) + ApplyLifecycleTransition(VideoBackendLifecycleState::Configuring, "Configuring video backend input."); + if (mInputCaptureDisabled) + { + MutableState().hasInputSource = false; + MutableState().statusMessage = "DeckLink input capture disabled by VST_DISABLE_INPUT_CAPTURE for output timing isolation."; + return true; + } + if (!mVideoIODevice->ConfigureInput( + [this](const VideoIOFrame& frame) { HandleInputFrame(frame); }, + inputVideoMode, + error)) + { + ApplyLifecycleFailure(error.empty() ? "Video backend input configuration failed." : error); + return false; + } + return true; +} + +bool VideoBackend::ConfigureOutput(const VideoFormat& outputVideoMode, bool externalKeyingEnabled, std::string& error) +{ + mPlayoutPolicy = NormalizeVideoPlayoutPolicy(mPlayoutPolicy); + mOutputProductionController.Configure(mPlayoutPolicy); + mReadyOutputQueue.Configure(mPlayoutPolicy); + if (mLifecycle.State() != VideoBackendLifecycleState::Configuring) + ApplyLifecycleTransition(VideoBackendLifecycleState::Configuring, "Configuring video backend output."); + if (!mVideoIODevice->ConfigureOutput( + [this](const VideoIOCompletion& completion) { HandleOutputFrameCompletion(completion); }, + outputVideoMode, + externalKeyingEnabled, + error)) + { + ApplyLifecycleFailure(error.empty() ? "Video backend output configuration failed." : error); + return false; + } + SystemOutputFramePoolConfig poolConfig; + poolConfig.width = mVideoIODevice->OutputFrameWidth(); + poolConfig.height = mVideoIODevice->OutputFrameHeight(); + poolConfig.pixelFormat = mVideoIODevice->OutputPixelFormat(); + poolConfig.rowBytes = mVideoIODevice->OutputFrameRowBytes(); + poolConfig.capacity = mPlayoutPolicy.outputFramePoolSize; + mSystemOutputFramePool.Configure(poolConfig); + RecordSystemMemoryPlayoutStats(); + return ApplyLifecycleTransition(VideoBackendLifecycleState::Configured, "Video backend configured."); +} + +bool VideoBackend::Start() +{ + ApplyLifecycleTransition(VideoBackendLifecycleState::Prerolling, "Video backend preroll starting."); + if (!mVideoIODevice->PrepareOutputSchedule()) + { + ApplyLifecycleFailure(StatusMessage().empty() ? "Video backend output schedule preparation failed." : StatusMessage()); + return false; + } + + StartOutputCompletionWorker(); + StartOutputProducerWorker(); + + if (!WarmupOutputPreroll()) + { + StopOutputProducerWorker(); + StopOutputCompletionWorker(); + ApplyLifecycleFailure(StatusMessage().empty() ? "Video backend preroll warmup failed." : StatusMessage()); + return false; + } + + if (!mInputCaptureDisabled && !mVideoIODevice->StartInputStreams()) + { + StopOutputProducerWorker(); + StopOutputCompletionWorker(); + ApplyLifecycleFailure(StatusMessage().empty() ? "Video backend input stream start failed." : StatusMessage()); + return false; + } + + if (!mVideoIODevice->StartScheduledPlayback()) + { + StopOutputProducerWorker(); + mVideoIODevice->Stop(); + StopOutputCompletionWorker(); + ApplyLifecycleFailure(StatusMessage().empty() ? "Video backend scheduled playback start failed." : StatusMessage()); + return false; + } + + ApplyLifecycleTransition(VideoBackendLifecycleState::Running, "Video backend started."); + return true; +} + +bool VideoBackend::Stop() +{ + ApplyLifecycleTransition(VideoBackendLifecycleState::Stopping, "Video backend stopping."); + StopOutputProducerWorker(); + const bool stopped = mVideoIODevice->Stop(); + StopOutputCompletionWorker(); + if (stopped) + ApplyLifecycleTransition(VideoBackendLifecycleState::Stopped, "Video backend stopped."); + else + ApplyLifecycleFailure(StatusMessage().empty() ? "Video backend stop failed." : StatusMessage()); + return stopped; +} + +const VideoIOState& VideoBackend::State() const +{ + return mVideoIODevice->State(); +} + +VideoIOState& VideoBackend::MutableState() +{ + return mVideoIODevice->MutableState(); +} + +bool VideoBackend::BeginOutputFrame(VideoIOOutputFrame& frame) +{ + return mVideoIODevice->BeginOutputFrame(frame); +} + +void VideoBackend::EndOutputFrame(VideoIOOutputFrame& frame) +{ + mVideoIODevice->EndOutputFrame(frame); +} + +bool VideoBackend::ScheduleOutputFrame(const VideoIOOutputFrame& frame) +{ + return mVideoIODevice->ScheduleOutputFrame(frame); +} + +VideoPlayoutRecoveryDecision VideoBackend::AccountForCompletionResult(VideoIOCompletionResult result, uint64_t readyQueueDepth) +{ + return mVideoIODevice->AccountForCompletionResult(result, readyQueueDepth); +} + +bool VideoBackend::HasInputDevice() const +{ + return mVideoIODevice->HasInputDevice(); +} + +bool VideoBackend::HasInputSource() const +{ + if (mInputCaptureDisabled) + return false; + return mVideoIODevice->HasInputSource(); +} + +unsigned VideoBackend::InputFrameWidth() const +{ + return mVideoIODevice->InputFrameWidth(); +} + +unsigned VideoBackend::InputFrameHeight() const +{ + return mVideoIODevice->InputFrameHeight(); +} + +unsigned VideoBackend::OutputFrameWidth() const +{ + return mVideoIODevice->OutputFrameWidth(); +} + +unsigned VideoBackend::OutputFrameHeight() const +{ + return mVideoIODevice->OutputFrameHeight(); +} + +unsigned VideoBackend::CaptureTextureWidth() const +{ + return mVideoIODevice->CaptureTextureWidth(); +} + +unsigned VideoBackend::OutputPackTextureWidth() const +{ + return mVideoIODevice->OutputPackTextureWidth(); +} + +VideoIOPixelFormat VideoBackend::InputPixelFormat() const +{ + return mVideoIODevice->InputPixelFormat(); +} + +const std::string& VideoBackend::InputDisplayModeName() const +{ + return mVideoIODevice->InputDisplayModeName(); +} + +const std::string& VideoBackend::OutputModelName() const +{ + return mVideoIODevice->OutputModelName(); +} + +bool VideoBackend::SupportsInternalKeying() const +{ + return mVideoIODevice->SupportsInternalKeying(); +} + +bool VideoBackend::SupportsExternalKeying() const +{ + return mVideoIODevice->SupportsExternalKeying(); +} + +bool VideoBackend::KeyerInterfaceAvailable() const +{ + return mVideoIODevice->KeyerInterfaceAvailable(); +} + +bool VideoBackend::ExternalKeyingActive() const +{ + return mVideoIODevice->ExternalKeyingActive(); +} + +const std::string& VideoBackend::StatusMessage() const +{ + return mVideoIODevice->StatusMessage(); +} + +bool VideoBackend::ShouldPrioritizeOutputOverPreview() const +{ + const RenderOutputQueueMetrics metrics = mReadyOutputQueue.GetMetrics(); + return metrics.depth < static_cast(mPlayoutPolicy.targetReadyFrames); +} + +void VideoBackend::SetStatusMessage(const std::string& message) +{ + mVideoIODevice->SetStatusMessage(message); +} + +void VideoBackend::PublishStatus(bool externalKeyingConfigured, const std::string& statusMessage) +{ + if (!statusMessage.empty()) + SetStatusMessage(statusMessage); + + mHealthTelemetry.ReportVideoIOStatus( + "decklink", + OutputModelName(), + SupportsInternalKeying(), + SupportsExternalKeying(), + KeyerInterfaceAvailable(), + externalKeyingConfigured, + ExternalKeyingActive(), + StatusMessage()); + PublishBackendStateChanged(VideoBackendLifecycle::StateName(mLifecycle.State()), StatusMessage()); +} + +void VideoBackend::ReportNoInputDeviceSignalStatus() +{ + mHealthTelemetry.ReportSignalStatus( + false, + InputFrameWidth(), + InputFrameHeight(), + InputDisplayModeName()); + PublishBackendStateChanged("no-input-device", "No input device is available."); +} + +void VideoBackend::HandleInputFrame(const VideoIOFrame& frame) +{ + if (mInputCaptureDisabled) + return; + + const VideoIOState& state = mVideoIODevice->State(); + mHealthTelemetry.TryReportSignalStatus(!frame.hasNoInputSource, state.inputFrameSize.width, state.inputFrameSize.height, state.inputDisplayModeName); + PublishInputSignalChanged(frame, state); + PublishInputFrameArrived(frame); + + if (mBridge) + mBridge->UploadInputFrame(frame, state); +} + +void VideoBackend::HandleOutputFrameCompletion(const VideoIOCompletion& completion) +{ + { + std::lock_guard lock(mOutputCompletionMutex); + if (!mOutputCompletionWorkerRunning || mOutputCompletionWorkerStopping) + return; + mPendingOutputCompletions.push_back(completion); + } + mOutputCompletionCondition.notify_one(); +} + +void VideoBackend::StartOutputCompletionWorker() +{ + { + std::lock_guard lock(mOutputCompletionMutex); + if (mOutputCompletionWorkerRunning) + return; + + mPendingOutputCompletions.clear(); + mReadyOutputQueue.Clear(); + mNextReadyOutputFrameIndex = 0; + mHasReadyQueueDepthBaseline = false; + mMinReadyQueueDepth = 0; + mMaxReadyQueueDepth = 0; + mReadyQueueZeroDepthCount = 0; + mOutputRenderMilliseconds = 0.0; + mSmoothedOutputRenderMilliseconds = 0.0; + mMaxOutputRenderMilliseconds = 0.0; + mOutputFrameAcquireMilliseconds = 0.0; + mOutputFrameRenderRequestMilliseconds = 0.0; + mOutputFrameEndAccessMilliseconds = 0.0; + mLastLateStreak = 0; + mLastDropStreak = 0; + mOutputCompletionWorkerStopping = false; + mOutputCompletionWorkerRunning = true; + mOutputCompletionWorker = std::thread(&VideoBackend::OutputCompletionWorkerMain, this); + } +} + +void VideoBackend::StopOutputCompletionWorker() +{ + StopOutputProducerWorker(); + + bool shouldJoin = false; + { + std::lock_guard lock(mOutputCompletionMutex); + if (mOutputCompletionWorkerRunning) + mOutputCompletionWorkerStopping = true; + shouldJoin = mOutputCompletionWorker.joinable(); + } + mOutputCompletionCondition.notify_one(); + + if (shouldJoin) + mOutputCompletionWorker.join(); +} + +void VideoBackend::StartOutputProducerWorker() +{ + std::lock_guard lock(mOutputProducerMutex); + if (mOutputProducerWorkerRunning) + return; + + const double frameBudgetMilliseconds = State().frameBudgetMilliseconds; + const auto frameDuration = frameBudgetMilliseconds > 0.0 + ? std::chrono::duration_cast( + std::chrono::duration(frameBudgetMilliseconds)) + : std::chrono::milliseconds(16); + mRenderCadenceController.Configure(frameDuration, std::chrono::steady_clock::now()); + mLastOutputProductionCompletion = VideoIOCompletion(); + mLastOutputProductionTime = std::chrono::steady_clock::time_point(); + mOutputProducerWorkerStopping = false; + mOutputProducerWorkerRunning = true; + mOutputProducerWorker = std::thread(&VideoBackend::OutputProducerWorkerMain, this); + mOutputProducerCondition.notify_one(); +} + +void VideoBackend::StopOutputProducerWorker() +{ + bool shouldJoin = false; + { + std::lock_guard lock(mOutputProducerMutex); + if (mOutputProducerWorkerRunning) + mOutputProducerWorkerStopping = true; + shouldJoin = mOutputProducerWorker.joinable(); + } + mOutputProducerCondition.notify_one(); + + if (shouldJoin) + mOutputProducerWorker.join(); +} + +void VideoBackend::NotifyOutputProducer() +{ + mOutputProducerCondition.notify_one(); +} + +bool VideoBackend::WarmupOutputPreroll() +{ + const VideoPlayoutPolicy policy = NormalizeVideoPlayoutPolicy(mPlayoutPolicy); + const std::size_t targetPrerollFrames = static_cast(policy.targetPrerollFrames); + if (targetPrerollFrames == 0) + return true; + + const double frameBudgetMilliseconds = State().frameBudgetMilliseconds > 0.0 ? State().frameBudgetMilliseconds : 16.0; + const auto estimatedCadenceTime = std::chrono::duration_cast( + std::chrono::duration(frameBudgetMilliseconds * static_cast(targetPrerollFrames + 2))); + const auto timeout = (std::max)(std::chrono::milliseconds(1000), estimatedCadenceTime + std::chrono::milliseconds(500)); + const auto deadline = std::chrono::steady_clock::now() + timeout; + + while (std::chrono::steady_clock::now() < deadline) + { + ScheduleReadyOutputFramesToTarget(); + const SystemOutputFramePoolMetrics metrics = mSystemOutputFramePool.GetMetrics(); + RecordSystemMemoryPlayoutStats(); + if (metrics.scheduledCount >= targetPrerollFrames) + return true; + + NotifyOutputProducer(); + const auto waitDuration = (std::min)(OutputProducerWakeInterval(), std::chrono::milliseconds(5)); + std::unique_lock lock(mOutputProducerMutex); + mOutputProducerCondition.wait_for(lock, waitDuration); + if (mOutputProducerWorkerStopping) + return false; + } + + SetStatusMessage("Timed out warming up DeckLink preroll from rendered system-memory frames."); + return false; +} + +void VideoBackend::OutputCompletionWorkerMain() +{ + for (;;) + { + VideoIOCompletion completion; + { + std::unique_lock lock(mOutputCompletionMutex); + mOutputCompletionCondition.wait(lock, [this]() { + return mOutputCompletionWorkerStopping || !mPendingOutputCompletions.empty(); + }); + + if (mPendingOutputCompletions.empty()) + { + if (mOutputCompletionWorkerStopping) + { + mOutputCompletionWorkerRunning = false; + return; + } + continue; + } + + completion = mPendingOutputCompletions.front(); + mPendingOutputCompletions.pop_front(); + } + + ProcessOutputFrameCompletion(completion); + } +} + +void VideoBackend::OutputProducerWorkerMain() +{ + for (;;) + { + { + std::lock_guard lock(mOutputProducerMutex); + if (mOutputProducerWorkerStopping) + { + mOutputProducerWorkerRunning = false; + return; + } + } + + ScheduleReadyOutputFramesToTarget(); + + const RenderOutputQueueMetrics metrics = mReadyOutputQueue.GetMetrics(); + RecordReadyQueueDepthSample(metrics); + + const auto now = std::chrono::steady_clock::now(); + RenderCadenceDecision cadenceDecision = mRenderCadenceController.Tick(now); + if (cadenceDecision.action == RenderCadenceAction::Wait) + { + const auto waitDuration = (std::min)( + std::chrono::duration_cast(cadenceDecision.waitDuration), + OutputProducerWakeInterval()); + std::unique_lock lock(mOutputProducerMutex); + mOutputProducerCondition.wait_for(lock, waitDuration); + if (mOutputProducerWorkerStopping) + { + mOutputProducerWorkerRunning = false; + return; + } + continue; + } + + VideoIOCompletion completion; + { + std::lock_guard lock(mOutputProducerMutex); + if (mOutputProducerWorkerStopping) + continue; + completion = mLastOutputProductionCompletion; + } + + const std::size_t producedFrames = ProduceReadyOutputFrames(completion, 1); + if (producedFrames > 0) + { + mLastOutputProductionTime = std::chrono::steady_clock::now(); + ScheduleReadyOutputFramesToTarget(); + continue; + } + + { + std::unique_lock lock(mOutputProducerMutex); + mOutputProducerCondition.wait_for(lock, OutputProducerWakeInterval()); + if (mOutputProducerWorkerStopping) + { + mOutputProducerWorkerRunning = false; + return; + } + } + } +} + +std::chrono::milliseconds VideoBackend::OutputProducerWakeInterval() const +{ + const double frameBudgetMilliseconds = State().frameBudgetMilliseconds; + if (frameBudgetMilliseconds <= 0.0) + return std::chrono::milliseconds(8); + + const int intervalMilliseconds = (std::max)(1, static_cast(std::floor(frameBudgetMilliseconds * 0.75))); + return std::chrono::milliseconds(intervalMilliseconds); +} + +void VideoBackend::ProcessOutputFrameCompletion(const VideoIOCompletion& completion) +{ + if (completion.outputFrameBuffer != nullptr) + mSystemOutputFramePool.ReleaseSlotByBuffer(completion.outputFrameBuffer); + RecordFramePacing(completion.result); + PublishOutputFrameCompleted(completion); + const RenderOutputQueueMetrics initialQueueMetrics = mReadyOutputQueue.GetMetrics(); + RecordReadyQueueDepthSample(initialQueueMetrics); + const VideoPlayoutRecoveryDecision recoveryDecision = AccountForCompletionResult(completion.result, initialQueueMetrics.depth); + { + std::lock_guard lock(mOutputMetricsMutex); + mLastLateStreak = recoveryDecision.lateStreak; + mLastDropStreak = recoveryDecision.dropStreak; + } + { + std::lock_guard lock(mOutputProducerMutex); + mLastOutputProductionCompletion = completion; + } + NotifyOutputProducer(); + + RecordBackendPlayoutHealth(completion.result, recoveryDecision); + RecordSystemMemoryPlayoutStats(); +} + +std::size_t VideoBackend::ScheduleReadyOutputFramesToTarget() +{ + const std::size_t targetScheduledFrames = static_cast(mPlayoutPolicy.targetPrerollFrames); + std::size_t scheduledFrames = 0; + for (;;) + { + const SystemOutputFramePoolMetrics poolMetrics = mSystemOutputFramePool.GetMetrics(); + if (poolMetrics.scheduledCount >= targetScheduledFrames) + break; + if (!ScheduleReadyOutputFrame()) + break; + ++scheduledFrames; + } + return scheduledFrames; +} + +void VideoBackend::RecordBackendPlayoutHealth(VideoIOCompletionResult result, const VideoPlayoutRecoveryDecision& recoveryDecision) +{ + const RenderOutputQueueMetrics queueMetrics = mReadyOutputQueue.GetMetrics(); + std::size_t minReadyQueueDepth = 0; + std::size_t maxReadyQueueDepth = 0; + uint64_t readyQueueZeroDepthCount = 0; + double outputRenderMilliseconds = 0.0; + double smoothedOutputRenderMilliseconds = 0.0; + double maxOutputRenderMilliseconds = 0.0; + double outputFrameAcquireMilliseconds = 0.0; + double outputFrameRenderRequestMilliseconds = 0.0; + double outputFrameEndAccessMilliseconds = 0.0; + { + std::lock_guard lock(mOutputMetricsMutex); + minReadyQueueDepth = mMinReadyQueueDepth; + maxReadyQueueDepth = mMaxReadyQueueDepth; + readyQueueZeroDepthCount = mReadyQueueZeroDepthCount; + outputRenderMilliseconds = mOutputRenderMilliseconds; + smoothedOutputRenderMilliseconds = mSmoothedOutputRenderMilliseconds; + maxOutputRenderMilliseconds = mMaxOutputRenderMilliseconds; + outputFrameAcquireMilliseconds = mOutputFrameAcquireMilliseconds; + outputFrameRenderRequestMilliseconds = mOutputFrameRenderRequestMilliseconds; + outputFrameEndAccessMilliseconds = mOutputFrameEndAccessMilliseconds; + } + + mHealthTelemetry.TryRecordBackendPlayoutHealth( + VideoBackendLifecycle::StateName(mLifecycle.State()), + CompletionResultName(result), + queueMetrics.depth, + queueMetrics.capacity, + queueMetrics.pushedCount, + minReadyQueueDepth, + maxReadyQueueDepth, + readyQueueZeroDepthCount, + queueMetrics.poppedCount, + queueMetrics.droppedCount, + queueMetrics.underrunCount, + outputRenderMilliseconds, + smoothedOutputRenderMilliseconds, + maxOutputRenderMilliseconds, + outputFrameAcquireMilliseconds, + outputFrameRenderRequestMilliseconds, + outputFrameEndAccessMilliseconds, + recoveryDecision.completedFrameIndex, + recoveryDecision.scheduledFrameIndex, + recoveryDecision.scheduledLeadFrames, + recoveryDecision.measuredLagFrames, + recoveryDecision.catchUpFrames, + recoveryDecision.lateStreak, + recoveryDecision.dropStreak, + mLateFrameCount, + mDroppedFrameCount, + mFlushedFrameCount, + mLifecycle.State() == VideoBackendLifecycleState::Degraded, + StatusMessage()); +} + +std::size_t VideoBackend::ProduceReadyOutputFrames(const VideoIOCompletion& completion, std::size_t maxFrames) +{ + if (maxFrames == 0) + return 0; + + std::lock_guard productionLock(mOutputProductionMutex); + RenderOutputQueueMetrics metrics = mReadyOutputQueue.GetMetrics(); + std::size_t producedFrames = 0; + while (producedFrames < maxFrames) + { + if (!RenderReadyOutputFrame(mVideoIODevice->State(), completion)) + break; + ++producedFrames; + metrics = mReadyOutputQueue.GetMetrics(); + RecordReadyQueueDepthSample(metrics); + } + return producedFrames; +} + +OutputProductionPressure VideoBackend::BuildOutputProductionPressure(const RenderOutputQueueMetrics& metrics) const +{ + OutputProductionPressure pressure; + pressure.readyQueueDepth = metrics.depth; + pressure.readyQueueCapacity = metrics.capacity; + pressure.readyQueueUnderrunCount = metrics.underrunCount; + { + std::lock_guard lock(mOutputMetricsMutex); + pressure.lateStreak = mLastLateStreak; + pressure.dropStreak = mLastDropStreak; + } + return pressure; +} + +bool VideoBackend::RenderReadyOutputFrame(const VideoIOState& state, const VideoIOCompletion& completion) +{ + const auto renderStart = std::chrono::steady_clock::now(); + OutputFrameSlot outputSlot; + VideoIOOutputFrame outputFrame; + const auto acquireStart = std::chrono::steady_clock::now(); + if (!mSystemOutputFramePool.AcquireFreeSlot(outputSlot)) + { + if (!mReadyOutputQueue.DropOldestFrame() || !mSystemOutputFramePool.AcquireFreeSlot(outputSlot)) + return false; + } + outputFrame = outputSlot.frame; + const auto acquireEnd = std::chrono::steady_clock::now(); + + bool rendered = true; + const auto renderRequestStart = std::chrono::steady_clock::now(); + if (mBridge) + rendered = mBridge->RenderScheduledFrame(state, completion, outputFrame); + const auto renderRequestEnd = std::chrono::steady_clock::now(); + + const auto endAccessStart = std::chrono::steady_clock::now(); + const bool publishedReady = mSystemOutputFramePool.PublishReadySlot(outputSlot); + const auto endAccessEnd = std::chrono::steady_clock::now(); + const double acquireMilliseconds = std::chrono::duration_cast>(acquireEnd - acquireStart).count(); + const double renderRequestMilliseconds = std::chrono::duration_cast>(renderRequestEnd - renderRequestStart).count(); + const double endAccessMilliseconds = std::chrono::duration_cast>(endAccessEnd - endAccessStart).count(); + + if (!rendered) + { + mSystemOutputFramePool.ReleaseSlot(outputSlot); + ApplyLifecycleTransition(VideoBackendLifecycleState::Degraded, "Output frame render request failed; skipping schedule for this frame."); + const double renderMilliseconds = std::chrono::duration_cast>( + std::chrono::steady_clock::now() - renderStart).count(); + RecordOutputRenderDuration(renderMilliseconds, acquireMilliseconds, renderRequestMilliseconds, endAccessMilliseconds); + return false; + } + + if (!publishedReady) + { + mSystemOutputFramePool.ReleaseSlot(outputSlot); + return false; + } + + const double renderMilliseconds = std::chrono::duration_cast>( + std::chrono::steady_clock::now() - renderStart).count(); + RecordOutputRenderDuration(renderMilliseconds, acquireMilliseconds, renderRequestMilliseconds, endAccessMilliseconds); + + RenderOutputFrame readyFrame; + readyFrame.frame = outputFrame; + readyFrame.frameIndex = ++mNextReadyOutputFrameIndex; + readyFrame.releaseFrame = [this](VideoIOOutputFrame& frame) { + mSystemOutputFramePool.ReleaseSlotByBuffer(frame.bytes); + }; + const bool pushed = mReadyOutputQueue.Push(readyFrame); + if (!pushed) + mSystemOutputFramePool.ReleaseSlot(outputSlot); + RecordSystemMemoryPlayoutStats(); + return pushed; +} + +bool VideoBackend::ScheduleReadyOutputFrame() +{ + std::lock_guard schedulingLock(mOutputSchedulingMutex); + RenderOutputFrame readyFrame; + if (!mReadyOutputQueue.TryPop(readyFrame)) + return false; + RecordReadyQueueDepthSample(mReadyOutputQueue.GetMetrics()); + + if (!mSystemOutputFramePool.MarkScheduledByBuffer(readyFrame.frame.bytes)) + { + if (readyFrame.releaseFrame) + readyFrame.releaseFrame(readyFrame.frame); + return false; + } + + if (!ScheduleOutputFrame(readyFrame.frame)) + { + RecordDeckLinkBufferTelemetry(); + mSystemOutputFramePool.ReleaseSlotByBuffer(readyFrame.frame.bytes); + return false; + } + + RecordDeckLinkBufferTelemetry(); + PublishOutputFrameScheduled(readyFrame.frame); + RecordSystemMemoryPlayoutStats(); + return true; +} + +bool VideoBackend::ScheduleBlackUnderrunFrame() +{ + VideoIOOutputFrame outputFrame; + if (!BeginOutputFrame(outputFrame)) + { + ApplyLifecycleTransition(VideoBackendLifecycleState::Degraded, "Output underrun: no output frame was available for fallback scheduling."); + return false; + } + + if (outputFrame.bytes != nullptr && outputFrame.rowBytes > 0 && outputFrame.height > 0) + std::memset(outputFrame.bytes, 0, static_cast(outputFrame.rowBytes) * outputFrame.height); + EndOutputFrame(outputFrame); + + if (!ScheduleOutputFrame(outputFrame)) + { + RecordDeckLinkBufferTelemetry(); + ApplyLifecycleTransition(VideoBackendLifecycleState::Degraded, "Output underrun: black fallback frame scheduling failed."); + return false; + } + + RecordDeckLinkBufferTelemetry(); + ApplyLifecycleTransition(VideoBackendLifecycleState::Degraded, "Output underrun: scheduled black fallback frame."); + PublishOutputFrameScheduled(outputFrame); + return true; +} + +void VideoBackend::RecordFramePacing(VideoIOCompletionResult completionResult) +{ + const auto now = std::chrono::steady_clock::now(); + if (mLastPlayoutCompletionTime != std::chrono::steady_clock::time_point()) + { + mCompletionIntervalMilliseconds = std::chrono::duration_cast>(now - mLastPlayoutCompletionTime).count(); + if (mSmoothedCompletionIntervalMilliseconds <= 0.0) + mSmoothedCompletionIntervalMilliseconds = mCompletionIntervalMilliseconds; + else + mSmoothedCompletionIntervalMilliseconds = mSmoothedCompletionIntervalMilliseconds * 0.9 + mCompletionIntervalMilliseconds * 0.1; + if (mCompletionIntervalMilliseconds > mMaxCompletionIntervalMilliseconds) + mMaxCompletionIntervalMilliseconds = mCompletionIntervalMilliseconds; + } + mLastPlayoutCompletionTime = now; + + if (completionResult == VideoIOCompletionResult::DisplayedLate) + ++mLateFrameCount; + else if (completionResult == VideoIOCompletionResult::Dropped) + ++mDroppedFrameCount; + else if (completionResult == VideoIOCompletionResult::Flushed) + ++mFlushedFrameCount; + + mHealthTelemetry.TryRecordFramePacingStats( + mCompletionIntervalMilliseconds, + mSmoothedCompletionIntervalMilliseconds, + mMaxCompletionIntervalMilliseconds, + mLateFrameCount, + mDroppedFrameCount, + mFlushedFrameCount); + PublishTimingSample("VideoBackend", "completionInterval", mCompletionIntervalMilliseconds, "ms"); + PublishTimingSample("VideoBackend", "smoothedCompletionInterval", mSmoothedCompletionIntervalMilliseconds, "ms"); +} + +void VideoBackend::RecordReadyQueueDepthSample(const RenderOutputQueueMetrics& metrics) +{ + std::lock_guard lock(mOutputMetricsMutex); + if (!mHasReadyQueueDepthBaseline) + { + mHasReadyQueueDepthBaseline = true; + mMinReadyQueueDepth = metrics.depth; + mMaxReadyQueueDepth = metrics.depth; + } + else + { + mMinReadyQueueDepth = (std::min)(mMinReadyQueueDepth, metrics.depth); + mMaxReadyQueueDepth = (std::max)(mMaxReadyQueueDepth, metrics.depth); + } + + if (metrics.depth == 0) + ++mReadyQueueZeroDepthCount; +} + +void VideoBackend::RecordDeckLinkBufferTelemetry() +{ + if (!mVideoIODevice) + return; + + const VideoIOState& state = mVideoIODevice->State(); + mHealthTelemetry.TryRecordDeckLinkBufferTelemetry( + state.actualDeckLinkBufferedFramesAvailable, + state.actualDeckLinkBufferedFrames, + static_cast(mPlayoutPolicy.targetPrerollFrames), + state.deckLinkScheduleCallMilliseconds, + state.deckLinkScheduleFailureCount); +} + +void VideoBackend::RecordSystemMemoryPlayoutStats() +{ + const SystemOutputFramePoolMetrics poolMetrics = mSystemOutputFramePool.GetMetrics(); + const RenderOutputQueueMetrics queueMetrics = mReadyOutputQueue.GetMetrics(); + RecordDeckLinkBufferTelemetry(); + mHealthTelemetry.TryRecordSystemMemoryPlayoutStats( + poolMetrics.freeCount, + poolMetrics.readyCount, + poolMetrics.scheduledCount, + poolMetrics.readyUnderrunCount, + 0, + queueMetrics.droppedCount, + 0.0, + 0.0); +} + +void VideoBackend::RecordOutputRenderDuration(double renderMilliseconds, double acquireMilliseconds, double renderRequestMilliseconds, double endAccessMilliseconds) +{ + std::lock_guard lock(mOutputMetricsMutex); + mOutputRenderMilliseconds = (std::max)(renderMilliseconds, 0.0); + if (mSmoothedOutputRenderMilliseconds <= 0.0) + mSmoothedOutputRenderMilliseconds = mOutputRenderMilliseconds; + else + mSmoothedOutputRenderMilliseconds = mSmoothedOutputRenderMilliseconds * 0.9 + mOutputRenderMilliseconds * 0.1; + mMaxOutputRenderMilliseconds = (std::max)(mMaxOutputRenderMilliseconds, mOutputRenderMilliseconds); + mOutputFrameAcquireMilliseconds = (std::max)(acquireMilliseconds, 0.0); + mOutputFrameRenderRequestMilliseconds = (std::max)(renderRequestMilliseconds, 0.0); + mOutputFrameEndAccessMilliseconds = (std::max)(endAccessMilliseconds, 0.0); + + PublishTimingSample("VideoBackend", "outputRender", mOutputRenderMilliseconds, "ms"); + PublishTimingSample("VideoBackend", "smoothedOutputRender", mSmoothedOutputRenderMilliseconds, "ms"); +} + +bool VideoBackend::ApplyLifecycleTransition(VideoBackendLifecycleState state, const std::string& message) +{ + const VideoBackendLifecycleTransition transition = mLifecycle.TransitionTo(state, message); + if (!transition.accepted) + { + PublishBackendStateChanged(VideoBackendLifecycle::StateName(transition.current), transition.errorMessage); + return false; + } + + PublishBackendStateChanged(VideoBackendLifecycle::StateName(transition.current), message); + return true; +} + +bool VideoBackend::ApplyLifecycleFailure(const std::string& message) +{ + const VideoBackendLifecycleTransition transition = mLifecycle.Fail(message); + if (!transition.accepted) + { + PublishBackendStateChanged(VideoBackendLifecycle::StateName(transition.current), transition.errorMessage); + return false; + } + + PublishBackendStateChanged(VideoBackendLifecycle::StateName(transition.current), message); + return true; +} + +void VideoBackend::PublishBackendStateChanged(const std::string& state, const std::string& message) +{ + try + { + BackendStateChangedEvent event; + event.backendName = "decklink"; + event.state = state; + event.message = message; + if (!mRuntimeEventDispatcher.PublishPayload(event, "VideoBackend")) + OutputDebugStringA("BackendStateChanged event publish failed.\n"); + } + catch (...) + { + OutputDebugStringA("BackendStateChanged event publish threw.\n"); + } +} + +void VideoBackend::PublishInputSignalChanged(const VideoIOFrame& frame, const VideoIOState& state) +{ + const bool hasSignal = !frame.hasNoInputSource; + const unsigned width = state.inputFrameSize.width; + const unsigned height = state.inputFrameSize.height; + if (mHasLastInputSignal && + mLastInputSignal == hasSignal && + mLastInputSignalWidth == width && + mLastInputSignalHeight == height && + mLastInputSignalModeName == state.inputDisplayModeName) + { + return; + } + + mHasLastInputSignal = true; + mLastInputSignal = hasSignal; + mLastInputSignalWidth = width; + mLastInputSignalHeight = height; + mLastInputSignalModeName = state.inputDisplayModeName; + + try + { + InputSignalChangedEvent event; + event.hasSignal = hasSignal; + event.width = width; + event.height = height; + event.modeName = state.inputDisplayModeName; + if (!mRuntimeEventDispatcher.PublishPayload(event, "VideoBackend")) + OutputDebugStringA("InputSignalChanged event publish failed.\n"); + } + catch (...) + { + OutputDebugStringA("InputSignalChanged event publish threw.\n"); + } +} + +void VideoBackend::PublishInputFrameArrived(const VideoIOFrame& frame) +{ + try + { + InputFrameArrivedEvent event; + event.frameIndex = ++mInputFrameIndex; + event.width = frame.width; + event.height = frame.height; + event.rowBytes = frame.rowBytes; + event.pixelFormat = PixelFormatName(frame.pixelFormat); + event.hasNoInputSource = frame.hasNoInputSource; + if (!mRuntimeEventDispatcher.PublishPayload(event, "VideoBackend")) + OutputDebugStringA("InputFrameArrived event publish failed.\n"); + } + catch (...) + { + OutputDebugStringA("InputFrameArrived event publish threw.\n"); + } +} + +void VideoBackend::PublishOutputFrameScheduled(const VideoIOOutputFrame& frame) +{ + try + { + OutputFrameScheduledEvent event; + event.frameIndex = ++mOutputFrameScheduleIndex; + (void)frame; + if (!mRuntimeEventDispatcher.PublishPayload(event, "VideoBackend")) + OutputDebugStringA("OutputFrameScheduled event publish failed.\n"); + } + catch (...) + { + OutputDebugStringA("OutputFrameScheduled event publish threw.\n"); + } +} + +void VideoBackend::PublishOutputFrameCompleted(const VideoIOCompletion& completion) +{ + try + { + OutputFrameCompletedEvent event; + event.frameIndex = ++mOutputFrameCompletionIndex; + event.result = CompletionResultName(completion.result); + if (!mRuntimeEventDispatcher.PublishPayload(event, "VideoBackend")) + OutputDebugStringA("OutputFrameCompleted event publish failed.\n"); + } + catch (...) + { + OutputDebugStringA("OutputFrameCompleted event publish threw.\n"); + } +} + +void VideoBackend::PublishTimingSample(const std::string& subsystem, const std::string& metric, double value, const std::string& unit) +{ + try + { + TimingSampleRecordedEvent event; + event.subsystem = subsystem; + event.metric = metric; + event.value = value; + event.unit = unit; + if (!mRuntimeEventDispatcher.PublishPayload(event, "HealthTelemetry")) + OutputDebugStringA("TimingSampleRecorded event publish failed.\n"); + } + catch (...) + { + OutputDebugStringA("TimingSampleRecorded event publish threw.\n"); + } +} + +std::string VideoBackend::CompletionResultName(VideoIOCompletionResult result) +{ + switch (result) + { + case VideoIOCompletionResult::Completed: + return "Completed"; + case VideoIOCompletionResult::DisplayedLate: + return "DisplayedLate"; + case VideoIOCompletionResult::Dropped: + return "Dropped"; + case VideoIOCompletionResult::Flushed: + return "Flushed"; + case VideoIOCompletionResult::Unknown: + default: + return "Unknown"; + } +} + +std::string VideoBackend::PixelFormatName(VideoIOPixelFormat pixelFormat) +{ + return std::string(VideoIOPixelFormatName(pixelFormat)); +} + +bool VideoBackend::IsEnvironmentFlagEnabled(const char* name) +{ + if (name == nullptr || name[0] == '\0') + return false; + + char* value = nullptr; + std::size_t valueSize = 0; + if (_dupenv_s(&value, &valueSize, name) != 0 || value == nullptr) + return false; + + const std::string flag(value); + std::free(value); + return flag == "1" || flag == "true" || flag == "TRUE" || flag == "yes" || flag == "on"; +} diff --git a/src/video/VideoBackend.h b/src/video/VideoBackend.h new file mode 100644 index 0000000..81eed7f --- /dev/null +++ b/src/video/VideoBackend.h @@ -0,0 +1,161 @@ +#pragma once + +#include "OutputProductionController.h" +#include "RenderCadenceController.h" +#include "RenderOutputQueue.h" +#include "SystemOutputFramePool.h" +#include "VideoBackendLifecycle.h" +#include "VideoIOTypes.h" +#include "VideoPlayoutPolicy.h" + +#include +#include +#include +#include +#include +#include +#include +#include + +class HealthTelemetry; +class OpenGLVideoIOBridge; +class RenderEngine; +class RuntimeEventDispatcher; +class VideoIODevice; + +class VideoBackend +{ +public: + VideoBackend(RenderEngine& renderEngine, HealthTelemetry& healthTelemetry, RuntimeEventDispatcher& runtimeEventDispatcher); + ~VideoBackend(); + + void ReleaseResources(); + VideoBackendLifecycleState LifecycleState() const; + bool DiscoverDevicesAndModes(const VideoFormatSelection& videoModes, std::string& error); + bool SelectPreferredFormats(const VideoFormatSelection& videoModes, bool outputAlphaRequired, std::string& error); + bool ConfigureInput(const VideoFormat& inputVideoMode, std::string& error); + bool ConfigureOutput(const VideoFormat& outputVideoMode, bool externalKeyingEnabled, std::string& error); + bool Start(); + bool Stop(); + + const VideoIOState& State() const; + VideoIOState& MutableState(); + bool BeginOutputFrame(VideoIOOutputFrame& frame); + void EndOutputFrame(VideoIOOutputFrame& frame); + bool ScheduleOutputFrame(const VideoIOOutputFrame& frame); + VideoPlayoutRecoveryDecision AccountForCompletionResult(VideoIOCompletionResult result, uint64_t readyQueueDepth); + void RecordBackendPlayoutHealth(VideoIOCompletionResult result, const VideoPlayoutRecoveryDecision& recoveryDecision); + + bool HasInputDevice() const; + bool HasInputSource() const; + unsigned InputFrameWidth() const; + unsigned InputFrameHeight() const; + unsigned OutputFrameWidth() const; + unsigned OutputFrameHeight() const; + unsigned CaptureTextureWidth() const; + unsigned OutputPackTextureWidth() const; + VideoIOPixelFormat InputPixelFormat() const; + const std::string& InputDisplayModeName() const; + const std::string& OutputModelName() const; + bool SupportsInternalKeying() const; + bool SupportsExternalKeying() const; + bool KeyerInterfaceAvailable() const; + bool ExternalKeyingActive() const; + const std::string& StatusMessage() const; + bool ShouldPrioritizeOutputOverPreview() const; + void SetStatusMessage(const std::string& message); + void PublishStatus(bool externalKeyingConfigured, const std::string& statusMessage = std::string()); + void ReportNoInputDeviceSignalStatus(); + +private: + void HandleInputFrame(const VideoIOFrame& frame); + void HandleOutputFrameCompletion(const VideoIOCompletion& completion); + void StartOutputCompletionWorker(); + void StopOutputCompletionWorker(); + void OutputCompletionWorkerMain(); + void StartOutputProducerWorker(); + void StopOutputProducerWorker(); + void OutputProducerWorkerMain(); + void NotifyOutputProducer(); + bool WarmupOutputPreroll(); + std::chrono::milliseconds OutputProducerWakeInterval() const; + void ProcessOutputFrameCompletion(const VideoIOCompletion& completion); + std::size_t ProduceReadyOutputFrames(const VideoIOCompletion& completion, std::size_t maxFrames); + OutputProductionPressure BuildOutputProductionPressure(const RenderOutputQueueMetrics& metrics) const; + bool RenderReadyOutputFrame(const VideoIOState& state, const VideoIOCompletion& completion); + std::size_t ScheduleReadyOutputFramesToTarget(); + bool ScheduleReadyOutputFrame(); + bool ScheduleBlackUnderrunFrame(); + void RecordFramePacing(VideoIOCompletionResult completionResult); + void RecordReadyQueueDepthSample(const RenderOutputQueueMetrics& metrics); + void RecordDeckLinkBufferTelemetry(); + void RecordSystemMemoryPlayoutStats(); + void RecordOutputRenderDuration(double renderMilliseconds, double acquireMilliseconds, double renderRequestMilliseconds, double endAccessMilliseconds); + bool ApplyLifecycleTransition(VideoBackendLifecycleState state, const std::string& message); + bool ApplyLifecycleFailure(const std::string& message); + void PublishBackendStateChanged(const std::string& state, const std::string& message); + void PublishInputSignalChanged(const VideoIOFrame& frame, const VideoIOState& state); + void PublishInputFrameArrived(const VideoIOFrame& frame); + void PublishOutputFrameScheduled(const VideoIOOutputFrame& frame); + void PublishOutputFrameCompleted(const VideoIOCompletion& completion); + void PublishTimingSample(const std::string& subsystem, const std::string& metric, double value, const std::string& unit); + static std::string CompletionResultName(VideoIOCompletionResult result); + static std::string PixelFormatName(VideoIOPixelFormat pixelFormat); + static bool IsEnvironmentFlagEnabled(const char* name); + + HealthTelemetry& mHealthTelemetry; + RuntimeEventDispatcher& mRuntimeEventDispatcher; + VideoBackendLifecycle mLifecycle; + VideoPlayoutPolicy mPlayoutPolicy; + OutputProductionController mOutputProductionController; + RenderCadenceController mRenderCadenceController; + RenderOutputQueue mReadyOutputQueue; + SystemOutputFramePool mSystemOutputFramePool; + std::unique_ptr mVideoIODevice; + std::unique_ptr mBridge; + std::mutex mOutputCompletionMutex; + std::condition_variable mOutputCompletionCondition; + std::deque mPendingOutputCompletions; + std::thread mOutputCompletionWorker; + std::mutex mOutputProducerMutex; + std::condition_variable mOutputProducerCondition; + std::thread mOutputProducerWorker; + VideoIOCompletion mLastOutputProductionCompletion; + std::chrono::steady_clock::time_point mLastOutputProductionTime; + std::mutex mOutputProductionMutex; + std::mutex mOutputSchedulingMutex; + mutable std::mutex mOutputMetricsMutex; + bool mOutputCompletionWorkerRunning = false; + bool mOutputCompletionWorkerStopping = false; + bool mOutputProducerWorkerRunning = false; + bool mOutputProducerWorkerStopping = false; + bool mInputCaptureDisabled = false; + uint64_t mNextReadyOutputFrameIndex = 0; + uint64_t mInputFrameIndex = 0; + uint64_t mOutputFrameScheduleIndex = 0; + uint64_t mOutputFrameCompletionIndex = 0; + bool mHasLastInputSignal = false; + bool mLastInputSignal = false; + unsigned mLastInputSignalWidth = 0; + unsigned mLastInputSignalHeight = 0; + std::string mLastInputSignalModeName; + std::chrono::steady_clock::time_point mLastPlayoutCompletionTime; + double mCompletionIntervalMilliseconds = 0.0; + double mSmoothedCompletionIntervalMilliseconds = 0.0; + double mMaxCompletionIntervalMilliseconds = 0.0; + bool mHasReadyQueueDepthBaseline = false; + std::size_t mMinReadyQueueDepth = 0; + std::size_t mMaxReadyQueueDepth = 0; + uint64_t mReadyQueueZeroDepthCount = 0; + double mOutputRenderMilliseconds = 0.0; + double mSmoothedOutputRenderMilliseconds = 0.0; + double mMaxOutputRenderMilliseconds = 0.0; + double mOutputFrameAcquireMilliseconds = 0.0; + double mOutputFrameRenderRequestMilliseconds = 0.0; + double mOutputFrameEndAccessMilliseconds = 0.0; + uint64_t mLastLateStreak = 0; + uint64_t mLastDropStreak = 0; + uint64_t mLateFrameCount = 0; + uint64_t mDroppedFrameCount = 0; + uint64_t mFlushedFrameCount = 0; +}; diff --git a/src/video/VideoBackendLifecycle.cpp b/src/video/VideoBackendLifecycle.cpp new file mode 100644 index 0000000..5bfd763 --- /dev/null +++ b/src/video/VideoBackendLifecycle.cpp @@ -0,0 +1,123 @@ +#include "VideoBackendLifecycle.h" + +VideoBackendLifecycleState VideoBackendLifecycle::State() const +{ + return mState; +} + +const std::string& VideoBackendLifecycle::FailureReason() const +{ + return mFailureReason; +} + +VideoBackendLifecycleTransition VideoBackendLifecycle::TransitionTo(VideoBackendLifecycleState next, const std::string& reason) +{ + VideoBackendLifecycleTransition transition; + transition.previous = mState; + transition.current = next; + transition.reason = reason; + transition.accepted = CanTransition(mState, next); + if (!transition.accepted) + { + transition.current = mState; + transition.errorMessage = std::string("Invalid video backend lifecycle transition from ") + + StateName(mState) + " to " + StateName(next) + "."; + return transition; + } + + mState = next; + transition.current = mState; + if (mState != VideoBackendLifecycleState::Failed) + mFailureReason.clear(); + return transition; +} + +VideoBackendLifecycleTransition VideoBackendLifecycle::Fail(const std::string& reason) +{ + VideoBackendLifecycleTransition transition = TransitionTo(VideoBackendLifecycleState::Failed, reason); + if (transition.accepted) + mFailureReason = reason; + return transition; +} + +bool VideoBackendLifecycle::CanTransition(VideoBackendLifecycleState current, VideoBackendLifecycleState next) +{ + if (current == next) + return true; + + switch (current) + { + case VideoBackendLifecycleState::Uninitialized: + return next == VideoBackendLifecycleState::Discovering || + next == VideoBackendLifecycleState::Stopped || + next == VideoBackendLifecycleState::Failed; + case VideoBackendLifecycleState::Discovering: + return next == VideoBackendLifecycleState::Discovered || + next == VideoBackendLifecycleState::Failed; + case VideoBackendLifecycleState::Discovered: + return next == VideoBackendLifecycleState::Configuring || + next == VideoBackendLifecycleState::Stopped || + next == VideoBackendLifecycleState::Failed; + case VideoBackendLifecycleState::Configuring: + return next == VideoBackendLifecycleState::Configured || + next == VideoBackendLifecycleState::Failed; + case VideoBackendLifecycleState::Configured: + return next == VideoBackendLifecycleState::Prerolling || + next == VideoBackendLifecycleState::Stopped || + next == VideoBackendLifecycleState::Failed; + case VideoBackendLifecycleState::Prerolling: + return next == VideoBackendLifecycleState::Running || + next == VideoBackendLifecycleState::Stopping || + next == VideoBackendLifecycleState::Failed; + case VideoBackendLifecycleState::Running: + return next == VideoBackendLifecycleState::Degraded || + next == VideoBackendLifecycleState::Stopping || + next == VideoBackendLifecycleState::Failed; + case VideoBackendLifecycleState::Degraded: + return next == VideoBackendLifecycleState::Running || + next == VideoBackendLifecycleState::Stopping || + next == VideoBackendLifecycleState::Failed; + case VideoBackendLifecycleState::Stopping: + return next == VideoBackendLifecycleState::Stopped || + next == VideoBackendLifecycleState::Failed; + case VideoBackendLifecycleState::Stopped: + return next == VideoBackendLifecycleState::Discovering || + next == VideoBackendLifecycleState::Failed; + case VideoBackendLifecycleState::Failed: + return next == VideoBackendLifecycleState::Stopped || + next == VideoBackendLifecycleState::Discovering; + default: + return false; + } +} + +const char* VideoBackendLifecycle::StateName(VideoBackendLifecycleState state) +{ + switch (state) + { + case VideoBackendLifecycleState::Uninitialized: + return "uninitialized"; + case VideoBackendLifecycleState::Discovering: + return "discovering"; + case VideoBackendLifecycleState::Discovered: + return "discovered"; + case VideoBackendLifecycleState::Configuring: + return "configuring"; + case VideoBackendLifecycleState::Configured: + return "configured"; + case VideoBackendLifecycleState::Prerolling: + return "prerolling"; + case VideoBackendLifecycleState::Running: + return "running"; + case VideoBackendLifecycleState::Degraded: + return "degraded"; + case VideoBackendLifecycleState::Stopping: + return "stopping"; + case VideoBackendLifecycleState::Stopped: + return "stopped"; + case VideoBackendLifecycleState::Failed: + return "failed"; + default: + return "unknown"; + } +} diff --git a/src/video/VideoBackendLifecycle.h b/src/video/VideoBackendLifecycle.h new file mode 100644 index 0000000..bc9a5d6 --- /dev/null +++ b/src/video/VideoBackendLifecycle.h @@ -0,0 +1,43 @@ +#pragma once + +#include + +enum class VideoBackendLifecycleState +{ + Uninitialized, + Discovering, + Discovered, + Configuring, + Configured, + Prerolling, + Running, + Degraded, + Stopping, + Stopped, + Failed +}; + +struct VideoBackendLifecycleTransition +{ + VideoBackendLifecycleState previous = VideoBackendLifecycleState::Uninitialized; + VideoBackendLifecycleState current = VideoBackendLifecycleState::Uninitialized; + bool accepted = false; + std::string reason; + std::string errorMessage; +}; + +class VideoBackendLifecycle +{ +public: + VideoBackendLifecycleState State() const; + const std::string& FailureReason() const; + VideoBackendLifecycleTransition TransitionTo(VideoBackendLifecycleState next, const std::string& reason); + VideoBackendLifecycleTransition Fail(const std::string& reason); + + static bool CanTransition(VideoBackendLifecycleState current, VideoBackendLifecycleState next); + static const char* StateName(VideoBackendLifecycleState state); + +private: + VideoBackendLifecycleState mState = VideoBackendLifecycleState::Uninitialized; + std::string mFailureReason; +}; diff --git a/src/video/VideoIOFormat.cpp b/src/video/VideoIOFormat.cpp new file mode 100644 index 0000000..90e1a11 --- /dev/null +++ b/src/video/VideoIOFormat.cpp @@ -0,0 +1,170 @@ +#include "VideoIOFormat.h" + +#include +#include + +#ifdef min +#undef min +#endif +#ifdef max +#undef max +#endif + +namespace +{ +uint16_t Clamp10(int value, int minimum, int maximum) +{ + return static_cast(std::max(minimum, std::min(maximum, value))); +} + +uint32_t MakeV210Word(uint16_t a, uint16_t b, uint16_t c) +{ + return (static_cast(a) & 0x3ffu) + | ((static_cast(b) & 0x3ffu) << 10) + | ((static_cast(c) & 0x3ffu) << 20); +} + +void StoreWord(std::array& bytes, std::size_t wordIndex, uint32_t word) +{ + const std::size_t offset = wordIndex * 4; + bytes[offset + 0] = static_cast(word & 0xffu); + bytes[offset + 1] = static_cast((word >> 8) & 0xffu); + bytes[offset + 2] = static_cast((word >> 16) & 0xffu); + bytes[offset + 3] = static_cast((word >> 24) & 0xffu); +} + +uint32_t LoadWord(const std::array& bytes, std::size_t wordIndex) +{ + const std::size_t offset = wordIndex * 4; + return static_cast(bytes[offset + 0]) + | (static_cast(bytes[offset + 1]) << 8) + | (static_cast(bytes[offset + 2]) << 16) + | (static_cast(bytes[offset + 3]) << 24); +} + +uint16_t Component(uint32_t word, unsigned index) +{ + return static_cast((word >> (index * 10)) & 0x3ffu); +} +} + +const char* VideoIOPixelFormatName(VideoIOPixelFormat format) +{ + switch (format) + { + case VideoIOPixelFormat::V210: + return "10-bit YUV v210"; + case VideoIOPixelFormat::Yuva10: + return "10-bit YUVA Ay10"; + case VideoIOPixelFormat::Bgra8: + return "8-bit BGRA"; + case VideoIOPixelFormat::Uyvy8: + default: + return "8-bit YUV UYVY"; + } +} + +bool VideoIOPixelFormatIsTenBit(VideoIOPixelFormat format) +{ + return format == VideoIOPixelFormat::V210 || format == VideoIOPixelFormat::Yuva10; +} + +VideoIOPixelFormat ChoosePreferredVideoIOFormat(bool tenBitSupported) +{ + return tenBitSupported ? VideoIOPixelFormat::V210 : VideoIOPixelFormat::Uyvy8; +} + +unsigned VideoIOBytesPerPixel(VideoIOPixelFormat format) +{ + switch (format) + { + case VideoIOPixelFormat::Uyvy8: + return 2u; + case VideoIOPixelFormat::Bgra8: + return 4u; + case VideoIOPixelFormat::Yuva10: + return 4u; + case VideoIOPixelFormat::V210: + default: + return 0u; + } +} + +unsigned VideoIORowBytes(VideoIOPixelFormat format, unsigned frameWidth) +{ + if (format == VideoIOPixelFormat::V210) + return MinimumV210RowBytes(frameWidth); + if (format == VideoIOPixelFormat::Yuva10) + return MinimumYuva10RowBytes(frameWidth); + return frameWidth * VideoIOBytesPerPixel(format); +} + +unsigned PackedTextureWidthFromRowBytes(unsigned rowBytes) +{ + return (rowBytes + 3u) / 4u; +} + +unsigned MinimumV210RowBytes(unsigned frameWidth) +{ + return ((frameWidth + 5u) / 6u) * 16u; +} + +unsigned MinimumYuva10RowBytes(unsigned frameWidth) +{ + return ((frameWidth + 63u) / 64u) * 256u; +} + +unsigned ActiveV210WordsForWidth(unsigned frameWidth) +{ + return ((frameWidth + 5u) / 6u) * 4u; +} + +V210CodeValues Rec709RgbToLegalV210(float red, float green, float blue) +{ + red = std::max(0.0f, std::min(1.0f, red)); + green = std::max(0.0f, std::min(1.0f, green)); + blue = std::max(0.0f, std::min(1.0f, blue)); + + const float y = 0.2126f * red + 0.7152f * green + 0.0722f * blue; + const float cb = (blue - y) / 1.8556f + 0.5f; + const float cr = (red - y) / 1.5748f + 0.5f; + + V210CodeValues values; + values.y = Clamp10(static_cast(std::lround(64.0f + y * 876.0f)), 64, 940); + values.cb = Clamp10(static_cast(std::lround(64.0f + cb * 896.0f)), 64, 960); + values.cr = Clamp10(static_cast(std::lround(64.0f + cr * 896.0f)), 64, 960); + return values; +} + +std::array PackV210Block(const V210SixPixelBlock& block) +{ + std::array bytes = {}; + StoreWord(bytes, 0, MakeV210Word(block.cb[0], block.y[0], block.cr[0])); + StoreWord(bytes, 1, MakeV210Word(block.y[1], block.cb[1], block.y[2])); + StoreWord(bytes, 2, MakeV210Word(block.cr[1], block.y[3], block.cb[2])); + StoreWord(bytes, 3, MakeV210Word(block.y[4], block.cr[2], block.y[5])); + return bytes; +} + +V210SixPixelBlock UnpackV210Block(const std::array& bytes) +{ + const uint32_t word0 = LoadWord(bytes, 0); + const uint32_t word1 = LoadWord(bytes, 1); + const uint32_t word2 = LoadWord(bytes, 2); + const uint32_t word3 = LoadWord(bytes, 3); + + V210SixPixelBlock block; + block.cb[0] = Component(word0, 0); + block.y[0] = Component(word0, 1); + block.cr[0] = Component(word0, 2); + block.y[1] = Component(word1, 0); + block.cb[1] = Component(word1, 1); + block.y[2] = Component(word1, 2); + block.cr[1] = Component(word2, 0); + block.y[3] = Component(word2, 1); + block.cb[2] = Component(word2, 2); + block.y[4] = Component(word3, 0); + block.cr[2] = Component(word3, 1); + block.y[5] = Component(word3, 2); + return block; +} diff --git a/src/video/VideoIOFormat.h b/src/video/VideoIOFormat.h new file mode 100644 index 0000000..740b39d --- /dev/null +++ b/src/video/VideoIOFormat.h @@ -0,0 +1,39 @@ +#pragma once + +#include +#include + +enum class VideoIOPixelFormat +{ + Uyvy8, + V210, + Yuva10, + Bgra8 +}; + +struct V210CodeValues +{ + uint16_t y = 64; + uint16_t cb = 512; + uint16_t cr = 512; +}; + +struct V210SixPixelBlock +{ + std::array y = {}; + std::array cb = {}; + std::array cr = {}; +}; + +const char* VideoIOPixelFormatName(VideoIOPixelFormat format); +bool VideoIOPixelFormatIsTenBit(VideoIOPixelFormat format); +VideoIOPixelFormat ChoosePreferredVideoIOFormat(bool tenBitSupported); +unsigned VideoIOBytesPerPixel(VideoIOPixelFormat format); +unsigned VideoIORowBytes(VideoIOPixelFormat format, unsigned frameWidth); +unsigned PackedTextureWidthFromRowBytes(unsigned rowBytes); +unsigned MinimumV210RowBytes(unsigned frameWidth); +unsigned MinimumYuva10RowBytes(unsigned frameWidth); +unsigned ActiveV210WordsForWidth(unsigned frameWidth); +V210CodeValues Rec709RgbToLegalV210(float red, float green, float blue); +std::array PackV210Block(const V210SixPixelBlock& block); +V210SixPixelBlock UnpackV210Block(const std::array& bytes); diff --git a/src/video/VideoIOTypes.h b/src/video/VideoIOTypes.h new file mode 100644 index 0000000..77217bc --- /dev/null +++ b/src/video/VideoIOTypes.h @@ -0,0 +1,164 @@ +#pragma once + +#include "DeckLinkDisplayMode.h" +#include "VideoIOFormat.h" + +#include +#include +#include + +enum class VideoIOBackend +{ + DeckLink +}; + +enum class VideoIOCompletionResult +{ + Completed, + DisplayedLate, + Dropped, + Flushed, + Unknown +}; + +struct VideoIOConfig +{ + VideoFormatSelection videoModes; + bool externalKeyingEnabled = false; + bool preferTenBit = true; +}; + +struct VideoIOState +{ + FrameSize inputFrameSize; + FrameSize outputFrameSize; + VideoIOPixelFormat inputPixelFormat = VideoIOPixelFormat::Uyvy8; + VideoIOPixelFormat outputPixelFormat = VideoIOPixelFormat::Bgra8; + unsigned inputFrameRowBytes = 0; + unsigned outputFrameRowBytes = 0; + unsigned captureTextureWidth = 0; + unsigned outputPackTextureWidth = 0; + std::string inputDisplayModeName = "1080p59.94"; + std::string outputDisplayModeName = "1080p59.94"; + std::string outputModelName; + std::string statusMessage; + std::string formatStatusMessage; + bool hasInputDevice = false; + bool hasInputSource = false; + bool supportsInternalKeying = false; + bool supportsExternalKeying = false; + bool keyerInterfaceAvailable = false; + bool externalKeyingActive = false; + double frameBudgetMilliseconds = 0.0; + bool actualDeckLinkBufferedFramesAvailable = false; + uint64_t actualDeckLinkBufferedFrames = 0; + double deckLinkScheduleCallMilliseconds = 0.0; + uint64_t deckLinkScheduleFailureCount = 0; + bool deckLinkScheduleLeadAvailable = false; + int64_t deckLinkPlaybackStreamTime = 0; + uint64_t deckLinkPlaybackFrameIndex = 0; + uint64_t deckLinkNextScheduleFrameIndex = 0; + int64_t deckLinkScheduleLeadFrames = 0; + uint64_t deckLinkScheduleRealignmentCount = 0; +}; + +struct VideoIOFrame +{ + void* bytes = nullptr; + long rowBytes = 0; + unsigned width = 0; + unsigned height = 0; + VideoIOPixelFormat pixelFormat = VideoIOPixelFormat::Uyvy8; + bool hasNoInputSource = false; +}; + +struct VideoIOOutputFrame +{ + void* bytes = nullptr; + long rowBytes = 0; + unsigned width = 0; + unsigned height = 0; + VideoIOPixelFormat pixelFormat = VideoIOPixelFormat::Bgra8; + void* nativeFrame = nullptr; + void* nativeBuffer = nullptr; +}; + +struct VideoIOCompletion +{ + VideoIOCompletionResult result = VideoIOCompletionResult::Completed; + void* outputFrameBuffer = nullptr; +}; + +struct VideoIOScheduleTime +{ + int64_t streamTime = 0; + int64_t duration = 0; + int64_t timeScale = 0; + uint64_t frameIndex = 0; +}; + +struct VideoPlayoutRecoveryDecision +{ + VideoIOCompletionResult result = VideoIOCompletionResult::Completed; + uint64_t completedFrameIndex = 0; + uint64_t scheduledFrameIndex = 0; + uint64_t readyQueueDepth = 0; + uint64_t scheduledLeadFrames = 0; + uint64_t measuredLagFrames = 0; + uint64_t catchUpFrames = 0; + uint64_t lateStreak = 0; + uint64_t dropStreak = 0; +}; + +class VideoIODevice +{ +public: + using InputFrameCallback = std::function; + using OutputFrameCallback = std::function; + + virtual ~VideoIODevice() = default; + virtual void ReleaseResources() = 0; + virtual bool DiscoverDevicesAndModes(const VideoFormatSelection& videoModes, std::string& error) = 0; + virtual bool SelectPreferredFormats(const VideoFormatSelection& videoModes, bool outputAlphaRequired, std::string& error) = 0; + virtual bool ConfigureInput(InputFrameCallback callback, const VideoFormat& inputVideoMode, std::string& error) = 0; + virtual bool ConfigureOutput(OutputFrameCallback callback, const VideoFormat& outputVideoMode, bool externalKeyingEnabled, std::string& error) = 0; + virtual bool PrepareOutputSchedule() = 0; + virtual bool StartInputStreams() = 0; + virtual bool StartScheduledPlayback() = 0; + virtual bool Start() = 0; + virtual bool Stop() = 0; + virtual const VideoIOState& State() const = 0; + virtual VideoIOState& MutableState() = 0; + virtual bool BeginOutputFrame(VideoIOOutputFrame& frame) = 0; + virtual void EndOutputFrame(VideoIOOutputFrame& frame) = 0; + virtual bool ScheduleOutputFrame(const VideoIOOutputFrame& frame) = 0; + virtual VideoPlayoutRecoveryDecision AccountForCompletionResult(VideoIOCompletionResult result, uint64_t readyQueueDepth) = 0; + + bool HasInputDevice() const { return State().hasInputDevice; } + bool HasInputSource() const { return State().hasInputSource; } + bool InputOutputDimensionsDiffer() const { return State().inputFrameSize != State().outputFrameSize; } + const FrameSize& InputFrameSize() const { return State().inputFrameSize; } + const FrameSize& OutputFrameSize() const { return State().outputFrameSize; } + unsigned InputFrameWidth() const { return State().inputFrameSize.width; } + unsigned InputFrameHeight() const { return State().inputFrameSize.height; } + unsigned OutputFrameWidth() const { return State().outputFrameSize.width; } + unsigned OutputFrameHeight() const { return State().outputFrameSize.height; } + VideoIOPixelFormat InputPixelFormat() const { return State().inputPixelFormat; } + VideoIOPixelFormat OutputPixelFormat() const { return State().outputPixelFormat; } + bool InputIsTenBit() const { return VideoIOPixelFormatIsTenBit(State().inputPixelFormat); } + bool OutputIsTenBit() const { return VideoIOPixelFormatIsTenBit(State().outputPixelFormat); } + unsigned InputFrameRowBytes() const { return State().inputFrameRowBytes; } + unsigned OutputFrameRowBytes() const { return State().outputFrameRowBytes; } + unsigned CaptureTextureWidth() const { return State().captureTextureWidth; } + unsigned OutputPackTextureWidth() const { return State().outputPackTextureWidth; } + const std::string& FormatStatusMessage() const { return State().formatStatusMessage; } + const std::string& InputDisplayModeName() const { return State().inputDisplayModeName; } + const std::string& OutputModelName() const { return State().outputModelName; } + bool SupportsInternalKeying() const { return State().supportsInternalKeying; } + bool SupportsExternalKeying() const { return State().supportsExternalKeying; } + bool KeyerInterfaceAvailable() const { return State().keyerInterfaceAvailable; } + bool ExternalKeyingActive() const { return State().externalKeyingActive; } + const std::string& StatusMessage() const { return State().statusMessage; } + double FrameBudgetMilliseconds() const { return State().frameBudgetMilliseconds; } + void SetStatusMessage(const std::string& message) { MutableState().statusMessage = message; } +}; diff --git a/src/video/VideoPlayoutPolicy.h b/src/video/VideoPlayoutPolicy.h new file mode 100644 index 0000000..72e5a55 --- /dev/null +++ b/src/video/VideoPlayoutPolicy.h @@ -0,0 +1,37 @@ +#pragma once + +#include + +enum class VideoUnderrunBehavior +{ + ReuseLastCompletedFrame, + BlackFrame +}; + +struct VideoPlayoutPolicy +{ + unsigned outputFramePoolSize = 10; + unsigned targetPrerollFrames = 4; + unsigned targetReadyFrames = 2; + unsigned maxReadyFrames = 4; + unsigned minimumSpareDeviceFrames = 1; + uint64_t lateOrDropCatchUpFrames = 0; + VideoUnderrunBehavior underrunBehavior = VideoUnderrunBehavior::ReuseLastCompletedFrame; + bool adaptiveHeadroomEnabled = false; +}; + +inline VideoPlayoutPolicy NormalizeVideoPlayoutPolicy(VideoPlayoutPolicy policy) +{ + if (policy.outputFramePoolSize == 0) + policy.outputFramePoolSize = 1; + if (policy.targetPrerollFrames == 0) + policy.targetPrerollFrames = 1; + if (policy.targetReadyFrames == 0) + policy.targetReadyFrames = 1; + if (policy.maxReadyFrames < policy.targetReadyFrames) + policy.maxReadyFrames = policy.targetReadyFrames; + const unsigned minimumOutputFramePoolSize = policy.targetPrerollFrames + policy.maxReadyFrames + policy.minimumSpareDeviceFrames; + if (policy.outputFramePoolSize < minimumOutputFramePoolSize) + policy.outputFramePoolSize = minimumOutputFramePoolSize; + return policy; +} diff --git a/src/video/VideoPlayoutScheduler.cpp b/src/video/VideoPlayoutScheduler.cpp new file mode 100644 index 0000000..750e301 --- /dev/null +++ b/src/video/VideoPlayoutScheduler.cpp @@ -0,0 +1,108 @@ +#include "VideoPlayoutScheduler.h" + +void VideoPlayoutScheduler::Configure(int64_t frameDuration, int64_t timeScale) +{ + Configure(frameDuration, timeScale, VideoPlayoutPolicy()); +} + +void VideoPlayoutScheduler::Configure(int64_t frameDuration, int64_t timeScale, const VideoPlayoutPolicy& policy) +{ + mFrameDuration = frameDuration; + mTimeScale = timeScale; + mPolicy = NormalizeVideoPlayoutPolicy(policy); + Reset(); +} + +void VideoPlayoutScheduler::Reset() +{ + mScheduledFrameIndex = 0; + mCompletedFrameIndex = 0; + mLateStreak = 0; + mDropStreak = 0; +} + +VideoIOScheduleTime VideoPlayoutScheduler::NextScheduleTime() +{ + VideoIOScheduleTime time; + time.streamTime = static_cast(mScheduledFrameIndex) * mFrameDuration; + time.duration = mFrameDuration; + time.timeScale = mTimeScale; + time.frameIndex = mScheduledFrameIndex; + ++mScheduledFrameIndex; + return time; +} + +void VideoPlayoutScheduler::AlignNextScheduleTimeToPlayback(int64_t streamTime, uint64_t leadFrames) +{ + if (mFrameDuration <= 0 || streamTime < 0) + return; + + const uint64_t playbackFrameIndex = static_cast(streamTime / mFrameDuration); + const uint64_t minimumScheduleIndex = playbackFrameIndex + leadFrames; + if (minimumScheduleIndex > mScheduledFrameIndex) + mScheduledFrameIndex = minimumScheduleIndex; +} + +VideoPlayoutRecoveryDecision VideoPlayoutScheduler::AccountForCompletionResult(VideoIOCompletionResult result, uint64_t readyQueueDepth) +{ + ++mCompletedFrameIndex; + if (result == VideoIOCompletionResult::DisplayedLate) + ++mLateStreak; + else + mLateStreak = 0; + if (result == VideoIOCompletionResult::Dropped) + ++mDropStreak; + else + mDropStreak = 0; + + const uint64_t measuredLagFrames = MeasureLag(result, readyQueueDepth); + const uint64_t catchUpFrames = measuredLagFrames < mPolicy.lateOrDropCatchUpFrames + ? measuredLagFrames + : mPolicy.lateOrDropCatchUpFrames; + if (catchUpFrames > 0) + mScheduledFrameIndex += catchUpFrames; + + VideoPlayoutRecoveryDecision decision; + decision.result = result; + decision.completedFrameIndex = mCompletedFrameIndex; + decision.scheduledFrameIndex = mScheduledFrameIndex; + decision.readyQueueDepth = readyQueueDepth; + decision.scheduledLeadFrames = mScheduledFrameIndex > mCompletedFrameIndex + ? mScheduledFrameIndex - mCompletedFrameIndex + : 0; + decision.measuredLagFrames = measuredLagFrames; + decision.catchUpFrames = catchUpFrames; + decision.lateStreak = mLateStreak; + decision.dropStreak = mDropStreak; + return decision; +} + +double VideoPlayoutScheduler::FrameBudgetMilliseconds() const +{ + return mTimeScale != 0 + ? (static_cast(mFrameDuration) * 1000.0) / static_cast(mTimeScale) + : 0.0; +} + +uint64_t VideoPlayoutScheduler::MeasureLag(VideoIOCompletionResult result, uint64_t readyQueueDepth) const +{ + if (result != VideoIOCompletionResult::DisplayedLate && result != VideoIOCompletionResult::Dropped) + return 0; + + uint64_t lagFrames = 1; + if (result == VideoIOCompletionResult::DisplayedLate && mLateStreak > lagFrames) + lagFrames = mLateStreak; + if (result == VideoIOCompletionResult::Dropped && mDropStreak * 2 > lagFrames) + lagFrames = mDropStreak * 2; + + if (mCompletedFrameIndex >= mScheduledFrameIndex) + { + const uint64_t scheduleLagFrames = mCompletedFrameIndex - mScheduledFrameIndex + 1; + if (scheduleLagFrames > lagFrames) + lagFrames = scheduleLagFrames; + } + if (readyQueueDepth < mPolicy.targetReadyFrames && mPolicy.targetReadyFrames - readyQueueDepth > lagFrames) + lagFrames = mPolicy.targetReadyFrames - readyQueueDepth; + + return lagFrames; +} diff --git a/src/video/VideoPlayoutScheduler.h b/src/video/VideoPlayoutScheduler.h new file mode 100644 index 0000000..a231ea8 --- /dev/null +++ b/src/video/VideoPlayoutScheduler.h @@ -0,0 +1,36 @@ +#pragma once + +#include "VideoIOTypes.h" +#include "VideoPlayoutPolicy.h" + +#include + +class VideoPlayoutScheduler +{ +public: + void Configure(int64_t frameDuration, int64_t timeScale); + void Configure(int64_t frameDuration, int64_t timeScale, const VideoPlayoutPolicy& policy); + void Reset(); + VideoIOScheduleTime NextScheduleTime(); + void AlignNextScheduleTimeToPlayback(int64_t streamTime, uint64_t leadFrames); + VideoPlayoutRecoveryDecision AccountForCompletionResult(VideoIOCompletionResult result, uint64_t readyQueueDepth = 0); + double FrameBudgetMilliseconds() const; + uint64_t ScheduledFrameIndex() const { return mScheduledFrameIndex; } + uint64_t CompletedFrameIndex() const { return mCompletedFrameIndex; } + int64_t FrameDuration() const { return mFrameDuration; } + uint64_t LateStreak() const { return mLateStreak; } + uint64_t DropStreak() const { return mDropStreak; } + int64_t TimeScale() const { return mTimeScale; } + const VideoPlayoutPolicy& Policy() const { return mPolicy; } + +private: + uint64_t MeasureLag(VideoIOCompletionResult result, uint64_t readyQueueDepth) const; + + int64_t mFrameDuration = 0; + int64_t mTimeScale = 0; + uint64_t mScheduledFrameIndex = 0; + uint64_t mCompletedFrameIndex = 0; + uint64_t mLateStreak = 0; + uint64_t mDropStreak = 0; + VideoPlayoutPolicy mPolicy; +}; diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt new file mode 100644 index 0000000..4ea8238 --- /dev/null +++ b/tests/CMakeLists.txt @@ -0,0 +1,97 @@ +add_video_shader_test(RenderCadenceCompositorClockTests + "${SRC_DIR}/render/RenderCadenceClock.cpp" + "${TEST_DIR}/RenderCadenceCompositorClockTests.cpp" +) + +add_video_shader_test(RenderCadenceCompositorJsonWriterTests + "${SRC_DIR}/json/JsonWriter.cpp" + "${TEST_DIR}/RenderCadenceCompositorJsonWriterTests.cpp" +) + +add_video_shader_test(RenderCadenceCompositorLoggerTests + "${SRC_DIR}/logging/Logger.cpp" + "${TEST_DIR}/RenderCadenceCompositorLoggerTests.cpp" +) + +add_video_shader_test(RenderCadenceCompositorTelemetryTests + "${SRC_DIR}/json/JsonWriter.cpp" + "${TEST_DIR}/RenderCadenceCompositorTelemetryTests.cpp" +) + +add_video_shader_test(RuntimeJsonTests + "${SRC_DIR}/runtime/RuntimeJson.cpp" + "${TEST_DIR}/RuntimeJsonTests.cpp" +) + +add_video_shader_test(RuntimeParameterUtilsTests + "${SRC_DIR}/runtime/RuntimeJson.cpp" + "${SRC_DIR}/runtime/RuntimeParameterUtils.cpp" + "${TEST_DIR}/RuntimeParameterUtilsTests.cpp" +) + +add_video_shader_test(ShaderPackageRegistryTests + "${SRC_DIR}/runtime/RuntimeJson.cpp" + "${SRC_DIR}/shader/ShaderPackageRegistry.cpp" + "${TEST_DIR}/ShaderPackageRegistryTests.cpp" +) + +add_video_shader_test(ShaderSlangValidationTests + "${SRC_DIR}/runtime/RuntimeJson.cpp" + "${SRC_DIR}/shader/ShaderCompiler.cpp" + "${SRC_DIR}/shader/ShaderPackageRegistry.cpp" + "${TEST_DIR}/ShaderSlangValidationTests.cpp" +) + +add_video_shader_test(Std140BufferTests + "${TEST_DIR}/Std140BufferTests.cpp" +) + +add_video_shader_test(VideoIOFormatTests + "${SRC_DIR}/video/DeckLinkVideoIOFormat.cpp" + "${SRC_DIR}/video/VideoIOFormat.cpp" + "${TEST_DIR}/VideoIOFormatTests.cpp" +) + +add_video_shader_test(VideoPlayoutSchedulerTests + "${SRC_DIR}/video/VideoPlayoutScheduler.cpp" + "${TEST_DIR}/VideoPlayoutSchedulerTests.cpp" +) + +add_video_shader_test(OutputProductionControllerTests + "${SRC_DIR}/video/OutputProductionController.cpp" + "${TEST_DIR}/OutputProductionControllerTests.cpp" +) + +add_video_shader_test(RenderOutputQueueTests + "${SRC_DIR}/video/RenderOutputQueue.cpp" + "${TEST_DIR}/RenderOutputQueueTests.cpp" +) + +add_video_shader_test(RenderCadenceControllerTests + "${SRC_DIR}/video/RenderCadenceController.cpp" + "${TEST_DIR}/RenderCadenceControllerTests.cpp" +) + +add_video_shader_test(SystemOutputFramePoolTests + "${SRC_DIR}/video/SystemOutputFramePool.cpp" + "${SRC_DIR}/video/VideoIOFormat.cpp" + "${TEST_DIR}/SystemOutputFramePoolTests.cpp" +) + +add_video_shader_test(VideoBackendLifecycleTests + "${SRC_DIR}/video/VideoBackendLifecycle.cpp" + "${TEST_DIR}/VideoBackendLifecycleTests.cpp" +) + +add_video_shader_test(VideoIODeviceFakeTests + "${SRC_DIR}/video/VideoIOFormat.cpp" + "${TEST_DIR}/VideoIODeviceFakeTests.cpp" +) + +set_tests_properties(RenderCadenceCompositorLoggerTests PROPERTIES + ENVIRONMENT "VIDEO_SHADER_TEST_LOG_TO_CONSOLE=0" +) + +set_tests_properties(ShaderSlangValidationTests PROPERTIES + ENVIRONMENT "SLANG_ROOT=${SLANG_ROOT}" +)