src/mesa/main/image.c

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