Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

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