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)
 
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)
 
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_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_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 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