/*

SDL - Simple DirectMedia Layer

This library is free software; you can redistribute it and/or

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

You should have received a copy of the GNU Lesser General Public

License along with this library; if not, write to the Free Software

Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

Sam Lantinga

#include "SDL_endian.h"

#include "SDL_x11image_c.h"

#ifndef NO_SHARED_MEMORY

/* Shared memory error handler routine */

static int shm_error;

static int (*X_handler)(Display *, XErrorEvent *) = NULL;

static int shm_errhandler(Display *d, XErrorEvent *e)

{

if ( e->error_code == BadAccess ) {

return(0);

} else

return(X_handler(d,e));

}

/* Dynamic X11 may not have SHM entry points on this box. */

if ((use_mitshm) && (!SDL_X11_HAVE_SHM))

use_mitshm = 0;

if(!use_mitshm)

return;

shminfo.shmid = shmget(IPC_PRIVATE, screen->h*screen->pitch,

IPC_CREAT | 0777);

if ( shminfo.shmid >= 0 ) {

shminfo.shmaddr = (char *)shmat(shminfo.shmid, 0, 0);

shminfo.readOnly = False;

if ( shminfo.shmaddr != (char *)-1 ) {

shm_error = False;

X_handler = XSetErrorHandler(shm_errhandler);

XShmAttach(SDL_Display, &shminfo);

XSync(SDL_Display, True);

XSetErrorHandler(X_handler);

} else {

shm_error = True;

}

if ( shm_error )

use_mitshm = 0;

if ( use_mitshm )

screen->pixels = shminfo.shmaddr;

}

#endif /* ! NO_SHARED_MEMORY */

/* Various screen update functions available */

static void X11_NormalUpdate(_THIS, int numrects, SDL_Rect *rects);

static void X11_MITSHMUpdate(_THIS, int numrects, SDL_Rect *rects);

int X11_SetupImage(_THIS, SDL_Surface *screen)

{

#ifndef NO_SHARED_MEMORY

try_mitshm(this, screen);

if(use_mitshm) {

this->hidden->depth, ZPixmap,

shminfo.shmaddr, &shminfo,

screen->w, screen->h);

XShmDetach(SDL_Display, &shminfo);

XSync(SDL_Display, False);

shmdt(shminfo.shmaddr);

screen->pixels = NULL;

}

this->UpdateRects = X11_MITSHMUpdate;

if ( screen->pixels == NULL ) {

SDL_OutOfMemory();

return -1;

}

bpp = screen->format->BytesPerPixel;

this->hidden->depth, ZPixmap, 0,

(char *)screen->pixels,

screen->w, screen->h,

32, 0);

if ( SDL_Ximage == NULL )

goto error;

/* XPutImage will convert byte sex automatically */

SDL_Ximage->byte_order = (SDL_BYTEORDER == SDL_BIG_ENDIAN)

? MSBFirst : LSBFirst;

this->UpdateRects = X11_NormalUpdate;

}

error:

SDL_SetError("Couldn't create XImage");

return 1;

}

void X11_DestroyImage(_THIS, SDL_Surface *screen)

{

if ( SDL_Ximage ) {

#ifndef NO_SHARED_MEMORY

if ( use_mitshm ) {

XShmDetach(SDL_Display, &shminfo);

XSync(SDL_Display, False);

shmdt(shminfo.shmaddr);

}

#endif /* ! NO_SHARED_MEMORY */

SDL_Ximage = NULL;

}

if ( screen ) {

screen->pixels = NULL;

}

}

static int num_CPU(void)

{

static int num_cpus = 0;

if(!num_cpus) {

char line[BUFSIZ];

FILE *pstat = fopen("/proc/stat", "r");

if ( pstat ) {

while ( fgets(line, sizeof(line), pstat) ) {

++num_cpus;

}

}

fclose(pstat);

}

#elif defined(_SC_NPROCESSORS_ONLN)

/* number of processors online (SVR4.0MP compliant machines) */

num_cpus = sysconf(_SC_NPROCESSORS_ONLN);

#elif defined(_SC_NPROCESSORS_CONF)

/* number of processors configured (SVR4.0MP compliant machines) */

num_cpus = sysconf(_SC_NPROCESSORS_CONF);

#endif

if ( num_cpus <= 0 ) {

num_cpus = 1;

}

}

return num_cpus;

}

int X11_ResizeImage(_THIS, SDL_Surface *screen, Uint32 flags)

{

int retval;

X11_DestroyImage(this, screen);

if ( flags & SDL_OPENGL ) { /* No image when using GL */

retval = 0;

} else {

retval = X11_SetupImage(this, screen);

/* We support asynchronous blitting on the display */

if ( flags & SDL_ASYNCBLIT ) {

/* This is actually slower on single-CPU systems,

probably because of CPU contention between the

X server and the application.

Note: Is this still true with XFree86 4.0?

*/

if ( num_CPU() > 1 ) {

screen->flags |= SDL_ASYNCBLIT;

}

}

}

return(retval);

}

/* We don't actually allow hardware surfaces other than the main one */

int X11_AllocHWSurface(_THIS, SDL_Surface *surface)

{

return(-1);

}

void X11_FreeHWSurface(_THIS, SDL_Surface *surface)

{

return;

}

int X11_LockHWSurface(_THIS, SDL_Surface *surface)

{

if ( (surface == SDL_VideoSurface) && blit_queued ) {

blit_queued = 0;

}

return(0);

}

void X11_UnlockHWSurface(_THIS, SDL_Surface *surface)

{

return;

}

int X11_FlipHWSurface(_THIS, SDL_Surface *surface)

{

return(0);

}

static void X11_NormalUpdate(_THIS, int numrects, SDL_Rect *rects)

{

int i;

for (i = 0; i < numrects; ++i) {

if ( rects[i].w == 0 || rects[i].h == 0 ) { /* Clipped? */

continue;

rects[i].x, rects[i].y,

rects[i].x, rects[i].y, rects[i].w, rects[i].h);

}

if ( SDL_VideoSurface->flags & SDL_ASYNCBLIT ) {

}

}

static void X11_MITSHMUpdate(_THIS, int numrects, SDL_Rect *rects)

{

#ifndef NO_SHARED_MEMORY

int i;

for ( i=0; i<numrects; ++i ) {

continue;

}

rects[i].x, rects[i].y,

rects[i].x, rects[i].y, rects[i].w, rects[i].h,

False);

}

if ( SDL_VideoSurface->flags & SDL_ASYNCBLIT ) {

}

#endif /* ! NO_SHARED_MEMORY */

}

/* There's a problem with the automatic refreshing of the display.

Even though the XVideo code uses the GFX_Display to update the

video memory, it appears that updating the window asynchronously

from a different thread will cause "blackouts" of the window.

This is a sort of a hacked workaround for the problem.

*/

static int enable_autorefresh = 1;

void X11_DisableAutoRefresh(_THIS)

{

--enable_autorefresh;

}

void X11_EnableAutoRefresh(_THIS)

{

++enable_autorefresh;

}

void X11_RefreshDisplay(_THIS)

{

/* Don't refresh a display that doesn't have an image (like GL)

Instead, post an expose event so the application can refresh.

*/

return;

}

#ifndef NO_SHARED_MEMORY

if ( this->UpdateRects == X11_MITSHMUpdate ) {

0, 0, 0, 0, this->screen->w, this->screen->h,

False);