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