Merge svn changes up to r28641

Convert vo_x11_border (used in vo_gl/gl2 though the vo_gl_border
macro) to use a wrapper macro in old-style VOs which do not provide a
VO object argument. Before this function had an explicit global_vo
argument in vo_gl/gl2. New vo_vdpau uses it too so use the same
mechanism as most other functions.

12 files changed, 842 insertions, 13 deletions

diff --git a/libvo/sub.c b/libvo/sub.c
index 47bfdac2e8..987ab76ba0 100644
--- a/libvo/sub.c
+++ b/libvo/sub.c
@@ -21,7 +21,7 @@
 #include <string.h>
 
 #include "config.h"
-#ifdef HAVE_MALLOC_H
+#if HAVE_MALLOC_H
 #include <malloc.h>
 #endif
 
@@ -1242,7 +1242,7 @@ struct osd_state *osd_create(void)
 #ifdef CONFIG_DVDNAV
     new_osd_obj(OSDTYPE_DVDNAV);
 #endif
-#if CONFIG_TV_TELETEXT
+#ifdef CONFIG_TV_TELETEXT
     new_osd_obj(OSDTYPE_TELETEXT);
 #endif
 #ifdef CONFIG_FREETYPE
diff --git a/libvo/video_out.c b/libvo/video_out.c
index 6d177ecabe..e81faee69d 100644
--- a/libvo/video_out.c
+++ b/libvo/video_out.c
@@ -75,6 +75,7 @@ extern struct vo_driver video_out_xmga;
 extern struct vo_driver video_out_x11;
 extern struct vo_driver video_out_xover;
 extern struct vo_driver video_out_xvmc;
+extern struct vo_driver video_out_vdpau;
 extern struct vo_driver video_out_xv;
 extern struct vo_driver video_out_gl;
 extern struct vo_driver video_out_gl2;
@@ -157,6 +158,9 @@ const struct vo_driver *video_out_drivers[] =
 #ifdef CONFIG_3DFX
         &video_out_3dfx,
 #endif
+#if CONFIG_VDPAU
+        &video_out_vdpau,
+#endif
 #ifdef CONFIG_XV
         &video_out_xv,
 #endif
@@ -444,8 +448,13 @@ static void src_dst_split_scaling(int src_size, int dst_size, int scaled_src_siz
  * Can be extended to take future cropping support into account.
  *
  * \param crop specifies the cropping border size in the left, right, top and bottom members, may be NULL
+ * \param borders the border values as e.g. EOSD (ASS) and properly placed DVD highlight support requires,
+ *                may be NULL and only left and top are currently valid.
  */
-void calc_src_dst_rects(struct vo *vo, int src_width, int src_height, struct vo_rect *src, struct vo_rect *dst, struct vo_rect *crop) {
+void calc_src_dst_rects(struct vo *vo, int src_width, int src_height,
+                        struct vo_rect *src, struct vo_rect *dst,
+                        struct vo_rect *borders, const struct vo_rect *crop)
+{
   static const struct vo_rect no_crop = {0, 0, 0, 0, 0, 0};
   int scaled_width  = 0;
   int scaled_height = 0;
@@ -458,11 +467,18 @@ void calc_src_dst_rects(struct vo *vo, int src_width, int src_height, struct vo_
   dst->top  = 0; dst->bottom = vo->dheight;
   src->left = 0; src->right  = src_width;
   src->top  = 0; src->bottom = src_height;
+  if (borders) {
+    borders->left = 0; borders->top = 0;
+  }
   if (vo_fs) {
     aspect(vo, &scaled_width, &scaled_height, A_ZOOM);
     panscan_calc(vo);
     scaled_width  += vo->panscan_x;
     scaled_height += vo->panscan_y;
+    if (borders) {
+      borders->left = (vo->dwidth  - scaled_width ) / 2;
+      borders->top  = (vo->dheight - scaled_height) / 2;
+    }
     src_dst_split_scaling(src_width, vo->dwidth, scaled_width,
                           &src->left, &src->right, &dst->left, &dst->right);
     src_dst_split_scaling(src_height, vo->dheight, scaled_height,
diff --git a/libvo/video_out.h b/libvo/video_out.h
index 64d4e1bb77..c2f7daa859 100644
--- a/libvo/video_out.h
+++ b/libvo/video_out.h
@@ -321,6 +321,8 @@ int lookup_keymap_table(const struct keymap *map, int key);
 struct vo_rect {
   int left, right, top, bottom, width, height;
 };
-void calc_src_dst_rects(struct vo *vo, int src_width, int src_height, struct vo_rect *src, struct vo_rect *dst, struct vo_rect *crop);
+void calc_src_dst_rects(struct vo *vo, int src_width, int src_height,
+                        struct vo_rect *src, struct vo_rect *dst,
+                        struct vo_rect *borders, const struct vo_rect *crop);
 
 #endif /* MPLAYER_VIDEO_OUT_H */
diff --git a/libvo/vo_direct3d.c b/libvo/vo_direct3d.c
index ef1d0ba9dc..c0f79d45d4 100644
--- a/libvo/vo_direct3d.c
+++ b/libvo/vo_direct3d.c
@@ -63,6 +63,8 @@ static struct global_priv {
                                 fullscreen */
     int src_width;              /**< Source (movie) width */
     int src_height;             /**< Source (movie) heigth */
+    int border_x;               /**< horizontal border value for OSD */
+    int border_y;               /**< vertical border value for OSD */
 
     D3DFORMAT movie_src_fmt;        /**< Movie colorspace format (depends on
                                     the movie's codec) */
@@ -149,7 +151,8 @@ static void calc_fs_rect(void)
 {
     struct vo_rect src_rect;
     struct vo_rect dst_rect;
-    calc_src_dst_rects(priv->src_width, priv->src_height, &src_rect, &dst_rect, NULL);
+    struct vo_rect borders;
+    calc_src_dst_rects(priv->src_width, priv->src_height, &src_rect, &dst_rect, &borders, NULL);
 
     priv->fs_movie_rect.left     = dst_rect.left;
     priv->fs_movie_rect.right    = dst_rect.right;
@@ -159,6 +162,8 @@ static void calc_fs_rect(void)
     priv->fs_panscan_rect.right  = src_rect.right;
     priv->fs_panscan_rect.top    = src_rect.top;
     priv->fs_panscan_rect.bottom = src_rect.bottom;
+    priv->border_x               = borders.left;
+    priv->border_y               = borders.top;
 
     mp_msg(MSGT_VO, MSGL_V,
            "<vo_direct3d>Fullscreen movie rectangle: t: %ld, l: %ld, r: %ld, b:%ld\n",
@@ -1027,7 +1032,8 @@ static void draw_osd(void)
         /* required for if subs are in the boarder region */
         priv->is_clear_needed = 1;
 
-        vo_draw_text(priv->osd_width, priv->osd_height, draw_alpha);
+        vo_draw_text_ext(priv->osd_width, priv->osd_height, priv->border_x, priv->border_y,
+                         priv->border_x, priv->border_y, priv->src_width, priv->src_height, draw_alpha);
 
         if (!priv->device_texture_sys)
         {
diff --git a/libvo/vo_dxr3.c b/libvo/vo_dxr3.c
index 74250b382c..e9474a0eb2 100644
--- a/libvo/vo_dxr3.c
+++ b/libvo/vo_dxr3.c
@@ -37,7 +37,7 @@
 #include "config.h"
 #include "mp_msg.h"
 #include "help_mp.h"
-#ifdef HAVE_MALLOC_H
+#if HAVE_MALLOC_H
 #include <malloc.h>
 #endif
 #include "fastmemcpy.h"
diff --git a/libvo/vo_gl.c b/libvo/vo_gl.c
index 8b19e30d21..73ab5dbf82 100644
--- a/libvo/vo_gl.c
+++ b/libvo/vo_gl.c
@@ -155,6 +155,7 @@ static void resize(int x,int y){
 
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
+  ass_border_x = ass_border_y = 0;
   if (vo_fs && use_aspect) {
     int new_w, new_h;
     GLdouble scale_x, scale_y;
@@ -1137,7 +1138,7 @@ static int control(uint32_t request, void *data)
     resize(vo_dwidth, vo_dheight);
     return VO_TRUE;
   case VOCTRL_BORDER:
-    vo_gl_border(global_vo);
+    vo_gl_border();
     resize(vo_dwidth, vo_dheight);
     return VO_TRUE;
   case VOCTRL_GET_PANSCAN:
diff --git a/libvo/vo_gl2.c b/libvo/vo_gl2.c
index 0b7393a6ef..66099e16d0 100644
--- a/libvo/vo_gl2.c
+++ b/libvo/vo_gl2.c
@@ -897,7 +897,7 @@ static int control(uint32_t request, void *data)
       resize(&vo_dwidth, &vo_dheight);
       return VO_TRUE;
     case VOCTRL_BORDER:
-      vo_gl_border(global_vo);
+      vo_gl_border();
       return VO_TRUE;
     case VOCTRL_GET_PANSCAN:
       return VO_TRUE;
diff --git a/libvo/vo_vdpau.c b/libvo/vo_vdpau.c
new file mode 100644
index 0000000000..41dafaa169
--- /dev/null
+++ b/libvo/vo_vdpau.c
@@ -0,0 +1,803 @@
+/*
+ * VDPAU video output driver
+ *
+ * Copyright (C) 2008 NVIDIA
+ *
+ * This file is part of MPlayer.
+ *
+ * MPlayer is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * MPlayer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with MPlayer; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/**
+ * \defgroup  VDPAU_Presentation VDPAU Presentation
+ * \ingroup Decoder
+ *
+ * Actual decoding and presentation are implemented here.
+ * All necessary frame information is collected through
+ * the "vdpau_render_state" structure after parsing all headers
+ * etc. in libavcodec for different codecs.
+ *
+ * @{
+ */
+
+#include <stdio.h>
+#include <dlfcn.h>
+
+#include "config.h"
+#include "mp_msg.h"
+#include "video_out.h"
+#include "video_out_internal.h"
+#include "x11_common.h"
+#include "aspect.h"
+#include "sub.h"
+
+#include "libavcodec/vdpau.h"
+
+#include "gui/interface.h"
+
+#include "libavutil/common.h"
+
+static vo_info_t info = {
+    "VDPAU with X11",
+    "vdpau",
+    "Rajib Mahapatra <rmahapatra@nvidia.com> and others",
+    ""
+};
+
+LIBVO_EXTERN(vdpau)
+
+#define CHECK_ST_ERROR(message) \
+    if (vdp_st != VDP_STATUS_OK) { \
+        mp_msg(MSGT_VO, MSGL_ERR, "[vdpau] %s: %s\n", \
+               message, vdp_get_error_string(vdp_st)); \
+        return -1; \
+    }
+
+#define CHECK_ST_WARNING(message) \
+    if (vdp_st != VDP_STATUS_OK) \
+        mp_msg(MSGT_VO, MSGL_WARN, "[vdpau] %s: %s\n", \
+               message, vdp_get_error_string(vdp_st));
+
+/* number of video and output surfaces */
+#define NUM_OUTPUT_SURFACES                3
+#define MAX_VIDEO_SURFACES                 50
+
+/* number of palette entries */
+#define PALETTE_SIZE 256
+
+/*
+ * Global variable declaration - VDPAU specific
+ */
+
+/* Declaration for all variables of win_x11_init_vdpau_procs() and
+ * win_x11_init_vdpau_flip_queue() functions
+ */
+static VdpDevice                          vdp_device;
+static VdpDeviceCreateX11                *vdp_device_create;
+static VdpGetProcAddress                 *vdp_get_proc_address;
+
+static VdpPresentationQueueTarget         vdp_flip_target;
+static VdpPresentationQueue               vdp_flip_queue;
+
+static VdpDeviceDestroy                  *vdp_device_destroy;
+static VdpVideoSurfaceCreate             *vdp_video_surface_create;
+static VdpVideoSurfaceDestroy            *vdp_video_surface_destroy;
+
+static VdpGetErrorString                 *vdp_get_error_string;
+
+/* May be used in software filtering/postprocessing options
+ * in MPlayer (./mplayer -vf ..) if we copy video_surface data to
+ * system memory.
+ */
+static VdpVideoSurfacePutBitsYCbCr       *vdp_video_surface_put_bits_y_cb_cr;
+static VdpOutputSurfacePutBitsNative     *vdp_output_surface_put_bits_native;
+
+static VdpOutputSurfaceCreate            *vdp_output_surface_create;
+static VdpOutputSurfaceDestroy           *vdp_output_surface_destroy;
+
+/* VideoMixer puts video_surface data on displayable output_surface. */
+static VdpVideoMixerCreate               *vdp_video_mixer_create;
+static VdpVideoMixerDestroy              *vdp_video_mixer_destroy;
+static VdpVideoMixerRender               *vdp_video_mixer_render;
+
+static VdpPresentationQueueTargetDestroy *vdp_presentation_queue_target_destroy;
+static VdpPresentationQueueCreate        *vdp_presentation_queue_create;
+static VdpPresentationQueueDestroy       *vdp_presentation_queue_destroy;
+static VdpPresentationQueueDisplay       *vdp_presentation_queue_display;
+static VdpPresentationQueueBlockUntilSurfaceIdle *vdp_presentation_queue_block_until_surface_idle;
+static VdpPresentationQueueTargetCreateX11       *vdp_presentation_queue_target_create_x11;
+
+/* output_surfaces[2] is used in composite-picture. */
+static VdpOutputSurfaceRenderOutputSurface       *vdp_output_surface_render_output_surface;
+static VdpOutputSurfacePutBitsIndexed            *vdp_output_surface_put_bits_indexed;
+
+static VdpDecoderCreate                          *vdp_decoder_create;
+static VdpDecoderDestroy                         *vdp_decoder_destroy;
+static VdpDecoderRender                          *vdp_decoder_render;
+
+static void                              *vdpau_lib_handle;
+static VdpOutputSurface                   output_surfaces[NUM_OUTPUT_SURFACES];
+static int                                output_surface_width, output_surface_height;
+
+static VdpVideoMixer                      video_mixer;
+
+static VdpDecoder                         decoder;
+static int                                decoder_max_refs;
+
+static VdpRect                            src_rect_vid;
+static VdpRect                            out_rect_vid;
+static int                                border_x, border_y;
+
+static struct vdpau_render_state          surface_render[MAX_VIDEO_SURFACES];
+static int                                surface_num;
+static int                                vid_surface_num;
+static uint32_t                           vid_width, vid_height;
+static uint32_t                           image_format;
+static const VdpChromaType                vdp_chroma_type = VDP_CHROMA_TYPE_420;
+
+/* draw_osd */
+static unsigned char                     *index_data;
+static int                                index_data_size;
+static uint32_t                           palette[PALETTE_SIZE];
+
+/*
+ * X11 specific
+ */
+static int                                visible_buf;
+static int                                int_pause;
+
+static void video_to_output_surface(void)
+{
+    VdpTime dummy;
+    VdpStatus vdp_st;
+    VdpOutputSurface output_surface = output_surfaces[surface_num];
+    if (vid_surface_num < 0)
+        return;
+
+    vdp_st = vdp_presentation_queue_block_until_surface_idle(vdp_flip_queue,
+                                                             output_surface,
+                                                             &dummy);
+    CHECK_ST_WARNING("Error when calling vdp_presentation_queue_block_until_surface_idle")
+
+    vdp_st = vdp_video_mixer_render(video_mixer, VDP_INVALID_HANDLE, 0,
+                                    VDP_VIDEO_MIXER_PICTURE_STRUCTURE_FRAME,
+                                    0, NULL, surface_render[vid_surface_num].surface, 0, NULL, &src_rect_vid,
+                                    output_surface,
+                                    NULL, &out_rect_vid, 0, NULL);
+    CHECK_ST_WARNING("Error when calling vdp_video_mixer_render")
+}
+
+static void resize(void)
+{
+    VdpStatus vdp_st;
+    int i;
+    struct vo_rect src_rect;
+    struct vo_rect dst_rect;
+    struct vo_rect borders;
+    calc_src_dst_rects(vid_width, vid_height, &src_rect, &dst_rect, &borders, NULL);
+    out_rect_vid.x0 = dst_rect.left;
+    out_rect_vid.x1 = dst_rect.right;
+    out_rect_vid.y0 = dst_rect.top;
+    out_rect_vid.y1 = dst_rect.bottom;
+    src_rect_vid.x0 = src_rect.left;
+    src_rect_vid.x1 = src_rect.right;
+    src_rect_vid.y0 = src_rect.top;
+    src_rect_vid.y1 = src_rect.bottom;
+    border_x        = borders.left;
+    border_y        = borders.top;
+#ifdef CONFIG_FREETYPE
+    // adjust font size to display size
+    force_load_font = 1;
+#endif
+    vo_osd_changed(OSDTYPE_OSD);
+
+    if (output_surface_width < vo_dwidth || output_surface_height < vo_dheight) {
+        if (output_surface_width < vo_dwidth) {
+            output_surface_width += output_surface_width >> 1;
+            output_surface_width = FFMAX(output_surface_width, vo_dwidth);
+        }
+        if (output_surface_height < vo_dheight) {
+            output_surface_height += output_surface_height >> 1;
+            output_surface_height = FFMAX(output_surface_height, vo_dheight);
+        }
+        // Creation of output_surfaces
+        for (i = 0; i < NUM_OUTPUT_SURFACES; i++) {
+            if (output_surfaces[i] != VDP_INVALID_HANDLE)
+                vdp_output_surface_destroy(output_surfaces[i]);
+            vdp_st = vdp_output_surface_create(vdp_device, VDP_RGBA_FORMAT_B8G8R8A8,
+                                               output_surface_width, output_surface_height,
+                                               &output_surfaces[i]);
+            CHECK_ST_WARNING("Error when calling vdp_output_surface_create")
+            mp_msg(MSGT_VO, MSGL_DBG2, "OUT CREATE: %u\n", output_surfaces[i]);
+        }
+    }
+    video_to_output_surface();
+    if (visible_buf)
+        flip_page();
+}
+
+/* Initialize vdp_get_proc_address, called from preinit() */
+static int win_x11_init_vdpau_procs(void)
+{
+    VdpStatus vdp_st;
+
+    struct vdp_function {
+        const int id;
+        void *pointer;
+    };
+
+    const struct vdp_function *dsc;
+
+    static const struct vdp_function vdp_func[] = {
+        {VDP_FUNC_ID_GET_ERROR_STRING,          &vdp_get_error_string},
+        {VDP_FUNC_ID_DEVICE_DESTROY,            &vdp_device_destroy},
+        {VDP_FUNC_ID_VIDEO_SURFACE_CREATE,      &vdp_video_surface_create},
+        {VDP_FUNC_ID_VIDEO_SURFACE_DESTROY,     &vdp_video_surface_destroy},
+        {VDP_FUNC_ID_VIDEO_SURFACE_PUT_BITS_Y_CB_CR,
+                        &vdp_video_surface_put_bits_y_cb_cr},
+        {VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_NATIVE,
+                        &vdp_output_surface_put_bits_native},
+        {VDP_FUNC_ID_OUTPUT_SURFACE_CREATE,     &vdp_output_surface_create},
+        {VDP_FUNC_ID_OUTPUT_SURFACE_DESTROY,    &vdp_output_surface_destroy},
+        {VDP_FUNC_ID_VIDEO_MIXER_CREATE, &vdp_video_mixer_create},
+        {VDP_FUNC_ID_VIDEO_MIXER_DESTROY,       &vdp_video_mixer_destroy},
+        {VDP_FUNC_ID_VIDEO_MIXER_RENDER,        &vdp_video_mixer_render},
+        {VDP_FUNC_ID_PRESENTATION_QUEUE_TARGET_DESTROY,
+                        &vdp_presentation_queue_target_destroy},
+        {VDP_FUNC_ID_PRESENTATION_QUEUE_CREATE, &vdp_presentation_queue_create},
+        {VDP_FUNC_ID_PRESENTATION_QUEUE_DESTROY,
+                        &vdp_presentation_queue_destroy},
+        {VDP_FUNC_ID_PRESENTATION_QUEUE_DISPLAY,
+                        &vdp_presentation_queue_display},
+        {VDP_FUNC_ID_PRESENTATION_QUEUE_BLOCK_UNTIL_SURFACE_IDLE,
+                        &vdp_presentation_queue_block_until_surface_idle},
+        {VDP_FUNC_ID_PRESENTATION_QUEUE_TARGET_CREATE_X11,
+                        &vdp_presentation_queue_target_create_x11},
+        {VDP_FUNC_ID_OUTPUT_SURFACE_RENDER_OUTPUT_SURFACE,
+                        &vdp_output_surface_render_output_surface},
+        {VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_INDEXED,
+                        &vdp_output_surface_put_bits_indexed},
+        {VDP_FUNC_ID_DECODER_CREATE,            &vdp_decoder_create},
+        {VDP_FUNC_ID_DECODER_RENDER,            &vdp_decoder_render},
+        {VDP_FUNC_ID_DECODER_DESTROY,           &vdp_decoder_destroy},
+        {0, NULL}
+    };
+
+    vdp_st = vdp_device_create(mDisplay, mScreen,
+                               &vdp_device, &vdp_get_proc_address);
+    if (vdp_st != VDP_STATUS_OK) {
+        mp_msg(MSGT_VO, MSGL_ERR, "[vdpau] Error when calling vdp_device_create_x11: %i\n", vdp_st);
+        return -1;
+    }
+
+    for (dsc = vdp_func; dsc->pointer; dsc++) {
+        vdp_st = vdp_get_proc_address(vdp_device, dsc->id, dsc->pointer);
+        if (vdp_st != VDP_STATUS_OK) {
+            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) : "?");
+            return -1;
+        }
+    }
+    return 0;
+}
+
+/* Initialize vdpau_flip_queue, called from config() */
+static int win_x11_init_vdpau_flip_queue(void)
+{
+    VdpStatus vdp_st;
+
+    vdp_st = vdp_presentation_queue_target_create_x11(vdp_device, vo_window,
+                                                      &vdp_flip_target);
+    CHECK_ST_ERROR("Error when calling vdp_presentation_queue_target_create_x11")
+
+    vdp_st = vdp_presentation_queue_create(vdp_device, vdp_flip_target,
+                                           &vdp_flip_queue);
+    CHECK_ST_ERROR("Error when calling vdp_presentation_queue_create")
+
+    return 0;
+}
+
+static int create_vdp_mixer(VdpChromaType vdp_chroma_type) {
+#define VDP_NUM_MIXER_PARAMETER 3
+    VdpStatus vdp_st;
+    static const VdpVideoMixerParameter parameters[VDP_NUM_MIXER_PARAMETER] = {
+        VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_WIDTH,
+        VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_HEIGHT,
+        VDP_VIDEO_MIXER_PARAMETER_CHROMA_TYPE
+    };
+    const void *const parameter_values[VDP_NUM_MIXER_PARAMETER] = {
+        &vid_width,
+        &vid_height,
+        &vdp_chroma_type
+    };
+
+    vdp_st = vdp_video_mixer_create(vdp_device, 0, 0,
+                                    VDP_NUM_MIXER_PARAMETER,
+                                    parameters, parameter_values,
+                                    &video_mixer);
+    CHECK_ST_ERROR("Error when calling vdp_video_mixer_create")
+
+    return 0;
+}
+
+// Free everything specific to a certain video file
+static void free_video_specific(void) {
+    int i;
+    VdpStatus vdp_st;
+
+    if (decoder != VDP_INVALID_HANDLE)
+        vdp_decoder_destroy(decoder);
+    decoder = VDP_INVALID_HANDLE;
+    decoder_max_refs = -1;
+
+    for (i = 0; i < MAX_VIDEO_SURFACES; i++) {
+        if (surface_render[i].surface != VDP_INVALID_HANDLE) {
+          vdp_st = vdp_video_surface_destroy(surface_render[i].surface);
+          CHECK_ST_WARNING("Error when calling vdp_video_surface_destroy")
+        }
+        surface_render[i].surface = VDP_INVALID_HANDLE;
+    }
+
+    if (video_mixer != VDP_INVALID_HANDLE)
+        vdp_st = vdp_video_mixer_destroy(video_mixer);
+    CHECK_ST_WARNING("Error when calling vdp_video_mixer_destroy")
+    video_mixer = VDP_INVALID_HANDLE;
+}
+
+/*
+ * connect to X server, create and map window, initialize all
+ * VDPAU objects, create different surfaces etc.
+ */
+static int config(uint32_t width, uint32_t height, uint32_t d_width,
+                  uint32_t d_height, uint32_t flags, char *title,
+                  uint32_t format)
+{
+    XVisualInfo vinfo;
+    XSetWindowAttributes xswa;
+    XWindowAttributes attribs;
+    unsigned long xswamask;
+    int depth;
+
+#ifdef CONFIG_XF86VM
+    int vm = flags & VOFLAG_MODESWITCHING;
+#endif
+
+    image_format = format;
+
+    int_pause = 0;
+    visible_buf = 0;
+
+#ifdef CONFIG_GUI
+    if (use_gui)
+        guiGetEvent(guiSetShVideo, 0);  // the GUI will set up / resize our window
+    else
+#endif
+    {
+#ifdef CONFIG_XF86VM
+        if (vm)
+            vo_vm_switch();
+        else
+#endif
+        XGetWindowAttributes(mDisplay, DefaultRootWindow(mDisplay), &attribs);
+        depth = attribs.depth;
+        if (depth != 15 && depth != 16 && depth != 24 && depth != 32)
+            depth = 24;
+        XMatchVisualInfo(mDisplay, mScreen, depth, TrueColor, &vinfo);
+
+        xswa.background_pixel = 0;
+        xswa.border_pixel     = 0;
+        xswamask = CWBackPixel | CWBorderPixel;
+
+        vo_x11_create_vo_window(&vinfo, vo_dx, vo_dy, d_width, d_height,
+                                flags, CopyFromParent, "vdpau", title);
+        XChangeWindowAttributes(mDisplay, vo_window, xswamask, &xswa);
+
+#ifdef CONFIG_XF86VM
+        if (vm) {
+            /* Grab the mouse pointer in our window */
+            if (vo_grabpointer)
+                XGrabPointer(mDisplay, vo_window, True, 0,
+                             GrabModeAsync, GrabModeAsync,
+                             vo_window, None, CurrentTime);
+            XSetInputFocus(mDisplay, vo_window, RevertToNone, CurrentTime);
+        }
+#endif
+    }
+
+    if ((flags & VOFLAG_FULLSCREEN) && WinID <= 0)
+        vo_fs = 1;
+
+    /* -----VDPAU related code here -------- */
+
+    free_video_specific();
+
+    if (vdp_flip_queue == VDP_INVALID_HANDLE && win_x11_init_vdpau_flip_queue())
+        return -1;
+
+    // video width and height
+    vid_width  = width;
+    vid_height = height;
+
+    if (create_vdp_mixer(vdp_chroma_type))
+        return -1;
+
+    surface_num = 0;
+    vid_surface_num = -1;
+    resize();
+
+    return 0;
+}
+
+static void check_events(void)
+{
+    int e = vo_x11_check_events(mDisplay);
+
+    if (e & VO_EVENT_RESIZE)
+        resize();
+
+    if ((e & VO_EVENT_EXPOSE || e & VO_EVENT_RESIZE) && int_pause) {
+        /* did we already draw a buffer */
+        if (visible_buf) {
+            /* redraw the last visible buffer */
+            VdpStatus vdp_st;
+            vdp_st = vdp_presentation_queue_display(vdp_flip_queue,
+                                                    output_surfaces[surface_num],
+                                                    vo_dwidth, vo_dheight,
+                                                    0);
+            CHECK_ST_WARNING("Error when calling vdp_presentation_queue_display")
+        }
+    }
+}
+
+static void draw_osd_I8A8(int x0,int y0, int w,int h, unsigned char *src,
+                          unsigned char *srca, int stride)
+{
+    VdpOutputSurface output_surface = output_surfaces[surface_num];
+    VdpStatus vdp_st;
+    int i, j;
+    int pitch;
+    int index_data_size_required;
+    VdpRect output_indexed_rect_vid;
+    VdpOutputSurfaceRenderBlendState blend_state;
+
+    if (!w || !h)
+        return;
+
+    index_data_size_required = 2*w*h;
+    if (index_data_size < index_data_size_required) {
+        index_data      = realloc(index_data, index_data_size_required);
+        index_data_size = index_data_size_required;
+    }
+
+    // index_data creation, component order - I, A, I, A, .....
+    for (i = 0; i < h; i++)
+        for (j = 0; j < w; j++) {
+            index_data[i*2*w + j*2]     =  src [i*stride+j];
+            index_data[i*2*w + j*2 + 1] = -srca[i*stride+j];
+        }
+
+    output_indexed_rect_vid.x0 = x0;
+    output_indexed_rect_vid.y0 = y0;
+    output_indexed_rect_vid.x1 = x0 + w;
+    output_indexed_rect_vid.y1 = y0 + h;
+
+    pitch = w*2;
+
+    // write source_data to output_surfaces[2].
+    vdp_st = vdp_output_surface_put_bits_indexed(output_surfaces[2],
+                                                 VDP_INDEXED_FORMAT_I8A8,
+                                                 (const void *const*)&index_data,
+                                                 &pitch,
+                                                 &output_indexed_rect_vid,
+                                                 VDP_COLOR_TABLE_FORMAT_B8G8R8X8,
+                                                 (void *)palette);
+    CHECK_ST_WARNING("Error when calling vdp_output_surface_put_bits_indexed")
+
+    blend_state.struct_version                 = VDP_OUTPUT_SURFACE_RENDER_BLEND_STATE_VERSION;
+    blend_state.blend_factor_source_color      = VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE;
+    blend_state.blend_factor_source_alpha      = VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE;
+    blend_state.blend_factor_destination_color = VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
+    blend_state.blend_factor_destination_alpha = VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
+    blend_state.blend_equation_color           = VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_ADD;
+    blend_state.blend_equation_alpha           = VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_ADD;
+
+    vdp_st = vdp_output_surface_render_output_surface(output_surface,
+                                                      &output_indexed_rect_vid,
+                                                      output_surfaces[2],
+                                                      &output_indexed_rect_vid,
+                                                      NULL,
+                                                      &blend_state,
+                                                      VDP_OUTPUT_SURFACE_RENDER_ROTATE_0);
+    CHECK_ST_WARNING("Error when calling vdp_output_surface_render_output_surface")
+}
+
+static void draw_osd(void)
+{
+    mp_msg(MSGT_VO, MSGL_DBG2, "DRAW_OSD\n");
+
+    vo_draw_text_ext(vo_dwidth, vo_dheight, border_x, border_y, border_x, border_y,
+                     vid_width, vid_height, draw_osd_I8A8);
+}
+
+static void flip_page(void)
+{
+    VdpStatus vdp_st;
+    mp_msg(MSGT_VO, MSGL_DBG2, "\nFLIP_PAGE VID:%u -> OUT:%u\n",
+           surface_render[vid_surface_num].surface, output_surfaces[surface_num]);
+
+    vdp_st = vdp_presentation_queue_display(vdp_flip_queue, output_surfaces[surface_num],
+                                            vo_dwidth, vo_dheight,
+                                            0);
+    CHECK_ST_WARNING("Error when calling vdp_presentation_queue_display")
+
+    surface_num = !surface_num;
+    visible_buf = 1;
+}
+
+static int draw_slice(uint8_t *image[], int stride[], int w, int h,
+                      int x, int y)
+{
+    VdpStatus vdp_st;
+    struct vdpau_render_state *rndr = (struct vdpau_render_state *)image[0];
+    int max_refs = image_format == IMGFMT_VDPAU_H264 ? rndr->info.h264.num_ref_frames : 2;
+    if (!IMGFMT_IS_VDPAU(image_format))
+        return VO_FALSE;
+    if (decoder == VDP_INVALID_HANDLE || decoder_max_refs < max_refs) {
+        VdpDecoderProfile vdp_decoder_profile;
+        if (decoder != VDP_INVALID_HANDLE)
+            vdp_decoder_destroy(decoder);
+        decoder = VDP_INVALID_HANDLE;
+        switch (image_format) {
+            case IMGFMT_VDPAU_MPEG1:
+                vdp_decoder_profile = VDP_DECODER_PROFILE_MPEG1;
+                break;
+            case IMGFMT_VDPAU_MPEG2:
+                vdp_decoder_profile = VDP_DECODER_PROFILE_MPEG2_MAIN;
+                break;
+            case IMGFMT_VDPAU_H264:
+                vdp_decoder_profile = VDP_DECODER_PROFILE_H264_HIGH;
+                break;
+            case IMGFMT_VDPAU_WMV3:
+                vdp_decoder_profile = VDP_DECODER_PROFILE_VC1_MAIN;
+                break;
+            case IMGFMT_VDPAU_VC1:
+                vdp_decoder_profile = VDP_DECODER_PROFILE_VC1_ADVANCED;
+                break;
+        }
+        vdp_st = vdp_decoder_create(vdp_device, vdp_decoder_profile, vid_width, vid_height, max_refs, &decoder);
+        CHECK_ST_WARNING("Failed creating VDPAU decoder");
+        decoder_max_refs = max_refs;
+    }
+    vdp_st = vdp_decoder_render(decoder, rndr->surface, (void *)&rndr->info, rndr->bitstream_buffers_used, rndr->bitstream_buffers);
+    CHECK_ST_WARNING("Failed VDPAU decoder rendering");
+    return VO_TRUE;
+}
+
+
+static int draw_frame(uint8_t *src[])
+{
+    return VO_ERROR;
+}
+
+static struct vdpau_render_state *get_surface(int number)
+{
+    if (number > MAX_VIDEO_SURFACES)
+        return NULL;
+    if (surface_render[number].surface == VDP_INVALID_HANDLE) {
+        VdpStatus vdp_st;
+        vdp_st = vdp_video_surface_create(vdp_device, vdp_chroma_type,
+                                          vid_width, vid_height,
+                                          &surface_render[number].surface);
+        CHECK_ST_WARNING("Error when calling vdp_video_surface_create")
+        if (vdp_st != VDP_STATUS_OK)
+            return NULL;
+    }
+    mp_msg(MSGT_VO, MSGL_DBG2, "VID CREATE: %u\n", surface_render[number].surface);
+    return &surface_render[number];
+}
+
+static uint32_t draw_image(mp_image_t *mpi)
+{
+    if (IMGFMT_IS_VDPAU(image_format)) {
+        struct vdpau_render_state *rndr = mpi->priv;
+        vid_surface_num = rndr - surface_render;
+    } else if (!(mpi->flags & MP_IMGFLAG_DRAW_CALLBACK)) {
+        VdpStatus vdp_st;
+        void *destdata[3] = {mpi->planes[0], mpi->planes[2], mpi->planes[1]};
+        struct vdpau_render_state *rndr = get_surface(0);
+        vid_surface_num = rndr - surface_render;
+        vdp_st = vdp_video_surface_put_bits_y_cb_cr(rndr->surface,
+                                                    VDP_YCBCR_FORMAT_YV12,
+                                                    (const void *const*)destdata,
+                                                    mpi->stride); // pitch
+        CHECK_ST_ERROR("Error when calling vdp_video_surface_put_bits_y_cb_cr")
+    }
+
+    video_to_output_surface();
+    return VO_TRUE;
+}
+
+static uint32_t get_image(mp_image_t *mpi)
+{
+    struct vdpau_render_state *rndr;
+
+    // no dr for non-decoding for now
+    if (!IMGFMT_IS_VDPAU(image_format)) return VO_FALSE;
+    if (mpi->type != MP_IMGTYPE_NUMBERED) return VO_FALSE;
+
+    rndr = get_surface(mpi->number);
+    if (!rndr) {
+        mp_msg(MSGT_VO, MSGL_ERR, "[vdpau] no surfaces available in get_image\n");
+        // TODO: this probably breaks things forever, provide a dummy buffer?
+        return VO_FALSE;
+    }
+    mpi->flags |= MP_IMGFLAG_DIRECT;
+    mpi->stride[0] = mpi->stride[1] = mpi->stride[2] = 0;
+    mpi->planes[0] = mpi->planes[1] = mpi->planes[2] = NULL;
+    // hack to get around a check and to avoid a special-case in vd_ffmpeg.c
+    mpi->planes[0] = (void *)rndr;
+    mpi->num_planes = 1;
+