src/mesa/drivers/x11/xm_buffer.c

   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)
  41 static volatile int mesaXErrorFlag = 0;
  42
  43 /**
  44  * Catches potential Xlib errors.
  45  */
  46 static int
  47 mesaHandleXError(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  */
  59 static GLboolean
  60 alloc_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
 153 static GLboolean
 154 alloc_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  */
 167 static void
 168 alloc_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
 233 static void
 234 xmesa_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  */
 248 static GLboolean
 249 xmesa_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  */
 275 static GLboolean
 276 xmesa_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
 320 struct xmesa_renderbuffer *
 321 xmesa_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  */
 349 void
 350 xmesa_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 }