[sdl_omap.git] / src / video / x11 / SDL_x11image.c

/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2009 Sam Lantinga

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    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
    Lesser General Public License for more details.

    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
    slouken@libsdl.org
*/
#include "SDL_config.h"

#include <stdio.h>
#include <unistd.h>

#include "SDL_endian.h"
#include "../../events/SDL_events_c.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 ) {
        	shm_error = True;
        	return(0);
        } else
		return(X_handler(d,e));
}

static void try_mitshm(_THIS, SDL_Surface *screen)
{
	/* 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);
			if ( shm_error )
				shmdt(shminfo.shmaddr);
		} else {
			shm_error = True;
		}
		shmctl(shminfo.shmid, IPC_RMID, NULL);
	} 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) {
		SDL_Ximage = XShmCreateImage(SDL_Display, SDL_Visual,
					     this->hidden->depth, ZPixmap,
					     shminfo.shmaddr, &shminfo, 
					     screen->w, screen->h);
		if(!SDL_Ximage) {
			XShmDetach(SDL_Display, &shminfo);
			XSync(SDL_Display, False);
			shmdt(shminfo.shmaddr);
			screen->pixels = NULL;
			goto error;
		}
		this->UpdateRects = X11_MITSHMUpdate;
	}
	if(!use_mitshm)
#endif /* not NO_SHARED_MEMORY */
	{
		int bpp;
		screen->pixels = SDL_malloc(screen->h*screen->pitch);
		if ( screen->pixels == NULL ) {
			SDL_OutOfMemory();
			return -1;
		}
 	        bpp = screen->format->BytesPerPixel;
		SDL_Ximage = XCreateImage(SDL_Display, SDL_Visual,
					  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;
	}
	screen->pitch = SDL_Ximage->bytes_per_line;
	return(0);

error:
	SDL_SetError("Couldn't create XImage");
	return 1;
}

void X11_DestroyImage(_THIS, SDL_Surface *screen)
{
	if ( SDL_Ximage ) {
		XDestroyImage(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;
	}
}

/* Determine the number of CPUs in the system */
static int num_CPU(void)
{
       static int num_cpus = 0;

       if(!num_cpus) {
#if defined(__LINUX__)
           char line[BUFSIZ];
           FILE *pstat = fopen("/proc/stat", "r");
           if ( pstat ) {
               while ( fgets(line, sizeof(line), pstat) ) {
                   if (SDL_memcmp(line, "cpu", 3) == 0 && line[3] != ' ') {
                       ++num_cpus;
                   }
               }
               fclose(pstat);
           }
#elif defined(__IRIX__)
	   num_cpus = sysconf(_SC_NPROC_ONLN);
#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 ) {
		XSync(GFX_Display, False);
		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;
		}
		XPutImage(GFX_Display, SDL_Window, SDL_GC, SDL_Ximage,
			  rects[i].x, rects[i].y,
			  rects[i].x, rects[i].y, rects[i].w, rects[i].h);
	}
	if ( SDL_VideoSurface->flags & SDL_ASYNCBLIT ) {
		XFlush(GFX_Display);
		blit_queued = 1;
	} else {
		XSync(GFX_Display, False);
	}
}

static void X11_MITSHMUpdate(_THIS, int numrects, SDL_Rect *rects)
{
#ifndef NO_SHARED_MEMORY
	int i;

	for ( i=0; i<numrects; ++i ) {
		if ( rects[i].w == 0 || rects[i].h == 0 ) { /* Clipped? */
			continue;
		}
		XShmPutImage(GFX_Display, SDL_Window, SDL_GC, SDL_Ximage,
				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 ) {
		XFlush(GFX_Display);
		blit_queued = 1;
	} else {
		XSync(GFX_Display, False);
	}
#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.
	 */
	if ( ! SDL_Ximage || (enable_autorefresh <= 0) ) {
		SDL_PrivateExpose();
		return;
	}
#ifndef NO_SHARED_MEMORY
	if ( this->UpdateRects == X11_MITSHMUpdate ) {
		XShmPutImage(SDL_Display, SDL_Window, SDL_GC, SDL_Ximage,
				0, 0, 0, 0, this->screen->w, this->screen->h,
				False);
	} else
#endif /* ! NO_SHARED_MEMORY */
	{
		XPutImage(SDL_Display, SDL_Window, SDL_GC, SDL_Ximage,
			  0, 0, 0, 0, this->screen->w, this->screen->h);
	}
	XSync(SDL_Display, False);
}
Commit	Line	Data
e14743d1	1	/*
	2	SDL - Simple DirectMedia Layer
	3	Copyright (C) 1997-2009 Sam Lantinga
	4
	5	This library is free software; you can redistribute it and/or
	6	modify it under the terms of the GNU Lesser General Public
	7	License as published by the Free Software Foundation; either
	8	version 2.1 of the License, or (at your option) any later version.
	9
	10	This library is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	Lesser General Public License for more details.
	14
	15	You should have received a copy of the GNU Lesser General Public
	16	License along with this library; if not, write to the Free Software
	17	Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	18
	19	Sam Lantinga
	20	slouken@libsdl.org
	21	*/
	22	#include "SDL_config.h"
	23
	24	#include <stdio.h>
	25	#include <unistd.h>
	26
	27	#include "SDL_endian.h"
	28	#include "../../events/SDL_events_c.h"
	29	#include "SDL_x11image_c.h"
	30
	31	#ifndef NO_SHARED_MEMORY
	32
	33	/* Shared memory error handler routine */
	34	static int shm_error;
	35	static int (X_handler)(Display , XErrorEvent *) = NULL;
	36	static int shm_errhandler(Display d, XErrorEvent e)
	37	{
	38	if ( e->error_code == BadAccess ) {
	39	shm_error = True;
	40	return(0);
	41	} else
	42	return(X_handler(d,e));
	43	}
	44
	45	static void try_mitshm(_THIS, SDL_Surface *screen)
	46	{
	47	/* Dynamic X11 may not have SHM entry points on this box. */
	48	if ((use_mitshm) && (!SDL_X11_HAVE_SHM))
	49	use_mitshm = 0;
	50
	51	if(!use_mitshm)
	52	return;
	53	shminfo.shmid = shmget(IPC_PRIVATE, screen->h*screen->pitch,
	54	IPC_CREAT \| 0777);
	55	if ( shminfo.shmid >= 0 ) {
	56	shminfo.shmaddr = (char *)shmat(shminfo.shmid, 0, 0);
	57	shminfo.readOnly = False;
	58	if ( shminfo.shmaddr != (char *)-1 ) {
	59	shm_error = False;
	60	X_handler = XSetErrorHandler(shm_errhandler);
	61	XShmAttach(SDL_Display, &shminfo);
	62	XSync(SDL_Display, True);
	63	XSetErrorHandler(X_handler);
	64	if ( shm_error )
65	shmdt(shminfo.shmaddr);
66	} else {
67	shm_error = True;
68	}
69	shmctl(shminfo.shmid, IPC_RMID, NULL);
70	} else {
71	shm_error = True;
72	}
73	if ( shm_error )
74	use_mitshm = 0;
75	if ( use_mitshm )
76	screen->pixels = shminfo.shmaddr;
77	}
78	#endif /* ! NO_SHARED_MEMORY */
79
80	/* Various screen update functions available */
81	static void X11_NormalUpdate(_THIS, int numrects, SDL_Rect *rects);
82	static void X11_MITSHMUpdate(_THIS, int numrects, SDL_Rect *rects);
83
84	int X11_SetupImage(_THIS, SDL_Surface *screen)
85	{
86	#ifndef NO_SHARED_MEMORY
87	try_mitshm(this, screen);
88	if(use_mitshm) {
89	SDL_Ximage = XShmCreateImage(SDL_Display, SDL_Visual,
90	this->hidden->depth, ZPixmap,
91	shminfo.shmaddr, &shminfo,
92	screen->w, screen->h);
93	if(!SDL_Ximage) {
94	XShmDetach(SDL_Display, &shminfo);
95	XSync(SDL_Display, False);
96	shmdt(shminfo.shmaddr);
97	screen->pixels = NULL;
98	goto error;
99	}
100	this->UpdateRects = X11_MITSHMUpdate;
101	}
102	if(!use_mitshm)
103	#endif /* not NO_SHARED_MEMORY */
104	{
105	int bpp;
106	screen->pixels = SDL_malloc(screen->h*screen->pitch);
107	if ( screen->pixels == NULL ) {
108	SDL_OutOfMemory();
109	return -1;
110	}
111	bpp = screen->format->BytesPerPixel;
112	SDL_Ximage = XCreateImage(SDL_Display, SDL_Visual,
113	this->hidden->depth, ZPixmap, 0,
114	(char *)screen->pixels,
115	screen->w, screen->h,
116	32, 0);
117	if ( SDL_Ximage == NULL )
118	goto error;
119	/* XPutImage will convert byte sex automatically */
120	SDL_Ximage->byte_order = (SDL_BYTEORDER == SDL_BIG_ENDIAN)
121	? MSBFirst : LSBFirst;
122	this->UpdateRects = X11_NormalUpdate;
123	}
124	screen->pitch = SDL_Ximage->bytes_per_line;
125	return(0);
126
127	error:
128	SDL_SetError("Couldn't create XImage");
129	return 1;
130	}
131
132	void X11_DestroyImage(_THIS, SDL_Surface *screen)
133	{
134	if ( SDL_Ximage ) {
135	XDestroyImage(SDL_Ximage);
136	#ifndef NO_SHARED_MEMORY
137	if ( use_mitshm ) {
138	XShmDetach(SDL_Display, &shminfo);
139	XSync(SDL_Display, False);
140	shmdt(shminfo.shmaddr);
141	}
142	#endif /* ! NO_SHARED_MEMORY */
143	SDL_Ximage = NULL;
144	}
145	if ( screen ) {
146	screen->pixels = NULL;
147	}
148	}
149
150	/* Determine the number of CPUs in the system */
151	static int num_CPU(void)
152	{
153	static int num_cpus = 0;
154
155	if(!num_cpus) {
156	#if defined(__LINUX__)
157	char line[BUFSIZ];
158	FILE *pstat = fopen("/proc/stat", "r");
159	if ( pstat ) {
160	while ( fgets(line, sizeof(line), pstat) ) {
161	if (SDL_memcmp(line, "cpu", 3) == 0 && line[3] != ' ') {
162	++num_cpus;
163	}
164	}
165	fclose(pstat);
166	}
167	#elif defined(__IRIX__)
168	num_cpus = sysconf(_SC_NPROC_ONLN);
169	#elif defined(_SC_NPROCESSORS_ONLN)
170	/* number of processors online (SVR4.0MP compliant machines) */
171	num_cpus = sysconf(_SC_NPROCESSORS_ONLN);
172	#elif defined(_SC_NPROCESSORS_CONF)
173	/* number of processors configured (SVR4.0MP compliant machines) */
174	num_cpus = sysconf(_SC_NPROCESSORS_CONF);
175	#endif
176	if ( num_cpus <= 0 ) {
177	num_cpus = 1;
178	}
179	}
180	return num_cpus;
181	}
182
183	int X11_ResizeImage(_THIS, SDL_Surface *screen, Uint32 flags)
184	{
185	int retval;
186
187	X11_DestroyImage(this, screen);
188	if ( flags & SDL_OPENGL ) { /* No image when using GL */
189	retval = 0;
190	} else {
191	retval = X11_SetupImage(this, screen);
192	/* We support asynchronous blitting on the display */
193	if ( flags & SDL_ASYNCBLIT ) {
194	/* This is actually slower on single-CPU systems,
195	probably because of CPU contention between the
196	X server and the application.
197	Note: Is this still true with XFree86 4.0?
198	*/
199	if ( num_CPU() > 1 ) {
200	screen->flags \|= SDL_ASYNCBLIT;
201	}
202	}
203	}
204	return(retval);
205	}
206
207	/* We don't actually allow hardware surfaces other than the main one */
208	int X11_AllocHWSurface(_THIS, SDL_Surface *surface)
209	{
210	return(-1);
211	}
212	void X11_FreeHWSurface(_THIS, SDL_Surface *surface)
213	{
214	return;
215	}
216
217	int X11_LockHWSurface(_THIS, SDL_Surface *surface)
218	{
219	if ( (surface == SDL_VideoSurface) && blit_queued ) {
220	XSync(GFX_Display, False);
221	blit_queued = 0;
222	}
223	return(0);
224	}
225	void X11_UnlockHWSurface(_THIS, SDL_Surface *surface)
226	{
227	return;
228	}
229
230	int X11_FlipHWSurface(_THIS, SDL_Surface *surface)
231	{
232	return(0);
233	}
234
235	static void X11_NormalUpdate(_THIS, int numrects, SDL_Rect *rects)
236	{
237	int i;
238
239	for (i = 0; i < numrects; ++i) {
240	if ( rects[i].w == 0 \|\| rects[i].h == 0 ) { /* Clipped? */
241	continue;
242	}
243	XPutImage(GFX_Display, SDL_Window, SDL_GC, SDL_Ximage,
244	rects[i].x, rects[i].y,
245	rects[i].x, rects[i].y, rects[i].w, rects[i].h);
246	}
247	if ( SDL_VideoSurface->flags & SDL_ASYNCBLIT ) {
248	XFlush(GFX_Display);
249	blit_queued = 1;
250	} else {
251	XSync(GFX_Display, False);
252	}
253	}
254
255	static void X11_MITSHMUpdate(_THIS, int numrects, SDL_Rect *rects)
256	{
257	#ifndef NO_SHARED_MEMORY
258	int i;
259
260	for ( i=0; i<numrects; ++i ) {
261	if ( rects[i].w == 0 \|\| rects[i].h == 0 ) { /* Clipped? */
262	continue;
263	}
264	XShmPutImage(GFX_Display, SDL_Window, SDL_GC, SDL_Ximage,
265	rects[i].x, rects[i].y,
266	rects[i].x, rects[i].y, rects[i].w, rects[i].h,
267	False);
268	}
269	if ( SDL_VideoSurface->flags & SDL_ASYNCBLIT ) {
270	XFlush(GFX_Display);
271	blit_queued = 1;
272	} else {
273	XSync(GFX_Display, False);
274	}
275	#endif /* ! NO_SHARED_MEMORY */
276	}
277
278	/* There's a problem with the automatic refreshing of the display.
279	Even though the XVideo code uses the GFX_Display to update the
280	video memory, it appears that updating the window asynchronously
281	from a different thread will cause "blackouts" of the window.
282	This is a sort of a hacked workaround for the problem.
283	*/
284	static int enable_autorefresh = 1;
285
286	void X11_DisableAutoRefresh(_THIS)
287	{
288	--enable_autorefresh;
289	}
290
291	void X11_EnableAutoRefresh(_THIS)
292	{
293	++enable_autorefresh;
294	}
295
296	void X11_RefreshDisplay(_THIS)
297	{
298	/* Don't refresh a display that doesn't have an image (like GL)
299	Instead, post an expose event so the application can refresh.
300	*/
301	if ( ! SDL_Ximage \|\| (enable_autorefresh <= 0) ) {
302	SDL_PrivateExpose();
303	return;
304	}
305	#ifndef NO_SHARED_MEMORY
306	if ( this->UpdateRects == X11_MITSHMUpdate ) {
307	XShmPutImage(SDL_Display, SDL_Window, SDL_GC, SDL_Ximage,
308	0, 0, 0, 0, this->screen->w, this->screen->h,
309	False);
310	} else
311	#endif /* ! NO_SHARED_MEMORY */
312	{
313	XPutImage(SDL_Display, SDL_Window, SDL_GC, SDL_Ximage,
314	0, 0, 0, 0, this->screen->w, this->screen->h);
315	}
316	XSync(SDL_Display, False);
317	}
318