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)

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)

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_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_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_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 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 {
    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 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_BASE_WINSYS 0x1000

typedef VdpStatus VdpGetProcAddress(
    VdpDevice device,
    VdpFuncId function_id,
    /* output parameters follow */
    void * *  function_pointer
);


#ifdef __cplusplus
}
#endif

#endif