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