vdpau.h

Go to the documentation of this file.

/*
 * This source file is documented using Doxygen markup.
 * See http://www.stack.nl/~dimitri/doxygen/
 */
 
/*
 * This copyright notice applies to this header file:
 *
 * Copyright (c) 2008-2015 NVIDIA Corporation
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * 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 AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */
 
#ifndef _VDPAU_H
#define _VDPAU_H
 
#include <stdint.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define VDP_TRUE 1
#define VDP_FALSE 0
typedef int VdpBool;
 
#define VDP_INVALID_HANDLE 0xffffffffU
 
typedef uint32_t VdpChromaType;
 
#define VDP_CHROMA_TYPE_420 ((VdpChromaType)0)
#define VDP_CHROMA_TYPE_422 ((VdpChromaType)1)
#define VDP_CHROMA_TYPE_444 ((VdpChromaType)2)
 
#define VDP_CHROMA_TYPE_420_FIELD ((VdpChromaType)3)
#define VDP_CHROMA_TYPE_422_FIELD ((VdpChromaType)4)
#define VDP_CHROMA_TYPE_444_FIELD ((VdpChromaType)5)
 
#define VDP_CHROMA_TYPE_420_FRAME ((VdpChromaType)6)
#define VDP_CHROMA_TYPE_422_FRAME ((VdpChromaType)7)
#define VDP_CHROMA_TYPE_444_FRAME ((VdpChromaType)8)
#define VDP_CHROMA_TYPE_420_16 ((VdpChromaType)9)
#define VDP_CHROMA_TYPE_422_16 ((VdpChromaType)10)
#define VDP_CHROMA_TYPE_444_16 ((VdpChromaType)11)
 
#define VDP_CHROMA_TYPE_420_FIELD_16 ((VdpChromaType)12)
#define VDP_CHROMA_TYPE_422_FIELD_16 ((VdpChromaType)13)
#define VDP_CHROMA_TYPE_444_FIELD_16 ((VdpChromaType)14)
 
#define VDP_CHROMA_TYPE_420_FRAME_16 ((VdpChromaType)15)
#define VDP_CHROMA_TYPE_422_FRAME_16 ((VdpChromaType)16)
#define VDP_CHROMA_TYPE_444_FRAME_16 ((VdpChromaType)17)
 
typedef uint32_t VdpYCbCrFormat;
 
#define VDP_YCBCR_FORMAT_NV12     ((VdpYCbCrFormat)0)
#define VDP_YCBCR_FORMAT_YV12     ((VdpYCbCrFormat)1)
#define VDP_YCBCR_FORMAT_UYVY     ((VdpYCbCrFormat)2)
#define VDP_YCBCR_FORMAT_YUYV     ((VdpYCbCrFormat)3)
#define VDP_YCBCR_FORMAT_Y8U8V8A8 ((VdpYCbCrFormat)4)
#define VDP_YCBCR_FORMAT_V8U8Y8A8 ((VdpYCbCrFormat)5)
#define VDP_YCBCR_FORMAT_Y_UV_444     ((VdpYCbCrFormat)6)
#define VDP_YCBCR_FORMAT_Y_U_V_444     ((VdpYCbCrFormat)7)
#define VDP_YCBCR_FORMAT_P010           ((VdpYCbCrFormat)8)
#define VDP_YCBCR_FORMAT_P016           ((VdpYCbCrFormat)9)
 #define VDP_YCBCR_FORMAT_Y_U_V_444_16     ((VdpYCbCrFormat)11)
 
typedef uint32_t VdpRGBAFormat;
 
#define VDP_RGBA_FORMAT_B8G8R8A8    ((VdpRGBAFormat)0)
#define VDP_RGBA_FORMAT_R8G8B8A8    ((VdpRGBAFormat)1)
#define VDP_RGBA_FORMAT_R10G10B10A2 ((VdpRGBAFormat)2)
#define VDP_RGBA_FORMAT_B10G10R10A2 ((VdpRGBAFormat)3)
#define VDP_RGBA_FORMAT_A8          ((VdpRGBAFormat)4)
 
typedef uint32_t VdpIndexedFormat;
 
#define VDP_INDEXED_FORMAT_A4I4 ((VdpIndexedFormat)0)
#define VDP_INDEXED_FORMAT_I4A4 ((VdpIndexedFormat)1)
#define VDP_INDEXED_FORMAT_A8I8 ((VdpIndexedFormat)2)
#define VDP_INDEXED_FORMAT_I8A8 ((VdpIndexedFormat)3)
 
typedef struct {
    uint32_t x;
    uint32_t y;
} VdpPoint;
 
typedef struct {
    uint32_t x0;
    uint32_t y0;
    uint32_t x1;
    uint32_t y1;
} VdpRect;
 
typedef struct {
    float red;
    float green;
    float blue;
    float alpha;
} VdpColor;
 
typedef enum {
    VDP_STATUS_OK = 0,
    VDP_STATUS_NO_IMPLEMENTATION,
    VDP_STATUS_DISPLAY_PREEMPTED,
    VDP_STATUS_INVALID_HANDLE,
    VDP_STATUS_INVALID_POINTER,
    VDP_STATUS_INVALID_CHROMA_TYPE,
    VDP_STATUS_INVALID_Y_CB_CR_FORMAT,
    VDP_STATUS_INVALID_RGBA_FORMAT,
    VDP_STATUS_INVALID_INDEXED_FORMAT,
    VDP_STATUS_INVALID_COLOR_STANDARD,
    VDP_STATUS_INVALID_COLOR_TABLE_FORMAT,
    VDP_STATUS_INVALID_BLEND_FACTOR,
    VDP_STATUS_INVALID_BLEND_EQUATION,
    VDP_STATUS_INVALID_FLAG,
    VDP_STATUS_INVALID_DECODER_PROFILE,
    VDP_STATUS_INVALID_VIDEO_MIXER_FEATURE,
    VDP_STATUS_INVALID_VIDEO_MIXER_PARAMETER,
    VDP_STATUS_INVALID_VIDEO_MIXER_ATTRIBUTE,
    VDP_STATUS_INVALID_VIDEO_MIXER_PICTURE_STRUCTURE,
    VDP_STATUS_INVALID_FUNC_ID,
    VDP_STATUS_INVALID_SIZE,
    VDP_STATUS_INVALID_VALUE,
    VDP_STATUS_INVALID_STRUCT_VERSION,
    VDP_STATUS_RESOURCES,
    VDP_STATUS_HANDLE_DEVICE_MISMATCH,
    VDP_STATUS_ERROR,
} VdpStatus;
 
typedef char const * VdpGetErrorString(
    VdpStatus status
);
 
#define VDPAU_INTERFACE_VERSION 1
 
#define VDPAU_VERSION 1
 
typedef VdpStatus VdpGetApiVersion(
    /* output parameters follow */
    uint32_t * api_version
);
 
typedef VdpStatus VdpGetInformationString(
    /* output parameters follow */
    char const * * information_string
);
 
typedef uint32_t VdpDevice;
 
typedef VdpStatus VdpDeviceDestroy(
    VdpDevice device
);
 
typedef float VdpCSCMatrix[3][4];
 
#define VDP_PROCAMP_VERSION 0
 
typedef struct {
    uint32_t struct_version;
    float brightness;
    float contrast;
    float saturation;
    float hue;
} VdpProcamp;
 
typedef uint32_t VdpColorStandard;
 
#define VDP_COLOR_STANDARD_ITUR_BT_601 ((VdpColorStandard)0)
#define VDP_COLOR_STANDARD_ITUR_BT_709 ((VdpColorStandard)1)
#define VDP_COLOR_STANDARD_SMPTE_240M  ((VdpColorStandard)2)
 
typedef VdpStatus VdpGenerateCSCMatrix(
    VdpProcamp *     procamp,
    VdpColorStandard standard,
    /* output parameters follow */
    VdpCSCMatrix *   csc_matrix
);
 
typedef VdpStatus VdpVideoSurfaceQueryCapabilities(
    VdpDevice     device,
    VdpChromaType surface_chroma_type,
    /* output parameters follow */
    VdpBool *     is_supported,
    uint32_t *    max_width,
    uint32_t *    max_height
);
 
typedef VdpStatus VdpVideoSurfaceQueryGetPutBitsYCbCrCapabilities(
    VdpDevice      device,
    VdpChromaType  surface_chroma_type,
    VdpYCbCrFormat bits_ycbcr_format,
    /* output parameters follow */
    VdpBool *      is_supported
);
 
typedef uint32_t VdpVideoSurface;
 
typedef VdpStatus VdpVideoSurfaceCreate(
    VdpDevice         device,
    VdpChromaType     chroma_type,
    uint32_t          width,
    uint32_t          height,
    /* output parameters follow */
    VdpVideoSurface * surface
);
 
typedef VdpStatus VdpVideoSurfaceDestroy(
    VdpVideoSurface surface
);
 
typedef VdpStatus VdpVideoSurfaceGetParameters(
    VdpVideoSurface surface,
    /* output parameters follow */
    VdpChromaType * chroma_type,
    uint32_t *      width,
    uint32_t *      height
);
 
typedef VdpStatus VdpVideoSurfaceGetBitsYCbCr(
    VdpVideoSurface  surface,
    VdpYCbCrFormat   destination_ycbcr_format,
    void * const *   destination_data,
    uint32_t const * destination_pitches
);
 
typedef VdpStatus VdpVideoSurfacePutBitsYCbCr(
    VdpVideoSurface      surface,
    VdpYCbCrFormat       source_ycbcr_format,
    void const * const * source_data,
    uint32_t const *     source_pitches
);
 
typedef uint32_t VdpColorTableFormat;
 
#define VDP_COLOR_TABLE_FORMAT_B8G8R8X8 ((VdpColorTableFormat)0)
 
typedef VdpStatus VdpOutputSurfaceQueryCapabilities(
    VdpDevice     device,
    VdpRGBAFormat surface_rgba_format,
    /* output parameters follow */
    VdpBool *     is_supported,
    uint32_t *    max_width,
    uint32_t *    max_height
);
 
typedef VdpStatus VdpOutputSurfaceQueryGetPutBitsNativeCapabilities(
    VdpDevice     device,
    VdpRGBAFormat surface_rgba_format,
    /* output parameters follow */
    VdpBool *     is_supported
);
 
typedef VdpStatus VdpOutputSurfaceQueryPutBitsIndexedCapabilities(
    VdpDevice           device,
    VdpRGBAFormat       surface_rgba_format,
    VdpIndexedFormat    bits_indexed_format,
    VdpColorTableFormat color_table_format,
    /* output parameters follow */
    VdpBool *           is_supported
);
 
typedef VdpStatus VdpOutputSurfaceQueryPutBitsYCbCrCapabilities(
    VdpDevice      device,
    VdpRGBAFormat  surface_rgba_format,
    VdpYCbCrFormat bits_ycbcr_format,
    /* output parameters follow */
    VdpBool *      is_supported
);
 
typedef uint32_t VdpOutputSurface;
 
typedef VdpStatus VdpOutputSurfaceCreate(
    VdpDevice          device,
    VdpRGBAFormat      rgba_format,
    uint32_t           width,
    uint32_t           height,
    /* output parameters follow */
    VdpOutputSurface * surface
);
 
typedef VdpStatus VdpOutputSurfaceDestroy(
    VdpOutputSurface surface
);
 
typedef VdpStatus VdpOutputSurfaceGetParameters(
    VdpOutputSurface surface,
    /* output parameters follow */
    VdpRGBAFormat *  rgba_format,
    uint32_t *       width,
    uint32_t *       height
);
 
typedef VdpStatus VdpOutputSurfaceGetBitsNative(
    VdpOutputSurface surface,
    VdpRect const *  source_rect,
    void * const *   destination_data,
    uint32_t const * destination_pitches
);
 
typedef VdpStatus VdpOutputSurfacePutBitsNative(
    VdpOutputSurface     surface,
    void const * const * source_data,
    uint32_t const *     source_pitches,
    VdpRect const *      destination_rect
);
 
typedef VdpStatus VdpOutputSurfacePutBitsIndexed(
    VdpOutputSurface     surface,
    VdpIndexedFormat     source_indexed_format,
    void const * const * source_data,
    uint32_t const *     source_pitch,
    VdpRect const *      destination_rect,
    VdpColorTableFormat  color_table_format,
    void const *         color_table
);
 
typedef VdpStatus VdpOutputSurfacePutBitsYCbCr(
    VdpOutputSurface     surface,
    VdpYCbCrFormat       source_ycbcr_format,
    void const * const * source_data,
    uint32_t const *     source_pitches,
    VdpRect const *      destination_rect,
    VdpCSCMatrix const * csc_matrix
);
 
typedef VdpStatus VdpBitmapSurfaceQueryCapabilities(
    VdpDevice     device,
    VdpRGBAFormat surface_rgba_format,
    /* output parameters follow */
    VdpBool *     is_supported,
    uint32_t *    max_width,
    uint32_t *    max_height
);
 
typedef uint32_t VdpBitmapSurface;
 
typedef VdpStatus VdpBitmapSurfaceCreate(
    VdpDevice          device,
    VdpRGBAFormat      rgba_format,
    uint32_t           width,
    uint32_t           height,
    VdpBool            frequently_accessed,
    /* output parameters follow */
    VdpBitmapSurface * surface
);
 
typedef VdpStatus VdpBitmapSurfaceDestroy(
    VdpBitmapSurface surface
);
 
typedef VdpStatus VdpBitmapSurfaceGetParameters(
    VdpBitmapSurface surface,
    /* output parameters follow */
    VdpRGBAFormat *  rgba_format,
    uint32_t *       width,
    uint32_t *       height,
    VdpBool *        frequently_accessed
);
 
typedef VdpStatus VdpBitmapSurfacePutBitsNative(
    VdpBitmapSurface     surface,
    void const * const * source_data,
    uint32_t const *     source_pitches,
    VdpRect const *      destination_rect
);
 
typedef enum {
    VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ZERO                     = 0,
    VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE                      = 1,
    VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_SRC_COLOR                = 2,
    VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_SRC_COLOR      = 3,
    VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_SRC_ALPHA                = 4,
    VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA      = 5,
    VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_DST_ALPHA                = 6,
    VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_DST_ALPHA      = 7,
    VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_DST_COLOR                = 8,
    VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_DST_COLOR      = 9,
    VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_SRC_ALPHA_SATURATE       = 10,
    VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_CONSTANT_COLOR           = 11,
    VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 12,
    VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_CONSTANT_ALPHA           = 13,
    VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 14,
} VdpOutputSurfaceRenderBlendFactor;
 
typedef enum {
    VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_SUBTRACT         = 0,
    VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_REVERSE_SUBTRACT = 1,
    VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_ADD              = 2,
    VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_MIN              = 3,
    VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_MAX              = 4,
} VdpOutputSurfaceRenderBlendEquation;
 
#define VDP_OUTPUT_SURFACE_RENDER_BLEND_STATE_VERSION 0
 
typedef struct {
    uint32_t struct_version;
    VdpOutputSurfaceRenderBlendFactor   blend_factor_source_color;
    VdpOutputSurfaceRenderBlendFactor   blend_factor_destination_color;
    VdpOutputSurfaceRenderBlendFactor   blend_factor_source_alpha;
    VdpOutputSurfaceRenderBlendFactor   blend_factor_destination_alpha;
    VdpOutputSurfaceRenderBlendEquation blend_equation_color;
    VdpOutputSurfaceRenderBlendEquation blend_equation_alpha;
    VdpColor                            blend_constant;
} VdpOutputSurfaceRenderBlendState;
 
#define VDP_OUTPUT_SURFACE_RENDER_ROTATE_0   0
 
#define VDP_OUTPUT_SURFACE_RENDER_ROTATE_90  1
 
#define VDP_OUTPUT_SURFACE_RENDER_ROTATE_180 2
 
#define VDP_OUTPUT_SURFACE_RENDER_ROTATE_270 3
 
#define VDP_OUTPUT_SURFACE_RENDER_COLOR_PER_VERTEX (1 << 2)
 
typedef VdpStatus VdpOutputSurfaceRenderOutputSurface(
    VdpOutputSurface                         destination_surface,
    VdpRect const *                          destination_rect,
    VdpOutputSurface                         source_surface,
    VdpRect const *                          source_rect,
    VdpColor const *                         colors,
    VdpOutputSurfaceRenderBlendState const * blend_state,
    uint32_t                                 flags
);
 
typedef VdpStatus VdpOutputSurfaceRenderBitmapSurface(
    VdpOutputSurface                         destination_surface,
    VdpRect const *                          destination_rect,
    VdpBitmapSurface                         source_surface,
    VdpRect const *                          source_rect,
    VdpColor const *                         colors,
    VdpOutputSurfaceRenderBlendState const * blend_state,
    uint32_t                                 flags
);
 
typedef uint32_t VdpDecoderProfile;
 
#define VDP_DECODER_PROFILE_MPEG1                       ((VdpDecoderProfile)0)
#define VDP_DECODER_PROFILE_MPEG2_SIMPLE                ((VdpDecoderProfile)1)
#define VDP_DECODER_PROFILE_MPEG2_MAIN                  ((VdpDecoderProfile)2)
#define VDP_DECODER_PROFILE_H264_BASELINE               ((VdpDecoderProfile)6)
#define VDP_DECODER_PROFILE_H264_MAIN                   ((VdpDecoderProfile)7)
#define VDP_DECODER_PROFILE_H264_HIGH                   ((VdpDecoderProfile)8)
#define VDP_DECODER_PROFILE_VC1_SIMPLE                  ((VdpDecoderProfile)9)
#define VDP_DECODER_PROFILE_VC1_MAIN                    ((VdpDecoderProfile)10)
#define VDP_DECODER_PROFILE_VC1_ADVANCED                ((VdpDecoderProfile)11)
#define VDP_DECODER_PROFILE_MPEG4_PART2_SP              ((VdpDecoderProfile)12)
#define VDP_DECODER_PROFILE_MPEG4_PART2_ASP             ((VdpDecoderProfile)13)
#define VDP_DECODER_PROFILE_DIVX4_QMOBILE               ((VdpDecoderProfile)14)
#define VDP_DECODER_PROFILE_DIVX4_MOBILE                ((VdpDecoderProfile)15)
#define VDP_DECODER_PROFILE_DIVX4_HOME_THEATER          ((VdpDecoderProfile)16)
#define VDP_DECODER_PROFILE_DIVX4_HD_1080P              ((VdpDecoderProfile)17)
#define VDP_DECODER_PROFILE_DIVX5_QMOBILE               ((VdpDecoderProfile)18)
#define VDP_DECODER_PROFILE_DIVX5_MOBILE                ((VdpDecoderProfile)19)
#define VDP_DECODER_PROFILE_DIVX5_HOME_THEATER          ((VdpDecoderProfile)20)
#define VDP_DECODER_PROFILE_DIVX5_HD_1080P              ((VdpDecoderProfile)21)
#define VDP_DECODER_PROFILE_H264_CONSTRAINED_BASELINE   ((VdpDecoderProfile)22)
#define VDP_DECODER_PROFILE_H264_EXTENDED               ((VdpDecoderProfile)23)
#define VDP_DECODER_PROFILE_H264_PROGRESSIVE_HIGH       ((VdpDecoderProfile)24)
#define VDP_DECODER_PROFILE_H264_CONSTRAINED_HIGH       ((VdpDecoderProfile)25)
#define VDP_DECODER_PROFILE_H264_HIGH_444_PREDICTIVE    ((VdpDecoderProfile)26)
#define VDP_DECODER_PROFILE_VP9_PROFILE_0               ((VdpDecoderProfile)27)
#define VDP_DECODER_PROFILE_VP9_PROFILE_1               ((VdpDecoderProfile)28)
#define VDP_DECODER_PROFILE_VP9_PROFILE_2               ((VdpDecoderProfile)29)
#define VDP_DECODER_PROFILE_VP9_PROFILE_3               ((VdpDecoderProfile)30)
#define VDP_DECODER_PROFILE_HEVC_MAIN                   ((VdpDecoderProfile)100)
#define VDP_DECODER_PROFILE_HEVC_MAIN_10                ((VdpDecoderProfile)101)
#define VDP_DECODER_PROFILE_HEVC_MAIN_STILL             ((VdpDecoderProfile)102)
#define VDP_DECODER_PROFILE_HEVC_MAIN_12                ((VdpDecoderProfile)103)
#define VDP_DECODER_PROFILE_HEVC_MAIN_444               ((VdpDecoderProfile)104)
#define VDP_DECODER_PROFILE_HEVC_MAIN_444_10            ((VdpDecoderProfile)105)
#define VDP_DECODER_PROFILE_HEVC_MAIN_444_12            ((VdpDecoderProfile)106)
#define VDP_DECODER_PROFILE_AV1_MAIN                    ((VdpDecoderProfile)107)
#define VDP_DECODER_PROFILE_AV1_HIGH                    ((VdpDecoderProfile)108)
#define VDP_DECODER_PROFILE_AV1_PROFESSIONAL            ((VdpDecoderProfile)109)
 
#define VDP_DECODER_LEVEL_MPEG1_NA 0
 
#define VDP_DECODER_LEVEL_MPEG2_LL   0
#define VDP_DECODER_LEVEL_MPEG2_ML   1
#define VDP_DECODER_LEVEL_MPEG2_HL14 2
#define VDP_DECODER_LEVEL_MPEG2_HL   3
 
#define VDP_DECODER_LEVEL_H264_1     10
#define VDP_DECODER_LEVEL_H264_1b    9
#define VDP_DECODER_LEVEL_H264_1_1   11
#define VDP_DECODER_LEVEL_H264_1_2   12
#define VDP_DECODER_LEVEL_H264_1_3   13
#define VDP_DECODER_LEVEL_H264_2     20
#define VDP_DECODER_LEVEL_H264_2_1   21
#define VDP_DECODER_LEVEL_H264_2_2   22
#define VDP_DECODER_LEVEL_H264_3     30
#define VDP_DECODER_LEVEL_H264_3_1   31
#define VDP_DECODER_LEVEL_H264_3_2   32
#define VDP_DECODER_LEVEL_H264_4     40
#define VDP_DECODER_LEVEL_H264_4_1   41
#define VDP_DECODER_LEVEL_H264_4_2   42
#define VDP_DECODER_LEVEL_H264_5     50
#define VDP_DECODER_LEVEL_H264_5_1   51
 
#define VDP_DECODER_LEVEL_VC1_SIMPLE_LOW    0
#define VDP_DECODER_LEVEL_VC1_SIMPLE_MEDIUM 1
 
#define VDP_DECODER_LEVEL_VC1_MAIN_LOW    0
#define VDP_DECODER_LEVEL_VC1_MAIN_MEDIUM 1
#define VDP_DECODER_LEVEL_VC1_MAIN_HIGH   2
 
#define VDP_DECODER_LEVEL_VC1_ADVANCED_L0 0
#define VDP_DECODER_LEVEL_VC1_ADVANCED_L1 1
#define VDP_DECODER_LEVEL_VC1_ADVANCED_L2 2
#define VDP_DECODER_LEVEL_VC1_ADVANCED_L3 3
#define VDP_DECODER_LEVEL_VC1_ADVANCED_L4 4
 
#define VDP_DECODER_LEVEL_MPEG4_PART2_SP_L0 0
#define VDP_DECODER_LEVEL_MPEG4_PART2_SP_L1 1
#define VDP_DECODER_LEVEL_MPEG4_PART2_SP_L2 2
#define VDP_DECODER_LEVEL_MPEG4_PART2_SP_L3 3
 
#define VDP_DECODER_LEVEL_MPEG4_PART2_ASP_L0 0
#define VDP_DECODER_LEVEL_MPEG4_PART2_ASP_L1 1
#define VDP_DECODER_LEVEL_MPEG4_PART2_ASP_L2 2
#define VDP_DECODER_LEVEL_MPEG4_PART2_ASP_L3 3
#define VDP_DECODER_LEVEL_MPEG4_PART2_ASP_L4 4
#define VDP_DECODER_LEVEL_MPEG4_PART2_ASP_L5 5
 
#define VDP_DECODER_LEVEL_DIVX_NA 0
 
#define VDP_DECODER_LEVEL_VP9_L1 1
 
#define VDP_DECODER_LEVEL_AV1_2_0 0
#define VDP_DECODER_LEVEL_AV1_2_1 1
#define VDP_DECODER_LEVEL_AV1_2_2 2
#define VDP_DECODER_LEVEL_AV1_2_3 3
#define VDP_DECODER_LEVEL_AV1_3_0 4
#define VDP_DECODER_LEVEL_AV1_3_1 5
#define VDP_DECODER_LEVEL_AV1_3_2 6
#define VDP_DECODER_LEVEL_AV1_3_3 7
#define VDP_DECODER_LEVEL_AV1_4_0 8
#define VDP_DECODER_LEVEL_AV1_4_1 9
#define VDP_DECODER_LEVEL_AV1_4_2 10
#define VDP_DECODER_LEVEL_AV1_4_3 11
#define VDP_DECODER_LEVEL_AV1_5_0 12
#define VDP_DECODER_LEVEL_AV1_5_1 13
#define VDP_DECODER_LEVEL_AV1_5_2 14
#define VDP_DECODER_LEVEL_AV1_5_3 15
#define VDP_DECODER_LEVEL_AV1_6_0 16
#define VDP_DECODER_LEVEL_AV1_6_1 17
#define VDP_DECODER_LEVEL_AV1_6_2 18
#define VDP_DECODER_LEVEL_AV1_6_3 19
#define VDP_DECODER_LEVEL_AV1_7_0 20
#define VDP_DECODER_LEVEL_AV1_7_1 21
#define VDP_DECODER_LEVEL_AV1_7_2 22
#define VDP_DECODER_LEVEL_AV1_7_3 23
 
#define VDP_DECODER_LEVEL_HEVC_1         30
#define VDP_DECODER_LEVEL_HEVC_2         60
#define VDP_DECODER_LEVEL_HEVC_2_1       63
#define VDP_DECODER_LEVEL_HEVC_3         90
#define VDP_DECODER_LEVEL_HEVC_3_1       93
#define VDP_DECODER_LEVEL_HEVC_4        120
#define VDP_DECODER_LEVEL_HEVC_4_1      123
#define VDP_DECODER_LEVEL_HEVC_5        150
#define VDP_DECODER_LEVEL_HEVC_5_1      153
#define VDP_DECODER_LEVEL_HEVC_5_2      156
#define VDP_DECODER_LEVEL_HEVC_6        180
#define VDP_DECODER_LEVEL_HEVC_6_1      183
#define VDP_DECODER_LEVEL_HEVC_6_2      186
 
typedef enum {
    VDP_VIDEO_SURFACE_FIELD_STRUCTURE         = (1 << 0),
    VDP_VIDEO_SURFACE_FRAME_STRUCTURE         = (1 << 1)
} VdpVideoSurfaceSupportedPictureStructure;
 
typedef enum {
    VDP_DECODER_PROFILE_MAX_LEVEL                      = 0,
    VDP_DECODER_PROFILE_MAX_MACROBLOCKS                = 1,
    VDP_DECODER_PROFILE_MAX_WIDTH                      = 2,
    VDP_DECODER_PROFILE_MAX_HEIGHT                     = 3,
    VDP_DECODER_PROFILE_SUPPORTED_PICTURE_STRUCTURE    = 4,
    VDP_DECODER_PROFILE_SUPPORTED_CHROMA_TYPES         = 5
} VdpDecoderCapability;
 
typedef VdpStatus VdpDecoderQueryProfileCapability(
    VdpDevice                   device,
    VdpDecoderProfile           profile,
    /* output parameters follow */
    VdpDecoderCapability        capability,
    void *                      capability_value
);
 
typedef VdpStatus VdpDecoderQueryCapabilities(
    VdpDevice         device,
    VdpDecoderProfile profile,
    /* output parameters follow */
    VdpBool *         is_supported,
    uint32_t *        max_level,
    uint32_t *        max_macroblocks,
    uint32_t *        max_width,
    uint32_t *        max_height
);
 
typedef uint32_t VdpDecoder;
 
typedef VdpStatus VdpDecoderCreate(
    VdpDevice         device,
    VdpDecoderProfile profile,
    uint32_t          width,
    uint32_t          height,
    uint32_t          max_references,
    /* output parameters follow */
    VdpDecoder *      decoder
);
 
typedef VdpStatus VdpDecoderDestroy(
    VdpDecoder decoder
);
 
typedef VdpStatus VdpDecoderGetParameters(
    VdpDecoder          decoder,
    /* output parameters follow */
    VdpDecoderProfile * profile,
    uint32_t *          width,
    uint32_t *          height
);
 
#define VDP_BITSTREAM_BUFFER_VERSION 0
 
typedef struct {
    uint32_t     struct_version;
    void const * bitstream;
    uint32_t     bitstream_bytes;
} VdpBitstreamBuffer;
 
typedef void VdpPictureInfo;
 
typedef struct {
    VdpVideoSurface forward_reference;
    VdpVideoSurface backward_reference;
    uint32_t        slice_count;
 
    uint8_t picture_structure;
    uint8_t picture_coding_type;
    uint8_t intra_dc_precision;
    uint8_t frame_pred_frame_dct;
    uint8_t concealment_motion_vectors;
    uint8_t intra_vlc_format;
    uint8_t alternate_scan;
    uint8_t q_scale_type;
    uint8_t top_field_first;
    uint8_t full_pel_forward_vector;
    uint8_t full_pel_backward_vector;
    uint8_t f_code[2][2];
    uint8_t intra_quantizer_matrix[64];
    uint8_t non_intra_quantizer_matrix[64];
} VdpPictureInfoMPEG1Or2;
 
typedef struct {
    VdpVideoSurface surface;
    VdpBool         is_long_term;
    VdpBool         top_is_reference;
    VdpBool         bottom_is_reference;
    int32_t         field_order_cnt[2];
    uint16_t        frame_idx;
} VdpReferenceFrameH264;
 
typedef struct {
    uint32_t slice_count;
    int32_t  field_order_cnt[2];
    VdpBool  is_reference;
 
    uint16_t frame_num;
    uint8_t  field_pic_flag;
    uint8_t  bottom_field_flag;
    uint8_t  num_ref_frames;
    uint8_t  mb_adaptive_frame_field_flag;
    uint8_t  constrained_intra_pred_flag;
    uint8_t  weighted_pred_flag;
    uint8_t  weighted_bipred_idc;
    uint8_t  frame_mbs_only_flag;
    uint8_t  transform_8x8_mode_flag;
    int8_t   chroma_qp_index_offset;
    int8_t   second_chroma_qp_index_offset;
    int8_t   pic_init_qp_minus26;
    uint8_t  num_ref_idx_l0_active_minus1;
    uint8_t  num_ref_idx_l1_active_minus1;
    uint8_t  log2_max_frame_num_minus4;
    uint8_t  pic_order_cnt_type;
    uint8_t  log2_max_pic_order_cnt_lsb_minus4;
    uint8_t  delta_pic_order_always_zero_flag;
    uint8_t  direct_8x8_inference_flag;
    uint8_t  entropy_coding_mode_flag;
    uint8_t  pic_order_present_flag;
    uint8_t  deblocking_filter_control_present_flag;
    uint8_t  redundant_pic_cnt_present_flag;
    uint8_t scaling_lists_4x4[6][16];
    uint8_t scaling_lists_8x8[2][64];
    VdpReferenceFrameH264 referenceFrames[16];
} VdpPictureInfoH264;
 
typedef struct {
    VdpPictureInfoH264 pictureInfo;
 
    uint8_t qpprime_y_zero_transform_bypass_flag;
    uint8_t separate_colour_plane_flag;
} VdpPictureInfoH264Predictive;
 
typedef struct {
    VdpVideoSurface forward_reference;
    VdpVideoSurface backward_reference;
 
    uint32_t slice_count;
    uint8_t  picture_type;
    uint8_t  frame_coding_mode;
 
    uint8_t postprocflag;
    uint8_t pulldown;
    uint8_t interlace;
    uint8_t tfcntrflag;
    uint8_t finterpflag;
    uint8_t psf;
    uint8_t dquant;
    uint8_t panscan_flag;
    uint8_t refdist_flag;
    uint8_t quantizer;
    uint8_t extended_mv;
    uint8_t extended_dmv;
    uint8_t overlap;
    uint8_t vstransform;
    uint8_t loopfilter;
    uint8_t fastuvmc;
    uint8_t range_mapy_flag;
    uint8_t range_mapy;
    uint8_t range_mapuv_flag;
    uint8_t range_mapuv;
 
    uint8_t multires;
    uint8_t syncmarker;
    uint8_t rangered;
    uint8_t maxbframes;
    uint8_t deblockEnable;
    uint8_t pquant;
} VdpPictureInfoVC1;
 
typedef struct {
    VdpVideoSurface forward_reference;
    VdpVideoSurface backward_reference;
 
    int32_t trd[2];
    int32_t trb[2];
    uint16_t vop_time_increment_resolution;
    uint8_t vop_coding_type;
    uint8_t vop_fcode_forward;
    uint8_t vop_fcode_backward;
    uint8_t resync_marker_disable;
    uint8_t interlaced;
    uint8_t quant_type;
    uint8_t quarter_sample;
    uint8_t short_video_header;
    uint8_t rounding_control;
    uint8_t alternate_vertical_scan_flag;
    uint8_t top_field_first;
    uint8_t intra_quantizer_matrix[64];
    uint8_t non_intra_quantizer_matrix[64];
} VdpPictureInfoMPEG4Part2;
 
typedef VdpPictureInfoMPEG4Part2 VdpPictureInfoDivX4;
 
typedef VdpPictureInfoMPEG4Part2 VdpPictureInfoDivX5;
 
typedef struct
{
    unsigned int width;
    unsigned int height;
 
    //Frame Indices
    VdpVideoSurface lastReference;
    VdpVideoSurface goldenReference;
    VdpVideoSurface altReference;
 
    unsigned char colorSpace;
 
    unsigned short profile;
    unsigned short frameContextIdx;
    unsigned short keyFrame;
    unsigned short showFrame;
    unsigned short errorResilient;
    unsigned short frameParallelDecoding;
    unsigned short subSamplingX;
    unsigned short subSamplingY;
    unsigned short intraOnly;
    unsigned short allowHighPrecisionMv;
    unsigned short refreshEntropyProbs;
 
    unsigned char  refFrameSignBias[4];
 
    unsigned char bitDepthMinus8Luma;
    unsigned char bitDepthMinus8Chroma;
    unsigned char loopFilterLevel;
    unsigned char loopFilterSharpness;
 
    unsigned char modeRefLfEnabled;
    unsigned char log2TileColumns;
    unsigned char log2TileRows;
 
    unsigned char segmentEnabled;
    unsigned char segmentMapUpdate;
    unsigned char segmentMapTemporalUpdate;
    unsigned char segmentFeatureMode;
 
    unsigned char segmentFeatureEnable[8][4];
    short         segmentFeatureData[8][4];
    unsigned char mbSegmentTreeProbs[7];
    unsigned char segmentPredProbs[3];
    unsigned char reservedSegment16Bits[2];
 
    int qpYAc;
    int qpYDc;
    int qpChDc;
    int qpChAc;
 
    unsigned int activeRefIdx[3];
    unsigned int resetFrameContext;
    unsigned int mcompFilterType;
    unsigned int mbRefLfDelta[4];
    unsigned int mbModeLfDelta[2];
    unsigned int uncompressedHeaderSize;
    unsigned int compressedHeaderSize;
} VdpPictureInfoVP9;
 
typedef struct {
    uint8_t chroma_format_idc;
    uint8_t separate_colour_plane_flag;
    uint32_t pic_width_in_luma_samples;
    uint32_t pic_height_in_luma_samples;
    uint8_t bit_depth_luma_minus8;
    uint8_t bit_depth_chroma_minus8;
    uint8_t log2_max_pic_order_cnt_lsb_minus4;
    uint8_t sps_max_dec_pic_buffering_minus1;
    uint8_t log2_min_luma_coding_block_size_minus3;
    uint8_t log2_diff_max_min_luma_coding_block_size;
    uint8_t log2_min_transform_block_size_minus2;
    uint8_t log2_diff_max_min_transform_block_size;
    uint8_t max_transform_hierarchy_depth_inter;
    uint8_t max_transform_hierarchy_depth_intra;
    uint8_t scaling_list_enabled_flag;
    uint8_t ScalingList4x4[6][16];
    uint8_t ScalingList8x8[6][64];
    uint8_t ScalingList16x16[6][64];
    uint8_t ScalingList32x32[2][64];
    uint8_t ScalingListDCCoeff16x16[6];
    uint8_t ScalingListDCCoeff32x32[2];
    uint8_t amp_enabled_flag;
    uint8_t sample_adaptive_offset_enabled_flag;
    uint8_t pcm_enabled_flag;
    uint8_t pcm_sample_bit_depth_luma_minus1;
    uint8_t pcm_sample_bit_depth_chroma_minus1;
    uint8_t log2_min_pcm_luma_coding_block_size_minus3;
    uint8_t log2_diff_max_min_pcm_luma_coding_block_size;
    uint8_t pcm_loop_filter_disabled_flag;
    uint8_t num_short_term_ref_pic_sets;
    uint8_t long_term_ref_pics_present_flag;
    uint8_t num_long_term_ref_pics_sps;
    uint8_t sps_temporal_mvp_enabled_flag;
    uint8_t strong_intra_smoothing_enabled_flag;
    uint8_t dependent_slice_segments_enabled_flag;
    uint8_t output_flag_present_flag;
    uint8_t num_extra_slice_header_bits;
    uint8_t sign_data_hiding_enabled_flag;
    uint8_t cabac_init_present_flag;
    uint8_t num_ref_idx_l0_default_active_minus1;
    uint8_t num_ref_idx_l1_default_active_minus1;
    int8_t init_qp_minus26;
    uint8_t constrained_intra_pred_flag;
    uint8_t transform_skip_enabled_flag;
    uint8_t cu_qp_delta_enabled_flag;
    uint8_t diff_cu_qp_delta_depth;
    int8_t pps_cb_qp_offset;
    int8_t pps_cr_qp_offset;
    uint8_t pps_slice_chroma_qp_offsets_present_flag;
    uint8_t weighted_pred_flag;
    uint8_t weighted_bipred_flag;
    uint8_t transquant_bypass_enabled_flag;
    uint8_t tiles_enabled_flag;
    uint8_t entropy_coding_sync_enabled_flag;
    uint8_t num_tile_columns_minus1;
    uint8_t num_tile_rows_minus1;
    uint8_t uniform_spacing_flag;
    uint16_t column_width_minus1[20];
    uint16_t row_height_minus1[22];
    uint8_t loop_filter_across_tiles_enabled_flag;
    uint8_t pps_loop_filter_across_slices_enabled_flag;
    uint8_t deblocking_filter_control_present_flag;
    uint8_t deblocking_filter_override_enabled_flag;
    uint8_t pps_deblocking_filter_disabled_flag;
    int8_t pps_beta_offset_div2;
    int8_t pps_tc_offset_div2;
    uint8_t lists_modification_present_flag;
    uint8_t log2_parallel_merge_level_minus2;
    uint8_t slice_segment_header_extension_present_flag;
    uint8_t IDRPicFlag;
    uint8_t RAPPicFlag;
    uint8_t CurrRpsIdx;
    uint32_t NumPocTotalCurr;
    uint32_t NumDeltaPocsOfRefRpsIdx;
    uint32_t NumShortTermPictureSliceHeaderBits;
    uint32_t NumLongTermPictureSliceHeaderBits;
    int32_t CurrPicOrderCntVal;
 
    VdpVideoSurface RefPics[16];
    int32_t PicOrderCntVal[16];
    uint8_t IsLongTerm[16];
    uint8_t NumPocStCurrBefore;
    uint8_t NumPocStCurrAfter;
    uint8_t NumPocLtCurr;
    uint8_t RefPicSetStCurrBefore[8];
    uint8_t RefPicSetStCurrAfter[8];
    uint8_t RefPicSetLtCurr[8];
} VdpPictureInfoHEVC;
 
typedef struct {
    VdpPictureInfoHEVC pictureInfo;
 
    /* SPS Range Extensions for Main 444, Main 10, etc. */
    uint8_t sps_range_extension_flag;
    /* sps extension for transform_skip_rotation_enabled_flag */
    uint8_t transformSkipRotationEnableFlag;
    /* sps extension for transform_skip_context_enabled_flag */
    uint8_t transformSkipContextEnableFlag;
    /* sps implicit_rdpcm_enabled_flag */
    uint8_t implicitRdpcmEnableFlag;
    /* sps explicit_rdpcm_enabled_flag */
    uint8_t explicitRdpcmEnableFlag;
    /* sps extended_precision_processing_flag,always 0 in current profile */
    uint8_t extendedPrecisionProcessingFlag;
    /* sps intra_smoothing_disabled_flag */
    uint8_t intraSmoothingDisabledFlag;
    /* sps high_precision_offsets_enabled_flag */
    uint8_t highPrecisionOffsetsEnableFlag;
    /* sps persistent_rice_adaptation_enabled_flag */
    uint8_t persistentRiceAdaptationEnableFlag;
    /* sps cabac_bypass_alignment_enabled_flag, always 0 in current profile */
    uint8_t cabacBypassAlignmentEnableFlag;
    /* sps intraBlockCopyEnableFlag, always 0 not used by the spec as of now */
    uint8_t intraBlockCopyEnableFlag;
 
    /* PPS Range Extensions for Main 444, Main 10, etc. */
    uint8_t pps_range_extension_flag;
    /* pps extension log2_max_transform_skip_block_size_minus2, 0...5 */
    uint8_t log2MaxTransformSkipSize;
    /* pps cross_component_prediction_enabled_flag */
    uint8_t crossComponentPredictionEnableFlag;
    /* pps chroma_qp_adjustment_enabled_flag */
    uint8_t chromaQpAdjustmentEnableFlag;
    /* pps diff_cu_chroma_qp_adjustment_depth, 0...3 */
    uint8_t diffCuChromaQpAdjustmentDepth;
    /* pps chroma_qp_adjustment_table_size_minus1+1, 1...6 */
    uint8_t chromaQpAdjustmentTableSize;
    /* pps log2_sao_offset_scale_luma, max(0,bitdepth-10), */
    /* maxBitdepth 16 for future. */
    uint8_t log2SaoOffsetScaleLuma;
    /* pps log2_sao_offset_scale_chroma */
    uint8_t log2SaoOffsetScaleChroma;
    /* -[12,+12] */
    int8_t cb_qp_adjustment[6];
    /* -[12,+12] */
    int8_t cr_qp_adjustment[6];
 
} VdpPictureInfoHEVC444;
 
 
typedef struct
{
     unsigned int width;
     unsigned int height;
 
     unsigned int   frame_offset;                        // defined as order_hint in AV1 specification
 
     // sequence header
     unsigned int   profile;                         // 0 = profile0, 1 = profile1, 2 = profile2
     unsigned int   use_128x128_superblock;          // superblock size 0:64x64, 1: 128x128
     unsigned int   subsampling_x;                   // (subsampling_x, _y) 1,1 = 420, 1,0 = 422, 0,0 = 444
     unsigned int   subsampling_y;
     unsigned int   mono_chrome;                     // for monochrome content, mono_chrome = 1 and (subsampling_x, _y) should be 1,1
     unsigned int   bit_depth_minus8;                // bit depth minus 8
     unsigned int   enable_filter_intra;             // tool enable in seq level, 0 : disable 1: frame header control
     unsigned int   enable_intra_edge_filter;        // intra edge filtering process, 0 : disable 1: enabled
     unsigned int   enable_interintra_compound;      // interintra, 0 : not present 1: present
     unsigned int   enable_masked_compound;          // 1: mode info for inter blocks may contain the syntax element compound_type.
                                                         // 0: syntax element compound_type will not be present
     unsigned int   enable_dual_filter;              // vertical and horiz filter selection, 1: enable and 0: disable
     unsigned int   enable_order_hint;               // order hint, and related tools, 1: enable and 0: disable
     unsigned int   order_hint_bits_minus1;          // is used to compute OrderHintBits
     unsigned int   enable_jnt_comp;                 // joint compound modes, 1: enable and 0: disable
     unsigned int   enable_superres;                 // superres in seq level, 0 : disable 1: frame level control
     unsigned int   enable_cdef;                     // cdef filtering in seq level, 0 : disable 1: frame level control
     unsigned int   enable_restoration;              // loop restoration filtering in seq level, 0 : disable 1: frame level control
     unsigned int   enable_fgs;                      // defined as film_grain_params_present in AV1 specification
 
     // frame header
     unsigned int   frame_type;                     // 0:Key frame, 1:Inter frame, 2:intra only, 3:s-frame
     unsigned int   show_frame;                     // show_frame = 1 implies that frame should be immediately output once decoded
     unsigned int   disable_cdf_update;              // CDF update during symbol decoding, 1: disabled, 0: enabled
     unsigned int   allow_screen_content_tools;      // 1: intra blocks may use palette encoding, 0: palette encoding is never used
     unsigned int   force_integer_mv;                // 1: motion vectors will always be integers, 0: can contain fractional bits
     unsigned int   coded_denom;                     // coded_denom of the superres scale as specified in AV1 specification
     unsigned int   allow_intrabc;                   // 1: intra block copy may be used, 0: intra block copy is not allowed
     unsigned int   allow_high_precision_mv;         // 1/8 precision mv enable
     unsigned int   interp_filter;                   // interpolation filter. Refer to section 6.8.9 of the AV1 specification Version 1.0.0 with Errata 1
     unsigned int   switchable_motion_mode ;          // defined as is_motion_mode_switchable in AV1 specification
     unsigned int   use_ref_frame_mvs ;               // 1: current frame can use the previous frame mv information, 0: will not use.
     unsigned int   disable_frame_end_update_cdf ;    // 1: indicates that the end of frame CDF update is disabled
     unsigned int   delta_q_present ;                 // quantizer index delta values are present in the block level
     unsigned int   delta_q_res;                     // left shift which should be applied to decoded quantizer index delta values
     unsigned int   using_qmatrix ;                   // 1: quantizer matrix will be used to compute quantizers
     unsigned int   coded_lossless ;                  // 1: all segments use lossless coding
     unsigned int   use_superres ;                    // 1: superres enabled for frame
     unsigned int   tx_mode;                         // 0: ONLY4x4,1:LARGEST,2:SELECT
     unsigned int   reference_mode ;                  // 0: SINGLE, 1: SELECT
     unsigned int   allow_warped_motion ;             // 1: allow_warped_motion may be present, 0: allow_warped_motion will not be present
     unsigned int   reduced_tx_set ;                  // 1: frame is restricted to subset of the full set of transform types, 0: no such restriction
     unsigned int   skip_mode ;                       // 1: most of the mode info is skipped, 0: mode info is not skipped
 
     // tiling info
     unsigned int   num_tile_cols;                   // number of tiles across the frame., max is 64
     unsigned int   num_tile_rows;                   // number of tiles down the frame., max is 64
     unsigned int   context_update_tile_id;          // specifies which tile to use for the CDF update
     unsigned short tile_widths[64];                 // Width of each column in superblocks
     unsigned short tile_heights[64];                // height of each row in superblocks
     unsigned int   tile_info[256 * 2];              //AV1_MAX_TILES = 256
 
     // CDEF - refer to section 6.10.14 of the AV1 specification Version 1.0.0 with Errata 1
     unsigned char  cdef_damping_minus_3;            // controls the amount of damping in the deringing filter
     unsigned char  cdef_bits;                       // the number of bits needed to specify which CDEF filter to apply
     unsigned char  cdef_y_strength[8];                  // 0-3 bits: y_pri_strength, 4-7 bits y_sec_strength
     unsigned char  cdef_uv_strength[8];                 // 0-3 bits: uv_pri_strength, 4-7 bits uv_sec_strength
 
     // SkipModeFrames
     unsigned char   SkipModeFrame0;                 // specifies the frames to use for compound prediction when skip_mode is equal to 1.
     unsigned char   SkipModeFrame1;
 
     // qp information - refer to section 6.8.11 of the AV1 specification Version 1.0.0 with Errata 1
     unsigned char  base_qindex;                         // indicates the base frame qindex. Defined as base_q_idx in AV1 specification
     char           qp_y_dc_delta_q;                     // indicates the Y DC quantizer relative to base_q_idx. Defined as DeltaQYDc in AV1 specification
     char           qp_u_dc_delta_q;                     // indicates the U DC quantizer relative to base_q_idx. Defined as DeltaQUDc in AV1 specification
     char           qp_v_dc_delta_q;                     // indicates the V DC quantizer relative to base_q_idx. Defined as DeltaQVDc in AV1 specification
     char           qp_u_ac_delta_q;                     // indicates the U AC quantizer relative to base_q_idx. Defined as DeltaQUAc in AV1 specification
     char           qp_v_ac_delta_q;                     // indicates the V AC quantizer relative to base_q_idx. Defined as DeltaQVAc in AV1 specification
     unsigned char  qm_y;                                // specifies the level in the quantizer matrix that should be used for luma plane decoding
     unsigned char  qm_u;                                // specifies the level in the quantizer matrix that should be used for chroma U plane decoding
     unsigned char  qm_v;                                // specifies the level in the quantizer matrix that should be used for chroma V plane decoding
 
     // segmentation - refer to section 6.8.13 of the AV1 specification Version 1.0.0 with Errata 1
     unsigned char segmentation_enabled ;             // 1 indicates that this frame makes use of the segmentation tool
     unsigned char segmentation_update_map ;          // 1 indicates that the segmentation map are updated during the decoding of this frame
     unsigned char segmentation_update_data ;         // 1 indicates that new parameters are about to be specified for each segment
     unsigned char segmentation_temporal_update ;     // 1 indicates that the updates to the segmentation map are coded relative to the existing segmentation map
     short         segmentation_feature_data[8][8];      // specifies the feature data for a segment feature
     unsigned char segmentation_feature_mask[8];         // indicates that the corresponding feature is unused or feature value is coded
 
     // loopfilter - refer to section 6.8.10 of the AV1 specification Version 1.0.0 with Errata 1
     unsigned char  loop_filter_level[2];                // contains loop filter strength values
     unsigned char  loop_filter_level_u;                 // loop filter strength value of U plane
     unsigned char  loop_filter_level_v;                 // loop filter strength value of V plane
     unsigned char  loop_filter_sharpness;               // indicates the sharpness level
     char           loop_filter_ref_deltas[8];           // contains the adjustment needed for the filter level based on the chosen reference frame
     char           loop_filter_mode_deltas[2];          // contains the adjustment needed for the filter level based on the chosen mode
     unsigned char  loop_filter_delta_enabled ;       // indicates that the filter level depends on the mode and reference frame used to predict a block
     unsigned char  loop_filter_delta_update ;        // indicates that additional syntax elements are present that specify which mode and
                                                         // reference frame deltas are to be updated
     unsigned char  delta_lf_present ;                // specifies whether loop filter delta values are present in the block level
     unsigned char  delta_lf_res;                    // specifies the left shift to apply to the decoded loop filter values
     unsigned char  delta_lf_multi  ;                 // separate loop filter deltas for Hy,Vy,U,V edges
     unsigned char  reserved4_2bits;                 // reserved bits; must be set to 0
 
     // restoration - refer to section 6.10.15 of the AV1 specification Version 1.0.0 with Errata 1
     unsigned char lr_unit_size[3];                     // specifies the size of loop restoration units: 0: 32, 1: 64, 2: 128, 3: 256
     unsigned char lr_type[3] ;                         // used to compute FrameRestorationType
 
     // reference frames
     unsigned int primary_ref_frame;                    // specifies which reference frame contains the CDF values and other state that should be
                                                         // loaded at the start of the frame
     unsigned int ref_frame_map[8];                     // frames in dpb that can be used as reference for current or future frames
 
     unsigned char temporal_layer_id;                // temporal layer id
     unsigned char spatial_layer_id;                 // spatial layer id
 
     // ref frame list
     struct
     {
         unsigned int   width;
         unsigned int   height;
         unsigned int  index;
     } ref_frame[7];                                     // frames used as reference frame for current frame.
 
     // global motion
     struct {
         unsigned char invalid ;
         unsigned char wmtype;                       // defined as GmType in AV1 specification
         int           wmmat[6];                         // defined as gm_params[] in AV1 specification
     } global_motion[7];                                 // global motion params for reference frames
 
     // film grain params - refer to section 6.8.20 of the AV1 specification Version 1.0.0 with Errata 1
     unsigned short apply_grain ;
     unsigned short overlap_flag ;
     unsigned short scaling_shift_minus8;
     unsigned short chroma_scaling_from_luma ;
     unsigned short ar_coeff_lag;
     unsigned short ar_coeff_shift_minus6;
     unsigned short grain_scale_shift;
     unsigned short clip_to_restricted_range ;
     unsigned char  num_y_points;
     unsigned char  scaling_points_y[14][2];
     unsigned char  num_cb_points;
     unsigned char  scaling_points_cb[10][2];
     unsigned char  num_cr_points;
     unsigned char  scaling_points_cr[10][2];
     unsigned short random_seed;
     short          ar_coeffs_y[24];
     short          ar_coeffs_cb[25];
     short          ar_coeffs_cr[25];
     unsigned char  cb_mult;
     unsigned char  cb_luma_mult;
     short          cb_offset;
     unsigned char  cr_mult;
     unsigned char  cr_luma_mult;
     short          cr_offset;
 
} VdpPictureInfoAV1;
 
 
typedef VdpPictureInfoHEVC444 VdpPictureInfoHEVCRangeExt;
 
typedef VdpStatus VdpDecoderRender(
    VdpDecoder                 decoder,
    VdpVideoSurface            target,
    VdpPictureInfo const *     picture_info,
    uint32_t                   bitstream_buffer_count,
    VdpBitstreamBuffer const * bitstream_buffers
);
 
typedef uint32_t VdpVideoMixerFeature;
 
#define VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL         ((VdpVideoMixerFeature)0)
#define VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL_SPATIAL ((VdpVideoMixerFeature)1)
#define VDP_VIDEO_MIXER_FEATURE_INVERSE_TELECINE             ((VdpVideoMixerFeature)2)
#define VDP_VIDEO_MIXER_FEATURE_NOISE_REDUCTION              ((VdpVideoMixerFeature)3)
#define VDP_VIDEO_MIXER_FEATURE_SHARPNESS                    ((VdpVideoMixerFeature)4)
#define VDP_VIDEO_MIXER_FEATURE_LUMA_KEY                     ((VdpVideoMixerFeature)5)
#define VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L1      ((VdpVideoMixerFeature)11)
#define VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L2      ((VdpVideoMixerFeature)12)
#define VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L3      ((VdpVideoMixerFeature)13)
#define VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L4      ((VdpVideoMixerFeature)14)
#define VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L5      ((VdpVideoMixerFeature)15)
#define VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L6      ((VdpVideoMixerFeature)16)
#define VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L7      ((VdpVideoMixerFeature)17)
#define VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L8      ((VdpVideoMixerFeature)18)
#define VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L9      ((VdpVideoMixerFeature)19)
 
typedef uint32_t VdpVideoMixerParameter;
 
#define VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_WIDTH  ((VdpVideoMixerParameter)0)
#define VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_HEIGHT ((VdpVideoMixerParameter)1)
#define VDP_VIDEO_MIXER_PARAMETER_CHROMA_TYPE          ((VdpVideoMixerParameter)2)
#define VDP_VIDEO_MIXER_PARAMETER_LAYERS               ((VdpVideoMixerParameter)3)
 
typedef uint32_t VdpVideoMixerAttribute;
 
#define VDP_VIDEO_MIXER_ATTRIBUTE_BACKGROUND_COLOR      ((VdpVideoMixerAttribute)0)
#define VDP_VIDEO_MIXER_ATTRIBUTE_CSC_MATRIX            ((VdpVideoMixerAttribute)1)
#define VDP_VIDEO_MIXER_ATTRIBUTE_NOISE_REDUCTION_LEVEL ((VdpVideoMixerAttribute)2)
#define VDP_VIDEO_MIXER_ATTRIBUTE_SHARPNESS_LEVEL       ((VdpVideoMixerAttribute)3)
#define VDP_VIDEO_MIXER_ATTRIBUTE_LUMA_KEY_MIN_LUMA     ((VdpVideoMixerAttribute)4)
#define VDP_VIDEO_MIXER_ATTRIBUTE_LUMA_KEY_MAX_LUMA     ((VdpVideoMixerAttribute)5)
#define VDP_VIDEO_MIXER_ATTRIBUTE_SKIP_CHROMA_DEINTERLACE ((VdpVideoMixerAttribute)6)
 
typedef VdpStatus VdpVideoMixerQueryFeatureSupport(
    VdpDevice            device,
    VdpVideoMixerFeature feature,
    /* output parameters follow */
    VdpBool *            is_supported
);
 
typedef VdpStatus VdpVideoMixerQueryParameterSupport(
    VdpDevice              device,
    VdpVideoMixerParameter parameter,
    /* output parameters follow */
    VdpBool *              is_supported
);
 
typedef VdpStatus VdpVideoMixerQueryAttributeSupport(
    VdpDevice              device,
    VdpVideoMixerAttribute attribute,
    /* output parameters follow */
    VdpBool *              is_supported
);
 
typedef VdpStatus VdpVideoMixerQueryParameterValueRange(
    VdpDevice              device,
    VdpVideoMixerParameter parameter,
    /* output parameters follow */
    void *                min_value,
    void *                max_value
);
 
typedef VdpStatus VdpVideoMixerQueryAttributeValueRange(
    VdpDevice              device,
    VdpVideoMixerAttribute attribute,
    /* output parameters follow */
    void *                min_value,
    void *                max_value
);
 
typedef uint32_t VdpVideoMixer;
 
typedef VdpStatus VdpVideoMixerCreate(
    VdpDevice                      device,
    // The set of features to request
    uint32_t                       feature_count,
    VdpVideoMixerFeature const *   features,
    // The parameters used during creation
    uint32_t                       parameter_count,
    VdpVideoMixerParameter const * parameters,
    void const * const *           parameter_values,
    /* output parameters follow */
    VdpVideoMixer *                mixer
);
 
typedef VdpStatus VdpVideoMixerSetFeatureEnables(
    VdpVideoMixer                mixer,
    uint32_t                     feature_count,
    VdpVideoMixerFeature const * features,
    VdpBool const *              feature_enables
);
 
typedef VdpStatus VdpVideoMixerSetAttributeValues(
    VdpVideoMixer                  mixer,
    uint32_t                       attribute_count,
    VdpVideoMixerAttribute const * attributes,
    void const * const *           attribute_values
);
 
typedef VdpStatus VdpVideoMixerGetFeatureSupport(
    VdpVideoMixer                mixer,
    uint32_t                     feature_count,
    VdpVideoMixerFeature const * features,
    /* output parameters follow */
    VdpBool *                    feature_supports
);
 
typedef VdpStatus VdpVideoMixerGetFeatureEnables(
    VdpVideoMixer                mixer,
    uint32_t                     feature_count,
    VdpVideoMixerFeature const * features,
    /* output parameters follow */
    VdpBool *                    feature_enables
);
 
typedef VdpStatus VdpVideoMixerGetParameterValues(
    VdpVideoMixer                  mixer,
    uint32_t                       parameter_count,
    VdpVideoMixerParameter const * parameters,
    /* output parameters follow */
    void * const *                 parameter_values
);
 
typedef VdpStatus VdpVideoMixerGetAttributeValues(
    VdpVideoMixer                  mixer,
    uint32_t                       attribute_count,
    VdpVideoMixerAttribute const * attributes,
    /* output parameters follow */
    void * const *                 attribute_values
);
 
typedef VdpStatus VdpVideoMixerDestroy(
    VdpVideoMixer mixer
);
 
typedef enum {
    VDP_VIDEO_MIXER_PICTURE_STRUCTURE_TOP_FIELD,
    VDP_VIDEO_MIXER_PICTURE_STRUCTURE_BOTTOM_FIELD,
    VDP_VIDEO_MIXER_PICTURE_STRUCTURE_FRAME,
} VdpVideoMixerPictureStructure;
 
#define VDP_LAYER_VERSION 0
 
typedef struct {
    uint32_t struct_version;
    VdpOutputSurface source_surface;
    VdpRect const *  source_rect;
     VdpRect const * destination_rect;
} VdpLayer;
 
typedef VdpStatus VdpVideoMixerRender(
    VdpVideoMixer                 mixer,
    VdpOutputSurface              background_surface,
    VdpRect const *               background_source_rect,
    VdpVideoMixerPictureStructure current_picture_structure,
    uint32_t                      video_surface_past_count,
    VdpVideoSurface const *       video_surface_past,
    VdpVideoSurface               video_surface_current,
    uint32_t                      video_surface_future_count,
    VdpVideoSurface const *       video_surface_future,
    VdpRect const *               video_source_rect,
    VdpOutputSurface              destination_surface,
    VdpRect const *               destination_rect,
    VdpRect const *               destination_video_rect,
    uint32_t                      layer_count,
    VdpLayer const *              layers
);
 
typedef uint64_t VdpTime;
 
typedef uint32_t VdpPresentationQueueTarget;
 
typedef VdpStatus VdpPresentationQueueTargetDestroy(
    VdpPresentationQueueTarget presentation_queue_target
);
 
typedef uint32_t VdpPresentationQueue;
 
typedef VdpStatus VdpPresentationQueueCreate(
    VdpDevice                  device,
    VdpPresentationQueueTarget presentation_queue_target,
    /* output parameters follow */
    VdpPresentationQueue *     presentation_queue
);
 
typedef VdpStatus VdpPresentationQueueDestroy(
    VdpPresentationQueue presentation_queue
);
 
typedef VdpStatus VdpPresentationQueueSetBackgroundColor(
    VdpPresentationQueue presentation_queue,
    VdpColor * const     background_color
);
 
typedef VdpStatus VdpPresentationQueueGetBackgroundColor(
    VdpPresentationQueue presentation_queue,
    VdpColor *           background_color
);
 
typedef VdpStatus VdpPresentationQueueGetTime(
    VdpPresentationQueue presentation_queue,
    /* output parameters follow */
    VdpTime *            current_time
);
 
typedef VdpStatus VdpPresentationQueueDisplay(
    VdpPresentationQueue presentation_queue,
    VdpOutputSurface     surface,
    uint32_t             clip_width,
    uint32_t             clip_height,
    VdpTime              earliest_presentation_time
);
 
typedef VdpStatus VdpPresentationQueueBlockUntilSurfaceIdle(
    VdpPresentationQueue presentation_queue,
    VdpOutputSurface     surface,
    /* output parameters follow */
    VdpTime *            first_presentation_time
);
 
typedef enum {
    VDP_PRESENTATION_QUEUE_STATUS_IDLE,
    VDP_PRESENTATION_QUEUE_STATUS_QUEUED,
    VDP_PRESENTATION_QUEUE_STATUS_VISIBLE,
} VdpPresentationQueueStatus;
 
typedef VdpStatus VdpPresentationQueueQuerySurfaceStatus(
    VdpPresentationQueue         presentation_queue,
    VdpOutputSurface             surface,
    /* output parameters follow */
    VdpPresentationQueueStatus * status,
    VdpTime *                    first_presentation_time
);
 
typedef void VdpPreemptionCallback(
    VdpDevice device,
    void *   context
);
 
typedef VdpStatus VdpPreemptionCallbackRegister(
    VdpDevice             device,
    VdpPreemptionCallback callback,
    void *               context
);
 
typedef uint32_t VdpFuncId;
 
#define VDP_FUNC_ID_GET_ERROR_STRING                                            ((VdpFuncId)0)
#define VDP_FUNC_ID_GET_PROC_ADDRESS                                            ((VdpFuncId)1)
#define VDP_FUNC_ID_GET_API_VERSION                                             ((VdpFuncId)2)
#define VDP_FUNC_ID_GET_INFORMATION_STRING                                      ((VdpFuncId)4)
#define VDP_FUNC_ID_DEVICE_DESTROY                                              ((VdpFuncId)5)
#define VDP_FUNC_ID_GENERATE_CSC_MATRIX                                         ((VdpFuncId)6)
#define VDP_FUNC_ID_VIDEO_SURFACE_QUERY_CAPABILITIES                            ((VdpFuncId)7)
#define VDP_FUNC_ID_VIDEO_SURFACE_QUERY_GET_PUT_BITS_Y_CB_CR_CAPABILITIES       ((VdpFuncId)8)
#define VDP_FUNC_ID_VIDEO_SURFACE_CREATE                                        ((VdpFuncId)9)
#define VDP_FUNC_ID_VIDEO_SURFACE_DESTROY                                       ((VdpFuncId)10)
#define VDP_FUNC_ID_VIDEO_SURFACE_GET_PARAMETERS                                ((VdpFuncId)11)
#define VDP_FUNC_ID_VIDEO_SURFACE_GET_BITS_Y_CB_CR                              ((VdpFuncId)12)
#define VDP_FUNC_ID_VIDEO_SURFACE_PUT_BITS_Y_CB_CR                              ((VdpFuncId)13)
#define VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_CAPABILITIES                           ((VdpFuncId)14)
#define VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_GET_PUT_BITS_NATIVE_CAPABILITIES       ((VdpFuncId)15)
#define VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_PUT_BITS_INDEXED_CAPABILITIES          ((VdpFuncId)16)
#define VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_PUT_BITS_Y_CB_CR_CAPABILITIES          ((VdpFuncId)17)
#define VDP_FUNC_ID_OUTPUT_SURFACE_CREATE                                       ((VdpFuncId)18)
#define VDP_FUNC_ID_OUTPUT_SURFACE_DESTROY                                      ((VdpFuncId)19)
#define VDP_FUNC_ID_OUTPUT_SURFACE_GET_PARAMETERS                               ((VdpFuncId)20)
#define VDP_FUNC_ID_OUTPUT_SURFACE_GET_BITS_NATIVE                              ((VdpFuncId)21)
#define VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_NATIVE                              ((VdpFuncId)22)
#define VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_INDEXED                             ((VdpFuncId)23)
#define VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_Y_CB_CR                             ((VdpFuncId)24)
#define VDP_FUNC_ID_BITMAP_SURFACE_QUERY_CAPABILITIES                           ((VdpFuncId)25)
#define VDP_FUNC_ID_BITMAP_SURFACE_CREATE                                       ((VdpFuncId)26)
#define VDP_FUNC_ID_BITMAP_SURFACE_DESTROY                                      ((VdpFuncId)27)
#define VDP_FUNC_ID_BITMAP_SURFACE_GET_PARAMETERS                               ((VdpFuncId)28)
#define VDP_FUNC_ID_BITMAP_SURFACE_PUT_BITS_NATIVE                              ((VdpFuncId)29)
#define VDP_FUNC_ID_OUTPUT_SURFACE_RENDER_OUTPUT_SURFACE                        ((VdpFuncId)33)
#define VDP_FUNC_ID_OUTPUT_SURFACE_RENDER_BITMAP_SURFACE                        ((VdpFuncId)34)
#define VDP_FUNC_ID_OUTPUT_SURFACE_RENDER_VIDEO_SURFACE_LUMA                    ((VdpFuncId)35)
#define VDP_FUNC_ID_DECODER_QUERY_CAPABILITIES                                  ((VdpFuncId)36)
#define VDP_FUNC_ID_DECODER_CREATE                                              ((VdpFuncId)37)
#define VDP_FUNC_ID_DECODER_DESTROY                                             ((VdpFuncId)38)
#define VDP_FUNC_ID_DECODER_GET_PARAMETERS                                      ((VdpFuncId)39)
#define VDP_FUNC_ID_DECODER_RENDER                                              ((VdpFuncId)40)
#define VDP_FUNC_ID_VIDEO_MIXER_QUERY_FEATURE_SUPPORT                           ((VdpFuncId)41)
#define VDP_FUNC_ID_VIDEO_MIXER_QUERY_PARAMETER_SUPPORT                         ((VdpFuncId)42)
#define VDP_FUNC_ID_VIDEO_MIXER_QUERY_ATTRIBUTE_SUPPORT                         ((VdpFuncId)43)
#define VDP_FUNC_ID_VIDEO_MIXER_QUERY_PARAMETER_VALUE_RANGE                     ((VdpFuncId)44)
#define VDP_FUNC_ID_VIDEO_MIXER_QUERY_ATTRIBUTE_VALUE_RANGE                     ((VdpFuncId)45)
#define VDP_FUNC_ID_VIDEO_MIXER_CREATE                                          ((VdpFuncId)46)
#define VDP_FUNC_ID_VIDEO_MIXER_SET_FEATURE_ENABLES                             ((VdpFuncId)47)
#define VDP_FUNC_ID_VIDEO_MIXER_SET_ATTRIBUTE_VALUES                            ((VdpFuncId)48)
#define VDP_FUNC_ID_VIDEO_MIXER_GET_FEATURE_SUPPORT                             ((VdpFuncId)49)
#define VDP_FUNC_ID_VIDEO_MIXER_GET_FEATURE_ENABLES                             ((VdpFuncId)50)
#define VDP_FUNC_ID_VIDEO_MIXER_GET_PARAMETER_VALUES                            ((VdpFuncId)51)
#define VDP_FUNC_ID_VIDEO_MIXER_GET_ATTRIBUTE_VALUES                            ((VdpFuncId)52)
#define VDP_FUNC_ID_VIDEO_MIXER_DESTROY                                         ((VdpFuncId)53)
#define VDP_FUNC_ID_VIDEO_MIXER_RENDER                                          ((VdpFuncId)54)
#define VDP_FUNC_ID_PRESENTATION_QUEUE_TARGET_DESTROY                           ((VdpFuncId)55)
#define VDP_FUNC_ID_PRESENTATION_QUEUE_CREATE                                   ((VdpFuncId)56)
#define VDP_FUNC_ID_PRESENTATION_QUEUE_DESTROY                                  ((VdpFuncId)57)
#define VDP_FUNC_ID_PRESENTATION_QUEUE_SET_BACKGROUND_COLOR                     ((VdpFuncId)58)
#define VDP_FUNC_ID_PRESENTATION_QUEUE_GET_BACKGROUND_COLOR                     ((VdpFuncId)59)
#define VDP_FUNC_ID_PRESENTATION_QUEUE_GET_TIME                                 ((VdpFuncId)62)
#define VDP_FUNC_ID_PRESENTATION_QUEUE_DISPLAY                                  ((VdpFuncId)63)
#define VDP_FUNC_ID_PRESENTATION_QUEUE_BLOCK_UNTIL_SURFACE_IDLE                 ((VdpFuncId)64)
#define VDP_FUNC_ID_PRESENTATION_QUEUE_QUERY_SURFACE_STATUS                     ((VdpFuncId)65)
#define VDP_FUNC_ID_PREEMPTION_CALLBACK_REGISTER                                ((VdpFuncId)66)
#define VDP_FUNC_ID_DECODER_QUERY_CAPABILITY                                    ((VdpFuncId)67)
 
#define VDP_FUNC_ID_BASE_WINSYS 0x1000
 
typedef VdpStatus VdpGetProcAddress(
    VdpDevice device,
    VdpFuncId function_id,
    /* output parameters follow */
    void * *  function_pointer
);
 
#ifdef __cplusplus
}
#endif
 
#endif