src/mesa/drivers/x11/xm_dd.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  6.5.2
   4  *
   5  * Copyright (C) 1999-2006  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 #include "glxheader.h"
  27 #include "bufferobj.h"
  28 #include "buffers.h"
  29 #include "context.h"
  30 #include "colormac.h"
  31 #include "depth.h"
  32 #include "drawpix.h"
  33 #include "extensions.h"
  34 #include "framebuffer.h"
  35 #include "macros.h"
  36 #include "image.h"
  37 #include "imports.h"
  38 #include "mtypes.h"
  39 #include "state.h"
  40 #include "texobj.h"
  41 #include "teximage.h"
  42 #include "texstore.h"
  43 #include "texformat.h"
  44 #include "xmesaP.h"
  45 #include "array_cache/acache.h"
  46 #include "swrast/swrast.h"
  47 #include "swrast/s_context.h"
  48 #include "swrast_setup/swrast_setup.h"
  49 #include "tnl/tnl.h"
  50 #include "tnl/t_context.h"
  51
  52 #ifdef XFree86Server
  53 #include <GL/glxtokens.h>
  54 #endif
  55
  56
  57
  58 /*
  59  * Dithering kernels and lookup tables.
  60  */
  61
  62 const int xmesa_kernel8[DITH_DY * DITH_DX] = {
  63     0 * MAXC,  8 * MAXC,  2 * MAXC, 10 * MAXC,
  64    12 * MAXC,  4 * MAXC, 14 * MAXC,  6 * MAXC,
  65     3 * MAXC, 11 * MAXC,  1 * MAXC,  9 * MAXC,
  66    15 * MAXC,  7 * MAXC, 13 * MAXC,  5 * MAXC,
  67 };
  68
  69 const short xmesa_HPCR_DRGB[3][2][16] = {
  70    {
  71       { 16, -4,  1,-11, 14, -6,  3, -9, 15, -5,  2,-10, 13, -7,  4, -8},
  72       {-15,  5,  0, 12,-13,  7, -2, 10,-14,  6, -1, 11,-12,  8, -3,  9}
  73    },
  74    {
  75       {-11, 15, -7,  3, -8, 14, -4,  2,-10, 16, -6,  4, -9, 13, -5,  1},
  76       { 12,-14,  8, -2,  9,-13,  5, -1, 11,-15,  7, -3, 10,-12,  6,  0}
  77    },
  78    {
  79       {  6,-18, 26,-14,  2,-22, 30,-10,  8,-16, 28,-12,  4,-20, 32, -8},
  80       { -4, 20,-24, 16,  0, 24,-28, 12, -6, 18,-26, 14, -2, 22,-30, 10}
  81    }
  82 };
  83
  84 const int xmesa_kernel1[16] = {
  85    0*47,  9*47,  4*47, 12*47,     /* 47 = (255*3)/16 */
  86    6*47,  2*47, 14*47,  8*47,
  87   10*47,  1*47,  5*47, 11*47,
  88    7*47, 13*47,  3*47, 15*47
  89 };
  90
  91
  92 /*
  93  * Return the size (width, height) of the X window for the given GLframebuffer.
  94  * Output:  width - width of buffer in pixels.
  95  *          height - height of buffer in pixels.
  96  */
  97 static void
  98 get_buffer_size( GLframebuffer *buffer, GLuint *width, GLuint *height )
  99 {
 100    /* We can do this cast because the first field in the XMesaBuffer
 101     * struct is a GLframebuffer struct.  If this weren't true, we'd
 102     * need a pointer from the GLframebuffer to the XMesaBuffer.
 103     */
 104    const XMesaBuffer xmBuffer = (XMesaBuffer) buffer;
 105    unsigned int winwidth, winheight;
 106 #ifdef XFree86Server
 107    /* XFree86 GLX renderer */
 108    winwidth = MIN2(xmBuffer->frontxrb->drawable->width, MAX_WIDTH);
 109    winheight = MIN2(xmBuffer->frontxrb->drawable->height, MAX_HEIGHT);
 110 #else
 111    Window root;
 112    Status stat;
 113    int winx, winy;
 114    unsigned int bw, d;
 115
 116    _glthread_LOCK_MUTEX(_xmesa_lock);
 117    XSync(xmBuffer->xm_visual->display, 0); /* added for Chromium */
 118
 119    stat = XGetGeometry( xmBuffer->xm_visual->display, xmBuffer->frontxrb->pixmap,
 120                  &root, &winx, &winy, &winwidth, &winheight, &bw, &d );
 121    _glthread_UNLOCK_MUTEX(_xmesa_lock);
 122
 123    if (!stat) {
 124       /* probably querying a window that's recently been destroyed */
 125       _mesa_warning(NULL, "XGetGeometry failed!\n");
 126       *width = *height = 1;
 127       return;
 128    }
 129 #endif
 130
 131    *width = winwidth;
 132    *height = winheight;
 133 }
 134
 135
 136 static void
 137 finish_or_flush( GLcontext *ctx )
 138 {
 139 #ifdef XFree86Server
 140       /* NOT_NEEDED */
 141 #else
 142    const XMesaContext xmesa = XMESA_CONTEXT(ctx);
 143    if (xmesa) {
 144       _glthread_LOCK_MUTEX(_xmesa_lock);
 145       XSync( xmesa->display, False );
 146       _glthread_UNLOCK_MUTEX(_xmesa_lock);
 147    }
 148 #endif
 149 }
 150
 151
 152 static void
 153 clear_index( GLcontext *ctx, GLuint index )
 154 {
 155    if (ctx->DrawBuffer->Name == 0) {
 156       const XMesaContext xmesa = XMESA_CONTEXT(ctx);
 157       XMesaBuffer xmbuf = XMESA_BUFFER(ctx->DrawBuffer);
 158       xmesa->clearpixel = (unsigned long) index;
 159       XMesaSetForeground( xmesa->display, xmbuf->cleargc, (unsigned long) index );
 160    }
 161 }
 162
 163
 164 static void
 165 clear_color( GLcontext *ctx, const GLfloat color[4] )
 166 {
 167    if (ctx->DrawBuffer->Name == 0) {
 168       const XMesaContext xmesa = XMESA_CONTEXT(ctx);
 169       XMesaBuffer xmbuf = XMESA_BUFFER(ctx->DrawBuffer);
 170
 171       CLAMPED_FLOAT_TO_UBYTE(xmesa->clearcolor[0], color[0]);
 172       CLAMPED_FLOAT_TO_UBYTE(xmesa->clearcolor[1], color[1]);
 173       CLAMPED_FLOAT_TO_UBYTE(xmesa->clearcolor[2], color[2]);
 174       CLAMPED_FLOAT_TO_UBYTE(xmesa->clearcolor[3], color[3]);
 175       xmesa->clearpixel = xmesa_color_to_pixel( ctx,
 176                                                 xmesa->clearcolor[0],
 177                                                 xmesa->clearcolor[1],
 178                                                 xmesa->clearcolor[2],
 179                                                 xmesa->clearcolor[3],
 180                                                 xmesa->xm_visual->undithered_pf );
 181       _glthread_LOCK_MUTEX(_xmesa_lock);
 182       XMesaSetForeground( xmesa->display, xmbuf->cleargc,
 183                           xmesa->clearpixel );
 184       _glthread_UNLOCK_MUTEX(_xmesa_lock);
 185    }
 186 }
 187
 188
 189
 190 /* Set index mask ala glIndexMask */
 191 static void
 192 index_mask( GLcontext *ctx, GLuint mask )
 193 {
 194    const XMesaContext xmesa = XMESA_CONTEXT(ctx);
 195    XMesaBuffer xmbuf = XMESA_BUFFER(ctx->DrawBuffer);
 196    /* not sure this conditional is really needed */
 197    if (xmbuf->backxrb && xmbuf->backxrb->pixmap) {
 198       unsigned long m;
 199       if (mask==0xffffffff) {
 200          m = ((unsigned long)~0L);
 201       }
 202       else {
 203          m = (unsigned long) mask;
 204       }
 205       XMesaSetPlaneMask( xmesa->display, xmbuf->cleargc, m );
 206       XMesaSetPlaneMask( xmesa->display, xmbuf->gc, m );
 207    }
 208 }
 209
 210
 211 /* Implements glColorMask() */
 212 static void
 213 color_mask(GLcontext *ctx,
 214            GLboolean rmask, GLboolean gmask, GLboolean bmask, GLboolean amask)
 215 {
 216    const XMesaContext xmesa = XMESA_CONTEXT(ctx);
 217    XMesaBuffer xmbuf;
 218    const int xclass = xmesa->xm_visual->mesa_visual.visualType;
 219    (void) amask;
 220
 221    if (ctx->DrawBuffer->Name != 0)
 222       return;
 223
 224    xmbuf = XMESA_BUFFER(ctx->DrawBuffer);
 225
 226    if (xclass == GLX_TRUE_COLOR || xclass == GLX_DIRECT_COLOR) {
 227       unsigned long m;
 228       if (rmask && gmask && bmask) {
 229          m = ((unsigned long)~0L);
 230       }
 231       else {
 232          m = 0;
 233          if (rmask)   m |= GET_REDMASK(xmesa->xm_visual);
 234          if (gmask)   m |= GET_GREENMASK(xmesa->xm_visual);
 235          if (bmask)   m |= GET_BLUEMASK(xmesa->xm_visual);
 236       }
 237       XMesaSetPlaneMask( xmesa->display, xmbuf->cleargc, m );
 238       XMesaSetPlaneMask( xmesa->display, xmbuf->gc, m );
 239    }
 240 }
 241
 242
 243
 244 /**********************************************************************/
 245 /*** glClear implementations                                        ***/
 246 /**********************************************************************/
 247
 248
 249 /**
 250  * Clear the front or back color buffer, if it's implemented with a pixmap.
 251  */
 252 static void
 253 clear_pixmap(GLcontext *ctx, struct xmesa_renderbuffer *xrb, GLboolean all,
 254              GLint x, GLint y, GLint width, GLint height)
 255 {
 256    const XMesaContext xmesa = XMESA_CONTEXT(ctx);
 257    XMesaBuffer xmbuf = XMESA_BUFFER(ctx->DrawBuffer);
 258
 259    assert(xmbuf);
 260    assert(xrb->pixmap);
 261    assert(xmesa);
 262    assert(xmesa->display);
 263    assert(xrb->pixmap);
 264    assert(xmbuf->cleargc);
 265
 266    if (all) {
 267       XMesaFillRectangle( xmesa->display, xrb->pixmap, xmbuf->cleargc,
 268                           0, 0, xrb->Base.Width + 1, xrb->Base.Height + 1 );
 269    }
 270    else {
 271       XMesaFillRectangle( xmesa->display, xrb->pixmap, xmbuf->cleargc,
 272                           x, xrb->Base.Height - y - height,
 273                           width, height );
 274    }
 275 }
 276
 277
 278 static void
 279 clear_8bit_ximage( GLcontext *ctx, struct xmesa_renderbuffer *xrb,
 280                    GLboolean all, GLint x, GLint y, GLint width, GLint height )
 281 {
 282    const XMesaContext xmesa = XMESA_CONTEXT(ctx);
 283
 284    if (all) {
 285       const size_t n = xrb->ximage->bytes_per_line * xrb->Base.Height;
 286       MEMSET( xrb->ximage->data, xmesa->clearpixel, n );
 287    }
 288    else {
 289       GLint i;
 290       for (i=0;i<height;i++) {
 291          GLubyte *ptr = PIXEL_ADDR1(xrb, x, y + i);
 292          MEMSET( ptr, xmesa->clearpixel, width );
 293       }
 294    }
 295 }
 296
 297
 298 static void
 299 clear_HPCR_ximage( GLcontext *ctx, struct xmesa_renderbuffer *xrb,
 300                    GLboolean all, GLint x, GLint y, GLint width, GLint height )
 301 {
 302    const XMesaContext xmesa = XMESA_CONTEXT(ctx);
 303
 304    if (all) {
 305       const GLuint c16 = xrb->ximage->bytes_per_line & ~0xf;
 306       GLuint i;
 307       GLubyte *ptr  = (GLubyte *) xrb->ximage->data;
 308       for (i = 0; i < xrb->Base.Height; i++) {
 309          GLuint j;
 310          const GLubyte *sptr = xmesa->xm_visual->hpcr_clear_ximage_pattern[0];
 311          if (i&1) {
 312             sptr += 16;
 313          }
 314          for (j=0; j<c16; j+=16) {
 315             ptr[0] = sptr[0];
 316             ptr[1] = sptr[1];
 317             ptr[2] = sptr[2];
 318             ptr[3] = sptr[3];
 319             ptr[4] = sptr[4];
 320             ptr[5] = sptr[5];
 321             ptr[6] = sptr[6];
 322             ptr[7] = sptr[7];
 323             ptr[8] = sptr[8];
 324             ptr[9] = sptr[9];
 325             ptr[10] = sptr[10];
 326             ptr[11] = sptr[11];
 327             ptr[12] = sptr[12];
 328             ptr[13] = sptr[13];
 329             ptr[14] = sptr[14];
 330             ptr[15] = sptr[15];
 331             ptr += 16;
 332          }
 333          for (; j < (GLuint) xrb->ximage->bytes_per_line; j++) {
 334             *ptr = sptr[j&15];
 335             ptr++;
 336          }
 337       }
 338    }
 339    else {
 340       GLint i;
 341       for (i=y; i<y+height; i++) {
 342          GLubyte *ptr = PIXEL_ADDR1( xrb, x, i );
 343          int j;
 344          const GLubyte *sptr = xmesa->xm_visual->hpcr_clear_ximage_pattern[0];
 345          if (i&1) {
 346             sptr += 16;
 347          }
 348          for (j=x; j<x+width; j++) {
 349             *ptr = sptr[j&15];
 350             ptr++;
 351          }
 352       }
 353    }
 354 }
 355
 356
 357 static void
 358 clear_16bit_ximage( GLcontext *ctx, struct xmesa_renderbuffer *xrb,
 359                     GLboolean all, GLint x, GLint y, GLint width, GLint height)
 360 {
 361    const XMesaContext xmesa = XMESA_CONTEXT(ctx);
 362    register GLuint pixel = (GLuint) xmesa->clearpixel;
 363
 364    if (xmesa->swapbytes) {
 365       pixel = ((pixel >> 8) & 0x00ff) | ((pixel << 8) & 0xff00);
 366    }
 367
 368    if (all) {
 369       GLuint *ptr4 = (GLuint *) xrb->ximage->data;
 370       if ((pixel & 0xff) == ((pixel >> 8) & 0xff)) {
 371          /* low and high bytes are equal so use memset() */
 372          const GLuint n = xrb->ximage->bytes_per_line * xrb->Base.Height;
 373          MEMSET( ptr4, pixel & 0xff, n );
 374       }
 375       else {
 376          const GLuint n = xrb->ximage->bytes_per_line * xrb->Base.Height / 4;
 377          GLuint i;
 378          pixel = pixel | (pixel<<16);
 379          for (i = 0; i < n; i++) {
 380             ptr4[i] = pixel;
 381          }
 382          ptr4 += n;
 383          /* might be one last GLushort to set */
 384          if ((xrb->ximage->bytes_per_line * xrb->Base.Height) & 0x2)
 385             *(GLushort *)ptr4 = pixel & 0xffff;
 386       }
 387    }
 388    else {
 389       GLint i, j;
 390       for (j=0;j<height;j++) {
 391          GLushort *ptr2 = PIXEL_ADDR2(xrb, x, y + j);
 392          for (i=0;i<width;i++) {
 393             *ptr2++ = pixel;
 394          }
 395       }
 396    }
 397 }
 398
 399
 400 /* Optimized code provided by Nozomi Ytow <noz@xfree86.org> */
 401 static void
 402 clear_24bit_ximage(GLcontext *ctx, struct xmesa_renderbuffer *xrb,
 403                    GLboolean all, GLint x, GLint y, GLint width, GLint height)
 404 {
 405    const XMesaContext xmesa = XMESA_CONTEXT(ctx);
 406    const GLubyte r = xmesa->clearcolor[0];
 407    const GLubyte g = xmesa->clearcolor[1];
 408    const GLubyte b = xmesa->clearcolor[2];
 409
 410    if (all) {
 411       if (r == g && g == b) {
 412          /* same value for all three components (gray) */
 413          const GLint w3 = xrb->Base.Width * 3;
 414          const GLint h = xrb->Base.Height;
 415          GLint i;
 416          for (i = 0; i < h; i++) {
 417             bgr_t *ptr3 = PIXEL_ADDR3(xrb, 0, i);
 418             MEMSET(ptr3, r, w3);
 419          }
 420       }
 421       else {
 422          /* the usual case */
 423          const GLint w = xrb->Base.Width;
 424          const GLint h = xrb->Base.Height;
 425          GLint i, j;
 426          for (i = 0; i < h; i++) {
 427             bgr_t *ptr3 = PIXEL_ADDR3(xrb, 0, i);
 428             for (j = 0; j < w; j++) {
 429                ptr3->r = r;
 430                ptr3->g = g;
 431                ptr3->b = b;
 432                ptr3++;
 433             }
 434          }
 435       }
 436    }
 437    else {
 438       /* only clear subrect of color buffer */
 439       if (r == g && g == b) {
 440          /* same value for all three components (gray) */
 441          GLint j;
 442          for (j=0;j<height;j++) {
 443             bgr_t *ptr3 = PIXEL_ADDR3(xrb, x, y + j);
 444             MEMSET(ptr3, r, 3 * width);
 445          }
 446       }
 447       else {
 448          /* non-gray clear color */
 449          GLint i, j;
 450          for (j = 0; j < height; j++) {
 451             bgr_t *ptr3 = PIXEL_ADDR3(xrb, x, y + j);
 452             for (i = 0; i < width; i++) {
 453                ptr3->r = r;
 454                ptr3->g = g;
 455                ptr3->b = b;
 456                ptr3++;
 457             }
 458          }
 459       }
 460    }
 461 }
 462
 463
 464 static void
 465 clear_32bit_ximage(GLcontext *ctx, struct xmesa_renderbuffer *xrb,
 466                    GLboolean all, GLint x, GLint y, GLint width, GLint height)
 467 {
 468    const XMesaContext xmesa = XMESA_CONTEXT(ctx);
 469    register GLuint pixel = (GLuint) xmesa->clearpixel;
 470
 471    if (!xrb->ximage)
 472       return;
 473
 474    if (xmesa->swapbytes) {
 475       pixel = ((pixel >> 24) & 0x000000ff)
 476             | ((pixel >> 8)  & 0x0000ff00)
 477             | ((pixel << 8)  & 0x00ff0000)
 478             | ((pixel << 24) & 0xff000000);
 479    }
 480
 481    if (all) {
 482       const GLuint n = xrb->Base.Width * xrb->Base.Height;
 483       GLuint *ptr4 = (GLuint *) xrb->ximage->data;
 484       if (pixel == 0) {
 485          _mesa_memset(ptr4, pixel, 4 * n);
 486       }
 487       else {
 488          GLuint i;
 489          for (i = 0; i < n; i++)
 490             ptr4[i] = pixel;
 491       }
 492    }
 493    else {
 494       GLint i, j;
 495       for (j = 0; j < height; j++) {
 496          GLuint *ptr4 = PIXEL_ADDR4(xrb, x, y + j);
 497          for (i = 0; i < width; i++) {
 498             ptr4[i] = pixel;
 499          }
 500       }
 501    }
 502 }
 503
 504
 505 static void
 506 clear_nbit_ximage(GLcontext *ctx, struct xmesa_renderbuffer *xrb,
 507                   GLboolean all, GLint x, GLint y, GLint width, GLint height)
 508 {
 509    const XMesaContext xmesa = XMESA_CONTEXT(ctx);
 510    XMesaImage *img = xrb->ximage;
 511    GLint i, j;
 512
 513    /* We can ignore 'all' here - x, y, width, height are always right */
 514    (void) all;
 515
 516    /* TODO: optimize this */
 517    y = YFLIP(xrb, y);
 518    for (j = 0; j < height; j++) {
 519       for (i = 0; i < width; i++) {
 520          XMesaPutPixel(img, x+i, y-j, xmesa->clearpixel);
 521       }
 522    }
 523 }
 524
 525
 526
 527 static void
 528 clear_buffers( GLcontext *ctx, GLbitfield mask,
 529                GLboolean all, GLint x, GLint y, GLint width, GLint height )
 530 {
 531    if (ctx->DrawBuffer->Name == 0) {
 532       /* this is a window system framebuffer */
 533       const GLuint *colorMask = (GLuint *) &ctx->Color.ColorMask;
 534       XMesaBuffer b = XMESA_BUFFER(ctx->DrawBuffer);
 535
 536       /* we can't handle color or index masking */
 537       if (*colorMask == 0xffffffff && ctx->Color.IndexMask == 0xffffffff) {
 538          if (mask & BUFFER_BIT_FRONT_LEFT) {
 539             /* clear front color buffer */
 540             struct gl_renderbuffer *frontRb
 541                = ctx->DrawBuffer->Attachment[BUFFER_FRONT_LEFT].Renderbuffer;
 542             if (b->frontxrb == xmesa_renderbuffer(frontRb)) {
 543                /* renderbuffer is not wrapped - great! */
 544                b->frontxrb->clearFunc(ctx, b->frontxrb, all, x, y,
 545                                       width, height);
 546                mask &= ~BUFFER_BIT_FRONT_LEFT;
 547             }
 548             else {
 549                /* we can't directly clear an alpha-wrapped color buffer */
 550             }
 551          }
 552          if (mask & BUFFER_BIT_BACK_LEFT) {
 553             /* clear back color buffer */
 554             struct gl_renderbuffer *backRb
 555                = ctx->DrawBuffer->Attachment[BUFFER_BACK_LEFT].Renderbuffer;
 556             if (b->backxrb == xmesa_renderbuffer(backRb)) {
 557                /* renderbuffer is not wrapped - great! */
 558                b->backxrb->clearFunc(ctx, b->backxrb, all, x, y,
 559                                      width, height);
 560                mask &= ~BUFFER_BIT_BACK_LEFT;
 561             }
 562          }
 563       }
 564    }
 565    if (mask)
 566       _swrast_Clear( ctx, mask, all, x, y, width, height );
 567 }
 568
 569
 570 /**
 571  * Called by ctx->Driver.ResizeBuffers()
 572  * Resize the front/back colorbuffers to match the latest window size.
 573  */
 574 void
 575 xmesa_resize_buffers(GLcontext *ctx, GLframebuffer *buffer,
 576                      GLuint width, GLuint height)
 577 {
 578    /* We can do this cast because the first field in the XMesaBuffer
 579     * struct is a GLframebuffer struct.  If this weren't true, we'd
 580     * need a pointer from the GLframebuffer to the XMesaBuffer.
 581     */
 582    XMesaBuffer xmBuffer = (XMesaBuffer) buffer;
 583
 584    xmesa_alloc_back_buffer(xmBuffer, width, height);
 585
 586    _mesa_resize_framebuffer(ctx, buffer, width, height);
 587 }
 588
 589
 590 #ifndef XFree86Server
 591 /* XXX this was never tested in the Xserver environment */
 592
 593 /**
 594  * This function implements glDrawPixels() with an XPutImage call when
 595  * drawing to the front buffer (X Window drawable).
 596  * The image format must be GL_BGRA to match the PF_8R8G8B pixel format.
 597  */
 598 static void
 599 xmesa_DrawPixels_8R8G8B( GLcontext *ctx,
 600                          GLint x, GLint y, GLsizei width, GLsizei height,
 601                          GLenum format, GLenum type,
 602                          const struct gl_pixelstore_attrib *unpack,
 603                          const GLvoid *pixels )
 604 {
 605    const SWcontext *swrast = SWRAST_CONTEXT( ctx );
 606    struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[0][0];
 607    struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb->Wrapped;
 608
 609    if (swrast->NewState)
 610       _swrast_validate_derived( ctx );
 611
 612    if (ctx->DrawBuffer->Name == 0 &&
 613        format == GL_BGRA &&
 614        type == GL_UNSIGNED_BYTE &&
 615        (swrast->_RasterMask & ~CLIP_BIT) == 0 && /* no blend, z-test, etc */
 616        ctx->_ImageTransferState == 0 &&  /* no color tables, scale/bias, etc */
 617        ctx->Pixel.ZoomX == 1.0 &&        /* no zooming */
 618        ctx->Pixel.ZoomY == 1.0 &&
 619        xrb->pixmap &&
 620        xrb->Base.AlphaBits == 0)
 621    {
 622       const XMesaContext xmesa = XMESA_CONTEXT(ctx);
 623       XMesaBuffer xmbuf = XMESA_BUFFER(ctx->DrawBuffer);
 624       XMesaDisplay *dpy = xmesa->xm_visual->display;
 625       const XMesaGC gc = xmbuf->gc;
 626       int dstX = x;
 627       int dstY = y;
 628       int w = width;
 629       int h = height;
 630       struct gl_pixelstore_attrib clippedUnpack = *unpack;
 631
 632       ASSERT(xmesa->xm_visual->dithered_pf == PF_8R8G8B);
 633       ASSERT(xmesa->xm_visual->undithered_pf == PF_8R8G8B);
 634       ASSERT(dpy);
 635       ASSERT(gc);
 636
 637       if (unpack->BufferObj->Name) {
 638          /* unpack from PBO */
 639          GLubyte *buf;
 640          if (!_mesa_validate_pbo_access(2, unpack, width, height, 1,
 641                                         format, type, pixels)) {
 642             _mesa_error(ctx, GL_INVALID_OPERATION,
 643                         "glDrawPixels(invalid PBO access)");
 644             return;
 645          }
 646          buf = (GLubyte *) ctx->Driver.MapBuffer(ctx,
 647                                                  GL_PIXEL_UNPACK_BUFFER_EXT,
 648                                                  GL_READ_ONLY_ARB,
 649                                                  unpack->BufferObj);
 650          if (!buf) {
 651             /* buffer is already mapped - that's an error */
 652             _mesa_error(ctx, GL_INVALID_OPERATION,
 653                         "glDrawPixels(PBO is mapped)");
 654             return;
 655          }
 656          pixels = ADD_POINTERS(buf, pixels);
 657       }
 658
 659       if (_mesa_clip_drawpixels(ctx, &dstX, &dstY, &w, &h, &clippedUnpack)) {
 660          /* This is a little tricky since all coordinates up to now have
 661           * been in the OpenGL bottom-to-top orientation.  X is top-to-bottom
 662           * so we have to carefully compute the Y coordinates/addresses here.
 663           */
 664          int srcX = clippedUnpack.SkipPixels;
 665          int srcY = clippedUnpack.SkipRows;
 666          int rowLength = clippedUnpack.RowLength;
 667          XMesaImage ximage;
 668          MEMSET(&ximage, 0, sizeof(XMesaImage));
 669          ximage.width = width;
 670          ximage.height = height;
 671          ximage.format = ZPixmap;
 672          ximage.data = (char *) pixels
 673             + ((srcY + h - 1) * rowLength + srcX) * 4;
 674          ximage.byte_order = LSBFirst;
 675          ximage.bitmap_unit = 32;
 676          ximage.bitmap_bit_order = LSBFirst;
 677          ximage.bitmap_pad = 32;
 678          ximage.depth = 24;
 679          ximage.bytes_per_line = -rowLength * 4; /* negative to flip image */
 680          ximage.bits_per_pixel = 32;
 681          /* it seems we don't need to set the ximage.red/green/blue_mask fields */
 682          /* flip Y axis for dest position */
 683          dstY = YFLIP(xrb, dstY) - h + 1;
 684          XPutImage(dpy, xrb->pixmap, gc, &ximage, 0, 0, dstX, dstY, w, h);
 685       }
 686
 687       if (unpack->BufferObj->Name) {
 688          ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
 689                                  unpack->BufferObj);
 690       }
 691    }
 692    else {
 693       /* software fallback */
 694       _swrast_DrawPixels(ctx, x, y, width, height,
 695                          format, type, unpack, pixels);
 696    }
 697 }
 698
 699
 700
 701 /**
 702  * This function implements glDrawPixels() with an XPutImage call when
 703  * drawing to the front buffer (X Window drawable).  The image format
 704  * must be GL_RGB and image type must be GL_UNSIGNED_SHORT_5_6_5 to
 705  * match the PF_5R6G5B pixel format.
 706  */
 707 static void
 708 xmesa_DrawPixels_5R6G5B( GLcontext *ctx,
 709                          GLint x, GLint y, GLsizei width, GLsizei height,
 710                          GLenum format, GLenum type,
 711                          const struct gl_pixelstore_attrib *unpack,
 712                          const GLvoid *pixels )
 713 {
 714    struct xmesa_renderbuffer *xrb
 715       = (struct xmesa_renderbuffer *) ctx->DrawBuffer->_ColorDrawBuffers[0][0];
 716    const XMesaContext xmesa = XMESA_CONTEXT(ctx);
 717    const SWcontext *swrast = SWRAST_CONTEXT( ctx );
 718    XMesaDisplay *dpy = xmesa->xm_visual->display;
 719    XMesaBuffer xmbuf = XMESA_BUFFER(ctx->DrawBuffer);
 720    const XMesaGC gc = xmbuf->gc;
 721
 722    ASSERT(dpy);
 723    ASSERT(gc);
 724    ASSERT(xmesa->xm_visual->undithered_pf == PF_5R6G5B);
 725
 726    if (swrast->NewState)
 727       _swrast_validate_derived( ctx );
 728
 729    if (xrb->pixmap &&
 730        format == GL_RGB &&
 731        type == GL_UNSIGNED_SHORT_5_6_5 &&
 732        !ctx->Color.DitherFlag &&  /* no dithering */
 733        (swrast->_RasterMask & ~CLIP_BIT) == 0 && /* no blend, z-test, etc */
 734        ctx->_ImageTransferState == 0 &&  /* no color tables, scale/bias, etc */
 735        ctx->Pixel.ZoomX == 1.0 &&        /* no zooming */
 736        ctx->Pixel.ZoomY == 1.0) {
 737       int dstX = x;
 738       int dstY = y;
 739       int w = width;
 740       int h = height;
 741       struct gl_pixelstore_attrib clippedUnpack = *unpack;
 742
 743       if (unpack->BufferObj->Name) {
 744          /* unpack from PBO */
 745          GLubyte *buf;
 746          if (!_mesa_validate_pbo_access(2, unpack, width, height, 1,
 747                                         format, type, pixels)) {
 748             _mesa_error(ctx, GL_INVALID_OPERATION,
 749                         "glDrawPixels(invalid PBO access)");
 750             return;
 751          }
 752          buf = (GLubyte *) ctx->Driver.MapBuffer(ctx,
 753                                                  GL_PIXEL_UNPACK_BUFFER_EXT,
 754                                                  GL_READ_ONLY_ARB,
 755                                                  unpack->BufferObj);
 756          if (!buf) {
 757             /* buffer is already mapped - that's an error */
 758             _mesa_error(ctx, GL_INVALID_OPERATION,
 759                         "glDrawPixels(PBO is mapped)");
 760             return;
 761          }
 762          pixels = ADD_POINTERS(buf, pixels);
 763       }
 764
 765       if (_mesa_clip_drawpixels(ctx, &dstX, &dstY, &w, &h, &clippedUnpack)) {
 766          /* This is a little tricky since all coordinates up to now have
 767           * been in the OpenGL bottom-to-top orientation.  X is top-to-bottom
 768           * so we have to carefully compute the Y coordinates/addresses here.
 769           */
 770          int srcX = clippedUnpack.SkipPixels;
 771          int srcY = clippedUnpack.SkipRows;
 772          int rowLength = clippedUnpack.RowLength;
 773          XMesaImage ximage;
 774          MEMSET(&ximage, 0, sizeof(XMesaImage));
 775          ximage.width = width;
 776          ximage.height = height;
 777          ximage.format = ZPixmap;
 778          ximage.data = (char *) pixels
 779             + ((srcY + h - 1) * rowLength + srcX) * 2;
 780          ximage.byte_order = LSBFirst;
 781          ximage.bitmap_unit = 16;
 782          ximage.bitmap_bit_order = LSBFirst;
 783          ximage.bitmap_pad = 16;
 784          ximage.depth = 16;
 785          ximage.bytes_per_line = -rowLength * 2; /* negative to flip image */
 786          ximage.bits_per_pixel = 16;
 787          /* it seems we don't need to set the ximage.red/green/blue_mask fields */
 788          /* flip Y axis for dest position */
 789          dstY = YFLIP(xrb, dstY) - h + 1;
 790          XPutImage(dpy, xrb->pixmap, gc, &ximage, 0, 0, dstX, dstY, w, h);
 791       }
 792
 793       if (unpack->BufferObj->Name) {
 794          ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
 795                                  unpack->BufferObj);
 796       }
 797    }
 798    else {
 799       /* software fallback */
 800       _swrast_DrawPixels(ctx, x, y, width, height,
 801                          format, type, unpack, pixels);
 802    }
 803 }
 804
 805
 806
 807 /**
 808  * Implement glCopyPixels for the front color buffer (or back buffer Pixmap)
 809  * for the color buffer.  Don't support zooming, pixel transfer, etc.
 810  * We do support copying from one window to another, ala glXMakeCurrentRead.
 811  */
 812 static void
 813 xmesa_CopyPixels( GLcontext *ctx,
 814                   GLint srcx, GLint srcy, GLsizei width, GLsizei height,
 815                   GLint destx, GLint desty, GLenum type )
 816 {
 817    const XMesaContext xmesa = XMESA_CONTEXT(ctx);
 818    const SWcontext *swrast = SWRAST_CONTEXT( ctx );
 819    XMesaDisplay *dpy = xmesa->xm_visual->display;
 820    const XMesaGC gc = ((XMesaBuffer) ctx->DrawBuffer)->gc;
 821    struct xmesa_renderbuffer *srcXrb = (struct xmesa_renderbuffer *)
 822       ctx->ReadBuffer->_ColorReadBuffer;
 823    struct xmesa_renderbuffer *dstXrb = (struct xmesa_renderbuffer *)
 824       ctx->DrawBuffer->_ColorDrawBuffers[0][0];
 825
 826    ASSERT(dpy);
 827    ASSERT(gc);
 828
 829    if (swrast->NewState)
 830       _swrast_validate_derived( ctx );
 831
 832    if (ctx->Color.DrawBuffer[0] == GL_FRONT &&
 833        ctx->Pixel.ReadBuffer == GL_FRONT &&
 834        srcXrb->pixmap &&
 835        dstXrb->pixmap &&
 836        type == GL_COLOR &&
 837        (swrast->_RasterMask & ~CLIP_BIT) == 0 && /* no blend, z-test, etc */
 838        ctx->_ImageTransferState == 0 &&  /* no color tables, scale/bias, etc */
 839        ctx->Pixel.ZoomX == 1.0 &&        /* no zooming */
 840        ctx->Pixel.ZoomY == 1.0) {
 841       /* Note: we don't do any special clipping work here.  We could,
 842        * but X will do it for us.
 843        */
 844       srcy = YFLIP(srcXrb, srcy) - height + 1;
 845       desty = YFLIP(dstXrb, desty) - height + 1;
 846       XCopyArea(dpy, srcXrb->pixmap, dstXrb->pixmap, gc,
 847                 srcx, srcy, width, height, destx, desty);
 848    }
 849    else {
 850       _swrast_CopyPixels(ctx, srcx, srcy, width, height, destx, desty, type );
 851    }
 852 }
 853 #endif /* XFree86Server */
 854
 855
 856
 857 /*
 858  * Every driver should implement a GetString function in order to
 859  * return a meaningful GL_RENDERER string.
 860  */
 861 static const GLubyte *
 862 get_string( GLcontext *ctx, GLenum name )
 863 {
 864    (void) ctx;
 865    switch (name) {
 866       case GL_RENDERER:
 867 #ifdef XFree86Server
 868          return (const GLubyte *) "Mesa GLX Indirect";
 869 #else
 870          return (const GLubyte *) "Mesa X11";
 871 #endif
 872       case GL_VENDOR:
 873 #ifdef XFree86Server
 874          return (const GLubyte *) "Mesa project: www.mesa3d.org";
 875 #else
 876          return NULL;
 877 #endif
 878       default:
 879          return NULL;
 880    }
 881 }
 882
 883
 884 /*
 885  * We implement the glEnable function only because we care about
 886  * dither enable/disable.
 887  */
 888 static void
 889 enable( GLcontext *ctx, GLenum pname, GLboolean state )
 890 {
 891    const XMesaContext xmesa = XMESA_CONTEXT(ctx);
 892
 893    switch (pname) {
 894       case GL_DITHER:
 895          if (state)
 896             xmesa->pixelformat = xmesa->xm_visual->dithered_pf;
 897          else
 898             xmesa->pixelformat = xmesa->xm_visual->undithered_pf;
 899          break;
 900       default:
 901          ;  /* silence compiler warning */
 902    }
 903 }
 904
 905
 906 static void
 907 clear_color_HPCR_ximage( GLcontext *ctx, const GLfloat color[4] )
 908 {
 909    int i;
 910    const XMesaContext xmesa = XMESA_CONTEXT(ctx);
 911
 912    CLAMPED_FLOAT_TO_UBYTE(xmesa->clearcolor[0], color[0]);
 913    CLAMPED_FLOAT_TO_UBYTE(xmesa->clearcolor[1], color[1]);
 914    CLAMPED_FLOAT_TO_UBYTE(xmesa->clearcolor[2], color[2]);
 915    CLAMPED_FLOAT_TO_UBYTE(xmesa->clearcolor[3], color[3]);
 916
 917    if (color[0] == 0.0 && color[1] == 0.0 && color[2] == 0.0) {
 918       /* black is black */
 919       MEMSET( xmesa->xm_visual->hpcr_clear_ximage_pattern, 0x0 ,
 920               sizeof(xmesa->xm_visual->hpcr_clear_ximage_pattern));
 921    }
 922    else {
 923       /* build clear pattern */
 924       for (i=0; i<16; i++) {
 925          xmesa->xm_visual->hpcr_clear_ximage_pattern[0][i] =
 926             DITHER_HPCR(i, 0,
 927                         xmesa->clearcolor[0],
 928                         xmesa->clearcolor[1],
 929                         xmesa->clearcolor[2]);
 930          xmesa->xm_visual->hpcr_clear_ximage_pattern[1][i]    =
 931             DITHER_HPCR(i, 1,
 932                         xmesa->clearcolor[0],
 933                         xmesa->clearcolor[1],
 934                         xmesa->clearcolor[2]);
 935       }
 936    }
 937 }
 938
 939
 940 static void
 941 clear_color_HPCR_pixmap( GLcontext *ctx, const GLfloat color[4] )
 942 {
 943    int i;
 944    const XMesaContext xmesa = XMESA_CONTEXT(ctx);
 945
 946    CLAMPED_FLOAT_TO_UBYTE(xmesa->clearcolor[0], color[0]);
 947    CLAMPED_FLOAT_TO_UBYTE(xmesa->clearcolor[1], color[1]);
 948    CLAMPED_FLOAT_TO_UBYTE(xmesa->clearcolor[2], color[2]);
 949    CLAMPED_FLOAT_TO_UBYTE(xmesa->clearcolor[3], color[3]);
 950
 951    if (color[0] == 0.0 && color[1] == 0.0 && color[2] == 0.0) {
 952       /* black is black */
 953       for (i=0; i<16; i++) {
 954          XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 0, 0);
 955          XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 1, 0);
 956       }
 957    }
 958    else {
 959       for (i=0; i<16; i++) {
 960          XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 0,
 961                        DITHER_HPCR(i, 0,
 962                                    xmesa->clearcolor[0],
 963                                    xmesa->clearcolor[1],
 964                                    xmesa->clearcolor[2]));
 965          XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 1,
 966                        DITHER_HPCR(i, 1,
 967                                    xmesa->clearcolor[0],
 968                                    xmesa->clearcolor[1],
 969                                    xmesa->clearcolor[2]));
 970       }
 971    }
 972    /* change tile pixmap content */
 973    XMesaPutImage(xmesa->display,
 974                  (XMesaDrawable)xmesa->xm_visual->hpcr_clear_pixmap,
 975                  XMESA_BUFFER(ctx->DrawBuffer)->cleargc,
 976                  xmesa->xm_visual->hpcr_clear_ximage, 0, 0, 0, 0, 16, 2);
 977 }
 978
 979
 980 /**
 981  * Called when the driver should update its state, based on the new_state
 982  * flags.
 983  */
 984 void
 985 xmesa_update_state( GLcontext *ctx, GLbitfield new_state )
 986 {
 987    const XMesaContext xmesa = XMESA_CONTEXT(ctx);
 988
 989    /* Propagate statechange information to swrast and swrast_setup
 990     * modules.  The X11 driver has no internal GL-dependent state.
 991     */
 992    _swrast_InvalidateState( ctx, new_state );
 993    _ac_InvalidateState( ctx, new_state );
 994    _tnl_InvalidateState( ctx, new_state );
 995    _swsetup_InvalidateState( ctx, new_state );
 996
 997    if (ctx->DrawBuffer->Name != 0)
 998       return;
 999
1000    /*
1001     * GL_DITHER, GL_READ/DRAW_BUFFER, buffer binding state, etc. effect
1002     * renderbuffer span/clear funcs.
1003     */
1004    if (new_state & (_NEW_COLOR | _NEW_PIXEL | _NEW_BUFFERS)) {
1005       XMesaBuffer xmbuf = XMESA_BUFFER(ctx->DrawBuffer);
1006       struct xmesa_renderbuffer *front_xrb, *back_xrb;
1007
1008       front_xrb = xmbuf->frontxrb;
1009       if (front_xrb) {
1010          xmesa_set_renderbuffer_funcs(front_xrb, xmesa->pixelformat,
1011                                       xmesa->xm_visual->BitsPerPixel);
1012          front_xrb->clearFunc = clear_pixmap;
1013       }
1014
1015       back_xrb = xmbuf->backxrb;
1016       if (back_xrb) {
1017          xmesa_set_renderbuffer_funcs(back_xrb, xmesa->pixelformat,
1018                                       xmesa->xm_visual->BitsPerPixel);
1019          if (xmbuf->backxrb->pixmap) {
1020             back_xrb->clearFunc = clear_pixmap;
1021          }
1022          else {
1023             switch (xmesa->xm_visual->BitsPerPixel) {
1024             case 8:
1025                if (xmesa->xm_visual->hpcr_clear_flag) {
1026                   back_xrb->clearFunc = clear_HPCR_ximage;
1027                }
1028                else {
1029                   back_xrb->clearFunc = clear_8bit_ximage;
1030                }
1031                break;
1032             case 16:
1033                back_xrb->clearFunc = clear_16bit_ximage;
1034                break;
1035             case 24:
1036                back_xrb->clearFunc = clear_24bit_ximage;
1037                break;
1038             case 32:
1039                back_xrb->clearFunc = clear_32bit_ximage;
1040                break;
1041             default:
1042                back_xrb->clearFunc = clear_nbit_ximage;
1043                break;
1044             }
1045          }
1046       }
1047    }
1048
1049    if (xmesa->xm_visual->hpcr_clear_flag) {
1050       /* this depends on whether we're drawing to the front or back buffer */
1051       /* XXX FIX THIS! */
1052 #if 0
1053       if (pixmap) {
1054          ctx->Driver.ClearColor = clear_color_HPCR_pixmap;
1055       }
1056       else {
1057          ctx->Driver.ClearColor = clear_color_HPCR_ximage;
1058       }
1059 #else
1060       (void) clear_color_HPCR_pixmap;
1061       (void) clear_color_HPCR_ximage;
1062 #endif
1063    }
1064 }
1065
1066
1067
1068 /**
1069  * Called via ctx->Driver.TestProxyTeximage().  Normally, we'd just use
1070  * the _mesa_test_proxy_teximage() fallback function, but we're going to
1071  * special-case the 3D texture case to allow textures up to 512x512x32
1072  * texels.
1073  */
1074 static GLboolean
1075 test_proxy_teximage(GLcontext *ctx, GLenum target, GLint level,
1076                     GLint internalFormat, GLenum format, GLenum type,
1077                     GLint width, GLint height, GLint depth, GLint border)
1078 {
1079    if (target == GL_PROXY_TEXTURE_3D) {
1080       /* special case for 3D textures */
1081       if (width * height * depth > 512 * 512 * 64 ||
1082           width  < 2 * border ||
1083           (!ctx->Extensions.ARB_texture_non_power_of_two &&
1084            _mesa_bitcount(width  - 2 * border) != 1) ||
1085           height < 2 * border ||
1086           (!ctx->Extensions.ARB_texture_non_power_of_two &&
1087            _mesa_bitcount(height - 2 * border) != 1) ||
1088           depth  < 2 * border ||
1089           (!ctx->Extensions.ARB_texture_non_power_of_two &&
1090            _mesa_bitcount(depth  - 2 * border) != 1)) {
1091          /* Bad size, or too many texels */
1092          return GL_FALSE;
1093       }
1094       return GL_TRUE;
1095    }
1096    else {
1097       /* use the fallback routine for 1D, 2D, cube and rect targets */
1098       return _mesa_test_proxy_teximage(ctx, target, level, internalFormat,
1099                                        format, type, width, height, depth,
1100                                        border);
1101    }
1102 }
1103
1104
1105 /**
1106  * In SW, we don't really compress GL_COMPRESSED_RGB[A] textures!
1107  */
1108 static const struct gl_texture_format *
1109 choose_tex_format( GLcontext *ctx, GLint internalFormat,
1110                    GLenum format, GLenum type )
1111 {
1112    switch (internalFormat) {
1113       case GL_COMPRESSED_RGB_ARB:
1114          return &_mesa_texformat_rgb;
1115       case GL_COMPRESSED_RGBA_ARB:
1116          return &_mesa_texformat_rgba;
1117       default:
1118          return _mesa_choose_tex_format(ctx, internalFormat, format, type);
1119    }
1120 }
1121
1122
1123 /**
1124  * Get the current drawing (and reading) window's size and update the
1125  * corresponding gl_framebuffer(s) if needed.
1126  */
1127 static void
1128 update_framebuffer_size(GLcontext *ctx)
1129 {
1130    struct gl_framebuffer *fb = ctx->WinSysDrawBuffer;
1131    GLuint newWidth, newHeight;
1132    get_buffer_size(fb, &newWidth, &newHeight);
1133    if (newWidth != fb->Width || newHeight != fb->Height) {
1134       xmesa_resize_buffers(ctx, fb, newWidth, newHeight);
1135    }
1136
1137    if (ctx->WinSysReadBuffer != ctx->WinSysDrawBuffer) {
1138       /* Update readbuffer's size */
1139       struct gl_framebuffer *fb = ctx->WinSysReadBuffer;
1140       GLuint newWidth, newHeight;
1141       get_buffer_size(fb, &newWidth, &newHeight);
1142       if (newWidth != fb->Width || newHeight != fb->Height) {
1143          xmesa_resize_buffers(ctx, fb, newWidth, newHeight);
1144          ctx->NewState |= _NEW_BUFFERS;
1145       }
1146    }
1147 }
1148
1149
1150 /**
1151  * Called by glViewport.
1152  * This is a good time for us to poll the current X window size and adjust
1153  * our renderbuffers to match the current window size.
1154  * Remember, we have no opportunity to respond to conventional
1155  * X Resize/StructureNotify events since the X driver has no event loop.
1156  * Thus, we poll.
1157  * Note that this trick isn't fool-proof.  If the application never calls
1158  * glViewport, our notion of the current window size may be incorrect.
1159  * That problem led to the GLX_MESA_resize_buffers extension.
1160  */
1161 static void
1162 xmesa_viewport(GLcontext *ctx, GLint x, GLint y, GLsizei w, GLsizei h)
1163 {
1164    (void) x;
1165    (void) y;
1166    (void) w;
1167    (void) h;
1168    update_framebuffer_size(ctx);
1169 }
1170
1171
1172 #if ENABLE_EXT_timer_query
1173
1174 /*
1175  * The GL_EXT_timer_query extension is not enabled for the XServer
1176  * indirect renderer.  Not sure about how/if wrapping of gettimeofday()
1177  * is done, etc.
1178  */
1179
1180 struct xmesa_query_object
1181 {
1182    struct gl_query_object Base;
1183    struct timeval StartTime;
1184 };
1185
1186
1187 static struct gl_query_object *
1188 xmesa_new_query_object(GLcontext *ctx, GLuint id)
1189 {
1190    struct xmesa_query_object *q = CALLOC_STRUCT(xmesa_query_object);
1191    if (q) {
1192       q->Base.Id = id;
1193       q->Base.Ready = GL_TRUE;
1194    }
1195    return &q->Base;
1196 }
1197
1198
1199 static void
1200 xmesa_begin_query(GLcontext *ctx, GLenum target, struct gl_query_object *q)
1201 {
1202    if (target == GL_TIME_ELAPSED_EXT) {
1203       struct xmesa_query_object *xq = (struct xmesa_query_object *) q;
1204       (void) gettimeofday(&xq->StartTime, NULL);
1205    }
1206 }
1207
1208
1209 /**
1210  * Return the difference between the two given times in microseconds.
1211  */
1212 #ifdef __VMS
1213 #define suseconds_t unsigned int
1214 #endif
1215 static GLuint64EXT
1216 time_diff(const struct timeval *t0, const struct timeval *t1)
1217 {
1218    GLuint64EXT seconds0 = t0->tv_sec & 0xff;  /* 0 .. 255 seconds */
1219    GLuint64EXT seconds1 = t1->tv_sec & 0xff;  /* 0 .. 255 seconds */
1220    GLuint64EXT nanosec0 = (seconds0 * 1000000 + t0->tv_usec) * 1000;
1221    GLuint64EXT nanosec1 = (seconds1 * 1000000 + t1->tv_usec) * 1000;
1222    return nanosec1 - nanosec0;
1223 }
1224
1225
1226 static void
1227 xmesa_end_query(GLcontext *ctx, GLenum target, struct gl_query_object *q)
1228 {
1229    if (target == GL_TIME_ELAPSED_EXT) {
1230       struct xmesa_query_object *xq = (struct xmesa_query_object *) q;
1231       struct timeval endTime;
1232       (void) gettimeofday(&endTime, NULL);
1233       /* result is in nanoseconds! */
1234       q->Result = time_diff(&xq->StartTime, &endTime);
1235    }
1236    q->Ready = GL_TRUE;
1237 }
1238
1239 #endif /* ENABLE_timer_query */
1240
1241
1242 /**
1243  * Initialize the device driver function table with the functions
1244  * we implement in this driver.
1245  */
1246 void
1247 xmesa_init_driver_functions( XMesaVisual xmvisual,
1248                              struct dd_function_table *driver )
1249 {
1250    driver->GetString = get_string;
1251    driver->UpdateState = xmesa_update_state;
1252    driver->GetBufferSize = get_buffer_size;
1253    driver->Flush = finish_or_flush;
1254    driver->Finish = finish_or_flush;
1255    driver->ClearIndex = clear_index;
1256    driver->ClearColor = clear_color;
1257    driver->IndexMask = index_mask;
1258    driver->ColorMask = color_mask;
1259    driver->Enable = enable;
1260    driver->Clear = clear_buffers;
1261    driver->ResizeBuffers = xmesa_resize_buffers;
1262    driver->Viewport = xmesa_viewport;
1263 #ifndef XFree86Server
1264    driver->CopyPixels = xmesa_CopyPixels;
1265    if (xmvisual->undithered_pf == PF_8R8G8B &&
1266        xmvisual->dithered_pf == PF_8R8G8B) {
1267       driver->DrawPixels = xmesa_DrawPixels_8R8G8B;
1268    }
1269    else if (xmvisual->undithered_pf == PF_5R6G5B) {
1270       driver->DrawPixels = xmesa_DrawPixels_5R6G5B;
1271    }
1272 #endif
1273    driver->TestProxyTexImage = test_proxy_teximage;
1274 #if ENABLE_EXT_texure_compression_s3tc
1275    driver->ChooseTextureFormat = choose_tex_format;
1276 #else
1277    (void) choose_tex_format;
1278 #endif
1279
1280 #if ENABLE_EXT_timer_query
1281    driver->NewQueryObject = xmesa_new_query_object;
1282    driver->BeginQuery = xmesa_begin_query;
1283    driver->EndQuery = xmesa_end_query;
1284 #endif
1285 }
1286
1287
1288 #define XMESA_NEW_POINT  (_NEW_POINT | \
1289                           _NEW_RENDERMODE | \
1290                           _SWRAST_NEW_RASTERMASK)
1291
1292 #define XMESA_NEW_LINE   (_NEW_LINE | \
1293                           _NEW_TEXTURE | \
1294                           _NEW_LIGHT | \
1295                           _NEW_DEPTH | \
1296                           _NEW_RENDERMODE | \
1297                           _SWRAST_NEW_RASTERMASK)
1298
1299 #define XMESA_NEW_TRIANGLE (_NEW_POLYGON | \
1300                             _NEW_TEXTURE | \
1301                             _NEW_LIGHT | \
1302                             _NEW_DEPTH | \
1303                             _NEW_RENDERMODE | \
1304                             _SWRAST_NEW_RASTERMASK)
1305
1306
1307 /**
1308  * Extend the software rasterizer with our line/point/triangle
1309  * functions.
1310  * Called during context creation only.
1311  */
1312 void xmesa_register_swrast_functions( GLcontext *ctx )
1313 {
1314    SWcontext *swrast = SWRAST_CONTEXT( ctx );
1315
1316    swrast->choose_point = xmesa_choose_point;
1317    swrast->choose_line = xmesa_choose_line;
1318    swrast->choose_triangle = xmesa_choose_triangle;
1319
1320    /* XXX these lines have no net effect.  Remove??? */
1321    swrast->InvalidatePointMask |= XMESA_NEW_POINT;
1322    swrast->InvalidateLineMask |= XMESA_NEW_LINE;
1323    swrast->InvalidateTriangleMask |= XMESA_NEW_TRIANGLE;
1324 }