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