static int
GGI_helper_x_shm_setup(struct ggi_helper *helper,
const char *args, void *argptr)
{
ggi_x_priv *priv;
int major, minor;
Bool pixmaps;
DPRINT_LIBS("GGI_helper_x_shm_setup(%p, %s, %p) called\n",
helper, args, argptr);
priv = GGIX_PRIV(helper->visual);
if (XShmQueryExtension(priv->disp) != True)
return GGI_ENOFUNC;
if (XShmQueryVersion(priv->disp, &major, &minor, &pixmaps) != True)
return GGI_ENOFUNC;
DPRINT_LIBS("X: MIT-SHM: SHM version %i.%i %s pixmap support\n",
major, minor, pixmaps ? "with" : "without");
priv->createfb = _ggi_xshm_create_ximage;
priv->freefb = _ggi_xshm_free_ximage;
return GGI_OK;
}
bool X11Grabber::Setup()
{
_x11Display = XOpenDisplay(NULL);
if (_x11Display == nullptr)
{
std::cerr << "X11GRABBER ERROR: Unable to open display";
if (getenv("DISPLAY")) {
std::cerr << " " << std::string(getenv("DISPLAY")) << std::endl;
} else {
std::cerr << ". DISPLAY environment variable not set" << std::endl;
}
return false;
}
_window = DefaultRootWindow(_x11Display);
int dummy, pixmaps_supported;
_XRenderAvailable = XRenderQueryExtension(_x11Display, &dummy, &dummy);
_XShmAvailable = XShmQueryExtension(_x11Display);
XShmQueryVersion(_x11Display, &dummy, &dummy, &pixmaps_supported);
_XShmPixmapAvailable = pixmaps_supported && XShmPixmapFormat(_x11Display) == ZPixmap;
return true;
}
bool X11Grabber::Setup()
{
_x11Display = XOpenDisplay(NULL);
if (_x11Display == nullptr)
{
Error(_log, "Unable to open display");
if (getenv("DISPLAY"))
{
Error(_log, "%s",getenv("DISPLAY"));
}
else
{
Error(_log, "DISPLAY environment variable not set");
}
return false;
}
_window = DefaultRootWindow(_x11Display);
int dummy, pixmaps_supported;
_XRenderAvailable = XRenderQueryExtension(_x11Display, &dummy, &dummy);
_XShmAvailable = XShmQueryExtension(_x11Display);
XShmQueryVersion(_x11Display, &dummy, &dummy, &pixmaps_supported);
_XShmPixmapAvailable = pixmaps_supported && XShmPixmapFormat(_x11Display) == ZPixmap;
// Image scaling is performed by XRender when available, otherwise by ImageResampler
_imageResampler.setHorizontalPixelDecimation(_XRenderAvailable ? 1 : _horizontalDecimation);
_imageResampler.setVerticalPixelDecimation(_XRenderAvailable ? 1 : _verticalDecimation);
return true;
}
static Bool
NestedClientTryXShm(NestedClientPrivatePtr pPriv, int scrnIndex, int width, int height, int depth) {
int shmMajor, shmMinor;
Bool hasSharedPixmaps;
if (!XShmQueryExtension(pPriv->display)) {
xf86DrvMsg(scrnIndex, X_INFO, "XShmQueryExtension failed. Dropping XShm support.\n");
return FALSE;
}
if (XShmQueryVersion(pPriv->display, &shmMajor, &shmMinor,
&hasSharedPixmaps)) {
xf86DrvMsg(scrnIndex, X_INFO,
"XShm extension version %d.%d %s shared pixmaps\n",
shmMajor, shmMinor, (hasSharedPixmaps) ? "with" : "without");
}
pPriv->img = XShmCreateImage(pPriv->display,
DefaultVisualOfScreen(pPriv->screen),
depth,
ZPixmap,
NULL, /* data */
&pPriv->shminfo,
width,
height);
if (!pPriv->img) {
xf86DrvMsg(scrnIndex, X_ERROR, "XShmCreateImage failed. Dropping XShm support.\n");
return FALSE;
}
/* XXX: change the 0777 mask? */
pPriv->shminfo.shmid = shmget(IPC_PRIVATE,
pPriv->img->bytes_per_line *
pPriv->img->height,
IPC_CREAT | 0777);
if (pPriv->shminfo.shmid == -1) {
xf86DrvMsg(scrnIndex, X_ERROR, "shmget failed. Dropping XShm support.\n");
XDestroyImage(pPriv->img);
return FALSE;
}
pPriv->shminfo.shmaddr = (char *)shmat(pPriv->shminfo.shmid, NULL, 0);
if (pPriv->shminfo.shmaddr == (char *) -1) {
xf86DrvMsg(scrnIndex, X_ERROR, "shmaddr failed. Dropping XShm support.\n");
XDestroyImage(pPriv->img);
return FALSE;
}
pPriv->img->data = pPriv->shminfo.shmaddr;
pPriv->shminfo.readOnly = FALSE;
XShmAttach(pPriv->display, &pPriv->shminfo);
pPriv->usingShm = TRUE;
return TRUE;
}
static PyObject *
tkwin_ShmQueryVersion(TkWinObject *self, PyObject *args)
{
int major, minor;
Bool pixmaps;
XShmQueryVersion(Tk_Display(self->tkwin), &major, &minor, &pixmaps);
return Py_BuildValue("iii", major, minor, pixmaps);
}
static int
can_use_shm(Display *dpy)
{
int major, minor, has_pixmap;
if (!XShmQueryExtension(dpy))
return 0;
XShmQueryVersion(dpy, &major, &minor, &has_pixmap);
return has_pixmap;
}
int main(int, char **)
{
Display *dpy = 0;
int minor;
int major;
int pixmaps;
if (dpy && XShmQueryVersion(dpy, &major, &minor, &pixmaps)) {
minor = 0;
major = 0;
pixmaps = 0;
}
return 0;
}
static gboolean
ccm_display_init_shm (CCMDisplay * self)
{
g_return_val_if_fail (self != NULL, FALSE);
int major, minor;
if (XShmQueryExtension (self->priv->xdisplay) &&
XShmQueryVersion (self->priv->xdisplay, &major, &minor,
&self->priv->shm_shared_pixmap))
{
self->priv->shm.available = TRUE;
return TRUE;
}
return FALSE;
}
void MCScreenDC::initatoms()
{
XSetErrorHandler(xerror);
XSync( dpy, false ) ;
int ev1, ev2;
int major, minor;
Bool pix;
MCshmpix = False ;
if (!MCshmoff )
if ( XQueryExtension(dpy, "MIT-SHM", &shmopcode, &ev1, &ev2))
if ( XShmQueryVersion(dpy, &major, &minor, &pix))
{
MCshm = True;
MCshmpix = pix; // For shared memory pixmap's we need this to be true as well...
}
create_stipple();
selectionatom = XInternAtom(dpy, SELECTIONNAME, False);
MCprotocolatom = XInternAtom(dpy, "WM_PROTOCOLS", False);
MCtakefocusatom = XInternAtom(dpy, "WM_TAKE_FOCUS", False);
MCdeletewindowatom = XInternAtom(dpy, "WM_DELETE_WINDOW", False);
MCstateatom = XInternAtom(dpy, "WM_STATE", False);
MCmwmmessageatom = XInternAtom(dpy, "_MOTIF_WM_MESSAGES", True);
MCmwmhintsatom = XInternAtom(dpy, "_MOTIF_WM_HINTS", True);
#ifdef OLWM
MColwinatom = XInternAtom(dpy, "_OL_WIN_ATTR" , True);
MColwtotheratom = XInternAtom(dpy, "_OL_WT_OTHER", True);
MColwtpropatom = XInternAtom(dpy, "_OL_WT_PROP", True);
MColadecoratom = XInternAtom(dpy, "_OL_DECOR_ADD", True);
MColddecoratom = XInternAtom(dpy, "_OL_DECOR_DEL", True);
MColresizeatom = XInternAtom(dpy, "_OL_DECOR_RESIZE", True);
MColheaderatom = XInternAtom(dpy, "_OL_DECOR_HEADER", True);
MColcloseatom = XInternAtom(dpy, "_OL_DECOR_CLOSE", True);
#endif
MClayeratom = XInternAtom(dpy, "_WIN_LAYER", False);
MCclipboardatom = XInternAtom(dpy, "CLIPBOARD", False);
MCclientlistatom = XInternAtom(dpy, "_NET_CLIENT_LIST", True);
MCstrutpartialatom = XInternAtom(dpy, "_NET_WM_STRUT_PARTIAL", True);
MCworkareaatom = XInternAtom(dpy, "_NET_WORKAREA", True);
}
int bg_x11_window_check_shm(Display * dpy, int * completion_type)
{
#if 0
return 0;
#else
int major;
int minor;
Bool pixmaps;
int ret;
if ((XShmQueryVersion (dpy, &major, &minor,
&pixmaps) == 0) ||
(major < 1) || ((major == 1) && (minor < 1)))
ret = 0;
else
ret = 1;
if(ret)
*completion_type = XShmGetEventBase(dpy) + ShmCompletion;
return ret;
#endif
}
int mlx_int_deal_shm(t_xvar *xvar)
{
int use_pshm;
int bidon;
char *dpy;
char buff[33];
xvar->use_xshm = XShmQueryVersion(xvar->display,&bidon,&bidon,&(use_pshm));
if (xvar->use_xshm && use_pshm)
xvar->pshm_format = XShmPixmapFormat(xvar->display);
else
xvar->pshm_format = -1;
gethostname(buff,32);
dpy = getenv(ENV_DISPLAY);
if (dpy && strlen(dpy) && *dpy!=':' && strncmp(dpy,buff,strlen(buff)) &&
strncmp(dpy,LOCALHOST,strlen(LOCALHOST)) )
{
xvar->pshm_format = -1;
xvar->use_xshm = 0;
}
}
int video_init(void)
{
XGCValues gc_values;
Display *display;
_video_gc = video_get_gc(&gc_values);
display = x11ui_get_display_ptr();
x11video_log = log_open("X11Video");
color_init();
#ifdef USE_MITSHM
if (!try_mitshm) {
use_mitshm = 0;
} else {
/* This checks if the server has MITSHM extensions available
If try_mitshm is true and we are on a different machine,
frame_buffer_alloc will fall back to non shared memory calls. */
int major_version, minor_version, pixmap_flag;
/* Check whether the server supports the Shared Memory Extension. */
if (!XShmQueryVersion(display, &major_version, &minor_version, &pixmap_flag)) {
log_warning(x11video_log, "The MITSHM extension is not supported on this display.");
use_mitshm = 0;
} else {
DEBUG_MITSHM((_("MITSHM extensions version %d.%d detected."), major_version, minor_version));
if (!pixmap_flag) {
DEBUG_MITSHM(("The MITSHM extension is supported on this display, but shared pixmaps are not available."));
}
use_mitshm = 1;
}
}
#else
use_mitshm = 0;
#endif
return 0;
}
static void SetupImage (void)
{
TakedownImage();
#ifdef MITSHM
GUI.use_shared_memory = TRUE;
int major, minor;
Bool shared;
if (!XShmQueryVersion(GUI.display, &major, &minor, &shared) || !shared)
GUI.image = NULL;
else
GUI.image = XShmCreateImage(GUI.display, GUI.visual, GUI.depth, ZPixmap, NULL, &GUI.sm_info, SNES_WIDTH * 2, SNES_HEIGHT_EXTENDED * 2);
if (!GUI.image)
GUI.use_shared_memory = FALSE;
else
{
GUI.sm_info.shmid = shmget(IPC_PRIVATE, GUI.image->bytes_per_line * GUI.image->height, IPC_CREAT | 0777);
if (GUI.sm_info.shmid < 0)
{
XDestroyImage(GUI.image);
GUI.use_shared_memory = FALSE;
}
else
{
GUI.image->data = GUI.sm_info.shmaddr = (char *) shmat(GUI.sm_info.shmid, 0, 0);
if (!GUI.image->data)
{
XDestroyImage(GUI.image);
shmctl(GUI.sm_info.shmid, IPC_RMID, 0);
GUI.use_shared_memory = FALSE;
}
else
{
GUI.sm_info.readOnly = False;
XSetErrorHandler(ErrorHandler);
XShmAttach(GUI.display, &GUI.sm_info);
XSync(GUI.display, False);
// X Error handler might clear GUI.use_shared_memory if XShmAttach failed.
if (!GUI.use_shared_memory)
{
XDestroyImage(GUI.image);
shmdt(GUI.sm_info.shmaddr);
shmctl(GUI.sm_info.shmid, IPC_RMID, 0);
}
}
}
}
if (!GUI.use_shared_memory)
{
fprintf(stderr, "use_shared_memory failed, switching to XPutImage.\n");
#endif
GUI.image = XCreateImage(GUI.display, GUI.visual, GUI.depth, ZPixmap, 0, NULL, SNES_WIDTH * 2, SNES_HEIGHT_EXTENDED * 2, BitmapUnit(GUI.display), 0);
GUI.image->data = (char *) malloc(GUI.image->bytes_per_line * GUI.image->height);
if (!GUI.image || !GUI.image->data)
FatalError("XCreateImage failed.");
#ifdef MITSHM
}
#endif
#ifdef LSB_FIRST
GUI.image->byte_order = LSBFirst;
#else
GUI.image->byte_order = MSBFirst;
#endif
GFX.Pitch = SNES_WIDTH * 2 * 2;
GUI.snes_buffer = (uint8 *) calloc(GFX.Pitch * ((SNES_HEIGHT_EXTENDED + 4) * 2), 1);
if (!GUI.snes_buffer)
FatalError("Failed to allocate GUI.snes_buffer.");
GFX.Screen = (uint16 *) (GUI.snes_buffer + (GFX.Pitch * 2 * 2));
GUI.filter_buffer = (uint8 *) calloc((SNES_WIDTH * 2) * 2 * (SNES_HEIGHT_EXTENDED * 2), 1);
if (!GUI.filter_buffer)
FatalError("Failed to allocate GUI.filter_buffer.");
if (GUI.depth == 15 || GUI.depth == 16)
{
GUI.blit_screen_pitch = GUI.image->bytes_per_line;
GUI.blit_screen = (uint8 *) GUI.image->data;
GUI.need_convert = FALSE;
}
else
{
GUI.blit_screen_pitch = (SNES_WIDTH * 2) * 2;
GUI.blit_screen = GUI.filter_buffer;
GUI.need_convert = TRUE;
}
S9xGraphicsInit();
}
void wsXInit( void* mDisplay )
{
int eventbase;
int errorbase;
if(mDisplay){
wsDisplay=mDisplay;
} else {
char * DisplayName = ":0.0";
if ( getenv( "DISPLAY" ) ) DisplayName=getenv( "DISPLAY" );
wsDisplay=XOpenDisplay( DisplayName );
if ( !wsDisplay )
{
mp_msg( MSGT_GPLAYER,MSGL_FATAL,MSGTR_WS_CouldNotOpenDisplay );
exit( 0 );
}
}
/* enable DND atoms */
wsXDNDInitialize();
{ /* on remote display XShm will be disabled - LGB */
char *dispname=DisplayString(wsDisplay);
int localdisp=1;
if (dispname&&*dispname!=':') {
localdisp=0;
wsUseXShm=0;
}
mp_dbg( MSGT_GPLAYER,MSGL_DBG2,"[ws] display name: %s => %s display.\n",dispname,localdisp?"local":"REMOTE");
if (!localdisp) mp_msg( MSGT_GPLAYER,MSGL_V,MSGTR_WS_RemoteDisplay );
}
if ( !XShmQueryExtension( wsDisplay ) )
{
mp_msg( MSGT_GPLAYER,MSGL_ERR,MSGTR_WS_NoXshm );
wsUseXShm=0;
}
#ifdef HAVE_XSHAPE
if ( !XShapeQueryExtension( wsDisplay,&eventbase,&errorbase ) )
{
mp_msg( MSGT_GPLAYER,MSGL_ERR,MSGTR_WS_NoXshape );
wsUseXShape=0;
}
#else
wsUseXShape=0;
#endif
XSynchronize( wsDisplay,True );
wsScreen=DefaultScreen( wsDisplay );
wsRootWin=RootWindow( wsDisplay,wsScreen );
#ifdef HAVE_XF86VM
{
int clock;
XF86VidModeModeLine modeline;
XF86VidModeGetModeLine( wsDisplay,wsScreen,&clock ,&modeline );
wsMaxX=modeline.hdisplay;
wsMaxY=modeline.vdisplay;
}
#endif
{
wsOrgX = wsOrgY = 0;
if ( !wsMaxX )
wsMaxX=DisplayWidth( wsDisplay,wsScreen );
if ( !wsMaxY )
wsMaxY=DisplayHeight( wsDisplay,wsScreen );
}
vo_screenwidth = wsMaxX; vo_screenheight = wsMaxY;
xinerama_x = wsOrgX; xinerama_y = wsOrgY;
update_xinerama_info();
wsMaxX = vo_screenwidth; wsMaxY = vo_screenheight;
wsOrgX = xinerama_x; wsOrgY = xinerama_y;
wsGetDepthOnScreen();
#ifdef DEBUG
{
int minor,major,shp;
mp_msg( MSGT_GPLAYER,MSGL_DBG2,"[ws] Screen depth: %d\n",wsDepthOnScreen );
mp_msg( MSGT_GPLAYER,MSGL_DBG2,"[ws] size: %dx%d\n",wsMaxX,wsMaxY );
#ifdef HAVE_XINERAMA
mp_msg( MSGT_GPLAYER,MSGL_DBG2,"[ws] origin: +%d+%d\n",wsOrgX,wsOrgY );
#endif
mp_msg( MSGT_GPLAYER,MSGL_DBG2,"[ws] red mask: 0x%x\n",wsRedMask );
mp_msg( MSGT_GPLAYER,MSGL_DBG2,"[ws] green mask: 0x%x\n",wsGreenMask );
mp_msg( MSGT_GPLAYER,MSGL_DBG2,"[ws] blue mask: 0x%x\n",wsBlueMask );
if ( wsUseXShm )
{
XShmQueryVersion( wsDisplay,&major,&minor,&shp );
mp_msg( MSGT_GPLAYER,MSGL_DBG2,"[ws] XShm version is %d.%d\n",major,minor );
}
#ifdef HAVE_XSHAPE
if ( wsUseXShape )
{
XShapeQueryVersion( wsDisplay,&major,&minor );
mp_msg( MSGT_GPLAYER,MSGL_DBG2,"[ws] XShape version is %d.%d\n",major,minor );
}
#endif
}
#endif
wsOutMask=wsGetOutMask();
mp_dbg( MSGT_GPLAYER,MSGL_DBG2,"[ws] Initialized converter: " );
sws_rgb2rgb_init(get_sws_cpuflags());
switch ( wsOutMask )
{
case wsRGB32:
mp_dbg( MSGT_GPLAYER,MSGL_DBG2,"rgb32 to rgb32\n" );
wsConvFunc=rgb32torgb32;
break;
case wsBGR32:
mp_dbg( MSGT_GPLAYER,MSGL_DBG2,"rgb32 to bgr32\n" );
wsConvFunc=rgb32tobgr32;
break;
case wsRGB24:
mp_dbg( MSGT_GPLAYER,MSGL_DBG2,"rgb32 to rgb24\n" );
wsConvFunc=rgb32to24;
break;
case wsBGR24:
mp_dbg( MSGT_GPLAYER,MSGL_DBG2,"rgb32 to bgr24\n" );
wsConvFunc=rgb32tobgr24;
break;
case wsRGB16:
mp_dbg( MSGT_GPLAYER,MSGL_DBG2,"rgb32 to rgb16\n" );
wsConvFunc=rgb32to16;
break;
case wsBGR16:
mp_dbg( MSGT_GPLAYER,MSGL_DBG2,"rgb32 to bgr16\n" );
wsConvFunc=rgb32tobgr16;
break;
case wsRGB15:
mp_dbg( MSGT_GPLAYER,MSGL_DBG2,"rgb32 to rgb15\n" );
wsConvFunc=rgb32to15;
break;
case wsBGR15:
mp_dbg( MSGT_GPLAYER,MSGL_DBG2,"rgb32 to bgr15\n" );
wsConvFunc=rgb32tobgr15;
break;
}
XSetErrorHandler( wsErrorHandler );
}
void wsInit(Display *display)
{
int eventbase;
int errorbase;
mp_msg(MSGT_GPLAYER, MSGL_V, "X init.\n");
wsDisplay = display;
wsSetErrorHandler();
/* enable DND atoms */
wsXDNDInitialize();
{ /* on remote display XShm will be disabled - LGB */
char *dispname = DisplayString(wsDisplay);
int localdisp = 1;
if (dispname && *dispname != ':') {
localdisp = 0;
wsUseXShm = False;
}
mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[ws] display name: %s => %s display.\n", dispname, localdisp ? "local" : "REMOTE");
if (!localdisp)
mp_msg(MSGT_GPLAYER, MSGL_INFO, MSGTR_WS_RemoteDisplay);
}
#ifdef HAVE_SHM
if (!XShmQueryExtension(wsDisplay))
#endif
wsUseXShm = False;
if (!wsUseXShm)
mp_msg(MSGT_GPLAYER, MSGL_INFO, MSGTR_WS_NoXshm);
#ifdef CONFIG_XSHAPE
if (!XShapeQueryExtension(wsDisplay, &eventbase, &errorbase))
#endif
wsUseXShape = False;
if (!wsUseXShape)
mp_msg(MSGT_GPLAYER, MSGL_WARN, MSGTR_WS_NoXshape);
XSynchronize(wsDisplay, True);
wsScreen = DefaultScreen(wsDisplay);
wsRootWin = RootWindow(wsDisplay, wsScreen);
#ifdef CONFIG_XF86VM
{
int clock;
XF86VidModeModeLine modeline;
XF86VidModeGetModeLine(wsDisplay, wsScreen, &clock, &modeline);
wsMaxX = modeline.hdisplay;
wsMaxY = modeline.vdisplay;
}
#endif
{
wsOrgX = wsOrgY = 0;
if (!wsMaxX)
wsMaxX = DisplayWidth(wsDisplay, wsScreen);
if (!wsMaxY)
wsMaxY = DisplayHeight(wsDisplay, wsScreen);
}
wsWindowUpdateXinerama(NULL);
wsGetScreenDepth();
mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[ws] Screen depth: %d\n", wsScreenDepth);
mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[ws] size: %dx%d\n", wsMaxX, wsMaxY);
#ifdef CONFIG_XINERAMA
mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[ws] origin: +%d+%d\n", wsOrgX, wsOrgY);
#endif
mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[ws] red mask: 0x%x\n", wsRedMask);
mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[ws] green mask: 0x%x\n", wsGreenMask);
mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[ws] blue mask: 0x%x\n", wsBlueMask);
#ifdef HAVE_SHM
if (wsUseXShm) {
int minor, major, shp;
XShmQueryVersion(wsDisplay, &major, &minor, &shp);
mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[ws] XShm version is %d.%d\n", major, minor);
}
#endif
#ifdef CONFIG_XSHAPE
if (wsUseXShape) {
int minor, major;
XShapeQueryVersion(wsDisplay, &major, &minor);
mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[ws] XShape version is %d.%d\n", major, minor);
}
#endif
if (wsScreenDepth == 32 && wsRedMask == 0xff0000 && wsGreenMask == 0x00ff00 && wsBlueMask == 0x0000ff)
out_pix_fmt = PIX_FMT_RGB32;
else if (wsScreenDepth == 32 && wsRedMask == 0x0000ff && wsGreenMask == 0x00ff00 && wsBlueMask == 0xff0000)
out_pix_fmt = PIX_FMT_BGR32;
else if (wsScreenDepth == 24 && wsRedMask == 0xff0000 && wsGreenMask == 0x00ff00 && wsBlueMask == 0x0000ff)
out_pix_fmt = PIX_FMT_RGB24;
else if (wsScreenDepth == 24 && wsRedMask == 0x0000ff && wsGreenMask == 0x00ff00 && wsBlueMask == 0xff0000)
out_pix_fmt = PIX_FMT_BGR24;
else if (wsScreenDepth == 16 && wsRedMask == 0xf800 && wsGreenMask == 0x7e0 && wsBlueMask == 0x1f)
out_pix_fmt = PIX_FMT_RGB565;
else if (wsScreenDepth == 16 && wsRedMask == 0x1f && wsGreenMask == 0x7e0 && wsBlueMask == 0xf800)
out_pix_fmt = PIX_FMT_BGR565;
else if (wsScreenDepth == 15 && wsRedMask == 0x7c00 && wsGreenMask == 0x3e0 && wsBlueMask == 0x1f)
out_pix_fmt = PIX_FMT_RGB555;
else if (wsScreenDepth == 15 && wsRedMask == 0x1f && wsGreenMask == 0x3e0 && wsBlueMask == 0x7c00)
out_pix_fmt = PIX_FMT_BGR555;
}
int main (void)
{
int i;
int allocateOK;
ximg = NULL;
d = XOpenDisplay (NULL);
if (!d)
fputs ("Couldn't open display\n", stderr), exit (1);
screen = DefaultScreen (d);
gc = DefaultGC (d, screen);
/* Find a visual */
vis.screen = screen;
vlist = XGetVisualInfo (d, VisualScreenMask, &vis, &match);
if (!vlist)
fputs ("No matched visuals\n", stderr), exit (1);
vis = vlist[0];
XFree (vlist);
// That's not a fair comparison colormap_size is depth in bits!
// if (vis.colormap_size < COLORS)
// printf("Colormap is too small: %i.\n",vis.colormap_size); // , exit (1);
printf("Colour depth: %i\n",vis.colormap_size);
win = XCreateSimpleWindow (d, DefaultRootWindow (d),
0, 0, WIN_W, WIN_H, 0,
WhitePixel (d, screen), BlackPixel (d, screen));
int xclass=get_xvisinfo_class(vis);
// printf("class = %i\n",xclass);
stylee = ( vis.depth > 8 ? styleeTrueColor : styleePrivate );
// printf("stylee=%i\n",stylee);
if ( get_xvisinfo_class(vis) % 2 == 1) { /* The odd numbers can redefine colors */
// printf("%i\n",get_xvisinfo_class(vis));
colormap = DefaultColormap (d, screen);
Visual *defaultVisual=DefaultVisual(d,screen);
/* Allocate cells */
allocateOK = (XAllocColorCells (d, colormap, 1,
NULL, 0, color, COLORS) != 0);
// printf("Allocated OK? %i\n",allocateOK);
if (allocateOK) {
// printf("Allocated OK\n");
// This doesn't work for installed colormap!
/* Modify the colorcells */
for (i = 0; i < COLORS; i++)
xrgb[i].pixel = color[i];
XStoreColors (d, colormap, xrgb, COLORS);
} else {
colormap = XCreateColormap(d,win,defaultVisual,AllocNone);
// redocolors();
}
// black = XBlackPixel(d,screen);
// white = XWhitePixel(d,screen);
} else if ( get_xvisinfo_class(vis) == TrueColor) {
colormap = DefaultColormap (d, screen);
// printf("TrueColor %i = %i\n",xclass,TrueColor);
/* This will lookup the color and sets the xrgb[i].pixel value */
// for (i = 0; i < COLORS; i++)
// XAllocColor (d, colormap, &xrgb[i]);
} else
fprintf (stderr, "Not content with visual class %d.\n",
get_xvisinfo_class(vis) ), exit (1);
/* Find out if MITSHM is supported and useable */
printf ("MITSHM: ");
if (XShmQueryVersion (d, &mitshm_major_code,
&mitshm_minor_code, &shared_pixmaps)) {
int (*handler) (Display *, XErrorEvent *);
ximg = XShmCreateImage (d, vis.visual,
vis.depth, XShmPixmapFormat (d),
NULL, &shminfo, WIN_W, WIN_H);
shminfo.shmid = shmget (IPC_PRIVATE,
ximg->bytes_per_line * ximg->height,
IPC_CREAT | 0777);
shminfo.shmaddr = (char *)shmat (shminfo.shmid, 0, 0);
ximg->data = (char *)shminfo.shmaddr;
handler = XSetErrorHandler (mitshm_handler);
XShmAttach (d, &shminfo); /* Tell the server to attach */
XSync (d, 0);
XSetErrorHandler (handler);
shmctl (shminfo.shmid, IPC_RMID, 0);
/* Mark this shm segment for deletion at once. The segment will
* automatically become released when both the server and this
* client have detached from it.
* (Process termination automagically detach shm segments) */
if (!can_use_mitshm) {
shmdt (shminfo.shmaddr);
ximg = NULL;
}
}
if (ximg == NULL) {
can_use_mitshm = 0;
/* XInitImage(ximg); */
ximg = XCreateImage (d, vis.visual, vis.depth, ZPixmap,
0, (char *)malloc (WIN_W * WIN_H), WIN_W, WIN_H, 8, 0);
}
if (can_use_mitshm)
printf ("YES!\n");
else
printf ("NO, using fallback instead.\n");
// DrawFractal (ximg,xrgb);
XSelectInput (d, win, ButtonPressMask | ExposureMask);
XMapWindow (d, win);
real_main();
// XNextEvent (d, &ev);
// switch (ev.type) {
// case ButtonPress:
// should_quit = 1;
// break;
// case Expose:
// if (can_use_mitshm)
// XShmPutImage (d, win, gc, img, 0, 0, 0, 0, WIN_W, WIN_H, True);
// else
// XPutImage (d, win, gc, img, 0, 0, 0, 0, WIN_W, WIN_H);
// break;
// default:
// break;
// }
if (get_xvisinfo_class(vis) % 2 == 1 || get_xvisinfo_class(vis) == TrueColor) {
unsigned long color[COLORS];
if (allocateOK) {
for (i = 0; i < COLORS; i++)
color[i] = xrgb[i].pixel;
XFreeColors (d, colormap, color, COLORS, 0);
} /* Allocated colors freed */
} else {
XUninstallColormap (d, colormap);
}
if (can_use_mitshm) {
XShmDetach (d, &shminfo); /* Server detached */
XDestroyImage (ximg); /* Image struct freed */
shmdt (shminfo.shmaddr); /* We're detached */
} else
XDestroyImage (ximg); /* Image struct freed */
XDestroyWindow (d, win); /* Window removed */
XCloseDisplay (d); /* Display disconnected */
/* So you can see how your computer compares to your friend's */
getrusage (RUSAGE_SELF, &resource_utilization);
float seconds=(float)resource_utilization.ru_utime.tv_sec
+(float)resource_utilization.ru_utime.tv_usec*0.000000001;
printf("CPU seconds per frame: %f\n",seconds/(float)frameno);
// printf ("CPU seconds consumed: %ds and %dµs\n",
// (int) resource_utilization.ru_utime.tv_sec,
// (int) resource_utilization.ru_utime.tv_usec);
return 0;
}
/**
** X11 initialize.
*/
global void CloneInitDisplay(void)
{
int i;
Window window;
XGCValues gcvalue;
XSizeHints hints;
XWMHints wmhints;
XClassHint classhint;
XSetWindowAttributes attributes;
int shm_major,shm_minor;
Bool pixmap_support;
XShmSegmentInfo shminfo;
XVisualInfo xvi;
XPixmapFormatValues *xpfv;
if( !(TheDisplay=XOpenDisplay(NULL)) ) {
fprintf(stderr,"Cannot connect to X-Server.\n");
exit(-1);
}
TheScreen=DefaultScreen(TheDisplay);
// I need shared memory pixmap extension.
if( !XShmQueryVersion(TheDisplay,&shm_major,&shm_minor,&pixmap_support) ) {
fprintf(stderr,"SHM-Extensions required.\n");
exit(-1);
}
if( !pixmap_support ) {
fprintf(stderr,"SHM-Extensions with pixmap supported required.\n");
exit(-1);
}
// Look for a nice visual
#ifdef USE_HICOLOR
if(XMatchVisualInfo(TheDisplay, TheScreen, 16, TrueColor, &xvi))
goto foundvisual;
if(XMatchVisualInfo(TheDisplay, TheScreen, 15, TrueColor, &xvi))
goto foundvisual;
fprintf(stderr,"Sorry, this version is for 15/16-bit displays only.\n");
#else
if(XMatchVisualInfo(TheDisplay, TheScreen, 8, PseudoColor, &xvi))
goto foundvisual;
fprintf(stderr,"Sorry, this version is for 8-bit displays only.\n");
#endif
#if 0
if(XMatchVisualInfo(TheDisplay, TheScreen, 24, TrueColor, &xvi))
goto foundvisual;
#endif
exit(-1);
foundvisual:
xpfv=XListPixmapFormats(TheDisplay, &i);
for(i--;i>=0;i--) if(xpfv[i].depth==xvi.depth) break;
if(i<0) {
fprintf(stderr,"No Pixmap format for visual depth?\n");
exit(-1);
}
VideoDepth=xvi.depth;
VideoWidth = 640;
VideoHeight = 480;
MapWidth = 14; // FIXME: Not the correct way
MapHeight = 14;
shminfo.shmid=shmget(IPC_PRIVATE,
(VideoWidth*xpfv[i].bits_per_pixel+xpfv[i].scanline_pad-1) /
xpfv[i].scanline_pad * xpfv[i].scanline_pad * VideoHeight / 8,
IPC_CREAT|0777);
XFree(xpfv);
if( !shminfo.shmid==-1 ) {
fprintf(stderr,"shmget failed.\n");
exit(-1);
}
VideoMemory=(VMemType*)shminfo.shmaddr=shmat(shminfo.shmid,0,0);
if( shminfo.shmaddr==(void*)-1 ) {
shmctl(shminfo.shmid,IPC_RMID,0);
fprintf(stderr,"shmat failed.\n");
exit(-1);
}
shminfo.readOnly=False;
if( !XShmAttach(TheDisplay,&shminfo) ) {
shmctl(shminfo.shmid,IPC_RMID,0);
fprintf(stderr,"XShmAttach failed.\n");
exit(-1);
}
// Mark segment as deleted as soon as both clone and the X server have
// attached to it. The POSIX spec says that a segment marked as deleted
// can no longer have addition processes attach to it, but Linux will let
// them anyway.
shmctl(shminfo.shmid,IPC_RMID,0);
TheMainDrawable=attributes.background_pixmap=
XShmCreatePixmap(TheDisplay,DefaultRootWindow(TheDisplay)
,shminfo.shmaddr,&shminfo
,VideoWidth,VideoHeight
,xvi.depth);
attributes.cursor = XCreateFontCursor(TheDisplay,XC_tcross-1);
attributes.backing_store = NotUseful;
attributes.save_under = False;
attributes.event_mask = KeyPressMask|KeyReleaseMask|/*ExposureMask|*/
FocusChangeMask|ButtonPressMask|PointerMotionMask|ButtonReleaseMask;
i = CWBackPixmap|CWBackingStore|CWSaveUnder|CWEventMask|CWCursor;
if(xvi.class==PseudoColor) {
i|=CWColormap;
attributes.colormap =
XCreateColormap( TheDisplay, xvi.screen, xvi.visual, AllocNone);
// FIXME: Really should fill in the colormap right now
}
window=XCreateWindow(TheDisplay,DefaultRootWindow(TheDisplay)
,0,0,VideoWidth,VideoHeight,3
,xvi.depth,InputOutput,xvi.visual ,i,&attributes);
TheMainWindow=window;
gcvalue.graphics_exposures=False;
GcLine=XCreateGC(TheDisplay,window,GCGraphicsExposures,&gcvalue);
//
// Clear initial window.
//
XSetForeground(TheDisplay,GcLine,BlackPixel(TheDisplay,TheScreen));
XFillRectangle(TheDisplay,TheMainDrawable,GcLine,0,0
,VideoWidth,VideoHeight);
WmDeleteWindowAtom=XInternAtom(TheDisplay,"WM_DELETE_WINDOW",False);
//
// Set some usefull min/max sizes as well as a 1.3 aspect
//
#if 0
if( geometry ) {
hints.flags=0;
f=XParseGeometry(geometry
,&hints.x,&hints.y,&hints.width,&hints.height);
if( f&XValue ) {
if( f&XNegative ) {
hints.x+=DisplayWidth-hints.width;
}
hints.flags|=USPosition;
// FIXME: win gravity
}
if( f&YValue ) {
if( f&YNegative ) {
hints.y+=DisplayHeight-hints.height;
}
hints.flags|=USPosition;
// FIXME: win gravity
}
if( f&WidthValue ) {
hints.flags|=USSize;
}
if( f&HeightValue ) {
hints.flags|=USSize;
}
} else {
#endif
hints.width=VideoWidth;
hints.height=VideoHeight;
hints.flags=PSize;
#if 0
}
#endif
hints.min_width=VideoWidth;
hints.min_height=VideoHeight;
hints.max_width=VideoWidth;
hints.max_height=VideoHeight;
hints.min_aspect.x=4;
hints.min_aspect.y=3;
hints.max_aspect.x=4;
hints.max_aspect.y=3;
hints.width_inc=4;
hints.height_inc=3;
hints.flags|=PMinSize|PMaxSize|PAspect|PResizeInc;
wmhints.input=True;
wmhints.initial_state=NormalState;
wmhints.window_group=window;
wmhints.flags=InputHint|StateHint|WindowGroupHint;
classhint.res_name="aleclone";
classhint.res_class="AleClone";
XSetStandardProperties(TheDisplay,window
,"ALE Clone","ALE Clone",None,(char**)0,0,&hints);
XSetClassHint(TheDisplay,window,&classhint);
XSetWMHints(TheDisplay,window,&wmhints);
XSetWMProtocols(TheDisplay,window,&WmDeleteWindowAtom,1);
XMapWindow(TheDisplay,window);
//
// Input handling.
//
XAddConnectionWatch(TheDisplay,MyConnectionWatch,NULL);
}
void wsXInit(Display *mDisplay)
{
int eventbase;
int errorbase;
// NOTE TO MYSELF: Use global mDisplay, get rid of wsDisplay.
wsDisplay = mDisplay;
XSetErrorHandler(wsErrorHandler);
/* enable DND atoms */
wsXDNDInitialize();
{ /* on remote display XShm will be disabled - LGB */
char *dispname = DisplayString(wsDisplay);
int localdisp = 1;
if (dispname && *dispname != ':') {
localdisp = 0;
wsUseXShm = 0;
}
mp_dbg(MSGT_GPLAYER, MSGL_DBG2, "[ws] display name: %s => %s display.\n", dispname, localdisp ? "local" : "REMOTE");
if (!localdisp)
mp_msg(MSGT_GPLAYER, MSGL_INFO, MSGTR_WS_RemoteDisplay);
}
if (!XShmQueryExtension(wsDisplay)) {
mp_msg(MSGT_GPLAYER, MSGL_INFO, MSGTR_WS_NoXshm);
wsUseXShm = 0;
}
#ifdef CONFIG_XSHAPE
if (!XShapeQueryExtension(wsDisplay, &eventbase, &errorbase)) {
mp_msg(MSGT_GPLAYER, MSGL_WARN, MSGTR_WS_NoXshape);
wsUseXShape = 0;
}
#else
wsUseXShape = 0;
#endif
XSynchronize(wsDisplay, True);
wsScreen = DefaultScreen(wsDisplay);
wsRootWin = RootWindow(wsDisplay, wsScreen);
#ifdef CONFIG_XF86VM
{
int clock;
XF86VidModeModeLine modeline;
XF86VidModeGetModeLine(wsDisplay, wsScreen, &clock, &modeline);
wsMaxX = modeline.hdisplay;
wsMaxY = modeline.vdisplay;
}
#endif
{
wsOrgX = wsOrgY = 0;
if (!wsMaxX)
wsMaxX = DisplayWidth(wsDisplay, wsScreen);
if (!wsMaxY)
wsMaxY = DisplayHeight(wsDisplay, wsScreen);
}
vo_screenwidth = wsMaxX;
vo_screenheight = wsMaxY;
xinerama_x = wsOrgX;
xinerama_y = wsOrgY;
update_xinerama_info();
wsMaxX = vo_screenwidth;
wsMaxY = vo_screenheight;
wsOrgX = xinerama_x;
wsOrgY = xinerama_y;
wsGetDepthOnScreen();
mp_dbg(MSGT_GPLAYER, MSGL_DBG2, "[ws] Screen depth: %d\n", wsDepthOnScreen);
mp_dbg(MSGT_GPLAYER, MSGL_DBG2, "[ws] size: %dx%d\n", wsMaxX, wsMaxY);
#ifdef CONFIG_XINERAMA
mp_dbg(MSGT_GPLAYER, MSGL_DBG2, "[ws] origin: +%d+%d\n", wsOrgX, wsOrgY);
#endif
mp_dbg(MSGT_GPLAYER, MSGL_DBG2, "[ws] red mask: 0x%x\n", wsRedMask);
mp_dbg(MSGT_GPLAYER, MSGL_DBG2, "[ws] green mask: 0x%x\n", wsGreenMask);
mp_dbg(MSGT_GPLAYER, MSGL_DBG2, "[ws] blue mask: 0x%x\n", wsBlueMask);
#ifdef MP_DEBUG
if (wsUseXShm) {
int minor, major, shp;
XShmQueryVersion(wsDisplay, &major, &minor, &shp);
mp_dbg(MSGT_GPLAYER, MSGL_DBG2, "[ws] XShm version is %d.%d\n", major, minor);
}
#ifdef CONFIG_XSHAPE
if (wsUseXShape) {
int minor, major;
XShapeQueryVersion(wsDisplay, &major, &minor);
mp_dbg(MSGT_GPLAYER, MSGL_DBG2, "[ws] XShape version is %d.%d\n", major, minor);
}
#endif
#endif
wsOutMask = wsGetOutMask();
switch (wsOutMask) {
case wsRGB32:
out_pix_fmt = PIX_FMT_RGB32;
break;
case wsBGR32:
out_pix_fmt = PIX_FMT_BGR32;
break;
case wsRGB24:
out_pix_fmt = PIX_FMT_RGB24;
break;
case wsBGR24:
out_pix_fmt = PIX_FMT_BGR24;
break;
case wsRGB16:
out_pix_fmt = PIX_FMT_RGB565;
break;
case wsBGR16:
out_pix_fmt = PIX_FMT_BGR565;
break;
case wsRGB15:
out_pix_fmt = PIX_FMT_RGB555;
break;
case wsBGR15:
out_pix_fmt = PIX_FMT_BGR555;
break;
}
}
/*
* Setup X11 wnd System
*/
void
X11_SetupWindow (GF_VideoOutput * vout)
{
X11VID ();
const char *sOpt;
xWindow->display = XOpenDisplay (NULL);
xWindow->screennum = DefaultScreen (xWindow->display);
xWindow->screenptr = DefaultScreenOfDisplay (xWindow->display);
xWindow->visual = DefaultVisualOfScreen (xWindow->screenptr);
xWindow->depth = DefaultDepth (xWindow->display, xWindow->screennum);
switch (xWindow->depth) {
case 8:
xWindow->pixel_format = GF_PIXEL_GREYSCALE;
break;
case 16:
xWindow->pixel_format = GF_PIXEL_RGB_565;
break;
case 24:
xWindow->pixel_format = GF_PIXEL_RGB_32;
break;
default:
xWindow->pixel_format = GF_PIXEL_GREYSCALE;
break;
}
xWindow->bpp = xWindow->depth / 8;
xWindow->bpp = xWindow->bpp == 3 ? 4 : xWindow->bpp;
vout->max_screen_width = DisplayWidth(xWindow->display, xWindow->screennum);
vout->max_screen_height = DisplayHeight(xWindow->display, xWindow->screennum);
/*
* Full screen wnd
*/
xWindow->full_wnd = XCreateWindow (xWindow->display,
RootWindowOfScreen (xWindow->screenptr),
0, 0,
vout->max_screen_width,
vout->max_screen_height, 0,
xWindow->depth, InputOutput,
xWindow->visual, 0, NULL);
XSelectInput(xWindow->display, xWindow->full_wnd,
FocusChangeMask | ExposureMask | PointerMotionMask | ButtonReleaseMask | ButtonPressMask | KeyPressMask | KeyReleaseMask);
if (!xWindow->par_wnd) {
xWindow->w_width = 320;
xWindow->w_height = 20;
xWindow->wnd = XCreateWindow (xWindow->display,
RootWindowOfScreen(xWindow->screenptr), 0, 0,
xWindow->w_width, xWindow->w_height, 0,
xWindow->depth, InputOutput,
xWindow->visual, 0, NULL);
XMapWindow (xWindow->display, (Window) xWindow->wnd);
} else {
XWindowAttributes pwa;
XGetWindowAttributes(xWindow->display, xWindow->par_wnd, &pwa);
xWindow->w_width = pwa.width;
xWindow->w_height = pwa.height;
xWindow->wnd = XCreateWindow (xWindow->display, xWindow->par_wnd, pwa.x, pwa.y,
xWindow->w_width, xWindow->w_height, 0,
xWindow->depth, InputOutput,
xWindow->visual, 0, NULL);
XMapWindow (xWindow->display, (Window) xWindow->wnd);
}
XSync(xWindow->display, False);
XUnmapWindow (xWindow->display, (Window) xWindow->wnd);
XSync(xWindow->display, False);
old_handler = XSetErrorHandler(X11_BadAccess_ByPass);
selectinput_err = 0;
XSelectInput(xWindow->display, xWindow->wnd,
FocusChangeMask | StructureNotifyMask | PropertyChangeMask | ExposureMask |
PointerMotionMask | ButtonReleaseMask | ButtonPressMask |
KeyPressMask | KeyReleaseMask);
XSync(xWindow->display, False);
XSetErrorHandler(old_handler);
if (selectinput_err) {
XSelectInput(xWindow->display, xWindow->wnd,
StructureNotifyMask | PropertyChangeMask | ExposureMask |
KeyPressMask | KeyReleaseMask);
GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("[X11] Cannot select input focus\n"));
}
XSync(xWindow->display, False);
XMapWindow (xWindow->display, (Window) xWindow->wnd);
XSizeHints *Hints = XAllocSizeHints ();
Hints->flags = PSize | PMinSize;
Hints->min_width = 32;
Hints->min_height = 32;
Hints->max_height = 4096;
Hints->max_width = 4096;
if (!xWindow->par_wnd) {
XSetWMNormalHints (xWindow->display, xWindow->wnd, Hints);
XStoreName (xWindow->display, xWindow->wnd, "GPAC X11 Output");
}
Hints->x = 0;
Hints->y = 0;
Hints->flags |= USPosition;
XSetWMNormalHints (xWindow->display, xWindow->full_wnd, Hints);
XFree (Hints);
xWindow->the_gc = XCreateGC (xWindow->display, xWindow->wnd, 0, NULL);
xWindow->videoaccesstype = VIDEO_XI_STANDARD;
#ifdef GPAC_HAS_X11_SHM
sOpt = gf_modules_get_option((GF_BaseInterface *)vout, "Video", "UseHardwareMemory");
if (sOpt && !strcmp(sOpt, "yes")) {
int XShmMajor, XShmMinor;
Bool XShmPixmaps;
if (XShmQueryVersion(xWindow->display, &XShmMajor, &XShmMinor, &XShmPixmaps)) {
/*this is disabled due to flip pb (we cannot reposition backbuffer)*/
if (0 && XShmPixmaps && (XShmPixmapFormat(xWindow->display) == ZPixmap)) {
xWindow->videoaccesstype = VIDEO_XI_SHMPIXMAP;
} else {
xWindow->videoaccesstype = VIDEO_XI_SHMSTD;
GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("[X11] Using X11 Hardware Blit\n"));
}
}
}
#endif
GF_SAFEALLOC(xWindow->back_buffer, X11WrapSurface);
xWindow->back_buffer->id = -1;
XSetWindowAttributes xsw;
xsw.border_pixel = WhitePixel (xWindow->display, xWindow->screennum);
xsw.background_pixel = BlackPixel (xWindow->display, xWindow->screennum);
xsw.win_gravity = NorthWestGravity;
XChangeWindowAttributes (xWindow->display, xWindow->wnd, CWBackPixel | CWWinGravity, &xsw);
xsw.override_redirect = True;
XChangeWindowAttributes(xWindow->display, xWindow->full_wnd,
CWOverrideRedirect | CWBackPixel | CWBorderPixel | CWWinGravity, &xsw);
if (!xWindow->par_wnd) {
xWindow->WM_DELETE_WINDOW = XInternAtom (xWindow->display, "WM_DELETE_WINDOW", False);
XSetWMProtocols(xWindow->display, xWindow->wnd, &xWindow->WM_DELETE_WINDOW, 1);
}
{
XEvent ev;
long mask;
memset (&ev, 0, sizeof (ev));
ev.xclient.type = ClientMessage;
ev.xclient.window = RootWindowOfScreen (xWindow->screenptr);
ev.xclient.message_type = XInternAtom (xWindow->display, "KWM_KEEP_ON_TOP", False);
ev.xclient.format = 32;
ev.xclient.data.l[0] = xWindow->full_wnd;
ev.xclient.data.l[1] = CurrentTime;
mask = SubstructureRedirectMask;
XSendEvent (xWindow->display,RootWindowOfScreen (xWindow->screenptr), False,
mask, &ev);
}
#ifdef GPAC_HAS_OPENGL
if (xWindow->is_3D_out) {
int attribs[64];
int i;
i=0;
attribs[i++] = GLX_RGBA;
attribs[i++] = GLX_RED_SIZE;
attribs[i++] = 5;
attribs[i++] = GLX_GREEN_SIZE;
attribs[i++] = 5;
attribs[i++] = GLX_BLUE_SIZE;
attribs[i++] = 5;
attribs[i++] = GLX_DEPTH_SIZE;
attribs[i++] = 16;
if (xWindow->gl_cfg.double_buffered) attribs[i++] = GLX_DOUBLEBUFFER;
attribs[i++] = None;
xWindow->glx_visualinfo = glXChooseVisual(xWindow->display, xWindow->screennum, attribs);
if (!xWindow->glx_visualinfo) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("[X11] Error selecting GL display\n"));
}
}
#endif
xWindow->setup_done = 1;
}
bool video::init_window(int xsize, int ysize)
{
{ //enclose local variables before fail label
g_sizex = xsize; g_sizey = ysize;
// Open the display
if (!dpy) {
dpy = XOpenDisplay(display_name);
if (!dpy) {
fprintf(stderr, "Can't open X11 display %s\n", XDisplayName(display_name));
goto fail;
}
}
int theScreen = DefaultScreen(dpy);
scrn = ScreenOfDisplay(dpy, theScreen);
dispdepth = DefaultDepth(dpy, theScreen);
XVisualInfo vinfo;
if (!( (dispdepth >= 15 && dispdepth <= 32 && XMatchVisualInfo(dpy, theScreen, dispdepth, TrueColor, &vinfo) )
|| XMatchVisualInfo(dpy, theScreen, 24, TrueColor, &vinfo)
|| XMatchVisualInfo(dpy, theScreen, 32, TrueColor, &vinfo)
|| XMatchVisualInfo(dpy, theScreen, 16, TrueColor, &vinfo)
|| XMatchVisualInfo(dpy, theScreen, 15, TrueColor, &vinfo)
)) {
fprintf(stderr, "Display has no appropriate True Color visual\n");
goto fail;
}
vis = vinfo.visual;
depth = dispdepth = vinfo.depth;
mask2bits(vinfo.red_mask, red_mask, red_shift);
mask2bits(vinfo.green_mask, green_mask, green_shift);
mask2bits(vinfo.blue_mask, blue_mask, blue_shift);
rootW = RootWindow(dpy, theScreen);
cmap = XCreateColormap(dpy, rootW, vis, AllocNone);
XSetWindowAttributes attrs;
attrs.backing_store = Always;
attrs.colormap = cmap;
attrs.event_mask = StructureNotifyMask|KeyPressMask|ButtonPressMask|ButtonReleaseMask;
attrs.background_pixel = BlackPixelOfScreen(scrn);
attrs.border_pixel = WhitePixelOfScreen(scrn);
win = XCreateWindow(dpy, rootW,
0, 0, xsize, ysize, 2,
dispdepth, InputOutput, vis,
CWBackingStore | CWColormap | CWEventMask |
CWBackPixel | CWBorderPixel,
&attrs);
if(!win) {
fprintf(stderr, "Can't create the window\n");
goto fail;
}
XSizeHints sh;
sh.flags = PSize | PMinSize | PMaxSize;
sh.width = sh.min_width = sh.max_width = xsize;
sh.height = sh.min_height = sh.max_height = ysize;
XSetStandardProperties( dpy, win, g_video->title, g_video->title, None, NULL, 0, &sh );
_XA_WM_DELETE_WINDOW = XInternAtom(dpy, "WM_DELETE_WINDOW", false);
XSetWMProtocols(dpy, win, &_XA_WM_DELETE_WINDOW, 1);
gc = XCreateGC(dpy, win, 0L, &xgcv);
XMapRaised(dpy, win);
XFlush(dpy);
#ifdef X_FULLSYNC
XSynchronize(dpy, true);
#endif
XSetErrorHandler(xerr_handler);
int imgbytes = xsize*ysize*(dispdepth<=16?2:4);
const char *vidstr;
#ifndef X_NOSHMEM
int major, minor, pixmaps;
if(XShmQueryExtension(dpy) &&
XShmQueryVersion(dpy, &major, &minor, &pixmaps))
{ // Shared memory
if(NULL!=getenv(NOSHMEM_env_var_name) && 0!=strcmp("0",getenv(NOSHMEM_env_var_name))) {
goto generic;
}
shmseginfo.shmid = shmget(IPC_PRIVATE, imgbytes, IPC_CREAT|0777);
if(shmseginfo.shmid < 0) {
fprintf(stderr, "Warning: Can't get shared memory: %s\n", strerror(errno));
goto generic;
}
g_pImg = (unsigned int*)(shmseginfo.shmaddr = (char*)shmat(shmseginfo.shmid, 0, 0));
if(g_pImg == (unsigned int*)-1) {
fprintf(stderr, "Warning: Can't attach to shared memory: %s\n", strerror(errno));
shmctl(shmseginfo.shmid, IPC_RMID, NULL);
goto generic;
}
shmseginfo.readOnly = false;
if(!XShmAttach(dpy, &shmseginfo) || x_error) {
char err[256]; XGetErrorText(dpy, x_error, err, 255);
fprintf(stderr, "Warning: Can't attach shared memory to display: %s (%d)\n", err, x_error);
shmdt(shmseginfo.shmaddr); shmctl(shmseginfo.shmid, IPC_RMID, NULL);
goto generic;
}
already_called_X_ShmAttach = true;
#ifndef X_NOSHMPIX
if(pixmaps && XShmPixmapFormat(dpy) == ZPixmap)
{ // Pixmaps
vidtype = 2; vidstr = "X11 shared memory pixmap";
pixmap = XShmCreatePixmap(dpy, win, (char*)g_pImg, &shmseginfo, xsize, ysize, dispdepth);
XSetWindowBackgroundPixmap(dpy, win, pixmap);
} else
#endif//!X_NOSHMPIX
{ // Standard
vidtype = 1; vidstr = "X11 shared memory";
ximage = XShmCreateImage(dpy, vis, dispdepth,
ZPixmap, 0, &shmseginfo, xsize, ysize);
if(!ximage) {
fprintf(stderr, "Can't create the shared image\n");
goto fail;
}
assert(ximage->bytes_per_line == xsize*(dispdepth<=16?2:4));
ximage->data = shmseginfo.shmaddr;
}
} else
#endif
{
#ifndef X_NOSHMEM
generic:
#endif
vidtype = 0; vidstr = "generic X11";
g_pImg = new unsigned int[imgbytes/sizeof(int)];
ximage = XCreateImage(dpy, vis, dispdepth, ZPixmap, 0, (char*)g_pImg, xsize, ysize, 32, imgbytes/ysize);
if(!ximage) {
fprintf(stderr, "Can't create the image\n");
goto fail;
}
}
// Note: It may be more efficient to adopt the server's byte order
// and swap once per get_color() call instead of once per pixel.
const uint32_t probe = 0x03020100;
const bool big_endian = (((const char*)(&probe))[0]==0x03);
ximage->byte_order = big_endian ? MSBFirst : LSBFirst;
printf("Note: using %s with %s visual for %d-bit color depth\n", vidstr, vis==DefaultVisual(dpy, theScreen)?"default":"non-default", dispdepth);
running = true;
return true;
} // end of enclosing local variables
fail:
terminate(); init_console();
return false;
}
static DFBResult
InitLocal( DFBX11 *x11, DFBX11Shared *shared, CoreDFB *core )
{
int i, n;
XInitThreads();
if (direct_config_get_int_value( "x11-sync" ))
x11->Sync = sync_display;
else
x11->Sync = sync_display_noop;
x11->shared = shared;
x11->core = core;
x11->display = XOpenDisplay(getenv("DISPLAY"));
if (!x11->display) {
D_ERROR("X11: Error in XOpenDisplay for '%s'\n", getenv("DISPLAY"));
return DFB_INIT;
}
x11->screenptr = DefaultScreenOfDisplay(x11->display);
x11->screennum = DefaultScreen(x11->display);
D_DEBUG_AT( X11_Core, " -> ndepths %d\n", x11->screenptr->ndepths);
for (i=0; i<x11->screenptr->ndepths; i++) {
const Depth *depth = &x11->screenptr->depths[i];
D_DEBUG_AT( X11_Core, " -> [%d] depth %d, nvisuals %d\n", i, depth->depth, depth->nvisuals );
for (n=0; n<depth->nvisuals; n++) {
Visual *visual = &depth->visuals[n];
D_DEBUG_AT( X11_Core, "[Visual %d] ID 0x%02lx, depth %d, RGB 0x%06lx/0x%06lx/0x%06lx, %d bpRGB, %d entr.\n",
n, visual->visualid, depth->depth,
visual->red_mask, visual->green_mask, visual->blue_mask,
visual->bits_per_rgb, visual->map_entries );
//if (depth->depth != d)
// continue;
//if (visual->visualid == 0x24) {
// x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB32)] = visual;
// continue;
//}
switch (depth->depth) {
case 32:
if (visual->red_mask == 0xff0000 &&
visual->green_mask == 0x00ff00 &&
visual->blue_mask == 0x0000ff &&
!x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_ARGB)])
x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_ARGB)] = visual;
break;
case 24:
if (visual->red_mask == 0xff0000 &&
visual->green_mask == 0x00ff00 &&
visual->blue_mask == 0x0000ff &&
!x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB32)])
x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB32)] = visual;
break;
case 16:
if (visual->red_mask == 0xf800 &&
visual->green_mask == 0x07e0 &&
visual->blue_mask == 0x001f &&
!x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB16)])
x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB16)] = visual;
break;
case 15:
if (visual->red_mask == 0x7c00 &&
visual->green_mask == 0x03e0 &&
visual->blue_mask == 0x001f &&
!x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB555)])
x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB555)] = visual;
break;
}
}
}
DFBSurfacePixelFormat formats[] = { DSPF_ARGB, DSPF_RGB32, DSPF_RGB16, DSPF_RGB555 };
for (i=0; i<D_ARRAY_SIZE(formats); i++) {
Visual *visual = x11->visuals[DFB_PIXELFORMAT_INDEX(formats[i])];
if (visual) {
D_DEBUG_AT( X11_Core, " %-20s [Visual ID 0x%02lx] RGB 0x%06lx/0x%06lx/0x%06lx, %d bpRGB, %d entr.\n",
dfb_pixelformat_name(formats[i]), visual->visualid, visual->red_mask, visual->green_mask, visual->blue_mask,
visual->bits_per_rgb, visual->map_entries );
}
else
D_DEBUG_AT( X11_Core, " %-20s [NO VISUAL]\n", dfb_pixelformat_name(formats[i]) );
}
if (XShmQueryExtension( x11->display ))
XShmQueryVersion( x11->display, &x11->xshm_major, &x11->xshm_minor, &x11->use_shm );
x11->use_shm = 0;
x11->screen = dfb_screens_register( NULL, x11, x11PrimaryScreenFuncs );
for (i=0; i<shared->outputs * shared->layers; i++) {
if (!dfb_layers_register( x11->screen, x11, x11PrimaryLayerFuncs ))
return DFB_INIT;
}
return DFB_OK;
}
static void *create_shm( int size )
{
struct shmid_ds shm_info;
int error = 1;
int major;
int minor;
Bool pixmaps;
int maxid;
if( ( XShmQueryVersion( display, &major, &minor, &pixmaps) == 0 ) ||
(major < 1) || ((major == 1) && (minor < 1))) {
fprintf( stderr, "xvoutput: No xshm extension available.\n" );
return 0;
}
maxid = shmctl( 0, SHM_INFO, &shm_info );
if( maxid < 0 ) {
fprintf( stderr, "\n"
" Your kernel has been compiled without support for shared\n"
" memory. Please fix this in your kernel before running\n"
" tvtime.\n\n" );
return 0;
}
shminfo.shmid = shmget( IPC_PRIVATE, size, IPC_CREAT | 0777 );
if( shminfo.shmid != -1 ) {
shminfo.shmaddr = (char *) shmat( shminfo.shmid, 0, 0 );
if( shminfo.shmaddr != (char *)-1 ) {
/**
* XShmAttach fails on remote displays, so we have to catch
* this event.
*/
XSync( display, False );
x11_InstallXErrorHandler();
shminfo.readOnly = True;
if( XShmAttach( display, &shminfo ) ) {
error = 0;
} else {
fprintf( stderr, "xvoutput: tvtime cannot run on a remote X server.\n" );
}
XSync( display, False );
/**
* We immediately delete the shared memory segment to ensure
* that we clean up after crashes.
*/
shmctl( shminfo.shmid, IPC_RMID, 0 );
}
} else {
fprintf( stderr, "xvoutput: Out of memory.\n" );
}
if( error ) {
return 0;
} else {
return shminfo.shmaddr;
}
}
int main(int argc, char **argv)
{
int num_queued;
time_t start_time;
double t;
long num_frames, fast_skip = 200, fast_rewind = 200;
unsigned int width, height;
XEvent xevent;
const char *prgname = argv[0];
const char *classname = "XLndmovie";
char *pixel_file_name = NULL;
FILE *pixel_file;
unsigned char *buffer = NULL, *huff = NULL;
XImage *shm_image;
XShmSegmentInfo shminfo;
int shm_major, shm_minor;
Bool shm_pixmaps;
int ShmCompletionType;
int shmtransfer_completed;
int i, count, step_key = 0;
char xkey[32];
KeySym keysym;
XComposeStatus compose;
int oc;
extern int optind;
extern char *optarg;
init_signal_handling();
display = xwin_init(NULL, prgname, classname, argc, argv, &screen_no, &width, &height);
fixed_font = XLoadQueryFont(display, "fixed");
mit_shm = XShmQueryVersion(display, &shm_major, &shm_minor, &shm_pixmaps);
mit_shm = XShmQueryExtension(display);
if (mit_shm == True)
{
/* printf("Shared memory extension used (found V %d.%d)\n", shm_major, shm_minor); */
ShmCompletionType = XShmGetEventBase(display) + ShmCompletion;
}
/*
else
printf("Standard Xlib used, no shared memory\n");
*/
while ((oc = getopt(argc, argv, "c:f:r:h")) != -1)
{
switch (oc)
{
case 'c':
cell_boxsize = strtol(optarg, NULL, 10);
break;
case 'f':
fast_skip = strtol(optarg, NULL, 10);
if (fast_skip < 1)
fast_skip = 200;
break;
case 'r':
fast_rewind = strtol(optarg, NULL, 10);
if (fast_rewind < 1)
fast_rewind = 200;
break;
default:
fprintf(stderr, "Unknown option \'-%c\' -- ignored\n", oc);
break;
}
}
if (optind < argc)
pixel_file_name = argv[optind++];
else
{
fprintf(stderr, "No pixel file specified -- exit\n");
exit (EXIT_FAILURE);
}
pixel_file = fopen(pixel_file_name, "rb");
if (pixel_file == NULL)
{
fprintf(stderr, "Failed to open pixel file \"%s\" -- exit\n", pixel_file_name);
exit (EXIT_FAILURE);
}
read_pixheader(pixel_file);
if ((cell_boxsize <= 0) || ((width / world_width) < cell_boxsize))
cell_boxsize = width / world_width;
if ((height / world_height) < cell_boxsize)
cell_boxsize = height / world_height;
if (cell_boxsize <= 0)
cell_boxsize = 1;
if ((height / world_height) < cell_boxsize)
cell_boxsize = height / world_height;
window_width = world_width * cell_boxsize;
pixmap_height = world_height * cell_boxsize;
if (fixed_font)
window_height = pixmap_height + fixed_font->ascent + fixed_font->descent + 5;
else
window_height = pixmap_height;
buffer = (unsigned char *) malloc(world_width * world_height * sizeof(char));
if (buffer == NULL)
{
fprintf(stderr, "Failed to allocate internal buffer\n");
exit (EXIT_FAILURE);
}
huff = (unsigned char *) malloc(world_width * world_height * sizeof(char));
if (buffer == NULL)
{
fprintf(stderr, "Failed to allocate internal buffer\n");
free(buffer);
exit (EXIT_FAILURE);
}
window = create_window(MOVER | FULLER | CLOSER | RTARROW | LFARROW | UPARROW | DNARROW,
window_width, window_height, redraw_pixworld, close_pixwindow, 100, 100, window_width, window_height);
XSelectInput(display, window, WH_EVENTMASK | WH_SELECTMASK);
map_window(window);
if (create_lndgcs(lnd_gc, lndx_gc, background_gc, &text_gc))
{
fprintf(stderr, "Failed to create necessary GCs (insufficient colors?)\n");
free(buffer);
free(huff);
exit (EXIT_FAILURE);
}
if (mit_shm)
{
shm_image = XShmCreateImage(display, DefaultVisual(display, screen_no),
DefaultDepth(display, screen_no), ZPixmap, NULL, &shminfo, window_width, pixmap_height);
/*
printf("XImage Structure:\n");
printf("width = %d, height = %d, depth = %d\n", shm_image->width, shm_image->height, shm_image->depth);
printf("format: ");
switch (shm_image->format)
{
case XYBitmap:
printf("XYBitmap\n");
break;
case XYPixmap:
printf("XYPixmap\n");
break;
case ZPixmap:
printf("ZPixmap\n");
break;
default:
printf("UNKNOWN (%d)\n", shm_image->format);
break;
}
printf("%d bytes per line, %d bits per pixel\n", shm_image->bytes_per_line, shm_image->bits_per_pixel);
switch (shm_image->byte_order)
{
case MSBFirst:
printf("byte order: MSBFirst\n");
break;
case LSBFirst:
printf("byte order: LSBFirst\n");
break;
default:
printf("byte order UNKNOWN (%d)\n", shm_image->byte_order);
break;
}
switch (shm_image->bitmap_bit_order)
{
case MSBFirst:
printf("bitmap bit order: MSBFirst\n");
break;
case LSBFirst:
printf("bitmap bit order: LSBFirst\n");
break;
default:
printf("bitmap bit order UNKNOWN (%d)\n", shm_image->bitmap_bit_order);
break;
}
*/
shminfo.shmid = shmget(IPC_PRIVATE, shm_image->bytes_per_line * shm_image->height, IPC_CREAT | 0777);
if (shminfo.shmid == -1)
{
fprintf(stderr, "Failed to get shared memory segment, falling back to standard Xlib\n");
mit_shm = 0;
}
else
{
shminfo.shmaddr = shmat(shminfo.shmid, 0, 0);
shm_image->data = shminfo.shmaddr;
shminfo.readOnly = False;
if (XShmAttach(display, &shminfo))
; /* printf("Shared mem successfully attached to server\n"); */
else
{
mit_shm = 0;
XDestroyImage(shm_image);
shmdt(shminfo.shmaddr);
shmctl(shminfo.shmid, IPC_RMID, 0);
printf("Shared memory released\n");
}
}
}
if (!mit_shm)
{
paint_pixmap = XCreatePixmap(display, window, window_width, pixmap_height, DefaultDepth(display, screen_no));
XFillRectangle(display, paint_pixmap, background_gc[15], 0, 0, window_width, pixmap_height);
}
redraw_pixmap = XCreatePixmap(display, window, window_width, pixmap_height, DefaultDepth(display, screen_no));
XFillRectangle(display, redraw_pixmap, background_gc[15], 0, 0, window_width, pixmap_height);
/*
for (i = 0; i < 6; i++)
{
XPutPixel(shm_image, 0, 0, lnd_pixel[i]);
printf("lnd_pixel[%d]=%08lx -> data=%02x\n", i, lnd_pixel[i], shm_image->data[0]);
XPutPixel(shm_image, 0, 0, lndx_pixel[i]);
printf("lndx_pixel[%d]=%08lx -> data=%02x\n", i, lndx_pixel[i], shm_image->data[0]);
}
XPutPixel(shm_image, 0, 0, back_pixel);
printf("back_pixel=%08lx -> data=%02x\n", back_pixel, shm_image->data[0]);
*/
do
{
XNextEvent(display, &xevent);
num_queued = XEventsQueued(display, QueuedAfterFlush);
process_xevent(&xevent);
}
while (!((xevent.type == Expose) && (xevent.xexpose.window == window)));
shmtransfer_completed = 1;
start_time = time(NULL);
num_frames = 0;
while (!game_over)
{
if(feof(pixel_file) || ferror(pixel_file))
{
if (resume_fpos != -1)
{
mode = SINGLE_STEP;
/* printf("switched to single step due to feof / ferror\n"); */
step_key = 0;
/*
printf("rewinding to resume pos %ld\n", resume_fpos);
fseek(pixel_file, resume_fpos, SEEK_SET);
*/
}
else
{
fprintf(stderr, "Encountered EOF without finding any entry point -- quitting\n");
game_over = 1;
}
}
num_queued = XEventsQueued(display, QueuedAfterFlush);
while ((num_queued) || ((mode == SINGLE_STEP) && !step_key))
{
XNextEvent(display, &xevent);
num_queued = XEventsQueued(display, QueuedAfterFlush);
/* printf("received event: %s, window: %d\n", event_name[xevent.type], (int) xevent.xany.window); */
if (process_xevent(&xevent))
continue;
if (xevent.type == ShmCompletionType)
{
/* printf("shm transfer completed\n"); */
shmtransfer_completed = 1;
}
if (xevent.type == KeyPress)
{
count = XLookupString(&(xevent.xkey), xkey, 32, &keysym, &compose);
if (count)
{
switch(xkey[0])
{
case 'f':
/* printf("fast forward\n"); */
/* printf("rewind position: %ld\n", resume_fpos); */
mode = FAST_FORWARD;
break;
case 'r':
/* printf("fast rewind\n"); */
/* printf("rewind position: %ld\n", resume_fpos); */
mode = FAST_REWIND;
break;
case 'b':
/* printf("backward play\n"); */
/* printf("rewind position: %ld\n", resume_fpos); */
mode = BACKWARD_PLAY;
rewind_generation(pixel_file);
break;
case 's':
/* printf("single step\n"); */
mode = SINGLE_STEP;
step_key = 0;
break;
case 'n':
/* printf("normal play\n"); */
/* printf("rewind position: %ld\n", resume_fpos); */
mode = NORMAL_PLAY;
break;
case 'q': case 'Q':
/* printf("game over, bye bye\n"); */
mode = NORMAL_PLAY;
step_key = 1;
game_over = 1;
break;
default:
step_key = 1;
break;
}
}
}
}
if ((mode == NORMAL_PLAY) || (mode == BACKWARD_PLAY) || ((mode == SINGLE_STEP) && step_key)
|| ((mode == FAST_FORWARD) && ((generation % fast_skip) == (fast_skip - 1)))
|| ((mode == FAST_REWIND) && ((generation % fast_rewind) == 1)))
{
if (mit_shm && shmtransfer_completed)
{
if (shm_draw_generation(pixel_file, shm_image, buffer, huff))
{
mode = SINGLE_STEP;
/* printf("switched to single step after shm_draw_generation\n"); */
step_key = 0;
}
else
{
if (window != BadValue)
XShmPutImage(display, window, background_gc[15], shm_image, 0, 0, 0, window_height - pixmap_height, window_width, pixmap_height, True);
if (redraw_pixmap != BadValue)
XShmPutImage(display, redraw_pixmap, background_gc[15], shm_image, 0, 0, 0, 0, window_width, pixmap_height, True);
shmtransfer_completed = 0;
num_frames++;
}
}
else
{
if (draw_generation(pixel_file, paint_pixmap, buffer, huff))
{
mode = SINGLE_STEP;
/* printf("switched to single step after draw_generation\n"); */
step_key = 0;
}
else
{
if (window != BadValue)
XCopyArea(display, paint_pixmap, window, background_gc[15], 0, 0, window_width, pixmap_height, 0, window_height - pixmap_height);
if (redraw_pixmap != BadValue)
XCopyArea(display, paint_pixmap, redraw_pixmap, background_gc[15], 0, 0, window_width, pixmap_height, 0, 0);
num_frames++;
}
}
redraw_text();
if (mode == FAST_REWIND)
{
if (rewind_generation(pixel_file))
{
mode = SINGLE_STEP;
/* printf("switched to single step after rewind_generation\n"); */
step_key = 0;
}
}
step_key = 0;
}
switch (mode)
{
case BACKWARD_PLAY:
if (rewind_generation(pixel_file))
{
mode = SINGLE_STEP;
/* printf("switched to single step after rewind_generation\n"); */
step_key = 0;
}
/* fall through */
case FAST_REWIND:
if (rewind_generation(pixel_file))
{
mode = SINGLE_STEP;
/* printf("switched to single step after rewind_generation\n"); */
step_key = 0;
}
redraw_text();
break;
case FAST_FORWARD:
if (skip_frame(pixel_file))
{
mode = SINGLE_STEP;
/* printf("switched to single step after skip_frame\n"); */
step_key = 0;
}
redraw_text();
break;
}
}
t = difftime(time(NULL), start_time);
/* printf("%ld frames in %f seconds (%f frames/sec)\n", num_frames, t, num_frames / t); */
if (mit_shm)
{
XShmDetach(display, &shminfo);
XDestroyImage(shm_image);
shmdt(shminfo.shmaddr);
shmctl(shminfo.shmid, IPC_RMID, 0);
printf("Shared memory released\n");
}
free_lndgcs();
if (window != BadValue)
remove_window(window);
if (redraw_pixmap != BadValue)
XFreePixmap(display, redraw_pixmap);
if (paint_pixmap != BadValue)
XFreePixmap(display, paint_pixmap);
free(buffer);
free(huff);
return (EXIT_SUCCESS);
}
/*
* Setup X11 wnd System
*/
void
X11_SetupWindow (GF_VideoOutput * vout)
{
X11VID ();
const char *sOpt;
Bool autorepeat, supported;
xWindow->display = XOpenDisplay (NULL);
xWindow->screennum = DefaultScreen (xWindow->display);
xWindow->screenptr = DefaultScreenOfDisplay (xWindow->display);
xWindow->visual = DefaultVisualOfScreen (xWindow->screenptr);
xWindow->depth = DefaultDepth (xWindow->display, xWindow->screennum);
{
Float screenWidth = (Float)XWidthOfScreen(xWindow->screenptr);
Float screenWidthIn = (Float)XWidthMMOfScreen(xWindow->screenptr) / 25.4f;
Float screenHeight = (Float)XHeightOfScreen(xWindow->screenptr);
Float screenHeightIn = (Float)XHeightMMOfScreen(xWindow->screenptr) / 25.4f;
vout->dpi_x = (u32)(screenWidth / screenWidthIn);
vout->dpi_y = (u32)(screenHeight / screenHeightIn);
}
switch (xWindow->depth) {
case 8:
xWindow->pixel_format = GF_PIXEL_GREYSCALE;
break;
case 16:
xWindow->pixel_format = GF_PIXEL_RGB_565;
break;
case 24:
xWindow->pixel_format = GF_PIXEL_RGB_32;
break;
default:
xWindow->pixel_format = GF_PIXEL_GREYSCALE;
break;
}
xWindow->bpp = xWindow->depth / 8;
xWindow->bpp = xWindow->bpp == 3 ? 4 : xWindow->bpp;
xWindow->screennum=0;
vout->max_screen_width = DisplayWidth(xWindow->display, xWindow->screennum);
vout->max_screen_height = DisplayHeight(xWindow->display, xWindow->screennum);
/*
* Full screen wnd
*/
xWindow->full_wnd = XCreateWindow (xWindow->display,
RootWindowOfScreen (xWindow->screenptr),
0, 0,
vout->max_screen_width,
vout->max_screen_height, 0,
xWindow->depth, InputOutput,
xWindow->visual, 0, NULL);
XSelectInput(xWindow->display, xWindow->full_wnd,
FocusChangeMask | ExposureMask | PointerMotionMask | ButtonReleaseMask | ButtonPressMask | KeyPressMask | KeyReleaseMask);
if (!xWindow->par_wnd) {
xWindow->w_width = 320;
xWindow->w_height = 240;
xWindow->wnd = XCreateWindow (xWindow->display,
RootWindowOfScreen(xWindow->screenptr), 0, 0,
xWindow->w_width, xWindow->w_height, 0,
xWindow->depth, InputOutput,
xWindow->visual, 0, NULL);
XMapWindow (xWindow->display, (Window) xWindow->wnd);
} else {
XWindowAttributes pwa;
XGetWindowAttributes(xWindow->display, xWindow->par_wnd, &pwa);
xWindow->w_width = pwa.width;
xWindow->w_height = pwa.height;
xWindow->wnd = XCreateWindow (xWindow->display, xWindow->par_wnd, pwa.x, pwa.y,
xWindow->w_width, xWindow->w_height, 0,
xWindow->depth, InputOutput,
xWindow->visual, 0, NULL);
XMapWindow (xWindow->display, (Window) xWindow->wnd);
}
XSync(xWindow->display, False);
XUnmapWindow (xWindow->display, (Window) xWindow->wnd);
XSync(xWindow->display, False);
old_handler = XSetErrorHandler(X11_BadAccess_ByPass);
selectinput_err = 0;
XSelectInput(xWindow->display, xWindow->wnd,
FocusChangeMask | StructureNotifyMask | PropertyChangeMask | ExposureMask |
PointerMotionMask | ButtonReleaseMask | ButtonPressMask |
KeyPressMask | KeyReleaseMask);
XSync(xWindow->display, False);
XSetErrorHandler(old_handler);
if (selectinput_err) {
XSelectInput(xWindow->display, xWindow->wnd,
StructureNotifyMask | PropertyChangeMask | ExposureMask |
KeyPressMask | KeyReleaseMask);
GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("[X11] Cannot select input focus\n"));
}
XSync(xWindow->display, False);
XMapWindow (xWindow->display, (Window) xWindow->wnd);
XSizeHints *Hints = XAllocSizeHints ();
Hints->flags = PSize | PMinSize;
Hints->min_width = 64;
Hints->min_height = 64;
Hints->max_height = 4096;
Hints->max_width = 4096;
if (!xWindow->par_wnd) {
XSetWMNormalHints (xWindow->display, xWindow->wnd, Hints);
XStoreName (xWindow->display, xWindow->wnd, "GPAC X11 Output");
}
Hints->x = 0;
Hints->y = 0;
Hints->flags |= USPosition;
XSetWMNormalHints (xWindow->display, xWindow->full_wnd, Hints);
autorepeat = 1;
XkbSetDetectableAutoRepeat(xWindow->display, autorepeat, &supported);
if (xWindow->init_flags & GF_TERM_WINDOW_NO_DECORATION) {
#define PROP_MOTIF_WM_HINTS_ELEMENTS 5
#define MWM_HINTS_DECORATIONS (1L << 1)
struct {
unsigned long flags;
unsigned long functions;
unsigned long decorations;
long inputMode;
unsigned long status;
} hints = {2, 0, 0, 0, 0};
hints.flags = MWM_HINTS_DECORATIONS;
hints.decorations = 0;
XChangeProperty(xWindow->display, xWindow->wnd, XInternAtom(xWindow->display,"_MOTIF_WM_HINTS", False), XInternAtom(xWindow->display, "_MOTIF_WM_HINTS", False), 32, PropModeReplace, (unsigned char *)&hints, PROP_MOTIF_WM_HINTS_ELEMENTS);
}
xWindow->the_gc = XCreateGC (xWindow->display, xWindow->wnd, 0, NULL);
xWindow->use_shared_memory = 0;
#ifdef GPAC_HAS_X11_SHM
sOpt = gf_modules_get_option((GF_BaseInterface *)vout, "Video", "UseHardwareMemory");
if (sOpt && !strcmp(sOpt, "yes")) {
int XShmMajor, XShmMinor;
Bool XShmPixmaps;
if (XShmQueryVersion(xWindow->display, &XShmMajor, &XShmMinor, &XShmPixmaps)) {
xWindow->use_shared_memory = 1;
GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("[X11] Using X11 Shared Memory\n"));
if ((XShmPixmaps==True) && (XShmPixmapFormat(xWindow->display)==ZPixmap)) {
GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("[X11] X11 Shared Memory Pixmaps available\n"));
}
}
}
#endif
#ifdef GPAC_HAS_X11_XV
sOpt = gf_modules_get_option((GF_BaseInterface *)vout, "Video", "DisableColorKeying");
if (sOpt && !strcmp(sOpt, "yes")) {
xWindow->xvport = X11_GetXVideoPort(vout, GF_PIXEL_I420, 0);
} else {
xWindow->xvport = X11_GetXVideoPort(vout, GF_PIXEL_I420, 1);
if (xWindow->xvport<0) {
GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("[X11] Hardware has no color keying\n"));
vout->overlay_color_key = 0;
xWindow->xvport = X11_GetXVideoPort(vout, GF_PIXEL_I420, 0);
} else {
GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("[X11] Hardware uses color key %08x\n", vout->overlay_color_key));
}
}
if (xWindow->xvport>=0) {
XvUngrabPort(xWindow->display, xWindow->xvport, CurrentTime );
xWindow->xvport = -1;
vout->yuv_pixel_format = X11_GetPixelFormat(xWindow->xv_pf_format);
vout->Blit = X11_Blit;
vout->hw_caps |= GF_VIDEO_HW_HAS_YUV_OVERLAY;
GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("[X11] Using XV YUV Overlays\n"));
#ifdef GPAC_HAS_X11_SHM
/*if user asked for YUV->RGB on offscreen, do it (it may crash the system)*/
sOpt = gf_modules_get_option((GF_BaseInterface *)vout, "Video", "EnableOffscreenYUV");
if (sOpt && !strcmp(sOpt, "yes")) {
vout->hw_caps |= GF_VIDEO_HW_HAS_YUV;
GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("[X11] Using XV Offscreen YUV2RGB acceleration\n"));
}
#endif
}
#endif
XSetWindowAttributes xsw;
xsw.border_pixel = WhitePixel (xWindow->display, xWindow->screennum);
xsw.background_pixel = BlackPixel (xWindow->display, xWindow->screennum);
xsw.win_gravity = NorthWestGravity;
XChangeWindowAttributes (xWindow->display, xWindow->wnd, CWBackPixel | CWWinGravity, &xsw);
xsw.override_redirect = True;
XChangeWindowAttributes(xWindow->display, xWindow->full_wnd,
CWOverrideRedirect | CWBackPixel | CWBorderPixel | CWWinGravity, &xsw);
if (!xWindow->par_wnd) {
xWindow->WM_DELETE_WINDOW = XInternAtom (xWindow->display, "WM_DELETE_WINDOW", False);
XSetWMProtocols(xWindow->display, xWindow->wnd, &xWindow->WM_DELETE_WINDOW, 1);
}
{
XEvent ev;
long mask;
memset (&ev, 0, sizeof (ev));
ev.xclient.type = ClientMessage;
ev.xclient.window = RootWindowOfScreen (xWindow->screenptr);
ev.xclient.message_type = XInternAtom (xWindow->display, "KWM_KEEP_ON_TOP", False);
ev.xclient.format = 32;
ev.xclient.data.l[0] = xWindow->full_wnd;
ev.xclient.data.l[1] = CurrentTime;
mask = SubstructureRedirectMask;
XSendEvent (xWindow->display,RootWindowOfScreen (xWindow->screenptr), False,
mask, &ev);
}
/*openGL setup*/
#ifdef GPAC_HAS_OPENGL
{
int attribs[64];
int i, nb_bits;
sOpt = gf_modules_get_option((GF_BaseInterface *)vout, "Video", "GLNbBitsPerComponent");
/* Most outputs are 24/32 bits these days, use 8 bits per channel instead of 5, works better on MacOS X */
nb_bits = sOpt ? atoi(sOpt) : 8;
if (!sOpt){
gf_modules_set_option((GF_BaseInterface *)vout, "Video", "GLNbBitsPerComponent", "8");
}
i=0;
attribs[i++] = GLX_RGBA;
attribs[i++] = GLX_RED_SIZE;
attribs[i++] = nb_bits;
attribs[i++] = GLX_GREEN_SIZE;
attribs[i++] = nb_bits;
attribs[i++] = GLX_BLUE_SIZE;
attribs[i++] = nb_bits;
sOpt = gf_modules_get_option((GF_BaseInterface *)vout, "Video", "GLNbBitsDepth");
nb_bits = sOpt ? atoi(sOpt) : 16;
if (!sOpt){
gf_modules_set_option((GF_BaseInterface *)vout, "Video", "GLNbBitsDepth", "16");
}
if (nb_bits) {
attribs[i++] = GLX_DEPTH_SIZE;
attribs[i++] = nb_bits;
}
sOpt = gf_modules_get_option((GF_BaseInterface *)vout, "Video", "UseGLDoubleBuffering");
if (!sOpt){
gf_modules_set_option((GF_BaseInterface *)vout, "Video", "UseGLDoubleBuffering", "yes");
}
if (!sOpt || !strcmp(sOpt, "yes")) attribs[i++] = GLX_DOUBLEBUFFER;
attribs[i++] = None;
xWindow->glx_visualinfo = glXChooseVisual(xWindow->display, xWindow->screennum, attribs);
if (!xWindow->glx_visualinfo) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("[X11] Error selecting GL display\n"));
}
}
xWindow->gl_wnd = XCreateWindow (xWindow->display, RootWindowOfScreen (xWindow->screenptr),
0,
0,
200,
200, 0,
xWindow->depth, InputOutput,
xWindow->visual, 0, NULL);
XSync(xWindow->display, False);
XUnmapWindow(xWindow->display, (Window) xWindow->gl_wnd);
XSync(xWindow->display, False);
sOpt = gf_modules_get_option((GF_BaseInterface *)vout, "Video", "X113DOffscreenMode");
if (!sOpt)
gf_modules_set_option((GF_BaseInterface *)vout, "Video", "X113DOffscreenMode", "Pixmap");
if (sOpt && !strcmp(sOpt, "Window")) {
xWindow->offscreen_type = 1;
} else if (sOpt && !strcmp(sOpt, "VisibleWindow")) {
xWindow->offscreen_type = 2;
XSetWMNormalHints (xWindow->display, xWindow->gl_wnd, Hints);
} else if (sOpt && !strcmp(sOpt, "Pixmap")) {
xWindow->offscreen_type = 0;
} else {
xWindow->offscreen_type = 0;
}
#endif
/*turn off xscreensaver*/
X11_XScreenSaverState(xWindow, 0);
xWindow->setup_done = 1;
XFree (Hints);
}
void xf_xdamage_init(xfInfo* xfi)
{
Bool pixmaps;
int damage_event;
int damage_error;
int major, minor;
XGCValues values;
if (XShmQueryExtension(xfi->display) != False)
{
XShmQueryVersion(xfi->display, &major, &minor, &pixmaps);
if (pixmaps != True)
{
printf("XShmQueryVersion failed\n");
return;
}
}
else
{
printf("XShmQueryExtension failed\n");
return;
}
if (XDamageQueryExtension(xfi->display, &damage_event, &damage_error) == 0)
{
printf("XDamageQueryExtension failed\n");
return;
}
XDamageQueryVersion(xfi->display, &major, &minor);
if (XDamageQueryVersion(xfi->display, &major, &minor) == 0)
{
printf("XDamageQueryVersion failed\n");
return;
}
else if (major < 1)
{
printf("XDamageQueryVersion failed: major:%d minor:%d\n", major, minor);
return;
}
xfi->xdamage_notify_event = damage_event + XDamageNotify;
xfi->xdamage = XDamageCreate(xfi->display, xfi->root_window, XDamageReportDeltaRectangles);
if (xfi->xdamage == None)
{
printf("XDamageCreate failed\n");
return;
}
#ifdef WITH_XFIXES
xfi->xdamage_region = XFixesCreateRegion(xfi->display, NULL, 0);
if (xfi->xdamage_region == None)
{
printf("XFixesCreateRegion failed\n");
XDamageDestroy(xfi->display, xfi->xdamage);
xfi->xdamage = None;
return;
}
#endif
values.subwindow_mode = IncludeInferiors;
xfi->xdamage_gc = XCreateGC(xfi->display, xfi->root_window, GCSubwindowMode, &values);
XSetFunction(xfi->display, xfi->xdamage_gc, GXcopy);
}
static DFBResult
InitLocal( DFBX11 *x11, DFBX11Shared *shared, CoreDFB *core )
{
int i, n, d;
XInitThreads();
x11->shared = shared;
x11->core = core;
x11->display = XOpenDisplay(getenv("DISPLAY"));
if (!x11->display) {
D_ERROR("X11: Error in XOpenDisplay for '%s'\n", getenv("DISPLAY"));
return DFB_INIT;
}
x11->screenptr = DefaultScreenOfDisplay(x11->display);
x11->screennum = DefaultScreen(x11->display);
d = DefaultDepthOfScreen(x11->screenptr);
for (i=0; i<x11->screenptr->ndepths; i++) {
const Depth *depth = &x11->screenptr->depths[i];
for (n=0; n<depth->nvisuals; n++) {
Visual *visual = &depth->visuals[n];
D_DEBUG_AT( X11_Core, "[Visual %d] ID 0x%02lx, depth %d, RGB 0x%06lx/0x%06lx/0x%06lx, %d bpRGB, %d entr.\n",
n, visual->visualid, depth->depth,
visual->red_mask, visual->green_mask, visual->blue_mask,
visual->bits_per_rgb, visual->map_entries );
if (depth->depth != d)
continue;
switch (depth->depth) {
case 32:
if (visual->red_mask == 0xff0000 &&
visual->green_mask == 0x00ff00 &&
visual->blue_mask == 0x0000ff &&
!x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_ARGB)])
x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_ARGB)] = visual;
break;
case 24:
if (visual->red_mask == 0xff0000 &&
visual->green_mask == 0x00ff00 &&
visual->blue_mask == 0x0000ff &&
!x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB32)])
x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB32)] = visual;
break;
case 16:
if (visual->red_mask == 0xf800 &&
visual->green_mask == 0x07e0 &&
visual->blue_mask == 0x001f &&
!x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB16)])
x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB16)] = visual;
break;
case 15:
if (visual->red_mask == 0x7c00 &&
visual->green_mask == 0x03e0 &&
visual->blue_mask == 0x001f &&
!x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB555)])
x11->visuals[DFB_PIXELFORMAT_INDEX(DSPF_RGB555)] = visual;
break;
}
}
}
if (XShmQueryExtension( x11->display ))
XShmQueryVersion( x11->display, &x11->xshm_major, &x11->xshm_minor, &x11->use_shm );
x11->screen = dfb_screens_register( NULL, x11, x11PrimaryScreenFuncs );
dfb_layers_register( x11->screen, x11, x11PrimaryLayerFuncs );
dfb_layers_register( x11->screen, x11, x11PrimaryLayerFuncs );
dfb_layers_register( x11->screen, x11, x11PrimaryLayerFuncs );
return DFB_OK;
}
int xf_xshm_init(xfInfo* xfi)
{
Bool pixmaps;
int major, minor;
if (XShmQueryExtension(xfi->display) != False)
{
XShmQueryVersion(xfi->display, &major, &minor, &pixmaps);
if (pixmaps != True)
{
fprintf(stderr, "XShmQueryVersion failed\n");
return -1;
}
}
else
{
fprintf(stderr, "XShmQueryExtension failed\n");
return -1;
}
xfi->fb_shm_info.shmid = -1;
xfi->fb_shm_info.shmaddr = (char*) -1;
xfi->fb_image = XShmCreateImage(xfi->display, xfi->visual, xfi->depth,
ZPixmap, NULL, &(xfi->fb_shm_info), xfi->width, xfi->height);
if (!xfi->fb_image)
{
fprintf(stderr, "XShmCreateImage failed\n");
return -1;
}
xfi->fb_shm_info.shmid = shmget(IPC_PRIVATE,
xfi->fb_image->bytes_per_line * xfi->fb_image->height, IPC_CREAT | 0600);
if (xfi->fb_shm_info.shmid == -1)
{
fprintf(stderr, "shmget failed\n");
return -1;
}
xfi->fb_shm_info.readOnly = False;
xfi->fb_shm_info.shmaddr = shmat(xfi->fb_shm_info.shmid, 0, 0);
xfi->fb_image->data = xfi->fb_shm_info.shmaddr;
if (xfi->fb_shm_info.shmaddr == ((char*) -1))
{
fprintf(stderr, "shmat failed\n");
return -1;
}
XShmAttach(xfi->display, &(xfi->fb_shm_info));
XSync(xfi->display, False);
shmctl(xfi->fb_shm_info.shmid, IPC_RMID, 0);
fprintf(stderr, "display: %p root_window: %p width: %d height: %d depth: %d\n",
xfi->display, (void*) xfi->root_window, xfi->fb_image->width, xfi->fb_image->height, xfi->fb_image->depth);
xfi->fb_pixmap = XShmCreatePixmap(xfi->display,
xfi->root_window, xfi->fb_image->data, &(xfi->fb_shm_info),
xfi->fb_image->width, xfi->fb_image->height, xfi->fb_image->depth);
return 0;
}
static int x11_shadow_xshm_init(x11ShadowSubsystem* subsystem)
{
Bool pixmaps;
int major, minor;
XGCValues values;
if (!XShmQueryExtension(subsystem->display))
return -1;
if (!XShmQueryVersion(subsystem->display, &major, &minor, &pixmaps))
return -1;
if (!pixmaps)
return -1;
subsystem->fb_shm_info.shmid = -1;
subsystem->fb_shm_info.shmaddr = (char*) -1;
subsystem->fb_shm_info.readOnly = False;
subsystem->fb_image = XShmCreateImage(subsystem->display, subsystem->visual, subsystem->depth,
ZPixmap, NULL, &(subsystem->fb_shm_info), subsystem->width, subsystem->height);
if (!subsystem->fb_image)
{
WLog_ERR(TAG, "XShmCreateImage failed");
return -1;
}
subsystem->fb_shm_info.shmid = shmget(IPC_PRIVATE,
subsystem->fb_image->bytes_per_line * subsystem->fb_image->height, IPC_CREAT | 0600);
if (subsystem->fb_shm_info.shmid == -1)
{
WLog_ERR(TAG, "shmget failed");
return -1;
}
subsystem->fb_shm_info.shmaddr = shmat(subsystem->fb_shm_info.shmid, 0, 0);
subsystem->fb_image->data = subsystem->fb_shm_info.shmaddr;
if (subsystem->fb_shm_info.shmaddr == ((char*) -1))
{
WLog_ERR(TAG, "shmat failed");
return -1;
}
if (!XShmAttach(subsystem->display, &(subsystem->fb_shm_info)))
return -1;
XSync(subsystem->display, False);
shmctl(subsystem->fb_shm_info.shmid, IPC_RMID, 0);
subsystem->fb_pixmap = XShmCreatePixmap(subsystem->display,
subsystem->root_window, subsystem->fb_image->data, &(subsystem->fb_shm_info),
subsystem->fb_image->width, subsystem->fb_image->height, subsystem->fb_image->depth);
XSync(subsystem->display, False);
if (!subsystem->fb_pixmap)
return -1;
values.subwindow_mode = IncludeInferiors;
values.graphics_exposures = False;
subsystem->xshm_gc = XCreateGC(subsystem->display, subsystem->root_window,
GCSubwindowMode | GCGraphicsExposures, &values);
XSetFunction(subsystem->display, subsystem->xshm_gc, GXcopy);
XSync(subsystem->display, False);
return 1;
}
int
ga_xwin_init(const char *displayname, gaImage *gaimg) {
int ignore = 0;
//
bzero(&__xshminfo, sizeof(__xshminfo));
// open display
if((display = XOpenDisplay(displayname)) == NULL) {
ga_error("cannot open display \"%s\"\n", displayname ? displayname : "DEFAULT");
return -1;
}
// check MIT extension
if(XQueryExtension(display, "MIT-SHM", &ignore, &ignore, &ignore) ) {
int major, minor;
Bool pixmaps;
if(XShmQueryVersion(display, &major, &minor, &pixmaps) == True) {
ga_error("XShm extention version %d.%d %s shared pixmaps\n",
major, minor, (pixmaps==True) ? "with" : "without");
} else {
ga_error("XShm extension not supported.\n");
goto xcap_init_error;
}
}
// get default screen
screenNumber = XDefaultScreen(display);
if((screen = XScreenOfDisplay(display, screenNumber)) == NULL) {
ga_error("cannot obtain screen #%d\n", screenNumber);
goto xcap_init_error;
}
//
width = XDisplayWidth(display, screenNumber);
height = XDisplayHeight(display, screenNumber);
depth = XDisplayPlanes(display, screenNumber);
ga_error("X-Window-init: dimension: %dx%dx%d @ %d/%d\n",
width, height, depth,
screenNumber, XScreenCount(display));
//
if((image = XShmCreateImage(display,
XDefaultVisual(display, screenNumber),
depth, ZPixmap, NULL, &__xshminfo,
width, height)) == NULL) {
ga_error("XShmCreateImage failed.\n");
goto xcap_init_error;
}
//
if((__xshminfo.shmid = shmget(IPC_PRIVATE,
image->bytes_per_line*image->height,
IPC_CREAT | 0777)) < 0) {
perror("shmget");
goto xcap_init_error;
}
//
__xshminfo.shmaddr = image->data = (char*) shmat(__xshminfo.shmid, 0, 0);
__xshminfo.readOnly = False;
if(XShmAttach(display, &__xshminfo) == 0) {
ga_error("XShmAttach failed.\n");
goto xcap_init_error;
}
//
__xshmattached = true;
rootWindow = XRootWindow(display, screenNumber);
gaimg->width = image->width;
gaimg->height = image->height;
gaimg->bytes_per_line = image->bytes_per_line;
//
return 0;
//
xcap_init_error:
ga_xwin_deinit();
return -1;
}
