image.c revision d488af5b34e390a9b81dac96053bd45f34ffffff
1/* $Id: image.c,v 1.64 2002/03/13 04:34:32 brianp Exp $ */ 2 3/* 4 * Mesa 3-D graphics library 5 * Version: 4.1 6 * 7 * Copyright (C) 1999-2002 Brian Paul All Rights Reserved. 8 * 9 * Permission is hereby granted, free of charge, to any person obtaining a 10 * copy of this software and associated documentation files (the "Software"), 11 * to deal in the Software without restriction, including without limitation 12 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 13 * and/or sell copies of the Software, and to permit persons to whom the 14 * Software is furnished to do so, subject to the following conditions: 15 * 16 * The above copyright notice and this permission notice shall be included 17 * in all copies or substantial portions of the Software. 18 * 19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 20 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 22 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN 23 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 24 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 25 */ 26 27 28#ifdef PC_HEADER 29#include "all.h" 30#else 31#include "glheader.h" 32#include "colormac.h" 33#include "context.h" 34#include "image.h" 35#include "histogram.h" 36#include "macros.h" 37#include "mem.h" 38#include "mmath.h" 39#include "pixel.h" 40#include "mtypes.h" 41#endif 42 43 44 45/* 46 * These are the image packing parameters for Mesa's internal images. 47 * That is, _mesa_unpack_image() returns image data in this format. 48 * When we execute image commands (glDrawPixels, glTexImage, etc) 49 * from within display lists we have to be sure to set the current 50 * unpacking params to these values! 51 */ 52const struct gl_pixelstore_attrib _mesa_native_packing = { 53 1, /* Alignment */ 54 0, /* RowLength */ 55 0, /* SkipPixels */ 56 0, /* SkipRows */ 57 0, /* ImageHeight */ 58 0, /* SkipImages */ 59 GL_FALSE, /* SwapBytes */ 60 GL_FALSE /* LsbFirst */ 61}; 62 63 64 65/* 66 * Flip the 8 bits in each byte of the given array. 67 * 68 * XXX try this trick to flip bytes someday: 69 * v = ((v & 0x55555555) << 1) | ((v >> 1) & 0x55555555); 70 * v = ((v & 0x33333333) << 2) | ((v >> 2) & 0x33333333); 71 * v = ((v & 0x0f0f0f0f) << 4) | ((v >> 4) & 0x0f0f0f0f); 72 */ 73static void 74flip_bytes( GLubyte *p, GLuint n ) 75{ 76 register GLuint i, a, b; 77 78 for (i=0;i<n;i++) { 79 b = (GLuint) p[i]; /* words are often faster than bytes */ 80 a = ((b & 0x01) << 7) | 81 ((b & 0x02) << 5) | 82 ((b & 0x04) << 3) | 83 ((b & 0x08) << 1) | 84 ((b & 0x10) >> 1) | 85 ((b & 0x20) >> 3) | 86 ((b & 0x40) >> 5) | 87 ((b & 0x80) >> 7); 88 p[i] = (GLubyte) a; 89 } 90} 91 92 93/* 94 * Flip the order of the 2 bytes in each word in the given array. 95 */ 96void 97_mesa_swap2( GLushort *p, GLuint n ) 98{ 99 register GLuint i; 100 101 for (i=0;i<n;i++) { 102 p[i] = (p[i] >> 8) | ((p[i] << 8) & 0xff00); 103 } 104} 105 106 107 108/* 109 * Flip the order of the 4 bytes in each word in the given array. 110 */ 111void 112_mesa_swap4( GLuint *p, GLuint n ) 113{ 114 register GLuint i, a, b; 115 116 for (i=0;i<n;i++) { 117 b = p[i]; 118 a = (b >> 24) 119 | ((b >> 8) & 0xff00) 120 | ((b << 8) & 0xff0000) 121 | ((b << 24) & 0xff000000); 122 p[i] = a; 123 } 124} 125 126 127 128 129/* 130 * Return the size, in bytes, of the given GL datatype. 131 * Return 0 if GL_BITMAP. 132 * Return -1 if invalid type enum. 133 */ 134GLint _mesa_sizeof_type( GLenum type ) 135{ 136 switch (type) { 137 case GL_BITMAP: 138 return 0; 139 case GL_UNSIGNED_BYTE: 140 return sizeof(GLubyte); 141 case GL_BYTE: 142 return sizeof(GLbyte); 143 case GL_UNSIGNED_SHORT: 144 return sizeof(GLushort); 145 case GL_SHORT: 146 return sizeof(GLshort); 147 case GL_UNSIGNED_INT: 148 return sizeof(GLuint); 149 case GL_INT: 150 return sizeof(GLint); 151 case GL_FLOAT: 152 return sizeof(GLfloat); 153 default: 154 return -1; 155 } 156} 157 158 159/* 160 * Same as _mesa_sizeof_packed_type() but we also accept the 161 * packed pixel format datatypes. 162 */ 163GLint _mesa_sizeof_packed_type( GLenum type ) 164{ 165 switch (type) { 166 case GL_BITMAP: 167 return 0; 168 case GL_UNSIGNED_BYTE: 169 return sizeof(GLubyte); 170 case GL_BYTE: 171 return sizeof(GLbyte); 172 case GL_UNSIGNED_SHORT: 173 return sizeof(GLushort); 174 case GL_SHORT: 175 return sizeof(GLshort); 176 case GL_UNSIGNED_INT: 177 return sizeof(GLuint); 178 case GL_INT: 179 return sizeof(GLint); 180 case GL_FLOAT: 181 return sizeof(GLfloat); 182 case GL_UNSIGNED_BYTE_3_3_2: 183 return sizeof(GLubyte); 184 case GL_UNSIGNED_BYTE_2_3_3_REV: 185 return sizeof(GLubyte); 186 case GL_UNSIGNED_SHORT_5_6_5: 187 return sizeof(GLshort); 188 case GL_UNSIGNED_SHORT_5_6_5_REV: 189 return sizeof(GLshort); 190 case GL_UNSIGNED_SHORT_4_4_4_4: 191 return sizeof(GLshort); 192 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 193 return sizeof(GLshort); 194 case GL_UNSIGNED_SHORT_5_5_5_1: 195 return sizeof(GLshort); 196 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 197 return sizeof(GLshort); 198 case GL_UNSIGNED_INT_8_8_8_8: 199 return sizeof(GLuint); 200 case GL_UNSIGNED_INT_8_8_8_8_REV: 201 return sizeof(GLuint); 202 case GL_UNSIGNED_INT_10_10_10_2: 203 return sizeof(GLuint); 204 case GL_UNSIGNED_INT_2_10_10_10_REV: 205 return sizeof(GLuint); 206 default: 207 return -1; 208 } 209} 210 211 212 213/* 214 * Return the number of components in a GL enum pixel type. 215 * Return -1 if bad format. 216 */ 217GLint _mesa_components_in_format( GLenum format ) 218{ 219 switch (format) { 220 case GL_COLOR_INDEX: 221 case GL_COLOR_INDEX1_EXT: 222 case GL_COLOR_INDEX2_EXT: 223 case GL_COLOR_INDEX4_EXT: 224 case GL_COLOR_INDEX8_EXT: 225 case GL_COLOR_INDEX12_EXT: 226 case GL_COLOR_INDEX16_EXT: 227 case GL_STENCIL_INDEX: 228 case GL_DEPTH_COMPONENT: 229 case GL_RED: 230 case GL_GREEN: 231 case GL_BLUE: 232 case GL_ALPHA: 233 case GL_LUMINANCE: 234 case GL_INTENSITY: 235 return 1; 236 case GL_LUMINANCE_ALPHA: 237 return 2; 238 case GL_RGB: 239 return 3; 240 case GL_RGBA: 241 return 4; 242 case GL_BGR: 243 return 3; 244 case GL_BGRA: 245 return 4; 246 case GL_ABGR_EXT: 247 return 4; 248 default: 249 return -1; 250 } 251} 252 253 254/* 255 * Return bytes per pixel for given format and type 256 * Return -1 if bad format or type. 257 */ 258GLint _mesa_bytes_per_pixel( GLenum format, GLenum type ) 259{ 260 GLint comps = _mesa_components_in_format( format ); 261 if (comps < 0) 262 return -1; 263 264 switch (type) { 265 case GL_BITMAP: 266 return 0; /* special case */ 267 case GL_BYTE: 268 case GL_UNSIGNED_BYTE: 269 return comps * sizeof(GLubyte); 270 case GL_SHORT: 271 case GL_UNSIGNED_SHORT: 272 return comps * sizeof(GLshort); 273 case GL_INT: 274 case GL_UNSIGNED_INT: 275 return comps * sizeof(GLint); 276 case GL_FLOAT: 277 return comps * sizeof(GLfloat); 278 case GL_UNSIGNED_BYTE_3_3_2: 279 case GL_UNSIGNED_BYTE_2_3_3_REV: 280 if (format == GL_RGB || format == GL_BGR) 281 return sizeof(GLubyte); 282 else 283 return -1; /* error */ 284 case GL_UNSIGNED_SHORT_5_6_5: 285 case GL_UNSIGNED_SHORT_5_6_5_REV: 286 if (format == GL_RGB || format == GL_BGR) 287 return sizeof(GLshort); 288 else 289 return -1; /* error */ 290 case GL_UNSIGNED_SHORT_4_4_4_4: 291 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 292 case GL_UNSIGNED_SHORT_5_5_5_1: 293 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 294 if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT) 295 return sizeof(GLushort); 296 else 297 return -1; 298 case GL_UNSIGNED_INT_8_8_8_8: 299 case GL_UNSIGNED_INT_8_8_8_8_REV: 300 case GL_UNSIGNED_INT_10_10_10_2: 301 case GL_UNSIGNED_INT_2_10_10_10_REV: 302 if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT) 303 return sizeof(GLuint); 304 else 305 return -1; 306 default: 307 return -1; 308 } 309} 310 311 312/* 313 * Test if the given pixel format and type are legal. 314 * Return GL_TRUE for legal, GL_FALSE for illegal. 315 */ 316GLboolean 317_mesa_is_legal_format_and_type( GLenum format, GLenum type ) 318{ 319 switch (format) { 320 case GL_COLOR_INDEX: 321 case GL_STENCIL_INDEX: 322 switch (type) { 323 case GL_BITMAP: 324 case GL_BYTE: 325 case GL_UNSIGNED_BYTE: 326 case GL_SHORT: 327 case GL_UNSIGNED_SHORT: 328 case GL_INT: 329 case GL_UNSIGNED_INT: 330 case GL_FLOAT: 331 return GL_TRUE; 332 default: 333 return GL_FALSE; 334 } 335 case GL_RED: 336 case GL_GREEN: 337 case GL_BLUE: 338 case GL_ALPHA: 339 case GL_INTENSITY: 340 case GL_LUMINANCE: 341 case GL_LUMINANCE_ALPHA: 342 case GL_DEPTH_COMPONENT: 343 switch (type) { 344 case GL_BYTE: 345 case GL_UNSIGNED_BYTE: 346 case GL_SHORT: 347 case GL_UNSIGNED_SHORT: 348 case GL_INT: 349 case GL_UNSIGNED_INT: 350 case GL_FLOAT: 351 return GL_TRUE; 352 default: 353 return GL_FALSE; 354 } 355 case GL_RGB: 356 case GL_BGR: 357 switch (type) { 358 case GL_BYTE: 359 case GL_UNSIGNED_BYTE: 360 case GL_SHORT: 361 case GL_UNSIGNED_SHORT: 362 case GL_INT: 363 case GL_UNSIGNED_INT: 364 case GL_FLOAT: 365 case GL_UNSIGNED_BYTE_3_3_2: 366 case GL_UNSIGNED_BYTE_2_3_3_REV: 367 case GL_UNSIGNED_SHORT_5_6_5: 368 case GL_UNSIGNED_SHORT_5_6_5_REV: 369 return GL_TRUE; 370 default: 371 return GL_FALSE; 372 } 373 case GL_RGBA: 374 case GL_BGRA: 375 case GL_ABGR_EXT: 376 switch (type) { 377 case GL_BYTE: 378 case GL_UNSIGNED_BYTE: 379 case GL_SHORT: 380 case GL_UNSIGNED_SHORT: 381 case GL_INT: 382 case GL_UNSIGNED_INT: 383 case GL_FLOAT: 384 case GL_UNSIGNED_SHORT_4_4_4_4: 385 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 386 case GL_UNSIGNED_SHORT_5_5_5_1: 387 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 388 case GL_UNSIGNED_INT_8_8_8_8: 389 case GL_UNSIGNED_INT_8_8_8_8_REV: 390 case GL_UNSIGNED_INT_10_10_10_2: 391 case GL_UNSIGNED_INT_2_10_10_10_REV: 392 return GL_TRUE; 393 default: 394 return GL_FALSE; 395 } 396 default: 397 ; /* fall-through */ 398 } 399 return GL_FALSE; 400} 401 402 403 404/* 405 * Return the address of a pixel in an image (actually a volume). 406 * Pixel unpacking/packing parameters are observed according to 'packing'. 407 * Input: image - start of image data 408 * width, height - size of image 409 * format - image format 410 * type - pixel component type 411 * packing - the pixelstore attributes 412 * img - which image in the volume (0 for 1D or 2D images) 413 * row, column - location of pixel in the image 414 * Return: address of pixel at (image,row,column) in image or NULL if error. 415 */ 416GLvoid * 417_mesa_image_address( const struct gl_pixelstore_attrib *packing, 418 const GLvoid *image, GLsizei width, 419 GLsizei height, GLenum format, GLenum type, 420 GLint img, GLint row, GLint column ) 421{ 422 GLint alignment; /* 1, 2 or 4 */ 423 GLint pixels_per_row; 424 GLint rows_per_image; 425 GLint skiprows; 426 GLint skippixels; 427 GLint skipimages; /* for 3-D volume images */ 428 GLubyte *pixel_addr; 429 430 alignment = packing->Alignment; 431 if (packing->RowLength > 0) { 432 pixels_per_row = packing->RowLength; 433 } 434 else { 435 pixels_per_row = width; 436 } 437 if (packing->ImageHeight > 0) { 438 rows_per_image = packing->ImageHeight; 439 } 440 else { 441 rows_per_image = height; 442 } 443 skiprows = packing->SkipRows; 444 skippixels = packing->SkipPixels; 445 skipimages = packing->SkipImages; 446 447 if (type==GL_BITMAP) { 448 /* BITMAP data */ 449 GLint comp_per_pixel; /* components per pixel */ 450 GLint bytes_per_comp; /* bytes per component */ 451 GLint bytes_per_row; 452 GLint bytes_per_image; 453 454 /* Compute bytes per component */ 455 bytes_per_comp = _mesa_sizeof_packed_type( type ); 456 if (bytes_per_comp<0) { 457 return NULL; 458 } 459 460 /* Compute number of components per pixel */ 461 comp_per_pixel = _mesa_components_in_format( format ); 462 if (comp_per_pixel<0 && type != GL_BITMAP) { 463 return NULL; 464 } 465 466 bytes_per_row = alignment 467 * CEILING( comp_per_pixel*pixels_per_row, 8*alignment ); 468 469 bytes_per_image = bytes_per_row * rows_per_image; 470 471 pixel_addr = (GLubyte *) image 472 + (skipimages + img) * bytes_per_image 473 + (skiprows + row) * bytes_per_row 474 + (skippixels + column) / 8; 475 } 476 else { 477 /* Non-BITMAP data */ 478 GLint bytes_per_pixel, bytes_per_row, remainder, bytes_per_image; 479 480 bytes_per_pixel = _mesa_bytes_per_pixel( format, type ); 481 482 /* The pixel type and format should have been error checked earlier */ 483 assert(bytes_per_pixel > 0); 484 485 bytes_per_row = pixels_per_row * bytes_per_pixel; 486 remainder = bytes_per_row % alignment; 487 if (remainder > 0) 488 bytes_per_row += (alignment - remainder); 489 490 ASSERT(bytes_per_row % alignment == 0); 491 492 bytes_per_image = bytes_per_row * rows_per_image; 493 494 /* compute final pixel address */ 495 pixel_addr = (GLubyte *) image 496 + (skipimages + img) * bytes_per_image 497 + (skiprows + row) * bytes_per_row 498 + (skippixels + column) * bytes_per_pixel; 499 } 500 501 return (GLvoid *) pixel_addr; 502} 503 504 505 506/* 507 * Compute the stride between image rows (in bytes) for the given 508 * pixel packing parameters and image width, format and type. 509 */ 510GLint 511_mesa_image_row_stride( const struct gl_pixelstore_attrib *packing, 512 GLint width, GLenum format, GLenum type ) 513{ 514 ASSERT(packing); 515 if (type == GL_BITMAP) { 516 /* BITMAP data */ 517 if (packing->RowLength == 0) { 518 GLint bytes = (width + 7) / 8; 519 return bytes; 520 } 521 else { 522 GLint bytes = (packing->RowLength + 7) / 8; 523 return bytes; 524 } 525 } 526 else { 527 /* Non-BITMAP data */ 528 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type); 529 GLint bytesPerRow, remainder; 530 if (bytesPerPixel <= 0) 531 return -1; /* error */ 532 if (packing->RowLength == 0) { 533 bytesPerRow = bytesPerPixel * width; 534 } 535 else { 536 bytesPerRow = bytesPerPixel * packing->RowLength; 537 } 538 remainder = bytesPerRow % packing->Alignment; 539 if (remainder > 0) 540 bytesPerRow += (packing->Alignment - remainder); 541 return bytesPerRow; 542 } 543} 544 545 546 547/* 548 * Compute the stride between images in a 3D texture (in bytes) for the given 549 * pixel packing parameters and image width, format and type. 550 */ 551GLint 552_mesa_image_image_stride( const struct gl_pixelstore_attrib *packing, 553 GLint width, GLint height, 554 GLenum format, GLenum type ) 555{ 556 ASSERT(packing); 557 ASSERT(type != GL_BITMAP); 558 559 { 560 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type); 561 GLint bytesPerRow, bytesPerImage, remainder; 562 563 if (bytesPerPixel <= 0) 564 return -1; /* error */ 565 if (packing->RowLength == 0) { 566 bytesPerRow = bytesPerPixel * width; 567 } 568 else { 569 bytesPerRow = bytesPerPixel * packing->RowLength; 570 } 571 remainder = bytesPerRow % packing->Alignment; 572 if (remainder > 0) 573 bytesPerRow += (packing->Alignment - remainder); 574 575 if (packing->ImageHeight == 0) 576 bytesPerImage = bytesPerRow * height; 577 else 578 bytesPerImage = bytesPerRow * packing->ImageHeight; 579 580 return bytesPerImage; 581 } 582} 583 584 585 586 587/* 588 * Unpack a 32x32 pixel polygon stipple from user memory using the 589 * current pixel unpack settings. 590 */ 591void 592_mesa_unpack_polygon_stipple( const GLubyte *pattern, GLuint dest[32], 593 const struct gl_pixelstore_attrib *unpacking ) 594{ 595 GLubyte *ptrn = (GLubyte *) _mesa_unpack_bitmap( 32, 32, pattern, unpacking ); 596 if (ptrn) { 597 /* Convert pattern from GLubytes to GLuints and handle big/little 598 * endian differences 599 */ 600 GLubyte *p = ptrn; 601 GLint i; 602 for (i = 0; i < 32; i++) { 603 dest[i] = (p[0] << 24) 604 | (p[1] << 16) 605 | (p[2] << 8) 606 | (p[3] ); 607 p += 4; 608 } 609 FREE(ptrn); 610 } 611} 612 613 614 615/* 616 * Pack polygon stipple into user memory given current pixel packing 617 * settings. 618 */ 619void 620_mesa_pack_polygon_stipple( const GLuint pattern[32], GLubyte *dest, 621 const struct gl_pixelstore_attrib *packing ) 622{ 623 /* Convert pattern from GLuints to GLubytes to handle big/little 624 * endian differences. 625 */ 626 GLubyte ptrn[32*4]; 627 GLint i; 628 for (i = 0; i < 32; i++) { 629 ptrn[i * 4 + 0] = (GLubyte) ((pattern[i] >> 24) & 0xff); 630 ptrn[i * 4 + 1] = (GLubyte) ((pattern[i] >> 16) & 0xff); 631 ptrn[i * 4 + 2] = (GLubyte) ((pattern[i] >> 8 ) & 0xff); 632 ptrn[i * 4 + 3] = (GLubyte) ((pattern[i] ) & 0xff); 633 } 634 635 _mesa_pack_bitmap(32, 32, ptrn, dest, packing); 636} 637 638 639/* 640 * Unpack bitmap data. Resulting data will be in most-significant-bit-first 641 * order with row alignment = 1 byte. 642 */ 643GLvoid * 644_mesa_unpack_bitmap( GLint width, GLint height, const GLubyte *pixels, 645 const struct gl_pixelstore_attrib *packing ) 646{ 647 GLint bytes, row, width_in_bytes; 648 GLubyte *buffer, *dst; 649 650 if (!pixels) 651 return NULL; 652 653 /* Alloc dest storage */ 654 bytes = ((width + 7) / 8 * height); 655 buffer = (GLubyte *) MALLOC( bytes ); 656 if (!buffer) 657 return NULL; 658 659 660 width_in_bytes = CEILING( width, 8 ); 661 dst = buffer; 662 for (row = 0; row < height; row++) { 663 const GLubyte *src = (const GLubyte *) 664 _mesa_image_address(packing, pixels, width, height, 665 GL_COLOR_INDEX, GL_BITMAP, 0, row, 0); 666 if (!src) { 667 FREE(buffer); 668 return NULL; 669 } 670 671 if (packing->SkipPixels == 0) { 672 MEMCPY( dst, src, width_in_bytes ); 673 if (packing->LsbFirst) { 674 flip_bytes( dst, width_in_bytes ); 675 } 676 } 677 else { 678 /* handling SkipPixels is a bit tricky (no pun intended!) */ 679 GLint i; 680 if (packing->LsbFirst) { 681 GLubyte srcMask = 1 << (packing->SkipPixels & 0x7); 682 GLubyte dstMask = 128; 683 const GLubyte *s = src; 684 GLubyte *d = dst; 685 *d = 0; 686 for (i = 0; i < width; i++) { 687 if (*s & srcMask) { 688 *d |= dstMask; 689 } 690 if (srcMask == 128) { 691 srcMask = 1; 692 s++; 693 } 694 else { 695 srcMask = srcMask << 1; 696 } 697 if (dstMask == 1) { 698 dstMask = 128; 699 d++; 700 *d = 0; 701 } 702 else { 703 dstMask = dstMask >> 1; 704 } 705 } 706 } 707 else { 708 GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7); 709 GLubyte dstMask = 128; 710 const GLubyte *s = src; 711 GLubyte *d = dst; 712 *d = 0; 713 for (i = 0; i < width; i++) { 714 if (*s & srcMask) { 715 *d |= dstMask; 716 } 717 if (srcMask == 1) { 718 srcMask = 128; 719 s++; 720 } 721 else { 722 srcMask = srcMask >> 1; 723 } 724 if (dstMask == 1) { 725 dstMask = 128; 726 d++; 727 *d = 0; 728 } 729 else { 730 dstMask = dstMask >> 1; 731 } 732 } 733 } 734 } 735 dst += width_in_bytes; 736 } 737 738 return buffer; 739} 740 741 742/* 743 * Pack bitmap data. 744 */ 745void 746_mesa_pack_bitmap( GLint width, GLint height, const GLubyte *source, 747 GLubyte *dest, const struct gl_pixelstore_attrib *packing ) 748{ 749 GLint row, width_in_bytes; 750 const GLubyte *src; 751 752 if (!source) 753 return; 754 755 width_in_bytes = CEILING( width, 8 ); 756 src = source; 757 for (row = 0; row < height; row++) { 758 GLubyte *dst = (GLubyte *) _mesa_image_address( packing, dest, 759 width, height, GL_COLOR_INDEX, GL_BITMAP, 0, row, 0 ); 760 if (!dst) 761 return; 762 763 if (packing->SkipPixels == 0) { 764 MEMCPY( dst, src, width_in_bytes ); 765 if (packing->LsbFirst) { 766 flip_bytes( dst, width_in_bytes ); 767 } 768 } 769 else { 770 /* handling SkipPixels is a bit tricky (no pun intended!) */ 771 GLint i; 772 if (packing->LsbFirst) { 773 GLubyte srcMask = 1 << (packing->SkipPixels & 0x7); 774 GLubyte dstMask = 128; 775 const GLubyte *s = src; 776 GLubyte *d = dst; 777 *d = 0; 778 for (i = 0; i < width; i++) { 779 if (*s & srcMask) { 780 *d |= dstMask; 781 } 782 if (srcMask == 128) { 783 srcMask = 1; 784 s++; 785 } 786 else { 787 srcMask = srcMask << 1; 788 } 789 if (dstMask == 1) { 790 dstMask = 128; 791 d++; 792 *d = 0; 793 } 794 else { 795 dstMask = dstMask >> 1; 796 } 797 } 798 } 799 else { 800 GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7); 801 GLubyte dstMask = 128; 802 const GLubyte *s = src; 803 GLubyte *d = dst; 804 *d = 0; 805 for (i = 0; i < width; i++) { 806 if (*s & srcMask) { 807 *d |= dstMask; 808 } 809 if (srcMask == 1) { 810 srcMask = 128; 811 s++; 812 } 813 else { 814 srcMask = srcMask >> 1; 815 } 816 if (dstMask == 1) { 817 dstMask = 128; 818 d++; 819 *d = 0; 820 } 821 else { 822 dstMask = dstMask >> 1; 823 } 824 } 825 } 826 } 827 src += width_in_bytes; 828 } 829} 830 831 832 833/* 834 * Used to pack an array [][4] of RGBA GLchan colors as specified 835 * by the dstFormat, dstType and dstPacking. Used by glReadPixels, 836 * glGetConvolutionFilter(), etc. 837 */ 838void 839_mesa_pack_float_rgba_span( GLcontext *ctx, 840 GLuint n, CONST GLfloat rgbaIn[][4], 841 GLenum dstFormat, GLenum dstType, 842 GLvoid *dstAddr, 843 const struct gl_pixelstore_attrib *dstPacking, 844 GLuint transferOps ) 845{ 846 const GLint comps = _mesa_components_in_format(dstFormat); 847 GLfloat luminance[MAX_WIDTH]; 848 GLfloat (*rgba)[4]; 849 GLuint i; 850 851 if (transferOps) { 852 /* make copy of incoming data */ 853 DEFMARRAY(GLfloat, rgbaCopy, MAX_WIDTH, 4); /* mac 32k limitation */ 854 CHECKARRAY(rgbaCopy, return); /* mac 32k limitation */ 855 856 for (i = 0; i < n; i++) { 857 rgbaCopy[i][0] = rgbaIn[i][0]; 858 rgbaCopy[i][1] = rgbaIn[i][1]; 859 rgbaCopy[i][2] = rgbaIn[i][2]; 860 rgbaCopy[i][3] = rgbaIn[i][3]; 861 } 862 863 rgba = (GLfloat (*)[4]) rgbaCopy; 864 865 /* scale & bias */ 866 if (transferOps & IMAGE_SCALE_BIAS_BIT) { 867 _mesa_scale_and_bias_rgba(ctx, n, rgba, 868 ctx->Pixel.RedScale, ctx->Pixel.GreenScale, 869 ctx->Pixel.BlueScale, ctx->Pixel.AlphaScale, 870 ctx->Pixel.RedBias, ctx->Pixel.GreenBias, 871 ctx->Pixel.BlueBias, ctx->Pixel.AlphaBias); 872 } 873 /* color map lookup */ 874 if (transferOps & IMAGE_MAP_COLOR_BIT) { 875 _mesa_map_rgba( ctx, n, rgba ); 876 } 877 /* GL_COLOR_TABLE lookup */ 878 if (transferOps & IMAGE_COLOR_TABLE_BIT) { 879 _mesa_lookup_rgba(&ctx->ColorTable, n, rgba); 880 } 881 /* convolution */ 882 if (transferOps & IMAGE_CONVOLUTION_BIT) { 883 /* this has to be done in the calling code */ 884 } 885 /* GL_POST_CONVOLUTION_RED/GREEN/BLUE/ALPHA_SCALE/BIAS */ 886 if (transferOps & IMAGE_POST_CONVOLUTION_SCALE_BIAS) { 887 _mesa_scale_and_bias_rgba(ctx, n, rgba, 888 ctx->Pixel.PostConvolutionScale[RCOMP], 889 ctx->Pixel.PostConvolutionScale[GCOMP], 890 ctx->Pixel.PostConvolutionScale[BCOMP], 891 ctx->Pixel.PostConvolutionScale[ACOMP], 892 ctx->Pixel.PostConvolutionBias[RCOMP], 893 ctx->Pixel.PostConvolutionBias[GCOMP], 894 ctx->Pixel.PostConvolutionBias[BCOMP], 895 ctx->Pixel.PostConvolutionBias[ACOMP]); 896 } 897 /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */ 898 if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) { 899 _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, n, rgba); 900 } 901 /* color matrix transform */ 902 if (transferOps & IMAGE_COLOR_MATRIX_BIT) { 903 _mesa_transform_rgba(ctx, n, rgba); 904 } 905 /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */ 906 if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) { 907 _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, n, rgba); 908 } 909 /* update histogram count */ 910 if (transferOps & IMAGE_HISTOGRAM_BIT) { 911 _mesa_update_histogram(ctx, n, (CONST GLfloat (*)[4]) rgba); 912 } 913 /* min/max here */ 914 if (transferOps & IMAGE_MIN_MAX_BIT) { 915 _mesa_update_minmax(ctx, n, (CONST GLfloat (*)[4]) rgba); 916 if (ctx->MinMax.Sink) { 917 UNDEFARRAY(rgbaCopy); /* mac 32k limitation */ 918 return; 919 } 920 } 921 UNDEFARRAY(rgbaCopy); /* mac 32k limitation */ 922 } 923 else { 924 /* use incoming data, not a copy */ 925 rgba = (GLfloat (*)[4]) rgbaIn; 926 } 927 928 /* XXX clamp rgba to [0,1]? */ 929 930 931 if (dstFormat == GL_LUMINANCE || dstFormat == GL_LUMINANCE_ALPHA) { 932 for (i = 0; i < n; i++) { 933 GLfloat sum = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP]; 934#if CHAN_TYPE == GL_FLOAT 935 luminance[i] = sum; 936#else 937 luminance[i] = CLAMP(sum, 0.0F, 1.0F); 938#endif 939 } 940 } 941 942 /* 943 * Pack/store the pixels. Ugh! Lots of cases!!! 944 */ 945 switch (dstType) { 946 case GL_UNSIGNED_BYTE: 947 { 948 GLubyte *dst = (GLubyte *) dstAddr; 949 switch (dstFormat) { 950 case GL_RED: 951 for (i=0;i<n;i++) 952 dst[i] = FLOAT_TO_UBYTE(rgba[i][RCOMP]); 953 break; 954 case GL_GREEN: 955 for (i=0;i<n;i++) 956 dst[i] = FLOAT_TO_UBYTE(rgba[i][GCOMP]); 957 break; 958 case GL_BLUE: 959 for (i=0;i<n;i++) 960 dst[i] = FLOAT_TO_UBYTE(rgba[i][BCOMP]); 961 break; 962 case GL_ALPHA: 963 for (i=0;i<n;i++) 964 dst[i] = FLOAT_TO_UBYTE(rgba[i][ACOMP]); 965 break; 966 case GL_LUMINANCE: 967 for (i=0;i<n;i++) 968 dst[i] = FLOAT_TO_UBYTE(luminance[i]); 969 break; 970 case GL_LUMINANCE_ALPHA: 971 for (i=0;i<n;i++) { 972 dst[i*2+0] = FLOAT_TO_UBYTE(luminance[i]); 973 dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][ACOMP]); 974 } 975 break; 976 case GL_RGB: 977 for (i=0;i<n;i++) { 978 dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]); 979 dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]); 980 dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]); 981 } 982 break; 983 case GL_RGBA: 984 for (i=0;i<n;i++) { 985 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]); 986 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]); 987 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]); 988 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]); 989 } 990 break; 991 case GL_BGR: 992 for (i=0;i<n;i++) { 993 dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]); 994 dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]); 995 dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]); 996 } 997 break; 998 case GL_BGRA: 999 for (i=0;i<n;i++) { 1000 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]); 1001 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]); 1002 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]); 1003 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]); 1004 } 1005 break; 1006 case GL_ABGR_EXT: 1007 for (i=0;i<n;i++) { 1008 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][ACOMP]); 1009 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][BCOMP]); 1010 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][GCOMP]); 1011 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][RCOMP]); 1012 } 1013 break; 1014 default: 1015 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); 1016 } 1017 } 1018 break; 1019 case GL_BYTE: 1020 { 1021 GLbyte *dst = (GLbyte *) dstAddr; 1022 switch (dstFormat) { 1023 case GL_RED: 1024 for (i=0;i<n;i++) 1025 dst[i] = FLOAT_TO_BYTE(rgba[i][RCOMP]); 1026 break; 1027 case GL_GREEN: 1028 for (i=0;i<n;i++) 1029 dst[i] = FLOAT_TO_BYTE(rgba[i][GCOMP]); 1030 break; 1031 case GL_BLUE: 1032 for (i=0;i<n;i++) 1033 dst[i] = FLOAT_TO_BYTE(rgba[i][BCOMP]); 1034 break; 1035 case GL_ALPHA: 1036 for (i=0;i<n;i++) 1037 dst[i] = FLOAT_TO_BYTE(rgba[i][ACOMP]); 1038 break; 1039 case GL_LUMINANCE: 1040 for (i=0;i<n;i++) 1041 dst[i] = FLOAT_TO_BYTE(luminance[i]); 1042 break; 1043 case GL_LUMINANCE_ALPHA: 1044 for (i=0;i<n;i++) { 1045 dst[i*2+0] = FLOAT_TO_BYTE(luminance[i]); 1046 dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][ACOMP]); 1047 } 1048 break; 1049 case GL_RGB: 1050 for (i=0;i<n;i++) { 1051 dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]); 1052 dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]); 1053 dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]); 1054 } 1055 break; 1056 case GL_RGBA: 1057 for (i=0;i<n;i++) { 1058 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]); 1059 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]); 1060 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]); 1061 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]); 1062 } 1063 break; 1064 case GL_BGR: 1065 for (i=0;i<n;i++) { 1066 dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]); 1067 dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]); 1068 dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]); 1069 } 1070 break; 1071 case GL_BGRA: 1072 for (i=0;i<n;i++) { 1073 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]); 1074 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]); 1075 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]); 1076 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]); 1077 } 1078 case GL_ABGR_EXT: 1079 for (i=0;i<n;i++) { 1080 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][ACOMP]); 1081 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][BCOMP]); 1082 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][GCOMP]); 1083 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][RCOMP]); 1084 } 1085 break; 1086 default: 1087 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); 1088 } 1089 } 1090 break; 1091 case GL_UNSIGNED_SHORT: 1092 { 1093 GLushort *dst = (GLushort *) dstAddr; 1094 switch (dstFormat) { 1095 case GL_RED: 1096 for (i=0;i<n;i++) 1097 dst[i] = FLOAT_TO_USHORT(rgba[i][RCOMP]); 1098 break; 1099 case GL_GREEN: 1100 for (i=0;i<n;i++) 1101 dst[i] = FLOAT_TO_USHORT(rgba[i][GCOMP]); 1102 break; 1103 case GL_BLUE: 1104 for (i=0;i<n;i++) 1105 dst[i] = FLOAT_TO_USHORT(rgba[i][BCOMP]); 1106 break; 1107 case GL_ALPHA: 1108 for (i=0;i<n;i++) 1109 dst[i] = FLOAT_TO_USHORT(rgba[i][ACOMP]); 1110 break; 1111 case GL_LUMINANCE: 1112 for (i=0;i<n;i++) 1113 dst[i] = FLOAT_TO_USHORT(luminance[i]); 1114 break; 1115 case GL_LUMINANCE_ALPHA: 1116 for (i=0;i<n;i++) { 1117 dst[i*2+0] = FLOAT_TO_USHORT(luminance[i]); 1118 dst[i*2+1] = FLOAT_TO_USHORT(rgba[i][ACOMP]); 1119 } 1120 break; 1121 case GL_RGB: 1122 for (i=0;i<n;i++) { 1123 dst[i*3+0] = FLOAT_TO_USHORT(rgba[i][RCOMP]); 1124 dst[i*3+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]); 1125 dst[i*3+2] = FLOAT_TO_USHORT(rgba[i][BCOMP]); 1126 } 1127 break; 1128 case GL_RGBA: 1129 for (i=0;i<n;i++) { 1130 dst[i*4+0] = FLOAT_TO_USHORT(rgba[i][RCOMP]); 1131 dst[i*4+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]); 1132 dst[i*4+2] = FLOAT_TO_USHORT(rgba[i][BCOMP]); 1133 dst[i*4+3] = FLOAT_TO_USHORT(rgba[i][ACOMP]); 1134 } 1135 break; 1136 case GL_BGR: 1137 for (i=0;i<n;i++) { 1138 dst[i*3+0] = FLOAT_TO_USHORT(rgba[i][BCOMP]); 1139 dst[i*3+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]); 1140 dst[i*3+2] = FLOAT_TO_USHORT(rgba[i][RCOMP]); 1141 } 1142 break; 1143 case GL_BGRA: 1144 for (i=0;i<n;i++) { 1145 dst[i*4+0] = FLOAT_TO_USHORT(rgba[i][BCOMP]); 1146 dst[i*4+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]); 1147 dst[i*4+2] = FLOAT_TO_USHORT(rgba[i][RCOMP]); 1148 dst[i*4+3] = FLOAT_TO_USHORT(rgba[i][ACOMP]); 1149 } 1150 break; 1151 case GL_ABGR_EXT: 1152 for (i=0;i<n;i++) { 1153 dst[i*4+0] = FLOAT_TO_USHORT(rgba[i][ACOMP]); 1154 dst[i*4+1] = FLOAT_TO_USHORT(rgba[i][BCOMP]); 1155 dst[i*4+2] = FLOAT_TO_USHORT(rgba[i][GCOMP]); 1156 dst[i*4+3] = FLOAT_TO_USHORT(rgba[i][RCOMP]); 1157 } 1158 break; 1159 default: 1160 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); 1161 } 1162 if (dstPacking->SwapBytes) { 1163 _mesa_swap2( (GLushort *) dst, n * comps); 1164 } 1165 } 1166 break; 1167 case GL_SHORT: 1168 { 1169 GLshort *dst = (GLshort *) dstAddr; 1170 switch (dstFormat) { 1171 case GL_RED: 1172 for (i=0;i<n;i++) 1173 dst[i] = FLOAT_TO_SHORT(rgba[i][RCOMP]); 1174 break; 1175 case GL_GREEN: 1176 for (i=0;i<n;i++) 1177 dst[i] = FLOAT_TO_SHORT(rgba[i][GCOMP]); 1178 break; 1179 case GL_BLUE: 1180 for (i=0;i<n;i++) 1181 dst[i] = FLOAT_TO_SHORT(rgba[i][BCOMP]); 1182 break; 1183 case GL_ALPHA: 1184 for (i=0;i<n;i++) 1185 dst[i] = FLOAT_TO_SHORT(rgba[i][ACOMP]); 1186 break; 1187 case GL_LUMINANCE: 1188 for (i=0;i<n;i++) 1189 dst[i] = FLOAT_TO_SHORT(luminance[i]); 1190 break; 1191 case GL_LUMINANCE_ALPHA: 1192 for (i=0;i<n;i++) { 1193 dst[i*2+0] = FLOAT_TO_SHORT(luminance[i]); 1194 dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][ACOMP]); 1195 } 1196 break; 1197 case GL_RGB: 1198 for (i=0;i<n;i++) { 1199 dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]); 1200 dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]); 1201 dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]); 1202 } 1203 break; 1204 case GL_RGBA: 1205 for (i=0;i<n;i++) { 1206 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]); 1207 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]); 1208 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]); 1209 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]); 1210 } 1211 break; 1212 case GL_BGR: 1213 for (i=0;i<n;i++) { 1214 dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]); 1215 dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]); 1216 dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]); 1217 } 1218 break; 1219 case GL_BGRA: 1220 for (i=0;i<n;i++) { 1221 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]); 1222 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]); 1223 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]); 1224 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]); 1225 } 1226 case GL_ABGR_EXT: 1227 for (i=0;i<n;i++) { 1228 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][ACOMP]); 1229 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][BCOMP]); 1230 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][GCOMP]); 1231 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][RCOMP]); 1232 } 1233 break; 1234 default: 1235 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); 1236 } 1237 if (dstPacking->SwapBytes) { 1238 _mesa_swap2( (GLushort *) dst, n * comps ); 1239 } 1240 } 1241 break; 1242 case GL_UNSIGNED_INT: 1243 { 1244 GLuint *dst = (GLuint *) dstAddr; 1245 switch (dstFormat) { 1246 case GL_RED: 1247 for (i=0;i<n;i++) 1248 dst[i] = FLOAT_TO_UINT(rgba[i][RCOMP]); 1249 break; 1250 case GL_GREEN: 1251 for (i=0;i<n;i++) 1252 dst[i] = FLOAT_TO_UINT(rgba[i][GCOMP]); 1253 break; 1254 case GL_BLUE: 1255 for (i=0;i<n;i++) 1256 dst[i] = FLOAT_TO_UINT(rgba[i][BCOMP]); 1257 break; 1258 case GL_ALPHA: 1259 for (i=0;i<n;i++) 1260 dst[i] = FLOAT_TO_UINT(rgba[i][ACOMP]); 1261 break; 1262 case GL_LUMINANCE: 1263 for (i=0;i<n;i++) 1264 dst[i] = FLOAT_TO_UINT(luminance[i]); 1265 break; 1266 case GL_LUMINANCE_ALPHA: 1267 for (i=0;i<n;i++) { 1268 dst[i*2+0] = FLOAT_TO_UINT(luminance[i]); 1269 dst[i*2+1] = FLOAT_TO_UINT(rgba[i][ACOMP]); 1270 } 1271 break; 1272 case GL_RGB: 1273 for (i=0;i<n;i++) { 1274 dst[i*3+0] = FLOAT_TO_UINT(rgba[i][RCOMP]); 1275 dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]); 1276 dst[i*3+2] = FLOAT_TO_UINT(rgba[i][BCOMP]); 1277 } 1278 break; 1279 case GL_RGBA: 1280 for (i=0;i<n;i++) { 1281 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][RCOMP]); 1282 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]); 1283 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][BCOMP]); 1284 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]); 1285 } 1286 break; 1287 case GL_BGR: 1288 for (i=0;i<n;i++) { 1289 dst[i*3+0] = FLOAT_TO_UINT(rgba[i][BCOMP]); 1290 dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]); 1291 dst[i*3+2] = FLOAT_TO_UINT(rgba[i][RCOMP]); 1292 } 1293 break; 1294 case GL_BGRA: 1295 for (i=0;i<n;i++) { 1296 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][BCOMP]); 1297 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]); 1298 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][RCOMP]); 1299 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]); 1300 } 1301 break; 1302 case GL_ABGR_EXT: 1303 for (i=0;i<n;i++) { 1304 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][ACOMP]); 1305 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][BCOMP]); 1306 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][GCOMP]); 1307 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][RCOMP]); 1308 } 1309 break; 1310 default: 1311 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); 1312 } 1313 if (dstPacking->SwapBytes) { 1314 _mesa_swap4( (GLuint *) dst, n * comps ); 1315 } 1316 } 1317 break; 1318 case GL_INT: 1319 { 1320 GLint *dst = (GLint *) dstAddr; 1321 switch (dstFormat) { 1322 case GL_RED: 1323 for (i=0;i<n;i++) 1324 dst[i] = FLOAT_TO_INT(rgba[i][RCOMP]); 1325 break; 1326 case GL_GREEN: 1327 for (i=0;i<n;i++) 1328 dst[i] = FLOAT_TO_INT(rgba[i][GCOMP]); 1329 break; 1330 case GL_BLUE: 1331 for (i=0;i<n;i++) 1332 dst[i] = FLOAT_TO_INT(rgba[i][BCOMP]); 1333 break; 1334 case GL_ALPHA: 1335 for (i=0;i<n;i++) 1336 dst[i] = FLOAT_TO_INT(rgba[i][ACOMP]); 1337 break; 1338 case GL_LUMINANCE: 1339 for (i=0;i<n;i++) 1340 dst[i] = FLOAT_TO_INT(luminance[i]); 1341 break; 1342 case GL_LUMINANCE_ALPHA: 1343 for (i=0;i<n;i++) { 1344 dst[i*2+0] = FLOAT_TO_INT(luminance[i]); 1345 dst[i*2+1] = FLOAT_TO_INT(rgba[i][ACOMP]); 1346 } 1347 break; 1348 case GL_RGB: 1349 for (i=0;i<n;i++) { 1350 dst[i*3+0] = FLOAT_TO_INT(rgba[i][RCOMP]); 1351 dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]); 1352 dst[i*3+2] = FLOAT_TO_INT(rgba[i][BCOMP]); 1353 } 1354 break; 1355 case GL_RGBA: 1356 for (i=0;i<n;i++) { 1357 dst[i*4+0] = FLOAT_TO_INT(rgba[i][RCOMP]); 1358 dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]); 1359 dst[i*4+2] = FLOAT_TO_INT(rgba[i][BCOMP]); 1360 dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]); 1361 } 1362 break; 1363 case GL_BGR: 1364 for (i=0;i<n;i++) { 1365 dst[i*3+0] = FLOAT_TO_INT(rgba[i][BCOMP]); 1366 dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]); 1367 dst[i*3+2] = FLOAT_TO_INT(rgba[i][RCOMP]); 1368 } 1369 break; 1370 case GL_BGRA: 1371 for (i=0;i<n;i++) { 1372 dst[i*4+0] = FLOAT_TO_INT(rgba[i][BCOMP]); 1373 dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]); 1374 dst[i*4+2] = FLOAT_TO_INT(rgba[i][RCOMP]); 1375 dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]); 1376 } 1377 break; 1378 case GL_ABGR_EXT: 1379 for (i=0;i<n;i++) { 1380 dst[i*4+0] = FLOAT_TO_INT(rgba[i][ACOMP]); 1381 dst[i*4+1] = FLOAT_TO_INT(rgba[i][BCOMP]); 1382 dst[i*4+2] = FLOAT_TO_INT(rgba[i][GCOMP]); 1383 dst[i*4+3] = FLOAT_TO_INT(rgba[i][RCOMP]); 1384 } 1385 break; 1386 default: 1387 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); 1388 } 1389 if (dstPacking->SwapBytes) { 1390 _mesa_swap4( (GLuint *) dst, n * comps ); 1391 } 1392 } 1393 break; 1394 case GL_FLOAT: 1395 { 1396 GLfloat *dst = (GLfloat *) dstAddr; 1397 switch (dstFormat) { 1398 case GL_RED: 1399 for (i=0;i<n;i++) 1400 dst[i] = rgba[i][RCOMP]; 1401 break; 1402 case GL_GREEN: 1403 for (i=0;i<n;i++) 1404 dst[i] = rgba[i][GCOMP]; 1405 break; 1406 case GL_BLUE: 1407 for (i=0;i<n;i++) 1408 dst[i] = rgba[i][BCOMP]; 1409 break; 1410 case GL_ALPHA: 1411 for (i=0;i<n;i++) 1412 dst[i] = rgba[i][ACOMP]; 1413 break; 1414 case GL_LUMINANCE: 1415 for (i=0;i<n;i++) 1416 dst[i] = luminance[i]; 1417 break; 1418 case GL_LUMINANCE_ALPHA: 1419 for (i=0;i<n;i++) { 1420 dst[i*2+0] = luminance[i]; 1421 dst[i*2+1] = rgba[i][ACOMP]; 1422 } 1423 break; 1424 case GL_RGB: 1425 for (i=0;i<n;i++) { 1426 dst[i*3+0] = rgba[i][RCOMP]; 1427 dst[i*3+1] = rgba[i][GCOMP]; 1428 dst[i*3+2] = rgba[i][BCOMP]; 1429 } 1430 break; 1431 case GL_RGBA: 1432 for (i=0;i<n;i++) { 1433 dst[i*4+0] = rgba[i][RCOMP]; 1434 dst[i*4+1] = rgba[i][GCOMP]; 1435 dst[i*4+2] = rgba[i][BCOMP]; 1436 dst[i*4+3] = rgba[i][ACOMP]; 1437 } 1438 break; 1439 case GL_BGR: 1440 for (i=0;i<n;i++) { 1441 dst[i*3+0] = rgba[i][BCOMP]; 1442 dst[i*3+1] = rgba[i][GCOMP]; 1443 dst[i*3+2] = rgba[i][RCOMP]; 1444 } 1445 break; 1446 case GL_BGRA: 1447 for (i=0;i<n;i++) { 1448 dst[i*4+0] = rgba[i][BCOMP]; 1449 dst[i*4+1] = rgba[i][GCOMP]; 1450 dst[i*4+2] = rgba[i][RCOMP]; 1451 dst[i*4+3] = rgba[i][ACOMP]; 1452 } 1453 break; 1454 case GL_ABGR_EXT: 1455 for (i=0;i<n;i++) { 1456 dst[i*4+0] = rgba[i][ACOMP]; 1457 dst[i*4+1] = rgba[i][BCOMP]; 1458 dst[i*4+2] = rgba[i][GCOMP]; 1459 dst[i*4+3] = rgba[i][RCOMP]; 1460 } 1461 break; 1462 default: 1463 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); 1464 } 1465 if (dstPacking->SwapBytes) { 1466 _mesa_swap4( (GLuint *) dst, n * comps ); 1467 } 1468 } 1469 break; 1470 case GL_UNSIGNED_BYTE_3_3_2: 1471 if (dstFormat == GL_RGB) { 1472 GLubyte *dst = (GLubyte *) dstAddr; 1473 for (i=0;i<n;i++) { 1474 dst[i] = (((GLint) (rgba[i][RCOMP] * 7.0F)) << 5) 1475 | (((GLint) (rgba[i][GCOMP] * 7.0F)) << 2) 1476 | (((GLint) (rgba[i][BCOMP] * 3.0F)) ); 1477 } 1478 } 1479 break; 1480 case GL_UNSIGNED_BYTE_2_3_3_REV: 1481 if (dstFormat == GL_RGB) { 1482 GLubyte *dst = (GLubyte *) dstAddr; 1483 for (i=0;i<n;i++) { 1484 dst[i] = (((GLint) (rgba[i][RCOMP] * 7.0F)) ) 1485 | (((GLint) (rgba[i][GCOMP] * 7.0F)) << 3) 1486 | (((GLint) (rgba[i][BCOMP] * 3.0F)) << 5); 1487 } 1488 } 1489 break; 1490 case GL_UNSIGNED_SHORT_5_6_5: 1491 if (dstFormat == GL_RGB) { 1492 GLushort *dst = (GLushort *) dstAddr; 1493 for (i=0;i<n;i++) { 1494 dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) << 11) 1495 | (((GLint) (rgba[i][GCOMP] * 63.0F)) << 5) 1496 | (((GLint) (rgba[i][BCOMP] * 31.0F)) ); 1497 } 1498 } 1499 break; 1500 case GL_UNSIGNED_SHORT_5_6_5_REV: 1501 if (dstFormat == GL_RGB) { 1502 GLushort *dst = (GLushort *) dstAddr; 1503 for (i=0;i<n;i++) { 1504 dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) ) 1505 | (((GLint) (rgba[i][GCOMP] * 63.0F)) << 5) 1506 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 11); 1507 } 1508 } 1509 break; 1510 case GL_UNSIGNED_SHORT_4_4_4_4: 1511 if (dstFormat == GL_RGBA) { 1512 GLushort *dst = (GLushort *) dstAddr; 1513 for (i=0;i<n;i++) { 1514 dst[i] = (((GLint) (rgba[i][RCOMP] * 15.0F)) << 12) 1515 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 8) 1516 | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 4) 1517 | (((GLint) (rgba[i][ACOMP] * 15.0F)) ); 1518 } 1519 } 1520 else if (dstFormat == GL_BGRA) { 1521 GLushort *dst = (GLushort *) dstAddr; 1522 for (i=0;i<n;i++) { 1523 dst[i] = (((GLint) (rgba[i][BCOMP] * 15.0F)) << 12) 1524 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 8) 1525 | (((GLint) (rgba[i][RCOMP] * 15.0F)) << 4) 1526 | (((GLint) (rgba[i][ACOMP] * 15.0F)) ); 1527 } 1528 } 1529 else if (dstFormat == GL_ABGR_EXT) { 1530 GLushort *dst = (GLushort *) dstAddr; 1531 for (i=0;i<n;i++) { 1532 dst[i] = (((GLint) (rgba[i][ACOMP] * 15.0F)) << 4) 1533 | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 8) 1534 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 12) 1535 | (((GLint) (rgba[i][RCOMP] * 15.0F)) ); 1536 } 1537 } 1538 break; 1539 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 1540 if (dstFormat == GL_RGBA) { 1541 GLushort *dst = (GLushort *) dstAddr; 1542 for (i=0;i<n;i++) { 1543 dst[i] = (((GLint) (rgba[i][RCOMP] * 15.0F)) ) 1544 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 4) 1545 | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 8) 1546 | (((GLint) (rgba[i][ACOMP] * 15.0F)) << 12); 1547 } 1548 } 1549 else if (dstFormat == GL_BGRA) { 1550 GLushort *dst = (GLushort *) dstAddr; 1551 for (i=0;i<n;i++) { 1552 dst[i] = (((GLint) (rgba[i][BCOMP] * 15.0F)) ) 1553 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 4) 1554 | (((GLint) (rgba[i][RCOMP] * 15.0F)) << 8) 1555 | (((GLint) (rgba[i][ACOMP] * 15.0F)) << 12); 1556 } 1557 } 1558 else if (dstFormat == GL_ABGR_EXT) { 1559 GLushort *dst = (GLushort *) dstAddr; 1560 for (i=0;i<n;i++) { 1561 dst[i] = (((GLint) (rgba[i][ACOMP] * 15.0F)) ) 1562 | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 4) 1563 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 8) 1564 | (((GLint) (rgba[i][RCOMP] * 15.0F)) << 12); 1565 } 1566 } 1567 break; 1568 case GL_UNSIGNED_SHORT_5_5_5_1: 1569 if (dstFormat == GL_RGBA) { 1570 GLushort *dst = (GLushort *) dstAddr; 1571 for (i=0;i<n;i++) { 1572 dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) << 11) 1573 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 6) 1574 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 1) 1575 | (((GLint) (rgba[i][ACOMP] * 1.0F)) ); 1576 } 1577 } 1578 else if (dstFormat == GL_BGRA) { 1579 GLushort *dst = (GLushort *) dstAddr; 1580 for (i=0;i<n;i++) { 1581 dst[i] = (((GLint) (rgba[i][BCOMP] * 31.0F)) << 11) 1582 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 6) 1583 | (((GLint) (rgba[i][RCOMP] * 31.0F)) << 1) 1584 | (((GLint) (rgba[i][ACOMP] * 1.0F)) ); 1585 } 1586 } 1587 else if (dstFormat == GL_ABGR_EXT) { 1588 GLushort *dst = (GLushort *) dstAddr; 1589 for (i=0;i<n;i++) { 1590 dst[i] = (((GLint) (rgba[i][ACOMP] * 31.0F)) << 11) 1591 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 6) 1592 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 1) 1593 | (((GLint) (rgba[i][RCOMP] * 1.0F)) ); 1594 } 1595 } 1596 break; 1597 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 1598 if (dstFormat == GL_RGBA) { 1599 GLushort *dst = (GLushort *) dstAddr; 1600 for (i=0;i<n;i++) { 1601 dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) ) 1602 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 5) 1603 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 10) 1604 | (((GLint) (rgba[i][ACOMP] * 1.0F)) << 15); 1605 } 1606 } 1607 else if (dstFormat == GL_BGRA) { 1608 GLushort *dst = (GLushort *) dstAddr; 1609 for (i=0;i<n;i++) { 1610 dst[i] = (((GLint) (rgba[i][BCOMP] * 31.0F)) ) 1611 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 5) 1612 | (((GLint) (rgba[i][RCOMP] * 31.0F)) << 10) 1613 | (((GLint) (rgba[i][ACOMP] * 1.0F)) << 15); 1614 } 1615 } 1616 else if (dstFormat == GL_ABGR_EXT) { 1617 GLushort *dst = (GLushort *) dstAddr; 1618 for (i=0;i<n;i++) { 1619 dst[i] = (((GLint) (rgba[i][ACOMP] * 31.0F)) ) 1620 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 5) 1621 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 10) 1622 | (((GLint) (rgba[i][RCOMP] * 1.0F)) << 15); 1623 } 1624 } 1625 break; 1626 case GL_UNSIGNED_INT_8_8_8_8: 1627 if (dstFormat == GL_RGBA) { 1628 GLuint *dst = (GLuint *) dstAddr; 1629 for (i=0;i<n;i++) { 1630 dst[i] = (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 24) 1631 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16) 1632 | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 8) 1633 | (((GLuint) (rgba[i][ACOMP] * 255.0F)) ); 1634 } 1635 } 1636 else if (dstFormat == GL_BGRA) { 1637 GLuint *dst = (GLuint *) dstAddr; 1638 for (i=0;i<n;i++) { 1639 dst[i] = (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 24) 1640 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16) 1641 | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 8) 1642 | (((GLuint) (rgba[i][ACOMP] * 255.0F)) ); 1643 } 1644 } 1645 else if (dstFormat == GL_ABGR_EXT) { 1646 GLuint *dst = (GLuint *) dstAddr; 1647 for (i=0;i<n;i++) { 1648 dst[i] = (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24) 1649 | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 16) 1650 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 8) 1651 | (((GLuint) (rgba[i][RCOMP] * 255.0F)) ); 1652 } 1653 } 1654 break; 1655 case GL_UNSIGNED_INT_8_8_8_8_REV: 1656 if (dstFormat == GL_RGBA) { 1657 GLuint *dst = (GLuint *) dstAddr; 1658 for (i=0;i<n;i++) { 1659 dst[i] = (((GLuint) (rgba[i][RCOMP] * 255.0F)) ) 1660 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 8) 1661 | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 16) 1662 | (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24); 1663 } 1664 } 1665 else if (dstFormat == GL_BGRA) { 1666 GLuint *dst = (GLuint *) dstAddr; 1667 for (i=0;i<n;i++) { 1668 dst[i] = (((GLuint) (rgba[i][BCOMP] * 255.0F)) ) 1669 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 8) 1670 | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 16) 1671 | (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24); 1672 } 1673 } 1674 else if (dstFormat == GL_ABGR_EXT) { 1675 GLuint *dst = (GLuint *) dstAddr; 1676 for (i=0;i<n;i++) { 1677 dst[i] = (((GLuint) (rgba[i][ACOMP] * 255.0F)) ) 1678 | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 8) 1679 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16) 1680 | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 24); 1681 } 1682 } 1683 break; 1684 case GL_UNSIGNED_INT_10_10_10_2: 1685 if (dstFormat == GL_RGBA) { 1686 GLuint *dst = (GLuint *) dstAddr; 1687 for (i=0;i<n;i++) { 1688 dst[i] = (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 22) 1689 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 12) 1690 | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 2) 1691 | (((GLuint) (rgba[i][ACOMP] * 3.0F)) ); 1692 } 1693 } 1694 else if (dstFormat == GL_BGRA) { 1695 GLuint *dst = (GLuint *) dstAddr; 1696 for (i=0;i<n;i++) { 1697 dst[i] = (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 22) 1698 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 12) 1699 | (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 2) 1700 | (((GLuint) (rgba[i][ACOMP] * 3.0F)) ); 1701 } 1702 } 1703 else if (dstFormat == GL_ABGR_EXT) { 1704 GLuint *dst = (GLuint *) dstAddr; 1705 for (i=0;i<n;i++) { 1706 dst[i] = (((GLuint) (rgba[i][ACOMP] * 1023.0F)) << 22) 1707 | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 12) 1708 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 2) 1709 | (((GLuint) (rgba[i][RCOMP] * 3.0F)) ); 1710 } 1711 } 1712 break; 1713 case GL_UNSIGNED_INT_2_10_10_10_REV: 1714 if (dstFormat == GL_RGBA) { 1715 GLuint *dst = (GLuint *) dstAddr; 1716 for (i=0;i<n;i++) { 1717 dst[i] = (((GLuint) (rgba[i][RCOMP] * 1023.0F)) ) 1718 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 10) 1719 | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 20) 1720 | (((GLuint) (rgba[i][ACOMP] * 3.0F)) << 30); 1721 } 1722 } 1723 else if (dstFormat == GL_BGRA) { 1724 GLuint *dst = (GLuint *) dstAddr; 1725 for (i=0;i<n;i++) { 1726 dst[i] = (((GLuint) (rgba[i][BCOMP] * 1023.0F)) ) 1727 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 10) 1728 | (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 20) 1729 | (((GLuint) (rgba[i][ACOMP] * 3.0F)) << 30); 1730 } 1731 } 1732 else if (dstFormat == GL_ABGR_EXT) { 1733 GLuint *dst = (GLuint *) dstAddr; 1734 for (i=0;i<n;i++) { 1735 dst[i] = (((GLuint) (rgba[i][ACOMP] * 1023.0F)) ) 1736 | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 10) 1737 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 20) 1738 | (((GLuint) (rgba[i][RCOMP] * 3.0F)) << 30); 1739 } 1740 } 1741 break; 1742 default: 1743 _mesa_problem(ctx, "bad type in _mesa_pack_float_rgba_span"); 1744 } 1745} 1746 1747 1748 1749/* 1750 * Pack the given RGBA span into client memory at 'dest' address 1751 * in the given pixel format and type. 1752 * Optionally apply the enabled pixel transfer ops. 1753 * Pack into memory using the given packing params struct. 1754 * This is used by glReadPixels and glGetTexImage?D() 1755 * Input: ctx - the context 1756 * n - number of pixels in the span 1757 * rgba - the pixels 1758 * format - dest packing format 1759 * type - dest packing datatype 1760 * destination - destination packing address 1761 * packing - pixel packing parameters 1762 * transferOps - bitmask of IMAGE_*_BIT operations to apply 1763 */ 1764void 1765_mesa_pack_rgba_span( GLcontext *ctx, 1766 GLuint n, CONST GLchan srcRgba[][4], 1767 GLenum dstFormat, GLenum dstType, 1768 GLvoid *dstAddr, 1769 const struct gl_pixelstore_attrib *dstPacking, 1770 GLuint transferOps) 1771{ 1772 ASSERT((ctx->NewState & _NEW_PIXEL) == 0 || transferOps == 0); 1773 1774 /* Test for optimized case first */ 1775 if (transferOps == 0 && dstFormat == GL_RGBA && dstType == CHAN_TYPE) { 1776 /* common simple case */ 1777 MEMCPY(dstAddr, srcRgba, n * 4 * sizeof(GLchan)); 1778 } 1779 else if (transferOps == 0 && dstFormat == GL_RGB && dstType == CHAN_TYPE) { 1780 /* common simple case */ 1781 GLuint i; 1782 GLchan *dest = (GLchan *) dstAddr; 1783 for (i = 0; i < n; i++) { 1784 dest[0] = srcRgba[i][RCOMP]; 1785 dest[1] = srcRgba[i][GCOMP]; 1786 dest[2] = srcRgba[i][BCOMP]; 1787 dest += 3; 1788 } 1789 } 1790 else { 1791 /* general solution */ 1792 GLuint i; 1793 DEFMARRAY(GLfloat, rgba, MAX_WIDTH, 4); /* mac 32k limitation */ 1794 CHECKARRAY(rgba, return); /* mac 32k limitation */ 1795 1796 assert(n <= MAX_WIDTH); 1797 /* convert color components to floating point */ 1798 for (i=0;i<n;i++) { 1799 rgba[i][RCOMP] = CHAN_TO_FLOAT(srcRgba[i][RCOMP]); 1800 rgba[i][GCOMP] = CHAN_TO_FLOAT(srcRgba[i][GCOMP]); 1801 rgba[i][BCOMP] = CHAN_TO_FLOAT(srcRgba[i][BCOMP]); 1802 rgba[i][ACOMP] = CHAN_TO_FLOAT(srcRgba[i][ACOMP]); 1803 } 1804 _mesa_pack_float_rgba_span(ctx, n, (const GLfloat (*)[4]) rgba, 1805 dstFormat, dstType, dstAddr, 1806 dstPacking, transferOps); 1807 UNDEFARRAY(rgba); /* mac 32k limitation */ 1808 } 1809} 1810 1811 1812#define SWAP2BYTE(VALUE) \ 1813 { \ 1814 GLubyte *bytes = (GLubyte *) &(VALUE); \ 1815 GLubyte tmp = bytes[0]; \ 1816 bytes[0] = bytes[1]; \ 1817 bytes[1] = tmp; \ 1818 } 1819 1820#define SWAP4BYTE(VALUE) \ 1821 { \ 1822 GLubyte *bytes = (GLubyte *) &(VALUE); \ 1823 GLubyte tmp = bytes[0]; \ 1824 bytes[0] = bytes[3]; \ 1825 bytes[3] = tmp; \ 1826 tmp = bytes[1]; \ 1827 bytes[1] = bytes[2]; \ 1828 bytes[2] = tmp; \ 1829 } 1830 1831 1832static void 1833extract_uint_indexes(GLuint n, GLuint indexes[], 1834 GLenum srcFormat, GLenum srcType, const GLvoid *src, 1835 const struct gl_pixelstore_attrib *unpack ) 1836{ 1837 assert(srcFormat == GL_COLOR_INDEX); 1838 1839 ASSERT(srcType == GL_BITMAP || 1840 srcType == GL_UNSIGNED_BYTE || 1841 srcType == GL_BYTE || 1842 srcType == GL_UNSIGNED_SHORT || 1843 srcType == GL_SHORT || 1844 srcType == GL_UNSIGNED_INT || 1845 srcType == GL_INT || 1846 srcType == GL_FLOAT); 1847 1848 switch (srcType) { 1849 case GL_BITMAP: 1850 { 1851 GLubyte *ubsrc = (GLubyte *) src; 1852 if (unpack->LsbFirst) { 1853 GLubyte mask = 1 << (unpack->SkipPixels & 0x7); 1854 GLuint i; 1855 for (i = 0; i < n; i++) { 1856 indexes[i] = (*ubsrc & mask) ? 1 : 0; 1857 if (mask == 128) { 1858 mask = 1; 1859 ubsrc++; 1860 } 1861 else { 1862 mask = mask << 1; 1863 } 1864 } 1865 } 1866 else { 1867 GLubyte mask = 128 >> (unpack->SkipPixels & 0x7); 1868 GLuint i; 1869 for (i = 0; i < n; i++) { 1870 indexes[i] = (*ubsrc & mask) ? 1 : 0; 1871 if (mask == 1) { 1872 mask = 128; 1873 ubsrc++; 1874 } 1875 else { 1876 mask = mask >> 1; 1877 } 1878 } 1879 } 1880 } 1881 break; 1882 case GL_UNSIGNED_BYTE: 1883 { 1884 GLuint i; 1885 const GLubyte *s = (const GLubyte *) src; 1886 for (i = 0; i < n; i++) 1887 indexes[i] = s[i]; 1888 } 1889 break; 1890 case GL_BYTE: 1891 { 1892 GLuint i; 1893 const GLbyte *s = (const GLbyte *) src; 1894 for (i = 0; i < n; i++) 1895 indexes[i] = s[i]; 1896 } 1897 break; 1898 case GL_UNSIGNED_SHORT: 1899 { 1900 GLuint i; 1901 const GLushort *s = (const GLushort *) src; 1902 if (unpack->SwapBytes) { 1903 for (i = 0; i < n; i++) { 1904 GLushort value = s[i]; 1905 SWAP2BYTE(value); 1906 indexes[i] = value; 1907 } 1908 } 1909 else { 1910 for (i = 0; i < n; i++) 1911 indexes[i] = s[i]; 1912 } 1913 } 1914 break; 1915 case GL_SHORT: 1916 { 1917 GLuint i; 1918 const GLshort *s = (const GLshort *) src; 1919 if (unpack->SwapBytes) { 1920 for (i = 0; i < n; i++) { 1921 GLshort value = s[i]; 1922 SWAP2BYTE(value); 1923 indexes[i] = value; 1924 } 1925 } 1926 else { 1927 for (i = 0; i < n; i++) 1928 indexes[i] = s[i]; 1929 } 1930 } 1931 break; 1932 case GL_UNSIGNED_INT: 1933 { 1934 GLuint i; 1935 const GLuint *s = (const GLuint *) src; 1936 if (unpack->SwapBytes) { 1937 for (i = 0; i < n; i++) { 1938 GLuint value = s[i]; 1939 SWAP4BYTE(value); 1940 indexes[i] = value; 1941 } 1942 } 1943 else { 1944 for (i = 0; i < n; i++) 1945 indexes[i] = s[i]; 1946 } 1947 } 1948 break; 1949 case GL_INT: 1950 { 1951 GLuint i; 1952 const GLint *s = (const GLint *) src; 1953 if (unpack->SwapBytes) { 1954 for (i = 0; i < n; i++) { 1955 GLint value = s[i]; 1956 SWAP4BYTE(value); 1957 indexes[i] = value; 1958 } 1959 } 1960 else { 1961 for (i = 0; i < n; i++) 1962 indexes[i] = s[i]; 1963 } 1964 } 1965 break; 1966 case GL_FLOAT: 1967 { 1968 GLuint i; 1969 const GLfloat *s = (const GLfloat *) src; 1970 if (unpack->SwapBytes) { 1971 for (i = 0; i < n; i++) { 1972 GLfloat value = s[i]; 1973 SWAP4BYTE(value); 1974 indexes[i] = (GLuint) value; 1975 } 1976 } 1977 else { 1978 for (i = 0; i < n; i++) 1979 indexes[i] = (GLuint) s[i]; 1980 } 1981 } 1982 break; 1983 default: 1984 _mesa_problem(NULL, "bad srcType in extract_uint_indexes"); 1985 return; 1986 } 1987} 1988 1989 1990 1991/* 1992 * This function extracts floating point RGBA values from arbitrary 1993 * image data. srcFormat and srcType are the format and type parameters 1994 * passed to glDrawPixels, glTexImage[123]D, glTexSubImage[123]D, etc. 1995 * 1996 * Refering to section 3.6.4 of the OpenGL 1.2 spec, this function 1997 * implements the "Conversion to floating point", "Conversion to RGB", 1998 * and "Final Expansion to RGBA" operations. 1999 * 2000 * Args: n - number of pixels 2001 * rgba - output colors 2002 * srcFormat - format of incoming data 2003 * srcType - datatype of incoming data 2004 * src - source data pointer 2005 * swapBytes - perform byteswapping of incoming data? 2006 */ 2007static void 2008extract_float_rgba(GLuint n, GLfloat rgba[][4], 2009 GLenum srcFormat, GLenum srcType, const GLvoid *src, 2010 GLboolean swapBytes) 2011{ 2012 GLint redIndex, greenIndex, blueIndex, alphaIndex; 2013 GLint stride; 2014 GLint rComp, bComp, gComp, aComp; 2015 2016 ASSERT(srcFormat == GL_RED || 2017 srcFormat == GL_GREEN || 2018 srcFormat == GL_BLUE || 2019 srcFormat == GL_ALPHA || 2020 srcFormat == GL_LUMINANCE || 2021 srcFormat == GL_LUMINANCE_ALPHA || 2022 srcFormat == GL_INTENSITY || 2023 srcFormat == GL_RGB || 2024 srcFormat == GL_BGR || 2025 srcFormat == GL_RGBA || 2026 srcFormat == GL_BGRA || 2027 srcFormat == GL_ABGR_EXT); 2028 2029 ASSERT(srcType == GL_UNSIGNED_BYTE || 2030 srcType == GL_BYTE || 2031 srcType == GL_UNSIGNED_SHORT || 2032 srcType == GL_SHORT || 2033 srcType == GL_UNSIGNED_INT || 2034 srcType == GL_INT || 2035 srcType == GL_FLOAT || 2036 srcType == GL_UNSIGNED_BYTE_3_3_2 || 2037 srcType == GL_UNSIGNED_BYTE_2_3_3_REV || 2038 srcType == GL_UNSIGNED_SHORT_5_6_5 || 2039 srcType == GL_UNSIGNED_SHORT_5_6_5_REV || 2040 srcType == GL_UNSIGNED_SHORT_4_4_4_4 || 2041 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV || 2042 srcType == GL_UNSIGNED_SHORT_5_5_5_1 || 2043 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV || 2044 srcType == GL_UNSIGNED_INT_8_8_8_8 || 2045 srcType == GL_UNSIGNED_INT_8_8_8_8_REV || 2046 srcType == GL_UNSIGNED_INT_10_10_10_2 || 2047 srcType == GL_UNSIGNED_INT_2_10_10_10_REV); 2048 2049 rComp = gComp = bComp = aComp = -1; 2050 2051 switch (srcFormat) { 2052 case GL_RED: 2053 redIndex = 0; 2054 greenIndex = blueIndex = alphaIndex = -1; 2055 stride = 1; 2056 break; 2057 case GL_GREEN: 2058 greenIndex = 0; 2059 redIndex = blueIndex = alphaIndex = -1; 2060 stride = 1; 2061 break; 2062 case GL_BLUE: 2063 blueIndex = 0; 2064 redIndex = greenIndex = alphaIndex = -1; 2065 stride = 1; 2066 break; 2067 case GL_ALPHA: 2068 redIndex = greenIndex = blueIndex = -1; 2069 alphaIndex = 0; 2070 stride = 1; 2071 break; 2072 case GL_LUMINANCE: 2073 redIndex = greenIndex = blueIndex = 0; 2074 alphaIndex = -1; 2075 stride = 1; 2076 break; 2077 case GL_LUMINANCE_ALPHA: 2078 redIndex = greenIndex = blueIndex = 0; 2079 alphaIndex = 1; 2080 stride = 2; 2081 break; 2082 case GL_INTENSITY: 2083 redIndex = greenIndex = blueIndex = alphaIndex = 0; 2084 stride = 1; 2085 break; 2086 case GL_RGB: 2087 redIndex = 0; 2088 greenIndex = 1; 2089 blueIndex = 2; 2090 alphaIndex = -1; 2091 stride = 3; 2092 break; 2093 case GL_BGR: 2094 redIndex = 2; 2095 greenIndex = 1; 2096 blueIndex = 0; 2097 alphaIndex = -1; 2098 stride = 3; 2099 break; 2100 case GL_RGBA: 2101 redIndex = 0; 2102 greenIndex = 1; 2103 blueIndex = 2; 2104 alphaIndex = 3; 2105 rComp = 0; 2106 gComp = 1; 2107 bComp = 2; 2108 aComp = 3; 2109 stride = 4; 2110 break; 2111 case GL_BGRA: 2112 redIndex = 2; 2113 greenIndex = 1; 2114 blueIndex = 0; 2115 alphaIndex = 3; 2116 rComp = 2; 2117 gComp = 1; 2118 bComp = 0; 2119 aComp = 3; 2120 stride = 4; 2121 break; 2122 case GL_ABGR_EXT: 2123 redIndex = 3; 2124 greenIndex = 2; 2125 blueIndex = 1; 2126 alphaIndex = 0; 2127 rComp = 3; 2128 gComp = 2; 2129 bComp = 1; 2130 aComp = 0; 2131 stride = 4; 2132 break; 2133 default: 2134 _mesa_problem(NULL, "bad srcFormat in extract float data"); 2135 return; 2136 } 2137 2138 2139#define PROCESS(INDEX, CHANNEL, DEFAULT, TYPE, CONVERSION) \ 2140 if ((INDEX) < 0) { \ 2141 GLuint i; \ 2142 for (i = 0; i < n; i++) { \ 2143 rgba[i][CHANNEL] = DEFAULT; \ 2144 } \ 2145 } \ 2146 else if (swapBytes) { \ 2147 const TYPE *s = (const TYPE *) src; \ 2148 GLuint i; \ 2149 for (i = 0; i < n; i++) { \ 2150 TYPE value = s[INDEX]; \ 2151 if (sizeof(TYPE) == 2) { \ 2152 SWAP2BYTE(value); \ 2153 } \ 2154 else if (sizeof(TYPE) == 4) { \ 2155 SWAP4BYTE(value); \ 2156 } \ 2157 rgba[i][CHANNEL] = (GLfloat) CONVERSION(value); \ 2158 s += stride; \ 2159 } \ 2160 } \ 2161 else { \ 2162 const TYPE *s = (const TYPE *) src; \ 2163 GLuint i; \ 2164 for (i = 0; i < n; i++) { \ 2165 rgba[i][CHANNEL] = (GLfloat) CONVERSION(s[INDEX]); \ 2166 s += stride; \ 2167 } \ 2168 } 2169 2170 switch (srcType) { 2171 case GL_UNSIGNED_BYTE: 2172 PROCESS(redIndex, RCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT); 2173 PROCESS(greenIndex, GCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT); 2174 PROCESS(blueIndex, BCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT); 2175 PROCESS(alphaIndex, ACOMP, 1.0F, GLubyte, UBYTE_TO_FLOAT); 2176 break; 2177 case GL_BYTE: 2178 PROCESS(redIndex, RCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT); 2179 PROCESS(greenIndex, GCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT); 2180 PROCESS(blueIndex, BCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT); 2181 PROCESS(alphaIndex, ACOMP, 1.0F, GLbyte, BYTE_TO_FLOAT); 2182 break; 2183 case GL_UNSIGNED_SHORT: 2184 PROCESS(redIndex, RCOMP, 0.0F, GLushort, USHORT_TO_FLOAT); 2185 PROCESS(greenIndex, GCOMP, 0.0F, GLushort, USHORT_TO_FLOAT); 2186 PROCESS(blueIndex, BCOMP, 0.0F, GLushort, USHORT_TO_FLOAT); 2187 PROCESS(alphaIndex, ACOMP, 1.0F, GLushort, USHORT_TO_FLOAT); 2188 break; 2189 case GL_SHORT: 2190 PROCESS(redIndex, RCOMP, 0.0F, GLshort, SHORT_TO_FLOAT); 2191 PROCESS(greenIndex, GCOMP, 0.0F, GLshort, SHORT_TO_FLOAT); 2192 PROCESS(blueIndex, BCOMP, 0.0F, GLshort, SHORT_TO_FLOAT); 2193 PROCESS(alphaIndex, ACOMP, 1.0F, GLshort, SHORT_TO_FLOAT); 2194 break; 2195 case GL_UNSIGNED_INT: 2196 PROCESS(redIndex, RCOMP, 0.0F, GLuint, UINT_TO_FLOAT); 2197 PROCESS(greenIndex, GCOMP, 0.0F, GLuint, UINT_TO_FLOAT); 2198 PROCESS(blueIndex, BCOMP, 0.0F, GLuint, UINT_TO_FLOAT); 2199 PROCESS(alphaIndex, ACOMP, 1.0F, GLuint, UINT_TO_FLOAT); 2200 break; 2201 case GL_INT: 2202 PROCESS(redIndex, RCOMP, 0.0F, GLint, INT_TO_FLOAT); 2203 PROCESS(greenIndex, GCOMP, 0.0F, GLint, INT_TO_FLOAT); 2204 PROCESS(blueIndex, BCOMP, 0.0F, GLint, INT_TO_FLOAT); 2205 PROCESS(alphaIndex, ACOMP, 1.0F, GLint, INT_TO_FLOAT); 2206 break; 2207 case GL_FLOAT: 2208 PROCESS(redIndex, RCOMP, 0.0F, GLfloat, (GLfloat)); 2209 PROCESS(greenIndex, GCOMP, 0.0F, GLfloat, (GLfloat)); 2210 PROCESS(blueIndex, BCOMP, 0.0F, GLfloat, (GLfloat)); 2211 PROCESS(alphaIndex, ACOMP, 1.0F, GLfloat, (GLfloat)); 2212 break; 2213 case GL_UNSIGNED_BYTE_3_3_2: 2214 { 2215 const GLubyte *ubsrc = (const GLubyte *) src; 2216 GLuint i; 2217 for (i = 0; i < n; i ++) { 2218 GLubyte p = ubsrc[i]; 2219 rgba[i][RCOMP] = ((p >> 5) ) * (1.0F / 7.0F); 2220 rgba[i][GCOMP] = ((p >> 2) & 0x7) * (1.0F / 7.0F); 2221 rgba[i][BCOMP] = ((p ) & 0x3) * (1.0F / 3.0F); 2222 rgba[i][ACOMP] = 1.0F; 2223 } 2224 } 2225 break; 2226 case GL_UNSIGNED_BYTE_2_3_3_REV: 2227 { 2228 const GLubyte *ubsrc = (const GLubyte *) src; 2229 GLuint i; 2230 for (i = 0; i < n; i ++) { 2231 GLubyte p = ubsrc[i]; 2232 rgba[i][RCOMP] = ((p ) & 0x7) * (1.0F / 7.0F); 2233 rgba[i][GCOMP] = ((p >> 3) & 0x7) * (1.0F / 7.0F); 2234 rgba[i][BCOMP] = ((p >> 6) ) * (1.0F / 3.0F); 2235 rgba[i][ACOMP] = 1.0F; 2236 } 2237 } 2238 break; 2239 case GL_UNSIGNED_SHORT_5_6_5: 2240 if (swapBytes) { 2241 const GLushort *ussrc = (const GLushort *) src; 2242 GLuint i; 2243 for (i = 0; i < n; i ++) { 2244 GLushort p = ussrc[i]; 2245 SWAP2BYTE(p); 2246 rgba[i][RCOMP] = ((p >> 11) ) * (1.0F / 31.0F); 2247 rgba[i][GCOMP] = ((p >> 5) & 0x3f) * (1.0F / 63.0F); 2248 rgba[i][BCOMP] = ((p ) & 0x1f) * (1.0F / 31.0F); 2249 rgba[i][ACOMP] = 1.0F; 2250 } 2251 } 2252 else { 2253 const GLushort *ussrc = (const GLushort *) src; 2254 GLuint i; 2255 for (i = 0; i < n; i ++) { 2256 GLushort p = ussrc[i]; 2257 rgba[i][RCOMP] = ((p >> 11) ) * (1.0F / 31.0F); 2258 rgba[i][GCOMP] = ((p >> 5) & 0x3f) * (1.0F / 63.0F); 2259 rgba[i][BCOMP] = ((p ) & 0x1f) * (1.0F / 31.0F); 2260 rgba[i][ACOMP] = 1.0F; 2261 } 2262 } 2263 break; 2264 case GL_UNSIGNED_SHORT_5_6_5_REV: 2265 if (swapBytes) { 2266 const GLushort *ussrc = (const GLushort *) src; 2267 GLuint i; 2268 for (i = 0; i < n; i ++) { 2269 GLushort p = ussrc[i]; 2270 SWAP2BYTE(p); 2271 rgba[i][RCOMP] = ((p ) & 0x1f) * (1.0F / 31.0F); 2272 rgba[i][GCOMP] = ((p >> 5) & 0x3f) * (1.0F / 63.0F); 2273 rgba[i][BCOMP] = ((p >> 11) ) * (1.0F / 31.0F); 2274 rgba[i][ACOMP] = 1.0F; 2275 } 2276 } 2277 else { 2278 const GLushort *ussrc = (const GLushort *) src; 2279 GLuint i; 2280 for (i = 0; i < n; i ++) { 2281 GLushort p = ussrc[i]; 2282 rgba[i][RCOMP] = ((p ) & 0x1f) * (1.0F / 31.0F); 2283 rgba[i][GCOMP] = ((p >> 5) & 0x3f) * (1.0F / 63.0F); 2284 rgba[i][BCOMP] = ((p >> 11) ) * (1.0F / 31.0F); 2285 rgba[i][ACOMP] = 1.0F; 2286 } 2287 } 2288 break; 2289 case GL_UNSIGNED_SHORT_4_4_4_4: 2290 if (swapBytes) { 2291 const GLushort *ussrc = (const GLushort *) src; 2292 GLuint i; 2293 for (i = 0; i < n; i ++) { 2294 GLushort p = ussrc[i]; 2295 SWAP2BYTE(p); 2296 rgba[i][rComp] = ((p >> 12) ) * (1.0F / 15.0F); 2297 rgba[i][gComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F); 2298 rgba[i][bComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F); 2299 rgba[i][aComp] = ((p ) & 0xf) * (1.0F / 15.0F); 2300 } 2301 } 2302 else { 2303 const GLushort *ussrc = (const GLushort *) src; 2304 GLuint i; 2305 for (i = 0; i < n; i ++) { 2306 GLushort p = ussrc[i]; 2307 rgba[i][rComp] = ((p >> 12) ) * (1.0F / 15.0F); 2308 rgba[i][gComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F); 2309 rgba[i][bComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F); 2310 rgba[i][aComp] = ((p ) & 0xf) * (1.0F / 15.0F); 2311 } 2312 } 2313 break; 2314 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 2315 if (swapBytes) { 2316 const GLushort *ussrc = (const GLushort *) src; 2317 GLuint i; 2318 for (i = 0; i < n; i ++) { 2319 GLushort p = ussrc[i]; 2320 SWAP2BYTE(p); 2321 rgba[i][rComp] = ((p ) & 0xf) * (1.0F / 15.0F); 2322 rgba[i][gComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F); 2323 rgba[i][bComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F); 2324 rgba[i][aComp] = ((p >> 12) ) * (1.0F / 15.0F); 2325 } 2326 } 2327 else { 2328 const GLushort *ussrc = (const GLushort *) src; 2329 GLuint i; 2330 for (i = 0; i < n; i ++) { 2331 GLushort p = ussrc[i]; 2332 rgba[i][rComp] = ((p ) & 0xf) * (1.0F / 15.0F); 2333 rgba[i][gComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F); 2334 rgba[i][bComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F); 2335 rgba[i][aComp] = ((p >> 12) ) * (1.0F / 15.0F); 2336 } 2337 } 2338 break; 2339 case GL_UNSIGNED_SHORT_5_5_5_1: 2340 if (swapBytes) { 2341 const GLushort *ussrc = (const GLushort *) src; 2342 GLuint i; 2343 for (i = 0; i < n; i ++) { 2344 GLushort p = ussrc[i]; 2345 SWAP2BYTE(p); 2346 rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F); 2347 rgba[i][gComp] = ((p >> 6) & 0x1f) * (1.0F / 31.0F); 2348 rgba[i][bComp] = ((p >> 1) & 0x1f) * (1.0F / 31.0F); 2349 rgba[i][aComp] = ((p ) & 0x1) * (1.0F / 1.0F); 2350 } 2351 } 2352 else { 2353 const GLushort *ussrc = (const GLushort *) src; 2354 GLuint i; 2355 for (i = 0; i < n; i ++) { 2356 GLushort p = ussrc[i]; 2357 rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F); 2358 rgba[i][gComp] = ((p >> 6) & 0x1f) * (1.0F / 31.0F); 2359 rgba[i][bComp] = ((p >> 1) & 0x1f) * (1.0F / 31.0F); 2360 rgba[i][aComp] = ((p ) & 0x1) * (1.0F / 1.0F); 2361 } 2362 } 2363 break; 2364 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 2365 if (swapBytes) { 2366 const GLushort *ussrc = (const GLushort *) src; 2367 GLuint i; 2368 for (i = 0; i < n; i ++) { 2369 GLushort p = ussrc[i]; 2370 SWAP2BYTE(p); 2371 rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F); 2372 rgba[i][gComp] = ((p >> 5) & 0x1f) * (1.0F / 31.0F); 2373 rgba[i][bComp] = ((p >> 10) & 0x1f) * (1.0F / 31.0F); 2374 rgba[i][aComp] = ((p >> 15) ) * (1.0F / 1.0F); 2375 } 2376 } 2377 else { 2378 const GLushort *ussrc = (const GLushort *) src; 2379 GLuint i; 2380 for (i = 0; i < n; i ++) { 2381 GLushort p = ussrc[i]; 2382 rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F); 2383 rgba[i][gComp] = ((p >> 5) & 0x1f) * (1.0F / 31.0F); 2384 rgba[i][bComp] = ((p >> 10) & 0x1f) * (1.0F / 31.0F); 2385 rgba[i][aComp] = ((p >> 15) ) * (1.0F / 1.0F); 2386 } 2387 } 2388 break; 2389 case GL_UNSIGNED_INT_8_8_8_8: 2390 if (swapBytes) { 2391 const GLuint *uisrc = (const GLuint *) src; 2392 GLuint i; 2393 for (i = 0; i < n; i ++) { 2394 GLuint p = uisrc[i]; 2395 rgba[i][rComp] = UBYTE_TO_FLOAT((p ) & 0xff); 2396 rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 8) & 0xff); 2397 rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff); 2398 rgba[i][aComp] = UBYTE_TO_FLOAT((p >> 24) ); 2399 } 2400 } 2401 else { 2402 const GLuint *uisrc = (const GLuint *) src; 2403 GLuint i; 2404 for (i = 0; i < n; i ++) { 2405 GLuint p = uisrc[i]; 2406 rgba[i][rComp] = UBYTE_TO_FLOAT((p >> 24) ); 2407 rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff); 2408 rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 8) & 0xff); 2409 rgba[i][aComp] = UBYTE_TO_FLOAT((p ) & 0xff); 2410 } 2411 } 2412 break; 2413 case GL_UNSIGNED_INT_8_8_8_8_REV: 2414 if (swapBytes) { 2415 const GLuint *uisrc = (const GLuint *) src; 2416 GLuint i; 2417 for (i = 0; i < n; i ++) { 2418 GLuint p = uisrc[i]; 2419 rgba[i][rComp] = UBYTE_TO_FLOAT((p >> 24) ); 2420 rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff); 2421 rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 8) & 0xff); 2422 rgba[i][aComp] = UBYTE_TO_FLOAT((p ) & 0xff); 2423 } 2424 } 2425 else { 2426 const GLuint *uisrc = (const GLuint *) src; 2427 GLuint i; 2428 for (i = 0; i < n; i ++) { 2429 GLuint p = uisrc[i]; 2430 rgba[i][rComp] = UBYTE_TO_FLOAT((p ) & 0xff); 2431 rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 8) & 0xff); 2432 rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff); 2433 rgba[i][aComp] = UBYTE_TO_FLOAT((p >> 24) ); 2434 } 2435 } 2436 break; 2437 case GL_UNSIGNED_INT_10_10_10_2: 2438 if (swapBytes) { 2439 const GLuint *uisrc = (const GLuint *) src; 2440 GLuint i; 2441 for (i = 0; i < n; i ++) { 2442 GLuint p = uisrc[i]; 2443 SWAP4BYTE(p); 2444 rgba[i][rComp] = ((p >> 22) ) * (1.0F / 1023.0F); 2445 rgba[i][gComp] = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F); 2446 rgba[i][bComp] = ((p >> 2) & 0x3ff) * (1.0F / 1023.0F); 2447 rgba[i][aComp] = ((p ) & 0x3 ) * (1.0F / 3.0F); 2448 } 2449 } 2450 else { 2451 const GLuint *uisrc = (const GLuint *) src; 2452 GLuint i; 2453 for (i = 0; i < n; i ++) { 2454 GLuint p = uisrc[i]; 2455 rgba[i][rComp] = ((p >> 22) ) * (1.0F / 1023.0F); 2456 rgba[i][gComp] = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F); 2457 rgba[i][bComp] = ((p >> 2) & 0x3ff) * (1.0F / 1023.0F); 2458 rgba[i][aComp] = ((p ) & 0x3 ) * (1.0F / 3.0F); 2459 } 2460 } 2461 break; 2462 case GL_UNSIGNED_INT_2_10_10_10_REV: 2463 if (swapBytes) { 2464 const GLuint *uisrc = (const GLuint *) src; 2465 GLuint i; 2466 for (i = 0; i < n; i ++) { 2467 GLuint p = uisrc[i]; 2468 SWAP4BYTE(p); 2469 rgba[i][rComp] = ((p ) & 0x3ff) * (1.0F / 1023.0F); 2470 rgba[i][gComp] = ((p >> 10) & 0x3ff) * (1.0F / 1023.0F); 2471 rgba[i][bComp] = ((p >> 20) & 0x3ff) * (1.0F / 1023.0F); 2472 rgba[i][aComp] = ((p >> 30) ) * (1.0F / 3.0F); 2473 } 2474 } 2475 else { 2476 const GLuint *uisrc = (const GLuint *) src; 2477 GLuint i; 2478 for (i = 0; i < n; i ++) { 2479 GLuint p = uisrc[i]; 2480 rgba[i][rComp] = ((p ) & 0x3ff) * (1.0F / 1023.0F); 2481 rgba[i][gComp] = ((p >> 10) & 0x3ff) * (1.0F / 1023.0F); 2482 rgba[i][bComp] = ((p >> 20) & 0x3ff) * (1.0F / 1023.0F); 2483 rgba[i][aComp] = ((p >> 30) ) * (1.0F / 3.0F); 2484 } 2485 } 2486 break; 2487 default: 2488 _mesa_problem(NULL, "bad srcType in extract float data"); 2489 break; 2490 } 2491} 2492 2493 2494 2495/* 2496 * Unpack a row of color image data from a client buffer according to 2497 * the pixel unpacking parameters. 2498 * Return GLubyte values in the specified dest image format. 2499 * This is (or will be) used by glDrawPixels and glTexImage?D(). 2500 * Input: ctx - the context 2501 * n - number of pixels in the span 2502 * dstFormat - format of destination color array 2503 * dest - the destination color array 2504 * srcFormat - source image format 2505 * srcType - source image datatype 2506 * source - source image pointer 2507 * srcPacking - pixel unpacking parameters 2508 * transferOps - bitmask of IMAGE_*_BIT values of operations to apply 2509 * 2510 * XXX perhaps expand this to process whole images someday. 2511 */ 2512void 2513_mesa_unpack_chan_color_span( GLcontext *ctx, 2514 GLuint n, GLenum dstFormat, GLchan dest[], 2515 GLenum srcFormat, GLenum srcType, 2516 const GLvoid *source, 2517 const struct gl_pixelstore_attrib *srcPacking, 2518 GLuint transferOps ) 2519{ 2520 ASSERT(dstFormat == GL_ALPHA || 2521 dstFormat == GL_LUMINANCE || 2522 dstFormat == GL_LUMINANCE_ALPHA || 2523 dstFormat == GL_INTENSITY || 2524 dstFormat == GL_RGB || 2525 dstFormat == GL_RGBA || 2526 dstFormat == GL_COLOR_INDEX); 2527 2528 ASSERT(srcFormat == GL_RED || 2529 srcFormat == GL_GREEN || 2530 srcFormat == GL_BLUE || 2531 srcFormat == GL_ALPHA || 2532 srcFormat == GL_LUMINANCE || 2533 srcFormat == GL_LUMINANCE_ALPHA || 2534 srcFormat == GL_INTENSITY || 2535 srcFormat == GL_RGB || 2536 srcFormat == GL_BGR || 2537 srcFormat == GL_RGBA || 2538 srcFormat == GL_BGRA || 2539 srcFormat == GL_ABGR_EXT || 2540 srcFormat == GL_COLOR_INDEX); 2541 2542 ASSERT(srcType == GL_BITMAP || 2543 srcType == GL_UNSIGNED_BYTE || 2544 srcType == GL_BYTE || 2545 srcType == GL_UNSIGNED_SHORT || 2546 srcType == GL_SHORT || 2547 srcType == GL_UNSIGNED_INT || 2548 srcType == GL_INT || 2549 srcType == GL_FLOAT || 2550 srcType == GL_UNSIGNED_BYTE_3_3_2 || 2551 srcType == GL_UNSIGNED_BYTE_2_3_3_REV || 2552 srcType == GL_UNSIGNED_SHORT_5_6_5 || 2553 srcType == GL_UNSIGNED_SHORT_5_6_5_REV || 2554 srcType == GL_UNSIGNED_SHORT_4_4_4_4 || 2555 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV || 2556 srcType == GL_UNSIGNED_SHORT_5_5_5_1 || 2557 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV || 2558 srcType == GL_UNSIGNED_INT_8_8_8_8 || 2559 srcType == GL_UNSIGNED_INT_8_8_8_8_REV || 2560 srcType == GL_UNSIGNED_INT_10_10_10_2 || 2561 srcType == GL_UNSIGNED_INT_2_10_10_10_REV); 2562 2563 /* Try simple cases first */ 2564 if (transferOps == 0 && srcType == CHAN_TYPE) { 2565 if (dstFormat == GL_RGBA) { 2566 if (srcFormat == GL_RGBA) { 2567 MEMCPY( dest, source, n * 4 * sizeof(GLchan) ); 2568 return; 2569 } 2570 else if (srcFormat == GL_RGB) { 2571 GLuint i; 2572 const GLchan *src = (const GLchan *) source; 2573 GLchan *dst = dest; 2574 for (i = 0; i < n; i++) { 2575 dst[0] = src[0]; 2576 dst[1] = src[1]; 2577 dst[2] = src[2]; 2578 dst[3] = CHAN_MAX; 2579 src += 3; 2580 dst += 4; 2581 } 2582 return; 2583 } 2584 } 2585 else if (dstFormat == GL_RGB) { 2586 if (srcFormat == GL_RGB) { 2587 MEMCPY( dest, source, n * 3 * sizeof(GLchan) ); 2588 return; 2589 } 2590 else if (srcFormat == GL_RGBA) { 2591 GLuint i; 2592 const GLchan *src = (const GLchan *) source; 2593 GLchan *dst = dest; 2594 for (i = 0; i < n; i++) { 2595 dst[0] = src[0]; 2596 dst[1] = src[1]; 2597 dst[2] = src[2]; 2598 src += 4; 2599 dst += 3; 2600 } 2601 return; 2602 } 2603 } 2604 else if (dstFormat == srcFormat) { 2605 GLint comps = _mesa_components_in_format(srcFormat); 2606 assert(comps > 0); 2607 MEMCPY( dest, source, n * comps * sizeof(GLchan) ); 2608 return; 2609 } 2610 } 2611 2612 2613 /* general solution begins here */ 2614 { 2615 GLint dstComponents; 2616 GLint dstRedIndex, dstGreenIndex, dstBlueIndex, dstAlphaIndex; 2617 GLint dstLuminanceIndex, dstIntensityIndex; 2618 DEFMARRAY(GLfloat, rgba, MAX_WIDTH, 4); /* mac 32k limitation */ 2619 CHECKARRAY(rgba, return); /* mac 32k limitation */ 2620 2621 dstComponents = _mesa_components_in_format( dstFormat ); 2622 /* source & dest image formats should have been error checked by now */ 2623 assert(dstComponents > 0); 2624 2625 /* 2626 * Extract image data and convert to RGBA floats 2627 */ 2628 assert(n <= MAX_WIDTH); 2629 if (srcFormat == GL_COLOR_INDEX) { 2630 GLuint indexes[MAX_WIDTH]; 2631 extract_uint_indexes(n, indexes, srcFormat, srcType, source, 2632 srcPacking); 2633 2634 if (dstFormat == GL_COLOR_INDEX 2635 && (transferOps & IMAGE_MAP_COLOR_BIT)) { 2636 _mesa_map_ci(ctx, n, indexes); 2637 } 2638 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) { 2639 _mesa_shift_and_offset_ci(ctx, n, indexes); 2640 } 2641 2642 if (dstFormat == GL_COLOR_INDEX) { 2643 /* convert to GLchan and return */ 2644 GLuint i; 2645 for (i = 0; i < n; i++) { 2646 dest[i] = (GLchan) (indexes[i] & 0xff); 2647 } 2648 UNDEFARRAY(rgba); /* mac 32k limitation */ 2649 return; 2650 } 2651 else { 2652 /* Convert indexes to RGBA */ 2653 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba); 2654 } 2655 } 2656 else { 2657 extract_float_rgba(n, rgba, srcFormat, srcType, source, 2658 srcPacking->SwapBytes); 2659 2660 /* scale and bias colors */ 2661 if (transferOps & IMAGE_SCALE_BIAS_BIT) { 2662 _mesa_scale_and_bias_rgba(ctx, n, rgba, 2663 ctx->Pixel.RedScale, ctx->Pixel.GreenScale, 2664 ctx->Pixel.BlueScale, ctx->Pixel.AlphaScale, 2665 ctx->Pixel.RedBias, ctx->Pixel.GreenBias, 2666 ctx->Pixel.BlueBias, ctx->Pixel.AlphaBias); 2667 } 2668 /* color map lookup */ 2669 if (transferOps & IMAGE_MAP_COLOR_BIT) { 2670 _mesa_map_rgba(ctx, n, rgba); 2671 } 2672 } 2673 2674 if (transferOps) { 2675 /* GL_COLOR_TABLE lookup */ 2676 if (transferOps & IMAGE_COLOR_TABLE_BIT) { 2677 _mesa_lookup_rgba(&ctx->ColorTable, n, rgba); 2678 } 2679 /* convolution */ 2680 if (transferOps & IMAGE_CONVOLUTION_BIT) { 2681 /* this has to be done in the calling code */ 2682 } 2683 /* GL_POST_CONVOLUTION_RED/GREEN/BLUE/ALPHA_SCALE/BIAS */ 2684 if (transferOps & IMAGE_POST_CONVOLUTION_SCALE_BIAS) { 2685 _mesa_scale_and_bias_rgba(ctx, n, rgba, 2686 ctx->Pixel.PostConvolutionScale[RCOMP], 2687 ctx->Pixel.PostConvolutionScale[GCOMP], 2688 ctx->Pixel.PostConvolutionScale[BCOMP], 2689 ctx->Pixel.PostConvolutionScale[ACOMP], 2690 ctx->Pixel.PostConvolutionBias[RCOMP], 2691 ctx->Pixel.PostConvolutionBias[GCOMP], 2692 ctx->Pixel.PostConvolutionBias[BCOMP], 2693 ctx->Pixel.PostConvolutionBias[ACOMP]); 2694 } 2695 /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */ 2696 if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) { 2697 _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, n, rgba); 2698 } 2699 /* color matrix transform */ 2700 if (transferOps & IMAGE_COLOR_MATRIX_BIT) { 2701 _mesa_transform_rgba(ctx, n, rgba); 2702 } 2703 /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */ 2704 if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) { 2705 _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, n, rgba); 2706 } 2707 /* update histogram count */ 2708 if (transferOps & IMAGE_HISTOGRAM_BIT) { 2709 _mesa_update_histogram(ctx, n, (CONST GLfloat (*)[4]) rgba); 2710 } 2711 /* min/max here */ 2712 if (transferOps & IMAGE_MIN_MAX_BIT) { 2713 _mesa_update_minmax(ctx, n, (CONST GLfloat (*)[4]) rgba); 2714 } 2715 } 2716 2717 /* clamp to [0,1] */ 2718#if CHAN_TYPE != GL_FLOAT 2719 { 2720 GLuint i; 2721 for (i = 0; i < n; i++) { 2722 rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F); 2723 rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F); 2724 rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F); 2725 rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F); 2726 } 2727 } 2728#endif 2729 2730 /* Now determine which color channels we need to produce. 2731 * And determine the dest index (offset) within each color tuple. 2732 */ 2733 switch (dstFormat) { 2734 case GL_ALPHA: 2735 dstAlphaIndex = 0; 2736 dstRedIndex = dstGreenIndex = dstBlueIndex = -1; 2737 dstLuminanceIndex = dstIntensityIndex = -1; 2738 break; 2739 case GL_LUMINANCE: 2740 dstLuminanceIndex = 0; 2741 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1; 2742 dstIntensityIndex = -1; 2743 break; 2744 case GL_LUMINANCE_ALPHA: 2745 dstLuminanceIndex = 0; 2746 dstAlphaIndex = 1; 2747 dstRedIndex = dstGreenIndex = dstBlueIndex = -1; 2748 dstIntensityIndex = -1; 2749 break; 2750 case GL_INTENSITY: 2751 dstIntensityIndex = 0; 2752 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1; 2753 dstLuminanceIndex = -1; 2754 break; 2755 case GL_RGB: 2756 dstRedIndex = 0; 2757 dstGreenIndex = 1; 2758 dstBlueIndex = 2; 2759 dstAlphaIndex = dstLuminanceIndex = dstIntensityIndex = -1; 2760 break; 2761 case GL_RGBA: 2762 dstRedIndex = 0; 2763 dstGreenIndex = 1; 2764 dstBlueIndex = 2; 2765 dstAlphaIndex = 3; 2766 dstLuminanceIndex = dstIntensityIndex = -1; 2767 break; 2768 default: 2769 _mesa_problem(ctx, "bad dstFormat in _mesa_unpack_chan_span()"); 2770 UNDEFARRAY(rgba); /* mac 32k limitation */ 2771 return; 2772 } 2773 2774 2775 /* Now return the GLchan data in the requested dstFormat */ 2776 2777 if (dstRedIndex >= 0) { 2778 GLchan *dst = dest; 2779 GLuint i; 2780 for (i = 0; i < n; i++) { 2781 CLAMPED_FLOAT_TO_CHAN(dst[dstRedIndex], rgba[i][RCOMP]); 2782 dst += dstComponents; 2783 } 2784 } 2785 2786 if (dstGreenIndex >= 0) { 2787 GLchan *dst = dest; 2788 GLuint i; 2789 for (i = 0; i < n; i++) { 2790 CLAMPED_FLOAT_TO_CHAN(dst[dstGreenIndex], rgba[i][GCOMP]); 2791 dst += dstComponents; 2792 } 2793 } 2794 2795 if (dstBlueIndex >= 0) { 2796 GLchan *dst = dest; 2797 GLuint i; 2798 for (i = 0; i < n; i++) { 2799 CLAMPED_FLOAT_TO_CHAN(dst[dstBlueIndex], rgba[i][BCOMP]); 2800 dst += dstComponents; 2801 } 2802 } 2803 2804 if (dstAlphaIndex >= 0) { 2805 GLchan *dst = dest; 2806 GLuint i; 2807 for (i = 0; i < n; i++) { 2808 CLAMPED_FLOAT_TO_CHAN(dst[dstAlphaIndex], rgba[i][ACOMP]); 2809 dst += dstComponents; 2810 } 2811 } 2812 2813 if (dstIntensityIndex >= 0) { 2814 GLchan *dst = dest; 2815 GLuint i; 2816 assert(dstIntensityIndex == 0); 2817 assert(dstComponents == 1); 2818 for (i = 0; i < n; i++) { 2819 /* Intensity comes from red channel */ 2820 CLAMPED_FLOAT_TO_CHAN(dst[i], rgba[i][RCOMP]); 2821 } 2822 } 2823 2824 if (dstLuminanceIndex >= 0) { 2825 GLchan *dst = dest; 2826 GLuint i; 2827 assert(dstLuminanceIndex == 0); 2828 for (i = 0; i < n; i++) { 2829 /* Luminance comes from red channel */ 2830 CLAMPED_FLOAT_TO_CHAN(dst[0], rgba[i][RCOMP]); 2831 dst += dstComponents; 2832 } 2833 } 2834 UNDEFARRAY(rgba); /* mac 32k limitation */ 2835 } 2836} 2837 2838 2839void 2840_mesa_unpack_float_color_span( GLcontext *ctx, 2841 GLuint n, GLenum dstFormat, GLfloat dest[], 2842 GLenum srcFormat, GLenum srcType, 2843 const GLvoid *source, 2844 const struct gl_pixelstore_attrib *srcPacking, 2845 GLuint transferOps, GLboolean clamp ) 2846{ 2847 ASSERT(dstFormat == GL_ALPHA || 2848 dstFormat == GL_LUMINANCE || 2849 dstFormat == GL_LUMINANCE_ALPHA || 2850 dstFormat == GL_INTENSITY || 2851 dstFormat == GL_RGB || 2852 dstFormat == GL_RGBA || 2853 dstFormat == GL_COLOR_INDEX); 2854 2855 ASSERT(srcFormat == GL_RED || 2856 srcFormat == GL_GREEN || 2857 srcFormat == GL_BLUE || 2858 srcFormat == GL_ALPHA || 2859 srcFormat == GL_LUMINANCE || 2860 srcFormat == GL_LUMINANCE_ALPHA || 2861 srcFormat == GL_INTENSITY || 2862 srcFormat == GL_RGB || 2863 srcFormat == GL_BGR || 2864 srcFormat == GL_RGBA || 2865 srcFormat == GL_BGRA || 2866 srcFormat == GL_ABGR_EXT || 2867 srcFormat == GL_COLOR_INDEX); 2868 2869 ASSERT(srcType == GL_BITMAP || 2870 srcType == GL_UNSIGNED_BYTE || 2871 srcType == GL_BYTE || 2872 srcType == GL_UNSIGNED_SHORT || 2873 srcType == GL_SHORT || 2874 srcType == GL_UNSIGNED_INT || 2875 srcType == GL_INT || 2876 srcType == GL_FLOAT || 2877 srcType == GL_UNSIGNED_BYTE_3_3_2 || 2878 srcType == GL_UNSIGNED_BYTE_2_3_3_REV || 2879 srcType == GL_UNSIGNED_SHORT_5_6_5 || 2880 srcType == GL_UNSIGNED_SHORT_5_6_5_REV || 2881 srcType == GL_UNSIGNED_SHORT_4_4_4_4 || 2882 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV || 2883 srcType == GL_UNSIGNED_SHORT_5_5_5_1 || 2884 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV || 2885 srcType == GL_UNSIGNED_INT_8_8_8_8 || 2886 srcType == GL_UNSIGNED_INT_8_8_8_8_REV || 2887 srcType == GL_UNSIGNED_INT_10_10_10_2 || 2888 srcType == GL_UNSIGNED_INT_2_10_10_10_REV); 2889 2890 /* general solution, no special cases, yet */ 2891 { 2892 GLint dstComponents; 2893 GLint dstRedIndex, dstGreenIndex, dstBlueIndex, dstAlphaIndex; 2894 GLint dstLuminanceIndex, dstIntensityIndex; 2895 DEFMARRAY(GLfloat, rgba, MAX_WIDTH, 4); /* mac 32k limitation */ 2896 CHECKARRAY(rgba, return); /* mac 32k limitation */ 2897 2898 dstComponents = _mesa_components_in_format( dstFormat ); 2899 /* source & dest image formats should have been error checked by now */ 2900 assert(dstComponents > 0); 2901 2902 /* 2903 * Extract image data and convert to RGBA floats 2904 */ 2905 assert(n <= MAX_WIDTH); 2906 if (srcFormat == GL_COLOR_INDEX) { 2907 GLuint indexes[MAX_WIDTH]; 2908 extract_uint_indexes(n, indexes, srcFormat, srcType, source, 2909 srcPacking); 2910 2911 if (dstFormat == GL_COLOR_INDEX 2912 && (transferOps & IMAGE_MAP_COLOR_BIT)) { 2913 _mesa_map_ci(ctx, n, indexes); 2914 } 2915 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) { 2916 _mesa_shift_and_offset_ci(ctx, n, indexes); 2917 } 2918 2919 if (dstFormat == GL_COLOR_INDEX) { 2920 /* convert to GLchan and return */ 2921 GLuint i; 2922 for (i = 0; i < n; i++) { 2923 dest[i] = (GLchan) (indexes[i] & 0xff); 2924 } 2925 UNDEFARRAY(rgba); /* mac 32k limitation */ 2926 return; 2927 } 2928 else { 2929 /* Convert indexes to RGBA */ 2930 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba); 2931 } 2932 } 2933 else { 2934 extract_float_rgba(n, rgba, srcFormat, srcType, source, 2935 srcPacking->SwapBytes); 2936 2937 /* scale and bias colors */ 2938 if (transferOps & IMAGE_SCALE_BIAS_BIT) { 2939 _mesa_scale_and_bias_rgba(ctx, n, rgba, 2940 ctx->Pixel.RedScale, ctx->Pixel.GreenScale, 2941 ctx->Pixel.BlueScale, ctx->Pixel.AlphaScale, 2942 ctx->Pixel.RedBias, ctx->Pixel.GreenBias, 2943 ctx->Pixel.BlueBias, ctx->Pixel.AlphaBias); 2944 } 2945 /* color map lookup */ 2946 if (transferOps & IMAGE_MAP_COLOR_BIT) { 2947 _mesa_map_rgba(ctx, n, rgba); 2948 } 2949 } 2950 2951 if (transferOps) { 2952 /* GL_COLOR_TABLE lookup */ 2953 if (transferOps & IMAGE_COLOR_TABLE_BIT) { 2954 _mesa_lookup_rgba(&ctx->ColorTable, n, rgba); 2955 } 2956 /* convolution */ 2957 if (transferOps & IMAGE_CONVOLUTION_BIT) { 2958 /* XXX to do */ 2959 } 2960 /* GL_POST_CONVOLUTION_RED/GREEN/BLUE/ALPHA_SCALE/BIAS */ 2961 if (transferOps & IMAGE_POST_CONVOLUTION_SCALE_BIAS) { 2962 _mesa_scale_and_bias_rgba(ctx, n, rgba, 2963 ctx->Pixel.PostConvolutionScale[RCOMP], 2964 ctx->Pixel.PostConvolutionScale[GCOMP], 2965 ctx->Pixel.PostConvolutionScale[BCOMP], 2966 ctx->Pixel.PostConvolutionScale[ACOMP], 2967 ctx->Pixel.PostConvolutionBias[RCOMP], 2968 ctx->Pixel.PostConvolutionBias[GCOMP], 2969 ctx->Pixel.PostConvolutionBias[BCOMP], 2970 ctx->Pixel.PostConvolutionBias[ACOMP]); 2971 } 2972 /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */ 2973 if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) { 2974 _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, n, rgba); 2975 } 2976 /* color matrix transform */ 2977 if (transferOps & IMAGE_COLOR_MATRIX_BIT) { 2978 _mesa_transform_rgba(ctx, n, rgba); 2979 } 2980 /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */ 2981 if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) { 2982 _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, n, rgba); 2983 } 2984 /* update histogram count */ 2985 if (transferOps & IMAGE_HISTOGRAM_BIT) { 2986 _mesa_update_histogram(ctx, n, (CONST GLfloat (*)[4]) rgba); 2987 } 2988 /* min/max here */ 2989 if (transferOps & IMAGE_MIN_MAX_BIT) { 2990 _mesa_update_minmax(ctx, n, (CONST GLfloat (*)[4]) rgba); 2991 } 2992 } 2993 2994 /* clamp to [0,1] */ 2995#if CHAN_TYPE != GL_FLOAT 2996 if (clamp) { 2997 GLuint i; 2998 for (i = 0; i < n; i++) { 2999 rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F); 3000 rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F); 3001 rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F); 3002 rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F); 3003 } 3004 } 3005#endif 3006 3007 /* Now determine which color channels we need to produce. 3008 * And determine the dest index (offset) within each color tuple. 3009 */ 3010 switch (dstFormat) { 3011 case GL_ALPHA: 3012 dstAlphaIndex = 0; 3013 dstRedIndex = dstGreenIndex = dstBlueIndex = -1; 3014 dstLuminanceIndex = dstIntensityIndex = -1; 3015 break; 3016 case GL_LUMINANCE: 3017 dstLuminanceIndex = 0; 3018 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1; 3019 dstIntensityIndex = -1; 3020 break; 3021 case GL_LUMINANCE_ALPHA: 3022 dstLuminanceIndex = 0; 3023 dstAlphaIndex = 1; 3024 dstRedIndex = dstGreenIndex = dstBlueIndex = -1; 3025 dstIntensityIndex = -1; 3026 break; 3027 case GL_INTENSITY: 3028 dstIntensityIndex = 0; 3029 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1; 3030 dstLuminanceIndex = -1; 3031 break; 3032 case GL_RGB: 3033 dstRedIndex = 0; 3034 dstGreenIndex = 1; 3035 dstBlueIndex = 2; 3036 dstAlphaIndex = dstLuminanceIndex = dstIntensityIndex = -1; 3037 break; 3038 case GL_RGBA: 3039 dstRedIndex = 0; 3040 dstGreenIndex = 1; 3041 dstBlueIndex = 2; 3042 dstAlphaIndex = 3; 3043 dstLuminanceIndex = dstIntensityIndex = -1; 3044 break; 3045 default: 3046 _mesa_problem(ctx, "bad dstFormat in _mesa_unpack_float_color_span()"); 3047 UNDEFARRAY(rgba); /* mac 32k limitation */ 3048 return; 3049 } 3050 3051 /* Now pack results in the requested dstFormat */ 3052 if (dstRedIndex >= 0) { 3053 GLfloat *dst = dest; 3054 GLuint i; 3055 for (i = 0; i < n; i++) { 3056 dst[dstRedIndex] = rgba[i][RCOMP]; 3057 dst += dstComponents; 3058 } 3059 } 3060 3061 if (dstGreenIndex >= 0) { 3062 GLfloat *dst = dest; 3063 GLuint i; 3064 for (i = 0; i < n; i++) { 3065 dst[dstGreenIndex] = rgba[i][GCOMP]; 3066 dst += dstComponents; 3067 } 3068 } 3069 3070 if (dstBlueIndex >= 0) { 3071 GLfloat *dst = dest; 3072 GLuint i; 3073 for (i = 0; i < n; i++) { 3074 dst[dstBlueIndex] = rgba[i][BCOMP]; 3075 dst += dstComponents; 3076 } 3077 } 3078 3079 if (dstAlphaIndex >= 0) { 3080 GLfloat *dst = dest; 3081 GLuint i; 3082 for (i = 0; i < n; i++) { 3083 dst[dstAlphaIndex] = rgba[i][ACOMP]; 3084 dst += dstComponents; 3085 } 3086 } 3087 3088 if (dstIntensityIndex >= 0) { 3089 GLfloat *dst = dest; 3090 GLuint i; 3091 assert(dstIntensityIndex == 0); 3092 assert(dstComponents == 1); 3093 for (i = 0; i < n; i++) { 3094 /* Intensity comes from red channel */ 3095 dst[i] = rgba[i][RCOMP]; 3096 } 3097 } 3098 3099 if (dstLuminanceIndex >= 0) { 3100 GLfloat *dst = dest; 3101 GLuint i; 3102 assert(dstLuminanceIndex == 0); 3103 for (i = 0; i < n; i++) { 3104 /* Luminance comes from red channel */ 3105 dst[0] = rgba[i][RCOMP]; 3106 dst += dstComponents; 3107 } 3108 } 3109 UNDEFARRAY(rgba); /* mac 32k limitation */ 3110 } 3111} 3112 3113 3114 3115 3116/* 3117 * Unpack a row of color index data from a client buffer according to 3118 * the pixel unpacking parameters. 3119 * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc. 3120 * 3121 * Args: ctx - the context 3122 * n - number of pixels 3123 * dstType - destination datatype 3124 * dest - destination array 3125 * srcType - source pixel type 3126 * source - source data pointer 3127 * srcPacking - pixel unpacking parameters 3128 * transferOps - the pixel transfer operations to apply 3129 */ 3130void 3131_mesa_unpack_index_span( const GLcontext *ctx, GLuint n, 3132 GLenum dstType, GLvoid *dest, 3133 GLenum srcType, const GLvoid *source, 3134 const struct gl_pixelstore_attrib *srcPacking, 3135 GLuint transferOps ) 3136{ 3137 ASSERT(srcType == GL_BITMAP || 3138 srcType == GL_UNSIGNED_BYTE || 3139 srcType == GL_BYTE || 3140 srcType == GL_UNSIGNED_SHORT || 3141 srcType == GL_SHORT || 3142 srcType == GL_UNSIGNED_INT || 3143 srcType == GL_INT || 3144 srcType == GL_FLOAT); 3145 3146 ASSERT(dstType == GL_UNSIGNED_BYTE || 3147 dstType == GL_UNSIGNED_SHORT || 3148 dstType == GL_UNSIGNED_INT); 3149 3150 3151 transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT); 3152 3153 /* 3154 * Try simple cases first 3155 */ 3156 if (transferOps == 0 && srcType == GL_UNSIGNED_BYTE 3157 && dstType == GL_UNSIGNED_BYTE) { 3158 MEMCPY(dest, source, n * sizeof(GLubyte)); 3159 } 3160 else if (transferOps == 0 && srcType == GL_UNSIGNED_INT 3161 && dstType == GL_UNSIGNED_INT && !srcPacking->SwapBytes) { 3162 MEMCPY(dest, source, n * sizeof(GLuint)); 3163 } 3164 else { 3165 /* 3166 * general solution 3167 */ 3168 GLuint indexes[MAX_WIDTH]; 3169 assert(n <= MAX_WIDTH); 3170 3171 extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source, 3172 srcPacking); 3173 3174 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) { 3175 /* shift and offset indexes */ 3176 _mesa_shift_and_offset_ci(ctx, n, indexes); 3177 } 3178 if (transferOps & IMAGE_MAP_COLOR_BIT) { 3179 /* Apply lookup table */ 3180 _mesa_map_ci(ctx, n, indexes); 3181 } 3182 3183 /* convert to dest type */ 3184 switch (dstType) { 3185 case GL_UNSIGNED_BYTE: 3186 { 3187 GLubyte *dst = (GLubyte *) dest; 3188 GLuint i; 3189 for (i = 0; i < n; i++) { 3190 dst[i] = (GLubyte) (indexes[i] & 0xff); 3191 } 3192 } 3193 break; 3194 case GL_UNSIGNED_SHORT: 3195 { 3196 GLuint *dst = (GLuint *) dest; 3197 GLuint i; 3198 for (i = 0; i < n; i++) { 3199 dst[i] = (GLushort) (indexes[i] & 0xffff); 3200 } 3201 } 3202 break; 3203 case GL_UNSIGNED_INT: 3204 MEMCPY(dest, indexes, n * sizeof(GLuint)); 3205 break; 3206 default: 3207 _mesa_problem(ctx, "bad dstType in _mesa_unpack_index_span"); 3208 } 3209 } 3210} 3211 3212 3213void 3214_mesa_pack_index_span( const GLcontext *ctx, GLuint n, 3215 GLenum dstType, GLvoid *dest, const GLuint *source, 3216 const struct gl_pixelstore_attrib *dstPacking, 3217 GLuint transferOps ) 3218{ 3219 GLuint indexes[MAX_WIDTH]; 3220 3221 ASSERT(n <= MAX_WIDTH); 3222 3223 transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT); 3224 3225 if (transferOps & (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT)) { 3226 /* make a copy of input */ 3227 MEMCPY(indexes, source, n * sizeof(GLuint)); 3228 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) { 3229 _mesa_shift_and_offset_ci( ctx, n, indexes); 3230 } 3231 if (transferOps & IMAGE_MAP_COLOR_BIT) { 3232 _mesa_map_ci(ctx, n, indexes); 3233 } 3234 source = indexes; 3235 } 3236 3237 switch (dstType) { 3238 case GL_UNSIGNED_BYTE: 3239 { 3240 GLubyte *dst = (GLubyte *) dest; 3241 GLuint i; 3242 for (i = 0; i < n; i++) { 3243 *dst++ = (GLubyte) source[i]; 3244 } 3245 } 3246 break; 3247 case GL_BYTE: 3248 { 3249 GLbyte *dst = (GLbyte *) dest; 3250 GLuint i; 3251 for (i = 0; i < n; i++) { 3252 dst[i] = (GLbyte) source[i]; 3253 } 3254 } 3255 break; 3256 case GL_UNSIGNED_SHORT: 3257 { 3258 GLushort *dst = (GLushort *) dest; 3259 GLuint i; 3260 for (i = 0; i < n; i++) { 3261 dst[i] = (GLushort) source[i]; 3262 } 3263 if (dstPacking->SwapBytes) { 3264 _mesa_swap2( (GLushort *) dst, n ); 3265 } 3266 } 3267 break; 3268 case GL_SHORT: 3269 { 3270 GLshort *dst = (GLshort *) dest; 3271 GLuint i; 3272 for (i = 0; i < n; i++) { 3273 dst[i] = (GLshort) source[i]; 3274 } 3275 if (dstPacking->SwapBytes) { 3276 _mesa_swap2( (GLushort *) dst, n ); 3277 } 3278 } 3279 break; 3280 case GL_UNSIGNED_INT: 3281 { 3282 GLuint *dst = (GLuint *) dest; 3283 GLuint i; 3284 for (i = 0; i < n; i++) { 3285 dst[i] = (GLuint) source[i]; 3286 } 3287 if (dstPacking->SwapBytes) { 3288 _mesa_swap4( (GLuint *) dst, n ); 3289 } 3290 } 3291 break; 3292 case GL_INT: 3293 { 3294 GLint *dst = (GLint *) dest; 3295 GLuint i; 3296 for (i = 0; i < n; i++) { 3297 dst[i] = (GLint) source[i]; 3298 } 3299 if (dstPacking->SwapBytes) { 3300 _mesa_swap4( (GLuint *) dst, n ); 3301 } 3302 } 3303 break; 3304 case GL_FLOAT: 3305 { 3306 GLfloat *dst = (GLfloat *) dest; 3307 GLuint i; 3308 for (i = 0; i < n; i++) { 3309 dst[i] = (GLfloat) source[i]; 3310 } 3311 if (dstPacking->SwapBytes) { 3312 _mesa_swap4( (GLuint *) dst, n ); 3313 } 3314 } 3315 break; 3316 default: 3317 _mesa_problem(ctx, "bad type in _mesa_pack_index_span"); 3318 } 3319} 3320 3321 3322 3323/* 3324 * Unpack a row of stencil data from a client buffer according to 3325 * the pixel unpacking parameters. 3326 * This is (or will be) used by glDrawPixels 3327 * 3328 * Args: ctx - the context 3329 * n - number of pixels 3330 * dstType - destination datatype 3331 * dest - destination array 3332 * srcType - source pixel type 3333 * source - source data pointer 3334 * srcPacking - pixel unpacking parameters 3335 * transferOps - apply offset/bias/lookup ops? 3336 */ 3337void 3338_mesa_unpack_stencil_span( const GLcontext *ctx, GLuint n, 3339 GLenum dstType, GLvoid *dest, 3340 GLenum srcType, const GLvoid *source, 3341 const struct gl_pixelstore_attrib *srcPacking, 3342 GLuint transferOps ) 3343{ 3344 ASSERT(srcType == GL_BITMAP || 3345 srcType == GL_UNSIGNED_BYTE || 3346 srcType == GL_BYTE || 3347 srcType == GL_UNSIGNED_SHORT || 3348 srcType == GL_SHORT || 3349 srcType == GL_UNSIGNED_INT || 3350 srcType == GL_INT || 3351 srcType == GL_FLOAT); 3352 3353 ASSERT(dstType == GL_UNSIGNED_BYTE || 3354 dstType == GL_UNSIGNED_SHORT || 3355 dstType == GL_UNSIGNED_INT); 3356 3357 /* only shift and offset apply to stencil */ 3358 transferOps &= IMAGE_SHIFT_OFFSET_BIT; 3359 3360 /* 3361 * Try simple cases first 3362 */ 3363 if (transferOps == 0 && 3364 srcType == GL_UNSIGNED_BYTE && 3365 dstType == GL_UNSIGNED_BYTE) { 3366 MEMCPY(dest, source, n * sizeof(GLubyte)); 3367 } 3368 else if (transferOps == 0 && 3369 srcType == GL_UNSIGNED_INT && 3370 dstType == GL_UNSIGNED_INT && 3371 !srcPacking->SwapBytes) { 3372 MEMCPY(dest, source, n * sizeof(GLuint)); 3373 } 3374 else { 3375 /* 3376 * general solution 3377 */ 3378 GLuint indexes[MAX_WIDTH]; 3379 assert(n <= MAX_WIDTH); 3380 3381 extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source, 3382 srcPacking); 3383 3384 if (transferOps) { 3385 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) { 3386 /* shift and offset indexes */ 3387 _mesa_shift_and_offset_ci(ctx, n, indexes); 3388 } 3389 3390 if (ctx->Pixel.MapStencilFlag) { 3391 /* Apply stencil lookup table */ 3392 GLuint mask = ctx->Pixel.MapStoSsize - 1; 3393 GLuint i; 3394 for (i=0;i<n;i++) { 3395 indexes[i] = ctx->Pixel.MapStoS[ indexes[i] & mask ]; 3396 } 3397 } 3398 } 3399 3400 /* convert to dest type */ 3401 switch (dstType) { 3402 case GL_UNSIGNED_BYTE: 3403 { 3404 GLubyte *dst = (GLubyte *) dest; 3405 GLuint i; 3406 for (i = 0; i < n; i++) { 3407 dst[i] = (GLubyte) (indexes[i] & 0xff); 3408 } 3409 } 3410 break; 3411 case GL_UNSIGNED_SHORT: 3412 { 3413 GLuint *dst = (GLuint *) dest; 3414 GLuint i; 3415 for (i = 0; i < n; i++) { 3416 dst[i] = (GLushort) (indexes[i] & 0xffff); 3417 } 3418 } 3419 break; 3420 case GL_UNSIGNED_INT: 3421 MEMCPY(dest, indexes, n * sizeof(GLuint)); 3422 break; 3423 default: 3424 _mesa_problem(ctx, "bad dstType in _mesa_unpack_stencil_span"); 3425 } 3426 } 3427} 3428 3429 3430void 3431_mesa_pack_stencil_span( const GLcontext *ctx, GLuint n, 3432 GLenum dstType, GLvoid *dest, const GLstencil *source, 3433 const struct gl_pixelstore_attrib *dstPacking ) 3434{ 3435 GLstencil stencil[MAX_WIDTH]; 3436 3437 ASSERT(n <= MAX_WIDTH); 3438 3439 if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset || 3440 ctx->Pixel.MapStencilFlag) { 3441 /* make a copy of input */ 3442 MEMCPY(stencil, source, n * sizeof(GLstencil)); 3443 if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset) { 3444 _mesa_shift_and_offset_stencil( ctx, n, stencil ); 3445 } 3446 if (ctx->Pixel.MapStencilFlag) { 3447 _mesa_map_stencil( ctx, n, stencil ); 3448 } 3449 source = stencil; 3450 } 3451 3452 switch (dstType) { 3453 case GL_UNSIGNED_BYTE: 3454 if (sizeof(GLstencil) == 8) { 3455 MEMCPY( dest, source, n ); 3456 } 3457 else { 3458 GLubyte *dst = (GLubyte *) dest; 3459 GLuint i; 3460 for (i=0;i<n;i++) { 3461 dst[i] = (GLubyte) source[i]; 3462 } 3463 } 3464 break; 3465 case GL_BYTE: 3466 if (sizeof(GLstencil) == 8) { 3467 MEMCPY( dest, source, n ); 3468 } 3469 else { 3470 GLbyte *dst = (GLbyte *) dest; 3471 GLuint i; 3472 for (i=0;i<n;i++) { 3473 dst[i] = (GLbyte) source[i]; 3474 } 3475 } 3476 break; 3477 case GL_UNSIGNED_SHORT: 3478 { 3479 GLushort *dst = (GLushort *) dest; 3480 GLuint i; 3481 for (i=0;i<n;i++) { 3482 dst[i] = (GLushort) source[i]; 3483 } 3484 if (dstPacking->SwapBytes) { 3485 _mesa_swap2( (GLushort *) dst, n ); 3486 } 3487 } 3488 break; 3489 case GL_SHORT: 3490 { 3491 GLshort *dst = (GLshort *) dest; 3492 GLuint i; 3493 for (i=0;i<n;i++) { 3494 dst[i] = (GLshort) source[i]; 3495 } 3496 if (dstPacking->SwapBytes) { 3497 _mesa_swap2( (GLushort *) dst, n ); 3498 } 3499 } 3500 break; 3501 case GL_UNSIGNED_INT: 3502 { 3503 GLuint *dst = (GLuint *) dest; 3504 GLuint i; 3505 for (i=0;i<n;i++) { 3506 dst[i] = (GLuint) source[i]; 3507 } 3508 if (dstPacking->SwapBytes) { 3509 _mesa_swap4( (GLuint *) dst, n ); 3510 } 3511 } 3512 break; 3513 case GL_INT: 3514 { 3515 GLint *dst = (GLint *) dest; 3516 GLuint i; 3517 for (i=0;i<n;i++) { 3518 *dst++ = (GLint) source[i]; 3519 } 3520 if (dstPacking->SwapBytes) { 3521 _mesa_swap4( (GLuint *) dst, n ); 3522 } 3523 } 3524 break; 3525 case GL_FLOAT: 3526 { 3527 GLfloat *dst = (GLfloat *) dest; 3528 GLuint i; 3529 for (i=0;i<n;i++) { 3530 dst[i] = (GLfloat) source[i]; 3531 } 3532 if (dstPacking->SwapBytes) { 3533 _mesa_swap4( (GLuint *) dst, n ); 3534 } 3535 } 3536 break; 3537 case GL_BITMAP: 3538 if (dstPacking->LsbFirst) { 3539 GLubyte *dst = (GLubyte *) dest; 3540 GLint shift = 0; 3541 GLuint i; 3542 for (i = 0; i < n; i++) { 3543 if (shift == 0) 3544 *dst = 0; 3545 *dst |= ((source[i] != 0) << shift); 3546 shift++; 3547 if (shift == 8) { 3548 shift = 0; 3549 dst++; 3550 } 3551 } 3552 } 3553 else { 3554 GLubyte *dst = (GLubyte *) dest; 3555 GLint shift = 7; 3556 GLuint i; 3557 for (i = 0; i < n; i++) { 3558 if (shift == 7) 3559 *dst = 0; 3560 *dst |= ((source[i] != 0) << shift); 3561 shift--; 3562 if (shift < 0) { 3563 shift = 7; 3564 dst++; 3565 } 3566 } 3567 } 3568 break; 3569 default: 3570 _mesa_problem(ctx, "bad type in _mesa_pack_index_span"); 3571 } 3572} 3573 3574 3575 3576void 3577_mesa_unpack_depth_span( const GLcontext *ctx, GLuint n, GLfloat *dest, 3578 GLenum srcType, const GLvoid *source, 3579 const struct gl_pixelstore_attrib *srcPacking ) 3580{ 3581 switch (srcType) { 3582 case GL_BYTE: 3583 { 3584 GLuint i; 3585 const GLubyte *src = (const GLubyte *) source; 3586 for (i = 0; i < n; i++) { 3587 dest[i] = BYTE_TO_FLOAT(src[i]); 3588 } 3589 } 3590 break; 3591 case GL_UNSIGNED_BYTE: 3592 { 3593 GLuint i; 3594 const GLubyte *src = (const GLubyte *) source; 3595 for (i = 0; i < n; i++) { 3596 dest[i] = UBYTE_TO_FLOAT(src[i]); 3597 } 3598 } 3599 break; 3600 case GL_SHORT: 3601 { 3602 GLuint i; 3603 const GLshort *src = (const GLshort *) source; 3604 for (i = 0; i < n; i++) { 3605 dest[i] = SHORT_TO_FLOAT(src[i]); 3606 } 3607 } 3608 break; 3609 case GL_UNSIGNED_SHORT: 3610 { 3611 GLuint i; 3612 const GLushort *src = (const GLushort *) source; 3613 for (i = 0; i < n; i++) { 3614 dest[i] = USHORT_TO_FLOAT(src[i]); 3615 } 3616 } 3617 break; 3618 case GL_INT: 3619 { 3620 GLuint i; 3621 const GLint *src = (const GLint *) source; 3622 for (i = 0; i < n; i++) { 3623 dest[i] = INT_TO_FLOAT(src[i]); 3624 } 3625 } 3626 break; 3627 case GL_UNSIGNED_INT: 3628 { 3629 GLuint i; 3630 const GLuint *src = (const GLuint *) source; 3631 for (i = 0; i < n; i++) { 3632 dest[i] = UINT_TO_FLOAT(src[i]); 3633 } 3634 } 3635 break; 3636 case GL_FLOAT: 3637 MEMCPY(dest, source, n * sizeof(GLfloat)); 3638 break; 3639 default: 3640 _mesa_problem(NULL, "bad type in _mesa_unpack_depth_span()"); 3641 return; 3642 } 3643 3644 3645 /* apply depth scale and bias and clamp to [0,1] */ 3646 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) { 3647 GLuint i; 3648 for (i = 0; i < n; i++) { 3649 GLfloat d = dest[i] * ctx->Pixel.DepthScale + ctx->Pixel.DepthBias; 3650 dest[i] = CLAMP(d, 0.0F, 1.0F); 3651 } 3652 } 3653} 3654 3655 3656 3657/* 3658 * Pack an array of depth values. The values are floats in [0,1]. 3659 */ 3660void 3661_mesa_pack_depth_span( const GLcontext *ctx, GLuint n, GLvoid *dest, 3662 GLenum dstType, const GLfloat *depthSpan, 3663 const struct gl_pixelstore_attrib *dstPacking ) 3664{ 3665 GLfloat depthCopy[MAX_WIDTH]; 3666 const GLboolean bias_or_scale = ctx->Pixel.DepthBias != 0.0 || 3667 ctx->Pixel.DepthScale != 1.0; 3668 3669 ASSERT(n <= MAX_WIDTH); 3670 3671 if (bias_or_scale) { 3672 GLuint i; 3673 for (i = 0; i < n; i++) { 3674 GLfloat d; 3675 d = depthSpan[i] * ctx->Pixel.DepthScale + ctx->Pixel.DepthBias; 3676 depthCopy[i] = CLAMP(d, 0.0F, 1.0F); 3677 } 3678 depthSpan = depthCopy; 3679 } 3680 3681 switch (dstType) { 3682 case GL_UNSIGNED_BYTE: 3683 { 3684 GLubyte *dst = (GLubyte *) dest; 3685 GLuint i; 3686 for (i = 0; i < n; i++) { 3687 dst[i] = FLOAT_TO_UBYTE( depthSpan[i] ); 3688 } 3689 } 3690 break; 3691 case GL_BYTE: 3692 { 3693 GLbyte *dst = (GLbyte *) dest; 3694 GLuint i; 3695 for (i = 0; i < n; i++) { 3696 dst[i] = FLOAT_TO_BYTE( depthSpan[i] ); 3697 } 3698 } 3699 break; 3700 case GL_UNSIGNED_SHORT: 3701 { 3702 GLushort *dst = (GLushort *) dest; 3703 GLuint i; 3704 for (i = 0; i < n; i++) { 3705 dst[i] = FLOAT_TO_USHORT( depthSpan[i] ); 3706 } 3707 if (dstPacking->SwapBytes) { 3708 _mesa_swap2( (GLushort *) dst, n ); 3709 } 3710 } 3711 break; 3712 case GL_SHORT: 3713 { 3714 GLshort *dst = (GLshort *) dest; 3715 GLuint i; 3716 for (i = 0; i < n; i++) { 3717 dst[i] = FLOAT_TO_SHORT( depthSpan[i] ); 3718 } 3719 if (dstPacking->SwapBytes) { 3720 _mesa_swap2( (GLushort *) dst, n ); 3721 } 3722 } 3723 break; 3724 case GL_UNSIGNED_INT: 3725 { 3726 GLuint *dst = (GLuint *) dest; 3727 GLuint i; 3728 for (i = 0; i < n; i++) { 3729 dst[i] = FLOAT_TO_UINT( depthSpan[i] ); 3730 } 3731 if (dstPacking->SwapBytes) { 3732 _mesa_swap4( (GLuint *) dst, n ); 3733 } 3734 } 3735 break; 3736 case GL_INT: 3737 { 3738 GLint *dst = (GLint *) dest; 3739 GLuint i; 3740 for (i = 0; i < n; i++) { 3741 dst[i] = FLOAT_TO_INT( depthSpan[i] ); 3742 } 3743 if (dstPacking->SwapBytes) { 3744 _mesa_swap4( (GLuint *) dst, n ); 3745 } 3746 } 3747 break; 3748 case GL_FLOAT: 3749 { 3750 GLfloat *dst = (GLfloat *) dest; 3751 GLuint i; 3752 for (i = 0; i < n; i++) { 3753 dst[i] = depthSpan[i]; 3754 } 3755 if (dstPacking->SwapBytes) { 3756 _mesa_swap4( (GLuint *) dst, n ); 3757 } 3758 } 3759 break; 3760 default: 3761 _mesa_problem(ctx, "bad type in _mesa_pack_depth_span"); 3762 } 3763} 3764 3765 3766 3767 3768/* 3769 * Unpack image data. Apply byteswapping, byte flipping (bitmap). 3770 * Return all image data in a contiguous block. 3771 */ 3772void * 3773_mesa_unpack_image( GLsizei width, GLsizei height, GLsizei depth, 3774 GLenum format, GLenum type, const GLvoid *pixels, 3775 const struct gl_pixelstore_attrib *unpack ) 3776{ 3777 GLint bytesPerRow, compsPerRow; 3778 GLboolean flipBytes, swap2, swap4; 3779 3780 if (!pixels) 3781 return NULL; /* not necessarily an error */ 3782 3783 if (width <= 0 || height <= 0 || depth <= 0) 3784 return NULL; /* generate error later */ 3785 3786 if (format == GL_BITMAP) { 3787 bytesPerRow = (width + 7) >> 3; 3788 flipBytes = !unpack->LsbFirst; 3789 swap2 = swap4 = GL_FALSE; 3790 compsPerRow = 0; 3791 } 3792 else { 3793 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type); 3794 const GLint components = _mesa_components_in_format(format); 3795 GLint bytesPerComp; 3796 if (bytesPerPixel <= 0 || components <= 0) 3797 return NULL; /* bad format or type. generate error later */ 3798 bytesPerRow = bytesPerPixel * width; 3799 bytesPerComp = bytesPerPixel / components; 3800 flipBytes = GL_FALSE; 3801 swap2 = (bytesPerComp == 2) && unpack->SwapBytes; 3802 swap4 = (bytesPerComp == 4) && unpack->SwapBytes; 3803 compsPerRow = components * width; 3804 assert(compsPerRow >= width); 3805 } 3806 3807 { 3808 GLubyte *destBuffer = (GLubyte *) MALLOC(bytesPerRow * height * depth); 3809 GLubyte *dst; 3810 GLint img, row; 3811 if (!destBuffer) 3812 return NULL; /* generate GL_OUT_OF_MEMORY later */ 3813 3814 dst = destBuffer; 3815 for (img = 0; img < depth; img++) { 3816 for (row = 0; row < height; row++) { 3817 const GLvoid *src = _mesa_image_address(unpack, pixels, 3818 width, height, format, type, img, row, 0); 3819 MEMCPY(dst, src, bytesPerRow); 3820 /* byte flipping/swapping */ 3821 if (flipBytes) { 3822 flip_bytes((GLubyte *) dst, bytesPerRow); 3823 } 3824 else if (swap2) { 3825 _mesa_swap2((GLushort*) dst, compsPerRow); 3826 } 3827 else if (swap4) { 3828 _mesa_swap4((GLuint*) dst, compsPerRow); 3829 } 3830 dst += bytesPerRow; 3831 } 3832 } 3833 return destBuffer; 3834 } 3835} 3836