Skip to content

V
vlc-1.1
Commit 40ae1df5 authored by Rémi Denis-Courmont's avatar Rémi Denis-Courmont
Browse files
Options

Xlib: remove (most) non-GLX stuff

parent b25a657d
Hide whitespace changes
Inline Side-by-side
Showing with 1 addition and 1468 deletions
modules/video_output/x11/xcommon.c
View file @ 40ae1df5
......@@ -52,10 +52,6 @@
#include <X11/Xproto.h>
#include <X11/Xmd.h>
#include <X11/Xutil.h>
#if defined (HAVE_SYS_SHM_H) && !defined (MODULE_NAME_IS_glx)
# include <sys/shm.h> /* shmget(), shmctl() */
# include <X11/extensions/XShm.h>
#endif
#ifdef DPMSINFO_IN_DPMS_H
# include <X11/extensions/dpms.h>
#endif
......@@ -64,13 +60,6 @@
# include <GL/glx.h>
#endif
#ifdef MODULE_NAME_IS_xvmc
# include <X11/extensions/Xv.h>
# include <X11/extensions/Xvlib.h>
# include <X11/extensions/vldXvMC.h>
# include "../../codec/xvmc/accel_xvmc.h"
#endif
#include "xcommon.h"
/*****************************************************************************
......@@ -79,26 +68,12 @@
int Activate ( vlc_object_t * );
void Deactivate ( vlc_object_t * );
#ifndef MODULE_NAME_IS_glx
static int InitVideo ( vout_thread_t * );
static void EndVideo ( vout_thread_t * );
static void DisplayVideo ( vout_thread_t *, picture_t * );
static int InitDisplay ( vout_thread_t * );
#endif
static int ManageVideo ( vout_thread_t * );
static int Control ( vout_thread_t *, int, va_list );
static int CreateWindow ( vout_thread_t *, x11_window_t * );
static void DestroyWindow ( vout_thread_t *, x11_window_t * );
#ifndef MODULE_NAME_IS_glx
static int NewPicture ( vout_thread_t *, picture_t * );
static void FreePicture ( vout_thread_t *, picture_t * );
# ifdef HAVE_SYS_SHM_H
static int i_shm_major = 0;
# endif
#endif
static void ToggleFullScreen ( vout_thread_t * );
static void EnableXScreenSaver ( vout_thread_t * );
......@@ -108,13 +83,6 @@ static void CreateCursor ( vout_thread_t * );
static void DestroyCursor ( vout_thread_t * );
static void ToggleCursor ( vout_thread_t * );
#if defined(MODULE_NAME_IS_xvmc)
static int XVideoGetPort ( vout_thread_t *, vlc_fourcc_t, picture_heap_t * );
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 int X11ErrorHandler( Display *, XErrorEvent * );
#ifdef HAVE_XSP
......@@ -135,23 +103,8 @@ int Activate ( vlc_object_t *p_this )
{
vout_thread_t *p_vout = (vout_thread_t *)p_this;
char * psz_display;
#if defined(MODULE_NAME_IS_xvmc)
char *psz_value;
char * psz_chroma;
vlc_fourcc_t i_chroma = 0;
bool b_chroma = 0;
#endif
#ifndef MODULE_NAME_IS_glx
p_vout->pf_init = InitVideo;
p_vout->pf_end = EndVideo;
p_vout->pf_display = DisplayVideo;
#endif
#ifdef MODULE_NAME_IS_xvmc
p_vout->pf_render = RenderVideo;
#else
p_vout->pf_render = NULL;
#endif
p_vout->pf_manage = ManageVideo;
p_vout->pf_control = Control;
......@@ -182,69 +135,7 @@ int Activate ( vlc_object_t *p_this )
/* 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_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 = vlc_fourcc_GetCodec( VIDEO_ES, X112VLC_FOURCC(p_vout->output.i_chroma) );
#elif defined(MODULE_NAME_IS_glx)
#if defined(MODULE_NAME_IS_glx)
{
int i_opcode, i_evt, i_err = 0;
int i_maj, i_min = 0;
......@@ -311,80 +202,12 @@ int Activate ( vlc_object_t *p_this )
return VLC_EGENERIC;
}
#ifndef MODULE_NAME_IS_glx
/* 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->window );
XCloseDisplay( p_vout->p_sys->p_display );
free( p_vout->p_sys );
return VLC_EGENERIC;
}
#endif
/* Disable screen saver */
DisableXScreenSaver( p_vout );
/* Misc init */
p_vout->p_sys->i_time_button_last_pressed = 0;
#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_this );
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
......@@ -411,26 +234,6 @@ void Deactivate ( vlc_object_t *p_this )
ToggleCursor( p_vout );
}
#if 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
......@@ -441,247 +244,9 @@ void Deactivate ( vlc_object_t *p_this )
XCloseDisplay( p_vout->p_sys->p_display );
/* Destroy structure */
#ifdef MODULE_NAME_IS_xvmc
free_context_lock( &p_vout->p_sys->xvmc_lock );
#endif
free( p_vout->p_sys );
}
#ifdef MODULE_NAME_IS_xvmc
#define XINE_IMGFMT_YV12 (('2'<<24)|('1'<<16)|('V'<<8)|'Y')
/* called xlocked */
#if 0
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;
}
#endif
#if 0
static void xvmc_sync_surface( vout_thread_t *p_vout, XvMCSurface * srf )
{
XvMCSyncSurface( p_vout->p_sys->p_display, srf );
}
#endif
#if 0
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);
}
#endif
static void RenderVideo( vout_thread_t *p_vout, picture_t *p_pic )
{
vlc_xxmc_t *xxmc = NULL;
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 )) )
{
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 );
}
#endif
#ifdef HAVE_XSP
/*****************************************************************************
* EnablePixelDoubling: Enables pixel doubling
......@@ -716,259 +281,6 @@ static void DisablePixelDoubling( vout_thread_t *p_vout )
#endif
#if !defined(MODULE_NAME_IS_glx)
/*****************************************************************************
* 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_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_CODEC_RGB16:
#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;
#endif
break;
case VLC_CODEC_RGB15:
#if defined( WORDS_BIGENDIAN )
p_vout->output.i_rmask = 0x7c00;
p_vout->output.i_gmask = 0x03e0;
p_vout->output.i_bmask = 0x001f;
#else
p_vout->output.i_rmask = 0x001f;
p_vout->output.i_gmask = 0x03e0;
p_vout->output.i_bmask = 0x7c00;
#endif
break;
}
#endif
#endif
/* Try to initialize up to MAX_DIRECTBUFFERS direct buffers */
while( I_OUTPUTPICTURES < MAX_DIRECTBUFFERS )
{
p_pic = NULL;
/* Find an empty picture slot */
for( i_index = 0 ; i_index < VOUT_MAX_PICTURES ; i_index++ )
{
if( p_vout->p_picture[ i_index ].i_status == FREE_PICTURE )
{
p_pic = p_vout->p_picture + i_index;
break;
}
}
/* Allocate the picture */
if( p_pic == NULL || NewPicture( p_vout, p_pic ) )
{
break;
}
p_pic->i_status = DESTROYED_PICTURE;
p_pic->i_type = DIRECT_PICTURE;
PP_OUTPUTPICTURE[ I_OUTPUTPICTURES ] = p_pic;
I_OUTPUTPICTURES++;
}
if( p_vout->output.i_chroma == VLC_CODEC_YV12 )
{
/* U and V inverted compared to I420
* Fixme: this should be handled by the vout core */
p_vout->output.i_chroma = VLC_CODEC_I420;
p_vout->fmt_out.i_chroma = VLC_CODEC_I420;
}
return VLC_SUCCESS;
}
/*****************************************************************************
* DisplayVideo: displays previously rendered output
*****************************************************************************
* This function sends the currently rendered image to X11 server.
* (The Xv extension takes care of "double-buffering".)
*****************************************************************************/
static void DisplayVideo( vout_thread_t *p_vout, picture_t *p_pic )
{
unsigned int i_width, i_height, i_x, i_y;
vout_PlacePicture( p_vout, p_vout->p_sys->window.i_width,
p_vout->p_sys->window.i_height,
&i_x, &i_y, &i_width, &i_height );
#ifdef MODULE_NAME_IS_xvmc
xvmc_context_reader_lock( &p_vout->p_sys->xvmc_lock );
vlc_xxmc_t *xxmc = &p_pic->p_sys->xxmc_data;
if( !xxmc->decoded ||
!xxmc_xvmc_surface_valid( p_vout, p_pic->p_sys->xvmc_surf ) )
{
msg_Dbg( p_vout, "DisplayVideo decoded=%d\tsurfacevalid=%d",
xxmc->decoded,
xxmc_xvmc_surface_valid( p_vout, p_pic->p_sys->xvmc_surf ) );
xvmc_context_reader_unlock( &p_vout->p_sys->xvmc_lock );
return;
}
int src_width = p_vout->output.i_width;
int src_height = p_vout->output.i_height;
int src_x, src_y;
if( p_vout->p_sys->xvmc_crop_style == 1 )
{
src_x = 20;
src_y = 20;
src_width -= 40;
src_height -= 40;
}
else if( p_vout->p_sys->xvmc_crop_style == 2 )
{
src_x = 20;
src_y = 40;
src_width -= 40;
src_height -= 80;
}
else if( p_vout->p_sys->xvmc_crop_style == 3 )
{
src_x = 40;
src_y = 20;
src_width -= 80;
src_height -= 40;
}
else
{
src_x = 0;
src_y = 0;
}
int first_field;
if( p_vout->p_sys->xvmc_deinterlace_method > 0 )
{ /* BOB DEINTERLACE */
if( (p_pic->p_sys->nb_display == 0) ||
(p_vout->p_sys->xvmc_deinterlace_method == 1) )
{
first_field = (p_pic->b_top_field_first) ?
XVMC_BOTTOM_FIELD : XVMC_TOP_FIELD;
}
else
{
first_field = (p_pic->b_top_field_first) ?
XVMC_TOP_FIELD : XVMC_BOTTOM_FIELD;
}
}
else
{
first_field = XVMC_FRAME_PICTURE;
}
XVMCLOCKDISPLAY( p_vout->p_sys->p_display );
XvMCFlushSurface( p_vout->p_sys->p_display, p_pic->p_sys->xvmc_surf );
/* XvMCSyncSurface(p_vout->p_sys->p_display, p_picture->p_sys->xvmc_surf); */
XvMCPutSurface( p_vout->p_sys->p_display,
p_pic->p_sys->xvmc_surf,
p_vout->p_sys->window.video_window,
src_x,
src_y,
src_width,
src_height,
0 /*dest_x*/,
0 /*dest_y*/,
i_width,
i_height,
first_field);
XVMCUNLOCKDISPLAY( p_vout->p_sys->p_display );
if( p_vout->p_sys->xvmc_deinterlace_method == 2 )
{ /* BOB DEINTERLACE */
if( p_pic->p_sys->nb_display == 0 )/* && ((t2-t1) < 15000)) */
{
mtime_t last_date = p_pic->date;
vlc_mutex_lock( &p_vout->picture_lock );
if( !p_vout->p_sys->last_date )
{
p_pic->date += 20000;
}
else
{
p_pic->date = ((3 * p_pic->date -
p_vout->p_sys->last_date) / 2 );
}
p_vout->p_sys->last_date = last_date;
p_pic->b_force = 1;
p_pic->p_sys->nb_display = 1;
vlc_mutex_unlock( &p_vout->picture_lock );
}
else
{
p_pic->p_sys->nb_display = 0;
p_pic->b_force = 0;
}
}
xvmc_context_reader_unlock( &p_vout->p_sys->xvmc_lock );
#endif
#ifdef HAVE_SYS_SHM_H
if( p_vout->p_sys->i_shm_opcode )
{
/* Display rendered image using shared memory extension */
XvShmPutImage( p_vout->p_sys->p_display, p_vout->p_sys->i_xvport,
p_vout->p_sys->window.video_window,
p_vout->p_sys->window.gc, p_pic->p_sys->p_image,
p_vout->fmt_out.i_x_offset,
p_vout->fmt_out.i_y_offset,
p_vout->fmt_out.i_visible_width,
p_vout->fmt_out.i_visible_height,
0 /*dest_x*/, 0 /*dest_y*/, i_width, i_height,
False /* Don't put True here or you'll waste your CPU */ );
}
else
#endif /* HAVE_SYS_SHM_H */
{
/* Use standard XPutImage -- this is gonna be slow ! */
XvPutImage( p_vout->p_sys->p_display, p_vout->p_sys->i_xvport,
p_vout->p_sys->window.video_window,
p_vout->p_sys->window.gc, p_pic->p_sys->p_image,
p_vout->fmt_out.i_x_offset,
p_vout->fmt_out.i_y_offset,
p_vout->fmt_out.i_visible_width,
p_vout->fmt_out.i_visible_height,
0 /*dest_x*/, 0 /*dest_y*/, i_width, i_height );
}
/* Make sure the command is sent now - do NOT use XFlush !*/
XSync( p_vout->p_sys->p_display, False );
}
#endif
/*****************************************************************************
* ManageVideo: handle X11 events
*****************************************************************************
......@@ -981,10 +293,6 @@ static int ManageVideo( vout_thread_t *p_vout )
XEvent xevent; /* X11 event */
vlc_value_t val;
#ifdef MODULE_NAME_IS_xvmc
xvmc_context_reader_lock( &p_vout->p_sys->xvmc_lock );
#endif
/* Handle events from the owner window */
while( XCheckWindowEvent( p_vout->p_sys->p_display,
p_vout->p_sys->window.owner_window->handle.xid,
......@@ -1289,33 +597,9 @@ static int ManageVideo( vout_thread_t *p_vout )
}
}
#ifdef MODULE_NAME_IS_xvmc
xvmc_context_reader_unlock( &p_vout->p_sys->xvmc_lock );
#endif
return 0;
}
#if !defined( MODULE_NAME_IS_glx )
/*****************************************************************************
* EndVideo: terminate X11 video thread output method
*****************************************************************************
* Destroy the X11 XImages created by Init. It is called at the end of
* the thread, but also each time the window is resized.
*****************************************************************************/
static void EndVideo( vout_thread_t *p_vout )
{
int i_index;
/* Free the direct buffers we allocated */
for( i_index = I_OUTPUTPICTURES ; i_index ; )
{
i_index--;
FreePicture( p_vout, PP_OUTPUTPICTURE[ i_index ] );
}
}
#endif
/* following functions are local */
/*****************************************************************************
......@@ -1504,166 +788,6 @@ static void DestroyWindow( vout_thread_t *p_vout, x11_window_t *p_win )
vout_window_Delete( p_win->owner_window );
}
/*****************************************************************************
* NewPicture: allocate a picture
*****************************************************************************
* Returns 0 on success, -1 otherwise
*****************************************************************************/
#if !defined(MODULE_NAME_IS_glx)
static int NewPicture( vout_thread_t *p_vout, picture_t *p_pic )
{
int i_plane;
/* We know the chroma, allocate a buffer which will be used
* directly by the decoder */
p_pic->p_sys = malloc( sizeof( picture_sys_t ) );
if( p_pic->p_sys == NULL )
{
return -1;
}
#ifdef MODULE_NAME_IS_xvmc
p_pic->p_sys->p_vout = p_vout;
p_pic->p_sys->xvmc_surf = NULL;
p_pic->p_sys->xxmc_data.decoded = 0;
p_pic->p_sys->xxmc_data.proc_xxmc_update_frame = xxmc_do_update_frame;
// p_pic->p_accel_data = &p_pic->p_sys->xxmc_data;
p_pic->p_sys->nb_display = 0;
#endif
/* Fill in picture_t fields */
if( picture_Setup( p_pic, p_vout->output.i_chroma,
p_vout->output.i_width, p_vout->output.i_height,
p_vout->output.i_aspect ) )
return -1;
#ifdef HAVE_SYS_SHM_H
if( p_vout->p_sys->i_shm_opcode )
{
/* Create image using XShm extension */
p_pic->p_sys->p_image =
CreateShmImage( p_vout, p_vout->p_sys->p_display,
p_vout->p_sys->i_xvport,
VLC2X11_FOURCC(p_vout->output.i_chroma),
&p_pic->p_sys->shminfo,
p_vout->output.i_width, p_vout->output.i_height );
}
if( !p_vout->p_sys->i_shm_opcode || !p_pic->p_sys->p_image )
#endif /* HAVE_SYS_SHM_H */
{
/* Create image without XShm extension */
p_pic->p_sys->p_image =
CreateImage( p_vout, p_vout->p_sys->p_display,
p_vout->p_sys->i_xvport,
VLC2X11_FOURCC(p_vout->output.i_chroma),
p_pic->format.i_bits_per_pixel,
p_vout->output.i_width, p_vout->output.i_height );
#ifdef HAVE_SYS_SHM_H
if( p_pic->p_sys->p_image && p_vout->p_sys->i_shm_opcode )
{
msg_Warn( p_vout, "couldn't create SHM image, disabling SHM" );
p_vout->p_sys->i_shm_opcode = 0;
}
#endif /* HAVE_SYS_SHM_H */
}
if( p_pic->p_sys->p_image == NULL )
{
free( p_pic->p_sys );
return -1;
}
switch( p_vout->output.i_chroma )
{
case VLC_CODEC_I420:
case VLC_CODEC_YV12:
case VLC_CODEC_Y211:
case VLC_CODEC_YUYV:
case VLC_CODEC_UYVY:
case VLC_CODEC_RGB15:
case VLC_CODEC_RGB16:
case VLC_CODEC_RGB24: /* Fixme: pixel pitch == 4 ? */
case VLC_CODEC_RGB32:
for( i_plane = 0; i_plane < p_pic->p_sys->p_image->num_planes;
i_plane++ )
{
p_pic->p[i_plane].p_pixels = (uint8_t*)p_pic->p_sys->p_image->data
+ p_pic->p_sys->p_image->offsets[i_plane];
p_pic->p[i_plane].i_pitch =
p_pic->p_sys->p_image->pitches[i_plane];
}
if( p_vout->output.i_chroma == VLC_CODEC_YV12 )
{
/* U and V inverted compared to I420
* Fixme: this should be handled by the vout core */
p_pic->U_PIXELS = (uint8_t*)p_pic->p_sys->p_image->data
+ p_pic->p_sys->p_image->offsets[2];
p_pic->V_PIXELS = (uint8_t*)p_pic->p_sys->p_image->data
+ p_pic->p_sys->p_image->offsets[1];
}
break;
default:
/* Unknown chroma, tell the guy to get lost */
IMAGE_FREE( p_pic->p_sys->p_image );
free( p_pic->p_sys );
msg_Err( p_vout, "never heard of chroma 0x%.8x (%4.4s)",
p_vout->output.i_chroma, (char*)&p_vout->output.i_chroma );
p_pic->i_planes = 0;
return -1;
}
return 0;
}
/*****************************************************************************
* FreePicture: destroy a picture allocated with NewPicture
*****************************************************************************
* Destroy XImage AND associated data. If using Shm, detach shared memory
* segment from server and process, then free it. The XDestroyImage manpage
* says that both the image structure _and_ the data pointed to by the
* image structure are freed, so no need to free p_image->data.
*****************************************************************************/
static void FreePicture( vout_thread_t *p_vout, picture_t *p_pic )
{
/* The order of operations is correct */
#ifdef HAVE_SYS_SHM_H
if( p_vout->p_sys->i_shm_opcode )
{
XShmDetach( p_vout->p_sys->p_display, &p_pic->p_sys->shminfo );
IMAGE_FREE( p_pic->p_sys->p_image );
shmctl( p_pic->p_sys->shminfo.shmid, IPC_RMID, 0 );
if( shmdt( p_pic->p_sys->shminfo.shmaddr ) )
{
msg_Err( p_vout, "cannot detach shared memory (%m)" );
}
}
else
#endif
{
IMAGE_FREE( p_pic->p_sys->p_image );
}
#ifdef MODULE_NAME_IS_xvmc
if( p_pic->p_sys->xvmc_surf != NULL )
{
xxmc_xvmc_free_surface(p_vout , p_pic->p_sys->xvmc_surf);
p_pic->p_sys->xvmc_surf = NULL;
}
#endif
/* Do NOT use XFlush here ! */
XSync( p_vout->p_sys->p_display, False );
free( p_pic->p_sys );
}
#endif /* !MODULE_NAME_IS_glx */
/*****************************************************************************
* ToggleFullScreen: Enable or disable full screen mode
*****************************************************************************
......@@ -1816,334 +940,6 @@ static void ToggleCursor( vout_thread_t *p_vout )
}
}
#if defined(MODULE_NAME_IS_xvmc)
/*****************************************************************************
* XVideoGetPort: get YUV12 port
*****************************************************************************/
static int XVideoGetPort( vout_thread_t *p_vout,
vlc_fourcc_t i_chroma, picture_heap_t *p_heap )
{
XvAdaptorInfo *p_adaptor;
unsigned int i;
unsigned int i_adaptor, i_num_adaptors;
int i_requested_adaptor;
int i_selected_port;
switch( XvQueryExtension( p_vout->p_sys->p_display, &i, &i, &i, &i, &i ) )
{
case Success:
break;
case XvBadExtension:
msg_Warn( p_vout, "XvBadExtension" );
return -1;
case XvBadAlloc:
msg_Warn( p_vout, "XvBadAlloc" );
return -1;
default:
msg_Warn( p_vout, "XvQueryExtension failed" );
return -1;
}
switch( XvQueryAdaptors( p_vout->p_sys->p_display,
DefaultRootWindow( p_vout->p_sys->p_display ),
&i_num_adaptors, &p_adaptor ) )
{
case Success:
break;
case XvBadExtension:
msg_Warn( p_vout, "XvBadExtension for XvQueryAdaptors" );
return -1;
case XvBadAlloc:
msg_Warn( p_vout, "XvBadAlloc for XvQueryAdaptors" );
return -1;
default:
msg_Warn( p_vout, "XvQueryAdaptors failed" );
return -1;
}
i_selected_port = -1;
i_requested_adaptor = config_GetInt( p_vout, "xvmc-adaptor" );
for( i_adaptor = 0; i_adaptor < i_num_adaptors; ++i_adaptor )
{
XvImageFormatValues *p_formats;
int i_format, i_num_formats;
int i_port;
/* If we requested an adaptor and it's not this one, we aren't
* interested */
if( i_requested_adaptor != -1 && ((int)i_adaptor != i_requested_adaptor) )
{
continue;
}
/* If the adaptor doesn't have the required properties, skip it */
if( !( p_adaptor[ i_adaptor ].type & XvInputMask ) ||
!( p_adaptor[ i_adaptor ].type & XvImageMask ) )
{
continue;
}
/* Check that adaptor supports our requested format... */
p_formats = XvListImageFormats( p_vout->p_sys->p_display,
p_adaptor[i_adaptor].base_id,
&i_num_formats );
for( i_format = 0;
i_format < i_num_formats && ( i_selected_port == -1 );
i_format++ )
{
XvAttribute *p_attr;
int i_attr, i_num_attributes;
Atom autopaint = None, colorkey = None;
/* If this is not the format we want, or at least a
* similar one, forget it */
if( !vout_ChromaCmp( p_formats[ i_format ].id, i_chroma ) )
{
continue;
}
/* Look for the first available port supporting this format */
for( i_port = p_adaptor[i_adaptor].base_id;
( i_port < (int)(p_adaptor[i_adaptor].base_id
+ p_adaptor[i_adaptor].num_ports) )
&& ( i_selected_port == -1 );
i_port++ )
{
if( XvGrabPort( p_vout->p_sys->p_display, i_port, CurrentTime )
== Success )
{
i_selected_port = i_port;
p_heap->i_chroma = p_formats[ i_format ].id;
#if XvVersion > 2 || ( XvVersion == 2 && XvRevision >= 2 )
p_heap->i_rmask = p_formats[ i_format ].red_mask;
p_heap->i_gmask = p_formats[ i_format ].green_mask;
p_heap->i_bmask = p_formats[ i_format ].blue_mask;
#endif
}
}
/* If no free port was found, forget it */
if( i_selected_port == -1 )
{
continue;
}
/* If we found a port, print information about it */
msg_Dbg( p_vout, "adaptor %i, port %i, format 0x%x (%4.4s) %s",
i_adaptor, i_selected_port, p_formats[ i_format ].id,
(char *)&p_formats[ i_format ].id,
( p_formats[ i_format ].format == XvPacked ) ?
"packed" : "planar" );
/* Use XV_AUTOPAINT_COLORKEY if supported, otherwise we will
* manually paint the colour key */
p_attr = XvQueryPortAttributes( p_vout->p_sys->p_display,
i_selected_port,
&i_num_attributes );
for( i_attr = 0; i_attr < i_num_attributes; i_attr++ )
{
if( !strcmp( p_attr[i_attr].name, "XV_AUTOPAINT_COLORKEY" ) )
{
autopaint = XInternAtom( p_vout->p_sys->p_display,
"XV_AUTOPAINT_COLORKEY", False );
XvSetPortAttribute( p_vout->p_sys->p_display,
i_selected_port, autopaint, 1 );
}
if( !strcmp( p_attr[i_attr].name, "XV_COLORKEY" ) )
{
/* Find out the default colour key */
colorkey = XInternAtom( p_vout->p_sys->p_display,
"XV_COLORKEY", False );
XvGetPortAttribute( p_vout->p_sys->p_display,
i_selected_port, colorkey,
&p_vout->p_sys->i_colourkey );
}
}
p_vout->p_sys->b_paint_colourkey =
autopaint == None && colorkey != None;
if( p_attr != NULL )
{
XFree( p_attr );
}
}
if( p_formats != NULL )
{
XFree( p_formats );
}
}
if( i_num_adaptors > 0 )
{
XvFreeAdaptorInfo( p_adaptor );
}
if( i_selected_port == -1 )
{
int i_chroma_tmp = X112VLC_FOURCC( i_chroma );
if( i_requested_adaptor == -1 )
{
msg_Warn( p_vout, "no free XVideo port found for format "
"0x%.8x (%4.4s)", i_chroma_tmp, (char*)&i_chroma_tmp );
}
else
{
msg_Warn( p_vout, "XVideo adaptor %i does not have a free "
"XVideo port for format 0x%.8x (%4.4s)",
i_requested_adaptor, i_chroma_tmp, (char*)&i_chroma_tmp );
}
}
return i_selected_port;
}
#endif
#ifndef MODULE_NAME_IS_glx
/*****************************************************************************
* InitDisplay: open and initialize X11 device
*****************************************************************************
* Create a window according to video output given size, and set other
* properties according to the display properties.
*****************************************************************************/
static int InitDisplay( vout_thread_t *p_vout )
{
#ifdef HAVE_SYS_SHM_H
p_vout->p_sys->i_shm_opcode = 0;
if( config_GetInt( p_vout, MODULE_STRING "-shm" ) > 0 )
{
int major, evt, err;
if( XQueryExtension( p_vout->p_sys->p_display, "MIT-SHM", &major,
&evt, &err )
&& XShmQueryExtension( p_vout->p_sys->p_display ) )
p_vout->p_sys->i_shm_opcode = major;
if( p_vout->p_sys->i_shm_opcode )
{
int minor;
Bool pixmaps;
XShmQueryVersion( p_vout->p_sys->p_display, &major, &minor,
&pixmaps );
msg_Dbg( p_vout, "XShm video extension v%d.%d "
"(with%s pixmaps, opcode: %d)",
major, minor, pixmaps ? "" : "out",
p_vout->p_sys->i_shm_opcode );
}
else
msg_Warn( p_vout, "XShm video extension not available" );
}
else
msg_Dbg( p_vout, "XShm video extension disabled" );
#endif
return VLC_SUCCESS;
}
#ifdef HAVE_SYS_SHM_H
/*****************************************************************************
* CreateShmImage: create an XImage or XvImage using shared memory extension
*****************************************************************************
* Prepare an XImage or XvImage for display function.
* The order of the operations respects the recommandations of the mit-shm
* document by J.Corbet and K.Packard. Most of the parameters were copied from
* there. See http://ftp.xfree86.org/pub/XFree86/4.0/doc/mit-shm.TXT
*****************************************************************************/
IMAGE_TYPE * CreateShmImage( vout_thread_t *p_vout,
Display* p_display, EXTRA_ARGS_SHM,
int i_width, int i_height )
{
IMAGE_TYPE *p_image;
Status result;
/* Create XImage / XvImage */
#if defined(MODULE_NAME_IS_xvmc)
p_image = XvShmCreateImage( p_display, i_xvport, i_chroma, 0,
i_width, i_height, p_shm );
#endif
if( p_image == NULL )
{
msg_Err( p_vout, "image creation failed" );
return NULL;
}
/* For too big image, the buffer returned is sometimes too small, prevent
* VLC to segfault because of it
* FIXME is it normal ? Is there a way to detect it
* before (XvQueryBestSize did not) ? */
if( p_image->width < i_width || p_image->height < i_height )
{
msg_Err( p_vout, "cannot allocate shared image data with the right size "
"(%dx%d instead of %dx%d)",
p_image->width, p_image->height,
i_width, i_height );
IMAGE_FREE( p_image );
return NULL;
}
/* Allocate shared memory segment. */
p_shm->shmid = shmget( IPC_PRIVATE, DATA_SIZE(p_image), IPC_CREAT | 0600 );
if( p_shm->shmid < 0 )
{
msg_Err( p_vout, "cannot allocate shared image data (%m)" );
IMAGE_FREE( p_image );
return NULL;
}
/* Attach shared memory segment to process (read/write) */
p_shm->shmaddr = p_image->data = shmat( p_shm->shmid, 0, 0 );
if(! p_shm->shmaddr )
{
msg_Err( p_vout, "cannot attach shared memory (%m)" );
IMAGE_FREE( p_image );
shmctl( p_shm->shmid, IPC_RMID, 0 );
return NULL;
}
/* Read-only data. We won't be using XShmGetImage */
p_shm->readOnly = True;
/* Attach shared memory segment to X server */
XSynchronize( p_display, True );
i_shm_major = p_vout->p_sys->i_shm_opcode;
result = XShmAttach( p_display, p_shm );
if( result == False || !i_shm_major )
{
msg_Err( p_vout, "cannot attach shared memory to X server" );
IMAGE_FREE( p_image );
shmctl( p_shm->shmid, IPC_RMID, 0 );
shmdt( p_shm->shmaddr );
return NULL;
}
XSynchronize( p_display, False );
/* Send image to X server. This instruction is required, since having
* built a Shm XImage and not using it causes an error on XCloseDisplay,
* and remember NOT to use XFlush ! */
XSync( p_display, False );
#if 0
/* Mark the shm segment to be removed when there are no more
* attachements, so it is automatic on process exit or after shmdt */
shmctl( p_shm->shmid, IPC_RMID, 0 );
#endif
return p_image;
}
#endif
#endif
/*****************************************************************************
* X11ErrorHandler: replace error handler so we can intercept some of them
*****************************************************************************/
......@@ -2165,18 +961,6 @@ static int X11ErrorHandler( Display * display, XErrorEvent * event )
return 0;
}
#if defined (HAVE_SYS_SHM_H) && !defined (MODULE_NAME_IS_glx)
if( event->request_code == i_shm_major ) /* MIT-SHM */
{
fprintf( stderr,
"[????????] x11 video output notice:"
" buggy X11 server claims shared memory\n"
"[????????] x11 video output notice:"
" support though it does not work (OpenSSH?)\n" );
return i_shm_major = 0;
}
#endif
XSetErrorHandler(NULL);
return (XSetErrorHandler(X11ErrorHandler))( display, event );
}
......
modules/video_output/x11/xcommon.h
View file @ 40ae1df5
......@@ -27,30 +27,6 @@
/*****************************************************************************
* Defines
*****************************************************************************/
#if defined(MODULE_NAME_IS_xvmc)
# define IMAGE_TYPE XvImage
# define EXTRA_ARGS int i_xvport, int i_chroma, int i_bits_per_pixel
# define EXTRA_ARGS_SHM int i_xvport, int i_chroma, XShmSegmentInfo *p_shm
# define DATA_SIZE(p) (p)->data_size
# define IMAGE_FREE XFree /* There is nothing like XvDestroyImage */
#else
# define IMAGE_TYPE XImage
# define EXTRA_ARGS Visual *p_visual, int i_depth, int i_bytes_per_pixel
# define EXTRA_ARGS_SHM Visual *p_visual, int i_depth, XShmSegmentInfo *p_shm
# define DATA_SIZE(p) ((p)->bytes_per_line * (p)->height)
# define IMAGE_FREE XDestroyImage
#endif
#define X11_FOURCC( a, b, c, d ) \
( ((uint32_t)a) | ( ((uint32_t)b) << 8 ) \
| ( ((uint32_t)c) << 16 ) | ( ((uint32_t)d) << 24 ) )
#define VLC2X11_FOURCC( i ) \
X11_FOURCC( ((char *)&i)[0], ((char *)&i)[1], ((char *)&i)[2], \
((char *)&i)[3] )
#define X112VLC_FOURCC( i ) \
VLC_FOURCC( i & 0xff, (i >> 8) & 0xff, (i >> 16) & 0xff, \
(i >> 24) & 0xff )
struct vout_window_t;
/*****************************************************************************
......@@ -74,123 +50,6 @@ typedef struct x11_window_t
Atom wm_delete_window;
} x11_window_t;
/*****************************************************************************
* Xxmc defines
*****************************************************************************/
#ifdef MODULE_NAME_IS_xvmc
typedef struct
{ /* CLUT == Color LookUp Table */
uint8_t cb;
uint8_t cr;
uint8_t y;
uint8_t foo;
} clut_t;
#define XX44_PALETTE_SIZE 32
#define OVL_PALETTE_SIZE 256
#define XVMC_MAX_SURFACES 16
#define XVMC_MAX_SUBPICTURES 4
#define FOURCC_IA44 0x34344149
#define FOURCC_AI44 0x34344941
typedef struct
{
unsigned size;
unsigned max_used;
uint32_t cluts[XX44_PALETTE_SIZE];
/* cache palette entries for both colors and clip_colors */
int lookup_cache[OVL_PALETTE_SIZE*2];
} xx44_palette_t;
/*
* Functions to handle the vlc-specific palette.
*/
void clear_xx44_palette( xx44_palette_t *p );
/*
* Convert the xine-specific palette to something useful.
*/
void xx44_to_xvmc_palette( const xx44_palette_t *p,unsigned char *xvmc_palette,
unsigned first_xx44_entry, unsigned num_xx44_entries,
unsigned num_xvmc_components, char *xvmc_components );
typedef struct
{
vlc_macroblocks_t vlc_mc;
XvMCBlockArray blocks; /* pointer to memory for dct block array */
int num_blocks;
XvMCMacroBlock *macroblockptr; /* pointer to current macro block */
XvMCMacroBlock *macroblockbaseptr; /* pointer to base MacroBlock in MB array */
XvMCMacroBlockArray macro_blocks; /* pointer to memory for macroblock array */
int slices;
} xvmc_macroblocks_t;
typedef struct
{
unsigned int mpeg_flags;
unsigned int accel_flags;
unsigned int max_width;
unsigned int max_height;
unsigned int sub_max_width;
unsigned int sub_max_height;
int type_id;
XvImageFormatValues subPicType;
int flags;
} xvmc_capabilities_t;
typedef struct xvmc_surface_handler_s
{
XvMCSurface surfaces[XVMC_MAX_SURFACES];
int surfInUse[XVMC_MAX_SURFACES];
int surfValid[XVMC_MAX_SURFACES];
XvMCSubpicture subpictures[XVMC_MAX_SUBPICTURES];
int subInUse[XVMC_MAX_SUBPICTURES];
int subValid[XVMC_MAX_SUBPICTURES];
pthread_mutex_t mutex;
} xvmc_surface_handler_t;
typedef struct context_lock_s
{
pthread_mutex_t mutex;
pthread_cond_t cond;
int num_readers;
} context_lock_t;
#define XVMCLOCKDISPLAY(display) XLockDisplay(display);
#define XVMCUNLOCKDISPLAY(display) XUnlockDisplay(display);
void xvmc_context_reader_unlock( context_lock_t *c );
void xvmc_context_reader_lock( context_lock_t *c );
void xvmc_context_writer_lock( context_lock_t *c );
void xvmc_context_writer_unlock( context_lock_t *c );
void free_context_lock( context_lock_t *c );
void xxmc_dispose_context( vout_thread_t *p_vout );
int xxmc_xvmc_surface_valid( vout_thread_t *p_vout, XvMCSurface *surf );
void xxmc_xvmc_free_surface( vout_thread_t *p_vout, XvMCSurface *surf );
void xvmc_vld_slice( picture_t *picture );
void xvmc_vld_frame( picture_t *picture );
void xxmc_do_update_frame( picture_t *picture, uint32_t width, uint32_t height,
double ratio, int format, int flags);
int checkXvMCCap( vout_thread_t *p_vout);
XvMCSubpicture *xxmc_xvmc_alloc_subpicture( vout_thread_t *p_vout,
XvMCContext *context, unsigned short width, unsigned short height,
int xvimage_id );
void xxmc_xvmc_free_subpicture( vout_thread_t *p_vout, XvMCSubpicture *sub );
void blend_xx44( uint8_t *dst_img, subpicture_t *sub_img, int dst_width,
int dst_height, int dst_pitch, xx44_palette_t *palette,int ia44);
#endif /* XvMC defines */
/*****************************************************************************
* vout_sys_t: video output method descriptor
*****************************************************************************
......@@ -207,17 +66,6 @@ struct vout_sys_t
/* Our window */
x11_window_t window;
/* X11 generic properties */
#if defined (HAVE_SYS_SHM_H) && !defined (MODULE_NAME_IS_glx)
int i_shm_opcode; /* shared memory extension opcode */
#endif
#if defined(MODULE_NAME_IS_xvmc)
int i_xvport;
bool b_paint_colourkey;
int i_colourkey;
#endif
/* Screen saver properties */
int i_ss_timeout; /* timeout */
int i_ss_interval; /* interval between changes */
......@@ -242,92 +90,11 @@ struct vout_sys_t
GLXWindow gwnd;
#endif
#ifdef MODULE_NAME_IS_xvmc
/* XvMC related stuff here */
xvmc_macroblocks_t macroblocks;
xvmc_capabilities_t *xvmc_cap;
unsigned int xvmc_num_cap;
unsigned int xvmc_max_subpic_x;
unsigned int xvmc_max_subpic_y;
int xvmc_eventbase;
int xvmc_errbase;
int hwSubpictures;
XvMCSubpicture *old_subpic;
XvMCSubpicture *new_subpic;
xx44_palette_t palette;
int first_overlay;
float cpu_saver;
int cpu_save_enabled;
int reverse_nvidia_palette;
int context_flags;
/*
* These variables are protected by the context lock:
*/
unsigned xvmc_cur_cap;
int xvmc_backend_subpic;
XvMCContext context;
int contextActive;
xvmc_surface_handler_t xvmc_surf_handler;
unsigned xvmc_mpeg;
unsigned xvmc_accel;
unsigned last_accel_request;
unsigned xvmc_width;
unsigned xvmc_height;
int have_xvmc_autopaint;
int xvmc_xoverlay_type;
int unsigned_intra;
/*
* Only creation and destruction of the below.
*/
char *xvmc_palette;
XvImage *subImage;
XShmSegmentInfo subShmInfo;
/*
* The mutex below is needed since XlockDisplay wasn't really enough
* to protect the XvMC Calls.
*/
context_lock_t xvmc_lock;
subpicture_t * p_last_subtitle_save;
int xvmc_deinterlace_method;
int xvmc_crop_style;
mtime_t last_date;
//alphablend_t alphablend_extra_data;
#endif
#ifdef HAVE_XSP
int i_hw_scale;
#endif
};
#ifndef MODULE_NAME_IS_glx
/*****************************************************************************
* picture_sys_t: direct buffer method descriptor
*****************************************************************************
* This structure is part of the picture descriptor, it describes the
* XVideo specific properties of a direct buffer.
*****************************************************************************/
struct picture_sys_t
{
IMAGE_TYPE * p_image;
#ifdef HAVE_SYS_SHM_H
XShmSegmentInfo shminfo; /* shared memory zone information */
#endif
#ifdef MODULE_NAME_IS_xvmc
XvMCSurface *xvmc_surf;
vlc_xxmc_t xxmc_data;
int last_sw_format;
vout_thread_t *p_vout;
int nb_display;
#endif
};
#endif
/*****************************************************************************
* mwmhints_t: window manager hints
*****************************************************************************
......@@ -346,21 +113,3 @@ typedef struct mwmhints_t
unsigned long status;
} mwmhints_t;
/*****************************************************************************
* Chroma defines
*****************************************************************************/
#if defined(MODULE_NAME_IS_xvmc)
# define MAX_DIRECTBUFFERS (VOUT_MAX_PICTURES+2)
#else
# define MAX_DIRECTBUFFERS 2
#endif
#ifndef MODULE_NAME_IS_glx
IMAGE_TYPE *CreateImage ( vout_thread_t *,
Display *, EXTRA_ARGS, int, int );
#ifdef HAVE_SYS_SHM_H
IMAGE_TYPE *CreateShmImage ( vout_thread_t *,
Display *, EXTRA_ARGS_SHM, int, int );
#endif
#endif
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment