# include "config.h"
#endif
-#include <vlc/vlc.h>
+#include <vlc_common.h>
#include <vlc_interface.h>
#include <vlc_playlist.h>
#include <vlc_vout.h>
+#include <vlc_window.h>
#include <vlc_keys.h>
#include <errno.h> /* ENOMEM */
/*****************************************************************************
* Local prototypes
*****************************************************************************/
-int E_(Activate) ( vlc_object_t * );
-void E_(Deactivate) ( vlc_object_t * );
+int Activate ( vlc_object_t * );
+void Deactivate ( vlc_object_t * );
static int InitVideo ( vout_thread_t * );
static void EndVideo ( 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, vlc_fourcc_t * );
+static int XVideoGetPort ( vout_thread_t *, vlc_fourcc_t, picture_heap_t * );
static void XVideoReleasePort( vout_thread_t *, int );
#endif
* vout properties to choose the window size, and change them according to the
* actual properties of the display.
*****************************************************************************/
-int E_(Activate) ( vlc_object_t *p_this )
+int Activate ( vlc_object_t *p_this )
{
vout_thread_t *p_vout = (vout_thread_t *)p_this;
char * psz_display;
/* Allocate structure */
p_vout->p_sys = malloc( sizeof( vout_sys_t ) );
if( p_vout->p_sys == NULL )
- {
- msg_Err( p_vout, "out of memory" );
return VLC_ENOMEM;
- }
- vlc_mutex_init( p_vout, &p_vout->p_sys->lock );
+ /* key and mouse event handling */
+ p_vout->p_sys->i_vout_event = var_CreateGetInteger( p_vout, "vout-event" );
/* Open display, using the "display" config variable or the DISPLAY
* environment variable */
/* 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.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
* 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.i_chroma );
+ &p_vout->output );
if( p_vout->p_sys->i_xvport < 0 )
{
/* It failed, but it's not completely lost ! We try to open an
* 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.i_chroma );
+ &p_vout->output );
if( p_vout->p_sys->i_xvport < 0 )
{
XCloseDisplay( p_vout->p_sys->p_display );
if( checkXvMCCap( p_vout ) == VLC_EGENERIC )
{
msg_Err( p_vout, "no XVMC capability found" );
- E_(Deactivate)( p_vout );
+ Deactivate( p_vout );
return VLC_EGENERIC;
}
subpicture_t sub_pic;
*****************************************************************************
* Terminate an output method created by Open
*****************************************************************************/
-void E_(Deactivate) ( vlc_object_t *p_this )
+void Deactivate ( vlc_object_t *p_this )
{
vout_thread_t *p_vout = (vout_thread_t *)p_this;
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
{
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;
}
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
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'):
#endif
break;
}
+#endif
#elif defined(MODULE_NAME_IS_x11)
/* Initialize the output structure: RGB with square pixels, whatever
p_vout->p_sys->p_win->i_height,
&i_x, &i_y, &i_width, &i_height );
- vlc_mutex_lock( &p_vout->p_sys->lock );
-
#ifdef MODULE_NAME_IS_xvmc
xvmc_context_reader_lock( &p_vout->p_sys->xvmc_lock );
msg_Dbg( p_vout, "DisplayVideo decoded=%d\tsurfacevalid=%d",
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;
}
/* Make sure the command is sent now - do NOT use XFlush !*/
XSync( p_vout->p_sys->p_display, False );
-
- vlc_mutex_unlock( &p_vout->p_sys->lock );
}
/*****************************************************************************
XEvent xevent; /* X11 event */
vlc_value_t val;
- vlc_mutex_lock( &p_vout->p_sys->lock );
-
#ifdef MODULE_NAME_IS_xvmc
xvmc_context_reader_lock( &p_vout->p_sys->xvmc_lock );
#endif
if( p_vout->p_sys->p_win->owner_window )
{
while( XCheckWindowEvent( p_vout->p_sys->p_display,
- p_vout->p_sys->p_win->owner_window,
+ p_vout->p_sys->p_win->owner_window->handle.xid,
StructureNotifyMask, &xevent ) == True )
{
/* ConfigureNotify event: prepare */
switch( ((XButtonEvent *)&xevent)->button )
{
case Button1:
- var_Get( p_vout, "mouse-button-down", &val );
- val.i_int &= ~1;
- var_Set( p_vout, "mouse-button-down", val );
+ {
+ var_Get( p_vout, "mouse-button-down", &val );
+ val.i_int &= ~1;
+ var_Set( p_vout, "mouse-button-down", val );
- val.b_bool = true;
- var_Set( p_vout, "mouse-clicked", val );
+ var_SetBool( p_vout, "mouse-clicked", true );
+ var_SetBool( p_vout->p_libvlc, "intf-popupmenu", false );
+ }
break;
case Button2:
{
- playlist_t *p_playlist;
-
var_Get( p_vout, "mouse-button-down", &val );
val.i_int &= ~2;
var_Set( p_vout, "mouse-button-down", val );
- p_playlist = vlc_object_find( p_vout,
- VLC_OBJECT_PLAYLIST,
- FIND_ANYWHERE );
- if( p_playlist != NULL )
- {
- vlc_value_t val;
- var_Get( p_playlist, "intf-show", &val );
- val.b_bool = !val.b_bool;
- var_Set( p_playlist, "intf-show", val );
- vlc_object_release( p_playlist );
- }
+ var_Get( p_vout->p_libvlc, "intf-show", &val );
+ val.b_bool = !val.b_bool;
+ var_Set( p_vout->p_libvlc, "intf-show", val );
}
break;
case Button3:
{
- intf_thread_t *p_intf;
- playlist_t *p_playlist;
-
var_Get( p_vout, "mouse-button-down", &val );
val.i_int &= ~4;
var_Set( p_vout, "mouse-button-down", val );
- p_intf = vlc_object_find( p_vout, VLC_OBJECT_INTF,
- FIND_ANYWHERE );
- if( p_intf )
- {
- p_intf->b_menu_change = 1;
- vlc_object_release( p_intf );
- }
-
- p_playlist = vlc_object_find( p_vout,
- VLC_OBJECT_PLAYLIST,
- FIND_ANYWHERE );
- if( p_playlist != NULL )
- {
- vlc_value_t val; val.b_bool = true;
- var_Set( p_playlist, "intf-popupmenu", val );
- vlc_object_release( p_playlist );
- }
+
+ var_SetBool( p_vout->p_libvlc, "intf-popupmenu", true );
}
break;
else if( xevent.type == MotionNotify )
{
unsigned int i_width, i_height, i_x, i_y;
- vlc_value_t val;
/* somewhat different use for vout_PlacePicture:
* here the values are needed to give to mouse coordinates
var_Set( p_vout, "mouse-y", val );
- val.b_bool = true;
- var_Set( p_vout, "mouse-moved", val );
+ var_SetBool( p_vout, "mouse-moved", true );
p_vout->p_sys->i_time_mouse_last_moved = mdate();
if( ! p_vout->p_sys->b_mouse_pointer_visible )
p_win->video_window, p_win->gc, 0, 0,
p_win->i_width, p_win->i_height );
}
-#endif
+#endif
#if 0
if( p_vout->p_libvlc->p_input_bank->pp_input[0] != NULL )
== p_vout->p_sys->p_win->wm_delete_window ) )
{
/* the user wants to close the window */
- playlist_t * p_playlist =
- (playlist_t *)vlc_object_find( p_vout, VLC_OBJECT_PLAYLIST,
- FIND_ANYWHERE );
+ playlist_t * p_playlist = pl_Hold( p_vout );
if( p_playlist != NULL )
{
playlist_Stop( p_playlist );
- vlc_object_release( p_playlist );
+ pl_Release( p_vout );
}
}
}
*/
if ( p_vout->i_changes & VOUT_FULLSCREEN_CHANGE )
{
- vlc_value_t val_fs, val_ontop;
-
/* Update the object variable and trigger callback */
- val_fs.b_bool = !p_vout->b_fullscreen;
-
- var_Set( p_vout, "fullscreen", val_fs );
-
- /* Disable "always on top" in fullscreen mode */
- var_Get( p_vout, "video-on-top", &val_ontop );
- if( val_ontop.b_bool )
- WindowOnTop( p_vout, val_fs.b_bool );
+ var_SetBool( p_vout, "fullscreen", !p_vout->b_fullscreen );
ToggleFullScreen( p_vout );
p_vout->i_changes &= ~VOUT_FULLSCREEN_CHANGE;
}
+ /* autoscale toggle */
+ if( p_vout->i_changes & VOUT_SCALE_CHANGE )
+ {
+ p_vout->i_changes &= ~VOUT_SCALE_CHANGE;
+
+ p_vout->b_autoscale = var_GetBool( p_vout, "autoscale" );
+ p_vout->i_zoom = ZOOM_FP_FACTOR;
+
+ p_vout->i_changes |= VOUT_SIZE_CHANGE;
+ }
+
+ /* scaling factor */
+ if( p_vout->i_changes & VOUT_ZOOM_CHANGE )
+ {
+ p_vout->i_changes &= ~VOUT_ZOOM_CHANGE;
+
+ p_vout->b_autoscale = false;
+ p_vout->i_zoom =
+ (int)( ZOOM_FP_FACTOR * var_GetFloat( p_vout, "scale" ) );
+
+ p_vout->i_changes |= VOUT_SIZE_CHANGE;
+ }
+
if( p_vout->i_changes & VOUT_CROP_CHANGE ||
p_vout->i_changes & VOUT_ASPECT_CHANGE )
{
i_x, i_y, i_width, i_height );
}
+ /* cursor hiding depending on --vout-event option
+ * activated if:
+ * value = 1 (Fullsupport) (default value)
+ * or value = 2 (Fullscreen-Only) and condition met
+ */
+ bool b_vout_event = ( ( p_vout->p_sys->i_vout_event == 1 )
+ || ( p_vout->p_sys->i_vout_event == 2 && p_vout->b_fullscreen )
+ );
+
/* Autohide Cursour */
if( mdate() - p_vout->p_sys->i_time_mouse_last_moved >
p_vout->p_sys->i_mouse_hide_timeout )
{
/* Hide the mouse automatically */
- if( p_vout->p_sys->b_mouse_pointer_visible )
+ if( b_vout_event && p_vout->p_sys->b_mouse_pointer_visible )
{
ToggleCursor( p_vout );
}
}
}
#endif
-
- vlc_mutex_unlock( &p_vout->p_sys->lock );
return 0;
}
XGCValues xgcvalues;
XEvent xevent;
- bool b_expose = false;
- bool b_configure_notify = false;
bool b_map_notify = false;
vlc_value_t val;
if( !p_vout->b_fullscreen )
{
- p_win->owner_window = (Window)
- vout_RequestWindow( p_vout, &p_win->i_x, &p_win->i_y,
- &p_win->i_width, &p_win->i_height );
-
+ p_win->owner_window = vout_RequestXWindow( p_vout, &p_win->i_x,
+ &p_win->i_y, &p_win->i_width, &p_win->i_height );
xsize_hints.base_width = xsize_hints.width = p_win->i_width;
xsize_hints.base_height = xsize_hints.height = p_win->i_height;
xsize_hints.flags = PSize | PMinSize;
else
{
/* Fullscreen window size and position */
- p_win->owner_window = 0;
+ p_win->owner_window = NULL;
p_win->i_x = p_win->i_y = 0;
p_win->i_width =
DisplayWidth( p_vout->p_sys->p_display, p_vout->p_sys->i_screen );
unsigned int dummy4, dummy5;
/* Select events we are interested in. */
- XSelectInput( p_vout->p_sys->p_display, p_win->owner_window,
- StructureNotifyMask );
+ XSelectInput( p_vout->p_sys->p_display,
+ p_win->owner_window->handle.xid, StructureNotifyMask );
/* Get the parent window's geometry information */
- XGetGeometry( p_vout->p_sys->p_display, p_win->owner_window,
+ XGetGeometry( p_vout->p_sys->p_display,
+ p_win->owner_window->handle.xid,
&dummy1, &dummy2, &dummy3,
&p_win->i_width,
&p_win->i_height,
&dummy4, &dummy5 );
- /* We are already configured */
- b_configure_notify = true;
-
/* From man XSelectInput: only one client at a time can select a
* ButtonPress event, so we need to open a new window anyway. */
p_win->base_window =
XCreateWindow( p_vout->p_sys->p_display,
- p_win->owner_window,
+ p_win->owner_window->handle.xid,
0, 0,
p_win->i_width, p_win->i_height,
0,
p_win->base_window,
GCGraphicsExposures, &xgcvalues );
- /* Send orders to server, and wait until window is displayed - three
- * events must be received: a MapNotify event, an Expose event allowing
- * drawing in the window, and a ConfigureNotify to get the window
- * dimensions. Once those events have been received, only
- * ConfigureNotify events need to be received. */
+ /* Wait till the window is mapped */
XMapWindow( p_vout->p_sys->p_display, p_win->base_window );
do
{
XWindowEvent( p_vout->p_sys->p_display, p_win->base_window,
- SubstructureNotifyMask | StructureNotifyMask |
- ExposureMask, &xevent);
- if( (xevent.type == Expose)
- && (xevent.xexpose.window == p_win->base_window) )
- {
- b_expose = true;
- /* ConfigureNotify isn't sent if there isn't a window manager.
- * Expose should be the last event to be received so it should
- * be fine to assume we won't receive it anymore. */
- b_configure_notify = true;
- }
- else if( (xevent.type == MapNotify)
+ SubstructureNotifyMask | StructureNotifyMask, &xevent);
+ if( (xevent.type == MapNotify)
&& (xevent.xmap.window == p_win->base_window) )
{
b_map_notify = true;
else if( (xevent.type == ConfigureNotify)
&& (xevent.xconfigure.window == p_win->base_window) )
{
- b_configure_notify = true;
p_win->i_width = xevent.xconfigure.width;
p_win->i_height = xevent.xconfigure.height;
}
- } while( !( b_expose && b_configure_notify && b_map_notify ) );
+ } while( !b_map_notify );
- XSelectInput( p_vout->p_sys->p_display, p_win->base_window,
- StructureNotifyMask | KeyPressMask |
- ButtonPressMask | ButtonReleaseMask |
- PointerMotionMask );
+ /* key and mouse events handling depending on --vout-event option
+ * activated if:
+ * value = 1 (Fullsupport) (default value)
+ * or value = 2 (Fullscreen-Only) and condition met
+ */
+ bool b_vout_event = ( ( p_vout->p_sys->i_vout_event == 1 )
+ || ( p_vout->p_sys->i_vout_event == 2 && p_vout->b_fullscreen )
+ );
+ if ( b_vout_event )
+ XSelectInput( p_vout->p_sys->p_display, p_win->base_window,
+ StructureNotifyMask | KeyPressMask |
+ ButtonPressMask | ButtonReleaseMask |
+ PointerMotionMask );
#ifdef MODULE_NAME_IS_x11
if( XDefaultDepth(p_vout->p_sys->p_display, p_vout->p_sys->i_screen) == 8 )
XUnmapWindow( p_vout->p_sys->p_display, p_win->base_window );
XDestroyWindow( p_vout->p_sys->p_display, p_win->base_window );
- if( p_win->owner_window )
- vout_ReleaseWindow( p_vout, (void *)p_win->owner_window );
+ vout_ReleaseWindow( p_win->owner_window );
}
/*****************************************************************************
p_pic->V_PIXELS = (uint8_t*)p_pic->p_sys->p_image->data
+ p_pic->p_sys->p_image->offsets[1];
}
+
break;
#else
static void ToggleFullScreen ( vout_thread_t *p_vout )
{
Atom prop;
- XEvent xevent;
mwmhints_t mwmhints;
XSetWindowAttributes attributes;
{
msg_Dbg( p_vout, "entering fullscreen mode" );
+ /* Getting current window position */
+ Window root_win;
+ Window* child_windows;
+ unsigned int num_child_windows;
+ Window parent_win;
+ Window child_win;
+ XWindowAttributes win_attr;
+ int screen_x,screen_y;
+
+ XGetWindowAttributes(
+ p_vout->p_sys->p_display,
+ p_vout->p_sys->p_win->video_window,
+ &win_attr);
+
+ XQueryTree(
+ p_vout->p_sys->p_display,
+ p_vout->p_sys->p_win->video_window,
+ &root_win,
+ &parent_win,
+ &child_windows,
+ &num_child_windows);
+ XFree(child_windows);
+
+ XTranslateCoordinates(
+ p_vout->p_sys->p_display,
+ parent_win, win_attr.root,
+ win_attr.x,win_attr.y,
+ &screen_x,&screen_y,
+ &child_win);
+
+ msg_Dbg( p_vout, "X %d/%d Y %d/%d", win_attr.x,screen_x,win_attr.y,screen_y);
+ /* screen_x and screen_y are current position */
+
p_vout->p_sys->b_altfullscreen =
config_GetInt( p_vout, MODULE_STRING "-altfullscreen" );
(XEvent*)&event );
}
+/* "bad fullscreen" - set this to 0. doing fullscreen this way is problematic
+ * for many reasons and basically fights with the window manager as the wm
+ * reparents AND vlc goes and reparents - multiple times. don't do it. it just
+ * makes it more inefficient and less "nice" to the x11 citizenry. this turns
+ * it off */
+#define BADFS 0
+/* explicitly asking for focus when you fullscreened is a little silly. the
+ * window manager SHOULD be handling this itself based on its own focus
+ * policies. if the user is "using" a given xinerama/xrandr screen or x11
+ * multihead screen AND vlc wants to fullscreen the wm should also focus it
+ * as its the only thing on the screen. if vlc fullscreens and its on
+ * "another monitor" to the one the user is using - this may "steal" the focus
+ * as really the wm should be deciding if, on fullscreening of a window
+ * the focus should go there or not, so let the wm decided */
+#define APPFOCUS 0
/* Make sure the change is effective */
XReparentWindow( p_vout->p_sys->p_display,
p_vout->p_sys->p_win->base_window,
SCREEN = config_GetInt( p_vout,
MODULE_STRING "-xineramascreen" );
- /* just check that user has entered a good value */
+ /* just check that user has entered a good value,
+ * otherwise use that screen where window is */
if( SCREEN >= i_num_screens || SCREEN < 0 )
{
msg_Dbg( p_vout, "requested screen number invalid (%d/%d)", SCREEN, i_num_screens );
- SCREEN = 0;
+#define left screens[SCREEN].x_org
+#define right left + screens[SCREEN].width
+#define top screens[SCREEN].y_org
+#define bottom top + screens[SCREEN].height
+
+ for( SCREEN = i_num_screens-1; SCREEN > 0; SCREEN--)
+ {
+ if( left <= screen_x && screen_x <= right &&
+ top <= screen_y && screen_y <= bottom )
+ break;
+ }
+#undef bottom
+#undef top
+#undef right
+#undef left
}
/* Get the X/Y upper left corner coordinate of the above screen */
EnablePixelDoubling( p_vout );
#endif
+#if APPFOCUS // RASTER: let the wm do focus policy
/* Activate the window (give it the focus) */
XClientMessageEvent event;
DefaultRootWindow( p_vout->p_sys->p_display ),
False, SubstructureRedirectMask,
(XEvent*)&event );
+#endif
}
else
{
* window has already been mapped because the XMapWindow() request
* has not necessarily been sent directly to our window (remember,
* the call is first redirected to the window manager) */
+
+#if BADFS // RASTER: this is silly... if we have already mapped before
+ XEvent xevent;
do
{
XWindowEvent( p_vout->p_sys->p_display,
p_vout->p_sys->p_win->base_window,
StructureNotifyMask, &xevent );
} while( xevent.type != MapNotify );
+#else
+ XSync(p_vout->p_sys->p_display, False);
+#endif
/* Be careful, this can generate a BadMatch error if the window is not
* already mapped by the server (see above) */
* XVideoGetPort: get YUV12 port
*****************************************************************************/
static int XVideoGetPort( vout_thread_t *p_vout,
- vlc_fourcc_t i_chroma, vlc_fourcc_t *pi_newchroma )
+ vlc_fourcc_t i_chroma, picture_heap_t *p_heap )
{
XvAdaptorInfo *p_adaptor;
unsigned int i;
== Success )
{
i_selected_port = i_port;
- *pi_newchroma = p_formats[ i_format ].id;
+ 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
}
}
#ifdef HAVE_SYS_SHM_H
p_vout->p_sys->i_shm_opcode = 0;
- if( config_GetInt( p_vout, MODULE_STRING "-shm" ) )
+ if( config_GetInt( p_vout, MODULE_STRING "-shm" ) > 0 )
{
int major, evt, err;
if( p_vout->p_sys->i_shm_opcode )
{
- int major, minor;
+ int minor;
Bool pixmaps;
XShmQueryVersion( p_vout->p_sys->p_display, &major, &minor,
/* Create XImage / XvImage */
#ifdef MODULE_NAME_IS_xvideo
-
- /* Make sure the buffer is aligned to multiple of 16 */
- i_height = ( i_height + 15 ) >> 4 << 4;
- i_width = ( i_width + 15 ) >> 4 << 4;
-
p_image = XvShmCreateImage( p_display, i_xvport, i_chroma, 0,
i_width, i_height, p_shm );
#elif defined(MODULE_NAME_IS_xvmc)
/* Allocate memory for image */
#ifdef MODULE_NAME_IS_xvideo
-
- /* Make sure the buffer is aligned to multiple of 16 */
- i_height = ( i_height + 15 ) >> 4 << 4;
- i_width = ( i_width + 15 ) >> 4 << 4;
-
p_data = malloc( i_width * i_height * i_bits_per_pixel / 8 );
#elif defined(MODULE_NAME_IS_x11)
i_bytes_per_line = i_width * i_bytes_per_pixel;
p_data = malloc( i_bytes_per_line * i_height );
#endif
if( !p_data )
- {
- msg_Err( p_vout, "out of memory" );
return NULL;
- }
#ifdef MODULE_NAME_IS_x11
/* Optimize the quantum of a scanline regarding its size - the quantum is
#ifdef HAVE_SYS_SHM_H
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
+#ifndef HAVE_OSSO
XSetErrorHandler(NULL);
return (XSetErrorHandler(X11ErrorHandler))( display, event );
+#else
+ /* Work-around Maemo Xvideo bug */
+ return 0;
+#endif
}
#ifdef MODULE_NAME_IS_x11
switch( i_query )
{
- case VOUT_GET_SIZE:
- if( p_vout->p_sys->p_win->owner_window )
- return vout_ControlWindow( p_vout,
- (void *)p_vout->p_sys->p_win->owner_window, i_query, args);
-
- pi_width = va_arg( args, unsigned int * );
- pi_height = va_arg( args, unsigned int * );
-
- vlc_mutex_lock( &p_vout->p_sys->lock );
- *pi_width = p_vout->p_sys->p_win->i_width;
- *pi_height = p_vout->p_sys->p_win->i_height;
- vlc_mutex_unlock( &p_vout->p_sys->lock );
- return VLC_SUCCESS;
-
case VOUT_SET_SIZE:
if( p_vout->p_sys->p_win->owner_window )
- return vout_ControlWindow( p_vout,
- (void *)p_vout->p_sys->p_win->owner_window, i_query, args);
-
- vlc_mutex_lock( &p_vout->p_sys->lock );
+ return vout_ControlWindow( p_vout->p_sys->p_win->owner_window,
+ i_query, args);
i_width = va_arg( args, unsigned int );
i_height = va_arg( args, unsigned int );
#ifdef MODULE_NAME_IS_xvmc
xvmc_context_reader_unlock( &p_vout->p_sys->xvmc_lock );
#endif
- vlc_mutex_unlock( &p_vout->p_sys->lock );
return VLC_SUCCESS;
- case VOUT_CLOSE:
- vlc_mutex_lock( &p_vout->p_sys->lock );
- XUnmapWindow( p_vout->p_sys->p_display,
- p_vout->p_sys->original_window.base_window );
- vlc_mutex_unlock( &p_vout->p_sys->lock );
- /* Fall through */
-
- case VOUT_REPARENT:
- vlc_mutex_lock( &p_vout->p_sys->lock );
- if( i_query == VOUT_REPARENT ) d = (Drawable)va_arg( args, int );
- if( !d )
- {
-#ifdef MODULE_NAME_IS_xvmc
- xvmc_context_reader_lock( &p_vout->p_sys->xvmc_lock );
-#endif
- XReparentWindow( p_vout->p_sys->p_display,
- p_vout->p_sys->original_window.base_window,
- DefaultRootWindow( p_vout->p_sys->p_display ),
- 0, 0 );
- }
- else
- XReparentWindow( p_vout->p_sys->p_display,
- p_vout->p_sys->original_window.base_window,
- d, 0, 0);
- XSync( p_vout->p_sys->p_display, False );
- p_vout->p_sys->original_window.owner_window = 0;
-#ifdef MODULE_NAME_IS_xvmc
- xvmc_context_reader_unlock( &p_vout->p_sys->xvmc_lock );
-#endif
- vlc_mutex_unlock( &p_vout->p_sys->lock );
- return vout_vaControlDefault( p_vout, i_query, args );
-
case VOUT_SET_STAY_ON_TOP:
if( p_vout->p_sys->p_win->owner_window )
- return vout_ControlWindow( p_vout,
- (void *)p_vout->p_sys->p_win->owner_window, i_query, args);
+ return vout_ControlWindow( p_vout->p_sys->p_win->owner_window,
+ i_query, args);
b_arg = (bool) va_arg( args, int );
- vlc_mutex_lock( &p_vout->p_sys->lock );
#ifdef MODULE_NAME_IS_xvmc
xvmc_context_reader_lock( &p_vout->p_sys->xvmc_lock );
#endif
#ifdef MODULE_NAME_IS_xvmc
xvmc_context_reader_unlock( &p_vout->p_sys->xvmc_lock );
#endif
- vlc_mutex_unlock( &p_vout->p_sys->lock );
return VLC_SUCCESS;
default:
- return vout_vaControlDefault( p_vout, i_query, args );
+ return VLC_EGENERIC;
}
}
/*****************************************************************************
* Key events handling
*****************************************************************************/
-static struct
+static const struct
{
int i_x11key;
int i_vlckey;
projects / vlc / blobdiff