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