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