root/modules/video_output/x11/xcommon.c

/*****************************************************************************
 * xcommon.c: Functions common to the X11 and XVideo plugins
 *****************************************************************************
 * Copyright (C) 1998-2006 the VideoLAN team
 * $Id$
 *
 * Authors: Vincent Seguin <seguin@via.ecp.fr>
 *          Sam Hocevar <sam@zoy.org>
 *          David Kennedy <dkennedy@tinytoad.com>
 *          Gildas Bazin <gbazin@videolan.org>
 *
 * This program 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.
 *
 * This program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
 *****************************************************************************/

/*****************************************************************************
 * Preamble
 *****************************************************************************/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

#include <vlc_common.h>
#include <vlc_interface.h>
#include <vlc_playlist.h>
#include <vlc_vout.h>
#include <vlc_keys.h>

#include <errno.h>                                                 /* ENOMEM */

#ifdef HAVE_MACHINE_PARAM_H
    /* BSD */
#   include <machine/param.h>
#   include <sys/types.h>                                  /* typedef ushort */
#   include <sys/ipc.h>
#endif

#ifndef WIN32
#   include <netinet/in.h>                            /* BSD: struct in_addr */
#endif

#ifdef HAVE_XSP
#include <X11/extensions/Xsp.h>
#endif

#ifdef HAVE_SYS_SHM_H
#   include <sys/shm.h>                                /* shmget(), shmctl() */
#endif

#include <X11/Xlib.h>
#include <X11/Xproto.h>
#include <X11/Xmd.h>
#include <X11/Xutil.h>
#include <X11/keysym.h>
#include <X11/XF86keysym.h>
#ifdef HAVE_SYS_SHM_H
#   include <X11/extensions/XShm.h>
#endif
#ifdef DPMSINFO_IN_DPMS_H
#   include <X11/extensions/dpms.h>
#endif

#if defined(MODULE_NAME_IS_xvideo) || defined(MODULE_NAME_IS_xvmc)
#   include <X11/extensions/Xv.h>
#   include <X11/extensions/Xvlib.h>
#endif

#ifdef MODULE_NAME_IS_glx
#   include <GL/glx.h>
#endif

#ifdef HAVE_XINERAMA
#   include <X11/extensions/Xinerama.h>
#endif

#ifdef HAVE_X11_EXTENSIONS_XF86VMODE_H
#   include <X11/extensions/xf86vmode.h>
#endif

#ifdef MODULE_NAME_IS_xvmc
#   include <X11/extensions/vldXvMC.h>
#   include "../../codec/xvmc/accel_xvmc.h"
#endif

#include "xcommon.h"

/*****************************************************************************
 * Local prototypes
 *****************************************************************************/
int  Activate   ( vlc_object_t * );
void Deactivate ( vlc_object_t * );

static int  InitVideo      ( vout_thread_t * );
static void EndVideo       ( vout_thread_t * );
static void DisplayVideo   ( vout_thread_t *, picture_t * );
static int  ManageVideo    ( vout_thread_t * );
static int  Control        ( vout_thread_t *, int, va_list );

static int  InitDisplay    ( vout_thread_t * );

static int  CreateWindow   ( vout_thread_t *, x11_window_t * );
static void DestroyWindow  ( vout_thread_t *, x11_window_t * );

static int  NewPicture     ( vout_thread_t *, picture_t * );
static void FreePicture    ( vout_thread_t *, picture_t * );

#ifndef MODULE_NAME_IS_glx
static IMAGE_TYPE *CreateImage    ( vout_thread_t *,
                                    Display *, EXTRA_ARGS, int, int );
#endif

#ifdef HAVE_SYS_SHM_H
#ifndef MODULE_NAME_IS_glx
IMAGE_TYPE *CreateShmImage ( vout_thread_t *,
                                    Display *, EXTRA_ARGS_SHM, int, int );
#endif
static int i_shm_major = 0;
#endif

static void ToggleFullScreen      ( vout_thread_t * );

static void EnableXScreenSaver    ( vout_thread_t * );
static void DisableXScreenSaver   ( vout_thread_t * );

static void CreateCursor   ( vout_thread_t * );
static void DestroyCursor  ( vout_thread_t * );
static void ToggleCursor   ( vout_thread_t * );

#if defined(MODULE_NAME_IS_xvideo) || defined(MODULE_NAME_IS_xvmc)
static int  XVideoGetPort    ( vout_thread_t *, vlc_fourcc_t, picture_heap_t * );
static void XVideoReleasePort( vout_thread_t *, int );
#endif

#ifdef MODULE_NAME_IS_x11
static void SetPalette     ( vout_thread_t *,
                             uint16_t *, uint16_t *, uint16_t * );
#endif

#ifdef MODULE_NAME_IS_xvmc
static void RenderVideo    ( vout_thread_t *, picture_t * );
static int  xvmc_check_yv12( Display *display, XvPortID port );
static void xvmc_update_XV_DOUBLE_BUFFER( vout_thread_t *p_vout );
#endif

static void TestNetWMSupport( vout_thread_t * );
static int ConvertKey( int );

static int WindowOnTop( vout_thread_t *, bool );

static int X11ErrorHandler( Display *, XErrorEvent * );

#ifdef HAVE_XSP
static void EnablePixelDoubling( vout_thread_t *p_vout );
static void DisablePixelDoubling( vout_thread_t *p_vout );
#endif

#ifdef HAVE_OSSO
static const int i_backlight_on_interval = 300;
#endif



/*****************************************************************************
 * Activate: allocate X11 video thread output method
 *****************************************************************************
 * This function allocate and initialize a X11 vout method. It uses some of the
 * vout properties to choose the window size, and change them according to the
 * actual properties of the display.
 *****************************************************************************/
int Activate ( vlc_object_t *p_this )
{
    vout_thread_t *p_vout = (vout_thread_t *)p_this;
    char *        psz_display;
    vlc_value_t   val;
#if defined(MODULE_NAME_IS_xvmc)
    char *psz_value;
#endif
#if defined(MODULE_NAME_IS_xvideo) || defined(MODULE_NAME_IS_xvmc)
    char *       psz_chroma;
    vlc_fourcc_t i_chroma = 0;
    bool   b_chroma = 0;
#endif

    p_vout->pf_init = InitVideo;
    p_vout->pf_end = EndVideo;
    p_vout->pf_manage = ManageVideo;
#ifdef MODULE_NAME_IS_xvmc
    p_vout->pf_render = RenderVideo;
#else
    p_vout->pf_render = NULL;
#endif
    p_vout->pf_display = DisplayVideo;
    p_vout->pf_control = Control;

    /* Allocate structure */
    p_vout->p_sys = malloc( sizeof( vout_sys_t ) );
    if( p_vout->p_sys == NULL )
        return VLC_ENOMEM;

    vlc_mutex_init( &p_vout->p_sys->lock );

    /* Open display, using the "display" config variable or the DISPLAY
     * environment variable */
    psz_display = config_GetPsz( p_vout, MODULE_STRING "-display" );

    p_vout->p_sys->p_display = XOpenDisplay( psz_display );

    if( p_vout->p_sys->p_display == NULL )                         /* error */
    {
        msg_Err( p_vout, "cannot open display %s",
                         XDisplayName( psz_display ) );
        free( p_vout->p_sys );
        free( psz_display );
        return VLC_EGENERIC;
    }
    free( psz_display );

    /* Replace error handler so we can intercept some non-fatal errors */
    XSetErrorHandler( X11ErrorHandler );

    /* Get a screen ID matching the XOpenDisplay return value */
    p_vout->p_sys->i_screen = DefaultScreen( p_vout->p_sys->p_display );

#if defined(MODULE_NAME_IS_xvideo) || defined(MODULE_NAME_IS_xvmc)
    psz_chroma = config_GetPsz( p_vout, "xvideo-chroma" );
    if( psz_chroma )
    {
        if( strlen( psz_chroma ) >= 4 )
        {
            /* Do not use direct assignment because we are not sure of the
             * alignment. */
            memcpy(&i_chroma, psz_chroma, 4);
            b_chroma = 1;
        }

        free( psz_chroma );
    }

    if( b_chroma )
    {
        msg_Dbg( p_vout, "forcing chroma 0x%.8x (%4.4s)",
                 i_chroma, (char*)&i_chroma );
    }
    else
    {
        i_chroma = p_vout->render.i_chroma;
    }

    /* Check that we have access to an XVideo port providing this chroma */
    p_vout->p_sys->i_xvport = XVideoGetPort( p_vout, VLC2X11_FOURCC(i_chroma),
                                             &p_vout->output );
    if( p_vout->p_sys->i_xvport < 0 )
    {
        /* If a specific chroma format was requested, then we don't try to
         * be cleverer than the user. He knew pretty well what he wanted. */
        if( b_chroma )
        {
            XCloseDisplay( p_vout->p_sys->p_display );
            free( p_vout->p_sys );
            return VLC_EGENERIC;
        }

        /* It failed, but it's not completely lost ! We try to open an
         * XVideo port for an YUY2 picture. We'll need to do an YUV
         * conversion, but at least it has got scaling. */
        p_vout->p_sys->i_xvport =
                        XVideoGetPort( p_vout, X11_FOURCC('Y','U','Y','2'),
                                               &p_vout->output );
        if( p_vout->p_sys->i_xvport < 0 )
        {
            /* It failed, but it's not completely lost ! We try to open an
             * XVideo port for a simple 16bpp RGB picture. We'll need to do
             * an YUV conversion, but at least it has got scaling. */
            p_vout->p_sys->i_xvport =
                            XVideoGetPort( p_vout, X11_FOURCC('R','V','1','6'),
                                                   &p_vout->output );
            if( p_vout->p_sys->i_xvport < 0 )
            {
                XCloseDisplay( p_vout->p_sys->p_display );
                free( p_vout->p_sys );
                return VLC_EGENERIC;
            }
        }
    }
    p_vout->output.i_chroma = X112VLC_FOURCC(p_vout->output.i_chroma);
#elif defined(MODULE_NAME_IS_glx)
    {
        int i_opcode, i_evt, i_err = 0;
        int i_maj, i_min = 0;

        /* Check for GLX extension */
        if( !XQueryExtension( p_vout->p_sys->p_display, "GLX",
                              &i_opcode, &i_evt, &i_err ) )
        {
            msg_Err( p_this, "GLX extension not supported" );
            XCloseDisplay( p_vout->p_sys->p_display );
            free( p_vout->p_sys );
            return VLC_EGENERIC;
        }
        if( !glXQueryExtension( p_vout->p_sys->p_display, &i_err, &i_evt ) )
        {
            msg_Err( p_this, "glXQueryExtension failed" );
            XCloseDisplay( p_vout->p_sys->p_display );
            free( p_vout->p_sys );
            return VLC_EGENERIC;
        }

        /* Check GLX version */
        if (!glXQueryVersion( p_vout->p_sys->p_display, &i_maj, &i_min ) )
        {
            msg_Err( p_this, "glXQueryVersion failed" );
            XCloseDisplay( p_vout->p_sys->p_display );
            free( p_vout->p_sys );
            return VLC_EGENERIC;
        }
        if( i_maj <= 0 || ((i_maj == 1) && (i_min < 3)) )
        {
            p_vout->p_sys->b_glx13 = false;
            msg_Dbg( p_this, "using GLX 1.2 API" );
        }
        else
        {
            p_vout->p_sys->b_glx13 = true;
            msg_Dbg( p_this, "using GLX 1.3 API" );
        }
    }
#endif

    /* Create blank cursor (for mouse cursor autohiding) */
    p_vout->p_sys->i_time_mouse_last_moved = mdate();
    p_vout->p_sys->i_mouse_hide_timeout =
        var_GetInteger(p_vout, "mouse-hide-timeout") * 1000;
    p_vout->p_sys->b_mouse_pointer_visible = 1;
    CreateCursor( p_vout );

    /* Set main window's size */
    p_vout->p_sys->original_window.i_width = p_vout->i_window_width;
    p_vout->p_sys->original_window.i_height = p_vout->i_window_height;
    var_Create( p_vout, "video-title", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
    /* Spawn base window - this window will include the video output window,
     * but also command buttons, subtitles and other indicators */
    if( CreateWindow( p_vout, &p_vout->p_sys->original_window ) )
    {
        msg_Err( p_vout, "cannot create X11 window" );
        DestroyCursor( p_vout );
        XCloseDisplay( p_vout->p_sys->p_display );
        free( p_vout->p_sys );
        return VLC_EGENERIC;
    }

    /* Open and initialize device. */
    if( InitDisplay( p_vout ) )
    {
        msg_Err( p_vout, "cannot initialize X11 display" );
        DestroyCursor( p_vout );
        DestroyWindow( p_vout, &p_vout->p_sys->original_window );
        XCloseDisplay( p_vout->p_sys->p_display );
        free( p_vout->p_sys );
        return VLC_EGENERIC;
    }

    /* Disable screen saver */
    DisableXScreenSaver( p_vout );

    /* Misc init */
    p_vout->p_sys->b_altfullscreen = 0;
    p_vout->p_sys->i_time_button_last_pressed = 0;

    TestNetWMSupport( p_vout );

#ifdef MODULE_NAME_IS_xvmc
    p_vout->p_sys->p_last_subtitle_save = NULL;
    psz_value = config_GetPsz( p_vout, "xvmc-deinterlace-mode" );

    /* Look what method was requested */
    //var_Create( p_vout, "xvmc-deinterlace-mode", VLC_VAR_STRING );
    //var_Change( p_vout, "xvmc-deinterlace-mode", VLC_VAR_INHERITVALUE, &val, NULL );
    if( psz_value )
    {
        if( (strcmp(psz_value, "bob") == 0) ||
            (strcmp(psz_value, "blend") == 0) )
           p_vout->p_sys->xvmc_deinterlace_method = 2;
        else if (strcmp(psz_value, "discard") == 0)
           p_vout->p_sys->xvmc_deinterlace_method = 1;
        else
           p_vout->p_sys->xvmc_deinterlace_method = 0;
        free(psz_value );
    }
    else
        p_vout->p_sys->xvmc_deinterlace_method = 0;

    /* Look what method was requested */
    //var_Create( p_vout, "xvmc-crop-style", VLC_VAR_STRING );
    //var_Change( p_vout, "xvmc-crop-style", VLC_VAR_INHERITVALUE, &val, NULL );
    psz_value = config_GetPsz( p_vout, "xvmc-crop-style" );

    if( psz_value )
    {
        if( strncmp( psz_value, "eq", 2 ) == 0 )
           p_vout->p_sys->xvmc_crop_style = 1;
        else if( strncmp( psz_value, "4-16", 4 ) == 0)
           p_vout->p_sys->xvmc_crop_style = 2;
        else if( strncmp( psz_value, "16-4", 4 ) == 0)
           p_vout->p_sys->xvmc_crop_style = 3;
        else
           p_vout->p_sys->xvmc_crop_style = 0;
        free( psz_value );
    }
    else
        p_vout->p_sys->xvmc_crop_style = 0;

    msg_Dbg(p_vout, "Deinterlace = %d", p_vout->p_sys->xvmc_deinterlace_method);
    msg_Dbg(p_vout, "Crop = %d", p_vout->p_sys->xvmc_crop_style);

    if( checkXvMCCap( p_vout ) == VLC_EGENERIC )
    {
        msg_Err( p_vout, "no XVMC capability found" );
        Deactivate( p_vout );
        return VLC_EGENERIC;
    }
    subpicture_t sub_pic;
    sub_pic.p_sys = NULL;
    p_vout->p_sys->last_date = 0;
#endif

#ifdef HAVE_XSP
    p_vout->p_sys->i_hw_scale = 1;
#endif

#ifdef HAVE_OSSO
    p_vout->p_sys->i_backlight_on_counter = i_backlight_on_interval;
    p_vout->p_sys->p_octx = osso_initialize( "vlc", VERSION, 0, NULL );
    if ( p_vout->p_sys->p_octx == NULL ) {
        msg_Err( p_vout, "Could not get osso context" );
    } else {
        msg_Dbg( p_vout, "Initialized osso context" );
    }
#endif

    /* Variable to indicate if the window should be on top of others */
    /* Trigger a callback right now */
    var_Get( p_vout, "video-on-top", &val );
    var_Set( p_vout, "video-on-top", val );

    return VLC_SUCCESS;
}

/*****************************************************************************
 * Deactivate: destroy X11 video thread output method
 *****************************************************************************
 * Terminate an output method created by Open
 *****************************************************************************/
void Deactivate ( vlc_object_t *p_this )
{
    vout_thread_t *p_vout = (vout_thread_t *)p_this;

    /* If the fullscreen window is still open, close it */
    if( p_vout->b_fullscreen )
    {
        ToggleFullScreen( p_vout );
    }

    /* Restore cursor if it was blanked */
    if( !p_vout->p_sys->b_mouse_pointer_visible )
    {
        ToggleCursor( p_vout );
    }

#ifdef MODULE_NAME_IS_x11
    /* Destroy colormap */
    if( XDefaultDepth(p_vout->p_sys->p_display, p_vout->p_sys->i_screen) == 8 )
    {
        XFreeColormap( p_vout->p_sys->p_display, p_vout->p_sys->colormap );
    }
#elif defined(MODULE_NAME_IS_xvideo)
    XVideoReleasePort( p_vout, p_vout->p_sys->i_xvport );
#elif defined(MODULE_NAME_IS_xvmc)
    if( p_vout->p_sys->xvmc_cap )
    {
        xvmc_context_writer_lock( &p_vout->p_sys->xvmc_lock );
        xxmc_dispose_context( p_vout );
        if( p_vout->p_sys->old_subpic )
        {
            xxmc_xvmc_free_subpicture( p_vout, p_vout->p_sys->old_subpic );
            p_vout->p_sys->old_subpic = NULL;
        }
        if( p_vout->p_sys->new_subpic )
        {
            xxmc_xvmc_free_subpicture( p_vout, p_vout->p_sys->new_subpic );
            p_vout->p_sys->new_subpic = NULL;
        }
        free( p_vout->p_sys->xvmc_cap );
        xvmc_context_writer_unlock( &p_vout->p_sys->xvmc_lock );
    }
#endif

#ifdef HAVE_XSP
    DisablePixelDoubling(p_vout);
#endif

    DestroyCursor( p_vout );
    EnableXScreenSaver( p_vout );
    DestroyWindow( p_vout, &p_vout->p_sys->original_window );
    XCloseDisplay( p_vout->p_sys->p_display );

    /* Destroy structure */
    vlc_mutex_destroy( &p_vout->p_sys->lock );
#ifdef MODULE_NAME_IS_xvmc
    free_context_lock( &p_vout->p_sys->xvmc_lock );
#endif

#ifdef HAVE_OSSO
    if ( p_vout->p_sys->p_octx != NULL ) {
        msg_Dbg( p_vout, "Deinitializing osso context" );
        osso_deinitialize( p_vout->p_sys->p_octx );
    }
#endif

    free( p_vout->p_sys );
}

#ifdef MODULE_NAME_IS_xvmc

#define XINE_IMGFMT_YV12 (('2'<<24)|('1'<<16)|('V'<<8)|'Y')

/* called xlocked */
static int xvmc_check_yv12( Display *display, XvPortID port )
{
    XvImageFormatValues *formatValues;
    int                  formats;
    int                  i;

    formatValues = XvListImageFormats( display, port, &formats );

    for( i = 0; i < formats; i++ )
    {
        if( ( formatValues[i].id == XINE_IMGFMT_YV12 ) &&
            ( !( strncmp( formatValues[i].guid, "YV12", 4 ) ) ) )
        {
            XFree (formatValues);
            return 0;
        }
    }

    XFree (formatValues);
    return 1;
}

static void xvmc_sync_surface( vout_thread_t *p_vout, XvMCSurface * srf )
{
    XvMCSyncSurface( p_vout->p_sys->p_display, srf );
}

static void xvmc_update_XV_DOUBLE_BUFFER( vout_thread_t *p_vout )
{
    Atom         atom;
    int          xv_double_buffer;

    xv_double_buffer = 1;

    XLockDisplay( p_vout->p_sys->p_display );
    atom = XInternAtom( p_vout->p_sys->p_display, "XV_DOUBLE_BUFFER", False );
#if 0
    XvSetPortAttribute (p_vout->p_sys->p_display, p_vout->p_sys->i_xvport, atom, xv_double_buffer);
#endif
    XvMCSetAttribute( p_vout->p_sys->p_display, &p_vout->p_sys->context, atom, xv_double_buffer );
    XUnlockDisplay( p_vout->p_sys->p_display );

    //xprintf(this->xine, XINE_VERBOSITY_DEBUG,
    //    "video_out_xxmc: double buffering mode = %d\n", xv_double_buffer);
}

static void RenderVideo( vout_thread_t *p_vout, picture_t *p_pic )
{
    vlc_xxmc_t *xxmc = NULL;

    vlc_mutex_lock( &p_vout->p_sys->lock );
    xvmc_context_reader_lock( &p_vout->p_sys->xvmc_lock );

    xxmc = &p_pic->p_sys->xxmc_data;
    if( (!xxmc->decoded ||
        !xxmc_xvmc_surface_valid( p_vout, p_pic->p_sys->xvmc_surf )) )
    {
        vlc_mutex_unlock( &p_vout->p_sys->lock );
        xvmc_context_reader_unlock( &p_vout->p_sys->xvmc_lock );
        return;
    }

#if 0
    vlc_mutex_lock( &p_vout->lastsubtitle_lock );
    if (p_vout->p_sys->p_last_subtitle != NULL)
    {
        if( p_vout->p_sys->p_last_subtitle_save != p_vout->p_sys->p_last_subtitle )
        {
            p_vout->p_sys->new_subpic =
                xxmc_xvmc_alloc_subpicture( p_vout, &p_vout->p_sys->context,
                    p_vout->p_sys->xvmc_width,
                    p_vout->p_sys->xvmc_height,
                    p_vout->p_sys->xvmc_cap[p_vout->p_sys->xvmc_cur_cap].subPicType.id );

            if (p_vout->p_sys->new_subpic)
            {
                XVMCLOCKDISPLAY( p_vout->p_sys->p_display );
                XvMCClearSubpicture( p_vout->p_sys->p_display,
                        p_vout->p_sys->new_subpic,
                        0,
                        0,
                        p_vout->p_sys->xvmc_width,
                        p_vout->p_sys->xvmc_height,
                        0x00 );
                XVMCUNLOCKDISPLAY( p_vout->p_sys->p_display );
                clear_xx44_palette( &p_vout->p_sys->palette );

                if( sub_pic.p_sys == NULL )
                {
                    sub_pic.p_sys = malloc( sizeof( picture_sys_t ) );
                    if( sub_pic.p_sys != NULL )
                    {
                        sub_pic.p_sys->p_vout = p_vout;
                        sub_pic.p_sys->xvmc_surf = NULL;
                        sub_pic.p_sys->p_image = p_vout->p_sys->subImage;
                    }
                }
                sub_pic.p_sys->p_image = p_vout->p_sys->subImage;
                sub_pic.p->p_pixels = sub_pic.p_sys->p_image->data;
                sub_pic.p->i_pitch = p_vout->output.i_width;

                memset( p_vout->p_sys->subImage->data, 0,
                        (p_vout->p_sys->subImage->width * p_vout->p_sys->subImage->height) );

                if (p_vout->p_last_subtitle != NULL)
                {
                    blend_xx44( p_vout->p_sys->subImage->data,
                                p_vout->p_last_subtitle,
                                p_vout->p_sys->subImage->width,
                                p_vout->p_sys->subImage->height,
                                p_vout->p_sys->subImage->width,
                                &p_vout->p_sys->palette,
                                (p_vout->p_sys->subImage->id == FOURCC_IA44) );
                }

                XVMCLOCKDISPLAY( p_vout->p_sys->p_display );
                XvMCCompositeSubpicture( p_vout->p_sys->p_display,
                                         p_vout->p_sys->new_subpic,
                                         p_vout->p_sys->subImage,
                                         0, /* overlay->x */
                                         0, /* overlay->y */
                                         p_vout->output.i_width, /* overlay->width, */
                                         p_vout->output.i_height, /* overlay->height */
                                         0, /* overlay->x */
                                         0 ); /*overlay->y */
                XVMCUNLOCKDISPLAY( p_vout->p_sys->p_display );
                if (p_vout->p_sys->old_subpic)
                {
                    xxmc_xvmc_free_subpicture( p_vout,
                                               p_vout->p_sys->old_subpic);
                    p_vout->p_sys->old_subpic = NULL;
                }
                if (p_vout->p_sys->new_subpic)
                {
                    p_vout->p_sys->old_subpic = p_vout->p_sys->new_subpic;
                    p_vout->p_sys->new_subpic = NULL;
                    xx44_to_xvmc_palette( &p_vout->p_sys->palette,
                            p_vout->p_sys->xvmc_palette,
                            0,
                            p_vout->p_sys->old_subpic->num_palette_entries,
                            p_vout->p_sys->old_subpic->entry_bytes,
                            p_vout->p_sys->old_subpic->component_order );
                    XVMCLOCKDISPLAY( p_vout->p_sys->p_display );
                    XvMCSetSubpicturePalette( p_vout->p_sys->p_display,
                                              p_vout->p_sys->old_subpic,
                                              p_vout->p_sys->xvmc_palette );
                    XvMCFlushSubpicture( p_vout->p_sys->p_display,
                                         p_vout->p_sys->old_subpic);
                    XvMCSyncSubpicture( p_vout->p_sys->p_display,
                                        p_vout->p_sys->old_subpic );
                    XVMCUNLOCKDISPLAY( p_vout->p_sys->p_display );
                }

                XVMCLOCKDISPLAY( p_vout->p_sys->p_display);
                if (p_vout->p_sys->xvmc_backend_subpic )
                {
                    XvMCBlendSubpicture( p_vout->p_sys->p_display,
                                         p_pic->p_sys->xvmc_surf,
                                         p_vout->p_sys->old_subpic,
                                         0,
                                         0,
                                         p_vout->p_sys->xvmc_width,
                                         p_vout->p_sys->xvmc_height,
                                         0,
                                         0,
                                         p_vout->p_sys->xvmc_width,
                                         p_vout->p_sys->xvmc_height );
                }
                else
                {
                    XvMCBlendSubpicture2( p_vout->p_sys->p_display,
                                          p_pic->p_sys->xvmc_surf,
                                          p_pic->p_sys->xvmc_surf,
                                          p_vout->p_sys->old_subpic,
                                          0,
                                          0,
                                          p_vout->p_sys->xvmc_width,
                                          p_vout->p_sys->xvmc_height,
                                          0,
                                          0,
                                          p_vout->p_sys->xvmc_width,
                                          p_vout->p_sys->xvmc_height );
               }
               XVMCUNLOCKDISPLAY(p_vout->p_sys->p_display);
            }
        }
        else
        {
            XVMCLOCKDISPLAY( p_vout->p_sys->p_display );
            if( p_vout->p_sys->xvmc_backend_subpic )
            {
                XvMCBlendSubpicture( p_vout->p_sys->p_display,
                                     p_pic->p_sys->xvmc_surf,
                                     p_vout->p_sys->old_subpic,
                                     0, 0,
                                     p_vout->p_sys->xvmc_width,
                                     p_vout->p_sys->xvmc_height,
                                     0, 0,
                                     p_vout->p_sys->xvmc_width,
                                     p_vout->p_sys->xvmc_height );
            }
            else
            {
                XvMCBlendSubpicture2( p_vout->p_sys->p_display,
                                      p_pic->p_sys->xvmc_surf,
                                      p_pic->p_sys->xvmc_surf,
                                      p_vout->p_sys->old_subpic,
                                      0, 0,
                                      p_vout->p_sys->xvmc_width,
                                      p_vout->p_sys->xvmc_height,
                                      0, 0,
                                      p_vout->p_sys->xvmc_width,
                                      p_vout->p_sys->xvmc_height );
            }
            XVMCUNLOCKDISPLAY( p_vout->p_sys->p_display );
        }
    }
    p_vout->p_sys->p_last_subtitle_save = p_vout->p_last_subtitle;

    vlc_mutex_unlock( &p_vout->lastsubtitle_lock );
#endif
    xvmc_context_reader_unlock( &p_vout->p_sys->xvmc_lock );

    vlc_mutex_unlock( &p_vout->p_sys->lock );
}
#endif

#ifdef HAVE_XSP
/*****************************************************************************
 * EnablePixelDoubling: Enables pixel doubling
 *****************************************************************************
 * Checks if the double size image fits in current window, and enables pixel
 * doubling accordingly. The i_hw_scale is the integer scaling factor.
 *****************************************************************************/
static void EnablePixelDoubling( vout_thread_t *p_vout )
{
    int i_hor_scale = ( p_vout->p_sys->p_win->i_width ) / p_vout->render.i_width;
    int i_vert_scale =  ( p_vout->p_sys->p_win->i_height ) / p_vout->render.i_height;
    if ( ( i_hor_scale > 1 ) && ( i_vert_scale > 1 ) ) {
        p_vout->p_sys->i_hw_scale = 2;
        msg_Dbg( p_vout, "Enabling pixel doubling, scaling factor %d", p_vout->p_sys->i_hw_scale );
        XSPSetPixelDoubling( p_vout->p_sys->p_display, 0, 1 );
    }
}

/*****************************************************************************
 * DisablePixelDoubling: Disables pixel doubling
 *****************************************************************************
 * The scaling factor i_hw_scale is reset to the no-scaling value 1.
 *****************************************************************************/
static void DisablePixelDoubling( vout_thread_t *p_vout )
{
    if ( p_vout->p_sys->i_hw_scale > 1 ) {
        msg_Dbg( p_vout, "Disabling pixel doubling" );
        XSPSetPixelDoubling( p_vout->p_sys->p_display, 0, 0 );
        p_vout->p_sys->i_hw_scale = 1;
    }
}
#endif



/*****************************************************************************
 * InitVideo: initialize X11 video thread output method
 *****************************************************************************
 * This function create the XImages needed by the output thread. It is called
 * at the beginning of the thread, but also each time the window is resized.
 *****************************************************************************/
static int InitVideo( vout_thread_t *p_vout )
{
    unsigned int i_index = 0;
    picture_t *p_pic;

    I_OUTPUTPICTURES = 0;

#if defined(MODULE_NAME_IS_xvideo) || defined(MODULE_NAME_IS_xvmc)
    /* Initialize the output structure; we already found an XVideo port,
     * and the corresponding chroma we will be using. Since we can
     * arbitrary scale, stick to the coordinates and aspect. */
    p_vout->output.i_width  = p_vout->render.i_width;
    p_vout->output.i_height = p_vout->render.i_height;
    p_vout->output.i_aspect = p_vout->render.i_aspect;

    p_vout->fmt_out = p_vout->fmt_in;
    p_vout->fmt_out.i_chroma = p_vout->output.i_chroma;

#if XvVersion < 2 || ( XvVersion == 2 && XvRevision < 2 )
    switch( p_vout->output.i_chroma )
    {
        case VLC_FOURCC('R','V','1','6'):
#if defined( WORDS_BIGENDIAN )
            p_vout->output.i_rmask = 0xf800;
            p_vout->output.i_gmask = 0x07e0;
            p_vout->output.i_bmask = 0x001f;
#else
            p_vout->output.i_rmask = 0x001f;
            p_vout->output.i_gmask = 0x07e0;
            p_vout->output.i_bmask = 0xf800;