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