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 "enums.h" 47 #include "image.h" 48 #include "imports.h" 49 #include "macros.h" 50 #include "mtypes.h" 51 #include "pack.h" 52 #include "pixeltransfer.h" 53 #include "imports.h" 54 #include "glformats.h" 55 #include "format_utils.h" 56 #include "format_pack.h" 57 58 59 /** 60 * Flip the 8 bits in each byte of the given array. 61 * 62 * \param p array. 63 * \param n number of bytes. 64 * 65 * \todo try this trick to flip bytes someday: 66 * \code 67 * v = ((v & 0x55555555) << 1) | ((v >> 1) & 0x55555555); 68 * v = ((v & 0x33333333) << 2) | ((v >> 2) & 0x33333333); 69 * v = ((v & 0x0f0f0f0f) << 4) | ((v >> 4) & 0x0f0f0f0f); 70 * \endcode 71 */ 72 static void 73 flip_bytes( GLubyte *p, GLuint n ) 74 { 75 GLuint i, a, b; 76 for (i = 0; i < n; i++) { 77 b = (GLuint) p[i]; /* words are often faster than bytes */ 78 a = ((b & 0x01) << 7) | 79 ((b & 0x02) << 5) | 80 ((b & 0x04) << 3) | 81 ((b & 0x08) << 1) | 82 ((b & 0x10) >> 1) | 83 ((b & 0x20) >> 3) | 84 ((b & 0x40) >> 5) | 85 ((b & 0x80) >> 7); 86 p[i] = (GLubyte) a; 87 } 88 } 89 90 91 92 /* 93 * Unpack a 32x32 pixel polygon stipple from user memory using the 94 * current pixel unpack settings. 95 */ 96 void 97 _mesa_unpack_polygon_stipple( const GLubyte *pattern, GLuint dest[32], 98 const struct gl_pixelstore_attrib *unpacking ) 99 { 100 GLubyte *ptrn = (GLubyte *) _mesa_unpack_image(2, 32, 32, 1, GL_COLOR_INDEX, 101 GL_BITMAP, 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 */ 124 void 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 * Pack bitmap data. 146 */ 147 void 148 _mesa_pack_bitmap( GLint width, GLint height, const GLubyte *source, 149 GLubyte *dest, const struct gl_pixelstore_attrib *packing ) 150 { 151 GLint row, width_in_bytes; 152 const GLubyte *src; 153 154 if (!source) 155 return; 156 157 width_in_bytes = DIV_ROUND_UP( width, 8 ); 158 src = source; 159 for (row = 0; row < height; row++) { 160 GLubyte *dst = (GLubyte *) _mesa_image_address2d(packing, dest, 161 width, height, GL_COLOR_INDEX, GL_BITMAP, row, 0); 162 if (!dst) 163 return; 164 165 if ((packing->SkipPixels & 7) == 0) { 166 memcpy( dst, src, width_in_bytes ); 167 if (packing->LsbFirst) { 168 flip_bytes( dst, width_in_bytes ); 169 } 170 } 171 else { 172 /* handling SkipPixels is a bit tricky (no pun intended!) */ 173 GLint i; 174 if (packing->LsbFirst) { 175 GLubyte srcMask = 128; 176 GLubyte dstMask = 1 << (packing->SkipPixels & 0x7); 177 const GLubyte *s = src; 178 GLubyte *d = dst; 179 *d = 0; 180 for (i = 0; i < width; i++) { 181 if (*s & srcMask) { 182 *d |= dstMask; 183 } 184 if (srcMask == 1) { 185 srcMask = 128; 186 s++; 187 } 188 else { 189 srcMask = srcMask >> 1; 190 } 191 if (dstMask == 128) { 192 dstMask = 1; 193 d++; 194 *d = 0; 195 } 196 else { 197 dstMask = dstMask << 1; 198 } 199 } 200 } 201 else { 202 GLubyte srcMask = 128; 203 GLubyte dstMask = 128 >> (packing->SkipPixels & 0x7); 204 const GLubyte *s = src; 205 GLubyte *d = dst; 206 *d = 0; 207 for (i = 0; i < width; i++) { 208 if (*s & srcMask) { 209 *d |= dstMask; 210 } 211 if (srcMask == 1) { 212 srcMask = 128; 213 s++; 214 } 215 else { 216 srcMask = srcMask >> 1; 217 } 218 if (dstMask == 1) { 219 dstMask = 128; 220 d++; 221 *d = 0; 222 } 223 else { 224 dstMask = dstMask >> 1; 225 } 226 } 227 } 228 } 229 src += width_in_bytes; 230 } 231 } 232 233 234 #define SWAP2BYTE(VALUE) \ 235 { \ 236 GLubyte *bytes = (GLubyte *) &(VALUE); \ 237 GLubyte tmp = bytes[0]; \ 238 bytes[0] = bytes[1]; \ 239 bytes[1] = tmp; \ 240 } 241 242 #define SWAP4BYTE(VALUE) \ 243 { \ 244 GLubyte *bytes = (GLubyte *) &(VALUE); \ 245 GLubyte tmp = bytes[0]; \ 246 bytes[0] = bytes[3]; \ 247 bytes[3] = tmp; \ 248 tmp = bytes[1]; \ 249 bytes[1] = bytes[2]; \ 250 bytes[2] = tmp; \ 251 } 252 253 254 static void 255 extract_uint_indexes(GLuint n, GLuint indexes[], 256 GLenum srcFormat, GLenum srcType, const GLvoid *src, 257 const struct gl_pixelstore_attrib *unpack ) 258 { 259 assert(srcFormat == GL_COLOR_INDEX || srcFormat == GL_STENCIL_INDEX); 260 261 assert(srcType == GL_BITMAP || 262 srcType == GL_UNSIGNED_BYTE || 263 srcType == GL_BYTE || 264 srcType == GL_UNSIGNED_SHORT || 265 srcType == GL_SHORT || 266 srcType == GL_UNSIGNED_INT || 267 srcType == GL_INT || 268 srcType == GL_UNSIGNED_INT_24_8_EXT || 269 srcType == GL_HALF_FLOAT_ARB || 270 srcType == GL_HALF_FLOAT_OES || 271 srcType == GL_FLOAT || 272 srcType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV); 273 274 switch (srcType) { 275 case GL_BITMAP: 276 { 277 GLubyte *ubsrc = (GLubyte *) src; 278 if (unpack->LsbFirst) { 279 GLubyte mask = 1 << (unpack->SkipPixels & 0x7); 280 GLuint i; 281 for (i = 0; i < n; i++) { 282 indexes[i] = (*ubsrc & mask) ? 1 : 0; 283 if (mask == 128) { 284 mask = 1; 285 ubsrc++; 286 } 287 else { 288 mask = mask << 1; 289 } 290 } 291 } 292 else { 293 GLubyte mask = 128 >> (unpack->SkipPixels & 0x7); 294 GLuint i; 295 for (i = 0; i < n; i++) { 296 indexes[i] = (*ubsrc & mask) ? 1 : 0; 297 if (mask == 1) { 298 mask = 128; 299 ubsrc++; 300 } 301 else { 302 mask = mask >> 1; 303 } 304 } 305 } 306 } 307 break; 308 case GL_UNSIGNED_BYTE: 309 { 310 GLuint i; 311 const GLubyte *s = (const GLubyte *) src; 312 for (i = 0; i < n; i++) 313 indexes[i] = s[i]; 314 } 315 break; 316 case GL_BYTE: 317 { 318 GLuint i; 319 const GLbyte *s = (const GLbyte *) src; 320 for (i = 0; i < n; i++) 321 indexes[i] = s[i]; 322 } 323 break; 324 case GL_UNSIGNED_SHORT: 325 { 326 GLuint i; 327 const GLushort *s = (const GLushort *) src; 328 if (unpack->SwapBytes) { 329 for (i = 0; i < n; i++) { 330 GLushort value = s[i]; 331 SWAP2BYTE(value); 332 indexes[i] = value; 333 } 334 } 335 else { 336 for (i = 0; i < n; i++) 337 indexes[i] = s[i]; 338 } 339 } 340 break; 341 case GL_SHORT: 342 { 343 GLuint i; 344 const GLshort *s = (const GLshort *) src; 345 if (unpack->SwapBytes) { 346 for (i = 0; i < n; i++) { 347 GLshort value = s[i]; 348 SWAP2BYTE(value); 349 indexes[i] = value; 350 } 351 } 352 else { 353 for (i = 0; i < n; i++) 354 indexes[i] = s[i]; 355 } 356 } 357 break; 358 case GL_UNSIGNED_INT: 359 { 360 GLuint i; 361 const GLuint *s = (const GLuint *) src; 362 if (unpack->SwapBytes) { 363 for (i = 0; i < n; i++) { 364 GLuint value = s[i]; 365 SWAP4BYTE(value); 366 indexes[i] = value; 367 } 368 } 369 else { 370 for (i = 0; i < n; i++) 371 indexes[i] = s[i]; 372 } 373 } 374 break; 375 case GL_INT: 376 { 377 GLuint i; 378 const GLint *s = (const GLint *) src; 379 if (unpack->SwapBytes) { 380 for (i = 0; i < n; i++) { 381 GLint value = s[i]; 382 SWAP4BYTE(value); 383 indexes[i] = value; 384 } 385 } 386 else { 387 for (i = 0; i < n; i++) 388 indexes[i] = s[i]; 389 } 390 } 391 break; 392 case GL_FLOAT: 393 { 394 GLuint i; 395 const GLfloat *s = (const GLfloat *) src; 396 if (unpack->SwapBytes) { 397 for (i = 0; i < n; i++) { 398 GLfloat value = s[i]; 399 SWAP4BYTE(value); 400 indexes[i] = (GLuint) value; 401 } 402 } 403 else { 404 for (i = 0; i < n; i++) 405 indexes[i] = (GLuint) s[i]; 406 } 407 } 408 break; 409 case GL_HALF_FLOAT_ARB: 410 case GL_HALF_FLOAT_OES: 411 { 412 GLuint i; 413 const GLhalfARB *s = (const GLhalfARB *) src; 414 if (unpack->SwapBytes) { 415 for (i = 0; i < n; i++) { 416 GLhalfARB value = s[i]; 417 SWAP2BYTE(value); 418 indexes[i] = (GLuint) _mesa_half_to_float(value); 419 } 420 } 421 else { 422 for (i = 0; i < n; i++) 423 indexes[i] = (GLuint) _mesa_half_to_float(s[i]); 424 } 425 } 426 break; 427 case GL_UNSIGNED_INT_24_8_EXT: 428 { 429 GLuint i; 430 const GLuint *s = (const GLuint *) src; 431 if (unpack->SwapBytes) { 432 for (i = 0; i < n; i++) { 433 GLuint value = s[i]; 434 SWAP4BYTE(value); 435 indexes[i] = value & 0xff; /* lower 8 bits */ 436 } 437 } 438 else { 439 for (i = 0; i < n; i++) 440 indexes[i] = s[i] & 0xff; /* lower 8 bits */ 441 } 442 } 443 break; 444 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: 445 { 446 GLuint i; 447 const GLuint *s = (const GLuint *) src; 448 if (unpack->SwapBytes) { 449 for (i = 0; i < n; i++) { 450 GLuint value = s[i*2+1]; 451 SWAP4BYTE(value); 452 indexes[i] = value & 0xff; /* lower 8 bits */ 453 } 454 } 455 else { 456 for (i = 0; i < n; i++) 457 indexes[i] = s[i*2+1] & 0xff; /* lower 8 bits */ 458 } 459 } 460 break; 461 462 default: 463 _mesa_problem(NULL, "bad srcType in extract_uint_indexes"); 464 return; 465 } 466 } 467 468 469 static inline GLuint 470 clamp_float_to_uint(GLfloat f) 471 { 472 return f < 0.0F ? 0 : _mesa_lroundevenf(f); 473 } 474 475 476 static inline GLuint 477 clamp_half_to_uint(GLhalfARB h) 478 { 479 GLfloat f = _mesa_half_to_float(h); 480 return f < 0.0F ? 0 : _mesa_lroundevenf(f); 481 } 482 483 484 /* 485 * Unpack a row of stencil data from a client buffer according to 486 * the pixel unpacking parameters. 487 * This is (or will be) used by glDrawPixels 488 * 489 * Args: ctx - the context 490 * n - number of pixels 491 * dstType - destination data type 492 * dest - destination array 493 * srcType - source pixel type 494 * source - source data pointer 495 * srcPacking - pixel unpacking parameters 496 * transferOps - apply offset/bias/lookup ops? 497 */ 498 void 499 _mesa_unpack_stencil_span( struct gl_context *ctx, GLuint n, 500 GLenum dstType, GLvoid *dest, 501 GLenum srcType, const GLvoid *source, 502 const struct gl_pixelstore_attrib *srcPacking, 503 GLbitfield transferOps ) 504 { 505 assert(srcType == GL_BITMAP || 506 srcType == GL_UNSIGNED_BYTE || 507 srcType == GL_BYTE || 508 srcType == GL_UNSIGNED_SHORT || 509 srcType == GL_SHORT || 510 srcType == GL_UNSIGNED_INT || 511 srcType == GL_INT || 512 srcType == GL_UNSIGNED_INT_24_8_EXT || 513 srcType == GL_HALF_FLOAT_ARB || 514 srcType == GL_HALF_FLOAT_OES || 515 srcType == GL_FLOAT || 516 srcType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV); 517 518 assert(dstType == GL_UNSIGNED_BYTE || 519 dstType == GL_UNSIGNED_SHORT || 520 dstType == GL_UNSIGNED_INT || 521 dstType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV); 522 523 /* only shift and offset apply to stencil */ 524 transferOps &= IMAGE_SHIFT_OFFSET_BIT; 525 526 /* 527 * Try simple cases first 528 */ 529 if (transferOps == 0 && 530 !ctx->Pixel.MapStencilFlag && 531 srcType == GL_UNSIGNED_BYTE && 532 dstType == GL_UNSIGNED_BYTE) { 533 memcpy(dest, source, n * sizeof(GLubyte)); 534 } 535 else if (transferOps == 0 && 536 !ctx->Pixel.MapStencilFlag && 537 srcType == GL_UNSIGNED_INT && 538 dstType == GL_UNSIGNED_INT && 539 !srcPacking->SwapBytes) { 540 memcpy(dest, source, n * sizeof(GLuint)); 541 } 542 else { 543 /* 544 * general solution 545 */ 546 GLuint *indexes = malloc(n * sizeof(GLuint)); 547 548 if (!indexes) { 549 _mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil unpacking"); 550 return; 551 } 552 553 extract_uint_indexes(n, indexes, GL_STENCIL_INDEX, srcType, source, 554 srcPacking); 555 556 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) { 557 /* shift and offset indexes */ 558 _mesa_shift_and_offset_ci(ctx, n, indexes); 559 } 560 561 if (ctx->Pixel.MapStencilFlag) { 562 /* Apply stencil lookup table */ 563 const GLuint mask = ctx->PixelMaps.StoS.Size - 1; 564 GLuint i; 565 for (i = 0; i < n; i++) { 566 indexes[i] = (GLuint)ctx->PixelMaps.StoS.Map[ indexes[i] & mask ]; 567 } 568 } 569 570 /* convert to dest type */ 571 switch (dstType) { 572 case GL_UNSIGNED_BYTE: 573 { 574 GLubyte *dst = (GLubyte *) dest; 575 GLuint i; 576 for (i = 0; i < n; i++) { 577 dst[i] = (GLubyte) (indexes[i] & 0xff); 578 } 579 } 580 break; 581 case GL_UNSIGNED_SHORT: 582 { 583 GLuint *dst = (GLuint *) dest; 584 GLuint i; 585 for (i = 0; i < n; i++) { 586 dst[i] = (GLushort) (indexes[i] & 0xffff); 587 } 588 } 589 break; 590 case GL_UNSIGNED_INT: 591 memcpy(dest, indexes, n * sizeof(GLuint)); 592 break; 593 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: 594 { 595 GLuint *dst = (GLuint *) dest; 596 GLuint i; 597 for (i = 0; i < n; i++) { 598 dst[i*2+1] = indexes[i] & 0xff; /* lower 8 bits */ 599 } 600 } 601 break; 602 default: 603 _mesa_problem(ctx, "bad dstType in _mesa_unpack_stencil_span"); 604 } 605 606 free(indexes); 607 } 608 } 609 610 611 void 612 _mesa_pack_stencil_span( struct gl_context *ctx, GLuint n, 613 GLenum dstType, GLvoid *dest, const GLubyte *source, 614 const struct gl_pixelstore_attrib *dstPacking ) 615 { 616 GLubyte *stencil = malloc(n * sizeof(GLubyte)); 617 618 if (!stencil) { 619 _mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil packing"); 620 return; 621 } 622 623 if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset || 624 ctx->Pixel.MapStencilFlag) { 625 /* make a copy of input */ 626 memcpy(stencil, source, n * sizeof(GLubyte)); 627 _mesa_apply_stencil_transfer_ops(ctx, n, stencil); 628 source = stencil; 629 } 630 631 switch (dstType) { 632 case GL_UNSIGNED_BYTE: 633 memcpy(dest, source, n); 634 break; 635 case GL_BYTE: 636 { 637 GLbyte *dst = (GLbyte *) dest; 638 GLuint i; 639 for (i=0;i<n;i++) { 640 dst[i] = (GLbyte) (source[i] & 0x7f); 641 } 642 } 643 break; 644 case GL_UNSIGNED_SHORT: 645 { 646 GLushort *dst = (GLushort *) dest; 647 GLuint i; 648 for (i=0;i<n;i++) { 649 dst[i] = (GLushort) source[i]; 650 } 651 if (dstPacking->SwapBytes) { 652 _mesa_swap2( (GLushort *) dst, n ); 653 } 654 } 655 break; 656 case GL_SHORT: 657 { 658 GLshort *dst = (GLshort *) dest; 659 GLuint i; 660 for (i=0;i<n;i++) { 661 dst[i] = (GLshort) source[i]; 662 } 663 if (dstPacking->SwapBytes) { 664 _mesa_swap2( (GLushort *) dst, n ); 665 } 666 } 667 break; 668 case GL_UNSIGNED_INT: 669 { 670 GLuint *dst = (GLuint *) dest; 671 GLuint i; 672 for (i=0;i<n;i++) { 673 dst[i] = (GLuint) source[i]; 674 } 675 if (dstPacking->SwapBytes) { 676 _mesa_swap4( (GLuint *) dst, n ); 677 } 678 } 679 break; 680 case GL_INT: 681 { 682 GLint *dst = (GLint *) dest; 683 GLuint i; 684 for (i=0;i<n;i++) { 685 dst[i] = (GLint) source[i]; 686 } 687 if (dstPacking->SwapBytes) { 688 _mesa_swap4( (GLuint *) dst, n ); 689 } 690 } 691 break; 692 case GL_FLOAT: 693 { 694 GLfloat *dst = (GLfloat *) dest; 695 GLuint i; 696 for (i=0;i<n;i++) { 697 dst[i] = (GLfloat) source[i]; 698 } 699 if (dstPacking->SwapBytes) { 700 _mesa_swap4( (GLuint *) dst, n ); 701 } 702 } 703 break; 704 case GL_HALF_FLOAT_ARB: 705 case GL_HALF_FLOAT_OES: 706 { 707 GLhalfARB *dst = (GLhalfARB *) dest; 708 GLuint i; 709 for (i=0;i<n;i++) { 710 dst[i] = _mesa_float_to_half( (float) source[i] ); 711 } 712 if (dstPacking->SwapBytes) { 713 _mesa_swap2( (GLushort *) dst, n ); 714 } 715 } 716 break; 717 case GL_BITMAP: 718 if (dstPacking->LsbFirst) { 719 GLubyte *dst = (GLubyte *) dest; 720 GLint shift = 0; 721 GLuint i; 722 for (i = 0; i < n; i++) { 723 if (shift == 0) 724 *dst = 0; 725 *dst |= ((source[i] != 0) << shift); 726 shift++; 727 if (shift == 8) { 728 shift = 0; 729 dst++; 730 } 731 } 732 } 733 else { 734 GLubyte *dst = (GLubyte *) dest; 735 GLint shift = 7; 736 GLuint i; 737 for (i = 0; i < n; i++) { 738 if (shift == 7) 739 *dst = 0; 740 *dst |= ((source[i] != 0) << shift); 741 shift--; 742 if (shift < 0) { 743 shift = 7; 744 dst++; 745 } 746 } 747 } 748 break; 749 default: 750 _mesa_problem(ctx, "bad type in _mesa_pack_index_span"); 751 } 752 753 free(stencil); 754 } 755 756 #define DEPTH_VALUES(GLTYPE, GLTYPE2FLOAT) \ 757 do { \ 758 GLuint i; \ 759 const GLTYPE *src = (const GLTYPE *)source; \ 760 for (i = 0; i < n; i++) { \ 761 GLTYPE value = src[i]; \ 762 if (srcPacking->SwapBytes) { \ 763 if (sizeof(GLTYPE) == 2) { \ 764 SWAP2BYTE(value); \ 765 } else if (sizeof(GLTYPE) == 4) { \ 766 SWAP4BYTE(value); \ 767 } \ 768 } \ 769 depthValues[i] = GLTYPE2FLOAT(value); \ 770 } \ 771 } while (0) 772 773 774 /** 775 * Unpack a row of depth/z values from memory, returning GLushort, GLuint 776 * or GLfloat values. 777 * The glPixelTransfer (scale/bias) params will be applied. 778 * 779 * \param dstType one of GL_UNSIGNED_SHORT, GL_UNSIGNED_INT, GL_FLOAT 780 * \param depthMax max value for returned GLushort or GLuint values 781 * (ignored for GLfloat). 782 */ 783 void 784 _mesa_unpack_depth_span( struct gl_context *ctx, GLuint n, 785 GLenum dstType, GLvoid *dest, GLuint depthMax, 786 GLenum srcType, const GLvoid *source, 787 const struct gl_pixelstore_attrib *srcPacking ) 788 { 789 GLfloat *depthTemp = NULL, *depthValues; 790 GLboolean needClamp = GL_FALSE; 791 792 /* Look for special cases first. 793 * Not only are these faster, they're less prone to numeric conversion 794 * problems. Otherwise, converting from an int type to a float then 795 * back to an int type can introduce errors that will show up as 796 * artifacts in things like depth peeling which uses glCopyTexImage. 797 */ 798 if (ctx->Pixel.DepthScale == 1.0F && ctx->Pixel.DepthBias == 0.0F) { 799 if (srcType == GL_UNSIGNED_INT && dstType == GL_UNSIGNED_SHORT) { 800 const GLuint *src = (const GLuint *) source; 801 GLushort *dst = (GLushort *) dest; 802 GLuint i; 803 for (i = 0; i < n; i++) { 804 dst[i] = src[i] >> 16; 805 } 806 return; 807 } 808 if (srcType == GL_UNSIGNED_SHORT 809 && dstType == GL_UNSIGNED_INT 810 && depthMax == 0xffffffff) { 811 const GLushort *src = (const GLushort *) source; 812 GLuint *dst = (GLuint *) dest; 813 GLuint i; 814 for (i = 0; i < n; i++) { 815 dst[i] = src[i] | (src[i] << 16); 816 } 817 return; 818 } 819 if (srcType == GL_UNSIGNED_INT_24_8 820 && dstType == GL_UNSIGNED_INT 821 && depthMax == 0xffffff) { 822 const GLuint *src = (const GLuint *) source; 823 GLuint *dst = (GLuint *) dest; 824 GLuint i; 825 for (i = 0; i < n; i++) { 826 dst[i] = src[i] >> 8; 827 } 828 return; 829 } 830 /* XXX may want to add additional cases here someday */ 831 } 832 833 /* general case path follows */ 834 835 if (dstType == GL_FLOAT) { 836 depthValues = (GLfloat *) dest; 837 } 838 else { 839 depthTemp = malloc(n * sizeof(GLfloat)); 840 if (!depthTemp) { 841 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking"); 842 return; 843 } 844 845 depthValues = depthTemp; 846 } 847 848 /* Convert incoming values to GLfloat. Some conversions will require 849 * clamping, below. 850 */ 851 switch (srcType) { 852 case GL_BYTE: 853 DEPTH_VALUES(GLbyte, BYTE_TO_FLOATZ); 854 needClamp = GL_TRUE; 855 break; 856 case GL_UNSIGNED_BYTE: 857 DEPTH_VALUES(GLubyte, UBYTE_TO_FLOAT); 858 break; 859 case GL_SHORT: 860 DEPTH_VALUES(GLshort, SHORT_TO_FLOATZ); 861 needClamp = GL_TRUE; 862 break; 863 case GL_UNSIGNED_SHORT: 864 DEPTH_VALUES(GLushort, USHORT_TO_FLOAT); 865 break; 866 case GL_INT: 867 DEPTH_VALUES(GLint, INT_TO_FLOAT); 868 needClamp = GL_TRUE; 869 break; 870 case GL_UNSIGNED_INT: 871 DEPTH_VALUES(GLuint, UINT_TO_FLOAT); 872 break; 873 case GL_UNSIGNED_INT_24_8_EXT: /* GL_EXT_packed_depth_stencil */ 874 if (dstType == GL_UNSIGNED_INT_24_8_EXT && 875 depthMax == 0xffffff && 876 ctx->Pixel.DepthScale == 1.0F && 877 ctx->Pixel.DepthBias == 0.0F) { 878 const GLuint *src = (const GLuint *) source; 879 GLuint *zValues = (GLuint *) dest; 880 GLuint i; 881 for (i = 0; i < n; i++) { 882 GLuint value = src[i]; 883 if (srcPacking->SwapBytes) { 884 SWAP4BYTE(value); 885 } 886 zValues[i] = value & 0xffffff00; 887 } 888 free(depthTemp); 889 return; 890 } 891 else { 892 const GLuint *src = (const GLuint *) source; 893 const GLfloat scale = 1.0f / 0xffffff; 894 GLuint i; 895 for (i = 0; i < n; i++) { 896 GLuint value = src[i]; 897 if (srcPacking->SwapBytes) { 898 SWAP4BYTE(value); 899 } 900 depthValues[i] = (value >> 8) * scale; 901 } 902 } 903 break; 904 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: 905 { 906 GLuint i; 907 const GLfloat *src = (const GLfloat *)source; 908 for (i = 0; i < n; i++) { 909 GLfloat value = src[i * 2]; 910 if (srcPacking->SwapBytes) { 911 SWAP4BYTE(value); 912 } 913 depthValues[i] = value; 914 } 915 needClamp = GL_TRUE; 916 } 917 break; 918 case GL_FLOAT: 919 DEPTH_VALUES(GLfloat, 1*); 920 needClamp = GL_TRUE; 921 break; 922 case GL_HALF_FLOAT_ARB: 923 case GL_HALF_FLOAT_OES: 924 { 925 GLuint i; 926 const GLhalfARB *src = (const GLhalfARB *) source; 927 for (i = 0; i < n; i++) { 928 GLhalfARB value = src[i]; 929 if (srcPacking->SwapBytes) { 930 SWAP2BYTE(value); 931 } 932 depthValues[i] = _mesa_half_to_float(value); 933 } 934 needClamp = GL_TRUE; 935 } 936 break; 937 default: 938 _mesa_problem(NULL, "bad type in _mesa_unpack_depth_span()"); 939 free(depthTemp); 940 return; 941 } 942 943 /* apply depth scale and bias */ 944 { 945 const GLfloat scale = ctx->Pixel.DepthScale; 946 const GLfloat bias = ctx->Pixel.DepthBias; 947 if (scale != 1.0F || bias != 0.0F) { 948 GLuint i; 949 for (i = 0; i < n; i++) { 950 depthValues[i] = depthValues[i] * scale + bias; 951 } 952 needClamp = GL_TRUE; 953 } 954 } 955 956 /* clamp to [0, 1] */ 957 if (needClamp) { 958 GLuint i; 959 for (i = 0; i < n; i++) { 960 depthValues[i] = CLAMP(depthValues[i], 0.0F, 1.0F); 961 } 962 } 963 964 /* 965 * Convert values to dstType 966 */ 967 if (dstType == GL_UNSIGNED_INT) { 968 GLuint *zValues = (GLuint *) dest; 969 GLuint i; 970 if (depthMax <= 0xffffff) { 971 /* no overflow worries */ 972 for (i = 0; i < n; i++) { 973 zValues[i] = (GLuint) (depthValues[i] * (GLfloat) depthMax); 974 } 975 } 976 else { 977 /* need to use double precision to prevent overflow problems */ 978 for (i = 0; i < n; i++) { 979 GLdouble z = depthValues[i] * (GLdouble) depthMax; 980 if (z >= (GLdouble) 0xffffffff) 981 zValues[i] = 0xffffffff; 982 else 983 zValues[i] = (GLuint) z; 984 } 985 } 986 } 987 else if (dstType == GL_UNSIGNED_SHORT) { 988 GLushort *zValues = (GLushort *) dest; 989 GLuint i; 990 assert(depthMax <= 0xffff); 991 for (i = 0; i < n; i++) { 992 zValues[i] = (GLushort) (depthValues[i] * (GLfloat) depthMax); 993 } 994 } 995 else if (dstType == GL_FLOAT) { 996 /* Nothing to do. depthValues is pointing to dest. */ 997 } 998 else if (dstType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV) { 999 GLfloat *zValues = (GLfloat*) dest; 1000 GLuint i; 1001 for (i = 0; i < n; i++) { 1002 zValues[i*2] = depthValues[i]; 1003 } 1004 } 1005 else { 1006 assert(0); 1007 } 1008 1009 free(depthTemp); 1010 } 1011 1012 1013 /* 1014 * Pack an array of depth values. The values are floats in [0,1]. 1015 */ 1016 void 1017 _mesa_pack_depth_span( struct gl_context *ctx, GLuint n, GLvoid *dest, 1018 GLenum dstType, const GLfloat *depthSpan, 1019 const struct gl_pixelstore_attrib *dstPacking ) 1020 { 1021 GLfloat *depthCopy = malloc(n * sizeof(GLfloat)); 1022 if (!depthCopy) { 1023 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing"); 1024 return; 1025 } 1026 1027 if (ctx->Pixel.DepthScale != 1.0F || ctx->Pixel.DepthBias != 0.0F) { 1028 memcpy(depthCopy, depthSpan, n * sizeof(GLfloat)); 1029 _mesa_scale_and_bias_depth(ctx, n, depthCopy); 1030 depthSpan = depthCopy; 1031 } 1032 1033 switch (dstType) { 1034 case GL_UNSIGNED_BYTE: 1035 { 1036 GLubyte *dst = (GLubyte *) dest; 1037 GLuint i; 1038 for (i = 0; i < n; i++) { 1039 dst[i] = FLOAT_TO_UBYTE( depthSpan[i] ); 1040 } 1041 } 1042 break; 1043 case GL_BYTE: 1044 { 1045 GLbyte *dst = (GLbyte *) dest; 1046 GLuint i; 1047 for (i = 0; i < n; i++) { 1048 dst[i] = FLOAT_TO_BYTE( depthSpan[i] ); 1049 } 1050 } 1051 break; 1052 case GL_UNSIGNED_SHORT: 1053 { 1054 GLushort *dst = (GLushort *) dest; 1055 GLuint i; 1056 for (i = 0; i < n; i++) { 1057 CLAMPED_FLOAT_TO_USHORT(dst[i], depthSpan[i]); 1058 } 1059 if (dstPacking->SwapBytes) { 1060 _mesa_swap2( (GLushort *) dst, n ); 1061 } 1062 } 1063 break; 1064 case GL_SHORT: 1065 { 1066 GLshort *dst = (GLshort *) dest; 1067 GLuint i; 1068 for (i = 0; i < n; i++) { 1069 dst[i] = FLOAT_TO_SHORT( depthSpan[i] ); 1070 } 1071 if (dstPacking->SwapBytes) { 1072 _mesa_swap2( (GLushort *) dst, n ); 1073 } 1074 } 1075 break; 1076 case GL_UNSIGNED_INT_24_8: 1077 { 1078 const GLdouble scale = (GLdouble) 0xffffff; 1079 GLuint *dst = (GLuint *) dest; 1080 GLuint i; 1081 for (i = 0; i < n; i++) { 1082 GLuint z = (GLuint) (depthSpan[i] * scale); 1083 assert(z <= 0xffffff); 1084 dst[i] = (z << 8); 1085 } 1086 if (dstPacking->SwapBytes) { 1087 _mesa_swap4( (GLuint *) dst, n ); 1088 } 1089 break; 1090 } 1091 case GL_UNSIGNED_INT: 1092 { 1093 GLuint *dst = (GLuint *) dest; 1094 GLuint i; 1095 for (i = 0; i < n; i++) { 1096 dst[i] = FLOAT_TO_UINT( depthSpan[i] ); 1097 } 1098 if (dstPacking->SwapBytes) { 1099 _mesa_swap4( (GLuint *) dst, n ); 1100 } 1101 } 1102 break; 1103 case GL_INT: 1104 { 1105 GLint *dst = (GLint *) dest; 1106 GLuint i; 1107 for (i = 0; i < n; i++) { 1108 dst[i] = FLOAT_TO_INT( depthSpan[i] ); 1109 } 1110 if (dstPacking->SwapBytes) { 1111 _mesa_swap4( (GLuint *) dst, n ); 1112 } 1113 } 1114 break; 1115 case GL_FLOAT: 1116 { 1117 GLfloat *dst = (GLfloat *) dest; 1118 GLuint i; 1119 for (i = 0; i < n; i++) { 1120 dst[i] = depthSpan[i]; 1121 } 1122 if (dstPacking->SwapBytes) { 1123 _mesa_swap4( (GLuint *) dst, n ); 1124 } 1125 } 1126 break; 1127 case GL_HALF_FLOAT_ARB: 1128 case GL_HALF_FLOAT_OES: 1129 { 1130 GLhalfARB *dst = (GLhalfARB *) dest; 1131 GLuint i; 1132 for (i = 0; i < n; i++) { 1133 dst[i] = _mesa_float_to_half(depthSpan[i]); 1134 } 1135 if (dstPacking->SwapBytes) { 1136 _mesa_swap2( (GLushort *) dst, n ); 1137 } 1138 } 1139 break; 1140 default: 1141 _mesa_problem(ctx, "bad type in _mesa_pack_depth_span (%s)", 1142 _mesa_enum_to_string(dstType)); 1143 } 1144 1145 free(depthCopy); 1146 } 1147 1148 1149 1150 /** 1151 * Pack depth and stencil values as GL_DEPTH_STENCIL (GL_UNSIGNED_INT_24_8 etc) 1152 */ 1153 void 1154 _mesa_pack_depth_stencil_span(struct gl_context *ctx,GLuint n, 1155 GLenum dstType, GLuint *dest, 1156 const GLfloat *depthVals, 1157 const GLubyte *stencilVals, 1158 const struct gl_pixelstore_attrib *dstPacking) 1159 { 1160 GLfloat *depthCopy = malloc(n * sizeof(GLfloat)); 1161 GLubyte *stencilCopy = malloc(n * sizeof(GLubyte)); 1162 GLuint i; 1163 1164 if (!depthCopy || !stencilCopy) { 1165 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing"); 1166 free(depthCopy); 1167 free(stencilCopy); 1168 return; 1169 } 1170 1171 if (ctx->Pixel.DepthScale != 1.0F || ctx->Pixel.DepthBias != 0.0F) { 1172 memcpy(depthCopy, depthVals, n * sizeof(GLfloat)); 1173 _mesa_scale_and_bias_depth(ctx, n, depthCopy); 1174 depthVals = depthCopy; 1175 } 1176 1177 if (ctx->Pixel.IndexShift || 1178 ctx->Pixel.IndexOffset || 1179 ctx->Pixel.MapStencilFlag) { 1180 memcpy(stencilCopy, stencilVals, n * sizeof(GLubyte)); 1181 _mesa_apply_stencil_transfer_ops(ctx, n, stencilCopy); 1182 stencilVals = stencilCopy; 1183 } 1184 1185 switch (dstType) { 1186 case GL_UNSIGNED_INT_24_8: 1187 for (i = 0; i < n; i++) { 1188 GLuint z = (GLuint) (depthVals[i] * 0xffffff); 1189 dest[i] = (z << 8) | (stencilVals[i] & 0xff); 1190 } 1191 break; 1192 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: 1193 for (i = 0; i < n; i++) { 1194 ((GLfloat*)dest)[i*2] = depthVals[i]; 1195 dest[i*2+1] = stencilVals[i] & 0xff; 1196 } 1197 break; 1198 } 1199 1200 if (dstPacking->SwapBytes) { 1201 _mesa_swap4(dest, n); 1202 } 1203 1204 free(depthCopy); 1205 free(stencilCopy); 1206 } 1207 1208 1209 1210 /** 1211 * Unpack image data. Apply byte swapping, byte flipping (bitmap). 1212 * Return all image data in a contiguous block. This is used when we 1213 * compile glDrawPixels, glTexImage, etc into a display list. We 1214 * need a copy of the data in a standard format. 1215 */ 1216 void * 1217 _mesa_unpack_image( GLuint dimensions, 1218 GLsizei width, GLsizei height, GLsizei depth, 1219 GLenum format, GLenum type, const GLvoid *pixels, 1220 const struct gl_pixelstore_attrib *unpack ) 1221 { 1222 GLint bytesPerRow, compsPerRow; 1223 GLboolean flipBytes, swap2, swap4; 1224 1225 if (!pixels) 1226 return NULL; /* not necessarily an error */ 1227 1228 if (width <= 0 || height <= 0 || depth <= 0) 1229 return NULL; /* generate error later */ 1230 1231 if (type == GL_BITMAP) { 1232 bytesPerRow = (width + 7) >> 3; 1233 flipBytes = unpack->LsbFirst; 1234 swap2 = swap4 = GL_FALSE; 1235 compsPerRow = 0; 1236 } 1237 else { 1238 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type); 1239 GLint components = _mesa_components_in_format(format); 1240 GLint bytesPerComp; 1241 1242 if (_mesa_type_is_packed(type)) 1243 components = 1; 1244 1245 if (bytesPerPixel <= 0 || components <= 0) 1246 return NULL; /* bad format or type. generate error later */ 1247 bytesPerRow = bytesPerPixel * width; 1248 bytesPerComp = bytesPerPixel / components; 1249 flipBytes = GL_FALSE; 1250 swap2 = (bytesPerComp == 2) && unpack->SwapBytes; 1251 swap4 = (bytesPerComp == 4) && unpack->SwapBytes; 1252 compsPerRow = components * width; 1253 assert(compsPerRow >= width); 1254 } 1255 1256 { 1257 GLubyte *destBuffer 1258 = malloc(bytesPerRow * height * depth); 1259 GLubyte *dst; 1260 GLint img, row; 1261 if (!destBuffer) 1262 return NULL; /* generate GL_OUT_OF_MEMORY later */ 1263 1264 dst = destBuffer; 1265 for (img = 0; img < depth; img++) { 1266 for (row = 0; row < height; row++) { 1267 const GLvoid *src = _mesa_image_address(dimensions, unpack, pixels, 1268 width, height, format, type, img, row, 0); 1269 1270 if ((type == GL_BITMAP) && (unpack->SkipPixels & 0x7)) { 1271 GLint i; 1272 flipBytes = GL_FALSE; 1273 if (unpack->LsbFirst) { 1274 GLubyte srcMask = 1 << (unpack->SkipPixels & 0x7); 1275 GLubyte dstMask = 128; 1276 const GLubyte *s = src; 1277 GLubyte *d = dst; 1278 *d = 0; 1279 for (i = 0; i < width; i++) { 1280 if (*s & srcMask) { 1281 *d |= dstMask; 1282 } 1283 if (srcMask == 128) { 1284 srcMask = 1; 1285 s++; 1286 } 1287 else { 1288 srcMask = srcMask << 1; 1289 } 1290 if (dstMask == 1) { 1291 dstMask = 128; 1292 d++; 1293 *d = 0; 1294 } 1295 else { 1296 dstMask = dstMask >> 1; 1297 } 1298 } 1299 } 1300 else { 1301 GLubyte srcMask = 128 >> (unpack->SkipPixels & 0x7); 1302 GLubyte dstMask = 128; 1303 const GLubyte *s = src; 1304 GLubyte *d = dst; 1305 *d = 0; 1306 for (i = 0; i < width; i++) { 1307 if (*s & srcMask) { 1308 *d |= dstMask; 1309 } 1310 if (srcMask == 1) { 1311 srcMask = 128; 1312 s++; 1313 } 1314 else { 1315 srcMask = srcMask >> 1; 1316 } 1317 if (dstMask == 1) { 1318 dstMask = 128; 1319 d++; 1320 *d = 0; 1321 } 1322 else { 1323 dstMask = dstMask >> 1; 1324 } 1325 } 1326 } 1327 } 1328 else { 1329 memcpy(dst, src, bytesPerRow); 1330 } 1331 1332 /* byte flipping/swapping */ 1333 if (flipBytes) { 1334 flip_bytes((GLubyte *) dst, bytesPerRow); 1335 } 1336 else if (swap2) { 1337 _mesa_swap2((GLushort*) dst, compsPerRow); 1338 } 1339 else if (swap4) { 1340 _mesa_swap4((GLuint*) dst, compsPerRow); 1341 } 1342 dst += bytesPerRow; 1343 } 1344 } 1345 return destBuffer; 1346 } 1347 } 1348 1349 void 1350 _mesa_pack_luminance_from_rgba_float(GLuint n, GLfloat rgba[][4], 1351 GLvoid *dstAddr, GLenum dst_format, 1352 GLbitfield transferOps) 1353 { 1354 int i; 1355 GLfloat *dst = (GLfloat *) dstAddr; 1356 1357 switch (dst_format) { 1358 case GL_LUMINANCE: 1359 if (transferOps & IMAGE_CLAMP_BIT) { 1360 for (i = 0; i < n; i++) { 1361 GLfloat sum = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP]; 1362 dst[i] = CLAMP(sum, 0.0F, 1.0F); 1363 } 1364 } else { 1365 for (i = 0; i < n; i++) { 1366 dst[i] = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP]; 1367 } 1368 } 1369 return; 1370 case GL_LUMINANCE_ALPHA: 1371 if (transferOps & IMAGE_CLAMP_BIT) { 1372 for (i = 0; i < n; i++) { 1373 GLfloat sum = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP]; 1374 dst[2*i] = CLAMP(sum, 0.0F, 1.0F); 1375 dst[2*i+1] = rgba[i][ACOMP]; 1376 } 1377 } else { 1378 for (i = 0; i < n; i++) { 1379 dst[2*i] = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP]; 1380 dst[2*i+1] = rgba[i][ACOMP]; 1381 } 1382 } 1383 return; 1384 default: 1385 assert(!"Unsupported format"); 1386 } 1387 } 1388 1389 static int32_t 1390 clamp_sint64_to_sint32(int64_t src) 1391 { 1392 return CLAMP(src, INT32_MIN, INT32_MAX); 1393 } 1394 1395 static int32_t 1396 clamp_sint64_to_uint32(int64_t src) 1397 { 1398 return CLAMP(src, 0, UINT32_MAX); 1399 } 1400 1401 static int32_t 1402 clamp_uint64_to_uint32(uint64_t src) 1403 { 1404 return MIN2(src, UINT32_MAX); 1405 } 1406 1407 static int32_t 1408 clamp_uint64_to_sint32(uint64_t src) 1409 { 1410 return MIN2(src, INT32_MAX); 1411 } 1412 1413 static int32_t 1414 convert_integer_luminance64(int64_t src64, int bits, 1415 bool dst_is_signed, bool src_is_signed) 1416 { 1417 int32_t src32; 1418 1419 /* Clamp Luminance value from 64-bit to 32-bit. Consider if we need 1420 * any signed<->unsigned conversion too. 1421 */ 1422 if (src_is_signed && dst_is_signed) 1423 src32 = clamp_sint64_to_sint32(src64); 1424 else if (src_is_signed && !dst_is_signed) 1425 src32 = clamp_sint64_to_uint32(src64); 1426 else if (!src_is_signed && dst_is_signed) 1427 src32 = clamp_uint64_to_sint32(src64); 1428 else 1429 src32 = clamp_uint64_to_uint32(src64); 1430 1431 /* If the dst type is < 32-bit, we need an extra clamp */ 1432 if (bits == 32) { 1433 return src32; 1434 } else { 1435 if (dst_is_signed) 1436 return _mesa_signed_to_signed(src32, bits); 1437 else 1438 return _mesa_unsigned_to_unsigned(src32, bits); 1439 } 1440 } 1441 1442 static int32_t 1443 convert_integer(int32_t src, int bits, bool dst_is_signed, bool src_is_signed) 1444 { 1445 if (src_is_signed && dst_is_signed) 1446 return _mesa_signed_to_signed(src, bits); 1447 else if (src_is_signed && !dst_is_signed) 1448 return _mesa_signed_to_unsigned(src, bits); 1449 else if (!src_is_signed && dst_is_signed) 1450 return _mesa_unsigned_to_signed(src, bits); 1451 else 1452 return _mesa_unsigned_to_unsigned(src, bits); 1453 } 1454 1455 void 1456 _mesa_pack_luminance_from_rgba_integer(GLuint n, 1457 GLuint rgba[][4], bool rgba_is_signed, 1458 GLvoid *dstAddr, 1459 GLenum dst_format, 1460 GLenum dst_type) 1461 { 1462 int i; 1463 int64_t lum64; 1464 int32_t lum32, alpha; 1465 bool dst_is_signed; 1466 int dst_bits; 1467 1468 assert(dst_format == GL_LUMINANCE_INTEGER_EXT || 1469 dst_format == GL_LUMINANCE_ALPHA_INTEGER_EXT); 1470 1471 /* We first compute luminance values as a 64-bit addition of the 1472 * 32-bit R,G,B components, then we clamp the result to the dst type size. 1473 * 1474 * Notice that this operation involves casting the 32-bit R,G,B components 1475 * to 64-bit before the addition. Since rgba is defined as a GLuint array 1476 * we need to be careful when rgba packs signed data and make sure 1477 * that we cast to a 32-bit signed integer values before casting them to 1478 * 64-bit signed integers. 1479 */ 1480 dst_is_signed = (dst_type == GL_BYTE || dst_type == GL_SHORT || 1481 dst_type == GL_INT); 1482 1483 dst_bits = _mesa_sizeof_type(dst_type) * 8; 1484 assert(dst_bits > 0); 1485 1486 switch (dst_format) { 1487 case GL_LUMINANCE_INTEGER_EXT: 1488 for (i = 0; i < n; i++) { 1489 if (!rgba_is_signed) { 1490 lum64 = (uint64_t) rgba[i][RCOMP] + 1491 (uint64_t) rgba[i][GCOMP] + 1492 (uint64_t) rgba[i][BCOMP]; 1493 } else { 1494 lum64 = (int64_t) ((int32_t) rgba[i][RCOMP]) + 1495 (int64_t) ((int32_t) rgba[i][GCOMP]) + 1496 (int64_t) ((int32_t) rgba[i][BCOMP]); 1497 } 1498 lum32 = convert_integer_luminance64(lum64, dst_bits, 1499 dst_is_signed, rgba_is_signed); 1500 switch (dst_type) { 1501 case GL_BYTE: 1502 case GL_UNSIGNED_BYTE: { 1503 GLbyte *dst = (GLbyte *) dstAddr; 1504 dst[i] = lum32; 1505 break; 1506 } 1507 case GL_SHORT: 1508 case GL_UNSIGNED_SHORT: { 1509 GLshort *dst = (GLshort *) dstAddr; 1510 dst[i] = lum32; 1511 break; 1512 } 1513 case GL_INT: 1514 case GL_UNSIGNED_INT: { 1515 GLint *dst = (GLint *) dstAddr; 1516 dst[i] = lum32; 1517 break; 1518 } 1519 } 1520 } 1521 return; 1522 case GL_LUMINANCE_ALPHA_INTEGER_EXT: 1523 for (i = 0; i < n; i++) { 1524 if (!rgba_is_signed) { 1525 lum64 = (uint64_t) rgba[i][RCOMP] + 1526 (uint64_t) rgba[i][GCOMP] + 1527 (uint64_t) rgba[i][BCOMP]; 1528 } else { 1529 lum64 = (int64_t) ((int32_t) rgba[i][RCOMP]) + 1530 (int64_t) ((int32_t) rgba[i][GCOMP]) + 1531 (int64_t) ((int32_t) rgba[i][BCOMP]); 1532 } 1533 lum32 = convert_integer_luminance64(lum64, dst_bits, 1534 dst_is_signed, rgba_is_signed); 1535 alpha = convert_integer(rgba[i][ACOMP], dst_bits, 1536 dst_is_signed, rgba_is_signed); 1537 switch (dst_type) { 1538 case GL_BYTE: 1539 case GL_UNSIGNED_BYTE: { 1540 GLbyte *dst = (GLbyte *) dstAddr; 1541 dst[2*i] = lum32; 1542 dst[2*i+1] = alpha; 1543 break; 1544 } 1545 case GL_SHORT: 1546 case GL_UNSIGNED_SHORT: { 1547 GLshort *dst = (GLshort *) dstAddr; 1548 dst[i] = lum32; 1549 dst[2*i+1] = alpha; 1550 break; 1551 } 1552 case GL_INT: 1553 case GL_UNSIGNED_INT: { 1554 GLint *dst = (GLint *) dstAddr; 1555 dst[i] = lum32; 1556 dst[2*i+1] = alpha; 1557 break; 1558 } 1559 } 1560 } 1561 return; 1562 } 1563 } 1564 1565 GLfloat * 1566 _mesa_unpack_color_index_to_rgba_float(struct gl_context *ctx, GLuint dims, 1567 const void *src, GLenum srcFormat, GLenum srcType, 1568 int srcWidth, int srcHeight, int srcDepth, 1569 const struct gl_pixelstore_attrib *srcPacking, 1570 GLbitfield transferOps) 1571 { 1572 int count, img; 1573 GLuint *indexes; 1574 GLfloat *rgba, *dstPtr; 1575 1576 count = srcWidth * srcHeight; 1577 indexes = malloc(count * sizeof(GLuint)); 1578 if (!indexes) { 1579 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking"); 1580 return NULL; 1581 } 1582 1583 rgba = malloc(4 * count * srcDepth * sizeof(GLfloat)); 1584 if (!rgba) { 1585 free(indexes); 1586 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking"); 1587 return NULL; 1588 } 1589 1590 /* Convert indexes to RGBA float */ 1591 dstPtr = rgba; 1592 for (img = 0; img < srcDepth; img++) { 1593 const GLubyte *srcPtr = 1594 (const GLubyte *) _mesa_image_address(dims, srcPacking, src, 1595 srcWidth, srcHeight, 1596 srcFormat, srcType, 1597 img, 0, 0); 1598 1599 extract_uint_indexes(count, indexes, srcFormat, srcType, srcPtr, srcPacking); 1600 1601 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) 1602 _mesa_shift_and_offset_ci(ctx, count, indexes); 1603 1604 _mesa_map_ci_to_rgba(ctx, count, indexes, (float (*)[4])dstPtr); 1605 1606 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting 1607 * with color indexes. 1608 */ 1609 transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT); 1610 _mesa_apply_rgba_transfer_ops(ctx, transferOps, count, (float (*)[4])dstPtr); 1611 1612 dstPtr += srcHeight * srcWidth * 4; 1613 } 1614 1615 free(indexes); 1616 1617 return rgba; 1618 } 1619 1620 GLubyte * 1621 _mesa_unpack_color_index_to_rgba_ubyte(struct gl_context *ctx, GLuint dims, 1622 const void *src, GLenum srcFormat, GLenum srcType, 1623 int srcWidth, int srcHeight, int srcDepth, 1624 const struct gl_pixelstore_attrib *srcPacking, 1625 GLbitfield transferOps) 1626 { 1627 GLfloat *rgba; 1628 GLubyte *dst; 1629 int count, i; 1630 1631 transferOps |= IMAGE_CLAMP_BIT; 1632 rgba = _mesa_unpack_color_index_to_rgba_float(ctx, dims, 1633 src, srcFormat, srcType, 1634 srcWidth, srcHeight, srcDepth, 1635 srcPacking, transferOps); 1636 1637 count = srcWidth * srcHeight * srcDepth; 1638 dst = malloc(count * 4 * sizeof(GLubyte)); 1639 for (i = 0; i < count; i++) { 1640 CLAMPED_FLOAT_TO_UBYTE(dst[i * 4 + 0], rgba[i * 4 + 0]); 1641 CLAMPED_FLOAT_TO_UBYTE(dst[i * 4 + 1], rgba[i * 4 + 1]); 1642 CLAMPED_FLOAT_TO_UBYTE(dst[i * 4 + 2], rgba[i * 4 + 2]); 1643 CLAMPED_FLOAT_TO_UBYTE(dst[i * 4 + 3], rgba[i * 4 + 3]); 1644 } 1645 1646 free(rgba); 1647 1648 return dst; 1649 } 1650
