?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ao_pulse: support native mute control
[mplayer.git] / libvo / vo_vdpau.c
blob0971ae47ea745ca729e240e9a27c0556fb599409
1 /*
2 * VDPAU video output driver
3 *
4 * Copyright (C) 2008 NVIDIA
5 * Copyright (C) 2009 Uoti Urpala
6 *
7 * This file is part of MPlayer.
8 *
9 * MPlayer is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * MPlayer is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License along
20 * with MPlayer; if not, write to the Free Software Foundation, Inc.,
21 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
22 */
23
24 /*
25 * Actual decoding and presentation are implemented here.
26 * All necessary frame information is collected through
27 * the "vdpau_render_state" structure after parsing all headers
28 * etc. in libavcodec for different codecs.
29 */
30
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <stdint.h>
34 #include <stdbool.h>
35 #include <limits.h>
36
37 #include "config.h"
38 #include "mp_msg.h"
39 #include "options.h"
40 #include "talloc.h"
41 #include "video_out.h"
42 #include "x11_common.h"
43 #include "aspect.h"
44 #include "csputils.h"
45 #include "sub/sub.h"
46 #include "subopt-helper.h"
47 #include "libmpcodecs/vfcap.h"
48 #include "libmpcodecs/mp_image.h"
49 #include "osdep/timer.h"
50
51 #include "libavcodec/vdpau.h"
52
53 #include "sub/font_load.h"
54
55 #include "libavutil/common.h"
56 #include "libavutil/mathematics.h"
57
58 #include "sub/ass_mp.h"
59
60 #define WRAP_ADD(x, a, m) ((a) < 0 \
61 ? ((x)+(a)+(m) < (m) ? (x)+(a)+(m) : (x)+(a)) \
62 : ((x)+(a) < (m) ? (x)+(a) : (x)+(a)-(m)))
63
64 #define CHECK_ST_ERROR(message) \
65 do { \
66 if (vdp_st != VDP_STATUS_OK) { \
67 mp_msg(MSGT_VO, MSGL_ERR, "[vdpau] %s: %s\n", \
68 message, vdp->get_error_string(vdp_st)); \
69 return -1; \
70 } \
71 } while (0)
72
73 #define CHECK_ST_WARNING(message) \
74 do { \
75 if (vdp_st != VDP_STATUS_OK) \
76 mp_msg(MSGT_VO, MSGL_WARN, "[ vdpau] %s: %s\n", \
77 message, vdp->get_error_string(vdp_st)); \
78 } while (0)
79
80 /* number of video and output surfaces */
81 #define MAX_OUTPUT_SURFACES 15
82 #define MAX_VIDEO_SURFACES 50
83 #define NUM_BUFFERED_VIDEO 5
84
85 /* number of palette entries */
86 #define PALETTE_SIZE 256
87
88 /* Initial size of EOSD surface in pixels (x*x) */
89 #define EOSD_SURFACE_INITIAL_SIZE 256
90
91 /* Pixelformat used for output surfaces */
92 #define OUTPUT_RGBA_FORMAT VDP_RGBA_FORMAT_B8G8R8A8
93
94 /*
95 * Global variable declaration - VDPAU specific
96 */
97
98 struct vdp_functions {
99 #define VDP_FUNCTION(vdp_type, _, mp_name) vdp_type *mp_name;
100 #include "vdpau_template.c"
101 #undef VDP_FUNCTION
102 };
103
104 struct vdpctx {
105 struct vdp_functions *vdp;
106
107 VdpDevice vdp_device;
108 bool is_preempted;
109 bool preemption_acked;
110 bool preemption_user_notified;
111 unsigned int last_preemption_retry_fail;
112 VdpGetProcAddress *vdp_get_proc_address;
113
114 VdpPresentationQueueTarget flip_target;
115 VdpPresentationQueue flip_queue;
116 uint64_t last_vdp_time;
117 unsigned int last_sync_update;
118
119 /* an extra last output surface is used for OSD and screenshots */
120 VdpOutputSurface output_surfaces[MAX_OUTPUT_SURFACES + 1];
121 int num_output_surfaces;
122 struct buffered_video_surface {
123 VdpVideoSurface surface;
124 double pts;
125 mp_image_t *mpi;
126 } buffered_video[NUM_BUFFERED_VIDEO];
127 int deint_queue_pos;
128 int output_surface_width, output_surface_height;
129
130 VdpVideoMixer video_mixer;
131 struct mp_csp_details colorspace;
132 int deint;
133 int deint_type;
134 int deint_counter;
135 int pullup;
136 float denoise;
137 float sharpen;
138 int hqscaling;
139 int chroma_deint;
140 int flip_offset_window;
141 int flip_offset_fs;
142 int top_field_first;
143 bool flip;
144
145 VdpDecoder decoder;
146 int decoder_max_refs;
147
148 VdpRect src_rect_vid;
149 VdpRect out_rect_vid;
150 int border_x, border_y;
151
152 struct vdpau_render_state surface_render[MAX_VIDEO_SURFACES];
153 int surface_num;
154 int query_surface_num;
155 VdpTime recent_vsync_time;
156 float user_fps;
157 unsigned int vsync_interval;
158 uint64_t last_queue_time;
159 uint64_t queue_time[MAX_OUTPUT_SURFACES];
160 uint64_t last_ideal_time;
161 bool dropped_frame;
162 uint64_t dropped_time;
163 uint32_t vid_width, vid_height;
164 uint32_t vid_d_width, vid_d_height;
165 uint32_t image_format;
166 VdpChromaType vdp_chroma_type;
167 VdpYCbCrFormat vdp_pixel_format;
168
169 /* draw_osd */
170 unsigned char *index_data;
171 int index_data_size;
172 uint32_t palette[PALETTE_SIZE];
173
174 // EOSD
175 // Pool of surfaces
176 struct eosd_bitmap_surface {
177 VdpBitmapSurface surface;
178 int w;
179 int h;
180 uint32_t max_width;
181 uint32_t max_height;
182 } eosd_surface;
183
184 // List of surfaces to be rendered
185 struct eosd_target {
186 VdpRect source;
187 VdpRect dest;
188 VdpColor color;
189 } *eosd_targets;
190 int eosd_targets_size;
191 int *eosd_scratch;
192
193 int eosd_render_count;
194
195 // Video equalizer
196 struct mp_csp_equalizer video_eq;
197
198 // These tell what's been initialized and uninit() should free/uninitialize
199 bool mode_switched;
200 };
201
202 static int change_vdptime_sync(struct vdpctx *vc, unsigned int *t)
203 {
204 struct vdp_functions *vdp = vc->vdp;
205 VdpStatus vdp_st;
206 VdpTime vdp_time;
207 vdp_st = vdp->presentation_queue_get_time(vc->flip_queue, &vdp_time);
208 CHECK_ST_ERROR("Error when calling vdp_presentation_queue_get_time");
209 unsigned int t1 = *t;
210 unsigned int t2 = GetTimer();
211 uint64_t old = vc->last_vdp_time + (t1 - vc->last_sync_update) * 1000ULL;
212 if (vdp_time > old)
213 if (vdp_time > old + (t2 - t1) * 1000ULL)
214 vdp_time -= (t2 - t1) * 1000ULL;
215 else
216 vdp_time = old;
217 mp_msg(MSGT_VO, MSGL_DBG2, "[vdpau] adjusting VdpTime offset by %f µs\n",
218 (int64_t)(vdp_time - old) / 1000.);
219 vc->last_vdp_time = vdp_time;
220 vc->last_sync_update = t1;
221 *t = t2;
222 return 0;
223 }
224
225 static uint64_t sync_vdptime(struct vo *vo)
226 {
227 struct vdpctx *vc = vo->priv;
228
229 unsigned int t = GetTimer();
230 if (t - vc->last_sync_update > 5000000)
231 change_vdptime_sync(vc, &t);
232 uint64_t now = (t - vc->last_sync_update) * 1000ULL + vc->last_vdp_time;
233 // Make sure nanosecond inaccuracies don't make things inconsistent
234 now = FFMAX(now, vc->recent_vsync_time);
235 return now;
236 }
237
238 static uint64_t convert_to_vdptime(struct vo *vo, unsigned int t)
239 {
240 struct vdpctx *vc = vo->priv;
241 return (int)(t - vc->last_sync_update) * 1000LL + vc->last_vdp_time;
242 }
243
244 static int render_video_to_output_surface(struct vo *vo,
245 VdpOutputSurface output_surface,
246 VdpRect *output_rect)
247 {
248 struct vdpctx *vc = vo->priv;
249 struct vdp_functions *vdp = vc->vdp;
250 VdpTime dummy;
251 VdpStatus vdp_st;
252 if (vc->deint_queue_pos < 0)
253 return -1;
254
255 struct buffered_video_surface *bv = vc->buffered_video;
256 int field = VDP_VIDEO_MIXER_PICTURE_STRUCTURE_FRAME;
257 unsigned int dp = vc->deint_queue_pos;
258 // dp==0 means last field of latest frame, 1 earlier field of latest frame,
259 // 2 last field of previous frame and so on
260 if (vc->deint) {
261 field = vc->top_field_first ^ (dp & 1) ?
262 VDP_VIDEO_MIXER_PICTURE_STRUCTURE_BOTTOM_FIELD:
263 VDP_VIDEO_MIXER_PICTURE_STRUCTURE_TOP_FIELD;
264 }
265 const VdpVideoSurface *past_fields = (const VdpVideoSurface []){
266 bv[(dp+1)/2].surface, bv[(dp+2)/2].surface};
267 const VdpVideoSurface *future_fields = (const VdpVideoSurface []){
268 dp >= 1 ? bv[(dp-1)/2].surface : VDP_INVALID_HANDLE};
269 vdp_st = vdp->presentation_queue_block_until_surface_idle(vc->flip_queue,
270 output_surface,
271 &dummy);
272 CHECK_ST_WARNING("Error when calling "
273 "vdp_presentation_queue_block_until_surface_idle");
274
275 vdp_st = vdp->video_mixer_render(vc->video_mixer, VDP_INVALID_HANDLE,
276 0, field, 2, past_fields,
277 bv[dp/2].surface, 1, future_fields,
278 &vc->src_rect_vid, output_surface,
279 NULL, output_rect, 0, NULL);
280 CHECK_ST_WARNING("Error when calling vdp_video_mixer_render");
281 return 0;
282 }
283
284 static int video_to_output_surface(struct vo *vo)
285 {
286 struct vdpctx *vc = vo->priv;
287
288 return render_video_to_output_surface(vo,
289 vc->output_surfaces[vc->surface_num],
290 &vc->out_rect_vid);
291 }
292
293 static int next_deint_queue_pos(struct vo *vo, bool eof)
294 {
295 struct vdpctx *vc = vo->priv;
296
297 int dqp = vc->deint_queue_pos;
298 if (dqp < 0)
299 dqp += 1000;
300 else
301 dqp = vc->deint >= 2 ? dqp - 1 : dqp - 2 | 1;
302 if (dqp < (eof ? 0 : 3))
303 return -1;
304 return dqp;
305 }
306
307 static void set_next_frame_info(struct vo *vo, bool eof)
308 {
309 struct vdpctx *vc = vo->priv;
310
311 vo->frame_loaded = false;
312 int dqp = next_deint_queue_pos(vo, eof);
313 if (dqp < 0)
314 return;
315 vo->frame_loaded = true;
316
317 // Set pts values
318 struct buffered_video_surface *bv = vc->buffered_video;
319 int idx = dqp >> 1;
320 if (idx == 0) { // no future frame/pts available
321 vo->next_pts = bv[0].pts;
322 vo->next_pts2 = MP_NOPTS_VALUE;
323 } else if (!(vc->deint >= 2)) { // no field-splitting deinterlace
324 vo->next_pts = bv[idx].pts;
325 vo->next_pts2 = bv[idx - 1].pts;
326 } else { // deinterlace with separate fields
327 double intermediate_pts;
328 double diff = bv[idx - 1].pts - bv[idx].pts;
329 if (diff > 0 && diff < 0.5)
330 intermediate_pts = (bv[idx].pts + bv[idx - 1].pts) / 2;
331 else
332 intermediate_pts = bv[idx].pts;
333 if (dqp & 1) { // first field
334 vo->next_pts = bv[idx].pts;
335 vo->next_pts2 = intermediate_pts;
336 } else {
337 vo->next_pts = intermediate_pts;
338 vo->next_pts2 = bv[idx - 1].pts;
339 }
340 }
341 }
342
343 static void add_new_video_surface(struct vo *vo, VdpVideoSurface surface,
344 struct mp_image *reserved_mpi, double pts)
345 {
346 struct vdpctx *vc = vo->priv;
347 struct buffered_video_surface *bv = vc->buffered_video;
348
349 if (reserved_mpi)
350 reserved_mpi->usage_count++;
351 if (bv[NUM_BUFFERED_VIDEO - 1].mpi)
352 bv[NUM_BUFFERED_VIDEO - 1].mpi->usage_count--;
353
354 for (int i = NUM_BUFFERED_VIDEO - 1; i > 0; i--)
355 bv[i] = bv[i - 1];
356 bv[0] = (struct buffered_video_surface){
357 .mpi = reserved_mpi,
358 .surface = surface,
359 .pts = pts,
360 };
361
362 vc->deint_queue_pos = FFMIN(vc->deint_queue_pos + 2,
363 NUM_BUFFERED_VIDEO * 2 - 3);
364 set_next_frame_info(vo, false);
365 }
366
367 static void forget_frames(struct vo *vo)
368 {
369 struct vdpctx *vc = vo->priv;
370
371 vc->deint_queue_pos = -1001;
372 vc->dropped_frame = false;
373 for (int i = 0; i < NUM_BUFFERED_VIDEO; i++) {
374 struct buffered_video_surface *p = vc->buffered_video + i;
375 if (p->mpi)
376 p->mpi->usage_count--;
377 *p = (struct buffered_video_surface){
378 .surface = VDP_INVALID_HANDLE,
379 };
380 }
381 }
382
383 static void resize(struct vo *vo)
384 {
385 struct vdpctx *vc = vo->priv;
386 struct vdp_functions *vdp = vc->vdp;
387 VdpStatus vdp_st;
388 int i;
389 struct vo_rect src_rect;
390 struct vo_rect dst_rect;
391 struct vo_rect borders;
392 calc_src_dst_rects(vo, vc->vid_width, vc->vid_height, &src_rect, &dst_rect,
393 &borders, NULL);
394 vc->out_rect_vid.x0 = dst_rect.left;
395 vc->out_rect_vid.x1 = dst_rect.right;
396 vc->out_rect_vid.y0 = dst_rect.top;
397 vc->out_rect_vid.y1 = dst_rect.bottom;
398 vc->src_rect_vid.x0 = src_rect.left;
399 vc->src_rect_vid.x1 = src_rect.right;
400 vc->src_rect_vid.y0 = vc->flip ? src_rect.bottom : src_rect.top;
401 vc->src_rect_vid.y1 = vc->flip ? src_rect.top : src_rect.bottom;
402 vc->border_x = borders.left;
403 vc->border_y = borders.top;
404 #ifdef CONFIG_FREETYPE
405 // adjust font size to display size
406 force_load_font = 1;
407 #endif
408 vo_osd_changed(OSDTYPE_OSD);
409 int flip_offset_ms = vo_fs ? vc->flip_offset_fs : vc->flip_offset_window;
410 vo->flip_queue_offset = flip_offset_ms / 1000.;
411
412 int min_output_width = FFMAX(vo->dwidth, vc->vid_width);
413 int min_output_height = FFMAX(vo->dheight, vc->vid_height);
414
415 if (vc->output_surface_width < min_output_width
416 || vc->output_surface_height < min_output_height) {
417 if (vc->output_surface_width < min_output_width) {
418 vc->output_surface_width += vc->output_surface_width >> 1;
419 vc->output_surface_width = FFMAX(vc->output_surface_width,
420 min_output_width);
421 }
422 if (vc->output_surface_height < min_output_height) {
423 vc->output_surface_height += vc->output_surface_height >> 1;
424 vc->output_surface_height = FFMAX(vc->output_surface_height,
425 min_output_height);
426 }
427 // Creation of output_surfaces
428 for (i = 0; i <= vc->num_output_surfaces; i++) {
429 if (vc->output_surfaces[i] != VDP_INVALID_HANDLE) {
430 vdp_st = vdp->output_surface_destroy(vc->output_surfaces[i]);
431 CHECK_ST_WARNING("Error when calling "
432 "vdp_output_surface_destroy");
433 }
434 vdp_st = vdp->output_surface_create(vc->vdp_device,
435 OUTPUT_RGBA_FORMAT,
436 vc->output_surface_width,
437 vc->output_surface_height,
438 &vc->output_surfaces[i]);
439 CHECK_ST_WARNING("Error when calling vdp_output_surface_create");
440 mp_msg(MSGT_VO, MSGL_DBG2, "vdpau out create: %u\n",
441 vc->output_surfaces[i]);
442 }
443 }
444 vo->want_redraw = true;
445 }
446
447 static void preemption_callback(VdpDevice device, void *context)
448 {
449 struct vdpctx *vc = context;
450 vc->is_preempted = true;
451 vc->preemption_acked = false;
452 }
453
454 /* Initialize vdp_get_proc_address, called from preinit() */
455 static int win_x11_init_vdpau_procs(struct vo *vo)
456 {
457 struct vo_x11_state *x11 = vo->x11;
458 struct vdpctx *vc = vo->priv;
459 talloc_free(vc->vdp); // In case this is reinitialization after preemption
460 struct vdp_functions *vdp = talloc_zero(vc, struct vdp_functions);
461 vc->vdp = vdp;
462 VdpStatus vdp_st;
463
464 struct vdp_function {
465 const int id;
466 int offset;
467 };
468
469 const struct vdp_function *dsc;
470
471 static const struct vdp_function vdp_func[] = {
472 #define VDP_FUNCTION(_, macro_name, mp_name) {macro_name, offsetof(struct vdp_functions, mp_name)},
473 #include "vdpau_template.c"
474 #undef VDP_FUNCTION
475 {0, -1}
476 };
477
478 vdp_st = vdp_device_create_x11(x11->display, x11->screen, &vc->vdp_device,
479 &vc->vdp_get_proc_address);
480 if (vdp_st != VDP_STATUS_OK) {
481 if (vc->is_preempted)
482 mp_msg(MSGT_VO, MSGL_DBG2, "[vdpau] Error calling "
483 "vdp_device_create_x11 while preempted: %d\n", vdp_st);
484 else
485 mp_msg(MSGT_VO, MSGL_ERR, "[vdpau] Error when calling "
486 "vdp_device_create_x11: %d\n", vdp_st);
487 return -1;
488 }
489
490 vdp->get_error_string = NULL;
491 for (dsc = vdp_func; dsc->offset >= 0; dsc++) {
492 vdp_st = vc->vdp_get_proc_address(vc->vdp_device, dsc->id,
493 (void **)((char *)vdp + dsc->offset));
494 if (vdp_st != VDP_STATUS_OK) {
495 mp_msg(MSGT_VO, MSGL_ERR, "[vdpau] Error when calling "
496 "vdp_get_proc_address(function id %d): %s\n", dsc->id,
497 vdp->get_error_string ? vdp->get_error_string(vdp_st) : "?");
498 return -1;
499 }
500 }
501 vdp_st = vdp->preemption_callback_register(vc->vdp_device,
502 preemption_callback, vc);
503 return 0;
504 }
505
506 static int win_x11_init_vdpau_flip_queue(struct vo *vo)
507 {
508 struct vdpctx *vc = vo->priv;
509 struct vdp_functions *vdp = vc->vdp;
510 struct vo_x11_state *x11 = vo->x11;
511 VdpStatus vdp_st;
512
513 if (vc->flip_target == VDP_INVALID_HANDLE) {
514 vdp_st = vdp->presentation_queue_target_create_x11(vc->vdp_device,
515 x11->window,
516 &vc->flip_target);
517 CHECK_ST_ERROR("Error when calling "
518 "vdp_presentation_queue_target_create_x11");
519 }
520
521 /* Emperically this seems to be the first call which fails when we
522 * try to reinit after preemption while the user is still switched
523 * from X to a virtual terminal (creating the vdp_device initially
524 * succeeds, as does creating the flip_target above). This is
525 * probably not guaranteed behavior, but we'll assume it as a simple
526 * way to reduce warnings while trying to recover from preemption.
527 */
528 if (vc->flip_queue == VDP_INVALID_HANDLE) {
529 vdp_st = vdp->presentation_queue_create(vc->vdp_device, vc->flip_target,
530 &vc->flip_queue);
531 if (vc->is_preempted && vdp_st != VDP_STATUS_OK) {
532 mp_msg(MSGT_VO, MSGL_DBG2, "[vdpau] Failed to create flip queue "
533 "while preempted: %s\n", vdp->get_error_string(vdp_st));
534 return -1;
535 } else
536 CHECK_ST_ERROR("Error when calling vdp_presentation_queue_create");
537 }
538
539 VdpTime vdp_time;
540 vdp_st = vdp->presentation_queue_get_time(vc->flip_queue, &vdp_time);
541 CHECK_ST_ERROR("Error when calling vdp_presentation_queue_get_time");
542 vc->last_vdp_time = vdp_time;
543 vc->last_sync_update = GetTimer();
544
545 vc->vsync_interval = 1;
546 if (vc->user_fps > 0) {
547 vc->vsync_interval = 1e9 / vc->user_fps;
548 mp_msg(MSGT_VO, MSGL_INFO, "[vdpau] Assuming user-specified display "
549 "refresh rate of %.3f Hz.\n", vc->user_fps);
550 } else if (vc->user_fps == 0) {
551 #ifdef CONFIG_XF86VM
552 double fps = vo_vm_get_fps(vo);
553 if (!fps)
554 mp_msg(MSGT_VO, MSGL_WARN, "[vdpau] Failed to get display FPS\n");
555 else {
556 vc->vsync_interval = 1e9 / fps;
557 // This is verbose, but I'm not yet sure how common wrong values are
558 mp_msg(MSGT_VO, MSGL_INFO,
559 "[vdpau] Got display refresh rate %.3f Hz.\n"
560 "[vdpau] If that value looks wrong give the "
561 "-vo vdpau:fps=X suboption manually.\n", fps);
562 }
563 #else
564 mp_msg(MSGT_VO, MSGL_INFO, "[vdpau] This binary has been compiled "
565 "without XF86VidMode support.\n");
566 mp_msg(MSGT_VO, MSGL_INFO, "[vdpau] Can't use vsync-aware timing "
567 "without manually provided -vo vdpau:fps=X suboption.\n");
568 #endif
569 } else
570 mp_msg(MSGT_VO, MSGL_V, "[vdpau] framedrop/timing logic disabled by "
571 "user.\n");
572
573 return 0;
574 }
575
576 static int set_video_attribute(struct vdpctx *vc, VdpVideoMixerAttribute attr,
577 const void *value, char *attr_name)
578 {
579 struct vdp_functions *vdp = vc->vdp;
580 VdpStatus vdp_st;
581
582 vdp_st = vdp->video_mixer_set_attribute_values(vc->video_mixer, 1, &attr,
583 &value);
584 if (vdp_st != VDP_STATUS_OK) {
585 mp_msg(MSGT_VO, MSGL_ERR, "[vdpau] Error setting video mixer "
586 "attribute %s: %s\n", attr_name, vdp->get_error_string(vdp_st));
587 return -1;
588 }
589 return 0;
590 }
591
592 static void update_csc_matrix(struct vo *vo)
593 {
594 struct vdpctx *vc = vo->priv;
595
596 mp_msg(MSGT_VO, MSGL_V, "[vdpau] Updating CSC matrix\n");
597
598 // VdpCSCMatrix happens to be compatible with mplayer's CSC matrix type
599 // both are float[3][4]
600 VdpCSCMatrix matrix;
601
602 struct mp_csp_params cparams = {
603 .colorspace = vc->colorspace, .input_bits = 8, .texture_bits = 8 };
604 mp_csp_copy_equalizer_values(&cparams, &vc->video_eq);
605 mp_get_yuv2rgb_coeffs(&cparams, matrix);
606
607 set_video_attribute(vc, VDP_VIDEO_MIXER_ATTRIBUTE_CSC_MATRIX,
608 &matrix, "CSC matrix");
609 }
610
611 #define SET_VIDEO_ATTR(attr_name, attr_type, value) set_video_attribute(vc, \
612 VDP_VIDEO_MIXER_ATTRIBUTE_ ## attr_name, &(attr_type){value},\
613 # attr_name)
614 static int create_vdp_mixer(struct vo *vo, VdpChromaType vdp_chroma_type)
615 {
616 struct vdpctx *vc = vo->priv;
617 struct vdp_functions *vdp = vc->vdp;
618 #define VDP_NUM_MIXER_PARAMETER 3
619 #define MAX_NUM_FEATURES 6
620 int i;
621 VdpStatus vdp_st;
622
623 if (vc->video_mixer != VDP_INVALID_HANDLE)
624 return 0;
625
626 int feature_count = 0;
627 VdpVideoMixerFeature features[MAX_NUM_FEATURES];
628 VdpBool feature_enables[MAX_NUM_FEATURES];
629 static const VdpVideoMixerParameter parameters[VDP_NUM_MIXER_PARAMETER] = {
630 VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_WIDTH,
631 VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_HEIGHT,
632 VDP_VIDEO_MIXER_PARAMETER_CHROMA_TYPE,
633 };
634 const void *const parameter_values[VDP_NUM_MIXER_PARAMETER] = {
635 &vc->vid_width,
636 &vc->vid_height,
637 &vdp_chroma_type,
638 };
639 features[feature_count++] = VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL;
640 if (vc->deint_type == 4)
641 features[feature_count++] =
642 VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL_SPATIAL;
643 if (vc->pullup)
644 features[feature_count++] = VDP_VIDEO_MIXER_FEATURE_INVERSE_TELECINE;
645 if (vc->denoise)
646 features[feature_count++] = VDP_VIDEO_MIXER_FEATURE_NOISE_REDUCTION;
647 if (vc->sharpen)
648 features[feature_count++] = VDP_VIDEO_MIXER_FEATURE_SHARPNESS;
649 if (vc->hqscaling) {
650 VdpVideoMixerFeature hqscaling_feature =
651 VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L1 + vc->hqscaling-1;
652 VdpBool hqscaling_available;
653 vdp_st = vdp->video_mixer_query_feature_support(vc->vdp_device,
654 hqscaling_feature,
655 &hqscaling_available);
656 CHECK_ST_ERROR("Error when calling video_mixer_query_feature_support");
657 if (hqscaling_available)
658 features[feature_count++] = hqscaling_feature;
659 else
660 mp_msg(MSGT_VO, MSGL_ERR, "[vdpau] Your hardware or VDPAU "
661 "library does not support requested hqscaling.\n");
662 }
663
664 vdp_st = vdp->video_mixer_create(vc->vdp_device, feature_count, features,
665 VDP_NUM_MIXER_PARAMETER,
666 parameters, parameter_values,
667 &vc->video_mixer);
668 CHECK_ST_ERROR("Error when calling vdp_video_mixer_create");
669
670 for (i = 0; i < feature_count; i++)
671 feature_enables[i] = VDP_TRUE;
672 if (vc->deint < 3)
673 feature_enables[0] = VDP_FALSE;
674 if (vc->deint_type == 4 && vc->deint < 4)
675 feature_enables[1] = VDP_FALSE;
676 if (feature_count) {
677 vdp_st = vdp->video_mixer_set_feature_enables(vc->video_mixer,
678 feature_count, features,
679 feature_enables);
680 CHECK_ST_WARNING("Error calling vdp_video_mixer_set_feature_enables");
681 }
682 if (vc->denoise)
683 SET_VIDEO_ATTR(NOISE_REDUCTION_LEVEL, float, vc->denoise);
684 if (vc->sharpen)
685 SET_VIDEO_ATTR(SHARPNESS_LEVEL, float, vc->sharpen);
686 if (!vc->chroma_deint)
687 SET_VIDEO_ATTR(SKIP_CHROMA_DEINTERLACE, uint8_t, 1);
688
689 update_csc_matrix(vo);
690 return 0;
691 }
692
693 // Free everything specific to a certain video file
694 static void free_video_specific(struct vo *vo)
695 {
696 struct vdpctx *vc = vo->priv;
697 struct vdp_functions *vdp = vc->vdp;
698 int i;
699 VdpStatus vdp_st;
700
701 if (vc->decoder != VDP_INVALID_HANDLE)
702 vdp->decoder_destroy(vc->decoder);
703 vc->decoder = VDP_INVALID_HANDLE;
704 vc->decoder_max_refs = -1;
705
706 forget_frames(vo);
707
708 for (i = 0; i < MAX_VIDEO_SURFACES; i++) {
709 if (vc->surface_render[i].surface != VDP_INVALID_HANDLE) {
710 vdp_st = vdp->video_surface_destroy(vc->surface_render[i].surface);
711 CHECK_ST_WARNING("Error when calling vdp_video_surface_destroy");
712 }
713 vc->surface_render[i].surface = VDP_INVALID_HANDLE;
714 }
715
716 if (vc->video_mixer != VDP_INVALID_HANDLE) {
717 vdp_st = vdp->video_mixer_destroy(vc->video_mixer);
718 CHECK_ST_WARNING("Error when calling vdp_video_mixer_destroy");
719 }
720 vc->video_mixer = VDP_INVALID_HANDLE;
721 }
722
723 static int create_vdp_decoder(struct vo *vo, int max_refs)
724 {
725 struct vdpctx *vc = vo->priv;
726 struct vdp_functions *vdp = vc->vdp;
727 VdpStatus vdp_st;
728 VdpDecoderProfile vdp_decoder_profile;
729 if (vc->decoder != VDP_INVALID_HANDLE)
730 vdp->decoder_destroy(vc->decoder);
731 switch (vc->image_format) {
732 case IMGFMT_VDPAU_MPEG1:
733 vdp_decoder_profile = VDP_DECODER_PROFILE_MPEG1;
734 break;
735 case IMGFMT_VDPAU_MPEG2:
736 vdp_decoder_profile = VDP_DECODER_PROFILE_MPEG2_MAIN;
737 break;
738 case IMGFMT_VDPAU_H264:
739 vdp_decoder_profile = VDP_DECODER_PROFILE_H264_HIGH;
740 mp_msg(MSGT_VO, MSGL_V, "[vdpau] Creating H264 hardware decoder "
741 "for %d reference frames.\n", max_refs);
742 break;
743 case IMGFMT_VDPAU_WMV3:
744 vdp_decoder_profile = VDP_DECODER_PROFILE_VC1_MAIN;
745 break;
746 case IMGFMT_VDPAU_VC1:
747 vdp_decoder_profile = VDP_DECODER_PROFILE_VC1_ADVANCED;
748 break;
749 case IMGFMT_VDPAU_MPEG4:
750 vdp_decoder_profile = VDP_DECODER_PROFILE_MPEG4_PART2_ASP;
751 break;
752 default:
753 mp_msg(MSGT_VO, MSGL_ERR, "[vdpau] Unknown image format!\n");
754 goto fail;
755 }
756 vdp_st = vdp->decoder_create(vc->vdp_device, vdp_decoder_profile,
757 vc->vid_width, vc->vid_height, max_refs,
758 &vc->decoder);
759 CHECK_ST_WARNING("Failed creating VDPAU decoder");
760 if (vdp_st != VDP_STATUS_OK) {
761 fail:
762 vc->decoder = VDP_INVALID_HANDLE;
763 vc->decoder_max_refs = 0;
764 return 0;
765 }
766 vc->decoder_max_refs = max_refs;
767 return 1;
768 }
769
770 static int initialize_vdpau_objects(struct vo *vo)
771 {
772 struct vdpctx *vc = vo->priv;
773 struct vdp_functions *vdp = vc->vdp;
774 VdpStatus vdp_st;
775
776 vc->vdp_chroma_type = VDP_CHROMA_TYPE_420;
777 switch (vc->image_format) {
778 case IMGFMT_YV12:
779 case IMGFMT_I420:
780 case IMGFMT_IYUV:
781 vc->vdp_pixel_format = VDP_YCBCR_FORMAT_YV12;
782 break;
783 case IMGFMT_NV12:
784 vc->vdp_pixel_format = VDP_YCBCR_FORMAT_NV12;
785 break;
786 case IMGFMT_YUY2:
787 vc->vdp_pixel_format = VDP_YCBCR_FORMAT_YUYV;
788 vc->vdp_chroma_type = VDP_CHROMA_TYPE_422;
789 break;
790 case IMGFMT_UYVY:
791 vc->vdp_pixel_format = VDP_YCBCR_FORMAT_UYVY;
792 vc->vdp_chroma_type = VDP_CHROMA_TYPE_422;
793 }
794 if (win_x11_init_vdpau_flip_queue(vo) < 0)
795 return -1;
796
797 if (create_vdp_mixer(vo, vc->vdp_chroma_type) < 0)
798 return -1;
799
800 vdp_st = vdp->
801 bitmap_surface_query_capabilities(vc->vdp_device,
802 VDP_RGBA_FORMAT_A8,
803 &(VdpBool){0},
804 &vc->eosd_surface.max_width,
805 &vc->eosd_surface.max_height);
806 CHECK_ST_WARNING("Query to get max EOSD surface size failed");
807 forget_frames(vo);
808 resize(vo);
809 return 0;
810 }
811
812 static void mark_vdpau_objects_uninitialized(struct vo *vo)
813 {
814 struct vdpctx *vc = vo->priv;
815
816 vc->decoder = VDP_INVALID_HANDLE;
817 for (int i = 0; i < MAX_VIDEO_SURFACES; i++)
818 vc->surface_render[i].surface = VDP_INVALID_HANDLE;
819 forget_frames(vo);
820 vc->video_mixer = VDP_INVALID_HANDLE;
821 vc->flip_queue = VDP_INVALID_HANDLE;
822 vc->flip_target = VDP_INVALID_HANDLE;
823 for (int i = 0; i <= MAX_OUTPUT_SURFACES; i++)
824 vc->output_surfaces[i] = VDP_INVALID_HANDLE;
825 vc->vdp_device = VDP_INVALID_HANDLE;
826 vc->eosd_surface = (struct eosd_bitmap_surface){
827 .surface = VDP_INVALID_HANDLE,
828 };
829 vc->output_surface_width = vc->output_surface_height = -1;
830 vc->eosd_render_count = 0;
831 }
832
833 static int handle_preemption(struct vo *vo)
834 {
835 struct vdpctx *vc = vo->priv;
836
837 if (!vc->is_preempted)
838 return 0;
839 if (!vc->preemption_acked)
840 mark_vdpau_objects_uninitialized(vo);
841 vc->preemption_acked = true;
842 if (!vc->preemption_user_notified) {
843 mp_tmsg(MSGT_VO, MSGL_ERR, "[vdpau] Got display preemption notice! "
844 "Will attempt to recover.\n");
845 vc->preemption_user_notified = true;
846 }
847 /* Trying to initialize seems to be quite slow, so only try once a
848 * second to avoid using 100% CPU. */
849 if (vc->last_preemption_retry_fail
850 && GetTimerMS() - vc->last_preemption_retry_fail < 1000)
851 return -1;
852 if (win_x11_init_vdpau_procs(vo) < 0 || initialize_vdpau_objects(vo) < 0) {
853 vc->last_preemption_retry_fail = GetTimerMS() | 1;
854 return -1;
855 }
856 vc->last_preemption_retry_fail = 0;
857 vc->is_preempted = false;
858 vc->preemption_user_notified = false;
859 mp_tmsg(MSGT_VO, MSGL_INFO, "[vdpau] Recovered from display preemption.\n");
860 return 1;
861 }
862
863 /*
864 * connect to X server, create and map window, initialize all
865 * VDPAU objects, create different surfaces etc.
866 */
867 static int config(struct vo *vo, uint32_t width, uint32_t height,
868 uint32_t d_width, uint32_t d_height, uint32_t flags,
869 uint32_t format)
870 {
871 struct vdpctx *vc = vo->priv;
872 struct vo_x11_state *x11 = vo->x11;
873 XVisualInfo vinfo;
874 XSetWindowAttributes xswa;
875 XWindowAttributes attribs;
876 unsigned long xswamask;
877 int depth;
878
879 #ifdef CONFIG_XF86VM
880 int vm = flags & VOFLAG_MODESWITCHING;
881 #endif
882
883 if (handle_preemption(vo) < 0)
884 return -1;
885
886 vc->flip = flags & VOFLAG_FLIPPING;
887 vc->image_format = format;
888 vc->vid_width = width;
889 vc->vid_height = height;
890 vc->vid_d_width = d_width;
891 vc->vid_d_height = d_height;
892
893 free_video_specific(vo);
894 if (IMGFMT_IS_VDPAU(vc->image_format) && !create_vdp_decoder(vo, 2))
895 return -1;
896
897 #ifdef CONFIG_XF86VM
898 if (vm) {
899 vo_vm_switch(vo);
900 vc->mode_switched = true;
901 }
902 #endif
903 XGetWindowAttributes(x11->display, DefaultRootWindow(x11->display),
904 &attribs);
905 depth = attribs.depth;
906 if (depth != 15 && depth != 16 && depth != 24 && depth != 32)
907 depth = 24;
908 XMatchVisualInfo(x11->display, x11->screen, depth, TrueColor, &vinfo);
909
910 xswa.background_pixel = 0;
911 xswa.border_pixel = 0;
912 /* Do not use CWBackPixel: It leads to VDPAU errors after
913 * aspect ratio changes. */
914 xswamask = CWBorderPixel;
915
916 vo_x11_create_vo_window(vo, &vinfo, vo->dx, vo->dy, d_width, d_height,
917 flags, CopyFromParent, "vdpau");
918 XChangeWindowAttributes(x11->display, x11->window, xswamask, &xswa);
919
920 #ifdef CONFIG_XF86VM
921 if (vm) {
922 /* Grab the mouse pointer in our window */
923 if (vo_grabpointer)
924 XGrabPointer(x11->display, x11->window, True, 0,
925 GrabModeAsync, GrabModeAsync,
926 x11->window, None, CurrentTime);
927 XSetInputFocus(x11->display, x11->window, RevertToNone, CurrentTime);
928 }
929 #endif
930
931 if ((flags & VOFLAG_FULLSCREEN) && WinID <= 0)
932 vo_fs = 1;
933
934 if (initialize_vdpau_objects(vo) < 0)
935 return -1;
936
937 return 0;
938 }
939
940 static void check_events(struct vo *vo)
941 {
942 if (handle_preemption(vo) < 0)
943 return;
944
945 int e = vo_x11_check_events(vo);
946
947 if (e & VO_EVENT_RESIZE)
948 resize(vo);
949 else if (e & VO_EVENT_EXPOSE) {
950 vo->want_redraw = true;
951 }
952 }
953
954 static void draw_osd_I8A8(void *ctx, int x0, int y0, int w, int h,
955 unsigned char *src, unsigned char *srca, int stride)
956 {
957 struct vo *vo = ctx;
958 struct vdpctx *vc = vo->priv;
959 struct vdp_functions *vdp = vc->vdp;
960 VdpOutputSurface output_surface = vc->output_surfaces[vc->surface_num];
961 VdpStatus vdp_st;
962 int i;
963 int pitch;
964 int index_data_size_required;
965 VdpRect output_indexed_rect_vid;
966
967 if (!w || !h)
968 return;
969
970 index_data_size_required = 2*w*h;
971 if (vc->index_data_size < index_data_size_required) {
972 vc->index_data = talloc_realloc_size(vc, vc->index_data,
973 index_data_size_required);
974 vc->index_data_size = index_data_size_required;
975 }
976
977 // index_data creation, component order - I, A, I, A, .....
978 for (i = 0; i < h; i++)
979 for (int j = 0; j < w; j++) {
980 vc->index_data[i*2*w + j*2] = src [i*stride+j];
981 vc->index_data[i*2*w + j*2 + 1] = -srca[i*stride+j];
982 }
983
984 output_indexed_rect_vid.x0 = x0;
985 output_indexed_rect_vid.y0 = y0;
986 output_indexed_rect_vid.x1 = x0 + w;
987 output_indexed_rect_vid.y1 = y0 + h;
988
989 pitch = w*2;
990
991 // write source_data to osd_surface.
992 VdpOutputSurface osd_surface = vc->output_surfaces[vc->num_output_surfaces];
993 vdp_st = vdp->
994 output_surface_put_bits_indexed(osd_surface, VDP_INDEXED_FORMAT_I8A8,
995 (const void *const*)&vc->index_data,
996 &pitch, &output_indexed_rect_vid,
997 VDP_COLOR_TABLE_FORMAT_B8G8R8X8,
998 (void *)vc->palette);
999 CHECK_ST_WARNING("Error when calling vdp_output_surface_put_bits_indexed");
1000
1001 VdpOutputSurfaceRenderBlendState blend_state = {
1002 .struct_version = VDP_OUTPUT_SURFACE_RENDER_BLEND_STATE_VERSION,
1003 .blend_factor_source_color =
1004 VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE,
1005 .blend_factor_source_alpha =
1006 VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE,
1007 .blend_factor_destination_color =
1008 VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
1009 .blend_factor_destination_alpha =
1010 VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
1011 .blend_equation_color = VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_ADD,
1012 .blend_equation_alpha = VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_ADD,
1013 };
1014
1015 vdp_st = vdp->
1016 output_surface_render_output_surface(output_surface,
1017 &output_indexed_rect_vid,
1018 osd_surface,
1019 &output_indexed_rect_vid,
1020 NULL, &blend_state,
1021 VDP_OUTPUT_SURFACE_RENDER_ROTATE_0);
1022 CHECK_ST_WARNING("Error when calling "
1023 "vdp_output_surface_render_output_surface");
1024 }
1025
1026 static void draw_eosd(struct vo *vo)
1027 {
1028 struct vdpctx *vc = vo->priv;
1029 struct vdp_functions *vdp = vc->vdp;
1030 VdpStatus vdp_st;
1031 VdpOutputSurface output_surface = vc->output_surfaces[vc->surface_num];
1032 int i;
1033
1034 VdpOutputSurfaceRenderBlendState blend_state = {
1035 .struct_version = VDP_OUTPUT_SURFACE_RENDER_BLEND_STATE_VERSION,
1036 .blend_factor_source_color =
1037 VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_SRC_ALPHA,
1038 .blend_factor_source_alpha =
1039 VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE,
1040 .blend_factor_destination_color =
1041 VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
1042 .blend_factor_destination_alpha =
1043 VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_SRC_ALPHA,
1044 .blend_equation_color = VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_ADD,
1045 .blend_equation_alpha = VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_ADD,
1046 };
1047
1048 for (i = 0; i < vc->eosd_render_count; i++) {
1049 vdp_st = vdp->
1050 output_surface_render_bitmap_surface(output_surface,
1051 &vc->eosd_targets[i].dest,
1052 vc->eosd_surface.surface,
1053 &vc->eosd_targets[i].source,
1054 &vc->eosd_targets[i].color,
1055 &blend_state,
1056 VDP_OUTPUT_SURFACE_RENDER_ROTATE_0);
1057 CHECK_ST_WARNING("EOSD: Error when rendering");
1058 }
1059 }
1060
1061 #define HEIGHT_SORT_BITS 4
1062 static int size_index(struct eosd_target *r)
1063 {
1064 unsigned int h = r->source.y1;
1065 int n = av_log2_16bit(h);
1066 return (n << HEIGHT_SORT_BITS)
1067 + (- 1 - (h << HEIGHT_SORT_BITS >> n) & (1 << HEIGHT_SORT_BITS) - 1);
1068 }
1069
1070 /* Pack the given rectangles into an area of size w * h.
1071 * The size of each rectangle is read from .source.x1/.source.y1.
1072 * The height of each rectangle must be at least 1 and less than 65536.
1073 * The .source rectangle is then set corresponding to the packed position.
1074 * 'scratch' must point to work memory for num_rects+16 ints.
1075 * Return 0 on success, -1 if the rectangles did not fit in w*h.
1076 *
1077 * The rectangles are placed in rows in order approximately sorted by
1078 * height (the approximate sorting is simpler than a full one would be,
1079 * and allows the algorithm to work in linear time). Additionally, to
1080 * reduce wasted space when there are a few tall rectangles, empty
1081 * lower-right parts of rows are filled recursively when the size of
1082 * rectangles in the row drops past a power-of-two threshold. So if a
1083 * row starts with rectangles of size 3x50, 10x40 and 5x20 then the
1084 * free rectangle with corners (13, 20)-(w, 50) is filled recursively.
1085 */
1086 static int pack_rectangles(struct eosd_target *rects, int num_rects,
1087 int w, int h, int *scratch)
1088 {
1089 int bins[16 << HEIGHT_SORT_BITS];
1090 int sizes[16 << HEIGHT_SORT_BITS] = {};
1091 for (int i = 0; i < num_rects; i++)
1092 sizes[size_index(rects + i)]++;
1093 int idx = 0;
1094 for (int i = 0; i < 16 << HEIGHT_SORT_BITS; i += 1 << HEIGHT_SORT_BITS) {
1095 for (int j = 0; j < 1 << HEIGHT_SORT_BITS; j++) {
1096 bins[i + j] = idx;
1097 idx += sizes[i + j];
1098 }
1099 scratch[idx++] = -1;
1100 }
1101 for (int i = 0; i < num_rects; i++)
1102 scratch[bins[size_index(rects + i)]++] = i;
1103 for (int i = 0; i < 16; i++)
1104 bins[i] = bins[i << HEIGHT_SORT_BITS] - sizes[i << HEIGHT_SORT_BITS];
1105 struct {
1106 int size, x, bottom;
1107 } stack[16] = {{15, 0, h}}, s = {};
1108 int stackpos = 1;
1109 int y;
1110 while (stackpos) {
1111 y = s.bottom;
1112 s = stack[--stackpos];
1113 s.size++;
1114 while (s.size--) {
1115 int maxy = -1;
1116 int obj;
1117 while ((obj = scratch[bins[s.size]]) >= 0) {
1118 int bottom = y + rects[obj].source.y1;
1119 if (bottom > s.bottom)
1120 break;
1121 int right = s.x + rects[obj].source.x1;
1122 if (right > w)
1123 break;
1124 bins[s.size]++;
1125 rects[obj].source.x0 = s.x;
1126 rects[obj].source.x1 += s.x;
1127 rects[obj].source.y0 = y;
1128 rects[obj].source.y1 += y;
1129 num_rects--;
1130 if (maxy <= 0)
1131 stack[stackpos++] = s;
1132 s.x = right;
1133 maxy = FFMAX(maxy, bottom);
1134 }
1135 if (maxy > 0)
1136 s.bottom = maxy;
1137 }
1138 }
1139 return num_rects ? -1 : 0;
1140 }
1141
1142 static void generate_eosd(struct vo *vo, mp_eosd_images_t *imgs)
1143 {
1144 struct vdpctx *vc = vo->priv;
1145 struct vdp_functions *vdp = vc->vdp;
1146 VdpStatus vdp_st;
1147 int i;
1148 ASS_Image *img = imgs->imgs;
1149 ASS_Image *p;
1150 struct eosd_bitmap_surface *sfc = &vc->eosd_surface;
1151 bool need_upload = false;
1152
1153 if (imgs->changed == 0)
1154 return; // Nothing changed, no need to redraw
1155
1156 vc->eosd_render_count = 0;
1157
1158 if (!img)
1159 return; // There's nothing to render!
1160
1161 if (imgs->changed == 1)
1162 goto eosd_skip_upload;
1163
1164 need_upload = true;
1165 bool reallocate = false;
1166 while (1) {
1167 for (p = img, i = 0; p; p = p->next) {
1168 if (p->w <= 0 || p->h <= 0)
1169 continue;
1170 // Allocate new space for surface/target arrays
1171 if (i >= vc->eosd_targets_size) {
1172 vc->eosd_targets_size = FFMAX(vc->eosd_targets_size * 2, 512);
1173 vc->eosd_targets =
1174 talloc_realloc_size(vc, vc->eosd_targets,
1175 vc->eosd_targets_size
1176 * sizeof(*vc->eosd_targets));
1177 vc->eosd_scratch =
1178 talloc_realloc_size(vc, vc->eosd_scratch,
1179 (vc->eosd_targets_size + 16)
1180 * sizeof(*vc->eosd_scratch));
1181 }
1182 vc->eosd_targets[i].source.x1 = p->w;
1183 vc->eosd_targets[i].source.y1 = p->h;
1184 i++;
1185 }
1186 if (pack_rectangles(vc->eosd_targets, i, sfc->w, sfc->h,
1187 vc->eosd_scratch) >= 0)
1188 break;
1189 int w = FFMIN(FFMAX(sfc->w * 2, EOSD_SURFACE_INITIAL_SIZE),
1190 sfc->max_width);
1191 int h = FFMIN(FFMAX(sfc->h * 2, EOSD_SURFACE_INITIAL_SIZE),
1192 sfc->max_height);
1193 if (w == sfc->w && h == sfc->h) {
1194 mp_msg(MSGT_VO, MSGL_ERR, "[vdpau] EOSD bitmaps do not fit on "
1195 "a surface with the maximum supported size\n");
1196 return;
1197 } else {
1198 sfc->w = w;
1199 sfc->h = h;
1200 }
1201 reallocate = true;
1202 }
1203 if (reallocate) {
1204 if (sfc->surface != VDP_INVALID_HANDLE) {
1205 vdp_st = vdp->bitmap_surface_destroy(sfc->surface);
1206 CHECK_ST_WARNING("Error when calling vdp_bitmap_surface_destroy");
1207 }
1208 mp_msg(MSGT_VO, MSGL_V, "[vdpau] Allocating a %dx%d surface for "
1209 "EOSD bitmaps.\n", sfc->w, sfc->h);
1210 vdp_st = vdp->bitmap_surface_create(vc->vdp_device, VDP_RGBA_FORMAT_A8,
1211 sfc->w, sfc->h, true,
1212 &sfc->surface);
1213 if (vdp_st != VDP_STATUS_OK)
1214 sfc->surface = VDP_INVALID_HANDLE;
1215 CHECK_ST_WARNING("EOSD: error when creating surface");
1216 }
1217
1218 eosd_skip_upload:
1219 if (sfc->surface == VDP_INVALID_HANDLE)
1220 return;
1221 for (p = img; p; p = p->next) {
1222 if (p->w <= 0 || p->h <= 0)
1223 continue;
1224 struct eosd_target *target = &vc->eosd_targets[vc->eosd_render_count];
1225 if (need_upload) {
1226 vdp_st = vdp->
1227 bitmap_surface_put_bits_native(sfc->surface,
1228 (const void *) &p->bitmap,
1229 &p->stride, &target->source);
1230 CHECK_ST_WARNING("EOSD: putbits failed");
1231 }
1232 // Render dest, color, etc.
1233 target->color.alpha = 1.0 - ((p->color >> 0) & 0xff) / 255.0;
1234 target->color.blue = ((p->color >> 8) & 0xff) / 255.0;
1235 target->color.green = ((p->color >> 16) & 0xff) / 255.0;
1236 target->color.red = ((p->color >> 24) & 0xff) / 255.0;
1237 target->dest.x0 = p->dst_x;
1238 target->dest.y0 = p->dst_y;
1239 target->dest.x1 = p->w + p->dst_x;
1240 target->dest.y1 = p->h + p->dst_y;
1241 vc->eosd_render_count++;
1242 }
1243 }
1244
1245 static void draw_osd(struct vo *vo, struct osd_state *osd)
1246 {
1247 struct vdpctx *vc = vo->priv;
1248
1249 if (handle_preemption(vo) < 0)
1250 return;
1251
1252 osd_draw_text_ext(osd, vo->dwidth, vo->dheight, vc->border_x, vc->border_y,
1253 vc->border_x, vc->border_y, vc->vid_width,
1254 vc->vid_height, draw_osd_I8A8, vo);
1255 }
1256
1257 static int update_presentation_queue_status(struct vo *vo)
1258 {
1259 struct vdpctx *vc = vo->priv;
1260 struct vdp_functions *vdp = vc->vdp;
1261 VdpStatus vdp_st;
1262
1263 while (vc->query_surface_num != vc->surface_num) {
1264 VdpTime vtime;
1265 VdpPresentationQueueStatus status;
1266 VdpOutputSurface surface = vc->output_surfaces[vc->query_surface_num];
1267 vdp_st = vdp->presentation_queue_query_surface_status(vc->flip_queue,
1268 surface,
1269 &status, &vtime);
1270 CHECK_ST_WARNING("Error calling "
1271 "presentation_queue_query_surface_status");
1272 if (status == VDP_PRESENTATION_QUEUE_STATUS_QUEUED)
1273 break;
1274 if (vc->vsync_interval > 1) {
1275 uint64_t qtime = vc->queue_time[vc->query_surface_num];
1276 if (vtime < qtime + vc->vsync_interval / 2)
1277 mp_msg(MSGT_VO, MSGL_V, "[vdpau] Frame shown too early\n");
1278 if (vtime > qtime + vc->vsync_interval)
1279 mp_msg(MSGT_VO, MSGL_V, "[vdpau] Frame shown late\n");
1280 }
1281 vc->query_surface_num = WRAP_ADD(vc->query_surface_num, 1,
1282 vc->num_output_surfaces);
1283 vc->recent_vsync_time = vtime;
1284 }
1285 int num_queued = WRAP_ADD(vc->surface_num, -vc->query_surface_num,
1286 vc->num_output_surfaces);
1287 mp_msg(MSGT_VO, MSGL_DBG3, "[vdpau] Queued surface count (before add): "
1288 "%d\n", num_queued);
1289 return num_queued;
1290 }
1291
1292 static inline uint64_t prev_vs2(struct vdpctx *vc, uint64_t ts, int shift)
1293 {
1294 uint64_t offset = ts - vc->recent_vsync_time;
1295 // Fix negative values for 1<<shift vsyncs before vc->recent_vsync_time
1296 offset += (uint64_t)vc->vsync_interval << shift;
1297 offset %= vc->vsync_interval;
1298 return ts - offset;
1299 }
1300
1301 static void flip_page_timed(struct vo *vo, unsigned int pts_us, int duration)
1302 {
1303 struct vdpctx *vc = vo->priv;
1304 struct vdp_functions *vdp = vc->vdp;
1305 VdpStatus vdp_st;
1306 uint32_t vsync_interval = vc->vsync_interval;
1307
1308 if (handle_preemption(vo) < 0)
1309 return;
1310
1311 if (duration > INT_MAX / 1000)
1312 duration = -1;
1313 else
1314 duration *= 1000;
1315
1316 if (vc->user_fps < 0)
1317 duration = -1; // Make sure drop logic is disabled
1318
1319 uint64_t now = sync_vdptime(vo);
1320 uint64_t pts = pts_us ? convert_to_vdptime(vo, pts_us) : now;
1321 uint64_t ideal_pts = pts;
1322 uint64_t npts = duration >= 0 ? pts + duration : UINT64_MAX;
1323
1324 #define PREV_VS2(ts, shift) prev_vs2(vc, ts, shift)
1325 // Only gives accurate results for ts >= vc->recent_vsync_time
1326 #define PREV_VSYNC(ts) PREV_VS2(ts, 0)
1327
1328 /* We hope to be here at least one vsync before the frame should be shown.
1329 * If we are running late then don't drop the frame unless there is
1330 * already one queued for the next vsync; even if we _hope_ to show the
1331 * next frame soon enough to mean this one should be dropped we might
1332 * not make the target time in reality. Without this check we could drop
1333 * every frame, freezing the display completely if video lags behind.
1334 */
1335 if (now > PREV_VSYNC(FFMAX(pts, vc->last_queue_time + vsync_interval)))
1336 npts = UINT64_MAX;
1337
1338 /* Allow flipping a frame at a vsync if its presentation time is a
1339 * bit after that vsync and the change makes the flip time delta
1340 * from previous frame better match the target timestamp delta.
1341 * This avoids instability with frame timestamps falling near vsyncs.
1342 * For example if the frame timestamps were (with vsyncs at
1343 * integer values) 0.01, 1.99, 4.01, 5.99, 8.01, ... then
1344 * straightforward timing at next vsync would flip the frames at
1345 * 1, 2, 5, 6, 9; this changes it to 1, 2, 4, 6, 8 and so on with
1346 * regular 2-vsync intervals.
1347 *
1348 * Also allow moving the frame forward if it looks like we dropped
1349 * the previous frame incorrectly (now that we know better after
1350 * having final exact timestamp information for this frame) and
1351 * there would unnecessarily be a vsync without a frame change.
1352 */
1353 uint64_t vsync = PREV_VSYNC(pts);
1354 if (pts < vsync + vsync_interval / 4
1355 && (vsync - PREV_VS2(vc->last_queue_time, 16)
1356 > pts - vc->last_ideal_time + vsync_interval / 2
1357 || vc->dropped_frame && vsync > vc->dropped_time))
1358 pts -= vsync_interval / 2;
1359
1360 vc->dropped_frame = true; // changed at end if false
1361 vc->dropped_time = ideal_pts;
1362
1363 pts = FFMAX(pts, vc->last_queue_time + vsync_interval);
1364 pts = FFMAX(pts, now);
1365 if (npts < PREV_VSYNC(pts) + vsync_interval)
1366 return;
1367
1368 int num_flips = update_presentation_queue_status(vo);
1369 vsync = vc->recent_vsync_time + num_flips * vc->vsync_interval;
1370 now = sync_vdptime(vo);
1371 pts = FFMAX(pts, now);
1372 pts = FFMAX(pts, vsync + (vsync_interval >> 2));
1373 vsync = PREV_VSYNC(pts);
1374 if (npts < vsync + vsync_interval)
1375 return;
1376 pts = vsync + (vsync_interval >> 2);
1377 vdp_st =
1378 vdp->presentation_queue_display(vc->flip_queue,
1379 vc->output_surfaces[vc->surface_num],
1380 vo->dwidth, vo->dheight, pts);
1381 CHECK_ST_WARNING("Error when calling vdp_presentation_queue_display");
1382
1383 vc->last_queue_time = pts;
1384 vc->queue_time[vc->surface_num] = pts;
1385 vc->last_ideal_time = ideal_pts;
1386 vc->dropped_frame = false;
1387 vc->surface_num = WRAP_ADD(vc->surface_num, 1, vc->num_output_surfaces);
1388 }
1389
1390 static int draw_slice(struct vo *vo, uint8_t *image[], int stride[], int w,
1391 int h, int x, int y)
1392 {
1393 struct vdpctx *vc = vo->priv;
1394 struct vdp_functions *vdp = vc->vdp;
1395 VdpStatus vdp_st;
1396
1397 if (handle_preemption(vo) < 0)
1398 return VO_TRUE;
1399
1400 struct vdpau_render_state *rndr = (struct vdpau_render_state *)image[0];
1401 int max_refs = vc->image_format == IMGFMT_VDPAU_H264 ?
1402 rndr->info.h264.num_ref_frames : 2;
1403 if (!IMGFMT_IS_VDPAU(vc->image_format))
1404 return VO_FALSE;
1405 if ((vc->decoder == VDP_INVALID_HANDLE || vc->decoder_max_refs < max_refs)
1406 && !create_vdp_decoder(vo, max_refs))
1407 return VO_FALSE;
1408
1409 vdp_st = vdp->decoder_render(vc->decoder, rndr->surface,
1410 (void *)&rndr->info,
1411 rndr->bitstream_buffers_used,
1412 rndr->bitstream_buffers);
1413 CHECK_ST_WARNING("Failed VDPAU decoder rendering");
1414 return VO_TRUE;
1415 }
1416
1417
1418 static struct vdpau_render_state *get_surface(struct vo *vo, int number)
1419 {
1420 struct vdpctx *vc = vo->priv;
1421 struct vdp_functions *vdp = vc->vdp;
1422
1423 if (number > MAX_VIDEO_SURFACES)
1424 return NULL;
1425 if (vc->surface_render[number].surface == VDP_INVALID_HANDLE
1426 && !vc->is_preempted) {
1427 VdpStatus vdp_st;
1428 vdp_st = vdp->video_surface_create(vc->vdp_device, vc->vdp_chroma_type,
1429 vc->vid_width, vc->vid_height,
1430 &vc->surface_render[number].surface);
1431 CHECK_ST_WARNING("Error when calling vdp_video_surface_create");
1432 }
1433 mp_msg(MSGT_VO, MSGL_DBG3, "vdpau vid create: %u\n",
1434 vc->surface_render[number].surface);
1435 return &vc->surface_render[number];
1436 }
1437
1438 static void draw_image(struct vo *vo, mp_image_t *mpi, double pts)
1439 {
1440 struct vdpctx *vc = vo->priv;
1441 struct vdp_functions *vdp = vc->vdp;
1442 struct mp_image *reserved_mpi = NULL;
1443 struct vdpau_render_state *rndr;
1444
1445 if (IMGFMT_IS_VDPAU(vc->image_format)) {
1446 rndr = mpi->priv;
1447 reserved_mpi = mpi;
1448 } else if (!(mpi->flags & MP_IMGFLAG_DRAW_CALLBACK)) {
1449 rndr = get_surface(vo, vc->deint_counter);
1450 vc->deint_counter = WRAP_ADD(vc->deint_counter, 1, NUM_BUFFERED_VIDEO);
1451 if (handle_preemption(vo) >= 0) {
1452 VdpStatus vdp_st;
1453 const void *destdata[3] = {mpi->planes[0], mpi->planes[2],
1454 mpi->planes[1]};
1455 if (vc->image_format == IMGFMT_NV12)
1456 destdata[1] = destdata[2];
1457 vdp_st = vdp->video_surface_put_bits_y_cb_cr(rndr->surface,
1458 vc->vdp_pixel_format, destdata, mpi->stride);
1459 CHECK_ST_WARNING("Error when calling "
1460 "vdp_video_surface_put_bits_y_cb_cr");
1461 }
1462 } else
1463 // We don't support slice callbacks so this shouldn't occur -
1464 // I think the flags test above in pointless, but I'm adding
1465 // this instead of removing it just in case.
1466 abort();
1467 if (mpi->fields & MP_IMGFIELD_ORDERED)
1468 vc->top_field_first = !!(mpi->fields & MP_IMGFIELD_TOP_FIRST);
1469 else
1470 vc->top_field_first = 1;
1471
1472 add_new_video_surface(vo, rndr->surface, reserved_mpi, pts);
1473
1474 return;
1475 }
1476
1477 // warning: the size and pixel format of surface must match that of the
1478 // surfaces in vc->output_surfaces
1479 static struct mp_image *read_output_surface(struct vdpctx *vc,
1480 VdpOutputSurface surface)
1481 {
1482 VdpStatus vdp_st;
1483 struct vdp_functions *vdp = vc->vdp;
1484 struct mp_image *image = alloc_mpi(vc->output_surface_width,
1485 vc->output_surface_height, IMGFMT_BGR32);
1486
1487 void *dst_planes[] = { image->planes[0] };
1488 uint32_t dst_pitches[] = { image->stride[0] };
1489 vdp_st = vdp->output_surface_get_bits_native(surface, NULL, dst_planes,
1490 dst_pitches);
1491 CHECK_ST_WARNING("Error when calling vdp_output_surface_get_bits_native");
1492
1493 return image;
1494 }
1495
1496 static struct mp_image *get_screenshot(struct vo *vo)
1497 {
1498 struct vdpctx *vc = vo->priv;
1499
1500 VdpOutputSurface screenshot_surface =
1501 vc->output_surfaces[vc->num_output_surfaces];
1502
1503 VdpRect rc = { .x1 = vc->vid_width, .y1 = vc->vid_height };
1504 render_video_to_output_surface(vo, screenshot_surface, &rc);
1505
1506 struct mp_image *image = read_output_surface(vc, screenshot_surface);
1507
1508 image->width = vc->vid_width;
1509 image->height = vc->vid_height;
1510 image->w = vc->vid_d_width;
1511 image->h = vc->vid_d_height;
1512
1513 return image;
1514 }
1515
1516 static struct mp_image *get_window_screenshot(struct vo *vo)
1517 {
1518 struct vdpctx *vc = vo->priv;
1519 int last_surface = WRAP_ADD(vc->surface_num, -1, vc->num_output_surfaces);
1520 VdpOutputSurface screen = vc->output_surfaces[last_surface];
1521 struct mp_image *image = read_output_surface(vo->priv, screen);
1522 image->width = image->w = vo->dwidth;
1523 image->height = image->h = vo->dheight;
1524 return image;
1525 }
1526
1527 static uint32_t get_image(struct vo *vo, mp_image_t *mpi)
1528 {
1529 struct vdpctx *vc = vo->priv;
1530 struct vdpau_render_state *rndr;
1531
1532 // no dr for non-decoding for now
1533 if (!IMGFMT_IS_VDPAU(vc->image_format))
1534 return VO_FALSE;
1535 if (mpi->type != MP_IMGTYPE_NUMBERED)
1536 return VO_FALSE;
1537
1538 rndr = get_surface(vo, mpi->number);
1539 if (!rndr) {
1540 mp_msg(MSGT_VO, MSGL_ERR, "[vdpau] no surfaces available in "
1541 "get_image\n");
1542 // TODO: this probably breaks things forever, provide a dummy buffer?
1543 return VO_FALSE;
1544 }
1545 mpi->flags |= MP_IMGFLAG_DIRECT;
1546 mpi->stride[0] = mpi->stride[1] = mpi->stride[2] = 0;
1547 mpi->planes[0] = mpi->planes[1] = mpi->planes[2] = NULL;
1548 // hack to get around a check and to avoid a special-case in vd_ffmpeg.c
1549 mpi->planes[0] = (void *)rndr;
1550 mpi->num_planes = 1;
1551 mpi->priv = rndr;
1552 return VO_TRUE;
1553 }
1554
1555 static int query_format(uint32_t format)
1556 {
1557 int default_flags = VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW
1558 | VFCAP_HWSCALE_UP | VFCAP_HWSCALE_DOWN | VFCAP_OSD | VFCAP_EOSD
1559 | VFCAP_EOSD_UNSCALED | VFCAP_FLIP;
1560 switch (format) {
1561 case IMGFMT_YV12:
1562 case IMGFMT_I420:
1563 case IMGFMT_IYUV:
1564 case IMGFMT_NV12:
1565 case IMGFMT_YUY2:
1566 case IMGFMT_UYVY:
1567 return default_flags | VOCAP_NOSLICES;
1568 case IMGFMT_VDPAU_MPEG1:
1569 case IMGFMT_VDPAU_MPEG2:
1570 case IMGFMT_VDPAU_H264:
1571 case IMGFMT_VDPAU_WMV3:
1572 case IMGFMT_VDPAU_VC1:
1573 case IMGFMT_VDPAU_MPEG4:
1574 return default_flags;
1575 }
1576 return 0;
1577 }
1578
1579 static void destroy_vdpau_objects(struct vo *vo)
1580 {
1581 struct vdpctx *vc = vo->priv;
1582 struct vdp_functions *vdp = vc->vdp;
1583
1584 int i;
1585 VdpStatus vdp_st;
1586
1587 free_video_specific(vo);
1588
1589 if (vc->flip_queue != VDP_INVALID_HANDLE) {
1590 vdp_st = vdp->presentation_queue_destroy(vc->flip_queue);
1591 CHECK_ST_WARNING("Error when calling vdp_presentation_queue_destroy");
1592 }
1593
1594 if (vc->flip_target != VDP_INVALID_HANDLE) {
1595 vdp_st = vdp->presentation_queue_target_destroy(vc->flip_target);
1596 CHECK_ST_WARNING("Error when calling "
1597 "vdp_presentation_queue_target_destroy");
1598 }
1599
1600 for (i = 0; i <= vc->num_output_surfaces; i++) {
1601 if (vc->output_surfaces[i] == VDP_INVALID_HANDLE)
1602 continue;
1603 vdp_st = vdp->output_surface_destroy(vc->output_surfaces[i]);
1604 CHECK_ST_WARNING("Error when calling vdp_output_surface_destroy");
1605 }
1606
1607 if (vc->eosd_surface.surface != VDP_INVALID_HANDLE) {
1608 vdp_st = vdp->bitmap_surface_destroy(vc->eosd_surface.surface);
1609 CHECK_ST_WARNING("Error when calling vdp_bitmap_surface_destroy");
1610 }
1611
1612 vdp_st = vdp->device_destroy(vc->vdp_device);
1613 CHECK_ST_WARNING("Error when calling vdp_device_destroy");
1614 }
1615
1616 static void uninit(struct vo *vo)
1617 {
1618 struct vdpctx *vc = vo->priv;
1619
1620 /* Destroy all vdpau objects */
1621 destroy_vdpau_objects(vo);
1622
1623 #ifdef CONFIG_XF86VM
1624 if (vc->mode_switched)
1625 vo_vm_close(vo);
1626 #endif
1627 vo_x11_uninit(vo);
1628
1629 // Free bitstream buffers allocated by FFmpeg
1630 for (int i = 0; i < MAX_VIDEO_SURFACES; i++)
1631 av_freep(&vc->surface_render[i].bitstream_buffers);
1632 }
1633
1634 static int preinit(struct vo *vo, const char *arg)
1635 {
1636 int i;
1637 int user_colorspace = 0;
1638 int studio_levels = 0;
1639
1640 struct vdpctx *vc = talloc_zero(vo, struct vdpctx);
1641 vo->priv = vc;
1642
1643 // Mark everything as invalid first so uninit() can tell what has been
1644 // allocated
1645 mark_vdpau_objects_uninitialized(vo);
1646
1647 vc->colorspace = (struct mp_csp_details) MP_CSP_DETAILS_DEFAULTS;
1648 vc->deint_type = 3;
1649 vc->chroma_deint = 1;
1650 vc->flip_offset_window = 50;
1651 vc->flip_offset_fs = 50;
1652 vc->num_output_surfaces = 3;
1653 vc->video_eq.capabilities = MP_CSP_EQ_CAPS_COLORMATRIX;
1654 const opt_t subopts[] = {
1655 {"deint", OPT_ARG_INT, &vc->deint, NULL},
1656 {"chroma-deint", OPT_ARG_BOOL, &vc->chroma_deint, NULL},
1657 {"pullup", OPT_ARG_BOOL, &vc->pullup, NULL},
1658 {"denoise", OPT_ARG_FLOAT, &vc->denoise, NULL},
1659 {"sharpen", OPT_ARG_FLOAT, &vc->sharpen, NULL},
1660 {"colorspace", OPT_ARG_INT, &user_colorspace, NULL},
1661 {"studio", OPT_ARG_BOOL, &studio_levels, NULL},
1662 {"hqscaling", OPT_ARG_INT, &vc->hqscaling, NULL},
1663 {"fps", OPT_ARG_FLOAT, &vc->user_fps, NULL},
1664 {"queuetime_windowed", OPT_ARG_INT, &vc->flip_offset_window, NULL},
1665 {"queuetime_fs", OPT_ARG_INT, &vc->flip_offset_fs, NULL},
1666 {"output_surfaces", OPT_ARG_INT, &vc->num_output_surfaces, NULL},
1667 {NULL}
1668 };
1669 if (subopt_parse(arg, subopts) != 0) {
1670 mp_msg(MSGT_VO, MSGL_FATAL, "[vdpau] Could not parse suboptions.\n");
1671 return -1;
1672 }
1673 if (vc->hqscaling < 0 || vc->hqscaling > 9) {
1674 mp_msg(MSGT_VO, MSGL_FATAL, "[vdpau] Invalid value for suboption "
1675 "hqscaling\n");
1676 return -1;
1677 }
1678 if (vc->num_output_surfaces < 2) {
1679 mp_msg(MSGT_VO, MSGL_FATAL, "[vdpau] Invalid suboption "
1680 "output_surfaces: can't use less than 2 surfaces\n");
1681 return -1;
1682 }
1683 if (user_colorspace != 0 || studio_levels != 0) {
1684 mp_msg(MSGT_VO, MSGL_ERR, "[vdpau] \"colorspace\" and \"studio\""
1685 " suboptions have been removed. Use options --colormatrix and"
1686 " --colormatrix-output-range=limited instead.\n");
1687 return -1;
1688 }
1689 if (vc->num_output_surfaces > MAX_OUTPUT_SURFACES) {
1690 mp_msg(MSGT_VO, MSGL_WARN, "[vdpau] Number of output surfaces "
1691 "is limited to %d.\n", MAX_OUTPUT_SURFACES);
1692 vc->num_output_surfaces = MAX_OUTPUT_SURFACES;
1693 }
1694 if (vc->deint)
1695 vc->deint_type = FFABS(vc->deint);
1696 if (vc->deint < 0)
1697 vc->deint = 0;
1698
1699 if (!vo_init(vo))
1700 return -1;
1701
1702 // After this calling uninit() should work to free resources
1703
1704 if (win_x11_init_vdpau_procs(vo) < 0) {
1705 if (vc->vdp->device_destroy)
1706 vc->vdp->device_destroy(vc->vdp_device);
1707 vo_x11_uninit(vo);
1708 return -1;
1709 }
1710
1711 // full grayscale palette.
1712 for (i = 0; i < PALETTE_SIZE; ++i)
1713 vc->palette[i] = (i << 16) | (i << 8) | i;
1714
1715 return 0;
1716 }
1717
1718 static int get_equalizer(struct vo *vo, const char *name, int *value)
1719 {
1720 struct vdpctx *vc = vo->priv;
1721 return mp_csp_equalizer_get(&vc->video_eq, name, value) >= 0 ?
1722 VO_TRUE : VO_NOTIMPL;
1723 }
1724
1725 static bool status_ok(struct vo *vo)
1726 {
1727 if (!vo->config_ok || handle_preemption(vo) < 0)
1728 return false;
1729 return true;
1730 }
1731
1732 static int set_equalizer(struct vo *vo, const char *name, int value)
1733 {
1734 struct vdpctx *vc = vo->priv;
1735
1736 if (mp_csp_equalizer_set(&vc->video_eq, name, value) < 0)
1737 return VO_NOTIMPL;
1738
1739 if (status_ok(vo))
1740 update_csc_matrix(vo);
1741 return true;
1742 }
1743
1744 static void checked_resize(struct vo *vo)
1745 {
1746 if (!status_ok(vo))
1747 return;
1748 resize(vo);
1749 }
1750
1751 static int control(struct vo *vo, uint32_t request, void *data)
1752 {
1753 struct vdpctx *vc = vo->priv;
1754 struct vdp_functions *vdp = vc->vdp;
1755
1756 handle_preemption(vo);
1757
1758 switch (request) {
1759 case VOCTRL_GET_DEINTERLACE:
1760 *(int *)data = vc->deint;
1761 return VO_TRUE;
1762 case VOCTRL_SET_DEINTERLACE:
1763 vc->deint = *(int *)data;
1764 if (vc->deint)
1765 vc->deint = vc->deint_type;
1766 if (vc->deint_type > 2 && status_ok(vo)) {
1767 VdpStatus vdp_st;
1768 VdpVideoMixerFeature features[1] =
1769 {vc->deint_type == 3 ?
1770 VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL :
1771 VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL_SPATIAL};
1772 VdpBool feature_enables[1] = {vc->deint ? VDP_TRUE : VDP_FALSE};
1773 vdp_st = vdp->video_mixer_set_feature_enables(vc->video_mixer,
1774 1, features,
1775 feature_enables);
1776 CHECK_ST_WARNING("Error changing deinterlacing settings");
1777 }
1778 vo->want_redraw = true;
1779 return VO_TRUE;
1780 case VOCTRL_PAUSE:
1781 if (vc->dropped_frame)
1782 vo->want_redraw = true;
1783 return true;
1784 case VOCTRL_QUERY_FORMAT:
1785 return query_format(*(uint32_t *)data);
1786 case VOCTRL_GET_IMAGE:
1787 return get_image(vo, data);
1788 case VOCTRL_DRAW_IMAGE:
1789 abort(); // draw_image() should get called directly
1790 case VOCTRL_BORDER:
1791 vo_x11_border(vo);
1792 checked_resize(vo);
1793 return VO_TRUE;
1794 case VOCTRL_FULLSCREEN:
1795 vo_x11_fullscreen(vo);
1796 checked_resize(vo);
1797 return VO_TRUE;
1798 case VOCTRL_GET_PANSCAN:
1799 return VO_TRUE;
1800 case VOCTRL_SET_PANSCAN:
1801 checked_resize(vo);
1802 return VO_TRUE;
1803 case VOCTRL_SET_EQUALIZER: {
1804 vo->want_redraw = true;
1805 struct voctrl_set_equalizer_args *args = data;
1806 return set_equalizer(vo, args->name, args->value);
1807 }
1808 case VOCTRL_GET_EQUALIZER: {
1809 struct voctrl_get_equalizer_args *args = data;
1810 return get_equalizer(vo, args->name, args->valueptr);
1811 }
1812 case VOCTRL_SET_YUV_COLORSPACE:
1813 vc->colorspace = *(struct mp_csp_details *)data;
1814 if (status_ok(vo))
1815 update_csc_matrix(vo);
1816 vo->want_redraw = true;
1817 return true;
1818 case VOCTRL_GET_YUV_COLORSPACE:
1819 *(struct mp_csp_details *)data = vc->colorspace;
1820 return true;
1821 case VOCTRL_ONTOP:
1822 vo_x11_ontop(vo);
1823 return VO_TRUE;
1824 case VOCTRL_UPDATE_SCREENINFO:
1825 update_xinerama_info(vo);
1826 return VO_TRUE;
1827 case VOCTRL_DRAW_EOSD:
1828 if (!data)
1829 return VO_FALSE;
1830 if (status_ok(vo)) {
1831 generate_eosd(vo, data);
1832 draw_eosd(vo);
1833 }
1834 return VO_TRUE;
1835 case VOCTRL_GET_EOSD_RES: {
1836 struct mp_eosd_res *r = data;
1837 r->w = vo->dwidth;
1838 r->h = vo->dheight;
1839 r->ml = r->mr = vc->border_x;
1840 r->mt = r->mb = vc->border_y;
1841 return VO_TRUE;
1842 }
1843 case VOCTRL_NEWFRAME:
1844 vc->deint_queue_pos = next_deint_queue_pos(vo, true);
1845 if (status_ok(vo))
1846 video_to_output_surface(vo);
1847 return true;
1848 case VOCTRL_SKIPFRAME:
1849 vc->deint_queue_pos = next_deint_queue_pos(vo, true);
1850 return true;
1851 case VOCTRL_REDRAW_FRAME:
1852 if (status_ok(vo))
1853 video_to_output_surface(vo);
1854 return true;
1855 case VOCTRL_RESET:
1856 forget_frames(vo);
1857 return true;
1858 case VOCTRL_SCREENSHOT: {
1859 if (!status_ok(vo))
1860 return false;
1861 struct voctrl_screenshot_args *args = data;
1862 if (args->full_window)
1863 args->out_image = get_window_screenshot(vo);
1864 else
1865 args->out_image = get_screenshot(vo);
1866 return true;
1867 }
1868 }
1869 return VO_NOTIMPL;
1870 }
1871
1872 const struct vo_driver video_out_vdpau = {
1873 .is_new = true,
1874 .buffer_frames = true,
1875 .info = &(const struct vo_info_s){
1876 "VDPAU with X11",
1877 "vdpau",
1878 "Rajib Mahapatra <rmahapatra@nvidia.com> and others",
1879 ""
1880 },
1881 .preinit = preinit,
1882 .config = config,
1883 .control = control,
1884 .draw_image = draw_image,
1885 .get_buffered_frame = set_next_frame_info,
1886 .draw_slice = draw_slice,
1887 .draw_osd = draw_osd,
1888 .flip_page_timed = flip_page_timed,
1889 .check_events = check_events,
1890 .uninit = uninit,
1891 };
MPlayer development branch