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