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