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 #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
ChromaToPipe(VdpChromaType vdpau_type)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
PipeToChroma(enum pipe_video_chroma_format pipe_type)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
FormatYCBCRToPipeChroma(VdpYCbCrFormat vdpau_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
FormatYCBCRToPipe(VdpYCbCrFormat vdpau_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
PipeToFormatYCBCR(enum pipe_format p_format)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
PipeToFormatRGBA(enum pipe_format p_format)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
FormatIndexedToPipe(VdpRGBAFormat vdpau_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
FormatColorTableToPipe(VdpColorTableFormat vdpau_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
ProfileToPipe(VdpDecoderProfile vdpau_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
PipeToProfile(enum pipe_video_profile p_profile)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 *
RectToPipe(const VdpRect * src,struct u_rect * dst)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
RectToPipeBox(const VdpRect * rect,struct pipe_resource * res)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
CheckSurfaceParams(struct pipe_screen * screen,const struct pipe_resource * templ)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
VDPAU_MSG(unsigned int level,const char * fmt,...)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
DeviceReference(vlVdpDevice ** ptr,vlVdpDevice * dev)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