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_MAIN: 233 return PIPE_VIDEO_PROFILE_MPEG4_AVC_MAIN; 234 case VDP_DECODER_PROFILE_H264_HIGH: 235 return PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH; 236 case VDP_DECODER_PROFILE_MPEG4_PART2_SP: 237 return PIPE_VIDEO_PROFILE_MPEG4_SIMPLE; 238 case VDP_DECODER_PROFILE_MPEG4_PART2_ASP: 239 return PIPE_VIDEO_PROFILE_MPEG4_ADVANCED_SIMPLE; 240 case VDP_DECODER_PROFILE_VC1_SIMPLE: 241 return PIPE_VIDEO_PROFILE_VC1_SIMPLE; 242 case VDP_DECODER_PROFILE_VC1_MAIN: 243 return PIPE_VIDEO_PROFILE_VC1_MAIN; 244 case VDP_DECODER_PROFILE_VC1_ADVANCED: 245 return PIPE_VIDEO_PROFILE_VC1_ADVANCED; 246 case VDP_DECODER_PROFILE_HEVC_MAIN: 247 return PIPE_VIDEO_PROFILE_HEVC_MAIN; 248 case VDP_DECODER_PROFILE_HEVC_MAIN_10: 249 return PIPE_VIDEO_PROFILE_HEVC_MAIN_10; 250 case VDP_DECODER_PROFILE_HEVC_MAIN_STILL: 251 return PIPE_VIDEO_PROFILE_HEVC_MAIN_STILL; 252 case VDP_DECODER_PROFILE_HEVC_MAIN_12: 253 return PIPE_VIDEO_PROFILE_HEVC_MAIN_12; 254 case VDP_DECODER_PROFILE_HEVC_MAIN_444: 255 return PIPE_VIDEO_PROFILE_HEVC_MAIN_444; 256 default: 257 return PIPE_VIDEO_PROFILE_UNKNOWN; 258 } 259 } 260 261 static inline VdpDecoderProfile 262 PipeToProfile(enum pipe_video_profile p_profile) 263 { 264 switch (p_profile) { 265 case PIPE_VIDEO_PROFILE_MPEG1: 266 return VDP_DECODER_PROFILE_MPEG1; 267 case PIPE_VIDEO_PROFILE_MPEG2_SIMPLE: 268 return VDP_DECODER_PROFILE_MPEG2_SIMPLE; 269 case PIPE_VIDEO_PROFILE_MPEG2_MAIN: 270 return VDP_DECODER_PROFILE_MPEG2_MAIN; 271 case PIPE_VIDEO_PROFILE_MPEG4_AVC_BASELINE: 272 return VDP_DECODER_PROFILE_H264_BASELINE; 273 case PIPE_VIDEO_PROFILE_MPEG4_AVC_MAIN: 274 return VDP_DECODER_PROFILE_H264_MAIN; 275 case PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH: 276 return VDP_DECODER_PROFILE_H264_HIGH; 277 case PIPE_VIDEO_PROFILE_MPEG4_SIMPLE: 278 return VDP_DECODER_PROFILE_MPEG4_PART2_SP; 279 case PIPE_VIDEO_PROFILE_MPEG4_ADVANCED_SIMPLE: 280 return VDP_DECODER_PROFILE_MPEG4_PART2_ASP; 281 case PIPE_VIDEO_PROFILE_VC1_SIMPLE: 282 return VDP_DECODER_PROFILE_VC1_SIMPLE; 283 case PIPE_VIDEO_PROFILE_VC1_MAIN: 284 return VDP_DECODER_PROFILE_VC1_MAIN; 285 case PIPE_VIDEO_PROFILE_VC1_ADVANCED: 286 return VDP_DECODER_PROFILE_VC1_ADVANCED; 287 case PIPE_VIDEO_PROFILE_HEVC_MAIN: 288 return VDP_DECODER_PROFILE_HEVC_MAIN; 289 case PIPE_VIDEO_PROFILE_HEVC_MAIN_10: 290 return VDP_DECODER_PROFILE_HEVC_MAIN_10; 291 case PIPE_VIDEO_PROFILE_HEVC_MAIN_STILL: 292 return VDP_DECODER_PROFILE_HEVC_MAIN_STILL; 293 case PIPE_VIDEO_PROFILE_HEVC_MAIN_12: 294 return VDP_DECODER_PROFILE_HEVC_MAIN_12; 295 case PIPE_VIDEO_PROFILE_HEVC_MAIN_444: 296 return VDP_DECODER_PROFILE_HEVC_MAIN_444; 297 default: 298 assert(0); 299 return -1; 300 } 301 } 302 303 static inline struct u_rect * 304 RectToPipe(const VdpRect *src, struct u_rect *dst) 305 { 306 if (src) { 307 dst->x0 = src->x0; 308 dst->y0 = src->y0; 309 dst->x1 = src->x1; 310 dst->y1 = src->y1; 311 return dst; 312 } 313 return NULL; 314 } 315 316 static inline struct pipe_box 317 RectToPipeBox(const VdpRect *rect, struct pipe_resource *res) 318 { 319 struct pipe_box box; 320 321 box.x = 0; 322 box.y = 0; 323 box.z = 0; 324 box.width = res->width0; 325 box.height = res->height0; 326 box.depth = 1; 327 328 if (rect) { 329 box.x = MIN2(rect->x0, rect->x1); 330 box.y = MIN2(rect->y0, rect->y1); 331 box.width = abs(rect->x1 - rect->x0); 332 box.height = abs(rect->y1 - rect->y0); 333 } 334 335 return box; 336 } 337 338 static inline bool 339 CheckSurfaceParams(struct pipe_screen *screen, 340 const struct pipe_resource *templ) 341 { 342 return screen->is_format_supported( 343 screen, templ->format, templ->target, templ->nr_samples, templ->bind); 344 } 345 346 typedef struct 347 { 348 struct pipe_reference reference; 349 struct vl_screen *vscreen; 350 struct pipe_context *context; 351 struct vl_compositor compositor; 352 struct pipe_sampler_view *dummy_sv; 353 pipe_mutex mutex; 354 } vlVdpDevice; 355 356 typedef struct 357 { 358 vlVdpDevice *device; 359 struct vl_compositor_state cstate; 360 361 struct { 362 bool supported, enabled; 363 float luma_min, luma_max; 364 } luma_key; 365 366 struct { 367 bool supported, enabled, spatial; 368 struct vl_deint_filter *filter; 369 } deint; 370 371 struct { 372 bool supported, enabled; 373 struct vl_bicubic_filter *filter; 374 } bicubic; 375 376 struct { 377 bool supported, enabled; 378 unsigned level; 379 struct vl_median_filter *filter; 380 } noise_reduction; 381 382 struct { 383 bool supported, enabled; 384 float value; 385 struct vl_matrix_filter *filter; 386 } sharpness; 387 388 unsigned video_width, video_height; 389 enum pipe_video_chroma_format chroma_format; 390 unsigned max_layers, skip_chroma_deint; 391 392 bool custom_csc; 393 vl_csc_matrix csc; 394 } vlVdpVideoMixer; 395 396 typedef struct 397 { 398 vlVdpDevice *device; 399 struct pipe_video_buffer templat, *video_buffer; 400 } vlVdpSurface; 401 402 typedef struct 403 { 404 vlVdpDevice *device; 405 struct pipe_sampler_view *sampler_view; 406 } vlVdpBitmapSurface; 407 408 typedef uint64_t vlVdpTime; 409 410 typedef struct 411 { 412 vlVdpDevice *device; 413 struct pipe_surface *surface; 414 struct pipe_sampler_view *sampler_view; 415 struct pipe_fence_handle *fence; 416 struct vl_compositor_state cstate; 417 struct u_rect dirty_area; 418 bool send_to_X; 419 } vlVdpOutputSurface; 420 421 typedef struct 422 { 423 vlVdpDevice *device; 424 Drawable drawable; 425 } vlVdpPresentationQueueTarget; 426 427 typedef struct 428 { 429 vlVdpDevice *device; 430 Drawable drawable; 431 struct vl_compositor_state cstate; 432 vlVdpOutputSurface *last_surf; 433 } vlVdpPresentationQueue; 434 435 typedef struct 436 { 437 vlVdpDevice *device; 438 pipe_mutex mutex; 439 struct pipe_video_codec *decoder; 440 } vlVdpDecoder; 441 442 typedef uint32_t vlHandle; 443 444 boolean vlCreateHTAB(void); 445 void vlDestroyHTAB(void); 446 vlHandle vlAddDataHTAB(void *data); 447 void* vlGetDataHTAB(vlHandle handle); 448 void vlRemoveDataHTAB(vlHandle handle); 449 450 boolean vlGetFuncFTAB(VdpFuncId function_id, void **func); 451 452 /* Public functions */ 453 VdpDeviceCreateX11 vdp_imp_device_create_x11; 454 455 void vlVdpDefaultSamplerViewTemplate(struct pipe_sampler_view *templ, struct pipe_resource *res); 456 457 /* Internal function pointers */ 458 VdpGetErrorString vlVdpGetErrorString; 459 VdpDeviceDestroy vlVdpDeviceDestroy; 460 void vlVdpDeviceFree(vlVdpDevice *dev); 461 VdpGetProcAddress vlVdpGetProcAddress; 462 VdpGetApiVersion vlVdpGetApiVersion; 463 VdpGetInformationString vlVdpGetInformationString; 464 VdpVideoSurfaceQueryCapabilities vlVdpVideoSurfaceQueryCapabilities; 465 VdpVideoSurfaceQueryGetPutBitsYCbCrCapabilities vlVdpVideoSurfaceQueryGetPutBitsYCbCrCapabilities; 466 VdpDecoderQueryCapabilities vlVdpDecoderQueryCapabilities; 467 VdpOutputSurfaceQueryCapabilities vlVdpOutputSurfaceQueryCapabilities; 468 VdpOutputSurfaceQueryGetPutBitsNativeCapabilities vlVdpOutputSurfaceQueryGetPutBitsNativeCapabilities; 469 VdpOutputSurfaceQueryPutBitsIndexedCapabilities vlVdpOutputSurfaceQueryPutBitsIndexedCapabilities; 470 VdpOutputSurfaceQueryPutBitsYCbCrCapabilities vlVdpOutputSurfaceQueryPutBitsYCbCrCapabilities; 471 VdpBitmapSurfaceQueryCapabilities vlVdpBitmapSurfaceQueryCapabilities; 472 VdpVideoMixerQueryFeatureSupport vlVdpVideoMixerQueryFeatureSupport; 473 VdpVideoMixerQueryParameterSupport vlVdpVideoMixerQueryParameterSupport; 474 VdpVideoMixerQueryParameterValueRange vlVdpVideoMixerQueryParameterValueRange; 475 VdpVideoMixerQueryAttributeSupport vlVdpVideoMixerQueryAttributeSupport; 476 VdpVideoMixerQueryAttributeValueRange vlVdpVideoMixerQueryAttributeValueRange; 477 VdpVideoSurfaceCreate vlVdpVideoSurfaceCreate; 478 VdpVideoSurfaceDestroy vlVdpVideoSurfaceDestroy; 479 VdpVideoSurfaceGetParameters vlVdpVideoSurfaceGetParameters; 480 VdpVideoSurfaceGetBitsYCbCr vlVdpVideoSurfaceGetBitsYCbCr; 481 VdpVideoSurfacePutBitsYCbCr vlVdpVideoSurfacePutBitsYCbCr; 482 void vlVdpVideoSurfaceClear(vlVdpSurface *vlsurf); 483 VdpDecoderCreate vlVdpDecoderCreate; 484 VdpDecoderDestroy vlVdpDecoderDestroy; 485 VdpDecoderGetParameters vlVdpDecoderGetParameters; 486 VdpDecoderRender vlVdpDecoderRender; 487 VdpOutputSurfaceCreate vlVdpOutputSurfaceCreate; 488 VdpOutputSurfaceDestroy vlVdpOutputSurfaceDestroy; 489 VdpOutputSurfaceGetParameters vlVdpOutputSurfaceGetParameters; 490 VdpOutputSurfaceGetBitsNative vlVdpOutputSurfaceGetBitsNative; 491 VdpOutputSurfacePutBitsNative vlVdpOutputSurfacePutBitsNative; 492 VdpOutputSurfacePutBitsIndexed vlVdpOutputSurfacePutBitsIndexed; 493 VdpOutputSurfacePutBitsYCbCr vlVdpOutputSurfacePutBitsYCbCr; 494 VdpOutputSurfaceRenderOutputSurface vlVdpOutputSurfaceRenderOutputSurface; 495 VdpOutputSurfaceRenderBitmapSurface vlVdpOutputSurfaceRenderBitmapSurface; 496 VdpBitmapSurfaceCreate vlVdpBitmapSurfaceCreate; 497 VdpBitmapSurfaceDestroy vlVdpBitmapSurfaceDestroy; 498 VdpBitmapSurfaceGetParameters vlVdpBitmapSurfaceGetParameters; 499 VdpBitmapSurfacePutBitsNative vlVdpBitmapSurfacePutBitsNative; 500 VdpPresentationQueueTargetDestroy vlVdpPresentationQueueTargetDestroy; 501 VdpPresentationQueueCreate vlVdpPresentationQueueCreate; 502 VdpPresentationQueueDestroy vlVdpPresentationQueueDestroy; 503 VdpPresentationQueueSetBackgroundColor vlVdpPresentationQueueSetBackgroundColor; 504 VdpPresentationQueueGetBackgroundColor vlVdpPresentationQueueGetBackgroundColor; 505 VdpPresentationQueueGetTime vlVdpPresentationQueueGetTime; 506 VdpPresentationQueueDisplay vlVdpPresentationQueueDisplay; 507 VdpPresentationQueueBlockUntilSurfaceIdle vlVdpPresentationQueueBlockUntilSurfaceIdle; 508 VdpPresentationQueueQuerySurfaceStatus vlVdpPresentationQueueQuerySurfaceStatus; 509 VdpPreemptionCallback vlVdpPreemptionCallback; 510 VdpPreemptionCallbackRegister vlVdpPreemptionCallbackRegister; 511 VdpVideoMixerSetFeatureEnables vlVdpVideoMixerSetFeatureEnables; 512 VdpVideoMixerCreate vlVdpVideoMixerCreate; 513 VdpVideoMixerRender vlVdpVideoMixerRender; 514 VdpVideoMixerSetAttributeValues vlVdpVideoMixerSetAttributeValues; 515 VdpVideoMixerGetFeatureSupport vlVdpVideoMixerGetFeatureSupport; 516 VdpVideoMixerGetFeatureEnables vlVdpVideoMixerGetFeatureEnables; 517 VdpVideoMixerGetParameterValues vlVdpVideoMixerGetParameterValues; 518 VdpVideoMixerGetAttributeValues vlVdpVideoMixerGetAttributeValues; 519 VdpVideoMixerDestroy vlVdpVideoMixerDestroy; 520 VdpGenerateCSCMatrix vlVdpGenerateCSCMatrix; 521 /* Winsys specific internal function pointers */ 522 VdpPresentationQueueTargetCreateX11 vlVdpPresentationQueueTargetCreateX11; 523 524 525 /* interop to mesa state tracker */ 526 VdpVideoSurfaceGallium vlVdpVideoSurfaceGallium; 527 VdpOutputSurfaceGallium vlVdpOutputSurfaceGallium; 528 VdpVideoSurfaceDMABuf vlVdpVideoSurfaceDMABuf; 529 VdpOutputSurfaceDMABuf vlVdpOutputSurfaceDMABuf; 530 531 #define VDPAU_OUT 0 532 #define VDPAU_ERR 1 533 #define VDPAU_WARN 2 534 #define VDPAU_TRACE 3 535 536 static inline void VDPAU_MSG(unsigned int level, const char *fmt, ...) 537 { 538 static int debug_level = -1; 539 540 if (debug_level == -1) { 541 debug_level = MAX2(debug_get_num_option("VDPAU_DEBUG", 0), 0); 542 } 543 544 if (level <= debug_level) { 545 va_list ap; 546 va_start(ap, fmt); 547 _debug_vprintf(fmt, ap); 548 va_end(ap); 549 } 550 } 551 552 static inline void 553 DeviceReference(vlVdpDevice **ptr, vlVdpDevice *dev) 554 { 555 vlVdpDevice *old_dev = *ptr; 556 557 if (pipe_reference(&(*ptr)->reference, &dev->reference)) 558 vlVdpDeviceFree(old_dev); 559 *ptr = dev; 560 } 561 562 #endif /* VDPAU_PRIVATE_H */ 563