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; }