image.c revision 9499e017b7e05411a32b3e4fa94885eaec0d7277
1/* $Id: image.c,v 1.46 2000/10/30 16:32:43 brianp Exp $ */ 2 3/* 4 * Mesa 3-D graphics library 5 * Version: 3.5 6 * 7 * Copyright (C) 1999-2000 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 "imaging.h" 36#include "macros.h" 37#include "mem.h" 38#include "mmath.h" 39#include "pixel.h" 40#include "types.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 case GL_BGR: 344 switch (type) { 345 case GL_BYTE: 346 case GL_UNSIGNED_BYTE: 347 case GL_SHORT: 348 case GL_UNSIGNED_SHORT: 349 case GL_INT: 350 case GL_UNSIGNED_INT: 351 case GL_FLOAT: 352 return GL_TRUE; 353 default: 354 return GL_FALSE; 355 } 356 case GL_RGB: 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 * Unpack a 32x32 pixel polygon stipple from user memory using the 549 * current pixel unpack settings. 550 */ 551void 552_mesa_unpack_polygon_stipple( const GLubyte *pattern, GLuint dest[32], 553 const struct gl_pixelstore_attrib *unpacking ) 554{ 555 GLubyte *ptrn = (GLubyte *) _mesa_unpack_bitmap( 32, 32, pattern, unpacking ); 556 if (ptrn) { 557 /* Convert pattern from GLubytes to GLuints and handle big/little 558 * endian differences 559 */ 560 GLubyte *p = ptrn; 561 GLint i; 562 for (i = 0; i < 32; i++) { 563 dest[i] = (p[0] << 24) 564 | (p[1] << 16) 565 | (p[2] << 8) 566 | (p[3] ); 567 p += 4; 568 } 569 FREE(ptrn); 570 } 571} 572 573 574 575/* 576 * Pack polygon stipple into user memory given current pixel packing 577 * settings. 578 */ 579void 580_mesa_pack_polygon_stipple( const GLuint pattern[32], GLubyte *dest, 581 const struct gl_pixelstore_attrib *packing ) 582{ 583 /* Convert pattern from GLuints to GLubytes to handle big/little 584 * endian differences. 585 */ 586 GLubyte ptrn[32*4]; 587 GLint i; 588 for (i = 0; i < 32; i++) { 589 ptrn[i * 4 + 0] = (GLubyte) ((pattern[i] >> 24) & 0xff); 590 ptrn[i * 4 + 1] = (GLubyte) ((pattern[i] >> 16) & 0xff); 591 ptrn[i * 4 + 2] = (GLubyte) ((pattern[i] >> 8 ) & 0xff); 592 ptrn[i * 4 + 3] = (GLubyte) ((pattern[i] ) & 0xff); 593 } 594 595 _mesa_pack_bitmap(32, 32, ptrn, dest, packing); 596} 597 598 599/* 600 * Unpack bitmap data. Resulting data will be in most-significant-bit-first 601 * order with row alignment = 1 byte. 602 */ 603GLvoid * 604_mesa_unpack_bitmap( GLint width, GLint height, const GLubyte *pixels, 605 const struct gl_pixelstore_attrib *packing ) 606{ 607 GLint bytes, row, width_in_bytes; 608 GLubyte *buffer, *dst; 609 610 if (!pixels) 611 return NULL; 612 613 /* Alloc dest storage */ 614 bytes = ((width + 7) / 8 * height); 615 buffer = (GLubyte *) MALLOC( bytes ); 616 if (!buffer) 617 return NULL; 618 619 620 width_in_bytes = CEILING( width, 8 ); 621 dst = buffer; 622 for (row = 0; row < height; row++) { 623 GLubyte *src = _mesa_image_address( packing, pixels, width, height, 624 GL_COLOR_INDEX, GL_BITMAP, 625 0, row, 0 ); 626 if (!src) { 627 FREE(buffer); 628 return NULL; 629 } 630 631 if (packing->SkipPixels == 0) { 632 MEMCPY( dst, src, width_in_bytes ); 633 if (packing->LsbFirst) { 634 flip_bytes( dst, width_in_bytes ); 635 } 636 } 637 else { 638 /* handling SkipPixels is a bit tricky (no pun intended!) */ 639 GLint i; 640 if (packing->LsbFirst) { 641 GLubyte srcMask = 1 << (packing->SkipPixels & 0x7); 642 GLubyte dstMask = 128; 643 GLubyte *s = src; 644 GLubyte *d = dst; 645 *d = 0; 646 for (i = 0; i < width; i++) { 647 if (*s & srcMask) { 648 *d |= dstMask; 649 } 650 if (srcMask == 128) { 651 srcMask = 1; 652 s++; 653 } 654 else { 655 srcMask = srcMask << 1; 656 } 657 if (dstMask == 1) { 658 dstMask = 128; 659 d++; 660 *d = 0; 661 } 662 else { 663 dstMask = dstMask >> 1; 664 } 665 } 666 } 667 else { 668 GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7); 669 GLubyte dstMask = 128; 670 GLubyte *s = src; 671 GLubyte *d = dst; 672 *d = 0; 673 for (i = 0; i < width; i++) { 674 if (*s & srcMask) { 675 *d |= dstMask; 676 } 677 if (srcMask == 1) { 678 srcMask = 128; 679 s++; 680 } 681 else { 682 srcMask = srcMask >> 1; 683 } 684 if (dstMask == 1) { 685 dstMask = 128; 686 d++; 687 *d = 0; 688 } 689 else { 690 dstMask = dstMask >> 1; 691 } 692 } 693 } 694 } 695 dst += width_in_bytes; 696 } 697 698 return buffer; 699} 700 701 702/* 703 * Pack bitmap data. 704 */ 705void 706_mesa_pack_bitmap( GLint width, GLint height, const GLubyte *source, 707 GLubyte *dest, const struct gl_pixelstore_attrib *packing ) 708{ 709 GLint row, width_in_bytes; 710 const GLubyte *src; 711 712 if (!source) 713 return; 714 715 width_in_bytes = CEILING( width, 8 ); 716 src = source; 717 for (row = 0; row < height; row++) { 718 GLubyte *dst = _mesa_image_address( packing, dest, width, height, 719 GL_COLOR_INDEX, GL_BITMAP, 720 0, row, 0 ); 721 if (!dst) 722 return; 723 724 if (packing->SkipPixels == 0) { 725 MEMCPY( dst, src, width_in_bytes ); 726 if (packing->LsbFirst) { 727 flip_bytes( dst, width_in_bytes ); 728 } 729 } 730 else { 731 /* handling SkipPixels is a bit tricky (no pun intended!) */ 732 GLint i; 733 if (packing->LsbFirst) { 734 GLubyte srcMask = 1 << (packing->SkipPixels & 0x7); 735 GLubyte dstMask = 128; 736 const GLubyte *s = src; 737 GLubyte *d = dst; 738 *d = 0; 739 for (i = 0; i < width; i++) { 740 if (*s & srcMask) { 741 *d |= dstMask; 742 } 743 if (srcMask == 128) { 744 srcMask = 1; 745 s++; 746 } 747 else { 748 srcMask = srcMask << 1; 749 } 750 if (dstMask == 1) { 751 dstMask = 128; 752 d++; 753 *d = 0; 754 } 755 else { 756 dstMask = dstMask >> 1; 757 } 758 } 759 } 760 else { 761 GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7); 762 GLubyte dstMask = 128; 763 const GLubyte *s = src; 764 GLubyte *d = dst; 765 *d = 0; 766 for (i = 0; i < width; i++) { 767 if (*s & srcMask) { 768 *d |= dstMask; 769 } 770 if (srcMask == 1) { 771 srcMask = 128; 772 s++; 773 } 774 else { 775 srcMask = srcMask >> 1; 776 } 777 if (dstMask == 1) { 778 dstMask = 128; 779 d++; 780 *d = 0; 781 } 782 else { 783 dstMask = dstMask >> 1; 784 } 785 } 786 } 787 } 788 src += width_in_bytes; 789 } 790} 791 792 793 794void 795_mesa_pack_float_rgba_span( GLcontext *ctx, 796 GLuint n, CONST GLfloat rgbaIn[][4], 797 GLenum dstFormat, GLenum dstType, 798 GLvoid *dstAddr, 799 const struct gl_pixelstore_attrib *dstPacking, 800 GLuint transferOps ) 801{ 802 const GLint comps = _mesa_components_in_format(dstFormat); 803 GLfloat luminance[MAX_WIDTH]; 804 GLfloat (*rgba)[4]; 805 GLuint i; 806 807 if (transferOps) { 808 /* make copy of incoming data */ 809 GLfloat rgbaCopy[MAX_WIDTH][4]; 810 for (i = 0; i < n; i++) { 811 rgbaCopy[i][0] = rgbaIn[i][0]; 812 rgbaCopy[i][1] = rgbaIn[i][1]; 813 rgbaCopy[i][2] = rgbaIn[i][2]; 814 rgbaCopy[i][3] = rgbaIn[i][3]; 815 } 816 817 rgba = (GLfloat (*)[4]) rgbaCopy; 818 819 /* scale & bias */ 820 if (transferOps & IMAGE_SCALE_BIAS_BIT) { 821 _mesa_scale_and_bias_rgba( ctx, n, rgba ); 822 } 823 /* color map lookup */ 824 if (transferOps & IMAGE_MAP_COLOR_BIT) { 825 _mesa_map_rgba( ctx, n, rgba ); 826 } 827 /* GL_COLOR_TABLE lookup */ 828 if (transferOps & IMAGE_COLOR_TABLE_BIT) { 829 _mesa_lookup_rgba(&ctx->ColorTable, n, rgba); 830 } 831 /* convolution */ 832 if (transferOps & IMAGE_CONVOLUTION_BIT) { 833 /* this has to be done in the calling code */ 834 } 835 /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */ 836 if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) { 837 _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, n, rgba); 838 } 839 /* color matrix transform */ 840 if (transferOps & IMAGE_COLOR_MATRIX_BIT) { 841 _mesa_transform_rgba(ctx, n, rgba); 842 } 843 /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */ 844 if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) { 845 _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, n, rgba); 846 } 847 /* update histogram count */ 848 if (transferOps & IMAGE_HISTOGRAM_BIT) { 849 _mesa_update_histogram(ctx, n, (CONST GLfloat (*)[4]) rgba); 850 } 851 /* min/max here */ 852 if (transferOps & IMAGE_MIN_MAX_BIT) { 853 _mesa_update_minmax(ctx, n, (CONST GLfloat (*)[4]) rgba); 854 if (ctx->MinMax.Sink) 855 return; 856 } 857 } 858 else { 859 /* use incoming data, not a copy */ 860 rgba = (GLfloat (*)[4]) rgbaIn; 861 } 862 863 /* XXX clamp rgba to [0,1]? */ 864 865 866 if (dstFormat == GL_LUMINANCE || dstFormat == GL_LUMINANCE_ALPHA) { 867 for (i = 0; i < n; i++) { 868 GLfloat sum = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP]; 869 luminance[i] = CLAMP(sum, 0.0F, 1.0F); 870 } 871 } 872 873 /* 874 * Pack/store the pixels. Ugh! Lots of cases!!! 875 */ 876 switch (dstType) { 877 case GL_UNSIGNED_BYTE: 878 { 879 GLubyte *dst = (GLubyte *) dstAddr; 880 switch (dstFormat) { 881 case GL_RED: 882 for (i=0;i<n;i++) 883 dst[i] = FLOAT_TO_UBYTE(rgba[i][RCOMP]); 884 break; 885 case GL_GREEN: 886 for (i=0;i<n;i++) 887 dst[i] = FLOAT_TO_UBYTE(rgba[i][GCOMP]); 888 break; 889 case GL_BLUE: 890 for (i=0;i<n;i++) 891 dst[i] = FLOAT_TO_UBYTE(rgba[i][BCOMP]); 892 break; 893 case GL_ALPHA: 894 for (i=0;i<n;i++) 895 dst[i] = FLOAT_TO_UBYTE(rgba[i][ACOMP]); 896 break; 897 case GL_LUMINANCE: 898 for (i=0;i<n;i++) 899 dst[i] = FLOAT_TO_UBYTE(luminance[i]); 900 break; 901 case GL_LUMINANCE_ALPHA: 902 for (i=0;i<n;i++) { 903 dst[i*2+0] = FLOAT_TO_UBYTE(luminance[i]); 904 dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][ACOMP]); 905 } 906 break; 907 case GL_RGB: 908 for (i=0;i<n;i++) { 909 dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]); 910 dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]); 911 dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]); 912 } 913 break; 914 case GL_RGBA: 915 for (i=0;i<n;i++) { 916 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]); 917 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]); 918 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]); 919 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]); 920 } 921 break; 922 case GL_BGR: 923 for (i=0;i<n;i++) { 924 dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]); 925 dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]); 926 dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]); 927 } 928 break; 929 case GL_BGRA: 930 for (i=0;i<n;i++) { 931 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]); 932 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]); 933 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]); 934 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]); 935 } 936 break; 937 case GL_ABGR_EXT: 938 for (i=0;i<n;i++) { 939 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][ACOMP]); 940 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][BCOMP]); 941 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][GCOMP]); 942 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][RCOMP]); 943 } 944 break; 945 default: 946 gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); 947 } 948 } 949 break; 950 case GL_BYTE: 951 { 952 GLbyte *dst = (GLbyte *) dstAddr; 953 switch (dstFormat) { 954 case GL_RED: 955 for (i=0;i<n;i++) 956 dst[i] = FLOAT_TO_BYTE(rgba[i][RCOMP]); 957 break; 958 case GL_GREEN: 959 for (i=0;i<n;i++) 960 dst[i] = FLOAT_TO_BYTE(rgba[i][GCOMP]); 961 break; 962 case GL_BLUE: 963 for (i=0;i<n;i++) 964 dst[i] = FLOAT_TO_BYTE(rgba[i][BCOMP]); 965 break; 966 case GL_ALPHA: 967 for (i=0;i<n;i++) 968 dst[i] = FLOAT_TO_BYTE(rgba[i][ACOMP]); 969 break; 970 case GL_LUMINANCE: 971 for (i=0;i<n;i++) 972 dst[i] = FLOAT_TO_BYTE(luminance[i]); 973 break; 974 case GL_LUMINANCE_ALPHA: 975 for (i=0;i<n;i++) { 976 dst[i*2+0] = FLOAT_TO_BYTE(luminance[i]); 977 dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][ACOMP]); 978 } 979 break; 980 case GL_RGB: 981 for (i=0;i<n;i++) { 982 dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]); 983 dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]); 984 dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]); 985 } 986 break; 987 case GL_RGBA: 988 for (i=0;i<n;i++) { 989 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]); 990 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]); 991 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]); 992 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]); 993 } 994 break; 995 case GL_BGR: 996 for (i=0;i<n;i++) { 997 dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]); 998 dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]); 999 dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]); 1000 } 1001 break; 1002 case GL_BGRA: 1003 for (i=0;i<n;i++) { 1004 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]); 1005 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]); 1006 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]); 1007 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]); 1008 } 1009 case GL_ABGR_EXT: 1010 for (i=0;i<n;i++) { 1011 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][ACOMP]); 1012 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][BCOMP]); 1013 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][GCOMP]); 1014 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][RCOMP]); 1015 } 1016 break; 1017 default: 1018 gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); 1019 } 1020 } 1021 break; 1022 case GL_UNSIGNED_SHORT: 1023 { 1024 GLushort *dst = (GLushort *) dstAddr; 1025 switch (dstFormat) { 1026 case GL_RED: 1027 for (i=0;i<n;i++) 1028 dst[i] = FLOAT_TO_USHORT(rgba[i][RCOMP]); 1029 break; 1030 case GL_GREEN: 1031 for (i=0;i<n;i++) 1032 dst[i] = FLOAT_TO_USHORT(rgba[i][GCOMP]); 1033 break; 1034 case GL_BLUE: 1035 for (i=0;i<n;i++) 1036 dst[i] = FLOAT_TO_USHORT(rgba[i][BCOMP]); 1037 break; 1038 case GL_ALPHA: 1039 for (i=0;i<n;i++) 1040 dst[i] = FLOAT_TO_USHORT(rgba[i][ACOMP]); 1041 break; 1042 case GL_LUMINANCE: 1043 for (i=0;i<n;i++) 1044 dst[i] = FLOAT_TO_USHORT(luminance[i]); 1045 break; 1046 case GL_LUMINANCE_ALPHA: 1047 for (i=0;i<n;i++) { 1048 dst[i*2+0] = FLOAT_TO_USHORT(luminance[i]); 1049 dst[i*2+1] = FLOAT_TO_USHORT(rgba[i][ACOMP]); 1050 } 1051 break; 1052 case GL_RGB: 1053 for (i=0;i<n;i++) { 1054 dst[i*3+0] = FLOAT_TO_USHORT(rgba[i][RCOMP]); 1055 dst[i*3+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]); 1056 dst[i*3+2] = FLOAT_TO_USHORT(rgba[i][BCOMP]); 1057 } 1058 break; 1059 case GL_RGBA: 1060 for (i=0;i<n;i++) { 1061 dst[i*4+0] = FLOAT_TO_USHORT(rgba[i][RCOMP]); 1062 dst[i*4+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]); 1063 dst[i*4+2] = FLOAT_TO_USHORT(rgba[i][BCOMP]); 1064 dst[i*4+3] = FLOAT_TO_USHORT(rgba[i][ACOMP]); 1065 } 1066 break; 1067 case GL_BGR: 1068 for (i=0;i<n;i++) { 1069 dst[i*3+0] = FLOAT_TO_USHORT(rgba[i][BCOMP]); 1070 dst[i*3+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]); 1071 dst[i*3+2] = FLOAT_TO_USHORT(rgba[i][RCOMP]); 1072 } 1073 break; 1074 case GL_BGRA: 1075 for (i=0;i<n;i++) { 1076 dst[i*4+0] = FLOAT_TO_USHORT(rgba[i][BCOMP]); 1077 dst[i*4+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]); 1078 dst[i*4+2] = FLOAT_TO_USHORT(rgba[i][RCOMP]); 1079 dst[i*4+3] = FLOAT_TO_USHORT(rgba[i][ACOMP]); 1080 } 1081 break; 1082 case GL_ABGR_EXT: 1083 for (i=0;i<n;i++) { 1084 dst[i*4+0] = FLOAT_TO_USHORT(rgba[i][ACOMP]); 1085 dst[i*4+1] = FLOAT_TO_USHORT(rgba[i][BCOMP]); 1086 dst[i*4+2] = FLOAT_TO_USHORT(rgba[i][GCOMP]); 1087 dst[i*4+3] = FLOAT_TO_USHORT(rgba[i][RCOMP]); 1088 } 1089 break; 1090 default: 1091 gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); 1092 } 1093 if (dstPacking->SwapBytes) { 1094 _mesa_swap2( (GLushort *) dst, n * comps); 1095 } 1096 } 1097 break; 1098 case GL_SHORT: 1099 { 1100 GLshort *dst = (GLshort *) dstAddr; 1101 switch (dstFormat) { 1102 case GL_RED: 1103 for (i=0;i<n;i++) 1104 dst[i] = FLOAT_TO_SHORT(rgba[i][RCOMP]); 1105 break; 1106 case GL_GREEN: 1107 for (i=0;i<n;i++) 1108 dst[i] = FLOAT_TO_SHORT(rgba[i][GCOMP]); 1109 break; 1110 case GL_BLUE: 1111 for (i=0;i<n;i++) 1112 dst[i] = FLOAT_TO_SHORT(rgba[i][BCOMP]); 1113 break; 1114 case GL_ALPHA: 1115 for (i=0;i<n;i++) 1116 dst[i] = FLOAT_TO_SHORT(rgba[i][ACOMP]); 1117 break; 1118 case GL_LUMINANCE: 1119 for (i=0;i<n;i++) 1120 dst[i] = FLOAT_TO_SHORT(luminance[i]); 1121 break; 1122 case GL_LUMINANCE_ALPHA: 1123 for (i=0;i<n;i++) { 1124 dst[i*2+0] = FLOAT_TO_SHORT(luminance[i]); 1125 dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][ACOMP]); 1126 } 1127 break; 1128 case GL_RGB: 1129 for (i=0;i<n;i++) { 1130 dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]); 1131 dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]); 1132 dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]); 1133 } 1134 break; 1135 case GL_RGBA: 1136 for (i=0;i<n;i++) { 1137 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]); 1138 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]); 1139 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]); 1140 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]); 1141 } 1142 break; 1143 case GL_BGR: 1144 for (i=0;i<n;i++) { 1145 dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]); 1146 dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]); 1147 dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]); 1148 } 1149 break; 1150 case GL_BGRA: 1151 for (i=0;i<n;i++) { 1152 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]); 1153 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]); 1154 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]); 1155 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]); 1156 } 1157 case GL_ABGR_EXT: 1158 for (i=0;i<n;i++) { 1159 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][ACOMP]); 1160 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][BCOMP]); 1161 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][GCOMP]); 1162 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][RCOMP]); 1163 } 1164 break; 1165 default: 1166 gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); 1167 } 1168 if (dstPacking->SwapBytes) { 1169 _mesa_swap2( (GLushort *) dst, n * comps ); 1170 } 1171 } 1172 break; 1173 case GL_UNSIGNED_INT: 1174 { 1175 GLuint *dst = (GLuint *) dstAddr; 1176 switch (dstFormat) { 1177 case GL_RED: 1178 for (i=0;i<n;i++) 1179 dst[i] = FLOAT_TO_UINT(rgba[i][RCOMP]); 1180 break; 1181 case GL_GREEN: 1182 for (i=0;i<n;i++) 1183 dst[i] = FLOAT_TO_UINT(rgba[i][GCOMP]); 1184 break; 1185 case GL_BLUE: 1186 for (i=0;i<n;i++) 1187 dst[i] = FLOAT_TO_UINT(rgba[i][BCOMP]); 1188 break; 1189 case GL_ALPHA: 1190 for (i=0;i<n;i++) 1191 dst[i] = FLOAT_TO_UINT(rgba[i][ACOMP]); 1192 break; 1193 case GL_LUMINANCE: 1194 for (i=0;i<n;i++) 1195 dst[i] = FLOAT_TO_UINT(luminance[i]); 1196 break; 1197 case GL_LUMINANCE_ALPHA: 1198 for (i=0;i<n;i++) { 1199 dst[i*2+0] = FLOAT_TO_UINT(luminance[i]); 1200 dst[i*2+1] = FLOAT_TO_UINT(rgba[i][ACOMP]); 1201 } 1202 break; 1203 case GL_RGB: 1204 for (i=0;i<n;i++) { 1205 dst[i*3+0] = FLOAT_TO_UINT(rgba[i][RCOMP]); 1206 dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]); 1207 dst[i*3+2] = FLOAT_TO_UINT(rgba[i][BCOMP]); 1208 } 1209 break; 1210 case GL_RGBA: 1211 for (i=0;i<n;i++) { 1212 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][RCOMP]); 1213 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]); 1214 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][BCOMP]); 1215 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]); 1216 } 1217 break; 1218 case GL_BGR: 1219 for (i=0;i<n;i++) { 1220 dst[i*3+0] = FLOAT_TO_UINT(rgba[i][BCOMP]); 1221 dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]); 1222 dst[i*3+2] = FLOAT_TO_UINT(rgba[i][RCOMP]); 1223 } 1224 break; 1225 case GL_BGRA: 1226 for (i=0;i<n;i++) { 1227 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][BCOMP]); 1228 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]); 1229 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][RCOMP]); 1230 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]); 1231 } 1232 break; 1233 case GL_ABGR_EXT: 1234 for (i=0;i<n;i++) { 1235 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][ACOMP]); 1236 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][BCOMP]); 1237 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][GCOMP]); 1238 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][RCOMP]); 1239 } 1240 break; 1241 default: 1242 gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); 1243 } 1244 if (dstPacking->SwapBytes) { 1245 _mesa_swap4( (GLuint *) dst, n * comps ); 1246 } 1247 } 1248 break; 1249 case GL_INT: 1250 { 1251 GLint *dst = (GLint *) dstAddr; 1252 switch (dstFormat) { 1253 case GL_RED: 1254 for (i=0;i<n;i++) 1255 dst[i] = FLOAT_TO_INT(rgba[i][RCOMP]); 1256 break; 1257 case GL_GREEN: 1258 for (i=0;i<n;i++) 1259 dst[i] = FLOAT_TO_INT(rgba[i][GCOMP]); 1260 break; 1261 case GL_BLUE: 1262 for (i=0;i<n;i++) 1263 dst[i] = FLOAT_TO_INT(rgba[i][BCOMP]); 1264 break; 1265 case GL_ALPHA: 1266 for (i=0;i<n;i++) 1267 dst[i] = FLOAT_TO_INT(rgba[i][ACOMP]); 1268 break; 1269 case GL_LUMINANCE: 1270 for (i=0;i<n;i++) 1271 dst[i] = FLOAT_TO_INT(luminance[i]); 1272 break; 1273 case GL_LUMINANCE_ALPHA: 1274 for (i=0;i<n;i++) { 1275 dst[i*2+0] = FLOAT_TO_INT(luminance[i]); 1276 dst[i*2+1] = FLOAT_TO_INT(rgba[i][ACOMP]); 1277 } 1278 break; 1279 case GL_RGB: 1280 for (i=0;i<n;i++) { 1281 dst[i*3+0] = FLOAT_TO_INT(rgba[i][RCOMP]); 1282 dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]); 1283 dst[i*3+2] = FLOAT_TO_INT(rgba[i][BCOMP]); 1284 } 1285 break; 1286 case GL_RGBA: 1287 for (i=0;i<n;i++) { 1288 dst[i*4+0] = FLOAT_TO_INT(rgba[i][RCOMP]); 1289 dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]); 1290 dst[i*4+2] = FLOAT_TO_INT(rgba[i][BCOMP]); 1291 dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]); 1292 } 1293 break; 1294 case GL_BGR: 1295 for (i=0;i<n;i++) { 1296 dst[i*3+0] = FLOAT_TO_INT(rgba[i][BCOMP]); 1297 dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]); 1298 dst[i*3+2] = FLOAT_TO_INT(rgba[i][RCOMP]); 1299 } 1300 break; 1301 case GL_BGRA: 1302 for (i=0;i<n;i++) { 1303 dst[i*4+0] = FLOAT_TO_INT(rgba[i][BCOMP]); 1304 dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]); 1305 dst[i*4+2] = FLOAT_TO_INT(rgba[i][RCOMP]); 1306 dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]); 1307 } 1308 break; 1309 case GL_ABGR_EXT: 1310 for (i=0;i<n;i++) { 1311 dst[i*4+0] = FLOAT_TO_INT(rgba[i][ACOMP]); 1312 dst[i*4+1] = FLOAT_TO_INT(rgba[i][BCOMP]); 1313 dst[i*4+2] = FLOAT_TO_INT(rgba[i][GCOMP]); 1314 dst[i*4+3] = FLOAT_TO_INT(rgba[i][RCOMP]); 1315 } 1316 break; 1317 default: 1318 gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); 1319 } 1320 if (dstPacking->SwapBytes) { 1321 _mesa_swap4( (GLuint *) dst, n * comps ); 1322 } 1323 } 1324 break; 1325 case GL_FLOAT: 1326 { 1327 GLfloat *dst = (GLfloat *) dstAddr; 1328 switch (dstFormat) { 1329 case GL_RED: 1330 for (i=0;i<n;i++) 1331 dst[i] = rgba[i][RCOMP]; 1332 break; 1333 case GL_GREEN: 1334 for (i=0;i<n;i++) 1335 dst[i] = rgba[i][GCOMP]; 1336 break; 1337 case GL_BLUE: 1338 for (i=0;i<n;i++) 1339 dst[i] = rgba[i][BCOMP]; 1340 break; 1341 case GL_ALPHA: 1342 for (i=0;i<n;i++) 1343 dst[i] = rgba[i][ACOMP]; 1344 break; 1345 case GL_LUMINANCE: 1346 for (i=0;i<n;i++) 1347 dst[i] = luminance[i]; 1348 break; 1349 case GL_LUMINANCE_ALPHA: 1350 for (i=0;i<n;i++) { 1351 dst[i*2+0] = luminance[i]; 1352 dst[i*2+1] = rgba[i][ACOMP]; 1353 } 1354 break; 1355 case GL_RGB: 1356 for (i=0;i<n;i++) { 1357 dst[i*3+0] = rgba[i][RCOMP]; 1358 dst[i*3+1] = rgba[i][GCOMP]; 1359 dst[i*3+2] = rgba[i][BCOMP]; 1360 } 1361 break; 1362 case GL_RGBA: 1363 for (i=0;i<n;i++) { 1364 dst[i*4+0] = rgba[i][RCOMP]; 1365 dst[i*4+1] = rgba[i][GCOMP]; 1366 dst[i*4+2] = rgba[i][BCOMP]; 1367 dst[i*4+3] = rgba[i][ACOMP]; 1368 } 1369 break; 1370 case GL_BGR: 1371 for (i=0;i<n;i++) { 1372 dst[i*3+0] = rgba[i][BCOMP]; 1373 dst[i*3+1] = rgba[i][GCOMP]; 1374 dst[i*3+2] = rgba[i][RCOMP]; 1375 } 1376 break; 1377 case GL_BGRA: 1378 for (i=0;i<n;i++) { 1379 dst[i*4+0] = rgba[i][BCOMP]; 1380 dst[i*4+1] = rgba[i][GCOMP]; 1381 dst[i*4+2] = rgba[i][RCOMP]; 1382 dst[i*4+3] = rgba[i][ACOMP]; 1383 } 1384 break; 1385 case GL_ABGR_EXT: 1386 for (i=0;i<n;i++) { 1387 dst[i*4+0] = rgba[i][ACOMP]; 1388 dst[i*4+1] = rgba[i][BCOMP]; 1389 dst[i*4+2] = rgba[i][GCOMP]; 1390 dst[i*4+3] = rgba[i][RCOMP]; 1391 } 1392 break; 1393 default: 1394 gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); 1395 } 1396 if (dstPacking->SwapBytes) { 1397 _mesa_swap4( (GLuint *) dst, n * comps ); 1398 } 1399 } 1400 break; 1401 case GL_UNSIGNED_BYTE_3_3_2: 1402 if (dstFormat == GL_RGB) { 1403 GLubyte *dst = (GLubyte *) dstAddr; 1404 for (i=0;i<n;i++) { 1405 dst[i] = (((GLint) (rgba[i][RCOMP] * 7.0F)) << 5) 1406 | (((GLint) (rgba[i][GCOMP] * 7.0F)) << 2) 1407 | (((GLint) (rgba[i][BCOMP] * 3.0F)) ); 1408 } 1409 } 1410 break; 1411 case GL_UNSIGNED_BYTE_2_3_3_REV: 1412 if (dstFormat == GL_RGB) { 1413 GLubyte *dst = (GLubyte *) dstAddr; 1414 for (i=0;i<n;i++) { 1415 dst[i] = (((GLint) (rgba[i][RCOMP] * 7.0F)) ) 1416 | (((GLint) (rgba[i][GCOMP] * 7.0F)) << 3) 1417 | (((GLint) (rgba[i][BCOMP] * 3.0F)) << 5); 1418 } 1419 } 1420 break; 1421 case GL_UNSIGNED_SHORT_5_6_5: 1422 if (dstFormat == GL_RGB) { 1423 GLushort *dst = (GLushort *) dstAddr; 1424 for (i=0;i<n;i++) { 1425 dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) << 11) 1426 | (((GLint) (rgba[i][GCOMP] * 63.0F)) << 5) 1427 | (((GLint) (rgba[i][BCOMP] * 31.0F)) ); 1428 } 1429 } 1430 break; 1431 case GL_UNSIGNED_SHORT_5_6_5_REV: 1432 if (dstFormat == GL_RGB) { 1433 GLushort *dst = (GLushort *) dstAddr; 1434 for (i=0;i<n;i++) { 1435 dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) ) 1436 | (((GLint) (rgba[i][GCOMP] * 63.0F)) << 5) 1437 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 11); 1438 } 1439 } 1440 break; 1441 case GL_UNSIGNED_SHORT_4_4_4_4: 1442 if (dstFormat == GL_RGBA) { 1443 GLushort *dst = (GLushort *) dstAddr; 1444 for (i=0;i<n;i++) { 1445 dst[i] = (((GLint) (rgba[i][RCOMP] * 15.0F)) << 12) 1446 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 8) 1447 | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 4) 1448 | (((GLint) (rgba[i][ACOMP] * 15.0F)) ); 1449 } 1450 } 1451 else if (dstFormat == GL_BGRA) { 1452 GLushort *dst = (GLushort *) dstAddr; 1453 for (i=0;i<n;i++) { 1454 dst[i] = (((GLint) (rgba[i][BCOMP] * 15.0F)) << 12) 1455 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 8) 1456 | (((GLint) (rgba[i][RCOMP] * 15.0F)) << 4) 1457 | (((GLint) (rgba[i][ACOMP] * 15.0F)) ); 1458 } 1459 } 1460 else if (dstFormat == GL_ABGR_EXT) { 1461 GLushort *dst = (GLushort *) dstAddr; 1462 for (i=0;i<n;i++) { 1463 dst[i] = (((GLint) (rgba[i][ACOMP] * 15.0F)) << 4) 1464 | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 8) 1465 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 12) 1466 | (((GLint) (rgba[i][RCOMP] * 15.0F)) ); 1467 } 1468 } 1469 break; 1470 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 1471 if (dstFormat == GL_RGBA) { 1472 GLushort *dst = (GLushort *) dstAddr; 1473 for (i=0;i<n;i++) { 1474 dst[i] = (((GLint) (rgba[i][RCOMP] * 15.0F)) ) 1475 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 4) 1476 | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 8) 1477 | (((GLint) (rgba[i][ACOMP] * 15.0F)) << 12); 1478 } 1479 } 1480 else if (dstFormat == GL_BGRA) { 1481 GLushort *dst = (GLushort *) dstAddr; 1482 for (i=0;i<n;i++) { 1483 dst[i] = (((GLint) (rgba[i][BCOMP] * 15.0F)) ) 1484 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 4) 1485 | (((GLint) (rgba[i][RCOMP] * 15.0F)) << 8) 1486 | (((GLint) (rgba[i][ACOMP] * 15.0F)) << 12); 1487 } 1488 } 1489 else if (dstFormat == GL_ABGR_EXT) { 1490 GLushort *dst = (GLushort *) dstAddr; 1491 for (i=0;i<n;i++) { 1492 dst[i] = (((GLint) (rgba[i][ACOMP] * 15.0F)) ) 1493 | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 4) 1494 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 8) 1495 | (((GLint) (rgba[i][RCOMP] * 15.0F)) << 12); 1496 } 1497 } 1498 break; 1499 case GL_UNSIGNED_SHORT_5_5_5_1: 1500 if (dstFormat == GL_RGBA) { 1501 GLushort *dst = (GLushort *) dstAddr; 1502 for (i=0;i<n;i++) { 1503 dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) << 11) 1504 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 6) 1505 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 1) 1506 | (((GLint) (rgba[i][ACOMP] * 1.0F)) ); 1507 } 1508 } 1509 else if (dstFormat == GL_BGRA) { 1510 GLushort *dst = (GLushort *) dstAddr; 1511 for (i=0;i<n;i++) { 1512 dst[i] = (((GLint) (rgba[i][BCOMP] * 31.0F)) << 11) 1513 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 6) 1514 | (((GLint) (rgba[i][RCOMP] * 31.0F)) << 1) 1515 | (((GLint) (rgba[i][ACOMP] * 1.0F)) ); 1516 } 1517 } 1518 else if (dstFormat == GL_ABGR_EXT) { 1519 GLushort *dst = (GLushort *) dstAddr; 1520 for (i=0;i<n;i++) { 1521 dst[i] = (((GLint) (rgba[i][ACOMP] * 31.0F)) << 11) 1522 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 6) 1523 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 1) 1524 | (((GLint) (rgba[i][RCOMP] * 1.0F)) ); 1525 } 1526 } 1527 break; 1528 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 1529 if (dstFormat == GL_RGBA) { 1530 GLushort *dst = (GLushort *) dstAddr; 1531 for (i=0;i<n;i++) { 1532 dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) ) 1533 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 5) 1534 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 10) 1535 | (((GLint) (rgba[i][ACOMP] * 1.0F)) << 15); 1536 } 1537 } 1538 else if (dstFormat == GL_BGRA) { 1539 GLushort *dst = (GLushort *) dstAddr; 1540 for (i=0;i<n;i++) { 1541 dst[i] = (((GLint) (rgba[i][BCOMP] * 31.0F)) ) 1542 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 5) 1543 | (((GLint) (rgba[i][RCOMP] * 31.0F)) << 10) 1544 | (((GLint) (rgba[i][ACOMP] * 1.0F)) << 15); 1545 } 1546 } 1547 else if (dstFormat == GL_ABGR_EXT) { 1548 GLushort *dst = (GLushort *) dstAddr; 1549 for (i=0;i<n;i++) { 1550 dst[i] = (((GLint) (rgba[i][ACOMP] * 31.0F)) ) 1551 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 5) 1552 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 10) 1553 | (((GLint) (rgba[i][RCOMP] * 1.0F)) << 15); 1554 } 1555 } 1556 break; 1557 case GL_UNSIGNED_INT_8_8_8_8: 1558 if (dstFormat == GL_RGBA) { 1559 GLuint *dst = (GLuint *) dstAddr; 1560 for (i=0;i<n;i++) { 1561 dst[i] = (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 24) 1562 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16) 1563 | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 8) 1564 | (((GLuint) (rgba[i][ACOMP] * 255.0F)) ); 1565 } 1566 } 1567 else if (dstFormat == GL_BGRA) { 1568 GLuint *dst = (GLuint *) dstAddr; 1569 for (i=0;i<n;i++) { 1570 dst[i] = (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 24) 1571 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16) 1572 | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 8) 1573 | (((GLuint) (rgba[i][ACOMP] * 255.0F)) ); 1574 } 1575 } 1576 else if (dstFormat == GL_ABGR_EXT) { 1577 GLuint *dst = (GLuint *) dstAddr; 1578 for (i=0;i<n;i++) { 1579 dst[i] = (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24) 1580 | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 16) 1581 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 8) 1582 | (((GLuint) (rgba[i][RCOMP] * 255.0F)) ); 1583 } 1584 } 1585 break; 1586 case GL_UNSIGNED_INT_8_8_8_8_REV: 1587 if (dstFormat == GL_RGBA) { 1588 GLuint *dst = (GLuint *) dstAddr; 1589 for (i=0;i<n;i++) { 1590 dst[i] = (((GLuint) (rgba[i][RCOMP] * 255.0F)) ) 1591 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 8) 1592 | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 16) 1593 | (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24); 1594 } 1595 } 1596 else if (dstFormat == GL_BGRA) { 1597 GLuint *dst = (GLuint *) dstAddr; 1598 for (i=0;i<n;i++) { 1599 dst[i] = (((GLuint) (rgba[i][BCOMP] * 255.0F)) ) 1600 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 8) 1601 | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 16) 1602 | (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24); 1603 } 1604 } 1605 else if (dstFormat == GL_ABGR_EXT) { 1606 GLuint *dst = (GLuint *) dstAddr; 1607 for (i=0;i<n;i++) { 1608 dst[i] = (((GLuint) (rgba[i][ACOMP] * 255.0F)) ) 1609 | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 8) 1610 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16) 1611 | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 24); 1612 } 1613 } 1614 break; 1615 case GL_UNSIGNED_INT_10_10_10_2: 1616 if (dstFormat == GL_RGBA) { 1617 GLuint *dst = (GLuint *) dstAddr; 1618 for (i=0;i<n;i++) { 1619 dst[i] = (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 22) 1620 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 12) 1621 | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 2) 1622 | (((GLuint) (rgba[i][ACOMP] * 3.0F)) ); 1623 } 1624 } 1625 else if (dstFormat == GL_BGRA) { 1626 GLuint *dst = (GLuint *) dstAddr; 1627 for (i=0;i<n;i++) { 1628 dst[i] = (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 22) 1629 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 12) 1630 | (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 2) 1631 | (((GLuint) (rgba[i][ACOMP] * 3.0F)) ); 1632 } 1633 } 1634 else if (dstFormat == GL_ABGR_EXT) { 1635 GLuint *dst = (GLuint *) dstAddr; 1636 for (i=0;i<n;i++) { 1637 dst[i] = (((GLuint) (rgba[i][ACOMP] * 1023.0F)) << 22) 1638 | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 12) 1639 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 2) 1640 | (((GLuint) (rgba[i][RCOMP] * 3.0F)) ); 1641 } 1642 } 1643 break; 1644 case GL_UNSIGNED_INT_2_10_10_10_REV: 1645 if (dstFormat == GL_RGBA) { 1646 GLuint *dst = (GLuint *) dstAddr; 1647 for (i=0;i<n;i++) { 1648 dst[i] = (((GLuint) (rgba[i][RCOMP] * 1023.0F)) ) 1649 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 10) 1650 | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 20) 1651 | (((GLuint) (rgba[i][ACOMP] * 3.0F)) << 30); 1652 } 1653 } 1654 else if (dstFormat == GL_BGRA) { 1655 GLuint *dst = (GLuint *) dstAddr; 1656 for (i=0;i<n;i++) { 1657 dst[i] = (((GLuint) (rgba[i][BCOMP] * 1023.0F)) ) 1658 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 10) 1659 | (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 20) 1660 | (((GLuint) (rgba[i][ACOMP] * 3.0F)) << 30); 1661 } 1662 } 1663 else if (dstFormat == GL_ABGR_EXT) { 1664 GLuint *dst = (GLuint *) dstAddr; 1665 for (i=0;i<n;i++) { 1666 dst[i] = (((GLuint) (rgba[i][ACOMP] * 1023.0F)) ) 1667 | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 10) 1668 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 20) 1669 | (((GLuint) (rgba[i][RCOMP] * 3.0F)) << 30); 1670 } 1671 } 1672 break; 1673 default: 1674 gl_problem(ctx, "bad type in _mesa_pack_float_rgba_span"); 1675 } 1676} 1677 1678 1679 1680/* 1681 * Pack the given RGBA span into client memory at 'dest' address 1682 * in the given pixel format and type. 1683 * Optionally apply the enabled pixel transfer ops. 1684 * Pack into memory using the given packing params struct. 1685 * This is used by glReadPixels and glGetTexImage?D() 1686 * Input: ctx - the context 1687 * n - number of pixels in the span 1688 * rgba - the pixels 1689 * format - dest packing format 1690 * type - dest packing datatype 1691 * destination - destination packing address 1692 * packing - pixel packing parameters 1693 * transferOps - bitmask of IMAGE_*_BIT operations to apply 1694 */ 1695void 1696_mesa_pack_rgba_span( GLcontext *ctx, 1697 GLuint n, CONST GLchan srcRgba[][4], 1698 GLenum dstFormat, GLenum dstType, 1699 GLvoid *dstAddr, 1700 const struct gl_pixelstore_attrib *dstPacking, 1701 GLuint transferOps) 1702{ 1703 ASSERT((ctx->NewState & _NEW_PIXEL) == 0); 1704 1705 /* Test for optimized case first */ 1706 if (transferOps == 0 && dstFormat == GL_RGBA && dstType == CHAN_TYPE) { 1707 /* common simple case */ 1708 MEMCPY(dstAddr, srcRgba, n * 4 * sizeof(GLchan)); 1709 } 1710 else if (transferOps == 0 && dstFormat == GL_RGB && dstType == CHAN_TYPE) { 1711 /* common simple case */ 1712 GLint i; 1713 GLchan *dest = (GLchan *) dstAddr; 1714 for (i = 0; i < n; i++) { 1715 dest[0] = srcRgba[i][RCOMP]; 1716 dest[1] = srcRgba[i][GCOMP]; 1717 dest[2] = srcRgba[i][BCOMP]; 1718 dest += 3; 1719 } 1720 } 1721 else { 1722 /* general solution */ 1723 GLfloat rgba[MAX_WIDTH][4]; 1724 GLuint i; 1725 assert(n <= MAX_WIDTH); 1726 /* convert color components to floating point */ 1727 for (i=0;i<n;i++) { 1728 rgba[i][RCOMP] = CHAN_TO_FLOAT(srcRgba[i][RCOMP]); 1729 rgba[i][GCOMP] = CHAN_TO_FLOAT(srcRgba[i][GCOMP]); 1730 rgba[i][BCOMP] = CHAN_TO_FLOAT(srcRgba[i][BCOMP]); 1731 rgba[i][ACOMP] = CHAN_TO_FLOAT(srcRgba[i][ACOMP]); 1732 } 1733 _mesa_pack_float_rgba_span(ctx, n, (const GLfloat (*)[4]) rgba, 1734 dstFormat, dstType, dstAddr, 1735 dstPacking, transferOps); 1736 } 1737} 1738 1739 1740#define SWAP2BYTE(VALUE) \ 1741 { \ 1742 GLubyte *bytes = (GLubyte *) &(VALUE); \ 1743 GLubyte tmp = bytes[0]; \ 1744 bytes[0] = bytes[1]; \ 1745 bytes[1] = tmp; \ 1746 } 1747 1748#define SWAP4BYTE(VALUE) \ 1749 { \ 1750 GLubyte *bytes = (GLubyte *) &(VALUE); \ 1751 GLubyte tmp = bytes[0]; \ 1752 bytes[0] = bytes[3]; \ 1753 bytes[3] = tmp; \ 1754 tmp = bytes[1]; \ 1755 bytes[1] = bytes[2]; \ 1756 bytes[2] = tmp; \ 1757 } 1758 1759 1760static void 1761extract_uint_indexes(GLuint n, GLuint indexes[], 1762 GLenum srcFormat, GLenum srcType, const GLvoid *src, 1763 const struct gl_pixelstore_attrib *unpack ) 1764{ 1765 assert(srcFormat == GL_COLOR_INDEX); 1766 1767 ASSERT(srcType == GL_BITMAP || 1768 srcType == GL_UNSIGNED_BYTE || 1769 srcType == GL_BYTE || 1770 srcType == GL_UNSIGNED_SHORT || 1771 srcType == GL_SHORT || 1772 srcType == GL_UNSIGNED_INT || 1773 srcType == GL_INT || 1774 srcType == GL_FLOAT); 1775 1776 switch (srcType) { 1777 case GL_BITMAP: 1778 { 1779 GLubyte *ubsrc = (GLubyte *) src; 1780 if (unpack->LsbFirst) { 1781 GLubyte mask = 1 << (unpack->SkipPixels & 0x7); 1782 GLuint i; 1783 for (i = 0; i < n; i++) { 1784 indexes[i] = (*ubsrc & mask) ? 1 : 0; 1785 if (mask == 128) { 1786 mask = 1; 1787 ubsrc++; 1788 } 1789 else { 1790 mask = mask << 1; 1791 } 1792 } 1793 } 1794 else { 1795 GLubyte mask = 128 >> (unpack->SkipPixels & 0x7); 1796 GLuint i; 1797 for (i = 0; i < n; i++) { 1798 indexes[i] = (*ubsrc & mask) ? 1 : 0; 1799 if (mask == 1) { 1800 mask = 128; 1801 ubsrc++; 1802 } 1803 else { 1804 mask = mask >> 1; 1805 } 1806 } 1807 } 1808 } 1809 break; 1810 case GL_UNSIGNED_BYTE: 1811 { 1812 GLuint i; 1813 const GLubyte *s = (const GLubyte *) src; 1814 for (i = 0; i < n; i++) 1815 indexes[i] = s[i]; 1816 } 1817 break; 1818 case GL_BYTE: 1819 { 1820 GLuint i; 1821 const GLbyte *s = (const GLbyte *) src; 1822 for (i = 0; i < n; i++) 1823 indexes[i] = s[i]; 1824 } 1825 break; 1826 case GL_UNSIGNED_SHORT: 1827 { 1828 GLuint i; 1829 const GLushort *s = (const GLushort *) src; 1830 if (unpack->SwapBytes) { 1831 for (i = 0; i < n; i++) { 1832 GLushort value = s[i]; 1833 SWAP2BYTE(value); 1834 indexes[i] = value; 1835 } 1836 } 1837 else { 1838 for (i = 0; i < n; i++) 1839 indexes[i] = s[i]; 1840 } 1841 } 1842 break; 1843 case GL_SHORT: 1844 { 1845 GLuint i; 1846 const GLshort *s = (const GLshort *) src; 1847 if (unpack->SwapBytes) { 1848 for (i = 0; i < n; i++) { 1849 GLshort value = s[i]; 1850 SWAP2BYTE(value); 1851 indexes[i] = value; 1852 } 1853 } 1854 else { 1855 for (i = 0; i < n; i++) 1856 indexes[i] = s[i]; 1857 } 1858 } 1859 break; 1860 case GL_UNSIGNED_INT: 1861 { 1862 GLuint i; 1863 const GLuint *s = (const GLuint *) src; 1864 if (unpack->SwapBytes) { 1865 for (i = 0; i < n; i++) { 1866 GLuint value = s[i]; 1867 SWAP4BYTE(value); 1868 indexes[i] = value; 1869 } 1870 } 1871 else { 1872 for (i = 0; i < n; i++) 1873 indexes[i] = s[i]; 1874 } 1875 } 1876 break; 1877 case GL_INT: 1878 { 1879 GLuint i; 1880 const GLint *s = (const GLint *) src; 1881 if (unpack->SwapBytes) { 1882 for (i = 0; i < n; i++) { 1883 GLint value = s[i]; 1884 SWAP4BYTE(value); 1885 indexes[i] = value; 1886 } 1887 } 1888 else { 1889 for (i = 0; i < n; i++) 1890 indexes[i] = s[i]; 1891 } 1892 } 1893 break; 1894 case GL_FLOAT: 1895 { 1896 GLuint i; 1897 const GLfloat *s = (const GLfloat *) src; 1898 if (unpack->SwapBytes) { 1899 for (i = 0; i < n; i++) { 1900 GLfloat value = s[i]; 1901 SWAP4BYTE(value); 1902 indexes[i] = (GLuint) value; 1903 } 1904 } 1905 else { 1906 for (i = 0; i < n; i++) 1907 indexes[i] = (GLuint) s[i]; 1908 } 1909 } 1910 break; 1911 default: 1912 gl_problem(NULL, "bad srcType in extract_uint_indexes"); 1913 return; 1914 } 1915} 1916 1917 1918 1919/* 1920 * This function extracts floating point RGBA values from arbitrary 1921 * image data. srcFormat and srcType are the format and type parameters 1922 * passed to glDrawPixels, glTexImage[123]D, glTexSubImage[123]D, etc. 1923 * 1924 * Refering to section 3.6.4 of the OpenGL 1.2 spec, this function 1925 * implements the "Conversion to floating point", "Conversion to RGB", 1926 * and "Final Expansion to RGBA" operations. 1927 * 1928 * Args: n - number of pixels 1929 * rgba - output colors 1930 * srcFormat - format of incoming data 1931 * srcType - datatype of incoming data 1932 * src - source data pointer 1933 * swapBytes - perform byteswapping of incoming data? 1934 */ 1935static void 1936extract_float_rgba(GLuint n, GLfloat rgba[][4], 1937 GLenum srcFormat, GLenum srcType, const GLvoid *src, 1938 GLboolean swapBytes) 1939{ 1940 GLint redIndex, greenIndex, blueIndex, alphaIndex; 1941 GLint stride; 1942 GLint rComp, bComp, gComp, aComp; 1943 1944 ASSERT(srcFormat == GL_RED || 1945 srcFormat == GL_GREEN || 1946 srcFormat == GL_BLUE || 1947 srcFormat == GL_ALPHA || 1948 srcFormat == GL_LUMINANCE || 1949 srcFormat == GL_LUMINANCE_ALPHA || 1950 srcFormat == GL_INTENSITY || 1951 srcFormat == GL_RGB || 1952 srcFormat == GL_BGR || 1953 srcFormat == GL_RGBA || 1954 srcFormat == GL_BGRA || 1955 srcFormat == GL_ABGR_EXT); 1956 1957 ASSERT(srcType == GL_UNSIGNED_BYTE || 1958 srcType == GL_BYTE || 1959 srcType == GL_UNSIGNED_SHORT || 1960 srcType == GL_SHORT || 1961 srcType == GL_UNSIGNED_INT || 1962 srcType == GL_INT || 1963 srcType == GL_FLOAT || 1964 srcType == GL_UNSIGNED_BYTE_3_3_2 || 1965 srcType == GL_UNSIGNED_BYTE_2_3_3_REV || 1966 srcType == GL_UNSIGNED_SHORT_5_6_5 || 1967 srcType == GL_UNSIGNED_SHORT_5_6_5_REV || 1968 srcType == GL_UNSIGNED_SHORT_4_4_4_4 || 1969 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV || 1970 srcType == GL_UNSIGNED_SHORT_5_5_5_1 || 1971 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV || 1972 srcType == GL_UNSIGNED_INT_8_8_8_8 || 1973 srcType == GL_UNSIGNED_INT_8_8_8_8_REV || 1974 srcType == GL_UNSIGNED_INT_10_10_10_2 || 1975 srcType == GL_UNSIGNED_INT_2_10_10_10_REV); 1976 1977 rComp = gComp = bComp = aComp = -1; 1978 1979 switch (srcFormat) { 1980 case GL_RED: 1981 redIndex = 0; 1982 greenIndex = blueIndex = alphaIndex = -1; 1983 stride = 1; 1984 break; 1985 case GL_GREEN: 1986 greenIndex = 0; 1987 redIndex = blueIndex = alphaIndex = -1; 1988 stride = 1; 1989 break; 1990 case GL_BLUE: 1991 blueIndex = 0; 1992 redIndex = greenIndex = alphaIndex = -1; 1993 stride = 1; 1994 break; 1995 case GL_ALPHA: 1996 redIndex = greenIndex = blueIndex = -1; 1997 alphaIndex = 0; 1998 stride = 1; 1999 break; 2000 case GL_LUMINANCE: 2001 redIndex = greenIndex = blueIndex = 0; 2002 alphaIndex = -1; 2003 stride = 1; 2004 break; 2005 case GL_LUMINANCE_ALPHA: 2006 redIndex = greenIndex = blueIndex = 0; 2007 alphaIndex = 1; 2008 stride = 2; 2009 break; 2010 case GL_INTENSITY: 2011 redIndex = 0; 2012 greenIndex = blueIndex = alphaIndex = -1; 2013 stride = 1; 2014 break; 2015 case GL_RGB: 2016 redIndex = 0; 2017 greenIndex = 1; 2018 blueIndex = 2; 2019 alphaIndex = -1; 2020 stride = 3; 2021 break; 2022 case GL_BGR: 2023 redIndex = 2; 2024 greenIndex = 1; 2025 blueIndex = 0; 2026 alphaIndex = -1; 2027 stride = 3; 2028 break; 2029 case GL_RGBA: 2030 redIndex = 0; 2031 greenIndex = 1; 2032 blueIndex = 2; 2033 alphaIndex = 3; 2034 rComp = 0; 2035 gComp = 1; 2036 bComp = 2; 2037 aComp = 3; 2038 stride = 4; 2039 break; 2040 case GL_BGRA: 2041 redIndex = 2; 2042 greenIndex = 1; 2043 blueIndex = 0; 2044 alphaIndex = 3; 2045 rComp = 2; 2046 gComp = 1; 2047 bComp = 0; 2048 aComp = 3; 2049 stride = 4; 2050 break; 2051 case GL_ABGR_EXT: 2052 redIndex = 3; 2053 greenIndex = 2; 2054 blueIndex = 1; 2055 alphaIndex = 0; 2056 rComp = 3; 2057 gComp = 2; 2058 bComp = 1; 2059 aComp = 0; 2060 stride = 4; 2061 break; 2062 default: 2063 gl_problem(NULL, "bad srcFormat in extract float data"); 2064 return; 2065 } 2066 2067 2068#define PROCESS(INDEX, CHANNEL, DEFAULT, TYPE, CONVERSION) \ 2069 if ((INDEX) < 0) { \ 2070 GLuint i; \ 2071 for (i = 0; i < n; i++) { \ 2072 rgba[i][CHANNEL] = DEFAULT; \ 2073 } \ 2074 } \ 2075 else if (swapBytes) { \ 2076 const TYPE *s = (const TYPE *) src; \ 2077 GLuint i; \ 2078 for (i = 0; i < n; i++) { \ 2079 TYPE value = s[INDEX]; \ 2080 if (sizeof(TYPE) == 2) { \ 2081 SWAP2BYTE(value); \ 2082 } \ 2083 else if (sizeof(TYPE) == 4) { \ 2084 SWAP4BYTE(value); \ 2085 } \ 2086 rgba[i][CHANNEL] = (GLfloat) CONVERSION(value); \ 2087 s += stride; \ 2088 } \ 2089 } \ 2090 else { \ 2091 const TYPE *s = (const TYPE *) src; \ 2092 GLuint i; \ 2093 for (i = 0; i < n; i++) { \ 2094 rgba[i][CHANNEL] = (GLfloat) CONVERSION(s[INDEX]); \ 2095 s += stride; \ 2096 } \ 2097 } 2098 2099 switch (srcType) { 2100 case GL_UNSIGNED_BYTE: 2101 PROCESS(redIndex, RCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT); 2102 PROCESS(greenIndex, GCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT); 2103 PROCESS(blueIndex, BCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT); 2104 PROCESS(alphaIndex, ACOMP, 1.0F, GLubyte, UBYTE_TO_FLOAT); 2105 break; 2106 case GL_BYTE: 2107 PROCESS(redIndex, RCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT); 2108 PROCESS(greenIndex, GCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT); 2109 PROCESS(blueIndex, BCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT); 2110 PROCESS(alphaIndex, ACOMP, 1.0F, GLbyte, BYTE_TO_FLOAT); 2111 break; 2112 case GL_UNSIGNED_SHORT: 2113 PROCESS(redIndex, RCOMP, 0.0F, GLushort, USHORT_TO_FLOAT); 2114 PROCESS(greenIndex, GCOMP, 0.0F, GLushort, USHORT_TO_FLOAT); 2115 PROCESS(blueIndex, BCOMP, 0.0F, GLushort, USHORT_TO_FLOAT); 2116 PROCESS(alphaIndex, ACOMP, 1.0F, GLushort, USHORT_TO_FLOAT); 2117 break; 2118 case GL_SHORT: 2119 PROCESS(redIndex, RCOMP, 0.0F, GLshort, SHORT_TO_FLOAT); 2120 PROCESS(greenIndex, GCOMP, 0.0F, GLshort, SHORT_TO_FLOAT); 2121 PROCESS(blueIndex, BCOMP, 0.0F, GLshort, SHORT_TO_FLOAT); 2122 PROCESS(alphaIndex, ACOMP, 1.0F, GLshort, SHORT_TO_FLOAT); 2123 break; 2124 case GL_UNSIGNED_INT: 2125 PROCESS(redIndex, RCOMP, 0.0F, GLuint, UINT_TO_FLOAT); 2126 PROCESS(greenIndex, GCOMP, 0.0F, GLuint, UINT_TO_FLOAT); 2127 PROCESS(blueIndex, BCOMP, 0.0F, GLuint, UINT_TO_FLOAT); 2128 PROCESS(alphaIndex, ACOMP, 1.0F, GLuint, UINT_TO_FLOAT); 2129 break; 2130 case GL_INT: 2131 PROCESS(redIndex, RCOMP, 0.0F, GLint, INT_TO_FLOAT); 2132 PROCESS(greenIndex, GCOMP, 0.0F, GLint, INT_TO_FLOAT); 2133 PROCESS(blueIndex, BCOMP, 0.0F, GLint, INT_TO_FLOAT); 2134 PROCESS(alphaIndex, ACOMP, 1.0F, GLint, INT_TO_FLOAT); 2135 break; 2136 case GL_FLOAT: 2137 PROCESS(redIndex, RCOMP, 0.0F, GLfloat, (GLfloat)); 2138 PROCESS(greenIndex, GCOMP, 0.0F, GLfloat, (GLfloat)); 2139 PROCESS(blueIndex, BCOMP, 0.0F, GLfloat, (GLfloat)); 2140 PROCESS(alphaIndex, ACOMP, 1.0F, GLfloat, (GLfloat)); 2141 break; 2142 case GL_UNSIGNED_BYTE_3_3_2: 2143 { 2144 const GLubyte *ubsrc = (const GLubyte *) src; 2145 GLuint i; 2146 for (i = 0; i < n; i ++) { 2147 GLubyte p = ubsrc[i]; 2148 rgba[i][RCOMP] = ((p >> 5) ) * (1.0F / 7.0F); 2149 rgba[i][GCOMP] = ((p >> 2) & 0x7) * (1.0F / 7.0F); 2150 rgba[i][BCOMP] = ((p ) & 0x3) * (1.0F / 3.0F); 2151 rgba[i][ACOMP] = 1.0F; 2152 } 2153 } 2154 break; 2155 case GL_UNSIGNED_BYTE_2_3_3_REV: 2156 { 2157 const GLubyte *ubsrc = (const GLubyte *) src; 2158 GLuint i; 2159 for (i = 0; i < n; i ++) { 2160 GLubyte p = ubsrc[i]; 2161 rgba[i][RCOMP] = ((p ) & 0x7) * (1.0F / 7.0F); 2162 rgba[i][GCOMP] = ((p >> 3) & 0x7) * (1.0F / 7.0F); 2163 rgba[i][BCOMP] = ((p >> 6) ) * (1.0F / 3.0F); 2164 rgba[i][ACOMP] = 1.0F; 2165 } 2166 } 2167 break; 2168 case GL_UNSIGNED_SHORT_5_6_5: 2169 if (swapBytes) { 2170 const GLushort *ussrc = (const GLushort *) src; 2171 GLuint i; 2172 for (i = 0; i < n; i ++) { 2173 GLushort p = ussrc[i]; 2174 SWAP2BYTE(p); 2175 rgba[i][RCOMP] = ((p >> 11) ) * (1.0F / 31.0F); 2176 rgba[i][GCOMP] = ((p >> 5) & 0x3f) * (1.0F / 63.0F); 2177 rgba[i][BCOMP] = ((p ) & 0x1f) * (1.0F / 31.0F); 2178 rgba[i][ACOMP] = 1.0F; 2179 } 2180 } 2181 else { 2182 const GLushort *ussrc = (const GLushort *) src; 2183 GLuint i; 2184 for (i = 0; i < n; i ++) { 2185 GLushort p = ussrc[i]; 2186 rgba[i][RCOMP] = ((p >> 11) ) * (1.0F / 31.0F); 2187 rgba[i][GCOMP] = ((p >> 5) & 0x3f) * (1.0F / 63.0F); 2188 rgba[i][BCOMP] = ((p ) & 0x1f) * (1.0F / 31.0F); 2189 rgba[i][ACOMP] = 1.0F; 2190 } 2191 } 2192 break; 2193 case GL_UNSIGNED_SHORT_5_6_5_REV: 2194 if (swapBytes) { 2195 const GLushort *ussrc = (const GLushort *) src; 2196 GLuint i; 2197 for (i = 0; i < n; i ++) { 2198 GLushort p = ussrc[i]; 2199 SWAP2BYTE(p); 2200 rgba[i][RCOMP] = ((p ) & 0x1f) * (1.0F / 31.0F); 2201 rgba[i][GCOMP] = ((p >> 5) & 0x3f) * (1.0F / 63.0F); 2202 rgba[i][BCOMP] = ((p >> 11) ) * (1.0F / 31.0F); 2203 rgba[i][ACOMP] = 1.0F; 2204 } 2205 } 2206 else { 2207 const GLushort *ussrc = (const GLushort *) src; 2208 GLuint i; 2209 for (i = 0; i < n; i ++) { 2210 GLushort p = ussrc[i]; 2211 rgba[i][RCOMP] = ((p ) & 0x1f) * (1.0F / 31.0F); 2212 rgba[i][GCOMP] = ((p >> 5) & 0x3f) * (1.0F / 63.0F); 2213 rgba[i][BCOMP] = ((p >> 11) ) * (1.0F / 31.0F); 2214 rgba[i][ACOMP] = 1.0F; 2215 } 2216 } 2217 break; 2218 case GL_UNSIGNED_SHORT_4_4_4_4: 2219 if (swapBytes) { 2220 const GLushort *ussrc = (const GLushort *) src; 2221 GLuint i; 2222 for (i = 0; i < n; i ++) { 2223 GLushort p = ussrc[i]; 2224 SWAP2BYTE(p); 2225 rgba[i][rComp] = ((p >> 12) ) * (1.0F / 15.0F); 2226 rgba[i][gComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F); 2227 rgba[i][bComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F); 2228 rgba[i][aComp] = ((p ) & 0xf) * (1.0F / 15.0F); 2229 } 2230 } 2231 else { 2232 const GLushort *ussrc = (const GLushort *) src; 2233 GLuint i; 2234 for (i = 0; i < n; i ++) { 2235 GLushort p = ussrc[i]; 2236 rgba[i][rComp] = ((p >> 12) ) * (1.0F / 15.0F); 2237 rgba[i][gComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F); 2238 rgba[i][bComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F); 2239 rgba[i][aComp] = ((p ) & 0xf) * (1.0F / 15.0F); 2240 } 2241 } 2242 break; 2243 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 2244 if (swapBytes) { 2245 const GLushort *ussrc = (const GLushort *) src; 2246 GLuint i; 2247 for (i = 0; i < n; i ++) { 2248 GLushort p = ussrc[i]; 2249 SWAP2BYTE(p); 2250 rgba[i][rComp] = ((p ) & 0xf) * (1.0F / 15.0F); 2251 rgba[i][gComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F); 2252 rgba[i][bComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F); 2253 rgba[i][aComp] = ((p >> 12) ) * (1.0F / 15.0F); 2254 } 2255 } 2256 else { 2257 const GLushort *ussrc = (const GLushort *) src; 2258 GLuint i; 2259 for (i = 0; i < n; i ++) { 2260 GLushort p = ussrc[i]; 2261 rgba[i][rComp] = ((p ) & 0xf) * (1.0F / 15.0F); 2262 rgba[i][gComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F); 2263 rgba[i][bComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F); 2264 rgba[i][aComp] = ((p >> 12) ) * (1.0F / 15.0F); 2265 } 2266 } 2267 break; 2268 case GL_UNSIGNED_SHORT_5_5_5_1: 2269 if (swapBytes) { 2270 const GLushort *ussrc = (const GLushort *) src; 2271 GLuint i; 2272 for (i = 0; i < n; i ++) { 2273 GLushort p = ussrc[i]; 2274 SWAP2BYTE(p); 2275 rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F); 2276 rgba[i][gComp] = ((p >> 6) & 0x1f) * (1.0F / 31.0F); 2277 rgba[i][bComp] = ((p >> 1) & 0x1f) * (1.0F / 31.0F); 2278 rgba[i][aComp] = ((p ) & 0x1) * (1.0F / 1.0F); 2279 } 2280 } 2281 else { 2282 const GLushort *ussrc = (const GLushort *) src; 2283 GLuint i; 2284 for (i = 0; i < n; i ++) { 2285 GLushort p = ussrc[i]; 2286 rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F); 2287 rgba[i][gComp] = ((p >> 6) & 0x1f) * (1.0F / 31.0F); 2288 rgba[i][bComp] = ((p >> 1) & 0x1f) * (1.0F / 31.0F); 2289 rgba[i][aComp] = ((p ) & 0x1) * (1.0F / 1.0F); 2290 } 2291 } 2292 break; 2293 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 2294 if (swapBytes) { 2295 const GLushort *ussrc = (const GLushort *) src; 2296 GLuint i; 2297 for (i = 0; i < n; i ++) { 2298 GLushort p = ussrc[i]; 2299 SWAP2BYTE(p); 2300 rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F); 2301 rgba[i][gComp] = ((p >> 5) & 0x1f) * (1.0F / 31.0F); 2302 rgba[i][bComp] = ((p >> 10) & 0x1f) * (1.0F / 31.0F); 2303 rgba[i][aComp] = ((p >> 15) ) * (1.0F / 1.0F); 2304 } 2305 } 2306 else { 2307 const GLushort *ussrc = (const GLushort *) src; 2308 GLuint i; 2309 for (i = 0; i < n; i ++) { 2310 GLushort p = ussrc[i]; 2311 rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F); 2312 rgba[i][gComp] = ((p >> 5) & 0x1f) * (1.0F / 31.0F); 2313 rgba[i][bComp] = ((p >> 10) & 0x1f) * (1.0F / 31.0F); 2314 rgba[i][aComp] = ((p >> 15) ) * (1.0F / 1.0F); 2315 } 2316 } 2317 break; 2318 case GL_UNSIGNED_INT_8_8_8_8: 2319 if (swapBytes) { 2320 const GLuint *uisrc = (const GLuint *) src; 2321 GLuint i; 2322 for (i = 0; i < n; i ++) { 2323 GLuint p = uisrc[i]; 2324 rgba[i][rComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p ) & 0xff); 2325 rgba[i][gComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 8) & 0xff); 2326 rgba[i][bComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 16) & 0xff); 2327 rgba[i][aComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 24) ); 2328 } 2329 } 2330 else { 2331 const GLuint *uisrc = (const GLuint *) src; 2332 GLuint i; 2333 for (i = 0; i < n; i ++) { 2334 GLuint p = uisrc[i]; 2335 rgba[i][rComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 24) ); 2336 rgba[i][gComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 16) & 0xff); 2337 rgba[i][bComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 8) & 0xff); 2338 rgba[i][aComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p ) & 0xff); 2339 } 2340 } 2341 break; 2342 case GL_UNSIGNED_INT_8_8_8_8_REV: 2343 if (swapBytes) { 2344 const GLuint *uisrc = (const GLuint *) src; 2345 GLuint i; 2346 for (i = 0; i < n; i ++) { 2347 GLuint p = uisrc[i]; 2348 rgba[i][rComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 24) ); 2349 rgba[i][gComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 16) & 0xff); 2350 rgba[i][bComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 8) & 0xff); 2351 rgba[i][aComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p ) & 0xff); 2352 } 2353 } 2354 else { 2355 const GLuint *uisrc = (const GLuint *) src; 2356 GLuint i; 2357 for (i = 0; i < n; i ++) { 2358 GLuint p = uisrc[i]; 2359 rgba[i][rComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p ) & 0xff); 2360 rgba[i][gComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 8) & 0xff); 2361 rgba[i][bComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 16) & 0xff); 2362 rgba[i][aComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 24) ); 2363 } 2364 } 2365 break; 2366 case GL_UNSIGNED_INT_10_10_10_2: 2367 if (swapBytes) { 2368 const GLuint *uisrc = (const GLuint *) src; 2369 GLuint i; 2370 for (i = 0; i < n; i ++) { 2371 GLuint p = uisrc[i]; 2372 SWAP4BYTE(p); 2373 rgba[i][rComp] = ((p >> 22) ) * (1.0F / 1023.0F); 2374 rgba[i][gComp] = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F); 2375 rgba[i][bComp] = ((p >> 2) & 0x3ff) * (1.0F / 1023.0F); 2376 rgba[i][aComp] = ((p ) & 0x3 ) * (1.0F / 3.0F); 2377 } 2378 } 2379 else { 2380 const GLuint *uisrc = (const GLuint *) src; 2381 GLuint i; 2382 for (i = 0; i < n; i ++) { 2383 GLuint p = uisrc[i]; 2384 rgba[i][rComp] = ((p >> 22) ) * (1.0F / 1023.0F); 2385 rgba[i][gComp] = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F); 2386 rgba[i][bComp] = ((p >> 2) & 0x3ff) * (1.0F / 1023.0F); 2387 rgba[i][aComp] = ((p ) & 0x3 ) * (1.0F / 3.0F); 2388 } 2389 } 2390 break; 2391 case GL_UNSIGNED_INT_2_10_10_10_REV: 2392 if (swapBytes) { 2393 const GLuint *uisrc = (const GLuint *) src; 2394 GLuint i; 2395 for (i = 0; i < n; i ++) { 2396 GLuint p = uisrc[i]; 2397 SWAP4BYTE(p); 2398 rgba[i][rComp] = ((p ) & 0x3ff) * (1.0F / 1023.0F); 2399 rgba[i][gComp] = ((p >> 10) & 0x3ff) * (1.0F / 1023.0F); 2400 rgba[i][bComp] = ((p >> 20) & 0x3ff) * (1.0F / 1023.0F); 2401 rgba[i][aComp] = ((p >> 30) ) * (1.0F / 3.0F); 2402 } 2403 } 2404 else { 2405 const GLuint *uisrc = (const GLuint *) src; 2406 GLuint i; 2407 for (i = 0; i < n; i ++) { 2408 GLuint p = uisrc[i]; 2409 rgba[i][rComp] = ((p ) & 0x3ff) * (1.0F / 1023.0F); 2410 rgba[i][gComp] = ((p >> 10) & 0x3ff) * (1.0F / 1023.0F); 2411 rgba[i][bComp] = ((p >> 20) & 0x3ff) * (1.0F / 1023.0F); 2412 rgba[i][aComp] = ((p >> 30) ) * (1.0F / 3.0F); 2413 } 2414 } 2415 break; 2416 default: 2417 gl_problem(NULL, "bad srcType in extract float data"); 2418 break; 2419 } 2420} 2421 2422 2423 2424/* 2425 * Unpack a row of color image data from a client buffer according to 2426 * the pixel unpacking parameters. 2427 * Return GLubyte values in the specified dest image format. 2428 * This is (or will be) used by glDrawPixels and glTexImage?D(). 2429 * Input: ctx - the context 2430 * n - number of pixels in the span 2431 * dstFormat - format of destination color array 2432 * dest - the destination color array 2433 * srcFormat - source image format 2434 * srcType - source image datatype 2435 * source - source image pointer 2436 * srcPacking - pixel unpacking parameters 2437 * transferOps - bitmask of IMAGE_*_BIT values of operations to apply 2438 * 2439 * XXX perhaps expand this to process whole images someday. 2440 */ 2441void 2442_mesa_unpack_chan_color_span( GLcontext *ctx, 2443 GLuint n, GLenum dstFormat, GLchan dest[], 2444 GLenum srcFormat, GLenum srcType, 2445 const GLvoid *source, 2446 const struct gl_pixelstore_attrib *srcPacking, 2447 GLuint transferOps ) 2448{ 2449 ASSERT(dstFormat == GL_ALPHA || 2450 dstFormat == GL_LUMINANCE || 2451 dstFormat == GL_LUMINANCE_ALPHA || 2452 dstFormat == GL_INTENSITY || 2453 dstFormat == GL_RGB || 2454 dstFormat == GL_RGBA || 2455 dstFormat == GL_COLOR_INDEX); 2456 2457 ASSERT(srcFormat == GL_RED || 2458 srcFormat == GL_GREEN || 2459 srcFormat == GL_BLUE || 2460 srcFormat == GL_ALPHA || 2461 srcFormat == GL_LUMINANCE || 2462 srcFormat == GL_LUMINANCE_ALPHA || 2463 srcFormat == GL_INTENSITY || 2464 srcFormat == GL_RGB || 2465 srcFormat == GL_BGR || 2466 srcFormat == GL_RGBA || 2467 srcFormat == GL_BGRA || 2468 srcFormat == GL_ABGR_EXT || 2469 srcFormat == GL_COLOR_INDEX); 2470 2471 ASSERT(srcType == GL_BITMAP || 2472 srcType == GL_UNSIGNED_BYTE || 2473 srcType == GL_BYTE || 2474 srcType == GL_UNSIGNED_SHORT || 2475 srcType == GL_SHORT || 2476 srcType == GL_UNSIGNED_INT || 2477 srcType == GL_INT || 2478 srcType == GL_FLOAT || 2479 srcType == GL_UNSIGNED_BYTE_3_3_2 || 2480 srcType == GL_UNSIGNED_BYTE_2_3_3_REV || 2481 srcType == GL_UNSIGNED_SHORT_5_6_5 || 2482 srcType == GL_UNSIGNED_SHORT_5_6_5_REV || 2483 srcType == GL_UNSIGNED_SHORT_4_4_4_4 || 2484 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV || 2485 srcType == GL_UNSIGNED_SHORT_5_5_5_1 || 2486 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV || 2487 srcType == GL_UNSIGNED_INT_8_8_8_8 || 2488 srcType == GL_UNSIGNED_INT_8_8_8_8_REV || 2489 srcType == GL_UNSIGNED_INT_10_10_10_2 || 2490 srcType == GL_UNSIGNED_INT_2_10_10_10_REV); 2491 2492 /* this is intended for RGBA mode only */ 2493 assert(ctx->Visual.RGBAflag); 2494 2495 /* Try simple cases first */ 2496 if (transferOps == 0 && srcType == CHAN_TYPE) { 2497 if (dstFormat == GL_RGBA) { 2498 if (srcFormat == GL_RGBA) { 2499 MEMCPY( dest, source, n * 4 * sizeof(GLchan) ); 2500 return; 2501 } 2502 else if (srcFormat == GL_RGB) { 2503 GLuint i; 2504 const GLchan *src = (const GLchan *) source; 2505 GLchan *dst = dest; 2506 for (i = 0; i < n; i++) { 2507 dst[0] = src[0]; 2508 dst[1] = src[1]; 2509 dst[2] = src[2]; 2510 dst[3] = CHAN_MAX; 2511 src += 3; 2512 dst += 4; 2513 } 2514 return; 2515 } 2516 } 2517 else if (dstFormat == GL_RGB) { 2518 if (srcFormat == GL_RGB) { 2519 MEMCPY( dest, source, n * 3 * sizeof(GLchan) ); 2520 return; 2521 } 2522 else if (srcFormat == GL_RGBA) { 2523 GLuint i; 2524 const GLchan *src = (const GLchan *) source; 2525 GLchan *dst = dest; 2526 for (i = 0; i < n; i++) { 2527 dst[0] = src[0]; 2528 dst[1] = src[1]; 2529 dst[2] = src[2]; 2530 src += 4; 2531 dst += 3; 2532 } 2533 return; 2534 } 2535 } 2536 else if (dstFormat == srcFormat) { 2537 GLint comps = _mesa_components_in_format(srcFormat); 2538 assert(comps > 0); 2539 MEMCPY( dest, source, n * comps * sizeof(GLchan) ); 2540 return; 2541 } 2542 } 2543 2544 2545 /* general solution begins here */ 2546 { 2547 GLfloat rgba[MAX_WIDTH][4]; 2548 GLint dstComponents; 2549 GLint dstRedIndex, dstGreenIndex, dstBlueIndex, dstAlphaIndex; 2550 GLint dstLuminanceIndex, dstIntensityIndex; 2551 2552 dstComponents = _mesa_components_in_format( dstFormat ); 2553 /* source & dest image formats should have been error checked by now */ 2554 assert(dstComponents > 0); 2555 2556 /* 2557 * Extract image data and convert to RGBA floats 2558 */ 2559 assert(n <= MAX_WIDTH); 2560 if (srcFormat == GL_COLOR_INDEX) { 2561 GLuint indexes[MAX_WIDTH]; 2562 extract_uint_indexes(n, indexes, srcFormat, srcType, source, 2563 srcPacking); 2564 2565 if (dstFormat == GL_COLOR_INDEX 2566 && (transferOps & IMAGE_MAP_COLOR_BIT)) { 2567 _mesa_map_ci(ctx, n, indexes); 2568 } 2569 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) { 2570 _mesa_shift_and_offset_ci(ctx, n, indexes); 2571 } 2572 2573 if (dstFormat == GL_COLOR_INDEX) { 2574 /* convert to GLchan and return */ 2575 GLuint i; 2576 for (i = 0; i < n; i++) { 2577 dest[i] = (GLchan) (indexes[i] & 0xff); 2578 } 2579 return; 2580 } 2581 else { 2582 /* Convert indexes to RGBA */ 2583 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba); 2584 } 2585 } 2586 else { 2587 extract_float_rgba(n, rgba, srcFormat, srcType, source, 2588 srcPacking->SwapBytes); 2589 2590 /* scale and bias colors */ 2591 if (transferOps & IMAGE_SCALE_BIAS_BIT) { 2592 _mesa_scale_and_bias_rgba(ctx, n, rgba); 2593 } 2594 /* color map lookup */ 2595 if (transferOps & IMAGE_MAP_COLOR_BIT) { 2596 _mesa_map_rgba(ctx, n, rgba); 2597 } 2598 } 2599 2600 if (transferOps) { 2601 /* GL_COLOR_TABLE lookup */ 2602 if (transferOps & IMAGE_COLOR_TABLE_BIT) { 2603 _mesa_lookup_rgba(&ctx->ColorTable, n, rgba); 2604 } 2605 /* convolution */ 2606 if (transferOps & IMAGE_CONVOLUTION_BIT) { 2607 /* this has to be done in the calling code */ 2608 } 2609 /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */ 2610 if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) { 2611 _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, n, rgba); 2612 } 2613 /* color matrix transform */ 2614 if (transferOps & IMAGE_COLOR_MATRIX_BIT) { 2615 _mesa_transform_rgba(ctx, n, rgba); 2616 } 2617 /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */ 2618 if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) { 2619 _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, n, rgba); 2620 } 2621 /* update histogram count */ 2622 if (transferOps & IMAGE_HISTOGRAM_BIT) { 2623 _mesa_update_histogram(ctx, n, (CONST GLfloat (*)[4]) rgba); 2624 } 2625 /* min/max here */ 2626 if (transferOps & IMAGE_MIN_MAX_BIT) { 2627 _mesa_update_minmax(ctx, n, (CONST GLfloat (*)[4]) rgba); 2628 } 2629 } 2630 2631 /* clamp to [0,1] */ 2632 { 2633 GLuint i; 2634 for (i = 0; i < n; i++) { 2635 rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F); 2636 rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F); 2637 rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F); 2638 rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F); 2639 } 2640 } 2641 2642 /* Now determine which color channels we need to produce. 2643 * And determine the dest index (offset) within each color tuple. 2644 */ 2645 switch (dstFormat) { 2646 case GL_ALPHA: 2647 dstAlphaIndex = 0; 2648 dstRedIndex = dstGreenIndex = dstBlueIndex = -1; 2649 dstLuminanceIndex = dstIntensityIndex = -1; 2650 break; 2651 case GL_LUMINANCE: 2652 dstLuminanceIndex = 0; 2653 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1; 2654 dstIntensityIndex = -1; 2655 break; 2656 case GL_LUMINANCE_ALPHA: 2657 dstLuminanceIndex = 0; 2658 dstAlphaIndex = 1; 2659 dstRedIndex = dstGreenIndex = dstBlueIndex = -1; 2660 dstIntensityIndex = -1; 2661 break; 2662 case GL_INTENSITY: 2663 dstIntensityIndex = 0; 2664 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1; 2665 dstLuminanceIndex = -1; 2666 break; 2667 case GL_RGB: 2668 dstRedIndex = 0; 2669 dstGreenIndex = 1; 2670 dstBlueIndex = 2; 2671 dstAlphaIndex = dstLuminanceIndex = dstIntensityIndex = -1; 2672 break; 2673 case GL_RGBA: 2674 dstRedIndex = 0; 2675 dstGreenIndex = 1; 2676 dstBlueIndex = 2; 2677 dstAlphaIndex = 3; 2678 dstLuminanceIndex = dstIntensityIndex = -1; 2679 break; 2680 default: 2681 gl_problem(ctx, "bad dstFormat in _mesa_unpack_chan_span()"); 2682 return; 2683 } 2684 2685 2686 /* Now return the GLchan data in the requested dstFormat */ 2687 2688 if (dstRedIndex >= 0) { 2689 GLchan *dst = dest; 2690 GLuint i; 2691 for (i = 0; i < n; i++) { 2692 dst[dstRedIndex] = FLOAT_TO_CHAN(rgba[i][RCOMP]); 2693 dst += dstComponents; 2694 } 2695 } 2696 2697 if (dstGreenIndex >= 0) { 2698 GLchan *dst = dest; 2699 GLuint i; 2700 for (i = 0; i < n; i++) { 2701 dst[dstGreenIndex] = FLOAT_TO_CHAN(rgba[i][GCOMP]); 2702 dst += dstComponents; 2703 } 2704 } 2705 2706 if (dstBlueIndex >= 0) { 2707 GLchan *dst = dest; 2708 GLuint i; 2709 for (i = 0; i < n; i++) { 2710 dst[dstBlueIndex] = FLOAT_TO_CHAN(rgba[i][BCOMP]); 2711 dst += dstComponents; 2712 } 2713 } 2714 2715 if (dstAlphaIndex >= 0) { 2716 GLchan *dst = dest; 2717 GLuint i; 2718 for (i = 0; i < n; i++) { 2719 dst[dstAlphaIndex] = FLOAT_TO_CHAN(rgba[i][ACOMP]); 2720 dst += dstComponents; 2721 } 2722 } 2723 2724 if (dstIntensityIndex >= 0) { 2725 GLchan *dst = dest; 2726 GLuint i; 2727 assert(dstIntensityIndex == 0); 2728 assert(dstComponents == 1); 2729 for (i = 0; i < n; i++) { 2730 /* Intensity comes from red channel */ 2731 dst[i] = FLOAT_TO_CHAN(rgba[i][RCOMP]); 2732 } 2733 } 2734 2735 if (dstLuminanceIndex >= 0) { 2736 GLchan *dst = dest; 2737 GLuint i; 2738 assert(dstLuminanceIndex == 0); 2739 for (i = 0; i < n; i++) { 2740 /* Luminance comes from red channel */ 2741 dst[0] = FLOAT_TO_CHAN(rgba[i][RCOMP]); 2742 dst += dstComponents; 2743 } 2744 } 2745 } 2746} 2747 2748 2749void 2750_mesa_unpack_float_color_span( GLcontext *ctx, 2751 GLuint n, GLenum dstFormat, GLfloat dest[], 2752 GLenum srcFormat, GLenum srcType, 2753 const GLvoid *source, 2754 const struct gl_pixelstore_attrib *srcPacking, 2755 GLuint transferOps, GLboolean clamp ) 2756{ 2757 ASSERT(dstFormat == GL_ALPHA || 2758 dstFormat == GL_LUMINANCE || 2759 dstFormat == GL_LUMINANCE_ALPHA || 2760 dstFormat == GL_INTENSITY || 2761 dstFormat == GL_RGB || 2762 dstFormat == GL_RGBA || 2763 dstFormat == GL_COLOR_INDEX); 2764 2765 ASSERT(srcFormat == GL_RED || 2766 srcFormat == GL_GREEN || 2767 srcFormat == GL_BLUE || 2768 srcFormat == GL_ALPHA || 2769 srcFormat == GL_LUMINANCE || 2770 srcFormat == GL_LUMINANCE_ALPHA || 2771 srcFormat == GL_INTENSITY || 2772 srcFormat == GL_RGB || 2773 srcFormat == GL_BGR || 2774 srcFormat == GL_RGBA || 2775 srcFormat == GL_BGRA || 2776 srcFormat == GL_ABGR_EXT || 2777 srcFormat == GL_COLOR_INDEX); 2778 2779 ASSERT(srcType == GL_BITMAP || 2780 srcType == GL_UNSIGNED_BYTE || 2781 srcType == GL_BYTE || 2782 srcType == GL_UNSIGNED_SHORT || 2783 srcType == GL_SHORT || 2784 srcType == GL_UNSIGNED_INT || 2785 srcType == GL_INT || 2786 srcType == GL_FLOAT || 2787 srcType == GL_UNSIGNED_BYTE_3_3_2 || 2788 srcType == GL_UNSIGNED_BYTE_2_3_3_REV || 2789 srcType == GL_UNSIGNED_SHORT_5_6_5 || 2790 srcType == GL_UNSIGNED_SHORT_5_6_5_REV || 2791 srcType == GL_UNSIGNED_SHORT_4_4_4_4 || 2792 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV || 2793 srcType == GL_UNSIGNED_SHORT_5_5_5_1 || 2794 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV || 2795 srcType == GL_UNSIGNED_INT_8_8_8_8 || 2796 srcType == GL_UNSIGNED_INT_8_8_8_8_REV || 2797 srcType == GL_UNSIGNED_INT_10_10_10_2 || 2798 srcType == GL_UNSIGNED_INT_2_10_10_10_REV); 2799 2800 /* this is intended for RGBA mode only */ 2801 assert(ctx->Visual.RGBAflag); 2802 2803 /* general solution, no special cases, yet */ 2804 { 2805 GLfloat rgba[MAX_WIDTH][4]; 2806 GLint dstComponents; 2807 GLint dstRedIndex, dstGreenIndex, dstBlueIndex, dstAlphaIndex; 2808 GLint dstLuminanceIndex, dstIntensityIndex; 2809 2810 dstComponents = _mesa_components_in_format( dstFormat ); 2811 /* source & dest image formats should have been error checked by now */ 2812 assert(dstComponents > 0); 2813 2814 /* 2815 * Extract image data and convert to RGBA floats 2816 */ 2817 assert(n <= MAX_WIDTH); 2818 if (srcFormat == GL_COLOR_INDEX) { 2819 GLuint indexes[MAX_WIDTH]; 2820 extract_uint_indexes(n, indexes, srcFormat, srcType, source, 2821 srcPacking); 2822 2823 if (dstFormat == GL_COLOR_INDEX 2824 && (transferOps & IMAGE_MAP_COLOR_BIT)) { 2825 _mesa_map_ci(ctx, n, indexes); 2826 } 2827 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) { 2828 _mesa_shift_and_offset_ci(ctx, n, indexes); 2829 } 2830 2831 if (dstFormat == GL_COLOR_INDEX) { 2832 /* convert to GLchan and return */ 2833 GLuint i; 2834 for (i = 0; i < n; i++) { 2835 dest[i] = (GLchan) (indexes[i] & 0xff); 2836 } 2837 return; 2838 } 2839 else { 2840 /* Convert indexes to RGBA */ 2841 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba); 2842 } 2843 } 2844 else { 2845 extract_float_rgba(n, rgba, srcFormat, srcType, source, 2846 srcPacking->SwapBytes); 2847 2848 /* scale and bias colors */ 2849 if (transferOps & IMAGE_SCALE_BIAS_BIT) { 2850 _mesa_scale_and_bias_rgba(ctx, n, rgba); 2851 } 2852 /* color map lookup */ 2853 if (transferOps & IMAGE_MAP_COLOR_BIT) { 2854 _mesa_map_rgba(ctx, n, rgba); 2855 } 2856 } 2857 2858 if (transferOps) { 2859 /* GL_COLOR_TABLE lookup */ 2860 if (transferOps & IMAGE_COLOR_TABLE_BIT) { 2861 _mesa_lookup_rgba(&ctx->ColorTable, n, rgba); 2862 } 2863 /* convolution */ 2864 if (transferOps & IMAGE_CONVOLUTION_BIT) { 2865 /* XXX to do */ 2866 } 2867 /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */ 2868 if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) { 2869 _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, n, rgba); 2870 } 2871 /* color matrix transform */ 2872 if (transferOps & IMAGE_COLOR_MATRIX_BIT) { 2873 _mesa_transform_rgba(ctx, n, rgba); 2874 } 2875 /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */ 2876 if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) { 2877 _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, n, rgba); 2878 } 2879 /* update histogram count */ 2880 if (transferOps & IMAGE_HISTOGRAM_BIT) { 2881 _mesa_update_histogram(ctx, n, (CONST GLfloat (*)[4]) rgba); 2882 } 2883 /* min/max here */ 2884 if (transferOps & IMAGE_MIN_MAX_BIT) { 2885 _mesa_update_minmax(ctx, n, (CONST GLfloat (*)[4]) rgba); 2886 } 2887 } 2888 2889 /* clamp to [0,1] */ 2890 if (clamp) { 2891 GLuint i; 2892 for (i = 0; i < n; i++) { 2893 rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F); 2894 rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F); 2895 rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F); 2896 rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F); 2897 } 2898 } 2899 2900 /* Now determine which color channels we need to produce. 2901 * And determine the dest index (offset) within each color tuple. 2902 */ 2903 switch (dstFormat) { 2904 case GL_ALPHA: 2905 dstAlphaIndex = 0; 2906 dstRedIndex = dstGreenIndex = dstBlueIndex = -1; 2907 dstLuminanceIndex = dstIntensityIndex = -1; 2908 break; 2909 case GL_LUMINANCE: 2910 dstLuminanceIndex = 0; 2911 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1; 2912 dstIntensityIndex = -1; 2913 break; 2914 case GL_LUMINANCE_ALPHA: 2915 dstLuminanceIndex = 0; 2916 dstAlphaIndex = 1; 2917 dstRedIndex = dstGreenIndex = dstBlueIndex = -1; 2918 dstIntensityIndex = -1; 2919 break; 2920 case GL_INTENSITY: 2921 dstIntensityIndex = 0; 2922 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1; 2923 dstLuminanceIndex = -1; 2924 break; 2925 case GL_RGB: 2926 dstRedIndex = 0; 2927 dstGreenIndex = 1; 2928 dstBlueIndex = 2; 2929 dstAlphaIndex = dstLuminanceIndex = dstIntensityIndex = -1; 2930 break; 2931 case GL_RGBA: 2932 dstRedIndex = 0; 2933 dstGreenIndex = 1; 2934 dstBlueIndex = 2; 2935 dstAlphaIndex = 3; 2936 dstLuminanceIndex = dstIntensityIndex = -1; 2937 break; 2938 default: 2939 gl_problem(ctx, "bad dstFormat in _mesa_unpack_float_color_span()"); 2940 return; 2941 } 2942 2943 /* Now pack results in the requested dstFormat */ 2944 if (dstRedIndex >= 0) { 2945 GLfloat *dst = dest; 2946 GLuint i; 2947 for (i = 0; i < n; i++) { 2948 dst[dstRedIndex] = rgba[i][RCOMP]; 2949 dst += dstComponents; 2950 } 2951 } 2952 2953 if (dstGreenIndex >= 0) { 2954 GLfloat *dst = dest; 2955 GLuint i; 2956 for (i = 0; i < n; i++) { 2957 dst[dstGreenIndex] = rgba[i][GCOMP]; 2958 dst += dstComponents; 2959 } 2960 } 2961 2962 if (dstBlueIndex >= 0) { 2963 GLfloat *dst = dest; 2964 GLuint i; 2965 for (i = 0; i < n; i++) { 2966 dst[dstBlueIndex] = rgba[i][BCOMP]; 2967 dst += dstComponents; 2968 } 2969 } 2970 2971 if (dstAlphaIndex >= 0) { 2972 GLfloat *dst = dest; 2973 GLuint i; 2974 for (i = 0; i < n; i++) { 2975 dst[dstAlphaIndex] = rgba[i][ACOMP]; 2976 dst += dstComponents; 2977 } 2978 } 2979 2980 if (dstIntensityIndex >= 0) { 2981 GLfloat *dst = dest; 2982 GLuint i; 2983 assert(dstIntensityIndex == 0); 2984 assert(dstComponents == 1); 2985 for (i = 0; i < n; i++) { 2986 /* Intensity comes from red channel */ 2987 dst[i] = rgba[i][RCOMP]; 2988 } 2989 } 2990 2991 if (dstLuminanceIndex >= 0) { 2992 GLfloat *dst = dest; 2993 GLuint i; 2994 assert(dstLuminanceIndex == 0); 2995 for (i = 0; i < n; i++) { 2996 /* Luminance comes from red channel */ 2997 dst[0] = rgba[i][RCOMP]; 2998 dst += dstComponents; 2999 } 3000 } 3001 } 3002} 3003 3004 3005 3006 3007/* 3008 * Unpack a row of color index data from a client buffer according to 3009 * the pixel unpacking parameters. 3010 * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc. 3011 * 3012 * Args: ctx - the context 3013 * n - number of pixels 3014 * dstType - destination datatype 3015 * dest - destination array 3016 * srcType - source pixel type 3017 * source - source data pointer 3018 * srcPacking - pixel unpacking parameters 3019 * transferOps - the pixel transfer operations to apply 3020 */ 3021void 3022_mesa_unpack_index_span( const GLcontext *ctx, GLuint n, 3023 GLenum dstType, GLvoid *dest, 3024 GLenum srcType, const GLvoid *source, 3025 const struct gl_pixelstore_attrib *srcPacking, 3026 GLuint transferOps ) 3027{ 3028 ASSERT(srcType == GL_BITMAP || 3029 srcType == GL_UNSIGNED_BYTE || 3030 srcType == GL_BYTE || 3031 srcType == GL_UNSIGNED_SHORT || 3032 srcType == GL_SHORT || 3033 srcType == GL_UNSIGNED_INT || 3034 srcType == GL_INT || 3035 srcType == GL_FLOAT); 3036 3037 ASSERT(dstType == GL_UNSIGNED_BYTE || 3038 dstType == GL_UNSIGNED_SHORT || 3039 dstType == GL_UNSIGNED_INT); 3040 3041 3042 transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT); 3043 3044 /* 3045 * Try simple cases first 3046 */ 3047 if (transferOps == 0 && srcType == GL_UNSIGNED_BYTE 3048 && dstType == GL_UNSIGNED_BYTE) { 3049 MEMCPY(dest, source, n * sizeof(GLubyte)); 3050 } 3051 else if (transferOps == 0 && srcType == GL_UNSIGNED_INT 3052 && dstType == GL_UNSIGNED_INT && !srcPacking->SwapBytes) { 3053 MEMCPY(dest, source, n * sizeof(GLuint)); 3054 } 3055 else { 3056 /* 3057 * general solution 3058 */ 3059 GLuint indexes[MAX_WIDTH]; 3060 assert(n <= MAX_WIDTH); 3061 3062 extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source, 3063 srcPacking); 3064 3065 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) { 3066 /* shift and offset indexes */ 3067 _mesa_shift_and_offset_ci(ctx, n, indexes); 3068 } 3069 if (transferOps & IMAGE_MAP_COLOR_BIT) { 3070 /* Apply lookup table */ 3071 _mesa_map_ci(ctx, n, indexes); 3072 } 3073 3074 /* convert to dest type */ 3075 switch (dstType) { 3076 case GL_UNSIGNED_BYTE: 3077 { 3078 GLubyte *dst = (GLubyte *) dest; 3079 GLuint i; 3080 for (i = 0; i < n; i++) { 3081 dst[i] = (GLubyte) (indexes[i] & 0xff); 3082 } 3083 } 3084 break; 3085 case GL_UNSIGNED_SHORT: 3086 { 3087 GLuint *dst = (GLuint *) dest; 3088 GLuint i; 3089 for (i = 0; i < n; i++) { 3090 dst[i] = (GLushort) (indexes[i] & 0xffff); 3091 } 3092 } 3093 break; 3094 case GL_UNSIGNED_INT: 3095 MEMCPY(dest, indexes, n * sizeof(GLuint)); 3096 break; 3097 default: 3098 gl_problem(ctx, "bad dstType in _mesa_unpack_index_span"); 3099 } 3100 } 3101} 3102 3103 3104/* 3105 * Unpack a row of stencil data from a client buffer according to 3106 * the pixel unpacking parameters. 3107 * This is (or will be) used by glDrawPixels 3108 * 3109 * Args: ctx - the context 3110 * n - number of pixels 3111 * dstType - destination datatype 3112 * dest - destination array 3113 * srcType - source pixel type 3114 * source - source data pointer 3115 * srcPacking - pixel unpacking parameters 3116 * transferOps - apply offset/bias/lookup ops? 3117 */ 3118void 3119_mesa_unpack_stencil_span( const GLcontext *ctx, GLuint n, 3120 GLenum dstType, GLvoid *dest, 3121 GLenum srcType, const GLvoid *source, 3122 const struct gl_pixelstore_attrib *srcPacking, 3123 GLuint transferOps ) 3124{ 3125 ASSERT(srcType == GL_BITMAP || 3126 srcType == GL_UNSIGNED_BYTE || 3127 srcType == GL_BYTE || 3128 srcType == GL_UNSIGNED_SHORT || 3129 srcType == GL_SHORT || 3130 srcType == GL_UNSIGNED_INT || 3131 srcType == GL_INT || 3132 srcType == GL_FLOAT); 3133 3134 ASSERT(dstType == GL_UNSIGNED_BYTE || 3135 dstType == GL_UNSIGNED_SHORT || 3136 dstType == GL_UNSIGNED_INT); 3137 3138 /* only shift and offset apply to stencil */ 3139 transferOps &= IMAGE_SHIFT_OFFSET_BIT; 3140 3141 /* 3142 * Try simple cases first 3143 */ 3144 if (transferOps == 0 && 3145 srcType == GL_UNSIGNED_BYTE && 3146 dstType == GL_UNSIGNED_BYTE) { 3147 MEMCPY(dest, source, n * sizeof(GLubyte)); 3148 } 3149 else if (transferOps == 0 && 3150 srcType == GL_UNSIGNED_INT && 3151 dstType == GL_UNSIGNED_INT && 3152 !srcPacking->SwapBytes) { 3153 MEMCPY(dest, source, n * sizeof(GLuint)); 3154 } 3155 else { 3156 /* 3157 * general solution 3158 */ 3159 GLuint indexes[MAX_WIDTH]; 3160 assert(n <= MAX_WIDTH); 3161 3162 extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source, 3163 srcPacking); 3164 3165 if (transferOps) { 3166 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) { 3167 /* shift and offset indexes */ 3168 _mesa_shift_and_offset_ci(ctx, n, indexes); 3169 } 3170 3171 if (ctx->Pixel.MapStencilFlag) { 3172 /* Apply stencil lookup table */ 3173 GLuint mask = ctx->Pixel.MapStoSsize - 1; 3174 GLuint i; 3175 for (i=0;i<n;i++) { 3176 indexes[i] = ctx->Pixel.MapStoS[ indexes[i] & mask ]; 3177 } 3178 } 3179 } 3180 3181 /* convert to dest type */ 3182 switch (dstType) { 3183 case GL_UNSIGNED_BYTE: 3184 { 3185 GLubyte *dst = (GLubyte *) dest; 3186 GLuint i; 3187 for (i = 0; i < n; i++) { 3188 dst[i] = (GLubyte) (indexes[i] & 0xff); 3189 } 3190 } 3191 break; 3192 case GL_UNSIGNED_SHORT: 3193 { 3194 GLuint *dst = (GLuint *) dest; 3195 GLuint i; 3196 for (i = 0; i < n; i++) { 3197 dst[i] = (GLushort) (indexes[i] & 0xffff); 3198 } 3199 } 3200 break; 3201 case GL_UNSIGNED_INT: 3202 MEMCPY(dest, indexes, n * sizeof(GLuint)); 3203 break; 3204 default: 3205 gl_problem(ctx, "bad dstType in _mesa_unpack_stencil_span"); 3206 } 3207 } 3208} 3209 3210 3211 3212void 3213_mesa_unpack_depth_span( const GLcontext *ctx, GLuint n, GLdepth *dest, 3214 GLenum srcType, const GLvoid *source, 3215 const struct gl_pixelstore_attrib *srcPacking, 3216 GLuint transferOps ) 3217{ 3218 GLfloat *depth = MALLOC(n * sizeof(GLfloat)); 3219 if (!depth) 3220 return; 3221 3222 switch (srcType) { 3223 case GL_BYTE: 3224 { 3225 GLuint i; 3226 const GLubyte *src = (const GLubyte *) source; 3227 for (i = 0; i < n; i++) { 3228 depth[i] = BYTE_TO_FLOAT(src[i]); 3229 } 3230 } 3231 break; 3232 case GL_UNSIGNED_BYTE: 3233 { 3234 GLuint i; 3235 const GLubyte *src = (const GLubyte *) source; 3236 for (i = 0; i < n; i++) { 3237 depth[i] = UBYTE_TO_FLOAT(src[i]); 3238 } 3239 } 3240 break; 3241 case GL_SHORT: 3242 { 3243 GLuint i; 3244 const GLshort *src = (const GLshort *) source; 3245 for (i = 0; i < n; i++) { 3246 depth[i] = SHORT_TO_FLOAT(src[i]); 3247 } 3248 } 3249 break; 3250 case GL_UNSIGNED_SHORT: 3251 { 3252 GLuint i; 3253 const GLushort *src = (const GLushort *) source; 3254 for (i = 0; i < n; i++) { 3255 depth[i] = USHORT_TO_FLOAT(src[i]); 3256 } 3257 } 3258 break; 3259 case GL_INT: 3260 { 3261 GLuint i; 3262 const GLint *src = (const GLint *) source; 3263 for (i = 0; i < n; i++) { 3264 depth[i] = INT_TO_FLOAT(src[i]); 3265 } 3266 } 3267 break; 3268 case GL_UNSIGNED_INT: 3269 { 3270 GLuint i; 3271 const GLuint *src = (const GLuint *) source; 3272 for (i = 0; i < n; i++) { 3273 depth[i] = UINT_TO_FLOAT(src[i]); 3274 } 3275 } 3276 break; 3277 case GL_FLOAT: 3278 MEMCPY(depth, source, n * sizeof(GLfloat)); 3279 break; 3280 default: 3281 gl_problem(NULL, "bad type in _mesa_unpack_depth_span()"); 3282 FREE(depth); 3283 return; 3284 } 3285 3286 3287 /* apply depth scale and bias */ 3288 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) { 3289 GLuint i; 3290 for (i = 0; i < n; i++) { 3291 depth[i] = depth[i] * ctx->Pixel.DepthScale + ctx->Pixel.DepthBias; 3292 } 3293 } 3294 3295 /* clamp depth values to [0,1] and convert from floats to integers */ 3296 { 3297 const GLfloat zs = ctx->Visual.DepthMaxF; 3298 GLuint i; 3299 for (i = 0; i < n; i++) { 3300 dest[i] = (GLdepth) (CLAMP(depth[i], 0.0F, 1.0F) * zs); 3301 } 3302 } 3303 3304 FREE(depth); 3305} 3306 3307 3308 3309/* 3310 * Unpack image data. Apply byteswapping, byte flipping (bitmap). 3311 * Return all image data in a contiguous block. 3312 */ 3313void * 3314_mesa_unpack_image( GLsizei width, GLsizei height, GLsizei depth, 3315 GLenum format, GLenum type, const GLvoid *pixels, 3316 const struct gl_pixelstore_attrib *unpack ) 3317{ 3318 GLint bytesPerRow, compsPerRow; 3319 GLboolean flipBytes, swap2, swap4; 3320 3321 if (!pixels) 3322 return NULL; /* not necessarily an error */ 3323 3324 if (width <= 0 || height <= 0 || depth <= 0) 3325 return NULL; /* generate error later */ 3326 3327 if (format == GL_BITMAP) { 3328 bytesPerRow = (width + 7) >> 3; 3329 flipBytes = !unpack->LsbFirst; 3330 swap2 = swap4 = GL_FALSE; 3331 compsPerRow = 0; 3332 } 3333 else { 3334 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type); 3335 const GLint components = _mesa_components_in_format(format); 3336 GLint bytesPerComp; 3337 if (bytesPerPixel <= 0 || components <= 0) 3338 return NULL; /* bad format or type. generate error later */ 3339 bytesPerRow = bytesPerPixel * width; 3340 bytesPerComp = bytesPerPixel / components; 3341 flipBytes = GL_FALSE; 3342 swap2 = (bytesPerComp == 2) && unpack->SwapBytes; 3343 swap4 = (bytesPerComp == 4) && unpack->SwapBytes; 3344 compsPerRow = components * width; 3345 assert(compsPerRow >= width); 3346 } 3347 3348 { 3349 GLubyte *destBuffer = MALLOC(bytesPerRow * height * depth); 3350 GLubyte *dst; 3351 GLint img, row; 3352 if (!destBuffer) 3353 return NULL; /* generate GL_OUT_OF_MEMORY later */ 3354 3355 dst = destBuffer; 3356 for (img = 0; img < depth; img++) { 3357 for (row = 0; row < height; row++) { 3358 const GLvoid *src = _mesa_image_address(unpack, pixels, 3359 width, height, format, type, img, row, 0); 3360 MEMCPY(dst, src, bytesPerRow); 3361 /* byte flipping/swapping */ 3362 if (flipBytes) { 3363 flip_bytes((GLubyte *) dst, bytesPerRow); 3364 } 3365 else if (swap2) { 3366 _mesa_swap2((GLushort*) dst, compsPerRow); 3367 } 3368 else if (swap4) { 3369 _mesa_swap4((GLuint*) dst, compsPerRow); 3370 } 3371 dst += bytesPerRow; 3372 } 3373 } 3374 return destBuffer; 3375 } 3376} 3377