Home | History | Annotate | Download | only in vdpau 
      1 /**************************************************************************
      2  *
      3  * Copyright 2010 Younes Manton & Thomas Balling Srensen.
      4  * All Rights Reserved.
      5  *
      6  * Permission is hereby granted, free of charge, to any person obtaining a
      7  * copy of this software and associated documentation files (the
      8  * "Software"), to deal in the Software without restriction, including
      9  * without limitation the rights to use, copy, modify, merge, publish,
     10  * distribute, sub license, and/or sell copies of the Software, and to
     11  * permit persons to whom the Software is furnished to do so, subject to
     12  * the following conditions:
     13  *
     14  * The above copyright notice and this permission notice (including the
     15  * next paragraph) shall be included in all copies or substantial portions
     16  * of the Software.
     17  *
     18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
     19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
     20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
     21  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
     22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
     23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
     24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
     25  *
     26  **************************************************************************/
     27 
     28 #ifndef VDPAU_PRIVATE_H
     29 #define VDPAU_PRIVATE_H
     30 
     31 #include <assert.h>
     32 
     33 #include <vdpau/vdpau.h>
     34 #include <vdpau/vdpau_x11.h>
     35 
     36 #include "pipe/p_compiler.h"
     37 #include "pipe/p_video_codec.h"
     38 
     39 #include "state_tracker/vdpau_interop.h"
     40 #include "state_tracker/vdpau_dmabuf.h"
     41 #include "state_tracker/vdpau_funcs.h"
     42 
     43 #include "util/u_debug.h"
     44 #include "util/u_rect.h"
     45 #include "os/os_thread.h"
     46 
     47 #include "vl/vl_video_buffer.h"
     48 #include "vl/vl_bicubic_filter.h"
     49 #include "vl/vl_compositor.h"
     50 #include "vl/vl_csc.h"
     51 #include "vl/vl_deint_filter.h"
     52 #include "vl/vl_matrix_filter.h"
     53 #include "vl/vl_median_filter.h"
     54 #include "vl/vl_winsys.h"
     55 
     56 /* Full VDPAU API documentation available at :
     57  * ftp://download.nvidia.com/XFree86/vdpau/doxygen/html/index.html */
     58 
     59 #define INFORMATION G3DVL VDPAU Driver Shared Library version VER_MAJOR.VER_MINOR
     60 #define QUOTEME(x) #x
     61 #define TOSTRING(x) QUOTEME(x)
     62 #define INFORMATION_STRING TOSTRING(INFORMATION)
     63 
     64 static inline enum pipe_video_chroma_format
     65 ChromaToPipe(VdpChromaType vdpau_type)
     66 {
     67    switch (vdpau_type) {
     68       case VDP_CHROMA_TYPE_420:
     69          return PIPE_VIDEO_CHROMA_FORMAT_420;
     70       case VDP_CHROMA_TYPE_422:
     71          return PIPE_VIDEO_CHROMA_FORMAT_422;
     72       case VDP_CHROMA_TYPE_444:
     73          return PIPE_VIDEO_CHROMA_FORMAT_444;
     74       default:
     75          assert(0);
     76    }
     77 
     78    return -1;
     79 }
     80 
     81 static inline VdpChromaType
     82 PipeToChroma(enum pipe_video_chroma_format pipe_type)
     83 {
     84    switch (pipe_type) {
     85       case PIPE_VIDEO_CHROMA_FORMAT_420:
     86          return VDP_CHROMA_TYPE_420;
     87       case PIPE_VIDEO_CHROMA_FORMAT_422:
     88          return VDP_CHROMA_TYPE_422;
     89       case PIPE_VIDEO_CHROMA_FORMAT_444:
     90          return VDP_CHROMA_TYPE_444;
     91       default:
     92          assert(0);
     93    }
     94 
     95    return -1;
     96 }
     97 
     98 static inline enum pipe_video_chroma_format
     99 FormatYCBCRToPipeChroma(VdpYCbCrFormat vdpau_format)
    100 {
    101    switch (vdpau_format) {
    102       case VDP_YCBCR_FORMAT_NV12:
    103          return PIPE_VIDEO_CHROMA_FORMAT_420;
    104       case VDP_YCBCR_FORMAT_YV12:
    105          return PIPE_VIDEO_CHROMA_FORMAT_420;
    106       case VDP_YCBCR_FORMAT_UYVY:
    107          return PIPE_VIDEO_CHROMA_FORMAT_422;
    108       case VDP_YCBCR_FORMAT_YUYV:
    109          return PIPE_VIDEO_CHROMA_FORMAT_422;
    110       case VDP_YCBCR_FORMAT_Y8U8V8A8:
    111          return PIPE_VIDEO_CHROMA_FORMAT_444;
    112       case VDP_YCBCR_FORMAT_V8U8Y8A8:
    113          return PIPE_VIDEO_CHROMA_FORMAT_444;
    114       default:
    115          assert(0);
    116    }
    117 
    118    return PIPE_FORMAT_NONE;
    119 }
    120 
    121 static inline enum pipe_format
    122 FormatYCBCRToPipe(VdpYCbCrFormat vdpau_format)
    123 {
    124    switch (vdpau_format) {
    125       case VDP_YCBCR_FORMAT_NV12:
    126          return PIPE_FORMAT_NV12;
    127       case VDP_YCBCR_FORMAT_YV12:
    128          return PIPE_FORMAT_YV12;
    129       case VDP_YCBCR_FORMAT_UYVY:
    130          return PIPE_FORMAT_UYVY;
    131       case VDP_YCBCR_FORMAT_YUYV:
    132          return PIPE_FORMAT_YUYV;
    133       case VDP_YCBCR_FORMAT_Y8U8V8A8:
    134          return PIPE_FORMAT_R8G8B8A8_UNORM;
    135       case VDP_YCBCR_FORMAT_V8U8Y8A8:
    136          return PIPE_FORMAT_B8G8R8A8_UNORM;
    137       default:
    138          assert(0);
    139    }
    140 
    141    return PIPE_FORMAT_NONE;
    142 }
    143 
    144 static inline VdpYCbCrFormat
    145 PipeToFormatYCBCR(enum pipe_format p_format)
    146 {
    147    switch (p_format) {
    148       case PIPE_FORMAT_NV12:
    149          return VDP_YCBCR_FORMAT_NV12;
    150       case PIPE_FORMAT_YV12:
    151          return VDP_YCBCR_FORMAT_YV12;
    152       case PIPE_FORMAT_UYVY:
    153          return VDP_YCBCR_FORMAT_UYVY;
    154       case PIPE_FORMAT_YUYV:
    155          return VDP_YCBCR_FORMAT_YUYV;
    156       case PIPE_FORMAT_R8G8B8A8_UNORM:
    157         return VDP_YCBCR_FORMAT_Y8U8V8A8;
    158       case PIPE_FORMAT_B8G8R8A8_UNORM:
    159          return VDP_YCBCR_FORMAT_V8U8Y8A8;
    160       default:
    161          assert(0);
    162    }
    163 
    164    return -1;
    165 }
    166 
    167 static inline VdpRGBAFormat
    168 PipeToFormatRGBA(enum pipe_format p_format)
    169 {
    170    switch (p_format) {
    171       case PIPE_FORMAT_A8_UNORM:
    172          return VDP_RGBA_FORMAT_A8;
    173       case PIPE_FORMAT_B10G10R10A2_UNORM:
    174          return VDP_RGBA_FORMAT_B10G10R10A2;
    175       case PIPE_FORMAT_B8G8R8A8_UNORM:
    176          return VDP_RGBA_FORMAT_B8G8R8A8;
    177       case PIPE_FORMAT_R10G10B10A2_UNORM:
    178          return VDP_RGBA_FORMAT_R10G10B10A2;
    179       case PIPE_FORMAT_R8G8B8A8_UNORM:
    180          return VDP_RGBA_FORMAT_R8G8B8A8;
    181       default:
    182          assert(0);
    183    }
    184 
    185    return -1;
    186 }
    187 
    188 static inline enum pipe_format
    189 FormatIndexedToPipe(VdpRGBAFormat vdpau_format)
    190 {
    191    switch (vdpau_format) {
    192       case VDP_INDEXED_FORMAT_A4I4:
    193          return PIPE_FORMAT_R4A4_UNORM;
    194       case VDP_INDEXED_FORMAT_I4A4:
    195          return PIPE_FORMAT_A4R4_UNORM;
    196       case VDP_INDEXED_FORMAT_A8I8:
    197          return PIPE_FORMAT_A8R8_UNORM;
    198       case VDP_INDEXED_FORMAT_I8A8:
    199          return PIPE_FORMAT_R8A8_UNORM;
    200       default:
    201          assert(0);
    202    }
    203 
    204    return PIPE_FORMAT_NONE;
    205 }
    206 
    207 static inline enum pipe_format
    208 FormatColorTableToPipe(VdpColorTableFormat vdpau_format)
    209 {
    210    switch(vdpau_format) {
    211       case VDP_COLOR_TABLE_FORMAT_B8G8R8X8:
    212          return PIPE_FORMAT_B8G8R8X8_UNORM;
    213       default:
    214          assert(0);
    215    }
    216 
    217    return PIPE_FORMAT_NONE;
    218 }
    219 
    220 static inline enum pipe_video_profile
    221 ProfileToPipe(VdpDecoderProfile vdpau_profile)
    222 {
    223    switch (vdpau_profile) {
    224       case VDP_DECODER_PROFILE_MPEG1:
    225          return PIPE_VIDEO_PROFILE_MPEG1;
    226       case VDP_DECODER_PROFILE_MPEG2_SIMPLE:
    227          return PIPE_VIDEO_PROFILE_MPEG2_SIMPLE;
    228       case VDP_DECODER_PROFILE_MPEG2_MAIN:
    229          return PIPE_VIDEO_PROFILE_MPEG2_MAIN;
    230       case VDP_DECODER_PROFILE_H264_BASELINE:
    231          return PIPE_VIDEO_PROFILE_MPEG4_AVC_BASELINE;
    232       case VDP_DECODER_PROFILE_H264_CONSTRAINED_BASELINE:
    233          return PIPE_VIDEO_PROFILE_MPEG4_AVC_CONSTRAINED_BASELINE;
    234       case VDP_DECODER_PROFILE_H264_MAIN:
    235          return PIPE_VIDEO_PROFILE_MPEG4_AVC_MAIN;
    236       case VDP_DECODER_PROFILE_H264_HIGH:
    237          return PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH;
    238       case VDP_DECODER_PROFILE_MPEG4_PART2_SP:
    239          return PIPE_VIDEO_PROFILE_MPEG4_SIMPLE;
    240       case VDP_DECODER_PROFILE_MPEG4_PART2_ASP:
    241          return PIPE_VIDEO_PROFILE_MPEG4_ADVANCED_SIMPLE;
    242       case VDP_DECODER_PROFILE_VC1_SIMPLE:
    243          return PIPE_VIDEO_PROFILE_VC1_SIMPLE;
    244       case VDP_DECODER_PROFILE_VC1_MAIN:
    245          return PIPE_VIDEO_PROFILE_VC1_MAIN;
    246       case VDP_DECODER_PROFILE_VC1_ADVANCED:
    247          return PIPE_VIDEO_PROFILE_VC1_ADVANCED;
    248       case VDP_DECODER_PROFILE_HEVC_MAIN:
    249          return PIPE_VIDEO_PROFILE_HEVC_MAIN;
    250       case VDP_DECODER_PROFILE_HEVC_MAIN_10:
    251          return PIPE_VIDEO_PROFILE_HEVC_MAIN_10;
    252       case VDP_DECODER_PROFILE_HEVC_MAIN_STILL:
    253          return PIPE_VIDEO_PROFILE_HEVC_MAIN_STILL;
    254       case VDP_DECODER_PROFILE_HEVC_MAIN_12:
    255          return PIPE_VIDEO_PROFILE_HEVC_MAIN_12;
    256       case VDP_DECODER_PROFILE_HEVC_MAIN_444:
    257          return PIPE_VIDEO_PROFILE_HEVC_MAIN_444;
    258       default:
    259          return PIPE_VIDEO_PROFILE_UNKNOWN;
    260    }
    261 }
    262 
    263 static inline VdpDecoderProfile
    264 PipeToProfile(enum pipe_video_profile p_profile)
    265 {
    266    switch (p_profile) {
    267       case PIPE_VIDEO_PROFILE_MPEG1:
    268          return VDP_DECODER_PROFILE_MPEG1;
    269       case PIPE_VIDEO_PROFILE_MPEG2_SIMPLE:
    270          return VDP_DECODER_PROFILE_MPEG2_SIMPLE;
    271       case PIPE_VIDEO_PROFILE_MPEG2_MAIN:
    272          return VDP_DECODER_PROFILE_MPEG2_MAIN;
    273       case PIPE_VIDEO_PROFILE_MPEG4_AVC_BASELINE:
    274          return VDP_DECODER_PROFILE_H264_BASELINE;
    275       case PIPE_VIDEO_PROFILE_MPEG4_AVC_CONSTRAINED_BASELINE:
    276          return VDP_DECODER_PROFILE_H264_CONSTRAINED_BASELINE;
    277       case PIPE_VIDEO_PROFILE_MPEG4_AVC_MAIN:
    278          return VDP_DECODER_PROFILE_H264_MAIN;
    279       case PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH:
    280          return VDP_DECODER_PROFILE_H264_HIGH;
    281       case PIPE_VIDEO_PROFILE_MPEG4_SIMPLE:
    282          return VDP_DECODER_PROFILE_MPEG4_PART2_SP;
    283       case PIPE_VIDEO_PROFILE_MPEG4_ADVANCED_SIMPLE:
    284          return VDP_DECODER_PROFILE_MPEG4_PART2_ASP;
    285       case PIPE_VIDEO_PROFILE_VC1_SIMPLE:
    286          return VDP_DECODER_PROFILE_VC1_SIMPLE;
    287       case PIPE_VIDEO_PROFILE_VC1_MAIN:
    288          return VDP_DECODER_PROFILE_VC1_MAIN;
    289       case PIPE_VIDEO_PROFILE_VC1_ADVANCED:
    290          return VDP_DECODER_PROFILE_VC1_ADVANCED;
    291       case PIPE_VIDEO_PROFILE_HEVC_MAIN:
    292          return VDP_DECODER_PROFILE_HEVC_MAIN;
    293       case PIPE_VIDEO_PROFILE_HEVC_MAIN_10:
    294          return VDP_DECODER_PROFILE_HEVC_MAIN_10;
    295       case PIPE_VIDEO_PROFILE_HEVC_MAIN_STILL:
    296          return VDP_DECODER_PROFILE_HEVC_MAIN_STILL;
    297       case PIPE_VIDEO_PROFILE_HEVC_MAIN_12:
    298          return VDP_DECODER_PROFILE_HEVC_MAIN_12;
    299       case PIPE_VIDEO_PROFILE_HEVC_MAIN_444:
    300          return VDP_DECODER_PROFILE_HEVC_MAIN_444;
    301       default:
    302          assert(0);
    303          return -1;
    304    }
    305 }
    306 
    307 static inline struct u_rect *
    308 RectToPipe(const VdpRect *src, struct u_rect *dst)
    309 {
    310    if (src) {
    311       dst->x0 = src->x0;
    312       dst->y0 = src->y0;
    313       dst->x1 = src->x1;
    314       dst->y1 = src->y1;
    315       return dst;
    316    }
    317    return NULL;
    318 }
    319 
    320 static inline struct pipe_box
    321 RectToPipeBox(const VdpRect *rect, struct pipe_resource *res)
    322 {
    323    struct pipe_box box;
    324 
    325    box.x = 0;
    326    box.y = 0;
    327    box.z = 0;
    328    box.width = res->width0;
    329    box.height = res->height0;
    330    box.depth = 1;
    331 
    332    if (rect) {
    333       box.x = MIN2(rect->x0, rect->x1);
    334       box.y = MIN2(rect->y0, rect->y1);
    335       box.width = abs(rect->x1 - rect->x0);
    336       box.height = abs(rect->y1 - rect->y0);
    337    }
    338 
    339    return box;
    340 }
    341 
    342 static inline bool
    343 CheckSurfaceParams(struct pipe_screen *screen,
    344                    const struct pipe_resource *templ)
    345 {
    346    return screen->is_format_supported(
    347          screen, templ->format, templ->target, templ->nr_samples, templ->bind);
    348 }
    349 
    350 typedef struct
    351 {
    352    struct pipe_reference reference;
    353    struct vl_screen *vscreen;
    354    struct pipe_context *context;
    355    struct vl_compositor compositor;
    356    struct pipe_sampler_view *dummy_sv;
    357    mtx_t mutex;
    358 } vlVdpDevice;
    359 
    360 typedef struct
    361 {
    362    vlVdpDevice *device;
    363    struct vl_compositor_state cstate;
    364 
    365    struct {
    366        bool supported, enabled;
    367        float luma_min, luma_max;
    368    } luma_key;
    369 
    370    struct {
    371 	  bool supported, enabled, spatial;
    372 	  struct vl_deint_filter *filter;
    373    } deint;
    374 
    375    struct {
    376 	  bool supported, enabled;
    377 	  struct vl_bicubic_filter *filter;
    378    } bicubic;
    379 
    380    struct {
    381       bool supported, enabled;
    382       unsigned level;
    383       struct vl_median_filter *filter;
    384    } noise_reduction;
    385 
    386    struct {
    387       bool supported, enabled;
    388       float value;
    389       struct vl_matrix_filter *filter;
    390    } sharpness;
    391 
    392    unsigned video_width, video_height;
    393    enum pipe_video_chroma_format chroma_format;
    394    unsigned max_layers, skip_chroma_deint;
    395 
    396    bool custom_csc;
    397    vl_csc_matrix csc;
    398 } vlVdpVideoMixer;
    399 
    400 typedef struct
    401 {
    402    vlVdpDevice *device;
    403    struct pipe_video_buffer templat, *video_buffer;
    404 } vlVdpSurface;
    405 
    406 typedef struct
    407 {
    408    vlVdpDevice *device;
    409    struct pipe_sampler_view *sampler_view;
    410 } vlVdpBitmapSurface;
    411 
    412 typedef uint64_t vlVdpTime;
    413 
    414 typedef struct
    415 {
    416    vlVdpDevice *device;
    417    struct pipe_surface *surface;
    418    struct pipe_sampler_view *sampler_view;
    419    struct pipe_fence_handle *fence;
    420    struct vl_compositor_state cstate;
    421    struct u_rect dirty_area;
    422    bool send_to_X;
    423 } vlVdpOutputSurface;
    424 
    425 typedef struct
    426 {
    427    vlVdpDevice *device;
    428    Drawable drawable;
    429 } vlVdpPresentationQueueTarget;
    430 
    431 typedef struct
    432 {
    433    vlVdpDevice *device;
    434    Drawable drawable;
    435    struct vl_compositor_state cstate;
    436    vlVdpOutputSurface *last_surf;
    437 } vlVdpPresentationQueue;
    438 
    439 typedef struct
    440 {
    441    vlVdpDevice *device;
    442    mtx_t mutex;
    443    struct pipe_video_codec *decoder;
    444 } vlVdpDecoder;
    445 
    446 typedef uint32_t vlHandle;
    447 
    448 boolean vlCreateHTAB(void);
    449 void vlDestroyHTAB(void);
    450 vlHandle vlAddDataHTAB(void *data);
    451 void* vlGetDataHTAB(vlHandle handle);
    452 void vlRemoveDataHTAB(vlHandle handle);
    453 
    454 boolean vlGetFuncFTAB(VdpFuncId function_id, void **func);
    455 
    456 /* Public functions */
    457 VdpDeviceCreateX11 vdp_imp_device_create_x11;
    458 
    459 void vlVdpDefaultSamplerViewTemplate(struct pipe_sampler_view *templ, struct pipe_resource *res);
    460 
    461 /* Internal function pointers */
    462 VdpGetErrorString vlVdpGetErrorString;
    463 VdpDeviceDestroy vlVdpDeviceDestroy;
    464 void vlVdpDeviceFree(vlVdpDevice *dev);
    465 VdpGetProcAddress vlVdpGetProcAddress;
    466 VdpGetApiVersion vlVdpGetApiVersion;
    467 VdpGetInformationString vlVdpGetInformationString;
    468 VdpVideoSurfaceQueryCapabilities vlVdpVideoSurfaceQueryCapabilities;
    469 VdpVideoSurfaceQueryGetPutBitsYCbCrCapabilities vlVdpVideoSurfaceQueryGetPutBitsYCbCrCapabilities;
    470 VdpDecoderQueryCapabilities vlVdpDecoderQueryCapabilities;
    471 VdpOutputSurfaceQueryCapabilities vlVdpOutputSurfaceQueryCapabilities;
    472 VdpOutputSurfaceQueryGetPutBitsNativeCapabilities vlVdpOutputSurfaceQueryGetPutBitsNativeCapabilities;
    473 VdpOutputSurfaceQueryPutBitsIndexedCapabilities vlVdpOutputSurfaceQueryPutBitsIndexedCapabilities;
    474 VdpOutputSurfaceQueryPutBitsYCbCrCapabilities vlVdpOutputSurfaceQueryPutBitsYCbCrCapabilities;
    475 VdpBitmapSurfaceQueryCapabilities vlVdpBitmapSurfaceQueryCapabilities;
    476 VdpVideoMixerQueryFeatureSupport vlVdpVideoMixerQueryFeatureSupport;
    477 VdpVideoMixerQueryParameterSupport vlVdpVideoMixerQueryParameterSupport;
    478 VdpVideoMixerQueryParameterValueRange vlVdpVideoMixerQueryParameterValueRange;
    479 VdpVideoMixerQueryAttributeSupport vlVdpVideoMixerQueryAttributeSupport;
    480 VdpVideoMixerQueryAttributeValueRange vlVdpVideoMixerQueryAttributeValueRange;
    481 VdpVideoSurfaceCreate vlVdpVideoSurfaceCreate;
    482 VdpVideoSurfaceDestroy vlVdpVideoSurfaceDestroy;
    483 VdpVideoSurfaceGetParameters vlVdpVideoSurfaceGetParameters;
    484 VdpVideoSurfaceGetBitsYCbCr vlVdpVideoSurfaceGetBitsYCbCr;
    485 VdpVideoSurfacePutBitsYCbCr vlVdpVideoSurfacePutBitsYCbCr;
    486 void vlVdpVideoSurfaceClear(vlVdpSurface *vlsurf);
    487 VdpDecoderCreate vlVdpDecoderCreate;
    488 VdpDecoderDestroy vlVdpDecoderDestroy;
    489 VdpDecoderGetParameters vlVdpDecoderGetParameters;
    490 VdpDecoderRender vlVdpDecoderRender;
    491 VdpOutputSurfaceCreate vlVdpOutputSurfaceCreate;
    492 VdpOutputSurfaceDestroy vlVdpOutputSurfaceDestroy;
    493 VdpOutputSurfaceGetParameters vlVdpOutputSurfaceGetParameters;
    494 VdpOutputSurfaceGetBitsNative vlVdpOutputSurfaceGetBitsNative;
    495 VdpOutputSurfacePutBitsNative vlVdpOutputSurfacePutBitsNative;
    496 VdpOutputSurfacePutBitsIndexed vlVdpOutputSurfacePutBitsIndexed;
    497 VdpOutputSurfacePutBitsYCbCr vlVdpOutputSurfacePutBitsYCbCr;
    498 VdpOutputSurfaceRenderOutputSurface vlVdpOutputSurfaceRenderOutputSurface;
    499 VdpOutputSurfaceRenderBitmapSurface vlVdpOutputSurfaceRenderBitmapSurface;
    500 VdpBitmapSurfaceCreate vlVdpBitmapSurfaceCreate;
    501 VdpBitmapSurfaceDestroy vlVdpBitmapSurfaceDestroy;
    502 VdpBitmapSurfaceGetParameters vlVdpBitmapSurfaceGetParameters;
    503 VdpBitmapSurfacePutBitsNative vlVdpBitmapSurfacePutBitsNative;
    504 VdpPresentationQueueTargetDestroy vlVdpPresentationQueueTargetDestroy;
    505 VdpPresentationQueueCreate vlVdpPresentationQueueCreate;
    506 VdpPresentationQueueDestroy vlVdpPresentationQueueDestroy;
    507 VdpPresentationQueueSetBackgroundColor vlVdpPresentationQueueSetBackgroundColor;
    508 VdpPresentationQueueGetBackgroundColor vlVdpPresentationQueueGetBackgroundColor;
    509 VdpPresentationQueueGetTime vlVdpPresentationQueueGetTime;
    510 VdpPresentationQueueDisplay vlVdpPresentationQueueDisplay;
    511 VdpPresentationQueueBlockUntilSurfaceIdle vlVdpPresentationQueueBlockUntilSurfaceIdle;
    512 VdpPresentationQueueQuerySurfaceStatus vlVdpPresentationQueueQuerySurfaceStatus;
    513 VdpPreemptionCallback vlVdpPreemptionCallback;
    514 VdpPreemptionCallbackRegister vlVdpPreemptionCallbackRegister;
    515 VdpVideoMixerSetFeatureEnables vlVdpVideoMixerSetFeatureEnables;
    516 VdpVideoMixerCreate vlVdpVideoMixerCreate;
    517 VdpVideoMixerRender vlVdpVideoMixerRender;
    518 VdpVideoMixerSetAttributeValues vlVdpVideoMixerSetAttributeValues;
    519 VdpVideoMixerGetFeatureSupport vlVdpVideoMixerGetFeatureSupport;
    520 VdpVideoMixerGetFeatureEnables vlVdpVideoMixerGetFeatureEnables;
    521 VdpVideoMixerGetParameterValues vlVdpVideoMixerGetParameterValues;
    522 VdpVideoMixerGetAttributeValues vlVdpVideoMixerGetAttributeValues;
    523 VdpVideoMixerDestroy vlVdpVideoMixerDestroy;
    524 VdpGenerateCSCMatrix vlVdpGenerateCSCMatrix;
    525 /* Winsys specific internal function pointers */
    526 VdpPresentationQueueTargetCreateX11 vlVdpPresentationQueueTargetCreateX11;
    527 
    528 
    529 /* interop to mesa state tracker */
    530 VdpVideoSurfaceGallium vlVdpVideoSurfaceGallium;
    531 VdpOutputSurfaceGallium vlVdpOutputSurfaceGallium;
    532 VdpVideoSurfaceDMABuf vlVdpVideoSurfaceDMABuf;
    533 VdpOutputSurfaceDMABuf vlVdpOutputSurfaceDMABuf;
    534 
    535 #define VDPAU_OUT   0
    536 #define VDPAU_ERR   1
    537 #define VDPAU_WARN  2
    538 #define VDPAU_TRACE 3
    539 
    540 static inline void VDPAU_MSG(unsigned int level, const char *fmt, ...)
    541 {
    542    static int debug_level = -1;
    543 
    544    if (debug_level == -1) {
    545       debug_level = MAX2(debug_get_num_option("VDPAU_DEBUG", 0), 0);
    546    }
    547 
    548    if (level <= debug_level) {
    549       va_list ap;
    550       va_start(ap, fmt);
    551       _debug_vprintf(fmt, ap);
    552       va_end(ap);
    553    }
    554 }
    555 
    556 static inline void
    557 DeviceReference(vlVdpDevice **ptr, vlVdpDevice *dev)
    558 {
    559    vlVdpDevice *old_dev = *ptr;
    560 
    561    if (pipe_reference(&(*ptr)->reference, &dev->reference))
    562       vlVdpDeviceFree(old_dev);
    563    *ptr = dev;
    564 }
    565 
    566 #endif /* VDPAU_PRIVATE_H */
    567