DFBResult
dfb_x11_image_init_handler( DFBX11 *x11, x11Image *image )
{
Visual *visual;
XImage *ximage;
D_MAGIC_ASSERT( image, x11Image );
if (!x11->use_shm)
return DFB_UNSUPPORTED;
/* Lookup visual. */
visual = x11->visuals[DFB_PIXELFORMAT_INDEX(image->format)];
if (!visual)
return DFB_UNSUPPORTED;
image->visual = visual;
XLockDisplay( x11->display );
ximage = XShmCreateImage( x11->display, image->visual, image->depth,
ZPixmap, NULL, &image->seginfo, image->width, image->height );
if (!ximage) {
D_ERROR( "X11/ShmImage: Error creating shared image (XShmCreateImage)!\n");
XUnlockDisplay( x11->display );
return DFB_FAILURE;
}
/* we firstly create our shared memory segment with the size we need, and
correct permissions for the owner, the group and the world --> 0777 */
image->seginfo.shmid = shmget( IPC_PRIVATE,
ximage->bytes_per_line * ximage->height,
IPC_CREAT | 0777 );
if (image->seginfo.shmid < 0)
goto error;
/* Then, we have to attach the segment to our process, and we let the
function search the correct memory place --> NULL. It's safest ! */
image->seginfo.shmaddr = shmat( image->seginfo.shmid, NULL, 0 );
if (!image->seginfo.shmaddr)
goto error_shmat;
ximage->data = image->seginfo.shmaddr;
/* We set the buffer in Read and Write mode */
image->seginfo.readOnly = False;
if (!XShmAttach( x11->display, &image->seginfo ))
goto error_xshmattach;
image->ximage = ximage;
image->pitch = ximage->bytes_per_line;
image->pixmap = XShmCreatePixmap( x11->display, DefaultRootWindow(x11->display), ximage->data,
&image->seginfo, image->width, image->height, image->depth );
image->gc = XCreateGC( x11->display, image->pixmap, 0, NULL );
XUnlockDisplay( x11->display );
return DFB_OK;
error_xshmattach:
shmdt( image->seginfo.shmaddr );
error_shmat:
shmctl( image->seginfo.shmid, IPC_RMID, NULL );
error:
XDestroyImage( ximage );
XUnlockDisplay( x11->display );
return DFB_FAILURE;
}
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;
}
QNativeImage::QNativeImage(int width, int height, QImage::Format format,bool /* isTextBuffer */, QWidget *widget)
: xshmimg(0), xshmpm(0)
{
QX11Info info = widget->x11Info();
int dd = info.depth();
Visual *vis = (Visual*) info.visual();
if (!X11->use_mitshm || format != QImage::Format_RGB16 && X11->bppForDepth.value(dd) != 32) {
image = QImage(width, height, format);
// follow good coding practice and set xshminfo attributes, though values not used in this case
xshminfo.readOnly = true;
xshminfo.shmaddr = 0;
xshminfo.shmid = 0;
xshminfo.shmseg = 0;
return;
}
xshmimg = XShmCreateImage(X11->display, vis, dd, ZPixmap, 0, &xshminfo, width, height);
if (!xshmimg) {
qWarning("QNativeImage: Unable to create shared XImage.");
return;
}
bool ok;
xshminfo.shmid = shmget(IPC_PRIVATE, xshmimg->bytes_per_line * xshmimg->height,
IPC_CREAT | 0700);
ok = xshminfo.shmid != -1;
if (ok) {
xshmimg->data = (char*)shmat(xshminfo.shmid, 0, 0);
xshminfo.shmaddr = xshmimg->data;
ok = (xshminfo.shmaddr != (char*)-1);
if (ok)
image = QImage((uchar *)xshmimg->data, width, height, format);
}
xshminfo.readOnly = false;
if (ok) {
ok = XShmAttach(X11->display, &xshminfo);
XSync(X11->display, False);
if (shmctl(xshminfo.shmid, IPC_RMID, 0) == -1)
qWarning() << "Error while marking the shared memory segment to be destroyed";
}
if (!ok) {
qWarning() << "QNativeImage: Unable to attach to shared memory segment.";
if (xshmimg->data) {
free(xshmimg->data);
xshmimg->data = 0;
}
XDestroyImage(xshmimg);
xshmimg = 0;
if (xshminfo.shmaddr)
shmdt(xshminfo.shmaddr);
if (xshminfo.shmid != -1)
shmctl(xshminfo.shmid, IPC_RMID, 0);
return;
}
if (X11->use_mitshm_pixmaps) {
xshmpm = XShmCreatePixmap(X11->display, DefaultRootWindow(X11->display), xshmimg->data,
&xshminfo, width, height, dd);
if (!xshmpm) {
qWarning() << "QNativeImage: Unable to create shared Pixmap.";
}
}
}
/*
* init backbuffer
*/
GF_Err X11_InitBackBuffer (GF_VideoOutput * vout, u32 VideoWidth, u32 VideoHeight)
{
Window cur_wnd;
u32 size;
VideoWidth = VideoWidth > 32 ? VideoWidth : 32;
VideoWidth = VideoWidth < 4096 ? VideoWidth : 4096;
VideoHeight = VideoHeight > 32 ? VideoHeight : 32;
VideoHeight = VideoHeight > 4096 ? 4096 : VideoHeight;
X11VID ();
if (!xWindow || !VideoWidth || !VideoHeight)
return GF_BAD_PARAM;
X11_ReleaseBackBuffer(vout);
/*WATCHOUT seems we need even width when using shared memory extensions*/
if (xWindow->use_shared_memory && (VideoWidth%2))
VideoWidth++;
size = VideoWidth * VideoHeight * xWindow->bpp;
cur_wnd = xWindow->fullscreen ? xWindow->full_wnd : xWindow->wnd;
#ifdef GPAC_HAS_X11_SHM
/*if we're using YUV blit to offscreen, we must use a pixmap*/
if (vout->hw_caps & GF_VIDEO_HW_HAS_YUV) {
GF_SAFEALLOC(xWindow->shmseginfo, XShmSegmentInfo);
xWindow->shmseginfo->shmid = shmget(IPC_PRIVATE, size, IPC_CREAT | 0776);
xWindow->shmseginfo->shmaddr = shmat(xWindow->shmseginfo->shmid, 0, 0);
xWindow->shmseginfo->readOnly = False;
if (!XShmAttach (xWindow->display, xWindow->shmseginfo)) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("[X11] Failed to attach shared memory!\n"));
}
xWindow->pixmap = XShmCreatePixmap(xWindow->display, cur_wnd,
(unsigned char *) xWindow->shmseginfo->shmaddr, xWindow->shmseginfo,
VideoWidth, VideoHeight, xWindow->depth);
memset((unsigned char *) xWindow->shmseginfo->shmaddr, 0, sizeof(char)*size);
XSetWindowBackgroundPixmap (xWindow->display, cur_wnd, xWindow->pixmap);
xWindow->pwidth = VideoWidth;
xWindow->pheight = VideoHeight;
GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("[X11] Using X11 Pixmap %08x\n", (u32)xWindow->pixmap));
} else if (xWindow->use_shared_memory) {
GF_SAFEALLOC(xWindow->shmseginfo, XShmSegmentInfo);
xWindow->surface = XShmCreateImage (xWindow->display, xWindow->visual,
xWindow->depth, ZPixmap, NULL, xWindow->shmseginfo,
VideoWidth, VideoHeight);
xWindow->shmseginfo->shmid = shmget(IPC_PRIVATE, xWindow->surface->bytes_per_line * xWindow->surface->height,
IPC_CREAT | 0777);
xWindow->surface->data = xWindow->shmseginfo->shmaddr = shmat(xWindow->shmseginfo->shmid, NULL, 0);
xWindow->shmseginfo->readOnly = False;
XShmAttach (xWindow->display, xWindow->shmseginfo);
} else
#endif
{
char *data = (char *) gf_malloc(sizeof(char)*size);
xWindow->surface = XCreateImage (xWindow->display, xWindow->visual,
xWindow->depth, ZPixmap,
0,
data,
VideoWidth, VideoHeight,
xWindow->bpp*8, xWindow->bpp*VideoWidth);
if (!xWindow->surface) {
gf_free(data);
return GF_IO_ERR;
}
}
xWindow->is_init = 1;
return GF_OK;
}
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;
}
/**
** 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);
}
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
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;
}
#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
{ // Standart
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
{
generic:
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;
}
}
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 varables
fail:
terminate();
init_console();
return false;
}
/*
* init backbuffer
*/
GF_Err X11_InitBackBuffer (GF_VideoOutput * vout, u32 VideoWidth, u32 VideoHeight)
{
Window cur_wnd;
u32 size;
VideoWidth = VideoWidth > 32 ? VideoWidth : 32;
VideoWidth = VideoWidth < 4096 ? VideoWidth : 4096;
VideoHeight = VideoHeight > 32 ? VideoHeight : 32;
VideoHeight = VideoHeight > 4096 ? 4096 : VideoHeight;
X11VID ();
if (!xWindow || !VideoWidth || !VideoHeight)
return GF_BAD_PARAM;
X11_ReleaseBackBuffer(vout);
/*WATCHOUT seems we need even width when using shared memory extensions*/
if ((xWindow->videoaccesstype!=VIDEO_XI_STANDARD) && (VideoWidth%2))
VideoWidth++;
xWindow->back_buffer->BPP = xWindow->bpp;
xWindow->back_buffer->width = VideoWidth;
xWindow->back_buffer->height = VideoHeight;
xWindow->back_buffer->pitch = VideoWidth * xWindow->bpp;
size = VideoWidth * VideoHeight * xWindow->bpp;
cur_wnd = xWindow->fullscreen ? xWindow->full_wnd : xWindow->wnd;
switch (xWindow->videoaccesstype) {
#ifdef GPAC_HAS_X11_SHM
case VIDEO_XI_SHMPIXMAP:
GF_SAFEALLOC(xWindow->shmseginfo, XShmSegmentInfo);
xWindow->shmseginfo->shmid = shmget(IPC_PRIVATE, size, IPC_CREAT | 0777);
xWindow->shmseginfo->shmaddr = shmat(xWindow->shmseginfo->shmid, 0, 0);
xWindow->back_buffer->buffer = (unsigned char *) xWindow->shmseginfo->shmaddr;
xWindow->shmseginfo->readOnly = False;
XShmAttach (xWindow->display, xWindow->shmseginfo);
xWindow->pixmap = XShmCreatePixmap (xWindow->display, cur_wnd,
xWindow->back_buffer->buffer, xWindow->shmseginfo,
VideoWidth, VideoHeight, xWindow->depth);
XSetWindowBackgroundPixmap (xWindow->display, cur_wnd, xWindow->pixmap);
break;
case VIDEO_XI_SHMSTD:
GF_SAFEALLOC(xWindow->shmseginfo, XShmSegmentInfo);
xWindow->surface = XShmCreateImage (xWindow->display, xWindow->visual,
xWindow->depth, ZPixmap, NULL, xWindow->shmseginfo,
VideoWidth, VideoHeight);
xWindow->shmseginfo->shmid = shmget(IPC_PRIVATE,
xWindow->surface->bytes_per_line * xWindow->surface->height,
IPC_CREAT | 0777);
xWindow->surface->data = xWindow->shmseginfo->shmaddr = shmat(xWindow->shmseginfo->shmid, NULL, 0);
xWindow->back_buffer->buffer = (unsigned char *) xWindow->surface->data;
xWindow->shmseginfo->readOnly = False;
XShmAttach (xWindow->display, xWindow->shmseginfo);
break;
#endif
case VIDEO_XI_STANDARD:
xWindow->back_buffer->buffer = (char *) malloc(sizeof(char)*size);
xWindow->surface = XCreateImage (xWindow->display, xWindow->visual,
xWindow->depth, ZPixmap,
0,
xWindow->back_buffer->buffer,
VideoWidth, VideoHeight,
xWindow->bpp*8, xWindow->back_buffer->pitch);
}
xWindow->is_init = 1;
return GF_OK;
}