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