src/mesa/main/pack.c

   1 /*
   2  * Mesa 3-D graphics library
   3  *
   4  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
   5  * Copyright (C) 2009-2010  VMware, Inc.  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  * THEA AUTHORS 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 /**
  27  * \file pack.c
  28  * Image and pixel span packing and unpacking.
  29  */
  30
  31
  32 #include "glheader.h"
  33 #include "colormac.h"
  34 #include "enums.h"
  35 #include "image.h"
  36 #include "imports.h"
  37 #include "mtypes.h"
  38 #include "pack.h"
  39 #include "pixeltransfer.h"
  40 #include "imports.h"
  41 #include "../../gallium/auxiliary/util/u_format_rgb9e5.h"
  42 #include "../../gallium/auxiliary/util/u_format_r11g11b10f.h"
  43
  44
  45 /**
  46  * NOTE:
  47  * Normally, BYTE_TO_FLOAT(0) returns 0.00392  That causes problems when
  48  * we later convert the float to a packed integer value (such as for
  49  * GL_RGB5_A1) because we'll wind up with a non-zero value.
  50  *
  51  * We redefine the macros here so zero is handled correctly.
  52  */
  53 #undef BYTE_TO_FLOAT
  54 #define BYTE_TO_FLOAT(B)    ((B) == 0 ? 0.0F : ((2.0F * (B) + 1.0F) * (1.0F/255.0F)))
  55
  56 #undef SHORT_TO_FLOAT
  57 #define SHORT_TO_FLOAT(S)   ((S) == 0 ? 0.0F : ((2.0F * (S) + 1.0F) * (1.0F/65535.0F)))
  58
  59
  60
  61 /** Compute ceiling of integer quotient of A divided by B. */
  62 #define CEILING( A, B )  ( (A) % (B) == 0 ? (A)/(B) : (A)/(B)+1 )
  63
  64
  65 /**
  66  * Flip the 8 bits in each byte of the given array.
  67  *
  68  * \param p array.
  69  * \param n number of bytes.
  70  *
  71  * \todo try this trick to flip bytes someday:
  72  * \code
  73  *  v = ((v & 0x55555555) << 1) | ((v >> 1) & 0x55555555);
  74  *  v = ((v & 0x33333333) << 2) | ((v >> 2) & 0x33333333);
  75  *  v = ((v & 0x0f0f0f0f) << 4) | ((v >> 4) & 0x0f0f0f0f);
  76  * \endcode
  77  */
  78 static void
  79 flip_bytes( GLubyte *p, GLuint n )
  80 {
  81    GLuint i, a, b;
  82    for (i = 0; i < n; i++) {
  83       b = (GLuint) p[i];        /* words are often faster than bytes */
  84       a = ((b & 0x01) << 7) |
  85           ((b & 0x02) << 5) |
  86           ((b & 0x04) << 3) |
  87           ((b & 0x08) << 1) |
  88           ((b & 0x10) >> 1) |
  89           ((b & 0x20) >> 3) |
  90           ((b & 0x40) >> 5) |
  91           ((b & 0x80) >> 7);
  92       p[i] = (GLubyte) a;
  93    }
  94 }
  95
  96
  97
  98 /*
  99  * Unpack a 32x32 pixel polygon stipple from user memory using the
 100  * current pixel unpack settings.
 101  */
 102 void
 103 _mesa_unpack_polygon_stipple( const GLubyte *pattern, GLuint dest[32],
 104                               const struct gl_pixelstore_attrib *unpacking )
 105 {
 106    GLubyte *ptrn = (GLubyte *) _mesa_unpack_bitmap(32, 32, pattern, unpacking);
 107    if (ptrn) {
 108       /* Convert pattern from GLubytes to GLuints and handle big/little
 109        * endian differences
 110        */
 111       GLubyte *p = ptrn;
 112       GLint i;
 113       for (i = 0; i < 32; i++) {
 114          dest[i] = (p[0] << 24)
 115                  | (p[1] << 16)
 116                  | (p[2] <<  8)
 117                  | (p[3]      );
 118          p += 4;
 119       }
 120       free(ptrn);
 121    }
 122 }
 123
 124
 125 /*
 126  * Pack polygon stipple into user memory given current pixel packing
 127  * settings.
 128  */
 129 void
 130 _mesa_pack_polygon_stipple( const GLuint pattern[32], GLubyte *dest,
 131                             const struct gl_pixelstore_attrib *packing )
 132 {
 133    /* Convert pattern from GLuints to GLubytes to handle big/little
 134     * endian differences.
 135     */
 136    GLubyte ptrn[32*4];
 137    GLint i;
 138    for (i = 0; i < 32; i++) {
 139       ptrn[i * 4 + 0] = (GLubyte) ((pattern[i] >> 24) & 0xff);
 140       ptrn[i * 4 + 1] = (GLubyte) ((pattern[i] >> 16) & 0xff);
 141       ptrn[i * 4 + 2] = (GLubyte) ((pattern[i] >> 8 ) & 0xff);
 142       ptrn[i * 4 + 3] = (GLubyte) ((pattern[i]      ) & 0xff);
 143    }
 144
 145    _mesa_pack_bitmap(32, 32, ptrn, dest, packing);
 146 }
 147
 148
 149 /*
 150  * Unpack bitmap data.  Resulting data will be in most-significant-bit-first
 151  * order with row alignment = 1 byte.
 152  */
 153 GLvoid *
 154 _mesa_unpack_bitmap( GLint width, GLint height, const GLubyte *pixels,
 155                      const struct gl_pixelstore_attrib *packing )
 156 {
 157    GLint bytes, row, width_in_bytes;
 158    GLubyte *buffer, *dst;
 159
 160    if (!pixels)
 161       return NULL;
 162
 163    /* Alloc dest storage */
 164    bytes = ((width + 7) / 8 * height);
 165    buffer = (GLubyte *) malloc( bytes );
 166    if (!buffer)
 167       return NULL;
 168
 169    width_in_bytes = CEILING( width, 8 );
 170    dst = buffer;
 171    for (row = 0; row < height; row++) {
 172       const GLubyte *src = (const GLubyte *)
 173          _mesa_image_address2d(packing, pixels, width, height,
 174                                GL_COLOR_INDEX, GL_BITMAP, row, 0);
 175       if (!src) {
 176          free(buffer);
 177          return NULL;
 178       }
 179
 180       if ((packing->SkipPixels & 7) == 0) {
 181          memcpy( dst, src, width_in_bytes );
 182          if (packing->LsbFirst) {
 183             flip_bytes( dst, width_in_bytes );
 184          }
 185       }
 186       else {
 187          /* handling SkipPixels is a bit tricky (no pun intended!) */
 188          GLint i;
 189          if (packing->LsbFirst) {
 190             GLubyte srcMask = 1 << (packing->SkipPixels & 0x7);
 191             GLubyte dstMask = 128;
 192             const GLubyte *s = src;
 193             GLubyte *d = dst;
 194             *d = 0;
 195             for (i = 0; i < width; i++) {
 196                if (*s & srcMask) {
 197                   *d |= dstMask;
 198                }
 199                if (srcMask == 128) {
 200                   srcMask = 1;
 201                   s++;
 202                }
 203                else {
 204                   srcMask = srcMask << 1;
 205                }
 206                if (dstMask == 1) {
 207                   dstMask = 128;
 208                   d++;
 209                   *d = 0;
 210                }
 211                else {
 212                   dstMask = dstMask >> 1;
 213                }
 214             }
 215          }
 216          else {
 217             GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7);
 218             GLubyte dstMask = 128;
 219             const GLubyte *s = src;
 220             GLubyte *d = dst;
 221             *d = 0;
 222             for (i = 0; i < width; i++) {
 223                if (*s & srcMask) {
 224                   *d |= dstMask;
 225                }
 226                if (srcMask == 1) {
 227                   srcMask = 128;
 228                   s++;
 229                }
 230                else {
 231                   srcMask = srcMask >> 1;
 232                }
 233                if (dstMask == 1) {
 234                   dstMask = 128;
 235                   d++;
 236                   *d = 0;
 237                }
 238                else {
 239                   dstMask = dstMask >> 1;
 240                }
 241             }
 242          }
 243       }
 244       dst += width_in_bytes;
 245    }
 246
 247    return buffer;
 248 }
 249
 250
 251 /*
 252  * Pack bitmap data.
 253  */
 254 void
 255 _mesa_pack_bitmap( GLint width, GLint height, const GLubyte *source,
 256                    GLubyte *dest, const struct gl_pixelstore_attrib *packing )
 257 {
 258    GLint row, width_in_bytes;
 259    const GLubyte *src;
 260
 261    if (!source)
 262       return;
 263
 264    width_in_bytes = CEILING( width, 8 );
 265    src = source;
 266    for (row = 0; row < height; row++) {
 267       GLubyte *dst = (GLubyte *) _mesa_image_address2d(packing, dest,
 268                        width, height, GL_COLOR_INDEX, GL_BITMAP, row, 0);
 269       if (!dst)
 270          return;
 271
 272       if ((packing->SkipPixels & 7) == 0) {
 273          memcpy( dst, src, width_in_bytes );
 274          if (packing->LsbFirst) {
 275             flip_bytes( dst, width_in_bytes );
 276          }
 277       }
 278       else {
 279          /* handling SkipPixels is a bit tricky (no pun intended!) */
 280          GLint i;
 281          if (packing->LsbFirst) {
 282             GLubyte srcMask = 128;
 283             GLubyte dstMask = 1 << (packing->SkipPixels & 0x7);
 284             const GLubyte *s = src;
 285             GLubyte *d = dst;
 286             *d = 0;
 287             for (i = 0; i < width; i++) {
 288                if (*s & srcMask) {
 289                   *d |= dstMask;
 290                }
 291                if (srcMask == 1) {
 292                   srcMask = 128;
 293                   s++;
 294                }
 295                else {
 296                   srcMask = srcMask >> 1;
 297                }
 298                if (dstMask == 128) {
 299                   dstMask = 1;
 300                   d++;
 301                   *d = 0;
 302                }
 303                else {
 304                   dstMask = dstMask << 1;
 305                }
 306             }
 307          }
 308          else {
 309             GLubyte srcMask = 128;
 310             GLubyte dstMask = 128 >> (packing->SkipPixels & 0x7);
 311             const GLubyte *s = src;
 312             GLubyte *d = dst;
 313             *d = 0;
 314             for (i = 0; i < width; i++) {
 315                if (*s & srcMask) {
 316                   *d |= dstMask;
 317                }
 318                if (srcMask == 1) {
 319                   srcMask = 128;
 320                   s++;
 321                }
 322                else {
 323                   srcMask = srcMask >> 1;
 324                }
 325                if (dstMask == 1) {
 326                   dstMask = 128;
 327                   d++;
 328                   *d = 0;
 329                }
 330                else {
 331                   dstMask = dstMask >> 1;
 332                }
 333             }
 334          }
 335       }
 336       src += width_in_bytes;
 337    }
 338 }
 339
 340
 341 /**
 342  * Get indexes of color components for a basic color format, such as
 343  * GL_RGBA, GL_RED, GL_LUMINANCE_ALPHA, etc.  Return -1 for indexes
 344  * that do not apply.
 345  */
 346 static void
 347 get_component_indexes(GLenum format,
 348                       GLint *redIndex,
 349                       GLint *greenIndex,
 350                       GLint *blueIndex,
 351                       GLint *alphaIndex,
 352                       GLint *luminanceIndex,
 353                       GLint *intensityIndex)
 354 {
 355    *redIndex = -1;
 356    *greenIndex = -1;
 357    *blueIndex = -1;
 358    *alphaIndex = -1;
 359    *luminanceIndex = -1;
 360    *intensityIndex = -1;
 361
 362    switch (format) {
 363    case GL_LUMINANCE:
 364    case GL_LUMINANCE_INTEGER_EXT:
 365       *luminanceIndex = 0;
 366       break;
 367    case GL_LUMINANCE_ALPHA:
 368    case GL_LUMINANCE_ALPHA_INTEGER_EXT:
 369       *luminanceIndex = 0;
 370       *alphaIndex = 1;
 371       break;
 372    case GL_INTENSITY:
 373       *intensityIndex = 0;
 374       break;
 375    case GL_RED:
 376    case GL_RED_INTEGER_EXT:
 377       *redIndex = 0;
 378       break;
 379    case GL_GREEN:
 380    case GL_GREEN_INTEGER_EXT:
 381       *greenIndex = 0;
 382       break;
 383    case GL_BLUE:
 384    case GL_BLUE_INTEGER_EXT:
 385       *blueIndex = 0;
 386       break;
 387    case GL_ALPHA:
 388    case GL_ALPHA_INTEGER_EXT:
 389       *alphaIndex = 0;
 390       break;
 391    case GL_RG:
 392    case GL_RG_INTEGER:
 393       *redIndex = 0;
 394       *greenIndex = 1;
 395       break;
 396    case GL_RGB:
 397    case GL_RGB_INTEGER_EXT:
 398       *redIndex = 0;
 399       *greenIndex = 1;
 400       *blueIndex = 2;
 401       break;
 402    case GL_BGR:
 403    case GL_BGR_INTEGER_EXT:
 404       *blueIndex = 0;
 405       *greenIndex = 1;
 406       *redIndex = 2;
 407       break;
 408    case GL_RGBA:
 409    case GL_RGBA_INTEGER_EXT:
 410       *redIndex = 0;
 411       *greenIndex = 1;
 412       *blueIndex = 2;
 413       *alphaIndex = 3;
 414       break;
 415    case GL_BGRA:
 416    case GL_BGRA_INTEGER:
 417       *redIndex = 2;
 418       *greenIndex = 1;
 419       *blueIndex = 0;
 420       *alphaIndex = 3;
 421       break;
 422    case GL_ABGR_EXT:
 423       *redIndex = 3;
 424       *greenIndex = 2;
 425       *blueIndex = 1;
 426       *alphaIndex = 0;
 427       break;
 428    case GL_DU8DV8_ATI:
 429    case GL_DUDV_ATI:
 430       *redIndex = 0;
 431       *greenIndex = 1;
 432       break;
 433    default:
 434       assert(0 && "bad format in get_component_indexes()");
 435    }
 436 }
 437
 438
 439
 440 /**
 441  * For small integer types, return the min and max possible values.
 442  * Used for clamping floats to unscaled integer types.
 443  * \return GL_TRUE if type is handled, GL_FALSE otherwise.
 444  */
 445 static GLboolean
 446 get_type_min_max(GLenum type, GLfloat *min, GLfloat *max)
 447 {
 448    switch (type) {
 449    case GL_BYTE:
 450       *min = -128.0;
 451       *max = 127.0;
 452       return GL_TRUE;
 453    case GL_UNSIGNED_BYTE:
 454       *min = 0.0;
 455       *max = 255.0;
 456       return GL_TRUE;
 457    case GL_SHORT:
 458       *min = -32768.0;
 459       *max = 32767.0;
 460       return GL_TRUE;
 461    case GL_UNSIGNED_SHORT:
 462       *min = 0.0;
 463       *max = 65535.0;
 464       return GL_TRUE;
 465    default:
 466       return GL_FALSE;
 467    }
 468 }
 469
 470
 471
 472 /**
 473  * Used to pack an array [][4] of RGBA float colors as specified
 474  * by the dstFormat, dstType and dstPacking.  Used by glReadPixels.
 475  * Historically, the RGBA values were in [0,1] and rescaled to fit
 476  * into GLubytes, etc.  But with new integer formats, the RGBA values
 477  * may have any value and we don't always rescale when converting to
 478  * integers.
 479  *
 480  * Note: the rgba values will be modified by this function when any pixel
 481  * transfer ops are enabled.
 482  */
 483 void
 484 _mesa_pack_rgba_span_float(struct gl_context *ctx, GLuint n, GLfloat rgba[][4],
 485                            GLenum dstFormat, GLenum dstType,
 486                            GLvoid *dstAddr,
 487                            const struct gl_pixelstore_attrib *dstPacking,
 488                            GLbitfield transferOps)
 489 {
 490    GLfloat *luminance;
 491    const GLint comps = _mesa_components_in_format(dstFormat);
 492    const GLboolean intDstFormat = _mesa_is_integer_format(dstFormat);
 493    GLuint i;
 494
 495    if (dstFormat == GL_LUMINANCE ||
 496        dstFormat == GL_LUMINANCE_ALPHA ||
 497        dstFormat == GL_LUMINANCE_INTEGER_EXT ||
 498        dstFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT) {
 499       luminance = (GLfloat *) malloc(n * sizeof(GLfloat));
 500       if (!luminance) {
 501          _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
 502          return;
 503       }
 504    }
 505    else {
 506       luminance = NULL;
 507    }
 508
 509    if (transferOps) {
 510       _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
 511    }
 512
 513    /*
 514     * Component clamping (besides clamping to [0,1] in
 515     * _mesa_apply_rgba_transfer_ops()).
 516     */
 517    if (intDstFormat) {
 518       /* clamping to dest type's min/max values */
 519       GLfloat min, max;
 520       if (get_type_min_max(dstType, &min, &max)) {
 521          for (i = 0; i < n; i++) {
 522             rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], min, max);
 523             rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], min, max);
 524             rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], min, max);
 525             rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], min, max);
 526          }
 527       }
 528    }
 529    else if (dstFormat == GL_LUMINANCE || dstFormat == GL_LUMINANCE_ALPHA) {
 530       /* compute luminance values */
 531       if (transferOps & IMAGE_CLAMP_BIT) {
 532          for (i = 0; i < n; i++) {
 533             GLfloat sum = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
 534             luminance[i] = CLAMP(sum, 0.0F, 1.0F);
 535          }
 536       }
 537       else {
 538          for (i = 0; i < n; i++) {
 539             luminance[i] = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
 540          }
 541       }
 542    }
 543
 544    /*
 545     * Pack/store the pixels.  Ugh!  Lots of cases!!!
 546     */
 547    switch (dstType) {
 548       case GL_UNSIGNED_BYTE:
 549          {
 550             GLubyte *dst = (GLubyte *) dstAddr;
 551             switch (dstFormat) {
 552                case GL_RED:
 553                   for (i=0;i<n;i++)
 554                      dst[i] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
 555                   break;
 556                case GL_GREEN:
 557                   for (i=0;i<n;i++)
 558                      dst[i] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
 559                   break;
 560                case GL_BLUE:
 561                   for (i=0;i<n;i++)
 562                      dst[i] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
 563                   break;
 564                case GL_ALPHA:
 565                   for (i=0;i<n;i++)
 566                      dst[i] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
 567                   break;
 568                case GL_LUMINANCE:
 569                   for (i=0;i<n;i++)
 570                      dst[i] = FLOAT_TO_UBYTE(luminance[i]);
 571                   break;
 572                case GL_LUMINANCE_ALPHA:
 573                   for (i=0;i<n;i++) {
 574                      dst[i*2+0] = FLOAT_TO_UBYTE(luminance[i]);
 575                      dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
 576                   }
 577                   break;
 578                case GL_RG:
 579                   for (i=0;i<n;i++) {
 580                      dst[i*2+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
 581                      dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
 582                   }
 583                   break;
 584                case GL_RGB:
 585                   for (i=0;i<n;i++) {
 586                      dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
 587                      dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
 588                      dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
 589                   }
 590                   break;
 591                case GL_RGBA:
 592                   for (i=0;i<n;i++) {
 593                      dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
 594                      dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
 595                      dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
 596                      dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
 597                   }
 598                   break;
 599                case GL_BGR:
 600                   for (i=0;i<n;i++) {
 601                      dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
 602                      dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
 603                      dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
 604                   }
 605                   break;
 606                case GL_BGRA:
 607                   for (i=0;i<n;i++) {
 608                      dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
 609                      dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
 610                      dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
 611                      dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
 612                   }
 613                   break;
 614                case GL_ABGR_EXT:
 615                   for (i=0;i<n;i++) {
 616                      dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
 617                      dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
 618                      dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
 619                      dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
 620                   }
 621                   break;
 622                case GL_RED_INTEGER_EXT:
 623                   for (i=0;i<n;i++) {
 624                      dst[i] = (GLubyte) rgba[i][RCOMP];
 625                   }
 626                   break;
 627                case GL_GREEN_INTEGER_EXT:
 628                   for (i=0;i<n;i++) {
 629                      dst[i] = (GLubyte) rgba[i][GCOMP];
 630                   }
 631                   break;
 632                case GL_BLUE_INTEGER_EXT:
 633                   for (i=0;i<n;i++) {
 634                      dst[i] = (GLubyte) rgba[i][BCOMP];
 635                   }
 636                   break;
 637                case GL_ALPHA_INTEGER_EXT:
 638                   for (i=0;i<n;i++) {
 639                      dst[i] = (GLubyte) rgba[i][ACOMP];
 640                   }
 641                   break;
 642                case GL_RGB_INTEGER_EXT:
 643                   for (i=0;i<n;i++) {
 644                      dst[i*3+0] = (GLubyte) rgba[i][RCOMP];
 645                      dst[i*3+1] = (GLubyte) rgba[i][GCOMP];
 646                      dst[i*3+2] = (GLubyte) rgba[i][BCOMP];
 647                   }
 648                   break;
 649                case GL_RGBA_INTEGER_EXT:
 650                   for (i=0;i<n;i++) {
 651                      dst[i*4+0] = (GLubyte) rgba[i][RCOMP];
 652                      dst[i*4+1] = (GLubyte) rgba[i][GCOMP];
 653                      dst[i*4+2] = (GLubyte) rgba[i][BCOMP];
 654                      dst[i*4+3] = (GLubyte) rgba[i][ACOMP];
 655                   }
 656                   break;
 657                case GL_BGR_INTEGER_EXT:
 658                   for (i=0;i<n;i++) {
 659                      dst[i*3+0] = (GLubyte) rgba[i][BCOMP];
 660                      dst[i*3+1] = (GLubyte) rgba[i][GCOMP];
 661                      dst[i*3+2] = (GLubyte) rgba[i][RCOMP];
 662                   }
 663                   break;
 664                case GL_BGRA_INTEGER_EXT:
 665                   for (i=0;i<n;i++) {
 666                      dst[i*4+0] = (GLubyte) rgba[i][BCOMP];
 667                      dst[i*4+1] = (GLubyte) rgba[i][GCOMP];
 668                      dst[i*4+2] = (GLubyte) rgba[i][RCOMP];
 669                      dst[i*4+3] = (GLubyte) rgba[i][ACOMP];
 670                   }
 671                   break;
 672                case GL_LUMINANCE_INTEGER_EXT:
 673                   for (i=0;i<n;i++) {
 674                      dst[i*2+0] = (GLubyte) (rgba[i][RCOMP] +
 675                                              rgba[i][GCOMP] +
 676                                              rgba[i][BCOMP]);
 677                      dst[i*2+1] = (GLubyte) rgba[i][ACOMP];
 678                   }
 679                   break;
 680                case GL_LUMINANCE_ALPHA_INTEGER_EXT:
 681                   for (i=0;i<n;i++) {
 682                      dst[i] = (GLubyte) (rgba[i][RCOMP] +
 683                                          rgba[i][GCOMP] +
 684                                          rgba[i][BCOMP]);
 685                   }
 686                   break;
 687                case GL_DUDV_ATI:
 688                case GL_DU8DV8_ATI:
 689                   for (i=0;i<n;i++) {
 690                      dst[i*2+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
 691                      dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
 692                   }
 693                   break;
 694                default:
 695                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
 696             }
 697          }
 698          break;
 699       case GL_BYTE:
 700          {
 701             GLbyte *dst = (GLbyte *) dstAddr;
 702             switch (dstFormat) {
 703                case GL_RED:
 704                   for (i=0;i<n;i++)
 705                      dst[i] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
 706                   break;
 707                case GL_GREEN:
 708                   for (i=0;i<n;i++)
 709                      dst[i] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
 710                   break;
 711                case GL_BLUE:
 712                   for (i=0;i<n;i++)
 713                      dst[i] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
 714                   break;
 715                case GL_ALPHA:
 716                   for (i=0;i<n;i++)
 717                      dst[i] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
 718                   break;
 719                case GL_LUMINANCE:
 720                   for (i=0;i<n;i++)
 721                      dst[i] = FLOAT_TO_BYTE(luminance[i]);
 722                   break;
 723                case GL_LUMINANCE_ALPHA:
 724                   for (i=0;i<n;i++) {
 725                      dst[i*2+0] = FLOAT_TO_BYTE(luminance[i]);
 726                      dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
 727                   }
 728                   break;
 729                case GL_RG:
 730                   for (i=0;i<n;i++) {
 731                      dst[i*2+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
 732                      dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
 733                   }
 734                   break;
 735                case GL_RGB:
 736                   for (i=0;i<n;i++) {
 737                      dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
 738                      dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
 739                      dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
 740                   }
 741                   break;
 742                case GL_RGBA:
 743                   for (i=0;i<n;i++) {
 744                      dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
 745                      dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
 746                      dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
 747                      dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
 748                   }
 749                   break;
 750                case GL_BGR:
 751                   for (i=0;i<n;i++) {
 752                      dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
 753                      dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
 754                      dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
 755                   }
 756                   break;
 757                case GL_BGRA:
 758                   for (i=0;i<n;i++) {
 759                      dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
 760                      dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
 761                      dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
 762                      dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
 763                   }
 764                   break;
 765                case GL_ABGR_EXT:
 766                   for (i=0;i<n;i++) {
 767                      dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
 768                      dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
 769                      dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
 770                      dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
 771                   }
 772                   break;
 773                case GL_RED_INTEGER_EXT:
 774                   for (i=0;i<n;i++) {
 775                      dst[i] = (GLbyte) rgba[i][RCOMP];
 776                   }
 777                   break;
 778                case GL_GREEN_INTEGER_EXT:
 779                   for (i=0;i<n;i++) {
 780                      dst[i] = (GLbyte) rgba[i][GCOMP];
 781                   }
 782                   break;
 783                case GL_BLUE_INTEGER_EXT:
 784                   for (i=0;i<n;i++) {
 785                      dst[i] = (GLbyte) rgba[i][BCOMP];
 786                   }
 787                   break;
 788                case GL_ALPHA_INTEGER_EXT:
 789                   for (i=0;i<n;i++) {
 790                      dst[i] = (GLbyte) rgba[i][ACOMP];
 791                   }
 792                   break;
 793                case GL_RGB_INTEGER_EXT:
 794                   for (i=0;i<n;i++) {
 795                      dst[i*3+0] = (GLbyte) rgba[i][RCOMP];
 796                      dst[i*3+1] = (GLbyte) rgba[i][GCOMP];
 797                      dst[i*3+2] = (GLbyte) rgba[i][BCOMP];
 798                   }
 799                   break;
 800                case GL_RGBA_INTEGER_EXT:
 801                   for (i=0;i<n;i++) {
 802                      dst[i*4+0] = (GLbyte) rgba[i][RCOMP];
 803                      dst[i*4+1] = (GLbyte) rgba[i][GCOMP];
 804                      dst[i*4+2] = (GLbyte) rgba[i][BCOMP];
 805                      dst[i*4+3] = (GLbyte) rgba[i][ACOMP];
 806                   }
 807                   break;
 808                case GL_BGR_INTEGER_EXT:
 809                   for (i=0;i<n;i++) {
 810                      dst[i*3+0] = (GLbyte) rgba[i][BCOMP];
 811                      dst[i*3+1] = (GLbyte) rgba[i][GCOMP];
 812                      dst[i*3+2] = (GLbyte) rgba[i][RCOMP];
 813                   }
 814                   break;
 815                case GL_BGRA_INTEGER_EXT:
 816                   for (i=0;i<n;i++) {
 817                      dst[i*4+0] = (GLbyte) rgba[i][BCOMP];
 818                      dst[i*4+1] = (GLbyte) rgba[i][GCOMP];
 819                      dst[i*4+2] = (GLbyte) rgba[i][RCOMP];
 820                      dst[i*4+3] = (GLbyte) rgba[i][ACOMP];
 821                   }
 822                   break;
 823                case GL_LUMINANCE_INTEGER_EXT:
 824                   for (i=0;i<n;i++) {
 825                      dst[i*2+0] = (GLbyte) (rgba[i][RCOMP] +
 826                                             rgba[i][GCOMP] +
 827                                             rgba[i][BCOMP]);
 828                      dst[i*2+1] = (GLbyte) rgba[i][ACOMP];
 829                   }
 830                   break;
 831                case GL_LUMINANCE_ALPHA_INTEGER_EXT:
 832                   for (i=0;i<n;i++) {
 833                      dst[i] = (GLbyte) (rgba[i][RCOMP] +
 834                                         rgba[i][GCOMP] +
 835                                         rgba[i][BCOMP]);
 836                   }
 837                   break;
 838                case GL_DUDV_ATI:
 839                case GL_DU8DV8_ATI:
 840                   for (i=0;i<n;i++) {
 841                      dst[i*2+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
 842                      dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
 843                   }
 844                   break;
 845                default:
 846                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
 847             }
 848          }
 849          break;
 850       case GL_UNSIGNED_SHORT:
 851          {
 852             GLushort *dst = (GLushort *) dstAddr;
 853             switch (dstFormat) {
 854                case GL_RED:
 855                   for (i=0;i<n;i++)
 856                      CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][RCOMP]);
 857                   break;
 858                case GL_GREEN:
 859                   for (i=0;i<n;i++)
 860                      CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][GCOMP]);
 861                   break;
 862                case GL_BLUE:
 863                   for (i=0;i<n;i++)
 864                      CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][BCOMP]);
 865                   break;
 866                case GL_ALPHA:
 867                   for (i=0;i<n;i++)
 868                      CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][ACOMP]);
 869                   break;
 870                case GL_LUMINANCE:
 871                   for (i=0;i<n;i++)
 872                      UNCLAMPED_FLOAT_TO_USHORT(dst[i], luminance[i]);
 873                   break;
 874                case GL_LUMINANCE_ALPHA:
 875                   for (i=0;i<n;i++) {
 876                      UNCLAMPED_FLOAT_TO_USHORT(dst[i*2+0], luminance[i]);
 877                      CLAMPED_FLOAT_TO_USHORT(dst[i*2+1], rgba[i][ACOMP]);
 878                   }
 879                   break;
 880                case GL_RG:
 881                   for (i=0;i<n;i++) {
 882                      CLAMPED_FLOAT_TO_USHORT(dst[i*2+0], rgba[i][RCOMP]);
 883                      CLAMPED_FLOAT_TO_USHORT(dst[i*2+1], rgba[i][GCOMP]);
 884                   }
 885                   break;
 886                case GL_RGB:
 887                   for (i=0;i<n;i++) {
 888                      CLAMPED_FLOAT_TO_USHORT(dst[i*3+0], rgba[i][RCOMP]);
 889                      CLAMPED_FLOAT_TO_USHORT(dst[i*3+1], rgba[i][GCOMP]);
 890                      CLAMPED_FLOAT_TO_USHORT(dst[i*3+2], rgba[i][BCOMP]);
 891                   }
 892                   break;
 893                case GL_RGBA:
 894                   for (i=0;i<n;i++) {
 895                      CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][RCOMP]);
 896                      CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][GCOMP]);
 897                      CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][BCOMP]);
 898                      CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][ACOMP]);
 899                   }
 900                   break;
 901                case GL_BGR:
 902                   for (i=0;i<n;i++) {
 903                      CLAMPED_FLOAT_TO_USHORT(dst[i*3+0], rgba[i][BCOMP]);
 904                      CLAMPED_FLOAT_TO_USHORT(dst[i*3+1], rgba[i][GCOMP]);
 905                      CLAMPED_FLOAT_TO_USHORT(dst[i*3+2], rgba[i][RCOMP]);
 906                   }
 907                   break;
 908                case GL_BGRA:
 909                   for (i=0;i<n;i++) {
 910                      CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][BCOMP]);
 911                      CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][GCOMP]);
 912                      CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][RCOMP]);
 913                      CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][ACOMP]);
 914                   }
 915                   break;
 916                case GL_ABGR_EXT:
 917                   for (i=0;i<n;i++) {
 918                      CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][ACOMP]);
 919                      CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][BCOMP]);
 920                      CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][GCOMP]);
 921                      CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][RCOMP]);
 922                   }
 923                   break;
 924                case GL_RED_INTEGER_EXT:
 925                   for (i=0;i<n;i++) {
 926                      dst[i] = (GLushort) rgba[i][RCOMP];
 927                   }
 928                   break;
 929                case GL_GREEN_INTEGER_EXT:
 930                   for (i=0;i<n;i++) {
 931                      dst[i] = (GLushort) rgba[i][GCOMP];
 932                   }
 933                   break;
 934                case GL_BLUE_INTEGER_EXT:
 935                   for (i=0;i<n;i++) {
 936                      dst[i] = (GLushort) rgba[i][BCOMP];
 937                   }
 938                   break;
 939                case GL_ALPHA_INTEGER_EXT:
 940                   for (i=0;i<n;i++) {
 941                      dst[i] = (GLushort) rgba[i][ACOMP];
 942                   }
 943                   break;
 944                case GL_RGB_INTEGER_EXT:
 945                   for (i=0;i<n;i++) {
 946                      dst[i*3+0] = (GLushort) rgba[i][RCOMP];
 947                      dst[i*3+1] = (GLushort) rgba[i][GCOMP];
 948                      dst[i*3+2] = (GLushort) rgba[i][BCOMP];
 949                   }
 950                   break;
 951                case GL_RGBA_INTEGER_EXT:
 952                   for (i=0;i<n;i++) {
 953                      dst[i*4+0] = (GLushort) rgba[i][RCOMP];
 954                      dst[i*4+1] = (GLushort) rgba[i][GCOMP];
 955                      dst[i*4+2] = (GLushort) rgba[i][BCOMP];
 956                      dst[i*4+3] = (GLushort) rgba[i][ACOMP];
 957                   }
 958                   break;
 959                case GL_BGR_INTEGER_EXT:
 960                   for (i=0;i<n;i++) {
 961                      dst[i*3+0] = (GLushort) rgba[i][BCOMP];
 962                      dst[i*3+1] = (GLushort) rgba[i][GCOMP];
 963                      dst[i*3+2] = (GLushort) rgba[i][RCOMP];
 964                   }
 965                   break;
 966                case GL_BGRA_INTEGER_EXT:
 967                   for (i=0;i<n;i++) {
 968                      dst[i*4+0] = (GLushort) rgba[i][BCOMP];
 969                      dst[i*4+1] = (GLushort) rgba[i][GCOMP];
 970                      dst[i*4+2] = (GLushort) rgba[i][RCOMP];
 971                      dst[i*4+3] = (GLushort) rgba[i][ACOMP];
 972                   }
 973                   break;
 974                case GL_LUMINANCE_INTEGER_EXT:
 975                   for (i=0;i<n;i++) {
 976                      dst[i*2+0] = (GLushort) (rgba[i][RCOMP] +
 977                                               rgba[i][GCOMP] +
 978                                               rgba[i][BCOMP]);
 979                      dst[i*2+1] = (GLushort) rgba[i][ACOMP];
 980                   }
 981                   break;
 982                case GL_LUMINANCE_ALPHA_INTEGER_EXT:
 983                   for (i=0;i<n;i++) {
 984                      dst[i] = (GLushort) (rgba[i][RCOMP] +
 985                                           rgba[i][GCOMP] +
 986                                           rgba[i][BCOMP]);
 987                   }
 988                   break;
 989                case GL_DUDV_ATI:
 990                case GL_DU8DV8_ATI:
 991                   for (i=0;i<n;i++) {
 992                      dst[i*2+0] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
 993                      dst[i*2+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
 994                   }
 995                   break;
 996                default:
 997                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
 998             }
 999          }
1000          break;
1001       case GL_SHORT:
1002          {
1003             GLshort *dst = (GLshort *) dstAddr;
1004             switch (dstFormat) {
1005                case GL_RED:
1006                   for (i=0;i<n;i++)
1007                      dst[i] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1008                   break;
1009                case GL_GREEN:
1010                   for (i=0;i<n;i++)
1011                      dst[i] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1012                   break;
1013                case GL_BLUE:
1014                   for (i=0;i<n;i++)
1015                      dst[i] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1016                   break;
1017                case GL_ALPHA:
1018                   for (i=0;i<n;i++)
1019                      dst[i] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1020                   break;
1021                case GL_LUMINANCE:
1022                   for (i=0;i<n;i++)
1023                      dst[i] = FLOAT_TO_SHORT(luminance[i]);
1024                   break;
1025                case GL_LUMINANCE_ALPHA:
1026                   for (i=0;i<n;i++) {
1027                      dst[i*2+0] = FLOAT_TO_SHORT(luminance[i]);
1028                      dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1029                   }
1030                   break;
1031                case GL_RG:
1032                   for (i=0;i<n;i++) {
1033                      dst[i*2+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1034                      dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1035                   }
1036                   break;
1037                case GL_RGB:
1038                   for (i=0;i<n;i++) {
1039                      dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1040                      dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1041                      dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1042                   }
1043                   break;
1044                case GL_RGBA:
1045                   for (i=0;i<n;i++) {
1046                      dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1047                      dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1048                      dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1049                      dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1050                   }
1051                   break;
1052                case GL_BGR:
1053                   for (i=0;i<n;i++) {
1054                      dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1055                      dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1056                      dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1057                   }
1058                   break;
1059                case GL_BGRA:
1060                   for (i=0;i<n;i++) {
1061                      dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1062                      dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1063                      dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1064                      dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1065                   }
1066                   break;
1067                case GL_ABGR_EXT:
1068                   for (i=0;i<n;i++) {
1069                      dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1070                      dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1071                      dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1072                      dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1073                   }
1074                   break;
1075                case GL_RED_INTEGER_EXT:
1076                   for (i=0;i<n;i++) {
1077                      dst[i] = (GLshort) rgba[i][RCOMP];
1078                   }
1079                   break;
1080                case GL_GREEN_INTEGER_EXT:
1081                   for (i=0;i<n;i++) {
1082                      dst[i] = (GLshort) rgba[i][GCOMP];
1083                   }
1084                   break;
1085                case GL_BLUE_INTEGER_EXT:
1086                   for (i=0;i<n;i++) {
1087                      dst[i] = (GLshort) rgba[i][BCOMP];
1088                   }
1089                   break;
1090                case GL_ALPHA_INTEGER_EXT:
1091                   for (i=0;i<n;i++) {
1092                      dst[i] = (GLshort) rgba[i][ACOMP];
1093                   }
1094                   break;
1095                case GL_RGB_INTEGER_EXT:
1096                   for (i=0;i<n;i++) {
1097                      dst[i*3+0] = (GLshort) rgba[i][RCOMP];
1098                      dst[i*3+1] = (GLshort) rgba[i][GCOMP];
1099                      dst[i*3+2] = (GLshort) rgba[i][BCOMP];
1100                   }
1101                   break;
1102                case GL_RGBA_INTEGER_EXT:
1103                   for (i=0;i<n;i++) {
1104                      dst[i*4+0] = (GLshort) rgba[i][RCOMP];
1105                      dst[i*4+1] = (GLshort) rgba[i][GCOMP];
1106                      dst[i*4+2] = (GLshort) rgba[i][BCOMP];
1107                      dst[i*4+3] = (GLshort) rgba[i][ACOMP];
1108                   }
1109                   break;
1110                case GL_BGR_INTEGER_EXT:
1111                   for (i=0;i<n;i++) {
1112                      dst[i*3+0] = (GLshort) rgba[i][BCOMP];
1113                      dst[i*3+1] = (GLshort) rgba[i][GCOMP];
1114                      dst[i*3+2] = (GLshort) rgba[i][RCOMP];
1115                   }
1116                   break;
1117                case GL_BGRA_INTEGER_EXT:
1118                   for (i=0;i<n;i++) {
1119                      dst[i*4+0] = (GLshort) rgba[i][BCOMP];
1120                      dst[i*4+1] = (GLshort) rgba[i][GCOMP];
1121                      dst[i*4+2] = (GLshort) rgba[i][RCOMP];
1122                      dst[i*4+3] = (GLshort) rgba[i][ACOMP];
1123                   }
1124                   break;
1125                case GL_LUMINANCE_INTEGER_EXT:
1126                   for (i=0;i<n;i++) {
1127                      dst[i*2+0] = (GLshort) (rgba[i][RCOMP] +
1128                                              rgba[i][GCOMP] +
1129                                              rgba[i][BCOMP]);
1130                      dst[i*2+1] = (GLshort) rgba[i][ACOMP];
1131                   }
1132                   break;
1133                case GL_LUMINANCE_ALPHA_INTEGER_EXT:
1134                   for (i=0;i<n;i++) {
1135                      dst[i] = (GLshort) (rgba[i][RCOMP] +
1136                                          rgba[i][GCOMP] +
1137                                          rgba[i][BCOMP]);
1138                   }
1139                   break;
1140                case GL_DUDV_ATI:
1141                case GL_DU8DV8_ATI:
1142                   for (i=0;i<n;i++) {
1143                      dst[i*2+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1144                      dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1145                   }
1146                   break;
1147                default:
1148                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1149             }
1150          }
1151          break;
1152       case GL_UNSIGNED_INT:
1153          {
1154             GLuint *dst = (GLuint *) dstAddr;
1155             switch (dstFormat) {
1156                case GL_RED:
1157                   for (i=0;i<n;i++)
1158                      dst[i] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1159                   break;
1160                case GL_GREEN:
1161                   for (i=0;i<n;i++)
1162                      dst[i] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1163                   break;
1164                case GL_BLUE:
1165                   for (i=0;i<n;i++)
1166                      dst[i] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1167                   break;
1168                case GL_ALPHA:
1169                   for (i=0;i<n;i++)
1170                      dst[i] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1171                   break;
1172                case GL_LUMINANCE:
1173                   for (i=0;i<n;i++)
1174                      dst[i] = FLOAT_TO_UINT(luminance[i]);
1175                   break;
1176                case GL_LUMINANCE_ALPHA:
1177                   for (i=0;i<n;i++) {
1178                      dst[i*2+0] = FLOAT_TO_UINT(luminance[i]);
1179                      dst[i*2+1] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1180                   }
1181                   break;
1182                case GL_RG:
1183                   for (i=0;i<n;i++) {
1184                      dst[i*2+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1185                      dst[i*2+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1186                   }
1187                   break;
1188                case GL_RGB:
1189                   for (i=0;i<n;i++) {
1190                      dst[i*3+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1191                      dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1192                      dst[i*3+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1193                   }
1194                   break;
1195                case GL_RGBA:
1196                   for (i=0;i<n;i++) {
1197                      dst[i*4+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1198                      dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1199                      dst[i*4+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1200                      dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1201                   }
1202                   break;
1203                case GL_BGR:
1204                   for (i=0;i<n;i++) {
1205                      dst[i*3+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1206                      dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1207                      dst[i*3+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1208                   }
1209                   break;
1210                case GL_BGRA:
1211                   for (i=0;i<n;i++) {
1212                      dst[i*4+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1213                      dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1214                      dst[i*4+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1215                      dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1216                   }
1217                   break;
1218                case GL_ABGR_EXT:
1219                   for (i=0;i<n;i++) {
1220                      dst[i*4+0] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1221                      dst[i*4+1] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1222                      dst[i*4+2] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1223                      dst[i*4+3] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1224                   }
1225                   break;
1226                case GL_RED_INTEGER_EXT:
1227                   for (i=0;i<n;i++) {
1228                      dst[i] = (GLuint) rgba[i][RCOMP];
1229                   }
1230                   break;
1231                case GL_GREEN_INTEGER_EXT:
1232                   for (i=0;i<n;i++) {
1233                      dst[i] = (GLuint) rgba[i][GCOMP];
1234                   }
1235                   break;
1236                case GL_BLUE_INTEGER_EXT:
1237                   for (i=0;i<n;i++) {
1238                      dst[i] = (GLuint) rgba[i][BCOMP];
1239                   }
1240                   break;
1241                case GL_ALPHA_INTEGER_EXT:
1242                   for (i=0;i<n;i++) {
1243                      dst[i] = (GLuint) rgba[i][ACOMP];
1244                   }
1245                   break;
1246                case GL_RGB_INTEGER_EXT:
1247                   for (i=0;i<n;i++) {
1248                      dst[i*3+0] = (GLuint) rgba[i][RCOMP];
1249                      dst[i*3+1] = (GLuint) rgba[i][GCOMP];
1250                      dst[i*3+2] = (GLuint) rgba[i][BCOMP];
1251                   }
1252                   break;
1253                case GL_RGBA_INTEGER_EXT:
1254                   for (i=0;i<n;i++) {
1255                      dst[i*4+0] = (GLuint) rgba[i][RCOMP];
1256                      dst[i*4+1] = (GLuint) rgba[i][GCOMP];
1257                      dst[i*4+2] = (GLuint) rgba[i][BCOMP];
1258                      dst[i*4+3] = (GLuint) rgba[i][ACOMP];
1259                   }
1260                   break;
1261                case GL_BGR_INTEGER_EXT:
1262                   for (i=0;i<n;i++) {
1263                      dst[i*3+0] = (GLuint) rgba[i][BCOMP];
1264                      dst[i*3+1] = (GLuint) rgba[i][GCOMP];
1265                      dst[i*3+2] = (GLuint) rgba[i][RCOMP];
1266                   }
1267                   break;
1268                case GL_BGRA_INTEGER_EXT:
1269                   for (i=0;i<n;i++) {
1270                      dst[i*4+0] = (GLuint) rgba[i][BCOMP];
1271                      dst[i*4+1] = (GLuint) rgba[i][GCOMP];
1272                      dst[i*4+2] = (GLuint) rgba[i][RCOMP];
1273                      dst[i*4+3] = (GLuint) rgba[i][ACOMP];
1274                   }
1275                   break;
1276                case GL_LUMINANCE_INTEGER_EXT:
1277                   for (i=0;i<n;i++) {
1278                      dst[i*2+0] = (GLuint) (rgba[i][RCOMP] +
1279                                             rgba[i][GCOMP] +
1280                                             rgba[i][BCOMP]);
1281                      dst[i*2+1] = (GLuint) rgba[i][ACOMP];
1282                   }
1283                   break;
1284                case GL_LUMINANCE_ALPHA_INTEGER_EXT:
1285                   for (i=0;i<n;i++) {
1286                      dst[i] = (GLuint) (rgba[i][RCOMP] +
1287                                         rgba[i][GCOMP] +
1288                                         rgba[i][BCOMP]);
1289                   }
1290                   break;
1291                case GL_DUDV_ATI:
1292                case GL_DU8DV8_ATI:
1293                   for (i=0;i<n;i++) {
1294                      dst[i*2+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1295                      dst[i*2+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1296                   }
1297                   break;
1298                default:
1299                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1300             }
1301          }
1302          break;
1303       case GL_INT:
1304          {
1305             GLint *dst = (GLint *) dstAddr;
1306             switch (dstFormat) {
1307                case GL_RED:
1308                   for (i=0;i<n;i++)
1309                      dst[i] = FLOAT_TO_INT(rgba[i][RCOMP]);
1310                   break;
1311                case GL_GREEN:
1312                   for (i=0;i<n;i++)
1313                      dst[i] = FLOAT_TO_INT(rgba[i][GCOMP]);
1314                   break;
1315                case GL_BLUE:
1316                   for (i=0;i<n;i++)
1317                      dst[i] = FLOAT_TO_INT(rgba[i][BCOMP]);
1318                   break;
1319                case GL_ALPHA:
1320                   for (i=0;i<n;i++)
1321                      dst[i] = FLOAT_TO_INT(rgba[i][ACOMP]);
1322                   break;
1323                case GL_LUMINANCE:
1324                   for (i=0;i<n;i++)
1325                      dst[i] = FLOAT_TO_INT(luminance[i]);
1326                   break;
1327                case GL_LUMINANCE_ALPHA:
1328                   for (i=0;i<n;i++) {
1329                      dst[i*2+0] = FLOAT_TO_INT(luminance[i]);
1330                      dst[i*2+1] = FLOAT_TO_INT(rgba[i][ACOMP]);
1331                   }
1332                   break;
1333                case GL_RG:
1334                   for (i=0;i<n;i++) {
1335                      dst[i*2+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
1336                      dst[i*2+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1337                   }
1338                   break;
1339                case GL_RGB:
1340                   for (i=0;i<n;i++) {
1341                      dst[i*3+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
1342                      dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1343                      dst[i*3+2] = FLOAT_TO_INT(rgba[i][BCOMP]);
1344                   }
1345                   break;
1346                case GL_RGBA:
1347                   for (i=0;i<n;i++) {
1348                      dst[i*4+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
1349                      dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1350                      dst[i*4+2] = FLOAT_TO_INT(rgba[i][BCOMP]);
1351                      dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);
1352                   }
1353                   break;
1354                case GL_BGR:
1355                   for (i=0;i<n;i++) {
1356                      dst[i*3+0] = FLOAT_TO_INT(rgba[i][BCOMP]);
1357                      dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1358                      dst[i*3+2] = FLOAT_TO_INT(rgba[i][RCOMP]);
1359                   }
1360                   break;
1361                case GL_BGRA:
1362                   for (i=0;i<n;i++) {
1363                      dst[i*4+0] = FLOAT_TO_INT(rgba[i][BCOMP]);
1364                      dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1365                      dst[i*4+2] = FLOAT_TO_INT(rgba[i][RCOMP]);
1366                      dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);
1367                   }
1368                   break;
1369                case GL_ABGR_EXT:
1370                   for (i=0;i<n;i++) {
1371                      dst[i*4+0] = FLOAT_TO_INT(rgba[i][ACOMP]);
1372                      dst[i*4+1] = FLOAT_TO_INT(rgba[i][BCOMP]);
1373                      dst[i*4+2] = FLOAT_TO_INT(rgba[i][GCOMP]);
1374                      dst[i*4+3] = FLOAT_TO_INT(rgba[i][RCOMP]);
1375                   }
1376                   break;
1377                case GL_DUDV_ATI:
1378                case GL_DU8DV8_ATI:
1379                   for (i=0;i<n;i++) {
1380                      dst[i*2+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
1381                      dst[i*2+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1382                   }
1383                   break;
1384                case GL_RED_INTEGER_EXT:
1385                   for (i=0;i<n;i++) {
1386                      dst[i] = (GLint) rgba[i][RCOMP];
1387                   }
1388                   break;
1389                case GL_GREEN_INTEGER_EXT:
1390                   for (i=0;i<n;i++) {
1391                      dst[i] = (GLint) rgba[i][GCOMP];
1392                   }
1393                   break;
1394                case GL_BLUE_INTEGER_EXT:
1395                   for (i=0;i<n;i++) {
1396                      dst[i] = (GLint) rgba[i][BCOMP];
1397                   }
1398                   break;
1399                case GL_ALPHA_INTEGER_EXT:
1400                   for (i=0;i<n;i++) {
1401                      dst[i] = (GLint) rgba[i][ACOMP];
1402                   }
1403                   break;
1404                case GL_RGB_INTEGER_EXT:
1405                   for (i=0;i<n;i++) {
1406                      dst[i*3+0] = (GLint) rgba[i][RCOMP];
1407                      dst[i*3+1] = (GLint) rgba[i][GCOMP];
1408                      dst[i*3+2] = (GLint) rgba[i][BCOMP];
1409                   }
1410                   break;
1411                case GL_RGBA_INTEGER_EXT:
1412                   for (i=0;i<n;i++) {
1413                      dst[i*4+0] = (GLint) rgba[i][RCOMP];
1414                      dst[i*4+1] = (GLint) rgba[i][GCOMP];
1415                      dst[i*4+2] = (GLint) rgba[i][BCOMP];
1416                      dst[i*4+3] = (GLint) rgba[i][ACOMP];
1417                   }
1418                   break;
1419                case GL_BGR_INTEGER_EXT:
1420                   for (i=0;i<n;i++) {
1421                      dst[i*3+0] = (GLint) rgba[i][BCOMP];
1422                      dst[i*3+1] = (GLint) rgba[i][GCOMP];
1423                      dst[i*3+2] = (GLint) rgba[i][RCOMP];
1424                   }
1425                   break;
1426                case GL_BGRA_INTEGER_EXT:
1427                   for (i=0;i<n;i++) {
1428                      dst[i*4+0] = (GLint) rgba[i][BCOMP];
1429                      dst[i*4+1] = (GLint) rgba[i][GCOMP];
1430                      dst[i*4+2] = (GLint) rgba[i][RCOMP];
1431                      dst[i*4+3] = (GLint) rgba[i][ACOMP];
1432                   }
1433                   break;
1434                case GL_LUMINANCE_INTEGER_EXT:
1435                   for (i=0;i<n;i++) {
1436                      dst[i*2+0] = (GLint) (rgba[i][RCOMP] +
1437                                            rgba[i][GCOMP] +
1438                                            rgba[i][BCOMP]);
1439                      dst[i*2+1] = (GLint) rgba[i][ACOMP];
1440                   }
1441                   break;
1442                case GL_LUMINANCE_ALPHA_INTEGER_EXT:
1443                   for (i=0;i<n;i++) {
1444                      dst[i] = (GLint) (rgba[i][RCOMP] +
1445                                        rgba[i][GCOMP] +
1446                                        rgba[i][BCOMP]);
1447                   }
1448                   break;
1449                default:
1450                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1451             }
1452          }
1453          break;
1454       case GL_FLOAT:
1455          {
1456             GLfloat *dst = (GLfloat *) dstAddr;
1457             switch (dstFormat) {
1458                case GL_RED:
1459                   for (i=0;i<n;i++)
1460                      dst[i] = rgba[i][RCOMP];
1461                   break;
1462                case GL_GREEN:
1463                   for (i=0;i<n;i++)
1464                      dst[i] = rgba[i][GCOMP];
1465                   break;
1466                case GL_BLUE:
1467                   for (i=0;i<n;i++)
1468                      dst[i] = rgba[i][BCOMP];
1469                   break;
1470                case GL_ALPHA:
1471                   for (i=0;i<n;i++)
1472                      dst[i] = rgba[i][ACOMP];
1473                   break;
1474                case GL_LUMINANCE:
1475                   for (i=0;i<n;i++)
1476                      dst[i] = luminance[i];
1477                   break;
1478                case GL_LUMINANCE_ALPHA:
1479                   for (i=0;i<n;i++) {
1480                      dst[i*2+0] = luminance[i];
1481                      dst[i*2+1] = rgba[i][ACOMP];
1482                   }
1483                   break;
1484                case GL_RG:
1485                   for (i=0;i<n;i++) {
1486                      dst[i*2+0] = rgba[i][RCOMP];
1487                      dst[i*2+1] = rgba[i][GCOMP];
1488                   }
1489                   break;
1490                case GL_RGB:
1491                   for (i=0;i<n;i++) {
1492                      dst[i*3+0] = rgba[i][RCOMP];
1493                      dst[i*3+1] = rgba[i][GCOMP];
1494                      dst[i*3+2] = rgba[i][BCOMP];
1495                   }
1496                   break;
1497                case GL_RGBA:
1498                   for (i=0;i<n;i++) {
1499                      dst[i*4+0] = rgba[i][RCOMP];
1500                      dst[i*4+1] = rgba[i][GCOMP];
1501                      dst[i*4+2] = rgba[i][BCOMP];
1502                      dst[i*4+3] = rgba[i][ACOMP];
1503                   }
1504                   break;
1505                case GL_BGR:
1506                   for (i=0;i<n;i++) {
1507                      dst[i*3+0] = rgba[i][BCOMP];
1508                      dst[i*3+1] = rgba[i][GCOMP];
1509                      dst[i*3+2] = rgba[i][RCOMP];
1510                   }
1511                   break;
1512                case GL_BGRA:
1513                   for (i=0;i<n;i++) {
1514                      dst[i*4+0] = rgba[i][BCOMP];
1515                      dst[i*4+1] = rgba[i][GCOMP];
1516                      dst[i*4+2] = rgba[i][RCOMP];
1517                      dst[i*4+3] = rgba[i][ACOMP];
1518                   }
1519                   break;
1520                case GL_ABGR_EXT:
1521                   for (i=0;i<n;i++) {
1522                      dst[i*4+0] = rgba[i][ACOMP];
1523                      dst[i*4+1] = rgba[i][BCOMP];
1524                      dst[i*4+2] = rgba[i][GCOMP];
1525                      dst[i*4+3] = rgba[i][RCOMP];
1526                   }
1527                   break;
1528                case GL_DUDV_ATI:
1529                case GL_DU8DV8_ATI:
1530                   for (i=0;i<n;i++) {
1531                      dst[i*2+0] = rgba[i][RCOMP];
1532                      dst[i*2+1] = rgba[i][GCOMP];
1533                   }
1534                   break;
1535                default:
1536                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1537             }
1538          }
1539          break;
1540       case GL_HALF_FLOAT_ARB:
1541          {
1542             GLhalfARB *dst = (GLhalfARB *) dstAddr;
1543             switch (dstFormat) {
1544                case GL_RED:
1545                   for (i=0;i<n;i++)
1546                      dst[i] = _mesa_float_to_half(rgba[i][RCOMP]);
1547                   break;
1548                case GL_GREEN:
1549                   for (i=0;i<n;i++)
1550                      dst[i] = _mesa_float_to_half(rgba[i][GCOMP]);
1551                   break;
1552                case GL_BLUE:
1553                   for (i=0;i<n;i++)
1554                      dst[i] = _mesa_float_to_half(rgba[i][BCOMP]);
1555                   break;
1556                case GL_ALPHA:
1557                   for (i=0;i<n;i++)
1558                      dst[i] = _mesa_float_to_half(rgba[i][ACOMP]);
1559                   break;
1560                case GL_LUMINANCE:
1561                   for (i=0;i<n;i++)
1562                      dst[i] = _mesa_float_to_half(luminance[i]);
1563                   break;
1564                case GL_LUMINANCE_ALPHA:
1565                   for (i=0;i<n;i++) {
1566                      dst[i*2+0] = _mesa_float_to_half(luminance[i]);
1567                      dst[i*2+1] = _mesa_float_to_half(rgba[i][ACOMP]);
1568                   }
1569                   break;
1570                case GL_RG:
1571                   for (i=0;i<n;i++) {
1572                      dst[i*2+0] = _mesa_float_to_half(rgba[i][RCOMP]);
1573                      dst[i*2+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1574                   }
1575                   break;
1576                case GL_RGB:
1577                   for (i=0;i<n;i++) {
1578                      dst[i*3+0] = _mesa_float_to_half(rgba[i][RCOMP]);
1579                      dst[i*3+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1580                      dst[i*3+2] = _mesa_float_to_half(rgba[i][BCOMP]);
1581                   }
1582                   break;
1583                case GL_RGBA:
1584                   for (i=0;i<n;i++) {
1585                      dst[i*4+0] = _mesa_float_to_half(rgba[i][RCOMP]);
1586                      dst[i*4+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1587                      dst[i*4+2] = _mesa_float_to_half(rgba[i][BCOMP]);
1588                      dst[i*4+3] = _mesa_float_to_half(rgba[i][ACOMP]);
1589                   }
1590                   break;
1591                case GL_BGR:
1592                   for (i=0;i<n;i++) {
1593                      dst[i*3+0] = _mesa_float_to_half(rgba[i][BCOMP]);
1594                      dst[i*3+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1595                      dst[i*3+2] = _mesa_float_to_half(rgba[i][RCOMP]);
1596                   }
1597                   break;
1598                case GL_BGRA:
1599                   for (i=0;i<n;i++) {
1600                      dst[i*4+0] = _mesa_float_to_half(rgba[i][BCOMP]);
1601                      dst[i*4+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1602                      dst[i*4+2] = _mesa_float_to_half(rgba[i][RCOMP]);
1603                      dst[i*4+3] = _mesa_float_to_half(rgba[i][ACOMP]);
1604                   }
1605                   break;
1606                case GL_ABGR_EXT:
1607                   for (i=0;i<n;i++) {
1608                      dst[i*4+0] = _mesa_float_to_half(rgba[i][ACOMP]);
1609                      dst[i*4+1] = _mesa_float_to_half(rgba[i][BCOMP]);
1610                      dst[i*4+2] = _mesa_float_to_half(rgba[i][GCOMP]);
1611                      dst[i*4+3] = _mesa_float_to_half(rgba[i][RCOMP]);
1612                   }
1613                   break;
1614                case GL_DUDV_ATI:
1615                case GL_DU8DV8_ATI:
1616                   for (i=0;i<n;i++) {
1617                      dst[i*2+0] = _mesa_float_to_half(rgba[i][RCOMP]);
1618                      dst[i*2+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1619                   }
1620                   break;
1621                default:
1622                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1623             }
1624          }
1625          break;
1626       case GL_UNSIGNED_BYTE_3_3_2:
1627          if (dstFormat == GL_RGB) {
1628             GLubyte *dst = (GLubyte *) dstAddr;
1629             for (i=0;i<n;i++) {
1630                dst[i] = (IROUND(rgba[i][RCOMP] * 7.0F) << 5)
1631                       | (IROUND(rgba[i][GCOMP] * 7.0F) << 2)
1632                       | (IROUND(rgba[i][BCOMP] * 3.0F)     );
1633             }
1634          }
1635          break;
1636       case GL_UNSIGNED_BYTE_2_3_3_REV:
1637          if (dstFormat == GL_RGB) {
1638             GLubyte *dst = (GLubyte *) dstAddr;
1639             for (i=0;i<n;i++) {
1640                dst[i] = (IROUND(rgba[i][RCOMP] * 7.0F)     )
1641                       | (IROUND(rgba[i][GCOMP] * 7.0F) << 3)
1642                       | (IROUND(rgba[i][BCOMP] * 3.0F) << 6);
1643             }
1644          }
1645          break;
1646       case GL_UNSIGNED_SHORT_5_6_5:
1647          if (dstFormat == GL_RGB) {
1648             GLushort *dst = (GLushort *) dstAddr;
1649             for (i=0;i<n;i++) {
1650                dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F) << 11)
1651                       | (IROUND(rgba[i][GCOMP] * 63.0F) <<  5)
1652                       | (IROUND(rgba[i][BCOMP] * 31.0F)      );
1653             }
1654          }
1655          break;
1656       case GL_UNSIGNED_SHORT_5_6_5_REV:
1657          if (dstFormat == GL_RGB) {
1658             GLushort *dst = (GLushort *) dstAddr;
1659             for (i=0;i<n;i++) {
1660                dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F)      )
1661                       | (IROUND(rgba[i][GCOMP] * 63.0F) <<  5)
1662                       | (IROUND(rgba[i][BCOMP] * 31.0F) << 11);
1663             }
1664          }
1665          break;
1666       case GL_UNSIGNED_SHORT_4_4_4_4:
1667          if (dstFormat == GL_RGBA) {
1668             GLushort *dst = (GLushort *) dstAddr;
1669             for (i=0;i<n;i++) {
1670                dst[i] = (IROUND(rgba[i][RCOMP] * 15.0F) << 12)
1671                       | (IROUND(rgba[i][GCOMP] * 15.0F) <<  8)
1672                       | (IROUND(rgba[i][BCOMP] * 15.0F) <<  4)
1673                       | (IROUND(rgba[i][ACOMP] * 15.0F)      );
1674             }
1675          }
1676          else if (dstFormat == GL_BGRA) {
1677             GLushort *dst = (GLushort *) dstAddr;
1678             for (i=0;i<n;i++) {
1679                dst[i] = (IROUND(rgba[i][BCOMP] * 15.0F) << 12)
1680                       | (IROUND(rgba[i][GCOMP] * 15.0F) <<  8)
1681                       | (IROUND(rgba[i][RCOMP] * 15.0F) <<  4)
1682                       | (IROUND(rgba[i][ACOMP] * 15.0F)      );
1683             }
1684          }
1685          else if (dstFormat == GL_ABGR_EXT) {
1686             GLushort *dst = (GLushort *) dstAddr;
1687             for (i=0;i<n;i++) {
1688                dst[i] = (IROUND(rgba[i][ACOMP] * 15.0F) << 12)
1689                       | (IROUND(rgba[i][BCOMP] * 15.0F) <<  8)
1690                       | (IROUND(rgba[i][GCOMP] * 15.0F) <<  4)
1691                       | (IROUND(rgba[i][RCOMP] * 15.0F)      );
1692             }
1693          }
1694          break;
1695       case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1696          if (dstFormat == GL_RGBA) {
1697             GLushort *dst = (GLushort *) dstAddr;
1698             for (i=0;i<n;i++) {
1699                dst[i] = (IROUND(rgba[i][RCOMP] * 15.0F)      )
1700                       | (IROUND(rgba[i][GCOMP] * 15.0F) <<  4)
1701                       | (IROUND(rgba[i][BCOMP] * 15.0F) <<  8)
1702                       | (IROUND(rgba[i][ACOMP] * 15.0F) << 12);
1703             }
1704          }
1705          else if (dstFormat == GL_BGRA) {
1706             GLushort *dst = (GLushort *) dstAddr;
1707             for (i=0;i<n;i++) {
1708                dst[i] = (IROUND(rgba[i][BCOMP] * 15.0F)      )
1709                       | (IROUND(rgba[i][GCOMP] * 15.0F) <<  4)
1710                       | (IROUND(rgba[i][RCOMP] * 15.0F) <<  8)
1711                       | (IROUND(rgba[i][ACOMP] * 15.0F) << 12);
1712             }
1713          }
1714          else if (dstFormat == GL_ABGR_EXT) {
1715             GLushort *dst = (GLushort *) dstAddr;
1716             for (i=0;i<n;i++) {
1717                dst[i] = (IROUND(rgba[i][ACOMP] * 15.0F)      )
1718                       | (IROUND(rgba[i][BCOMP] * 15.0F) <<  4)
1719                       | (IROUND(rgba[i][GCOMP] * 15.0F) <<  8)
1720                       | (IROUND(rgba[i][RCOMP] * 15.0F) << 12);
1721             }
1722          }
1723          break;
1724       case GL_UNSIGNED_SHORT_5_5_5_1:
1725          if (dstFormat == GL_RGBA) {
1726             GLushort *dst = (GLushort *) dstAddr;
1727             for (i=0;i<n;i++) {
1728                dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F) << 11)
1729                       | (IROUND(rgba[i][GCOMP] * 31.0F) <<  6)
1730                       | (IROUND(rgba[i][BCOMP] * 31.0F) <<  1)
1731                       | (IROUND(rgba[i][ACOMP] *  1.0F)      );
1732             }
1733          }
1734          else if (dstFormat == GL_BGRA) {
1735             GLushort *dst = (GLushort *) dstAddr;
1736             for (i=0;i<n;i++) {
1737                dst[i] = (IROUND(rgba[i][BCOMP] * 31.0F) << 11)
1738                       | (IROUND(rgba[i][GCOMP] * 31.0F) <<  6)
1739                       | (IROUND(rgba[i][RCOMP] * 31.0F) <<  1)
1740                       | (IROUND(rgba[i][ACOMP] *  1.0F)      );
1741             }
1742          }
1743          else if (dstFormat == GL_ABGR_EXT) {
1744             GLushort *dst = (GLushort *) dstAddr;
1745             for (i=0;i<n;i++) {
1746                dst[i] = (IROUND(rgba[i][ACOMP] * 31.0F) << 11)
1747                       | (IROUND(rgba[i][BCOMP] * 31.0F) <<  6)
1748                       | (IROUND(rgba[i][GCOMP] * 31.0F) <<  1)
1749                       | (IROUND(rgba[i][RCOMP] *  1.0F)      );
1750             }
1751          }
1752          break;
1753       case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1754          if (dstFormat == GL_RGBA) {
1755             GLushort *dst = (GLushort *) dstAddr;
1756             for (i=0;i<n;i++) {
1757                dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F)      )
1758                       | (IROUND(rgba[i][GCOMP] * 31.0F) <<  5)
1759                       | (IROUND(rgba[i][BCOMP] * 31.0F) << 10)
1760                       | (IROUND(rgba[i][ACOMP] *  1.0F) << 15);
1761             }
1762          }
1763          else if (dstFormat == GL_BGRA) {
1764             GLushort *dst = (GLushort *) dstAddr;
1765             for (i=0;i<n;i++) {
1766                dst[i] = (IROUND(rgba[i][BCOMP] * 31.0F)      )
1767                       | (IROUND(rgba[i][GCOMP] * 31.0F) <<  5)
1768                       | (IROUND(rgba[i][RCOMP] * 31.0F) << 10)
1769                       | (IROUND(rgba[i][ACOMP] *  1.0F) << 15);
1770             }
1771          }
1772          else if (dstFormat == GL_ABGR_EXT) {
1773             GLushort *dst = (GLushort *) dstAddr;
1774             for (i=0;i<n;i++) {
1775                dst[i] = (IROUND(rgba[i][ACOMP] * 31.0F)      )
1776                       | (IROUND(rgba[i][BCOMP] * 31.0F) <<  5)
1777                       | (IROUND(rgba[i][GCOMP] * 31.0F) << 10)
1778                       | (IROUND(rgba[i][RCOMP] *  1.0F) << 15);
1779             }
1780          }
1781          break;
1782       case GL_UNSIGNED_INT_8_8_8_8:
1783          if (dstFormat == GL_RGBA) {
1784             GLuint *dst = (GLuint *) dstAddr;
1785             for (i=0;i<n;i++) {
1786                dst[i] = (IROUND(rgba[i][RCOMP] * 255.F) << 24)
1787                       | (IROUND(rgba[i][GCOMP] * 255.F) << 16)
1788                       | (IROUND(rgba[i][BCOMP] * 255.F) <<  8)
1789                       | (IROUND(rgba[i][ACOMP] * 255.F)      );
1790             }
1791          }
1792          else if (dstFormat == GL_BGRA) {
1793             GLuint *dst = (GLuint *) dstAddr;
1794             for (i=0;i<n;i++) {
1795                dst[i] = (IROUND(rgba[i][BCOMP] * 255.F) << 24)
1796                       | (IROUND(rgba[i][GCOMP] * 255.F) << 16)
1797                       | (IROUND(rgba[i][RCOMP] * 255.F) <<  8)
1798                       | (IROUND(rgba[i][ACOMP] * 255.F)      );
1799             }
1800          }
1801          else if (dstFormat == GL_ABGR_EXT) {
1802             GLuint *dst = (GLuint *) dstAddr;
1803             for (i=0;i<n;i++) {
1804                dst[i] = (IROUND(rgba[i][ACOMP] * 255.F) << 24)
1805                       | (IROUND(rgba[i][BCOMP] * 255.F) << 16)
1806                       | (IROUND(rgba[i][GCOMP] * 255.F) <<  8)
1807                       | (IROUND(rgba[i][RCOMP] * 255.F)      );
1808             }
1809          }
1810          break;
1811       case GL_UNSIGNED_INT_8_8_8_8_REV:
1812          if (dstFormat == GL_RGBA) {
1813             GLuint *dst = (GLuint *) dstAddr;
1814             for (i=0;i<n;i++) {
1815                dst[i] = (IROUND(rgba[i][RCOMP] * 255.0F)      )
1816                       | (IROUND(rgba[i][GCOMP] * 255.0F) <<  8)
1817                       | (IROUND(rgba[i][BCOMP] * 255.0F) << 16)
1818                       | (IROUND(rgba[i][ACOMP] * 255.0F) << 24);
1819             }
1820          }
1821          else if (dstFormat == GL_BGRA) {
1822             GLuint *dst = (GLuint *) dstAddr;
1823             for (i=0;i<n;i++) {
1824                dst[i] = (IROUND(rgba[i][BCOMP] * 255.0F)      )
1825                       | (IROUND(rgba[i][GCOMP] * 255.0F) <<  8)
1826                       | (IROUND(rgba[i][RCOMP] * 255.0F) << 16)
1827                       | (IROUND(rgba[i][ACOMP] * 255.0F) << 24);
1828             }
1829          }
1830          else if (dstFormat == GL_ABGR_EXT) {
1831             GLuint *dst = (GLuint *) dstAddr;
1832             for (i=0;i<n;i++) {
1833                dst[i] = (IROUND(rgba[i][ACOMP] * 255.0F)      )
1834                       | (IROUND(rgba[i][BCOMP] * 255.0F) <<  8)
1835                       | (IROUND(rgba[i][GCOMP] * 255.0F) << 16)
1836                       | (IROUND(rgba[i][RCOMP] * 255.0F) << 24);
1837             }
1838          }
1839          break;
1840       case GL_UNSIGNED_INT_10_10_10_2:
1841          if (dstFormat == GL_RGBA) {
1842             GLuint *dst = (GLuint *) dstAddr;
1843             for (i=0;i<n;i++) {
1844                dst[i] = (IROUND(rgba[i][RCOMP] * 1023.0F) << 22)
1845                       | (IROUND(rgba[i][GCOMP] * 1023.0F) << 12)
1846                       | (IROUND(rgba[i][BCOMP] * 1023.0F) <<  2)
1847                       | (IROUND(rgba[i][ACOMP] *    3.0F)      );
1848             }
1849          }
1850          else if (dstFormat == GL_BGRA) {
1851             GLuint *dst = (GLuint *) dstAddr;
1852             for (i=0;i<n;i++) {
1853                dst[i] = (IROUND(rgba[i][BCOMP] * 1023.0F) << 22)
1854                       | (IROUND(rgba[i][GCOMP] * 1023.0F) << 12)
1855                       | (IROUND(rgba[i][RCOMP] * 1023.0F) <<  2)
1856                       | (IROUND(rgba[i][ACOMP] *    3.0F)      );
1857             }
1858          }
1859          else if (dstFormat == GL_ABGR_EXT) {
1860             GLuint *dst = (GLuint *) dstAddr;
1861             for (i=0;i<n;i++) {
1862                dst[i] = (IROUND(rgba[i][ACOMP] * 1023.0F) << 22)
1863                       | (IROUND(rgba[i][BCOMP] * 1023.0F) << 12)
1864                       | (IROUND(rgba[i][GCOMP] * 1023.0F) <<  2)
1865                       | (IROUND(rgba[i][RCOMP] *    3.0F)      );
1866             }
1867          }
1868          break;
1869       case GL_UNSIGNED_INT_2_10_10_10_REV:
1870          if (dstFormat == GL_RGBA) {
1871             GLuint *dst = (GLuint *) dstAddr;
1872             for (i=0;i<n;i++) {
1873                dst[i] = (IROUND(rgba[i][RCOMP] * 1023.0F)      )
1874                       | (IROUND(rgba[i][GCOMP] * 1023.0F) << 10)
1875                       | (IROUND(rgba[i][BCOMP] * 1023.0F) << 20)
1876                       | (IROUND(rgba[i][ACOMP] *    3.0F) << 30);
1877             }
1878          }
1879          else if (dstFormat == GL_BGRA) {
1880             GLuint *dst = (GLuint *) dstAddr;
1881             for (i=0;i<n;i++) {
1882                dst[i] = (IROUND(rgba[i][BCOMP] * 1023.0F)      )
1883                       | (IROUND(rgba[i][GCOMP] * 1023.0F) << 10)
1884                       | (IROUND(rgba[i][RCOMP] * 1023.0F) << 20)
1885                       | (IROUND(rgba[i][ACOMP] *    3.0F) << 30);
1886             }
1887          }
1888          else if (dstFormat == GL_ABGR_EXT) {
1889             GLuint *dst = (GLuint *) dstAddr;
1890             for (i=0;i<n;i++) {
1891                dst[i] = (IROUND(rgba[i][ACOMP] * 1023.0F)      )
1892                       | (IROUND(rgba[i][BCOMP] * 1023.0F) << 10)
1893                       | (IROUND(rgba[i][GCOMP] * 1023.0F) << 20)
1894                       | (IROUND(rgba[i][RCOMP] *    3.0F) << 30);
1895             }
1896          }
1897          break;
1898       case GL_UNSIGNED_INT_5_9_9_9_REV:
1899          {
1900             GLuint *dst = (GLuint *) dstAddr;
1901             for (i = 0; i < n; i++) {
1902                dst[i] = float3_to_rgb9e5(rgba[i]);
1903             }
1904          }
1905          break;
1906       case GL_UNSIGNED_INT_10F_11F_11F_REV:
1907          {
1908             GLuint *dst = (GLuint *) dstAddr;
1909             for (i = 0; i < n; i++) {
1910                dst[i] = float3_to_r11g11b10f(rgba[i]);
1911             }
1912          }
1913          break;
1914       default:
1915          _mesa_problem(ctx, "bad type in _mesa_pack_rgba_span_float");
1916          return;
1917    }
1918
1919    if (dstPacking->SwapBytes) {
1920       GLint swapSize = _mesa_sizeof_packed_type(dstType);
1921       if (swapSize == 2) {
1922          if (dstPacking->SwapBytes) {
1923             _mesa_swap2((GLushort *) dstAddr, n * comps);
1924          }
1925       }
1926       else if (swapSize == 4) {
1927          if (dstPacking->SwapBytes) {
1928             _mesa_swap4((GLuint *) dstAddr, n * comps);
1929          }
1930       }
1931    }
1932
1933    free(luminance);
1934 }
1935
1936
1937
1938 #define SWAP2BYTE(VALUE)                        \
1939    {                                            \
1940       GLubyte *bytes = (GLubyte *) &(VALUE);    \
1941       GLubyte tmp = bytes[0];                   \
1942       bytes[0] = bytes[1];                      \
1943       bytes[1] = tmp;                           \
1944    }
1945
1946 #define SWAP4BYTE(VALUE)                        \
1947    {                                            \
1948       GLubyte *bytes = (GLubyte *) &(VALUE);    \
1949       GLubyte tmp = bytes[0];                   \
1950       bytes[0] = bytes[3];                      \
1951       bytes[3] = tmp;                           \
1952       tmp = bytes[1];                           \
1953       bytes[1] = bytes[2];                      \
1954       bytes[2] = tmp;                           \
1955    }
1956
1957
1958 static void
1959 extract_uint_indexes(GLuint n, GLuint indexes[],
1960                      GLenum srcFormat, GLenum srcType, const GLvoid *src,
1961                      const struct gl_pixelstore_attrib *unpack )
1962 {
1963    ASSERT(srcFormat == GL_COLOR_INDEX || srcFormat == GL_STENCIL_INDEX);
1964
1965    ASSERT(srcType == GL_BITMAP ||
1966           srcType == GL_UNSIGNED_BYTE ||
1967           srcType == GL_BYTE ||
1968           srcType == GL_UNSIGNED_SHORT ||
1969           srcType == GL_SHORT ||
1970           srcType == GL_UNSIGNED_INT ||
1971           srcType == GL_INT ||
1972           srcType == GL_UNSIGNED_INT_24_8_EXT ||
1973           srcType == GL_HALF_FLOAT_ARB ||
1974           srcType == GL_FLOAT);
1975
1976    switch (srcType) {
1977       case GL_BITMAP:
1978          {
1979             GLubyte *ubsrc = (GLubyte *) src;
1980             if (unpack->LsbFirst) {
1981                GLubyte mask = 1 << (unpack->SkipPixels & 0x7);
1982                GLuint i;
1983                for (i = 0; i < n; i++) {
1984                   indexes[i] = (*ubsrc & mask) ? 1 : 0;
1985                   if (mask == 128) {
1986                      mask = 1;
1987                      ubsrc++;
1988                   }
1989                   else {
1990                      mask = mask << 1;
1991                   }
1992                }
1993             }
1994             else {
1995                GLubyte mask = 128 >> (unpack->SkipPixels & 0x7);
1996                GLuint i;
1997                for (i = 0; i < n; i++) {
1998                   indexes[i] = (*ubsrc & mask) ? 1 : 0;
1999                   if (mask == 1) {
2000                      mask = 128;
2001                      ubsrc++;
2002                   }
2003                   else {
2004                      mask = mask >> 1;
2005                   }
2006                }
2007             }
2008          }
2009          break;
2010       case GL_UNSIGNED_BYTE:
2011          {
2012             GLuint i;
2013             const GLubyte *s = (const GLubyte *) src;
2014             for (i = 0; i < n; i++)
2015                indexes[i] = s[i];
2016          }
2017          break;
2018       case GL_BYTE:
2019          {
2020             GLuint i;
2021             const GLbyte *s = (const GLbyte *) src;
2022             for (i = 0; i < n; i++)
2023                indexes[i] = s[i];
2024          }
2025          break;
2026       case GL_UNSIGNED_SHORT:
2027          {
2028             GLuint i;
2029             const GLushort *s = (const GLushort *) src;
2030             if (unpack->SwapBytes) {
2031                for (i = 0; i < n; i++) {
2032                   GLushort value = s[i];
2033                   SWAP2BYTE(value);
2034                   indexes[i] = value;
2035                }
2036             }
2037             else {
2038                for (i = 0; i < n; i++)
2039                   indexes[i] = s[i];
2040             }
2041          }
2042          break;
2043       case GL_SHORT:
2044          {
2045             GLuint i;
2046             const GLshort *s = (const GLshort *) src;
2047             if (unpack->SwapBytes) {
2048                for (i = 0; i < n; i++) {
2049                   GLshort value = s[i];
2050                   SWAP2BYTE(value);
2051                   indexes[i] = value;
2052                }
2053             }
2054             else {
2055                for (i = 0; i < n; i++)
2056                   indexes[i] = s[i];
2057             }
2058          }
2059          break;
2060       case GL_UNSIGNED_INT:
2061          {
2062             GLuint i;
2063             const GLuint *s = (const GLuint *) src;
2064             if (unpack->SwapBytes) {
2065                for (i = 0; i < n; i++) {
2066                   GLuint value = s[i];
2067                   SWAP4BYTE(value);
2068                   indexes[i] = value;
2069                }
2070             }
2071             else {
2072                for (i = 0; i < n; i++)
2073                   indexes[i] = s[i];
2074             }
2075          }
2076          break;
2077       case GL_INT:
2078          {
2079             GLuint i;
2080             const GLint *s = (const GLint *) src;
2081             if (unpack->SwapBytes) {
2082                for (i = 0; i < n; i++) {
2083                   GLint value = s[i];
2084                   SWAP4BYTE(value);
2085                   indexes[i] = value;
2086                }
2087             }
2088             else {
2089                for (i = 0; i < n; i++)
2090                   indexes[i] = s[i];
2091             }
2092          }
2093          break;
2094       case GL_FLOAT:
2095          {
2096             GLuint i;
2097             const GLfloat *s = (const GLfloat *) src;
2098             if (unpack->SwapBytes) {
2099                for (i = 0; i < n; i++) {
2100                   GLfloat value = s[i];
2101                   SWAP4BYTE(value);
2102                   indexes[i] = (GLuint) value;
2103                }
2104             }
2105             else {
2106                for (i = 0; i < n; i++)
2107                   indexes[i] = (GLuint) s[i];
2108             }
2109          }
2110          break;
2111       case GL_HALF_FLOAT_ARB:
2112          {
2113             GLuint i;
2114             const GLhalfARB *s = (const GLhalfARB *) src;
2115             if (unpack->SwapBytes) {
2116                for (i = 0; i < n; i++) {
2117                   GLhalfARB value = s[i];
2118                   SWAP2BYTE(value);
2119                   indexes[i] = (GLuint) _mesa_half_to_float(value);
2120                }
2121             }
2122             else {
2123                for (i = 0; i < n; i++)
2124                   indexes[i] = (GLuint) _mesa_half_to_float(s[i]);
2125             }
2126          }
2127          break;
2128       case GL_UNSIGNED_INT_24_8_EXT:
2129          {
2130             GLuint i;
2131             const GLuint *s = (const GLuint *) src;
2132             if (unpack->SwapBytes) {
2133                for (i = 0; i < n; i++) {
2134                   GLuint value = s[i];
2135                   SWAP4BYTE(value);
2136                   indexes[i] = value & 0xff;  /* lower 8 bits */
2137                }
2138             }
2139             else {
2140                for (i = 0; i < n; i++)
2141                   indexes[i] = s[i] & 0xff;  /* lower 8 bits */
2142             }
2143          }
2144          break;
2145
2146       default:
2147          _mesa_problem(NULL, "bad srcType in extract_uint_indexes");
2148          return;
2149    }
2150 }
2151
2152
2153 /**
2154  * Return source/dest RGBA indexes for unpacking pixels.
2155  */
2156 static void
2157 get_component_mapping(GLenum format,
2158                       GLint *rSrc,
2159                       GLint *gSrc,
2160                       GLint *bSrc,
2161                       GLint *aSrc,
2162                       GLint *rDst,
2163                       GLint *gDst,
2164                       GLint *bDst,
2165                       GLint *aDst)
2166 {
2167    switch (format) {
2168    case GL_RED:
2169    case GL_RED_INTEGER_EXT:
2170       *rSrc = 0;
2171       *gSrc = *bSrc = *aSrc = -1;
2172       break;
2173    case GL_GREEN:
2174    case GL_GREEN_INTEGER_EXT:
2175       *gSrc = 0;
2176       *rSrc = *bSrc = *aSrc = -1;
2177       break;
2178       case GL_BLUE:
2179    case GL_BLUE_INTEGER_EXT:
2180       *bSrc = 0;
2181       *rSrc = *gSrc = *aSrc = -1;
2182       break;
2183    case GL_ALPHA:
2184    case GL_ALPHA_INTEGER_EXT:
2185       *rSrc = *gSrc = *bSrc = -1;
2186       *aSrc = 0;
2187       break;
2188    case GL_LUMINANCE:
2189    case GL_LUMINANCE_INTEGER_EXT:
2190       *rSrc = *gSrc = *bSrc = 0;
2191       *aSrc = -1;
2192       break;
2193    case GL_LUMINANCE_ALPHA:
2194    case GL_LUMINANCE_ALPHA_INTEGER_EXT:
2195       *rSrc = *gSrc = *bSrc = 0;
2196       *aSrc = 1;
2197       break;
2198    case GL_INTENSITY:
2199       *rSrc = *gSrc = *bSrc = *aSrc = 0;
2200       break;
2201    case GL_RG:
2202    case GL_RG_INTEGER:
2203       *rSrc = 0;
2204       *gSrc = 1;
2205       *bSrc = -1;
2206       *aSrc = -1;
2207       *rDst = 0;
2208       *gDst = 1;
2209       *bDst = 2;
2210       *aDst = 3;
2211       break;
2212    case GL_RGB:
2213    case GL_RGB_INTEGER:
2214       *rSrc = 0;
2215       *gSrc = 1;
2216       *bSrc = 2;
2217       *aSrc = -1;
2218       *rDst = 0;
2219       *gDst = 1;
2220       *bDst = 2;
2221       *aDst = 3;
2222       break;
2223    case GL_BGR:
2224       *rSrc = 2;
2225       *gSrc = 1;
2226       *bSrc = 0;
2227       *aSrc = -1;
2228       *rDst = 2;
2229       *gDst = 1;
2230       *bDst = 0;
2231       *aDst = 3;
2232       break;
2233    case GL_RGBA:
2234    case GL_RGBA_INTEGER:
2235       *rSrc = 0;
2236       *gSrc = 1;
2237       *bSrc = 2;
2238       *aSrc = 3;
2239       *rDst = 0;
2240       *gDst = 1;
2241       *bDst = 2;
2242       *aDst = 3;
2243       break;
2244    case GL_BGRA:
2245       *rSrc = 2;
2246       *gSrc = 1;
2247       *bSrc = 0;
2248       *aSrc = 3;
2249       *rDst = 2;
2250       *gDst = 1;
2251       *bDst = 0;
2252       *aDst = 3;
2253       break;
2254    case GL_ABGR_EXT:
2255       *rSrc = 3;
2256       *gSrc = 2;
2257       *bSrc = 1;
2258       *aSrc = 0;
2259       *rDst = 3;
2260       *gDst = 2;
2261       *bDst = 1;
2262       *aDst = 0;
2263       break;
2264    case GL_DU8DV8_ATI:
2265    case GL_DUDV_ATI:
2266       *rSrc = 0;
2267       *gSrc = 1;
2268       *bSrc = -1;
2269       *aSrc = -1;
2270       break;
2271    default:
2272       _mesa_problem(NULL, "bad srcFormat %s in get_component_mapping",
2273                     _mesa_lookup_enum_by_nr(format));
2274       return;
2275    }
2276 }
2277
2278
2279
2280 /*
2281  * This function extracts floating point RGBA values from arbitrary
2282  * image data.  srcFormat and srcType are the format and type parameters
2283  * passed to glDrawPixels, glTexImage[123]D, glTexSubImage[123]D, etc.
2284  *
2285  * Refering to section 3.6.4 of the OpenGL 1.2 spec, this function
2286  * implements the "Conversion to floating point", "Conversion to RGB",
2287  * and "Final Expansion to RGBA" operations.
2288  *
2289  * Args:  n - number of pixels
2290  *        rgba - output colors
2291  *        srcFormat - format of incoming data
2292  *        srcType - data type of incoming data
2293  *        src - source data pointer
2294  *        swapBytes - perform byteswapping of incoming data?
2295  */
2296 static void
2297 extract_float_rgba(GLuint n, GLfloat rgba[][4],
2298                    GLenum srcFormat, GLenum srcType, const GLvoid *src,
2299                    GLboolean swapBytes)
2300 {
2301    GLint rSrc, gSrc, bSrc, aSrc;
2302    GLint stride;
2303    GLint rDst, bDst, gDst, aDst;
2304    GLboolean intFormat;
2305    GLfloat rs = 1.0f, gs = 1.0f, bs = 1.0f, as = 1.0f; /* scale factors */
2306
2307    ASSERT(srcFormat == GL_RED ||
2308           srcFormat == GL_GREEN ||
2309           srcFormat == GL_BLUE ||
2310           srcFormat == GL_ALPHA ||
2311           srcFormat == GL_LUMINANCE ||
2312           srcFormat == GL_LUMINANCE_ALPHA ||
2313           srcFormat == GL_INTENSITY ||
2314           srcFormat == GL_RG ||
2315           srcFormat == GL_RGB ||
2316           srcFormat == GL_BGR ||
2317           srcFormat == GL_RGBA ||
2318           srcFormat == GL_BGRA ||
2319           srcFormat == GL_ABGR_EXT ||
2320           srcFormat == GL_DU8DV8_ATI ||
2321           srcFormat == GL_DUDV_ATI ||
2322           srcFormat == GL_RED_INTEGER_EXT ||
2323           srcFormat == GL_GREEN_INTEGER_EXT ||
2324           srcFormat == GL_BLUE_INTEGER_EXT ||
2325           srcFormat == GL_ALPHA_INTEGER_EXT ||
2326           srcFormat == GL_RGB_INTEGER_EXT ||
2327           srcFormat == GL_RGBA_INTEGER_EXT ||
2328           srcFormat == GL_BGR_INTEGER_EXT ||
2329           srcFormat == GL_BGRA_INTEGER_EXT ||
2330           srcFormat == GL_LUMINANCE_INTEGER_EXT ||
2331           srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);
2332
2333    ASSERT(srcType == GL_UNSIGNED_BYTE ||
2334           srcType == GL_BYTE ||
2335           srcType == GL_UNSIGNED_SHORT ||
2336           srcType == GL_SHORT ||
2337           srcType == GL_UNSIGNED_INT ||
2338           srcType == GL_INT ||
2339           srcType == GL_HALF_FLOAT_ARB ||
2340           srcType == GL_FLOAT ||
2341           srcType == GL_UNSIGNED_BYTE_3_3_2 ||
2342           srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
2343           srcType == GL_UNSIGNED_SHORT_5_6_5 ||
2344           srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
2345           srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
2346           srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
2347           srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
2348           srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
2349           srcType == GL_UNSIGNED_INT_8_8_8_8 ||
2350           srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
2351           srcType == GL_UNSIGNED_INT_10_10_10_2 ||
2352           srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
2353           srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
2354           srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
2355
2356    get_component_mapping(srcFormat,
2357                          &rSrc, &gSrc, &bSrc, &aSrc,
2358                          &rDst, &gDst, &bDst, &aDst);
2359
2360    stride = _mesa_components_in_format(srcFormat);
2361
2362    intFormat = _mesa_is_integer_format(srcFormat);
2363
2364 #define PROCESS(SRC_INDEX, DST_INDEX, DEFAULT_FLT, DEFAULT_INT, TYPE, CONVERSION) \
2365    if ((SRC_INDEX) < 0) {                                               \
2366       GLuint i;                                                         \
2367       if (intFormat) {                                                  \
2368          for (i = 0; i < n; i++) {                                      \
2369             rgba[i][DST_INDEX] = DEFAULT_INT;                           \
2370          }                                                              \
2371       }                                                                 \
2372       else {                                                            \
2373          for (i = 0; i < n; i++) {                                      \
2374             rgba[i][DST_INDEX] = DEFAULT_FLT;                           \
2375          }                                                              \
2376       }                                                                 \
2377    }                                                                    \
2378    else if (swapBytes) {                                                \
2379       const TYPE *s = (const TYPE *) src;                               \
2380       GLuint i;                                                         \
2381       for (i = 0; i < n; i++) {                                         \
2382          TYPE value = s[SRC_INDEX];                                     \
2383          if (sizeof(TYPE) == 2) {                                       \
2384             SWAP2BYTE(value);                                           \
2385          }                                                              \
2386          else if (sizeof(TYPE) == 4) {                                  \
2387             SWAP4BYTE(value);                                           \
2388          }                                                              \
2389          if (intFormat)                                                 \
2390             rgba[i][DST_INDEX] = (GLfloat) value;                       \
2391          else                                                           \
2392             rgba[i][DST_INDEX] = (GLfloat) CONVERSION(value);           \
2393          s += stride;                                                   \
2394       }                                                                 \
2395    }                                                                    \
2396    else {                                                               \
2397       const TYPE *s = (const TYPE *) src;                               \
2398       GLuint i;                                                         \
2399       if (intFormat) {                                                  \
2400          for (i = 0; i < n; i++) {                                      \
2401             rgba[i][DST_INDEX] = (GLfloat) s[SRC_INDEX];                \
2402             s += stride;                                                \
2403          }                                                              \
2404       }                                                                 \
2405       else {                                                            \
2406          for (i = 0; i < n; i++) {                                      \
2407             rgba[i][DST_INDEX] = (GLfloat) CONVERSION(s[SRC_INDEX]);    \
2408             s += stride;                                                \
2409          }                                                              \
2410       }                                                                 \
2411    }
2412
2413    switch (srcType) {
2414       case GL_UNSIGNED_BYTE:
2415          PROCESS(rSrc, RCOMP, 0.0F,   0, GLubyte, UBYTE_TO_FLOAT);
2416          PROCESS(gSrc, GCOMP, 0.0F,   0, GLubyte, UBYTE_TO_FLOAT);
2417          PROCESS(bSrc, BCOMP, 0.0F,   0, GLubyte, UBYTE_TO_FLOAT);
2418          PROCESS(aSrc, ACOMP, 1.0F, 255, GLubyte, UBYTE_TO_FLOAT);
2419          break;
2420       case GL_BYTE:
2421          PROCESS(rSrc, RCOMP, 0.0F,   0, GLbyte, BYTE_TO_FLOAT);
2422          PROCESS(gSrc, GCOMP, 0.0F,   0, GLbyte, BYTE_TO_FLOAT);
2423          PROCESS(bSrc, BCOMP, 0.0F,   0, GLbyte, BYTE_TO_FLOAT);
2424          PROCESS(aSrc, ACOMP, 1.0F, 127, GLbyte, BYTE_TO_FLOAT);
2425          break;
2426       case GL_UNSIGNED_SHORT:
2427          PROCESS(rSrc, RCOMP, 0.0F,      0, GLushort, USHORT_TO_FLOAT);
2428          PROCESS(gSrc, GCOMP, 0.0F,      0, GLushort, USHORT_TO_FLOAT);
2429          PROCESS(bSrc, BCOMP, 0.0F,      0, GLushort, USHORT_TO_FLOAT);
2430          PROCESS(aSrc, ACOMP, 1.0F, 0xffff, GLushort, USHORT_TO_FLOAT);
2431          break;
2432       case GL_SHORT:
2433          PROCESS(rSrc, RCOMP, 0.0F,     0, GLshort, SHORT_TO_FLOAT);
2434          PROCESS(gSrc, GCOMP, 0.0F,     0, GLshort, SHORT_TO_FLOAT);
2435          PROCESS(bSrc, BCOMP, 0.0F,     0, GLshort, SHORT_TO_FLOAT);
2436          PROCESS(aSrc, ACOMP, 1.0F, 32767, GLshort, SHORT_TO_FLOAT);
2437          break;
2438       case GL_UNSIGNED_INT:
2439          PROCESS(rSrc, RCOMP, 0.0F,          0, GLuint, UINT_TO_FLOAT);
2440          PROCESS(gSrc, GCOMP, 0.0F,          0, GLuint, UINT_TO_FLOAT);
2441          PROCESS(bSrc, BCOMP, 0.0F,          0, GLuint, UINT_TO_FLOAT);
2442          PROCESS(aSrc, ACOMP, 1.0F, 0xffffffff, GLuint, UINT_TO_FLOAT);
2443          break;
2444       case GL_INT:
2445          PROCESS(rSrc, RCOMP, 0.0F,          0, GLint, INT_TO_FLOAT);
2446          PROCESS(gSrc, GCOMP, 0.0F,          0, GLint, INT_TO_FLOAT);
2447          PROCESS(bSrc, BCOMP, 0.0F,          0, GLint, INT_TO_FLOAT);
2448          PROCESS(aSrc, ACOMP, 1.0F, 2147483647, GLint, INT_TO_FLOAT);
2449          break;
2450       case GL_FLOAT:
2451          PROCESS(rSrc, RCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
2452          PROCESS(gSrc, GCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
2453          PROCESS(bSrc, BCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
2454          PROCESS(aSrc, ACOMP, 1.0F, 1.0F, GLfloat, (GLfloat));
2455          break;
2456       case GL_HALF_FLOAT_ARB:
2457          PROCESS(rSrc, RCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
2458          PROCESS(gSrc, GCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
2459          PROCESS(bSrc, BCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
2460          PROCESS(aSrc, ACOMP, 1.0F, 1.0F, GLhalfARB, _mesa_half_to_float);
2461          break;
2462       case GL_UNSIGNED_BYTE_3_3_2:
2463          {
2464             const GLubyte *ubsrc = (const GLubyte *) src;
2465             GLuint i;
2466             if (!intFormat) {
2467                rs = 1.0F / 7.0F;
2468                gs = 1.0F / 7.0F;
2469                bs = 1.0F / 3.0F;
2470             }
2471             for (i = 0; i < n; i ++) {
2472                GLubyte p = ubsrc[i];
2473                rgba[i][rDst] = ((p >> 5)      ) * rs;
2474                rgba[i][gDst] = ((p >> 2) & 0x7) * gs;
2475                rgba[i][bDst] = ((p     ) & 0x3) * bs;
2476                rgba[i][aDst] = 1.0F;
2477             }
2478          }
2479          break;
2480       case GL_UNSIGNED_BYTE_2_3_3_REV:
2481          {
2482             const GLubyte *ubsrc = (const GLubyte *) src;
2483             GLuint i;
2484             if (!intFormat) {
2485                rs = 1.0F / 7.0F;
2486                gs = 1.0F / 7.0F;
2487                bs = 1.0F / 3.0F;
2488             }
2489             for (i = 0; i < n; i ++) {
2490                GLubyte p = ubsrc[i];
2491                rgba[i][rDst] = ((p     ) & 0x7) * rs;
2492                rgba[i][gDst] = ((p >> 3) & 0x7) * gs;
2493                rgba[i][bDst] = ((p >> 6)      ) * bs;
2494                rgba[i][aDst] = 1.0F;
2495             }
2496          }
2497          break;
2498       case GL_UNSIGNED_SHORT_5_6_5:
2499          if (!intFormat) {
2500             rs = 1.0F / 31.0F;
2501             gs = 1.0F / 63.0F;
2502             bs = 1.0F / 31.0F;
2503          }
2504          if (swapBytes) {
2505             const GLushort *ussrc = (const GLushort *) src;
2506             GLuint i;
2507             for (i = 0; i < n; i ++) {
2508                GLushort p = ussrc[i];
2509                SWAP2BYTE(p);
2510                rgba[i][rDst] = ((p >> 11)       ) * rs;
2511                rgba[i][gDst] = ((p >>  5) & 0x3f) * gs;
2512                rgba[i][bDst] = ((p      ) & 0x1f) * bs;
2513                rgba[i][aDst] = 1.0F;
2514             }
2515          }
2516          else {
2517             const GLushort *ussrc = (const GLushort *) src;
2518             GLuint i;
2519             for (i = 0; i < n; i ++) {
2520                GLushort p = ussrc[i];
2521                rgba[i][rDst] = ((p >> 11)       ) * rs;
2522                rgba[i][gDst] = ((p >>  5) & 0x3f) * gs;
2523                rgba[i][bDst] = ((p      ) & 0x1f) * bs;
2524                rgba[i][aDst] = 1.0F;
2525             }
2526          }
2527          break;
2528       case GL_UNSIGNED_SHORT_5_6_5_REV:
2529          if (!intFormat) {
2530             rs = 1.0F / 31.0F;
2531             gs = 1.0F / 63.0F;
2532             bs = 1.0F / 31.0F;
2533          }
2534          if (swapBytes) {
2535             const GLushort *ussrc = (const GLushort *) src;
2536             GLuint i;
2537             for (i = 0; i < n; i ++) {
2538                GLushort p = ussrc[i];
2539                SWAP2BYTE(p);
2540                rgba[i][rDst] = ((p      ) & 0x1f) * rs;
2541                rgba[i][gDst] = ((p >>  5) & 0x3f) * gs;
2542                rgba[i][bDst] = ((p >> 11)       ) * bs;
2543                rgba[i][aDst] = 1.0F;
2544             }
2545          }
2546          else {
2547             const GLushort *ussrc = (const GLushort *) src;
2548             GLuint i;
2549             for (i = 0; i < n; i ++) {
2550                GLushort p = ussrc[i];
2551                rgba[i][rDst] = ((p      ) & 0x1f) * rs;
2552                rgba[i][gDst] = ((p >>  5) & 0x3f) * gs;
2553                rgba[i][bDst] = ((p >> 11)       ) * bs;
2554                rgba[i][aDst] = 1.0F;
2555             }
2556          }
2557          break;
2558       case GL_UNSIGNED_SHORT_4_4_4_4:
2559          if (!intFormat) {
2560             rs = gs = bs = as = 1.0F / 15.0F;
2561          }
2562          if (swapBytes) {
2563             const GLushort *ussrc = (const GLushort *) src;
2564             GLuint i;
2565             for (i = 0; i < n; i ++) {
2566                GLushort p = ussrc[i];
2567                SWAP2BYTE(p);
2568                rgba[i][rDst] = ((p >> 12)      ) * rs;
2569                rgba[i][gDst] = ((p >>  8) & 0xf) * gs;
2570                rgba[i][bDst] = ((p >>  4) & 0xf) * bs;
2571                rgba[i][aDst] = ((p      ) & 0xf) * as;
2572             }
2573          }
2574          else {
2575             const GLushort *ussrc = (const GLushort *) src;
2576             GLuint i;
2577             for (i = 0; i < n; i ++) {
2578                GLushort p = ussrc[i];
2579                rgba[i][rDst] = ((p >> 12)      ) * rs;
2580                rgba[i][gDst] = ((p >>  8) & 0xf) * gs;
2581                rgba[i][bDst] = ((p >>  4) & 0xf) * bs;
2582                rgba[i][aDst] = ((p      ) & 0xf) * as;
2583             }
2584          }
2585          break;
2586       case GL_UNSIGNED_SHORT_4_4_4_4_REV:
2587          if (!intFormat) {
2588             rs = gs = bs = as = 1.0F / 15.0F;
2589          }
2590          if (swapBytes) {
2591             const GLushort *ussrc = (const GLushort *) src;
2592             GLuint i;
2593             for (i = 0; i < n; i ++) {
2594                GLushort p = ussrc[i];
2595                SWAP2BYTE(p);
2596                rgba[i][rDst] = ((p      ) & 0xf) * rs;
2597                rgba[i][gDst] = ((p >>  4) & 0xf) * gs;
2598                rgba[i][bDst] = ((p >>  8) & 0xf) * bs;
2599                rgba[i][aDst] = ((p >> 12)      ) * as;
2600             }
2601          }
2602          else {
2603             const GLushort *ussrc = (const GLushort *) src;
2604             GLuint i;
2605             for (i = 0; i < n; i ++) {
2606                GLushort p = ussrc[i];
2607                rgba[i][rDst] = ((p      ) & 0xf) * rs;
2608                rgba[i][gDst] = ((p >>  4) & 0xf) * gs;
2609                rgba[i][bDst] = ((p >>  8) & 0xf) * bs;
2610                rgba[i][aDst] = ((p >> 12)      ) * as;
2611             }
2612          }
2613          break;
2614       case GL_UNSIGNED_SHORT_5_5_5_1:
2615          if (!intFormat) {
2616             rs = gs = bs = 1.0F / 31.0F;
2617          }
2618          if (swapBytes) {
2619             const GLushort *ussrc = (const GLushort *) src;
2620             GLuint i;
2621             for (i = 0; i < n; i ++) {
2622                GLushort p = ussrc[i];
2623                SWAP2BYTE(p);
2624                rgba[i][rDst] = ((p >> 11)       ) * rs;
2625                rgba[i][gDst] = ((p >>  6) & 0x1f) * gs;
2626                rgba[i][bDst] = ((p >>  1) & 0x1f) * bs;
2627                rgba[i][aDst] = ((p      ) & 0x1)  * as;
2628             }
2629          }
2630          else {
2631             const GLushort *ussrc = (const GLushort *) src;
2632             GLuint i;
2633             for (i = 0; i < n; i ++) {
2634                GLushort p = ussrc[i];
2635                rgba[i][rDst] = ((p >> 11)       ) * rs;
2636                rgba[i][gDst] = ((p >>  6) & 0x1f) * gs;
2637                rgba[i][bDst] = ((p >>  1) & 0x1f) * bs;
2638                rgba[i][aDst] = ((p      ) & 0x1)  * as;
2639             }
2640          }
2641          break;
2642       case GL_UNSIGNED_SHORT_1_5_5_5_REV:
2643          if (!intFormat) {
2644             rs = gs = bs = 1.0F / 31.0F;
2645          }
2646          if (swapBytes) {
2647             const GLushort *ussrc = (const GLushort *) src;
2648             GLuint i;
2649             for (i = 0; i < n; i ++) {
2650                GLushort p = ussrc[i];
2651                SWAP2BYTE(p);
2652                rgba[i][rDst] = ((p      ) & 0x1f) * rs;
2653                rgba[i][gDst] = ((p >>  5) & 0x1f) * gs;
2654                rgba[i][bDst] = ((p >> 10) & 0x1f) * bs;
2655                rgba[i][aDst] = ((p >> 15)       ) * as;
2656             }
2657          }
2658          else {
2659             const GLushort *ussrc = (const GLushort *) src;
2660             GLuint i;
2661             for (i = 0; i < n; i ++) {
2662                GLushort p = ussrc[i];
2663                rgba[i][rDst] = ((p      ) & 0x1f) * rs;
2664                rgba[i][gDst] = ((p >>  5) & 0x1f) * gs;
2665                rgba[i][bDst] = ((p >> 10) & 0x1f) * bs;
2666                rgba[i][aDst] = ((p >> 15)       ) * as;
2667             }
2668          }
2669          break;
2670       case GL_UNSIGNED_INT_8_8_8_8:
2671          if (swapBytes) {
2672             const GLuint *uisrc = (const GLuint *) src;
2673             GLuint i;
2674             if (intFormat) {
2675                for (i = 0; i < n; i ++) {
2676                   GLuint p = uisrc[i];
2677                   rgba[i][rDst] = (GLfloat) ((p      ) & 0xff);
2678                   rgba[i][gDst] = (GLfloat) ((p >>  8) & 0xff);
2679                   rgba[i][bDst] = (GLfloat) ((p >> 16) & 0xff);
2680                   rgba[i][aDst] = (GLfloat) ((p >> 24)       );
2681                }
2682             }
2683             else {
2684                for (i = 0; i < n; i ++) {
2685                   GLuint p = uisrc[i];
2686                   rgba[i][rDst] = UBYTE_TO_FLOAT((p      ) & 0xff);
2687                   rgba[i][gDst] = UBYTE_TO_FLOAT((p >>  8) & 0xff);
2688                   rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2689                   rgba[i][aDst] = UBYTE_TO_FLOAT((p >> 24)       );
2690                }
2691             }
2692          }
2693          else {
2694             const GLuint *uisrc = (const GLuint *) src;
2695             GLuint i;
2696             if (intFormat) {
2697                for (i = 0; i < n; i ++) {
2698                   GLuint p = uisrc[i];
2699                   rgba[i][rDst] = (GLfloat) ((p >> 24)       );
2700                   rgba[i][gDst] = (GLfloat) ((p >> 16) & 0xff);
2701                   rgba[i][bDst] = (GLfloat) ((p >>  8) & 0xff);
2702                   rgba[i][aDst] = (GLfloat) ((p      ) & 0xff);
2703                }
2704             }
2705             else {
2706                for (i = 0; i < n; i ++) {
2707                   GLuint p = uisrc[i];
2708                   rgba[i][rDst] = UBYTE_TO_FLOAT((p >> 24)       );
2709                   rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2710                   rgba[i][bDst] = UBYTE_TO_FLOAT((p >>  8) & 0xff);
2711                   rgba[i][aDst] = UBYTE_TO_FLOAT((p      ) & 0xff);
2712                }
2713             }
2714          }
2715          break;
2716       case GL_UNSIGNED_INT_8_8_8_8_REV:
2717          if (swapBytes) {
2718             const GLuint *uisrc = (const GLuint *) src;
2719             GLuint i;
2720             if (intFormat) {
2721                for (i = 0; i < n; i ++) {
2722                   GLuint p = uisrc[i];
2723                   rgba[i][rDst] = (GLfloat) ((p >> 24)       );
2724                   rgba[i][gDst] = (GLfloat) ((p >> 16) & 0xff);
2725                   rgba[i][bDst] = (GLfloat) ((p >>  8) & 0xff);
2726                   rgba[i][aDst] = (GLfloat) ((p      ) & 0xff);
2727                }
2728             }
2729             else {
2730                for (i = 0; i < n; i ++) {
2731                   GLuint p = uisrc[i];
2732                   rgba[i][rDst] = UBYTE_TO_FLOAT((p >> 24)       );
2733                   rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2734                   rgba[i][bDst] = UBYTE_TO_FLOAT((p >>  8) & 0xff);
2735                   rgba[i][aDst] = UBYTE_TO_FLOAT((p      ) & 0xff);
2736                }
2737             }
2738          }
2739          else {
2740             const GLuint *uisrc = (const GLuint *) src;
2741             GLuint i;
2742             if (intFormat) {
2743                for (i = 0; i < n; i ++) {
2744                   GLuint p = uisrc[i];
2745                   rgba[i][rDst] = (GLfloat) ((p      ) & 0xff);
2746                   rgba[i][gDst] = (GLfloat) ((p >>  8) & 0xff);
2747                   rgba[i][bDst] = (GLfloat) ((p >> 16) & 0xff);
2748                   rgba[i][aDst] = (GLfloat) ((p >> 24)       );
2749                }
2750             }
2751             else {
2752                for (i = 0; i < n; i ++) {
2753                   GLuint p = uisrc[i];
2754                   rgba[i][rDst] = UBYTE_TO_FLOAT((p      ) & 0xff);
2755                   rgba[i][gDst] = UBYTE_TO_FLOAT((p >>  8) & 0xff);
2756                   rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2757                   rgba[i][aDst] = UBYTE_TO_FLOAT((p >> 24)       );
2758                }
2759             }
2760          }
2761          break;
2762       case GL_UNSIGNED_INT_10_10_10_2:
2763          if (!intFormat) {
2764             rs = 1.0F / 1023.0F;
2765             gs = 1.0F / 1023.0F;
2766             bs = 1.0F / 1023.0F;
2767             as = 1.0F / 3.0F;
2768          }
2769          if (swapBytes) {
2770             const GLuint *uisrc = (const GLuint *) src;
2771             GLuint i;
2772             for (i = 0; i < n; i ++) {
2773                GLuint p = uisrc[i];
2774                SWAP4BYTE(p);
2775                rgba[i][rDst] = ((p >> 22)        ) * rs;
2776                rgba[i][gDst] = ((p >> 12) & 0x3ff) * gs;
2777                rgba[i][bDst] = ((p >>  2) & 0x3ff) * bs;
2778                rgba[i][aDst] = ((p      ) & 0x3  ) * as;
2779             }
2780          }
2781          else {
2782             const GLuint *uisrc = (const GLuint *) src;
2783             GLuint i;
2784             for (i = 0; i < n; i ++) {
2785                GLuint p = uisrc[i];
2786                rgba[i][rDst] = ((p >> 22)        ) * rs;
2787                rgba[i][gDst] = ((p >> 12) & 0x3ff) * gs;
2788                rgba[i][bDst] = ((p >>  2) & 0x3ff) * bs;
2789                rgba[i][aDst] = ((p      ) & 0x3  ) * as;
2790             }
2791          }
2792          break;
2793       case GL_UNSIGNED_INT_2_10_10_10_REV:
2794          if (!intFormat) {
2795             rs = 1.0F / 1023.0F;
2796             gs = 1.0F / 1023.0F;
2797             bs = 1.0F / 1023.0F;
2798             as = 1.0F / 3.0F;
2799          }
2800          if (swapBytes) {
2801             const GLuint *uisrc = (const GLuint *) src;
2802             GLuint i;
2803             for (i = 0; i < n; i ++) {
2804                GLuint p = uisrc[i];
2805                SWAP4BYTE(p);
2806                rgba[i][rDst] = ((p      ) & 0x3ff) * rs;
2807                rgba[i][gDst] = ((p >> 10) & 0x3ff) * gs;
2808                rgba[i][bDst] = ((p >> 20) & 0x3ff) * bs;
2809                rgba[i][aDst] = ((p >> 30)        ) * as;
2810             }
2811          }
2812          else {
2813             const GLuint *uisrc = (const GLuint *) src;
2814             GLuint i;
2815             for (i = 0; i < n; i ++) {
2816                GLuint p = uisrc[i];
2817                rgba[i][rDst] = ((p      ) & 0x3ff) * rs;
2818                rgba[i][gDst] = ((p >> 10) & 0x3ff) * gs;
2819                rgba[i][bDst] = ((p >> 20) & 0x3ff) * bs;
2820                rgba[i][aDst] = ((p >> 30)        ) * as;
2821             }
2822          }
2823          break;
2824       case GL_UNSIGNED_INT_5_9_9_9_REV:
2825          if (swapBytes) {
2826             const GLuint *uisrc = (const GLuint *) src;
2827             GLuint i;
2828             GLfloat f[3];
2829             for (i = 0; i < n; i ++) {
2830                GLuint p = uisrc[i];
2831                SWAP4BYTE(p);
2832                rgb9e5_to_float3(p, f);
2833                rgba[i][rDst] = f[0];
2834                rgba[i][gDst] = f[1];
2835                rgba[i][bDst] = f[2];
2836                rgba[i][aDst] = 1.0F;
2837             }
2838          }
2839          else {
2840             const GLuint *uisrc = (const GLuint *) src;
2841             GLuint i;
2842             GLfloat f[3];
2843             for (i = 0; i < n; i ++) {
2844                rgb9e5_to_float3(uisrc[i], f);
2845                rgba[i][rDst] = f[0];
2846                rgba[i][gDst] = f[1];
2847                rgba[i][bDst] = f[2];
2848                rgba[i][aDst] = 1.0F;
2849             }
2850          }
2851          break;
2852       case GL_UNSIGNED_INT_10F_11F_11F_REV:
2853          if (swapBytes) {
2854             const GLuint *uisrc = (const GLuint *) src;
2855             GLuint i;
2856             GLfloat f[3];
2857             for (i = 0; i < n; i ++) {
2858                GLuint p = uisrc[i];
2859                SWAP4BYTE(p);
2860                r11g11b10f_to_float3(p, f);
2861                rgba[i][rDst] = f[0];
2862                rgba[i][gDst] = f[1];
2863                rgba[i][bDst] = f[2];
2864                rgba[i][aDst] = 1.0F;
2865             }
2866          }
2867          else {
2868             const GLuint *uisrc = (const GLuint *) src;
2869             GLuint i;
2870             GLfloat f[3];
2871             for (i = 0; i < n; i ++) {
2872                r11g11b10f_to_float3(uisrc[i], f);
2873                rgba[i][rDst] = f[0];
2874                rgba[i][gDst] = f[1];
2875                rgba[i][bDst] = f[2];
2876                rgba[i][aDst] = 1.0F;
2877             }
2878          }
2879          break;
2880       default:
2881          _mesa_problem(NULL, "bad srcType in extract float data");
2882          break;
2883    }
2884 #undef PROCESS
2885 }
2886
2887
2888 static INLINE GLuint
2889 clamp_byte_to_uint(GLbyte b)
2890 {
2891    return b < 0 ? 0 : b;
2892 }
2893
2894
2895 static INLINE GLuint
2896 clamp_short_to_uint(GLshort s)
2897 {
2898    return s < 0 ? 0 : s;
2899 }
2900
2901
2902 static INLINE GLuint
2903 clamp_int_to_uint(GLint i)
2904 {
2905    return i < 0 ? 0 : i;
2906 }
2907
2908
2909 static INLINE GLuint
2910 clamp_float_to_uint(GLfloat f)
2911 {
2912    return f < 0.0F ? 0 : IROUND(f);
2913 }
2914
2915
2916 static INLINE GLuint
2917 clamp_half_to_uint(GLhalfARB h)
2918 {
2919    GLfloat f = _mesa_half_to_float(h);
2920    return f < 0.0F ? 0 : IROUND(f);
2921 }
2922
2923
2924 /**
2925  * \sa extract_float_rgba()
2926  */
2927 static void
2928 extract_uint_rgba(GLuint n, GLuint rgba[][4],
2929                   GLenum srcFormat, GLenum srcType, const GLvoid *src,
2930                   GLboolean swapBytes)
2931 {
2932    GLint rSrc, gSrc, bSrc, aSrc;
2933    GLint stride;
2934    GLint rDst, bDst, gDst, aDst;
2935
2936    ASSERT(srcFormat == GL_RED ||
2937           srcFormat == GL_GREEN ||
2938           srcFormat == GL_BLUE ||
2939           srcFormat == GL_ALPHA ||
2940           srcFormat == GL_LUMINANCE ||
2941           srcFormat == GL_LUMINANCE_ALPHA ||
2942           srcFormat == GL_INTENSITY ||
2943           srcFormat == GL_RG ||
2944           srcFormat == GL_RGB ||
2945           srcFormat == GL_BGR ||
2946           srcFormat == GL_RGBA ||
2947           srcFormat == GL_BGRA ||
2948           srcFormat == GL_ABGR_EXT ||
2949           srcFormat == GL_DU8DV8_ATI ||
2950           srcFormat == GL_DUDV_ATI ||
2951           srcFormat == GL_RED_INTEGER_EXT ||
2952           srcFormat == GL_GREEN_INTEGER_EXT ||
2953           srcFormat == GL_BLUE_INTEGER_EXT ||
2954           srcFormat == GL_ALPHA_INTEGER_EXT ||
2955           srcFormat == GL_RGB_INTEGER_EXT ||
2956           srcFormat == GL_RGBA_INTEGER_EXT ||
2957           srcFormat == GL_BGR_INTEGER_EXT ||
2958           srcFormat == GL_BGRA_INTEGER_EXT ||
2959           srcFormat == GL_LUMINANCE_INTEGER_EXT ||
2960           srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);
2961
2962    ASSERT(srcType == GL_UNSIGNED_BYTE ||
2963           srcType == GL_BYTE ||
2964           srcType == GL_UNSIGNED_SHORT ||
2965           srcType == GL_SHORT ||
2966           srcType == GL_UNSIGNED_INT ||
2967           srcType == GL_INT ||
2968           srcType == GL_HALF_FLOAT_ARB ||
2969           srcType == GL_FLOAT ||
2970           srcType == GL_UNSIGNED_BYTE_3_3_2 ||
2971           srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
2972           srcType == GL_UNSIGNED_SHORT_5_6_5 ||
2973           srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
2974           srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
2975           srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
2976           srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
2977           srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
2978           srcType == GL_UNSIGNED_INT_8_8_8_8 ||
2979           srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
2980           srcType == GL_UNSIGNED_INT_10_10_10_2 ||
2981           srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
2982           srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
2983           srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
2984
2985    get_component_mapping(srcFormat,
2986                          &rSrc, &gSrc, &bSrc, &aSrc,
2987                          &rDst, &gDst, &bDst, &aDst);
2988
2989    stride = _mesa_components_in_format(srcFormat);
2990
2991 #define PROCESS(SRC_INDEX, DST_INDEX, DEFAULT, TYPE, CONVERSION)        \
2992    if ((SRC_INDEX) < 0) {                                               \
2993       GLuint i;                                                         \
2994       for (i = 0; i < n; i++) {                                         \
2995          rgba[i][DST_INDEX] = DEFAULT;                                  \
2996       }                                                                 \
2997    }                                                                    \
2998    else if (swapBytes) {                                                \
2999       const TYPE *s = (const TYPE *) src;                               \
3000       GLuint i;                                                         \
3001       for (i = 0; i < n; i++) {                                         \
3002          TYPE value = s[SRC_INDEX];                                     \
3003          if (sizeof(TYPE) == 2) {                                       \
3004             SWAP2BYTE(value);                                           \
3005          }                                                              \
3006          else if (sizeof(TYPE) == 4) {                                  \
3007             SWAP4BYTE(value);                                           \
3008          }                                                              \
3009          rgba[i][DST_INDEX] = CONVERSION(value);                        \
3010          s += stride;                                                   \
3011       }                                                                 \
3012    }                                                                    \
3013    else {                                                               \
3014       const TYPE *s = (const TYPE *) src;                               \
3015       GLuint i;                                                         \
3016       for (i = 0; i < n; i++) {                                         \
3017          rgba[i][DST_INDEX] = CONVERSION(s[SRC_INDEX]);                 \
3018          s += stride;                                                   \
3019       }                                                                 \
3020    }
3021
3022    switch (srcType) {
3023       case GL_UNSIGNED_BYTE:
3024          PROCESS(rSrc, RCOMP, 0, GLubyte, (GLuint));
3025          PROCESS(gSrc, GCOMP, 0, GLubyte, (GLuint));
3026          PROCESS(bSrc, BCOMP, 0, GLubyte, (GLuint));
3027          PROCESS(aSrc, ACOMP, 1, GLubyte, (GLuint));
3028          break;
3029       case GL_BYTE:
3030          PROCESS(rSrc, RCOMP, 0, GLbyte, clamp_byte_to_uint);
3031          PROCESS(gSrc, GCOMP, 0, GLbyte, clamp_byte_to_uint);
3032          PROCESS(bSrc, BCOMP, 0, GLbyte, clamp_byte_to_uint);
3033          PROCESS(aSrc, ACOMP, 1, GLbyte, clamp_byte_to_uint);
3034          break;
3035       case GL_UNSIGNED_SHORT:
3036          PROCESS(rSrc, RCOMP, 0, GLushort, (GLuint));
3037          PROCESS(gSrc, GCOMP, 0, GLushort, (GLuint));
3038          PROCESS(bSrc, BCOMP, 0, GLushort, (GLuint));
3039          PROCESS(aSrc, ACOMP, 1, GLushort, (GLuint));
3040          break;
3041       case GL_SHORT:
3042          PROCESS(rSrc, RCOMP, 0, GLshort, clamp_short_to_uint);
3043          PROCESS(gSrc, GCOMP, 0, GLshort, clamp_short_to_uint);
3044          PROCESS(bSrc, BCOMP, 0, GLshort, clamp_short_to_uint);
3045          PROCESS(aSrc, ACOMP, 1, GLshort, clamp_short_to_uint);
3046          break;
3047       case GL_UNSIGNED_INT:
3048          PROCESS(rSrc, RCOMP, 0, GLuint, (GLuint));
3049          PROCESS(gSrc, GCOMP, 0, GLuint, (GLuint));
3050          PROCESS(bSrc, BCOMP, 0, GLuint, (GLuint));
3051          PROCESS(aSrc, ACOMP, 1, GLuint, (GLuint));
3052          break;
3053       case GL_INT:
3054          PROCESS(rSrc, RCOMP, 0, GLint, clamp_int_to_uint);
3055          PROCESS(gSrc, GCOMP, 0, GLint, clamp_int_to_uint);
3056          PROCESS(bSrc, BCOMP, 0, GLint, clamp_int_to_uint);
3057          PROCESS(aSrc, ACOMP, 1, GLint, clamp_int_to_uint);
3058          break;
3059       case GL_FLOAT:
3060          PROCESS(rSrc, RCOMP, 0, GLfloat, clamp_float_to_uint);
3061          PROCESS(gSrc, GCOMP, 0, GLfloat, clamp_float_to_uint);
3062          PROCESS(bSrc, BCOMP, 0, GLfloat, clamp_float_to_uint);
3063          PROCESS(aSrc, ACOMP, 1, GLfloat, clamp_float_to_uint);
3064          break;
3065       case GL_HALF_FLOAT_ARB:
3066          PROCESS(rSrc, RCOMP, 0, GLhalfARB, clamp_half_to_uint);
3067          PROCESS(gSrc, GCOMP, 0, GLhalfARB, clamp_half_to_uint);
3068          PROCESS(bSrc, BCOMP, 0, GLhalfARB, clamp_half_to_uint);
3069          PROCESS(aSrc, ACOMP, 1, GLhalfARB, clamp_half_to_uint);
3070          break;
3071       case GL_UNSIGNED_BYTE_3_3_2:
3072          {
3073             const GLubyte *ubsrc = (const GLubyte *) src;
3074             GLuint i;
3075             for (i = 0; i < n; i ++) {
3076                GLubyte p = ubsrc[i];
3077                rgba[i][rDst] = ((p >> 5)      );
3078                rgba[i][gDst] = ((p >> 2) & 0x7);
3079                rgba[i][bDst] = ((p     ) & 0x3);
3080                rgba[i][aDst] = 1;
3081             }
3082          }
3083          break;
3084       case GL_UNSIGNED_BYTE_2_3_3_REV:
3085          {
3086             const GLubyte *ubsrc = (const GLubyte *) src;
3087             GLuint i;
3088             for (i = 0; i < n; i ++) {
3089                GLubyte p = ubsrc[i];
3090                rgba[i][rDst] = ((p     ) & 0x7);
3091                rgba[i][gDst] = ((p >> 3) & 0x7);
3092                rgba[i][bDst] = ((p >> 6)      );
3093                rgba[i][aDst] = 1;
3094             }
3095          }
3096          break;
3097       case GL_UNSIGNED_SHORT_5_6_5:
3098          if (swapBytes) {
3099             const GLushort *ussrc = (const GLushort *) src;
3100             GLuint i;
3101             for (i = 0; i < n; i ++) {
3102                GLushort p = ussrc[i];
3103                SWAP2BYTE(p);
3104                rgba[i][rDst] = ((p >> 11)       );
3105                rgba[i][gDst] = ((p >>  5) & 0x3f);
3106                rgba[i][bDst] = ((p      ) & 0x1f);
3107                rgba[i][aDst] = 1;
3108             }
3109          }
3110          else {
3111             const GLushort *ussrc = (const GLushort *) src;
3112             GLuint i;
3113             for (i = 0; i < n; i ++) {
3114                GLushort p = ussrc[i];
3115                rgba[i][rDst] = ((p >> 11)       );
3116                rgba[i][gDst] = ((p >>  5) & 0x3f);
3117                rgba[i][bDst] = ((p      ) & 0x1f);
3118                rgba[i][aDst] = 1;
3119             }
3120          }
3121          break;
3122       case GL_UNSIGNED_SHORT_5_6_5_REV:
3123          if (swapBytes) {
3124             const GLushort *ussrc = (const GLushort *) src;
3125             GLuint i;
3126             for (i = 0; i < n; i ++) {
3127                GLushort p = ussrc[i];
3128                SWAP2BYTE(p);
3129                rgba[i][rDst] = ((p      ) & 0x1f);
3130                rgba[i][gDst] = ((p >>  5) & 0x3f);
3131                rgba[i][bDst] = ((p >> 11)       );
3132                rgba[i][aDst] = 1;
3133             }
3134          }
3135          else {
3136             const GLushort *ussrc = (const GLushort *) src;
3137             GLuint i;
3138             for (i = 0; i < n; i ++) {
3139                GLushort p = ussrc[i];
3140                rgba[i][rDst] = ((p      ) & 0x1f);
3141                rgba[i][gDst] = ((p >>  5) & 0x3f);
3142                rgba[i][bDst] = ((p >> 11)       );
3143                rgba[i][aDst] = 1;
3144             }
3145          }
3146          break;
3147       case GL_UNSIGNED_SHORT_4_4_4_4:
3148          if (swapBytes) {
3149             const GLushort *ussrc = (const GLushort *) src;
3150             GLuint i;
3151             for (i = 0; i < n; i ++) {
3152                GLushort p = ussrc[i];
3153                SWAP2BYTE(p);
3154                rgba[i][rDst] = ((p >> 12)      );
3155                rgba[i][gDst] = ((p >>  8) & 0xf);
3156                rgba[i][bDst] = ((p >>  4) & 0xf);
3157                rgba[i][aDst] = ((p      ) & 0xf);
3158             }
3159          }
3160          else {
3161             const GLushort *ussrc = (const GLushort *) src;
3162             GLuint i;
3163             for (i = 0; i < n; i ++) {
3164                GLushort p = ussrc[i];
3165                rgba[i][rDst] = ((p >> 12)      );
3166                rgba[i][gDst] = ((p >>  8) & 0xf);
3167                rgba[i][bDst] = ((p >>  4) & 0xf);
3168                rgba[i][aDst] = ((p      ) & 0xf);
3169             }
3170          }
3171          break;
3172       case GL_UNSIGNED_SHORT_4_4_4_4_REV:
3173          if (swapBytes) {
3174             const GLushort *ussrc = (const GLushort *) src;
3175             GLuint i;
3176             for (i = 0; i < n; i ++) {
3177                GLushort p = ussrc[i];
3178                SWAP2BYTE(p);
3179                rgba[i][rDst] = ((p      ) & 0xf);
3180                rgba[i][gDst] = ((p >>  4) & 0xf);
3181                rgba[i][bDst] = ((p >>  8) & 0xf);
3182                rgba[i][aDst] = ((p >> 12)      );
3183             }
3184          }
3185          else {
3186             const GLushort *ussrc = (const GLushort *) src;
3187             GLuint i;
3188             for (i = 0; i < n; i ++) {
3189                GLushort p = ussrc[i];
3190                rgba[i][rDst] = ((p      ) & 0xf);
3191                rgba[i][gDst] = ((p >>  4) & 0xf);
3192                rgba[i][bDst] = ((p >>  8) & 0xf);
3193                rgba[i][aDst] = ((p >> 12)      );
3194             }
3195          }
3196          break;
3197       case GL_UNSIGNED_SHORT_5_5_5_1:
3198          if (swapBytes) {
3199             const GLushort *ussrc = (const GLushort *) src;
3200             GLuint i;
3201             for (i = 0; i < n; i ++) {
3202                GLushort p = ussrc[i];
3203                SWAP2BYTE(p);
3204                rgba[i][rDst] = ((p >> 11)       );
3205                rgba[i][gDst] = ((p >>  6) & 0x1f);
3206                rgba[i][bDst] = ((p >>  1) & 0x1f);
3207                rgba[i][aDst] = ((p      ) & 0x1 );
3208             }
3209          }
3210          else {
3211             const GLushort *ussrc = (const GLushort *) src;
3212             GLuint i;
3213             for (i = 0; i < n; i ++) {
3214                GLushort p = ussrc[i];
3215                rgba[i][rDst] = ((p >> 11)       );
3216                rgba[i][gDst] = ((p >>  6) & 0x1f);
3217                rgba[i][bDst] = ((p >>  1) & 0x1f);
3218                rgba[i][aDst] = ((p      ) & 0x1 );
3219             }
3220          }
3221          break;
3222       case GL_UNSIGNED_SHORT_1_5_5_5_REV:
3223          if (swapBytes) {
3224             const GLushort *ussrc = (const GLushort *) src;
3225             GLuint i;
3226             for (i = 0; i < n; i ++) {
3227                GLushort p = ussrc[i];
3228                SWAP2BYTE(p);
3229                rgba[i][rDst] = ((p      ) & 0x1f);
3230                rgba[i][gDst] = ((p >>  5) & 0x1f);
3231                rgba[i][bDst] = ((p >> 10) & 0x1f);
3232                rgba[i][aDst] = ((p >> 15)       );
3233             }
3234          }
3235          else {
3236             const GLushort *ussrc = (const GLushort *) src;
3237             GLuint i;
3238             for (i = 0; i < n; i ++) {
3239                GLushort p = ussrc[i];
3240                rgba[i][rDst] = ((p      ) & 0x1f);
3241                rgba[i][gDst] = ((p >>  5) & 0x1f);
3242                rgba[i][bDst] = ((p >> 10) & 0x1f);
3243                rgba[i][aDst] = ((p >> 15)       );
3244             }
3245          }
3246          break;
3247       case GL_UNSIGNED_INT_8_8_8_8:
3248          if (swapBytes) {
3249             const GLuint *uisrc = (const GLuint *) src;
3250             GLuint i;
3251             for (i = 0; i < n; i ++) {
3252                GLuint p = uisrc[i];
3253                rgba[i][rDst] = ((p      ) & 0xff);
3254                rgba[i][gDst] = ((p >>  8) & 0xff);
3255                rgba[i][bDst] = ((p >> 16) & 0xff);
3256                rgba[i][aDst] = ((p >> 24)       );
3257             }
3258          }
3259          else {
3260             const GLuint *uisrc = (const GLuint *) src;
3261             GLuint i;
3262             for (i = 0; i < n; i ++) {
3263                GLuint p = uisrc[i];
3264                rgba[i][rDst] = ((p >> 24)       );
3265                rgba[i][gDst] = ((p >> 16) & 0xff);
3266                rgba[i][bDst] = ((p >>  8) & 0xff);
3267                rgba[i][aDst] = ((p      ) & 0xff);
3268             }
3269          }
3270          break;
3271       case GL_UNSIGNED_INT_8_8_8_8_REV:
3272          if (swapBytes) {
3273             const GLuint *uisrc = (const GLuint *) src;
3274             GLuint i;
3275             for (i = 0; i < n; i ++) {
3276                GLuint p = uisrc[i];
3277                rgba[i][rDst] = ((p >> 24)       );
3278                rgba[i][gDst] = ((p >> 16) & 0xff);
3279                rgba[i][bDst] = ((p >>  8) & 0xff);
3280                rgba[i][aDst] = ((p      ) & 0xff);
3281             }
3282          }
3283          else {
3284             const GLuint *uisrc = (const GLuint *) src;
3285             GLuint i;
3286             for (i = 0; i < n; i ++) {
3287                GLuint p = uisrc[i];
3288                rgba[i][rDst] = ((p      ) & 0xff);
3289                rgba[i][gDst] = ((p >>  8) & 0xff);
3290                rgba[i][bDst] = ((p >> 16) & 0xff);
3291                rgba[i][aDst] = ((p >> 24)       );
3292             }
3293          }
3294          break;
3295       case GL_UNSIGNED_INT_10_10_10_2:
3296          if (swapBytes) {
3297             const GLuint *uisrc = (const GLuint *) src;
3298             GLuint i;
3299             for (i = 0; i < n; i ++) {
3300                GLuint p = uisrc[i];
3301                SWAP4BYTE(p);
3302                rgba[i][rDst] = ((p >> 22)        );
3303                rgba[i][gDst] = ((p >> 12) & 0x3ff);
3304                rgba[i][bDst] = ((p >>  2) & 0x3ff);
3305                rgba[i][aDst] = ((p      ) & 0x3  );
3306             }
3307          }
3308          else {
3309             const GLuint *uisrc = (const GLuint *) src;
3310             GLuint i;
3311             for (i = 0; i < n; i ++) {
3312                GLuint p = uisrc[i];
3313                rgba[i][rDst] = ((p >> 22)        );
3314                rgba[i][gDst] = ((p >> 12) & 0x3ff);
3315                rgba[i][bDst] = ((p >>  2) & 0x3ff);
3316                rgba[i][aDst] = ((p      ) & 0x3  );
3317             }
3318          }
3319          break;
3320       case GL_UNSIGNED_INT_2_10_10_10_REV:
3321          if (swapBytes) {
3322             const GLuint *uisrc = (const GLuint *) src;
3323             GLuint i;
3324             for (i = 0; i < n; i ++) {
3325                GLuint p = uisrc[i];
3326                SWAP4BYTE(p);
3327                rgba[i][rDst] = ((p      ) & 0x3ff);
3328                rgba[i][gDst] = ((p >> 10) & 0x3ff);
3329                rgba[i][bDst] = ((p >> 20) & 0x3ff);
3330                rgba[i][aDst] = ((p >> 30)        );
3331             }
3332          }
3333          else {
3334             const GLuint *uisrc = (const GLuint *) src;
3335             GLuint i;
3336             for (i = 0; i < n; i ++) {
3337                GLuint p = uisrc[i];
3338                rgba[i][rDst] = ((p      ) & 0x3ff);
3339                rgba[i][gDst] = ((p >> 10) & 0x3ff);
3340                rgba[i][bDst] = ((p >> 20) & 0x3ff);
3341                rgba[i][aDst] = ((p >> 30)        );
3342             }
3343          }
3344          break;
3345       case GL_UNSIGNED_INT_5_9_9_9_REV:
3346          if (swapBytes) {
3347             const GLuint *uisrc = (const GLuint *) src;
3348             GLuint i;
3349             float f[3];
3350             for (i = 0; i < n; i ++) {
3351                GLuint p = uisrc[i];
3352                SWAP4BYTE(p);
3353                rgb9e5_to_float3(p, f);
3354                rgba[i][rDst] = clamp_float_to_uint(f[0]);
3355                rgba[i][gDst] = clamp_float_to_uint(f[1]);
3356                rgba[i][bDst] = clamp_float_to_uint(f[2]);
3357                rgba[i][aDst] = 1;
3358             }
3359          }
3360          else {
3361             const GLuint *uisrc = (const GLuint *) src;
3362             GLuint i;
3363             float f[3];
3364             for (i = 0; i < n; i ++) {
3365                GLuint p = uisrc[i];
3366                rgb9e5_to_float3(p, f);
3367                rgba[i][rDst] = clamp_float_to_uint(f[0]);
3368                rgba[i][gDst] = clamp_float_to_uint(f[1]);
3369                rgba[i][bDst] = clamp_float_to_uint(f[2]);
3370                rgba[i][aDst] = 1;
3371             }
3372          }
3373          break;
3374       case GL_UNSIGNED_INT_10F_11F_11F_REV:
3375          if (swapBytes) {
3376             const GLuint *uisrc = (const GLuint *) src;
3377             GLuint i;
3378             float f[3];
3379             for (i = 0; i < n; i ++) {
3380                GLuint p = uisrc[i];
3381                SWAP4BYTE(p);
3382                r11g11b10f_to_float3(p, f);
3383                rgba[i][rDst] = clamp_float_to_uint(f[0]);
3384                rgba[i][gDst] = clamp_float_to_uint(f[1]);
3385                rgba[i][bDst] = clamp_float_to_uint(f[2]);
3386                rgba[i][aDst] = 1;
3387             }
3388          }
3389          else {
3390             const GLuint *uisrc = (const GLuint *) src;
3391             GLuint i;
3392             float f[3];
3393             for (i = 0; i < n; i ++) {
3394                GLuint p = uisrc[i];
3395                r11g11b10f_to_float3(p, f);
3396                rgba[i][rDst] = clamp_float_to_uint(f[0]);
3397                rgba[i][gDst] = clamp_float_to_uint(f[1]);
3398                rgba[i][bDst] = clamp_float_to_uint(f[2]);
3399                rgba[i][aDst] = 1;
3400             }
3401          }
3402          break;
3403       default:
3404          _mesa_problem(NULL, "bad srcType in extract uint data");
3405          break;
3406    }
3407 #undef PROCESS
3408 }
3409
3410
3411
3412 /*
3413  * Unpack a row of color image data from a client buffer according to
3414  * the pixel unpacking parameters.
3415  * Return GLchan values in the specified dest image format.
3416  * This is used by glDrawPixels and glTexImage?D().
3417  * \param ctx - the context
3418  *         n - number of pixels in the span
3419  *         dstFormat - format of destination color array
3420  *         dest - the destination color array
3421  *         srcFormat - source image format
3422  *         srcType - source image  data type
3423  *         source - source image pointer
3424  *         srcPacking - pixel unpacking parameters
3425  *         transferOps - bitmask of IMAGE_*_BIT values of operations to apply
3426  *
3427  * XXX perhaps expand this to process whole images someday.
3428  */
3429 void
3430 _mesa_unpack_color_span_chan( struct gl_context *ctx,
3431                               GLuint n, GLenum dstFormat, GLchan dest[],
3432                               GLenum srcFormat, GLenum srcType,
3433                               const GLvoid *source,
3434                               const struct gl_pixelstore_attrib *srcPacking,
3435                               GLbitfield transferOps )
3436 {
3437    ASSERT(dstFormat == GL_ALPHA ||
3438           dstFormat == GL_LUMINANCE ||
3439           dstFormat == GL_LUMINANCE_ALPHA ||
3440           dstFormat == GL_INTENSITY ||
3441           dstFormat == GL_RED ||
3442           dstFormat == GL_RG ||
3443           dstFormat == GL_RGB ||
3444           dstFormat == GL_RGBA ||
3445           dstFormat == GL_COLOR_INDEX);
3446
3447    ASSERT(srcFormat == GL_RED ||
3448           srcFormat == GL_GREEN ||
3449           srcFormat == GL_BLUE ||
3450           srcFormat == GL_ALPHA ||
3451           srcFormat == GL_LUMINANCE ||
3452           srcFormat == GL_LUMINANCE_ALPHA ||
3453           srcFormat == GL_INTENSITY ||
3454           srcFormat == GL_RG ||
3455           srcFormat == GL_RGB ||
3456           srcFormat == GL_BGR ||
3457           srcFormat == GL_RGBA ||
3458           srcFormat == GL_BGRA ||
3459           srcFormat == GL_ABGR_EXT ||
3460           srcFormat == GL_COLOR_INDEX);
3461
3462    ASSERT(srcType == GL_BITMAP ||
3463           srcType == GL_UNSIGNED_BYTE ||
3464           srcType == GL_BYTE ||
3465           srcType == GL_UNSIGNED_SHORT ||
3466           srcType == GL_SHORT ||
3467           srcType == GL_UNSIGNED_INT ||
3468           srcType == GL_INT ||
3469           srcType == GL_HALF_FLOAT_ARB ||
3470           srcType == GL_FLOAT ||
3471           srcType == GL_UNSIGNED_BYTE_3_3_2 ||
3472           srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
3473           srcType == GL_UNSIGNED_SHORT_5_6_5 ||
3474           srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
3475           srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
3476           srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
3477           srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
3478           srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
3479           srcType == GL_UNSIGNED_INT_8_8_8_8 ||
3480           srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
3481           srcType == GL_UNSIGNED_INT_10_10_10_2 ||
3482           srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
3483           srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
3484           srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
3485
3486    /* Try simple cases first */
3487    if (transferOps == 0) {
3488       if (srcType == CHAN_TYPE) {
3489          if (dstFormat == GL_RGBA) {
3490             if (srcFormat == GL_RGBA) {
3491                memcpy( dest, source, n * 4 * sizeof(GLchan) );
3492                return;
3493             }
3494             else if (srcFormat == GL_RGB) {
3495                GLuint i;
3496                const GLchan *src = (const GLchan *) source;
3497                GLchan *dst = dest;
3498                for (i = 0; i < n; i++) {
3499                   dst[0] = src[0];
3500                   dst[1] = src[1];
3501                   dst[2] = src[2];
3502                   dst[3] = CHAN_MAX;
3503                   src += 3;
3504                   dst += 4;
3505                }
3506                return;
3507             }
3508          }
3509          else if (dstFormat == GL_RGB) {
3510             if (srcFormat == GL_RGB) {
3511                memcpy( dest, source, n * 3 * sizeof(GLchan) );
3512                return;
3513             }
3514             else if (srcFormat == GL_RGBA) {
3515                GLuint i;
3516                const GLchan *src = (const GLchan *) source;
3517                GLchan *dst = dest;
3518                for (i = 0; i < n; i++) {
3519                   dst[0] = src[0];
3520                   dst[1] = src[1];
3521                   dst[2] = src[2];
3522                   src += 4;
3523                   dst += 3;
3524                }
3525                return;
3526             }
3527          }
3528          else if (dstFormat == srcFormat) {
3529             GLint comps = _mesa_components_in_format(srcFormat);
3530             assert(comps > 0);
3531             memcpy( dest, source, n * comps * sizeof(GLchan) );
3532             return;
3533          }
3534       }
3535       /*
3536        * Common situation, loading 8bit RGBA/RGB source images
3537        * into 16/32 bit destination. (OSMesa16/32)
3538        */
3539       else if (srcType == GL_UNSIGNED_BYTE) {
3540          if (dstFormat == GL_RGBA) {
3541             if (srcFormat == GL_RGB) {
3542                GLuint i;
3543                const GLubyte *src = (const GLubyte *) source;
3544                GLchan *dst = dest;
3545                for (i = 0; i < n; i++) {
3546                   dst[0] = UBYTE_TO_CHAN(src[0]);
3547                   dst[1] = UBYTE_TO_CHAN(src[1]);
3548                   dst[2] = UBYTE_TO_CHAN(src[2]);
3549                   dst[3] = CHAN_MAX;
3550                   src += 3;
3551                   dst += 4;
3552                }
3553                return;
3554             }
3555             else if (srcFormat == GL_RGBA) {
3556                GLuint i;
3557                const GLubyte *src = (const GLubyte *) source;
3558                GLchan *dst = dest;
3559                for (i = 0; i < n; i++) {
3560                   dst[0] = UBYTE_TO_CHAN(src[0]);
3561                   dst[1] = UBYTE_TO_CHAN(src[1]);
3562                   dst[2] = UBYTE_TO_CHAN(src[2]);
3563                   dst[3] = UBYTE_TO_CHAN(src[3]);
3564                   src += 4;
3565                   dst += 4;
3566                }
3567                return;
3568              }
3569          }
3570          else if (dstFormat == GL_RGB) {
3571             if (srcFormat == GL_RGB) {
3572                GLuint i;
3573                const GLubyte *src = (const GLubyte *) source;
3574                GLchan *dst = dest;
3575                for (i = 0; i < n; i++) {
3576                   dst[0] = UBYTE_TO_CHAN(src[0]);
3577                   dst[1] = UBYTE_TO_CHAN(src[1]);
3578                   dst[2] = UBYTE_TO_CHAN(src[2]);
3579                   src += 3;
3580                   dst += 3;
3581                }
3582                return;
3583             }
3584             else if (srcFormat == GL_RGBA) {
3585                GLuint i;
3586                const GLubyte *src = (const GLubyte *) source;
3587                GLchan *dst = dest;
3588                for (i = 0; i < n; i++) {
3589                   dst[0] = UBYTE_TO_CHAN(src[0]);
3590                   dst[1] = UBYTE_TO_CHAN(src[1]);
3591                   dst[2] = UBYTE_TO_CHAN(src[2]);
3592                   src += 4;
3593                   dst += 3;
3594                }
3595                return;
3596             }
3597          }
3598       }
3599    }
3600
3601
3602    /* general solution begins here */
3603    {
3604       GLint dstComponents;
3605       GLint rDst, gDst, bDst, aDst, lDst, iDst;
3606       GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));
3607
3608       if (!rgba) {
3609          _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3610          return;
3611       }
3612
3613       dstComponents = _mesa_components_in_format( dstFormat );
3614       /* source & dest image formats should have been error checked by now */
3615       assert(dstComponents > 0);
3616
3617       /*
3618        * Extract image data and convert to RGBA floats
3619        */
3620       if (srcFormat == GL_COLOR_INDEX) {
3621          GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
3622
3623          if (!indexes) {
3624             _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3625             return;
3626          }
3627
3628          extract_uint_indexes(n, indexes, srcFormat, srcType, source,
3629                               srcPacking);
3630
3631          if (dstFormat == GL_COLOR_INDEX) {
3632             GLuint i;
3633             _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
3634             /* convert to GLchan and return */
3635             for (i = 0; i < n; i++) {
3636                dest[i] = (GLchan) (indexes[i] & 0xff);
3637             }
3638             free(indexes);
3639             free(rgba);
3640             return;
3641          }
3642          else {
3643             /* Convert indexes to RGBA */
3644             if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
3645                _mesa_shift_and_offset_ci(ctx, n, indexes);
3646             }
3647             _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
3648          }
3649
3650          /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
3651           * with color indexes.
3652           */
3653          transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT);
3654
3655          free(indexes);
3656       }
3657       else {
3658          /* non-color index data */
3659          extract_float_rgba(n, rgba, srcFormat, srcType, source,
3660                             srcPacking->SwapBytes);
3661       }
3662
3663       /* Need to clamp if returning GLubytes or GLushorts */
3664 #if CHAN_TYPE != GL_FLOAT
3665       transferOps |= IMAGE_CLAMP_BIT;
3666 #endif
3667
3668       if (transferOps) {
3669          _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
3670       }
3671
3672       get_component_indexes(dstFormat,
3673                             &rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
3674
3675       /* Now return the GLchan data in the requested dstFormat */
3676       if (rDst >= 0) {
3677          GLchan *dst = dest;
3678          GLuint i;
3679          for (i = 0; i < n; i++) {
3680             CLAMPED_FLOAT_TO_CHAN(dst[rDst], rgba[i][RCOMP]);
3681             dst += dstComponents;
3682          }
3683       }
3684
3685       if (gDst >= 0) {
3686          GLchan *dst = dest;
3687          GLuint i;
3688          for (i = 0; i < n; i++) {
3689             CLAMPED_FLOAT_TO_CHAN(dst[gDst], rgba[i][GCOMP]);
3690             dst += dstComponents;
3691          }
3692       }
3693
3694       if (bDst >= 0) {
3695          GLchan *dst = dest;
3696          GLuint i;
3697          for (i = 0; i < n; i++) {
3698             CLAMPED_FLOAT_TO_CHAN(dst[bDst], rgba[i][BCOMP]);
3699             dst += dstComponents;
3700          }
3701       }
3702
3703       if (aDst >= 0) {
3704          GLchan *dst = dest;
3705          GLuint i;
3706          for (i = 0; i < n; i++) {
3707             CLAMPED_FLOAT_TO_CHAN(dst[aDst], rgba[i][ACOMP]);
3708             dst += dstComponents;
3709          }
3710       }
3711
3712       if (iDst >= 0) {
3713          GLchan *dst = dest;
3714          GLuint i;
3715          assert(iDst == 0);
3716          assert(dstComponents == 1);
3717          for (i = 0; i < n; i++) {
3718             /* Intensity comes from red channel */
3719             CLAMPED_FLOAT_TO_CHAN(dst[i], rgba[i][RCOMP]);
3720          }
3721       }
3722
3723       if (lDst >= 0) {
3724          GLchan *dst = dest;
3725          GLuint i;
3726          assert(lDst == 0);
3727          for (i = 0; i < n; i++) {
3728             /* Luminance comes from red channel */
3729             CLAMPED_FLOAT_TO_CHAN(dst[0], rgba[i][RCOMP]);
3730             dst += dstComponents;
3731          }
3732       }
3733
3734       free(rgba);
3735    }
3736 }
3737
3738
3739 /**
3740  * Same as _mesa_unpack_color_span_chan(), but return GLfloat data
3741  * instead of GLchan.
3742  */
3743 void
3744 _mesa_unpack_color_span_float( struct gl_context *ctx,
3745                                GLuint n, GLenum dstFormat, GLfloat dest[],
3746                                GLenum srcFormat, GLenum srcType,
3747                                const GLvoid *source,
3748                                const struct gl_pixelstore_attrib *srcPacking,
3749                                GLbitfield transferOps )
3750 {
3751    ASSERT(dstFormat == GL_ALPHA ||
3752           dstFormat == GL_LUMINANCE ||
3753           dstFormat == GL_LUMINANCE_ALPHA ||
3754           dstFormat == GL_INTENSITY ||
3755           dstFormat == GL_RED ||
3756           dstFormat == GL_RG ||
3757           dstFormat == GL_RGB ||
3758           dstFormat == GL_RGBA ||
3759           dstFormat == GL_COLOR_INDEX);
3760
3761    ASSERT(srcFormat == GL_RED ||
3762           srcFormat == GL_GREEN ||
3763           srcFormat == GL_BLUE ||
3764           srcFormat == GL_ALPHA ||
3765           srcFormat == GL_LUMINANCE ||
3766           srcFormat == GL_LUMINANCE_ALPHA ||
3767           srcFormat == GL_INTENSITY ||
3768           srcFormat == GL_RG ||
3769           srcFormat == GL_RGB ||
3770           srcFormat == GL_BGR ||
3771           srcFormat == GL_RGBA ||
3772           srcFormat == GL_BGRA ||
3773           srcFormat == GL_ABGR_EXT ||
3774           srcFormat == GL_RED_INTEGER_EXT ||
3775           srcFormat == GL_GREEN_INTEGER_EXT ||
3776           srcFormat == GL_BLUE_INTEGER_EXT ||
3777           srcFormat == GL_ALPHA_INTEGER_EXT ||
3778           srcFormat == GL_RGB_INTEGER_EXT ||
3779           srcFormat == GL_RGBA_INTEGER_EXT ||
3780           srcFormat == GL_BGR_INTEGER_EXT ||
3781           srcFormat == GL_BGRA_INTEGER_EXT ||
3782           srcFormat == GL_LUMINANCE_INTEGER_EXT ||
3783           srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT ||
3784           srcFormat == GL_COLOR_INDEX);
3785
3786    ASSERT(srcType == GL_BITMAP ||
3787           srcType == GL_UNSIGNED_BYTE ||
3788           srcType == GL_BYTE ||
3789           srcType == GL_UNSIGNED_SHORT ||
3790           srcType == GL_SHORT ||
3791           srcType == GL_UNSIGNED_INT ||
3792           srcType == GL_INT ||
3793           srcType == GL_HALF_FLOAT_ARB ||
3794           srcType == GL_FLOAT ||
3795           srcType == GL_UNSIGNED_BYTE_3_3_2 ||
3796           srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
3797           srcType == GL_UNSIGNED_SHORT_5_6_5 ||
3798           srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
3799           srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
3800           srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
3801           srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
3802           srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
3803           srcType == GL_UNSIGNED_INT_8_8_8_8 ||
3804           srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
3805           srcType == GL_UNSIGNED_INT_10_10_10_2 ||
3806           srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
3807           srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
3808           srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
3809
3810    /* general solution, no special cases, yet */
3811    {
3812       GLint dstComponents;
3813       GLint rDst, gDst, bDst, aDst, lDst, iDst;
3814       GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));
3815
3816       if (!rgba) {
3817          _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3818          return;
3819       }
3820
3821       dstComponents = _mesa_components_in_format( dstFormat );
3822       /* source & dest image formats should have been error checked by now */
3823       assert(dstComponents > 0);
3824
3825       /*
3826        * Extract image data and convert to RGBA floats
3827        */
3828       if (srcFormat == GL_COLOR_INDEX) {
3829          GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
3830
3831          if (!indexes) {
3832             _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3833             free(rgba);
3834             return;
3835          }
3836
3837          extract_uint_indexes(n, indexes, srcFormat, srcType, source,
3838                               srcPacking);
3839
3840          if (dstFormat == GL_COLOR_INDEX) {
3841             GLuint i;
3842             _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
3843             /* convert to GLchan and return */
3844             for (i = 0; i < n; i++) {
3845                dest[i] = (GLchan) (indexes[i] & 0xff);
3846             }
3847             free(indexes);
3848             free(rgba);
3849             return;
3850          }
3851          else {
3852             /* Convert indexes to RGBA */
3853             if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
3854                _mesa_shift_and_offset_ci(ctx, n, indexes);
3855             }
3856             _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
3857          }
3858
3859          /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
3860           * with color indexes.
3861           */
3862          transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT);
3863
3864          free(indexes);
3865       }
3866       else {
3867          /* non-color index data */
3868          extract_float_rgba(n, rgba, srcFormat, srcType, source,
3869                             srcPacking->SwapBytes);
3870       }
3871
3872       if (transferOps) {
3873          _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
3874       }
3875
3876       get_component_indexes(dstFormat,
3877                             &rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
3878
3879       /* Now pack results in the requested dstFormat */
3880       if (rDst >= 0) {
3881          GLfloat *dst = dest;
3882          GLuint i;
3883          for (i = 0; i < n; i++) {
3884             dst[rDst] = rgba[i][RCOMP];
3885             dst += dstComponents;
3886          }
3887       }
3888
3889       if (gDst >= 0) {
3890          GLfloat *dst = dest;
3891          GLuint i;
3892          for (i = 0; i < n; i++) {
3893             dst[gDst] = rgba[i][GCOMP];
3894             dst += dstComponents;
3895          }
3896       }
3897
3898       if (bDst >= 0) {
3899          GLfloat *dst = dest;
3900          GLuint i;
3901          for (i = 0; i < n; i++) {
3902             dst[bDst] = rgba[i][BCOMP];
3903             dst += dstComponents;
3904          }
3905       }
3906
3907       if (aDst >= 0) {
3908          GLfloat *dst = dest;
3909          GLuint i;
3910          for (i = 0; i < n; i++) {
3911             dst[aDst] = rgba[i][ACOMP];
3912             dst += dstComponents;
3913          }
3914       }
3915
3916       if (iDst >= 0) {
3917          GLfloat *dst = dest;
3918          GLuint i;
3919          assert(iDst == 0);
3920          assert(dstComponents == 1);
3921          for (i = 0; i < n; i++) {
3922             /* Intensity comes from red channel */
3923             dst[i] = rgba[i][RCOMP];
3924          }
3925       }
3926
3927       if (lDst >= 0) {
3928          GLfloat *dst = dest;
3929          GLuint i;
3930          assert(lDst == 0);
3931          for (i = 0; i < n; i++) {
3932             /* Luminance comes from red channel */
3933             dst[0] = rgba[i][RCOMP];
3934             dst += dstComponents;
3935          }
3936       }
3937
3938       free(rgba);
3939    }
3940 }
3941
3942
3943 /**
3944  * Same as _mesa_unpack_color_span_chan(), but return GLuint data
3945  * instead of GLchan.
3946  * No pixel transfer ops are applied.
3947  */
3948 void
3949 _mesa_unpack_color_span_uint(struct gl_context *ctx,
3950                              GLuint n, GLenum dstFormat, GLuint *dest,
3951                              GLenum srcFormat, GLenum srcType,
3952                              const GLvoid *source,
3953                              const struct gl_pixelstore_attrib *srcPacking)
3954 {
3955    GLuint (*rgba)[4] = (GLuint (*)[4]) malloc(n * 4 * sizeof(GLfloat));
3956
3957    if (!rgba) {
3958       _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3959       return;
3960    }
3961
3962    ASSERT(dstFormat == GL_ALPHA ||
3963           dstFormat == GL_LUMINANCE ||
3964           dstFormat == GL_LUMINANCE_ALPHA ||
3965           dstFormat == GL_INTENSITY ||
3966           dstFormat == GL_RED ||
3967           dstFormat == GL_RG ||
3968           dstFormat == GL_RGB ||
3969           dstFormat == GL_RGBA);
3970
3971    ASSERT(srcFormat == GL_RED ||
3972           srcFormat == GL_GREEN ||
3973           srcFormat == GL_BLUE ||
3974           srcFormat == GL_ALPHA ||
3975           srcFormat == GL_LUMINANCE ||
3976           srcFormat == GL_LUMINANCE_ALPHA ||
3977           srcFormat == GL_INTENSITY ||
3978           srcFormat == GL_RG ||
3979           srcFormat == GL_RGB ||
3980           srcFormat == GL_BGR ||
3981           srcFormat == GL_RGBA ||
3982           srcFormat == GL_BGRA ||
3983           srcFormat == GL_ABGR_EXT ||
3984           srcFormat == GL_RED_INTEGER_EXT ||
3985           srcFormat == GL_GREEN_INTEGER_EXT ||
3986           srcFormat == GL_BLUE_INTEGER_EXT ||
3987           srcFormat == GL_ALPHA_INTEGER_EXT ||
3988           srcFormat == GL_RGB_INTEGER_EXT ||
3989           srcFormat == GL_RGBA_INTEGER_EXT ||
3990           srcFormat == GL_BGR_INTEGER_EXT ||
3991           srcFormat == GL_BGRA_INTEGER_EXT ||
3992           srcFormat == GL_LUMINANCE_INTEGER_EXT ||
3993           srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);
3994
3995    ASSERT(srcType == GL_UNSIGNED_BYTE ||
3996           srcType == GL_BYTE ||
3997           srcType == GL_UNSIGNED_SHORT ||
3998           srcType == GL_SHORT ||
3999           srcType == GL_UNSIGNED_INT ||
4000           srcType == GL_INT ||
4001           srcType == GL_HALF_FLOAT_ARB ||
4002           srcType == GL_FLOAT ||
4003           srcType == GL_UNSIGNED_BYTE_3_3_2 ||
4004           srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
4005           srcType == GL_UNSIGNED_SHORT_5_6_5 ||
4006           srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
4007           srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
4008           srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
4009           srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
4010           srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
4011           srcType == GL_UNSIGNED_INT_8_8_8_8 ||
4012           srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
4013           srcType == GL_UNSIGNED_INT_10_10_10_2 ||
4014           srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
4015           srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
4016           srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
4017
4018
4019    /* Extract image data as uint[4] pixels */
4020    extract_uint_rgba(n, rgba, srcFormat, srcType, source,
4021                      srcPacking->SwapBytes);
4022
4023    if (dstFormat == GL_RGBA) {
4024       /* simple case */
4025       memcpy(dest, rgba, 4 * sizeof(GLuint) * n);
4026    }
4027    else {
4028       /* general case */
4029       GLint rDst, gDst, bDst, aDst, lDst, iDst;
4030       GLint dstComponents = _mesa_components_in_format( dstFormat );
4031
4032       assert(dstComponents > 0);
4033
4034       get_component_indexes(dstFormat,
4035                             &rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
4036
4037       /* Now pack values in the requested dest format */
4038       if (rDst >= 0) {
4039          GLuint *dst = dest;
4040          GLuint i;
4041          for (i = 0; i < n; i++) {
4042             dst[rDst] = rgba[i][RCOMP];
4043             dst += dstComponents;
4044          }
4045       }
4046
4047       if (gDst >= 0) {
4048          GLuint *dst = dest;
4049          GLuint i;
4050          for (i = 0; i < n; i++) {
4051             dst[gDst] = rgba[i][GCOMP];
4052             dst += dstComponents;
4053          }
4054       }
4055
4056       if (bDst >= 0) {
4057          GLuint *dst = dest;
4058          GLuint i;
4059          for (i = 0; i < n; i++) {
4060             dst[bDst] = rgba[i][BCOMP];
4061             dst += dstComponents;
4062          }
4063       }
4064
4065       if (aDst >= 0) {
4066          GLuint *dst = dest;
4067          GLuint i;
4068          for (i = 0; i < n; i++) {
4069             dst[aDst] = rgba[i][ACOMP];
4070             dst += dstComponents;
4071          }
4072       }
4073
4074       if (iDst >= 0) {
4075          GLuint *dst = dest;
4076          GLuint i;
4077          assert(iDst == 0);
4078          assert(dstComponents == 1);
4079          for (i = 0; i < n; i++) {
4080             /* Intensity comes from red channel */
4081             dst[i] = rgba[i][RCOMP];
4082          }
4083       }
4084
4085       if (lDst >= 0) {
4086          GLuint *dst = dest;
4087          GLuint i;
4088          assert(lDst == 0);
4089          for (i = 0; i < n; i++) {
4090             /* Luminance comes from red channel */
4091             dst[0] = rgba[i][RCOMP];
4092             dst += dstComponents;
4093          }
4094       }
4095    }
4096
4097    free(rgba);
4098 }
4099
4100
4101
4102 /**
4103  * Similar to _mesa_unpack_color_span_float(), but for dudv data instead of rgba,
4104  * directly return GLbyte data, no transfer ops apply.
4105  */
4106 void
4107 _mesa_unpack_dudv_span_byte( struct gl_context *ctx,
4108                              GLuint n, GLenum dstFormat, GLbyte dest[],
4109                              GLenum srcFormat, GLenum srcType,
4110                              const GLvoid *source,
4111                              const struct gl_pixelstore_attrib *srcPacking,
4112                              GLbitfield transferOps )
4113 {
4114    ASSERT(dstFormat == GL_DUDV_ATI);
4115    ASSERT(srcFormat == GL_DUDV_ATI ||
4116           srcFormat == GL_DU8DV8_ATI);
4117
4118    ASSERT(srcType == GL_UNSIGNED_BYTE ||
4119           srcType == GL_BYTE ||
4120           srcType == GL_UNSIGNED_SHORT ||
4121           srcType == GL_SHORT ||
4122           srcType == GL_UNSIGNED_INT ||
4123           srcType == GL_INT ||
4124           srcType == GL_HALF_FLOAT_ARB ||
4125           srcType == GL_FLOAT);
4126
4127    /* general solution */
4128    {
4129       GLint dstComponents;
4130       GLbyte *dst = dest;
4131       GLuint i;
4132       GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));
4133
4134       if (!rgba) {
4135          _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
4136          return;
4137       }
4138
4139       dstComponents = _mesa_components_in_format( dstFormat );
4140       /* source & dest image formats should have been error checked by now */
4141       assert(dstComponents > 0);
4142
4143       /*
4144        * Extract image data and convert to RGBA floats
4145        */
4146       extract_float_rgba(n, rgba, srcFormat, srcType, source,
4147                          srcPacking->SwapBytes);
4148
4149
4150       /* Now determine which color channels we need to produce.
4151        * And determine the dest index (offset) within each color tuple.
4152        */
4153
4154       /* Now pack results in the requested dstFormat */
4155       for (i = 0; i < n; i++) {
4156          /* not sure - need clamp[-1,1] here? */
4157          dst[0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
4158          dst[1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
4159          dst += dstComponents;
4160       }
4161
4162       free(rgba);
4163    }
4164 }
4165
4166 /*
4167  * Unpack a row of color index data from a client buffer according to
4168  * the pixel unpacking parameters.
4169  * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.
4170  *
4171  * Args:  ctx - the context
4172  *        n - number of pixels
4173  *        dstType - destination data type
4174  *        dest - destination array
4175  *        srcType - source pixel type
4176  *        source - source data pointer
4177  *        srcPacking - pixel unpacking parameters
4178  *        transferOps - the pixel transfer operations to apply
4179  */
4180 void
4181 _mesa_unpack_index_span( struct gl_context *ctx, GLuint n,
4182                          GLenum dstType, GLvoid *dest,
4183                          GLenum srcType, const GLvoid *source,
4184                          const struct gl_pixelstore_attrib *srcPacking,
4185                          GLbitfield transferOps )
4186 {
4187    ASSERT(srcType == GL_BITMAP ||
4188           srcType == GL_UNSIGNED_BYTE ||
4189           srcType == GL_BYTE ||
4190           srcType == GL_UNSIGNED_SHORT ||
4191           srcType == GL_SHORT ||
4192           srcType == GL_UNSIGNED_INT ||
4193           srcType == GL_INT ||
4194           srcType == GL_HALF_FLOAT_ARB ||
4195           srcType == GL_FLOAT);
4196
4197    ASSERT(dstType == GL_UNSIGNED_BYTE ||
4198           dstType == GL_UNSIGNED_SHORT ||
4199           dstType == GL_UNSIGNED_INT);
4200
4201
4202    transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
4203
4204    /*
4205     * Try simple cases first
4206     */
4207    if (transferOps == 0 && srcType == GL_UNSIGNED_BYTE
4208        && dstType == GL_UNSIGNED_BYTE) {
4209       memcpy(dest, source, n * sizeof(GLubyte));
4210    }
4211    else if (transferOps == 0 && srcType == GL_UNSIGNED_INT
4212             && dstType == GL_UNSIGNED_INT && !srcPacking->SwapBytes) {
4213       memcpy(dest, source, n * sizeof(GLuint));
4214    }
4215    else {
4216       /*
4217        * general solution
4218        */
4219       GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
4220
4221       if (!indexes) {
4222          _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
4223          return;
4224       }
4225
4226       extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
4227                            srcPacking);
4228
4229       if (transferOps)
4230          _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
4231
4232       /* convert to dest type */
4233       switch (dstType) {
4234          case GL_UNSIGNED_BYTE:
4235             {
4236                GLubyte *dst = (GLubyte *) dest;
4237                GLuint i;
4238                for (i = 0; i < n; i++) {
4239                   dst[i] = (GLubyte) (indexes[i] & 0xff);
4240                }
4241             }
4242             break;
4243          case GL_UNSIGNED_SHORT:
4244             {
4245                GLuint *dst = (GLuint *) dest;
4246                GLuint i;
4247                for (i = 0; i < n; i++) {
4248                   dst[i] = (GLushort) (indexes[i] & 0xffff);
4249                }
4250             }
4251             break;
4252          case GL_UNSIGNED_INT:
4253             memcpy(dest, indexes, n * sizeof(GLuint));
4254             break;
4255          default:
4256             _mesa_problem(ctx, "bad dstType in _mesa_unpack_index_span");
4257       }
4258
4259       free(indexes);
4260    }
4261 }
4262
4263
4264 void
4265 _mesa_pack_index_span( struct gl_context *ctx, GLuint n,
4266                        GLenum dstType, GLvoid *dest, const GLuint *source,
4267                        const struct gl_pixelstore_attrib *dstPacking,
4268                        GLbitfield transferOps )
4269 {
4270    GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
4271
4272    if (!indexes) {
4273       _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
4274       return;
4275    }
4276
4277    transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
4278
4279    if (transferOps & (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT)) {
4280       /* make a copy of input */
4281       memcpy(indexes, source, n * sizeof(GLuint));
4282       _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
4283       source = indexes;
4284    }
4285
4286    switch (dstType) {
4287    case GL_UNSIGNED_BYTE:
4288       {
4289          GLubyte *dst = (GLubyte *) dest;
4290          GLuint i;
4291          for (i = 0; i < n; i++) {
4292             *dst++ = (GLubyte) source[i];
4293          }
4294       }
4295       break;
4296    case GL_BYTE:
4297       {
4298          GLbyte *dst = (GLbyte *) dest;
4299          GLuint i;
4300          for (i = 0; i < n; i++) {
4301             dst[i] = (GLbyte) source[i];
4302          }
4303       }
4304       break;
4305    case GL_UNSIGNED_SHORT:
4306       {
4307          GLushort *dst = (GLushort *) dest;
4308          GLuint i;
4309          for (i = 0; i < n; i++) {
4310             dst[i] = (GLushort) source[i];
4311          }
4312          if (dstPacking->SwapBytes) {
4313             _mesa_swap2( (GLushort *) dst, n );
4314          }
4315       }
4316       break;
4317    case GL_SHORT:
4318       {
4319          GLshort *dst = (GLshort *) dest;
4320          GLuint i;
4321          for (i = 0; i < n; i++) {
4322             dst[i] = (GLshort) source[i];
4323          }
4324          if (dstPacking->SwapBytes) {
4325             _mesa_swap2( (GLushort *) dst, n );
4326          }
4327       }
4328       break;
4329    case GL_UNSIGNED_INT:
4330       {
4331          GLuint *dst = (GLuint *) dest;
4332          GLuint i;
4333          for (i = 0; i < n; i++) {
4334             dst[i] = (GLuint) source[i];
4335          }
4336          if (dstPacking->SwapBytes) {
4337             _mesa_swap4( (GLuint *) dst, n );
4338          }
4339       }
4340       break;
4341    case GL_INT:
4342       {
4343          GLint *dst = (GLint *) dest;
4344          GLuint i;
4345          for (i = 0; i < n; i++) {
4346             dst[i] = (GLint) source[i];
4347          }
4348          if (dstPacking->SwapBytes) {
4349             _mesa_swap4( (GLuint *) dst, n );
4350          }
4351       }
4352       break;
4353    case GL_FLOAT:
4354       {
4355          GLfloat *dst = (GLfloat *) dest;
4356          GLuint i;
4357          for (i = 0; i < n; i++) {
4358             dst[i] = (GLfloat) source[i];
4359          }
4360          if (dstPacking->SwapBytes) {
4361             _mesa_swap4( (GLuint *) dst, n );
4362          }
4363       }
4364       break;
4365    case GL_HALF_FLOAT_ARB:
4366       {
4367          GLhalfARB *dst = (GLhalfARB *) dest;
4368          GLuint i;
4369          for (i = 0; i < n; i++) {
4370             dst[i] = _mesa_float_to_half((GLfloat) source[i]);
4371          }
4372          if (dstPacking->SwapBytes) {
4373             _mesa_swap2( (GLushort *) dst, n );
4374          }
4375       }
4376       break;
4377    default:
4378       _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
4379    }
4380
4381    free(indexes);
4382 }
4383
4384
4385 /*
4386  * Unpack a row of stencil data from a client buffer according to
4387  * the pixel unpacking parameters.
4388  * This is (or will be) used by glDrawPixels
4389  *
4390  * Args:  ctx - the context
4391  *        n - number of pixels
4392  *        dstType - destination data type
4393  *        dest - destination array
4394  *        srcType - source pixel type
4395  *        source - source data pointer
4396  *        srcPacking - pixel unpacking parameters
4397  *        transferOps - apply offset/bias/lookup ops?
4398  */
4399 void
4400 _mesa_unpack_stencil_span( struct gl_context *ctx, GLuint n,
4401                            GLenum dstType, GLvoid *dest,
4402                            GLenum srcType, const GLvoid *source,
4403                            const struct gl_pixelstore_attrib *srcPacking,
4404                            GLbitfield transferOps )
4405 {
4406    ASSERT(srcType == GL_BITMAP ||
4407           srcType == GL_UNSIGNED_BYTE ||
4408           srcType == GL_BYTE ||
4409           srcType == GL_UNSIGNED_SHORT ||
4410           srcType == GL_SHORT ||
4411           srcType == GL_UNSIGNED_INT ||
4412           srcType == GL_INT ||
4413           srcType == GL_UNSIGNED_INT_24_8_EXT ||
4414           srcType == GL_HALF_FLOAT_ARB ||
4415           srcType == GL_FLOAT);
4416
4417    ASSERT(dstType == GL_UNSIGNED_BYTE ||
4418           dstType == GL_UNSIGNED_SHORT ||
4419           dstType == GL_UNSIGNED_INT);
4420
4421    /* only shift and offset apply to stencil */
4422    transferOps &= IMAGE_SHIFT_OFFSET_BIT;
4423
4424    /*
4425     * Try simple cases first
4426     */
4427    if (transferOps == 0 &&
4428        !ctx->Pixel.MapStencilFlag &&
4429        srcType == GL_UNSIGNED_BYTE &&
4430        dstType == GL_UNSIGNED_BYTE) {
4431       memcpy(dest, source, n * sizeof(GLubyte));
4432    }
4433    else if (transferOps == 0 &&
4434             !ctx->Pixel.MapStencilFlag &&
4435             srcType == GL_UNSIGNED_INT &&
4436             dstType == GL_UNSIGNED_INT &&
4437             !srcPacking->SwapBytes) {
4438       memcpy(dest, source, n * sizeof(GLuint));
4439    }
4440    else {
4441       /*
4442        * general solution
4443        */
4444       GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
4445
4446       if (!indexes) {
4447          _mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil unpacking");
4448          return;
4449       }
4450
4451       extract_uint_indexes(n, indexes, GL_STENCIL_INDEX, srcType, source,
4452                            srcPacking);
4453
4454       if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
4455          /* shift and offset indexes */
4456          _mesa_shift_and_offset_ci(ctx, n, indexes);
4457       }
4458
4459       if (ctx->Pixel.MapStencilFlag) {
4460          /* Apply stencil lookup table */
4461          const GLuint mask = ctx->PixelMaps.StoS.Size - 1;
4462          GLuint i;
4463          for (i = 0; i < n; i++) {
4464             indexes[i] = (GLuint)ctx->PixelMaps.StoS.Map[ indexes[i] & mask ];
4465          }
4466       }
4467
4468       /* convert to dest type */
4469       switch (dstType) {
4470          case GL_UNSIGNED_BYTE:
4471             {
4472                GLubyte *dst = (GLubyte *) dest;
4473                GLuint i;
4474                for (i = 0; i < n; i++) {
4475                   dst[i] = (GLubyte) (indexes[i] & 0xff);
4476                }
4477             }
4478             break;
4479          case GL_UNSIGNED_SHORT:
4480             {
4481                GLuint *dst = (GLuint *) dest;
4482                GLuint i;
4483                for (i = 0; i < n; i++) {
4484                   dst[i] = (GLushort) (indexes[i] & 0xffff);
4485                }
4486             }
4487             break;
4488          case GL_UNSIGNED_INT:
4489             memcpy(dest, indexes, n * sizeof(GLuint));
4490             break;
4491          default:
4492             _mesa_problem(ctx, "bad dstType in _mesa_unpack_stencil_span");
4493       }
4494
4495       free(indexes);
4496    }
4497 }
4498
4499
4500 void
4501 _mesa_pack_stencil_span( struct gl_context *ctx, GLuint n,
4502                          GLenum dstType, GLvoid *dest, const GLstencil *source,
4503                          const struct gl_pixelstore_attrib *dstPacking )
4504 {
4505    GLstencil *stencil = (GLstencil *) malloc(n * sizeof(GLstencil));
4506
4507    if (!stencil) {
4508       _mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil packing");
4509       return;
4510    }
4511
4512    if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset ||
4513        ctx->Pixel.MapStencilFlag) {
4514       /* make a copy of input */
4515       memcpy(stencil, source, n * sizeof(GLstencil));
4516       _mesa_apply_stencil_transfer_ops(ctx, n, stencil);
4517       source = stencil;
4518    }
4519
4520    switch (dstType) {
4521    case GL_UNSIGNED_BYTE:
4522       if (sizeof(GLstencil) == 1) {
4523          memcpy( dest, source, n );
4524       }
4525       else {
4526          GLubyte *dst = (GLubyte *) dest;
4527          GLuint i;
4528          for (i=0;i<n;i++) {
4529             dst[i] = (GLubyte) source[i];
4530          }
4531       }
4532       break;
4533    case GL_BYTE:
4534       {
4535          GLbyte *dst = (GLbyte *) dest;
4536          GLuint i;
4537          for (i=0;i<n;i++) {
4538             dst[i] = (GLbyte) (source[i] & 0x7f);
4539          }
4540       }
4541       break;
4542    case GL_UNSIGNED_SHORT:
4543       {
4544          GLushort *dst = (GLushort *) dest;
4545          GLuint i;
4546          for (i=0;i<n;i++) {
4547             dst[i] = (GLushort) source[i];
4548          }
4549          if (dstPacking->SwapBytes) {
4550             _mesa_swap2( (GLushort *) dst, n );
4551          }
4552       }
4553       break;
4554    case GL_SHORT:
4555       {
4556          GLshort *dst = (GLshort *) dest;
4557          GLuint i;
4558          for (i=0;i<n;i++) {
4559             dst[i] = (GLshort) source[i];
4560          }
4561          if (dstPacking->SwapBytes) {
4562             _mesa_swap2( (GLushort *) dst, n );
4563          }
4564       }
4565       break;
4566    case GL_UNSIGNED_INT:
4567       {
4568          GLuint *dst = (GLuint *) dest;
4569          GLuint i;
4570          for (i=0;i<n;i++) {
4571             dst[i] = (GLuint) source[i];
4572          }
4573          if (dstPacking->SwapBytes) {
4574             _mesa_swap4( (GLuint *) dst, n );
4575          }
4576       }
4577       break;
4578    case GL_INT:
4579       {
4580          GLint *dst = (GLint *) dest;
4581          GLuint i;
4582          for (i=0;i<n;i++) {
4583             dst[i] = (GLint) source[i];
4584          }
4585          if (dstPacking->SwapBytes) {
4586             _mesa_swap4( (GLuint *) dst, n );
4587          }
4588       }
4589       break;
4590    case GL_FLOAT:
4591       {
4592          GLfloat *dst = (GLfloat *) dest;
4593          GLuint i;
4594          for (i=0;i<n;i++) {
4595             dst[i] = (GLfloat) source[i];
4596          }
4597          if (dstPacking->SwapBytes) {
4598             _mesa_swap4( (GLuint *) dst, n );
4599          }
4600       }
4601       break;
4602    case GL_HALF_FLOAT_ARB:
4603       {
4604          GLhalfARB *dst = (GLhalfARB *) dest;
4605          GLuint i;
4606          for (i=0;i<n;i++) {
4607             dst[i] = _mesa_float_to_half( (float) source[i] );
4608          }
4609          if (dstPacking->SwapBytes) {
4610             _mesa_swap2( (GLushort *) dst, n );
4611          }
4612       }
4613       break;
4614    case GL_BITMAP:
4615       if (dstPacking->LsbFirst) {
4616          GLubyte *dst = (GLubyte *) dest;
4617          GLint shift = 0;
4618          GLuint i;
4619          for (i = 0; i < n; i++) {
4620             if (shift == 0)
4621                *dst = 0;
4622             *dst |= ((source[i] != 0) << shift);
4623             shift++;
4624             if (shift == 8) {
4625                shift = 0;
4626                dst++;
4627             }
4628          }
4629       }
4630       else {
4631          GLubyte *dst = (GLubyte *) dest;
4632          GLint shift = 7;
4633          GLuint i;
4634          for (i = 0; i < n; i++) {
4635             if (shift == 7)
4636                *dst = 0;
4637             *dst |= ((source[i] != 0) << shift);
4638             shift--;
4639             if (shift < 0) {
4640                shift = 7;
4641                dst++;
4642             }
4643          }
4644       }
4645       break;
4646    default:
4647       _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
4648    }
4649
4650    free(stencil);
4651 }
4652
4653 #define DEPTH_VALUES(GLTYPE, GLTYPE2FLOAT)                              \
4654     do {                                                                \
4655         GLuint i;                                                       \
4656         const GLTYPE *src = (const GLTYPE *)source;                     \
4657         for (i = 0; i < n; i++) {                                       \
4658             GLTYPE value = src[i];                                      \
4659             if (srcPacking->SwapBytes) {                                \
4660                 if (sizeof(GLTYPE) == 2) {                              \
4661                     SWAP2BYTE(value);                                   \
4662                 } else if (sizeof(GLTYPE) == 4) {                       \
4663                     SWAP4BYTE(value);                                   \
4664                 }                                                       \
4665             }                                                           \
4666             depthValues[i] = GLTYPE2FLOAT(value);                       \
4667         }                                                               \
4668     } while (0)
4669
4670
4671 /**
4672  * Unpack a row of depth/z values from memory, returning GLushort, GLuint
4673  * or GLfloat values.
4674  * The glPixelTransfer (scale/bias) params will be applied.
4675  *
4676  * \param dstType  one of GL_UNSIGNED_SHORT, GL_UNSIGNED_INT, GL_FLOAT
4677  * \param depthMax  max value for returned GLushort or GLuint values
4678  *                  (ignored for GLfloat).
4679  */
4680 void
4681 _mesa_unpack_depth_span( struct gl_context *ctx, GLuint n,
4682                          GLenum dstType, GLvoid *dest, GLuint depthMax,
4683                          GLenum srcType, const GLvoid *source,
4684                          const struct gl_pixelstore_attrib *srcPacking )
4685 {
4686    GLfloat *depthTemp = NULL, *depthValues;
4687    GLboolean needClamp = GL_FALSE;
4688
4689    /* Look for special cases first.
4690     * Not only are these faster, they're less prone to numeric conversion
4691     * problems.  Otherwise, converting from an int type to a float then
4692     * back to an int type can introduce errors that will show up as
4693     * artifacts in things like depth peeling which uses glCopyTexImage.
4694     */
4695    if (ctx->Pixel.DepthScale == 1.0 && ctx->Pixel.DepthBias == 0.0) {
4696       if (srcType == GL_UNSIGNED_INT && dstType == GL_UNSIGNED_SHORT) {
4697          const GLuint *src = (const GLuint *) source;
4698          GLushort *dst = (GLushort *) dest;
4699          GLuint i;
4700          for (i = 0; i < n; i++) {
4701             dst[i] = src[i] >> 16;
4702          }
4703          return;
4704       }
4705       if (srcType == GL_UNSIGNED_SHORT
4706           && dstType == GL_UNSIGNED_INT
4707           && depthMax == 0xffffffff) {
4708          const GLushort *src = (const GLushort *) source;
4709          GLuint *dst = (GLuint *) dest;
4710          GLuint i;
4711          for (i = 0; i < n; i++) {
4712             dst[i] = src[i] | (src[i] << 16);
4713          }
4714          return;
4715       }
4716       if (srcType == GL_UNSIGNED_INT_24_8
4717           && dstType == GL_UNSIGNED_INT
4718           && depthMax == 0xffffff) {
4719          const GLuint *src = (const GLuint *) source;
4720          GLuint *dst = (GLuint *) dest;
4721          GLuint i;
4722          for (i = 0; i < n; i++) {
4723             dst[i] = src[i] >> 8;
4724          }
4725          return;
4726       }
4727       /* XXX may want to add additional cases here someday */
4728    }
4729
4730    /* general case path follows */
4731
4732    if (dstType == GL_FLOAT) {
4733       depthValues = (GLfloat *) dest;
4734    }
4735    else {
4736       depthTemp = (GLfloat *) malloc(n * sizeof(GLfloat));
4737       if (!depthTemp) {
4738          _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
4739          return;
4740       }
4741
4742       depthValues = depthTemp;
4743    }
4744
4745    /* Convert incoming values to GLfloat.  Some conversions will require
4746     * clamping, below.
4747     */
4748    switch (srcType) {
4749       case GL_BYTE:
4750          DEPTH_VALUES(GLbyte, BYTE_TO_FLOAT);
4751          needClamp = GL_TRUE;
4752          break;
4753       case GL_UNSIGNED_BYTE:
4754          DEPTH_VALUES(GLubyte, UBYTE_TO_FLOAT);
4755          break;
4756       case GL_SHORT:
4757          DEPTH_VALUES(GLshort, SHORT_TO_FLOAT);
4758          needClamp = GL_TRUE;
4759          break;
4760       case GL_UNSIGNED_SHORT:
4761          DEPTH_VALUES(GLushort, USHORT_TO_FLOAT);
4762          break;
4763       case GL_INT:
4764          DEPTH_VALUES(GLint, INT_TO_FLOAT);
4765          needClamp = GL_TRUE;
4766          break;
4767       case GL_UNSIGNED_INT:
4768          DEPTH_VALUES(GLuint, UINT_TO_FLOAT);
4769          break;
4770       case GL_UNSIGNED_INT_24_8_EXT: /* GL_EXT_packed_depth_stencil */
4771          if (dstType == GL_UNSIGNED_INT_24_8_EXT &&
4772              depthMax == 0xffffff &&
4773              ctx->Pixel.DepthScale == 1.0 &&
4774              ctx->Pixel.DepthBias == 0.0) {
4775             const GLuint *src = (const GLuint *) source;
4776             GLuint *zValues = (GLuint *) dest;
4777             GLuint i;
4778             for (i = 0; i < n; i++) {
4779                 GLuint value = src[i];
4780                 if (srcPacking->SwapBytes) {
4781                     SWAP4BYTE(value);
4782                 }
4783                 zValues[i] = value & 0xffffff00;
4784             }
4785             free(depthTemp);
4786             return;
4787          }
4788          else {
4789             const GLuint *src = (const GLuint *) source;
4790             const GLfloat scale = 1.0f / 0xffffff;
4791             GLuint i;
4792             for (i = 0; i < n; i++) {
4793                 GLuint value = src[i];
4794                 if (srcPacking->SwapBytes) {
4795                     SWAP4BYTE(value);
4796                 }
4797                 depthValues[i] = (value >> 8) * scale;
4798             }
4799          }
4800          break;
4801       case GL_FLOAT:
4802          DEPTH_VALUES(GLfloat, 1*);
4803          needClamp = GL_TRUE;
4804          break;
4805       case GL_HALF_FLOAT_ARB:
4806          {
4807             GLuint i;
4808             const GLhalfARB *src = (const GLhalfARB *) source;
4809             for (i = 0; i < n; i++) {
4810                GLhalfARB value = src[i];
4811                if (srcPacking->SwapBytes) {
4812                   SWAP2BYTE(value);
4813                }
4814                depthValues[i] = _mesa_half_to_float(value);
4815             }
4816             needClamp = GL_TRUE;
4817          }
4818          break;
4819       default:
4820          _mesa_problem(NULL, "bad type in _mesa_unpack_depth_span()");
4821          free(depthTemp);
4822          return;
4823    }
4824
4825    /* apply depth scale and bias */
4826    {
4827       const GLfloat scale = ctx->Pixel.DepthScale;
4828       const GLfloat bias = ctx->Pixel.DepthBias;
4829       if (scale != 1.0 || bias != 0.0) {
4830          GLuint i;
4831          for (i = 0; i < n; i++) {
4832             depthValues[i] = depthValues[i] * scale + bias;
4833          }
4834          needClamp = GL_TRUE;
4835       }
4836    }
4837
4838    /* clamp to [0, 1] */
4839    if (needClamp) {
4840       GLuint i;
4841       for (i = 0; i < n; i++) {
4842          depthValues[i] = (GLfloat)CLAMP(depthValues[i], 0.0, 1.0);
4843       }
4844    }
4845
4846    /*
4847     * Convert values to dstType
4848     */
4849    if (dstType == GL_UNSIGNED_INT) {
4850       GLuint *zValues = (GLuint *) dest;
4851       GLuint i;
4852       if (depthMax <= 0xffffff) {
4853          /* no overflow worries */
4854          for (i = 0; i < n; i++) {
4855             zValues[i] = (GLuint) (depthValues[i] * (GLfloat) depthMax);
4856          }
4857       }
4858       else {
4859          /* need to use double precision to prevent overflow problems */
4860          for (i = 0; i < n; i++) {
4861             GLdouble z = depthValues[i] * (GLfloat) depthMax;
4862             if (z >= (GLdouble) 0xffffffff)
4863                zValues[i] = 0xffffffff;
4864             else
4865                zValues[i] = (GLuint) z;
4866          }
4867       }
4868    }
4869    else if (dstType == GL_UNSIGNED_SHORT) {
4870       GLushort *zValues = (GLushort *) dest;
4871       GLuint i;
4872       ASSERT(depthMax <= 0xffff);
4873       for (i = 0; i < n; i++) {
4874          zValues[i] = (GLushort) (depthValues[i] * (GLfloat) depthMax);
4875       }
4876    }
4877    else {
4878       ASSERT(dstType == GL_FLOAT);
4879       /*ASSERT(depthMax == 1.0F);*/
4880    }
4881
4882    free(depthTemp);
4883 }
4884
4885
4886 /*
4887  * Pack an array of depth values.  The values are floats in [0,1].
4888  */
4889 void
4890 _mesa_pack_depth_span( struct gl_context *ctx, GLuint n, GLvoid *dest,
4891                        GLenum dstType, const GLfloat *depthSpan,
4892                        const struct gl_pixelstore_attrib *dstPacking )
4893 {
4894    GLfloat *depthCopy = (GLfloat *) malloc(n * sizeof(GLfloat));
4895    if (!depthCopy) {
4896       _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
4897       return;
4898    }
4899
4900    if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
4901       memcpy(depthCopy, depthSpan, n * sizeof(GLfloat));
4902       _mesa_scale_and_bias_depth(ctx, n, depthCopy);
4903       depthSpan = depthCopy;
4904    }
4905
4906    switch (dstType) {
4907    case GL_UNSIGNED_BYTE:
4908       {
4909          GLubyte *dst = (GLubyte *) dest;
4910          GLuint i;
4911          for (i = 0; i < n; i++) {
4912             dst[i] = FLOAT_TO_UBYTE( depthSpan[i] );
4913          }
4914       }
4915       break;
4916    case GL_BYTE:
4917       {
4918          GLbyte *dst = (GLbyte *) dest;
4919          GLuint i;
4920          for (i = 0; i < n; i++) {
4921             dst[i] = FLOAT_TO_BYTE( depthSpan[i] );
4922          }
4923       }
4924       break;
4925    case GL_UNSIGNED_SHORT:
4926       {
4927          GLushort *dst = (GLushort *) dest;
4928          GLuint i;
4929          for (i = 0; i < n; i++) {
4930             CLAMPED_FLOAT_TO_USHORT(dst[i], depthSpan[i]);
4931          }
4932          if (dstPacking->SwapBytes) {
4933             _mesa_swap2( (GLushort *) dst, n );
4934          }
4935       }
4936       break;
4937    case GL_SHORT:
4938       {
4939          GLshort *dst = (GLshort *) dest;
4940          GLuint i;
4941          for (i = 0; i < n; i++) {
4942             dst[i] = FLOAT_TO_SHORT( depthSpan[i] );
4943          }
4944          if (dstPacking->SwapBytes) {
4945             _mesa_swap2( (GLushort *) dst, n );
4946          }
4947       }
4948       break;
4949    case GL_UNSIGNED_INT:
4950       {
4951          GLuint *dst = (GLuint *) dest;
4952          GLuint i;
4953          for (i = 0; i < n; i++) {
4954             dst[i] = FLOAT_TO_UINT( depthSpan[i] );
4955          }
4956          if (dstPacking->SwapBytes) {
4957             _mesa_swap4( (GLuint *) dst, n );
4958          }
4959       }
4960       break;
4961    case GL_INT:
4962       {
4963          GLint *dst = (GLint *) dest;
4964          GLuint i;
4965          for (i = 0; i < n; i++) {
4966             dst[i] = FLOAT_TO_INT( depthSpan[i] );
4967          }
4968          if (dstPacking->SwapBytes) {
4969             _mesa_swap4( (GLuint *) dst, n );
4970          }
4971       }
4972       break;
4973    case GL_FLOAT:
4974       {
4975          GLfloat *dst = (GLfloat *) dest;
4976          GLuint i;
4977          for (i = 0; i < n; i++) {
4978             dst[i] = depthSpan[i];
4979          }
4980          if (dstPacking->SwapBytes) {
4981             _mesa_swap4( (GLuint *) dst, n );
4982          }
4983       }
4984       break;
4985    case GL_HALF_FLOAT_ARB:
4986       {
4987          GLhalfARB *dst = (GLhalfARB *) dest;
4988          GLuint i;
4989          for (i = 0; i < n; i++) {
4990             dst[i] = _mesa_float_to_half(depthSpan[i]);
4991          }
4992          if (dstPacking->SwapBytes) {
4993             _mesa_swap2( (GLushort *) dst, n );
4994          }
4995       }
4996       break;
4997    default:
4998       _mesa_problem(ctx, "bad type in _mesa_pack_depth_span");
4999    }
5000
5001    free(depthCopy);
5002 }
5003
5004
5005
5006 /**
5007  * Pack depth and stencil values as GL_DEPTH_STENCIL/GL_UNSIGNED_INT_24_8.
5008  */
5009 void
5010 _mesa_pack_depth_stencil_span(struct gl_context *ctx, GLuint n, GLuint *dest,
5011                               const GLfloat *depthVals,
5012                               const GLstencil *stencilVals,
5013                               const struct gl_pixelstore_attrib *dstPacking)
5014 {
5015    GLfloat *depthCopy = (GLfloat *) malloc(n * sizeof(GLfloat));
5016    GLstencil *stencilCopy = (GLstencil *) malloc(n * sizeof(GLstencil));
5017    GLuint i;
5018
5019    if (!depthCopy || !stencilCopy) {
5020       _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
5021       free(depthCopy);
5022       free(stencilCopy);
5023       return;
5024    }
5025
5026    if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
5027       memcpy(depthCopy, depthVals, n * sizeof(GLfloat));
5028       _mesa_scale_and_bias_depth(ctx, n, depthCopy);
5029       depthVals = depthCopy;
5030    }
5031
5032    if (ctx->Pixel.IndexShift ||
5033        ctx->Pixel.IndexOffset ||
5034        ctx->Pixel.MapStencilFlag) {
5035       memcpy(stencilCopy, stencilVals, n * sizeof(GLstencil));
5036       _mesa_apply_stencil_transfer_ops(ctx, n, stencilCopy);
5037       stencilVals = stencilCopy;
5038    }
5039
5040    for (i = 0; i < n; i++) {
5041       GLuint z = (GLuint) (depthVals[i] * 0xffffff);
5042       dest[i] = (z << 8) | (stencilVals[i] & 0xff);
5043    }
5044
5045    if (dstPacking->SwapBytes) {
5046       _mesa_swap4(dest, n);
5047    }
5048
5049    free(depthCopy);
5050    free(stencilCopy);
5051 }
5052
5053
5054
5055
5056 /**
5057  * Unpack image data.  Apply byte swapping, byte flipping (bitmap).
5058  * Return all image data in a contiguous block.  This is used when we
5059  * compile glDrawPixels, glTexImage, etc into a display list.  We
5060  * need a copy of the data in a standard format.
5061  */
5062 void *
5063 _mesa_unpack_image( GLuint dimensions,
5064                     GLsizei width, GLsizei height, GLsizei depth,
5065                     GLenum format, GLenum type, const GLvoid *pixels,
5066                     const struct gl_pixelstore_attrib *unpack )
5067 {
5068    GLint bytesPerRow, compsPerRow;
5069    GLboolean flipBytes, swap2, swap4;
5070
5071    if (!pixels)
5072       return NULL;  /* not necessarily an error */
5073
5074    if (width <= 0 || height <= 0 || depth <= 0)
5075       return NULL;  /* generate error later */
5076
5077    if (type == GL_BITMAP) {
5078       bytesPerRow = (width + 7) >> 3;
5079       flipBytes = unpack->LsbFirst;
5080       swap2 = swap4 = GL_FALSE;
5081       compsPerRow = 0;
5082    }
5083    else {
5084       const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
5085       GLint components = _mesa_components_in_format(format);
5086       GLint bytesPerComp;
5087
5088       if (_mesa_type_is_packed(type))
5089           components = 1;
5090
5091       if (bytesPerPixel <= 0 || components <= 0)
5092          return NULL;   /* bad format or type.  generate error later */
5093       bytesPerRow = bytesPerPixel * width;
5094       bytesPerComp = bytesPerPixel / components;
5095       flipBytes = GL_FALSE;
5096       swap2 = (bytesPerComp == 2) && unpack->SwapBytes;
5097       swap4 = (bytesPerComp == 4) && unpack->SwapBytes;
5098       compsPerRow = components * width;
5099       assert(compsPerRow >= width);
5100    }
5101
5102    {
5103       GLubyte *destBuffer
5104          = (GLubyte *) malloc(bytesPerRow * height * depth);
5105       GLubyte *dst;
5106       GLint img, row;
5107       if (!destBuffer)
5108          return NULL;   /* generate GL_OUT_OF_MEMORY later */
5109
5110       dst = destBuffer;
5111       for (img = 0; img < depth; img++) {
5112          for (row = 0; row < height; row++) {
5113             const GLvoid *src = _mesa_image_address(dimensions, unpack, pixels,
5114                                width, height, format, type, img, row, 0);
5115
5116             if ((type == GL_BITMAP) && (unpack->SkipPixels & 0x7)) {
5117                GLint i;
5118                flipBytes = GL_FALSE;
5119                if (unpack->LsbFirst) {
5120                   GLubyte srcMask = 1 << (unpack->SkipPixels & 0x7);
5121                   GLubyte dstMask = 128;
5122                   const GLubyte *s = src;
5123                   GLubyte *d = dst;
5124                   *d = 0;
5125                   for (i = 0; i < width; i++) {
5126                      if (*s & srcMask) {
5127                         *d |= dstMask;
5128                      }
5129                      if (srcMask == 128) {
5130                         srcMask = 1;
5131                         s++;
5132                      }
5133                      else {
5134                         srcMask = srcMask << 1;
5135                      }
5136                      if (dstMask == 1) {
5137                         dstMask = 128;
5138                         d++;
5139                         *d = 0;
5140                      }
5141                      else {
5142                         dstMask = dstMask >> 1;
5143                      }
5144                   }
5145                }
5146                else {
5147                   GLubyte srcMask = 128 >> (unpack->SkipPixels & 0x7);
5148                   GLubyte dstMask = 128;
5149                   const GLubyte *s = src;
5150                   GLubyte *d = dst;
5151                   *d = 0;
5152                   for (i = 0; i < width; i++) {
5153                      if (*s & srcMask) {
5154                         *d |= dstMask;
5155                      }
5156                      if (srcMask == 1) {
5157                         srcMask = 128;
5158                         s++;
5159                      }
5160                      else {
5161                         srcMask = srcMask >> 1;
5162                      }
5163                      if (dstMask == 1) {
5164                         dstMask = 128;
5165                         d++;
5166                         *d = 0;
5167                      }
5168                      else {
5169                         dstMask = dstMask >> 1;
5170                      }
5171                   }
5172                }
5173             }
5174             else {
5175                memcpy(dst, src, bytesPerRow);
5176             }
5177
5178             /* byte flipping/swapping */
5179             if (flipBytes) {
5180                flip_bytes((GLubyte *) dst, bytesPerRow);
5181             }
5182             else if (swap2) {
5183                _mesa_swap2((GLushort*) dst, compsPerRow);
5184             }
5185             else if (swap4) {
5186                _mesa_swap4((GLuint*) dst, compsPerRow);
5187             }
5188             dst += bytesPerRow;
5189          }
5190       }
5191       return destBuffer;
5192    }
5193 }
5194