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