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