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