xm_buffer.c revision 3464ebd5 
1/*
2 * Mesa 3-D graphics library
3 * Version:  6.5.2
4 *
5 * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 */
24
25
26/**
27 * \file xm_buffer.h
28 * Framebuffer and renderbuffer-related functions.
29 */
30
31
32#include "glxheader.h"
33#include "xmesaP.h"
34#include "main/imports.h"
35#include "main/formats.h"
36#include "main/framebuffer.h"
37#include "main/renderbuffer.h"
38
39
40#if defined(USE_XSHM)
41static volatile int mesaXErrorFlag = 0;
42
43/**
44 * Catches potential Xlib errors.
45 */
46static int
47mesaHandleXError(XMesaDisplay *dpy, XErrorEvent *event)
48{
49   (void) dpy;
50   (void) event;
51   mesaXErrorFlag = 1;
52   return 0;
53}
54
55/**
56 * Allocate a shared memory XImage back buffer for the given XMesaBuffer.
57 * Return:  GL_TRUE if success, GL_FALSE if error
58 */
59static GLboolean
60alloc_back_shm_ximage(XMesaBuffer b, GLuint width, GLuint height)
61{
62   /*
63    * We have to do a _lot_ of error checking here to be sure we can
64    * really use the XSHM extension.  It seems different servers trigger
65    * errors at different points if the extension won't work.  Therefore
66    * we have to be very careful...
67    */
68   GC gc;
69   int (*old_handler)(XMesaDisplay *, XErrorEvent *);
70
71   if (width == 0 || height == 0) {
72      /* this will be true the first time we're called on 'b' */
73      return GL_FALSE;
74   }
75
76   b->backxrb->ximage = XShmCreateImage(b->xm_visual->display,
77                                        b->xm_visual->visinfo->visual,
78                                        b->xm_visual->visinfo->depth,
79                                        ZPixmap, NULL, &b->shminfo,
80                                        width, height);
81   if (b->backxrb->ximage == NULL) {
82      _mesa_warning(NULL, "alloc_back_buffer: Shared memory error (XShmCreateImage), disabling.\n");
83      b->shm = 0;
84      return GL_FALSE;
85   }
86
87   b->shminfo.shmid = shmget(IPC_PRIVATE, b->backxrb->ximage->bytes_per_line
88			     * b->backxrb->ximage->height, IPC_CREAT|0777);
89   if (b->shminfo.shmid < 0) {
90      _mesa_warning(NULL, "shmget failed while allocating back buffer.\n");
91      XDestroyImage(b->backxrb->ximage);
92      b->backxrb->ximage = NULL;
93      _mesa_warning(NULL, "alloc_back_buffer: Shared memory error (shmget), disabling.\n");
94      b->shm = 0;
95      return GL_FALSE;
96   }
97
98   b->shminfo.shmaddr = b->backxrb->ximage->data
99                      = (char*)shmat(b->shminfo.shmid, 0, 0);
100   if (b->shminfo.shmaddr == (char *) -1) {
101      _mesa_warning(NULL, "shmat() failed while allocating back buffer.\n");
102      XDestroyImage(b->backxrb->ximage);
103      shmctl(b->shminfo.shmid, IPC_RMID, 0);
104      b->backxrb->ximage = NULL;
105      _mesa_warning(NULL, "alloc_back_buffer: Shared memory error (shmat), disabling.\n");
106      b->shm = 0;
107      return GL_FALSE;
108   }
109
110   b->shminfo.readOnly = False;
111   mesaXErrorFlag = 0;
112   old_handler = XSetErrorHandler(mesaHandleXError);
113   /* This may trigger the X protocol error we're ready to catch: */
114   XShmAttach(b->xm_visual->display, &b->shminfo);
115   XSync(b->xm_visual->display, False);
116
117   if (mesaXErrorFlag) {
118      /* we are on a remote display, this error is normal, don't print it */
119      XFlush(b->xm_visual->display);
120      mesaXErrorFlag = 0;
121      XDestroyImage(b->backxrb->ximage);
122      shmdt(b->shminfo.shmaddr);
123      shmctl(b->shminfo.shmid, IPC_RMID, 0);
124      b->backxrb->ximage = NULL;
125      b->shm = 0;
126      (void) XSetErrorHandler(old_handler);
127      return GL_FALSE;
128   }
129
130   shmctl(b->shminfo.shmid, IPC_RMID, 0); /* nobody else needs it */
131
132   /* Finally, try an XShmPutImage to be really sure the extension works */
133   gc = XCreateGC(b->xm_visual->display, b->frontxrb->drawable, 0, NULL);
134   XShmPutImage(b->xm_visual->display, b->frontxrb->drawable, gc,
135		 b->backxrb->ximage, 0, 0, 0, 0, 1, 1 /*one pixel*/, False);
136   XSync(b->xm_visual->display, False);
137   XFreeGC(b->xm_visual->display, gc);
138   (void) XSetErrorHandler(old_handler);
139   if (mesaXErrorFlag) {
140      XFlush(b->xm_visual->display);
141      mesaXErrorFlag = 0;
142      XDestroyImage(b->backxrb->ximage);
143      shmdt(b->shminfo.shmaddr);
144      shmctl(b->shminfo.shmid, IPC_RMID, 0);
145      b->backxrb->ximage = NULL;
146      b->shm = 0;
147      return GL_FALSE;
148   }
149
150   return GL_TRUE;
151}
152#else
153static GLboolean
154alloc_back_shm_ximage(XMesaBuffer b, GLuint width, GLuint height)
155{
156   /* Can't compile XSHM support */
157   return GL_FALSE;
158}
159#endif
160
161
162
163/**
164 * Setup an off-screen pixmap or Ximage to use as the back buffer.
165 * Input:  b - the X/Mesa buffer
166 */
167static void
168alloc_back_buffer(XMesaBuffer b, GLuint width, GLuint height)
169{
170   if (b->db_mode == BACK_XIMAGE) {
171      /* Deallocate the old backxrb->ximage, if any */
172      if (b->backxrb->ximage) {
173#if defined(USE_XSHM)
174	 if (b->shm) {
175	    XShmDetach(b->xm_visual->display, &b->shminfo);
176	    XDestroyImage(b->backxrb->ximage);
177	    shmdt(b->shminfo.shmaddr);
178	 }
179	 else
180#endif
181	   XMesaDestroyImage(b->backxrb->ximage);
182	 b->backxrb->ximage = NULL;
183      }
184
185      if (width == 0 || height == 0)
186         return;
187
188      /* Allocate new back buffer */
189      if (b->shm == 0 || !alloc_back_shm_ximage(b, width, height)) {
190	 /* Allocate a regular XImage for the back buffer. */
191	 b->backxrb->ximage = XCreateImage(b->xm_visual->display,
192                                      b->xm_visual->visinfo->visual,
193                                      GET_VISUAL_DEPTH(b->xm_visual),
194				      ZPixmap, 0,   /* format, offset */
195				      NULL,
196                                      width, height,
197				      8, 0);  /* pad, bytes_per_line */
198	 if (!b->backxrb->ximage) {
199	    _mesa_warning(NULL, "alloc_back_buffer: XCreateImage failed.\n");
200            return;
201	 }
202         b->backxrb->ximage->data = (char *) MALLOC(b->backxrb->ximage->height
203                                        * b->backxrb->ximage->bytes_per_line);
204         if (!b->backxrb->ximage->data) {
205            _mesa_warning(NULL, "alloc_back_buffer: MALLOC failed.\n");
206            XMesaDestroyImage(b->backxrb->ximage);
207            b->backxrb->ximage = NULL;
208         }
209      }
210      b->backxrb->pixmap = None;
211   }
212   else if (b->db_mode == BACK_PIXMAP) {
213      /* Free the old back pixmap */
214      if (b->backxrb->pixmap) {
215         XMesaFreePixmap(b->xm_visual->display, b->backxrb->pixmap);
216         b->backxrb->pixmap = 0;
217      }
218
219      if (width > 0 && height > 0) {
220         /* Allocate new back pixmap */
221         b->backxrb->pixmap = XMesaCreatePixmap(b->xm_visual->display,
222                                                b->frontxrb->drawable,
223                                                width, height,
224                                                GET_VISUAL_DEPTH(b->xm_visual));
225      }
226
227      b->backxrb->ximage = NULL;
228      b->backxrb->drawable = b->backxrb->pixmap;
229   }
230}
231
232
233static void
234xmesa_delete_renderbuffer(struct gl_renderbuffer *rb)
235{
236   /* XXX Note: the ximage or Pixmap attached to this renderbuffer
237    * should probably get freed here, but that's currently done in
238    * XMesaDestroyBuffer().
239    */
240   free(rb);
241}
242
243
244/**
245 * Reallocate renderbuffer storage for front color buffer.
246 * Called via gl_renderbuffer::AllocStorage()
247 */
248static GLboolean
249xmesa_alloc_front_storage(struct gl_context *ctx, struct gl_renderbuffer *rb,
250                          GLenum internalFormat, GLuint width, GLuint height)
251{
252   struct xmesa_renderbuffer *xrb = xmesa_renderbuffer(rb);
253
254   /* just clear these to be sure we don't accidentally use them */
255   xrb->origin1 = NULL;
256   xrb->origin2 = NULL;
257   xrb->origin3 = NULL;
258   xrb->origin4 = NULL;
259
260   /* for the FLIP macro: */
261   xrb->bottom = height - 1;
262
263   rb->Width = width;
264   rb->Height = height;
265   rb->InternalFormat = internalFormat;
266
267   return GL_TRUE;
268}
269
270
271/**
272 * Reallocate renderbuffer storage for back color buffer.
273 * Called via gl_renderbuffer::AllocStorage()
274 */
275static GLboolean
276xmesa_alloc_back_storage(struct gl_context *ctx, struct gl_renderbuffer *rb,
277                         GLenum internalFormat, GLuint width, GLuint height)
278{
279   struct xmesa_renderbuffer *xrb = xmesa_renderbuffer(rb);
280
281   /* reallocate the back buffer XImage or Pixmap */
282   assert(xrb->Parent);
283   alloc_back_buffer(xrb->Parent, width, height);
284
285   /* same as front buffer */
286   /* XXX why is this here? */
287   (void) xmesa_alloc_front_storage(ctx, rb, internalFormat, width, height);
288
289   /* plus... */
290   if (xrb->ximage) {
291      /* Needed by PIXELADDR1 macro */
292      xrb->width1 = xrb->ximage->bytes_per_line;
293      xrb->origin1 = (GLubyte *) xrb->ximage->data + xrb->width1 * (height - 1);
294
295      /* Needed by PIXELADDR2 macro */
296      xrb->width2 = xrb->ximage->bytes_per_line / 2;
297      xrb->origin2 = (GLushort *) xrb->ximage->data + xrb->width2 * (height - 1);
298
299      /* Needed by PIXELADDR3 macro */
300      xrb->width3 = xrb->ximage->bytes_per_line;
301      xrb->origin3 = (GLubyte *) xrb->ximage->data + xrb->width3 * (height - 1);
302
303      /* Needed by PIXELADDR4 macro */
304      xrb->width4 = xrb->ximage->width;
305      xrb->origin4 = (GLuint *) xrb->ximage->data + xrb->width4 * (height - 1);
306   }
307   else {
308      /* out of memory or buffer size is 0 x 0 */
309      xrb->width1 = xrb->width2 = xrb->width3 = xrb->width4 = 0;
310      xrb->origin1 = NULL;
311      xrb->origin2 = NULL;
312      xrb->origin3 = NULL;
313      xrb->origin4 = NULL;
314   }
315
316   return GL_TRUE;
317}
318
319
320struct xmesa_renderbuffer *
321xmesa_new_renderbuffer(struct gl_context *ctx, GLuint name, const struct gl_config *visual,
322                       GLboolean backBuffer)
323{
324   struct xmesa_renderbuffer *xrb = CALLOC_STRUCT(xmesa_renderbuffer);
325   if (xrb) {
326      GLuint name = 0;
327      _mesa_init_renderbuffer(&xrb->Base, name);
328
329      xrb->Base.Delete = xmesa_delete_renderbuffer;
330      if (backBuffer)
331         xrb->Base.AllocStorage = xmesa_alloc_back_storage;
332      else
333         xrb->Base.AllocStorage = xmesa_alloc_front_storage;
334
335      xrb->Base.InternalFormat = GL_RGBA;
336      xrb->Base.Format = MESA_FORMAT_RGBA8888;
337      xrb->Base._BaseFormat = GL_RGBA;
338      xrb->Base.DataType = GL_UNSIGNED_BYTE;
339      /* only need to set Red/Green/EtcBits fields for user-created RBs */
340   }
341   return xrb;
342}
343
344
345/**
346 * Called via gl_framebuffer::Delete() method when this buffer
347 * is _really_ being deleted.
348 */
349void
350xmesa_delete_framebuffer(struct gl_framebuffer *fb)
351{
352   XMesaBuffer b = XMESA_BUFFER(fb);
353
354   if (b->num_alloced > 0) {
355      /* If no other buffer uses this X colormap then free the colors. */
356      if (!xmesa_find_buffer(b->display, b->cmap, b)) {
357         XFreeColors(b->display, b->cmap,
358                     b->alloced_colors, b->num_alloced, 0);
359      }
360   }
361
362   if (b->gc)
363      XMesaFreeGC(b->display, b->gc);
364   if (b->cleargc)
365      XMesaFreeGC(b->display, b->cleargc);
366   if (b->swapgc)
367      XMesaFreeGC(b->display, b->swapgc);
368
369   if (fb->Visual.doubleBufferMode) {
370      /* free back ximage/pixmap/shmregion */
371      if (b->backxrb->ximage) {
372#if defined(USE_XSHM)
373         if (b->shm) {
374            XShmDetach( b->display, &b->shminfo );
375            XDestroyImage( b->backxrb->ximage );
376            shmdt( b->shminfo.shmaddr );
377         }
378         else
379#endif
380            XMesaDestroyImage( b->backxrb->ximage );
381         b->backxrb->ximage = NULL;
382      }
383      if (b->backxrb->pixmap) {
384         XMesaFreePixmap( b->display, b->backxrb->pixmap );
385         if (b->xm_visual->hpcr_clear_flag) {
386            XMesaFreePixmap( b->display,
387                             b->xm_visual->hpcr_clear_pixmap );
388            XMesaDestroyImage( b->xm_visual->hpcr_clear_ximage );
389         }
390      }
391   }
392
393   if (b->rowimage) {
394      free( b->rowimage->data );
395      b->rowimage->data = NULL;
396      XMesaDestroyImage( b->rowimage );
397   }
398
399   _mesa_free_framebuffer_data(fb);
400   free(fb);
401}
402