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