xm_api.c revision c8542705f712732d178d07da5ee1b7b25362db4b
1/* 2 * Mesa 3-D graphics library 3 * Version: 6.3 4 * 5 * Copyright (C) 1999-2005 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 * This file contains the implementations of all the XMesa* functions. 27 * 28 * 29 * NOTES: 30 * 31 * The window coordinate system origin (0,0) is in the lower-left corner 32 * of the window. X11's window coordinate origin is in the upper-left 33 * corner of the window. Therefore, most drawing functions in this 34 * file have to flip Y coordinates. 35 * 36 * Define USE_XSHM in the Makefile with -DUSE_XSHM if you want to compile 37 * in support for the MIT Shared Memory extension. If enabled, when you 38 * use an Ximage for the back buffer in double buffered mode, the "swap" 39 * operation will be faster. You must also link with -lXext. 40 * 41 * Byte swapping: If the Mesa host and the X display use a different 42 * byte order then there's some trickiness to be aware of when using 43 * XImages. The byte ordering used for the XImage is that of the X 44 * display, not the Mesa host. 45 * The color-to-pixel encoding for True/DirectColor must be done 46 * according to the display's visual red_mask, green_mask, and blue_mask. 47 * If XPutPixel is used to put a pixel into an XImage then XPutPixel will 48 * do byte swapping if needed. If one wants to directly "poke" the pixel 49 * into the XImage's buffer then the pixel must be byte swapped first. In 50 * Mesa, when byte swapping is needed we use the PF_TRUECOLOR pixel format 51 * and use XPutPixel everywhere except in the implementation of 52 * glClear(GL_COLOR_BUFFER_BIT). We want this function to be fast so 53 * instead of using XPutPixel we "poke" our values after byte-swapping 54 * the clear pixel value if needed. 55 * 56 */ 57 58#ifdef __CYGWIN__ 59#undef WIN32 60#undef __WIN32__ 61#endif 62 63#include "glxheader.h" 64#include "GL/xmesa.h" 65#include "xmesaP.h" 66#include "context.h" 67#include "extensions.h" 68#include "framebuffer.h" 69#include "glthread.h" 70#include "imports.h" 71#include "matrix.h" 72#include "mtypes.h" 73#include "macros.h" 74#include "renderbuffer.h" 75#include "texformat.h" 76#include "texobj.h" 77#include "texstore.h" 78#include "swrast/swrast.h" 79#include "swrast_setup/swrast_setup.h" 80#include "array_cache/acache.h" 81#include "tnl/tnl.h" 82#include "tnl/t_context.h" 83#include "tnl/t_pipeline.h" 84#include "drivers/common/driverfuncs.h" 85 86#ifdef XFree86Server 87#include <GL/glxtokens.h> 88#endif 89 90/* 91 * Global X driver lock 92 */ 93_glthread_Mutex _xmesa_lock; 94 95 96 97/* 98 * Lookup tables for HPCR pixel format: 99 */ 100static short hpcr_rgbTbl[3][256] = { 101{ 102 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 23, 103 24, 24, 25, 25, 26, 26, 27, 27, 28, 28, 29, 29, 30, 30, 31, 31, 104 32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37, 38, 38, 39, 39, 105 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 106 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 107 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 108 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 109 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 110112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 111128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 112144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 113160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 114176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 115192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 116208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 117224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239 118}, 119{ 120 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 23, 121 24, 24, 25, 25, 26, 26, 27, 27, 28, 28, 29, 29, 30, 30, 31, 31, 122 32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37, 38, 38, 39, 39, 123 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 124 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 125 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 126 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 127 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 128112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 129128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 130144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 131160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 132176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 133192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 134208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 135224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239 136}, 137{ 138 32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37, 38, 38, 39, 39, 139 40, 40, 41, 41, 42, 42, 43, 43, 44, 44, 45, 45, 46, 46, 47, 47, 140 48, 48, 49, 49, 50, 50, 51, 51, 52, 52, 53, 53, 54, 54, 55, 55, 141 56, 56, 57, 57, 58, 58, 59, 59, 60, 60, 61, 61, 62, 62, 63, 63, 142 64, 64, 65, 65, 66, 66, 67, 67, 68, 68, 69, 69, 70, 70, 71, 71, 143 72, 72, 73, 73, 74, 74, 75, 75, 76, 76, 77, 77, 78, 78, 79, 79, 144 80, 80, 81, 81, 82, 82, 83, 83, 84, 84, 85, 85, 86, 86, 87, 87, 145 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 146 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 147112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 148128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 149144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 150160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 151176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 152192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 153208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223 154} 155}; 156 157 158 159/**********************************************************************/ 160/***** X Utility Functions *****/ 161/**********************************************************************/ 162 163 164/* 165 * Return the host's byte order as LSBFirst or MSBFirst ala X. 166 */ 167#ifndef XFree86Server 168static int host_byte_order( void ) 169{ 170 int i = 1; 171 char *cptr = (char *) &i; 172 return (*cptr==1) ? LSBFirst : MSBFirst; 173} 174#endif 175 176 177/* 178 * Error handling. 179 */ 180#ifndef XFree86Server 181static volatile int mesaXErrorFlag = 0; 182 183static int mesaHandleXError( XMesaDisplay *dpy, XErrorEvent *event ) 184{ 185 (void) dpy; 186 (void) event; 187 mesaXErrorFlag = 1; 188 return 0; 189} 190#endif 191 192 193/* 194 * Check if the X Shared Memory extension is available. 195 * Return: 0 = not available 196 * 1 = shared XImage support available 197 * 2 = shared Pixmap support available also 198 */ 199#ifndef XFree86Server 200static int check_for_xshm( XMesaDisplay *display ) 201{ 202#ifdef USE_XSHM 203 int major, minor, ignore; 204 Bool pixmaps; 205 206 if (XQueryExtension( display, "MIT-SHM", &ignore, &ignore, &ignore )) { 207 if (XShmQueryVersion( display, &major, &minor, &pixmaps )==True) { 208 return (pixmaps==True) ? 2 : 1; 209 } 210 else { 211 return 0; 212 } 213 } 214 else { 215 return 0; 216 } 217#else 218 /* Can't compile XSHM support */ 219 return 0; 220#endif 221} 222#endif 223 224 225/* 226 * Apply gamma correction to an intensity value in [0..max]. Return the 227 * new intensity value. 228 */ 229static GLint gamma_adjust( GLfloat gamma, GLint value, GLint max ) 230{ 231 if (gamma == 1.0) { 232 return value; 233 } 234 else { 235 double x = (double) value / (double) max; 236 return IROUND_POS((GLfloat) max * _mesa_pow(x, 1.0F/gamma)); 237 } 238} 239 240 241 242/* 243 * Return the true number of bits per pixel for XImages. 244 * For example, if we request a 24-bit deep visual we may actually need/get 245 * 32bpp XImages. This function returns the appropriate bpp. 246 * Input: dpy - the X display 247 * visinfo - desribes the visual to be used for XImages 248 * Return: true number of bits per pixel for XImages 249 */ 250#ifdef XFree86Server 251 252static int bits_per_pixel( XMesaVisual xmv ) 253{ 254 const int depth = xmv->nplanes; 255 int i; 256 for (i = 0; i < screenInfo.numPixmapFormats; i++) { 257 if (screenInfo.formats[i].depth == depth) 258 return screenInfo.formats[i].bitsPerPixel; 259 } 260 return depth; /* should never get here, but this should be safe */ 261} 262 263#else 264 265static int bits_per_pixel( XMesaVisual xmv ) 266{ 267 XMesaDisplay *dpy = xmv->display; 268 XMesaVisualInfo visinfo = xmv->visinfo; 269 XMesaImage *img; 270 int bitsPerPixel; 271 /* Create a temporary XImage */ 272 img = XCreateImage( dpy, visinfo->visual, visinfo->depth, 273 ZPixmap, 0, /*format, offset*/ 274 (char*) MALLOC(8), /*data*/ 275 1, 1, /*width, height*/ 276 32, /*bitmap_pad*/ 277 0 /*bytes_per_line*/ 278 ); 279 assert(img); 280 /* grab the bits/pixel value */ 281 bitsPerPixel = img->bits_per_pixel; 282 /* free the XImage */ 283 _mesa_free( img->data ); 284 img->data = NULL; 285 XMesaDestroyImage( img ); 286 return bitsPerPixel; 287} 288#endif 289 290 291 292/* 293 * Determine if a given X window ID is valid (window exists). 294 * Do this by calling XGetWindowAttributes() for the window and 295 * checking if we catch an X error. 296 * Input: dpy - the display 297 * win - the window to check for existance 298 * Return: GL_TRUE - window exists 299 * GL_FALSE - window doesn't exist 300 */ 301#ifndef XFree86Server 302static GLboolean WindowExistsFlag; 303 304static int window_exists_err_handler( XMesaDisplay* dpy, XErrorEvent* xerr ) 305{ 306 (void) dpy; 307 if (xerr->error_code == BadWindow) { 308 WindowExistsFlag = GL_FALSE; 309 } 310 return 0; 311} 312 313static GLboolean window_exists( XMesaDisplay *dpy, Window win ) 314{ 315 XWindowAttributes wa; 316 int (*old_handler)( XMesaDisplay*, XErrorEvent* ); 317 WindowExistsFlag = GL_TRUE; 318 old_handler = XSetErrorHandler(window_exists_err_handler); 319 XGetWindowAttributes( dpy, win, &wa ); /* dummy request */ 320 XSetErrorHandler(old_handler); 321 return WindowExistsFlag; 322} 323#endif 324 325 326 327/**********************************************************************/ 328/***** Linked list of XMesaBuffers *****/ 329/**********************************************************************/ 330 331static XMesaBuffer XMesaBufferList = NULL; 332 333 334/** 335 * Allocate a new XMesaBuffer, initialize basic fields and add to 336 * the list of all buffers. 337 */ 338static XMesaBuffer 339alloc_xmesa_buffer(XMesaVisual vis, BufferType type, XMesaColormap cmap) 340{ 341 XMesaBuffer b = (XMesaBuffer) CALLOC_STRUCT(xmesa_buffer); 342 if (b) { 343 b->display = vis->display; 344 b->xm_visual = vis; 345 b->type = type; 346 b->cmap = cmap; 347 348 _mesa_initialize_framebuffer(&b->mesa_buffer, &vis->mesa_visual); 349 350 /* determine back buffer implementation */ 351 if (vis->mesa_visual.doubleBufferMode) { 352 if (vis->ximage_flag) { 353 b->db_state = BACK_XIMAGE; 354 } 355 else { 356 b->db_state = BACK_PIXMAP; 357 } 358 } 359 else { 360 b->db_state = 0; 361 } 362 363 /* Allocate the framebuffer's renderbuffers */ 364 assert(!b->mesa_buffer.Attachment[BUFFER_FRONT_LEFT].Renderbuffer); 365 assert(!b->mesa_buffer.Attachment[BUFFER_BACK_LEFT].Renderbuffer); 366 367 /* front renderbuffer */ 368 b->frontxrb = xmesa_new_renderbuffer(NULL, 0, vis->mesa_visual.rgbMode); 369 _mesa_add_renderbuffer(&b->mesa_buffer, BUFFER_FRONT_LEFT, 370 &b->frontxrb->Base); 371 372 /* back renderbuffer */ 373 if (vis->mesa_visual.doubleBufferMode) { 374 b->backxrb =xmesa_new_renderbuffer(NULL, 0, vis->mesa_visual.rgbMode); 375 _mesa_add_renderbuffer(&b->mesa_buffer, BUFFER_BACK_LEFT, 376 &b->backxrb->Base); 377 } 378 379 _mesa_add_soft_renderbuffers(&b->mesa_buffer, 380 GL_FALSE, /* color */ 381 vis->mesa_visual.haveDepthBuffer, 382 vis->mesa_visual.haveStencilBuffer, 383 vis->mesa_visual.haveAccumBuffer, 384 vis->mesa_visual.alphaBits > 0, 385 vis->mesa_visual.numAuxBuffers > 0 ); 386 387 /* insert into linked list */ 388 b->Next = XMesaBufferList; 389 XMesaBufferList = b; 390 } 391 return b; 392} 393 394 395/* 396 * Find an XMesaBuffer by matching X display and colormap but NOT matching 397 * the notThis buffer. 398 */ 399static XMesaBuffer find_xmesa_buffer(XMesaDisplay *dpy, 400 XMesaColormap cmap, 401 XMesaBuffer notThis) 402{ 403 XMesaBuffer b; 404 for (b=XMesaBufferList; b; b=b->Next) { 405 if (b->display==dpy && b->cmap==cmap && b!=notThis) { 406 return b; 407 } 408 } 409 return NULL; 410} 411 412 413/* 414 * Free an XMesaBuffer, remove from linked list, perhaps free X colormap 415 * entries. 416 */ 417static void free_xmesa_buffer(int client, XMesaBuffer buffer) 418{ 419 XMesaBuffer prev = NULL, b; 420 (void) client; 421 for (b=XMesaBufferList; b; b=b->Next) { 422 if (b==buffer) { 423 /* unlink bufer from list */ 424 if (prev) 425 prev->Next = buffer->Next; 426 else 427 XMesaBufferList = buffer->Next; 428 /* Check to free X colors */ 429 if (buffer->num_alloced>0) { 430 /* If no other buffer uses this X colormap then free the colors. */ 431 if (!find_xmesa_buffer(buffer->display, buffer->cmap, buffer)) { 432#ifdef XFree86Server 433 (void)FreeColors(buffer->cmap, client, 434 buffer->num_alloced, buffer->alloced_colors, 435 0); 436#else 437 XFreeColors(buffer->display, buffer->cmap, 438 buffer->alloced_colors, buffer->num_alloced, 0); 439#endif 440 } 441 } 442 443 _mesa_free_framebuffer_data(&buffer->mesa_buffer); 444 /* delete front/back renderbuffers */ 445 buffer->frontxrb->Base.Delete(&(buffer->frontxrb->Base)); 446 if (buffer->backxrb) 447 buffer->backxrb->Base.Delete(&(buffer->backxrb->Base)); 448 _mesa_free(buffer); 449 450 return; 451 } 452 /* continue search */ 453 prev = b; 454 } 455 /* buffer not found in XMesaBufferList */ 456 _mesa_problem(NULL,"free_xmesa_buffer() - buffer not found\n"); 457} 458 459 460/* Copy X color table stuff from one XMesaBuffer to another. */ 461static void copy_colortable_info(XMesaBuffer dst, const XMesaBuffer src) 462{ 463 MEMCPY(dst->color_table, src->color_table, sizeof(src->color_table)); 464 MEMCPY(dst->pixel_to_r, src->pixel_to_r, sizeof(src->pixel_to_r)); 465 MEMCPY(dst->pixel_to_g, src->pixel_to_g, sizeof(src->pixel_to_g)); 466 MEMCPY(dst->pixel_to_b, src->pixel_to_b, sizeof(src->pixel_to_b)); 467 dst->num_alloced = src->num_alloced; 468 MEMCPY(dst->alloced_colors, src->alloced_colors, 469 sizeof(src->alloced_colors)); 470} 471 472 473 474/**********************************************************************/ 475/***** Misc Private Functions *****/ 476/**********************************************************************/ 477 478 479/* 480 * Return number of bits set in n. 481 */ 482static int bitcount( unsigned long n ) 483{ 484 int bits; 485 for (bits=0; n>0; n=n>>1) { 486 if (n&1) { 487 bits++; 488 } 489 } 490 return bits; 491} 492 493 494 495/** 496 * Allocate a shared memory XImage back buffer for the given XMesaBuffer. 497 * Return: GL_TRUE if success, GL_FALSE if error 498 */ 499#ifndef XFree86Server 500static GLboolean 501alloc_shm_back_buffer(XMesaBuffer b, GLuint width, GLuint height) 502{ 503#ifdef USE_XSHM 504 /* 505 * We have to do a _lot_ of error checking here to be sure we can 506 * really use the XSHM extension. It seems different servers trigger 507 * errors at different points if the extension won't work. Therefore 508 * we have to be very careful... 509 */ 510 GC gc; 511 int (*old_handler)( XMesaDisplay *, XErrorEvent * ); 512 513 if (width == 0 || height == 0) { 514 /* this will be true the first time we're called on 'b' */ 515 return GL_FALSE; 516 } 517 518 b->backxrb->ximage = XShmCreateImage(b->xm_visual->display, 519 b->xm_visual->visinfo->visual, 520 b->xm_visual->visinfo->depth, 521 ZPixmap, NULL, &b->shminfo, 522 width, height); 523 if (b->backxrb->ximage == NULL) { 524 _mesa_warning(NULL, "alloc_back_buffer: Shared memory error (XShmCreateImage), disabling."); 525 b->shm = 0; 526 return GL_FALSE; 527 } 528 529 b->shminfo.shmid = shmget( IPC_PRIVATE, b->backxrb->ximage->bytes_per_line 530 * b->backxrb->ximage->height, IPC_CREAT|0777 ); 531 if (b->shminfo.shmid < 0) { 532 _mesa_warning(NULL, "shmget failed while allocating back buffer"); 533 XDestroyImage( b->backxrb->ximage ); 534 b->backxrb->ximage = NULL; 535 _mesa_warning(NULL, "alloc_back_buffer: Shared memory error (shmget), disabling."); 536 b->shm = 0; 537 return GL_FALSE; 538 } 539 540 b->shminfo.shmaddr = b->backxrb->ximage->data 541 = (char*)shmat( b->shminfo.shmid, 0, 0 ); 542 if (b->shminfo.shmaddr == (char *) -1) { 543 _mesa_warning(NULL, "shmat() failed while allocating back buffer"); 544 XDestroyImage( b->backxrb->ximage ); 545 shmctl( b->shminfo.shmid, IPC_RMID, 0 ); 546 b->backxrb->ximage = NULL; 547 _mesa_warning(NULL, "alloc_back_buffer: Shared memory error (shmat), disabling."); 548 b->shm = 0; 549 return GL_FALSE; 550 } 551 552 b->shminfo.readOnly = False; 553 mesaXErrorFlag = 0; 554 old_handler = XSetErrorHandler( mesaHandleXError ); 555 /* This may trigger the X protocol error we're ready to catch: */ 556 XShmAttach( b->xm_visual->display, &b->shminfo ); 557 XSync( b->xm_visual->display, False ); 558 559 if (mesaXErrorFlag) { 560 /* we are on a remote display, this error is normal, don't print it */ 561 XFlush( b->xm_visual->display ); 562 mesaXErrorFlag = 0; 563 XDestroyImage( b->backxrb->ximage ); 564 shmdt( b->shminfo.shmaddr ); 565 shmctl( b->shminfo.shmid, IPC_RMID, 0 ); 566 b->backxrb->ximage = NULL; 567 b->shm = 0; 568 (void) XSetErrorHandler( old_handler ); 569 return GL_FALSE; 570 } 571 572 shmctl( b->shminfo.shmid, IPC_RMID, 0 ); /* nobody else needs it */ 573 574 /* Finally, try an XShmPutImage to be really sure the extension works */ 575 gc = XCreateGC( b->xm_visual->display, b->frontxrb->pixmap, 0, NULL ); 576 XShmPutImage( b->xm_visual->display, b->frontxrb->pixmap, gc, 577 b->backxrb->ximage, 0, 0, 0, 0, 1, 1 /*one pixel*/, False ); 578 XSync( b->xm_visual->display, False ); 579 XFreeGC( b->xm_visual->display, gc ); 580 (void) XSetErrorHandler( old_handler ); 581 if (mesaXErrorFlag) { 582 XFlush( b->xm_visual->display ); 583 mesaXErrorFlag = 0; 584 XDestroyImage( b->backxrb->ximage ); 585 shmdt( b->shminfo.shmaddr ); 586 shmctl( b->shminfo.shmid, IPC_RMID, 0 ); 587 b->backxrb->ximage = NULL; 588 b->shm = 0; 589 return GL_FALSE; 590 } 591 592 return GL_TRUE; 593#else 594 /* Can't compile XSHM support */ 595 return GL_FALSE; 596#endif 597} 598#endif 599 600 601 602/* 603 * Setup an off-screen pixmap or Ximage to use as the back buffer. 604 * Input: b - the X/Mesa buffer 605 */ 606void 607xmesa_alloc_back_buffer( XMesaBuffer b, GLuint width, GLuint height ) 608{ 609 if (width == 0 || height == 0) 610 return; 611 612 if (b->db_state == BACK_XIMAGE) { 613 /* Deallocate the old backxrb->ximage, if any */ 614 if (b->backxrb->ximage) { 615#if defined(USE_XSHM) && !defined(XFree86Server) 616 if (b->shm) { 617 XShmDetach( b->xm_visual->display, &b->shminfo ); 618 XDestroyImage( b->backxrb->ximage ); 619 shmdt( b->shminfo.shmaddr ); 620 } 621 else 622#endif 623 XMesaDestroyImage( b->backxrb->ximage ); 624 b->backxrb->ximage = NULL; 625 } 626 627 /* Allocate new back buffer */ 628#ifdef XFree86Server 629 { 630 /* Allocate a regular XImage for the back buffer. */ 631 b->backxrb->ximage = XMesaCreateImage(b->xm_visual->BitsPerPixel, 632 width, height, NULL); 633#else 634 if (b->shm == 0 || !alloc_shm_back_buffer(b, width, height)) { 635 /* Allocate a regular XImage for the back buffer. */ 636 b->backxrb->ximage = XCreateImage( b->xm_visual->display, 637 b->xm_visual->visinfo->visual, 638 GET_VISUAL_DEPTH(b->xm_visual), 639 ZPixmap, 0, /* format, offset */ 640 NULL, 641 width, height, 642 8, 0 ); /* pad, bytes_per_line */ 643#endif 644 if (!b->backxrb->ximage) { 645 _mesa_warning(NULL, "alloc_back_buffer: XCreateImage failed."); 646 } 647 b->backxrb->ximage->data = (char *) MALLOC( b->backxrb->ximage->height 648 * b->backxrb->ximage->bytes_per_line ); 649 if (!b->backxrb->ximage->data) { 650 _mesa_warning(NULL, "alloc_back_buffer: MALLOC failed."); 651 XMesaDestroyImage( b->backxrb->ximage ); 652 b->backxrb->ximage = NULL; 653 } 654 } 655 b->backxrb->pixmap = None; 656 b->backxrb->ximage = b->backxrb->ximage; 657 } 658 else if (b->db_state==BACK_PIXMAP) { 659 if (!width) 660 width = 1; 661 if (!height) 662 height = 1; 663 664 /* Free the old back pixmap */ 665 if (b->backxrb->pixmap) { 666 XMesaFreePixmap( b->xm_visual->display, b->backxrb->pixmap ); 667 } 668 /* Allocate new back pixmap */ 669 b->backxrb->pixmap = XMesaCreatePixmap( b->xm_visual->display, b->frontxrb->pixmap, 670 width, height, 671 GET_VISUAL_DEPTH(b->xm_visual) ); 672 b->backxrb->ximage = NULL; 673 } 674} 675 676 677 678/* 679 * A replacement for XAllocColor. This function should never 680 * fail to allocate a color. When XAllocColor fails, we return 681 * the nearest matching color. If we have to allocate many colors 682 * this function isn't too efficient; the XQueryColors() could be 683 * done just once. 684 * Written by Michael Pichler, Brian Paul, Mark Kilgard 685 * Input: dpy - X display 686 * cmap - X colormap 687 * cmapSize - size of colormap 688 * In/Out: color - the XColor struct 689 * Output: exact - 1=exact color match, 0=closest match 690 * alloced - 1=XAlloc worked, 0=XAlloc failed 691 */ 692static void 693noFaultXAllocColor( int client, 694 XMesaDisplay *dpy, 695 XMesaColormap cmap, 696 int cmapSize, 697 XMesaColor *color, 698 int *exact, int *alloced ) 699{ 700#ifdef XFree86Server 701 Pixel *ppixIn; 702 xrgb *ctable; 703#else 704 /* we'll try to cache ctable for better remote display performance */ 705 static Display *prevDisplay = NULL; 706 static XMesaColormap prevCmap = 0; 707 static int prevCmapSize = 0; 708 static XMesaColor *ctable = NULL; 709#endif 710 XMesaColor subColor; 711 int i, bestmatch; 712 double mindist; /* 3*2^16^2 exceeds long int precision. */ 713 714 (void) client; 715 716 /* First try just using XAllocColor. */ 717#ifdef XFree86Server 718 if (AllocColor(cmap, 719 &color->red, &color->green, &color->blue, 720 &color->pixel, 721 client) == Success) { 722#else 723 if (XAllocColor(dpy, cmap, color)) { 724#endif 725 *exact = 1; 726 *alloced = 1; 727 return; 728 } 729 730 /* Alloc failed, search for closest match */ 731 732 /* Retrieve color table entries. */ 733 /* XXX alloca candidate. */ 734#ifdef XFree86Server 735 ppixIn = (Pixel *) MALLOC(cmapSize * sizeof(Pixel)); 736 ctable = (xrgb *) MALLOC(cmapSize * sizeof(xrgb)); 737 for (i = 0; i < cmapSize; i++) { 738 ppixIn[i] = i; 739 } 740 QueryColors(cmap, cmapSize, ppixIn, ctable); 741#else 742 if (prevDisplay != dpy || prevCmap != cmap 743 || prevCmapSize != cmapSize || !ctable) { 744 /* free previously cached color table */ 745 if (ctable) 746 _mesa_free(ctable); 747 /* Get the color table from X */ 748 ctable = (XMesaColor *) MALLOC(cmapSize * sizeof(XMesaColor)); 749 assert(ctable); 750 for (i = 0; i < cmapSize; i++) { 751 ctable[i].pixel = i; 752 } 753 XQueryColors(dpy, cmap, ctable, cmapSize); 754 prevDisplay = dpy; 755 prevCmap = cmap; 756 prevCmapSize = cmapSize; 757 } 758#endif 759 760 /* Find best match. */ 761 bestmatch = -1; 762 mindist = 0.0; 763 for (i = 0; i < cmapSize; i++) { 764 double dr = 0.30 * ((double) color->red - (double) ctable[i].red); 765 double dg = 0.59 * ((double) color->green - (double) ctable[i].green); 766 double db = 0.11 * ((double) color->blue - (double) ctable[i].blue); 767 double dist = dr * dr + dg * dg + db * db; 768 if (bestmatch < 0 || dist < mindist) { 769 bestmatch = i; 770 mindist = dist; 771 } 772 } 773 774 /* Return result. */ 775 subColor.red = ctable[bestmatch].red; 776 subColor.green = ctable[bestmatch].green; 777 subColor.blue = ctable[bestmatch].blue; 778 /* Try to allocate the closest match color. This should only 779 * fail if the cell is read/write. Otherwise, we're incrementing 780 * the cell's reference count. 781 */ 782#ifdef XFree86Server 783 if (AllocColor(cmap, 784 &subColor.red, &subColor.green, &subColor.blue, 785 &subColor.pixel, 786 client) == Success) { 787#else 788 if (XAllocColor(dpy, cmap, &subColor)) { 789#endif 790 *alloced = 1; 791 } 792 else { 793 /* do this to work around a problem reported by Frank Ortega */ 794 subColor.pixel = (unsigned long) bestmatch; 795 subColor.red = ctable[bestmatch].red; 796 subColor.green = ctable[bestmatch].green; 797 subColor.blue = ctable[bestmatch].blue; 798 subColor.flags = DoRed | DoGreen | DoBlue; 799 *alloced = 0; 800 } 801#ifdef XFree86Server 802 _mesa_free(ppixIn); 803 _mesa_free(ctable); 804#else 805 /* don't free table, save it for next time */ 806#endif 807 808 *color = subColor; 809 *exact = 0; 810} 811 812 813 814 815/* 816 * Do setup for PF_GRAYSCALE pixel format. 817 * Note that buffer may be NULL. 818 */ 819static GLboolean setup_grayscale( int client, XMesaVisual v, 820 XMesaBuffer buffer, XMesaColormap cmap ) 821{ 822 if (GET_VISUAL_DEPTH(v)<4 || GET_VISUAL_DEPTH(v)>16) { 823 return GL_FALSE; 824 } 825 826 if (buffer) { 827 XMesaBuffer prevBuffer; 828 829 if (!cmap) { 830 return GL_FALSE; 831 } 832 833 prevBuffer = find_xmesa_buffer(v->display, cmap, buffer); 834 if (prevBuffer && 835 (buffer->xm_visual->mesa_visual.rgbMode == 836 prevBuffer->xm_visual->mesa_visual.rgbMode)) { 837 /* Copy colormap stuff from previous XMesaBuffer which uses same 838 * X colormap. Do this to avoid time spent in noFaultXAllocColor. 839 */ 840 copy_colortable_info(buffer, prevBuffer); 841 } 842 else { 843 /* Allocate 256 shades of gray */ 844 int gray; 845 int colorsfailed = 0; 846 for (gray=0;gray<256;gray++) { 847 GLint r = gamma_adjust( v->RedGamma, gray, 255 ); 848 GLint g = gamma_adjust( v->GreenGamma, gray, 255 ); 849 GLint b = gamma_adjust( v->BlueGamma, gray, 255 ); 850 int exact, alloced; 851 XMesaColor xcol; 852 xcol.red = (r << 8) | r; 853 xcol.green = (g << 8) | g; 854 xcol.blue = (b << 8) | b; 855 noFaultXAllocColor( client, v->display, 856 cmap, GET_COLORMAP_SIZE(v), 857 &xcol, &exact, &alloced ); 858 if (!exact) { 859 colorsfailed++; 860 } 861 if (alloced) { 862 assert(buffer->num_alloced<256); 863 buffer->alloced_colors[buffer->num_alloced] = xcol.pixel; 864 buffer->num_alloced++; 865 } 866 867 /*OLD 868 assert(gray < 576); 869 buffer->color_table[gray*3+0] = xcol.pixel; 870 buffer->color_table[gray*3+1] = xcol.pixel; 871 buffer->color_table[gray*3+2] = xcol.pixel; 872 assert(xcol.pixel < 65536); 873 buffer->pixel_to_r[xcol.pixel] = gray * 30 / 100; 874 buffer->pixel_to_g[xcol.pixel] = gray * 59 / 100; 875 buffer->pixel_to_b[xcol.pixel] = gray * 11 / 100; 876 */ 877 buffer->color_table[gray] = xcol.pixel; 878 assert(xcol.pixel < 65536); 879 buffer->pixel_to_r[xcol.pixel] = gray; 880 buffer->pixel_to_g[xcol.pixel] = gray; 881 buffer->pixel_to_b[xcol.pixel] = gray; 882 } 883 884 if (colorsfailed && _mesa_getenv("MESA_DEBUG")) { 885 _mesa_warning(NULL, 886 "Note: %d out of 256 needed colors do not match exactly.\n", 887 colorsfailed ); 888 } 889 } 890 } 891 892 v->dithered_pf = PF_Grayscale; 893 v->undithered_pf = PF_Grayscale; 894 return GL_TRUE; 895} 896 897 898 899/* 900 * Setup RGB rendering for a window with a PseudoColor, StaticColor, 901 * or 8-bit TrueColor visual visual. We try to allocate a palette of 225 902 * colors (5 red, 9 green, 5 blue) and dither to approximate a 24-bit RGB 903 * color. While this function was originally designed just for 8-bit 904 * visuals, it has also proven to work from 4-bit up to 16-bit visuals. 905 * Dithering code contributed by Bob Mercier. 906 */ 907static GLboolean setup_dithered_color( int client, XMesaVisual v, 908 XMesaBuffer buffer, XMesaColormap cmap ) 909{ 910 if (GET_VISUAL_DEPTH(v)<4 || GET_VISUAL_DEPTH(v)>16) { 911 return GL_FALSE; 912 } 913 914 if (buffer) { 915 XMesaBuffer prevBuffer; 916 917 if (!cmap) { 918 return GL_FALSE; 919 } 920 921 prevBuffer = find_xmesa_buffer(v->display, cmap, buffer); 922 if (prevBuffer && 923 (buffer->xm_visual->mesa_visual.rgbMode == 924 prevBuffer->xm_visual->mesa_visual.rgbMode)) { 925 /* Copy colormap stuff from previous, matching XMesaBuffer. 926 * Do this to avoid time spent in noFaultXAllocColor. 927 */ 928 copy_colortable_info(buffer, prevBuffer); 929 } 930 else { 931 /* Allocate X colors and initialize color_table[], red_table[], etc */ 932 int r, g, b, i; 933 int colorsfailed = 0; 934 for (r = 0; r < DITH_R; r++) { 935 for (g = 0; g < DITH_G; g++) { 936 for (b = 0; b < DITH_B; b++) { 937 XMesaColor xcol; 938 int exact, alloced; 939 xcol.red =gamma_adjust(v->RedGamma, r*65535/(DITH_R-1),65535); 940 xcol.green=gamma_adjust(v->GreenGamma, g*65535/(DITH_G-1),65535); 941 xcol.blue =gamma_adjust(v->BlueGamma, b*65535/(DITH_B-1),65535); 942 noFaultXAllocColor( client, v->display, 943 cmap, GET_COLORMAP_SIZE(v), 944 &xcol, &exact, &alloced ); 945 if (!exact) { 946 colorsfailed++; 947 } 948 if (alloced) { 949 assert(buffer->num_alloced<256); 950 buffer->alloced_colors[buffer->num_alloced] = xcol.pixel; 951 buffer->num_alloced++; 952 } 953 i = DITH_MIX( r, g, b ); 954 assert(i < 576); 955 buffer->color_table[i] = xcol.pixel; 956 assert(xcol.pixel < 65536); 957 buffer->pixel_to_r[xcol.pixel] = r * 255 / (DITH_R-1); 958 buffer->pixel_to_g[xcol.pixel] = g * 255 / (DITH_G-1); 959 buffer->pixel_to_b[xcol.pixel] = b * 255 / (DITH_B-1); 960 } 961 } 962 } 963 964 if (colorsfailed && _mesa_getenv("MESA_DEBUG")) { 965 _mesa_warning(NULL, 966 "Note: %d out of %d needed colors do not match exactly.\n", 967 colorsfailed, DITH_R * DITH_G * DITH_B ); 968 } 969 } 970 } 971 972 v->dithered_pf = PF_Dither; 973 v->undithered_pf = PF_Lookup; 974 return GL_TRUE; 975} 976 977 978/* 979 * Setup for Hewlett Packard Color Recovery 8-bit TrueColor mode. 980 * HPCR simulates 24-bit color fidelity with an 8-bit frame buffer. 981 * Special dithering tables have to be initialized. 982 */ 983static void setup_8bit_hpcr( XMesaVisual v ) 984{ 985 /* HP Color Recovery contributed by: Alex De Bruyn (ad@lms.be) 986 * To work properly, the atom _HP_RGB_SMOOTH_MAP_LIST must be defined 987 * on the root window AND the colormap obtainable by XGetRGBColormaps 988 * for that atom must be set on the window. (see also tkInitWindow) 989 * If that colormap is not set, the output will look stripy. 990 */ 991 992 /* Setup color tables with gamma correction */ 993 int i; 994 double g; 995 996 g = 1.0 / v->RedGamma; 997 for (i=0; i<256; i++) { 998 GLint red = IROUND_POS(255.0 * _mesa_pow( hpcr_rgbTbl[0][i]/255.0, g )); 999 v->hpcr_rgbTbl[0][i] = CLAMP( red, 16, 239 ); 1000 } 1001 1002 g = 1.0 / v->GreenGamma; 1003 for (i=0; i<256; i++) { 1004 GLint green = IROUND_POS(255.0 * _mesa_pow( hpcr_rgbTbl[1][i]/255.0, g )); 1005 v->hpcr_rgbTbl[1][i] = CLAMP( green, 16, 239 ); 1006 } 1007 1008 g = 1.0 / v->BlueGamma; 1009 for (i=0; i<256; i++) { 1010 GLint blue = IROUND_POS(255.0 * _mesa_pow( hpcr_rgbTbl[2][i]/255.0, g )); 1011 v->hpcr_rgbTbl[2][i] = CLAMP( blue, 32, 223 ); 1012 } 1013 v->undithered_pf = PF_HPCR; /* can't really disable dithering for now */ 1014 v->dithered_pf = PF_HPCR; 1015 1016 /* which method should I use to clear */ 1017 /* GL_FALSE: keep the ordinary method */ 1018 /* GL_TRUE : clear with dither pattern */ 1019 v->hpcr_clear_flag = _mesa_getenv("MESA_HPCR_CLEAR") ? GL_TRUE : GL_FALSE; 1020 1021 if (v->hpcr_clear_flag) { 1022 v->hpcr_clear_pixmap = XMesaCreatePixmap(v->display, 1023 DefaultRootWindow(v->display), 1024 16, 2, 8); 1025#ifndef XFree86Server 1026 v->hpcr_clear_ximage = XGetImage(v->display, v->hpcr_clear_pixmap, 1027 0, 0, 16, 2, AllPlanes, ZPixmap); 1028#endif 1029 } 1030} 1031 1032 1033/* 1034 * Setup RGB rendering for a window with a True/DirectColor visual. 1035 */ 1036static void setup_truecolor( XMesaVisual v, XMesaBuffer buffer, 1037 XMesaColormap cmap ) 1038{ 1039 unsigned long rmask, gmask, bmask; 1040 (void) buffer; 1041 (void) cmap; 1042 1043 /* Compute red multiplier (mask) and bit shift */ 1044 v->rshift = 0; 1045 rmask = GET_REDMASK(v); 1046 while ((rmask & 1)==0) { 1047 v->rshift++; 1048 rmask = rmask >> 1; 1049 } 1050 1051 /* Compute green multiplier (mask) and bit shift */ 1052 v->gshift = 0; 1053 gmask = GET_GREENMASK(v); 1054 while ((gmask & 1)==0) { 1055 v->gshift++; 1056 gmask = gmask >> 1; 1057 } 1058 1059 /* Compute blue multiplier (mask) and bit shift */ 1060 v->bshift = 0; 1061 bmask = GET_BLUEMASK(v); 1062 while ((bmask & 1)==0) { 1063 v->bshift++; 1064 bmask = bmask >> 1; 1065 } 1066 1067 /* 1068 * Compute component-to-pixel lookup tables and dithering kernel 1069 */ 1070 { 1071 static GLubyte kernel[16] = { 1072 0*16, 8*16, 2*16, 10*16, 1073 12*16, 4*16, 14*16, 6*16, 1074 3*16, 11*16, 1*16, 9*16, 1075 15*16, 7*16, 13*16, 5*16, 1076 }; 1077 GLint rBits = bitcount(rmask); 1078 GLint gBits = bitcount(gmask); 1079 GLint bBits = bitcount(bmask); 1080 GLint maxBits; 1081 GLuint i; 1082 1083 /* convert pixel components in [0,_mask] to RGB values in [0,255] */ 1084 for (i=0; i<=rmask; i++) 1085 v->PixelToR[i] = (unsigned char) ((i * 255) / rmask); 1086 for (i=0; i<=gmask; i++) 1087 v->PixelToG[i] = (unsigned char) ((i * 255) / gmask); 1088 for (i=0; i<=bmask; i++) 1089 v->PixelToB[i] = (unsigned char) ((i * 255) / bmask); 1090 1091 /* convert RGB values from [0,255] to pixel components */ 1092 1093 for (i=0;i<256;i++) { 1094 GLint r = gamma_adjust(v->RedGamma, i, 255); 1095 GLint g = gamma_adjust(v->GreenGamma, i, 255); 1096 GLint b = gamma_adjust(v->BlueGamma, i, 255); 1097 v->RtoPixel[i] = (r >> (8-rBits)) << v->rshift; 1098 v->GtoPixel[i] = (g >> (8-gBits)) << v->gshift; 1099 v->BtoPixel[i] = (b >> (8-bBits)) << v->bshift; 1100 } 1101 /* overflow protection */ 1102 for (i=256;i<512;i++) { 1103 v->RtoPixel[i] = v->RtoPixel[255]; 1104 v->GtoPixel[i] = v->GtoPixel[255]; 1105 v->BtoPixel[i] = v->BtoPixel[255]; 1106 } 1107 1108 /* setup dithering kernel */ 1109 maxBits = rBits; 1110 if (gBits > maxBits) maxBits = gBits; 1111 if (bBits > maxBits) maxBits = bBits; 1112 for (i=0;i<16;i++) { 1113 v->Kernel[i] = kernel[i] >> maxBits; 1114 } 1115 1116 v->undithered_pf = PF_Truecolor; 1117 v->dithered_pf = (GET_VISUAL_DEPTH(v)<24) ? PF_Dither_True : PF_Truecolor; 1118 } 1119 1120 /* 1121 * Now check for TrueColor visuals which we can optimize. 1122 */ 1123 if ( GET_REDMASK(v) ==0x0000ff 1124 && GET_GREENMASK(v)==0x00ff00 1125 && GET_BLUEMASK(v) ==0xff0000 1126 && CHECK_BYTE_ORDER(v) 1127 && v->BitsPerPixel==32 1128 && sizeof(GLuint)==4 1129 && v->RedGamma==1.0 && v->GreenGamma==1.0 && v->BlueGamma==1.0) { 1130 /* common 32 bpp config used on SGI, Sun */ 1131 v->undithered_pf = v->dithered_pf = PF_8A8B8G8R; 1132 } 1133 else if (GET_REDMASK(v) ==0xff0000 1134 && GET_GREENMASK(v)==0x00ff00 1135 && GET_BLUEMASK(v) ==0x0000ff 1136 && CHECK_BYTE_ORDER(v) 1137 && v->BitsPerPixel==32 1138 && sizeof(GLuint)==4 1139 && v->RedGamma==1.0 && v->GreenGamma==1.0 && v->BlueGamma==1.0) { 1140 /* common 32 bpp config used on Linux, HP, IBM */ 1141 if (GET_VISUAL_DEPTH(v)==32) 1142 v->undithered_pf = v->dithered_pf = PF_8A8R8G8B; 1143 else 1144 v->undithered_pf = v->dithered_pf = PF_8R8G8B; 1145 } 1146 else if (GET_REDMASK(v) ==0xff0000 1147 && GET_GREENMASK(v)==0x00ff00 1148 && GET_BLUEMASK(v) ==0x0000ff 1149 && CHECK_BYTE_ORDER(v) 1150 && v->BitsPerPixel==24 1151 && sizeof(GLuint)==4 1152 && v->RedGamma==1.0 && v->GreenGamma==1.0 && v->BlueGamma==1.0) { 1153 /* common packed 24 bpp config used on Linux */ 1154 v->undithered_pf = v->dithered_pf = PF_8R8G8B24; 1155 } 1156 else if (GET_REDMASK(v) ==0xf800 1157 && GET_GREENMASK(v)==0x07e0 1158 && GET_BLUEMASK(v) ==0x001f 1159 && CHECK_BYTE_ORDER(v) 1160 && v->BitsPerPixel==16 1161 && sizeof(GLushort)==2 1162 && v->RedGamma==1.0 && v->GreenGamma==1.0 && v->BlueGamma==1.0) { 1163 /* 5-6-5 color weight on common PC VGA boards */ 1164 v->undithered_pf = PF_5R6G5B; 1165 v->dithered_pf = PF_Dither_5R6G5B; 1166 } 1167 else if (GET_REDMASK(v) ==0xe0 1168 && GET_GREENMASK(v)==0x1c 1169 && GET_BLUEMASK(v) ==0x03 1170 && CHECK_FOR_HPCR(v)) { 1171 setup_8bit_hpcr( v ); 1172 } 1173} 1174 1175 1176 1177/* 1178 * Setup RGB rendering for a window with a monochrome visual. 1179 */ 1180static void setup_monochrome( XMesaVisual v, XMesaBuffer b ) 1181{ 1182 (void) b; 1183 v->dithered_pf = v->undithered_pf = PF_1Bit; 1184 /* if black=1 then we must flip pixel values */ 1185 v->bitFlip = (GET_BLACK_PIXEL(v) != 0); 1186} 1187 1188 1189 1190/* 1191 * When a context is "made current" for the first time, we can finally 1192 * finish initializing the context's visual and buffer information. 1193 * Input: v - the XMesaVisual to initialize 1194 * b - the XMesaBuffer to initialize (may be NULL) 1195 * rgb_flag - TRUE = RGBA mode, FALSE = color index mode 1196 * window - the window/pixmap we're rendering into 1197 * cmap - the colormap associated with the window/pixmap 1198 * Return: GL_TRUE=success, GL_FALSE=failure 1199 */ 1200static GLboolean initialize_visual_and_buffer( int client, 1201 XMesaVisual v, 1202 XMesaBuffer b, 1203 GLboolean rgb_flag, 1204 XMesaDrawable window, 1205 XMesaColormap cmap ) 1206{ 1207#if NEW_RENDERBUFFER 1208 struct xmesa_renderbuffer *front_xrb, *back_xrb; 1209#endif 1210#ifndef XFree86Server 1211 XGCValues gcvalues; 1212#endif 1213 1214 if (b) { 1215 assert(b->xm_visual == v); 1216 } 1217 1218#if NEW_RENDERBUFFER 1219 if (b) { 1220 front_xrb = b->frontxrb; 1221 back_xrb = b->backxrb; 1222 } 1223 else { 1224 front_xrb = back_xrb = NULL; 1225 } 1226#endif 1227 1228 /* Save true bits/pixel */ 1229 v->BitsPerPixel = bits_per_pixel(v); 1230 assert(v->BitsPerPixel > 0); 1231 1232 1233 if (rgb_flag==GL_FALSE) { 1234 /* COLOR-INDEXED WINDOW: 1235 * Even if the visual is TrueColor or DirectColor we treat it as 1236 * being color indexed. This is weird but might be useful to someone. 1237 */ 1238 v->dithered_pf = v->undithered_pf = PF_Index; 1239 v->mesa_visual.indexBits = GET_VISUAL_DEPTH(v); 1240 } 1241 else { 1242 /* RGB WINDOW: 1243 * We support RGB rendering into almost any kind of visual. 1244 */ 1245 const int xclass = v->mesa_visual.visualType; 1246 if (xclass==GLX_TRUE_COLOR || xclass==GLX_DIRECT_COLOR) { 1247 setup_truecolor( v, b, cmap ); 1248 } 1249 else if (xclass==GLX_STATIC_GRAY && GET_VISUAL_DEPTH(v)==1) { 1250 setup_monochrome( v, b ); 1251 } 1252 else if (xclass==GLX_GRAY_SCALE || xclass==GLX_STATIC_GRAY) { 1253 if (!setup_grayscale( client, v, b, cmap )) { 1254 return GL_FALSE; 1255 } 1256 } 1257 else if ((xclass==GLX_PSEUDO_COLOR || xclass==GLX_STATIC_COLOR) 1258 && GET_VISUAL_DEPTH(v)>=4 && GET_VISUAL_DEPTH(v)<=16) { 1259 if (!setup_dithered_color( client, v, b, cmap )) { 1260 return GL_FALSE; 1261 } 1262 } 1263 else { 1264 _mesa_warning(NULL, "XMesa: RGB mode rendering not supported in given visual."); 1265 return GL_FALSE; 1266 } 1267 v->mesa_visual.indexBits = 0; 1268 1269 if (_mesa_getenv("MESA_NO_DITHER")) { 1270 v->dithered_pf = v->undithered_pf; 1271 } 1272 } 1273 1274 1275 /* 1276 * If MESA_INFO env var is set print out some debugging info 1277 * which can help Brian figure out what's going on when a user 1278 * reports bugs. 1279 */ 1280 if (_mesa_getenv("MESA_INFO")) { 1281 _mesa_printf("X/Mesa visual = %p\n", (void *) v); 1282 _mesa_printf("X/Mesa dithered pf = %u\n", v->dithered_pf); 1283 _mesa_printf("X/Mesa undithered pf = %u\n", v->undithered_pf); 1284 _mesa_printf("X/Mesa level = %d\n", v->mesa_visual.level); 1285 _mesa_printf("X/Mesa depth = %d\n", GET_VISUAL_DEPTH(v)); 1286 _mesa_printf("X/Mesa bits per pixel = %d\n", v->BitsPerPixel); 1287 } 1288 1289 if (b && window) { 1290 /* Do window-specific initializations */ 1291 1292 b->frontxrb->pixmap = window; 1293 1294 /* Setup for single/double buffering */ 1295 if (v->mesa_visual.doubleBufferMode) { 1296 /* Double buffered */ 1297#ifndef XFree86Server 1298 b->shm = check_for_xshm( v->display ); 1299#endif 1300 xmesa_alloc_back_buffer(b, b->mesa_buffer.Width, b->mesa_buffer.Height); 1301 } 1302 1303 /* X11 graphics contexts */ 1304#ifdef XFree86Server 1305 b->gc = CreateScratchGC(v->display, window->depth); 1306#else 1307 b->gc = XCreateGC( v->display, window, 0, NULL ); 1308#endif 1309 XMesaSetFunction( v->display, b->gc, GXcopy ); 1310 1311 /* cleargc - for glClear() */ 1312#ifdef XFree86Server 1313 b->cleargc = CreateScratchGC(v->display, window->depth); 1314#else 1315 b->cleargc = XCreateGC( v->display, window, 0, NULL ); 1316#endif 1317 XMesaSetFunction( v->display, b->cleargc, GXcopy ); 1318 1319 /* 1320 * Don't generate Graphics Expose/NoExpose events in swapbuffers(). 1321 * Patch contributed by Michael Pichler May 15, 1995. 1322 */ 1323#ifdef XFree86Server 1324 b->swapgc = CreateScratchGC(v->display, window->depth); 1325 { 1326 CARD32 v[1]; 1327 v[0] = FALSE; 1328 dixChangeGC(NullClient, b->swapgc, GCGraphicsExposures, v, NULL); 1329 } 1330#else 1331 gcvalues.graphics_exposures = False; 1332 b->swapgc = XCreateGC( v->display, window, 1333 GCGraphicsExposures, &gcvalues); 1334#endif 1335 XMesaSetFunction( v->display, b->swapgc, GXcopy ); 1336 /* 1337 * Set fill style and tile pixmap once for all for HPCR stuff 1338 * (instead of doing it each time in clear_color_HPCR_pixmap()) 1339 * Initialize whole stuff 1340 * Patch contributed by Jacques Leroy March 8, 1998. 1341 */ 1342 if (v->hpcr_clear_flag && back_xrb->pixmap) { 1343 int i; 1344 for (i=0; i<16; i++) 1345 { 1346 XMesaPutPixel(v->hpcr_clear_ximage, i, 0, 0); 1347 XMesaPutPixel(v->hpcr_clear_ximage, i, 1, 0); 1348 } 1349 XMesaPutImage(b->display, (XMesaDrawable)v->hpcr_clear_pixmap, 1350 b->cleargc, v->hpcr_clear_ximage, 0, 0, 0, 0, 16, 2); 1351 XMesaSetFillStyle( v->display, b->cleargc, FillTiled); 1352 XMesaSetTile( v->display, b->cleargc, v->hpcr_clear_pixmap ); 1353 } 1354 1355 /* Initialize the row buffer XImage for use in write_color_span() */ 1356#ifdef XFree86Server 1357 b->rowimage = XMesaCreateImage(GET_VISUAL_DEPTH(v), MAX_WIDTH, 1, 1358 (char *)MALLOC(MAX_WIDTH*4)); 1359#else 1360 b->rowimage = XCreateImage( v->display, 1361 v->visinfo->visual, 1362 v->visinfo->depth, 1363 ZPixmap, 0, /*format, offset*/ 1364 (char*) MALLOC(MAX_WIDTH*4), /*data*/ 1365 MAX_WIDTH, 1, /*width, height*/ 1366 32, /*bitmap_pad*/ 1367 0 /*bytes_per_line*/ ); 1368#endif 1369 if (!b->rowimage) 1370 return GL_FALSE; 1371 } 1372 1373 return GL_TRUE; 1374} 1375 1376 1377 1378/* 1379 * Convert an RGBA color to a pixel value. 1380 */ 1381unsigned long 1382xmesa_color_to_pixel(GLcontext *ctx, 1383 GLubyte r, GLubyte g, GLubyte b, GLubyte a, 1384 GLuint pixelFormat) 1385{ 1386 XMesaContext xmesa = XMESA_CONTEXT(ctx); 1387 switch (pixelFormat) { 1388 case PF_Index: 1389 return 0; 1390 case PF_Truecolor: 1391 { 1392 unsigned long p; 1393 PACK_TRUECOLOR( p, r, g, b ); 1394 return p; 1395 } 1396 case PF_8A8B8G8R: 1397 return PACK_8A8B8G8R( r, g, b, a ); 1398 case PF_8A8R8G8B: 1399 return PACK_8A8R8G8B( r, g, b, a ); 1400 case PF_8R8G8B: 1401 /* fall through */ 1402 case PF_8R8G8B24: 1403 return PACK_8R8G8B( r, g, b ); 1404 case PF_5R6G5B: 1405 return PACK_5R6G5B( r, g, b ); 1406 case PF_Dither: 1407 { 1408 DITHER_SETUP; 1409 return DITHER( 1, 0, r, g, b ); 1410 } 1411 case PF_1Bit: 1412 /* 382 = (3*255)/2 */ 1413 return ((r+g+b) > 382) ^ xmesa->xm_visual->bitFlip; 1414 case PF_HPCR: 1415 return DITHER_HPCR(1, 1, r, g, b); 1416 case PF_Lookup: 1417 { 1418 LOOKUP_SETUP; 1419 return LOOKUP( r, g, b ); 1420 } 1421 case PF_Grayscale: 1422 return GRAY_RGB( r, g, b ); 1423 case PF_Dither_True: 1424 /* fall through */ 1425 case PF_Dither_5R6G5B: 1426 { 1427 unsigned long p; 1428 PACK_TRUEDITHER(p, 1, 0, r, g, b); 1429 return p; 1430 } 1431 default: 1432 _mesa_problem(ctx, "Bad pixel format in xmesa_color_to_pixel"); 1433 } 1434 return 0; 1435} 1436 1437 1438#define NUM_VISUAL_TYPES 6 1439 1440/** 1441 * Convert an X visual type to a GLX visual type. 1442 * 1443 * \param visualType X visual type (i.e., \c TrueColor, \c StaticGray, etc.) 1444 * to be converted. 1445 * \return If \c visualType is a valid X visual type, a GLX visual type will 1446 * be returned. Otherwise \c GLX_NONE will be returned. 1447 * 1448 * \note 1449 * This code was lifted directly from lib/GL/glx/glcontextmodes.c in the 1450 * DRI CVS tree. 1451 */ 1452static GLint 1453xmesa_convert_from_x_visual_type( int visualType ) 1454{ 1455 static const int glx_visual_types[ NUM_VISUAL_TYPES ] = { 1456 GLX_STATIC_GRAY, GLX_GRAY_SCALE, 1457 GLX_STATIC_COLOR, GLX_PSEUDO_COLOR, 1458 GLX_TRUE_COLOR, GLX_DIRECT_COLOR 1459 }; 1460 1461 return ( (unsigned) visualType < NUM_VISUAL_TYPES ) 1462 ? glx_visual_types[ visualType ] : GLX_NONE; 1463} 1464 1465 1466/**********************************************************************/ 1467/***** Public Functions *****/ 1468/**********************************************************************/ 1469 1470 1471/* 1472 * Create a new X/Mesa visual. 1473 * Input: display - X11 display 1474 * visinfo - an XVisualInfo pointer 1475 * rgb_flag - GL_TRUE = RGB mode, 1476 * GL_FALSE = color index mode 1477 * alpha_flag - alpha buffer requested? 1478 * db_flag - GL_TRUE = double-buffered, 1479 * GL_FALSE = single buffered 1480 * stereo_flag - stereo visual? 1481 * ximage_flag - GL_TRUE = use an XImage for back buffer, 1482 * GL_FALSE = use an off-screen pixmap for back buffer 1483 * depth_size - requested bits/depth values, or zero 1484 * stencil_size - requested bits/stencil values, or zero 1485 * accum_red_size - requested bits/red accum values, or zero 1486 * accum_green_size - requested bits/green accum values, or zero 1487 * accum_blue_size - requested bits/blue accum values, or zero 1488 * accum_alpha_size - requested bits/alpha accum values, or zero 1489 * num_samples - number of samples/pixel if multisampling, or zero 1490 * level - visual level, usually 0 1491 * visualCaveat - ala the GLX extension, usually GLX_NONE 1492 * Return; a new XMesaVisual or 0 if error. 1493 */ 1494XMesaVisual XMesaCreateVisual( XMesaDisplay *display, 1495 XMesaVisualInfo visinfo, 1496 GLboolean rgb_flag, 1497 GLboolean alpha_flag, 1498 GLboolean db_flag, 1499 GLboolean stereo_flag, 1500 GLboolean ximage_flag, 1501 GLint depth_size, 1502 GLint stencil_size, 1503 GLint accum_red_size, 1504 GLint accum_green_size, 1505 GLint accum_blue_size, 1506 GLint accum_alpha_size, 1507 GLint num_samples, 1508 GLint level, 1509 GLint visualCaveat ) 1510{ 1511 char *gamma; 1512 XMesaVisual v; 1513 GLint red_bits, green_bits, blue_bits, alpha_bits; 1514 1515 /* For debugging only */ 1516 if (_mesa_getenv("MESA_XSYNC")) { 1517 /* This makes debugging X easier. 1518 * In your debugger, set a breakpoint on _XError to stop when an 1519 * X protocol error is generated. 1520 */ 1521#ifdef XFree86Server 1522 /* NOT_NEEDED */ 1523#else 1524 XSynchronize( display, 1 ); 1525#endif 1526 } 1527 1528 v = (XMesaVisual) CALLOC_STRUCT(xmesa_visual); 1529 if (!v) { 1530 return NULL; 1531 } 1532 1533 /* 1534 * In the X server, NULL is passed in for the display. It will have 1535 * to be set before using this visual. See XMesaSetVisualDisplay() 1536 * below. 1537 */ 1538 v->display = display; 1539 1540 /* Save a copy of the XVisualInfo struct because the user may X_mesa_free() 1541 * the struct but we may need some of the information contained in it 1542 * at a later time. 1543 */ 1544#ifndef XFree86Server 1545 v->visinfo = (XVisualInfo *) MALLOC(sizeof(*visinfo)); 1546 if(!v->visinfo) { 1547 _mesa_free(v); 1548 return NULL; 1549 } 1550 MEMCPY(v->visinfo, visinfo, sizeof(*visinfo)); 1551#endif 1552 1553 /* check for MESA_GAMMA environment variable */ 1554 gamma = _mesa_getenv("MESA_GAMMA"); 1555 if (gamma) { 1556 v->RedGamma = v->GreenGamma = v->BlueGamma = 0.0; 1557 sscanf( gamma, "%f %f %f", &v->RedGamma, &v->GreenGamma, &v->BlueGamma ); 1558 if (v->RedGamma<=0.0) v->RedGamma = 1.0; 1559 if (v->GreenGamma<=0.0) v->GreenGamma = v->RedGamma; 1560 if (v->BlueGamma<=0.0) v->BlueGamma = v->RedGamma; 1561 } 1562 else { 1563 v->RedGamma = v->GreenGamma = v->BlueGamma = 1.0; 1564 } 1565 1566 v->ximage_flag = ximage_flag; 1567 1568#ifdef XFree86Server 1569 /* We could calculate these values by ourselves. nplanes is either the sum 1570 * of the red, green, and blue bits or the number index bits. 1571 * ColormapEntries is either (1U << index_bits) or 1572 * (1U << max(redBits, greenBits, blueBits)). 1573 */ 1574 v->nplanes = visinfo->nplanes; 1575 v->ColormapEntries = visinfo->ColormapEntries; 1576 1577 v->mesa_visual.redMask = visinfo->redMask; 1578 v->mesa_visual.greenMask = visinfo->greenMask; 1579 v->mesa_visual.blueMask = visinfo->blueMask; 1580 v->mesa_visual.visualID = visinfo->vid; 1581 v->mesa_visual.screen = 0; /* FIXME: What should be done here? */ 1582#else 1583 v->mesa_visual.redMask = visinfo->red_mask; 1584 v->mesa_visual.greenMask = visinfo->green_mask; 1585 v->mesa_visual.blueMask = visinfo->blue_mask; 1586 v->mesa_visual.visualID = visinfo->visualid; 1587 v->mesa_visual.screen = visinfo->screen; 1588#endif 1589 1590#if defined(XFree86Server) || !(defined(__cplusplus) || defined(c_plusplus)) 1591 v->mesa_visual.visualType = xmesa_convert_from_x_visual_type(visinfo->class); 1592#else 1593 v->mesa_visual.visualType = xmesa_convert_from_x_visual_type(visinfo->c_class); 1594#endif 1595 1596 v->mesa_visual.visualRating = visualCaveat; 1597 1598 (void) initialize_visual_and_buffer( 0, v, NULL, rgb_flag, 0, 0 ); 1599 1600 { 1601 const int xclass = v->mesa_visual.visualType; 1602 if (xclass==GLX_TRUE_COLOR || xclass==GLX_DIRECT_COLOR) { 1603 red_bits = bitcount(GET_REDMASK(v)); 1604 green_bits = bitcount(GET_GREENMASK(v)); 1605 blue_bits = bitcount(GET_BLUEMASK(v)); 1606 alpha_bits = 0; 1607 } 1608 else { 1609 /* this is an approximation */ 1610 int depth; 1611 depth = GET_VISUAL_DEPTH(v); 1612 red_bits = depth / 3; 1613 depth -= red_bits; 1614 green_bits = depth / 2; 1615 depth -= green_bits; 1616 blue_bits = depth; 1617 alpha_bits = 0; 1618 assert( red_bits + green_bits + blue_bits == GET_VISUAL_DEPTH(v) ); 1619 } 1620 } 1621 1622 if (alpha_flag && alpha_bits == 0) 1623 alpha_bits = 8; 1624 1625 _mesa_initialize_visual( &v->mesa_visual, 1626 rgb_flag, db_flag, stereo_flag, 1627 red_bits, green_bits, 1628 blue_bits, alpha_bits, 1629 v->mesa_visual.indexBits, 1630 depth_size, 1631 stencil_size, 1632 accum_red_size, accum_green_size, 1633 accum_blue_size, accum_alpha_size, 1634 0 ); 1635 1636 /* XXX minor hack */ 1637 v->mesa_visual.level = level; 1638 return v; 1639} 1640 1641 1642void XMesaSetVisualDisplay( XMesaDisplay *dpy, XMesaVisual v ) 1643{ 1644 v->display = dpy; 1645} 1646 1647 1648void XMesaDestroyVisual( XMesaVisual v ) 1649{ 1650#ifndef XFree86Server 1651 _mesa_free(v->visinfo); 1652#endif 1653 _mesa_free(v); 1654} 1655 1656 1657 1658/** 1659 * Create a new XMesaContext. 1660 * \param v the XMesaVisual 1661 * \param share_list another XMesaContext with which to share display 1662 * lists or NULL if no sharing is wanted. 1663 * \return an XMesaContext or NULL if error. 1664 */ 1665XMesaContext XMesaCreateContext( XMesaVisual v, XMesaContext share_list ) 1666{ 1667 static GLboolean firstTime = GL_TRUE; 1668 XMesaContext c; 1669 GLcontext *mesaCtx; 1670 struct dd_function_table functions; 1671 TNLcontext *tnl; 1672 1673 if (firstTime) { 1674 _glthread_INIT_MUTEX(_xmesa_lock); 1675 firstTime = GL_FALSE; 1676 } 1677 1678 /* Note: the XMesaContext contains a Mesa GLcontext struct (inheritance) */ 1679 c = (XMesaContext) CALLOC_STRUCT(xmesa_context); 1680 if (!c) 1681 return NULL; 1682 1683 mesaCtx = &(c->mesa); 1684 1685 /* initialize with default driver functions, then plug in XMesa funcs */ 1686 _mesa_init_driver_functions(&functions); 1687 xmesa_init_driver_functions(v, &functions); 1688 if (!_mesa_initialize_context(mesaCtx, &v->mesa_visual, 1689 share_list ? &(share_list->mesa) : (GLcontext *) NULL, 1690 &functions, (void *) c)) { 1691 _mesa_free(c); 1692 return NULL; 1693 } 1694 1695 _mesa_enable_sw_extensions(mesaCtx); 1696 _mesa_enable_1_3_extensions(mesaCtx); 1697 _mesa_enable_1_4_extensions(mesaCtx); 1698 _mesa_enable_1_5_extensions(mesaCtx); 1699 _mesa_enable_2_0_extensions(mesaCtx); 1700#if SWTC 1701 if (c->Mesa_DXTn) { 1702 _mesa_enable_extension(c, "GL_EXT_texture_compression_s3tc"); 1703 _mesa_enable_extension(c, "GL_S3_s3tc"); 1704 } 1705 _mesa_enable_extension(c, "GL_3DFX_texture_compression_FXT1"); 1706#endif 1707 1708 /* finish up xmesa context initializations */ 1709 c->swapbytes = CHECK_BYTE_ORDER(v) ? GL_FALSE : GL_TRUE; 1710 c->xm_visual = v; 1711 c->xm_buffer = NULL; /* set later by XMesaMakeCurrent */ 1712 c->display = v->display; 1713 c->pixelformat = v->dithered_pf; /* Dithering is enabled by default */ 1714 1715 /* Initialize the software rasterizer and helper modules. 1716 */ 1717 if (!_swrast_CreateContext( mesaCtx ) || 1718 !_ac_CreateContext( mesaCtx ) || 1719 !_tnl_CreateContext( mesaCtx ) || 1720 !_swsetup_CreateContext( mesaCtx )) { 1721 _mesa_free_context_data(&c->mesa); 1722 _mesa_free(c); 1723 return NULL; 1724 } 1725 1726 /* tnl setup */ 1727 tnl = TNL_CONTEXT(mesaCtx); 1728 tnl->Driver.RunPipeline = _tnl_run_pipeline; 1729 /* swrast setup */ 1730 xmesa_register_swrast_functions( mesaCtx ); 1731 _swsetup_Wakeup(mesaCtx); 1732 1733 return c; 1734} 1735 1736 1737 1738void XMesaDestroyContext( XMesaContext c ) 1739{ 1740 GLcontext *mesaCtx = &c->mesa; 1741#ifdef FX 1742 XMesaBuffer xmbuf = XMESA_BUFFER(mesaCtx->DrawBuffer); 1743 1744 if (xmbuf && xmbuf->FXctx) 1745 fxMesaDestroyContext(xmbuf->FXctx); 1746#endif 1747 _swsetup_DestroyContext( mesaCtx ); 1748 _swrast_DestroyContext( mesaCtx ); 1749 _tnl_DestroyContext( mesaCtx ); 1750 _ac_DestroyContext( mesaCtx ); 1751 _mesa_free_context_data( mesaCtx ); 1752 _mesa_free( c ); 1753} 1754 1755 1756 1757/* 1758 * XXX this isn't a public function! It's a hack for the 3Dfx driver. 1759 * Create a new XMesaBuffer from an X window. 1760 * Input: v - the XMesaVisual 1761 * w - the window 1762 * c - the context 1763 * Return: new XMesaBuffer or NULL if error 1764 */ 1765XMesaBuffer 1766XMesaCreateWindowBuffer2(XMesaVisual v, XMesaWindow w, XMesaContext c) 1767{ 1768#ifndef XFree86Server 1769 XWindowAttributes attr; 1770#endif 1771#ifdef FX 1772 char *fxEnvVar; 1773#endif 1774 int client = 0; 1775 XMesaBuffer b; 1776 XMesaColormap cmap; 1777 1778 assert(v); 1779 (void) c; 1780 1781 /* Check that window depth matches visual depth */ 1782#ifdef XFree86Server 1783 client = CLIENT_ID(((XMesaDrawable)w)->id); 1784 1785 if (GET_VISUAL_DEPTH(v) != ((XMesaDrawable)w)->depth) { 1786 _mesa_warning(NULL, "XMesaCreateWindowBuffer: depth mismatch between visual (%d) and window (%d)!\n", 1787 GET_VISUAL_DEPTH(v), ((XMesaDrawable) w)->depth); 1788 return NULL; 1789 } 1790#else 1791 XGetWindowAttributes( v->display, w, &attr ); 1792 1793 if (GET_VISUAL_DEPTH(v) != attr.depth) { 1794 _mesa_warning(NULL, "XMesaCreateWindowBuffer: depth mismatch between visual (%d) and window (%d)!\n", 1795 GET_VISUAL_DEPTH(v), attr.depth); 1796 return NULL; 1797 } 1798#endif 1799 1800 /* Find colormap */ 1801#ifdef XFree86Server 1802 cmap = (ColormapPtr)LookupIDByType(wColormap(w), RT_COLORMAP); 1803#else 1804 if (attr.colormap) { 1805 cmap = attr.colormap; 1806 } 1807 else { 1808 _mesa_warning(NULL, "Window %u has no colormap!\n", (unsigned int) w); 1809 /* this is weird, a window w/out a colormap!? */ 1810 /* OK, let's just allocate a new one and hope for the best */ 1811 cmap = XCreateColormap(v->display, w, attr.visual, AllocNone); 1812 } 1813#endif 1814 1815 b = alloc_xmesa_buffer(v, WINDOW, cmap); 1816 if (!b) { 1817 return NULL; 1818 } 1819 1820 if (!initialize_visual_and_buffer( client, v, b, v->mesa_visual.rgbMode, 1821 (XMesaDrawable)w, cmap )) { 1822 free_xmesa_buffer(client, b); 1823 return NULL; 1824 } 1825 1826#ifdef FX 1827 fxEnvVar = _mesa_getenv("MESA_GLX_FX"); 1828 if (fxEnvVar) { 1829 if (fxEnvVar[0]!='d') { 1830 int attribs[100]; 1831 int numAttribs = 0; 1832 int hw; 1833 if (v->mesa_visual.depthBits > 0) { 1834 attribs[numAttribs++] = FXMESA_DEPTH_SIZE; 1835 attribs[numAttribs++] = v->mesa_visual.depthBits; 1836 } 1837 if (v->mesa_visual.doubleBufferMode) { 1838 attribs[numAttribs++] = FXMESA_DOUBLEBUFFER; 1839 } 1840 if (v->mesa_visual.accumRedBits > 0) { 1841 attribs[numAttribs++] = FXMESA_ACCUM_SIZE; 1842 attribs[numAttribs++] = v->mesa_visual.accumRedBits; 1843 } 1844 if (v->mesa_visual.stencilBits > 0) { 1845 attribs[numAttribs++] = FXMESA_STENCIL_SIZE; 1846 attribs[numAttribs++] = v->mesa_visual.stencilBits; 1847 } 1848 if (v->mesa_visual.alphaBits > 0) { 1849 attribs[numAttribs++] = FXMESA_ALPHA_SIZE; 1850 attribs[numAttribs++] = v->mesa_visual.alphaBits; 1851 } 1852 if (1) { 1853 attribs[numAttribs++] = FXMESA_SHARE_CONTEXT; 1854 attribs[numAttribs++] = (int) &(c->mesa); 1855 } 1856 attribs[numAttribs++] = FXMESA_NONE; 1857 1858 /* [dBorca] we should take an envvar for `fxMesaSelectCurrentBoard'!!! */ 1859 hw = fxMesaSelectCurrentBoard(0); 1860 1861 /* if these fail, there's a new bug somewhere */ 1862 ASSERT(b->mesa_buffer.Width > 0); 1863 ASSERT(b->mesa_buffer.Height > 0); 1864 1865 if ((hw == GR_SSTTYPE_VOODOO) || (hw == GR_SSTTYPE_Voodoo2)) { 1866 b->FXctx = fxMesaCreateBestContext(0, b->mesa_buffer.Width, 1867 b->mesa_buffer.Height, attribs); 1868 if ((v->undithered_pf!=PF_Index) && (b->backxrb->ximage)) { 1869 b->FXisHackUsable = b->FXctx ? GL_TRUE : GL_FALSE; 1870 if (b->FXctx && (fxEnvVar[0]=='w' || fxEnvVar[0]=='W')) { 1871 b->FXwindowHack = GL_TRUE; 1872 FX_grSstControl(GR_CONTROL_DEACTIVATE); 1873 } 1874 else { 1875 b->FXwindowHack = GL_FALSE; 1876 } 1877 } 1878 } 1879 else { 1880 if (fxEnvVar[0]=='w' || fxEnvVar[0]=='W') 1881 b->FXctx = fxMesaCreateContext(w, GR_RESOLUTION_NONE, 1882 GR_REFRESH_75Hz, attribs); 1883 else 1884 b->FXctx = fxMesaCreateBestContext(0, b->mesa_buffer.Width, 1885 b->mesa_buffer.Height, attribs); 1886 b->FXisHackUsable = GL_FALSE; 1887 b->FXwindowHack = GL_FALSE; 1888 } 1889 /* 1890 fprintf(stderr, 1891 "voodoo %d, wid %d height %d hack: usable %d active %d\n", 1892 hw, b->mesa_buffer.Width, b->mesa_buffer.Height, 1893 b->FXisHackUsable, b->FXwindowHack); 1894 */ 1895 } 1896 } 1897 else { 1898 _mesa_warning(NULL, "WARNING: This Mesa Library includes the Glide driver but\n"); 1899 _mesa_warning(NULL, " you have not defined the MESA_GLX_FX env. var.\n"); 1900 _mesa_warning(NULL, " (check the README.3DFX file for more information).\n\n"); 1901 _mesa_warning(NULL, " you can disable this message with a 'export MESA_GLX_FX=disable'.\n"); 1902 } 1903#endif 1904 1905 return b; 1906} 1907 1908 1909XMesaBuffer 1910XMesaCreateWindowBuffer(XMesaVisual v, XMesaWindow w) 1911{ 1912 return XMesaCreateWindowBuffer2( v, w, NULL ); 1913} 1914 1915 1916/** 1917 * Create a new XMesaBuffer from an X pixmap. 1918 * 1919 * \param v the XMesaVisual 1920 * \param p the pixmap 1921 * \param cmap the colormap, may be 0 if using a \c GLX_TRUE_COLOR or 1922 * \c GLX_DIRECT_COLOR visual for the pixmap 1923 * \returns new XMesaBuffer or NULL if error 1924 */ 1925XMesaBuffer 1926XMesaCreatePixmapBuffer(XMesaVisual v, XMesaPixmap p, XMesaColormap cmap) 1927{ 1928 int client = 0; 1929 XMesaBuffer b; 1930 1931 assert(v); 1932 1933 b = alloc_xmesa_buffer(v, PIXMAP, cmap); 1934 if (!b) { 1935 return NULL; 1936 } 1937 1938#ifdef XFree86Server 1939 client = CLIENT_ID(((XMesaDrawable)p)->id); 1940#endif 1941 1942 if (!initialize_visual_and_buffer(client, v, b, v->mesa_visual.rgbMode, 1943 (XMesaDrawable)p, cmap)) { 1944 free_xmesa_buffer(client, b); 1945 return NULL; 1946 } 1947 1948 return b; 1949} 1950 1951 1952 1953XMesaBuffer 1954XMesaCreatePBuffer(XMesaVisual v, XMesaColormap cmap, 1955 unsigned int width, unsigned int height) 1956{ 1957#ifdef XFree86Server 1958 return 0; 1959#else 1960 int client = 0; 1961 XMesaWindow root; 1962 XMesaDrawable drawable; /* X Pixmap Drawable */ 1963 XMesaBuffer b; 1964 1965 b = alloc_xmesa_buffer(v, PBUFFER, cmap); 1966 if (!b) { 1967 return NULL; 1968 } 1969 1970 /* allocate pixmap for front buffer */ 1971 root = RootWindow( v->display, v->visinfo->screen ); 1972 drawable = XCreatePixmap( v->display, root, width, height, v->visinfo->depth ); 1973 1974 if (!initialize_visual_and_buffer(client, v, b, v->mesa_visual.rgbMode, 1975 drawable, cmap)) { 1976 free_xmesa_buffer(client, b); 1977 return NULL; 1978 } 1979 1980 return b; 1981#endif 1982} 1983 1984 1985 1986/* 1987 * Deallocate an XMesaBuffer structure and all related info. 1988 */ 1989void XMesaDestroyBuffer( XMesaBuffer b ) 1990{ 1991 int client = 0; 1992 1993#ifdef XFree86Server 1994 if (b->frontxrb->pixmap) 1995 client = CLIENT_ID(b->frontxrb->pixmap->id); 1996#endif 1997 1998 if (b->gc) XMesaFreeGC( b->xm_visual->display, b->gc ); 1999 if (b->cleargc) XMesaFreeGC( b->xm_visual->display, b->cleargc ); 2000 if (b->swapgc) XMesaFreeGC( b->xm_visual->display, b->swapgc ); 2001 2002 if (b->backxrb->ximage) { 2003#if defined(USE_XSHM) && !defined(XFree86Server) 2004 if (b->shm) { 2005 XShmDetach( b->xm_visual->display, &b->shminfo ); 2006 XDestroyImage( b->backxrb->ximage ); 2007 shmdt( b->shminfo.shmaddr ); 2008 } 2009 else 2010#endif 2011 XMesaDestroyImage( b->backxrb->ximage ); 2012 } 2013 if (b->backxrb->pixmap) { 2014 XMesaFreePixmap( b->xm_visual->display, b->backxrb->pixmap ); 2015 if (b->xm_visual->hpcr_clear_flag) { 2016 XMesaFreePixmap( b->xm_visual->display, 2017 b->xm_visual->hpcr_clear_pixmap ); 2018 XMesaDestroyImage( b->xm_visual->hpcr_clear_ximage ); 2019 } 2020 } 2021 if (b->rowimage) { 2022 _mesa_free( b->rowimage->data ); 2023 b->rowimage->data = NULL; 2024 XMesaDestroyImage( b->rowimage ); 2025 } 2026 2027 free_xmesa_buffer(client, b); 2028} 2029 2030 2031 2032/* 2033 * Bind buffer b to context c and make c the current rendering context. 2034 */ 2035GLboolean XMesaMakeCurrent( XMesaContext c, XMesaBuffer b ) 2036{ 2037 return XMesaMakeCurrent2( c, b, b ); 2038} 2039 2040 2041/* 2042 * Bind buffer b to context c and make c the current rendering context. 2043 */ 2044GLboolean XMesaMakeCurrent2( XMesaContext c, XMesaBuffer drawBuffer, 2045 XMesaBuffer readBuffer ) 2046{ 2047 if (c) { 2048 if (!drawBuffer || !readBuffer) 2049 return GL_FALSE; /* must specify buffers! */ 2050 2051#ifdef FX 2052 if (drawBuffer->FXctx) { 2053 fxMesaMakeCurrent(drawBuffer->FXctx); 2054 2055 c->xm_buffer = drawBuffer; 2056 2057 return GL_TRUE; 2058 } 2059#endif 2060 if (&(c->mesa) == _mesa_get_current_context() 2061 && c->mesa.DrawBuffer == &drawBuffer->mesa_buffer 2062 && c->mesa.ReadBuffer == &readBuffer->mesa_buffer 2063 && ((XMesaBuffer) c->mesa.DrawBuffer)->wasCurrent) { 2064 /* same context and buffer, do nothing */ 2065 return GL_TRUE; 2066 } 2067 2068 c->xm_buffer = drawBuffer; 2069 2070 _mesa_make_current(&(c->mesa), 2071 &drawBuffer->mesa_buffer, 2072 &readBuffer->mesa_buffer); 2073 2074 if (c->xm_visual->mesa_visual.rgbMode) { 2075 /* 2076 * Must recompute and set these pixel values because colormap 2077 * can be different for different windows. 2078 */ 2079 c->clearpixel = xmesa_color_to_pixel( &c->mesa, 2080 c->clearcolor[0], 2081 c->clearcolor[1], 2082 c->clearcolor[2], 2083 c->clearcolor[3], 2084 c->xm_visual->undithered_pf); 2085 XMesaSetForeground(c->display, drawBuffer->cleargc, c->clearpixel); 2086 } 2087 2088 /* Solution to Stephane Rehel's problem with glXReleaseBuffersMESA(): */ 2089 drawBuffer->wasCurrent = GL_TRUE; 2090 } 2091 else { 2092 /* Detach */ 2093 _mesa_make_current( NULL, NULL, NULL ); 2094 } 2095 return GL_TRUE; 2096} 2097 2098 2099/* 2100 * Unbind the context c from its buffer. 2101 */ 2102GLboolean XMesaUnbindContext( XMesaContext c ) 2103{ 2104 /* A no-op for XFree86 integration purposes */ 2105 return GL_TRUE; 2106} 2107 2108 2109XMesaContext XMesaGetCurrentContext( void ) 2110{ 2111 GET_CURRENT_CONTEXT(ctx); 2112 if (ctx) { 2113 XMesaContext xmesa = XMESA_CONTEXT(ctx); 2114 return xmesa; 2115 } 2116 else { 2117 return 0; 2118 } 2119} 2120 2121 2122XMesaBuffer XMesaGetCurrentBuffer( void ) 2123{ 2124 GET_CURRENT_CONTEXT(ctx); 2125 if (ctx) { 2126 XMesaBuffer xmbuf = XMESA_BUFFER(ctx->DrawBuffer); 2127 return xmbuf; 2128 } 2129 else { 2130 return 0; 2131 } 2132} 2133 2134 2135/* New in Mesa 3.1 */ 2136XMesaBuffer XMesaGetCurrentReadBuffer( void ) 2137{ 2138 GET_CURRENT_CONTEXT(ctx); 2139 if (ctx) { 2140 return (XMesaBuffer) (ctx->ReadBuffer); 2141 } 2142 else { 2143 return 0; 2144 } 2145} 2146 2147 2148GLboolean XMesaForceCurrent(XMesaContext c) 2149{ 2150 if (c) { 2151 if (&(c->mesa) != _mesa_get_current_context()) { 2152 _mesa_make_current(&c->mesa, c->mesa.DrawBuffer, c->mesa.ReadBuffer); 2153 } 2154 } 2155 else { 2156 _mesa_make_current(NULL, NULL, NULL); 2157 } 2158 return GL_TRUE; 2159} 2160 2161 2162GLboolean XMesaLoseCurrent(XMesaContext c) 2163{ 2164 (void) c; 2165 _mesa_make_current(NULL, NULL, NULL); 2166 return GL_TRUE; 2167} 2168 2169 2170/* 2171 * Switch 3Dfx support hack between window and full-screen mode. 2172 */ 2173GLboolean XMesaSetFXmode( GLint mode ) 2174{ 2175#ifdef FX 2176 const char *fx = _mesa_getenv("MESA_GLX_FX"); 2177 if (fx && fx[0] != 'd') { 2178 GET_CURRENT_CONTEXT(ctx); 2179 GrHwConfiguration hw; 2180 if (!FX_grSstQueryHardware(&hw)) { 2181 /*fprintf(stderr, "!grSstQueryHardware\n");*/ 2182 return GL_FALSE; 2183 } 2184 if (hw.num_sst < 1) { 2185 /*fprintf(stderr, "hw.num_sst < 1\n");*/ 2186 return GL_FALSE; 2187 } 2188 if (ctx) { 2189 /* [dBorca] Hack alert: 2190 * oh, this is sooo wrong: ctx above is 2191 * really an fxMesaContext, not an XMesaContext 2192 */ 2193 XMesaBuffer xmbuf = XMESA_BUFFER(ctx->DrawBuffer); 2194 if (mode == XMESA_FX_WINDOW) { 2195 if (xmbuf->FXisHackUsable) { 2196 FX_grSstControl(GR_CONTROL_DEACTIVATE); 2197 xmbuf->FXwindowHack = GL_TRUE; 2198 return GL_TRUE; 2199 } 2200 } 2201 else if (mode == XMESA_FX_FULLSCREEN) { 2202 FX_grSstControl(GR_CONTROL_ACTIVATE); 2203 xmbuf->FXwindowHack = GL_FALSE; 2204 return GL_TRUE; 2205 } 2206 else { 2207 /* Error: Bad mode value */ 2208 } 2209 } 2210 } 2211 /*fprintf(stderr, "fallthrough\n");*/ 2212#else 2213 (void) mode; 2214#endif 2215 return GL_FALSE; 2216} 2217 2218 2219 2220#ifdef FX 2221/* 2222 * Read image from VooDoo frame buffer into X/Mesa's back XImage. 2223 */ 2224static void FXgetImage( XMesaBuffer b ) 2225{ 2226 GET_CURRENT_CONTEXT(ctx); 2227 static unsigned short pixbuf[MAX_WIDTH]; 2228 GLuint x, y; 2229 int xpos, ypos; 2230 XMesaWindow root; 2231 unsigned int bw, depth, width, height; 2232 XMesaContext xmesa = XMESA_CONTEXT(ctx); 2233 2234#ifdef XFree86Server 2235 x = b->frontxrb->pixmap->x; 2236 y = b->frontxrb->pixmap->y; 2237 width = b->frontxrb->pixmap->width; 2238 height = b->frontxrb->pixmap->height; 2239 depth = b->frontxrb->pixmap->depth; 2240#else 2241 XGetGeometry( b->xm_visual->display, b->frontxrb->pixmap, 2242 &root, &xpos, &ypos, &width, &height, &bw, &depth); 2243#endif 2244 if (b->mesa_buffer.Width != width || b->mesa_buffer.Height != height) { 2245 b->mesa_buffer.Width = MIN2((int)width, b->FXctx->width); 2246 b->mesa_buffer.Height = MIN2((int)height, b->FXctx->height); 2247 if (b->mesa_buffer.Width & 1) 2248 b->mesa_buffer.Width--; /* prevent odd width */ 2249 xmesa_alloc_back_buffer(b, b->mesa_buffer.Width, b->mesa_buffer.Height); 2250 } 2251 2252 /* [dBorca] we're always in the right GR_COLORFORMAT... aren't we? */ 2253 /* grLfbWriteColorFormat(GR_COLORFORMAT_ARGB); */ 2254 if (b->xm_visual->undithered_pf==PF_5R6G5B) { 2255 /* Special case: 16bpp RGB */ 2256 grLfbReadRegion( GR_BUFFER_FRONTBUFFER, /* src buffer */ 2257 0, b->FXctx->height - b->mesa_buffer.Height, /*pos*/ 2258 b->mesa_buffer.Width, b->mesa_buffer.Height, /* size */ 2259 b->mesa_buffer.Width * sizeof(GLushort), /* stride */ 2260 b->backxrb->ximage->data); /* dest buffer */ 2261 } 2262 else if (b->xm_visual->dithered_pf==PF_Dither 2263 && GET_VISUAL_DEPTH(b->xm_visual)==8) { 2264 /* Special case: 8bpp RGB */ 2265 for (y=0;y<b->mesa_buffer.Height;y++) { 2266 GLubyte *ptr = (GLubyte*) b->backxrb->ximage->data 2267 + b->backxrb->ximage->bytes_per_line * y; 2268 XDITHER_SETUP(y); 2269 2270 /* read row from 3Dfx frame buffer */ 2271 grLfbReadRegion( GR_BUFFER_FRONTBUFFER, 2272 0, b->FXctx->height-(b->mesa_buffer.Height-y), 2273 b->mesa_buffer.Width, 1, 2274 0, 2275 pixbuf ); 2276 2277 /* write to XImage back buffer */ 2278 for (x=0;x<b->mesa_buffer.Width;x++) { 2279 GLubyte r = (pixbuf[x] & 0xf800) >> 8; 2280 GLubyte g = (pixbuf[x] & 0x07e0) >> 3; 2281 GLubyte b = (pixbuf[x] & 0x001f) << 3; 2282 *ptr++ = XDITHER( x, r, g, b); 2283 } 2284 } 2285 } 2286 else { 2287 /* General case: slow! */ 2288 for (y=0;y<b->mesa_buffer.Height;y++) { 2289 /* read row from 3Dfx frame buffer */ 2290 grLfbReadRegion( GR_BUFFER_FRONTBUFFER, 2291 0, b->FXctx->height-(b->mesa_buffer.Height-y), 2292 b->mesa_buffer.Width, 1, 2293 0, 2294 pixbuf ); 2295 2296 /* write to XImage back buffer */ 2297 for (x=0;x<b->mesa_buffer.Width;x++) { 2298 XMesaPutPixel(b->backxrb->ximage,x,y, 2299 xmesa_color_to_pixel(ctx, 2300 (pixbuf[x] & 0xf800) >> 8, 2301 (pixbuf[x] & 0x07e0) >> 3, 2302 (pixbuf[x] & 0x001f) << 3, 2303 0xff, 2304 b->xm_visual->undithered_pf)); 2305 } 2306 } 2307 } 2308 /* grLfbWriteColorFormat(GR_COLORFORMAT_ABGR); */ 2309} 2310#endif 2311 2312 2313/* 2314 * Copy the back buffer to the front buffer. If there's no back buffer 2315 * this is a no-op. 2316 */ 2317void XMesaSwapBuffers( XMesaBuffer b ) 2318{ 2319 GET_CURRENT_CONTEXT(ctx); 2320 2321 /* If we're swapping the buffer associated with the current context 2322 * we have to flush any pending rendering commands first. 2323 */ 2324 if (ctx && ctx->DrawBuffer == &(b->mesa_buffer)) 2325 _mesa_notifySwapBuffers(ctx); 2326 2327 if (b->db_state) { 2328#ifdef FX 2329 if (b->FXctx) { 2330 fxMesaSwapBuffers(); 2331 2332 if (b->FXwindowHack) 2333 FXgetImage(b); 2334 else 2335 return; 2336 } 2337#endif 2338 if (b->backxrb->ximage) { 2339 /* Copy Ximage from host's memory to server's window */ 2340#if defined(USE_XSHM) && !defined(XFree86Server) 2341 if (b->shm) { 2342 /*_glthread_LOCK_MUTEX(_xmesa_lock);*/ 2343 XShmPutImage( b->xm_visual->display, b->frontxrb->pixmap, 2344 b->swapgc, 2345 b->backxrb->ximage, 0, 0, 2346 0, 0, b->mesa_buffer.Width, b->mesa_buffer.Height, 2347 False ); 2348 /*_glthread_UNLOCK_MUTEX(_xmesa_lock);*/ 2349 } 2350 else 2351#endif 2352 { 2353 /*_glthread_LOCK_MUTEX(_xmesa_lock);*/ 2354 XMesaPutImage( b->xm_visual->display, b->frontxrb->pixmap, 2355 b->swapgc, 2356 b->backxrb->ximage, 0, 0, 2357 0, 0, b->mesa_buffer.Width, b->mesa_buffer.Height ); 2358 /*_glthread_UNLOCK_MUTEX(_xmesa_lock);*/ 2359 } 2360 } 2361 else { 2362 /* Copy pixmap to window on server */ 2363 /*_glthread_LOCK_MUTEX(_xmesa_lock);*/ 2364 XMesaCopyArea( b->xm_visual->display, 2365 b->backxrb->pixmap, /* source drawable */ 2366 b->frontxrb->pixmap, /* dest. drawable */ 2367 b->swapgc, 2368 0, 0, b->mesa_buffer.Width, b->mesa_buffer.Height, 2369 0, 0 /* dest region */ 2370 ); 2371 /*_glthread_UNLOCK_MUTEX(_xmesa_lock);*/ 2372 } 2373 } 2374#if !defined(XFree86Server) 2375 XSync( b->xm_visual->display, False ); 2376#endif 2377} 2378 2379 2380 2381/* 2382 * Copy sub-region of back buffer to front buffer 2383 */ 2384void XMesaCopySubBuffer( XMesaBuffer b, int x, int y, int width, int height ) 2385{ 2386 GET_CURRENT_CONTEXT(ctx); 2387 2388 /* If we're swapping the buffer associated with the current context 2389 * we have to flush any pending rendering commands first. 2390 */ 2391 if (ctx && ctx->DrawBuffer == &(b->mesa_buffer)) 2392 _mesa_notifySwapBuffers(ctx); 2393 2394 if (b->db_state) { 2395 int yTop = b->mesa_buffer.Height - y - height; 2396#ifdef FX 2397 if (b->FXctx) { 2398 fxMesaSwapBuffers(); 2399 if (b->FXwindowHack) 2400 FXgetImage(b); 2401 else 2402 return; 2403 } 2404#endif 2405 if (b->backxrb->ximage) { 2406 /* Copy Ximage from host's memory to server's window */ 2407#if defined(USE_XSHM) && !defined(XFree86Server) 2408 if (b->shm) { 2409 /* XXX assuming width and height aren't too large! */ 2410 XShmPutImage( b->xm_visual->display, b->frontxrb->pixmap, 2411 b->swapgc, 2412 b->backxrb->ximage, x, yTop, 2413 x, yTop, width, height, False ); 2414 /* wait for finished event??? */ 2415 } 2416 else 2417#endif 2418 { 2419 /* XXX assuming width and height aren't too large! */ 2420 XMesaPutImage( b->xm_visual->display, b->frontxrb->pixmap, 2421 b->swapgc, 2422 b->backxrb->ximage, x, yTop, 2423 x, yTop, width, height ); 2424 } 2425 } 2426 else { 2427 /* Copy pixmap to window on server */ 2428 XMesaCopyArea( b->xm_visual->display, 2429 b->backxrb->pixmap, /* source drawable */ 2430 b->frontxrb->pixmap, /* dest. drawable */ 2431 b->swapgc, 2432 x, yTop, width, height, /* source region */ 2433 x, yTop /* dest region */ 2434 ); 2435 } 2436 } 2437} 2438 2439 2440/* 2441 * Return a pointer to the XMesa backbuffer Pixmap or XImage. This function 2442 * is a way to get "under the hood" of X/Mesa so one can manipulate the 2443 * back buffer directly. 2444 * Output: pixmap - pointer to back buffer's Pixmap, or 0 2445 * ximage - pointer to back buffer's XImage, or NULL 2446 * Return: GL_TRUE = context is double buffered 2447 * GL_FALSE = context is single buffered 2448 */ 2449GLboolean XMesaGetBackBuffer( XMesaBuffer b, 2450 XMesaPixmap *pixmap, 2451 XMesaImage **ximage ) 2452{ 2453 if (b->db_state) { 2454 if (pixmap) *pixmap = b->backxrb->pixmap; 2455 if (ximage) *ximage = b->backxrb->ximage; 2456 return GL_TRUE; 2457 } 2458 else { 2459 *pixmap = 0; 2460 *ximage = NULL; 2461 return GL_FALSE; 2462 } 2463} 2464 2465 2466/* 2467 * Return the depth buffer associated with an XMesaBuffer. 2468 * Input: b - the XMesa buffer handle 2469 * Output: width, height - size of buffer in pixels 2470 * bytesPerValue - bytes per depth value (2 or 4) 2471 * buffer - pointer to depth buffer values 2472 * Return: GL_TRUE or GL_FALSE to indicate success or failure. 2473 */ 2474GLboolean XMesaGetDepthBuffer( XMesaBuffer b, GLint *width, GLint *height, 2475 GLint *bytesPerValue, void **buffer ) 2476{ 2477 struct gl_renderbuffer *rb 2478 = b->mesa_buffer.Attachment[BUFFER_DEPTH].Renderbuffer; 2479 if (!rb || !rb->Data) { 2480 *width = 0; 2481 *height = 0; 2482 *bytesPerValue = 0; 2483 *buffer = 0; 2484 return GL_FALSE; 2485 } 2486 else { 2487 *width = b->mesa_buffer.Width; 2488 *height = b->mesa_buffer.Height; 2489 *bytesPerValue = b->mesa_buffer.Visual.depthBits <= 16 2490 ? sizeof(GLushort) : sizeof(GLuint); 2491 *buffer = rb->Data; 2492 return GL_TRUE; 2493 } 2494} 2495 2496 2497void XMesaFlush( XMesaContext c ) 2498{ 2499 if (c && c->xm_visual) { 2500#ifdef XFree86Server 2501 /* NOT_NEEDED */ 2502#else 2503 XSync( c->xm_visual->display, False ); 2504#endif 2505 } 2506} 2507 2508 2509 2510const char *XMesaGetString( XMesaContext c, int name ) 2511{ 2512 (void) c; 2513 if (name==XMESA_VERSION) { 2514 return "5.0"; 2515 } 2516 else if (name==XMESA_EXTENSIONS) { 2517 return ""; 2518 } 2519 else { 2520 return NULL; 2521 } 2522} 2523 2524 2525 2526XMesaBuffer XMesaFindBuffer( XMesaDisplay *dpy, XMesaDrawable d ) 2527{ 2528 XMesaBuffer b; 2529 for (b=XMesaBufferList; b; b=b->Next) { 2530 if (b->frontxrb->pixmap==d && b->display==dpy) { 2531 return b; 2532 } 2533 } 2534 return NULL; 2535} 2536 2537 2538 2539/* 2540 * Look for XMesaBuffers whose X window has been destroyed. 2541 * Deallocate any such XMesaBuffers. 2542 */ 2543void XMesaGarbageCollect( void ) 2544{ 2545 XMesaBuffer b, next; 2546 for (b=XMesaBufferList; b; b=next) { 2547 next = b->Next; 2548 if (b->display && b->frontxrb->pixmap && b->type == WINDOW) { 2549#ifdef XFree86Server 2550 /* NOT_NEEDED */ 2551#else 2552 XSync(b->display, False); 2553 if (!window_exists( b->display, b->frontxrb->pixmap )) { 2554 /* found a dead window, free the ancillary info */ 2555 XMesaDestroyBuffer( b ); 2556 } 2557#endif 2558 } 2559 } 2560} 2561 2562 2563void XMesaReset( void ) 2564{ 2565 while (XMesaBufferList) 2566 XMesaDestroyBuffer(XMesaBufferList); 2567 2568 XMesaBufferList = NULL; 2569} 2570 2571 2572unsigned long XMesaDitherColor( XMesaContext xmesa, GLint x, GLint y, 2573 GLfloat red, GLfloat green, 2574 GLfloat blue, GLfloat alpha ) 2575{ 2576 GLcontext *ctx = &xmesa->mesa; 2577 GLint r = (GLint) (red * 255.0F); 2578 GLint g = (GLint) (green * 255.0F); 2579 GLint b = (GLint) (blue * 255.0F); 2580 GLint a = (GLint) (alpha * 255.0F); 2581 2582 switch (xmesa->pixelformat) { 2583 case PF_Index: 2584 return 0; 2585 case PF_Truecolor: 2586 { 2587 unsigned long p; 2588 PACK_TRUECOLOR( p, r, g, b ); 2589 return p; 2590 } 2591 case PF_8A8B8G8R: 2592 return PACK_8A8B8G8R( r, g, b, a ); 2593 case PF_8A8R8G8B: 2594 return PACK_8A8R8G8B( r, g, b, a ); 2595 case PF_8R8G8B: 2596 return PACK_8R8G8B( r, g, b ); 2597 case PF_5R6G5B: 2598 return PACK_5R6G5B( r, g, b ); 2599 case PF_Dither: 2600 { 2601 DITHER_SETUP; 2602 return DITHER( x, y, r, g, b ); 2603 } 2604 case PF_1Bit: 2605 /* 382 = (3*255)/2 */ 2606 return ((r+g+b) > 382) ^ xmesa->xm_visual->bitFlip; 2607 case PF_HPCR: 2608 return DITHER_HPCR(x, y, r, g, b); 2609 case PF_Lookup: 2610 { 2611 LOOKUP_SETUP; 2612 return LOOKUP( r, g, b ); 2613 } 2614 case PF_Grayscale: 2615 return GRAY_RGB( r, g, b ); 2616 case PF_Dither_5R6G5B: 2617 /* fall through */ 2618 case PF_Dither_True: 2619 { 2620 unsigned long p; 2621 PACK_TRUEDITHER(p, x, y, r, g, b); 2622 return p; 2623 } 2624 default: 2625 _mesa_problem(NULL, "Bad pixel format in XMesaDitherColor"); 2626 } 2627 return 0; 2628} 2629 2630 2631/* 2632 * This is typically called when the window size changes and we need 2633 * to reallocate the buffer's back/depth/stencil/accum buffers. 2634 */ 2635void XMesaResizeBuffers( XMesaBuffer b ) 2636{ 2637#if OLD_RENDERBUFFER && 0 2638 xmesa_resize_buffers(ctx, &(b->mesa_buffer), 0, 0 ); 2639#endif 2640} 2641 2642