/*-------------------------------------------------------------------------------------
 *
 * Copyright (c) Microsoft Corporation
 *
 *-------------------------------------------------------------------------------------*/
import "oaidl.idl";
import "ocidl.idl";

import "dxgicommon.idl";
import "d3d12.idl";

cpp_quote("#include <winapifamily.h>")

#pragma region App Family
cpp_quote("#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)")

typedef enum D3D12_VIDEO_FIELD_TYPE
{
    D3D12_VIDEO_FIELD_TYPE_NONE = 0,
    D3D12_VIDEO_FIELD_TYPE_INTERLACED_TOP_FIELD_FIRST = 1,
    D3D12_VIDEO_FIELD_TYPE_INTERLACED_BOTTOM_FIELD_FIRST = 2,
} D3D12_VIDEO_FIELD_TYPE;

typedef enum D3D12_VIDEO_FRAME_STEREO_FORMAT
{
    D3D12_VIDEO_FRAME_STEREO_FORMAT_NONE = 0,
    D3D12_VIDEO_FRAME_STEREO_FORMAT_MONO = 1,
    D3D12_VIDEO_FRAME_STEREO_FORMAT_HORIZONTAL = 2,
    D3D12_VIDEO_FRAME_STEREO_FORMAT_VERTICAL = 3,
    D3D12_VIDEO_FRAME_STEREO_FORMAT_SEPARATE = 4,
} D3D12_VIDEO_FRAME_STEREO_FORMAT;

typedef struct D3D12_VIDEO_FORMAT
{
    DXGI_FORMAT Format;
    DXGI_COLOR_SPACE_TYPE ColorSpace;
} D3D12_VIDEO_FORMAT;

typedef struct D3D12_VIDEO_SAMPLE
{
    UINT Width;
    UINT Height;
    D3D12_VIDEO_FORMAT Format;
} D3D12_VIDEO_SAMPLE;

typedef enum D3D12_VIDEO_FRAME_CODED_INTERLACE_TYPE
{
    D3D12_VIDEO_FRAME_CODED_INTERLACE_TYPE_NONE = 0,
    D3D12_VIDEO_FRAME_CODED_INTERLACE_TYPE_FIELD_BASED = 1,
} D3D12_VIDEO_FRAME_CODED_INTERLACE_TYPE;

typedef enum D3D12_FEATURE_VIDEO
{
    D3D12_FEATURE_VIDEO_DECODE_SUPPORT = 0,
    D3D12_FEATURE_VIDEO_DECODE_PROFILES = 1,
    D3D12_FEATURE_VIDEO_DECODE_FORMATS = 2,
    D3D12_FEATURE_VIDEO_DECODE_CONVERSION_SUPPORT = 3,
    D3D12_FEATURE_VIDEO_PROCESS_SUPPORT = 5,
    D3D12_FEATURE_VIDEO_PROCESS_MAX_INPUT_STREAMS = 6,
    D3D12_FEATURE_VIDEO_PROCESS_REFERENCE_INFO = 7,
    D3D12_FEATURE_VIDEO_DECODER_HEAP_SIZE = 8,
    D3D12_FEATURE_VIDEO_PROCESSOR_SIZE = 9,
    D3D12_FEATURE_VIDEO_DECODE_PROFILE_COUNT = 10,
    D3D12_FEATURE_VIDEO_DECODE_FORMAT_COUNT = 11,
    D3D12_FEATURE_VIDEO_ARCHITECTURE = 17,
    D3D12_FEATURE_VIDEO_DECODE_HISTOGRAM = 18,
} D3D12_FEATURE_VIDEO;

typedef enum D3D12_BITSTREAM_ENCRYPTION_TYPE
{
    D3D12_BITSTREAM_ENCRYPTION_TYPE_NONE = 0,
} D3D12_BITSTREAM_ENCRYPTION_TYPE;

typedef struct D3D12_VIDEO_DECODE_CONFIGURATION
{
    GUID DecodeProfile;
    D3D12_BITSTREAM_ENCRYPTION_TYPE BitstreamEncryption;
    D3D12_VIDEO_FRAME_CODED_INTERLACE_TYPE InterlaceType;
} D3D12_VIDEO_DECODE_CONFIGURATION;

typedef struct D3D12_VIDEO_DECODER_DESC
{
    UINT NodeMask;
    D3D12_VIDEO_DECODE_CONFIGURATION Configuration;
} D3D12_VIDEO_DECODER_DESC;

typedef struct D3D12_VIDEO_DECODER_HEAP_DESC
{
    UINT NodeMask;
    D3D12_VIDEO_DECODE_CONFIGURATION Configuration;
    UINT DecodeWidth;
    UINT DecodeHeight;
    DXGI_FORMAT Format;
    DXGI_RATIONAL FrameRate;
    UINT BitRate;
    UINT MaxDecodePictureBufferCount;
} D3D12_VIDEO_DECODER_HEAP_DESC;

typedef struct D3D12_VIDEO_SIZE_RANGE
{
    UINT MaxWidth;
    UINT MaxHeight;
    UINT MinWidth;
    UINT MinHeight;
} D3D12_VIDEO_SIZE_RANGE;

typedef enum  D3D12_VIDEO_PROCESS_FILTER
{
    D3D12_VIDEO_PROCESS_FILTER_BRIGHTNESS = 0,
    D3D12_VIDEO_PROCESS_FILTER_CONTRAST = 1,
    D3D12_VIDEO_PROCESS_FILTER_HUE = 2,
    D3D12_VIDEO_PROCESS_FILTER_SATURATION = 3,
    D3D12_VIDEO_PROCESS_FILTER_NOISE_REDUCTION = 4,
    D3D12_VIDEO_PROCESS_FILTER_EDGE_ENHANCEMENT = 5,
    D3D12_VIDEO_PROCESS_FILTER_ANAMORPHIC_SCALING = 6,
    D3D12_VIDEO_PROCESS_FILTER_STEREO_ADJUSTMENT = 7,
} D3D12_VIDEO_PROCESS_FILTER;

typedef enum  D3D12_VIDEO_PROCESS_FILTER_FLAGS
{
    D3D12_VIDEO_PROCESS_FILTER_FLAG_NONE = 0x0,
    D3D12_VIDEO_PROCESS_FILTER_FLAG_BRIGHTNESS = (1 << D3D12_VIDEO_PROCESS_FILTER_BRIGHTNESS),
    D3D12_VIDEO_PROCESS_FILTER_FLAG_CONTRAST = (1 << D3D12_VIDEO_PROCESS_FILTER_CONTRAST),
    D3D12_VIDEO_PROCESS_FILTER_FLAG_HUE = (1 << D3D12_VIDEO_PROCESS_FILTER_HUE),
    D3D12_VIDEO_PROCESS_FILTER_FLAG_SATURATION = (1 << D3D12_VIDEO_PROCESS_FILTER_SATURATION),
    D3D12_VIDEO_PROCESS_FILTER_FLAG_NOISE_REDUCTION = (1 << D3D12_VIDEO_PROCESS_FILTER_NOISE_REDUCTION),
    D3D12_VIDEO_PROCESS_FILTER_FLAG_EDGE_ENHANCEMENT = (1 << D3D12_VIDEO_PROCESS_FILTER_EDGE_ENHANCEMENT),
    D3D12_VIDEO_PROCESS_FILTER_FLAG_ANAMORPHIC_SCALING = (1 << D3D12_VIDEO_PROCESS_FILTER_ANAMORPHIC_SCALING),
    D3D12_VIDEO_PROCESS_FILTER_FLAG_STEREO_ADJUSTMENT = (1 << D3D12_VIDEO_PROCESS_FILTER_STEREO_ADJUSTMENT),

} D3D12_VIDEO_PROCESS_FILTER_FLAGS;
cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_FILTER_FLAGS );")

typedef enum D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS
{
    D3D12_VIDEO_PROCESS_DEINTERLACE_FLAG_NONE = 0x0,
    D3D12_VIDEO_PROCESS_DEINTERLACE_FLAG_BOB = 0x1,
    D3D12_VIDEO_PROCESS_DEINTERLACE_FLAG_CUSTOM = 0x80000000,

} D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS;
cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS );")

typedef struct D3D12_VIDEO_PROCESS_ALPHA_BLENDING
{
    BOOL Enable;
    FLOAT Alpha;
} D3D12_VIDEO_PROCESS_ALPHA_BLENDING;

typedef struct D3D12_VIDEO_PROCESS_LUMA_KEY
{
    BOOL Enable;
    FLOAT Lower;
    FLOAT Upper;
} D3D12_VIDEO_PROCESS_LUMA_KEY;

typedef struct D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC
{
    DXGI_FORMAT Format;
    DXGI_COLOR_SPACE_TYPE ColorSpace;
    DXGI_RATIONAL SourceAspectRatio;
    DXGI_RATIONAL DestinationAspectRatio;
    DXGI_RATIONAL FrameRate;
    D3D12_VIDEO_SIZE_RANGE SourceSizeRange;
    D3D12_VIDEO_SIZE_RANGE DestinationSizeRange;
    BOOL EnableOrientation;
    D3D12_VIDEO_PROCESS_FILTER_FLAGS FilterFlags;
    D3D12_VIDEO_FRAME_STEREO_FORMAT StereoFormat;
    D3D12_VIDEO_FIELD_TYPE FieldType;
    D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS DeinterlaceMode;
    BOOL EnableAlphaBlending;
    D3D12_VIDEO_PROCESS_LUMA_KEY LumaKey;
    UINT NumPastFrames;
    UINT NumFutureFrames;
    BOOL EnableAutoProcessing;
} D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC;

typedef enum D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE
{
    D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE_OPAQUE = 0,
    D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE_BACKGROUND = 1,
    D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE_DESTINATION = 2,
    D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE_SOURCE_STREAM = 3,
} D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE;

typedef struct D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC
{
    DXGI_FORMAT Format;
    DXGI_COLOR_SPACE_TYPE ColorSpace;
    D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE AlphaFillMode;
    UINT AlphaFillModeSourceStreamIndex;
    FLOAT BackgroundColor[4];
    DXGI_RATIONAL FrameRate;
    BOOL EnableStereo;
} D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC;

[uuid(0946B7C9-EBF6-4047-BB73-8683E27DBB1F), object, local, pointer_default(unique)]
interface ID3D12VideoDecoderHeap
    : ID3D12Pageable
{
    D3D12_VIDEO_DECODER_HEAP_DESC GetDesc();
}

[uuid(1F052807-0B46-4ACC-8A89-364F793718A4), object, local, pointer_default(unique)]
interface ID3D12VideoDevice
    : IUnknown
{
    HRESULT CheckFeatureSupport(
        D3D12_FEATURE_VIDEO FeatureVideo,
        [annotation("_Inout_updates_bytes_(FeatureSupportDataSize)")] void* pFeatureSupportData,
        UINT FeatureSupportDataSize
        );

    HRESULT CreateVideoDecoder(
        [annotation("_In_")] const D3D12_VIDEO_DECODER_DESC* pDesc,
        [annotation("_In_")] REFIID riid, // Expected: IID_ID3D12VideoDecoder, 
        [out, iid_is(riid), annotation("_COM_Outptr_")] void** ppVideoDecoder
        );

    HRESULT CreateVideoDecoderHeap(
        [annotation("_In_")]const D3D12_VIDEO_DECODER_HEAP_DESC* pVideoDecoderHeapDesc,
        [annotation("_In_")] REFIID riid, // Expected: IID_ID3D12VideoDecoderHeap, 
        [out, iid_is(riid), annotation("_COM_Outptr_")] void** ppVideoDecoderHeap
        );

    HRESULT CreateVideoProcessor(
        UINT NodeMask,
        [annotation("_In_")] const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC* pOutputStreamDesc,
        UINT NumInputStreamDescs,
        [annotation("_In_reads_(NumInputStreamDescs)")]const D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC *pInputStreamDescs,
        [annotation("_In_")] REFIID riid, // Expected: IID_ID3D12VideoProcessor, 
        [out, iid_is(riid), annotation("_COM_Outptr_")] void **ppVideoProcessor
        );
}

[uuid(C59B6BDC-7720-4074-A136-17A156037470), object, local, pointer_default(unique)]
interface ID3D12VideoDecoder
    : ID3D12Pageable
{
    D3D12_VIDEO_DECODER_DESC GetDesc();
}

typedef enum D3D12_VIDEO_DECODE_TIER
{
    D3D12_VIDEO_DECODE_TIER_NOT_SUPPORTED = 0,
    D3D12_VIDEO_DECODE_TIER_1 = 1,
    D3D12_VIDEO_DECODE_TIER_2 = 2,
    D3D12_VIDEO_DECODE_TIER_3 = 3,
} D3D12_VIDEO_DECODE_TIER;

typedef enum D3D12_VIDEO_DECODE_SUPPORT_FLAGS
{
    D3D12_VIDEO_DECODE_SUPPORT_FLAG_NONE = 0x0,
    D3D12_VIDEO_DECODE_SUPPORT_FLAG_SUPPORTED = 0x1,

} D3D12_VIDEO_DECODE_SUPPORT_FLAGS;
cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_DECODE_SUPPORT_FLAGS );")

typedef enum D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS
{
    D3D12_VIDEO_DECODE_CONFIGURATION_FLAG_NONE                                      = 0x0,
    D3D12_VIDEO_DECODE_CONFIGURATION_FLAG_HEIGHT_ALIGNMENT_MULTIPLE_32_REQUIRED     = 0x1,
    D3D12_VIDEO_DECODE_CONFIGURATION_FLAG_POST_PROCESSING_SUPPORTED                 = 0x2,
    D3D12_VIDEO_DECODE_CONFIGURATION_FLAG_REFERENCE_ONLY_ALLOCATIONS_REQUIRED       = 0x4,
    D3D12_VIDEO_DECODE_CONFIGURATION_FLAG_ALLOW_RESOLUTION_CHANGE_ON_NON_KEY_FRAME  = 0x8,

} D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS;
cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS );")

typedef enum D3D12_VIDEO_DECODE_STATUS
{
    D3D12_VIDEO_DECODE_STATUS_OK = 0,
    D3D12_VIDEO_DECODE_STATUS_CONTINUE = 1,
    D3D12_VIDEO_DECODE_STATUS_CONTINUE_SKIP_DISPLAY = 2,
    D3D12_VIDEO_DECODE_STATUS_RESTART = 3,
} D3D12_VIDEO_DECODE_STATUS;

typedef enum D3D12_VIDEO_DECODE_ARGUMENT_TYPE
{
    D3D12_VIDEO_DECODE_ARGUMENT_TYPE_PICTURE_PARAMETERS = 0,
    D3D12_VIDEO_DECODE_ARGUMENT_TYPE_INVERSE_QUANTIZATION_MATRIX = 1,
    D3D12_VIDEO_DECODE_ARGUMENT_TYPE_SLICE_CONTROL = 2,
    D3D12_VIDEO_DECODE_ARGUMENT_TYPE_MAX_VALID = 3
} D3D12_VIDEO_DECODE_ARGUMENT_TYPE;

typedef struct D3D12_FEATURE_DATA_VIDEO_DECODE_SUPPORT
{
    UINT NodeIndex;                                            // input
    D3D12_VIDEO_DECODE_CONFIGURATION Configuration;            // input
    UINT Width;                                                // input
    UINT Height;                                               // input
    DXGI_FORMAT DecodeFormat;                                  // input
    DXGI_RATIONAL FrameRate;                                   // input
    UINT BitRate;                                              // input
    D3D12_VIDEO_DECODE_SUPPORT_FLAGS SupportFlags;             // output
    D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS ConfigurationFlags; // output
    D3D12_VIDEO_DECODE_TIER DecodeTier;                        // output
} D3D12_FEATURE_DATA_VIDEO_DECODE_SUPPORT;

typedef struct D3D12_FEATURE_DATA_VIDEO_DECODE_PROFILE_COUNT
{
    UINT NodeIndex;                                             // input
    UINT ProfileCount;                                          // output
} D3D12_FEATURE_DATA_VIDEO_DECODE_PROFILE_COUNT;

typedef struct D3D12_FEATURE_DATA_VIDEO_DECODE_PROFILES
{
    UINT NodeIndex;                                                   // input
    UINT ProfileCount;                                                // input
    [annotation("_Field_size_full_(ProfileCount)")] GUID *pProfiles;  // output. The list of supported profiles. The caller allocates storage for the profile list before calling CheckFeatureSupport.
} D3D12_FEATURE_DATA_VIDEO_DECODE_PROFILES;

typedef struct D3D12_FEATURE_DATA_VIDEO_DECODE_FORMAT_COUNT
{
    UINT NodeIndex;                                                             // input
    D3D12_VIDEO_DECODE_CONFIGURATION Configuration;                             // input
    UINT FormatCount;                                                           // output
} D3D12_FEATURE_DATA_VIDEO_DECODE_FORMAT_COUNT;

typedef struct D3D12_FEATURE_DATA_VIDEO_DECODE_FORMATS
{
    UINT NodeIndex;                                                              // input
    D3D12_VIDEO_DECODE_CONFIGURATION Configuration;                              // input
    UINT FormatCount;                                                            // input
    [annotation("_Field_size_full_(FormatCount)")] DXGI_FORMAT *pOutputFormats;  // output. The list of supported video formats. The caller allocates storage for the format list before calling CheckFeatureSupport.
} D3D12_FEATURE_DATA_VIDEO_DECODE_FORMATS;

typedef struct D3D12_FEATURE_DATA_VIDEO_ARCHITECTURE
{
    BOOL IOCoherent;
} D3D12_FEATURE_DATA_VIDEO_ARCHITECTURE;

typedef enum D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT
{
    D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_Y = 0,
    D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_U = 1, 
    D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_V = 2,
    
    D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_R = 0,
    D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_G = 1, 
    D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_B = 2,

    D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_A = 3,
} D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT; 

typedef enum D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS
{
    D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_NONE = 0x0,

    D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_Y = (1 << D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_Y),
    D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_U = (1 << D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_U), 
    D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_V = (1 << D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_V),

    D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_R = (1 << D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_R),
    D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_G = (1 << D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_G), 
    D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_B = (1 << D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_B),

    D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_A = (1 << D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_A),
} D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS; 
cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS );")

typedef struct D3D12_FEATURE_DATA_VIDEO_DECODE_HISTOGRAM
{
    UINT NodeIndex;                                                       // in
    GUID DecodeProfile;                                                   // in
    UINT Width;                                                           // in
    UINT Height;                                                          // in
    DXGI_FORMAT DecodeFormat;                                             // in
    D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS Components;              // out
    UINT BinCount;                                                        // out
    UINT CounterBitDepth;                                                 // out
} D3D12_FEATURE_DATA_VIDEO_DECODE_HISTOGRAM;

typedef enum D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS
{
    D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAG_NONE = 0x0,
    D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAG_SUPPORTED = 0x1,

} D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS;
cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS );")

typedef enum D3D12_VIDEO_SCALE_SUPPORT_FLAGS
{
    D3D12_VIDEO_SCALE_SUPPORT_FLAG_NONE = 0x0,
    D3D12_VIDEO_SCALE_SUPPORT_FLAG_POW2_ONLY = 0x1,
    D3D12_VIDEO_SCALE_SUPPORT_FLAG_EVEN_DIMENSIONS_ONLY = 0x2,

} D3D12_VIDEO_SCALE_SUPPORT_FLAGS;
cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_SCALE_SUPPORT_FLAGS );")

typedef struct D3D12_VIDEO_SCALE_SUPPORT
{
    D3D12_VIDEO_SIZE_RANGE OutputSizeRange;
    D3D12_VIDEO_SCALE_SUPPORT_FLAGS Flags;
} D3D12_VIDEO_SCALE_SUPPORT;

typedef struct D3D12_FEATURE_DATA_VIDEO_DECODE_CONVERSION_SUPPORT
{
    UINT NodeIndex;                                             // input
    D3D12_VIDEO_DECODE_CONFIGURATION Configuration;             // input
    D3D12_VIDEO_SAMPLE DecodeSample;                            // input
    D3D12_VIDEO_FORMAT OutputFormat;                            // input
    DXGI_RATIONAL FrameRate;                                    // input
    UINT BitRate;                                               // input
    D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS SupportFlags;   // output
    D3D12_VIDEO_SCALE_SUPPORT ScaleSupport;                     // output
} D3D12_FEATURE_DATA_VIDEO_DECODE_CONVERSION_SUPPORT;

typedef struct D3D12_FEATURE_DATA_VIDEO_DECODER_HEAP_SIZE
{
    D3D12_VIDEO_DECODER_HEAP_DESC VideoDecoderHeapDesc;         // input
    UINT64 MemoryPoolL0Size;                                    // output
    UINT64 MemoryPoolL1Size;                                    // output
} D3D12_FEATURE_DATA_VIDEO_DECODER_HEAP_SIZE;

typedef struct D3D12_FEATURE_DATA_VIDEO_PROCESSOR_SIZE
{
    UINT NodeMask;
    const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC* pOutputStreamDesc;    // input
    UINT NumInputStreamDescs;                                           // input
    const D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC *pInputStreamDescs;     // input
    UINT64 MemoryPoolL0Size;                                            // output
    UINT64 MemoryPoolL1Size;                                            // output
} D3D12_FEATURE_DATA_VIDEO_PROCESSOR_SIZE;

typedef struct D3D12_QUERY_DATA_VIDEO_DECODE_STATISTICS
{
    UINT64 Status;                      // see D3D12_VIDEO_DECODE_STATUS 
    UINT64 NumMacroblocksAffected;
    DXGI_RATIONAL FrameRate;
    UINT BitRate;
} D3D12_QUERY_DATA_VIDEO_DECODE_STATISTICS;

typedef struct D3D12_VIDEO_DECODE_SUB_SAMPLE_MAPPING_BLOCK
{
    UINT   ClearSize;
    UINT   EncryptedSize;
} D3D12_VIDEO_DECODE_SUB_SAMPLE_MAPPING_BLOCK;

typedef struct D3D12_VIDEO_DECODE_FRAME_ARGUMENT
{
    D3D12_VIDEO_DECODE_ARGUMENT_TYPE Type;
    UINT Size;
    [annotation("_Field_size_bytes_full_(Size)")] void *pData;
} D3D12_VIDEO_DECODE_FRAME_ARGUMENT;

typedef struct D3D12_VIDEO_DECODE_REFERENCE_FRAMES
{
    UINT NumTexture2Ds;
    [annotation("_Field_size_full_(NumTexture2Ds)")] ID3D12Resource** ppTexture2Ds;
    [annotation("_Field_size_full_(NumTexture2Ds)")] UINT* pSubresources;
    [annotation("_Field_size_full_opt_(NumTexture2Ds)")] ID3D12VideoDecoderHeap** ppHeaps; // If null, assume single decoder heap from input args.
} D3D12_VIDEO_DECODE_REFERENCE_FRAMES;

typedef struct D3D12_VIDEO_DECODE_COMPRESSED_BITSTREAM
{
    ID3D12Resource* pBuffer;
    UINT64 Offset;
    UINT64 Size;
} D3D12_VIDEO_DECODE_COMPRESSED_BITSTREAM;

typedef struct D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS
{
    BOOL Enable;
    ID3D12Resource* pReferenceTexture2D;
    UINT ReferenceSubresource;
    DXGI_COLOR_SPACE_TYPE OutputColorSpace;
    DXGI_COLOR_SPACE_TYPE DecodeColorSpace;
} D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS;

typedef struct D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS
{
    UINT NumFrameArguments;
    D3D12_VIDEO_DECODE_FRAME_ARGUMENT FrameArguments[D3D12_VIDEO_DECODE_MAX_ARGUMENTS];
    D3D12_VIDEO_DECODE_REFERENCE_FRAMES ReferenceFrames;
    D3D12_VIDEO_DECODE_COMPRESSED_BITSTREAM CompressedBitstream;
    ID3D12VideoDecoderHeap *pHeap;
} D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS;

typedef struct D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS
{
    ID3D12Resource* pOutputTexture2D;
    UINT OutputSubresource;
    D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS ConversionArguments;
} D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS;

[uuid(304FDB32-BEDE-410A-8545-943AC6A46138), object, local, pointer_default(unique)]
interface ID3D12VideoProcessor
    : ID3D12Pageable
{
    UINT GetNodeMask();
    UINT GetNumInputStreamDescs();
    HRESULT GetInputStreamDescs(UINT NumInputStreamDescs, [annotation("_Out_writes_(NumInputStreamDescs)")] D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC *pInputStreamDescs);
    D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC GetOutputStreamDesc();
}

typedef enum D3D12_VIDEO_PROCESS_FEATURE_FLAGS
{
    D3D12_VIDEO_PROCESS_FEATURE_FLAG_NONE = 0x0,
    D3D12_VIDEO_PROCESS_FEATURE_FLAG_ALPHA_FILL = 0x1,
    D3D12_VIDEO_PROCESS_FEATURE_FLAG_LUMA_KEY = 0x2,
    D3D12_VIDEO_PROCESS_FEATURE_FLAG_STEREO = 0x4,
    D3D12_VIDEO_PROCESS_FEATURE_FLAG_ROTATION = 0x8,
    D3D12_VIDEO_PROCESS_FEATURE_FLAG_FLIP = 0x10,
    D3D12_VIDEO_PROCESS_FEATURE_FLAG_ALPHA_BLENDING = 0x20,
    D3D12_VIDEO_PROCESS_FEATURE_FLAG_PIXEL_ASPECT_RATIO = 0x40,

} D3D12_VIDEO_PROCESS_FEATURE_FLAGS;
cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_FEATURE_FLAGS );")

typedef enum D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS
{
    D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_NONE = 0x0,
    D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_DENOISE = 0x01,
    D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_DERINGING = 0x02,
    D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_EDGE_ENHANCEMENT = 0x04,
    D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_COLOR_CORRECTION = 0x08,
    D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_FLESH_TONE_MAPPING = 0x10,
    D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_IMAGE_STABILIZATION = 0x20,
    D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_SUPER_RESOLUTION = 0x40,
    D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_ANAMORPHIC_SCALING = 0x80,
    D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_CUSTOM = 0x80000000,

} D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS;
cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS );")

typedef enum D3D12_VIDEO_PROCESS_ORIENTATION
{
    D3D12_VIDEO_PROCESS_ORIENTATION_DEFAULT = 0,
    D3D12_VIDEO_PROCESS_ORIENTATION_FLIP_HORIZONTAL = 1,
    D3D12_VIDEO_PROCESS_ORIENTATION_CLOCKWISE_90 = 2,
    D3D12_VIDEO_PROCESS_ORIENTATION_CLOCKWISE_90_FLIP_HORIZONTAL = 3,
    D3D12_VIDEO_PROCESS_ORIENTATION_CLOCKWISE_180 = 4,
    D3D12_VIDEO_PROCESS_ORIENTATION_FLIP_VERTICAL = 5,
    D3D12_VIDEO_PROCESS_ORIENTATION_CLOCKWISE_270 = 6,
    D3D12_VIDEO_PROCESS_ORIENTATION_CLOCKWISE_270_FLIP_HORIZONTAL = 7,
} D3D12_VIDEO_PROCESS_ORIENTATION;

typedef enum D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS
{
    D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAG_NONE = 0x0,
    D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAG_FRAME_DISCONTINUITY = 0x1,
    D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAG_FRAME_REPEAT = 0x2,

} D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS;
cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS );")

typedef struct D3D12_VIDEO_PROCESS_FILTER_RANGE
{
    INT   Minimum;
    INT   Maximum;
    INT   Default;
    FLOAT Multiplier;
} D3D12_VIDEO_PROCESS_FILTER_RANGE;

typedef enum D3D12_VIDEO_PROCESS_SUPPORT_FLAGS
{
    D3D12_VIDEO_PROCESS_SUPPORT_FLAG_NONE = 0x0,
    D3D12_VIDEO_PROCESS_SUPPORT_FLAG_SUPPORTED = 0x1,

} D3D12_VIDEO_PROCESS_SUPPORT_FLAGS;
cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_SUPPORT_FLAGS );")

typedef struct D3D12_FEATURE_DATA_VIDEO_PROCESS_SUPPORT
{
    UINT NodeIndex;                                                                         // input
    D3D12_VIDEO_SAMPLE InputSample;                                                         // input
    D3D12_VIDEO_FIELD_TYPE InputFieldType;                                                  // input
    D3D12_VIDEO_FRAME_STEREO_FORMAT InputStereoFormat;                                      // input
    DXGI_RATIONAL InputFrameRate;                                                           // input
    D3D12_VIDEO_FORMAT OutputFormat;                                                        // input
    D3D12_VIDEO_FRAME_STEREO_FORMAT OutputStereoFormat;                                     // input
    DXGI_RATIONAL OutputFrameRate;                                                          // input
    D3D12_VIDEO_PROCESS_SUPPORT_FLAGS SupportFlags;                                         // output
    D3D12_VIDEO_SCALE_SUPPORT ScaleSupport;                                                 // output
    D3D12_VIDEO_PROCESS_FEATURE_FLAGS FeatureSupport;                                       // output
    D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS DeinterlaceSupport;                               // output
    D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS AutoProcessingSupport;                        // output
    D3D12_VIDEO_PROCESS_FILTER_FLAGS FilterSupport;                                         // output
    D3D12_VIDEO_PROCESS_FILTER_RANGE FilterRangeSupport[D3D12_VIDEO_PROCESS_MAX_FILTERS];   // output
} D3D12_FEATURE_DATA_VIDEO_PROCESS_SUPPORT;

typedef struct D3D12_FEATURE_DATA_VIDEO_PROCESS_MAX_INPUT_STREAMS
{
    UINT NodeIndex;                                             // input
    UINT MaxInputStreams;                                       // output
} D3D12_FEATURE_DATA_VIDEO_PROCESS_MAX_INPUT_STREAMS;

typedef struct D3D12_FEATURE_DATA_VIDEO_PROCESS_REFERENCE_INFO
{
    UINT NodeIndex;                                             // input
    D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS DeinterlaceMode;      // input
    D3D12_VIDEO_PROCESS_FILTER_FLAGS Filters;                   // input
    D3D12_VIDEO_PROCESS_FEATURE_FLAGS FeatureSupport;           // input
    DXGI_RATIONAL InputFrameRate;                               // input
    DXGI_RATIONAL OutputFrameRate;                              // input 
    BOOL EnableAutoProcessing;                                  // input
    UINT PastFrames;                                            // output
    UINT FutureFrames;                                          // output
} D3D12_FEATURE_DATA_VIDEO_PROCESS_REFERENCE_INFO;

typedef struct D3D12_VIDEO_PROCESS_REFERENCE_SET
{
    UINT NumPastFrames;
    ID3D12Resource **ppPastFrames;
    UINT *pPastSubresources;
    UINT NumFutureFrames;
    ID3D12Resource **ppFutureFrames;
    UINT *pFutureSubresources;
} D3D12_VIDEO_PROCESS_REFERENCE_SET;

typedef struct D3D12_VIDEO_PROCESS_TRANSFORM
{
    D3D12_RECT SourceRectangle;
    D3D12_RECT DestinationRectangle;
    D3D12_VIDEO_PROCESS_ORIENTATION Orientation;
} D3D12_VIDEO_PROCESS_TRANSFORM;

typedef struct D3D12_VIDEO_PROCESS_INPUT_STREAM_RATE
{
    UINT OutputIndex;
    UINT InputFrameOrField;
} D3D12_VIDEO_PROCESS_INPUT_STREAM_RATE;

typedef struct D3D12_VIDEO_PROCESS_INPUT_STREAM
{
    ID3D12Resource *pTexture2D;
    UINT Subresource;
    D3D12_VIDEO_PROCESS_REFERENCE_SET ReferenceSet;
} D3D12_VIDEO_PROCESS_INPUT_STREAM;

typedef struct D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS
{
    D3D12_VIDEO_PROCESS_INPUT_STREAM InputStream[D3D12_VIDEO_PROCESS_STEREO_VIEWS];
    D3D12_VIDEO_PROCESS_TRANSFORM Transform;
    D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS Flags;
    D3D12_VIDEO_PROCESS_INPUT_STREAM_RATE RateInfo;
    INT FilterLevels[D3D12_VIDEO_PROCESS_MAX_FILTERS];
    D3D12_VIDEO_PROCESS_ALPHA_BLENDING AlphaBlending;
} D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS;

typedef struct D3D12_VIDEO_PROCESS_OUTPUT_STREAM
{
    ID3D12Resource* pTexture2D;
    UINT Subresource;
} D3D12_VIDEO_PROCESS_OUTPUT_STREAM;

typedef struct D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS
{
    D3D12_VIDEO_PROCESS_OUTPUT_STREAM OutputStream[D3D12_VIDEO_PROCESS_STEREO_VIEWS];
    D3D12_RECT TargetRectangle;
} D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS;

[uuid(3B60536E-AD29-4E64-A269-F853837E5E53), object, local, pointer_default(unique)]
interface ID3D12VideoDecodeCommandList
    : ID3D12CommandList
{
    HRESULT Close();

    HRESULT Reset(
        [annotation("_In_")] ID3D12CommandAllocator* pAllocator
        );

    void ClearState();

    void ResourceBarrier(
        [annotation("_In_")] UINT NumBarriers,
        [annotation("_In_reads_(NumBarriers)")] const D3D12_RESOURCE_BARRIER* pBarriers
        );

    void DiscardResource(
        [annotation("_In_")] ID3D12Resource* pResource,
        [annotation("_In_opt_")] const D3D12_DISCARD_REGION* pRegion
        );

    void BeginQuery(
        [annotation("_In_")] ID3D12QueryHeap* pQueryHeap,
        [annotation("_In_")] D3D12_QUERY_TYPE Type,
        [annotation("_In_")] UINT Index
        );

    void EndQuery(
        [annotation("_In_")] ID3D12QueryHeap* pQueryHeap,
        [annotation("_In_")] D3D12_QUERY_TYPE Type,
        [annotation("_In_")] UINT Index
        );

    void ResolveQueryData(
        [annotation("_In_")] ID3D12QueryHeap* pQueryHeap,
        [annotation("_In_")] D3D12_QUERY_TYPE Type,
        [annotation("_In_")] UINT StartIndex,
        [annotation("_In_")] UINT NumQueries,
        [annotation("_In_")] ID3D12Resource* pDestinationBuffer,
        [annotation("_In_")] UINT64 AlignedDestinationBufferOffset
        );

    void SetPredication(
        [annotation("_In_opt_")] ID3D12Resource* pBuffer,
        [annotation("_In_")] UINT64 AlignedBufferOffset,
        [annotation("_In_")] D3D12_PREDICATION_OP Operation
        );

    void SetMarker(
        UINT Metadata,
        [annotation("_In_reads_bytes_opt_(Size)")] const void* pData,
        UINT Size);

    void BeginEvent(
        UINT Metadata,
        [annotation("_In_reads_bytes_opt_(Size)")] const void* pData,
        UINT Size);

    void EndEvent();

    void DecodeFrame(
        [annotation("_In_")] ID3D12VideoDecoder* pDecoder,
        [annotation("_In_")] const D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS *pOutputArguments,
        [annotation("_In_")] const D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS *pInputArguments
        );

    void WriteBufferImmediate(
        UINT Count,
        [annotation("_In_reads_(Count)")] const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
        [annotation("_In_reads_opt_(Count)")] const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes
        );
}

[uuid(AEB2543A-167F-4682-ACC8-D159ED4A6209), object, local, pointer_default(unique)]
interface ID3D12VideoProcessCommandList
    : ID3D12CommandList
{
    HRESULT Close();

    HRESULT Reset(
        [annotation("_In_")] ID3D12CommandAllocator* pAllocator
        );

    void ClearState();

    void ResourceBarrier(
        [annotation("_In_")] UINT NumBarriers,
        [annotation("_In_reads_(NumBarriers)")] const D3D12_RESOURCE_BARRIER* pBarriers
        );

    void DiscardResource(
        [annotation("_In_")] ID3D12Resource* pResource,
        [annotation("_In_opt_")] const D3D12_DISCARD_REGION* pRegion
        );

    void BeginQuery(
        [annotation("_In_")] ID3D12QueryHeap* pQueryHeap,
        [annotation("_In_")] D3D12_QUERY_TYPE Type,
        [annotation("_In_")] UINT Index
        );

    void EndQuery(
        [annotation("_In_")] ID3D12QueryHeap* pQueryHeap,
        [annotation("_In_")] D3D12_QUERY_TYPE Type,
        [annotation("_In_")] UINT Index
        );

    void ResolveQueryData(
        [annotation("_In_")] ID3D12QueryHeap* pQueryHeap,
        [annotation("_In_")] D3D12_QUERY_TYPE Type,
        [annotation("_In_")] UINT StartIndex,
        [annotation("_In_")] UINT NumQueries,
        [annotation("_In_")] ID3D12Resource* pDestinationBuffer,
        [annotation("_In_")] UINT64 AlignedDestinationBufferOffset
        );

    void SetPredication(
        [annotation("_In_opt_")] ID3D12Resource* pBuffer,
        [annotation("_In_")] UINT64 AlignedBufferOffset,
        [annotation("_In_")] D3D12_PREDICATION_OP Operation
        );

    void SetMarker(
        UINT Metadata,
        [annotation("_In_reads_bytes_opt_(Size)")] const void* pData,
        UINT Size);

    void BeginEvent(
        UINT Metadata,
        [annotation("_In_reads_bytes_opt_(Size)")] const void* pData,
        UINT Size);

    void EndEvent();

    void ProcessFrames(
        [annotation("_In_")] ID3D12VideoProcessor* pVideoProcessor,
        [annotation("_In_")] const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS *pOutputArguments,
        UINT NumInputStreams,
        [annotation("_In_reads_(NumInputStreams)")] const D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS *pInputArguments
        );

    void WriteBufferImmediate(
        UINT Count,
        [annotation("_In_reads_(Count)")] const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
        [annotation("_In_reads_opt_(Count)")] const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes
        );
}

typedef struct D3D12_VIDEO_DECODE_OUTPUT_HISTOGRAM
{
    UINT64 Offset;
    ID3D12Resource* pBuffer;
} D3D12_VIDEO_DECODE_OUTPUT_HISTOGRAM;

typedef struct D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS1
{
    BOOL Enable;
    ID3D12Resource* pReferenceTexture2D;
    UINT ReferenceSubresource;
    DXGI_COLOR_SPACE_TYPE OutputColorSpace;
    DXGI_COLOR_SPACE_TYPE DecodeColorSpace;
    UINT OutputWidth;
    UINT OutputHeight;
} D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS1;

typedef struct D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS1
{
    ID3D12Resource* pOutputTexture2D;
    UINT OutputSubresource;
    D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS1 ConversionArguments;
    D3D12_VIDEO_DECODE_OUTPUT_HISTOGRAM Histograms[D3D12_VIDEO_DECODE_MAX_HISTOGRAM_COMPONENTS];
} D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS1;

[uuid(D52F011B-B56E-453C-A05A-A7F311C8F472), object, local, pointer_default(unique)]
interface ID3D12VideoDecodeCommandList1
    : ID3D12VideoDecodeCommandList
{
    void DecodeFrame1(
        [annotation("_In_")] ID3D12VideoDecoder* pDecoder,
        [annotation("_In_")] const D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS1 *pOutputArguments,
        [annotation("_In_")] const D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS *pInputArguments
        );
}

typedef struct D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS1
{
    D3D12_VIDEO_PROCESS_INPUT_STREAM InputStream[D3D12_VIDEO_PROCESS_STEREO_VIEWS];
    D3D12_VIDEO_PROCESS_TRANSFORM Transform;
    D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS Flags;
    D3D12_VIDEO_PROCESS_INPUT_STREAM_RATE RateInfo;
    INT FilterLevels[D3D12_VIDEO_PROCESS_MAX_FILTERS];
    D3D12_VIDEO_PROCESS_ALPHA_BLENDING AlphaBlending;
    D3D12_VIDEO_FIELD_TYPE FieldType;
} D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS1;

[uuid(542C5C4D-7596-434F-8C93-4EFA6766F267), object, local, pointer_default(unique)]
interface ID3D12VideoProcessCommandList1 : ID3D12VideoProcessCommandList
{
    void ProcessFrames1(
        [annotation("_In_")] ID3D12VideoProcessor* pVideoProcessor,
        [annotation("_In_")] const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS *pOutputArguments,
        UINT NumInputStreams,
        [annotation("_In_reads_(NumInputStreams)")] const D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS1 *pInputArguments
        );
}

cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_MPEG2, 0xee27417f, 0x5e28, 0x4e65, 0xbe, 0xea, 0x1d, 0x26, 0xb5, 0x08, 0xad, 0xc9); ")
cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_MPEG1_AND_MPEG2, 0x86695f12, 0x340e, 0x4f04, 0x9f, 0xd3, 0x92, 0x53, 0xdd, 0x32, 0x74, 0x60); ")
cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_H264, 0x1b81be68, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5);")
cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_H264_STEREO_PROGRESSIVE, 0xd79be8da, 0x0cf1, 0x4c81, 0xb8, 0x2a, 0x69, 0xa4, 0xe2, 0x36, 0xf4, 0x3d);")
cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_H264_STEREO, 0xf9aaccbb, 0xc2b6, 0x4cfc, 0x87, 0x79, 0x57, 0x07, 0xb1, 0x76, 0x05, 0x52);")
cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_H264_MULTIVIEW, 0x705b9d82, 0x76cf, 0x49d6, 0xb7, 0xe6, 0xac, 0x88, 0x72, 0xdb, 0x01, 0x3c);")
cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_VC1, 0x1b81beA3, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5);")
cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_VC1_D2010, 0x1b81beA4, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5);")
cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_MPEG4PT2_SIMPLE, 0xefd64d74, 0xc9e8,0x41d7,0xa5,0xe9,0xe9,0xb0,0xe3,0x9f,0xa3,0x19);")
cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_MPEG4PT2_ADVSIMPLE_NOGMC, 0xed418a9f, 0x010d, 0x4eda, 0x9a, 0xe3, 0x9a, 0x65, 0x35, 0x8d, 0x8d, 0x2e);")
cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_HEVC_MAIN, 0x5b11d51b, 0x2f4c, 0x4452, 0xbc, 0xc3, 0x09, 0xf2, 0xa1, 0x16, 0x0c, 0xc0);")
cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_HEVC_MAIN10, 0x107af0e0, 0xef1a, 0x4d19, 0xab, 0xa8, 0x67, 0xa1, 0x63, 0x07, 0x3d, 0x13);")
cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_VP9, 0x463707f8, 0xa1d0, 0x4585, 0x87, 0x6d, 0x83, 0xaa, 0x6d, 0x60, 0xb8, 0x9e);")
cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_VP9_10BIT_PROFILE2, 0xa4c749ef, 0x6ecf, 0x48aa, 0x84, 0x48, 0x50, 0xa7, 0xa1, 0x16, 0x5f, 0xf7);")
cpp_quote("DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_VP8, 0x90b899ea, 0x3a62, 0x4705, 0x88, 0xb3, 0x8d, 0xf0, 0x4b, 0x27, 0x44, 0xe7);")

cpp_quote("#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */")
#pragma endregion

cpp_quote( "DEFINE_GUID(IID_ID3D12VideoDecoderHeap,0x0946B7C9,0xEBF6,0x4047,0xBB,0x73,0x86,0x83,0xE2,0x7D,0xBB,0x1F);" )
cpp_quote( "DEFINE_GUID(IID_ID3D12VideoDevice,0x1F052807,0x0B46,0x4ACC,0x8A,0x89,0x36,0x4F,0x79,0x37,0x18,0xA4);" )
cpp_quote( "DEFINE_GUID(IID_ID3D12VideoDecoder,0xC59B6BDC,0x7720,0x4074,0xA1,0x36,0x17,0xA1,0x56,0x03,0x74,0x70);" )
cpp_quote( "DEFINE_GUID(IID_ID3D12VideoProcessor,0x304FDB32,0xBEDE,0x410A,0x85,0x45,0x94,0x3A,0xC6,0xA4,0x61,0x38);" )
cpp_quote( "DEFINE_GUID(IID_ID3D12VideoDecodeCommandList,0x3B60536E,0xAD29,0x4E64,0xA2,0x69,0xF8,0x53,0x83,0x7E,0x5E,0x53);" )
cpp_quote( "DEFINE_GUID(IID_ID3D12VideoProcessCommandList,0xAEB2543A,0x167F,0x4682,0xAC,0xC8,0xD1,0x59,0xED,0x4A,0x62,0x09);" )
cpp_quote( "DEFINE_GUID(IID_ID3D12VideoDecodeCommandList1,0xD52F011B,0xB56E,0x453C,0xA0,0x5A,0xA7,0xF3,0x11,0xC8,0xF4,0x72);" )
cpp_quote( "DEFINE_GUID(IID_ID3D12VideoProcessCommandList1,0x542C5C4D,0x7596,0x434F,0x8C,0x93,0x4E,0xFA,0x67,0x66,0xF2,0x67);" )
