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