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