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