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