| /* | |
| * Mesa 3-D graphics library | |
| * | |
| * Copyright (C) 1999-2006 Brian Paul All Rights Reserved. | |
| * | |
| * Permission is hereby granted, free of charge, to any person obtaining a | |
| * copy of this software and associated documentation files (the "Software"), | |
| * to deal in the Software without restriction, including without limitation | |
| * the rights to use, copy, modify, merge, publish, distribute, sublicense, | |
| * and/or sell copies of the Software, and to permit persons to whom the | |
| * Software is furnished to do so, subject to the following conditions: | |
| * | |
| * The above copyright notice and this permission notice shall be included | |
| * in all copies or substantial portions of the Software. | |
| * | |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | |
| * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
| * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR | |
| * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, | |
| * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR | |
| * OTHER DEALINGS IN THE SOFTWARE. | |
| */ | |
| /** | |
| * \file xm_buffer.h | |
| * Framebuffer and renderbuffer-related functions. | |
| */ | |
| #include "glxheader.h" | |
| #include "xmesaP.h" | |
| #include "main/errors.h" | |
| #include "main/imports.h" | |
| #include "main/formats.h" | |
| #include "main/framebuffer.h" | |
| #include "main/renderbuffer.h" | |
| #include "swrast/s_renderbuffer.h" | |
| #define XMESA_RENDERBUFFER 0x1234 | |
| #if defined(USE_XSHM) | |
| static volatile int mesaXErrorFlag = 0; | |
| /** | |
| * Catches potential Xlib errors. | |
| */ | |
| static int | |
| mesaHandleXError(XMesaDisplay *dpy, XErrorEvent *event) | |
| { | |
| (void) dpy; | |
| (void) event; | |
| mesaXErrorFlag = 1; | |
| return 0; | |
| } | |
| /** | |
| * Allocate a shared memory XImage back buffer for the given XMesaBuffer. | |
| * Return: GL_TRUE if success, GL_FALSE if error | |
| */ | |
| static GLboolean | |
| alloc_back_shm_ximage(XMesaBuffer b, GLuint width, GLuint height) | |
| { | |
| /* | |
| * We have to do a _lot_ of error checking here to be sure we can | |
| * really use the XSHM extension. It seems different servers trigger | |
| * errors at different points if the extension won't work. Therefore | |
| * we have to be very careful... | |
| */ | |
| GC gc; | |
| int (*old_handler)(XMesaDisplay *, XErrorEvent *); | |
| if (width == 0 || height == 0) { | |
| /* this will be true the first time we're called on 'b' */ | |
| return GL_FALSE; | |
| } | |
| b->backxrb->ximage = XShmCreateImage(b->xm_visual->display, | |
| b->xm_visual->visinfo->visual, | |
| b->xm_visual->visinfo->depth, | |
| ZPixmap, NULL, &b->shminfo, | |
| width, height); | |
| if (b->backxrb->ximage == NULL) { | |
| _mesa_warning(NULL, "alloc_back_buffer: Shared memory error (XShmCreateImage), disabling.\n"); | |
| b->shm = 0; | |
| return GL_FALSE; | |
| } | |
| b->shminfo.shmid = shmget(IPC_PRIVATE, b->backxrb->ximage->bytes_per_line | |
| * b->backxrb->ximage->height, IPC_CREAT|0777); | |
| if (b->shminfo.shmid < 0) { | |
| _mesa_warning(NULL, "shmget failed while allocating back buffer.\n"); | |
| XDestroyImage(b->backxrb->ximage); | |
| b->backxrb->ximage = NULL; | |
| _mesa_warning(NULL, "alloc_back_buffer: Shared memory error (shmget), disabling.\n"); | |
| b->shm = 0; | |
| return GL_FALSE; | |
| } | |
| b->shminfo.shmaddr = b->backxrb->ximage->data | |
| = (char*)shmat(b->shminfo.shmid, 0, 0); | |
| if (b->shminfo.shmaddr == (char *) -1) { | |
| _mesa_warning(NULL, "shmat() failed while allocating back buffer.\n"); | |
| XDestroyImage(b->backxrb->ximage); | |
| shmctl(b->shminfo.shmid, IPC_RMID, 0); | |
| b->backxrb->ximage = NULL; | |
| _mesa_warning(NULL, "alloc_back_buffer: Shared memory error (shmat), disabling.\n"); | |
| b->shm = 0; | |
| return GL_FALSE; | |
| } | |
| b->shminfo.readOnly = False; | |
| mesaXErrorFlag = 0; | |
| old_handler = XSetErrorHandler(mesaHandleXError); | |
| /* This may trigger the X protocol error we're ready to catch: */ | |
| XShmAttach(b->xm_visual->display, &b->shminfo); | |
| XSync(b->xm_visual->display, False); | |
| if (mesaXErrorFlag) { | |
| /* we are on a remote display, this error is normal, don't print it */ | |
| XFlush(b->xm_visual->display); | |
| mesaXErrorFlag = 0; | |
| XDestroyImage(b->backxrb->ximage); | |
| shmdt(b->shminfo.shmaddr); | |
| shmctl(b->shminfo.shmid, IPC_RMID, 0); | |
| b->backxrb->ximage = NULL; | |
| b->shm = 0; | |
| (void) XSetErrorHandler(old_handler); | |
| return GL_FALSE; | |
| } | |
| shmctl(b->shminfo.shmid, IPC_RMID, 0); /* nobody else needs it */ | |
| /* Finally, try an XShmPutImage to be really sure the extension works */ | |
| gc = XCreateGC(b->xm_visual->display, b->frontxrb->drawable, 0, NULL); | |
| XShmPutImage(b->xm_visual->display, b->frontxrb->drawable, gc, | |
| b->backxrb->ximage, 0, 0, 0, 0, 1, 1 /*one pixel*/, False); | |
| XSync(b->xm_visual->display, False); | |
| XFreeGC(b->xm_visual->display, gc); | |
| (void) XSetErrorHandler(old_handler); | |
| if (mesaXErrorFlag) { | |
| XFlush(b->xm_visual->display); | |
| mesaXErrorFlag = 0; | |
| XDestroyImage(b->backxrb->ximage); | |
| shmdt(b->shminfo.shmaddr); | |
| shmctl(b->shminfo.shmid, IPC_RMID, 0); | |
| b->backxrb->ximage = NULL; | |
| b->shm = 0; | |
| return GL_FALSE; | |
| } | |
| return GL_TRUE; | |
| } | |
| #else | |
| static GLboolean | |
| alloc_back_shm_ximage(XMesaBuffer b, GLuint width, GLuint height) | |
| { | |
| /* Can't compile XSHM support */ | |
| return GL_FALSE; | |
| } | |
| #endif | |
| /** | |
| * Setup an off-screen pixmap or Ximage to use as the back buffer. | |
| * Input: b - the X/Mesa buffer | |
| */ | |
| static void | |
| alloc_back_buffer(XMesaBuffer b, GLuint width, GLuint height) | |
| { | |
| if (b->db_mode == BACK_XIMAGE) { | |
| /* Deallocate the old backxrb->ximage, if any */ | |
| if (b->backxrb->ximage) { | |
| #if defined(USE_XSHM) | |
| if (b->shm) { | |
| XShmDetach(b->xm_visual->display, &b->shminfo); | |
| XDestroyImage(b->backxrb->ximage); | |
| shmdt(b->shminfo.shmaddr); | |
| } | |
| else | |
| #endif | |
| XMesaDestroyImage(b->backxrb->ximage); | |
| b->backxrb->ximage = NULL; | |
| } | |
| if (width == 0 || height == 0) | |
| return; | |
| /* Allocate new back buffer */ | |
| if (b->shm == 0 || !alloc_back_shm_ximage(b, width, height)) { | |
| /* Allocate a regular XImage for the back buffer. */ | |
| b->backxrb->ximage = XCreateImage(b->xm_visual->display, | |
| b->xm_visual->visinfo->visual, | |
| GET_VISUAL_DEPTH(b->xm_visual), | |
| ZPixmap, 0, /* format, offset */ | |
| NULL, | |
| width, height, | |
| 8, 0); /* pad, bytes_per_line */ | |
| if (!b->backxrb->ximage) { | |
| _mesa_warning(NULL, "alloc_back_buffer: XCreateImage failed.\n"); | |
| return; | |
| } | |
| b->backxrb->ximage->data = malloc(b->backxrb->ximage->height | |
| * b->backxrb->ximage->bytes_per_line); | |
| if (!b->backxrb->ximage->data) { | |
| _mesa_warning(NULL, "alloc_back_buffer: MALLOC failed.\n"); | |
| XMesaDestroyImage(b->backxrb->ximage); | |
| b->backxrb->ximage = NULL; | |
| } | |
| } | |
| b->backxrb->pixmap = None; | |
| } | |
| else if (b->db_mode == BACK_PIXMAP) { | |
| /* Free the old back pixmap */ | |
| if (b->backxrb->pixmap) { | |
| XMesaFreePixmap(b->xm_visual->display, b->backxrb->pixmap); | |
| b->backxrb->pixmap = 0; | |
| } | |
| if (width > 0 && height > 0) { | |
| /* Allocate new back pixmap */ | |
| b->backxrb->pixmap = XMesaCreatePixmap(b->xm_visual->display, | |
| b->frontxrb->drawable, | |
| width, height, | |
| GET_VISUAL_DEPTH(b->xm_visual)); | |
| } | |
| b->backxrb->ximage = NULL; | |
| b->backxrb->drawable = b->backxrb->pixmap; | |
| } | |
| } | |
| static void | |
| xmesa_delete_renderbuffer(struct gl_context *ctx, struct gl_renderbuffer *rb) | |
| { | |
| /* XXX Note: the ximage or Pixmap attached to this renderbuffer | |
| * should probably get freed here, but that's currently done in | |
| * XMesaDestroyBuffer(). | |
| */ | |
| free(rb); | |
| } | |
| /** | |
| * Reallocate renderbuffer storage for front color buffer. | |
| * Called via gl_renderbuffer::AllocStorage() | |
| */ | |
| static GLboolean | |
| xmesa_alloc_front_storage(struct gl_context *ctx, struct gl_renderbuffer *rb, | |
| GLenum internalFormat, GLuint width, GLuint height) | |
| { | |
| struct xmesa_renderbuffer *xrb = xmesa_renderbuffer(rb); | |
| /* just clear these to be sure we don't accidentally use them */ | |
| xrb->origin2 = NULL; | |
| xrb->origin3 = NULL; | |
| xrb->origin4 = NULL; | |
| /* for the FLIP macro: */ | |
| xrb->bottom = height - 1; | |
| rb->Width = width; | |
| rb->Height = height; | |
| rb->InternalFormat = internalFormat; | |
| return GL_TRUE; | |
| } | |
| /** | |
| * Reallocate renderbuffer storage for back color buffer. | |
| * Called via gl_renderbuffer::AllocStorage() | |
| */ | |
| static GLboolean | |
| xmesa_alloc_back_storage(struct gl_context *ctx, struct gl_renderbuffer *rb, | |
| GLenum internalFormat, GLuint width, GLuint height) | |
| { | |
| struct xmesa_renderbuffer *xrb = xmesa_renderbuffer(rb); | |
| /* reallocate the back buffer XImage or Pixmap */ | |
| assert(xrb->Parent); | |
| alloc_back_buffer(xrb->Parent, width, height); | |
| /* same as front buffer */ | |
| /* XXX why is this here? */ | |
| (void) xmesa_alloc_front_storage(ctx, rb, internalFormat, width, height); | |
| /* plus... */ | |
| if (xrb->ximage) { | |
| /* Needed by PIXELADDR2 macro */ | |
| xrb->width2 = xrb->ximage->bytes_per_line / 2; | |
| xrb->origin2 = (GLushort *) xrb->ximage->data + xrb->width2 * (height - 1); | |
| /* Needed by PIXELADDR3 macro */ | |
| xrb->width3 = xrb->ximage->bytes_per_line; | |
| xrb->origin3 = (GLubyte *) xrb->ximage->data + xrb->width3 * (height - 1); | |
| /* Needed by PIXELADDR4 macro */ | |
| xrb->width4 = xrb->ximage->width; | |
| xrb->origin4 = (GLuint *) xrb->ximage->data + xrb->width4 * (height - 1); | |
| } | |
| else { | |
| /* out of memory or buffer size is 0 x 0 */ | |
| xrb->width2 = xrb->width3 = xrb->width4 = 0; | |
| xrb->origin2 = NULL; | |
| xrb->origin3 = NULL; | |
| xrb->origin4 = NULL; | |
| } | |
| return GL_TRUE; | |
| } | |
| /** | |
| * Used for allocating front/back renderbuffers for an X window. | |
| */ | |
| struct xmesa_renderbuffer * | |
| xmesa_new_renderbuffer(struct gl_context *ctx, GLuint name, | |
| const struct xmesa_visual *xmvis, | |
| GLboolean backBuffer) | |
| { | |
| struct xmesa_renderbuffer *xrb = CALLOC_STRUCT(xmesa_renderbuffer); | |
| if (xrb) { | |
| GLuint name = 0; | |
| _mesa_init_renderbuffer(&xrb->Base.Base, name); | |
| xrb->Base.Base.Delete = xmesa_delete_renderbuffer; | |
| if (backBuffer) | |
| xrb->Base.Base.AllocStorage = xmesa_alloc_back_storage; | |
| else | |
| xrb->Base.Base.AllocStorage = xmesa_alloc_front_storage; | |
| xrb->Base.Base.InternalFormat = GL_RGBA; | |
| xrb->Base.Base._BaseFormat = GL_RGBA; | |
| xrb->Base.Base.ClassID = XMESA_RENDERBUFFER; | |
| switch (xmvis->undithered_pf) { | |
| case PF_8R8G8B: | |
| /* This will really only happen for pixmaps. We'll access the | |
| * pixmap via a temporary XImage which will be 32bpp. | |
| */ | |
| xrb->Base.Base.Format = MESA_FORMAT_B8G8R8X8_UNORM; | |
| break; | |
| case PF_8A8R8G8B: | |
| xrb->Base.Base.Format = MESA_FORMAT_B8G8R8A8_UNORM; | |
| break; | |
| case PF_8A8B8G8R: | |
| xrb->Base.Base.Format = MESA_FORMAT_R8G8B8A8_UNORM; | |
| break; | |
| case PF_5R6G5B: | |
| xrb->Base.Base.Format = MESA_FORMAT_B5G6R5_UNORM; | |
| break; | |
| default: | |
| _mesa_warning(ctx, "Bad pixel format in xmesa_new_renderbuffer"); | |
| xrb->Base.Base.Format = MESA_FORMAT_B8G8R8A8_UNORM; | |
| break; | |
| } | |
| /* only need to set Red/Green/EtcBits fields for user-created RBs */ | |
| } | |
| return xrb; | |
| } | |
| /** | |
| * Called via gl_framebuffer::Delete() method when this buffer | |
| * is _really_ being deleted. | |
| */ | |
| void | |
| xmesa_delete_framebuffer(struct gl_framebuffer *fb) | |
| { | |
| XMesaBuffer b = XMESA_BUFFER(fb); | |
| if (b->num_alloced > 0) { | |
| /* If no other buffer uses this X colormap then free the colors. */ | |
| if (!xmesa_find_buffer(b->display, b->cmap, b)) { | |
| XFreeColors(b->display, b->cmap, | |
| b->alloced_colors, b->num_alloced, 0); | |
| } | |
| } | |
| if (b->gc) | |
| XMesaFreeGC(b->display, b->gc); | |
| if (b->cleargc) | |
| XMesaFreeGC(b->display, b->cleargc); | |
| if (b->swapgc) | |
| XMesaFreeGC(b->display, b->swapgc); | |
| if (fb->Visual.doubleBufferMode) { | |
| /* free back ximage/pixmap/shmregion */ | |
| if (b->backxrb->ximage) { | |
| #if defined(USE_XSHM) | |
| if (b->shm) { | |
| XShmDetach( b->display, &b->shminfo ); | |
| XDestroyImage( b->backxrb->ximage ); | |
| shmdt( b->shminfo.shmaddr ); | |
| } | |
| else | |
| #endif | |
| XMesaDestroyImage( b->backxrb->ximage ); | |
| b->backxrb->ximage = NULL; | |
| } | |
| if (b->backxrb->pixmap) { | |
| XMesaFreePixmap( b->display, b->backxrb->pixmap ); | |
| } | |
| } | |
| _mesa_free_framebuffer_data(fb); | |
| free(fb); | |
| } | |
| /** | |
| * Called via ctx->Driver.MapRenderbuffer() | |
| */ | |
| void | |
| xmesa_MapRenderbuffer(struct gl_context *ctx, | |
| struct gl_renderbuffer *rb, | |
| GLuint x, GLuint y, GLuint w, GLuint h, | |
| GLbitfield mode, | |
| GLubyte **mapOut, GLint *rowStrideOut, | |
| bool flip_y) | |
| { | |
| struct xmesa_renderbuffer *xrb = xmesa_renderbuffer(rb); | |
| if (xrb->Base.Base.ClassID == XMESA_RENDERBUFFER) { | |
| XImage *ximage = xrb->ximage; | |
| assert(!xrb->map_mode); /* only a single mapping allowed */ | |
| xrb->map_mode = mode; | |
| xrb->map_x = x; | |
| xrb->map_y = y; | |
| xrb->map_w = w; | |
| xrb->map_h = h; | |
| if (ximage) { | |
| int y2 = rb->Height - y - 1; | |
| *mapOut = (GLubyte *) ximage->data | |
| + y2 * ximage->bytes_per_line | |
| + x * ximage->bits_per_pixel / 8; | |
| } | |
| else { | |
| /* this must be a pixmap/window renderbuffer */ | |
| int (*old_handler)(XMesaDisplay *, XErrorEvent *); | |
| int y2 = rb->Height - y - h; | |
| assert(xrb->pixmap); | |
| /* Install error handler for XGetImage() in case the window | |
| * isn't mapped. If we fail we'll create a temporary XImage. | |
| */ | |
| mesaXErrorFlag = 0; | |
| old_handler = XSetErrorHandler(mesaHandleXError); | |
| /* read pixel data out of the pixmap/window into an XImage */ | |
| ximage = XGetImage(xrb->Parent->display, | |
| xrb->pixmap, x, y2, w, h, | |
| AllPlanes, ZPixmap); | |
| XSetErrorHandler(old_handler); | |
| if (mesaXErrorFlag) { | |
| /* create new, temporary XImage */ | |
| int bytes_per_line = | |
| _mesa_format_row_stride(xrb->Base.Base.Format, | |
| xrb->Base.Base.Width); | |
| char *image = malloc(bytes_per_line * | |
| xrb->Base.Base.Height); | |
| ximage = XCreateImage(xrb->Parent->display, | |
| xrb->Parent->xm_visual->visinfo->visual, | |
| xrb->Parent->xm_visual->visinfo->depth, | |
| ZPixmap, /* format */ | |
| 0, /* offset */ | |
| image, /* data */ | |
| xrb->Base.Base.Width, | |
| xrb->Base.Base.Height, | |
| 8, /* pad */ | |
| bytes_per_line); | |
| } | |
| if (!ximage) { | |
| *mapOut = NULL; | |
| *rowStrideOut = 0; | |
| return; | |
| } | |
| xrb->map_ximage = ximage; | |
| /* the first row of the OpenGL image is last row of the XImage */ | |
| *mapOut = (GLubyte *) ximage->data | |
| + (h - 1) * ximage->bytes_per_line; | |
| } | |
| /* We return a negative stride here since XImage data is upside down | |
| * with respect to OpenGL images. | |
| */ | |
| *rowStrideOut = -ximage->bytes_per_line; | |
| return; | |
| } | |
| /* otherwise, this is an ordinary malloc-based renderbuffer */ | |
| _swrast_map_soft_renderbuffer(ctx, rb, x, y, w, h, mode, | |
| mapOut, rowStrideOut, false); | |
| } | |
| /** | |
| * Called via ctx->Driver.UnmapRenderbuffer() | |
| */ | |
| void | |
| xmesa_UnmapRenderbuffer(struct gl_context *ctx, struct gl_renderbuffer *rb) | |
| { | |
| struct xmesa_renderbuffer *xrb = xmesa_renderbuffer(rb); | |
| if (xrb->Base.Base.ClassID == XMESA_RENDERBUFFER) { | |
| XImage *ximage = xrb->ximage; | |
| if (!ximage) { | |
| /* this must be a pixmap/window renderbuffer */ | |
| assert(xrb->pixmap); | |
| assert(xrb->map_ximage); | |
| if (xrb->map_ximage) { | |
| if (xrb->map_mode & GL_MAP_WRITE_BIT) { | |
| /* put modified ximage data back into the pixmap/window */ | |
| int y2 = rb->Height - xrb->map_y - xrb->map_h; | |
| GC gc = XCreateGC(xrb->Parent->display, xrb->pixmap, 0, NULL); | |
| XPutImage(xrb->Parent->display, | |
| xrb->pixmap, /* dest */ | |
| gc, | |
| xrb->map_ximage, /* source */ | |
| 0, 0, /* src x, y */ | |
| xrb->map_x, y2, /* dest x, y */ | |
| xrb->map_w, xrb->map_h); /* size */ | |
| XFreeGC(xrb->Parent->display, gc); | |
| } | |
| XMesaDestroyImage(xrb->map_ximage); | |
| xrb->map_ximage = NULL; | |
| } | |
| } | |
| xrb->map_mode = 0x0; | |
| return; | |
| } | |
| /* otherwise, this is an ordinary malloc-based renderbuffer */ | |
| _swrast_unmap_soft_renderbuffer(ctx, rb); | |
| } | |