libvo/vo_vdpau.c

   1 /*
   2  * VDPAU video output driver
   3  *
   4  * Copyright (C) 2008 NVIDIA
   5  *
   6  * This file is part of MPlayer.
   7  *
   8  * MPlayer is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * MPlayer is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License along
  19  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
  20  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  21  */
  22
  23 /**
  24  * \defgroup  VDPAU_Presentation VDPAU Presentation
  25  * \ingroup Decoder
  26  *
  27  * Actual decoding and presentation are implemented here.
  28  * All necessary frame information is collected through
  29  * the "vdpau_render_state" structure after parsing all headers
  30  * etc. in libavcodec for different codecs.
  31  *
  32  * @{
  33  */
  34
  35 #include <stdio.h>
  36 #include <dlfcn.h>
  37
  38 #include "config.h"
  39 #include "mp_msg.h"
  40 #include "video_out.h"
  41 #include "video_out_internal.h"
  42 #include "x11_common.h"
  43 #include "aspect.h"
  44 #include "sub.h"
  45 #include "subopt-helper.h"
  46
  47 #include "libavcodec/vdpau.h"
  48
  49 #include "gui/interface.h"
  50
  51 #include "libavutil/common.h"
  52
  53 #include "libass/ass.h"
  54 #include "libass/ass_mp.h"
  55
  56 static vo_info_t info = {
  57     "VDPAU with X11",
  58     "vdpau",
  59     "Rajib Mahapatra <rmahapatra@nvidia.com> and others",
  60     ""
  61 };
  62
  63 LIBVO_EXTERN(vdpau)
  64
  65 #define CHECK_ST_ERROR(message) \
  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
  72 #define CHECK_ST_WARNING(message) \
  73     if (vdp_st != VDP_STATUS_OK) \
  74         mp_msg(MSGT_VO, MSGL_WARN, "[vdpau] %s: %s\n", \
  75                message, vdp_get_error_string(vdp_st));
  76
  77 /* number of video and output surfaces */
  78 #define NUM_OUTPUT_SURFACES                2
  79 #define MAX_VIDEO_SURFACES                 50
  80
  81 /* number of palette entries */
  82 #define PALETTE_SIZE 256
  83
  84 /* Initial maximum number of EOSD surfaces */
  85 #define EOSD_SURFACES_INITIAL 512
  86
  87 /*
  88  * Global variable declaration - VDPAU specific
  89  */
  90
  91 /* Declaration for all variables of win_x11_init_vdpau_procs() and
  92  * win_x11_init_vdpau_flip_queue() functions
  93  */
  94 static VdpDevice                          vdp_device;
  95 static VdpDeviceCreateX11                *vdp_device_create;
  96 static VdpGetProcAddress                 *vdp_get_proc_address;
  97
  98 static VdpPresentationQueueTarget         vdp_flip_target;
  99 static VdpPresentationQueue               vdp_flip_queue;
 100
 101 static VdpDeviceDestroy                  *vdp_device_destroy;
 102 static VdpVideoSurfaceCreate             *vdp_video_surface_create;
 103 static VdpVideoSurfaceDestroy            *vdp_video_surface_destroy;
 104
 105 static VdpGetErrorString                 *vdp_get_error_string;
 106
 107 /* May be used in software filtering/postprocessing options
 108  * in MPlayer (./mplayer -vf ..) if we copy video_surface data to
 109  * system memory.
 110  */
 111 static VdpVideoSurfacePutBitsYCbCr       *vdp_video_surface_put_bits_y_cb_cr;
 112 static VdpOutputSurfacePutBitsNative     *vdp_output_surface_put_bits_native;
 113
 114 static VdpOutputSurfaceCreate            *vdp_output_surface_create;
 115 static VdpOutputSurfaceDestroy           *vdp_output_surface_destroy;
 116
 117 /* VideoMixer puts video_surface data on displayable output_surface. */
 118 static VdpVideoMixerCreate               *vdp_video_mixer_create;
 119 static VdpVideoMixerDestroy              *vdp_video_mixer_destroy;
 120 static VdpVideoMixerRender               *vdp_video_mixer_render;
 121 static VdpVideoMixerSetFeatureEnables    *vdp_video_mixer_set_feature_enables;
 122 static VdpVideoMixerSetAttributeValues   *vdp_video_mixer_set_attribute_values;
 123
 124 static VdpPresentationQueueTargetDestroy *vdp_presentation_queue_target_destroy;
 125 static VdpPresentationQueueCreate        *vdp_presentation_queue_create;
 126 static VdpPresentationQueueDestroy       *vdp_presentation_queue_destroy;
 127 static VdpPresentationQueueDisplay       *vdp_presentation_queue_display;
 128 static VdpPresentationQueueBlockUntilSurfaceIdle *vdp_presentation_queue_block_until_surface_idle;
 129 static VdpPresentationQueueTargetCreateX11       *vdp_presentation_queue_target_create_x11;
 130
 131 static VdpOutputSurfaceRenderOutputSurface       *vdp_output_surface_render_output_surface;
 132 static VdpOutputSurfacePutBitsIndexed            *vdp_output_surface_put_bits_indexed;
 133 static VdpOutputSurfaceRenderBitmapSurface       *vdp_output_surface_render_bitmap_surface;
 134
 135 static VdpBitmapSurfaceCreate                    *vdp_bitmap_surface_create;
 136 static VdpBitmapSurfaceDestroy                   *vdp_bitmap_surface_destroy;
 137 static VdpBitmapSurfacePutBitsNative             *vdp_bitmap_surface_putbits_native;
 138
 139 static VdpDecoderCreate                          *vdp_decoder_create;
 140 static VdpDecoderDestroy                         *vdp_decoder_destroy;
 141 static VdpDecoderRender                          *vdp_decoder_render;
 142
 143 static void                              *vdpau_lib_handle;
 144 /* output_surfaces[NUM_OUTPUT_SURFACES] is misused for OSD. */
 145 #define osd_surface output_surfaces[NUM_OUTPUT_SURFACES]
 146 static VdpOutputSurface                   output_surfaces[NUM_OUTPUT_SURFACES + 1];
 147 static int                                output_surface_width, output_surface_height;
 148
 149 static VdpVideoMixer                      video_mixer;
 150 static int                                deint;
 151 static int                                deint_type;
 152 static int                                pullup;
 153 static float                              denoise;
 154 static float                              sharpen;
 155 static int                                top_field_first;
 156
 157 static VdpDecoder                         decoder;
 158 static int                                decoder_max_refs;
 159
 160 static VdpRect                            src_rect_vid;
 161 static VdpRect                            out_rect_vid;
 162 static int                                border_x, border_y;
 163
 164 static struct vdpau_render_state          surface_render[MAX_VIDEO_SURFACES];
 165 static int                                surface_num;
 166 static int                                vid_surface_num;
 167 static uint32_t                           vid_width, vid_height;
 168 static uint32_t                           image_format;
 169 static const VdpChromaType                vdp_chroma_type = VDP_CHROMA_TYPE_420;
 170
 171 /* draw_osd */
 172 static unsigned char                     *index_data;
 173 static int                                index_data_size;
 174 static uint32_t                           palette[PALETTE_SIZE];
 175
 176 // EOSD
 177 // Pool of surfaces
 178 struct {
 179     VdpBitmapSurface surface;
 180     int w;
 181     int h;
 182     char in_use;
 183 } *eosd_surfaces;
 184
 185 // List of surfaces to be rendered
 186 struct {
 187     VdpBitmapSurface surface;
 188     VdpRect source;
 189     VdpRect dest;
 190     VdpColor color;
 191 } *eosd_targets;
 192
 193 static int eosd_render_count;
 194 static int eosd_surface_count;
 195
 196 /*
 197  * X11 specific
 198  */
 199 static int                                visible_buf;
 200 static int                                int_pause;
 201
 202 static void video_to_output_surface(void)
 203 {
 204     VdpTime dummy;
 205     VdpStatus vdp_st;
 206     int i;
 207     if (vid_surface_num < 0)
 208         return;
 209
 210     // we would need to provide 2 past and 1 future frames to allow advanced
 211     // deinterlacing, which is not really possible currently.
 212     for (i = 0; i <= !!(deint > 1); i++) {
 213         int field = VDP_VIDEO_MIXER_PICTURE_STRUCTURE_FRAME;
 214         VdpOutputSurface output_surface;
 215         if (i)
 216             flip_page();
 217         if (deint)
 218             field = top_field_first == i ?
 219                     VDP_VIDEO_MIXER_PICTURE_STRUCTURE_BOTTOM_FIELD:
 220                     VDP_VIDEO_MIXER_PICTURE_STRUCTURE_TOP_FIELD;
 221         output_surface = output_surfaces[surface_num];
 222         vdp_st = vdp_presentation_queue_block_until_surface_idle(vdp_flip_queue,
 223                                                                  output_surface,
 224                                                                  &dummy);
 225         CHECK_ST_WARNING("Error when calling vdp_presentation_queue_block_until_surface_idle")
 226
 227         vdp_st = vdp_video_mixer_render(video_mixer, VDP_INVALID_HANDLE, 0,
 228                                         field, 0, NULL,
 229                                         surface_render[vid_surface_num].surface,
 230                                         0, NULL, &src_rect_vid,
 231                                         output_surface,
 232                                         NULL, &out_rect_vid, 0, NULL);
 233         CHECK_ST_WARNING("Error when calling vdp_video_mixer_render")
 234     }
 235 }
 236
 237 static void resize(void)
 238 {
 239     VdpStatus vdp_st;
 240     int i;
 241     struct vo_rect src_rect;
 242     struct vo_rect dst_rect;
 243     struct vo_rect borders;
 244     calc_src_dst_rects(vid_width, vid_height, &src_rect, &dst_rect, &borders, NULL);
 245     out_rect_vid.x0 = dst_rect.left;
 246     out_rect_vid.x1 = dst_rect.right;
 247     out_rect_vid.y0 = dst_rect.top;
 248     out_rect_vid.y1 = dst_rect.bottom;
 249     src_rect_vid.x0 = src_rect.left;
 250     src_rect_vid.x1 = src_rect.right;
 251     src_rect_vid.y0 = src_rect.top;
 252     src_rect_vid.y1 = src_rect.bottom;
 253     border_x        = borders.left;
 254     border_y        = borders.top;
 255 #ifdef CONFIG_FREETYPE
 256     // adjust font size to display size
 257     force_load_font = 1;
 258 #endif
 259     vo_osd_changed(OSDTYPE_OSD);
 260
 261     if (output_surface_width < vo_dwidth || output_surface_height < vo_dheight) {
 262         if (output_surface_width < vo_dwidth) {
 263             output_surface_width += output_surface_width >> 1;
 264             output_surface_width = FFMAX(output_surface_width, vo_dwidth);
 265         }
 266         if (output_surface_height < vo_dheight) {
 267             output_surface_height += output_surface_height >> 1;
 268             output_surface_height = FFMAX(output_surface_height, vo_dheight);
 269         }
 270         // Creation of output_surfaces
 271         for (i = 0; i <= NUM_OUTPUT_SURFACES; i++) {
 272             if (output_surfaces[i] != VDP_INVALID_HANDLE)
 273                 vdp_output_surface_destroy(output_surfaces[i]);
 274             vdp_st = vdp_output_surface_create(vdp_device, VDP_RGBA_FORMAT_B8G8R8A8,
 275                                                output_surface_width, output_surface_height,
 276                                                &output_surfaces[i]);
 277             CHECK_ST_WARNING("Error when calling vdp_output_surface_create")
 278             mp_msg(MSGT_VO, MSGL_DBG2, "OUT CREATE: %u\n", output_surfaces[i]);
 279         }
 280     }
 281     video_to_output_surface();
 282     if (visible_buf)
 283         flip_page();
 284 }
 285
 286 /* Initialize vdp_get_proc_address, called from preinit() */
 287 static int win_x11_init_vdpau_procs(void)
 288 {
 289     VdpStatus vdp_st;
 290
 291     struct vdp_function {
 292         const int id;
 293         void *pointer;
 294     };
 295
 296     const struct vdp_function *dsc;
 297
 298     static const struct vdp_function vdp_func[] = {
 299         {VDP_FUNC_ID_GET_ERROR_STRING,          &vdp_get_error_string},
 300         {VDP_FUNC_ID_DEVICE_DESTROY,            &vdp_device_destroy},
 301         {VDP_FUNC_ID_VIDEO_SURFACE_CREATE,      &vdp_video_surface_create},
 302         {VDP_FUNC_ID_VIDEO_SURFACE_DESTROY,     &vdp_video_surface_destroy},
 303         {VDP_FUNC_ID_VIDEO_SURFACE_PUT_BITS_Y_CB_CR,
 304                         &vdp_video_surface_put_bits_y_cb_cr},
 305         {VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_NATIVE,
 306                         &vdp_output_surface_put_bits_native},
 307         {VDP_FUNC_ID_OUTPUT_SURFACE_CREATE,     &vdp_output_surface_create},
 308         {VDP_FUNC_ID_OUTPUT_SURFACE_DESTROY,    &vdp_output_surface_destroy},
 309         {VDP_FUNC_ID_VIDEO_MIXER_CREATE, &vdp_video_mixer_create},
 310         {VDP_FUNC_ID_VIDEO_MIXER_DESTROY,       &vdp_video_mixer_destroy},
 311         {VDP_FUNC_ID_VIDEO_MIXER_RENDER,        &vdp_video_mixer_render},
 312         {VDP_FUNC_ID_VIDEO_MIXER_SET_FEATURE_ENABLES,
 313                         &vdp_video_mixer_set_feature_enables},
 314         {VDP_FUNC_ID_VIDEO_MIXER_SET_ATTRIBUTE_VALUES,
 315                         &vdp_video_mixer_set_attribute_values},
 316         {VDP_FUNC_ID_PRESENTATION_QUEUE_TARGET_DESTROY,
 317                         &vdp_presentation_queue_target_destroy},
 318         {VDP_FUNC_ID_PRESENTATION_QUEUE_CREATE, &vdp_presentation_queue_create},
 319         {VDP_FUNC_ID_PRESENTATION_QUEUE_DESTROY,
 320                         &vdp_presentation_queue_destroy},
 321         {VDP_FUNC_ID_PRESENTATION_QUEUE_DISPLAY,
 322                         &vdp_presentation_queue_display},
 323         {VDP_FUNC_ID_PRESENTATION_QUEUE_BLOCK_UNTIL_SURFACE_IDLE,
 324                         &vdp_presentation_queue_block_until_surface_idle},
 325         {VDP_FUNC_ID_PRESENTATION_QUEUE_TARGET_CREATE_X11,
 326                         &vdp_presentation_queue_target_create_x11},
 327         {VDP_FUNC_ID_OUTPUT_SURFACE_RENDER_OUTPUT_SURFACE,
 328                         &vdp_output_surface_render_output_surface},
 329         {VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_INDEXED,
 330                         &vdp_output_surface_put_bits_indexed},
 331         {VDP_FUNC_ID_DECODER_CREATE,            &vdp_decoder_create},
 332         {VDP_FUNC_ID_DECODER_RENDER,            &vdp_decoder_render},
 333         {VDP_FUNC_ID_DECODER_DESTROY,           &vdp_decoder_destroy},
 334         {VDP_FUNC_ID_BITMAP_SURFACE_CREATE,     &vdp_bitmap_surface_create},
 335         {VDP_FUNC_ID_BITMAP_SURFACE_DESTROY,    &vdp_bitmap_surface_destroy},
 336         {VDP_FUNC_ID_BITMAP_SURFACE_PUT_BITS_NATIVE,
 337                         &vdp_bitmap_surface_putbits_native},
 338         {VDP_FUNC_ID_OUTPUT_SURFACE_RENDER_BITMAP_SURFACE,
 339                         &vdp_output_surface_render_bitmap_surface},
 340         {0, NULL}
 341     };
 342
 343     vdp_st = vdp_device_create(mDisplay, mScreen,
 344                                &vdp_device, &vdp_get_proc_address);
 345     if (vdp_st != VDP_STATUS_OK) {
 346         mp_msg(MSGT_VO, MSGL_ERR, "[vdpau] Error when calling vdp_device_create_x11: %i\n", vdp_st);
 347         return -1;
 348     }
 349
 350     for (dsc = vdp_func; dsc->pointer; dsc++) {
 351         vdp_st = vdp_get_proc_address(vdp_device, dsc->id, dsc->pointer);
 352         if (vdp_st != VDP_STATUS_OK) {
 353             mp_msg(MSGT_VO, MSGL_ERR, "[vdpau] Error when calling vdp_get_proc_address(function id %d): %s\n", dsc->id, vdp_get_error_string ? vdp_get_error_string(vdp_st) : "?");
 354             return -1;
 355         }
 356     }
 357     return 0;
 358 }
 359
 360 /* Initialize vdpau_flip_queue, called from config() */
 361 static int win_x11_init_vdpau_flip_queue(void)
 362 {
 363     VdpStatus vdp_st;
 364
 365     vdp_st = vdp_presentation_queue_target_create_x11(vdp_device, vo_window,
 366                                                       &vdp_flip_target);
 367     CHECK_ST_ERROR("Error when calling vdp_presentation_queue_target_create_x11")
 368
 369     vdp_st = vdp_presentation_queue_create(vdp_device, vdp_flip_target,
 370                                            &vdp_flip_queue);
 371     CHECK_ST_ERROR("Error when calling vdp_presentation_queue_create")
 372
 373     return 0;
 374 }
 375
 376 static int create_vdp_mixer(VdpChromaType vdp_chroma_type) {
 377 #define VDP_NUM_MIXER_PARAMETER 3
 378 #define MAX_NUM_FEATURES 5
 379     int i;
 380     VdpStatus vdp_st;
 381     int feature_count = 0;
 382     VdpVideoMixerFeature features[MAX_NUM_FEATURES];
 383     VdpBool feature_enables[MAX_NUM_FEATURES];
 384     static const VdpVideoMixerAttribute denoise_attrib[] = {VDP_VIDEO_MIXER_ATTRIBUTE_NOISE_REDUCTION_LEVEL};
 385     const void * const denoise_value[] = {&denoise};
 386     static const VdpVideoMixerAttribute sharpen_attrib[] = {VDP_VIDEO_MIXER_ATTRIBUTE_SHARPNESS_LEVEL};
 387     const void * const sharpen_value[] = {&sharpen};
 388     static const VdpVideoMixerParameter parameters[VDP_NUM_MIXER_PARAMETER] = {
 389         VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_WIDTH,
 390         VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_HEIGHT,
 391         VDP_VIDEO_MIXER_PARAMETER_CHROMA_TYPE
 392     };
 393     const void *const parameter_values[VDP_NUM_MIXER_PARAMETER] = {
 394         &vid_width,
 395         &vid_height,
 396         &vdp_chroma_type
 397     };
 398     if (deint == 3)
 399         features[feature_count++] = VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL;
 400     if (deint == 4)
 401         features[feature_count++] = VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL_SPATIAL;
 402     if (pullup)
 403         features[feature_count++] = VDP_VIDEO_MIXER_FEATURE_INVERSE_TELECINE;
 404     if (denoise)
 405         features[feature_count++] = VDP_VIDEO_MIXER_FEATURE_NOISE_REDUCTION;
 406     if (sharpen)
 407         features[feature_count++] = VDP_VIDEO_MIXER_FEATURE_SHARPNESS;
 408
 409     vdp_st = vdp_video_mixer_create(vdp_device, feature_count, features,
 410                                     VDP_NUM_MIXER_PARAMETER,
 411                                     parameters, parameter_values,
 412                                     &video_mixer);
 413     CHECK_ST_ERROR("Error when calling vdp_video_mixer_create")
 414
 415     for (i = 0; i < feature_count; i++) feature_enables[i] = VDP_TRUE;
 416     if (feature_count)
 417         vdp_video_mixer_set_feature_enables(video_mixer, feature_count, features, feature_enables);
 418     if (denoise)
 419         vdp_video_mixer_set_attribute_values(video_mixer, 1, denoise_attrib, denoise_value);
 420     if (sharpen)
 421         vdp_video_mixer_set_attribute_values(video_mixer, 1, sharpen_attrib, sharpen_value);
 422
 423     return 0;
 424 }
 425
 426 // Free everything specific to a certain video file
 427 static void free_video_specific(void) {
 428     int i;
 429     VdpStatus vdp_st;
 430
 431     if (decoder != VDP_INVALID_HANDLE)
 432         vdp_decoder_destroy(decoder);
 433     decoder = VDP_INVALID_HANDLE;
 434     decoder_max_refs = -1;
 435
 436     for (i = 0; i < MAX_VIDEO_SURFACES; i++) {
 437         if (surface_render[i].surface != VDP_INVALID_HANDLE) {
 438           vdp_st = vdp_video_surface_destroy(surface_render[i].surface);
 439           CHECK_ST_WARNING("Error when calling vdp_video_surface_destroy")
 440         }
 441         surface_render[i].surface = VDP_INVALID_HANDLE;
 442     }
 443
 444     if (video_mixer != VDP_INVALID_HANDLE) {
 445         vdp_st = vdp_video_mixer_destroy(video_mixer);
 446         CHECK_ST_WARNING("Error when calling vdp_video_mixer_destroy")
 447     }
 448     video_mixer = VDP_INVALID_HANDLE;
 449 }
 450
 451 /*
 452  * connect to X server, create and map window, initialize all
 453  * VDPAU objects, create different surfaces etc.
 454  */
 455 static int config(uint32_t width, uint32_t height, uint32_t d_width,
 456                   uint32_t d_height, uint32_t flags, char *title,
 457                   uint32_t format)
 458 {
 459     XVisualInfo vinfo;
 460     XSetWindowAttributes xswa;
 461     XWindowAttributes attribs;
 462     unsigned long xswamask;
 463     int depth;
 464
 465 #ifdef CONFIG_XF86VM
 466     int vm = flags & VOFLAG_MODESWITCHING;
 467 #endif
 468
 469     image_format = format;
 470
 471     int_pause = 0;
 472     visible_buf = 0;
 473
 474 #ifdef CONFIG_GUI
 475     if (use_gui)
 476         guiGetEvent(guiSetShVideo, 0);  // the GUI will set up / resize our window
 477     else
 478 #endif
 479     {
 480 #ifdef CONFIG_XF86VM
 481         if (vm)
 482             vo_vm_switch();
 483         else
 484 #endif
 485         XGetWindowAttributes(mDisplay, DefaultRootWindow(mDisplay), &attribs);
 486         depth = attribs.depth;
 487         if (depth != 15 && depth != 16 && depth != 24 && depth != 32)
 488             depth = 24;
 489         XMatchVisualInfo(mDisplay, mScreen, depth, TrueColor, &vinfo);
 490
 491         xswa.background_pixel = 0;
 492         xswa.border_pixel     = 0;
 493         xswamask = CWBackPixel | CWBorderPixel;
 494
 495         vo_x11_create_vo_window(&vinfo, vo_dx, vo_dy, d_width, d_height,
 496                                 flags, CopyFromParent, "vdpau", title);
 497         XChangeWindowAttributes(mDisplay, vo_window, xswamask, &xswa);
 498
 499 #ifdef CONFIG_XF86VM
 500         if (vm) {
 501             /* Grab the mouse pointer in our window */
 502             if (vo_grabpointer)
 503                 XGrabPointer(mDisplay, vo_window, True, 0,
 504                              GrabModeAsync, GrabModeAsync,
 505                              vo_window, None, CurrentTime);
 506             XSetInputFocus(mDisplay, vo_window, RevertToNone, CurrentTime);
 507         }
 508 #endif
 509     }
 510
 511     if ((flags & VOFLAG_FULLSCREEN) && WinID <= 0)
 512         vo_fs = 1;
 513
 514     /* -----VDPAU related code here -------- */
 515
 516     free_video_specific();
 517
 518     if (vdp_flip_queue == VDP_INVALID_HANDLE && win_x11_init_vdpau_flip_queue())
 519         return -1;
 520
 521     // video width and height
 522     vid_width  = width;
 523     vid_height = height;
 524
 525     if (create_vdp_mixer(vdp_chroma_type))
 526         return -1;
 527
 528     surface_num = 0;
 529     vid_surface_num = -1;
 530     resize();
 531
 532     return 0;
 533 }
 534
 535 static void check_events(void)
 536 {
 537     int e = vo_x11_check_events(mDisplay);
 538
 539     if (e & VO_EVENT_RESIZE)
 540         resize();
 541
 542     if ((e & VO_EVENT_EXPOSE || e & VO_EVENT_RESIZE) && int_pause) {
 543         /* did we already draw a buffer */
 544         if (visible_buf) {
 545             /* redraw the last visible buffer */
 546             VdpStatus vdp_st;
 547             vdp_st = vdp_presentation_queue_display(vdp_flip_queue,
 548                                                     output_surfaces[surface_num],
 549                                                     vo_dwidth, vo_dheight,
 550                                                     0);
 551             CHECK_ST_WARNING("Error when calling vdp_presentation_queue_display")
 552         }
 553     }
 554 }
 555
 556 static void draw_osd_I8A8(int x0,int y0, int w,int h, unsigned char *src,
 557                           unsigned char *srca, int stride)
 558 {
 559     VdpOutputSurface output_surface = output_surfaces[surface_num];
 560     VdpStatus vdp_st;
 561     int i, j;
 562     int pitch;
 563     int index_data_size_required;
 564     VdpRect output_indexed_rect_vid;
 565     VdpOutputSurfaceRenderBlendState blend_state;
 566
 567     if (!w || !h)
 568         return;
 569
 570     index_data_size_required = 2*w*h;
 571     if (index_data_size < index_data_size_required) {
 572         index_data      = realloc(index_data, index_data_size_required);
 573         index_data_size = index_data_size_required;
 574     }
 575
 576     // index_data creation, component order - I, A, I, A, .....
 577     for (i = 0; i < h; i++)
 578         for (j = 0; j < w; j++) {
 579             index_data[i*2*w + j*2]     =  src [i*stride+j];
 580             index_data[i*2*w + j*2 + 1] = -srca[i*stride+j];
 581         }
 582
 583     output_indexed_rect_vid.x0 = x0;
 584     output_indexed_rect_vid.y0 = y0;
 585     output_indexed_rect_vid.x1 = x0 + w;
 586     output_indexed_rect_vid.y1 = y0 + h;
 587
 588     pitch = w*2;
 589
 590     // write source_data to osd_surface.
 591     vdp_st = vdp_output_surface_put_bits_indexed(osd_surface,
 592                                                  VDP_INDEXED_FORMAT_I8A8,
 593                                                  (const void *const*)&index_data,
 594                                                  &pitch,
 595                                                  &output_indexed_rect_vid,
 596                                                  VDP_COLOR_TABLE_FORMAT_B8G8R8X8,
 597                                                  (void *)palette);
 598     CHECK_ST_WARNING("Error when calling vdp_output_surface_put_bits_indexed")
 599
 600     blend_state.struct_version                 = VDP_OUTPUT_SURFACE_RENDER_BLEND_STATE_VERSION;
 601     blend_state.blend_factor_source_color      = VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE;
 602     blend_state.blend_factor_source_alpha      = VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE;
 603     blend_state.blend_factor_destination_color = VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
 604     blend_state.blend_factor_destination_alpha = VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
 605     blend_state.blend_equation_color           = VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_ADD;
 606     blend_state.blend_equation_alpha           = VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_ADD;
 607
 608     vdp_st = vdp_output_surface_render_output_surface(output_surface,
 609                                                       &output_indexed_rect_vid,
 610                                                       osd_surface,
 611                                                       &output_indexed_rect_vid,
 612                                                       NULL,
 613                                                       &blend_state,
 614                                                       VDP_OUTPUT_SURFACE_RENDER_ROTATE_0);
 615     CHECK_ST_WARNING("Error when calling vdp_output_surface_render_output_surface")
 616 }
 617
 618 static void draw_eosd(void) {
 619     VdpStatus vdp_st;
 620     VdpOutputSurface output_surface = output_surfaces[surface_num];
 621     VdpOutputSurfaceRenderBlendState blend_state;
 622     int i;
 623
 624     blend_state.struct_version                 = VDP_OUTPUT_SURFACE_RENDER_BLEND_STATE_VERSION;
 625     blend_state.blend_factor_source_color      = VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_SRC_ALPHA;
 626     blend_state.blend_factor_source_alpha      = VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE;
 627     blend_state.blend_factor_destination_color = VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
 628     blend_state.blend_factor_destination_alpha = VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_SRC_ALPHA;
 629     blend_state.blend_equation_color           = VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_ADD;
 630     blend_state.blend_equation_alpha           = VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_ADD;
 631
 632     for (i=0; i<eosd_render_count; i++) {
 633         vdp_st = vdp_output_surface_render_bitmap_surface(
 634             output_surface, &eosd_targets[i].dest,
 635             eosd_targets[i].surface, &eosd_targets[i].source,
 636             &eosd_targets[i].color, &blend_state,
 637             VDP_OUTPUT_SURFACE_RENDER_ROTATE_0);
 638         CHECK_ST_WARNING("EOSD: Error when rendering")
 639     }
 640 }
 641
 642 static void generate_eosd(mp_eosd_images_t *imgs) {
 643     VdpStatus vdp_st;
 644     VdpRect destRect;
 645     int j, found;
 646     ass_image_t *img = imgs->imgs;
 647     ass_image_t *i;
 648
 649     // Nothing changed, no need to redraw
 650     if (imgs->changed == 0)
 651         return;
 652     eosd_render_count = 0;
 653     // There's nothing to render!
 654     if (!img)
 655         return;
 656
 657     if (imgs->changed == 1)
 658         goto eosd_skip_upload;
 659
 660     for (j=0; j<eosd_surface_count; j++)
 661         eosd_surfaces[j].in_use = 0;
 662
 663     for (i = img; i; i = i->next) {
 664         // Try to reuse a suitable surface
 665         found = -1;
 666         for (j=0; j<eosd_surface_count; j++) {
 667             if (eosd_surfaces[j].surface != VDP_INVALID_HANDLE && !eosd_surfaces[j].in_use &&
 668                 eosd_surfaces[j].w >= i->w && eosd_surfaces[j].h >= i->h) {
 669                 found = j;
 670                 break;
 671             }
 672         }
 673         // None found, allocate a new surface
 674         if (found < 0) {
 675             for (j=0; j<eosd_surface_count; j++) {
 676                 if (!eosd_surfaces[j].in_use) {
 677                     if (eosd_surfaces[j].surface != VDP_INVALID_HANDLE)
 678                         vdp_bitmap_surface_destroy(eosd_surfaces[j].surface);
 679                     found = j;
 680                     break;
 681                 }
 682             }
 683             // Allocate new space for surface/target arrays
 684             if (found < 0) {
 685                 j = found = eosd_surface_count;
 686                 eosd_surface_count = eosd_surface_count ? eosd_surface_count*2 : EOSD_SURFACES_INITIAL;
 687                 eosd_surfaces = realloc(eosd_surfaces, eosd_surface_count * sizeof(*eosd_surfaces));
 688                 eosd_targets  = realloc(eosd_targets,  eosd_surface_count * sizeof(*eosd_targets));
 689                 for(j=found; j<eosd_surface_count; j++) {
 690                     eosd_surfaces[j].surface = VDP_INVALID_HANDLE;
 691                     eosd_surfaces[j].in_use = 0;
 692                 }
 693             }
 694             vdp_st = vdp_bitmap_surface_create(vdp_device, VDP_RGBA_FORMAT_A8,
 695                 i->w, i->h, VDP_TRUE, &eosd_surfaces[found].surface);
 696             CHECK_ST_WARNING("EOSD: error when creating surface")
 697             eosd_surfaces[found].w = i->w;
 698             eosd_surfaces[found].h = i->h;
 699         }
 700         eosd_surfaces[found].in_use = 1;
 701         eosd_targets[eosd_render_count].surface = eosd_surfaces[found].surface;
 702         destRect.x0 = 0;
 703         destRect.y0 = 0;
 704         destRect.x1 = i->w;
 705         destRect.y1 = i->h;
 706         vdp_st = vdp_bitmap_surface_putbits_native(eosd_targets[eosd_render_count].surface,
 707             (const void *) &i->bitmap, &i->stride, &destRect);
 708         CHECK_ST_WARNING("EOSD: putbits failed")
 709         eosd_render_count++;
 710     }
 711
 712 eosd_skip_upload:
 713     eosd_render_count = 0;
 714     for (i = img; i; i = i->next) {
 715         // Render dest, color, etc.
 716         eosd_targets[eosd_render_count].color.alpha = 1.0 - ((i->color >> 0) & 0xff) / 255.0;
 717         eosd_targets[eosd_render_count].color.blue  = ((i->color >>  8) & 0xff) / 255.0;
 718         eosd_targets[eosd_render_count].color.green = ((i->color >> 16) & 0xff) / 255.0;
 719         eosd_targets[eosd_render_count].color.red   = ((i->color >> 24) & 0xff) / 255.0;
 720         eosd_targets[eosd_render_count].dest.x0 = i->dst_x;
 721         eosd_targets[eosd_render_count].dest.y0 = i->dst_y;
 722         eosd_targets[eosd_render_count].dest.x1 = i->w + i->dst_x;
 723         eosd_targets[eosd_render_count].dest.y1 = i->h + i->dst_y;
 724         eosd_targets[eosd_render_count].source.x0 = 0;
 725         eosd_targets[eosd_render_count].source.y0 = 0;
 726         eosd_targets[eosd_render_count].source.x1 = i->w;
 727         eosd_targets[eosd_render_count].source.y1 = i->h;
 728         eosd_render_count++;
 729     }
 730 }
 731
 732 static void draw_osd(void)
 733 {
 734     mp_msg(MSGT_VO, MSGL_DBG2, "DRAW_OSD\n");
 735
 736     draw_eosd();
 737     vo_draw_text_ext(vo_dwidth, vo_dheight, border_x, border_y, border_x, border_y,
 738                      vid_width, vid_height, draw_osd_I8A8);
 739 }
 740
 741 static void flip_page(void)
 742 {
 743     VdpStatus vdp_st;
 744     mp_msg(MSGT_VO, MSGL_DBG2, "\nFLIP_PAGE VID:%u -> OUT:%u\n",
 745            surface_render[vid_surface_num].surface, output_surfaces[surface_num]);
 746
 747     vdp_st = vdp_presentation_queue_display(vdp_flip_queue, output_surfaces[surface_num],
 748                                             vo_dwidth, vo_dheight,
 749                                             0);
 750     CHECK_ST_WARNING("Error when calling vdp_presentation_queue_display")
 751
 752     surface_num = (surface_num + 1) % NUM_OUTPUT_SURFACES;
 753     visible_buf = 1;
 754 }
 755
 756 static int draw_slice(uint8_t *image[], int stride[], int w, int h,
 757                       int x, int y)
 758 {
 759     VdpStatus vdp_st;
 760     struct vdpau_render_state *rndr = (struct vdpau_render_state *)image[0];
 761     int max_refs = image_format == IMGFMT_VDPAU_H264 ? rndr->info.h264.num_ref_frames : 2;
 762     if (!IMGFMT_IS_VDPAU(image_format))
 763         return VO_FALSE;
 764     if (decoder == VDP_INVALID_HANDLE || decoder_max_refs < max_refs) {
 765         VdpDecoderProfile vdp_decoder_profile;
 766         if (decoder != VDP_INVALID_HANDLE)
 767             vdp_decoder_destroy(decoder);
 768         decoder = VDP_INVALID_HANDLE;
 769         switch (image_format) {
 770             case IMGFMT_VDPAU_MPEG1:
 771                 vdp_decoder_profile = VDP_DECODER_PROFILE_MPEG1;
 772                 break;
 773             case IMGFMT_VDPAU_MPEG2:
 774                 vdp_decoder_profile = VDP_DECODER_PROFILE_MPEG2_MAIN;
 775                 break;
 776             case IMGFMT_VDPAU_H264:
 777                 vdp_decoder_profile = VDP_DECODER_PROFILE_H264_HIGH;
 778                 break;
 779             case IMGFMT_VDPAU_WMV3:
 780                 vdp_decoder_profile = VDP_DECODER_PROFILE_VC1_MAIN;
 781                 break;
 782             case IMGFMT_VDPAU_VC1:
 783                 vdp_decoder_profile = VDP_DECODER_PROFILE_VC1_ADVANCED;
 784                 break;
 785         }
 786         vdp_st = vdp_decoder_create(vdp_device, vdp_decoder_profile, vid_width, vid_height, max_refs, &decoder);
 787         CHECK_ST_WARNING("Failed creating VDPAU decoder");
 788         decoder_max_refs = max_refs;
 789     }
 790     vdp_st = vdp_decoder_render(decoder, rndr->surface, (void *)&rndr->info, rndr->bitstream_buffers_used, rndr->bitstream_buffers);
 791     CHECK_ST_WARNING("Failed VDPAU decoder rendering");
 792     return VO_TRUE;
 793 }
 794
 795
 796 static int draw_frame(uint8_t *src[])
 797 {
 798     return VO_ERROR;
 799 }
 800
 801 static struct vdpau_render_state *get_surface(int number)
 802 {
 803     if (number > MAX_VIDEO_SURFACES)
 804         return NULL;
 805     if (surface_render[number].surface == VDP_INVALID_HANDLE) {
 806         VdpStatus vdp_st;
 807         vdp_st = vdp_video_surface_create(vdp_device, vdp_chroma_type,
 808                                           vid_width, vid_height,
 809                                           &surface_render[number].surface);
 810         CHECK_ST_WARNING("Error when calling vdp_video_surface_create")
 811         if (vdp_st != VDP_STATUS_OK)
 812             return NULL;
 813     }
 814     mp_msg(MSGT_VO, MSGL_DBG2, "VID CREATE: %u\n", surface_render[number].surface);
 815     return &surface_render[number];
 816 }
 817
 818 static uint32_t draw_image(mp_image_t *mpi)
 819 {
 820     if (IMGFMT_IS_VDPAU(image_format)) {
 821         struct vdpau_render_state *rndr = mpi->priv;
 822         vid_surface_num = rndr - surface_render;
 823     } else if (!(mpi->flags & MP_IMGFLAG_DRAW_CALLBACK)) {
 824         VdpStatus vdp_st;
 825         void *destdata[3] = {mpi->planes[0], mpi->planes[2], mpi->planes[1]};
 826         struct vdpau_render_state *rndr = get_surface(0);
 827         vid_surface_num = rndr - surface_render;
 828         vdp_st = vdp_video_surface_put_bits_y_cb_cr(rndr->surface,
 829                                                     VDP_YCBCR_FORMAT_YV12,
 830                                                     (const void *const*)destdata,
 831                                                     mpi->stride); // pitch
 832         CHECK_ST_ERROR("Error when calling vdp_video_surface_put_bits_y_cb_cr")
 833     }
 834     top_field_first = !!(mpi->fields & MP_IMGFIELD_TOP_FIRST);
 835
 836     video_to_output_surface();
 837     return VO_TRUE;
 838 }
 839
 840 static uint32_t get_image(mp_image_t *mpi)
 841 {
 842     struct vdpau_render_state *rndr;
 843
 844     // no dr for non-decoding for now
 845     if (!IMGFMT_IS_VDPAU(image_format)) return VO_FALSE;
 846     if (mpi->type != MP_IMGTYPE_NUMBERED) return VO_FALSE;
 847
 848     rndr = get_surface(mpi->number);
 849     if (!rndr) {
 850         mp_msg(MSGT_VO, MSGL_ERR, "[vdpau] no surfaces available in get_image\n");
 851         // TODO: this probably breaks things forever, provide a dummy buffer?
 852         return VO_FALSE;
 853     }
 854     mpi->flags |= MP_IMGFLAG_DIRECT;
 855     mpi->stride[0] = mpi->stride[1] = mpi->stride[2] = 0;
 856     mpi->planes[0] = mpi->planes[1] = mpi->planes[2] = NULL;
 857     // hack to get around a check and to avoid a special-case in vd_ffmpeg.c
 858     mpi->planes[0] = (void *)rndr;
 859     mpi->num_planes = 1;
 860     mpi->priv = rndr;
 861     return VO_TRUE;
 862 }
 863
 864 static int query_format(uint32_t format)
 865 {
 866     int default_flags = VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW | VFCAP_HWSCALE_UP | VFCAP_HWSCALE_DOWN | VFCAP_OSD | VFCAP_EOSD | VFCAP_EOSD_UNSCALED;
 867     switch (format) {
 868         case IMGFMT_YV12:
 869             return default_flags | VOCAP_NOSLICES;
 870         case IMGFMT_VDPAU_MPEG1:
 871         case IMGFMT_VDPAU_MPEG2:
 872         case IMGFMT_VDPAU_H264:
 873         case IMGFMT_VDPAU_WMV3:
 874         case IMGFMT_VDPAU_VC1:
 875             return default_flags;
 876     }
 877     return 0;
 878 }
 879
 880 static void DestroyVdpauObjects(void)
 881 {
 882     int i;
 883     VdpStatus vdp_st;
 884
 885     free_video_specific();
 886
 887     vdp_st = vdp_presentation_queue_destroy(vdp_flip_queue);
 888     CHECK_ST_WARNING("Error when calling vdp_presentation_queue_destroy")
 889
 890     vdp_st = vdp_presentation_queue_target_destroy(vdp_flip_target);
 891     CHECK_ST_WARNING("Error when calling vdp_presentation_queue_target_destroy")
 892
 893     for (i = 0; i <= NUM_OUTPUT_SURFACES; i++) {
 894         vdp_st = vdp_output_surface_destroy(output_surfaces[i]);
 895         output_surfaces[i] = VDP_INVALID_HANDLE;
 896         CHECK_ST_WARNING("Error when calling vdp_output_surface_destroy")
 897     }
 898
 899     for (i = 0; i<eosd_surface_count; i++) {
 900         if (eosd_surfaces[i].surface != VDP_INVALID_HANDLE) {
 901             vdp_st = vdp_bitmap_surface_destroy(eosd_surfaces[i].surface);
 902             CHECK_ST_WARNING("Error when calling vdp_bitmap_surface_destroy")
 903         }
 904         eosd_surfaces[i].surface = VDP_INVALID_HANDLE;
 905     }
 906
 907     vdp_st = vdp_device_destroy(vdp_device);
 908     CHECK_ST_WARNING("Error when calling vdp_device_destroy")
 909 }
 910
 911 static void uninit(void)
 912 {
 913     if (!vo_config_count)
 914         return;
 915     visible_buf = 0;
 916
 917     /* Destroy all vdpau objects */
 918     DestroyVdpauObjects();
 919
 920     free(index_data);
 921     index_data = NULL;
 922
 923     free(eosd_surfaces);
 924     eosd_surfaces = NULL;
 925     free(eosd_targets);
 926     eosd_targets = NULL;
 927
 928 #ifdef CONFIG_XF86VM
 929     vo_vm_close();
 930 #endif
 931     vo_x11_uninit();
 932
 933     dlclose(vdpau_lib_handle);
 934 }
 935
 936 static opt_t subopts[] = {
 937     {"deint",   OPT_ARG_INT,   &deint,   (opt_test_f)int_non_neg},
 938     {"pullup",  OPT_ARG_BOOL,  &pullup,  NULL},
 939     {"denoise", OPT_ARG_FLOAT, &denoise, NULL},
 940     {"sharpen", OPT_ARG_FLOAT, &sharpen, NULL},
 941     {NULL}
 942 };
 943
 944 static const char help_msg[] =
 945     "\n-vo vdpau command line help:\n"
 946     "Example: mplayer -vo vdpau:deint=2\n"
 947     "\nOptions:\n"
 948     "  deint (all modes > 0 respect -field-dominance)\n"
 949     "    0: no deinterlacing\n"
 950     "    1: only show first field\n"
 951     "    2: bob deinterlacing (current fallback)\n"
 952     "    3: temporal deinterlacing (not yet working)\n"
 953     "    4: temporal-spatial deinterlacing (not yet working)\n"
 954     "  pullup\n"
 955     "    Try to apply inverse-telecine (needs deinterlacing, not working)\n"
 956     "  denoise\n"
 957     "    Apply denoising, argument is strength from 0.0 to 1.0\n"
 958     "  sharpen\n"
 959     "    Apply sharpening or softening, argument is strength from -1.0 to 1.0\n"
 960     ;
 961
 962 static int preinit(const char *arg)
 963 {
 964     int i;
 965     static const char *vdpaulibrary = "libvdpau.so.1";
 966     static const char *vdpau_device_create = "vdp_device_create_x11";
 967
 968     deint = 0;
 969     deint_type = 3;
 970     pullup = 0;
 971     denoise = 0;
 972     sharpen = 0;
 973     if (subopt_parse(arg, subopts) != 0) {
 974         mp_msg(MSGT_VO, MSGL_FATAL, help_msg);
 975         return -1;
 976     }
 977     if (deint)
 978         deint_type = deint;
 979
 980     vdpau_lib_handle = dlopen(vdpaulibrary, RTLD_LAZY);
 981     if (!vdpau_lib_handle) {
 982         mp_msg(MSGT_VO, MSGL_ERR, "[vdpau] Could not open dynamic library %s\n",
 983                vdpaulibrary);
 984         return -1;
 985     }
 986     vdp_device_create = dlsym(vdpau_lib_handle, vdpau_device_create);
 987     if (!vdp_device_create) {
 988         mp_msg(MSGT_VO, MSGL_ERR, "[vdpau] Could not find function %s in %s\n",
 989                vdpau_device_create, vdpaulibrary);
 990         return -1;
 991     }
 992     if (!vo_init() || win_x11_init_vdpau_procs())
 993         return -1;
 994
 995     decoder = VDP_INVALID_HANDLE;
 996     for (i = 0; i < MAX_VIDEO_SURFACES; i++)
 997         surface_render[i].surface = VDP_INVALID_HANDLE;
 998     video_mixer = VDP_INVALID_HANDLE;
 999     for (i = 0; i < NUM_OUTPUT_SURFACES; i++)
1000         output_surfaces[i] = VDP_INVALID_HANDLE;
1001     vdp_flip_queue = VDP_INVALID_HANDLE;
1002     output_surface_width = output_surface_height = -1;
1003
1004     // full grayscale palette.
1005     for (i = 0; i < PALETTE_SIZE; ++i)
1006         palette[i] = (i << 16) | (i << 8) | i;
1007     index_data = NULL;
1008     index_data_size = 0;
1009
1010     eosd_surface_count = eosd_render_count = 0;
1011     eosd_surfaces = NULL;
1012     eosd_targets  = NULL;
1013
1014     return 0;
1015 }
1016
1017 static int control(uint32_t request, void *data)
1018 {
1019     switch (request) {
1020         case VOCTRL_GET_DEINTERLACE:
1021             *(int*)data = deint;
1022             return VO_TRUE;
1023         case VOCTRL_SET_DEINTERLACE:
1024             deint = *(int*)data;
1025             if (deint)
1026                 deint = deint_type;
1027             return VO_TRUE;
1028         case VOCTRL_PAUSE:
1029             return (int_pause = 1);
1030         case VOCTRL_RESUME:
1031             return (int_pause = 0);
1032         case VOCTRL_QUERY_FORMAT:
1033             return query_format(*(uint32_t *)data);
1034         case VOCTRL_GET_IMAGE:
1035             return get_image(data);
1036         case VOCTRL_DRAW_IMAGE:
1037             return draw_image(data);
1038         case VOCTRL_GUISUPPORT:
1039             return VO_TRUE;
1040         case VOCTRL_BORDER:
1041             vo_x11_border();
1042             resize();
1043             return VO_TRUE;
1044         case VOCTRL_FULLSCREEN:
1045             vo_x11_fullscreen();
1046             resize();
1047             return VO_TRUE;
1048         case VOCTRL_GET_PANSCAN:
1049             return VO_TRUE;
1050         case VOCTRL_SET_PANSCAN:
1051             resize();
1052             return VO_TRUE;
1053         case VOCTRL_SET_EQUALIZER: {
1054             struct voctrl_set_equalizer_args *args = data;
1055             return vo_x11_set_equalizer(args->name, args->value);
1056         }
1057         case VOCTRL_GET_EQUALIZER:
1058         {
1059             struct voctrl_get_equalizer_args *args = data;
1060             return vo_x11_get_equalizer(args->name, args->valueptr);
1061         }
1062         case VOCTRL_ONTOP:
1063             vo_x11_ontop();
1064             return VO_TRUE;
1065         case VOCTRL_UPDATE_SCREENINFO:
1066             update_xinerama_info();
1067             return VO_TRUE;
1068         case VOCTRL_DRAW_EOSD:
1069             if (!data)
1070                 return VO_FALSE;
1071             generate_eosd(data);
1072             return VO_TRUE;
1073         case VOCTRL_GET_EOSD_RES: {
1074             mp_eosd_res_t *r = data;
1075             r->mt = r->mb = r->ml = r->mr = 0;
1076             if (vo_fs) {
1077                 r->w = vo_screenwidth;
1078                 r->h = vo_screenheight;
1079                 r->ml = r->mr = border_x;
1080                 r->mt = r->mb = border_y;
1081             } else {
1082                 r->w = vo_dwidth;
1083                 r->h = vo_dheight;
1084             }
1085             return VO_TRUE;
1086         }
1087     }
1088     return VO_NOTIMPL;
1089 }
1090
1091 /* @} */