src/gallium/state_trackers/glx/xlib/xm_api.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.1
   4  *
   5  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 /**
  26  * \file xm_api.c
  27  *
  28  * All the XMesa* API functions.
  29  *
  30  *
  31  * NOTES:
  32  *
  33  * The window coordinate system origin (0,0) is in the lower-left corner
  34  * of the window.  X11's window coordinate origin is in the upper-left
  35  * corner of the window.  Therefore, most drawing functions in this
  36  * file have to flip Y coordinates.
  37  *
  38  *
  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  */
  72 static struct xm_driver driver;
  73 static 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  */
  95 boolean xmesa_strict_invalidate = FALSE;
  96
  97 void 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
 112 static struct xmesa_display Displays[MAX_DISPLAYS];
 113 static int NumDisplays = 0;
 114
 115 static int
 116 xmesa_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
 127 static XMesaDisplay
 128 xmesa_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  */
 192 static 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  */
 210 static int
 211 bits_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  */
 246 static GLboolean WindowExistsFlag;
 247
 248 static 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
 257 static 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
 268 static Status
 269 get_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  */
 288 void
 289 xmesa_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  */
 316 static GLuint
 317 choose_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  */
 375 static enum pipe_format
 376 choose_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
 420 static 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  */
 434 static XMesaBuffer
 435 create_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  */
 483 XMesaBuffer
 484 xmesa_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  */
 501 static void
 502 xmesa_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  */
 552 static GLboolean
 553 initialize_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  */
 619 static GLint
 620 xmesa_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  */
 661 PUBLIC
 662 XMesaVisual 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
 821 PUBLIC
 822 void XMesaDestroyVisual( XMesaVisual v )
 823 {
 824    free(v->visinfo);
 825    free(v);
 826 }
 827
 828
 829 /**
 830  * Return the informative name.
 831  */
 832 const char *
 833 xmesa_get_name(void)
 834 {
 835    return stapi->name;
 836 }
 837
 838
 839 /**
 840  * Do per-display initializations.
 841  */
 842 void
 843 xmesa_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  */
 856 PUBLIC
 857 XMesaContext 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
 902 fail:
 903    if (c->st)
 904       c->st->destroy(c->st);
 905
 906    free(c);
 907    return NULL;
 908 }
 909
 910
 911
 912 PUBLIC
 913 void 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  */
 935 PUBLIC XMesaBuffer
 936 XMesaCreateWindowBuffer(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  */
 990 PUBLIC XMesaBuffer
 991 XMesaCreatePixmapBuffer(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  */
1014 XMesaBuffer
1015 XMesaCreatePixmapTextureBuffer(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
1071 XMesaBuffer
1072 XMesaCreatePBuffer(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  */
1104 PUBLIC void
1105 XMesaDestroyBuffer(XMesaBuffer b)
1106 {
1107    xmesa_free_buffer(b);
1108 }
1109
1110
1111 /**
1112  * Notify the binding context to validate the buffer.
1113  */
1114 void
1115 xmesa_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  */
1124 void
1125 xmesa_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  */
1138 PUBLIC
1139 GLboolean 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  */
1183 GLboolean XMesaUnbindContext( XMesaContext c )
1184 {
1185    /* A no-op for XFree86 integration purposes */
1186    return GL_TRUE;
1187 }
1188
1189
1190 XMesaContext 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  */
1202 PUBLIC
1203 void 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  */
1219 void 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
1228 void 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
1248 XMesaBuffer 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  */
1263 void 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  */
1283 void 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
1304 PUBLIC void
1305 XMesaBindTexImage(Display *dpy, XMesaBuffer drawable, int buffer,
1306                   const int *attrib_list)
1307 {
1308 }
1309
1310
1311
1312 PUBLIC void
1313 XMesaReleaseTexImage(Display *dpy, XMesaBuffer drawable, int buffer)
1314 {
1315 }
1316
1317
1318 void
1319 XMesaCopyContext(XMesaContext src, XMesaContext dst, unsigned long mask)
1320 {
1321    if (dst->st->copy)
1322       dst->st->copy(dst->st, src->st, mask);
1323 }