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