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