Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

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