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) (x)
 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) (x)
 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) (x)
 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) (x)
 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*3+0] = (GLshort) rgba[i][RCOMP];
1179                      dst[i*3+1] = (GLshort) rgba[i][GCOMP];
1180                      dst[i*3+2] = (GLshort) rgba[i][BCOMP];
1181                   }
1182                   break;
1183                case GL_RGB_INTEGER_EXT:
1184                   for (i=0;i<n;i++) {
1185                      dst[i*3+0] = (GLshort) rgba[i][RCOMP];
1186                      dst[i*3+1] = (GLshort) rgba[i][GCOMP];
1187                      dst[i*3+2] = (GLshort) rgba[i][BCOMP];
1188                   }
1189                   break;
1190                case GL_RGBA_INTEGER_EXT:
1191                   for (i=0;i<n;i++) {
1192                      dst[i*4+0] = (GLshort) rgba[i][RCOMP];
1193                      dst[i*4+1] = (GLshort) rgba[i][GCOMP];
1194                      dst[i*4+2] = (GLshort) rgba[i][BCOMP];
1195                      dst[i*4+3] = (GLshort) rgba[i][ACOMP];
1196                   }
1197                   break;
1198                case GL_BGR_INTEGER_EXT:
1199                   for (i=0;i<n;i++) {
1200                      dst[i*3+0] = (GLshort) rgba[i][BCOMP];
1201                      dst[i*3+1] = (GLshort) rgba[i][GCOMP];
1202                      dst[i*3+2] = (GLshort) rgba[i][RCOMP];
1203                   }
1204                   break;
1205                case GL_BGRA_INTEGER_EXT:
1206                   for (i=0;i<n;i++) {
1207                      dst[i*4+0] = (GLshort) rgba[i][BCOMP];
1208                      dst[i*4+1] = (GLshort) rgba[i][GCOMP];
1209                      dst[i*4+2] = (GLshort) rgba[i][RCOMP];
1210                      dst[i*4+3] = (GLshort) rgba[i][ACOMP];
1211                   }
1212                   break;
1213                case GL_LUMINANCE_INTEGER_EXT:
1214                   for (i=0;i<n;i++) {
1215                      dst[i*2+0] = (GLshort) (rgba[i][RCOMP] +
1216                                              rgba[i][GCOMP] +
1217                                              rgba[i][BCOMP]);
1218                      dst[i*2+1] = (GLshort) rgba[i][ACOMP];
1219                   }
1220                   break;
1221                case GL_LUMINANCE_ALPHA_INTEGER_EXT:
1222                   for (i=0;i<n;i++) {
1223                      dst[i] = (GLshort) (rgba[i][RCOMP] +
1224                                          rgba[i][GCOMP] +
1225                                          rgba[i][BCOMP]);
1226                   }
1227                   break;
1228                case GL_DUDV_ATI:
1229                case GL_DU8DV8_ATI:
1230                   for (i=0;i<n;i++) {
1231                      dst[i*2+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1232                      dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1233                   }
1234                   break;
1235                default:
1236                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1237             }
1238          }
1239          break;
1240       case GL_UNSIGNED_INT:
1241          {
1242             GLuint *dst = (GLuint *) dstAddr;
1243             switch (dstFormat) {
1244                case GL_RED:
1245                   for (i=0;i<n;i++)
1246                      dst[i] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1247                   break;
1248                case GL_GREEN:
1249                   for (i=0;i<n;i++)
1250                      dst[i] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1251                   break;
1252                case GL_BLUE:
1253                   for (i=0;i<n;i++)
1254                      dst[i] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1255                   break;
1256                case GL_ALPHA:
1257                   for (i=0;i<n;i++)
1258                      dst[i] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1259                   break;
1260                case GL_LUMINANCE:
1261                   for (i=0;i<n;i++)
1262                      dst[i] = FLOAT_TO_UINT(luminance[i]);
1263                   break;
1264                case GL_LUMINANCE_ALPHA:
1265                   for (i=0;i<n;i++) {
1266                      dst[i*2+0] = FLOAT_TO_UINT(luminance[i]);
1267                      dst[i*2+1] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1268                   }
1269                   break;
1270                case GL_RG:
1271                   for (i=0;i<n;i++) {
1272                      dst[i*2+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1273                      dst[i*2+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1274                   }
1275                   break;
1276                case GL_RGB:
1277                   for (i=0;i<n;i++) {
1278                      dst[i*3+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1279                      dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1280                      dst[i*3+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1281                   }
1282                   break;
1283                case GL_RGBA:
1284                   for (i=0;i<n;i++) {
1285                      dst[i*4+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1286                      dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1287                      dst[i*4+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1288                      dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1289                   }
1290                   break;
1291                case GL_BGR:
1292                   for (i=0;i<n;i++) {
1293                      dst[i*3+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1294                      dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1295                      dst[i*3+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1296                   }
1297                   break;
1298                case GL_BGRA:
1299                   for (i=0;i<n;i++) {
1300                      dst[i*4+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1301                      dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1302                      dst[i*4+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1303                      dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1304                   }
1305                   break;
1306                case GL_ABGR_EXT:
1307                   for (i=0;i<n;i++) {
1308                      dst[i*4+0] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1309                      dst[i*4+1] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1310                      dst[i*4+2] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1311                      dst[i*4+3] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1312                   }
1313                   break;
1314                case GL_RED_INTEGER_EXT:
1315                   for (i=0;i<n;i++) {
1316                      dst[i] = (GLuint) rgba[i][RCOMP];
1317                   }
1318                   break;
1319                case GL_GREEN_INTEGER_EXT:
1320                   for (i=0;i<n;i++) {
1321                      dst[i] = (GLuint) rgba[i][GCOMP];
1322                   }
1323                   break;
1324                case GL_BLUE_INTEGER_EXT:
1325                   for (i=0;i<n;i++) {
1326                      dst[i] = (GLuint) rgba[i][BCOMP];
1327                   }
1328                   break;
1329                case GL_ALPHA_INTEGER_EXT:
1330                   for (i=0;i<n;i++) {
1331                      dst[i] = (GLuint) rgba[i][ACOMP];
1332                   }
1333                   break;
1334                case GL_RG_INTEGER:
1335                   for (i=0;i<n;i++) {
1336                      dst[i*2+0] = (GLuint) rgba[i][RCOMP];
1337                      dst[i*2+1] = (GLuint) rgba[i][GCOMP];
1338                   }
1339                   break;
1340                case GL_RGB_INTEGER_EXT:
1341                   for (i=0;i<n;i++) {
1342                      dst[i*3+0] = (GLuint) rgba[i][RCOMP];
1343                      dst[i*3+1] = (GLuint) rgba[i][GCOMP];
1344                      dst[i*3+2] = (GLuint) rgba[i][BCOMP];
1345                   }
1346                   break;
1347                case GL_RGBA_INTEGER_EXT:
1348                   for (i=0;i<n;i++) {
1349                      dst[i*4+0] = (GLuint) rgba[i][RCOMP];
1350                      dst[i*4+1] = (GLuint) rgba[i][GCOMP];
1351                      dst[i*4+2] = (GLuint) rgba[i][BCOMP];
1352                      dst[i*4+3] = (GLuint) rgba[i][ACOMP];
1353                   }
1354                   break;
1355                case GL_BGR_INTEGER_EXT:
1356                   for (i=0;i<n;i++) {
1357                      dst[i*3+0] = (GLuint) rgba[i][BCOMP];
1358                      dst[i*3+1] = (GLuint) rgba[i][GCOMP];
1359                      dst[i*3+2] = (GLuint) rgba[i][RCOMP];
1360                   }
1361                   break;
1362                case GL_BGRA_INTEGER_EXT:
1363                   for (i=0;i<n;i++) {
1364                      dst[i*4+0] = (GLuint) rgba[i][BCOMP];
1365                      dst[i*4+1] = (GLuint) rgba[i][GCOMP];
1366                      dst[i*4+2] = (GLuint) rgba[i][RCOMP];
1367                      dst[i*4+3] = (GLuint) rgba[i][ACOMP];
1368                   }
1369                   break;
1370                case GL_LUMINANCE_INTEGER_EXT:
1371                   for (i=0;i<n;i++) {
1372                      dst[i*2+0] = (GLuint) (rgba[i][RCOMP] +
1373                                             rgba[i][GCOMP] +
1374                                             rgba[i][BCOMP]);
1375                      dst[i*2+1] = (GLuint) rgba[i][ACOMP];
1376                   }
1377                   break;
1378                case GL_LUMINANCE_ALPHA_INTEGER_EXT:
1379                   for (i=0;i<n;i++) {
1380                      dst[i] = (GLuint) (rgba[i][RCOMP] +
1381                                         rgba[i][GCOMP] +
1382                                         rgba[i][BCOMP]);
1383                   }
1384                   break;
1385                case GL_DUDV_ATI:
1386                case GL_DU8DV8_ATI:
1387                   for (i=0;i<n;i++) {
1388                      dst[i*2+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1389                      dst[i*2+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1390                   }
1391                   break;
1392                default:
1393                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1394             }
1395          }
1396          break;
1397       case GL_INT:
1398          {
1399             GLint *dst = (GLint *) dstAddr;
1400             switch (dstFormat) {
1401                case GL_RED:
1402                   for (i=0;i<n;i++)
1403                      dst[i] = FLOAT_TO_INT(rgba[i][RCOMP]);
1404                   break;
1405                case GL_GREEN:
1406                   for (i=0;i<n;i++)
1407                      dst[i] = FLOAT_TO_INT(rgba[i][GCOMP]);
1408                   break;
1409                case GL_BLUE:
1410                   for (i=0;i<n;i++)
1411                      dst[i] = FLOAT_TO_INT(rgba[i][BCOMP]);
1412                   break;
1413                case GL_ALPHA:
1414                   for (i=0;i<n;i++)
1415                      dst[i] = FLOAT_TO_INT(rgba[i][ACOMP]);
1416                   break;
1417                case GL_LUMINANCE:
1418                   for (i=0;i<n;i++)
1419                      dst[i] = FLOAT_TO_INT(luminance[i]);
1420                   break;
1421                case GL_LUMINANCE_ALPHA:
1422                   for (i=0;i<n;i++) {
1423                      dst[i*2+0] = FLOAT_TO_INT(luminance[i]);
1424                      dst[i*2+1] = FLOAT_TO_INT(rgba[i][ACOMP]);
1425                   }
1426                   break;
1427                case GL_RG:
1428                   for (i=0;i<n;i++) {
1429                      dst[i*2+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
1430                      dst[i*2+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1431                   }
1432                   break;
1433                case GL_RGB:
1434                   for (i=0;i<n;i++) {
1435                      dst[i*3+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
1436                      dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1437                      dst[i*3+2] = FLOAT_TO_INT(rgba[i][BCOMP]);
1438                   }
1439                   break;
1440                case GL_RGBA:
1441                   for (i=0;i<n;i++) {
1442                      dst[i*4+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
1443                      dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1444                      dst[i*4+2] = FLOAT_TO_INT(rgba[i][BCOMP]);
1445                      dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);
1446                   }
1447                   break;
1448                case GL_BGR:
1449                   for (i=0;i<n;i++) {
1450                      dst[i*3+0] = FLOAT_TO_INT(rgba[i][BCOMP]);
1451                      dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1452                      dst[i*3+2] = FLOAT_TO_INT(rgba[i][RCOMP]);
1453                   }
1454                   break;
1455                case GL_BGRA:
1456                   for (i=0;i<n;i++) {
1457                      dst[i*4+0] = FLOAT_TO_INT(rgba[i][BCOMP]);
1458                      dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1459                      dst[i*4+2] = FLOAT_TO_INT(rgba[i][RCOMP]);
1460                      dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);
1461                   }
1462                   break;
1463                case GL_ABGR_EXT:
1464                   for (i=0;i<n;i++) {
1465                      dst[i*4+0] = FLOAT_TO_INT(rgba[i][ACOMP]);
1466                      dst[i*4+1] = FLOAT_TO_INT(rgba[i][BCOMP]);
1467                      dst[i*4+2] = FLOAT_TO_INT(rgba[i][GCOMP]);
1468                      dst[i*4+3] = FLOAT_TO_INT(rgba[i][RCOMP]);
1469                   }
1470                   break;
1471                case GL_DUDV_ATI:
1472                case GL_DU8DV8_ATI:
1473                   for (i=0;i<n;i++) {
1474                      dst[i*2+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
1475                      dst[i*2+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1476                   }
1477                   break;
1478                case GL_RED_INTEGER_EXT:
1479                   for (i=0;i<n;i++) {
1480                      dst[i] = (GLint) rgba[i][RCOMP];
1481                   }
1482                   break;
1483                case GL_GREEN_INTEGER_EXT:
1484                   for (i=0;i<n;i++) {
1485                      dst[i] = (GLint) rgba[i][GCOMP];
1486                   }
1487                   break;
1488                case GL_BLUE_INTEGER_EXT:
1489                   for (i=0;i<n;i++) {
1490                      dst[i] = (GLint) rgba[i][BCOMP];
1491                   }
1492                   break;
1493                case GL_ALPHA_INTEGER_EXT:
1494                   for (i=0;i<n;i++) {
1495                      dst[i] = (GLint) rgba[i][ACOMP];
1496                   }
1497                   break;
1498                case GL_RG_INTEGER:
1499                   for (i=0;i<n;i++) {
1500                      dst[i*2+0] = (GLint) rgba[i][RCOMP];
1501                      dst[i*2+1] = (GLint) rgba[i][GCOMP];
1502                   }
1503                   break;
1504                case GL_RGB_INTEGER_EXT:
1505                   for (i=0;i<n;i++) {
1506                      dst[i*3+0] = (GLint) rgba[i][RCOMP];
1507                      dst[i*3+1] = (GLint) rgba[i][GCOMP];
1508                      dst[i*3+2] = (GLint) rgba[i][BCOMP];
1509                   }
1510                   break;
1511                case GL_RGBA_INTEGER_EXT:
1512                   for (i=0;i<n;i++) {
1513                      dst[i*4+0] = (GLint) rgba[i][RCOMP];
1514                      dst[i*4+1] = (GLint) rgba[i][GCOMP];
1515                      dst[i*4+2] = (GLint) rgba[i][BCOMP];
1516                      dst[i*4+3] = (GLint) rgba[i][ACOMP];
1517                   }
1518                   break;
1519                case GL_BGR_INTEGER_EXT:
1520                   for (i=0;i<n;i++) {
1521                      dst[i*3+0] = (GLint) rgba[i][BCOMP];
1522                      dst[i*3+1] = (GLint) rgba[i][GCOMP];
1523                      dst[i*3+2] = (GLint) rgba[i][RCOMP];
1524                   }
1525                   break;
1526                case GL_BGRA_INTEGER_EXT:
1527                   for (i=0;i<n;i++) {
1528                      dst[i*4+0] = (GLint) rgba[i][BCOMP];
1529                      dst[i*4+1] = (GLint) rgba[i][GCOMP];
1530                      dst[i*4+2] = (GLint) rgba[i][RCOMP];
1531                      dst[i*4+3] = (GLint) rgba[i][ACOMP];
1532                   }
1533                   break;
1534                case GL_LUMINANCE_INTEGER_EXT:
1535                   for (i=0;i<n;i++) {
1536                      dst[i*2+0] = (GLint) (rgba[i][RCOMP] +
1537                                            rgba[i][GCOMP] +
1538                                            rgba[i][BCOMP]);
1539                      dst[i*2+1] = (GLint) rgba[i][ACOMP];
1540                   }
1541                   break;
1542                case GL_LUMINANCE_ALPHA_INTEGER_EXT:
1543                   for (i=0;i<n;i++) {
1544                      dst[i] = (GLint) (rgba[i][RCOMP] +
1545                                        rgba[i][GCOMP] +
1546                                        rgba[i][BCOMP]);
1547                   }
1548                   break;
1549                default:
1550                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1551             }
1552          }
1553          break;
1554       case GL_FLOAT:
1555          {
1556             GLfloat *dst = (GLfloat *) dstAddr;
1557             switch (dstFormat) {
1558                case GL_RED:
1559                   for (i=0;i<n;i++)
1560                      dst[i] = rgba[i][RCOMP];
1561                   break;
1562                case GL_GREEN:
1563                   for (i=0;i<n;i++)
1564                      dst[i] = rgba[i][GCOMP];
1565                   break;
1566                case GL_BLUE:
1567                   for (i=0;i<n;i++)
1568                      dst[i] = rgba[i][BCOMP];
1569                   break;
1570                case GL_ALPHA:
1571                   for (i=0;i<n;i++)
1572                      dst[i] = rgba[i][ACOMP];
1573                   break;
1574                case GL_LUMINANCE:
1575                   for (i=0;i<n;i++)
1576                      dst[i] = luminance[i];
1577                   break;
1578                case GL_LUMINANCE_ALPHA:
1579                   for (i=0;i<n;i++) {
1580                      dst[i*2+0] = luminance[i];
1581                      dst[i*2+1] = rgba[i][ACOMP];
1582                   }
1583                   break;
1584                case GL_RG:
1585                   for (i=0;i<n;i++) {
1586                      dst[i*2+0] = rgba[i][RCOMP];
1587                      dst[i*2+1] = rgba[i][GCOMP];
1588                   }
1589                   break;
1590                case GL_RGB:
1591                   for (i=0;i<n;i++) {
1592                      dst[i*3+0] = rgba[i][RCOMP];
1593                      dst[i*3+1] = rgba[i][GCOMP];
1594                      dst[i*3+2] = rgba[i][BCOMP];
1595                   }
1596                   break;
1597                case GL_RGBA:
1598                   for (i=0;i<n;i++) {
1599                      dst[i*4+0] = rgba[i][RCOMP];
1600                      dst[i*4+1] = rgba[i][GCOMP];
1601                      dst[i*4+2] = rgba[i][BCOMP];
1602                      dst[i*4+3] = rgba[i][ACOMP];
1603                   }
1604                   break;
1605                case GL_BGR:
1606                   for (i=0;i<n;i++) {
1607                      dst[i*3+0] = rgba[i][BCOMP];
1608                      dst[i*3+1] = rgba[i][GCOMP];
1609                      dst[i*3+2] = rgba[i][RCOMP];
1610                   }
1611                   break;
1612                case GL_BGRA:
1613                   for (i=0;i<n;i++) {
1614                      dst[i*4+0] = rgba[i][BCOMP];
1615                      dst[i*4+1] = rgba[i][GCOMP];
1616                      dst[i*4+2] = rgba[i][RCOMP];
1617                      dst[i*4+3] = rgba[i][ACOMP];
1618                   }
1619                   break;
1620                case GL_ABGR_EXT:
1621                   for (i=0;i<n;i++) {
1622                      dst[i*4+0] = rgba[i][ACOMP];
1623                      dst[i*4+1] = rgba[i][BCOMP];
1624                      dst[i*4+2] = rgba[i][GCOMP];
1625                      dst[i*4+3] = rgba[i][RCOMP];
1626                   }
1627                   break;
1628                case GL_DUDV_ATI:
1629                case GL_DU8DV8_ATI:
1630                   for (i=0;i<n;i++) {
1631                      dst[i*2+0] = rgba[i][RCOMP];
1632                      dst[i*2+1] = rgba[i][GCOMP];
1633                   }
1634                   break;
1635                default:
1636                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1637             }
1638          }
1639          break;
1640       case GL_HALF_FLOAT_ARB:
1641          {
1642             GLhalfARB *dst = (GLhalfARB *) dstAddr;
1643             switch (dstFormat) {
1644                case GL_RED:
1645                   for (i=0;i<n;i++)
1646                      dst[i] = _mesa_float_to_half(rgba[i][RCOMP]);
1647                   break;
1648                case GL_GREEN:
1649                   for (i=0;i<n;i++)
1650                      dst[i] = _mesa_float_to_half(rgba[i][GCOMP]);
1651                   break;
1652                case GL_BLUE:
1653                   for (i=0;i<n;i++)
1654                      dst[i] = _mesa_float_to_half(rgba[i][BCOMP]);
1655                   break;
1656                case GL_ALPHA:
1657                   for (i=0;i<n;i++)
1658                      dst[i] = _mesa_float_to_half(rgba[i][ACOMP]);
1659                   break;
1660                case GL_LUMINANCE:
1661                   for (i=0;i<n;i++)
1662                      dst[i] = _mesa_float_to_half(luminance[i]);
1663                   break;
1664                case GL_LUMINANCE_ALPHA:
1665                   for (i=0;i<n;i++) {
1666                      dst[i*2+0] = _mesa_float_to_half(luminance[i]);
1667                      dst[i*2+1] = _mesa_float_to_half(rgba[i][ACOMP]);
1668                   }
1669                   break;
1670                case GL_RG:
1671                   for (i=0;i<n;i++) {
1672                      dst[i*2+0] = _mesa_float_to_half(rgba[i][RCOMP]);
1673                      dst[i*2+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1674                   }
1675                   break;
1676                case GL_RGB:
1677                   for (i=0;i<n;i++) {
1678                      dst[i*3+0] = _mesa_float_to_half(rgba[i][RCOMP]);
1679                      dst[i*3+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1680                      dst[i*3+2] = _mesa_float_to_half(rgba[i][BCOMP]);
1681                   }
1682                   break;
1683                case GL_RGBA:
1684                   for (i=0;i<n;i++) {
1685                      dst[i*4+0] = _mesa_float_to_half(rgba[i][RCOMP]);
1686                      dst[i*4+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1687                      dst[i*4+2] = _mesa_float_to_half(rgba[i][BCOMP]);
1688                      dst[i*4+3] = _mesa_float_to_half(rgba[i][ACOMP]);
1689                   }
1690                   break;
1691                case GL_BGR:
1692                   for (i=0;i<n;i++) {
1693                      dst[i*3+0] = _mesa_float_to_half(rgba[i][BCOMP]);
1694                      dst[i*3+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1695                      dst[i*3+2] = _mesa_float_to_half(rgba[i][RCOMP]);
1696                   }
1697                   break;
1698                case GL_BGRA:
1699                   for (i=0;i<n;i++) {
1700                      dst[i*4+0] = _mesa_float_to_half(rgba[i][BCOMP]);
1701                      dst[i*4+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1702                      dst[i*4+2] = _mesa_float_to_half(rgba[i][RCOMP]);
1703                      dst[i*4+3] = _mesa_float_to_half(rgba[i][ACOMP]);
1704                   }
1705                   break;
1706                case GL_ABGR_EXT:
1707                   for (i=0;i<n;i++) {
1708                      dst[i*4+0] = _mesa_float_to_half(rgba[i][ACOMP]);
1709                      dst[i*4+1] = _mesa_float_to_half(rgba[i][BCOMP]);
1710                      dst[i*4+2] = _mesa_float_to_half(rgba[i][GCOMP]);
1711                      dst[i*4+3] = _mesa_float_to_half(rgba[i][RCOMP]);
1712                   }
1713                   break;
1714                case GL_DUDV_ATI:
1715                case GL_DU8DV8_ATI:
1716                   for (i=0;i<n;i++) {
1717                      dst[i*2+0] = _mesa_float_to_half(rgba[i][RCOMP]);
1718                      dst[i*2+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1719                   }
1720                   break;
1721                default:
1722                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1723             }
1724          }
1725          break;
1726       case GL_UNSIGNED_BYTE_3_3_2:
1727          if (dstFormat == GL_RGB) {
1728             GLubyte *dst = (GLubyte *) dstAddr;
1729             for (i=0;i<n;i++) {
1730                dst[i] = (IROUND(rgba[i][RCOMP] * 7.0F) << 5)
1731                       | (IROUND(rgba[i][GCOMP] * 7.0F) << 2)
1732                       | (IROUND(rgba[i][BCOMP] * 3.0F)     );
1733             }
1734          }
1735          break;
1736       case GL_UNSIGNED_BYTE_2_3_3_REV:
1737          if (dstFormat == GL_RGB) {
1738             GLubyte *dst = (GLubyte *) dstAddr;
1739             for (i=0;i<n;i++) {
1740                dst[i] = (IROUND(rgba[i][RCOMP] * 7.0F)     )
1741                       | (IROUND(rgba[i][GCOMP] * 7.0F) << 3)
1742                       | (IROUND(rgba[i][BCOMP] * 3.0F) << 6);
1743             }
1744          }
1745          break;
1746       case GL_UNSIGNED_SHORT_5_6_5:
1747          if (dstFormat == GL_RGB) {
1748             GLushort *dst = (GLushort *) dstAddr;
1749             for (i=0;i<n;i++) {
1750                dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F) << 11)
1751                       | (IROUND(rgba[i][GCOMP] * 63.0F) <<  5)
1752                       | (IROUND(rgba[i][BCOMP] * 31.0F)      );
1753             }
1754          }
1755          break;
1756       case GL_UNSIGNED_SHORT_5_6_5_REV:
1757          if (dstFormat == GL_RGB) {
1758             GLushort *dst = (GLushort *) dstAddr;
1759             for (i=0;i<n;i++) {
1760                dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F)      )
1761                       | (IROUND(rgba[i][GCOMP] * 63.0F) <<  5)
1762                       | (IROUND(rgba[i][BCOMP] * 31.0F) << 11);
1763             }
1764          }
1765          break;
1766       case GL_UNSIGNED_SHORT_4_4_4_4:
1767          if (dstFormat == GL_RGBA) {
1768             GLushort *dst = (GLushort *) dstAddr;
1769             for (i=0;i<n;i++) {
1770                dst[i] = (IROUND(rgba[i][RCOMP] * 15.0F) << 12)
1771                       | (IROUND(rgba[i][GCOMP] * 15.0F) <<  8)
1772                       | (IROUND(rgba[i][BCOMP] * 15.0F) <<  4)
1773                       | (IROUND(rgba[i][ACOMP] * 15.0F)      );
1774             }
1775          }
1776          else if (dstFormat == GL_BGRA) {
1777             GLushort *dst = (GLushort *) dstAddr;
1778             for (i=0;i<n;i++) {
1779                dst[i] = (IROUND(rgba[i][BCOMP] * 15.0F) << 12)
1780                       | (IROUND(rgba[i][GCOMP] * 15.0F) <<  8)
1781                       | (IROUND(rgba[i][RCOMP] * 15.0F) <<  4)
1782                       | (IROUND(rgba[i][ACOMP] * 15.0F)      );
1783             }
1784          }
1785          else if (dstFormat == GL_ABGR_EXT) {
1786             GLushort *dst = (GLushort *) dstAddr;
1787             for (i=0;i<n;i++) {
1788                dst[i] = (IROUND(rgba[i][ACOMP] * 15.0F) << 12)
1789                       | (IROUND(rgba[i][BCOMP] * 15.0F) <<  8)
1790                       | (IROUND(rgba[i][GCOMP] * 15.0F) <<  4)
1791                       | (IROUND(rgba[i][RCOMP] * 15.0F)      );
1792             }
1793          }
1794          break;
1795       case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1796          if (dstFormat == GL_RGBA) {
1797             GLushort *dst = (GLushort *) dstAddr;
1798             for (i=0;i<n;i++) {
1799                dst[i] = (IROUND(rgba[i][RCOMP] * 15.0F)      )
1800                       | (IROUND(rgba[i][GCOMP] * 15.0F) <<  4)
1801                       | (IROUND(rgba[i][BCOMP] * 15.0F) <<  8)
1802                       | (IROUND(rgba[i][ACOMP] * 15.0F) << 12);
1803             }
1804          }
1805          else if (dstFormat == GL_BGRA) {
1806             GLushort *dst = (GLushort *) dstAddr;
1807             for (i=0;i<n;i++) {
1808                dst[i] = (IROUND(rgba[i][BCOMP] * 15.0F)      )
1809                       | (IROUND(rgba[i][GCOMP] * 15.0F) <<  4)
1810                       | (IROUND(rgba[i][RCOMP] * 15.0F) <<  8)
1811                       | (IROUND(rgba[i][ACOMP] * 15.0F) << 12);
1812             }
1813          }
1814          else if (dstFormat == GL_ABGR_EXT) {
1815             GLushort *dst = (GLushort *) dstAddr;
1816             for (i=0;i<n;i++) {
1817                dst[i] = (IROUND(rgba[i][ACOMP] * 15.0F)      )
1818                       | (IROUND(rgba[i][BCOMP] * 15.0F) <<  4)
1819                       | (IROUND(rgba[i][GCOMP] * 15.0F) <<  8)
1820                       | (IROUND(rgba[i][RCOMP] * 15.0F) << 12);
1821             }
1822          }
1823          break;
1824       case GL_UNSIGNED_SHORT_5_5_5_1:
1825          if (dstFormat == GL_RGBA) {
1826             GLushort *dst = (GLushort *) dstAddr;
1827             for (i=0;i<n;i++) {
1828                dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F) << 11)
1829                       | (IROUND(rgba[i][GCOMP] * 31.0F) <<  6)
1830                       | (IROUND(rgba[i][BCOMP] * 31.0F) <<  1)
1831                       | (IROUND(rgba[i][ACOMP] *  1.0F)      );
1832             }
1833          }
1834          else if (dstFormat == GL_BGRA) {
1835             GLushort *dst = (GLushort *) dstAddr;
1836             for (i=0;i<n;i++) {
1837                dst[i] = (IROUND(rgba[i][BCOMP] * 31.0F) << 11)
1838                       | (IROUND(rgba[i][GCOMP] * 31.0F) <<  6)
1839                       | (IROUND(rgba[i][RCOMP] * 31.0F) <<  1)
1840                       | (IROUND(rgba[i][ACOMP] *  1.0F)      );
1841             }
1842          }
1843          else if (dstFormat == GL_ABGR_EXT) {
1844             GLushort *dst = (GLushort *) dstAddr;
1845             for (i=0;i<n;i++) {
1846                dst[i] = (IROUND(rgba[i][ACOMP] * 31.0F) << 11)
1847                       | (IROUND(rgba[i][BCOMP] * 31.0F) <<  6)
1848                       | (IROUND(rgba[i][GCOMP] * 31.0F) <<  1)
1849                       | (IROUND(rgba[i][RCOMP] *  1.0F)      );
1850             }
1851          }
1852          break;
1853       case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1854          if (dstFormat == GL_RGBA) {
1855             GLushort *dst = (GLushort *) dstAddr;
1856             for (i=0;i<n;i++) {
1857                dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F)      )
1858                       | (IROUND(rgba[i][GCOMP] * 31.0F) <<  5)
1859                       | (IROUND(rgba[i][BCOMP] * 31.0F) << 10)
1860                       | (IROUND(rgba[i][ACOMP] *  1.0F) << 15);
1861             }
1862          }
1863          else if (dstFormat == GL_BGRA) {
1864             GLushort *dst = (GLushort *) dstAddr;
1865             for (i=0;i<n;i++) {
1866                dst[i] = (IROUND(rgba[i][BCOMP] * 31.0F)      )
1867                       | (IROUND(rgba[i][GCOMP] * 31.0F) <<  5)
1868                       | (IROUND(rgba[i][RCOMP] * 31.0F) << 10)
1869                       | (IROUND(rgba[i][ACOMP] *  1.0F) << 15);
1870             }
1871          }
1872          else if (dstFormat == GL_ABGR_EXT) {
1873             GLushort *dst = (GLushort *) dstAddr;
1874             for (i=0;i<n;i++) {
1875                dst[i] = (IROUND(rgba[i][ACOMP] * 31.0F)      )
1876                       | (IROUND(rgba[i][BCOMP] * 31.0F) <<  5)
1877                       | (IROUND(rgba[i][GCOMP] * 31.0F) << 10)
1878                       | (IROUND(rgba[i][RCOMP] *  1.0F) << 15);
1879             }
1880          }
1881          break;
1882       case GL_UNSIGNED_INT_8_8_8_8:
1883          if (dstFormat == GL_RGBA) {
1884             GLuint *dst = (GLuint *) dstAddr;
1885             for (i=0;i<n;i++) {
1886                dst[i] = (IROUND(rgba[i][RCOMP] * 255.F) << 24)
1887                       | (IROUND(rgba[i][GCOMP] * 255.F) << 16)
1888                       | (IROUND(rgba[i][BCOMP] * 255.F) <<  8)
1889                       | (IROUND(rgba[i][ACOMP] * 255.F)      );
1890             }
1891          }
1892          else if (dstFormat == GL_BGRA) {
1893             GLuint *dst = (GLuint *) dstAddr;
1894             for (i=0;i<n;i++) {
1895                dst[i] = (IROUND(rgba[i][BCOMP] * 255.F) << 24)
1896                       | (IROUND(rgba[i][GCOMP] * 255.F) << 16)
1897                       | (IROUND(rgba[i][RCOMP] * 255.F) <<  8)
1898                       | (IROUND(rgba[i][ACOMP] * 255.F)      );
1899             }
1900          }
1901          else if (dstFormat == GL_ABGR_EXT) {
1902             GLuint *dst = (GLuint *) dstAddr;
1903             for (i=0;i<n;i++) {
1904                dst[i] = (IROUND(rgba[i][ACOMP] * 255.F) << 24)
1905                       | (IROUND(rgba[i][BCOMP] * 255.F) << 16)
1906                       | (IROUND(rgba[i][GCOMP] * 255.F) <<  8)
1907                       | (IROUND(rgba[i][RCOMP] * 255.F)      );
1908             }
1909          }
1910          break;
1911       case GL_UNSIGNED_INT_8_8_8_8_REV:
1912          if (dstFormat == GL_RGBA) {
1913             GLuint *dst = (GLuint *) dstAddr;
1914             for (i=0;i<n;i++) {
1915                dst[i] = (IROUND(rgba[i][RCOMP] * 255.0F)      )
1916                       | (IROUND(rgba[i][GCOMP] * 255.0F) <<  8)
1917                       | (IROUND(rgba[i][BCOMP] * 255.0F) << 16)
1918                       | (IROUND(rgba[i][ACOMP] * 255.0F) << 24);
1919             }
1920          }
1921          else if (dstFormat == GL_BGRA) {
1922             GLuint *dst = (GLuint *) dstAddr;
1923             for (i=0;i<n;i++) {
1924                dst[i] = (IROUND(rgba[i][BCOMP] * 255.0F)      )
1925                       | (IROUND(rgba[i][GCOMP] * 255.0F) <<  8)
1926                       | (IROUND(rgba[i][RCOMP] * 255.0F) << 16)
1927                       | (IROUND(rgba[i][ACOMP] * 255.0F) << 24);
1928             }
1929          }
1930          else if (dstFormat == GL_ABGR_EXT) {
1931             GLuint *dst = (GLuint *) dstAddr;
1932             for (i=0;i<n;i++) {
1933                dst[i] = (IROUND(rgba[i][ACOMP] * 255.0F)      )
1934                       | (IROUND(rgba[i][BCOMP] * 255.0F) <<  8)
1935                       | (IROUND(rgba[i][GCOMP] * 255.0F) << 16)
1936                       | (IROUND(rgba[i][RCOMP] * 255.0F) << 24);
1937             }
1938          }
1939          break;
1940       case GL_UNSIGNED_INT_10_10_10_2:
1941          if (dstFormat == GL_RGBA) {
1942             GLuint *dst = (GLuint *) dstAddr;
1943             for (i=0;i<n;i++) {
1944                dst[i] = (IROUND(rgba[i][RCOMP] * 1023.0F) << 22)
1945                       | (IROUND(rgba[i][GCOMP] * 1023.0F) << 12)
1946                       | (IROUND(rgba[i][BCOMP] * 1023.0F) <<  2)
1947                       | (IROUND(rgba[i][ACOMP] *    3.0F)      );
1948             }
1949          }
1950          else if (dstFormat == GL_BGRA) {
1951             GLuint *dst = (GLuint *) dstAddr;
1952             for (i=0;i<n;i++) {
1953                dst[i] = (IROUND(rgba[i][BCOMP] * 1023.0F) << 22)
1954                       | (IROUND(rgba[i][GCOMP] * 1023.0F) << 12)
1955                       | (IROUND(rgba[i][RCOMP] * 1023.0F) <<  2)
1956                       | (IROUND(rgba[i][ACOMP] *    3.0F)      );
1957             }
1958          }
1959          else if (dstFormat == GL_ABGR_EXT) {
1960             GLuint *dst = (GLuint *) dstAddr;
1961             for (i=0;i<n;i++) {
1962                dst[i] = (IROUND(rgba[i][ACOMP] * 1023.0F) << 22)
1963                       | (IROUND(rgba[i][BCOMP] * 1023.0F) << 12)
1964                       | (IROUND(rgba[i][GCOMP] * 1023.0F) <<  2)
1965                       | (IROUND(rgba[i][RCOMP] *    3.0F)      );
1966             }
1967          }
1968          break;
1969       case GL_UNSIGNED_INT_2_10_10_10_REV:
1970          if (dstFormat == GL_RGBA) {
1971             GLuint *dst = (GLuint *) dstAddr;
1972             for (i=0;i<n;i++) {
1973                dst[i] = (IROUND(rgba[i][RCOMP] * 1023.0F)      )
1974                       | (IROUND(rgba[i][GCOMP] * 1023.0F) << 10)
1975                       | (IROUND(rgba[i][BCOMP] * 1023.0F) << 20)
1976                       | (IROUND(rgba[i][ACOMP] *    3.0F) << 30);
1977             }
1978          }
1979          else if (dstFormat == GL_BGRA) {
1980             GLuint *dst = (GLuint *) dstAddr;
1981             for (i=0;i<n;i++) {
1982                dst[i] = (IROUND(rgba[i][BCOMP] * 1023.0F)      )
1983                       | (IROUND(rgba[i][GCOMP] * 1023.0F) << 10)
1984                       | (IROUND(rgba[i][RCOMP] * 1023.0F) << 20)
1985                       | (IROUND(rgba[i][ACOMP] *    3.0F) << 30);
1986             }
1987          }
1988          else if (dstFormat == GL_ABGR_EXT) {
1989             GLuint *dst = (GLuint *) dstAddr;
1990             for (i=0;i<n;i++) {
1991                dst[i] = (IROUND(rgba[i][ACOMP] * 1023.0F)      )
1992                       | (IROUND(rgba[i][BCOMP] * 1023.0F) << 10)
1993                       | (IROUND(rgba[i][GCOMP] * 1023.0F) << 20)
1994                       | (IROUND(rgba[i][RCOMP] *    3.0F) << 30);
1995             }
1996          }
1997          break;
1998       case GL_UNSIGNED_INT_5_9_9_9_REV:
1999          {
2000             GLuint *dst = (GLuint *) dstAddr;
2001             for (i = 0; i < n; i++) {
2002                dst[i] = float3_to_rgb9e5(rgba[i]);
2003             }
2004          }
2005          break;
2006       case GL_UNSIGNED_INT_10F_11F_11F_REV:
2007          {
2008             GLuint *dst = (GLuint *) dstAddr;
2009             for (i = 0; i < n; i++) {
2010                dst[i] = float3_to_r11g11b10f(rgba[i]);
2011             }
2012          }
2013          break;
2014       default:
2015          _mesa_problem(ctx, "bad type in _mesa_pack_rgba_span_float");
2016          free(luminance);
2017          return;
2018    }
2019
2020    if (dstPacking->SwapBytes) {
2021       GLint swapSize = _mesa_sizeof_packed_type(dstType);
2022       if (swapSize == 2) {
2023          if (dstPacking->SwapBytes) {
2024             _mesa_swap2((GLushort *) dstAddr, n * comps);
2025          }
2026       }
2027       else if (swapSize == 4) {
2028          if (dstPacking->SwapBytes) {
2029             _mesa_swap4((GLuint *) dstAddr, n * comps);
2030          }
2031       }
2032    }
2033
2034    free(luminance);
2035 }
2036
2037
2038
2039 #define SWAP2BYTE(VALUE)                        \
2040    {                                            \
2041       GLubyte *bytes = (GLubyte *) &(VALUE);    \
2042       GLubyte tmp = bytes[0];                   \
2043       bytes[0] = bytes[1];                      \
2044       bytes[1] = tmp;                           \
2045    }
2046
2047 #define SWAP4BYTE(VALUE)                        \
2048    {                                            \
2049       GLubyte *bytes = (GLubyte *) &(VALUE);    \
2050       GLubyte tmp = bytes[0];                   \
2051       bytes[0] = bytes[3];                      \
2052       bytes[3] = tmp;                           \
2053       tmp = bytes[1];                           \
2054       bytes[1] = bytes[2];                      \
2055       bytes[2] = tmp;                           \
2056    }
2057
2058
2059 static void
2060 extract_uint_indexes(GLuint n, GLuint indexes[],
2061                      GLenum srcFormat, GLenum srcType, const GLvoid *src,
2062                      const struct gl_pixelstore_attrib *unpack )
2063 {
2064    ASSERT(srcFormat == GL_COLOR_INDEX || srcFormat == GL_STENCIL_INDEX);
2065
2066    ASSERT(srcType == GL_BITMAP ||
2067           srcType == GL_UNSIGNED_BYTE ||
2068           srcType == GL_BYTE ||
2069           srcType == GL_UNSIGNED_SHORT ||
2070           srcType == GL_SHORT ||
2071           srcType == GL_UNSIGNED_INT ||
2072           srcType == GL_INT ||
2073           srcType == GL_UNSIGNED_INT_24_8_EXT ||
2074           srcType == GL_HALF_FLOAT_ARB ||
2075           srcType == GL_FLOAT ||
2076           srcType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
2077
2078    switch (srcType) {
2079       case GL_BITMAP:
2080          {
2081             GLubyte *ubsrc = (GLubyte *) src;
2082             if (unpack->LsbFirst) {
2083                GLubyte mask = 1 << (unpack->SkipPixels & 0x7);
2084                GLuint i;
2085                for (i = 0; i < n; i++) {
2086                   indexes[i] = (*ubsrc & mask) ? 1 : 0;
2087                   if (mask == 128) {
2088                      mask = 1;
2089                      ubsrc++;
2090                   }
2091                   else {
2092                      mask = mask << 1;
2093                   }
2094                }
2095             }
2096             else {
2097                GLubyte mask = 128 >> (unpack->SkipPixels & 0x7);
2098                GLuint i;
2099                for (i = 0; i < n; i++) {
2100                   indexes[i] = (*ubsrc & mask) ? 1 : 0;
2101                   if (mask == 1) {
2102                      mask = 128;
2103                      ubsrc++;
2104                   }
2105                   else {
2106                      mask = mask >> 1;
2107                   }
2108                }
2109             }
2110          }
2111          break;
2112       case GL_UNSIGNED_BYTE:
2113          {
2114             GLuint i;
2115             const GLubyte *s = (const GLubyte *) src;
2116             for (i = 0; i < n; i++)
2117                indexes[i] = s[i];
2118          }
2119          break;
2120       case GL_BYTE:
2121          {
2122             GLuint i;
2123             const GLbyte *s = (const GLbyte *) src;
2124             for (i = 0; i < n; i++)
2125                indexes[i] = s[i];
2126          }
2127          break;
2128       case GL_UNSIGNED_SHORT:
2129          {
2130             GLuint i;
2131             const GLushort *s = (const GLushort *) src;
2132             if (unpack->SwapBytes) {
2133                for (i = 0; i < n; i++) {
2134                   GLushort value = s[i];
2135                   SWAP2BYTE(value);
2136                   indexes[i] = value;
2137                }
2138             }
2139             else {
2140                for (i = 0; i < n; i++)
2141                   indexes[i] = s[i];
2142             }
2143          }
2144          break;
2145       case GL_SHORT:
2146          {
2147             GLuint i;
2148             const GLshort *s = (const GLshort *) src;
2149             if (unpack->SwapBytes) {
2150                for (i = 0; i < n; i++) {
2151                   GLshort value = s[i];
2152                   SWAP2BYTE(value);
2153                   indexes[i] = value;
2154                }
2155             }
2156             else {
2157                for (i = 0; i < n; i++)
2158                   indexes[i] = s[i];
2159             }
2160          }
2161          break;
2162       case GL_UNSIGNED_INT:
2163          {
2164             GLuint i;
2165             const GLuint *s = (const GLuint *) src;
2166             if (unpack->SwapBytes) {
2167                for (i = 0; i < n; i++) {
2168                   GLuint value = s[i];
2169                   SWAP4BYTE(value);
2170                   indexes[i] = value;
2171                }
2172             }
2173             else {
2174                for (i = 0; i < n; i++)
2175                   indexes[i] = s[i];
2176             }
2177          }
2178          break;
2179       case GL_INT:
2180          {
2181             GLuint i;
2182             const GLint *s = (const GLint *) src;
2183             if (unpack->SwapBytes) {
2184                for (i = 0; i < n; i++) {
2185                   GLint value = s[i];
2186                   SWAP4BYTE(value);
2187                   indexes[i] = value;
2188                }
2189             }
2190             else {
2191                for (i = 0; i < n; i++)
2192                   indexes[i] = s[i];
2193             }
2194          }
2195          break;
2196       case GL_FLOAT:
2197          {
2198             GLuint i;
2199             const GLfloat *s = (const GLfloat *) src;
2200             if (unpack->SwapBytes) {
2201                for (i = 0; i < n; i++) {
2202                   GLfloat value = s[i];
2203                   SWAP4BYTE(value);
2204                   indexes[i] = (GLuint) value;
2205                }
2206             }
2207             else {
2208                for (i = 0; i < n; i++)
2209                   indexes[i] = (GLuint) s[i];
2210             }
2211          }
2212          break;
2213       case GL_HALF_FLOAT_ARB:
2214          {
2215             GLuint i;
2216             const GLhalfARB *s = (const GLhalfARB *) src;
2217             if (unpack->SwapBytes) {
2218                for (i = 0; i < n; i++) {
2219                   GLhalfARB value = s[i];
2220                   SWAP2BYTE(value);
2221                   indexes[i] = (GLuint) _mesa_half_to_float(value);
2222                }
2223             }
2224             else {
2225                for (i = 0; i < n; i++)
2226                   indexes[i] = (GLuint) _mesa_half_to_float(s[i]);
2227             }
2228          }
2229          break;
2230       case GL_UNSIGNED_INT_24_8_EXT:
2231          {
2232             GLuint i;
2233             const GLuint *s = (const GLuint *) src;
2234             if (unpack->SwapBytes) {
2235                for (i = 0; i < n; i++) {
2236                   GLuint value = s[i];
2237                   SWAP4BYTE(value);
2238                   indexes[i] = value & 0xff;  /* lower 8 bits */
2239                }
2240             }
2241             else {
2242                for (i = 0; i < n; i++)
2243                   indexes[i] = s[i] & 0xff;  /* lower 8 bits */
2244             }
2245          }
2246          break;
2247       case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
2248          {
2249             GLuint i;
2250             const GLuint *s = (const GLuint *) src;
2251             if (unpack->SwapBytes) {
2252                for (i = 0; i < n; i++) {
2253                   GLuint value = s[i*2+1];
2254                   SWAP4BYTE(value);
2255                   indexes[i] = value & 0xff;  /* lower 8 bits */
2256                }
2257             }
2258             else {
2259                for (i = 0; i < n; i++)
2260                   indexes[i] = s[i*2+1] & 0xff;  /* lower 8 bits */
2261             }
2262          }
2263          break;
2264
2265       default:
2266          _mesa_problem(NULL, "bad srcType in extract_uint_indexes");
2267          return;
2268    }
2269 }
2270
2271
2272 /**
2273  * Return source/dest RGBA indexes for unpacking pixels.
2274  */
2275 static void
2276 get_component_mapping(GLenum format,
2277                       GLint *rSrc,
2278                       GLint *gSrc,
2279                       GLint *bSrc,
2280                       GLint *aSrc,
2281                       GLint *rDst,
2282                       GLint *gDst,
2283                       GLint *bDst,
2284                       GLint *aDst)
2285 {
2286    switch (format) {
2287    case GL_RED:
2288    case GL_RED_INTEGER_EXT:
2289       *rSrc = 0;
2290       *gSrc = *bSrc = *aSrc = -1;
2291       break;
2292    case GL_GREEN:
2293    case GL_GREEN_INTEGER_EXT:
2294       *gSrc = 0;
2295       *rSrc = *bSrc = *aSrc = -1;
2296       break;
2297    case GL_BLUE:
2298    case GL_BLUE_INTEGER_EXT:
2299       *bSrc = 0;
2300       *rSrc = *gSrc = *aSrc = -1;
2301       break;
2302    case GL_ALPHA:
2303    case GL_ALPHA_INTEGER_EXT:
2304       *rSrc = *gSrc = *bSrc = -1;
2305       *aSrc = 0;
2306       break;
2307    case GL_LUMINANCE:
2308    case GL_LUMINANCE_INTEGER_EXT:
2309       *rSrc = *gSrc = *bSrc = 0;
2310       *aSrc = -1;
2311       break;
2312    case GL_LUMINANCE_ALPHA:
2313    case GL_LUMINANCE_ALPHA_INTEGER_EXT:
2314       *rSrc = *gSrc = *bSrc = 0;
2315       *aSrc = 1;
2316       break;
2317    case GL_INTENSITY:
2318       *rSrc = *gSrc = *bSrc = *aSrc = 0;
2319       break;
2320    case GL_RG:
2321    case GL_RG_INTEGER:
2322       *rSrc = 0;
2323       *gSrc = 1;
2324       *bSrc = -1;
2325       *aSrc = -1;
2326       *rDst = 0;
2327       *gDst = 1;
2328       *bDst = 2;
2329       *aDst = 3;
2330       break;
2331    case GL_RGB:
2332    case GL_RGB_INTEGER:
2333       *rSrc = 0;
2334       *gSrc = 1;
2335       *bSrc = 2;
2336       *aSrc = -1;
2337       *rDst = 0;
2338       *gDst = 1;
2339       *bDst = 2;
2340       *aDst = 3;
2341       break;
2342    case GL_BGR:
2343    case GL_BGR_INTEGER:
2344       *rSrc = 2;
2345       *gSrc = 1;
2346       *bSrc = 0;
2347       *aSrc = -1;
2348       *rDst = 2;
2349       *gDst = 1;
2350       *bDst = 0;
2351       *aDst = 3;
2352       break;
2353    case GL_RGBA:
2354    case GL_RGBA_INTEGER:
2355       *rSrc = 0;
2356       *gSrc = 1;
2357       *bSrc = 2;
2358       *aSrc = 3;
2359       *rDst = 0;
2360       *gDst = 1;
2361       *bDst = 2;
2362       *aDst = 3;
2363       break;
2364    case GL_BGRA:
2365    case GL_BGRA_INTEGER:
2366       *rSrc = 2;
2367       *gSrc = 1;
2368       *bSrc = 0;
2369       *aSrc = 3;
2370       *rDst = 2;
2371       *gDst = 1;
2372       *bDst = 0;
2373       *aDst = 3;
2374       break;
2375    case GL_ABGR_EXT:
2376       *rSrc = 3;
2377       *gSrc = 2;
2378       *bSrc = 1;
2379       *aSrc = 0;
2380       *rDst = 3;
2381       *gDst = 2;
2382       *bDst = 1;
2383       *aDst = 0;
2384       break;
2385    case GL_DU8DV8_ATI:
2386    case GL_DUDV_ATI:
2387       *rSrc = 0;
2388       *gSrc = 1;
2389       *bSrc = -1;
2390       *aSrc = -1;
2391       break;
2392    default:
2393       _mesa_problem(NULL, "bad srcFormat %s in get_component_mapping",
2394                     _mesa_lookup_enum_by_nr(format));
2395       return;
2396    }
2397 }
2398
2399
2400
2401 /*
2402  * This function extracts floating point RGBA values from arbitrary
2403  * image data.  srcFormat and srcType are the format and type parameters
2404  * passed to glDrawPixels, glTexImage[123]D, glTexSubImage[123]D, etc.
2405  *
2406  * Refering to section 3.6.4 of the OpenGL 1.2 spec, this function
2407  * implements the "Conversion to floating point", "Conversion to RGB",
2408  * and "Final Expansion to RGBA" operations.
2409  *
2410  * Args:  n - number of pixels
2411  *        rgba - output colors
2412  *        srcFormat - format of incoming data
2413  *        srcType - data type of incoming data
2414  *        src - source data pointer
2415  *        swapBytes - perform byteswapping of incoming data?
2416  */
2417 static void
2418 extract_float_rgba(GLuint n, GLfloat rgba[][4],
2419                    GLenum srcFormat, GLenum srcType, const GLvoid *src,
2420                    GLboolean swapBytes)
2421 {
2422    GLint rSrc, gSrc, bSrc, aSrc;
2423    GLint stride;
2424    GLint rDst, bDst, gDst, aDst;
2425    GLboolean intFormat;
2426    GLfloat rs = 1.0f, gs = 1.0f, bs = 1.0f, as = 1.0f; /* scale factors */
2427
2428    ASSERT(srcFormat == GL_RED ||
2429           srcFormat == GL_GREEN ||
2430           srcFormat == GL_BLUE ||
2431           srcFormat == GL_ALPHA ||
2432           srcFormat == GL_LUMINANCE ||
2433           srcFormat == GL_LUMINANCE_ALPHA ||
2434           srcFormat == GL_INTENSITY ||
2435           srcFormat == GL_RG ||
2436           srcFormat == GL_RGB ||
2437           srcFormat == GL_BGR ||
2438           srcFormat == GL_RGBA ||
2439           srcFormat == GL_BGRA ||
2440           srcFormat == GL_ABGR_EXT ||
2441           srcFormat == GL_DU8DV8_ATI ||
2442           srcFormat == GL_DUDV_ATI ||
2443           srcFormat == GL_RED_INTEGER_EXT ||
2444           srcFormat == GL_GREEN_INTEGER_EXT ||
2445           srcFormat == GL_BLUE_INTEGER_EXT ||
2446           srcFormat == GL_ALPHA_INTEGER_EXT ||
2447           srcFormat == GL_RG_INTEGER ||
2448           srcFormat == GL_RGB_INTEGER_EXT ||
2449           srcFormat == GL_RGBA_INTEGER_EXT ||
2450           srcFormat == GL_BGR_INTEGER_EXT ||
2451           srcFormat == GL_BGRA_INTEGER_EXT ||
2452           srcFormat == GL_LUMINANCE_INTEGER_EXT ||
2453           srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);
2454
2455    ASSERT(srcType == GL_UNSIGNED_BYTE ||
2456           srcType == GL_BYTE ||
2457           srcType == GL_UNSIGNED_SHORT ||
2458           srcType == GL_SHORT ||
2459           srcType == GL_UNSIGNED_INT ||
2460           srcType == GL_INT ||
2461           srcType == GL_HALF_FLOAT_ARB ||
2462           srcType == GL_FLOAT ||
2463           srcType == GL_UNSIGNED_BYTE_3_3_2 ||
2464           srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
2465           srcType == GL_UNSIGNED_SHORT_5_6_5 ||
2466           srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
2467           srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
2468           srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
2469           srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
2470           srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
2471           srcType == GL_UNSIGNED_INT_8_8_8_8 ||
2472           srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
2473           srcType == GL_UNSIGNED_INT_10_10_10_2 ||
2474           srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
2475           srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
2476           srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
2477
2478    get_component_mapping(srcFormat,
2479                          &rSrc, &gSrc, &bSrc, &aSrc,
2480                          &rDst, &gDst, &bDst, &aDst);
2481
2482    stride = _mesa_components_in_format(srcFormat);
2483
2484    intFormat = _mesa_is_integer_format(srcFormat);
2485
2486 #define PROCESS(SRC_INDEX, DST_INDEX, DEFAULT_FLT, DEFAULT_INT, TYPE, CONVERSION) \
2487    if ((SRC_INDEX) < 0) {                                               \
2488       GLuint i;                                                         \
2489       if (intFormat) {                                                  \
2490          for (i = 0; i < n; i++) {                                      \
2491             rgba[i][DST_INDEX] = DEFAULT_INT;                           \
2492          }                                                              \
2493       }                                                                 \
2494       else {                                                            \
2495          for (i = 0; i < n; i++) {                                      \
2496             rgba[i][DST_INDEX] = DEFAULT_FLT;                           \
2497          }                                                              \
2498       }                                                                 \
2499    }                                                                    \
2500    else if (swapBytes) {                                                \
2501       const TYPE *s = (const TYPE *) src;                               \
2502       GLuint i;                                                         \
2503       for (i = 0; i < n; i++) {                                         \
2504          TYPE value = s[SRC_INDEX];                                     \
2505          if (sizeof(TYPE) == 2) {                                       \
2506             SWAP2BYTE(value);                                           \
2507          }                                                              \
2508          else if (sizeof(TYPE) == 4) {                                  \
2509             SWAP4BYTE(value);                                           \
2510          }                                                              \
2511          if (intFormat)                                                 \
2512             rgba[i][DST_INDEX] = (GLfloat) value;                       \
2513          else                                                           \
2514             rgba[i][DST_INDEX] = (GLfloat) CONVERSION(value);           \
2515          s += stride;                                                   \
2516       }                                                                 \
2517    }                                                                    \
2518    else {                                                               \
2519       const TYPE *s = (const TYPE *) src;                               \
2520       GLuint i;                                                         \
2521       if (intFormat) {                                                  \
2522          for (i = 0; i < n; i++) {                                      \
2523             rgba[i][DST_INDEX] = (GLfloat) s[SRC_INDEX];                \
2524             s += stride;                                                \
2525          }                                                              \
2526       }                                                                 \
2527       else {                                                            \
2528          for (i = 0; i < n; i++) {                                      \
2529             rgba[i][DST_INDEX] = (GLfloat) CONVERSION(s[SRC_INDEX]);    \
2530             s += stride;                                                \
2531          }                                                              \
2532       }                                                                 \
2533    }
2534
2535    switch (srcType) {
2536       case GL_UNSIGNED_BYTE:
2537          PROCESS(rSrc, RCOMP, 0.0F,   0, GLubyte, UBYTE_TO_FLOAT);
2538          PROCESS(gSrc, GCOMP, 0.0F,   0, GLubyte, UBYTE_TO_FLOAT);
2539          PROCESS(bSrc, BCOMP, 0.0F,   0, GLubyte, UBYTE_TO_FLOAT);
2540          PROCESS(aSrc, ACOMP, 1.0F, 255, GLubyte, UBYTE_TO_FLOAT);
2541          break;
2542       case GL_BYTE:
2543          PROCESS(rSrc, RCOMP, 0.0F,   0, GLbyte, BYTE_TO_FLOATZ);
2544          PROCESS(gSrc, GCOMP, 0.0F,   0, GLbyte, BYTE_TO_FLOATZ);
2545          PROCESS(bSrc, BCOMP, 0.0F,   0, GLbyte, BYTE_TO_FLOATZ);
2546          PROCESS(aSrc, ACOMP, 1.0F, 127, GLbyte, BYTE_TO_FLOATZ);
2547          break;
2548       case GL_UNSIGNED_SHORT:
2549          PROCESS(rSrc, RCOMP, 0.0F,      0, GLushort, USHORT_TO_FLOAT);
2550          PROCESS(gSrc, GCOMP, 0.0F,      0, GLushort, USHORT_TO_FLOAT);
2551          PROCESS(bSrc, BCOMP, 0.0F,      0, GLushort, USHORT_TO_FLOAT);
2552          PROCESS(aSrc, ACOMP, 1.0F, 0xffff, GLushort, USHORT_TO_FLOAT);
2553          break;
2554       case GL_SHORT:
2555          PROCESS(rSrc, RCOMP, 0.0F,     0, GLshort, SHORT_TO_FLOATZ);
2556          PROCESS(gSrc, GCOMP, 0.0F,     0, GLshort, SHORT_TO_FLOATZ);
2557          PROCESS(bSrc, BCOMP, 0.0F,     0, GLshort, SHORT_TO_FLOATZ);
2558          PROCESS(aSrc, ACOMP, 1.0F, 32767, GLshort, SHORT_TO_FLOATZ);
2559          break;
2560       case GL_UNSIGNED_INT:
2561          PROCESS(rSrc, RCOMP, 0.0F,          0, GLuint, UINT_TO_FLOAT);
2562          PROCESS(gSrc, GCOMP, 0.0F,          0, GLuint, UINT_TO_FLOAT);
2563          PROCESS(bSrc, BCOMP, 0.0F,          0, GLuint, UINT_TO_FLOAT);
2564          PROCESS(aSrc, ACOMP, 1.0F, 0xffffffff, GLuint, UINT_TO_FLOAT);
2565          break;
2566       case GL_INT:
2567          PROCESS(rSrc, RCOMP, 0.0F,          0, GLint, INT_TO_FLOAT);
2568          PROCESS(gSrc, GCOMP, 0.0F,          0, GLint, INT_TO_FLOAT);
2569          PROCESS(bSrc, BCOMP, 0.0F,          0, GLint, INT_TO_FLOAT);
2570          PROCESS(aSrc, ACOMP, 1.0F, 2147483647, GLint, INT_TO_FLOAT);
2571          break;
2572       case GL_FLOAT:
2573          PROCESS(rSrc, RCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
2574          PROCESS(gSrc, GCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
2575          PROCESS(bSrc, BCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
2576          PROCESS(aSrc, ACOMP, 1.0F, 1.0F, GLfloat, (GLfloat));
2577          break;
2578       case GL_HALF_FLOAT_ARB:
2579          PROCESS(rSrc, RCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
2580          PROCESS(gSrc, GCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
2581          PROCESS(bSrc, BCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
2582          PROCESS(aSrc, ACOMP, 1.0F, 1.0F, GLhalfARB, _mesa_half_to_float);
2583          break;
2584       case GL_UNSIGNED_BYTE_3_3_2:
2585          {
2586             const GLubyte *ubsrc = (const GLubyte *) src;
2587             GLuint i;
2588             if (!intFormat) {
2589                rs = 1.0F / 7.0F;
2590                gs = 1.0F / 7.0F;
2591                bs = 1.0F / 3.0F;
2592             }
2593             for (i = 0; i < n; i ++) {
2594                GLubyte p = ubsrc[i];
2595                rgba[i][rDst] = ((p >> 5)      ) * rs;
2596                rgba[i][gDst] = ((p >> 2) & 0x7) * gs;
2597                rgba[i][bDst] = ((p     ) & 0x3) * bs;
2598                rgba[i][aDst] = 1.0F;
2599             }
2600          }
2601          break;
2602       case GL_UNSIGNED_BYTE_2_3_3_REV:
2603          {
2604             const GLubyte *ubsrc = (const GLubyte *) src;
2605             GLuint i;
2606             if (!intFormat) {
2607                rs = 1.0F / 7.0F;
2608                gs = 1.0F / 7.0F;
2609                bs = 1.0F / 3.0F;
2610             }
2611             for (i = 0; i < n; i ++) {
2612                GLubyte p = ubsrc[i];
2613                rgba[i][rDst] = ((p     ) & 0x7) * rs;
2614                rgba[i][gDst] = ((p >> 3) & 0x7) * gs;
2615                rgba[i][bDst] = ((p >> 6)      ) * bs;
2616                rgba[i][aDst] = 1.0F;
2617             }
2618          }
2619          break;
2620       case GL_UNSIGNED_SHORT_5_6_5:
2621          if (!intFormat) {
2622             rs = 1.0F / 31.0F;
2623             gs = 1.0F / 63.0F;
2624             bs = 1.0F / 31.0F;
2625          }
2626          if (swapBytes) {
2627             const GLushort *ussrc = (const GLushort *) src;
2628             GLuint i;
2629             for (i = 0; i < n; i ++) {
2630                GLushort p = ussrc[i];
2631                SWAP2BYTE(p);
2632                rgba[i][rDst] = ((p >> 11)       ) * rs;
2633                rgba[i][gDst] = ((p >>  5) & 0x3f) * gs;
2634                rgba[i][bDst] = ((p      ) & 0x1f) * bs;
2635                rgba[i][aDst] = 1.0F;
2636             }
2637          }
2638          else {
2639             const GLushort *ussrc = (const GLushort *) src;
2640             GLuint i;
2641             for (i = 0; i < n; i ++) {
2642                GLushort p = ussrc[i];
2643                rgba[i][rDst] = ((p >> 11)       ) * rs;
2644                rgba[i][gDst] = ((p >>  5) & 0x3f) * gs;
2645                rgba[i][bDst] = ((p      ) & 0x1f) * bs;
2646                rgba[i][aDst] = 1.0F;
2647             }
2648          }
2649          break;
2650       case GL_UNSIGNED_SHORT_5_6_5_REV:
2651          if (!intFormat) {
2652             rs = 1.0F / 31.0F;
2653             gs = 1.0F / 63.0F;
2654             bs = 1.0F / 31.0F;
2655          }
2656          if (swapBytes) {
2657             const GLushort *ussrc = (const GLushort *) src;
2658             GLuint i;
2659             for (i = 0; i < n; i ++) {
2660                GLushort p = ussrc[i];
2661                SWAP2BYTE(p);
2662                rgba[i][rDst] = ((p      ) & 0x1f) * rs;
2663                rgba[i][gDst] = ((p >>  5) & 0x3f) * gs;
2664                rgba[i][bDst] = ((p >> 11)       ) * bs;
2665                rgba[i][aDst] = 1.0F;
2666             }
2667          }
2668          else {
2669             const GLushort *ussrc = (const GLushort *) src;
2670             GLuint i;
2671             for (i = 0; i < n; i ++) {
2672                GLushort p = ussrc[i];
2673                rgba[i][rDst] = ((p      ) & 0x1f) * rs;
2674                rgba[i][gDst] = ((p >>  5) & 0x3f) * gs;
2675                rgba[i][bDst] = ((p >> 11)       ) * bs;
2676                rgba[i][aDst] = 1.0F;
2677             }
2678          }
2679          break;
2680       case GL_UNSIGNED_SHORT_4_4_4_4:
2681          if (!intFormat) {
2682             rs = gs = bs = as = 1.0F / 15.0F;
2683          }
2684          if (swapBytes) {
2685             const GLushort *ussrc = (const GLushort *) src;
2686             GLuint i;
2687             for (i = 0; i < n; i ++) {
2688                GLushort p = ussrc[i];
2689                SWAP2BYTE(p);
2690                rgba[i][rDst] = ((p >> 12)      ) * rs;
2691                rgba[i][gDst] = ((p >>  8) & 0xf) * gs;
2692                rgba[i][bDst] = ((p >>  4) & 0xf) * bs;
2693                rgba[i][aDst] = ((p      ) & 0xf) * as;
2694             }
2695          }
2696          else {
2697             const GLushort *ussrc = (const GLushort *) src;
2698             GLuint i;
2699             for (i = 0; i < n; i ++) {
2700                GLushort p = ussrc[i];
2701                rgba[i][rDst] = ((p >> 12)      ) * rs;
2702                rgba[i][gDst] = ((p >>  8) & 0xf) * gs;
2703                rgba[i][bDst] = ((p >>  4) & 0xf) * bs;
2704                rgba[i][aDst] = ((p      ) & 0xf) * as;
2705             }
2706          }
2707          break;
2708       case GL_UNSIGNED_SHORT_4_4_4_4_REV:
2709          if (!intFormat) {
2710             rs = gs = bs = as = 1.0F / 15.0F;
2711          }
2712          if (swapBytes) {
2713             const GLushort *ussrc = (const GLushort *) src;
2714             GLuint i;
2715             for (i = 0; i < n; i ++) {
2716                GLushort p = ussrc[i];
2717                SWAP2BYTE(p);
2718                rgba[i][rDst] = ((p      ) & 0xf) * rs;
2719                rgba[i][gDst] = ((p >>  4) & 0xf) * gs;
2720                rgba[i][bDst] = ((p >>  8) & 0xf) * bs;
2721                rgba[i][aDst] = ((p >> 12)      ) * as;
2722             }
2723          }
2724          else {
2725             const GLushort *ussrc = (const GLushort *) src;
2726             GLuint i;
2727             for (i = 0; i < n; i ++) {
2728                GLushort p = ussrc[i];
2729                rgba[i][rDst] = ((p      ) & 0xf) * rs;
2730                rgba[i][gDst] = ((p >>  4) & 0xf) * gs;
2731                rgba[i][bDst] = ((p >>  8) & 0xf) * bs;
2732                rgba[i][aDst] = ((p >> 12)      ) * as;
2733             }
2734          }
2735          break;
2736       case GL_UNSIGNED_SHORT_5_5_5_1:
2737          if (!intFormat) {
2738             rs = gs = bs = 1.0F / 31.0F;
2739          }
2740          if (swapBytes) {
2741             const GLushort *ussrc = (const GLushort *) src;
2742             GLuint i;
2743             for (i = 0; i < n; i ++) {
2744                GLushort p = ussrc[i];
2745                SWAP2BYTE(p);
2746                rgba[i][rDst] = ((p >> 11)       ) * rs;
2747                rgba[i][gDst] = ((p >>  6) & 0x1f) * gs;
2748                rgba[i][bDst] = ((p >>  1) & 0x1f) * bs;
2749                rgba[i][aDst] = ((p      ) & 0x1)  * as;
2750             }
2751          }
2752          else {
2753             const GLushort *ussrc = (const GLushort *) src;
2754             GLuint i;
2755             for (i = 0; i < n; i ++) {
2756                GLushort p = ussrc[i];
2757                rgba[i][rDst] = ((p >> 11)       ) * rs;
2758                rgba[i][gDst] = ((p >>  6) & 0x1f) * gs;
2759                rgba[i][bDst] = ((p >>  1) & 0x1f) * bs;
2760                rgba[i][aDst] = ((p      ) & 0x1)  * as;
2761             }
2762          }
2763          break;
2764       case GL_UNSIGNED_SHORT_1_5_5_5_REV:
2765          if (!intFormat) {
2766             rs = gs = bs = 1.0F / 31.0F;
2767          }
2768          if (swapBytes) {
2769             const GLushort *ussrc = (const GLushort *) src;
2770             GLuint i;
2771             for (i = 0; i < n; i ++) {
2772                GLushort p = ussrc[i];
2773                SWAP2BYTE(p);
2774                rgba[i][rDst] = ((p      ) & 0x1f) * rs;
2775                rgba[i][gDst] = ((p >>  5) & 0x1f) * gs;
2776                rgba[i][bDst] = ((p >> 10) & 0x1f) * bs;
2777                rgba[i][aDst] = ((p >> 15)       ) * as;
2778             }
2779          }
2780          else {
2781             const GLushort *ussrc = (const GLushort *) src;
2782             GLuint i;
2783             for (i = 0; i < n; i ++) {
2784                GLushort p = ussrc[i];
2785                rgba[i][rDst] = ((p      ) & 0x1f) * rs;
2786                rgba[i][gDst] = ((p >>  5) & 0x1f) * gs;
2787                rgba[i][bDst] = ((p >> 10) & 0x1f) * bs;
2788                rgba[i][aDst] = ((p >> 15)       ) * as;
2789             }
2790          }
2791          break;
2792       case GL_UNSIGNED_INT_8_8_8_8:
2793          if (swapBytes) {
2794             const GLuint *uisrc = (const GLuint *) src;
2795             GLuint i;
2796             if (intFormat) {
2797                for (i = 0; i < n; i ++) {
2798                   GLuint p = uisrc[i];
2799                   rgba[i][rDst] = (GLfloat) ((p      ) & 0xff);
2800                   rgba[i][gDst] = (GLfloat) ((p >>  8) & 0xff);
2801                   rgba[i][bDst] = (GLfloat) ((p >> 16) & 0xff);
2802                   rgba[i][aDst] = (GLfloat) ((p >> 24)       );
2803                }
2804             }
2805             else {
2806                for (i = 0; i < n; i ++) {
2807                   GLuint p = uisrc[i];
2808                   rgba[i][rDst] = UBYTE_TO_FLOAT((p      ) & 0xff);
2809                   rgba[i][gDst] = UBYTE_TO_FLOAT((p >>  8) & 0xff);
2810                   rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2811                   rgba[i][aDst] = UBYTE_TO_FLOAT((p >> 24)       );
2812                }
2813             }
2814          }
2815          else {
2816             const GLuint *uisrc = (const GLuint *) src;
2817             GLuint i;
2818             if (intFormat) {
2819                for (i = 0; i < n; i ++) {
2820                   GLuint p = uisrc[i];
2821                   rgba[i][rDst] = (GLfloat) ((p >> 24)       );
2822                   rgba[i][gDst] = (GLfloat) ((p >> 16) & 0xff);
2823                   rgba[i][bDst] = (GLfloat) ((p >>  8) & 0xff);
2824                   rgba[i][aDst] = (GLfloat) ((p      ) & 0xff);
2825                }
2826             }
2827             else {
2828                for (i = 0; i < n; i ++) {
2829                   GLuint p = uisrc[i];
2830                   rgba[i][rDst] = UBYTE_TO_FLOAT((p >> 24)       );
2831                   rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2832                   rgba[i][bDst] = UBYTE_TO_FLOAT((p >>  8) & 0xff);
2833                   rgba[i][aDst] = UBYTE_TO_FLOAT((p      ) & 0xff);
2834                }
2835             }
2836          }
2837          break;
2838       case GL_UNSIGNED_INT_8_8_8_8_REV:
2839          if (swapBytes) {
2840             const GLuint *uisrc = (const GLuint *) src;
2841             GLuint i;
2842             if (intFormat) {
2843                for (i = 0; i < n; i ++) {
2844                   GLuint p = uisrc[i];
2845                   rgba[i][rDst] = (GLfloat) ((p >> 24)       );
2846                   rgba[i][gDst] = (GLfloat) ((p >> 16) & 0xff);
2847                   rgba[i][bDst] = (GLfloat) ((p >>  8) & 0xff);
2848                   rgba[i][aDst] = (GLfloat) ((p      ) & 0xff);
2849                }
2850             }
2851             else {
2852                for (i = 0; i < n; i ++) {
2853                   GLuint p = uisrc[i];
2854                   rgba[i][rDst] = UBYTE_TO_FLOAT((p >> 24)       );
2855                   rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2856                   rgba[i][bDst] = UBYTE_TO_FLOAT((p >>  8) & 0xff);
2857                   rgba[i][aDst] = UBYTE_TO_FLOAT((p      ) & 0xff);
2858                }
2859             }
2860          }
2861          else {
2862             const GLuint *uisrc = (const GLuint *) src;
2863             GLuint i;
2864             if (intFormat) {
2865                for (i = 0; i < n; i ++) {
2866                   GLuint p = uisrc[i];
2867                   rgba[i][rDst] = (GLfloat) ((p      ) & 0xff);
2868                   rgba[i][gDst] = (GLfloat) ((p >>  8) & 0xff);
2869                   rgba[i][bDst] = (GLfloat) ((p >> 16) & 0xff);
2870                   rgba[i][aDst] = (GLfloat) ((p >> 24)       );
2871                }
2872             }
2873             else {
2874                for (i = 0; i < n; i ++) {
2875                   GLuint p = uisrc[i];
2876                   rgba[i][rDst] = UBYTE_TO_FLOAT((p      ) & 0xff);
2877                   rgba[i][gDst] = UBYTE_TO_FLOAT((p >>  8) & 0xff);
2878                   rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2879                   rgba[i][aDst] = UBYTE_TO_FLOAT((p >> 24)       );
2880                }
2881             }
2882          }
2883          break;
2884       case GL_UNSIGNED_INT_10_10_10_2:
2885          if (!intFormat) {
2886             rs = 1.0F / 1023.0F;
2887             gs = 1.0F / 1023.0F;
2888             bs = 1.0F / 1023.0F;
2889             as = 1.0F / 3.0F;
2890          }
2891          if (swapBytes) {
2892             const GLuint *uisrc = (const GLuint *) src;
2893             GLuint i;
2894             for (i = 0; i < n; i ++) {
2895                GLuint p = uisrc[i];
2896                SWAP4BYTE(p);
2897                rgba[i][rDst] = ((p >> 22)        ) * rs;
2898                rgba[i][gDst] = ((p >> 12) & 0x3ff) * gs;
2899                rgba[i][bDst] = ((p >>  2) & 0x3ff) * bs;
2900                rgba[i][aDst] = ((p      ) & 0x3  ) * as;
2901             }
2902          }
2903          else {
2904             const GLuint *uisrc = (const GLuint *) src;
2905             GLuint i;
2906             for (i = 0; i < n; i ++) {
2907                GLuint p = uisrc[i];
2908                rgba[i][rDst] = ((p >> 22)        ) * rs;
2909                rgba[i][gDst] = ((p >> 12) & 0x3ff) * gs;
2910                rgba[i][bDst] = ((p >>  2) & 0x3ff) * bs;
2911                rgba[i][aDst] = ((p      ) & 0x3  ) * as;
2912             }
2913          }
2914          break;
2915       case GL_UNSIGNED_INT_2_10_10_10_REV:
2916          if (!intFormat) {
2917             rs = 1.0F / 1023.0F;
2918             gs = 1.0F / 1023.0F;
2919             bs = 1.0F / 1023.0F;
2920             as = 1.0F / 3.0F;
2921          }
2922          if (swapBytes) {
2923             const GLuint *uisrc = (const GLuint *) src;
2924             GLuint i;
2925             for (i = 0; i < n; i ++) {
2926                GLuint p = uisrc[i];
2927                SWAP4BYTE(p);
2928                rgba[i][rDst] = ((p      ) & 0x3ff) * rs;
2929                rgba[i][gDst] = ((p >> 10) & 0x3ff) * gs;
2930                rgba[i][bDst] = ((p >> 20) & 0x3ff) * bs;
2931                rgba[i][aDst] = ((p >> 30)        ) * as;
2932             }
2933          }
2934          else {
2935             const GLuint *uisrc = (const GLuint *) src;
2936             GLuint i;
2937             for (i = 0; i < n; i ++) {
2938                GLuint p = uisrc[i];
2939                rgba[i][rDst] = ((p      ) & 0x3ff) * rs;
2940                rgba[i][gDst] = ((p >> 10) & 0x3ff) * gs;
2941                rgba[i][bDst] = ((p >> 20) & 0x3ff) * bs;
2942                rgba[i][aDst] = ((p >> 30)        ) * as;
2943             }
2944          }
2945          break;
2946       case GL_UNSIGNED_INT_5_9_9_9_REV:
2947          if (swapBytes) {
2948             const GLuint *uisrc = (const GLuint *) src;
2949             GLuint i;
2950             GLfloat f[3];
2951             for (i = 0; i < n; i ++) {
2952                GLuint p = uisrc[i];
2953                SWAP4BYTE(p);
2954                rgb9e5_to_float3(p, f);
2955                rgba[i][rDst] = f[0];
2956                rgba[i][gDst] = f[1];
2957                rgba[i][bDst] = f[2];
2958                rgba[i][aDst] = 1.0F;
2959             }
2960          }
2961          else {
2962             const GLuint *uisrc = (const GLuint *) src;
2963             GLuint i;
2964             GLfloat f[3];
2965             for (i = 0; i < n; i ++) {
2966                rgb9e5_to_float3(uisrc[i], f);
2967                rgba[i][rDst] = f[0];
2968                rgba[i][gDst] = f[1];
2969                rgba[i][bDst] = f[2];
2970                rgba[i][aDst] = 1.0F;
2971             }
2972          }
2973          break;
2974       case GL_UNSIGNED_INT_10F_11F_11F_REV:
2975          if (swapBytes) {
2976             const GLuint *uisrc = (const GLuint *) src;
2977             GLuint i;
2978             GLfloat f[3];
2979             for (i = 0; i < n; i ++) {
2980                GLuint p = uisrc[i];
2981                SWAP4BYTE(p);
2982                r11g11b10f_to_float3(p, f);
2983                rgba[i][rDst] = f[0];
2984                rgba[i][gDst] = f[1];
2985                rgba[i][bDst] = f[2];
2986                rgba[i][aDst] = 1.0F;
2987             }
2988          }
2989          else {
2990             const GLuint *uisrc = (const GLuint *) src;
2991             GLuint i;
2992             GLfloat f[3];
2993             for (i = 0; i < n; i ++) {
2994                r11g11b10f_to_float3(uisrc[i], f);
2995                rgba[i][rDst] = f[0];
2996                rgba[i][gDst] = f[1];
2997                rgba[i][bDst] = f[2];
2998                rgba[i][aDst] = 1.0F;
2999             }
3000          }
3001          break;
3002       default:
3003          _mesa_problem(NULL, "bad srcType in extract float data");
3004          break;
3005    }
3006 #undef PROCESS
3007 }
3008
3009
3010 static inline GLuint
3011 clamp_byte_to_uint(GLbyte b)
3012 {
3013    return b < 0 ? 0 : b;
3014 }
3015
3016
3017 static inline GLuint
3018 clamp_short_to_uint(GLshort s)
3019 {
3020    return s < 0 ? 0 : s;
3021 }
3022
3023
3024 static inline GLuint
3025 clamp_int_to_uint(GLint i)
3026 {
3027    return i < 0 ? 0 : i;
3028 }
3029
3030
3031 static inline GLuint
3032 clamp_float_to_uint(GLfloat f)
3033 {
3034    return f < 0.0F ? 0 : IROUND(f);
3035 }
3036
3037
3038 static inline GLuint
3039 clamp_half_to_uint(GLhalfARB h)
3040 {
3041    GLfloat f = _mesa_half_to_float(h);
3042    return f < 0.0F ? 0 : IROUND(f);
3043 }
3044
3045
3046 /**
3047  * \sa extract_float_rgba()
3048  */
3049 static void
3050 extract_uint_rgba(GLuint n, GLuint rgba[][4],
3051                   GLenum srcFormat, GLenum srcType, const GLvoid *src,
3052                   GLboolean swapBytes)
3053 {
3054    GLint rSrc, gSrc, bSrc, aSrc;
3055    GLint stride;
3056    GLint rDst, bDst, gDst, aDst;
3057
3058    ASSERT(srcFormat == GL_RED ||
3059           srcFormat == GL_GREEN ||
3060           srcFormat == GL_BLUE ||
3061           srcFormat == GL_ALPHA ||
3062           srcFormat == GL_LUMINANCE ||
3063           srcFormat == GL_LUMINANCE_ALPHA ||
3064           srcFormat == GL_INTENSITY ||
3065           srcFormat == GL_RG ||
3066           srcFormat == GL_RGB ||
3067           srcFormat == GL_BGR ||
3068           srcFormat == GL_RGBA ||
3069           srcFormat == GL_BGRA ||
3070           srcFormat == GL_ABGR_EXT ||
3071           srcFormat == GL_DU8DV8_ATI ||
3072           srcFormat == GL_DUDV_ATI ||
3073           srcFormat == GL_RED_INTEGER_EXT ||
3074           srcFormat == GL_RG_INTEGER ||
3075           srcFormat == GL_GREEN_INTEGER_EXT ||
3076           srcFormat == GL_BLUE_INTEGER_EXT ||
3077           srcFormat == GL_ALPHA_INTEGER_EXT ||
3078           srcFormat == GL_RGB_INTEGER_EXT ||
3079           srcFormat == GL_RGBA_INTEGER_EXT ||
3080           srcFormat == GL_BGR_INTEGER_EXT ||
3081           srcFormat == GL_BGRA_INTEGER_EXT ||
3082           srcFormat == GL_LUMINANCE_INTEGER_EXT ||
3083           srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);
3084
3085    ASSERT(srcType == GL_UNSIGNED_BYTE ||
3086           srcType == GL_BYTE ||
3087           srcType == GL_UNSIGNED_SHORT ||
3088           srcType == GL_SHORT ||
3089           srcType == GL_UNSIGNED_INT ||
3090           srcType == GL_INT ||
3091           srcType == GL_HALF_FLOAT_ARB ||
3092           srcType == GL_FLOAT ||
3093           srcType == GL_UNSIGNED_BYTE_3_3_2 ||
3094           srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
3095           srcType == GL_UNSIGNED_SHORT_5_6_5 ||
3096           srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
3097           srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
3098           srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
3099           srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
3100           srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
3101           srcType == GL_UNSIGNED_INT_8_8_8_8 ||
3102           srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
3103           srcType == GL_UNSIGNED_INT_10_10_10_2 ||
3104           srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
3105           srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
3106           srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
3107
3108    get_component_mapping(srcFormat,
3109                          &rSrc, &gSrc, &bSrc, &aSrc,
3110                          &rDst, &gDst, &bDst, &aDst);
3111
3112    stride = _mesa_components_in_format(srcFormat);
3113
3114 #define PROCESS(SRC_INDEX, DST_INDEX, DEFAULT, TYPE, CONVERSION)        \
3115    if ((SRC_INDEX) < 0) {                                               \
3116       GLuint i;                                                         \
3117       for (i = 0; i < n; i++) {                                         \
3118          rgba[i][DST_INDEX] = DEFAULT;                                  \
3119       }                                                                 \
3120    }                                                                    \
3121    else if (swapBytes) {                                                \
3122       const TYPE *s = (const TYPE *) src;                               \
3123       GLuint i;                                                         \
3124       for (i = 0; i < n; i++) {                                         \
3125          TYPE value = s[SRC_INDEX];                                     \
3126          if (sizeof(TYPE) == 2) {                                       \
3127             SWAP2BYTE(value);                                           \
3128          }                                                              \
3129          else if (sizeof(TYPE) == 4) {                                  \
3130             SWAP4BYTE(value);                                           \
3131          }                                                              \
3132          rgba[i][DST_INDEX] = CONVERSION(value);                        \
3133          s += stride;                                                   \
3134       }                                                                 \
3135    }                                                                    \
3136    else {                                                               \
3137       const TYPE *s = (const TYPE *) src;                               \
3138       GLuint i;                                                         \
3139       for (i = 0; i < n; i++) {                                         \
3140          rgba[i][DST_INDEX] = CONVERSION(s[SRC_INDEX]);                 \
3141          s += stride;                                                   \
3142       }                                                                 \
3143    }
3144
3145    switch (srcType) {
3146       case GL_UNSIGNED_BYTE:
3147          PROCESS(rSrc, RCOMP, 0, GLubyte, (GLuint));
3148          PROCESS(gSrc, GCOMP, 0, GLubyte, (GLuint));
3149          PROCESS(bSrc, BCOMP, 0, GLubyte, (GLuint));
3150          PROCESS(aSrc, ACOMP, 1, GLubyte, (GLuint));
3151          break;
3152       case GL_BYTE:
3153          PROCESS(rSrc, RCOMP, 0, GLbyte, clamp_byte_to_uint);
3154          PROCESS(gSrc, GCOMP, 0, GLbyte, clamp_byte_to_uint);
3155          PROCESS(bSrc, BCOMP, 0, GLbyte, clamp_byte_to_uint);
3156          PROCESS(aSrc, ACOMP, 1, GLbyte, clamp_byte_to_uint);
3157          break;
3158       case GL_UNSIGNED_SHORT:
3159          PROCESS(rSrc, RCOMP, 0, GLushort, (GLuint));
3160          PROCESS(gSrc, GCOMP, 0, GLushort, (GLuint));
3161          PROCESS(bSrc, BCOMP, 0, GLushort, (GLuint));
3162          PROCESS(aSrc, ACOMP, 1, GLushort, (GLuint));
3163          break;
3164       case GL_SHORT:
3165          PROCESS(rSrc, RCOMP, 0, GLshort, clamp_short_to_uint);
3166          PROCESS(gSrc, GCOMP, 0, GLshort, clamp_short_to_uint);
3167          PROCESS(bSrc, BCOMP, 0, GLshort, clamp_short_to_uint);
3168          PROCESS(aSrc, ACOMP, 1, GLshort, clamp_short_to_uint);
3169          break;
3170       case GL_UNSIGNED_INT:
3171          PROCESS(rSrc, RCOMP, 0, GLuint, (GLuint));
3172          PROCESS(gSrc, GCOMP, 0, GLuint, (GLuint));
3173          PROCESS(bSrc, BCOMP, 0, GLuint, (GLuint));
3174          PROCESS(aSrc, ACOMP, 1, GLuint, (GLuint));
3175          break;
3176       case GL_INT:
3177          PROCESS(rSrc, RCOMP, 0, GLint, clamp_int_to_uint);
3178          PROCESS(gSrc, GCOMP, 0, GLint, clamp_int_to_uint);
3179          PROCESS(bSrc, BCOMP, 0, GLint, clamp_int_to_uint);
3180          PROCESS(aSrc, ACOMP, 1, GLint, clamp_int_to_uint);
3181          break;
3182       case GL_FLOAT:
3183          PROCESS(rSrc, RCOMP, 0, GLfloat, clamp_float_to_uint);
3184          PROCESS(gSrc, GCOMP, 0, GLfloat, clamp_float_to_uint);
3185          PROCESS(bSrc, BCOMP, 0, GLfloat, clamp_float_to_uint);
3186          PROCESS(aSrc, ACOMP, 1, GLfloat, clamp_float_to_uint);
3187          break;
3188       case GL_HALF_FLOAT_ARB:
3189          PROCESS(rSrc, RCOMP, 0, GLhalfARB, clamp_half_to_uint);
3190          PROCESS(gSrc, GCOMP, 0, GLhalfARB, clamp_half_to_uint);
3191          PROCESS(bSrc, BCOMP, 0, GLhalfARB, clamp_half_to_uint);
3192          PROCESS(aSrc, ACOMP, 1, GLhalfARB, clamp_half_to_uint);
3193          break;
3194       case GL_UNSIGNED_BYTE_3_3_2:
3195          {
3196             const GLubyte *ubsrc = (const GLubyte *) src;
3197             GLuint i;
3198             for (i = 0; i < n; i ++) {
3199                GLubyte p = ubsrc[i];
3200                rgba[i][rDst] = ((p >> 5)      );
3201                rgba[i][gDst] = ((p >> 2) & 0x7);
3202                rgba[i][bDst] = ((p     ) & 0x3);
3203                rgba[i][aDst] = 1;
3204             }
3205          }
3206          break;
3207       case GL_UNSIGNED_BYTE_2_3_3_REV:
3208          {
3209             const GLubyte *ubsrc = (const GLubyte *) src;
3210             GLuint i;
3211             for (i = 0; i < n; i ++) {
3212                GLubyte p = ubsrc[i];
3213                rgba[i][rDst] = ((p     ) & 0x7);
3214                rgba[i][gDst] = ((p >> 3) & 0x7);
3215                rgba[i][bDst] = ((p >> 6)      );
3216                rgba[i][aDst] = 1;
3217             }
3218          }
3219          break;
3220       case GL_UNSIGNED_SHORT_5_6_5:
3221          if (swapBytes) {
3222             const GLushort *ussrc = (const GLushort *) src;
3223             GLuint i;
3224             for (i = 0; i < n; i ++) {
3225                GLushort p = ussrc[i];
3226                SWAP2BYTE(p);
3227                rgba[i][rDst] = ((p >> 11)       );
3228                rgba[i][gDst] = ((p >>  5) & 0x3f);
3229                rgba[i][bDst] = ((p      ) & 0x1f);
3230                rgba[i][aDst] = 1;
3231             }
3232          }
3233          else {
3234             const GLushort *ussrc = (const GLushort *) src;
3235             GLuint i;
3236             for (i = 0; i < n; i ++) {
3237                GLushort p = ussrc[i];
3238                rgba[i][rDst] = ((p >> 11)       );
3239                rgba[i][gDst] = ((p >>  5) & 0x3f);
3240                rgba[i][bDst] = ((p      ) & 0x1f);
3241                rgba[i][aDst] = 1;
3242             }
3243          }
3244          break;
3245       case GL_UNSIGNED_SHORT_5_6_5_REV:
3246          if (swapBytes) {
3247             const GLushort *ussrc = (const GLushort *) src;
3248             GLuint i;
3249             for (i = 0; i < n; i ++) {
3250                GLushort p = ussrc[i];
3251                SWAP2BYTE(p);
3252                rgba[i][rDst] = ((p      ) & 0x1f);
3253                rgba[i][gDst] = ((p >>  5) & 0x3f);
3254                rgba[i][bDst] = ((p >> 11)       );
3255                rgba[i][aDst] = 1;
3256             }
3257          }
3258          else {
3259             const GLushort *ussrc = (const GLushort *) src;
3260             GLuint i;
3261             for (i = 0; i < n; i ++) {
3262                GLushort p = ussrc[i];
3263                rgba[i][rDst] = ((p      ) & 0x1f);
3264                rgba[i][gDst] = ((p >>  5) & 0x3f);
3265                rgba[i][bDst] = ((p >> 11)       );
3266                rgba[i][aDst] = 1;
3267             }
3268          }
3269          break;
3270       case GL_UNSIGNED_SHORT_4_4_4_4:
3271          if (swapBytes) {
3272             const GLushort *ussrc = (const GLushort *) src;
3273             GLuint i;
3274             for (i = 0; i < n; i ++) {
3275                GLushort p = ussrc[i];
3276                SWAP2BYTE(p);
3277                rgba[i][rDst] = ((p >> 12)      );
3278                rgba[i][gDst] = ((p >>  8) & 0xf);
3279                rgba[i][bDst] = ((p >>  4) & 0xf);
3280                rgba[i][aDst] = ((p      ) & 0xf);
3281             }
3282          }
3283          else {
3284             const GLushort *ussrc = (const GLushort *) src;
3285             GLuint i;
3286             for (i = 0; i < n; i ++) {
3287                GLushort p = ussrc[i];
3288                rgba[i][rDst] = ((p >> 12)      );
3289                rgba[i][gDst] = ((p >>  8) & 0xf);
3290                rgba[i][bDst] = ((p >>  4) & 0xf);
3291                rgba[i][aDst] = ((p      ) & 0xf);
3292             }
3293          }
3294          break;
3295       case GL_UNSIGNED_SHORT_4_4_4_4_REV:
3296          if (swapBytes) {
3297             const GLushort *ussrc = (const GLushort *) src;
3298             GLuint i;
3299             for (i = 0; i < n; i ++) {
3300                GLushort p = ussrc[i];
3301                SWAP2BYTE(p);
3302                rgba[i][rDst] = ((p      ) & 0xf);
3303                rgba[i][gDst] = ((p >>  4) & 0xf);
3304                rgba[i][bDst] = ((p >>  8) & 0xf);
3305                rgba[i][aDst] = ((p >> 12)      );
3306             }
3307          }
3308          else {
3309             const GLushort *ussrc = (const GLushort *) src;
3310             GLuint i;
3311             for (i = 0; i < n; i ++) {
3312                GLushort p = ussrc[i];
3313                rgba[i][rDst] = ((p      ) & 0xf);
3314                rgba[i][gDst] = ((p >>  4) & 0xf);
3315                rgba[i][bDst] = ((p >>  8) & 0xf);
3316                rgba[i][aDst] = ((p >> 12)      );
3317             }
3318          }
3319          break;
3320       case GL_UNSIGNED_SHORT_5_5_5_1:
3321          if (swapBytes) {
3322             const GLushort *ussrc = (const GLushort *) src;
3323             GLuint i;
3324             for (i = 0; i < n; i ++) {
3325                GLushort p = ussrc[i];
3326                SWAP2BYTE(p);
3327                rgba[i][rDst] = ((p >> 11)       );
3328                rgba[i][gDst] = ((p >>  6) & 0x1f);
3329                rgba[i][bDst] = ((p >>  1) & 0x1f);
3330                rgba[i][aDst] = ((p      ) & 0x1 );
3331             }
3332          }
3333          else {
3334             const GLushort *ussrc = (const GLushort *) src;
3335             GLuint i;
3336             for (i = 0; i < n; i ++) {
3337                GLushort p = ussrc[i];
3338                rgba[i][rDst] = ((p >> 11)       );
3339                rgba[i][gDst] = ((p >>  6) & 0x1f);
3340                rgba[i][bDst] = ((p >>  1) & 0x1f);
3341                rgba[i][aDst] = ((p      ) & 0x1 );
3342             }
3343          }
3344          break;
3345       case GL_UNSIGNED_SHORT_1_5_5_5_REV:
3346          if (swapBytes) {
3347             const GLushort *ussrc = (const GLushort *) src;
3348             GLuint i;
3349             for (i = 0; i < n; i ++) {
3350                GLushort p = ussrc[i];
3351                SWAP2BYTE(p);
3352                rgba[i][rDst] = ((p      ) & 0x1f);
3353                rgba[i][gDst] = ((p >>  5) & 0x1f);
3354                rgba[i][bDst] = ((p >> 10) & 0x1f);
3355                rgba[i][aDst] = ((p >> 15)       );
3356             }
3357          }
3358          else {
3359             const GLushort *ussrc = (const GLushort *) src;
3360             GLuint i;
3361             for (i = 0; i < n; i ++) {
3362                GLushort p = ussrc[i];
3363                rgba[i][rDst] = ((p      ) & 0x1f);
3364                rgba[i][gDst] = ((p >>  5) & 0x1f);
3365                rgba[i][bDst] = ((p >> 10) & 0x1f);
3366                rgba[i][aDst] = ((p >> 15)       );
3367             }
3368          }
3369          break;
3370       case GL_UNSIGNED_INT_8_8_8_8:
3371          if (swapBytes) {
3372             const GLuint *uisrc = (const GLuint *) src;
3373             GLuint i;
3374             for (i = 0; i < n; i ++) {
3375                GLuint p = uisrc[i];
3376                rgba[i][rDst] = ((p      ) & 0xff);
3377                rgba[i][gDst] = ((p >>  8) & 0xff);
3378                rgba[i][bDst] = ((p >> 16) & 0xff);
3379                rgba[i][aDst] = ((p >> 24)       );
3380             }
3381          }
3382          else {
3383             const GLuint *uisrc = (const GLuint *) src;
3384             GLuint i;
3385             for (i = 0; i < n; i ++) {
3386                GLuint p = uisrc[i];
3387                rgba[i][rDst] = ((p >> 24)       );
3388                rgba[i][gDst] = ((p >> 16) & 0xff);
3389                rgba[i][bDst] = ((p >>  8) & 0xff);
3390                rgba[i][aDst] = ((p      ) & 0xff);
3391             }
3392          }
3393          break;
3394       case GL_UNSIGNED_INT_8_8_8_8_REV:
3395          if (swapBytes) {
3396             const GLuint *uisrc = (const GLuint *) src;
3397             GLuint i;
3398             for (i = 0; i < n; i ++) {
3399                GLuint p = uisrc[i];
3400                rgba[i][rDst] = ((p >> 24)       );
3401                rgba[i][gDst] = ((p >> 16) & 0xff);
3402                rgba[i][bDst] = ((p >>  8) & 0xff);
3403                rgba[i][aDst] = ((p      ) & 0xff);
3404             }
3405          }
3406          else {
3407             const GLuint *uisrc = (const GLuint *) src;
3408             GLuint i;
3409             for (i = 0; i < n; i ++) {
3410                GLuint p = uisrc[i];
3411                rgba[i][rDst] = ((p      ) & 0xff);
3412                rgba[i][gDst] = ((p >>  8) & 0xff);
3413                rgba[i][bDst] = ((p >> 16) & 0xff);
3414                rgba[i][aDst] = ((p >> 24)       );
3415             }
3416          }
3417          break;
3418       case GL_UNSIGNED_INT_10_10_10_2:
3419          if (swapBytes) {
3420             const GLuint *uisrc = (const GLuint *) src;
3421             GLuint i;
3422             for (i = 0; i < n; i ++) {
3423                GLuint p = uisrc[i];
3424                SWAP4BYTE(p);
3425                rgba[i][rDst] = ((p >> 22)        );
3426                rgba[i][gDst] = ((p >> 12) & 0x3ff);
3427                rgba[i][bDst] = ((p >>  2) & 0x3ff);
3428                rgba[i][aDst] = ((p      ) & 0x3  );
3429             }
3430          }
3431          else {
3432             const GLuint *uisrc = (const GLuint *) src;
3433             GLuint i;
3434             for (i = 0; i < n; i ++) {
3435                GLuint p = uisrc[i];
3436                rgba[i][rDst] = ((p >> 22)        );
3437                rgba[i][gDst] = ((p >> 12) & 0x3ff);
3438                rgba[i][bDst] = ((p >>  2) & 0x3ff);
3439                rgba[i][aDst] = ((p      ) & 0x3  );
3440             }
3441          }
3442          break;
3443       case GL_UNSIGNED_INT_2_10_10_10_REV:
3444          if (swapBytes) {
3445             const GLuint *uisrc = (const GLuint *) src;
3446             GLuint i;
3447             for (i = 0; i < n; i ++) {
3448                GLuint p = uisrc[i];
3449                SWAP4BYTE(p);
3450                rgba[i][rDst] = ((p      ) & 0x3ff);
3451                rgba[i][gDst] = ((p >> 10) & 0x3ff);
3452                rgba[i][bDst] = ((p >> 20) & 0x3ff);
3453                rgba[i][aDst] = ((p >> 30)        );
3454             }
3455          }
3456          else {
3457             const GLuint *uisrc = (const GLuint *) src;
3458             GLuint i;
3459             for (i = 0; i < n; i ++) {
3460                GLuint p = uisrc[i];
3461                rgba[i][rDst] = ((p      ) & 0x3ff);
3462                rgba[i][gDst] = ((p >> 10) & 0x3ff);
3463                rgba[i][bDst] = ((p >> 20) & 0x3ff);
3464                rgba[i][aDst] = ((p >> 30)        );
3465             }
3466          }
3467          break;
3468       case GL_UNSIGNED_INT_5_9_9_9_REV:
3469          if (swapBytes) {
3470             const GLuint *uisrc = (const GLuint *) src;
3471             GLuint i;
3472             float f[3];
3473             for (i = 0; i < n; i ++) {
3474                GLuint p = uisrc[i];
3475                SWAP4BYTE(p);
3476                rgb9e5_to_float3(p, f);
3477                rgba[i][rDst] = clamp_float_to_uint(f[0]);
3478                rgba[i][gDst] = clamp_float_to_uint(f[1]);
3479                rgba[i][bDst] = clamp_float_to_uint(f[2]);
3480                rgba[i][aDst] = 1;
3481             }
3482          }
3483          else {
3484             const GLuint *uisrc = (const GLuint *) src;
3485             GLuint i;
3486             float f[3];
3487             for (i = 0; i < n; i ++) {
3488                GLuint p = uisrc[i];
3489                rgb9e5_to_float3(p, f);
3490                rgba[i][rDst] = clamp_float_to_uint(f[0]);
3491                rgba[i][gDst] = clamp_float_to_uint(f[1]);
3492                rgba[i][bDst] = clamp_float_to_uint(f[2]);
3493                rgba[i][aDst] = 1;
3494             }
3495          }
3496          break;
3497       case GL_UNSIGNED_INT_10F_11F_11F_REV:
3498          if (swapBytes) {
3499             const GLuint *uisrc = (const GLuint *) src;
3500             GLuint i;
3501             float f[3];
3502             for (i = 0; i < n; i ++) {
3503                GLuint p = uisrc[i];
3504                SWAP4BYTE(p);
3505                r11g11b10f_to_float3(p, f);
3506                rgba[i][rDst] = clamp_float_to_uint(f[0]);
3507                rgba[i][gDst] = clamp_float_to_uint(f[1]);
3508                rgba[i][bDst] = clamp_float_to_uint(f[2]);
3509                rgba[i][aDst] = 1;
3510             }
3511          }
3512          else {
3513             const GLuint *uisrc = (const GLuint *) src;
3514             GLuint i;
3515             float f[3];
3516             for (i = 0; i < n; i ++) {
3517                GLuint p = uisrc[i];
3518                r11g11b10f_to_float3(p, f);
3519                rgba[i][rDst] = clamp_float_to_uint(f[0]);
3520                rgba[i][gDst] = clamp_float_to_uint(f[1]);
3521                rgba[i][bDst] = clamp_float_to_uint(f[2]);
3522                rgba[i][aDst] = 1;
3523             }
3524          }
3525          break;
3526       default:
3527          _mesa_problem(NULL, "bad srcType in extract uint data");
3528          break;
3529    }
3530 #undef PROCESS
3531 }
3532
3533
3534
3535 /*
3536  * Unpack a row of color image data from a client buffer according to
3537  * the pixel unpacking parameters.
3538  * Return GLubyte values in the specified dest image format.
3539  * This is used by glDrawPixels and glTexImage?D().
3540  * \param ctx - the context
3541  *         n - number of pixels in the span
3542  *         dstFormat - format of destination color array
3543  *         dest - the destination color array
3544  *         srcFormat - source image format
3545  *         srcType - source image  data type
3546  *         source - source image pointer
3547  *         srcPacking - pixel unpacking parameters
3548  *         transferOps - bitmask of IMAGE_*_BIT values of operations to apply
3549  *
3550  * XXX perhaps expand this to process whole images someday.
3551  */
3552 void
3553 _mesa_unpack_color_span_ubyte(struct gl_context *ctx,
3554                               GLuint n, GLenum dstFormat, GLubyte dest[],
3555                               GLenum srcFormat, GLenum srcType,
3556                               const GLvoid *source,
3557                               const struct gl_pixelstore_attrib *srcPacking,
3558                               GLbitfield transferOps )
3559 {
3560    GLboolean intFormat = _mesa_is_integer_format(srcFormat);
3561    ASSERT(dstFormat == GL_ALPHA ||
3562           dstFormat == GL_LUMINANCE ||
3563           dstFormat == GL_LUMINANCE_ALPHA ||
3564           dstFormat == GL_INTENSITY ||
3565           dstFormat == GL_RED ||
3566           dstFormat == GL_RG ||
3567           dstFormat == GL_RGB ||
3568           dstFormat == GL_RGBA);
3569
3570    ASSERT(srcFormat == GL_RED ||
3571           srcFormat == GL_GREEN ||
3572           srcFormat == GL_BLUE ||
3573           srcFormat == GL_ALPHA ||
3574           srcFormat == GL_LUMINANCE ||
3575           srcFormat == GL_LUMINANCE_ALPHA ||
3576           srcFormat == GL_INTENSITY ||
3577           srcFormat == GL_RG ||
3578           srcFormat == GL_RGB ||
3579           srcFormat == GL_BGR ||
3580           srcFormat == GL_RGBA ||
3581           srcFormat == GL_BGRA ||
3582           srcFormat == GL_ABGR_EXT ||
3583           srcFormat == GL_COLOR_INDEX);
3584
3585    ASSERT(srcType == GL_BITMAP ||
3586           srcType == GL_UNSIGNED_BYTE ||
3587           srcType == GL_BYTE ||
3588           srcType == GL_UNSIGNED_SHORT ||
3589           srcType == GL_SHORT ||
3590           srcType == GL_UNSIGNED_INT ||
3591           srcType == GL_INT ||
3592           srcType == GL_HALF_FLOAT_ARB ||
3593           srcType == GL_FLOAT ||
3594           srcType == GL_UNSIGNED_BYTE_3_3_2 ||
3595           srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
3596           srcType == GL_UNSIGNED_SHORT_5_6_5 ||
3597           srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
3598           srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
3599           srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
3600           srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
3601           srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
3602           srcType == GL_UNSIGNED_INT_8_8_8_8 ||
3603           srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
3604           srcType == GL_UNSIGNED_INT_10_10_10_2 ||
3605           srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
3606           srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
3607           srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
3608
3609    /* EXT_texture_integer specifies no transfer ops on integer
3610     * types in the resolved issues section. Just set them to 0
3611     * for integer surfaces.
3612     */
3613    if (intFormat)
3614       transferOps = 0;
3615
3616    /* Try simple cases first */
3617    if (transferOps == 0) {
3618       if (srcType == GL_UNSIGNED_BYTE) {
3619          if (dstFormat == GL_RGBA) {
3620             if (srcFormat == GL_RGBA) {
3621                memcpy( dest, source, n * 4 * sizeof(GLubyte) );
3622                return;
3623             }
3624             else if (srcFormat == GL_RGB) {
3625                GLuint i;
3626                const GLubyte *src = (const GLubyte *) source;
3627                GLubyte *dst = dest;
3628                for (i = 0; i < n; i++) {
3629                   dst[0] = src[0];
3630                   dst[1] = src[1];
3631                   dst[2] = src[2];
3632                   dst[3] = 255;
3633                   src += 3;
3634                   dst += 4;
3635                }
3636                return;
3637             }
3638          }
3639          else if (dstFormat == GL_RGB) {
3640             if (srcFormat == GL_RGB) {
3641                memcpy( dest, source, n * 3 * sizeof(GLubyte) );
3642                return;
3643             }
3644             else if (srcFormat == GL_RGBA) {
3645                GLuint i;
3646                const GLubyte *src = (const GLubyte *) source;
3647                GLubyte *dst = dest;
3648                for (i = 0; i < n; i++) {
3649                   dst[0] = src[0];
3650                   dst[1] = src[1];
3651                   dst[2] = src[2];
3652                   src += 4;
3653                   dst += 3;
3654                }
3655                return;
3656             }
3657          }
3658          else if (dstFormat == srcFormat) {
3659             GLint comps = _mesa_components_in_format(srcFormat);
3660             assert(comps > 0);
3661             memcpy( dest, source, n * comps * sizeof(GLubyte) );
3662             return;
3663          }
3664       }
3665    }
3666
3667
3668    /* general solution begins here */
3669    {
3670       GLint dstComponents;
3671       GLint rDst, gDst, bDst, aDst, lDst, iDst;
3672       GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));
3673
3674       if (!rgba) {
3675          _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3676          return;
3677       }
3678
3679       dstComponents = _mesa_components_in_format( dstFormat );
3680       /* source & dest image formats should have been error checked by now */
3681       assert(dstComponents > 0);
3682
3683       /*
3684        * Extract image data and convert to RGBA floats
3685        */
3686       if (srcFormat == GL_COLOR_INDEX) {
3687          GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
3688
3689          if (!indexes) {
3690             _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3691             free(rgba);
3692             return;
3693          }
3694
3695          extract_uint_indexes(n, indexes, srcFormat, srcType, source,
3696                               srcPacking);
3697
3698          /* Convert indexes to RGBA */
3699          if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
3700             _mesa_shift_and_offset_ci(ctx, n, indexes);
3701          }
3702          _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
3703
3704          /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
3705           * with color indexes.
3706           */
3707          transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT);
3708
3709          free(indexes);
3710       }
3711       else {
3712          /* non-color index data */
3713          extract_float_rgba(n, rgba, srcFormat, srcType, source,
3714                             srcPacking->SwapBytes);
3715       }
3716
3717       /* Need to clamp if returning GLubytes */
3718       transferOps |= IMAGE_CLAMP_BIT;
3719
3720       if (transferOps) {
3721          _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
3722       }
3723
3724       get_component_indexes(dstFormat,
3725                             &rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
3726
3727       /* Now return the GLubyte data in the requested dstFormat */
3728       if (rDst >= 0) {
3729          GLubyte *dst = dest;
3730          GLuint i;
3731          for (i = 0; i < n; i++) {
3732             CLAMPED_FLOAT_TO_UBYTE(dst[rDst], rgba[i][RCOMP]);
3733             dst += dstComponents;
3734          }
3735       }
3736
3737       if (gDst >= 0) {
3738          GLubyte *dst = dest;
3739          GLuint i;
3740          for (i = 0; i < n; i++) {
3741             CLAMPED_FLOAT_TO_UBYTE(dst[gDst], rgba[i][GCOMP]);
3742             dst += dstComponents;
3743          }
3744       }
3745
3746       if (bDst >= 0) {
3747          GLubyte *dst = dest;
3748          GLuint i;
3749          for (i = 0; i < n; i++) {
3750             CLAMPED_FLOAT_TO_UBYTE(dst[bDst], rgba[i][BCOMP]);
3751             dst += dstComponents;
3752          }
3753       }
3754
3755       if (aDst >= 0) {
3756          GLubyte *dst = dest;
3757          GLuint i;
3758          for (i = 0; i < n; i++) {
3759             CLAMPED_FLOAT_TO_UBYTE(dst[aDst], rgba[i][ACOMP]);
3760             dst += dstComponents;
3761          }
3762       }
3763
3764       if (iDst >= 0) {
3765          GLubyte *dst = dest;
3766          GLuint i;
3767          assert(iDst == 0);
3768          assert(dstComponents == 1);
3769          for (i = 0; i < n; i++) {
3770             /* Intensity comes from red channel */
3771             CLAMPED_FLOAT_TO_UBYTE(dst[i], rgba[i][RCOMP]);
3772          }
3773       }
3774
3775       if (lDst >= 0) {
3776          GLubyte *dst = dest;
3777          GLuint i;
3778          assert(lDst == 0);
3779          for (i = 0; i < n; i++) {
3780             /* Luminance comes from red channel */
3781             CLAMPED_FLOAT_TO_UBYTE(dst[0], rgba[i][RCOMP]);
3782             dst += dstComponents;
3783          }
3784       }
3785
3786       free(rgba);
3787    }
3788 }
3789
3790
3791 /**
3792  * Same as _mesa_unpack_color_span_ubyte(), but return GLfloat data
3793  * instead of GLubyte.
3794  */
3795 void
3796 _mesa_unpack_color_span_float( struct gl_context *ctx,
3797                                GLuint n, GLenum dstFormat, GLfloat dest[],
3798                                GLenum srcFormat, GLenum srcType,
3799                                const GLvoid *source,
3800                                const struct gl_pixelstore_attrib *srcPacking,
3801                                GLbitfield transferOps )
3802 {
3803    ASSERT(dstFormat == GL_ALPHA ||
3804           dstFormat == GL_LUMINANCE ||
3805           dstFormat == GL_LUMINANCE_ALPHA ||
3806           dstFormat == GL_INTENSITY ||
3807           dstFormat == GL_RED ||
3808           dstFormat == GL_RG ||
3809           dstFormat == GL_RGB ||
3810           dstFormat == GL_RGBA);
3811
3812    ASSERT(srcFormat == GL_RED ||
3813           srcFormat == GL_GREEN ||
3814           srcFormat == GL_BLUE ||
3815           srcFormat == GL_ALPHA ||
3816           srcFormat == GL_LUMINANCE ||
3817           srcFormat == GL_LUMINANCE_ALPHA ||
3818           srcFormat == GL_INTENSITY ||
3819           srcFormat == GL_RG ||
3820           srcFormat == GL_RGB ||
3821           srcFormat == GL_BGR ||
3822           srcFormat == GL_RGBA ||
3823           srcFormat == GL_BGRA ||
3824           srcFormat == GL_ABGR_EXT ||
3825           srcFormat == GL_RED_INTEGER_EXT ||
3826           srcFormat == GL_GREEN_INTEGER_EXT ||
3827           srcFormat == GL_BLUE_INTEGER_EXT ||
3828           srcFormat == GL_ALPHA_INTEGER_EXT ||
3829           srcFormat == GL_RG_INTEGER ||
3830           srcFormat == GL_RGB_INTEGER_EXT ||
3831           srcFormat == GL_RGBA_INTEGER_EXT ||
3832           srcFormat == GL_BGR_INTEGER_EXT ||
3833           srcFormat == GL_BGRA_INTEGER_EXT ||
3834           srcFormat == GL_LUMINANCE_INTEGER_EXT ||
3835           srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT ||
3836           srcFormat == GL_COLOR_INDEX);
3837
3838    ASSERT(srcType == GL_BITMAP ||
3839           srcType == GL_UNSIGNED_BYTE ||
3840           srcType == GL_BYTE ||
3841           srcType == GL_UNSIGNED_SHORT ||
3842           srcType == GL_SHORT ||
3843           srcType == GL_UNSIGNED_INT ||
3844           srcType == GL_INT ||
3845           srcType == GL_HALF_FLOAT_ARB ||
3846           srcType == GL_FLOAT ||
3847           srcType == GL_UNSIGNED_BYTE_3_3_2 ||
3848           srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
3849           srcType == GL_UNSIGNED_SHORT_5_6_5 ||
3850           srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
3851           srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
3852           srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
3853           srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
3854           srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
3855           srcType == GL_UNSIGNED_INT_8_8_8_8 ||
3856           srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
3857           srcType == GL_UNSIGNED_INT_10_10_10_2 ||
3858           srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
3859           srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
3860           srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
3861
3862    /* general solution, no special cases, yet */
3863    {
3864       GLint dstComponents;
3865       GLint rDst, gDst, bDst, aDst, lDst, iDst;
3866       GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));
3867       GLboolean intFormat = _mesa_is_integer_format(srcFormat);
3868
3869       if (!rgba) {
3870          _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3871          return;
3872       }
3873
3874       dstComponents = _mesa_components_in_format( dstFormat );
3875       /* source & dest image formats should have been error checked by now */
3876       assert(dstComponents > 0);
3877
3878       /* EXT_texture_integer specifies no transfer ops on integer
3879        * types in the resolved issues section. Just set them to 0
3880        * for integer surfaces.
3881        */
3882       if (intFormat)
3883          transferOps = 0;
3884
3885       /*
3886        * Extract image data and convert to RGBA floats
3887        */
3888       if (srcFormat == GL_COLOR_INDEX) {
3889          GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
3890
3891          if (!indexes) {
3892             _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3893             free(rgba);
3894             return;
3895          }
3896
3897          extract_uint_indexes(n, indexes, srcFormat, srcType, source,
3898                               srcPacking);
3899
3900          /* Convert indexes to RGBA */
3901          if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
3902             _mesa_shift_and_offset_ci(ctx, n, indexes);
3903          }
3904          _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
3905
3906          /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
3907           * with color indexes.
3908           */
3909          transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT);
3910
3911          free(indexes);
3912       }
3913       else {
3914          /* non-color index data */
3915          extract_float_rgba(n, rgba, srcFormat, srcType, source,
3916                             srcPacking->SwapBytes);
3917       }
3918
3919       if (transferOps) {
3920          _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
3921       }
3922
3923       get_component_indexes(dstFormat,
3924                             &rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
3925
3926       /* Now pack results in the requested dstFormat */
3927       if (rDst >= 0) {
3928          GLfloat *dst = dest;
3929          GLuint i;
3930          for (i = 0; i < n; i++) {
3931             dst[rDst] = rgba[i][RCOMP];
3932             dst += dstComponents;
3933          }
3934       }
3935
3936       if (gDst >= 0) {
3937          GLfloat *dst = dest;
3938          GLuint i;
3939          for (i = 0; i < n; i++) {
3940             dst[gDst] = rgba[i][GCOMP];
3941             dst += dstComponents;
3942          }
3943       }
3944
3945       if (bDst >= 0) {
3946          GLfloat *dst = dest;
3947          GLuint i;
3948          for (i = 0; i < n; i++) {
3949             dst[bDst] = rgba[i][BCOMP];
3950             dst += dstComponents;
3951          }
3952       }
3953
3954       if (aDst >= 0) {
3955          GLfloat *dst = dest;
3956          GLuint i;
3957          for (i = 0; i < n; i++) {
3958             dst[aDst] = rgba[i][ACOMP];
3959             dst += dstComponents;
3960          }
3961       }
3962
3963       if (iDst >= 0) {
3964          GLfloat *dst = dest;
3965          GLuint i;
3966          assert(iDst == 0);
3967          assert(dstComponents == 1);
3968          for (i = 0; i < n; i++) {
3969             /* Intensity comes from red channel */
3970             dst[i] = rgba[i][RCOMP];
3971          }
3972       }
3973
3974       if (lDst >= 0) {
3975          GLfloat *dst = dest;
3976          GLuint i;
3977          assert(lDst == 0);
3978          for (i = 0; i < n; i++) {
3979             /* Luminance comes from red channel */
3980             dst[0] = rgba[i][RCOMP];
3981             dst += dstComponents;
3982          }
3983       }
3984
3985       free(rgba);
3986    }
3987 }
3988
3989
3990 /**
3991  * Same as _mesa_unpack_color_span_ubyte(), but return GLuint data
3992  * instead of GLubyte.
3993  * No pixel transfer ops are applied.
3994  */
3995 void
3996 _mesa_unpack_color_span_uint(struct gl_context *ctx,
3997                              GLuint n, GLenum dstFormat, GLuint *dest,
3998                              GLenum srcFormat, GLenum srcType,
3999                              const GLvoid *source,
4000                              const struct gl_pixelstore_attrib *srcPacking)
4001 {
4002    GLuint (*rgba)[4] = (GLuint (*)[4]) malloc(n * 4 * sizeof(GLfloat));
4003
4004    if (!rgba) {
4005       _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
4006       return;
4007    }
4008
4009    ASSERT(dstFormat == GL_ALPHA ||
4010           dstFormat == GL_LUMINANCE ||
4011           dstFormat == GL_LUMINANCE_ALPHA ||
4012           dstFormat == GL_INTENSITY ||
4013           dstFormat == GL_RED ||
4014           dstFormat == GL_RG ||
4015           dstFormat == GL_RGB ||
4016           dstFormat == GL_RGBA);
4017
4018    ASSERT(srcFormat == GL_RED ||
4019           srcFormat == GL_GREEN ||
4020           srcFormat == GL_BLUE ||
4021           srcFormat == GL_ALPHA ||
4022           srcFormat == GL_LUMINANCE ||
4023           srcFormat == GL_LUMINANCE_ALPHA ||
4024           srcFormat == GL_INTENSITY ||
4025           srcFormat == GL_RG ||
4026           srcFormat == GL_RGB ||
4027           srcFormat == GL_BGR ||
4028           srcFormat == GL_RGBA ||
4029           srcFormat == GL_BGRA ||
4030           srcFormat == GL_ABGR_EXT ||
4031           srcFormat == GL_RED_INTEGER_EXT ||
4032           srcFormat == GL_GREEN_INTEGER_EXT ||
4033           srcFormat == GL_BLUE_INTEGER_EXT ||
4034           srcFormat == GL_ALPHA_INTEGER_EXT ||
4035           srcFormat == GL_RG_INTEGER ||
4036           srcFormat == GL_RGB_INTEGER_EXT ||
4037           srcFormat == GL_RGBA_INTEGER_EXT ||
4038           srcFormat == GL_BGR_INTEGER_EXT ||
4039           srcFormat == GL_BGRA_INTEGER_EXT ||
4040           srcFormat == GL_LUMINANCE_INTEGER_EXT ||
4041           srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);
4042
4043    ASSERT(srcType == GL_UNSIGNED_BYTE ||
4044           srcType == GL_BYTE ||
4045           srcType == GL_UNSIGNED_SHORT ||
4046           srcType == GL_SHORT ||
4047           srcType == GL_UNSIGNED_INT ||
4048           srcType == GL_INT ||
4049           srcType == GL_HALF_FLOAT_ARB ||
4050           srcType == GL_FLOAT ||
4051           srcType == GL_UNSIGNED_BYTE_3_3_2 ||
4052           srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
4053           srcType == GL_UNSIGNED_SHORT_5_6_5 ||
4054           srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
4055           srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
4056           srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
4057           srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
4058           srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
4059           srcType == GL_UNSIGNED_INT_8_8_8_8 ||
4060           srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
4061           srcType == GL_UNSIGNED_INT_10_10_10_2 ||
4062           srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
4063           srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
4064           srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
4065
4066
4067    /* Extract image data as uint[4] pixels */
4068    extract_uint_rgba(n, rgba, srcFormat, srcType, source,
4069                      srcPacking->SwapBytes);
4070
4071    if (dstFormat == GL_RGBA) {
4072       /* simple case */
4073       memcpy(dest, rgba, 4 * sizeof(GLuint) * n);
4074    }
4075    else {
4076       /* general case */
4077       GLint rDst, gDst, bDst, aDst, lDst, iDst;
4078       GLint dstComponents = _mesa_components_in_format( dstFormat );
4079
4080       assert(dstComponents > 0);
4081
4082       get_component_indexes(dstFormat,
4083                             &rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
4084
4085       /* Now pack values in the requested dest format */
4086       if (rDst >= 0) {
4087          GLuint *dst = dest;
4088          GLuint i;
4089          for (i = 0; i < n; i++) {
4090             dst[rDst] = rgba[i][RCOMP];
4091             dst += dstComponents;
4092          }
4093       }
4094
4095       if (gDst >= 0) {
4096          GLuint *dst = dest;
4097          GLuint i;
4098          for (i = 0; i < n; i++) {
4099             dst[gDst] = rgba[i][GCOMP];
4100             dst += dstComponents;
4101          }
4102       }
4103
4104       if (bDst >= 0) {
4105          GLuint *dst = dest;
4106          GLuint i;
4107          for (i = 0; i < n; i++) {
4108             dst[bDst] = rgba[i][BCOMP];
4109             dst += dstComponents;
4110          }
4111       }
4112
4113       if (aDst >= 0) {
4114          GLuint *dst = dest;
4115          GLuint i;
4116          for (i = 0; i < n; i++) {
4117             dst[aDst] = rgba[i][ACOMP];
4118             dst += dstComponents;
4119          }
4120       }
4121
4122       if (iDst >= 0) {
4123          GLuint *dst = dest;
4124          GLuint i;
4125          assert(iDst == 0);
4126          assert(dstComponents == 1);
4127          for (i = 0; i < n; i++) {
4128             /* Intensity comes from red channel */
4129             dst[i] = rgba[i][RCOMP];
4130          }
4131       }
4132
4133       if (lDst >= 0) {
4134          GLuint *dst = dest;
4135          GLuint i;
4136          assert(lDst == 0);
4137          for (i = 0; i < n; i++) {
4138             /* Luminance comes from red channel */
4139             dst[0] = rgba[i][RCOMP];
4140             dst += dstComponents;
4141          }
4142       }
4143    }
4144
4145    free(rgba);
4146 }
4147
4148
4149
4150 /**
4151  * Similar to _mesa_unpack_color_span_float(), but for dudv data instead of rgba,
4152  * directly return GLbyte data, no transfer ops apply.
4153  */
4154 void
4155 _mesa_unpack_dudv_span_byte( struct gl_context *ctx,
4156                              GLuint n, GLenum dstFormat, GLbyte dest[],
4157                              GLenum srcFormat, GLenum srcType,
4158                              const GLvoid *source,
4159                              const struct gl_pixelstore_attrib *srcPacking,
4160                              GLbitfield transferOps )
4161 {
4162    ASSERT(dstFormat == GL_DUDV_ATI);
4163    ASSERT(srcFormat == GL_DUDV_ATI ||
4164           srcFormat == GL_DU8DV8_ATI);
4165
4166    ASSERT(srcType == GL_UNSIGNED_BYTE ||
4167           srcType == GL_BYTE ||
4168           srcType == GL_UNSIGNED_SHORT ||
4169           srcType == GL_SHORT ||
4170           srcType == GL_UNSIGNED_INT ||
4171           srcType == GL_INT ||
4172           srcType == GL_HALF_FLOAT_ARB ||
4173           srcType == GL_FLOAT);
4174
4175    /* general solution */
4176    {
4177       GLint dstComponents;
4178       GLbyte *dst = dest;
4179       GLuint i;
4180       GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));
4181
4182       if (!rgba) {
4183          _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
4184          return;
4185       }
4186
4187       dstComponents = _mesa_components_in_format( dstFormat );
4188       /* source & dest image formats should have been error checked by now */
4189       assert(dstComponents > 0);
4190
4191       /*
4192        * Extract image data and convert to RGBA floats
4193        */
4194       extract_float_rgba(n, rgba, srcFormat, srcType, source,
4195                          srcPacking->SwapBytes);
4196
4197
4198       /* Now determine which color channels we need to produce.
4199        * And determine the dest index (offset) within each color tuple.
4200        */
4201
4202       /* Now pack results in the requested dstFormat */
4203       for (i = 0; i < n; i++) {
4204          /* not sure - need clamp[-1,1] here? */
4205          dst[0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
4206          dst[1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
4207          dst += dstComponents;
4208       }
4209
4210       free(rgba);
4211    }
4212 }
4213
4214 /*
4215  * Unpack a row of color index data from a client buffer according to
4216  * the pixel unpacking parameters.
4217  * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.
4218  *
4219  * Args:  ctx - the context
4220  *        n - number of pixels
4221  *        dstType - destination data type
4222  *        dest - destination array
4223  *        srcType - source pixel type
4224  *        source - source data pointer
4225  *        srcPacking - pixel unpacking parameters
4226  *        transferOps - the pixel transfer operations to apply
4227  */
4228 void
4229 _mesa_unpack_index_span( struct gl_context *ctx, GLuint n,
4230                          GLenum dstType, GLvoid *dest,
4231                          GLenum srcType, const GLvoid *source,
4232                          const struct gl_pixelstore_attrib *srcPacking,
4233                          GLbitfield transferOps )
4234 {
4235    ASSERT(srcType == GL_BITMAP ||
4236           srcType == GL_UNSIGNED_BYTE ||
4237           srcType == GL_BYTE ||
4238           srcType == GL_UNSIGNED_SHORT ||
4239           srcType == GL_SHORT ||
4240           srcType == GL_UNSIGNED_INT ||
4241           srcType == GL_INT ||
4242           srcType == GL_HALF_FLOAT_ARB ||
4243           srcType == GL_FLOAT);
4244
4245    ASSERT(dstType == GL_UNSIGNED_BYTE ||
4246           dstType == GL_UNSIGNED_SHORT ||
4247           dstType == GL_UNSIGNED_INT);
4248
4249
4250    transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
4251
4252    /*
4253     * Try simple cases first
4254     */
4255    if (transferOps == 0 && srcType == GL_UNSIGNED_BYTE
4256        && dstType == GL_UNSIGNED_BYTE) {
4257       memcpy(dest, source, n * sizeof(GLubyte));
4258    }
4259    else if (transferOps == 0 && srcType == GL_UNSIGNED_INT
4260             && dstType == GL_UNSIGNED_INT && !srcPacking->SwapBytes) {
4261       memcpy(dest, source, n * sizeof(GLuint));
4262    }
4263    else {
4264       /*
4265        * general solution
4266        */
4267       GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
4268
4269       if (!indexes) {
4270          _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
4271          return;
4272       }
4273
4274       extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
4275                            srcPacking);
4276
4277       if (transferOps)
4278          _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
4279
4280       /* convert to dest type */
4281       switch (dstType) {
4282          case GL_UNSIGNED_BYTE:
4283             {
4284                GLubyte *dst = (GLubyte *) dest;
4285                GLuint i;
4286                for (i = 0; i < n; i++) {
4287                   dst[i] = (GLubyte) (indexes[i] & 0xff);
4288                }
4289             }
4290             break;
4291          case GL_UNSIGNED_SHORT:
4292             {
4293                GLuint *dst = (GLuint *) dest;
4294                GLuint i;
4295                for (i = 0; i < n; i++) {
4296                   dst[i] = (GLushort) (indexes[i] & 0xffff);
4297                }
4298             }
4299             break;
4300          case GL_UNSIGNED_INT:
4301             memcpy(dest, indexes, n * sizeof(GLuint));
4302             break;
4303          default:
4304             _mesa_problem(ctx, "bad dstType in _mesa_unpack_index_span");
4305       }
4306
4307       free(indexes);
4308    }
4309 }
4310
4311
4312 void
4313 _mesa_pack_index_span( struct gl_context *ctx, GLuint n,
4314                        GLenum dstType, GLvoid *dest, const GLuint *source,
4315                        const struct gl_pixelstore_attrib *dstPacking,
4316                        GLbitfield transferOps )
4317 {
4318    GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
4319
4320    if (!indexes) {
4321       _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
4322       return;
4323    }
4324
4325    transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
4326
4327    if (transferOps & (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT)) {
4328       /* make a copy of input */
4329       memcpy(indexes, source, n * sizeof(GLuint));
4330       _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
4331       source = indexes;
4332    }
4333
4334    switch (dstType) {
4335    case GL_UNSIGNED_BYTE:
4336       {
4337          GLubyte *dst = (GLubyte *) dest;
4338          GLuint i;
4339          for (i = 0; i < n; i++) {
4340             *dst++ = (GLubyte) source[i];
4341          }
4342       }
4343       break;
4344    case GL_BYTE:
4345       {
4346          GLbyte *dst = (GLbyte *) dest;
4347          GLuint i;
4348          for (i = 0; i < n; i++) {
4349             dst[i] = (GLbyte) source[i];
4350          }
4351       }
4352       break;
4353    case GL_UNSIGNED_SHORT:
4354       {
4355          GLushort *dst = (GLushort *) dest;
4356          GLuint i;
4357          for (i = 0; i < n; i++) {
4358             dst[i] = (GLushort) source[i];
4359          }
4360          if (dstPacking->SwapBytes) {
4361             _mesa_swap2( (GLushort *) dst, n );
4362          }
4363       }
4364       break;
4365    case GL_SHORT:
4366       {
4367          GLshort *dst = (GLshort *) dest;
4368          GLuint i;
4369          for (i = 0; i < n; i++) {
4370             dst[i] = (GLshort) source[i];
4371          }
4372          if (dstPacking->SwapBytes) {
4373             _mesa_swap2( (GLushort *) dst, n );
4374          }
4375       }
4376       break;
4377    case GL_UNSIGNED_INT:
4378       {
4379          GLuint *dst = (GLuint *) dest;
4380          GLuint i;
4381          for (i = 0; i < n; i++) {
4382             dst[i] = (GLuint) source[i];
4383          }
4384          if (dstPacking->SwapBytes) {
4385             _mesa_swap4( (GLuint *) dst, n );
4386          }
4387       }
4388       break;
4389    case GL_INT:
4390       {
4391          GLint *dst = (GLint *) dest;
4392          GLuint i;
4393          for (i = 0; i < n; i++) {
4394             dst[i] = (GLint) source[i];
4395          }
4396          if (dstPacking->SwapBytes) {
4397             _mesa_swap4( (GLuint *) dst, n );
4398          }
4399       }
4400       break;
4401    case GL_FLOAT:
4402       {
4403          GLfloat *dst = (GLfloat *) dest;
4404          GLuint i;
4405          for (i = 0; i < n; i++) {
4406             dst[i] = (GLfloat) source[i];
4407          }
4408          if (dstPacking->SwapBytes) {
4409             _mesa_swap4( (GLuint *) dst, n );
4410          }
4411       }
4412       break;
4413    case GL_HALF_FLOAT_ARB:
4414       {
4415          GLhalfARB *dst = (GLhalfARB *) dest;
4416          GLuint i;
4417          for (i = 0; i < n; i++) {
4418             dst[i] = _mesa_float_to_half((GLfloat) source[i]);
4419          }
4420          if (dstPacking->SwapBytes) {
4421             _mesa_swap2( (GLushort *) dst, n );
4422          }
4423       }
4424       break;
4425    default:
4426       _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
4427    }
4428
4429    free(indexes);
4430 }
4431
4432
4433 /*
4434  * Unpack a row of stencil data from a client buffer according to
4435  * the pixel unpacking parameters.
4436  * This is (or will be) used by glDrawPixels
4437  *
4438  * Args:  ctx - the context
4439  *        n - number of pixels
4440  *        dstType - destination data type
4441  *        dest - destination array
4442  *        srcType - source pixel type
4443  *        source - source data pointer
4444  *        srcPacking - pixel unpacking parameters
4445  *        transferOps - apply offset/bias/lookup ops?
4446  */
4447 void
4448 _mesa_unpack_stencil_span( struct gl_context *ctx, GLuint n,
4449                            GLenum dstType, GLvoid *dest,
4450                            GLenum srcType, const GLvoid *source,
4451                            const struct gl_pixelstore_attrib *srcPacking,
4452                            GLbitfield transferOps )
4453 {
4454    ASSERT(srcType == GL_BITMAP ||
4455           srcType == GL_UNSIGNED_BYTE ||
4456           srcType == GL_BYTE ||
4457           srcType == GL_UNSIGNED_SHORT ||
4458           srcType == GL_SHORT ||
4459           srcType == GL_UNSIGNED_INT ||
4460           srcType == GL_INT ||
4461           srcType == GL_UNSIGNED_INT_24_8_EXT ||
4462           srcType == GL_HALF_FLOAT_ARB ||
4463           srcType == GL_FLOAT ||
4464           srcType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
4465
4466    ASSERT(dstType == GL_UNSIGNED_BYTE ||
4467           dstType == GL_UNSIGNED_SHORT ||
4468           dstType == GL_UNSIGNED_INT ||
4469           dstType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
4470
4471    /* only shift and offset apply to stencil */
4472    transferOps &= IMAGE_SHIFT_OFFSET_BIT;
4473
4474    /*
4475     * Try simple cases first
4476     */
4477    if (transferOps == 0 &&
4478        !ctx->Pixel.MapStencilFlag &&
4479        srcType == GL_UNSIGNED_BYTE &&
4480        dstType == GL_UNSIGNED_BYTE) {
4481       memcpy(dest, source, n * sizeof(GLubyte));
4482    }
4483    else if (transferOps == 0 &&
4484             !ctx->Pixel.MapStencilFlag &&
4485             srcType == GL_UNSIGNED_INT &&
4486             dstType == GL_UNSIGNED_INT &&
4487             !srcPacking->SwapBytes) {
4488       memcpy(dest, source, n * sizeof(GLuint));
4489    }
4490    else {
4491       /*
4492        * general solution
4493        */
4494       GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
4495
4496       if (!indexes) {
4497          _mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil unpacking");
4498          return;
4499       }
4500
4501       extract_uint_indexes(n, indexes, GL_STENCIL_INDEX, srcType, source,
4502                            srcPacking);
4503
4504       if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
4505          /* shift and offset indexes */
4506          _mesa_shift_and_offset_ci(ctx, n, indexes);
4507       }
4508
4509       if (ctx->Pixel.MapStencilFlag) {
4510          /* Apply stencil lookup table */
4511          const GLuint mask = ctx->PixelMaps.StoS.Size - 1;
4512          GLuint i;
4513          for (i = 0; i < n; i++) {
4514             indexes[i] = (GLuint)ctx->PixelMaps.StoS.Map[ indexes[i] & mask ];
4515          }
4516       }
4517
4518       /* convert to dest type */
4519       switch (dstType) {
4520          case GL_UNSIGNED_BYTE:
4521             {
4522                GLubyte *dst = (GLubyte *) dest;
4523                GLuint i;
4524                for (i = 0; i < n; i++) {
4525                   dst[i] = (GLubyte) (indexes[i] & 0xff);
4526                }
4527             }
4528             break;
4529          case GL_UNSIGNED_SHORT:
4530             {
4531                GLuint *dst = (GLuint *) dest;
4532                GLuint i;
4533                for (i = 0; i < n; i++) {
4534                   dst[i] = (GLushort) (indexes[i] & 0xffff);
4535                }
4536             }
4537             break;
4538          case GL_UNSIGNED_INT:
4539             memcpy(dest, indexes, n * sizeof(GLuint));
4540             break;
4541          case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
4542             {
4543                GLuint *dst = (GLuint *) dest;
4544                GLuint i;
4545                for (i = 0; i < n; i++) {
4546                   dst[i*2+1] = indexes[i] & 0xff; /* lower 8 bits */
4547                }
4548             }
4549             break;
4550          default:
4551             _mesa_problem(ctx, "bad dstType in _mesa_unpack_stencil_span");
4552       }
4553
4554       free(indexes);
4555    }
4556 }
4557
4558
4559 void
4560 _mesa_pack_stencil_span( struct gl_context *ctx, GLuint n,
4561                          GLenum dstType, GLvoid *dest, const GLubyte *source,
4562                          const struct gl_pixelstore_attrib *dstPacking )
4563 {
4564    GLubyte *stencil = (GLubyte *) malloc(n * sizeof(GLubyte));
4565
4566    if (!stencil) {
4567       _mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil packing");
4568       return;
4569    }
4570
4571    if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset ||
4572        ctx->Pixel.MapStencilFlag) {
4573       /* make a copy of input */
4574       memcpy(stencil, source, n * sizeof(GLubyte));
4575       _mesa_apply_stencil_transfer_ops(ctx, n, stencil);
4576       source = stencil;
4577    }
4578
4579    switch (dstType) {
4580    case GL_UNSIGNED_BYTE:
4581       memcpy(dest, source, n);
4582       break;
4583    case GL_BYTE:
4584       {
4585          GLbyte *dst = (GLbyte *) dest;
4586          GLuint i;
4587          for (i=0;i<n;i++) {
4588             dst[i] = (GLbyte) (source[i] & 0x7f);
4589          }
4590       }
4591       break;
4592    case GL_UNSIGNED_SHORT:
4593       {
4594          GLushort *dst = (GLushort *) dest;
4595          GLuint i;
4596          for (i=0;i<n;i++) {
4597             dst[i] = (GLushort) source[i];
4598          }
4599          if (dstPacking->SwapBytes) {
4600             _mesa_swap2( (GLushort *) dst, n );
4601          }
4602       }
4603       break;
4604    case GL_SHORT:
4605       {
4606          GLshort *dst = (GLshort *) dest;
4607          GLuint i;
4608          for (i=0;i<n;i++) {
4609             dst[i] = (GLshort) source[i];
4610          }
4611          if (dstPacking->SwapBytes) {
4612             _mesa_swap2( (GLushort *) dst, n );
4613          }
4614       }
4615       break;
4616    case GL_UNSIGNED_INT:
4617       {
4618          GLuint *dst = (GLuint *) dest;
4619          GLuint i;
4620          for (i=0;i<n;i++) {
4621             dst[i] = (GLuint) source[i];
4622          }
4623          if (dstPacking->SwapBytes) {
4624             _mesa_swap4( (GLuint *) dst, n );
4625          }
4626       }
4627       break;
4628    case GL_INT:
4629       {
4630          GLint *dst = (GLint *) dest;
4631          GLuint i;
4632          for (i=0;i<n;i++) {
4633             dst[i] = (GLint) source[i];
4634          }
4635          if (dstPacking->SwapBytes) {
4636             _mesa_swap4( (GLuint *) dst, n );
4637          }
4638       }
4639       break;
4640    case GL_FLOAT:
4641       {
4642          GLfloat *dst = (GLfloat *) dest;
4643          GLuint i;
4644          for (i=0;i<n;i++) {
4645             dst[i] = (GLfloat) source[i];
4646          }
4647          if (dstPacking->SwapBytes) {
4648             _mesa_swap4( (GLuint *) dst, n );
4649          }
4650       }
4651       break;
4652    case GL_HALF_FLOAT_ARB:
4653       {
4654          GLhalfARB *dst = (GLhalfARB *) dest;
4655          GLuint i;
4656          for (i=0;i<n;i++) {
4657             dst[i] = _mesa_float_to_half( (float) source[i] );
4658          }
4659          if (dstPacking->SwapBytes) {
4660             _mesa_swap2( (GLushort *) dst, n );
4661          }
4662       }
4663       break;
4664    case GL_BITMAP:
4665       if (dstPacking->LsbFirst) {
4666          GLubyte *dst = (GLubyte *) dest;
4667          GLint shift = 0;
4668          GLuint i;
4669          for (i = 0; i < n; i++) {
4670             if (shift == 0)
4671                *dst = 0;
4672             *dst |= ((source[i] != 0) << shift);
4673             shift++;
4674             if (shift == 8) {
4675                shift = 0;
4676                dst++;
4677             }
4678          }
4679       }
4680       else {
4681          GLubyte *dst = (GLubyte *) dest;
4682          GLint shift = 7;
4683          GLuint i;
4684          for (i = 0; i < n; i++) {
4685             if (shift == 7)
4686                *dst = 0;
4687             *dst |= ((source[i] != 0) << shift);
4688             shift--;
4689             if (shift < 0) {
4690                shift = 7;
4691                dst++;
4692             }
4693          }
4694       }
4695       break;
4696    default:
4697       _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
4698    }
4699
4700    free(stencil);
4701 }
4702
4703 #define DEPTH_VALUES(GLTYPE, GLTYPE2FLOAT)                              \
4704     do {                                                                \
4705         GLuint i;                                                       \
4706         const GLTYPE *src = (const GLTYPE *)source;                     \
4707         for (i = 0; i < n; i++) {                                       \
4708             GLTYPE value = src[i];                                      \
4709             if (srcPacking->SwapBytes) {                                \
4710                 if (sizeof(GLTYPE) == 2) {                              \
4711                     SWAP2BYTE(value);                                   \
4712                 } else if (sizeof(GLTYPE) == 4) {                       \
4713                     SWAP4BYTE(value);                                   \
4714                 }                                                       \
4715             }                                                           \
4716             depthValues[i] = GLTYPE2FLOAT(value);                       \
4717         }                                                               \
4718     } while (0)
4719
4720
4721 /**
4722  * Unpack a row of depth/z values from memory, returning GLushort, GLuint
4723  * or GLfloat values.
4724  * The glPixelTransfer (scale/bias) params will be applied.
4725  *
4726  * \param dstType  one of GL_UNSIGNED_SHORT, GL_UNSIGNED_INT, GL_FLOAT
4727  * \param depthMax  max value for returned GLushort or GLuint values
4728  *                  (ignored for GLfloat).
4729  */
4730 void
4731 _mesa_unpack_depth_span( struct gl_context *ctx, GLuint n,
4732                          GLenum dstType, GLvoid *dest, GLuint depthMax,
4733                          GLenum srcType, const GLvoid *source,
4734                          const struct gl_pixelstore_attrib *srcPacking )
4735 {
4736    GLfloat *depthTemp = NULL, *depthValues;
4737    GLboolean needClamp = GL_FALSE;
4738
4739    /* Look for special cases first.
4740     * Not only are these faster, they're less prone to numeric conversion
4741     * problems.  Otherwise, converting from an int type to a float then
4742     * back to an int type can introduce errors that will show up as
4743     * artifacts in things like depth peeling which uses glCopyTexImage.
4744     */
4745    if (ctx->Pixel.DepthScale == 1.0 && ctx->Pixel.DepthBias == 0.0) {
4746       if (srcType == GL_UNSIGNED_INT && dstType == GL_UNSIGNED_SHORT) {
4747          const GLuint *src = (const GLuint *) source;
4748          GLushort *dst = (GLushort *) dest;
4749          GLuint i;
4750          for (i = 0; i < n; i++) {
4751             dst[i] = src[i] >> 16;
4752          }
4753          return;
4754       }
4755       if (srcType == GL_UNSIGNED_SHORT
4756           && dstType == GL_UNSIGNED_INT
4757           && depthMax == 0xffffffff) {
4758          const GLushort *src = (const GLushort *) source;
4759          GLuint *dst = (GLuint *) dest;
4760          GLuint i;
4761          for (i = 0; i < n; i++) {
4762             dst[i] = src[i] | (src[i] << 16);
4763          }
4764          return;
4765       }
4766       if (srcType == GL_UNSIGNED_INT_24_8
4767           && dstType == GL_UNSIGNED_INT
4768           && depthMax == 0xffffff) {
4769          const GLuint *src = (const GLuint *) source;
4770          GLuint *dst = (GLuint *) dest;
4771          GLuint i;
4772          for (i = 0; i < n; i++) {
4773             dst[i] = src[i] >> 8;
4774          }
4775          return;
4776       }
4777       /* XXX may want to add additional cases here someday */
4778    }
4779
4780    /* general case path follows */
4781
4782    if (dstType == GL_FLOAT) {
4783       depthValues = (GLfloat *) dest;
4784    }
4785    else {
4786       depthTemp = (GLfloat *) malloc(n * sizeof(GLfloat));
4787       if (!depthTemp) {
4788          _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
4789          return;
4790       }
4791
4792       depthValues = depthTemp;
4793    }
4794
4795    /* Convert incoming values to GLfloat.  Some conversions will require
4796     * clamping, below.
4797     */
4798    switch (srcType) {
4799       case GL_BYTE:
4800          DEPTH_VALUES(GLbyte, BYTE_TO_FLOATZ);
4801          needClamp = GL_TRUE;
4802          break;
4803       case GL_UNSIGNED_BYTE:
4804          DEPTH_VALUES(GLubyte, UBYTE_TO_FLOAT);
4805          break;
4806       case GL_SHORT:
4807          DEPTH_VALUES(GLshort, SHORT_TO_FLOATZ);
4808          needClamp = GL_TRUE;
4809          break;
4810       case GL_UNSIGNED_SHORT:
4811          DEPTH_VALUES(GLushort, USHORT_TO_FLOAT);
4812          break;
4813       case GL_INT:
4814          DEPTH_VALUES(GLint, INT_TO_FLOAT);
4815          needClamp = GL_TRUE;
4816          break;
4817       case GL_UNSIGNED_INT:
4818          DEPTH_VALUES(GLuint, UINT_TO_FLOAT);
4819          break;
4820       case GL_UNSIGNED_INT_24_8_EXT: /* GL_EXT_packed_depth_stencil */
4821          if (dstType == GL_UNSIGNED_INT_24_8_EXT &&
4822              depthMax == 0xffffff &&
4823              ctx->Pixel.DepthScale == 1.0 &&
4824              ctx->Pixel.DepthBias == 0.0) {
4825             const GLuint *src = (const GLuint *) source;
4826             GLuint *zValues = (GLuint *) dest;
4827             GLuint i;
4828             for (i = 0; i < n; i++) {
4829                 GLuint value = src[i];
4830                 if (srcPacking->SwapBytes) {
4831                     SWAP4BYTE(value);
4832                 }
4833                 zValues[i] = value & 0xffffff00;
4834             }
4835             free(depthTemp);
4836             return;
4837          }
4838          else {
4839             const GLuint *src = (const GLuint *) source;
4840             const GLfloat scale = 1.0f / 0xffffff;
4841             GLuint i;
4842             for (i = 0; i < n; i++) {
4843                 GLuint value = src[i];
4844                 if (srcPacking->SwapBytes) {
4845                     SWAP4BYTE(value);
4846                 }
4847                 depthValues[i] = (value >> 8) * scale;
4848             }
4849          }
4850          break;
4851       case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
4852          {
4853             GLuint i;
4854             const GLfloat *src = (const GLfloat *)source;
4855             for (i = 0; i < n; i++) {
4856                GLfloat value = src[i * 2];
4857                if (srcPacking->SwapBytes) {
4858                   SWAP4BYTE(value);
4859                }
4860                depthValues[i] = value;
4861             }
4862             needClamp = GL_TRUE;
4863          }
4864          break;
4865       case GL_FLOAT:
4866          DEPTH_VALUES(GLfloat, 1*);
4867          needClamp = GL_TRUE;
4868          break;
4869       case GL_HALF_FLOAT_ARB:
4870          {
4871             GLuint i;
4872             const GLhalfARB *src = (const GLhalfARB *) source;
4873             for (i = 0; i < n; i++) {
4874                GLhalfARB value = src[i];
4875                if (srcPacking->SwapBytes) {
4876                   SWAP2BYTE(value);
4877                }
4878                depthValues[i] = _mesa_half_to_float(value);
4879             }
4880             needClamp = GL_TRUE;
4881          }
4882          break;
4883       default:
4884          _mesa_problem(NULL, "bad type in _mesa_unpack_depth_span()");
4885          free(depthTemp);
4886          return;
4887    }
4888
4889    /* apply depth scale and bias */
4890    {
4891       const GLfloat scale = ctx->Pixel.DepthScale;
4892       const GLfloat bias = ctx->Pixel.DepthBias;
4893       if (scale != 1.0 || bias != 0.0) {
4894          GLuint i;
4895          for (i = 0; i < n; i++) {
4896             depthValues[i] = depthValues[i] * scale + bias;
4897          }
4898          needClamp = GL_TRUE;
4899       }
4900    }
4901
4902    /* clamp to [0, 1] */
4903    if (needClamp) {
4904       GLuint i;
4905       for (i = 0; i < n; i++) {
4906          depthValues[i] = (GLfloat)CLAMP(depthValues[i], 0.0, 1.0);
4907       }
4908    }
4909
4910    /*
4911     * Convert values to dstType
4912     */
4913    if (dstType == GL_UNSIGNED_INT) {
4914       GLuint *zValues = (GLuint *) dest;
4915       GLuint i;
4916       if (depthMax <= 0xffffff) {
4917          /* no overflow worries */
4918          for (i = 0; i < n; i++) {
4919             zValues[i] = (GLuint) (depthValues[i] * (GLfloat) depthMax);
4920          }
4921       }
4922       else {
4923          /* need to use double precision to prevent overflow problems */
4924          for (i = 0; i < n; i++) {
4925             GLdouble z = depthValues[i] * (GLfloat) depthMax;
4926             if (z >= (GLdouble) 0xffffffff)
4927                zValues[i] = 0xffffffff;
4928             else
4929                zValues[i] = (GLuint) z;
4930          }
4931       }
4932    }
4933    else if (dstType == GL_UNSIGNED_SHORT) {
4934       GLushort *zValues = (GLushort *) dest;
4935       GLuint i;
4936       ASSERT(depthMax <= 0xffff);
4937       for (i = 0; i < n; i++) {
4938          zValues[i] = (GLushort) (depthValues[i] * (GLfloat) depthMax);
4939       }
4940    }
4941    else if (dstType == GL_FLOAT) {
4942       /* Nothing to do. depthValues is pointing to dest. */
4943    }
4944    else if (dstType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV) {
4945       GLfloat *zValues = (GLfloat*) dest;
4946       GLuint i;
4947       for (i = 0; i < n; i++) {
4948          zValues[i*2] = depthValues[i];
4949       }
4950    }
4951    else {
4952       ASSERT(0);
4953    }
4954
4955    free(depthTemp);
4956 }
4957
4958
4959 /*
4960  * Pack an array of depth values.  The values are floats in [0,1].
4961  */
4962 void
4963 _mesa_pack_depth_span( struct gl_context *ctx, GLuint n, GLvoid *dest,
4964                        GLenum dstType, const GLfloat *depthSpan,
4965                        const struct gl_pixelstore_attrib *dstPacking )
4966 {
4967    GLfloat *depthCopy = (GLfloat *) malloc(n * sizeof(GLfloat));
4968    if (!depthCopy) {
4969       _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
4970       return;
4971    }
4972
4973    if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
4974       memcpy(depthCopy, depthSpan, n * sizeof(GLfloat));
4975       _mesa_scale_and_bias_depth(ctx, n, depthCopy);
4976       depthSpan = depthCopy;
4977    }
4978
4979    switch (dstType) {
4980    case GL_UNSIGNED_BYTE:
4981       {
4982          GLubyte *dst = (GLubyte *) dest;
4983          GLuint i;
4984          for (i = 0; i < n; i++) {
4985             dst[i] = FLOAT_TO_UBYTE( depthSpan[i] );
4986          }
4987       }
4988       break;
4989    case GL_BYTE:
4990       {
4991          GLbyte *dst = (GLbyte *) dest;
4992          GLuint i;
4993          for (i = 0; i < n; i++) {
4994             dst[i] = FLOAT_TO_BYTE( depthSpan[i] );
4995          }
4996       }
4997       break;
4998    case GL_UNSIGNED_SHORT:
4999       {
5000          GLushort *dst = (GLushort *) dest;
5001          GLuint i;
5002          for (i = 0; i < n; i++) {
5003             CLAMPED_FLOAT_TO_USHORT(dst[i], depthSpan[i]);
5004          }
5005          if (dstPacking->SwapBytes) {
5006             _mesa_swap2( (GLushort *) dst, n );
5007          }
5008       }
5009       break;
5010    case GL_SHORT:
5011       {
5012          GLshort *dst = (GLshort *) dest;
5013          GLuint i;
5014          for (i = 0; i < n; i++) {
5015             dst[i] = FLOAT_TO_SHORT( depthSpan[i] );
5016          }
5017          if (dstPacking->SwapBytes) {
5018             _mesa_swap2( (GLushort *) dst, n );
5019          }
5020       }
5021       break;
5022    case GL_UNSIGNED_INT:
5023       {
5024          GLuint *dst = (GLuint *) dest;
5025          GLuint i;
5026          for (i = 0; i < n; i++) {
5027             dst[i] = FLOAT_TO_UINT( depthSpan[i] );
5028          }
5029          if (dstPacking->SwapBytes) {
5030             _mesa_swap4( (GLuint *) dst, n );
5031          }
5032       }
5033       break;
5034    case GL_INT:
5035       {
5036          GLint *dst = (GLint *) dest;
5037          GLuint i;
5038          for (i = 0; i < n; i++) {
5039             dst[i] = FLOAT_TO_INT( depthSpan[i] );
5040          }
5041          if (dstPacking->SwapBytes) {
5042             _mesa_swap4( (GLuint *) dst, n );
5043          }
5044       }
5045       break;
5046    case GL_FLOAT:
5047       {
5048          GLfloat *dst = (GLfloat *) dest;
5049          GLuint i;
5050          for (i = 0; i < n; i++) {
5051             dst[i] = depthSpan[i];
5052          }
5053          if (dstPacking->SwapBytes) {
5054             _mesa_swap4( (GLuint *) dst, n );
5055          }
5056       }
5057       break;
5058    case GL_HALF_FLOAT_ARB:
5059       {
5060          GLhalfARB *dst = (GLhalfARB *) dest;
5061          GLuint i;
5062          for (i = 0; i < n; i++) {
5063             dst[i] = _mesa_float_to_half(depthSpan[i]);
5064          }
5065          if (dstPacking->SwapBytes) {
5066             _mesa_swap2( (GLushort *) dst, n );
5067          }
5068       }
5069       break;
5070    default:
5071       _mesa_problem(ctx, "bad type in _mesa_pack_depth_span");
5072    }
5073
5074    free(depthCopy);
5075 }
5076
5077
5078
5079 /**
5080  * Pack depth and stencil values as GL_DEPTH_STENCIL (GL_UNSIGNED_INT_24_8 etc)
5081  */
5082 void
5083 _mesa_pack_depth_stencil_span(struct gl_context *ctx,GLuint n,
5084                               GLenum dstType, GLuint *dest,
5085                               const GLfloat *depthVals,
5086                               const GLubyte *stencilVals,
5087                               const struct gl_pixelstore_attrib *dstPacking)
5088 {
5089    GLfloat *depthCopy = (GLfloat *) malloc(n * sizeof(GLfloat));
5090    GLubyte *stencilCopy = (GLubyte *) malloc(n * sizeof(GLubyte));
5091    GLuint i;
5092
5093    if (!depthCopy || !stencilCopy) {
5094       _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
5095       free(depthCopy);
5096       free(stencilCopy);
5097       return;
5098    }
5099
5100    if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
5101       memcpy(depthCopy, depthVals, n * sizeof(GLfloat));
5102       _mesa_scale_and_bias_depth(ctx, n, depthCopy);
5103       depthVals = depthCopy;
5104    }
5105
5106    if (ctx->Pixel.IndexShift ||
5107        ctx->Pixel.IndexOffset ||
5108        ctx->Pixel.MapStencilFlag) {
5109       memcpy(stencilCopy, stencilVals, n * sizeof(GLubyte));
5110       _mesa_apply_stencil_transfer_ops(ctx, n, stencilCopy);
5111       stencilVals = stencilCopy;
5112    }
5113
5114    switch (dstType) {
5115    case GL_UNSIGNED_INT_24_8:
5116       for (i = 0; i < n; i++) {
5117          GLuint z = (GLuint) (depthVals[i] * 0xffffff);
5118          dest[i] = (z << 8) | (stencilVals[i] & 0xff);
5119       }
5120       break;
5121    case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
5122       for (i = 0; i < n; i++) {
5123          ((GLfloat*)dest)[i*2] = depthVals[i];
5124          dest[i*2+1] = stencilVals[i] & 0xff;
5125       }
5126       break;
5127    }
5128
5129    if (dstPacking->SwapBytes) {
5130       _mesa_swap4(dest, n);
5131    }
5132
5133    free(depthCopy);
5134    free(stencilCopy);
5135 }
5136
5137
5138
5139
5140 /**
5141  * Unpack image data.  Apply byte swapping, byte flipping (bitmap).
5142  * Return all image data in a contiguous block.  This is used when we
5143  * compile glDrawPixels, glTexImage, etc into a display list.  We
5144  * need a copy of the data in a standard format.
5145  */
5146 void *
5147 _mesa_unpack_image( GLuint dimensions,
5148                     GLsizei width, GLsizei height, GLsizei depth,
5149                     GLenum format, GLenum type, const GLvoid *pixels,
5150                     const struct gl_pixelstore_attrib *unpack )
5151 {
5152    GLint bytesPerRow, compsPerRow;
5153    GLboolean flipBytes, swap2, swap4;
5154
5155    if (!pixels)
5156       return NULL;  /* not necessarily an error */
5157
5158    if (width <= 0 || height <= 0 || depth <= 0)
5159       return NULL;  /* generate error later */
5160
5161    if (type == GL_BITMAP) {
5162       bytesPerRow = (width + 7) >> 3;
5163       flipBytes = unpack->LsbFirst;
5164       swap2 = swap4 = GL_FALSE;
5165       compsPerRow = 0;
5166    }
5167    else {
5168       const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
5169       GLint components = _mesa_components_in_format(format);
5170       GLint bytesPerComp;
5171
5172       if (_mesa_type_is_packed(type))
5173           components = 1;
5174
5175       if (bytesPerPixel <= 0 || components <= 0)
5176          return NULL;   /* bad format or type.  generate error later */
5177       bytesPerRow = bytesPerPixel * width;
5178       bytesPerComp = bytesPerPixel / components;
5179       flipBytes = GL_FALSE;
5180       swap2 = (bytesPerComp == 2) && unpack->SwapBytes;
5181       swap4 = (bytesPerComp == 4) && unpack->SwapBytes;
5182       compsPerRow = components * width;
5183       assert(compsPerRow >= width);
5184    }
5185
5186    {
5187       GLubyte *destBuffer
5188          = (GLubyte *) malloc(bytesPerRow * height * depth);
5189       GLubyte *dst;
5190       GLint img, row;
5191       if (!destBuffer)
5192          return NULL;   /* generate GL_OUT_OF_MEMORY later */
5193
5194       dst = destBuffer;
5195       for (img = 0; img < depth; img++) {
5196          for (row = 0; row < height; row++) {
5197             const GLvoid *src = _mesa_image_address(dimensions, unpack, pixels,
5198                                width, height, format, type, img, row, 0);
5199
5200             if ((type == GL_BITMAP) && (unpack->SkipPixels & 0x7)) {
5201                GLint i;
5202                flipBytes = GL_FALSE;
5203                if (unpack->LsbFirst) {
5204                   GLubyte srcMask = 1 << (unpack->SkipPixels & 0x7);
5205                   GLubyte dstMask = 128;
5206                   const GLubyte *s = src;
5207                   GLubyte *d = dst;
5208                   *d = 0;
5209                   for (i = 0; i < width; i++) {
5210                      if (*s & srcMask) {
5211                         *d |= dstMask;
5212                      }
5213                      if (srcMask == 128) {
5214                         srcMask = 1;
5215                         s++;
5216                      }
5217                      else {
5218                         srcMask = srcMask << 1;
5219                      }
5220                      if (dstMask == 1) {
5221                         dstMask = 128;
5222                         d++;
5223                         *d = 0;
5224                      }
5225                      else {
5226                         dstMask = dstMask >> 1;
5227                      }
5228                   }
5229                }
5230                else {
5231                   GLubyte srcMask = 128 >> (unpack->SkipPixels & 0x7);
5232                   GLubyte dstMask = 128;
5233                   const GLubyte *s = src;
5234                   GLubyte *d = dst;
5235                   *d = 0;
5236                   for (i = 0; i < width; i++) {
5237                      if (*s & srcMask) {
5238                         *d |= dstMask;
5239                      }
5240                      if (srcMask == 1) {
5241                         srcMask = 128;
5242                         s++;
5243                      }
5244                      else {
5245                         srcMask = srcMask >> 1;
5246                      }
5247                      if (dstMask == 1) {
5248                         dstMask = 128;
5249                         d++;
5250                         *d = 0;
5251                      }
5252                      else {
5253                         dstMask = dstMask >> 1;
5254                      }
5255                   }
5256                }
5257             }
5258             else {
5259                memcpy(dst, src, bytesPerRow);
5260             }
5261
5262             /* byte flipping/swapping */
5263             if (flipBytes) {
5264                flip_bytes((GLubyte *) dst, bytesPerRow);
5265             }
5266             else if (swap2) {
5267                _mesa_swap2((GLushort*) dst, compsPerRow);
5268             }
5269             else if (swap4) {
5270                _mesa_swap4((GLuint*) dst, compsPerRow);
5271             }
5272             dst += bytesPerRow;
5273          }
5274       }
5275       return destBuffer;
5276    }
5277 }
5278