1 /**************************************************************************
2 *
3 * Copyright 2007 VMware, Inc., Bismarck, ND., USA
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
17 * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
18 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
19 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
20 * USE OR OTHER DEALINGS IN THE SOFTWARE.
21 *
22 * The above copyright notice and this permission notice (including the
23 * next paragraph) shall be included in all copies or substantial portions
24 * of the Software.
25 *
26 *
27 **************************************************************************/
28
29 /*
30 * Authors:
31 * Keith Whitwell
32 * Brian Paul
33 */
34
35 #include "pipe/p_format.h"
36 #include "pipe/p_context.h"
37 #include "util/u_inlines.h"
38 #include "util/u_format.h"
39 #include "util/u_math.h"
40 #include "util/u_memory.h"
41
42 #include "state_tracker/xlibsw_api.h"
43 #include "xlib_sw_winsys.h"
44
45 #include <X11/Xlib.h>
46 #include <X11/Xlibint.h>
47 #include <X11/Xutil.h>
48 #include <sys/ipc.h>
49 #include <sys/shm.h>
50 #include <X11/extensions/XShm.h>
51
52 DEBUG_GET_ONCE_BOOL_OPTION(xlib_no_shm, "XLIB_NO_SHM", FALSE)
53
54 /**
55 * Display target for Xlib winsys.
56 * Low-level OS/window system memory buffer
57 */
58 struct xlib_displaytarget
59 {
60 enum pipe_format format;
61 unsigned width;
62 unsigned height;
63 unsigned stride;
64
65 void *data;
66 void *mapped;
67
68 Display *display;
69 Visual *visual;
70 XImage *tempImage;
71 GC gc;
72
73 /* This is the last drawable that this display target was presented
74 * against. May need to recreate gc, tempImage when this changes??
75 */
76 Drawable drawable;
77
78 XShmSegmentInfo shminfo;
79 Bool shm; /** Using shared memory images? */
80 };
81
82
83 /**
84 * Subclass of sw_winsys for Xlib winsys
85 */
86 struct xlib_sw_winsys
87 {
88 struct sw_winsys base;
89 Display *display;
90 };
91
92
93
94 /** Cast wrapper */
95 static inline struct xlib_displaytarget *
xlib_displaytarget(struct sw_displaytarget * dt)96 xlib_displaytarget(struct sw_displaytarget *dt)
97 {
98 return (struct xlib_displaytarget *) dt;
99 }
100
101
102 /**
103 * X Shared Memory Image extension code
104 */
105
106 static volatile int XErrorFlag = 0;
107
108 /**
109 * Catches potential Xlib errors.
110 */
111 static int
handle_xerror(Display * dpy,XErrorEvent * event)112 handle_xerror(Display *dpy, XErrorEvent *event)
113 {
114 (void) dpy;
115 (void) event;
116 XErrorFlag = 1;
117 return 0;
118 }
119
120
121 static char *
alloc_shm(struct xlib_displaytarget * buf,unsigned size)122 alloc_shm(struct xlib_displaytarget *buf, unsigned size)
123 {
124 XShmSegmentInfo *const shminfo = & buf->shminfo;
125
126 shminfo->shmid = -1;
127 shminfo->shmaddr = (char *) -1;
128
129 shminfo->shmid = shmget(IPC_PRIVATE, size, IPC_CREAT|0777);
130 if (shminfo->shmid < 0) {
131 return NULL;
132 }
133
134 shminfo->shmaddr = (char *) shmat(shminfo->shmid, 0, 0);
135 if (shminfo->shmaddr == (char *) -1) {
136 shmctl(shminfo->shmid, IPC_RMID, 0);
137 return NULL;
138 }
139
140 shminfo->readOnly = False;
141 return shminfo->shmaddr;
142 }
143
144
145 /**
146 * Allocate a shared memory XImage back buffer for the given display target.
147 */
148 static void
alloc_shm_ximage(struct xlib_displaytarget * xlib_dt,struct xlib_drawable * xmb,unsigned width,unsigned height)149 alloc_shm_ximage(struct xlib_displaytarget *xlib_dt,
150 struct xlib_drawable *xmb,
151 unsigned width, unsigned height)
152 {
153 /*
154 * We have to do a _lot_ of error checking here to be sure we can
155 * really use the XSHM extension. It seems different servers trigger
156 * errors at different points if the extension won't work. Therefore
157 * we have to be very careful...
158 */
159 int (*old_handler)(Display *, XErrorEvent *);
160
161 xlib_dt->tempImage = XShmCreateImage(xlib_dt->display,
162 xmb->visual,
163 xmb->depth,
164 ZPixmap,
165 NULL,
166 &xlib_dt->shminfo,
167 width, height);
168 if (xlib_dt->tempImage == NULL) {
169 shmctl(xlib_dt->shminfo.shmid, IPC_RMID, 0);
170 xlib_dt->shm = False;
171 return;
172 }
173
174
175 XErrorFlag = 0;
176 old_handler = XSetErrorHandler(handle_xerror);
177 /* This may trigger the X protocol error we're ready to catch: */
178 XShmAttach(xlib_dt->display, &xlib_dt->shminfo);
179 XSync(xlib_dt->display, False);
180
181 /* Mark the segment to be destroyed, so that it is automatically destroyed
182 * when this process dies. Needs to be after XShmAttach() for *BSD.
183 */
184 shmctl(xlib_dt->shminfo.shmid, IPC_RMID, 0);
185
186 if (XErrorFlag) {
187 /* we are on a remote display, this error is normal, don't print it */
188 XFlush(xlib_dt->display);
189 XErrorFlag = 0;
190 XDestroyImage(xlib_dt->tempImage);
191 xlib_dt->tempImage = NULL;
192 xlib_dt->shm = False;
193 (void) XSetErrorHandler(old_handler);
194 return;
195 }
196
197 xlib_dt->shm = True;
198 }
199
200
201 static void
alloc_ximage(struct xlib_displaytarget * xlib_dt,struct xlib_drawable * xmb,unsigned width,unsigned height)202 alloc_ximage(struct xlib_displaytarget *xlib_dt,
203 struct xlib_drawable *xmb,
204 unsigned width, unsigned height)
205 {
206 /* try allocating a shared memory image first */
207 if (xlib_dt->shm) {
208 alloc_shm_ximage(xlib_dt, xmb, width, height);
209 if (xlib_dt->tempImage)
210 return; /* success */
211 }
212
213 /* try regular (non-shared memory) image */
214 xlib_dt->tempImage = XCreateImage(xlib_dt->display,
215 xmb->visual,
216 xmb->depth,
217 ZPixmap, 0,
218 NULL, width, height,
219 8, 0);
220 }
221
222 static boolean
xlib_is_displaytarget_format_supported(struct sw_winsys * ws,unsigned tex_usage,enum pipe_format format)223 xlib_is_displaytarget_format_supported(struct sw_winsys *ws,
224 unsigned tex_usage,
225 enum pipe_format format)
226 {
227 /* TODO: check visuals or other sensible thing here */
228 return TRUE;
229 }
230
231
232 static void *
xlib_displaytarget_map(struct sw_winsys * ws,struct sw_displaytarget * dt,unsigned flags)233 xlib_displaytarget_map(struct sw_winsys *ws,
234 struct sw_displaytarget *dt,
235 unsigned flags)
236 {
237 struct xlib_displaytarget *xlib_dt = xlib_displaytarget(dt);
238 xlib_dt->mapped = xlib_dt->data;
239 return xlib_dt->mapped;
240 }
241
242
243 static void
xlib_displaytarget_unmap(struct sw_winsys * ws,struct sw_displaytarget * dt)244 xlib_displaytarget_unmap(struct sw_winsys *ws,
245 struct sw_displaytarget *dt)
246 {
247 struct xlib_displaytarget *xlib_dt = xlib_displaytarget(dt);
248 xlib_dt->mapped = NULL;
249 }
250
251
252 static void
xlib_displaytarget_destroy(struct sw_winsys * ws,struct sw_displaytarget * dt)253 xlib_displaytarget_destroy(struct sw_winsys *ws,
254 struct sw_displaytarget *dt)
255 {
256 struct xlib_displaytarget *xlib_dt = xlib_displaytarget(dt);
257
258 if (xlib_dt->data) {
259 if (xlib_dt->shminfo.shmid >= 0) {
260 shmdt(xlib_dt->shminfo.shmaddr);
261 shmctl(xlib_dt->shminfo.shmid, IPC_RMID, 0);
262
263 xlib_dt->shminfo.shmid = -1;
264 xlib_dt->shminfo.shmaddr = (char *) -1;
265
266 xlib_dt->data = NULL;
267 if (xlib_dt->tempImage)
268 xlib_dt->tempImage->data = NULL;
269 }
270 else {
271 align_free(xlib_dt->data);
272 if (xlib_dt->tempImage && xlib_dt->tempImage->data == xlib_dt->data) {
273 xlib_dt->tempImage->data = NULL;
274 }
275 xlib_dt->data = NULL;
276 }
277 }
278
279 if (xlib_dt->tempImage) {
280 XDestroyImage(xlib_dt->tempImage);
281 xlib_dt->tempImage = NULL;
282 }
283
284 if (xlib_dt->gc)
285 XFreeGC(xlib_dt->display, xlib_dt->gc);
286
287 FREE(xlib_dt);
288 }
289
290
291 /**
292 * Display/copy the image in the surface into the X window specified
293 * by the display target.
294 */
295 static void
xlib_sw_display(struct xlib_drawable * xlib_drawable,struct sw_displaytarget * dt)296 xlib_sw_display(struct xlib_drawable *xlib_drawable,
297 struct sw_displaytarget *dt)
298 {
299 static boolean no_swap = 0;
300 static boolean firsttime = 1;
301 struct xlib_displaytarget *xlib_dt = xlib_displaytarget(dt);
302 Display *display = xlib_dt->display;
303 XImage *ximage;
304
305 if (firsttime) {
306 no_swap = getenv("SP_NO_RAST") != NULL;
307 firsttime = 0;
308 }
309
310 if (no_swap)
311 return;
312
313 if (xlib_dt->drawable != xlib_drawable->drawable) {
314 if (xlib_dt->gc) {
315 XFreeGC(display, xlib_dt->gc);
316 xlib_dt->gc = NULL;
317 }
318
319 if (xlib_dt->tempImage) {
320 XDestroyImage(xlib_dt->tempImage);
321 xlib_dt->tempImage = NULL;
322 }
323
324 xlib_dt->drawable = xlib_drawable->drawable;
325 }
326
327 if (xlib_dt->tempImage == NULL) {
328 assert(util_format_get_blockwidth(xlib_dt->format) == 1);
329 assert(util_format_get_blockheight(xlib_dt->format) == 1);
330 alloc_ximage(xlib_dt, xlib_drawable,
331 xlib_dt->stride / util_format_get_blocksize(xlib_dt->format),
332 xlib_dt->height);
333 if (!xlib_dt->tempImage)
334 return;
335 }
336
337 if (xlib_dt->gc == NULL) {
338 xlib_dt->gc = XCreateGC(display, xlib_drawable->drawable, 0, NULL);
339 XSetFunction(display, xlib_dt->gc, GXcopy);
340 }
341
342 if (xlib_dt->shm) {
343 ximage = xlib_dt->tempImage;
344 ximage->data = xlib_dt->data;
345
346 /* _debug_printf("XSHM\n"); */
347 XShmPutImage(xlib_dt->display, xlib_drawable->drawable, xlib_dt->gc,
348 ximage, 0, 0, 0, 0, xlib_dt->width, xlib_dt->height, False);
349 }
350 else {
351 /* display image in Window */
352 ximage = xlib_dt->tempImage;
353 ximage->data = xlib_dt->data;
354
355 /* check that the XImage has been previously initialized */
356 assert(ximage->format);
357 assert(ximage->bitmap_unit);
358
359 /* update XImage's fields */
360 ximage->width = xlib_dt->width;
361 ximage->height = xlib_dt->height;
362 ximage->bytes_per_line = xlib_dt->stride;
363
364 /* _debug_printf("XPUT\n"); */
365 XPutImage(xlib_dt->display, xlib_drawable->drawable, xlib_dt->gc,
366 ximage, 0, 0, 0, 0, xlib_dt->width, xlib_dt->height);
367 }
368
369 XFlush(xlib_dt->display);
370 }
371
372
373 /**
374 * Display/copy the image in the surface into the X window specified
375 * by the display target.
376 */
377 static void
xlib_displaytarget_display(struct sw_winsys * ws,struct sw_displaytarget * dt,void * context_private,struct pipe_box * box)378 xlib_displaytarget_display(struct sw_winsys *ws,
379 struct sw_displaytarget *dt,
380 void *context_private,
381 struct pipe_box *box)
382 {
383 struct xlib_drawable *xlib_drawable = (struct xlib_drawable *)context_private;
384 xlib_sw_display(xlib_drawable, dt);
385 }
386
387
388 static struct sw_displaytarget *
xlib_displaytarget_create(struct sw_winsys * winsys,unsigned tex_usage,enum pipe_format format,unsigned width,unsigned height,unsigned alignment,const void * front_private,unsigned * stride)389 xlib_displaytarget_create(struct sw_winsys *winsys,
390 unsigned tex_usage,
391 enum pipe_format format,
392 unsigned width, unsigned height,
393 unsigned alignment,
394 const void *front_private,
395 unsigned *stride)
396 {
397 struct xlib_displaytarget *xlib_dt;
398 unsigned nblocksy, size;
399
400 xlib_dt = CALLOC_STRUCT(xlib_displaytarget);
401 if (!xlib_dt)
402 goto no_xlib_dt;
403
404 xlib_dt->display = ((struct xlib_sw_winsys *)winsys)->display;
405 xlib_dt->format = format;
406 xlib_dt->width = width;
407 xlib_dt->height = height;
408
409 nblocksy = util_format_get_nblocksy(format, height);
410 xlib_dt->stride = align(util_format_get_stride(format, width), alignment);
411 size = xlib_dt->stride * nblocksy;
412
413 if (!debug_get_option_xlib_no_shm()) {
414 xlib_dt->data = alloc_shm(xlib_dt, size);
415 if (xlib_dt->data) {
416 xlib_dt->shm = True;
417 }
418 }
419
420 if (!xlib_dt->data) {
421 xlib_dt->data = align_malloc(size, alignment);
422 if (!xlib_dt->data)
423 goto no_data;
424 }
425
426 *stride = xlib_dt->stride;
427 return (struct sw_displaytarget *)xlib_dt;
428
429 no_data:
430 FREE(xlib_dt);
431 no_xlib_dt:
432 return NULL;
433 }
434
435
436 static struct sw_displaytarget *
xlib_displaytarget_from_handle(struct sw_winsys * winsys,const struct pipe_resource * templet,struct winsys_handle * whandle,unsigned * stride)437 xlib_displaytarget_from_handle(struct sw_winsys *winsys,
438 const struct pipe_resource *templet,
439 struct winsys_handle *whandle,
440 unsigned *stride)
441 {
442 assert(0);
443 return NULL;
444 }
445
446
447 static boolean
xlib_displaytarget_get_handle(struct sw_winsys * winsys,struct sw_displaytarget * dt,struct winsys_handle * whandle)448 xlib_displaytarget_get_handle(struct sw_winsys *winsys,
449 struct sw_displaytarget *dt,
450 struct winsys_handle *whandle)
451 {
452 assert(0);
453 return FALSE;
454 }
455
456
457 static void
xlib_destroy(struct sw_winsys * ws)458 xlib_destroy(struct sw_winsys *ws)
459 {
460 FREE(ws);
461 }
462
463
464 struct sw_winsys *
xlib_create_sw_winsys(Display * display)465 xlib_create_sw_winsys(Display *display)
466 {
467 struct xlib_sw_winsys *ws;
468
469 ws = CALLOC_STRUCT(xlib_sw_winsys);
470 if (!ws)
471 return NULL;
472
473 ws->display = display;
474 ws->base.destroy = xlib_destroy;
475
476 ws->base.is_displaytarget_format_supported = xlib_is_displaytarget_format_supported;
477
478 ws->base.displaytarget_create = xlib_displaytarget_create;
479 ws->base.displaytarget_from_handle = xlib_displaytarget_from_handle;
480 ws->base.displaytarget_get_handle = xlib_displaytarget_get_handle;
481 ws->base.displaytarget_map = xlib_displaytarget_map;
482 ws->base.displaytarget_unmap = xlib_displaytarget_unmap;
483 ws->base.displaytarget_destroy = xlib_displaytarget_destroy;
484
485 ws->base.displaytarget_display = xlib_displaytarget_display;
486
487 return &ws->base;
488 }
489