xm_api.c revision 5d2fad5444ebe0e2a66c49bd6254e2bc81618f6e 
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 *
39 * Byte swapping:  If the Mesa host and the X display use a different
40 * byte order then there's some trickiness to be aware of when using
41 * XImages.  The byte ordering used for the XImage is that of the X
42 * display, not the Mesa host.
43 * The color-to-pixel encoding for True/DirectColor must be done
44 * according to the display's visual red_mask, green_mask, and blue_mask.
45 * If XPutPixel is used to put a pixel into an XImage then XPutPixel will
46 * do byte swapping if needed.  If one wants to directly "poke" the pixel
47 * into the XImage's buffer then the pixel must be byte swapped first.
48 *
49 */
50
51#ifdef __CYGWIN__
52#undef WIN32
53#undef __WIN32__
54#endif
55
56#include "xm_api.h"
57#include "xm_st.h"
58
59#include "pipe/p_defines.h"
60#include "pipe/p_screen.h"
61#include "pipe/p_context.h"
62#include "util/u_atomic.h"
63
64#include "xm_public.h"
65#include <GL/glx.h>
66
67
68/* Driver interface routines, set up by xlib backend on library
69 * _init().  These are global in the same way that function names are
70 * global.
71 */
72static struct xm_driver driver;
73static struct st_api *stapi;
74
75/* Default strict invalidate to false.  This means we will not call
76 * XGetGeometry after every swapbuffers, which allows swapbuffers to
77 * remain asynchronous.  For apps running at 100fps with synchronous
78 * swapping, a 10% boost is typical.  For gears, I see closer to 20%
79 * speedup.
80 *
81 * Note that the work of copying data on swapbuffers doesn't disappear
82 * - this change just allows the X server to execute the PutImage
83 * asynchronously without us effectively blocked until its completion.
84 *
85 * This speeds up even llvmpipe's threaded rasterization as the
86 * swapbuffers operation was a large part of the serial component of
87 * an llvmpipe frame.
88 *
89 * The downside of this is correctness - applications which don't call
90 * glViewport on window resizes will get incorrect rendering.  A
91 * better solution would be to have per-frame but asynchronous
92 * invalidation.  Xcb almost looks as if it could provide this, but
93 * the API doesn't seem to quite be there.
94 */
95boolean xmesa_strict_invalidate = FALSE;
96
97void xmesa_set_driver( const struct xm_driver *templ )
98{
99   driver = *templ;
100   stapi = driver.create_st_api();
101
102   xmesa_strict_invalidate =
103      debug_get_bool_option("XMESA_STRICT_INVALIDATE", FALSE);
104}
105
106
107/*
108 * XXX replace this with a linked list, or better yet, try to attach the
109 * gallium/mesa extra bits to the X Display object with XAddExtension().
110 */
111#define MAX_DISPLAYS 10
112static struct xmesa_display Displays[MAX_DISPLAYS];
113static int NumDisplays = 0;
114
115static int
116xmesa_get_param(struct st_manager *smapi,
117                enum st_manager_param param)
118{
119   switch(param) {
120   case ST_MANAGER_BROKEN_INVALIDATE:
121      return !xmesa_strict_invalidate;
122   default:
123      return 0;
124   }
125}
126
127static XMesaDisplay
128xmesa_init_display( Display *display )
129{
130   pipe_static_mutex(init_mutex);
131   XMesaDisplay xmdpy;
132   int i;
133
134   pipe_mutex_lock(init_mutex);
135
136   /* Look for XMesaDisplay which corresponds to 'display' */
137   for (i = 0; i < NumDisplays; i++) {
138      if (Displays[i].display == display) {
139         /* Found it */
140         pipe_mutex_unlock(init_mutex);
141         return &Displays[i];
142      }
143   }
144
145   /* Create new XMesaDisplay */
146
147   assert(NumDisplays < MAX_DISPLAYS);
148   xmdpy = &Displays[NumDisplays];
149   NumDisplays++;
150
151   if (!xmdpy->display && display) {
152      xmdpy->display = display;
153      xmdpy->screen = driver.create_pipe_screen(display);
154      xmdpy->smapi = CALLOC_STRUCT(st_manager);
155      if (xmdpy->smapi) {
156         xmdpy->smapi->screen = xmdpy->screen;
157         xmdpy->smapi->get_param = xmesa_get_param;
158      }
159
160      if (xmdpy->screen && xmdpy->smapi) {
161         pipe_mutex_init(xmdpy->mutex);
162      }
163      else {
164         if (xmdpy->screen) {
165            xmdpy->screen->destroy(xmdpy->screen);
166            xmdpy->screen = NULL;
167         }
168         if (xmdpy->smapi) {
169            FREE(xmdpy->smapi);
170            xmdpy->smapi = NULL;
171         }
172
173         xmdpy->display = NULL;
174      }
175   }
176   if (!xmdpy->display || xmdpy->display != display)
177      xmdpy = NULL;
178
179   pipe_mutex_unlock(init_mutex);
180
181   return xmdpy;
182}
183
184/**********************************************************************/
185/*****                     X Utility Functions                    *****/
186/**********************************************************************/
187
188
189/**
190 * Return the host's byte order as LSBFirst or MSBFirst ala X.
191 */
192static int host_byte_order( void )
193{
194   int i = 1;
195   char *cptr = (char *) &i;
196   return (*cptr==1) ? LSBFirst : MSBFirst;
197}
198
199
200
201
202/**
203 * Return the true number of bits per pixel for XImages.
204 * For example, if we request a 24-bit deep visual we may actually need/get
205 * 32bpp XImages.  This function returns the appropriate bpp.
206 * Input:  dpy - the X display
207 *         visinfo - desribes the visual to be used for XImages
208 * Return:  true number of bits per pixel for XImages
209 */
210static int
211bits_per_pixel( XMesaVisual xmv )
212{
213   Display *dpy = xmv->display;
214   XVisualInfo * visinfo = xmv->visinfo;
215   XImage *img;
216   int bitsPerPixel;
217   /* Create a temporary XImage */
218   img = XCreateImage( dpy, visinfo->visual, visinfo->depth,
219		       ZPixmap, 0,           /*format, offset*/
220		       (char*) MALLOC(8),    /*data*/
221		       1, 1,                 /*width, height*/
222		       32,                   /*bitmap_pad*/
223		       0                     /*bytes_per_line*/
224                     );
225   assert(img);
226   /* grab the bits/pixel value */
227   bitsPerPixel = img->bits_per_pixel;
228   /* free the XImage */
229   free( img->data );
230   img->data = NULL;
231   XDestroyImage( img );
232   return bitsPerPixel;
233}
234
235
236
237/*
238 * Determine if a given X window ID is valid (window exists).
239 * Do this by calling XGetWindowAttributes() for the window and
240 * checking if we catch an X error.
241 * Input:  dpy - the display
242 *         win - the window to check for existance
243 * Return:  GL_TRUE - window exists
244 *          GL_FALSE - window doesn't exist
245 */
246static GLboolean WindowExistsFlag;
247
248static int window_exists_err_handler( Display* dpy, XErrorEvent* xerr )
249{
250   (void) dpy;
251   if (xerr->error_code == BadWindow) {
252      WindowExistsFlag = GL_FALSE;
253   }
254   return 0;
255}
256
257static GLboolean window_exists( Display *dpy, Window win )
258{
259   XWindowAttributes wa;
260   int (*old_handler)( Display*, XErrorEvent* );
261   WindowExistsFlag = GL_TRUE;
262   old_handler = XSetErrorHandler(window_exists_err_handler);
263   XGetWindowAttributes( dpy, win, &wa ); /* dummy request */
264   XSetErrorHandler(old_handler);
265   return WindowExistsFlag;
266}
267
268static Status
269get_drawable_size( Display *dpy, Drawable d, uint *width, uint *height )
270{
271   Window root;
272   Status stat;
273   int xpos, ypos;
274   unsigned int w, h, bw, depth;
275   stat = XGetGeometry(dpy, d, &root, &xpos, &ypos, &w, &h, &bw, &depth);
276   *width = w;
277   *height = h;
278   return stat;
279}
280
281
282/**
283 * Return the size of the window (or pixmap) that corresponds to the
284 * given XMesaBuffer.
285 * \param width  returns width in pixels
286 * \param height  returns height in pixels
287 */
288void
289xmesa_get_window_size(Display *dpy, XMesaBuffer b,
290                      GLuint *width, GLuint *height)
291{
292   XMesaDisplay xmdpy = xmesa_init_display(dpy);
293   Status stat;
294
295   pipe_mutex_lock(xmdpy->mutex);
296   stat = get_drawable_size(dpy, b->ws.drawable, width, height);
297   pipe_mutex_unlock(xmdpy->mutex);
298
299   if (!stat) {
300      /* probably querying a window that's recently been destroyed */
301      _mesa_warning(NULL, "XGetGeometry failed!\n");
302      *width = *height = 1;
303   }
304}
305
306#define GET_REDMASK(__v)        __v->mesa_visual.redMask
307#define GET_GREENMASK(__v)      __v->mesa_visual.greenMask
308#define GET_BLUEMASK(__v)       __v->mesa_visual.blueMask
309
310
311/**
312 * Choose the pixel format for the given visual.
313 * This will tell the gallium driver how to pack pixel data into
314 * drawing surfaces.
315 */
316static GLuint
317choose_pixel_format(XMesaVisual v)
318{
319   boolean native_byte_order = (host_byte_order() ==
320                                ImageByteOrder(v->display));
321
322   if (   GET_REDMASK(v)   == 0x0000ff
323       && GET_GREENMASK(v) == 0x00ff00
324       && GET_BLUEMASK(v)  == 0xff0000
325       && v->BitsPerPixel == 32) {
326      if (native_byte_order) {
327         /* no byteswapping needed */
328         return PIPE_FORMAT_R8G8B8A8_UNORM;
329      }
330      else {
331         return PIPE_FORMAT_A8B8G8R8_UNORM;
332      }
333   }
334   else if (   GET_REDMASK(v)   == 0xff0000
335            && GET_GREENMASK(v) == 0x00ff00
336            && GET_BLUEMASK(v)  == 0x0000ff
337            && v->BitsPerPixel == 32) {
338      if (native_byte_order) {
339         /* no byteswapping needed */
340         return PIPE_FORMAT_B8G8R8A8_UNORM;
341      }
342      else {
343         return PIPE_FORMAT_A8R8G8B8_UNORM;
344      }
345   }
346   else if (   GET_REDMASK(v)   == 0x0000ff00
347            && GET_GREENMASK(v) == 0x00ff0000
348            && GET_BLUEMASK(v)  == 0xff000000
349            && v->BitsPerPixel == 32) {
350      if (native_byte_order) {
351         /* no byteswapping needed */
352         return PIPE_FORMAT_A8R8G8B8_UNORM;
353      }
354      else {
355         return PIPE_FORMAT_B8G8R8A8_UNORM;
356      }
357   }
358   else if (   GET_REDMASK(v)   == 0xf800
359            && GET_GREENMASK(v) == 0x07e0
360            && GET_BLUEMASK(v)  == 0x001f
361            && native_byte_order
362            && v->BitsPerPixel == 16) {
363      /* 5-6-5 RGB */
364      return PIPE_FORMAT_B5G6R5_UNORM;
365   }
366
367   return PIPE_FORMAT_NONE;
368}
369
370
371/**
372 * Choose a depth/stencil format that satisfies the given depth and
373 * stencil sizes.
374 */
375static enum pipe_format
376choose_depth_stencil_format(XMesaDisplay xmdpy, int depth, int stencil)
377{
378   const enum pipe_texture_target target = PIPE_TEXTURE_2D;
379   const unsigned tex_usage = PIPE_BIND_DEPTH_STENCIL;
380   const unsigned sample_count = 0;
381   enum pipe_format formats[8], fmt;
382   int count, i;
383
384   count = 0;
385
386   if (depth <= 16 && stencil == 0) {
387      formats[count++] = PIPE_FORMAT_Z16_UNORM;
388   }
389   if (depth <= 24 && stencil == 0) {
390      formats[count++] = PIPE_FORMAT_X8Z24_UNORM;
391      formats[count++] = PIPE_FORMAT_Z24X8_UNORM;
392   }
393   if (depth <= 24 && stencil <= 8) {
394      formats[count++] = PIPE_FORMAT_S8_USCALED_Z24_UNORM;
395      formats[count++] = PIPE_FORMAT_Z24_UNORM_S8_USCALED;
396   }
397   if (depth <= 32 && stencil == 0) {
398      formats[count++] = PIPE_FORMAT_Z32_UNORM;
399   }
400
401   fmt = PIPE_FORMAT_NONE;
402   for (i = 0; i < count; i++) {
403      if (xmdpy->screen->is_format_supported(xmdpy->screen, formats[i],
404                                             target, sample_count,
405                                             tex_usage)) {
406         fmt = formats[i];
407         break;
408      }
409   }
410
411   return fmt;
412}
413
414
415
416/**********************************************************************/
417/*****                Linked list of XMesaBuffers                 *****/
418/**********************************************************************/
419
420static XMesaBuffer XMesaBufferList = NULL;
421
422
423/**
424 * Allocate a new XMesaBuffer object which corresponds to the given drawable.
425 * Note that XMesaBuffer is derived from struct gl_framebuffer.
426 * The new XMesaBuffer will not have any size (Width=Height=0).
427 *
428 * \param d  the corresponding X drawable (window or pixmap)
429 * \param type  either WINDOW, PIXMAP or PBUFFER, describing d
430 * \param vis  the buffer's visual
431 * \param cmap  the window's colormap, if known.
432 * \return new XMesaBuffer or NULL if any problem
433 */
434static XMesaBuffer
435create_xmesa_buffer(Drawable d, BufferType type,
436                    XMesaVisual vis, Colormap cmap)
437{
438   XMesaDisplay xmdpy = xmesa_init_display(vis->display);
439   XMesaBuffer b;
440   uint width, height;
441
442   ASSERT(type == WINDOW || type == PIXMAP || type == PBUFFER);
443
444   if (!xmdpy)
445      return NULL;
446
447   b = (XMesaBuffer) CALLOC_STRUCT(xmesa_buffer);
448   if (!b)
449      return NULL;
450
451   b->ws.drawable = d;
452   b->ws.visual = vis->visinfo->visual;
453   b->ws.depth = vis->visinfo->depth;
454
455   b->xm_visual = vis;
456   b->type = type;
457   b->cmap = cmap;
458
459   get_drawable_size(vis->display, d, &width, &height);
460
461   /*
462    * Create framebuffer, but we'll plug in our own renderbuffers below.
463    */
464   b->stfb = xmesa_create_st_framebuffer(xmdpy, b);
465
466   /* GLX_EXT_texture_from_pixmap */
467   b->TextureTarget = 0;
468   b->TextureFormat = GLX_TEXTURE_FORMAT_NONE_EXT;
469   b->TextureMipmap = 0;
470
471   /* insert buffer into linked list */
472   b->Next = XMesaBufferList;
473   XMesaBufferList = b;
474
475   return b;
476}
477
478
479/**
480 * Find an XMesaBuffer by matching X display and colormap but NOT matching
481 * the notThis buffer.
482 */
483XMesaBuffer
484xmesa_find_buffer(Display *dpy, Colormap cmap, XMesaBuffer notThis)
485{
486   XMesaBuffer b;
487   for (b = XMesaBufferList; b; b = b->Next) {
488      if (b->xm_visual->display == dpy &&
489          b->cmap == cmap &&
490          b != notThis) {
491         return b;
492      }
493   }
494   return NULL;
495}
496
497
498/**
499 * Remove buffer from linked list, delete if no longer referenced.
500 */
501static void
502xmesa_free_buffer(XMesaBuffer buffer)
503{
504   XMesaBuffer prev = NULL, b;
505
506   for (b = XMesaBufferList; b; b = b->Next) {
507      if (b == buffer) {
508         /* unlink buffer from list */
509         if (prev)
510            prev->Next = buffer->Next;
511         else
512            XMesaBufferList = buffer->Next;
513
514         /* Since the X window for the XMesaBuffer is going away, we don't
515          * want to dereference this pointer in the future.
516          */
517         b->ws.drawable = 0;
518
519         /* XXX we should move the buffer to a delete-pending list and destroy
520          * the buffer until it is no longer current.
521          */
522         xmesa_destroy_st_framebuffer(buffer->stfb);
523
524         free(buffer);
525
526         return;
527      }
528      /* continue search */
529      prev = b;
530   }
531   /* buffer not found in XMesaBufferList */
532   _mesa_problem(NULL,"xmesa_free_buffer() - buffer not found\n");
533}
534
535
536
537/**********************************************************************/
538/*****                   Misc Private Functions                   *****/
539/**********************************************************************/
540
541
542/**
543 * When a context is bound for the first time, we can finally finish
544 * initializing the context's visual and buffer information.
545 * \param v  the XMesaVisual to initialize
546 * \param b  the XMesaBuffer to initialize (may be NULL)
547 * \param rgb_flag  TRUE = RGBA mode, FALSE = color index mode
548 * \param window  the window/pixmap we're rendering into
549 * \param cmap  the colormap associated with the window/pixmap
550 * \return GL_TRUE=success, GL_FALSE=failure
551 */
552static GLboolean
553initialize_visual_and_buffer(XMesaVisual v, XMesaBuffer b,
554                             GLboolean rgb_flag, Drawable window,
555                             Colormap cmap)
556{
557   ASSERT(!b || b->xm_visual == v);
558
559   /* Save true bits/pixel */
560   v->BitsPerPixel = bits_per_pixel(v);
561   assert(v->BitsPerPixel > 0);
562
563   if (rgb_flag == GL_FALSE) {
564      /* COLOR-INDEXED WINDOW: not supported*/
565      return GL_FALSE;
566   }
567   else {
568      /* RGB WINDOW:
569       * We support RGB rendering into almost any kind of visual.
570       */
571      const int xclass = v->visualType;
572      if (xclass != GLX_TRUE_COLOR && xclass == !GLX_DIRECT_COLOR) {
573	 _mesa_warning(NULL,
574            "XMesa: RGB mode rendering not supported in given visual.\n");
575	 return GL_FALSE;
576      }
577      v->mesa_visual.indexBits = 0;
578
579      if (v->BitsPerPixel == 32) {
580         /* We use XImages for all front/back buffers.  If an X Window or
581          * X Pixmap is 32bpp, there's no guarantee that the alpha channel
582          * will be preserved.  For XImages we're in luck.
583          */
584         v->mesa_visual.alphaBits = 8;
585      }
586   }
587
588   /*
589    * If MESA_INFO env var is set print out some debugging info
590    * which can help Brian figure out what's going on when a user
591    * reports bugs.
592    */
593   if (_mesa_getenv("MESA_INFO")) {
594      printf("X/Mesa visual = %p\n", (void *) v);
595      printf("X/Mesa level = %d\n", v->mesa_visual.level);
596      printf("X/Mesa depth = %d\n", v->visinfo->depth);
597      printf("X/Mesa bits per pixel = %d\n", v->BitsPerPixel);
598   }
599
600   return GL_TRUE;
601}
602
603
604
605#define NUM_VISUAL_TYPES   6
606
607/**
608 * Convert an X visual type to a GLX visual type.
609 *
610 * \param visualType X visual type (i.e., \c TrueColor, \c StaticGray, etc.)
611 *        to be converted.
612 * \return If \c visualType is a valid X visual type, a GLX visual type will
613 *         be returned.  Otherwise \c GLX_NONE will be returned.
614 *
615 * \note
616 * This code was lifted directly from lib/GL/glx/glcontextmodes.c in the
617 * DRI CVS tree.
618 */
619static GLint
620xmesa_convert_from_x_visual_type( int visualType )
621{
622    static const int glx_visual_types[ NUM_VISUAL_TYPES ] = {
623	GLX_STATIC_GRAY,  GLX_GRAY_SCALE,
624	GLX_STATIC_COLOR, GLX_PSEUDO_COLOR,
625	GLX_TRUE_COLOR,   GLX_DIRECT_COLOR
626    };
627
628    return ( (unsigned) visualType < NUM_VISUAL_TYPES )
629	? glx_visual_types[ visualType ] : GLX_NONE;
630}
631
632
633/**********************************************************************/
634/*****                       Public Functions                     *****/
635/**********************************************************************/
636
637
638/*
639 * Create a new X/Mesa visual.
640 * Input:  display - X11 display
641 *         visinfo - an XVisualInfo pointer
642 *         rgb_flag - GL_TRUE = RGB mode,
643 *                    GL_FALSE = color index mode
644 *         alpha_flag - alpha buffer requested?
645 *         db_flag - GL_TRUE = double-buffered,
646 *                   GL_FALSE = single buffered
647 *         stereo_flag - stereo visual?
648 *         ximage_flag - GL_TRUE = use an XImage for back buffer,
649 *                       GL_FALSE = use an off-screen pixmap for back buffer
650 *         depth_size - requested bits/depth values, or zero
651 *         stencil_size - requested bits/stencil values, or zero
652 *         accum_red_size - requested bits/red accum values, or zero
653 *         accum_green_size - requested bits/green accum values, or zero
654 *         accum_blue_size - requested bits/blue accum values, or zero
655 *         accum_alpha_size - requested bits/alpha accum values, or zero
656 *         num_samples - number of samples/pixel if multisampling, or zero
657 *         level - visual level, usually 0
658 *         visualCaveat - ala the GLX extension, usually GLX_NONE
659 * Return;  a new XMesaVisual or 0 if error.
660 */
661PUBLIC
662XMesaVisual XMesaCreateVisual( Display *display,
663                               XVisualInfo * visinfo,
664                               GLboolean rgb_flag,
665                               GLboolean alpha_flag,
666                               GLboolean db_flag,
667                               GLboolean stereo_flag,
668                               GLboolean ximage_flag,
669                               GLint depth_size,
670                               GLint stencil_size,
671                               GLint accum_red_size,
672                               GLint accum_green_size,
673                               GLint accum_blue_size,
674                               GLint accum_alpha_size,
675                               GLint num_samples,
676                               GLint level,
677                               GLint visualCaveat )
678{
679   XMesaDisplay xmdpy = xmesa_init_display(display);
680   XMesaVisual v;
681   GLint red_bits, green_bits, blue_bits, alpha_bits;
682
683   if (!xmdpy)
684      return NULL;
685
686   /* For debugging only */
687   if (_mesa_getenv("MESA_XSYNC")) {
688      /* This makes debugging X easier.
689       * In your debugger, set a breakpoint on _XError to stop when an
690       * X protocol error is generated.
691       */
692      XSynchronize( display, 1 );
693   }
694
695   v = (XMesaVisual) CALLOC_STRUCT(xmesa_visual);
696   if (!v) {
697      return NULL;
698   }
699
700   v->display = display;
701
702   /* Save a copy of the XVisualInfo struct because the user may Xfree()
703    * the struct but we may need some of the information contained in it
704    * at a later time.
705    */
706   v->visinfo = (XVisualInfo *) MALLOC(sizeof(*visinfo));
707   if (!v->visinfo) {
708      free(v);
709      return NULL;
710   }
711   memcpy(v->visinfo, visinfo, sizeof(*visinfo));
712
713   v->ximage_flag = ximage_flag;
714
715   v->mesa_visual.redMask = visinfo->red_mask;
716   v->mesa_visual.greenMask = visinfo->green_mask;
717   v->mesa_visual.blueMask = visinfo->blue_mask;
718   v->visualID = visinfo->visualid;
719   v->screen = visinfo->screen;
720
721#if !(defined(__cplusplus) || defined(c_plusplus))
722   v->visualType = xmesa_convert_from_x_visual_type(visinfo->class);
723#else
724   v->visualType = xmesa_convert_from_x_visual_type(visinfo->c_class);
725#endif
726
727   v->mesa_visual.visualRating = visualCaveat;
728
729   if (alpha_flag)
730      v->mesa_visual.alphaBits = 8;
731
732   (void) initialize_visual_and_buffer( v, NULL, rgb_flag, 0, 0 );
733
734   {
735      const int xclass = v->visualType;
736      if (xclass == GLX_TRUE_COLOR || xclass == GLX_DIRECT_COLOR) {
737         red_bits   = _mesa_bitcount(GET_REDMASK(v));
738         green_bits = _mesa_bitcount(GET_GREENMASK(v));
739         blue_bits  = _mesa_bitcount(GET_BLUEMASK(v));
740      }
741      else {
742         /* this is an approximation */
743         int depth;
744         depth = v->visinfo->depth;
745         red_bits = depth / 3;
746         depth -= red_bits;
747         green_bits = depth / 2;
748         depth -= green_bits;
749         blue_bits = depth;
750         alpha_bits = 0;
751         assert( red_bits + green_bits + blue_bits == v->visinfo->depth );
752      }
753      alpha_bits = v->mesa_visual.alphaBits;
754   }
755
756   /* initialize visual */
757   {
758      struct gl_config *vis = &v->mesa_visual;
759
760      vis->rgbMode          = GL_TRUE;
761      vis->doubleBufferMode = db_flag;
762      vis->stereoMode       = stereo_flag;
763
764      vis->redBits          = red_bits;
765      vis->greenBits        = green_bits;
766      vis->blueBits         = blue_bits;
767      vis->alphaBits        = alpha_bits;
768      vis->rgbBits          = red_bits + green_bits + blue_bits;
769
770      vis->indexBits      = 0;
771      vis->depthBits      = depth_size;
772      vis->stencilBits    = stencil_size;
773
774      vis->accumRedBits   = accum_red_size;
775      vis->accumGreenBits = accum_green_size;
776      vis->accumBlueBits  = accum_blue_size;
777      vis->accumAlphaBits = accum_alpha_size;
778
779      vis->haveAccumBuffer   = accum_red_size > 0;
780      vis->haveDepthBuffer   = depth_size > 0;
781      vis->haveStencilBuffer = stencil_size > 0;
782
783      vis->numAuxBuffers = 0;
784      vis->level = 0;
785      vis->sampleBuffers = 0;
786      vis->samples = 0;
787   }
788
789   v->stvis.buffer_mask = ST_ATTACHMENT_FRONT_LEFT_MASK;
790   if (db_flag)
791      v->stvis.buffer_mask |= ST_ATTACHMENT_BACK_LEFT_MASK;
792   if (stereo_flag) {
793      v->stvis.buffer_mask |= ST_ATTACHMENT_FRONT_RIGHT_MASK;
794      if (db_flag)
795         v->stvis.buffer_mask |= ST_ATTACHMENT_BACK_RIGHT_MASK;
796   }
797
798   v->stvis.color_format = choose_pixel_format(v);
799   if (v->stvis.color_format == PIPE_FORMAT_NONE) {
800      FREE(v->visinfo);
801      FREE(v);
802      return NULL;
803   }
804
805   v->stvis.depth_stencil_format =
806      choose_depth_stencil_format(xmdpy, depth_size, stencil_size);
807
808   v->stvis.accum_format = (accum_red_size +
809         accum_green_size + accum_blue_size + accum_alpha_size) ?
810      PIPE_FORMAT_R16G16B16A16_SNORM : PIPE_FORMAT_NONE;
811
812   v->stvis.samples = num_samples;
813   v->stvis.render_buffer = ST_ATTACHMENT_INVALID;
814
815   /* XXX minor hack */
816   v->mesa_visual.level = level;
817   return v;
818}
819
820
821PUBLIC
822void XMesaDestroyVisual( XMesaVisual v )
823{
824   free(v->visinfo);
825   free(v);
826}
827
828
829/**
830 * Return the informative name.
831 */
832const char *
833xmesa_get_name(void)
834{
835   return stapi->name;
836}
837
838
839/**
840 * Do per-display initializations.
841 */
842void
843xmesa_init( Display *display )
844{
845   xmesa_init_display(display);
846}
847
848
849/**
850 * Create a new XMesaContext.
851 * \param v  the XMesaVisual
852 * \param share_list  another XMesaContext with which to share display
853 *                    lists or NULL if no sharing is wanted.
854 * \return an XMesaContext or NULL if error.
855 */
856PUBLIC
857XMesaContext XMesaCreateContext( XMesaVisual v, XMesaContext share_list,
858                                 GLuint major, GLuint minor,
859                                 GLuint profileMask, GLuint contextFlags)
860{
861   XMesaDisplay xmdpy = xmesa_init_display(v->display);
862   struct st_context_attribs attribs;
863   XMesaContext c;
864
865   if (!xmdpy)
866      return NULL;
867
868   /* Note: the XMesaContext contains a Mesa struct gl_context struct (inheritance) */
869   c = (XMesaContext) CALLOC_STRUCT(xmesa_context);
870   if (!c)
871      return NULL;
872
873   c->xm_visual = v;
874   c->xm_buffer = NULL;   /* set later by XMesaMakeCurrent */
875   c->xm_read_buffer = NULL;
876
877   memset(&attribs, 0, sizeof(attribs));
878   attribs.profile = ST_PROFILE_DEFAULT;
879   attribs.visual = v->stvis;
880   attribs.major = major;
881   attribs.minor = minor;
882   if (contextFlags & GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB)
883      attribs.flags |= ST_CONTEXT_FLAG_FORWARD_COMPATIBLE;
884   if (contextFlags & GLX_CONTEXT_DEBUG_BIT_ARB)
885      attribs.flags |= ST_CONTEXT_FLAG_DEBUG;
886   if (contextFlags & GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB)
887      attribs.flags |= ST_CONTEXT_FLAG_ROBUST_ACCESS;
888   if (profileMask & GLX_CONTEXT_CORE_PROFILE_BIT_ARB)
889      attribs.flags |= ST_CONTEXT_FLAG_CORE_PROFILE;
890   if (profileMask & GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB)
891      attribs.flags |= ST_CONTEXT_FLAG_COMPATIBLE_PROFILE;
892
893   c->st = stapi->create_context(stapi, xmdpy->smapi,
894         &attribs, (share_list) ? share_list->st : NULL);
895   if (c->st == NULL)
896      goto fail;
897
898   c->st->st_manager_private = (void *) c;
899
900   return c;
901
902fail:
903   if (c->st)
904      c->st->destroy(c->st);
905
906   free(c);
907   return NULL;
908}
909
910
911
912PUBLIC
913void XMesaDestroyContext( XMesaContext c )
914{
915   c->st->destroy(c->st);
916
917   /* FIXME: We should destroy the screen here, but if we do so, surfaces may
918    * outlive it, causing segfaults
919   struct pipe_screen *screen = c->st->pipe->screen;
920   screen->destroy(screen);
921   */
922
923   free(c);
924}
925
926
927
928/**
929 * Private function for creating an XMesaBuffer which corresponds to an
930 * X window or pixmap.
931 * \param v  the window's XMesaVisual
932 * \param w  the window we're wrapping
933 * \return  new XMesaBuffer or NULL if error
934 */
935PUBLIC XMesaBuffer
936XMesaCreateWindowBuffer(XMesaVisual v, Window w)
937{
938   XWindowAttributes attr;
939   XMesaBuffer b;
940   Colormap cmap;
941   int depth;
942
943   assert(v);
944   assert(w);
945
946   /* Check that window depth matches visual depth */
947   XGetWindowAttributes( v->display, w, &attr );
948   depth = attr.depth;
949   if (v->visinfo->depth != depth) {
950      _mesa_warning(NULL, "XMesaCreateWindowBuffer: depth mismatch between visual (%d) and window (%d)!\n",
951                    v->visinfo->depth, depth);
952      return NULL;
953   }
954
955   /* Find colormap */
956   if (attr.colormap) {
957      cmap = attr.colormap;
958   }
959   else {
960      _mesa_warning(NULL, "Window %u has no colormap!\n", (unsigned int) w);
961      /* this is weird, a window w/out a colormap!? */
962      /* OK, let's just allocate a new one and hope for the best */
963      cmap = XCreateColormap(v->display, w, attr.visual, AllocNone);
964   }
965
966   b = create_xmesa_buffer((Drawable) w, WINDOW, v, cmap);
967   if (!b)
968      return NULL;
969
970   if (!initialize_visual_and_buffer( v, b, v->mesa_visual.rgbMode,
971                                      (Drawable) w, cmap )) {
972      xmesa_free_buffer(b);
973      return NULL;
974   }
975
976   return b;
977}
978
979
980
981/**
982 * Create a new XMesaBuffer from an X pixmap.
983 *
984 * \param v    the XMesaVisual
985 * \param p    the pixmap
986 * \param cmap the colormap, may be 0 if using a \c GLX_TRUE_COLOR or
987 *             \c GLX_DIRECT_COLOR visual for the pixmap
988 * \returns new XMesaBuffer or NULL if error
989 */
990PUBLIC XMesaBuffer
991XMesaCreatePixmapBuffer(XMesaVisual v, Pixmap p, Colormap cmap)
992{
993   XMesaBuffer b;
994
995   assert(v);
996
997   b = create_xmesa_buffer((Drawable) p, PIXMAP, v, cmap);
998   if (!b)
999      return NULL;
1000
1001   if (!initialize_visual_and_buffer(v, b, v->mesa_visual.rgbMode,
1002				     (Drawable) p, cmap)) {
1003      xmesa_free_buffer(b);
1004      return NULL;
1005   }
1006
1007   return b;
1008}
1009
1010
1011/**
1012 * For GLX_EXT_texture_from_pixmap
1013 */
1014XMesaBuffer
1015XMesaCreatePixmapTextureBuffer(XMesaVisual v, Pixmap p,
1016                               Colormap cmap,
1017                               int format, int target, int mipmap)
1018{
1019   GET_CURRENT_CONTEXT(ctx);
1020   XMesaBuffer b;
1021
1022   assert(v);
1023
1024   b = create_xmesa_buffer((Drawable) p, PIXMAP, v, cmap);
1025   if (!b)
1026      return NULL;
1027
1028   /* get pixmap size */
1029   xmesa_get_window_size(v->display, b, &b->width, &b->height);
1030
1031   if (target == 0) {
1032      /* examine dims */
1033      if (ctx->Extensions.ARB_texture_non_power_of_two) {
1034         target = GLX_TEXTURE_2D_EXT;
1035      }
1036      else if (   _mesa_bitcount(b->width)  == 1
1037               && _mesa_bitcount(b->height) == 1) {
1038         /* power of two size */
1039         if (b->height == 1) {
1040            target = GLX_TEXTURE_1D_EXT;
1041         }
1042         else {
1043            target = GLX_TEXTURE_2D_EXT;
1044         }
1045      }
1046      else if (ctx->Extensions.NV_texture_rectangle) {
1047         target = GLX_TEXTURE_RECTANGLE_EXT;
1048      }
1049      else {
1050         /* non power of two textures not supported */
1051         XMesaDestroyBuffer(b);
1052         return 0;
1053      }
1054   }
1055
1056   b->TextureTarget = target;
1057   b->TextureFormat = format;
1058   b->TextureMipmap = mipmap;
1059
1060   if (!initialize_visual_and_buffer(v, b, v->mesa_visual.rgbMode,
1061				     (Drawable) p, cmap)) {
1062      xmesa_free_buffer(b);
1063      return NULL;
1064   }
1065
1066   return b;
1067}
1068
1069
1070
1071XMesaBuffer
1072XMesaCreatePBuffer(XMesaVisual v, Colormap cmap,
1073                   unsigned int width, unsigned int height)
1074{
1075   Window root;
1076   Drawable drawable;  /* X Pixmap Drawable */
1077   XMesaBuffer b;
1078
1079   /* allocate pixmap for front buffer */
1080   root = RootWindow( v->display, v->visinfo->screen );
1081   drawable = XCreatePixmap(v->display, root, width, height,
1082                            v->visinfo->depth);
1083   if (!drawable)
1084      return NULL;
1085
1086   b = create_xmesa_buffer(drawable, PBUFFER, v, cmap);
1087   if (!b)
1088      return NULL;
1089
1090   if (!initialize_visual_and_buffer(v, b, v->mesa_visual.rgbMode,
1091				     drawable, cmap)) {
1092      xmesa_free_buffer(b);
1093      return NULL;
1094   }
1095
1096   return b;
1097}
1098
1099
1100
1101/*
1102 * Deallocate an XMesaBuffer structure and all related info.
1103 */
1104PUBLIC void
1105XMesaDestroyBuffer(XMesaBuffer b)
1106{
1107   xmesa_free_buffer(b);
1108}
1109
1110
1111/**
1112 * Notify the binding context to validate the buffer.
1113 */
1114void
1115xmesa_notify_invalid_buffer(XMesaBuffer b)
1116{
1117   p_atomic_inc(&b->stfb->stamp);
1118}
1119
1120
1121/**
1122 * Query the current drawable size and notify the binding context.
1123 */
1124void
1125xmesa_check_buffer_size(XMesaBuffer b)
1126{
1127   if (b->type == PBUFFER)
1128      return;
1129
1130   xmesa_get_window_size(b->xm_visual->display, b, &b->width, &b->height);
1131   xmesa_notify_invalid_buffer(b);
1132}
1133
1134
1135/*
1136 * Bind buffer b to context c and make c the current rendering context.
1137 */
1138PUBLIC
1139GLboolean XMesaMakeCurrent2( XMesaContext c, XMesaBuffer drawBuffer,
1140                             XMesaBuffer readBuffer )
1141{
1142   XMesaContext old_ctx = XMesaGetCurrentContext();
1143
1144   if (old_ctx && old_ctx != c) {
1145      XMesaFlush(old_ctx);
1146      old_ctx->xm_buffer = NULL;
1147      old_ctx->xm_read_buffer = NULL;
1148   }
1149
1150   if (c) {
1151      if (!drawBuffer || !readBuffer)
1152         return GL_FALSE;  /* must specify buffers! */
1153
1154      if (c == old_ctx &&
1155	  c->xm_buffer == drawBuffer &&
1156	  c->xm_read_buffer == readBuffer)
1157	 return GL_TRUE;
1158
1159      xmesa_check_buffer_size(drawBuffer);
1160      if (readBuffer != drawBuffer)
1161         xmesa_check_buffer_size(readBuffer);
1162
1163      c->xm_buffer = drawBuffer;
1164      c->xm_read_buffer = readBuffer;
1165
1166      stapi->make_current(stapi, c->st, drawBuffer->stfb, readBuffer->stfb);
1167
1168      /* Solution to Stephane Rehel's problem with glXReleaseBuffersMESA(): */
1169      drawBuffer->wasCurrent = GL_TRUE;
1170   }
1171   else {
1172      /* Detach */
1173      stapi->make_current(stapi, NULL, NULL, NULL);
1174
1175   }
1176   return GL_TRUE;
1177}
1178
1179
1180/*
1181 * Unbind the context c from its buffer.
1182 */
1183GLboolean XMesaUnbindContext( XMesaContext c )
1184{
1185   /* A no-op for XFree86 integration purposes */
1186   return GL_TRUE;
1187}
1188
1189
1190XMesaContext XMesaGetCurrentContext( void )
1191{
1192   struct st_context_iface *st = stapi->get_current(stapi);
1193   return (XMesaContext) (st) ? st->st_manager_private : NULL;
1194}
1195
1196
1197
1198/**
1199 * Swap front and back color buffers and have winsys display front buffer.
1200 * If there's no front color buffer no swap actually occurs.
1201 */
1202PUBLIC
1203void XMesaSwapBuffers( XMesaBuffer b )
1204{
1205   XMesaContext xmctx = XMesaGetCurrentContext();
1206
1207   if (xmctx && xmctx->xm_buffer == b) {
1208      xmctx->st->flush( xmctx->st, ST_FLUSH_FRONT, NULL);
1209   }
1210
1211   xmesa_swap_st_framebuffer(b->stfb);
1212}
1213
1214
1215
1216/*
1217 * Copy sub-region of back buffer to front buffer
1218 */
1219void XMesaCopySubBuffer( XMesaBuffer b, int x, int y, int width, int height )
1220{
1221   xmesa_copy_st_framebuffer(b->stfb,
1222         ST_ATTACHMENT_BACK_LEFT, ST_ATTACHMENT_FRONT_LEFT,
1223         x, y, width, height);
1224}
1225
1226
1227
1228void XMesaFlush( XMesaContext c )
1229{
1230   if (c && c->xm_visual->display) {
1231      XMesaDisplay xmdpy = xmesa_init_display(c->xm_visual->display);
1232      struct pipe_fence_handle *fence = NULL;
1233
1234      c->st->flush(c->st, ST_FLUSH_FRONT, &fence);
1235      if (fence) {
1236         xmdpy->screen->fence_finish(xmdpy->screen, fence,
1237                                     PIPE_TIMEOUT_INFINITE);
1238         xmdpy->screen->fence_reference(xmdpy->screen, &fence, NULL);
1239      }
1240      XFlush( c->xm_visual->display );
1241   }
1242}
1243
1244
1245
1246
1247
1248XMesaBuffer XMesaFindBuffer( Display *dpy, Drawable d )
1249{
1250   XMesaBuffer b;
1251   for (b = XMesaBufferList; b; b = b->Next) {
1252      if (b->ws.drawable == d && b->xm_visual->display == dpy) {
1253         return b;
1254      }
1255   }
1256   return NULL;
1257}
1258
1259
1260/**
1261 * Free/destroy all XMesaBuffers associated with given display.
1262 */
1263void xmesa_destroy_buffers_on_display(Display *dpy)
1264{
1265   XMesaBuffer b, next;
1266   for (b = XMesaBufferList; b; b = next) {
1267      next = b->Next;
1268      if (b->xm_visual->display == dpy) {
1269         xmesa_free_buffer(b);
1270         /* delete head of list? */
1271         if (XMesaBufferList == b) {
1272            XMesaBufferList = next;
1273         }
1274      }
1275   }
1276}
1277
1278
1279/*
1280 * Look for XMesaBuffers whose X window has been destroyed.
1281 * Deallocate any such XMesaBuffers.
1282 */
1283void XMesaGarbageCollect( void )
1284{
1285   XMesaBuffer b, next;
1286   for (b=XMesaBufferList; b; b=next) {
1287      next = b->Next;
1288      if (b->xm_visual &&
1289          b->xm_visual->display &&
1290          b->ws.drawable &&
1291          b->type == WINDOW) {
1292         XSync(b->xm_visual->display, False);
1293         if (!window_exists( b->xm_visual->display, b->ws.drawable )) {
1294            /* found a dead window, free the ancillary info */
1295            XMesaDestroyBuffer( b );
1296         }
1297      }
1298   }
1299}
1300
1301
1302
1303
1304PUBLIC void
1305XMesaBindTexImage(Display *dpy, XMesaBuffer drawable, int buffer,
1306                  const int *attrib_list)
1307{
1308}
1309
1310
1311
1312PUBLIC void
1313XMesaReleaseTexImage(Display *dpy, XMesaBuffer drawable, int buffer)
1314{
1315}
1316
1317
1318void
1319XMesaCopyContext(XMesaContext src, XMesaContext dst, unsigned long mask)
1320{
1321   if (dst->st->copy)
1322      dst->st->copy(dst->st, src->st, mask);
1323}
1324