image.c revision c7ac486261ad30ef654f6d0b1608da4e8483cd40
1/* 2 * Mesa 3-D graphics library 3 * Version: 7.5 4 * 5 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. 6 * Copyright (C) 2009 VMware, Inc. All Rights Reserved. 7 * 8 * Permission is hereby granted, free of charge, to any person obtaining a 9 * copy of this software and associated documentation files (the "Software"), 10 * to deal in the Software without restriction, including without limitation 11 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 12 * and/or sell copies of the Software, and to permit persons to whom the 13 * Software is furnished to do so, subject to the following conditions: 14 * 15 * The above copyright notice and this permission notice shall be included 16 * in all copies or substantial portions of the Software. 17 * 18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 21 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN 22 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 23 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 24 */ 25 26 27/** 28 * \file image.c 29 * Image handling. 30 */ 31 32 33#include "glheader.h" 34#include "colormac.h" 35#include "context.h" 36#include "enums.h" 37#include "image.h" 38#include "imports.h" 39#include "macros.h" 40 41 42/** 43 * NOTE: 44 * Normally, BYTE_TO_FLOAT(0) returns 0.00392 That causes problems when 45 * we later convert the float to a packed integer value (such as for 46 * GL_RGB5_A1) because we'll wind up with a non-zero value. 47 * 48 * We redefine the macros here so zero is handled correctly. 49 */ 50#undef BYTE_TO_FLOAT 51#define BYTE_TO_FLOAT(B) ((B) == 0 ? 0.0F : ((2.0F * (B) + 1.0F) * (1.0F/255.0F))) 52 53#undef SHORT_TO_FLOAT 54#define SHORT_TO_FLOAT(S) ((S) == 0 ? 0.0F : ((2.0F * (S) + 1.0F) * (1.0F/65535.0F))) 55 56 57 58/** Compute ceiling of integer quotient of A divided by B. */ 59#define CEILING( A, B ) ( (A) % (B) == 0 ? (A)/(B) : (A)/(B)+1 ) 60 61 62/** 63 * \return GL_TRUE if type is packed pixel type, GL_FALSE otherwise. 64 */ 65GLboolean 66_mesa_type_is_packed(GLenum type) 67{ 68 switch (type) { 69 case GL_UNSIGNED_BYTE_3_3_2: 70 case GL_UNSIGNED_BYTE_2_3_3_REV: 71 case GL_UNSIGNED_SHORT_5_6_5: 72 case GL_UNSIGNED_SHORT_5_6_5_REV: 73 case GL_UNSIGNED_SHORT_4_4_4_4: 74 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 75 case GL_UNSIGNED_SHORT_5_5_5_1: 76 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 77 case GL_UNSIGNED_INT_8_8_8_8: 78 case GL_UNSIGNED_INT_8_8_8_8_REV: 79 case GL_UNSIGNED_INT_10_10_10_2: 80 case GL_UNSIGNED_INT_2_10_10_10_REV: 81 case GL_UNSIGNED_SHORT_8_8_MESA: 82 case GL_UNSIGNED_SHORT_8_8_REV_MESA: 83 case GL_UNSIGNED_INT_24_8_EXT: 84 return GL_TRUE; 85 } 86 87 return GL_FALSE; 88} 89 90/** 91 * Flip the 8 bits in each byte of the given array. 92 * 93 * \param p array. 94 * \param n number of bytes. 95 * 96 * \todo try this trick to flip bytes someday: 97 * \code 98 * v = ((v & 0x55555555) << 1) | ((v >> 1) & 0x55555555); 99 * v = ((v & 0x33333333) << 2) | ((v >> 2) & 0x33333333); 100 * v = ((v & 0x0f0f0f0f) << 4) | ((v >> 4) & 0x0f0f0f0f); 101 * \endcode 102 */ 103static void 104flip_bytes( GLubyte *p, GLuint n ) 105{ 106 GLuint i, a, b; 107 for (i = 0; i < n; i++) { 108 b = (GLuint) p[i]; /* words are often faster than bytes */ 109 a = ((b & 0x01) << 7) | 110 ((b & 0x02) << 5) | 111 ((b & 0x04) << 3) | 112 ((b & 0x08) << 1) | 113 ((b & 0x10) >> 1) | 114 ((b & 0x20) >> 3) | 115 ((b & 0x40) >> 5) | 116 ((b & 0x80) >> 7); 117 p[i] = (GLubyte) a; 118 } 119} 120 121 122/** 123 * Flip the order of the 2 bytes in each word in the given array. 124 * 125 * \param p array. 126 * \param n number of words. 127 */ 128void 129_mesa_swap2( GLushort *p, GLuint n ) 130{ 131 GLuint i; 132 for (i = 0; i < n; i++) { 133 p[i] = (p[i] >> 8) | ((p[i] << 8) & 0xff00); 134 } 135} 136 137 138 139/* 140 * Flip the order of the 4 bytes in each word in the given array. 141 */ 142void 143_mesa_swap4( GLuint *p, GLuint n ) 144{ 145 GLuint i, a, b; 146 for (i = 0; i < n; i++) { 147 b = p[i]; 148 a = (b >> 24) 149 | ((b >> 8) & 0xff00) 150 | ((b << 8) & 0xff0000) 151 | ((b << 24) & 0xff000000); 152 p[i] = a; 153 } 154} 155 156 157/** 158 * Get the size of a GL data type. 159 * 160 * \param type GL data type. 161 * 162 * \return the size, in bytes, of the given data type, 0 if a GL_BITMAP, or -1 163 * if an invalid type enum. 164 */ 165GLint 166_mesa_sizeof_type( GLenum type ) 167{ 168 switch (type) { 169 case GL_BITMAP: 170 return 0; 171 case GL_UNSIGNED_BYTE: 172 return sizeof(GLubyte); 173 case GL_BYTE: 174 return sizeof(GLbyte); 175 case GL_UNSIGNED_SHORT: 176 return sizeof(GLushort); 177 case GL_SHORT: 178 return sizeof(GLshort); 179 case GL_UNSIGNED_INT: 180 return sizeof(GLuint); 181 case GL_INT: 182 return sizeof(GLint); 183 case GL_FLOAT: 184 return sizeof(GLfloat); 185 case GL_DOUBLE: 186 return sizeof(GLdouble); 187 case GL_HALF_FLOAT_ARB: 188 return sizeof(GLhalfARB); 189 default: 190 return -1; 191 } 192} 193 194 195/** 196 * Same as _mesa_sizeof_type() but also accepting the packed pixel 197 * format data types. 198 */ 199GLint 200_mesa_sizeof_packed_type( GLenum type ) 201{ 202 switch (type) { 203 case GL_BITMAP: 204 return 0; 205 case GL_UNSIGNED_BYTE: 206 return sizeof(GLubyte); 207 case GL_BYTE: 208 return sizeof(GLbyte); 209 case GL_UNSIGNED_SHORT: 210 return sizeof(GLushort); 211 case GL_SHORT: 212 return sizeof(GLshort); 213 case GL_UNSIGNED_INT: 214 return sizeof(GLuint); 215 case GL_INT: 216 return sizeof(GLint); 217 case GL_HALF_FLOAT_ARB: 218 return sizeof(GLhalfARB); 219 case GL_FLOAT: 220 return sizeof(GLfloat); 221 case GL_UNSIGNED_BYTE_3_3_2: 222 return sizeof(GLubyte); 223 case GL_UNSIGNED_BYTE_2_3_3_REV: 224 return sizeof(GLubyte); 225 case GL_UNSIGNED_SHORT_5_6_5: 226 return sizeof(GLushort); 227 case GL_UNSIGNED_SHORT_5_6_5_REV: 228 return sizeof(GLushort); 229 case GL_UNSIGNED_SHORT_4_4_4_4: 230 return sizeof(GLushort); 231 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 232 return sizeof(GLushort); 233 case GL_UNSIGNED_SHORT_5_5_5_1: 234 return sizeof(GLushort); 235 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 236 return sizeof(GLushort); 237 case GL_UNSIGNED_INT_8_8_8_8: 238 return sizeof(GLuint); 239 case GL_UNSIGNED_INT_8_8_8_8_REV: 240 return sizeof(GLuint); 241 case GL_UNSIGNED_INT_10_10_10_2: 242 return sizeof(GLuint); 243 case GL_UNSIGNED_INT_2_10_10_10_REV: 244 return sizeof(GLuint); 245 case GL_UNSIGNED_SHORT_8_8_MESA: 246 case GL_UNSIGNED_SHORT_8_8_REV_MESA: 247 return sizeof(GLushort); 248 case GL_UNSIGNED_INT_24_8_EXT: 249 return sizeof(GLuint); 250 default: 251 return -1; 252 } 253} 254 255 256/** 257 * Get the number of components in a pixel format. 258 * 259 * \param format pixel format. 260 * 261 * \return the number of components in the given format, or -1 if a bad format. 262 */ 263GLint 264_mesa_components_in_format( GLenum format ) 265{ 266 switch (format) { 267 case GL_COLOR_INDEX: 268 case GL_COLOR_INDEX1_EXT: 269 case GL_COLOR_INDEX2_EXT: 270 case GL_COLOR_INDEX4_EXT: 271 case GL_COLOR_INDEX8_EXT: 272 case GL_COLOR_INDEX12_EXT: 273 case GL_COLOR_INDEX16_EXT: 274 case GL_STENCIL_INDEX: 275 case GL_DEPTH_COMPONENT: 276 case GL_RED: 277 case GL_GREEN: 278 case GL_BLUE: 279 case GL_ALPHA: 280 case GL_LUMINANCE: 281 case GL_INTENSITY: 282 return 1; 283 case GL_LUMINANCE_ALPHA: 284 return 2; 285 case GL_RGB: 286 return 3; 287 case GL_RGBA: 288 return 4; 289 case GL_BGR: 290 return 3; 291 case GL_BGRA: 292 return 4; 293 case GL_ABGR_EXT: 294 return 4; 295 case GL_YCBCR_MESA: 296 return 2; 297 case GL_DEPTH_STENCIL_EXT: 298 return 2; 299 case GL_DUDV_ATI: 300 case GL_DU8DV8_ATI: 301 return 2; 302 default: 303 return -1; 304 } 305} 306 307 308/** 309 * Get the bytes per pixel of pixel format type pair. 310 * 311 * \param format pixel format. 312 * \param type pixel type. 313 * 314 * \return bytes per pixel, or -1 if a bad format or type was given. 315 */ 316GLint 317_mesa_bytes_per_pixel( GLenum format, GLenum type ) 318{ 319 GLint comps = _mesa_components_in_format( format ); 320 if (comps < 0) 321 return -1; 322 323 switch (type) { 324 case GL_BITMAP: 325 return 0; /* special case */ 326 case GL_BYTE: 327 case GL_UNSIGNED_BYTE: 328 return comps * sizeof(GLubyte); 329 case GL_SHORT: 330 case GL_UNSIGNED_SHORT: 331 return comps * sizeof(GLshort); 332 case GL_INT: 333 case GL_UNSIGNED_INT: 334 return comps * sizeof(GLint); 335 case GL_FLOAT: 336 return comps * sizeof(GLfloat); 337 case GL_HALF_FLOAT_ARB: 338 return comps * sizeof(GLhalfARB); 339 case GL_UNSIGNED_BYTE_3_3_2: 340 case GL_UNSIGNED_BYTE_2_3_3_REV: 341 if (format == GL_RGB || format == GL_BGR) 342 return sizeof(GLubyte); 343 else 344 return -1; /* error */ 345 case GL_UNSIGNED_SHORT_5_6_5: 346 case GL_UNSIGNED_SHORT_5_6_5_REV: 347 if (format == GL_RGB || format == GL_BGR) 348 return sizeof(GLushort); 349 else 350 return -1; /* error */ 351 case GL_UNSIGNED_SHORT_4_4_4_4: 352 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 353 case GL_UNSIGNED_SHORT_5_5_5_1: 354 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 355 if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT) 356 return sizeof(GLushort); 357 else 358 return -1; 359 case GL_UNSIGNED_INT_8_8_8_8: 360 case GL_UNSIGNED_INT_8_8_8_8_REV: 361 case GL_UNSIGNED_INT_10_10_10_2: 362 case GL_UNSIGNED_INT_2_10_10_10_REV: 363 if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT) 364 return sizeof(GLuint); 365 else 366 return -1; 367 case GL_UNSIGNED_SHORT_8_8_MESA: 368 case GL_UNSIGNED_SHORT_8_8_REV_MESA: 369 if (format == GL_YCBCR_MESA) 370 return sizeof(GLushort); 371 else 372 return -1; 373 case GL_UNSIGNED_INT_24_8_EXT: 374 if (format == GL_DEPTH_STENCIL_EXT) 375 return sizeof(GLuint); 376 else 377 return -1; 378 default: 379 return -1; 380 } 381} 382 383 384/** 385 * Test for a legal pixel format and type. 386 * 387 * \param format pixel format. 388 * \param type pixel type. 389 * 390 * \return GL_TRUE if the given pixel format and type are legal, or GL_FALSE 391 * otherwise. 392 */ 393GLboolean 394_mesa_is_legal_format_and_type( GLcontext *ctx, GLenum format, GLenum type ) 395{ 396 switch (format) { 397 case GL_COLOR_INDEX: 398 case GL_STENCIL_INDEX: 399 switch (type) { 400 case GL_BITMAP: 401 case GL_BYTE: 402 case GL_UNSIGNED_BYTE: 403 case GL_SHORT: 404 case GL_UNSIGNED_SHORT: 405 case GL_INT: 406 case GL_UNSIGNED_INT: 407 case GL_FLOAT: 408 return GL_TRUE; 409 case GL_HALF_FLOAT_ARB: 410 return ctx->Extensions.ARB_half_float_pixel; 411 default: 412 return GL_FALSE; 413 } 414 case GL_RED: 415 case GL_GREEN: 416 case GL_BLUE: 417 case GL_ALPHA: 418#if 0 /* not legal! see table 3.6 of the 1.5 spec */ 419 case GL_INTENSITY: 420#endif 421 case GL_LUMINANCE: 422 case GL_LUMINANCE_ALPHA: 423 case GL_DEPTH_COMPONENT: 424 switch (type) { 425 case GL_BYTE: 426 case GL_UNSIGNED_BYTE: 427 case GL_SHORT: 428 case GL_UNSIGNED_SHORT: 429 case GL_INT: 430 case GL_UNSIGNED_INT: 431 case GL_FLOAT: 432 return GL_TRUE; 433 case GL_HALF_FLOAT_ARB: 434 return ctx->Extensions.ARB_half_float_pixel; 435 default: 436 return GL_FALSE; 437 } 438 case GL_RGB: 439 switch (type) { 440 case GL_BYTE: 441 case GL_UNSIGNED_BYTE: 442 case GL_SHORT: 443 case GL_UNSIGNED_SHORT: 444 case GL_INT: 445 case GL_UNSIGNED_INT: 446 case GL_FLOAT: 447 case GL_UNSIGNED_BYTE_3_3_2: 448 case GL_UNSIGNED_BYTE_2_3_3_REV: 449 case GL_UNSIGNED_SHORT_5_6_5: 450 case GL_UNSIGNED_SHORT_5_6_5_REV: 451 return GL_TRUE; 452 case GL_HALF_FLOAT_ARB: 453 return ctx->Extensions.ARB_half_float_pixel; 454 default: 455 return GL_FALSE; 456 } 457 case GL_BGR: 458 switch (type) { 459 /* NOTE: no packed types are supported with BGR. That's 460 * intentional, according to the GL spec. 461 */ 462 case GL_BYTE: 463 case GL_UNSIGNED_BYTE: 464 case GL_SHORT: 465 case GL_UNSIGNED_SHORT: 466 case GL_INT: 467 case GL_UNSIGNED_INT: 468 case GL_FLOAT: 469 return GL_TRUE; 470 case GL_HALF_FLOAT_ARB: 471 return ctx->Extensions.ARB_half_float_pixel; 472 default: 473 return GL_FALSE; 474 } 475 case GL_RGBA: 476 case GL_BGRA: 477 case GL_ABGR_EXT: 478 switch (type) { 479 case GL_BYTE: 480 case GL_UNSIGNED_BYTE: 481 case GL_SHORT: 482 case GL_UNSIGNED_SHORT: 483 case GL_INT: 484 case GL_UNSIGNED_INT: 485 case GL_FLOAT: 486 case GL_UNSIGNED_SHORT_4_4_4_4: 487 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 488 case GL_UNSIGNED_SHORT_5_5_5_1: 489 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 490 case GL_UNSIGNED_INT_8_8_8_8: 491 case GL_UNSIGNED_INT_8_8_8_8_REV: 492 case GL_UNSIGNED_INT_10_10_10_2: 493 case GL_UNSIGNED_INT_2_10_10_10_REV: 494 return GL_TRUE; 495 case GL_HALF_FLOAT_ARB: 496 return ctx->Extensions.ARB_half_float_pixel; 497 default: 498 return GL_FALSE; 499 } 500 case GL_YCBCR_MESA: 501 if (type == GL_UNSIGNED_SHORT_8_8_MESA || 502 type == GL_UNSIGNED_SHORT_8_8_REV_MESA) 503 return GL_TRUE; 504 else 505 return GL_FALSE; 506 case GL_DEPTH_STENCIL_EXT: 507 if (ctx->Extensions.EXT_packed_depth_stencil 508 && type == GL_UNSIGNED_INT_24_8_EXT) 509 return GL_TRUE; 510 else 511 return GL_FALSE; 512 case GL_DUDV_ATI: 513 case GL_DU8DV8_ATI: 514 switch (type) { 515 case GL_BYTE: 516 case GL_UNSIGNED_BYTE: 517 case GL_SHORT: 518 case GL_UNSIGNED_SHORT: 519 case GL_INT: 520 case GL_UNSIGNED_INT: 521 case GL_FLOAT: 522 return GL_TRUE; 523 default: 524 return GL_FALSE; 525 } 526 default: 527 ; /* fall-through */ 528 } 529 return GL_FALSE; 530} 531 532 533/** 534 * Test if the given image format is a color/RGBA format (i.e., not color 535 * index, depth, stencil, etc). 536 * \param format the image format value (may by an internal texture format) 537 * \return GL_TRUE if its a color/RGBA format, GL_FALSE otherwise. 538 */ 539GLboolean 540_mesa_is_color_format(GLenum format) 541{ 542 switch (format) { 543 case GL_RED: 544 case GL_GREEN: 545 case GL_BLUE: 546 case GL_ALPHA: 547 case GL_ALPHA4: 548 case GL_ALPHA8: 549 case GL_ALPHA12: 550 case GL_ALPHA16: 551 case 1: 552 case GL_LUMINANCE: 553 case GL_LUMINANCE4: 554 case GL_LUMINANCE8: 555 case GL_LUMINANCE12: 556 case GL_LUMINANCE16: 557 case 2: 558 case GL_LUMINANCE_ALPHA: 559 case GL_LUMINANCE4_ALPHA4: 560 case GL_LUMINANCE6_ALPHA2: 561 case GL_LUMINANCE8_ALPHA8: 562 case GL_LUMINANCE12_ALPHA4: 563 case GL_LUMINANCE12_ALPHA12: 564 case GL_LUMINANCE16_ALPHA16: 565 case GL_INTENSITY: 566 case GL_INTENSITY4: 567 case GL_INTENSITY8: 568 case GL_INTENSITY12: 569 case GL_INTENSITY16: 570 case 3: 571 case GL_RGB: 572 case GL_BGR: 573 case GL_R3_G3_B2: 574 case GL_RGB4: 575 case GL_RGB5: 576 case GL_RGB8: 577 case GL_RGB10: 578 case GL_RGB12: 579 case GL_RGB16: 580 case 4: 581 case GL_ABGR_EXT: 582 case GL_RGBA: 583 case GL_BGRA: 584 case GL_RGBA2: 585 case GL_RGBA4: 586 case GL_RGB5_A1: 587 case GL_RGBA8: 588 case GL_RGB10_A2: 589 case GL_RGBA12: 590 case GL_RGBA16: 591 /* float texture formats */ 592 case GL_ALPHA16F_ARB: 593 case GL_ALPHA32F_ARB: 594 case GL_LUMINANCE16F_ARB: 595 case GL_LUMINANCE32F_ARB: 596 case GL_LUMINANCE_ALPHA16F_ARB: 597 case GL_LUMINANCE_ALPHA32F_ARB: 598 case GL_INTENSITY16F_ARB: 599 case GL_INTENSITY32F_ARB: 600 case GL_RGB16F_ARB: 601 case GL_RGB32F_ARB: 602 case GL_RGBA16F_ARB: 603 case GL_RGBA32F_ARB: 604 /* compressed formats */ 605 case GL_COMPRESSED_ALPHA: 606 case GL_COMPRESSED_LUMINANCE: 607 case GL_COMPRESSED_LUMINANCE_ALPHA: 608 case GL_COMPRESSED_INTENSITY: 609 case GL_COMPRESSED_RGB: 610 case GL_COMPRESSED_RGBA: 611 case GL_RGB_S3TC: 612 case GL_RGB4_S3TC: 613 case GL_RGBA_S3TC: 614 case GL_RGBA4_S3TC: 615 case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: 616 case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: 617 case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: 618 case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: 619 case GL_COMPRESSED_RGB_FXT1_3DFX: 620 case GL_COMPRESSED_RGBA_FXT1_3DFX: 621#if FEATURE_EXT_texture_sRGB 622 case GL_SRGB_EXT: 623 case GL_SRGB8_EXT: 624 case GL_SRGB_ALPHA_EXT: 625 case GL_SRGB8_ALPHA8_EXT: 626 case GL_SLUMINANCE_ALPHA_EXT: 627 case GL_SLUMINANCE8_ALPHA8_EXT: 628 case GL_SLUMINANCE_EXT: 629 case GL_SLUMINANCE8_EXT: 630 case GL_COMPRESSED_SRGB_EXT: 631 case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT: 632 case GL_COMPRESSED_SRGB_ALPHA_EXT: 633 case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: 634 case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: 635 case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: 636 case GL_COMPRESSED_SLUMINANCE_EXT: 637 case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT: 638#endif /* FEATURE_EXT_texture_sRGB */ 639 return GL_TRUE; 640 /* signed texture formats */ 641 case GL_RGBA_SNORM: 642 case GL_RGBA8_SNORM: 643 return GL_TRUE; 644 case GL_YCBCR_MESA: /* not considered to be RGB */ 645 /* fall-through */ 646 default: 647 return GL_FALSE; 648 } 649} 650 651 652/** 653 * Test if the given image format is a color index format. 654 */ 655GLboolean 656_mesa_is_index_format(GLenum format) 657{ 658 switch (format) { 659 case GL_COLOR_INDEX: 660 case GL_COLOR_INDEX1_EXT: 661 case GL_COLOR_INDEX2_EXT: 662 case GL_COLOR_INDEX4_EXT: 663 case GL_COLOR_INDEX8_EXT: 664 case GL_COLOR_INDEX12_EXT: 665 case GL_COLOR_INDEX16_EXT: 666 return GL_TRUE; 667 default: 668 return GL_FALSE; 669 } 670} 671 672 673/** 674 * Test if the given image format is a depth component format. 675 */ 676GLboolean 677_mesa_is_depth_format(GLenum format) 678{ 679 switch (format) { 680 case GL_DEPTH_COMPONENT: 681 case GL_DEPTH_COMPONENT16: 682 case GL_DEPTH_COMPONENT24: 683 case GL_DEPTH_COMPONENT32: 684 return GL_TRUE; 685 default: 686 return GL_FALSE; 687 } 688} 689 690 691/** 692 * Test if the given image format is a stencil format. 693 */ 694GLboolean 695_mesa_is_stencil_format(GLenum format) 696{ 697 switch (format) { 698 case GL_STENCIL_INDEX: 699 case GL_DEPTH_STENCIL: 700 return GL_TRUE; 701 default: 702 return GL_FALSE; 703 } 704} 705 706 707/** 708 * Test if the given image format is a YCbCr format. 709 */ 710GLboolean 711_mesa_is_ycbcr_format(GLenum format) 712{ 713 switch (format) { 714 case GL_YCBCR_MESA: 715 return GL_TRUE; 716 default: 717 return GL_FALSE; 718 } 719} 720 721 722/** 723 * Test if the given image format is a depth+stencil format. 724 */ 725GLboolean 726_mesa_is_depthstencil_format(GLenum format) 727{ 728 switch (format) { 729 case GL_DEPTH24_STENCIL8_EXT: 730 case GL_DEPTH_STENCIL_EXT: 731 return GL_TRUE; 732 default: 733 return GL_FALSE; 734 } 735} 736 737/** 738 * Test if the given image format is a dudv format. 739 */ 740GLboolean 741_mesa_is_dudv_format(GLenum format) 742{ 743 switch (format) { 744 case GL_DUDV_ATI: 745 case GL_DU8DV8_ATI: 746 return GL_TRUE; 747 default: 748 return GL_FALSE; 749 } 750} 751 752 753/** 754 * Return the address of a specific pixel in an image (1D, 2D or 3D). 755 * 756 * Pixel unpacking/packing parameters are observed according to \p packing. 757 * 758 * \param dimensions either 1, 2 or 3 to indicate dimensionality of image 759 * \param image starting address of image data 760 * \param width the image width 761 * \param height theimage height 762 * \param format the pixel format 763 * \param type the pixel data type 764 * \param packing the pixelstore attributes 765 * \param img which image in the volume (0 for 1D or 2D images) 766 * \param row row of pixel in the image (0 for 1D images) 767 * \param column column of pixel in the image 768 * 769 * \return address of pixel on success, or NULL on error. 770 * 771 * \sa gl_pixelstore_attrib. 772 */ 773GLvoid * 774_mesa_image_address( GLuint dimensions, 775 const struct gl_pixelstore_attrib *packing, 776 const GLvoid *image, 777 GLsizei width, GLsizei height, 778 GLenum format, GLenum type, 779 GLint img, GLint row, GLint column ) 780{ 781 GLint alignment; /* 1, 2 or 4 */ 782 GLint pixels_per_row; 783 GLint rows_per_image; 784 GLint skiprows; 785 GLint skippixels; 786 GLint skipimages; /* for 3-D volume images */ 787 GLubyte *pixel_addr; 788 789 ASSERT(dimensions >= 1 && dimensions <= 3); 790 791 alignment = packing->Alignment; 792 if (packing->RowLength > 0) { 793 pixels_per_row = packing->RowLength; 794 } 795 else { 796 pixels_per_row = width; 797 } 798 if (packing->ImageHeight > 0) { 799 rows_per_image = packing->ImageHeight; 800 } 801 else { 802 rows_per_image = height; 803 } 804 805 skippixels = packing->SkipPixels; 806 /* Note: SKIP_ROWS _is_ used for 1D images */ 807 skiprows = packing->SkipRows; 808 /* Note: SKIP_IMAGES is only used for 3D images */ 809 skipimages = (dimensions == 3) ? packing->SkipImages : 0; 810 811 if (type == GL_BITMAP) { 812 /* BITMAP data */ 813 GLint comp_per_pixel; /* components per pixel */ 814 GLint bytes_per_comp; /* bytes per component */ 815 GLint bytes_per_row; 816 GLint bytes_per_image; 817 818 /* Compute bytes per component */ 819 bytes_per_comp = _mesa_sizeof_packed_type( type ); 820 if (bytes_per_comp < 0) { 821 return NULL; 822 } 823 824 /* Compute number of components per pixel */ 825 comp_per_pixel = _mesa_components_in_format( format ); 826 if (comp_per_pixel < 0) { 827 return NULL; 828 } 829 830 bytes_per_row = alignment 831 * CEILING( comp_per_pixel*pixels_per_row, 8*alignment ); 832 833 bytes_per_image = bytes_per_row * rows_per_image; 834 835 pixel_addr = (GLubyte *) image 836 + (skipimages + img) * bytes_per_image 837 + (skiprows + row) * bytes_per_row 838 + (skippixels + column) / 8; 839 } 840 else { 841 /* Non-BITMAP data */ 842 GLint bytes_per_pixel, bytes_per_row, remainder, bytes_per_image; 843 GLint topOfImage; 844 845 bytes_per_pixel = _mesa_bytes_per_pixel( format, type ); 846 847 /* The pixel type and format should have been error checked earlier */ 848 assert(bytes_per_pixel > 0); 849 850 bytes_per_row = pixels_per_row * bytes_per_pixel; 851 remainder = bytes_per_row % alignment; 852 if (remainder > 0) 853 bytes_per_row += (alignment - remainder); 854 855 ASSERT(bytes_per_row % alignment == 0); 856 857 bytes_per_image = bytes_per_row * rows_per_image; 858 859 if (packing->Invert) { 860 /* set pixel_addr to the last row */ 861 topOfImage = bytes_per_row * (height - 1); 862 bytes_per_row = -bytes_per_row; 863 } 864 else { 865 topOfImage = 0; 866 } 867 868 /* compute final pixel address */ 869 pixel_addr = (GLubyte *) image 870 + (skipimages + img) * bytes_per_image 871 + topOfImage 872 + (skiprows + row) * bytes_per_row 873 + (skippixels + column) * bytes_per_pixel; 874 } 875 876 return (GLvoid *) pixel_addr; 877} 878 879 880GLvoid * 881_mesa_image_address1d( const struct gl_pixelstore_attrib *packing, 882 const GLvoid *image, 883 GLsizei width, 884 GLenum format, GLenum type, 885 GLint column ) 886{ 887 return _mesa_image_address(1, packing, image, width, 1, 888 format, type, 0, 0, column); 889} 890 891 892GLvoid * 893_mesa_image_address2d( const struct gl_pixelstore_attrib *packing, 894 const GLvoid *image, 895 GLsizei width, GLsizei height, 896 GLenum format, GLenum type, 897 GLint row, GLint column ) 898{ 899 return _mesa_image_address(2, packing, image, width, height, 900 format, type, 0, row, column); 901} 902 903 904GLvoid * 905_mesa_image_address3d( const struct gl_pixelstore_attrib *packing, 906 const GLvoid *image, 907 GLsizei width, GLsizei height, 908 GLenum format, GLenum type, 909 GLint img, GLint row, GLint column ) 910{ 911 return _mesa_image_address(3, packing, image, width, height, 912 format, type, img, row, column); 913} 914 915 916 917/** 918 * Compute the stride (in bytes) between image rows. 919 * 920 * \param packing the pixelstore attributes 921 * \param width image width. 922 * \param format pixel format. 923 * \param type pixel data type. 924 * 925 * \return the stride in bytes for the given parameters, or -1 if error 926 */ 927GLint 928_mesa_image_row_stride( const struct gl_pixelstore_attrib *packing, 929 GLint width, GLenum format, GLenum type ) 930{ 931 GLint bytesPerRow, remainder; 932 933 ASSERT(packing); 934 935 if (type == GL_BITMAP) { 936 if (packing->RowLength == 0) { 937 bytesPerRow = (width + 7) / 8; 938 } 939 else { 940 bytesPerRow = (packing->RowLength + 7) / 8; 941 } 942 } 943 else { 944 /* Non-BITMAP data */ 945 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type); 946 if (bytesPerPixel <= 0) 947 return -1; /* error */ 948 if (packing->RowLength == 0) { 949 bytesPerRow = bytesPerPixel * width; 950 } 951 else { 952 bytesPerRow = bytesPerPixel * packing->RowLength; 953 } 954 } 955 956 remainder = bytesPerRow % packing->Alignment; 957 if (remainder > 0) { 958 bytesPerRow += (packing->Alignment - remainder); 959 } 960 961 if (packing->Invert) { 962 /* negate the bytes per row (negative row stride) */ 963 bytesPerRow = -bytesPerRow; 964 } 965 966 return bytesPerRow; 967} 968 969 970#if _HAVE_FULL_GL 971 972/* 973 * Compute the stride between images in a 3D texture (in bytes) for the given 974 * pixel packing parameters and image width, format and type. 975 */ 976GLint 977_mesa_image_image_stride( const struct gl_pixelstore_attrib *packing, 978 GLint width, GLint height, 979 GLenum format, GLenum type ) 980{ 981 GLint bytesPerRow, bytesPerImage, remainder; 982 983 ASSERT(packing); 984 985 if (type == GL_BITMAP) { 986 if (packing->RowLength == 0) { 987 bytesPerRow = (width + 7) / 8; 988 } 989 else { 990 bytesPerRow = (packing->RowLength + 7) / 8; 991 } 992 } 993 else { 994 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type); 995 996 if (bytesPerPixel <= 0) 997 return -1; /* error */ 998 if (packing->RowLength == 0) { 999 bytesPerRow = bytesPerPixel * width; 1000 } 1001 else { 1002 bytesPerRow = bytesPerPixel * packing->RowLength; 1003 } 1004 } 1005 1006 remainder = bytesPerRow % packing->Alignment; 1007 if (remainder > 0) 1008 bytesPerRow += (packing->Alignment - remainder); 1009 1010 if (packing->ImageHeight == 0) 1011 bytesPerImage = bytesPerRow * height; 1012 else 1013 bytesPerImage = bytesPerRow * packing->ImageHeight; 1014 1015 return bytesPerImage; 1016} 1017 1018 1019/* 1020 * Unpack a 32x32 pixel polygon stipple from user memory using the 1021 * current pixel unpack settings. 1022 */ 1023void 1024_mesa_unpack_polygon_stipple( const GLubyte *pattern, GLuint dest[32], 1025 const struct gl_pixelstore_attrib *unpacking ) 1026{ 1027 GLubyte *ptrn = (GLubyte *) _mesa_unpack_bitmap(32, 32, pattern, unpacking); 1028 if (ptrn) { 1029 /* Convert pattern from GLubytes to GLuints and handle big/little 1030 * endian differences 1031 */ 1032 GLubyte *p = ptrn; 1033 GLint i; 1034 for (i = 0; i < 32; i++) { 1035 dest[i] = (p[0] << 24) 1036 | (p[1] << 16) 1037 | (p[2] << 8) 1038 | (p[3] ); 1039 p += 4; 1040 } 1041 _mesa_free(ptrn); 1042 } 1043} 1044 1045 1046/* 1047 * Pack polygon stipple into user memory given current pixel packing 1048 * settings. 1049 */ 1050void 1051_mesa_pack_polygon_stipple( const GLuint pattern[32], GLubyte *dest, 1052 const struct gl_pixelstore_attrib *packing ) 1053{ 1054 /* Convert pattern from GLuints to GLubytes to handle big/little 1055 * endian differences. 1056 */ 1057 GLubyte ptrn[32*4]; 1058 GLint i; 1059 for (i = 0; i < 32; i++) { 1060 ptrn[i * 4 + 0] = (GLubyte) ((pattern[i] >> 24) & 0xff); 1061 ptrn[i * 4 + 1] = (GLubyte) ((pattern[i] >> 16) & 0xff); 1062 ptrn[i * 4 + 2] = (GLubyte) ((pattern[i] >> 8 ) & 0xff); 1063 ptrn[i * 4 + 3] = (GLubyte) ((pattern[i] ) & 0xff); 1064 } 1065 1066 _mesa_pack_bitmap(32, 32, ptrn, dest, packing); 1067} 1068 1069 1070/* 1071 * Unpack bitmap data. Resulting data will be in most-significant-bit-first 1072 * order with row alignment = 1 byte. 1073 */ 1074GLvoid * 1075_mesa_unpack_bitmap( GLint width, GLint height, const GLubyte *pixels, 1076 const struct gl_pixelstore_attrib *packing ) 1077{ 1078 GLint bytes, row, width_in_bytes; 1079 GLubyte *buffer, *dst; 1080 1081 if (!pixels) 1082 return NULL; 1083 1084 /* Alloc dest storage */ 1085 bytes = ((width + 7) / 8 * height); 1086 buffer = (GLubyte *) _mesa_malloc( bytes ); 1087 if (!buffer) 1088 return NULL; 1089 1090 width_in_bytes = CEILING( width, 8 ); 1091 dst = buffer; 1092 for (row = 0; row < height; row++) { 1093 const GLubyte *src = (const GLubyte *) 1094 _mesa_image_address2d(packing, pixels, width, height, 1095 GL_COLOR_INDEX, GL_BITMAP, row, 0); 1096 if (!src) { 1097 _mesa_free(buffer); 1098 return NULL; 1099 } 1100 1101 if ((packing->SkipPixels & 7) == 0) { 1102 memcpy( dst, src, width_in_bytes ); 1103 if (packing->LsbFirst) { 1104 flip_bytes( dst, width_in_bytes ); 1105 } 1106 } 1107 else { 1108 /* handling SkipPixels is a bit tricky (no pun intended!) */ 1109 GLint i; 1110 if (packing->LsbFirst) { 1111 GLubyte srcMask = 1 << (packing->SkipPixels & 0x7); 1112 GLubyte dstMask = 128; 1113 const GLubyte *s = src; 1114 GLubyte *d = dst; 1115 *d = 0; 1116 for (i = 0; i < width; i++) { 1117 if (*s & srcMask) { 1118 *d |= dstMask; 1119 } 1120 if (srcMask == 128) { 1121 srcMask = 1; 1122 s++; 1123 } 1124 else { 1125 srcMask = srcMask << 1; 1126 } 1127 if (dstMask == 1) { 1128 dstMask = 128; 1129 d++; 1130 *d = 0; 1131 } 1132 else { 1133 dstMask = dstMask >> 1; 1134 } 1135 } 1136 } 1137 else { 1138 GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7); 1139 GLubyte dstMask = 128; 1140 const GLubyte *s = src; 1141 GLubyte *d = dst; 1142 *d = 0; 1143 for (i = 0; i < width; i++) { 1144 if (*s & srcMask) { 1145 *d |= dstMask; 1146 } 1147 if (srcMask == 1) { 1148 srcMask = 128; 1149 s++; 1150 } 1151 else { 1152 srcMask = srcMask >> 1; 1153 } 1154 if (dstMask == 1) { 1155 dstMask = 128; 1156 d++; 1157 *d = 0; 1158 } 1159 else { 1160 dstMask = dstMask >> 1; 1161 } 1162 } 1163 } 1164 } 1165 dst += width_in_bytes; 1166 } 1167 1168 return buffer; 1169} 1170 1171 1172/* 1173 * Pack bitmap data. 1174 */ 1175void 1176_mesa_pack_bitmap( GLint width, GLint height, const GLubyte *source, 1177 GLubyte *dest, const struct gl_pixelstore_attrib *packing ) 1178{ 1179 GLint row, width_in_bytes; 1180 const GLubyte *src; 1181 1182 if (!source) 1183 return; 1184 1185 width_in_bytes = CEILING( width, 8 ); 1186 src = source; 1187 for (row = 0; row < height; row++) { 1188 GLubyte *dst = (GLubyte *) _mesa_image_address2d(packing, dest, 1189 width, height, GL_COLOR_INDEX, GL_BITMAP, row, 0); 1190 if (!dst) 1191 return; 1192 1193 if ((packing->SkipPixels & 7) == 0) { 1194 memcpy( dst, src, width_in_bytes ); 1195 if (packing->LsbFirst) { 1196 flip_bytes( dst, width_in_bytes ); 1197 } 1198 } 1199 else { 1200 /* handling SkipPixels is a bit tricky (no pun intended!) */ 1201 GLint i; 1202 if (packing->LsbFirst) { 1203 GLubyte srcMask = 128; 1204 GLubyte dstMask = 1 << (packing->SkipPixels & 0x7); 1205 const GLubyte *s = src; 1206 GLubyte *d = dst; 1207 *d = 0; 1208 for (i = 0; i < width; i++) { 1209 if (*s & srcMask) { 1210 *d |= dstMask; 1211 } 1212 if (srcMask == 1) { 1213 srcMask = 128; 1214 s++; 1215 } 1216 else { 1217 srcMask = srcMask >> 1; 1218 } 1219 if (dstMask == 128) { 1220 dstMask = 1; 1221 d++; 1222 *d = 0; 1223 } 1224 else { 1225 dstMask = dstMask << 1; 1226 } 1227 } 1228 } 1229 else { 1230 GLubyte srcMask = 128; 1231 GLubyte dstMask = 128 >> (packing->SkipPixels & 0x7); 1232 const GLubyte *s = src; 1233 GLubyte *d = dst; 1234 *d = 0; 1235 for (i = 0; i < width; i++) { 1236 if (*s & srcMask) { 1237 *d |= dstMask; 1238 } 1239 if (srcMask == 1) { 1240 srcMask = 128; 1241 s++; 1242 } 1243 else { 1244 srcMask = srcMask >> 1; 1245 } 1246 if (dstMask == 1) { 1247 dstMask = 128; 1248 d++; 1249 *d = 0; 1250 } 1251 else { 1252 dstMask = dstMask >> 1; 1253 } 1254 } 1255 } 1256 } 1257 src += width_in_bytes; 1258 } 1259} 1260 1261 1262/** 1263 * "Expand" a bitmap from 1-bit per pixel to 8-bits per pixel. 1264 * This is typically used to convert a bitmap into a GLubyte/pixel texture. 1265 * "On" bits will set texels to \p onValue. 1266 * "Off" bits will not modify texels. 1267 * \param width src bitmap width in pixels 1268 * \param height src bitmap height in pixels 1269 * \param unpack bitmap unpacking state 1270 * \param bitmap the src bitmap data 1271 * \param destBuffer start of dest buffer 1272 * \param destStride row stride in dest buffer 1273 * \param onValue if bit is 1, set destBuffer pixel to this value 1274 */ 1275void 1276_mesa_expand_bitmap(GLsizei width, GLsizei height, 1277 const struct gl_pixelstore_attrib *unpack, 1278 const GLubyte *bitmap, 1279 GLubyte *destBuffer, GLint destStride, 1280 GLubyte onValue) 1281{ 1282 const GLubyte *srcRow = (const GLubyte *) 1283 _mesa_image_address2d(unpack, bitmap, width, height, 1284 GL_COLOR_INDEX, GL_BITMAP, 0, 0); 1285 const GLint srcStride = _mesa_image_row_stride(unpack, width, 1286 GL_COLOR_INDEX, GL_BITMAP); 1287 GLint row, col; 1288 1289#define SET_PIXEL(COL, ROW) \ 1290 destBuffer[(ROW) * destStride + (COL)] = onValue; 1291 1292 for (row = 0; row < height; row++) { 1293 const GLubyte *src = srcRow; 1294 1295 if (unpack->LsbFirst) { 1296 /* Lsb first */ 1297 GLubyte mask = 1U << (unpack->SkipPixels & 0x7); 1298 for (col = 0; col < width; col++) { 1299 1300 if (*src & mask) { 1301 SET_PIXEL(col, row); 1302 } 1303 1304 if (mask == 128U) { 1305 src++; 1306 mask = 1U; 1307 } 1308 else { 1309 mask = mask << 1; 1310 } 1311 } 1312 1313 /* get ready for next row */ 1314 if (mask != 1) 1315 src++; 1316 } 1317 else { 1318 /* Msb first */ 1319 GLubyte mask = 128U >> (unpack->SkipPixels & 0x7); 1320 for (col = 0; col < width; col++) { 1321 1322 if (*src & mask) { 1323 SET_PIXEL(col, row); 1324 } 1325 1326 if (mask == 1U) { 1327 src++; 1328 mask = 128U; 1329 } 1330 else { 1331 mask = mask >> 1; 1332 } 1333 } 1334 1335 /* get ready for next row */ 1336 if (mask != 128) 1337 src++; 1338 } 1339 1340 srcRow += srcStride; 1341 } /* row */ 1342 1343#undef SET_PIXEL 1344} 1345 1346 1347/**********************************************************************/ 1348/***** Pixel processing functions ******/ 1349/**********************************************************************/ 1350 1351/* 1352 * Apply scale and bias factors to an array of RGBA pixels. 1353 */ 1354void 1355_mesa_scale_and_bias_rgba(GLuint n, GLfloat rgba[][4], 1356 GLfloat rScale, GLfloat gScale, 1357 GLfloat bScale, GLfloat aScale, 1358 GLfloat rBias, GLfloat gBias, 1359 GLfloat bBias, GLfloat aBias) 1360{ 1361 if (rScale != 1.0 || rBias != 0.0) { 1362 GLuint i; 1363 for (i = 0; i < n; i++) { 1364 rgba[i][RCOMP] = rgba[i][RCOMP] * rScale + rBias; 1365 } 1366 } 1367 if (gScale != 1.0 || gBias != 0.0) { 1368 GLuint i; 1369 for (i = 0; i < n; i++) { 1370 rgba[i][GCOMP] = rgba[i][GCOMP] * gScale + gBias; 1371 } 1372 } 1373 if (bScale != 1.0 || bBias != 0.0) { 1374 GLuint i; 1375 for (i = 0; i < n; i++) { 1376 rgba[i][BCOMP] = rgba[i][BCOMP] * bScale + bBias; 1377 } 1378 } 1379 if (aScale != 1.0 || aBias != 0.0) { 1380 GLuint i; 1381 for (i = 0; i < n; i++) { 1382 rgba[i][ACOMP] = rgba[i][ACOMP] * aScale + aBias; 1383 } 1384 } 1385} 1386 1387 1388/* 1389 * Apply pixel mapping to an array of floating point RGBA pixels. 1390 */ 1391void 1392_mesa_map_rgba( const GLcontext *ctx, GLuint n, GLfloat rgba[][4] ) 1393{ 1394 const GLfloat rscale = (GLfloat) (ctx->PixelMaps.RtoR.Size - 1); 1395 const GLfloat gscale = (GLfloat) (ctx->PixelMaps.GtoG.Size - 1); 1396 const GLfloat bscale = (GLfloat) (ctx->PixelMaps.BtoB.Size - 1); 1397 const GLfloat ascale = (GLfloat) (ctx->PixelMaps.AtoA.Size - 1); 1398 const GLfloat *rMap = ctx->PixelMaps.RtoR.Map; 1399 const GLfloat *gMap = ctx->PixelMaps.GtoG.Map; 1400 const GLfloat *bMap = ctx->PixelMaps.BtoB.Map; 1401 const GLfloat *aMap = ctx->PixelMaps.AtoA.Map; 1402 GLuint i; 1403 for (i=0;i<n;i++) { 1404 GLfloat r = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F); 1405 GLfloat g = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F); 1406 GLfloat b = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F); 1407 GLfloat a = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F); 1408 rgba[i][RCOMP] = rMap[IROUND(r * rscale)]; 1409 rgba[i][GCOMP] = gMap[IROUND(g * gscale)]; 1410 rgba[i][BCOMP] = bMap[IROUND(b * bscale)]; 1411 rgba[i][ACOMP] = aMap[IROUND(a * ascale)]; 1412 } 1413} 1414 1415 1416/* 1417 * Apply the color matrix and post color matrix scaling and biasing. 1418 */ 1419void 1420_mesa_transform_rgba(const GLcontext *ctx, GLuint n, GLfloat rgba[][4]) 1421{ 1422 const GLfloat rs = ctx->Pixel.PostColorMatrixScale[0]; 1423 const GLfloat rb = ctx->Pixel.PostColorMatrixBias[0]; 1424 const GLfloat gs = ctx->Pixel.PostColorMatrixScale[1]; 1425 const GLfloat gb = ctx->Pixel.PostColorMatrixBias[1]; 1426 const GLfloat bs = ctx->Pixel.PostColorMatrixScale[2]; 1427 const GLfloat bb = ctx->Pixel.PostColorMatrixBias[2]; 1428 const GLfloat as = ctx->Pixel.PostColorMatrixScale[3]; 1429 const GLfloat ab = ctx->Pixel.PostColorMatrixBias[3]; 1430 const GLfloat *m = ctx->ColorMatrixStack.Top->m; 1431 GLuint i; 1432 for (i = 0; i < n; i++) { 1433 const GLfloat r = rgba[i][RCOMP]; 1434 const GLfloat g = rgba[i][GCOMP]; 1435 const GLfloat b = rgba[i][BCOMP]; 1436 const GLfloat a = rgba[i][ACOMP]; 1437 rgba[i][RCOMP] = (m[0] * r + m[4] * g + m[ 8] * b + m[12] * a) * rs + rb; 1438 rgba[i][GCOMP] = (m[1] * r + m[5] * g + m[ 9] * b + m[13] * a) * gs + gb; 1439 rgba[i][BCOMP] = (m[2] * r + m[6] * g + m[10] * b + m[14] * a) * bs + bb; 1440 rgba[i][ACOMP] = (m[3] * r + m[7] * g + m[11] * b + m[15] * a) * as + ab; 1441 } 1442} 1443 1444 1445/** 1446 * Apply a color table lookup to an array of floating point RGBA colors. 1447 */ 1448void 1449_mesa_lookup_rgba_float(const struct gl_color_table *table, 1450 GLuint n, GLfloat rgba[][4]) 1451{ 1452 const GLint max = table->Size - 1; 1453 const GLfloat scale = (GLfloat) max; 1454 const GLfloat *lut = table->TableF; 1455 GLuint i; 1456 1457 if (!table->TableF || table->Size == 0) 1458 return; 1459 1460 switch (table->_BaseFormat) { 1461 case GL_INTENSITY: 1462 /* replace RGBA with I */ 1463 for (i = 0; i < n; i++) { 1464 GLint j = IROUND(rgba[i][RCOMP] * scale); 1465 GLfloat c = lut[CLAMP(j, 0, max)]; 1466 rgba[i][RCOMP] = 1467 rgba[i][GCOMP] = 1468 rgba[i][BCOMP] = 1469 rgba[i][ACOMP] = c; 1470 } 1471 break; 1472 case GL_LUMINANCE: 1473 /* replace RGB with L */ 1474 for (i = 0; i < n; i++) { 1475 GLint j = IROUND(rgba[i][RCOMP] * scale); 1476 GLfloat c = lut[CLAMP(j, 0, max)]; 1477 rgba[i][RCOMP] = 1478 rgba[i][GCOMP] = 1479 rgba[i][BCOMP] = c; 1480 } 1481 break; 1482 case GL_ALPHA: 1483 /* replace A with A */ 1484 for (i = 0; i < n; i++) { 1485 GLint j = IROUND(rgba[i][ACOMP] * scale); 1486 rgba[i][ACOMP] = lut[CLAMP(j, 0, max)]; 1487 } 1488 break; 1489 case GL_LUMINANCE_ALPHA: 1490 /* replace RGBA with LLLA */ 1491 for (i = 0; i < n; i++) { 1492 GLint jL = IROUND(rgba[i][RCOMP] * scale); 1493 GLint jA = IROUND(rgba[i][ACOMP] * scale); 1494 GLfloat luminance, alpha; 1495 jL = CLAMP(jL, 0, max); 1496 jA = CLAMP(jA, 0, max); 1497 luminance = lut[jL * 2 + 0]; 1498 alpha = lut[jA * 2 + 1]; 1499 rgba[i][RCOMP] = 1500 rgba[i][GCOMP] = 1501 rgba[i][BCOMP] = luminance; 1502 rgba[i][ACOMP] = alpha;; 1503 } 1504 break; 1505 case GL_RGB: 1506 /* replace RGB with RGB */ 1507 for (i = 0; i < n; i++) { 1508 GLint jR = IROUND(rgba[i][RCOMP] * scale); 1509 GLint jG = IROUND(rgba[i][GCOMP] * scale); 1510 GLint jB = IROUND(rgba[i][BCOMP] * scale); 1511 jR = CLAMP(jR, 0, max); 1512 jG = CLAMP(jG, 0, max); 1513 jB = CLAMP(jB, 0, max); 1514 rgba[i][RCOMP] = lut[jR * 3 + 0]; 1515 rgba[i][GCOMP] = lut[jG * 3 + 1]; 1516 rgba[i][BCOMP] = lut[jB * 3 + 2]; 1517 } 1518 break; 1519 case GL_RGBA: 1520 /* replace RGBA with RGBA */ 1521 for (i = 0; i < n; i++) { 1522 GLint jR = IROUND(rgba[i][RCOMP] * scale); 1523 GLint jG = IROUND(rgba[i][GCOMP] * scale); 1524 GLint jB = IROUND(rgba[i][BCOMP] * scale); 1525 GLint jA = IROUND(rgba[i][ACOMP] * scale); 1526 jR = CLAMP(jR, 0, max); 1527 jG = CLAMP(jG, 0, max); 1528 jB = CLAMP(jB, 0, max); 1529 jA = CLAMP(jA, 0, max); 1530 rgba[i][RCOMP] = lut[jR * 4 + 0]; 1531 rgba[i][GCOMP] = lut[jG * 4 + 1]; 1532 rgba[i][BCOMP] = lut[jB * 4 + 2]; 1533 rgba[i][ACOMP] = lut[jA * 4 + 3]; 1534 } 1535 break; 1536 default: 1537 _mesa_problem(NULL, "Bad format in _mesa_lookup_rgba_float"); 1538 return; 1539 } 1540} 1541 1542 1543 1544/** 1545 * Apply a color table lookup to an array of ubyte/RGBA colors. 1546 */ 1547void 1548_mesa_lookup_rgba_ubyte(const struct gl_color_table *table, 1549 GLuint n, GLubyte rgba[][4]) 1550{ 1551 const GLubyte *lut = table->TableUB; 1552 const GLfloat scale = (GLfloat) (table->Size - 1) / (GLfloat)255.0; 1553 GLuint i; 1554 1555 if (!table->TableUB || table->Size == 0) 1556 return; 1557 1558 switch (table->_BaseFormat) { 1559 case GL_INTENSITY: 1560 /* replace RGBA with I */ 1561 if (table->Size == 256) { 1562 for (i = 0; i < n; i++) { 1563 const GLubyte c = lut[rgba[i][RCOMP]]; 1564 rgba[i][RCOMP] = 1565 rgba[i][GCOMP] = 1566 rgba[i][BCOMP] = 1567 rgba[i][ACOMP] = c; 1568 } 1569 } 1570 else { 1571 for (i = 0; i < n; i++) { 1572 GLint j = IROUND((GLfloat) rgba[i][RCOMP] * scale); 1573 rgba[i][RCOMP] = 1574 rgba[i][GCOMP] = 1575 rgba[i][BCOMP] = 1576 rgba[i][ACOMP] = lut[j]; 1577 } 1578 } 1579 break; 1580 case GL_LUMINANCE: 1581 /* replace RGB with L */ 1582 if (table->Size == 256) { 1583 for (i = 0; i < n; i++) { 1584 const GLubyte c = lut[rgba[i][RCOMP]]; 1585 rgba[i][RCOMP] = 1586 rgba[i][GCOMP] = 1587 rgba[i][BCOMP] = c; 1588 } 1589 } 1590 else { 1591 for (i = 0; i < n; i++) { 1592 GLint j = IROUND((GLfloat) rgba[i][RCOMP] * scale); 1593 rgba[i][RCOMP] = 1594 rgba[i][GCOMP] = 1595 rgba[i][BCOMP] = lut[j]; 1596 } 1597 } 1598 break; 1599 case GL_ALPHA: 1600 /* replace A with A */ 1601 if (table->Size == 256) { 1602 for (i = 0; i < n; i++) { 1603 rgba[i][ACOMP] = lut[rgba[i][ACOMP]]; 1604 } 1605 } 1606 else { 1607 for (i = 0; i < n; i++) { 1608 GLint j = IROUND((GLfloat) rgba[i][ACOMP] * scale); 1609 rgba[i][ACOMP] = lut[j]; 1610 } 1611 } 1612 break; 1613 case GL_LUMINANCE_ALPHA: 1614 /* replace RGBA with LLLA */ 1615 if (table->Size == 256) { 1616 for (i = 0; i < n; i++) { 1617 GLubyte l = lut[rgba[i][RCOMP] * 2 + 0]; 1618 GLubyte a = lut[rgba[i][ACOMP] * 2 + 1];; 1619 rgba[i][RCOMP] = 1620 rgba[i][GCOMP] = 1621 rgba[i][BCOMP] = l; 1622 rgba[i][ACOMP] = a; 1623 } 1624 } 1625 else { 1626 for (i = 0; i < n; i++) { 1627 GLint jL = IROUND((GLfloat) rgba[i][RCOMP] * scale); 1628 GLint jA = IROUND((GLfloat) rgba[i][ACOMP] * scale); 1629 GLubyte luminance = lut[jL * 2 + 0]; 1630 GLubyte alpha = lut[jA * 2 + 1]; 1631 rgba[i][RCOMP] = 1632 rgba[i][GCOMP] = 1633 rgba[i][BCOMP] = luminance; 1634 rgba[i][ACOMP] = alpha; 1635 } 1636 } 1637 break; 1638 case GL_RGB: 1639 if (table->Size == 256) { 1640 for (i = 0; i < n; i++) { 1641 rgba[i][RCOMP] = lut[rgba[i][RCOMP] * 3 + 0]; 1642 rgba[i][GCOMP] = lut[rgba[i][GCOMP] * 3 + 1]; 1643 rgba[i][BCOMP] = lut[rgba[i][BCOMP] * 3 + 2]; 1644 } 1645 } 1646 else { 1647 for (i = 0; i < n; i++) { 1648 GLint jR = IROUND((GLfloat) rgba[i][RCOMP] * scale); 1649 GLint jG = IROUND((GLfloat) rgba[i][GCOMP] * scale); 1650 GLint jB = IROUND((GLfloat) rgba[i][BCOMP] * scale); 1651 rgba[i][RCOMP] = lut[jR * 3 + 0]; 1652 rgba[i][GCOMP] = lut[jG * 3 + 1]; 1653 rgba[i][BCOMP] = lut[jB * 3 + 2]; 1654 } 1655 } 1656 break; 1657 case GL_RGBA: 1658 if (table->Size == 256) { 1659 for (i = 0; i < n; i++) { 1660 rgba[i][RCOMP] = lut[rgba[i][RCOMP] * 4 + 0]; 1661 rgba[i][GCOMP] = lut[rgba[i][GCOMP] * 4 + 1]; 1662 rgba[i][BCOMP] = lut[rgba[i][BCOMP] * 4 + 2]; 1663 rgba[i][ACOMP] = lut[rgba[i][ACOMP] * 4 + 3]; 1664 } 1665 } 1666 else { 1667 for (i = 0; i < n; i++) { 1668 GLint jR = IROUND((GLfloat) rgba[i][RCOMP] * scale); 1669 GLint jG = IROUND((GLfloat) rgba[i][GCOMP] * scale); 1670 GLint jB = IROUND((GLfloat) rgba[i][BCOMP] * scale); 1671 GLint jA = IROUND((GLfloat) rgba[i][ACOMP] * scale); 1672 CLAMPED_FLOAT_TO_CHAN(rgba[i][RCOMP], lut[jR * 4 + 0]); 1673 CLAMPED_FLOAT_TO_CHAN(rgba[i][GCOMP], lut[jG * 4 + 1]); 1674 CLAMPED_FLOAT_TO_CHAN(rgba[i][BCOMP], lut[jB * 4 + 2]); 1675 CLAMPED_FLOAT_TO_CHAN(rgba[i][ACOMP], lut[jA * 4 + 3]); 1676 } 1677 } 1678 break; 1679 default: 1680 _mesa_problem(NULL, "Bad format in _mesa_lookup_rgba_chan"); 1681 return; 1682 } 1683} 1684 1685 1686 1687/* 1688 * Map color indexes to float rgba values. 1689 */ 1690void 1691_mesa_map_ci_to_rgba( const GLcontext *ctx, GLuint n, 1692 const GLuint index[], GLfloat rgba[][4] ) 1693{ 1694 GLuint rmask = ctx->PixelMaps.ItoR.Size - 1; 1695 GLuint gmask = ctx->PixelMaps.ItoG.Size - 1; 1696 GLuint bmask = ctx->PixelMaps.ItoB.Size - 1; 1697 GLuint amask = ctx->PixelMaps.ItoA.Size - 1; 1698 const GLfloat *rMap = ctx->PixelMaps.ItoR.Map; 1699 const GLfloat *gMap = ctx->PixelMaps.ItoG.Map; 1700 const GLfloat *bMap = ctx->PixelMaps.ItoB.Map; 1701 const GLfloat *aMap = ctx->PixelMaps.ItoA.Map; 1702 GLuint i; 1703 for (i=0;i<n;i++) { 1704 rgba[i][RCOMP] = rMap[index[i] & rmask]; 1705 rgba[i][GCOMP] = gMap[index[i] & gmask]; 1706 rgba[i][BCOMP] = bMap[index[i] & bmask]; 1707 rgba[i][ACOMP] = aMap[index[i] & amask]; 1708 } 1709} 1710 1711 1712/** 1713 * Map ubyte color indexes to ubyte/RGBA values. 1714 */ 1715void 1716_mesa_map_ci8_to_rgba8(const GLcontext *ctx, GLuint n, const GLubyte index[], 1717 GLubyte rgba[][4]) 1718{ 1719 GLuint rmask = ctx->PixelMaps.ItoR.Size - 1; 1720 GLuint gmask = ctx->PixelMaps.ItoG.Size - 1; 1721 GLuint bmask = ctx->PixelMaps.ItoB.Size - 1; 1722 GLuint amask = ctx->PixelMaps.ItoA.Size - 1; 1723 const GLubyte *rMap = ctx->PixelMaps.ItoR.Map8; 1724 const GLubyte *gMap = ctx->PixelMaps.ItoG.Map8; 1725 const GLubyte *bMap = ctx->PixelMaps.ItoB.Map8; 1726 const GLubyte *aMap = ctx->PixelMaps.ItoA.Map8; 1727 GLuint i; 1728 for (i=0;i<n;i++) { 1729 rgba[i][RCOMP] = rMap[index[i] & rmask]; 1730 rgba[i][GCOMP] = gMap[index[i] & gmask]; 1731 rgba[i][BCOMP] = bMap[index[i] & bmask]; 1732 rgba[i][ACOMP] = aMap[index[i] & amask]; 1733 } 1734} 1735 1736 1737void 1738_mesa_scale_and_bias_depth(const GLcontext *ctx, GLuint n, 1739 GLfloat depthValues[]) 1740{ 1741 const GLfloat scale = ctx->Pixel.DepthScale; 1742 const GLfloat bias = ctx->Pixel.DepthBias; 1743 GLuint i; 1744 for (i = 0; i < n; i++) { 1745 GLfloat d = depthValues[i] * scale + bias; 1746 depthValues[i] = CLAMP(d, 0.0F, 1.0F); 1747 } 1748} 1749 1750 1751void 1752_mesa_scale_and_bias_depth_uint(const GLcontext *ctx, GLuint n, 1753 GLuint depthValues[]) 1754{ 1755 const GLdouble max = (double) 0xffffffff; 1756 const GLdouble scale = ctx->Pixel.DepthScale; 1757 const GLdouble bias = ctx->Pixel.DepthBias * max; 1758 GLuint i; 1759 for (i = 0; i < n; i++) { 1760 GLdouble d = (GLdouble) depthValues[i] * scale + bias; 1761 d = CLAMP(d, 0.0, max); 1762 depthValues[i] = (GLuint) d; 1763 } 1764} 1765 1766 1767 1768/* 1769 * Update the min/max values from an array of fragment colors. 1770 */ 1771static void 1772update_minmax(GLcontext *ctx, GLuint n, const GLfloat rgba[][4]) 1773{ 1774 GLuint i; 1775 for (i = 0; i < n; i++) { 1776 /* update mins */ 1777 if (rgba[i][RCOMP] < ctx->MinMax.Min[RCOMP]) 1778 ctx->MinMax.Min[RCOMP] = rgba[i][RCOMP]; 1779 if (rgba[i][GCOMP] < ctx->MinMax.Min[GCOMP]) 1780 ctx->MinMax.Min[GCOMP] = rgba[i][GCOMP]; 1781 if (rgba[i][BCOMP] < ctx->MinMax.Min[BCOMP]) 1782 ctx->MinMax.Min[BCOMP] = rgba[i][BCOMP]; 1783 if (rgba[i][ACOMP] < ctx->MinMax.Min[ACOMP]) 1784 ctx->MinMax.Min[ACOMP] = rgba[i][ACOMP]; 1785 1786 /* update maxs */ 1787 if (rgba[i][RCOMP] > ctx->MinMax.Max[RCOMP]) 1788 ctx->MinMax.Max[RCOMP] = rgba[i][RCOMP]; 1789 if (rgba[i][GCOMP] > ctx->MinMax.Max[GCOMP]) 1790 ctx->MinMax.Max[GCOMP] = rgba[i][GCOMP]; 1791 if (rgba[i][BCOMP] > ctx->MinMax.Max[BCOMP]) 1792 ctx->MinMax.Max[BCOMP] = rgba[i][BCOMP]; 1793 if (rgba[i][ACOMP] > ctx->MinMax.Max[ACOMP]) 1794 ctx->MinMax.Max[ACOMP] = rgba[i][ACOMP]; 1795 } 1796} 1797 1798 1799/* 1800 * Update the histogram values from an array of fragment colors. 1801 */ 1802static void 1803update_histogram(GLcontext *ctx, GLuint n, const GLfloat rgba[][4]) 1804{ 1805 const GLint max = ctx->Histogram.Width - 1; 1806 GLfloat w = (GLfloat) max; 1807 GLuint i; 1808 1809 if (ctx->Histogram.Width == 0) 1810 return; 1811 1812 for (i = 0; i < n; i++) { 1813 GLint ri = IROUND(rgba[i][RCOMP] * w); 1814 GLint gi = IROUND(rgba[i][GCOMP] * w); 1815 GLint bi = IROUND(rgba[i][BCOMP] * w); 1816 GLint ai = IROUND(rgba[i][ACOMP] * w); 1817 ri = CLAMP(ri, 0, max); 1818 gi = CLAMP(gi, 0, max); 1819 bi = CLAMP(bi, 0, max); 1820 ai = CLAMP(ai, 0, max); 1821 ctx->Histogram.Count[ri][RCOMP]++; 1822 ctx->Histogram.Count[gi][GCOMP]++; 1823 ctx->Histogram.Count[bi][BCOMP]++; 1824 ctx->Histogram.Count[ai][ACOMP]++; 1825 } 1826} 1827 1828 1829/** 1830 * Apply various pixel transfer operations to an array of RGBA pixels 1831 * as indicated by the transferOps bitmask 1832 */ 1833void 1834_mesa_apply_rgba_transfer_ops(GLcontext *ctx, GLbitfield transferOps, 1835 GLuint n, GLfloat rgba[][4]) 1836{ 1837 /* scale & bias */ 1838 if (transferOps & IMAGE_SCALE_BIAS_BIT) { 1839 _mesa_scale_and_bias_rgba(n, rgba, 1840 ctx->Pixel.RedScale, ctx->Pixel.GreenScale, 1841 ctx->Pixel.BlueScale, ctx->Pixel.AlphaScale, 1842 ctx->Pixel.RedBias, ctx->Pixel.GreenBias, 1843 ctx->Pixel.BlueBias, ctx->Pixel.AlphaBias); 1844 } 1845 /* color map lookup */ 1846 if (transferOps & IMAGE_MAP_COLOR_BIT) { 1847 _mesa_map_rgba( ctx, n, rgba ); 1848 } 1849 /* GL_COLOR_TABLE lookup */ 1850 if (transferOps & IMAGE_COLOR_TABLE_BIT) { 1851 _mesa_lookup_rgba_float(&ctx->ColorTable[COLORTABLE_PRECONVOLUTION], n, rgba); 1852 } 1853 /* convolution */ 1854 if (transferOps & IMAGE_CONVOLUTION_BIT) { 1855 /* this has to be done in the calling code */ 1856 _mesa_problem(ctx, "IMAGE_CONVOLUTION_BIT set in _mesa_apply_transfer_ops"); 1857 } 1858 /* GL_POST_CONVOLUTION_RED/GREEN/BLUE/ALPHA_SCALE/BIAS */ 1859 if (transferOps & IMAGE_POST_CONVOLUTION_SCALE_BIAS) { 1860 _mesa_scale_and_bias_rgba(n, rgba, 1861 ctx->Pixel.PostConvolutionScale[RCOMP], 1862 ctx->Pixel.PostConvolutionScale[GCOMP], 1863 ctx->Pixel.PostConvolutionScale[BCOMP], 1864 ctx->Pixel.PostConvolutionScale[ACOMP], 1865 ctx->Pixel.PostConvolutionBias[RCOMP], 1866 ctx->Pixel.PostConvolutionBias[GCOMP], 1867 ctx->Pixel.PostConvolutionBias[BCOMP], 1868 ctx->Pixel.PostConvolutionBias[ACOMP]); 1869 } 1870 /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */ 1871 if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) { 1872 _mesa_lookup_rgba_float(&ctx->ColorTable[COLORTABLE_POSTCONVOLUTION], n, rgba); 1873 } 1874 /* color matrix transform */ 1875 if (transferOps & IMAGE_COLOR_MATRIX_BIT) { 1876 _mesa_transform_rgba(ctx, n, rgba); 1877 } 1878 /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */ 1879 if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) { 1880 _mesa_lookup_rgba_float(&ctx->ColorTable[COLORTABLE_POSTCOLORMATRIX], n, rgba); 1881 } 1882 /* update histogram count */ 1883 if (transferOps & IMAGE_HISTOGRAM_BIT) { 1884 update_histogram(ctx, n, (CONST GLfloat (*)[4]) rgba); 1885 } 1886 /* update min/max values */ 1887 if (transferOps & IMAGE_MIN_MAX_BIT) { 1888 update_minmax(ctx, n, (CONST GLfloat (*)[4]) rgba); 1889 } 1890 /* clamping to [0,1] */ 1891 if (transferOps & IMAGE_CLAMP_BIT) { 1892 GLuint i; 1893 for (i = 0; i < n; i++) { 1894 rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F); 1895 rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F); 1896 rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F); 1897 rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F); 1898 } 1899 } 1900} 1901 1902 1903/* 1904 * Apply color index shift and offset to an array of pixels. 1905 */ 1906static void 1907shift_and_offset_ci( const GLcontext *ctx, GLuint n, GLuint indexes[] ) 1908{ 1909 GLint shift = ctx->Pixel.IndexShift; 1910 GLint offset = ctx->Pixel.IndexOffset; 1911 GLuint i; 1912 if (shift > 0) { 1913 for (i=0;i<n;i++) { 1914 indexes[i] = (indexes[i] << shift) + offset; 1915 } 1916 } 1917 else if (shift < 0) { 1918 shift = -shift; 1919 for (i=0;i<n;i++) { 1920 indexes[i] = (indexes[i] >> shift) + offset; 1921 } 1922 } 1923 else { 1924 for (i=0;i<n;i++) { 1925 indexes[i] = indexes[i] + offset; 1926 } 1927 } 1928} 1929 1930 1931 1932/** 1933 * Apply color index shift, offset and table lookup to an array 1934 * of color indexes; 1935 */ 1936void 1937_mesa_apply_ci_transfer_ops(const GLcontext *ctx, GLbitfield transferOps, 1938 GLuint n, GLuint indexes[]) 1939{ 1940 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) { 1941 shift_and_offset_ci(ctx, n, indexes); 1942 } 1943 if (transferOps & IMAGE_MAP_COLOR_BIT) { 1944 const GLuint mask = ctx->PixelMaps.ItoI.Size - 1; 1945 GLuint i; 1946 for (i = 0; i < n; i++) { 1947 const GLuint j = indexes[i] & mask; 1948 indexes[i] = IROUND(ctx->PixelMaps.ItoI.Map[j]); 1949 } 1950 } 1951} 1952 1953 1954/** 1955 * Apply stencil index shift, offset and table lookup to an array 1956 * of stencil values. 1957 */ 1958void 1959_mesa_apply_stencil_transfer_ops(const GLcontext *ctx, GLuint n, 1960 GLstencil stencil[]) 1961{ 1962 if (ctx->Pixel.IndexShift != 0 || ctx->Pixel.IndexOffset != 0) { 1963 const GLint offset = ctx->Pixel.IndexOffset; 1964 GLint shift = ctx->Pixel.IndexShift; 1965 GLuint i; 1966 if (shift > 0) { 1967 for (i = 0; i < n; i++) { 1968 stencil[i] = (stencil[i] << shift) + offset; 1969 } 1970 } 1971 else if (shift < 0) { 1972 shift = -shift; 1973 for (i = 0; i < n; i++) { 1974 stencil[i] = (stencil[i] >> shift) + offset; 1975 } 1976 } 1977 else { 1978 for (i = 0; i < n; i++) { 1979 stencil[i] = stencil[i] + offset; 1980 } 1981 } 1982 } 1983 if (ctx->Pixel.MapStencilFlag) { 1984 GLuint mask = ctx->PixelMaps.StoS.Size - 1; 1985 GLuint i; 1986 for (i = 0; i < n; i++) { 1987 stencil[i] = (GLstencil)ctx->PixelMaps.StoS.Map[ stencil[i] & mask ]; 1988 } 1989 } 1990} 1991 1992 1993/** 1994 * Used to pack an array [][4] of RGBA float colors as specified 1995 * by the dstFormat, dstType and dstPacking. Used by glReadPixels, 1996 * glGetConvolutionFilter(), etc. 1997 * Note: the rgba values will be modified by this function when any pixel 1998 * transfer ops are enabled. 1999 */ 2000void 2001_mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4], 2002 GLenum dstFormat, GLenum dstType, 2003 GLvoid *dstAddr, 2004 const struct gl_pixelstore_attrib *dstPacking, 2005 GLbitfield transferOps) 2006{ 2007 GLfloat luminance[MAX_WIDTH]; 2008 const GLint comps = _mesa_components_in_format(dstFormat); 2009 GLuint i; 2010 2011 /* XXX 2012 * This test should probably go away. Have the caller set/clear the 2013 * IMAGE_CLAMP_BIT as needed. 2014 */ 2015 if (dstType != GL_FLOAT || ctx->Color.ClampReadColor == GL_TRUE) { 2016 /* need to clamp to [0, 1] */ 2017 transferOps |= IMAGE_CLAMP_BIT; 2018 } 2019 2020 if (transferOps) { 2021 _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba); 2022 if ((transferOps & IMAGE_MIN_MAX_BIT) && ctx->MinMax.Sink) { 2023 return; 2024 } 2025 } 2026 2027 if (dstFormat == GL_LUMINANCE || dstFormat == GL_LUMINANCE_ALPHA) { 2028 /* compute luminance values */ 2029 if (transferOps & IMAGE_CLAMP_BIT) { 2030 for (i = 0; i < n; i++) { 2031 GLfloat sum = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP]; 2032 luminance[i] = CLAMP(sum, 0.0F, 1.0F); 2033 } 2034 } 2035 else { 2036 for (i = 0; i < n; i++) { 2037 luminance[i] = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP]; 2038 } 2039 } 2040 } 2041 2042 /* 2043 * Pack/store the pixels. Ugh! Lots of cases!!! 2044 */ 2045 switch (dstType) { 2046 case GL_UNSIGNED_BYTE: 2047 { 2048 GLubyte *dst = (GLubyte *) dstAddr; 2049 switch (dstFormat) { 2050 case GL_RED: 2051 for (i=0;i<n;i++) 2052 dst[i] = FLOAT_TO_UBYTE(rgba[i][RCOMP]); 2053 break; 2054 case GL_GREEN: 2055 for (i=0;i<n;i++) 2056 dst[i] = FLOAT_TO_UBYTE(rgba[i][GCOMP]); 2057 break; 2058 case GL_BLUE: 2059 for (i=0;i<n;i++) 2060 dst[i] = FLOAT_TO_UBYTE(rgba[i][BCOMP]); 2061 break; 2062 case GL_ALPHA: 2063 for (i=0;i<n;i++) 2064 dst[i] = FLOAT_TO_UBYTE(rgba[i][ACOMP]); 2065 break; 2066 case GL_LUMINANCE: 2067 for (i=0;i<n;i++) 2068 dst[i] = FLOAT_TO_UBYTE(luminance[i]); 2069 break; 2070 case GL_LUMINANCE_ALPHA: 2071 for (i=0;i<n;i++) { 2072 dst[i*2+0] = FLOAT_TO_UBYTE(luminance[i]); 2073 dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][ACOMP]); 2074 } 2075 break; 2076 case GL_RGB: 2077 for (i=0;i<n;i++) { 2078 dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]); 2079 dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]); 2080 dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]); 2081 } 2082 break; 2083 case GL_RGBA: 2084 for (i=0;i<n;i++) { 2085 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]); 2086 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]); 2087 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]); 2088 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]); 2089 } 2090 break; 2091 case GL_BGR: 2092 for (i=0;i<n;i++) { 2093 dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]); 2094 dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]); 2095 dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]); 2096 } 2097 break; 2098 case GL_BGRA: 2099 for (i=0;i<n;i++) { 2100 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]); 2101 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]); 2102 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]); 2103 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]); 2104 } 2105 break; 2106 case GL_ABGR_EXT: 2107 for (i=0;i<n;i++) { 2108 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][ACOMP]); 2109 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][BCOMP]); 2110 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][GCOMP]); 2111 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][RCOMP]); 2112 } 2113 break; 2114 case GL_DUDV_ATI: 2115 case GL_DU8DV8_ATI: 2116 for (i=0;i<n;i++) { 2117 dst[i*2+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]); 2118 dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]); 2119 } 2120 break; 2121 default: 2122 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); 2123 } 2124 } 2125 break; 2126 case GL_BYTE: 2127 { 2128 GLbyte *dst = (GLbyte *) dstAddr; 2129 switch (dstFormat) { 2130 case GL_RED: 2131 for (i=0;i<n;i++) 2132 dst[i] = FLOAT_TO_BYTE(rgba[i][RCOMP]); 2133 break; 2134 case GL_GREEN: 2135 for (i=0;i<n;i++) 2136 dst[i] = FLOAT_TO_BYTE(rgba[i][GCOMP]); 2137 break; 2138 case GL_BLUE: 2139 for (i=0;i<n;i++) 2140 dst[i] = FLOAT_TO_BYTE(rgba[i][BCOMP]); 2141 break; 2142 case GL_ALPHA: 2143 for (i=0;i<n;i++) 2144 dst[i] = FLOAT_TO_BYTE(rgba[i][ACOMP]); 2145 break; 2146 case GL_LUMINANCE: 2147 for (i=0;i<n;i++) 2148 dst[i] = FLOAT_TO_BYTE(luminance[i]); 2149 break; 2150 case GL_LUMINANCE_ALPHA: 2151 for (i=0;i<n;i++) { 2152 dst[i*2+0] = FLOAT_TO_BYTE(luminance[i]); 2153 dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][ACOMP]); 2154 } 2155 break; 2156 case GL_RGB: 2157 for (i=0;i<n;i++) { 2158 dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]); 2159 dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]); 2160 dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]); 2161 } 2162 break; 2163 case GL_RGBA: 2164 for (i=0;i<n;i++) { 2165 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]); 2166 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]); 2167 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]); 2168 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]); 2169 } 2170 break; 2171 case GL_BGR: 2172 for (i=0;i<n;i++) { 2173 dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]); 2174 dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]); 2175 dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]); 2176 } 2177 break; 2178 case GL_BGRA: 2179 for (i=0;i<n;i++) { 2180 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]); 2181 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]); 2182 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]); 2183 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]); 2184 } 2185 break; 2186 case GL_ABGR_EXT: 2187 for (i=0;i<n;i++) { 2188 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][ACOMP]); 2189 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][BCOMP]); 2190 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][GCOMP]); 2191 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][RCOMP]); 2192 } 2193 break; 2194 case GL_DUDV_ATI: 2195 case GL_DU8DV8_ATI: 2196 for (i=0;i<n;i++) { 2197 dst[i*2+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]); 2198 dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]); 2199 } 2200 break; 2201 default: 2202 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); 2203 } 2204 } 2205 break; 2206 case GL_UNSIGNED_SHORT: 2207 { 2208 GLushort *dst = (GLushort *) dstAddr; 2209 switch (dstFormat) { 2210 case GL_RED: 2211 for (i=0;i<n;i++) 2212 CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][RCOMP]); 2213 break; 2214 case GL_GREEN: 2215 for (i=0;i<n;i++) 2216 CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][GCOMP]); 2217 break; 2218 case GL_BLUE: 2219 for (i=0;i<n;i++) 2220 CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][BCOMP]); 2221 break; 2222 case GL_ALPHA: 2223 for (i=0;i<n;i++) 2224 CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][ACOMP]); 2225 break; 2226 case GL_LUMINANCE: 2227 for (i=0;i<n;i++) 2228 UNCLAMPED_FLOAT_TO_USHORT(dst[i], luminance[i]); 2229 break; 2230 case GL_LUMINANCE_ALPHA: 2231 for (i=0;i<n;i++) { 2232 UNCLAMPED_FLOAT_TO_USHORT(dst[i*2+0], luminance[i]); 2233 CLAMPED_FLOAT_TO_USHORT(dst[i*2+1], rgba[i][ACOMP]); 2234 } 2235 break; 2236 case GL_RGB: 2237 for (i=0;i<n;i++) { 2238 CLAMPED_FLOAT_TO_USHORT(dst[i*3+0], rgba[i][RCOMP]); 2239 CLAMPED_FLOAT_TO_USHORT(dst[i*3+1], rgba[i][GCOMP]); 2240 CLAMPED_FLOAT_TO_USHORT(dst[i*3+2], rgba[i][BCOMP]); 2241 } 2242 break; 2243 case GL_RGBA: 2244 for (i=0;i<n;i++) { 2245 CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][RCOMP]); 2246 CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][GCOMP]); 2247 CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][BCOMP]); 2248 CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][ACOMP]); 2249 } 2250 break; 2251 case GL_BGR: 2252 for (i=0;i<n;i++) { 2253 CLAMPED_FLOAT_TO_USHORT(dst[i*3+0], rgba[i][BCOMP]); 2254 CLAMPED_FLOAT_TO_USHORT(dst[i*3+1], rgba[i][GCOMP]); 2255 CLAMPED_FLOAT_TO_USHORT(dst[i*3+2], rgba[i][RCOMP]); 2256 } 2257 break; 2258 case GL_BGRA: 2259 for (i=0;i<n;i++) { 2260 CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][BCOMP]); 2261 CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][GCOMP]); 2262 CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][RCOMP]); 2263 CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][ACOMP]); 2264 } 2265 break; 2266 case GL_ABGR_EXT: 2267 for (i=0;i<n;i++) { 2268 CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][ACOMP]); 2269 CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][BCOMP]); 2270 CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][GCOMP]); 2271 CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][RCOMP]); 2272 } 2273 break; 2274 case GL_DUDV_ATI: 2275 case GL_DU8DV8_ATI: 2276 for (i=0;i<n;i++) { 2277 dst[i*2+0] = FLOAT_TO_USHORT(rgba[i][RCOMP]); 2278 dst[i*2+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]); 2279 } 2280 break; 2281 default: 2282 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); 2283 } 2284 } 2285 break; 2286 case GL_SHORT: 2287 { 2288 GLshort *dst = (GLshort *) dstAddr; 2289 switch (dstFormat) { 2290 case GL_RED: 2291 for (i=0;i<n;i++) 2292 dst[i] = FLOAT_TO_SHORT(rgba[i][RCOMP]); 2293 break; 2294 case GL_GREEN: 2295 for (i=0;i<n;i++) 2296 dst[i] = FLOAT_TO_SHORT(rgba[i][GCOMP]); 2297 break; 2298 case GL_BLUE: 2299 for (i=0;i<n;i++) 2300 dst[i] = FLOAT_TO_SHORT(rgba[i][BCOMP]); 2301 break; 2302 case GL_ALPHA: 2303 for (i=0;i<n;i++) 2304 dst[i] = FLOAT_TO_SHORT(rgba[i][ACOMP]); 2305 break; 2306 case GL_LUMINANCE: 2307 for (i=0;i<n;i++) 2308 dst[i] = FLOAT_TO_SHORT(luminance[i]); 2309 break; 2310 case GL_LUMINANCE_ALPHA: 2311 for (i=0;i<n;i++) { 2312 dst[i*2+0] = FLOAT_TO_SHORT(luminance[i]); 2313 dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][ACOMP]); 2314 } 2315 break; 2316 case GL_RGB: 2317 for (i=0;i<n;i++) { 2318 dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]); 2319 dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]); 2320 dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]); 2321 } 2322 break; 2323 case GL_RGBA: 2324 for (i=0;i<n;i++) { 2325 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]); 2326 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]); 2327 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]); 2328 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]); 2329 } 2330 break; 2331 case GL_BGR: 2332 for (i=0;i<n;i++) { 2333 dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]); 2334 dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]); 2335 dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]); 2336 } 2337 break; 2338 case GL_BGRA: 2339 for (i=0;i<n;i++) { 2340 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]); 2341 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]); 2342 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]); 2343 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]); 2344 } 2345 break; 2346 case GL_ABGR_EXT: 2347 for (i=0;i<n;i++) { 2348 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][ACOMP]); 2349 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][BCOMP]); 2350 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][GCOMP]); 2351 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][RCOMP]); 2352 } 2353 break; 2354 case GL_DUDV_ATI: 2355 case GL_DU8DV8_ATI: 2356 for (i=0;i<n;i++) { 2357 dst[i*2+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]); 2358 dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]); 2359 } 2360 break; 2361 default: 2362 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); 2363 } 2364 } 2365 break; 2366 case GL_UNSIGNED_INT: 2367 { 2368 GLuint *dst = (GLuint *) dstAddr; 2369 switch (dstFormat) { 2370 case GL_RED: 2371 for (i=0;i<n;i++) 2372 dst[i] = FLOAT_TO_UINT(rgba[i][RCOMP]); 2373 break; 2374 case GL_GREEN: 2375 for (i=0;i<n;i++) 2376 dst[i] = FLOAT_TO_UINT(rgba[i][GCOMP]); 2377 break; 2378 case GL_BLUE: 2379 for (i=0;i<n;i++) 2380 dst[i] = FLOAT_TO_UINT(rgba[i][BCOMP]); 2381 break; 2382 case GL_ALPHA: 2383 for (i=0;i<n;i++) 2384 dst[i] = FLOAT_TO_UINT(rgba[i][ACOMP]); 2385 break; 2386 case GL_LUMINANCE: 2387 for (i=0;i<n;i++) 2388 dst[i] = FLOAT_TO_UINT(luminance[i]); 2389 break; 2390 case GL_LUMINANCE_ALPHA: 2391 for (i=0;i<n;i++) { 2392 dst[i*2+0] = FLOAT_TO_UINT(luminance[i]); 2393 dst[i*2+1] = FLOAT_TO_UINT(rgba[i][ACOMP]); 2394 } 2395 break; 2396 case GL_RGB: 2397 for (i=0;i<n;i++) { 2398 dst[i*3+0] = FLOAT_TO_UINT(rgba[i][RCOMP]); 2399 dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]); 2400 dst[i*3+2] = FLOAT_TO_UINT(rgba[i][BCOMP]); 2401 } 2402 break; 2403 case GL_RGBA: 2404 for (i=0;i<n;i++) { 2405 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][RCOMP]); 2406 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]); 2407 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][BCOMP]); 2408 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]); 2409 } 2410 break; 2411 case GL_BGR: 2412 for (i=0;i<n;i++) { 2413 dst[i*3+0] = FLOAT_TO_UINT(rgba[i][BCOMP]); 2414 dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]); 2415 dst[i*3+2] = FLOAT_TO_UINT(rgba[i][RCOMP]); 2416 } 2417 break; 2418 case GL_BGRA: 2419 for (i=0;i<n;i++) { 2420 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][BCOMP]); 2421 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]); 2422 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][RCOMP]); 2423 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]); 2424 } 2425 break; 2426 case GL_ABGR_EXT: 2427 for (i=0;i<n;i++) { 2428 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][ACOMP]); 2429 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][BCOMP]); 2430 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][GCOMP]); 2431 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][RCOMP]); 2432 } 2433 break; 2434 case GL_DUDV_ATI: 2435 case GL_DU8DV8_ATI: 2436 for (i=0;i<n;i++) { 2437 dst[i*2+0] = FLOAT_TO_UINT(rgba[i][RCOMP]); 2438 dst[i*2+1] = FLOAT_TO_UINT(rgba[i][GCOMP]); 2439 } 2440 break; 2441 default: 2442 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); 2443 } 2444 } 2445 break; 2446 case GL_INT: 2447 { 2448 GLint *dst = (GLint *) dstAddr; 2449 switch (dstFormat) { 2450 case GL_RED: 2451 for (i=0;i<n;i++) 2452 dst[i] = FLOAT_TO_INT(rgba[i][RCOMP]); 2453 break; 2454 case GL_GREEN: 2455 for (i=0;i<n;i++) 2456 dst[i] = FLOAT_TO_INT(rgba[i][GCOMP]); 2457 break; 2458 case GL_BLUE: 2459 for (i=0;i<n;i++) 2460 dst[i] = FLOAT_TO_INT(rgba[i][BCOMP]); 2461 break; 2462 case GL_ALPHA: 2463 for (i=0;i<n;i++) 2464 dst[i] = FLOAT_TO_INT(rgba[i][ACOMP]); 2465 break; 2466 case GL_LUMINANCE: 2467 for (i=0;i<n;i++) 2468 dst[i] = FLOAT_TO_INT(luminance[i]); 2469 break; 2470 case GL_LUMINANCE_ALPHA: 2471 for (i=0;i<n;i++) { 2472 dst[i*2+0] = FLOAT_TO_INT(luminance[i]); 2473 dst[i*2+1] = FLOAT_TO_INT(rgba[i][ACOMP]); 2474 } 2475 break; 2476 case GL_RGB: 2477 for (i=0;i<n;i++) { 2478 dst[i*3+0] = FLOAT_TO_INT(rgba[i][RCOMP]); 2479 dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]); 2480 dst[i*3+2] = FLOAT_TO_INT(rgba[i][BCOMP]); 2481 } 2482 break; 2483 case GL_RGBA: 2484 for (i=0;i<n;i++) { 2485 dst[i*4+0] = FLOAT_TO_INT(rgba[i][RCOMP]); 2486 dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]); 2487 dst[i*4+2] = FLOAT_TO_INT(rgba[i][BCOMP]); 2488 dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]); 2489 } 2490 break; 2491 case GL_BGR: 2492 for (i=0;i<n;i++) { 2493 dst[i*3+0] = FLOAT_TO_INT(rgba[i][BCOMP]); 2494 dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]); 2495 dst[i*3+2] = FLOAT_TO_INT(rgba[i][RCOMP]); 2496 } 2497 break; 2498 case GL_BGRA: 2499 for (i=0;i<n;i++) { 2500 dst[i*4+0] = FLOAT_TO_INT(rgba[i][BCOMP]); 2501 dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]); 2502 dst[i*4+2] = FLOAT_TO_INT(rgba[i][RCOMP]); 2503 dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]); 2504 } 2505 break; 2506 case GL_ABGR_EXT: 2507 for (i=0;i<n;i++) { 2508 dst[i*4+0] = FLOAT_TO_INT(rgba[i][ACOMP]); 2509 dst[i*4+1] = FLOAT_TO_INT(rgba[i][BCOMP]); 2510 dst[i*4+2] = FLOAT_TO_INT(rgba[i][GCOMP]); 2511 dst[i*4+3] = FLOAT_TO_INT(rgba[i][RCOMP]); 2512 } 2513 break; 2514 case GL_DUDV_ATI: 2515 case GL_DU8DV8_ATI: 2516 for (i=0;i<n;i++) { 2517 dst[i*2+0] = FLOAT_TO_INT(rgba[i][RCOMP]); 2518 dst[i*2+1] = FLOAT_TO_INT(rgba[i][GCOMP]); 2519 } 2520 break; 2521 default: 2522 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); 2523 } 2524 } 2525 break; 2526 case GL_FLOAT: 2527 { 2528 GLfloat *dst = (GLfloat *) dstAddr; 2529 switch (dstFormat) { 2530 case GL_RED: 2531 for (i=0;i<n;i++) 2532 dst[i] = rgba[i][RCOMP]; 2533 break; 2534 case GL_GREEN: 2535 for (i=0;i<n;i++) 2536 dst[i] = rgba[i][GCOMP]; 2537 break; 2538 case GL_BLUE: 2539 for (i=0;i<n;i++) 2540 dst[i] = rgba[i][BCOMP]; 2541 break; 2542 case GL_ALPHA: 2543 for (i=0;i<n;i++) 2544 dst[i] = rgba[i][ACOMP]; 2545 break; 2546 case GL_LUMINANCE: 2547 for (i=0;i<n;i++) 2548 dst[i] = luminance[i]; 2549 break; 2550 case GL_LUMINANCE_ALPHA: 2551 for (i=0;i<n;i++) { 2552 dst[i*2+0] = luminance[i]; 2553 dst[i*2+1] = rgba[i][ACOMP]; 2554 } 2555 break; 2556 case GL_RGB: 2557 for (i=0;i<n;i++) { 2558 dst[i*3+0] = rgba[i][RCOMP]; 2559 dst[i*3+1] = rgba[i][GCOMP]; 2560 dst[i*3+2] = rgba[i][BCOMP]; 2561 } 2562 break; 2563 case GL_RGBA: 2564 for (i=0;i<n;i++) { 2565 dst[i*4+0] = rgba[i][RCOMP]; 2566 dst[i*4+1] = rgba[i][GCOMP]; 2567 dst[i*4+2] = rgba[i][BCOMP]; 2568 dst[i*4+3] = rgba[i][ACOMP]; 2569 } 2570 break; 2571 case GL_BGR: 2572 for (i=0;i<n;i++) { 2573 dst[i*3+0] = rgba[i][BCOMP]; 2574 dst[i*3+1] = rgba[i][GCOMP]; 2575 dst[i*3+2] = rgba[i][RCOMP]; 2576 } 2577 break; 2578 case GL_BGRA: 2579 for (i=0;i<n;i++) { 2580 dst[i*4+0] = rgba[i][BCOMP]; 2581 dst[i*4+1] = rgba[i][GCOMP]; 2582 dst[i*4+2] = rgba[i][RCOMP]; 2583 dst[i*4+3] = rgba[i][ACOMP]; 2584 } 2585 break; 2586 case GL_ABGR_EXT: 2587 for (i=0;i<n;i++) { 2588 dst[i*4+0] = rgba[i][ACOMP]; 2589 dst[i*4+1] = rgba[i][BCOMP]; 2590 dst[i*4+2] = rgba[i][GCOMP]; 2591 dst[i*4+3] = rgba[i][RCOMP]; 2592 } 2593 break; 2594 case GL_DUDV_ATI: 2595 case GL_DU8DV8_ATI: 2596 for (i=0;i<n;i++) { 2597 dst[i*2+0] = rgba[i][RCOMP]; 2598 dst[i*2+1] = rgba[i][GCOMP]; 2599 } 2600 break; 2601 default: 2602 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); 2603 } 2604 } 2605 break; 2606 case GL_HALF_FLOAT_ARB: 2607 { 2608 GLhalfARB *dst = (GLhalfARB *) dstAddr; 2609 switch (dstFormat) { 2610 case GL_RED: 2611 for (i=0;i<n;i++) 2612 dst[i] = _mesa_float_to_half(rgba[i][RCOMP]); 2613 break; 2614 case GL_GREEN: 2615 for (i=0;i<n;i++) 2616 dst[i] = _mesa_float_to_half(rgba[i][GCOMP]); 2617 break; 2618 case GL_BLUE: 2619 for (i=0;i<n;i++) 2620 dst[i] = _mesa_float_to_half(rgba[i][BCOMP]); 2621 break; 2622 case GL_ALPHA: 2623 for (i=0;i<n;i++) 2624 dst[i] = _mesa_float_to_half(rgba[i][ACOMP]); 2625 break; 2626 case GL_LUMINANCE: 2627 for (i=0;i<n;i++) 2628 dst[i] = _mesa_float_to_half(luminance[i]); 2629 break; 2630 case GL_LUMINANCE_ALPHA: 2631 for (i=0;i<n;i++) { 2632 dst[i*2+0] = _mesa_float_to_half(luminance[i]); 2633 dst[i*2+1] = _mesa_float_to_half(rgba[i][ACOMP]); 2634 } 2635 break; 2636 case GL_RGB: 2637 for (i=0;i<n;i++) { 2638 dst[i*3+0] = _mesa_float_to_half(rgba[i][RCOMP]); 2639 dst[i*3+1] = _mesa_float_to_half(rgba[i][GCOMP]); 2640 dst[i*3+2] = _mesa_float_to_half(rgba[i][BCOMP]); 2641 } 2642 break; 2643 case GL_RGBA: 2644 for (i=0;i<n;i++) { 2645 dst[i*4+0] = _mesa_float_to_half(rgba[i][RCOMP]); 2646 dst[i*4+1] = _mesa_float_to_half(rgba[i][GCOMP]); 2647 dst[i*4+2] = _mesa_float_to_half(rgba[i][BCOMP]); 2648 dst[i*4+3] = _mesa_float_to_half(rgba[i][ACOMP]); 2649 } 2650 break; 2651 case GL_BGR: 2652 for (i=0;i<n;i++) { 2653 dst[i*3+0] = _mesa_float_to_half(rgba[i][BCOMP]); 2654 dst[i*3+1] = _mesa_float_to_half(rgba[i][GCOMP]); 2655 dst[i*3+2] = _mesa_float_to_half(rgba[i][RCOMP]); 2656 } 2657 break; 2658 case GL_BGRA: 2659 for (i=0;i<n;i++) { 2660 dst[i*4+0] = _mesa_float_to_half(rgba[i][BCOMP]); 2661 dst[i*4+1] = _mesa_float_to_half(rgba[i][GCOMP]); 2662 dst[i*4+2] = _mesa_float_to_half(rgba[i][RCOMP]); 2663 dst[i*4+3] = _mesa_float_to_half(rgba[i][ACOMP]); 2664 } 2665 break; 2666 case GL_ABGR_EXT: 2667 for (i=0;i<n;i++) { 2668 dst[i*4+0] = _mesa_float_to_half(rgba[i][ACOMP]); 2669 dst[i*4+1] = _mesa_float_to_half(rgba[i][BCOMP]); 2670 dst[i*4+2] = _mesa_float_to_half(rgba[i][GCOMP]); 2671 dst[i*4+3] = _mesa_float_to_half(rgba[i][RCOMP]); 2672 } 2673 break; 2674 case GL_DUDV_ATI: 2675 case GL_DU8DV8_ATI: 2676 for (i=0;i<n;i++) { 2677 dst[i*2+0] = _mesa_float_to_half(rgba[i][RCOMP]); 2678 dst[i*2+1] = _mesa_float_to_half(rgba[i][GCOMP]); 2679 } 2680 break; 2681 default: 2682 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); 2683 } 2684 } 2685 break; 2686 case GL_UNSIGNED_BYTE_3_3_2: 2687 if (dstFormat == GL_RGB) { 2688 GLubyte *dst = (GLubyte *) dstAddr; 2689 for (i=0;i<n;i++) { 2690 dst[i] = (IROUND(rgba[i][RCOMP] * 7.0F) << 5) 2691 | (IROUND(rgba[i][GCOMP] * 7.0F) << 2) 2692 | (IROUND(rgba[i][BCOMP] * 3.0F) ); 2693 } 2694 } 2695 break; 2696 case GL_UNSIGNED_BYTE_2_3_3_REV: 2697 if (dstFormat == GL_RGB) { 2698 GLubyte *dst = (GLubyte *) dstAddr; 2699 for (i=0;i<n;i++) { 2700 dst[i] = (IROUND(rgba[i][RCOMP] * 7.0F) ) 2701 | (IROUND(rgba[i][GCOMP] * 7.0F) << 3) 2702 | (IROUND(rgba[i][BCOMP] * 3.0F) << 6); 2703 } 2704 } 2705 break; 2706 case GL_UNSIGNED_SHORT_5_6_5: 2707 if (dstFormat == GL_RGB) { 2708 GLushort *dst = (GLushort *) dstAddr; 2709 for (i=0;i<n;i++) { 2710 dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F) << 11) 2711 | (IROUND(rgba[i][GCOMP] * 63.0F) << 5) 2712 | (IROUND(rgba[i][BCOMP] * 31.0F) ); 2713 } 2714 } 2715 break; 2716 case GL_UNSIGNED_SHORT_5_6_5_REV: 2717 if (dstFormat == GL_RGB) { 2718 GLushort *dst = (GLushort *) dstAddr; 2719 for (i=0;i<n;i++) { 2720 dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F) ) 2721 | (IROUND(rgba[i][GCOMP] * 63.0F) << 5) 2722 | (IROUND(rgba[i][BCOMP] * 31.0F) << 11); 2723 } 2724 } 2725 break; 2726 case GL_UNSIGNED_SHORT_4_4_4_4: 2727 if (dstFormat == GL_RGBA) { 2728 GLushort *dst = (GLushort *) dstAddr; 2729 for (i=0;i<n;i++) { 2730 dst[i] = (IROUND(rgba[i][RCOMP] * 15.0F) << 12) 2731 | (IROUND(rgba[i][GCOMP] * 15.0F) << 8) 2732 | (IROUND(rgba[i][BCOMP] * 15.0F) << 4) 2733 | (IROUND(rgba[i][ACOMP] * 15.0F) ); 2734 } 2735 } 2736 else if (dstFormat == GL_BGRA) { 2737 GLushort *dst = (GLushort *) dstAddr; 2738 for (i=0;i<n;i++) { 2739 dst[i] = (IROUND(rgba[i][BCOMP] * 15.0F) << 12) 2740 | (IROUND(rgba[i][GCOMP] * 15.0F) << 8) 2741 | (IROUND(rgba[i][RCOMP] * 15.0F) << 4) 2742 | (IROUND(rgba[i][ACOMP] * 15.0F) ); 2743 } 2744 } 2745 else if (dstFormat == GL_ABGR_EXT) { 2746 GLushort *dst = (GLushort *) dstAddr; 2747 for (i=0;i<n;i++) { 2748 dst[i] = (IROUND(rgba[i][ACOMP] * 15.0F) << 12) 2749 | (IROUND(rgba[i][BCOMP] * 15.0F) << 8) 2750 | (IROUND(rgba[i][GCOMP] * 15.0F) << 4) 2751 | (IROUND(rgba[i][RCOMP] * 15.0F) ); 2752 } 2753 } 2754 break; 2755 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 2756 if (dstFormat == GL_RGBA) { 2757 GLushort *dst = (GLushort *) dstAddr; 2758 for (i=0;i<n;i++) { 2759 dst[i] = (IROUND(rgba[i][RCOMP] * 15.0F) ) 2760 | (IROUND(rgba[i][GCOMP] * 15.0F) << 4) 2761 | (IROUND(rgba[i][BCOMP] * 15.0F) << 8) 2762 | (IROUND(rgba[i][ACOMP] * 15.0F) << 12); 2763 } 2764 } 2765 else if (dstFormat == GL_BGRA) { 2766 GLushort *dst = (GLushort *) dstAddr; 2767 for (i=0;i<n;i++) { 2768 dst[i] = (IROUND(rgba[i][BCOMP] * 15.0F) ) 2769 | (IROUND(rgba[i][GCOMP] * 15.0F) << 4) 2770 | (IROUND(rgba[i][RCOMP] * 15.0F) << 8) 2771 | (IROUND(rgba[i][ACOMP] * 15.0F) << 12); 2772 } 2773 } 2774 else if (dstFormat == GL_ABGR_EXT) { 2775 GLushort *dst = (GLushort *) dstAddr; 2776 for (i=0;i<n;i++) { 2777 dst[i] = (IROUND(rgba[i][ACOMP] * 15.0F) ) 2778 | (IROUND(rgba[i][BCOMP] * 15.0F) << 4) 2779 | (IROUND(rgba[i][GCOMP] * 15.0F) << 8) 2780 | (IROUND(rgba[i][RCOMP] * 15.0F) << 12); 2781 } 2782 } 2783 break; 2784 case GL_UNSIGNED_SHORT_5_5_5_1: 2785 if (dstFormat == GL_RGBA) { 2786 GLushort *dst = (GLushort *) dstAddr; 2787 for (i=0;i<n;i++) { 2788 dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F) << 11) 2789 | (IROUND(rgba[i][GCOMP] * 31.0F) << 6) 2790 | (IROUND(rgba[i][BCOMP] * 31.0F) << 1) 2791 | (IROUND(rgba[i][ACOMP] * 1.0F) ); 2792 } 2793 } 2794 else if (dstFormat == GL_BGRA) { 2795 GLushort *dst = (GLushort *) dstAddr; 2796 for (i=0;i<n;i++) { 2797 dst[i] = (IROUND(rgba[i][BCOMP] * 31.0F) << 11) 2798 | (IROUND(rgba[i][GCOMP] * 31.0F) << 6) 2799 | (IROUND(rgba[i][RCOMP] * 31.0F) << 1) 2800 | (IROUND(rgba[i][ACOMP] * 1.0F) ); 2801 } 2802 } 2803 else if (dstFormat == GL_ABGR_EXT) { 2804 GLushort *dst = (GLushort *) dstAddr; 2805 for (i=0;i<n;i++) { 2806 dst[i] = (IROUND(rgba[i][ACOMP] * 31.0F) << 11) 2807 | (IROUND(rgba[i][BCOMP] * 31.0F) << 6) 2808 | (IROUND(rgba[i][GCOMP] * 31.0F) << 1) 2809 | (IROUND(rgba[i][RCOMP] * 1.0F) ); 2810 } 2811 } 2812 break; 2813 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 2814 if (dstFormat == GL_RGBA) { 2815 GLushort *dst = (GLushort *) dstAddr; 2816 for (i=0;i<n;i++) { 2817 dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F) ) 2818 | (IROUND(rgba[i][GCOMP] * 31.0F) << 5) 2819 | (IROUND(rgba[i][BCOMP] * 31.0F) << 10) 2820 | (IROUND(rgba[i][ACOMP] * 1.0F) << 15); 2821 } 2822 } 2823 else if (dstFormat == GL_BGRA) { 2824 GLushort *dst = (GLushort *) dstAddr; 2825 for (i=0;i<n;i++) { 2826 dst[i] = (IROUND(rgba[i][BCOMP] * 31.0F) ) 2827 | (IROUND(rgba[i][GCOMP] * 31.0F) << 5) 2828 | (IROUND(rgba[i][RCOMP] * 31.0F) << 10) 2829 | (IROUND(rgba[i][ACOMP] * 1.0F) << 15); 2830 } 2831 } 2832 else if (dstFormat == GL_ABGR_EXT) { 2833 GLushort *dst = (GLushort *) dstAddr; 2834 for (i=0;i<n;i++) { 2835 dst[i] = (IROUND(rgba[i][ACOMP] * 31.0F) ) 2836 | (IROUND(rgba[i][BCOMP] * 31.0F) << 5) 2837 | (IROUND(rgba[i][GCOMP] * 31.0F) << 10) 2838 | (IROUND(rgba[i][RCOMP] * 1.0F) << 15); 2839 } 2840 } 2841 break; 2842 case GL_UNSIGNED_INT_8_8_8_8: 2843 if (dstFormat == GL_RGBA) { 2844 GLuint *dst = (GLuint *) dstAddr; 2845 for (i=0;i<n;i++) { 2846 dst[i] = (IROUND(rgba[i][RCOMP] * 255.F) << 24) 2847 | (IROUND(rgba[i][GCOMP] * 255.F) << 16) 2848 | (IROUND(rgba[i][BCOMP] * 255.F) << 8) 2849 | (IROUND(rgba[i][ACOMP] * 255.F) ); 2850 } 2851 } 2852 else if (dstFormat == GL_BGRA) { 2853 GLuint *dst = (GLuint *) dstAddr; 2854 for (i=0;i<n;i++) { 2855 dst[i] = (IROUND(rgba[i][BCOMP] * 255.F) << 24) 2856 | (IROUND(rgba[i][GCOMP] * 255.F) << 16) 2857 | (IROUND(rgba[i][RCOMP] * 255.F) << 8) 2858 | (IROUND(rgba[i][ACOMP] * 255.F) ); 2859 } 2860 } 2861 else if (dstFormat == GL_ABGR_EXT) { 2862 GLuint *dst = (GLuint *) dstAddr; 2863 for (i=0;i<n;i++) { 2864 dst[i] = (IROUND(rgba[i][ACOMP] * 255.F) << 24) 2865 | (IROUND(rgba[i][BCOMP] * 255.F) << 16) 2866 | (IROUND(rgba[i][GCOMP] * 255.F) << 8) 2867 | (IROUND(rgba[i][RCOMP] * 255.F) ); 2868 } 2869 } 2870 break; 2871 case GL_UNSIGNED_INT_8_8_8_8_REV: 2872 if (dstFormat == GL_RGBA) { 2873 GLuint *dst = (GLuint *) dstAddr; 2874 for (i=0;i<n;i++) { 2875 dst[i] = (IROUND(rgba[i][RCOMP] * 255.0F) ) 2876 | (IROUND(rgba[i][GCOMP] * 255.0F) << 8) 2877 | (IROUND(rgba[i][BCOMP] * 255.0F) << 16) 2878 | (IROUND(rgba[i][ACOMP] * 255.0F) << 24); 2879 } 2880 } 2881 else if (dstFormat == GL_BGRA) { 2882 GLuint *dst = (GLuint *) dstAddr; 2883 for (i=0;i<n;i++) { 2884 dst[i] = (IROUND(rgba[i][BCOMP] * 255.0F) ) 2885 | (IROUND(rgba[i][GCOMP] * 255.0F) << 8) 2886 | (IROUND(rgba[i][RCOMP] * 255.0F) << 16) 2887 | (IROUND(rgba[i][ACOMP] * 255.0F) << 24); 2888 } 2889 } 2890 else if (dstFormat == GL_ABGR_EXT) { 2891 GLuint *dst = (GLuint *) dstAddr; 2892 for (i=0;i<n;i++) { 2893 dst[i] = (IROUND(rgba[i][ACOMP] * 255.0F) ) 2894 | (IROUND(rgba[i][BCOMP] * 255.0F) << 8) 2895 | (IROUND(rgba[i][GCOMP] * 255.0F) << 16) 2896 | (IROUND(rgba[i][RCOMP] * 255.0F) << 24); 2897 } 2898 } 2899 break; 2900 case GL_UNSIGNED_INT_10_10_10_2: 2901 if (dstFormat == GL_RGBA) { 2902 GLuint *dst = (GLuint *) dstAddr; 2903 for (i=0;i<n;i++) { 2904 dst[i] = (IROUND(rgba[i][RCOMP] * 1023.0F) << 22) 2905 | (IROUND(rgba[i][GCOMP] * 1023.0F) << 12) 2906 | (IROUND(rgba[i][BCOMP] * 1023.0F) << 2) 2907 | (IROUND(rgba[i][ACOMP] * 3.0F) ); 2908 } 2909 } 2910 else if (dstFormat == GL_BGRA) { 2911 GLuint *dst = (GLuint *) dstAddr; 2912 for (i=0;i<n;i++) { 2913 dst[i] = (IROUND(rgba[i][BCOMP] * 1023.0F) << 22) 2914 | (IROUND(rgba[i][GCOMP] * 1023.0F) << 12) 2915 | (IROUND(rgba[i][RCOMP] * 1023.0F) << 2) 2916 | (IROUND(rgba[i][ACOMP] * 3.0F) ); 2917 } 2918 } 2919 else if (dstFormat == GL_ABGR_EXT) { 2920 GLuint *dst = (GLuint *) dstAddr; 2921 for (i=0;i<n;i++) { 2922 dst[i] = (IROUND(rgba[i][ACOMP] * 1023.0F) << 22) 2923 | (IROUND(rgba[i][BCOMP] * 1023.0F) << 12) 2924 | (IROUND(rgba[i][GCOMP] * 1023.0F) << 2) 2925 | (IROUND(rgba[i][RCOMP] * 3.0F) ); 2926 } 2927 } 2928 break; 2929 case GL_UNSIGNED_INT_2_10_10_10_REV: 2930 if (dstFormat == GL_RGBA) { 2931 GLuint *dst = (GLuint *) dstAddr; 2932 for (i=0;i<n;i++) { 2933 dst[i] = (IROUND(rgba[i][RCOMP] * 1023.0F) ) 2934 | (IROUND(rgba[i][GCOMP] * 1023.0F) << 10) 2935 | (IROUND(rgba[i][BCOMP] * 1023.0F) << 20) 2936 | (IROUND(rgba[i][ACOMP] * 3.0F) << 30); 2937 } 2938 } 2939 else if (dstFormat == GL_BGRA) { 2940 GLuint *dst = (GLuint *) dstAddr; 2941 for (i=0;i<n;i++) { 2942 dst[i] = (IROUND(rgba[i][BCOMP] * 1023.0F) ) 2943 | (IROUND(rgba[i][GCOMP] * 1023.0F) << 10) 2944 | (IROUND(rgba[i][RCOMP] * 1023.0F) << 20) 2945 | (IROUND(rgba[i][ACOMP] * 3.0F) << 30); 2946 } 2947 } 2948 else if (dstFormat == GL_ABGR_EXT) { 2949 GLuint *dst = (GLuint *) dstAddr; 2950 for (i=0;i<n;i++) { 2951 dst[i] = (IROUND(rgba[i][ACOMP] * 1023.0F) ) 2952 | (IROUND(rgba[i][BCOMP] * 1023.0F) << 10) 2953 | (IROUND(rgba[i][GCOMP] * 1023.0F) << 20) 2954 | (IROUND(rgba[i][RCOMP] * 3.0F) << 30); 2955 } 2956 } 2957 break; 2958 default: 2959 _mesa_problem(ctx, "bad type in _mesa_pack_rgba_span_float"); 2960 return; 2961 } 2962 2963 if (dstPacking->SwapBytes) { 2964 GLint swapSize = _mesa_sizeof_packed_type(dstType); 2965 if (swapSize == 2) { 2966 if (dstPacking->SwapBytes) { 2967 _mesa_swap2((GLushort *) dstAddr, n * comps); 2968 } 2969 } 2970 else if (swapSize == 4) { 2971 if (dstPacking->SwapBytes) { 2972 _mesa_swap4((GLuint *) dstAddr, n * comps); 2973 } 2974 } 2975 } 2976} 2977 2978 2979#define SWAP2BYTE(VALUE) \ 2980 { \ 2981 GLubyte *bytes = (GLubyte *) &(VALUE); \ 2982 GLubyte tmp = bytes[0]; \ 2983 bytes[0] = bytes[1]; \ 2984 bytes[1] = tmp; \ 2985 } 2986 2987#define SWAP4BYTE(VALUE) \ 2988 { \ 2989 GLubyte *bytes = (GLubyte *) &(VALUE); \ 2990 GLubyte tmp = bytes[0]; \ 2991 bytes[0] = bytes[3]; \ 2992 bytes[3] = tmp; \ 2993 tmp = bytes[1]; \ 2994 bytes[1] = bytes[2]; \ 2995 bytes[2] = tmp; \ 2996 } 2997 2998 2999static void 3000extract_uint_indexes(GLuint n, GLuint indexes[], 3001 GLenum srcFormat, GLenum srcType, const GLvoid *src, 3002 const struct gl_pixelstore_attrib *unpack ) 3003{ 3004 ASSERT(srcFormat == GL_COLOR_INDEX || srcFormat == GL_STENCIL_INDEX); 3005 3006 ASSERT(srcType == GL_BITMAP || 3007 srcType == GL_UNSIGNED_BYTE || 3008 srcType == GL_BYTE || 3009 srcType == GL_UNSIGNED_SHORT || 3010 srcType == GL_SHORT || 3011 srcType == GL_UNSIGNED_INT || 3012 srcType == GL_INT || 3013 srcType == GL_UNSIGNED_INT_24_8_EXT || 3014 srcType == GL_HALF_FLOAT_ARB || 3015 srcType == GL_FLOAT); 3016 3017 switch (srcType) { 3018 case GL_BITMAP: 3019 { 3020 GLubyte *ubsrc = (GLubyte *) src; 3021 if (unpack->LsbFirst) { 3022 GLubyte mask = 1 << (unpack->SkipPixels & 0x7); 3023 GLuint i; 3024 for (i = 0; i < n; i++) { 3025 indexes[i] = (*ubsrc & mask) ? 1 : 0; 3026 if (mask == 128) { 3027 mask = 1; 3028 ubsrc++; 3029 } 3030 else { 3031 mask = mask << 1; 3032 } 3033 } 3034 } 3035 else { 3036 GLubyte mask = 128 >> (unpack->SkipPixels & 0x7); 3037 GLuint i; 3038 for (i = 0; i < n; i++) { 3039 indexes[i] = (*ubsrc & mask) ? 1 : 0; 3040 if (mask == 1) { 3041 mask = 128; 3042 ubsrc++; 3043 } 3044 else { 3045 mask = mask >> 1; 3046 } 3047 } 3048 } 3049 } 3050 break; 3051 case GL_UNSIGNED_BYTE: 3052 { 3053 GLuint i; 3054 const GLubyte *s = (const GLubyte *) src; 3055 for (i = 0; i < n; i++) 3056 indexes[i] = s[i]; 3057 } 3058 break; 3059 case GL_BYTE: 3060 { 3061 GLuint i; 3062 const GLbyte *s = (const GLbyte *) src; 3063 for (i = 0; i < n; i++) 3064 indexes[i] = s[i]; 3065 } 3066 break; 3067 case GL_UNSIGNED_SHORT: 3068 { 3069 GLuint i; 3070 const GLushort *s = (const GLushort *) src; 3071 if (unpack->SwapBytes) { 3072 for (i = 0; i < n; i++) { 3073 GLushort value = s[i]; 3074 SWAP2BYTE(value); 3075 indexes[i] = value; 3076 } 3077 } 3078 else { 3079 for (i = 0; i < n; i++) 3080 indexes[i] = s[i]; 3081 } 3082 } 3083 break; 3084 case GL_SHORT: 3085 { 3086 GLuint i; 3087 const GLshort *s = (const GLshort *) src; 3088 if (unpack->SwapBytes) { 3089 for (i = 0; i < n; i++) { 3090 GLshort value = s[i]; 3091 SWAP2BYTE(value); 3092 indexes[i] = value; 3093 } 3094 } 3095 else { 3096 for (i = 0; i < n; i++) 3097 indexes[i] = s[i]; 3098 } 3099 } 3100 break; 3101 case GL_UNSIGNED_INT: 3102 { 3103 GLuint i; 3104 const GLuint *s = (const GLuint *) src; 3105 if (unpack->SwapBytes) { 3106 for (i = 0; i < n; i++) { 3107 GLuint value = s[i]; 3108 SWAP4BYTE(value); 3109 indexes[i] = value; 3110 } 3111 } 3112 else { 3113 for (i = 0; i < n; i++) 3114 indexes[i] = s[i]; 3115 } 3116 } 3117 break; 3118 case GL_INT: 3119 { 3120 GLuint i; 3121 const GLint *s = (const GLint *) src; 3122 if (unpack->SwapBytes) { 3123 for (i = 0; i < n; i++) { 3124 GLint value = s[i]; 3125 SWAP4BYTE(value); 3126 indexes[i] = value; 3127 } 3128 } 3129 else { 3130 for (i = 0; i < n; i++) 3131 indexes[i] = s[i]; 3132 } 3133 } 3134 break; 3135 case GL_FLOAT: 3136 { 3137 GLuint i; 3138 const GLfloat *s = (const GLfloat *) src; 3139 if (unpack->SwapBytes) { 3140 for (i = 0; i < n; i++) { 3141 GLfloat value = s[i]; 3142 SWAP4BYTE(value); 3143 indexes[i] = (GLuint) value; 3144 } 3145 } 3146 else { 3147 for (i = 0; i < n; i++) 3148 indexes[i] = (GLuint) s[i]; 3149 } 3150 } 3151 break; 3152 case GL_HALF_FLOAT_ARB: 3153 { 3154 GLuint i; 3155 const GLhalfARB *s = (const GLhalfARB *) src; 3156 if (unpack->SwapBytes) { 3157 for (i = 0; i < n; i++) { 3158 GLhalfARB value = s[i]; 3159 SWAP2BYTE(value); 3160 indexes[i] = (GLuint) _mesa_half_to_float(value); 3161 } 3162 } 3163 else { 3164 for (i = 0; i < n; i++) 3165 indexes[i] = (GLuint) _mesa_half_to_float(s[i]); 3166 } 3167 } 3168 break; 3169 case GL_UNSIGNED_INT_24_8_EXT: 3170 { 3171 GLuint i; 3172 const GLuint *s = (const GLuint *) src; 3173 if (unpack->SwapBytes) { 3174 for (i = 0; i < n; i++) { 3175 GLuint value = s[i]; 3176 SWAP4BYTE(value); 3177 indexes[i] = value & 0xff; /* lower 8 bits */ 3178 } 3179 } 3180 else { 3181 for (i = 0; i < n; i++) 3182 indexes[i] = s[i] & 0xff; /* lower 8 bits */ 3183 } 3184 } 3185 break; 3186 3187 default: 3188 _mesa_problem(NULL, "bad srcType in extract_uint_indexes"); 3189 return; 3190 } 3191} 3192 3193 3194/* 3195 * This function extracts floating point RGBA values from arbitrary 3196 * image data. srcFormat and srcType are the format and type parameters 3197 * passed to glDrawPixels, glTexImage[123]D, glTexSubImage[123]D, etc. 3198 * 3199 * Refering to section 3.6.4 of the OpenGL 1.2 spec, this function 3200 * implements the "Conversion to floating point", "Conversion to RGB", 3201 * and "Final Expansion to RGBA" operations. 3202 * 3203 * Args: n - number of pixels 3204 * rgba - output colors 3205 * srcFormat - format of incoming data 3206 * srcType - data type of incoming data 3207 * src - source data pointer 3208 * swapBytes - perform byteswapping of incoming data? 3209 */ 3210static void 3211extract_float_rgba(GLuint n, GLfloat rgba[][4], 3212 GLenum srcFormat, GLenum srcType, const GLvoid *src, 3213 GLboolean swapBytes) 3214{ 3215 GLint redIndex, greenIndex, blueIndex, alphaIndex; 3216 GLint stride; 3217 GLint rComp, bComp, gComp, aComp; 3218 3219 ASSERT(srcFormat == GL_RED || 3220 srcFormat == GL_GREEN || 3221 srcFormat == GL_BLUE || 3222 srcFormat == GL_ALPHA || 3223 srcFormat == GL_LUMINANCE || 3224 srcFormat == GL_LUMINANCE_ALPHA || 3225 srcFormat == GL_INTENSITY || 3226 srcFormat == GL_RGB || 3227 srcFormat == GL_BGR || 3228 srcFormat == GL_RGBA || 3229 srcFormat == GL_BGRA || 3230 srcFormat == GL_ABGR_EXT || 3231 srcFormat == GL_DU8DV8_ATI || 3232 srcFormat == GL_DUDV_ATI); 3233 3234 ASSERT(srcType == GL_UNSIGNED_BYTE || 3235 srcType == GL_BYTE || 3236 srcType == GL_UNSIGNED_SHORT || 3237 srcType == GL_SHORT || 3238 srcType == GL_UNSIGNED_INT || 3239 srcType == GL_INT || 3240 srcType == GL_HALF_FLOAT_ARB || 3241 srcType == GL_FLOAT || 3242 srcType == GL_UNSIGNED_BYTE_3_3_2 || 3243 srcType == GL_UNSIGNED_BYTE_2_3_3_REV || 3244 srcType == GL_UNSIGNED_SHORT_5_6_5 || 3245 srcType == GL_UNSIGNED_SHORT_5_6_5_REV || 3246 srcType == GL_UNSIGNED_SHORT_4_4_4_4 || 3247 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV || 3248 srcType == GL_UNSIGNED_SHORT_5_5_5_1 || 3249 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV || 3250 srcType == GL_UNSIGNED_INT_8_8_8_8 || 3251 srcType == GL_UNSIGNED_INT_8_8_8_8_REV || 3252 srcType == GL_UNSIGNED_INT_10_10_10_2 || 3253 srcType == GL_UNSIGNED_INT_2_10_10_10_REV); 3254 3255 rComp = gComp = bComp = aComp = -1; 3256 3257 switch (srcFormat) { 3258 case GL_RED: 3259 redIndex = 0; 3260 greenIndex = blueIndex = alphaIndex = -1; 3261 stride = 1; 3262 break; 3263 case GL_GREEN: 3264 greenIndex = 0; 3265 redIndex = blueIndex = alphaIndex = -1; 3266 stride = 1; 3267 break; 3268 case GL_BLUE: 3269 blueIndex = 0; 3270 redIndex = greenIndex = alphaIndex = -1; 3271 stride = 1; 3272 break; 3273 case GL_ALPHA: 3274 redIndex = greenIndex = blueIndex = -1; 3275 alphaIndex = 0; 3276 stride = 1; 3277 break; 3278 case GL_LUMINANCE: 3279 redIndex = greenIndex = blueIndex = 0; 3280 alphaIndex = -1; 3281 stride = 1; 3282 break; 3283 case GL_LUMINANCE_ALPHA: 3284 redIndex = greenIndex = blueIndex = 0; 3285 alphaIndex = 1; 3286 stride = 2; 3287 break; 3288 case GL_INTENSITY: 3289 redIndex = greenIndex = blueIndex = alphaIndex = 0; 3290 stride = 1; 3291 break; 3292 case GL_RGB: 3293 redIndex = 0; 3294 greenIndex = 1; 3295 blueIndex = 2; 3296 alphaIndex = -1; 3297 rComp = 0; 3298 gComp = 1; 3299 bComp = 2; 3300 aComp = 3; 3301 stride = 3; 3302 break; 3303 case GL_BGR: 3304 redIndex = 2; 3305 greenIndex = 1; 3306 blueIndex = 0; 3307 alphaIndex = -1; 3308 rComp = 2; 3309 gComp = 1; 3310 bComp = 0; 3311 aComp = 3; 3312 stride = 3; 3313 break; 3314 case GL_RGBA: 3315 redIndex = 0; 3316 greenIndex = 1; 3317 blueIndex = 2; 3318 alphaIndex = 3; 3319 rComp = 0; 3320 gComp = 1; 3321 bComp = 2; 3322 aComp = 3; 3323 stride = 4; 3324 break; 3325 case GL_BGRA: 3326 redIndex = 2; 3327 greenIndex = 1; 3328 blueIndex = 0; 3329 alphaIndex = 3; 3330 rComp = 2; 3331 gComp = 1; 3332 bComp = 0; 3333 aComp = 3; 3334 stride = 4; 3335 break; 3336 case GL_ABGR_EXT: 3337 redIndex = 3; 3338 greenIndex = 2; 3339 blueIndex = 1; 3340 alphaIndex = 0; 3341 rComp = 3; 3342 gComp = 2; 3343 bComp = 1; 3344 aComp = 0; 3345 stride = 4; 3346 break; 3347 case GL_DU8DV8_ATI: 3348 case GL_DUDV_ATI: 3349 redIndex = 0; 3350 greenIndex = 1; 3351 blueIndex = -1; 3352 alphaIndex = -1; 3353 stride = 2; 3354 break; 3355 default: 3356 _mesa_problem(NULL, "bad srcFormat %s in extract float data", 3357 _mesa_lookup_enum_by_nr(srcFormat)); 3358 return; 3359 } 3360 3361 3362#define PROCESS(INDEX, CHANNEL, DEFAULT, TYPE, CONVERSION) \ 3363 if ((INDEX) < 0) { \ 3364 GLuint i; \ 3365 for (i = 0; i < n; i++) { \ 3366 rgba[i][CHANNEL] = DEFAULT; \ 3367 } \ 3368 } \ 3369 else if (swapBytes) { \ 3370 const TYPE *s = (const TYPE *) src; \ 3371 GLuint i; \ 3372 for (i = 0; i < n; i++) { \ 3373 TYPE value = s[INDEX]; \ 3374 if (sizeof(TYPE) == 2) { \ 3375 SWAP2BYTE(value); \ 3376 } \ 3377 else if (sizeof(TYPE) == 4) { \ 3378 SWAP4BYTE(value); \ 3379 } \ 3380 rgba[i][CHANNEL] = (GLfloat) CONVERSION(value); \ 3381 s += stride; \ 3382 } \ 3383 } \ 3384 else { \ 3385 const TYPE *s = (const TYPE *) src; \ 3386 GLuint i; \ 3387 for (i = 0; i < n; i++) { \ 3388 rgba[i][CHANNEL] = (GLfloat) CONVERSION(s[INDEX]); \ 3389 s += stride; \ 3390 } \ 3391 } 3392 3393 switch (srcType) { 3394 case GL_UNSIGNED_BYTE: 3395 PROCESS(redIndex, RCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT); 3396 PROCESS(greenIndex, GCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT); 3397 PROCESS(blueIndex, BCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT); 3398 PROCESS(alphaIndex, ACOMP, 1.0F, GLubyte, UBYTE_TO_FLOAT); 3399 break; 3400 case GL_BYTE: 3401 PROCESS(redIndex, RCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT); 3402 PROCESS(greenIndex, GCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT); 3403 PROCESS(blueIndex, BCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT); 3404 PROCESS(alphaIndex, ACOMP, 1.0F, GLbyte, BYTE_TO_FLOAT); 3405 break; 3406 case GL_UNSIGNED_SHORT: 3407 PROCESS(redIndex, RCOMP, 0.0F, GLushort, USHORT_TO_FLOAT); 3408 PROCESS(greenIndex, GCOMP, 0.0F, GLushort, USHORT_TO_FLOAT); 3409 PROCESS(blueIndex, BCOMP, 0.0F, GLushort, USHORT_TO_FLOAT); 3410 PROCESS(alphaIndex, ACOMP, 1.0F, GLushort, USHORT_TO_FLOAT); 3411 break; 3412 case GL_SHORT: 3413 PROCESS(redIndex, RCOMP, 0.0F, GLshort, SHORT_TO_FLOAT); 3414 PROCESS(greenIndex, GCOMP, 0.0F, GLshort, SHORT_TO_FLOAT); 3415 PROCESS(blueIndex, BCOMP, 0.0F, GLshort, SHORT_TO_FLOAT); 3416 PROCESS(alphaIndex, ACOMP, 1.0F, GLshort, SHORT_TO_FLOAT); 3417 break; 3418 case GL_UNSIGNED_INT: 3419 PROCESS(redIndex, RCOMP, 0.0F, GLuint, UINT_TO_FLOAT); 3420 PROCESS(greenIndex, GCOMP, 0.0F, GLuint, UINT_TO_FLOAT); 3421 PROCESS(blueIndex, BCOMP, 0.0F, GLuint, UINT_TO_FLOAT); 3422 PROCESS(alphaIndex, ACOMP, 1.0F, GLuint, UINT_TO_FLOAT); 3423 break; 3424 case GL_INT: 3425 PROCESS(redIndex, RCOMP, 0.0F, GLint, INT_TO_FLOAT); 3426 PROCESS(greenIndex, GCOMP, 0.0F, GLint, INT_TO_FLOAT); 3427 PROCESS(blueIndex, BCOMP, 0.0F, GLint, INT_TO_FLOAT); 3428 PROCESS(alphaIndex, ACOMP, 1.0F, GLint, INT_TO_FLOAT); 3429 break; 3430 case GL_FLOAT: 3431 PROCESS(redIndex, RCOMP, 0.0F, GLfloat, (GLfloat)); 3432 PROCESS(greenIndex, GCOMP, 0.0F, GLfloat, (GLfloat)); 3433 PROCESS(blueIndex, BCOMP, 0.0F, GLfloat, (GLfloat)); 3434 PROCESS(alphaIndex, ACOMP, 1.0F, GLfloat, (GLfloat)); 3435 break; 3436 case GL_HALF_FLOAT_ARB: 3437 PROCESS(redIndex, RCOMP, 0.0F, GLhalfARB, _mesa_half_to_float); 3438 PROCESS(greenIndex, GCOMP, 0.0F, GLhalfARB, _mesa_half_to_float); 3439 PROCESS(blueIndex, BCOMP, 0.0F, GLhalfARB, _mesa_half_to_float); 3440 PROCESS(alphaIndex, ACOMP, 1.0F, GLhalfARB, _mesa_half_to_float); 3441 break; 3442 case GL_UNSIGNED_BYTE_3_3_2: 3443 { 3444 const GLubyte *ubsrc = (const GLubyte *) src; 3445 GLuint i; 3446 for (i = 0; i < n; i ++) { 3447 GLubyte p = ubsrc[i]; 3448 rgba[i][rComp] = ((p >> 5) ) * (1.0F / 7.0F); 3449 rgba[i][gComp] = ((p >> 2) & 0x7) * (1.0F / 7.0F); 3450 rgba[i][bComp] = ((p ) & 0x3) * (1.0F / 3.0F); 3451 rgba[i][aComp] = 1.0F; 3452 } 3453 } 3454 break; 3455 case GL_UNSIGNED_BYTE_2_3_3_REV: 3456 { 3457 const GLubyte *ubsrc = (const GLubyte *) src; 3458 GLuint i; 3459 for (i = 0; i < n; i ++) { 3460 GLubyte p = ubsrc[i]; 3461 rgba[i][rComp] = ((p ) & 0x7) * (1.0F / 7.0F); 3462 rgba[i][gComp] = ((p >> 3) & 0x7) * (1.0F / 7.0F); 3463 rgba[i][bComp] = ((p >> 6) ) * (1.0F / 3.0F); 3464 rgba[i][aComp] = 1.0F; 3465 } 3466 } 3467 break; 3468 case GL_UNSIGNED_SHORT_5_6_5: 3469 if (swapBytes) { 3470 const GLushort *ussrc = (const GLushort *) src; 3471 GLuint i; 3472 for (i = 0; i < n; i ++) { 3473 GLushort p = ussrc[i]; 3474 SWAP2BYTE(p); 3475 rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F); 3476 rgba[i][gComp] = ((p >> 5) & 0x3f) * (1.0F / 63.0F); 3477 rgba[i][bComp] = ((p ) & 0x1f) * (1.0F / 31.0F); 3478 rgba[i][aComp] = 1.0F; 3479 } 3480 } 3481 else { 3482 const GLushort *ussrc = (const GLushort *) src; 3483 GLuint i; 3484 for (i = 0; i < n; i ++) { 3485 GLushort p = ussrc[i]; 3486 rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F); 3487 rgba[i][gComp] = ((p >> 5) & 0x3f) * (1.0F / 63.0F); 3488 rgba[i][bComp] = ((p ) & 0x1f) * (1.0F / 31.0F); 3489 rgba[i][aComp] = 1.0F; 3490 } 3491 } 3492 break; 3493 case GL_UNSIGNED_SHORT_5_6_5_REV: 3494 if (swapBytes) { 3495 const GLushort *ussrc = (const GLushort *) src; 3496 GLuint i; 3497 for (i = 0; i < n; i ++) { 3498 GLushort p = ussrc[i]; 3499 SWAP2BYTE(p); 3500 rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F); 3501 rgba[i][gComp] = ((p >> 5) & 0x3f) * (1.0F / 63.0F); 3502 rgba[i][bComp] = ((p >> 11) ) * (1.0F / 31.0F); 3503 rgba[i][aComp] = 1.0F; 3504 } 3505 } 3506 else { 3507 const GLushort *ussrc = (const GLushort *) src; 3508 GLuint i; 3509 for (i = 0; i < n; i ++) { 3510 GLushort p = ussrc[i]; 3511 rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F); 3512 rgba[i][gComp] = ((p >> 5) & 0x3f) * (1.0F / 63.0F); 3513 rgba[i][bComp] = ((p >> 11) ) * (1.0F / 31.0F); 3514 rgba[i][aComp] = 1.0F; 3515 } 3516 } 3517 break; 3518 case GL_UNSIGNED_SHORT_4_4_4_4: 3519 if (swapBytes) { 3520 const GLushort *ussrc = (const GLushort *) src; 3521 GLuint i; 3522 for (i = 0; i < n; i ++) { 3523 GLushort p = ussrc[i]; 3524 SWAP2BYTE(p); 3525 rgba[i][rComp] = ((p >> 12) ) * (1.0F / 15.0F); 3526 rgba[i][gComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F); 3527 rgba[i][bComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F); 3528 rgba[i][aComp] = ((p ) & 0xf) * (1.0F / 15.0F); 3529 } 3530 } 3531 else { 3532 const GLushort *ussrc = (const GLushort *) src; 3533 GLuint i; 3534 for (i = 0; i < n; i ++) { 3535 GLushort p = ussrc[i]; 3536 rgba[i][rComp] = ((p >> 12) ) * (1.0F / 15.0F); 3537 rgba[i][gComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F); 3538 rgba[i][bComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F); 3539 rgba[i][aComp] = ((p ) & 0xf) * (1.0F / 15.0F); 3540 } 3541 } 3542 break; 3543 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 3544 if (swapBytes) { 3545 const GLushort *ussrc = (const GLushort *) src; 3546 GLuint i; 3547 for (i = 0; i < n; i ++) { 3548 GLushort p = ussrc[i]; 3549 SWAP2BYTE(p); 3550 rgba[i][rComp] = ((p ) & 0xf) * (1.0F / 15.0F); 3551 rgba[i][gComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F); 3552 rgba[i][bComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F); 3553 rgba[i][aComp] = ((p >> 12) ) * (1.0F / 15.0F); 3554 } 3555 } 3556 else { 3557 const GLushort *ussrc = (const GLushort *) src; 3558 GLuint i; 3559 for (i = 0; i < n; i ++) { 3560 GLushort p = ussrc[i]; 3561 rgba[i][rComp] = ((p ) & 0xf) * (1.0F / 15.0F); 3562 rgba[i][gComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F); 3563 rgba[i][bComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F); 3564 rgba[i][aComp] = ((p >> 12) ) * (1.0F / 15.0F); 3565 } 3566 } 3567 break; 3568 case GL_UNSIGNED_SHORT_5_5_5_1: 3569 if (swapBytes) { 3570 const GLushort *ussrc = (const GLushort *) src; 3571 GLuint i; 3572 for (i = 0; i < n; i ++) { 3573 GLushort p = ussrc[i]; 3574 SWAP2BYTE(p); 3575 rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F); 3576 rgba[i][gComp] = ((p >> 6) & 0x1f) * (1.0F / 31.0F); 3577 rgba[i][bComp] = ((p >> 1) & 0x1f) * (1.0F / 31.0F); 3578 rgba[i][aComp] = ((p ) & 0x1) * (1.0F / 1.0F); 3579 } 3580 } 3581 else { 3582 const GLushort *ussrc = (const GLushort *) src; 3583 GLuint i; 3584 for (i = 0; i < n; i ++) { 3585 GLushort p = ussrc[i]; 3586 rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F); 3587 rgba[i][gComp] = ((p >> 6) & 0x1f) * (1.0F / 31.0F); 3588 rgba[i][bComp] = ((p >> 1) & 0x1f) * (1.0F / 31.0F); 3589 rgba[i][aComp] = ((p ) & 0x1) * (1.0F / 1.0F); 3590 } 3591 } 3592 break; 3593 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 3594 if (swapBytes) { 3595 const GLushort *ussrc = (const GLushort *) src; 3596 GLuint i; 3597 for (i = 0; i < n; i ++) { 3598 GLushort p = ussrc[i]; 3599 SWAP2BYTE(p); 3600 rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F); 3601 rgba[i][gComp] = ((p >> 5) & 0x1f) * (1.0F / 31.0F); 3602 rgba[i][bComp] = ((p >> 10) & 0x1f) * (1.0F / 31.0F); 3603 rgba[i][aComp] = ((p >> 15) ) * (1.0F / 1.0F); 3604 } 3605 } 3606 else { 3607 const GLushort *ussrc = (const GLushort *) src; 3608 GLuint i; 3609 for (i = 0; i < n; i ++) { 3610 GLushort p = ussrc[i]; 3611 rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F); 3612 rgba[i][gComp] = ((p >> 5) & 0x1f) * (1.0F / 31.0F); 3613 rgba[i][bComp] = ((p >> 10) & 0x1f) * (1.0F / 31.0F); 3614 rgba[i][aComp] = ((p >> 15) ) * (1.0F / 1.0F); 3615 } 3616 } 3617 break; 3618 case GL_UNSIGNED_INT_8_8_8_8: 3619 if (swapBytes) { 3620 const GLuint *uisrc = (const GLuint *) src; 3621 GLuint i; 3622 for (i = 0; i < n; i ++) { 3623 GLuint p = uisrc[i]; 3624 rgba[i][rComp] = UBYTE_TO_FLOAT((p ) & 0xff); 3625 rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 8) & 0xff); 3626 rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff); 3627 rgba[i][aComp] = UBYTE_TO_FLOAT((p >> 24) ); 3628 } 3629 } 3630 else { 3631 const GLuint *uisrc = (const GLuint *) src; 3632 GLuint i; 3633 for (i = 0; i < n; i ++) { 3634 GLuint p = uisrc[i]; 3635 rgba[i][rComp] = UBYTE_TO_FLOAT((p >> 24) ); 3636 rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff); 3637 rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 8) & 0xff); 3638 rgba[i][aComp] = UBYTE_TO_FLOAT((p ) & 0xff); 3639 } 3640 } 3641 break; 3642 case GL_UNSIGNED_INT_8_8_8_8_REV: 3643 if (swapBytes) { 3644 const GLuint *uisrc = (const GLuint *) src; 3645 GLuint i; 3646 for (i = 0; i < n; i ++) { 3647 GLuint p = uisrc[i]; 3648 rgba[i][rComp] = UBYTE_TO_FLOAT((p >> 24) ); 3649 rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff); 3650 rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 8) & 0xff); 3651 rgba[i][aComp] = UBYTE_TO_FLOAT((p ) & 0xff); 3652 } 3653 } 3654 else { 3655 const GLuint *uisrc = (const GLuint *) src; 3656 GLuint i; 3657 for (i = 0; i < n; i ++) { 3658 GLuint p = uisrc[i]; 3659 rgba[i][rComp] = UBYTE_TO_FLOAT((p ) & 0xff); 3660 rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 8) & 0xff); 3661 rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff); 3662 rgba[i][aComp] = UBYTE_TO_FLOAT((p >> 24) ); 3663 } 3664 } 3665 break; 3666 case GL_UNSIGNED_INT_10_10_10_2: 3667 if (swapBytes) { 3668 const GLuint *uisrc = (const GLuint *) src; 3669 GLuint i; 3670 for (i = 0; i < n; i ++) { 3671 GLuint p = uisrc[i]; 3672 SWAP4BYTE(p); 3673 rgba[i][rComp] = ((p >> 22) ) * (1.0F / 1023.0F); 3674 rgba[i][gComp] = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F); 3675 rgba[i][bComp] = ((p >> 2) & 0x3ff) * (1.0F / 1023.0F); 3676 rgba[i][aComp] = ((p ) & 0x3 ) * (1.0F / 3.0F); 3677 } 3678 } 3679 else { 3680 const GLuint *uisrc = (const GLuint *) src; 3681 GLuint i; 3682 for (i = 0; i < n; i ++) { 3683 GLuint p = uisrc[i]; 3684 rgba[i][rComp] = ((p >> 22) ) * (1.0F / 1023.0F); 3685 rgba[i][gComp] = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F); 3686 rgba[i][bComp] = ((p >> 2) & 0x3ff) * (1.0F / 1023.0F); 3687 rgba[i][aComp] = ((p ) & 0x3 ) * (1.0F / 3.0F); 3688 } 3689 } 3690 break; 3691 case GL_UNSIGNED_INT_2_10_10_10_REV: 3692 if (swapBytes) { 3693 const GLuint *uisrc = (const GLuint *) src; 3694 GLuint i; 3695 for (i = 0; i < n; i ++) { 3696 GLuint p = uisrc[i]; 3697 SWAP4BYTE(p); 3698 rgba[i][rComp] = ((p ) & 0x3ff) * (1.0F / 1023.0F); 3699 rgba[i][gComp] = ((p >> 10) & 0x3ff) * (1.0F / 1023.0F); 3700 rgba[i][bComp] = ((p >> 20) & 0x3ff) * (1.0F / 1023.0F); 3701 rgba[i][aComp] = ((p >> 30) ) * (1.0F / 3.0F); 3702 } 3703 } 3704 else { 3705 const GLuint *uisrc = (const GLuint *) src; 3706 GLuint i; 3707 for (i = 0; i < n; i ++) { 3708 GLuint p = uisrc[i]; 3709 rgba[i][rComp] = ((p ) & 0x3ff) * (1.0F / 1023.0F); 3710 rgba[i][gComp] = ((p >> 10) & 0x3ff) * (1.0F / 1023.0F); 3711 rgba[i][bComp] = ((p >> 20) & 0x3ff) * (1.0F / 1023.0F); 3712 rgba[i][aComp] = ((p >> 30) ) * (1.0F / 3.0F); 3713 } 3714 } 3715 break; 3716 default: 3717 _mesa_problem(NULL, "bad srcType in extract float data"); 3718 break; 3719 } 3720} 3721 3722 3723/* 3724 * Unpack a row of color image data from a client buffer according to 3725 * the pixel unpacking parameters. 3726 * Return GLchan values in the specified dest image format. 3727 * This is used by glDrawPixels and glTexImage?D(). 3728 * \param ctx - the context 3729 * n - number of pixels in the span 3730 * dstFormat - format of destination color array 3731 * dest - the destination color array 3732 * srcFormat - source image format 3733 * srcType - source image data type 3734 * source - source image pointer 3735 * srcPacking - pixel unpacking parameters 3736 * transferOps - bitmask of IMAGE_*_BIT values of operations to apply 3737 * 3738 * XXX perhaps expand this to process whole images someday. 3739 */ 3740void 3741_mesa_unpack_color_span_chan( GLcontext *ctx, 3742 GLuint n, GLenum dstFormat, GLchan dest[], 3743 GLenum srcFormat, GLenum srcType, 3744 const GLvoid *source, 3745 const struct gl_pixelstore_attrib *srcPacking, 3746 GLbitfield transferOps ) 3747{ 3748 ASSERT(dstFormat == GL_ALPHA || 3749 dstFormat == GL_LUMINANCE || 3750 dstFormat == GL_LUMINANCE_ALPHA || 3751 dstFormat == GL_INTENSITY || 3752 dstFormat == GL_RGB || 3753 dstFormat == GL_RGBA || 3754 dstFormat == GL_COLOR_INDEX); 3755 3756 ASSERT(srcFormat == GL_RED || 3757 srcFormat == GL_GREEN || 3758 srcFormat == GL_BLUE || 3759 srcFormat == GL_ALPHA || 3760 srcFormat == GL_LUMINANCE || 3761 srcFormat == GL_LUMINANCE_ALPHA || 3762 srcFormat == GL_INTENSITY || 3763 srcFormat == GL_RGB || 3764 srcFormat == GL_BGR || 3765 srcFormat == GL_RGBA || 3766 srcFormat == GL_BGRA || 3767 srcFormat == GL_ABGR_EXT || 3768 srcFormat == GL_COLOR_INDEX); 3769 3770 ASSERT(srcType == GL_BITMAP || 3771 srcType == GL_UNSIGNED_BYTE || 3772 srcType == GL_BYTE || 3773 srcType == GL_UNSIGNED_SHORT || 3774 srcType == GL_SHORT || 3775 srcType == GL_UNSIGNED_INT || 3776 srcType == GL_INT || 3777 srcType == GL_HALF_FLOAT_ARB || 3778 srcType == GL_FLOAT || 3779 srcType == GL_UNSIGNED_BYTE_3_3_2 || 3780 srcType == GL_UNSIGNED_BYTE_2_3_3_REV || 3781 srcType == GL_UNSIGNED_SHORT_5_6_5 || 3782 srcType == GL_UNSIGNED_SHORT_5_6_5_REV || 3783 srcType == GL_UNSIGNED_SHORT_4_4_4_4 || 3784 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV || 3785 srcType == GL_UNSIGNED_SHORT_5_5_5_1 || 3786 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV || 3787 srcType == GL_UNSIGNED_INT_8_8_8_8 || 3788 srcType == GL_UNSIGNED_INT_8_8_8_8_REV || 3789 srcType == GL_UNSIGNED_INT_10_10_10_2 || 3790 srcType == GL_UNSIGNED_INT_2_10_10_10_REV); 3791 3792 /* Try simple cases first */ 3793 if (transferOps == 0) { 3794 if (srcType == CHAN_TYPE) { 3795 if (dstFormat == GL_RGBA) { 3796 if (srcFormat == GL_RGBA) { 3797 memcpy( dest, source, n * 4 * sizeof(GLchan) ); 3798 return; 3799 } 3800 else if (srcFormat == GL_RGB) { 3801 GLuint i; 3802 const GLchan *src = (const GLchan *) source; 3803 GLchan *dst = dest; 3804 for (i = 0; i < n; i++) { 3805 dst[0] = src[0]; 3806 dst[1] = src[1]; 3807 dst[2] = src[2]; 3808 dst[3] = CHAN_MAX; 3809 src += 3; 3810 dst += 4; 3811 } 3812 return; 3813 } 3814 } 3815 else if (dstFormat == GL_RGB) { 3816 if (srcFormat == GL_RGB) { 3817 memcpy( dest, source, n * 3 * sizeof(GLchan) ); 3818 return; 3819 } 3820 else if (srcFormat == GL_RGBA) { 3821 GLuint i; 3822 const GLchan *src = (const GLchan *) source; 3823 GLchan *dst = dest; 3824 for (i = 0; i < n; i++) { 3825 dst[0] = src[0]; 3826 dst[1] = src[1]; 3827 dst[2] = src[2]; 3828 src += 4; 3829 dst += 3; 3830 } 3831 return; 3832 } 3833 } 3834 else if (dstFormat == srcFormat) { 3835 GLint comps = _mesa_components_in_format(srcFormat); 3836 assert(comps > 0); 3837 memcpy( dest, source, n * comps * sizeof(GLchan) ); 3838 return; 3839 } 3840 } 3841 /* 3842 * Common situation, loading 8bit RGBA/RGB source images 3843 * into 16/32 bit destination. (OSMesa16/32) 3844 */ 3845 else if (srcType == GL_UNSIGNED_BYTE) { 3846 if (dstFormat == GL_RGBA) { 3847 if (srcFormat == GL_RGB) { 3848 GLuint i; 3849 const GLubyte *src = (const GLubyte *) source; 3850 GLchan *dst = dest; 3851 for (i = 0; i < n; i++) { 3852 dst[0] = UBYTE_TO_CHAN(src[0]); 3853 dst[1] = UBYTE_TO_CHAN(src[1]); 3854 dst[2] = UBYTE_TO_CHAN(src[2]); 3855 dst[3] = CHAN_MAX; 3856 src += 3; 3857 dst += 4; 3858 } 3859 return; 3860 } 3861 else if (srcFormat == GL_RGBA) { 3862 GLuint i; 3863 const GLubyte *src = (const GLubyte *) source; 3864 GLchan *dst = dest; 3865 for (i = 0; i < n; i++) { 3866 dst[0] = UBYTE_TO_CHAN(src[0]); 3867 dst[1] = UBYTE_TO_CHAN(src[1]); 3868 dst[2] = UBYTE_TO_CHAN(src[2]); 3869 dst[3] = UBYTE_TO_CHAN(src[3]); 3870 src += 4; 3871 dst += 4; 3872 } 3873 return; 3874 } 3875 } 3876 else if (dstFormat == GL_RGB) { 3877 if (srcFormat == GL_RGB) { 3878 GLuint i; 3879 const GLubyte *src = (const GLubyte *) source; 3880 GLchan *dst = dest; 3881 for (i = 0; i < n; i++) { 3882 dst[0] = UBYTE_TO_CHAN(src[0]); 3883 dst[1] = UBYTE_TO_CHAN(src[1]); 3884 dst[2] = UBYTE_TO_CHAN(src[2]); 3885 src += 3; 3886 dst += 3; 3887 } 3888 return; 3889 } 3890 else if (srcFormat == GL_RGBA) { 3891 GLuint i; 3892 const GLubyte *src = (const GLubyte *) source; 3893 GLchan *dst = dest; 3894 for (i = 0; i < n; i++) { 3895 dst[0] = UBYTE_TO_CHAN(src[0]); 3896 dst[1] = UBYTE_TO_CHAN(src[1]); 3897 dst[2] = UBYTE_TO_CHAN(src[2]); 3898 src += 4; 3899 dst += 3; 3900 } 3901 return; 3902 } 3903 } 3904 } 3905 } 3906 3907 3908 /* general solution begins here */ 3909 { 3910 GLint dstComponents; 3911 GLint dstRedIndex, dstGreenIndex, dstBlueIndex, dstAlphaIndex; 3912 GLint dstLuminanceIndex, dstIntensityIndex; 3913 GLfloat rgba[MAX_WIDTH][4]; 3914 3915 dstComponents = _mesa_components_in_format( dstFormat ); 3916 /* source & dest image formats should have been error checked by now */ 3917 assert(dstComponents > 0); 3918 3919 /* 3920 * Extract image data and convert to RGBA floats 3921 */ 3922 assert(n <= MAX_WIDTH); 3923 if (srcFormat == GL_COLOR_INDEX) { 3924 GLuint indexes[MAX_WIDTH]; 3925 extract_uint_indexes(n, indexes, srcFormat, srcType, source, 3926 srcPacking); 3927 3928 if (dstFormat == GL_COLOR_INDEX) { 3929 GLuint i; 3930 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes); 3931 /* convert to GLchan and return */ 3932 for (i = 0; i < n; i++) { 3933 dest[i] = (GLchan) (indexes[i] & 0xff); 3934 } 3935 return; 3936 } 3937 else { 3938 /* Convert indexes to RGBA */ 3939 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) { 3940 shift_and_offset_ci(ctx, n, indexes); 3941 } 3942 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba); 3943 } 3944 3945 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting 3946 * with color indexes. 3947 */ 3948 transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT); 3949 } 3950 else { 3951 /* non-color index data */ 3952 extract_float_rgba(n, rgba, srcFormat, srcType, source, 3953 srcPacking->SwapBytes); 3954 } 3955 3956 /* Need to clamp if returning GLubytes or GLushorts */ 3957#if CHAN_TYPE != GL_FLOAT 3958 transferOps |= IMAGE_CLAMP_BIT; 3959#endif 3960 3961 if (transferOps) { 3962 _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba); 3963 } 3964 3965 /* Now determine which color channels we need to produce. 3966 * And determine the dest index (offset) within each color tuple. 3967 */ 3968 switch (dstFormat) { 3969 case GL_ALPHA: 3970 dstAlphaIndex = 0; 3971 dstRedIndex = dstGreenIndex = dstBlueIndex = -1; 3972 dstLuminanceIndex = dstIntensityIndex = -1; 3973 break; 3974 case GL_LUMINANCE: 3975 dstLuminanceIndex = 0; 3976 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1; 3977 dstIntensityIndex = -1; 3978 break; 3979 case GL_LUMINANCE_ALPHA: 3980 dstLuminanceIndex = 0; 3981 dstAlphaIndex = 1; 3982 dstRedIndex = dstGreenIndex = dstBlueIndex = -1; 3983 dstIntensityIndex = -1; 3984 break; 3985 case GL_INTENSITY: 3986 dstIntensityIndex = 0; 3987 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1; 3988 dstLuminanceIndex = -1; 3989 break; 3990 case GL_RGB: 3991 dstRedIndex = 0; 3992 dstGreenIndex = 1; 3993 dstBlueIndex = 2; 3994 dstAlphaIndex = dstLuminanceIndex = dstIntensityIndex = -1; 3995 break; 3996 case GL_RGBA: 3997 dstRedIndex = 0; 3998 dstGreenIndex = 1; 3999 dstBlueIndex = 2; 4000 dstAlphaIndex = 3; 4001 dstLuminanceIndex = dstIntensityIndex = -1; 4002 break; 4003 default: 4004 _mesa_problem(ctx, "bad dstFormat in _mesa_unpack_chan_span()"); 4005 return; 4006 } 4007 4008 4009 /* Now return the GLchan data in the requested dstFormat */ 4010 4011 if (dstRedIndex >= 0) { 4012 GLchan *dst = dest; 4013 GLuint i; 4014 for (i = 0; i < n; i++) { 4015 CLAMPED_FLOAT_TO_CHAN(dst[dstRedIndex], rgba[i][RCOMP]); 4016 dst += dstComponents; 4017 } 4018 } 4019 4020 if (dstGreenIndex >= 0) { 4021 GLchan *dst = dest; 4022 GLuint i; 4023 for (i = 0; i < n; i++) { 4024 CLAMPED_FLOAT_TO_CHAN(dst[dstGreenIndex], rgba[i][GCOMP]); 4025 dst += dstComponents; 4026 } 4027 } 4028 4029 if (dstBlueIndex >= 0) { 4030 GLchan *dst = dest; 4031 GLuint i; 4032 for (i = 0; i < n; i++) { 4033 CLAMPED_FLOAT_TO_CHAN(dst[dstBlueIndex], rgba[i][BCOMP]); 4034 dst += dstComponents; 4035 } 4036 } 4037 4038 if (dstAlphaIndex >= 0) { 4039 GLchan *dst = dest; 4040 GLuint i; 4041 for (i = 0; i < n; i++) { 4042 CLAMPED_FLOAT_TO_CHAN(dst[dstAlphaIndex], rgba[i][ACOMP]); 4043 dst += dstComponents; 4044 } 4045 } 4046 4047 if (dstIntensityIndex >= 0) { 4048 GLchan *dst = dest; 4049 GLuint i; 4050 assert(dstIntensityIndex == 0); 4051 assert(dstComponents == 1); 4052 for (i = 0; i < n; i++) { 4053 /* Intensity comes from red channel */ 4054 CLAMPED_FLOAT_TO_CHAN(dst[i], rgba[i][RCOMP]); 4055 } 4056 } 4057 4058 if (dstLuminanceIndex >= 0) { 4059 GLchan *dst = dest; 4060 GLuint i; 4061 assert(dstLuminanceIndex == 0); 4062 for (i = 0; i < n; i++) { 4063 /* Luminance comes from red channel */ 4064 CLAMPED_FLOAT_TO_CHAN(dst[0], rgba[i][RCOMP]); 4065 dst += dstComponents; 4066 } 4067 } 4068 } 4069} 4070 4071 4072/** 4073 * Same as _mesa_unpack_color_span_chan(), but return GLfloat data 4074 * instead of GLchan. 4075 */ 4076void 4077_mesa_unpack_color_span_float( GLcontext *ctx, 4078 GLuint n, GLenum dstFormat, GLfloat dest[], 4079 GLenum srcFormat, GLenum srcType, 4080 const GLvoid *source, 4081 const struct gl_pixelstore_attrib *srcPacking, 4082 GLbitfield transferOps ) 4083{ 4084 ASSERT(dstFormat == GL_ALPHA || 4085 dstFormat == GL_LUMINANCE || 4086 dstFormat == GL_LUMINANCE_ALPHA || 4087 dstFormat == GL_INTENSITY || 4088 dstFormat == GL_RGB || 4089 dstFormat == GL_RGBA || 4090 dstFormat == GL_COLOR_INDEX); 4091 4092 ASSERT(srcFormat == GL_RED || 4093 srcFormat == GL_GREEN || 4094 srcFormat == GL_BLUE || 4095 srcFormat == GL_ALPHA || 4096 srcFormat == GL_LUMINANCE || 4097 srcFormat == GL_LUMINANCE_ALPHA || 4098 srcFormat == GL_INTENSITY || 4099 srcFormat == GL_RGB || 4100 srcFormat == GL_BGR || 4101 srcFormat == GL_RGBA || 4102 srcFormat == GL_BGRA || 4103 srcFormat == GL_ABGR_EXT || 4104 srcFormat == GL_COLOR_INDEX); 4105 4106 ASSERT(srcType == GL_BITMAP || 4107 srcType == GL_UNSIGNED_BYTE || 4108 srcType == GL_BYTE || 4109 srcType == GL_UNSIGNED_SHORT || 4110 srcType == GL_SHORT || 4111 srcType == GL_UNSIGNED_INT || 4112 srcType == GL_INT || 4113 srcType == GL_HALF_FLOAT_ARB || 4114 srcType == GL_FLOAT || 4115 srcType == GL_UNSIGNED_BYTE_3_3_2 || 4116 srcType == GL_UNSIGNED_BYTE_2_3_3_REV || 4117 srcType == GL_UNSIGNED_SHORT_5_6_5 || 4118 srcType == GL_UNSIGNED_SHORT_5_6_5_REV || 4119 srcType == GL_UNSIGNED_SHORT_4_4_4_4 || 4120 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV || 4121 srcType == GL_UNSIGNED_SHORT_5_5_5_1 || 4122 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV || 4123 srcType == GL_UNSIGNED_INT_8_8_8_8 || 4124 srcType == GL_UNSIGNED_INT_8_8_8_8_REV || 4125 srcType == GL_UNSIGNED_INT_10_10_10_2 || 4126 srcType == GL_UNSIGNED_INT_2_10_10_10_REV); 4127 4128 /* general solution, no special cases, yet */ 4129 { 4130 GLint dstComponents; 4131 GLint dstRedIndex, dstGreenIndex, dstBlueIndex, dstAlphaIndex; 4132 GLint dstLuminanceIndex, dstIntensityIndex; 4133 GLfloat rgba[MAX_WIDTH][4]; 4134 4135 dstComponents = _mesa_components_in_format( dstFormat ); 4136 /* source & dest image formats should have been error checked by now */ 4137 assert(dstComponents > 0); 4138 4139 /* 4140 * Extract image data and convert to RGBA floats 4141 */ 4142 assert(n <= MAX_WIDTH); 4143 if (srcFormat == GL_COLOR_INDEX) { 4144 GLuint indexes[MAX_WIDTH]; 4145 extract_uint_indexes(n, indexes, srcFormat, srcType, source, 4146 srcPacking); 4147 4148 if (dstFormat == GL_COLOR_INDEX) { 4149 GLuint i; 4150 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes); 4151 /* convert to GLchan and return */ 4152 for (i = 0; i < n; i++) { 4153 dest[i] = (GLchan) (indexes[i] & 0xff); 4154 } 4155 return; 4156 } 4157 else { 4158 /* Convert indexes to RGBA */ 4159 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) { 4160 shift_and_offset_ci(ctx, n, indexes); 4161 } 4162 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba); 4163 } 4164 4165 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting 4166 * with color indexes. 4167 */ 4168 transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT); 4169 } 4170 else { 4171 /* non-color index data */ 4172 extract_float_rgba(n, rgba, srcFormat, srcType, source, 4173 srcPacking->SwapBytes); 4174 } 4175 4176 if (transferOps) { 4177 _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba); 4178 } 4179 4180 /* Now determine which color channels we need to produce. 4181 * And determine the dest index (offset) within each color tuple. 4182 */ 4183 switch (dstFormat) { 4184 case GL_ALPHA: 4185 dstAlphaIndex = 0; 4186 dstRedIndex = dstGreenIndex = dstBlueIndex = -1; 4187 dstLuminanceIndex = dstIntensityIndex = -1; 4188 break; 4189 case GL_LUMINANCE: 4190 dstLuminanceIndex = 0; 4191 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1; 4192 dstIntensityIndex = -1; 4193 break; 4194 case GL_LUMINANCE_ALPHA: 4195 dstLuminanceIndex = 0; 4196 dstAlphaIndex = 1; 4197 dstRedIndex = dstGreenIndex = dstBlueIndex = -1; 4198 dstIntensityIndex = -1; 4199 break; 4200 case GL_INTENSITY: 4201 dstIntensityIndex = 0; 4202 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1; 4203 dstLuminanceIndex = -1; 4204 break; 4205 case GL_RGB: 4206 dstRedIndex = 0; 4207 dstGreenIndex = 1; 4208 dstBlueIndex = 2; 4209 dstAlphaIndex = dstLuminanceIndex = dstIntensityIndex = -1; 4210 break; 4211 case GL_RGBA: 4212 dstRedIndex = 0; 4213 dstGreenIndex = 1; 4214 dstBlueIndex = 2; 4215 dstAlphaIndex = 3; 4216 dstLuminanceIndex = dstIntensityIndex = -1; 4217 break; 4218 default: 4219 _mesa_problem(ctx, "bad dstFormat in _mesa_unpack_color_span_float()"); 4220 return; 4221 } 4222 4223 /* Now pack results in the requested dstFormat */ 4224 if (dstRedIndex >= 0) { 4225 GLfloat *dst = dest; 4226 GLuint i; 4227 for (i = 0; i < n; i++) { 4228 dst[dstRedIndex] = rgba[i][RCOMP]; 4229 dst += dstComponents; 4230 } 4231 } 4232 4233 if (dstGreenIndex >= 0) { 4234 GLfloat *dst = dest; 4235 GLuint i; 4236 for (i = 0; i < n; i++) { 4237 dst[dstGreenIndex] = rgba[i][GCOMP]; 4238 dst += dstComponents; 4239 } 4240 } 4241 4242 if (dstBlueIndex >= 0) { 4243 GLfloat *dst = dest; 4244 GLuint i; 4245 for (i = 0; i < n; i++) { 4246 dst[dstBlueIndex] = rgba[i][BCOMP]; 4247 dst += dstComponents; 4248 } 4249 } 4250 4251 if (dstAlphaIndex >= 0) { 4252 GLfloat *dst = dest; 4253 GLuint i; 4254 for (i = 0; i < n; i++) { 4255 dst[dstAlphaIndex] = rgba[i][ACOMP]; 4256 dst += dstComponents; 4257 } 4258 } 4259 4260 if (dstIntensityIndex >= 0) { 4261 GLfloat *dst = dest; 4262 GLuint i; 4263 assert(dstIntensityIndex == 0); 4264 assert(dstComponents == 1); 4265 for (i = 0; i < n; i++) { 4266 /* Intensity comes from red channel */ 4267 dst[i] = rgba[i][RCOMP]; 4268 } 4269 } 4270 4271 if (dstLuminanceIndex >= 0) { 4272 GLfloat *dst = dest; 4273 GLuint i; 4274 assert(dstLuminanceIndex == 0); 4275 for (i = 0; i < n; i++) { 4276 /* Luminance comes from red channel */ 4277 dst[0] = rgba[i][RCOMP]; 4278 dst += dstComponents; 4279 } 4280 } 4281 } 4282} 4283 4284/** 4285 * Similar to _mesa_unpack_color_span_float(), but for dudv data instead of rgba, 4286 * directly return GLbyte data, no transfer ops apply. 4287 */ 4288void 4289_mesa_unpack_dudv_span_byte( GLcontext *ctx, 4290 GLuint n, GLenum dstFormat, GLbyte dest[], 4291 GLenum srcFormat, GLenum srcType, 4292 const GLvoid *source, 4293 const struct gl_pixelstore_attrib *srcPacking, 4294 GLbitfield transferOps ) 4295{ 4296 ASSERT(dstFormat == GL_DUDV_ATI); 4297 ASSERT(srcFormat == GL_DUDV_ATI); 4298 4299 ASSERT(srcType == GL_UNSIGNED_BYTE || 4300 srcType == GL_BYTE || 4301 srcType == GL_UNSIGNED_SHORT || 4302 srcType == GL_SHORT || 4303 srcType == GL_UNSIGNED_INT || 4304 srcType == GL_INT || 4305 srcType == GL_HALF_FLOAT_ARB || 4306 srcType == GL_FLOAT); 4307 4308 /* general solution */ 4309 { 4310 GLint dstComponents; 4311 GLfloat rgba[MAX_WIDTH][4]; 4312 GLbyte *dst = dest; 4313 GLuint i; 4314 4315 dstComponents = _mesa_components_in_format( dstFormat ); 4316 /* source & dest image formats should have been error checked by now */ 4317 assert(dstComponents > 0); 4318 4319 /* 4320 * Extract image data and convert to RGBA floats 4321 */ 4322 assert(n <= MAX_WIDTH); 4323 extract_float_rgba(n, rgba, srcFormat, srcType, source, 4324 srcPacking->SwapBytes); 4325 4326 4327 /* Now determine which color channels we need to produce. 4328 * And determine the dest index (offset) within each color tuple. 4329 */ 4330 4331 /* Now pack results in the requested dstFormat */ 4332 for (i = 0; i < n; i++) { 4333 /* not sure - need clamp[-1,1] here? */ 4334 dst[0] = FLOAT_TO_BYTE(rgba[i][RCOMP]); 4335 dst[1] = FLOAT_TO_BYTE(rgba[i][GCOMP]); 4336 dst += dstComponents; 4337 } 4338 } 4339} 4340 4341/* 4342 * Unpack a row of color index data from a client buffer according to 4343 * the pixel unpacking parameters. 4344 * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc. 4345 * 4346 * Args: ctx - the context 4347 * n - number of pixels 4348 * dstType - destination data type 4349 * dest - destination array 4350 * srcType - source pixel type 4351 * source - source data pointer 4352 * srcPacking - pixel unpacking parameters 4353 * transferOps - the pixel transfer operations to apply 4354 */ 4355void 4356_mesa_unpack_index_span( const GLcontext *ctx, GLuint n, 4357 GLenum dstType, GLvoid *dest, 4358 GLenum srcType, const GLvoid *source, 4359 const struct gl_pixelstore_attrib *srcPacking, 4360 GLbitfield transferOps ) 4361{ 4362 ASSERT(srcType == GL_BITMAP || 4363 srcType == GL_UNSIGNED_BYTE || 4364 srcType == GL_BYTE || 4365 srcType == GL_UNSIGNED_SHORT || 4366 srcType == GL_SHORT || 4367 srcType == GL_UNSIGNED_INT || 4368 srcType == GL_INT || 4369 srcType == GL_HALF_FLOAT_ARB || 4370 srcType == GL_FLOAT); 4371 4372 ASSERT(dstType == GL_UNSIGNED_BYTE || 4373 dstType == GL_UNSIGNED_SHORT || 4374 dstType == GL_UNSIGNED_INT); 4375 4376 4377 transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT); 4378 4379 /* 4380 * Try simple cases first 4381 */ 4382 if (transferOps == 0 && srcType == GL_UNSIGNED_BYTE 4383 && dstType == GL_UNSIGNED_BYTE) { 4384 memcpy(dest, source, n * sizeof(GLubyte)); 4385 } 4386 else if (transferOps == 0 && srcType == GL_UNSIGNED_INT 4387 && dstType == GL_UNSIGNED_INT && !srcPacking->SwapBytes) { 4388 memcpy(dest, source, n * sizeof(GLuint)); 4389 } 4390 else { 4391 /* 4392 * general solution 4393 */ 4394 GLuint indexes[MAX_WIDTH]; 4395 assert(n <= MAX_WIDTH); 4396 4397 extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source, 4398 srcPacking); 4399 4400 if (transferOps) 4401 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes); 4402 4403 /* convert to dest type */ 4404 switch (dstType) { 4405 case GL_UNSIGNED_BYTE: 4406 { 4407 GLubyte *dst = (GLubyte *) dest; 4408 GLuint i; 4409 for (i = 0; i < n; i++) { 4410 dst[i] = (GLubyte) (indexes[i] & 0xff); 4411 } 4412 } 4413 break; 4414 case GL_UNSIGNED_SHORT: 4415 { 4416 GLuint *dst = (GLuint *) dest; 4417 GLuint i; 4418 for (i = 0; i < n; i++) { 4419 dst[i] = (GLushort) (indexes[i] & 0xffff); 4420 } 4421 } 4422 break; 4423 case GL_UNSIGNED_INT: 4424 memcpy(dest, indexes, n * sizeof(GLuint)); 4425 break; 4426 default: 4427 _mesa_problem(ctx, "bad dstType in _mesa_unpack_index_span"); 4428 } 4429 } 4430} 4431 4432 4433void 4434_mesa_pack_index_span( const GLcontext *ctx, GLuint n, 4435 GLenum dstType, GLvoid *dest, const GLuint *source, 4436 const struct gl_pixelstore_attrib *dstPacking, 4437 GLbitfield transferOps ) 4438{ 4439 GLuint indexes[MAX_WIDTH]; 4440 4441 ASSERT(n <= MAX_WIDTH); 4442 4443 transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT); 4444 4445 if (transferOps & (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT)) { 4446 /* make a copy of input */ 4447 memcpy(indexes, source, n * sizeof(GLuint)); 4448 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes); 4449 source = indexes; 4450 } 4451 4452 switch (dstType) { 4453 case GL_UNSIGNED_BYTE: 4454 { 4455 GLubyte *dst = (GLubyte *) dest; 4456 GLuint i; 4457 for (i = 0; i < n; i++) { 4458 *dst++ = (GLubyte) source[i]; 4459 } 4460 } 4461 break; 4462 case GL_BYTE: 4463 { 4464 GLbyte *dst = (GLbyte *) dest; 4465 GLuint i; 4466 for (i = 0; i < n; i++) { 4467 dst[i] = (GLbyte) source[i]; 4468 } 4469 } 4470 break; 4471 case GL_UNSIGNED_SHORT: 4472 { 4473 GLushort *dst = (GLushort *) dest; 4474 GLuint i; 4475 for (i = 0; i < n; i++) { 4476 dst[i] = (GLushort) source[i]; 4477 } 4478 if (dstPacking->SwapBytes) { 4479 _mesa_swap2( (GLushort *) dst, n ); 4480 } 4481 } 4482 break; 4483 case GL_SHORT: 4484 { 4485 GLshort *dst = (GLshort *) dest; 4486 GLuint i; 4487 for (i = 0; i < n; i++) { 4488 dst[i] = (GLshort) source[i]; 4489 } 4490 if (dstPacking->SwapBytes) { 4491 _mesa_swap2( (GLushort *) dst, n ); 4492 } 4493 } 4494 break; 4495 case GL_UNSIGNED_INT: 4496 { 4497 GLuint *dst = (GLuint *) dest; 4498 GLuint i; 4499 for (i = 0; i < n; i++) { 4500 dst[i] = (GLuint) source[i]; 4501 } 4502 if (dstPacking->SwapBytes) { 4503 _mesa_swap4( (GLuint *) dst, n ); 4504 } 4505 } 4506 break; 4507 case GL_INT: 4508 { 4509 GLint *dst = (GLint *) dest; 4510 GLuint i; 4511 for (i = 0; i < n; i++) { 4512 dst[i] = (GLint) source[i]; 4513 } 4514 if (dstPacking->SwapBytes) { 4515 _mesa_swap4( (GLuint *) dst, n ); 4516 } 4517 } 4518 break; 4519 case GL_FLOAT: 4520 { 4521 GLfloat *dst = (GLfloat *) dest; 4522 GLuint i; 4523 for (i = 0; i < n; i++) { 4524 dst[i] = (GLfloat) source[i]; 4525 } 4526 if (dstPacking->SwapBytes) { 4527 _mesa_swap4( (GLuint *) dst, n ); 4528 } 4529 } 4530 break; 4531 case GL_HALF_FLOAT_ARB: 4532 { 4533 GLhalfARB *dst = (GLhalfARB *) dest; 4534 GLuint i; 4535 for (i = 0; i < n; i++) { 4536 dst[i] = _mesa_float_to_half((GLfloat) source[i]); 4537 } 4538 if (dstPacking->SwapBytes) { 4539 _mesa_swap2( (GLushort *) dst, n ); 4540 } 4541 } 4542 break; 4543 default: 4544 _mesa_problem(ctx, "bad type in _mesa_pack_index_span"); 4545 } 4546} 4547 4548 4549/* 4550 * Unpack a row of stencil data from a client buffer according to 4551 * the pixel unpacking parameters. 4552 * This is (or will be) used by glDrawPixels 4553 * 4554 * Args: ctx - the context 4555 * n - number of pixels 4556 * dstType - destination data type 4557 * dest - destination array 4558 * srcType - source pixel type 4559 * source - source data pointer 4560 * srcPacking - pixel unpacking parameters 4561 * transferOps - apply offset/bias/lookup ops? 4562 */ 4563void 4564_mesa_unpack_stencil_span( const GLcontext *ctx, GLuint n, 4565 GLenum dstType, GLvoid *dest, 4566 GLenum srcType, const GLvoid *source, 4567 const struct gl_pixelstore_attrib *srcPacking, 4568 GLbitfield transferOps ) 4569{ 4570 ASSERT(srcType == GL_BITMAP || 4571 srcType == GL_UNSIGNED_BYTE || 4572 srcType == GL_BYTE || 4573 srcType == GL_UNSIGNED_SHORT || 4574 srcType == GL_SHORT || 4575 srcType == GL_UNSIGNED_INT || 4576 srcType == GL_INT || 4577 srcType == GL_UNSIGNED_INT_24_8_EXT || 4578 srcType == GL_HALF_FLOAT_ARB || 4579 srcType == GL_FLOAT); 4580 4581 ASSERT(dstType == GL_UNSIGNED_BYTE || 4582 dstType == GL_UNSIGNED_SHORT || 4583 dstType == GL_UNSIGNED_INT); 4584 4585 /* only shift and offset apply to stencil */ 4586 transferOps &= IMAGE_SHIFT_OFFSET_BIT; 4587 4588 /* 4589 * Try simple cases first 4590 */ 4591 if (transferOps == 0 && 4592 !ctx->Pixel.MapStencilFlag && 4593 srcType == GL_UNSIGNED_BYTE && 4594 dstType == GL_UNSIGNED_BYTE) { 4595 memcpy(dest, source, n * sizeof(GLubyte)); 4596 } 4597 else if (transferOps == 0 && 4598 !ctx->Pixel.MapStencilFlag && 4599 srcType == GL_UNSIGNED_INT && 4600 dstType == GL_UNSIGNED_INT && 4601 !srcPacking->SwapBytes) { 4602 memcpy(dest, source, n * sizeof(GLuint)); 4603 } 4604 else { 4605 /* 4606 * general solution 4607 */ 4608 GLuint indexes[MAX_WIDTH]; 4609 assert(n <= MAX_WIDTH); 4610 4611 extract_uint_indexes(n, indexes, GL_STENCIL_INDEX, srcType, source, 4612 srcPacking); 4613 4614 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) { 4615 /* shift and offset indexes */ 4616 shift_and_offset_ci(ctx, n, indexes); 4617 } 4618 4619 if (ctx->Pixel.MapStencilFlag) { 4620 /* Apply stencil lookup table */ 4621 const GLuint mask = ctx->PixelMaps.StoS.Size - 1; 4622 GLuint i; 4623 for (i = 0; i < n; i++) { 4624 indexes[i] = (GLuint)ctx->PixelMaps.StoS.Map[ indexes[i] & mask ]; 4625 } 4626 } 4627 4628 /* convert to dest type */ 4629 switch (dstType) { 4630 case GL_UNSIGNED_BYTE: 4631 { 4632 GLubyte *dst = (GLubyte *) dest; 4633 GLuint i; 4634 for (i = 0; i < n; i++) { 4635 dst[i] = (GLubyte) (indexes[i] & 0xff); 4636 } 4637 } 4638 break; 4639 case GL_UNSIGNED_SHORT: 4640 { 4641 GLuint *dst = (GLuint *) dest; 4642 GLuint i; 4643 for (i = 0; i < n; i++) { 4644 dst[i] = (GLushort) (indexes[i] & 0xffff); 4645 } 4646 } 4647 break; 4648 case GL_UNSIGNED_INT: 4649 memcpy(dest, indexes, n * sizeof(GLuint)); 4650 break; 4651 default: 4652 _mesa_problem(ctx, "bad dstType in _mesa_unpack_stencil_span"); 4653 } 4654 } 4655} 4656 4657 4658void 4659_mesa_pack_stencil_span( const GLcontext *ctx, GLuint n, 4660 GLenum dstType, GLvoid *dest, const GLstencil *source, 4661 const struct gl_pixelstore_attrib *dstPacking ) 4662{ 4663 GLstencil stencil[MAX_WIDTH]; 4664 4665 ASSERT(n <= MAX_WIDTH); 4666 4667 if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset || 4668 ctx->Pixel.MapStencilFlag) { 4669 /* make a copy of input */ 4670 memcpy(stencil, source, n * sizeof(GLstencil)); 4671 _mesa_apply_stencil_transfer_ops(ctx, n, stencil); 4672 source = stencil; 4673 } 4674 4675 switch (dstType) { 4676 case GL_UNSIGNED_BYTE: 4677 if (sizeof(GLstencil) == 1) { 4678 memcpy( dest, source, n ); 4679 } 4680 else { 4681 GLubyte *dst = (GLubyte *) dest; 4682 GLuint i; 4683 for (i=0;i<n;i++) { 4684 dst[i] = (GLubyte) source[i]; 4685 } 4686 } 4687 break; 4688 case GL_BYTE: 4689 { 4690 GLbyte *dst = (GLbyte *) dest; 4691 GLuint i; 4692 for (i=0;i<n;i++) { 4693 dst[i] = (GLbyte) (source[i] & 0x7f); 4694 } 4695 } 4696 break; 4697 case GL_UNSIGNED_SHORT: 4698 { 4699 GLushort *dst = (GLushort *) dest; 4700 GLuint i; 4701 for (i=0;i<n;i++) { 4702 dst[i] = (GLushort) source[i]; 4703 } 4704 if (dstPacking->SwapBytes) { 4705 _mesa_swap2( (GLushort *) dst, n ); 4706 } 4707 } 4708 break; 4709 case GL_SHORT: 4710 { 4711 GLshort *dst = (GLshort *) dest; 4712 GLuint i; 4713 for (i=0;i<n;i++) { 4714 dst[i] = (GLshort) source[i]; 4715 } 4716 if (dstPacking->SwapBytes) { 4717 _mesa_swap2( (GLushort *) dst, n ); 4718 } 4719 } 4720 break; 4721 case GL_UNSIGNED_INT: 4722 { 4723 GLuint *dst = (GLuint *) dest; 4724 GLuint i; 4725 for (i=0;i<n;i++) { 4726 dst[i] = (GLuint) source[i]; 4727 } 4728 if (dstPacking->SwapBytes) { 4729 _mesa_swap4( (GLuint *) dst, n ); 4730 } 4731 } 4732 break; 4733 case GL_INT: 4734 { 4735 GLint *dst = (GLint *) dest; 4736 GLuint i; 4737 for (i=0;i<n;i++) { 4738 dst[i] = (GLint) source[i]; 4739 } 4740 if (dstPacking->SwapBytes) { 4741 _mesa_swap4( (GLuint *) dst, n ); 4742 } 4743 } 4744 break; 4745 case GL_FLOAT: 4746 { 4747 GLfloat *dst = (GLfloat *) dest; 4748 GLuint i; 4749 for (i=0;i<n;i++) { 4750 dst[i] = (GLfloat) source[i]; 4751 } 4752 if (dstPacking->SwapBytes) { 4753 _mesa_swap4( (GLuint *) dst, n ); 4754 } 4755 } 4756 break; 4757 case GL_HALF_FLOAT_ARB: 4758 { 4759 GLhalfARB *dst = (GLhalfARB *) dest; 4760 GLuint i; 4761 for (i=0;i<n;i++) { 4762 dst[i] = _mesa_float_to_half( (float) source[i] ); 4763 } 4764 if (dstPacking->SwapBytes) { 4765 _mesa_swap2( (GLushort *) dst, n ); 4766 } 4767 } 4768 break; 4769 case GL_BITMAP: 4770 if (dstPacking->LsbFirst) { 4771 GLubyte *dst = (GLubyte *) dest; 4772 GLint shift = 0; 4773 GLuint i; 4774 for (i = 0; i < n; i++) { 4775 if (shift == 0) 4776 *dst = 0; 4777 *dst |= ((source[i] != 0) << shift); 4778 shift++; 4779 if (shift == 8) { 4780 shift = 0; 4781 dst++; 4782 } 4783 } 4784 } 4785 else { 4786 GLubyte *dst = (GLubyte *) dest; 4787 GLint shift = 7; 4788 GLuint i; 4789 for (i = 0; i < n; i++) { 4790 if (shift == 7) 4791 *dst = 0; 4792 *dst |= ((source[i] != 0) << shift); 4793 shift--; 4794 if (shift < 0) { 4795 shift = 7; 4796 dst++; 4797 } 4798 } 4799 } 4800 break; 4801 default: 4802 _mesa_problem(ctx, "bad type in _mesa_pack_index_span"); 4803 } 4804} 4805 4806#define DEPTH_VALUES(GLTYPE, GLTYPE2FLOAT) \ 4807 do { \ 4808 GLuint i; \ 4809 const GLTYPE *src = (const GLTYPE *)source; \ 4810 for (i = 0; i < n; i++) { \ 4811 GLTYPE value = src[i]; \ 4812 if (srcPacking->SwapBytes) { \ 4813 if (sizeof(GLTYPE) == 2) { \ 4814 SWAP2BYTE(value); \ 4815 } else if (sizeof(GLTYPE) == 4) { \ 4816 SWAP4BYTE(value); \ 4817 } \ 4818 } \ 4819 depthValues[i] = GLTYPE2FLOAT(value); \ 4820 } \ 4821 } while (0) 4822 4823 4824/** 4825 * Unpack a row of depth/z values from memory, returning GLushort, GLuint 4826 * or GLfloat values. 4827 * The glPixelTransfer (scale/bias) params will be applied. 4828 * 4829 * \param dstType one of GL_UNSIGNED_SHORT, GL_UNSIGNED_INT, GL_FLOAT 4830 * \param depthMax max value for returned GLushort or GLuint values 4831 * (ignored for GLfloat). 4832 */ 4833void 4834_mesa_unpack_depth_span( const GLcontext *ctx, GLuint n, 4835 GLenum dstType, GLvoid *dest, GLuint depthMax, 4836 GLenum srcType, const GLvoid *source, 4837 const struct gl_pixelstore_attrib *srcPacking ) 4838{ 4839 GLfloat depthTemp[MAX_WIDTH], *depthValues; 4840 GLboolean needClamp = GL_FALSE; 4841 4842 /* Look for special cases first. 4843 * Not only are these faster, they're less prone to numeric conversion 4844 * problems. Otherwise, converting from an int type to a float then 4845 * back to an int type can introduce errors that will show up as 4846 * artifacts in things like depth peeling which uses glCopyTexImage. 4847 */ 4848 if (ctx->Pixel.DepthScale == 1.0 && ctx->Pixel.DepthBias == 0.0) { 4849 if (srcType == GL_UNSIGNED_INT && dstType == GL_UNSIGNED_SHORT) { 4850 const GLuint *src = (const GLuint *) source; 4851 GLushort *dst = (GLushort *) dest; 4852 GLuint i; 4853 for (i = 0; i < n; i++) { 4854 dst[i] = src[i] >> 16; 4855 } 4856 return; 4857 } 4858 if (srcType == GL_UNSIGNED_SHORT 4859 && dstType == GL_UNSIGNED_INT 4860 && depthMax == 0xffffffff) { 4861 const GLushort *src = (const GLushort *) source; 4862 GLuint *dst = (GLuint *) dest; 4863 GLuint i; 4864 for (i = 0; i < n; i++) { 4865 dst[i] = src[i] | (src[i] << 16); 4866 } 4867 return; 4868 } 4869 if (srcType == GL_UNSIGNED_INT_24_8 4870 && dstType == GL_UNSIGNED_INT 4871 && depthMax == 0xffffff) { 4872 const GLuint *src = (const GLuint *) source; 4873 GLuint *dst = (GLuint *) dest; 4874 GLuint i; 4875 for (i = 0; i < n; i++) { 4876 dst[i] = src[i] >> 8; 4877 } 4878 return; 4879 } 4880 /* XXX may want to add additional cases here someday */ 4881 } 4882 4883 /* general case path follows */ 4884 4885 if (dstType == GL_FLOAT) { 4886 depthValues = (GLfloat *) dest; 4887 } 4888 else { 4889 depthValues = depthTemp; 4890 } 4891 4892 /* Convert incoming values to GLfloat. Some conversions will require 4893 * clamping, below. 4894 */ 4895 switch (srcType) { 4896 case GL_BYTE: 4897 DEPTH_VALUES(GLbyte, BYTE_TO_FLOAT); 4898 needClamp = GL_TRUE; 4899 break; 4900 case GL_UNSIGNED_BYTE: 4901 DEPTH_VALUES(GLubyte, UBYTE_TO_FLOAT); 4902 break; 4903 case GL_SHORT: 4904 DEPTH_VALUES(GLshort, SHORT_TO_FLOAT); 4905 needClamp = GL_TRUE; 4906 break; 4907 case GL_UNSIGNED_SHORT: 4908 DEPTH_VALUES(GLushort, USHORT_TO_FLOAT); 4909 break; 4910 case GL_INT: 4911 DEPTH_VALUES(GLint, INT_TO_FLOAT); 4912 needClamp = GL_TRUE; 4913 break; 4914 case GL_UNSIGNED_INT: 4915 DEPTH_VALUES(GLuint, UINT_TO_FLOAT); 4916 break; 4917 case GL_UNSIGNED_INT_24_8_EXT: /* GL_EXT_packed_depth_stencil */ 4918 if (dstType == GL_UNSIGNED_INT_24_8_EXT && 4919 depthMax == 0xffffff && 4920 ctx->Pixel.DepthScale == 1.0 && 4921 ctx->Pixel.DepthBias == 0.0) { 4922 const GLuint *src = (const GLuint *) source; 4923 GLuint *zValues = (GLuint *) dest; 4924 GLuint i; 4925 for (i = 0; i < n; i++) { 4926 GLuint value = src[i]; 4927 if (srcPacking->SwapBytes) { 4928 SWAP4BYTE(value); 4929 } 4930 zValues[i] = value & 0xffffff00; 4931 } 4932 return; 4933 } 4934 else { 4935 const GLuint *src = (const GLuint *) source; 4936 const GLfloat scale = 1.0f / 0xffffff; 4937 GLuint i; 4938 for (i = 0; i < n; i++) { 4939 GLuint value = src[i]; 4940 if (srcPacking->SwapBytes) { 4941 SWAP4BYTE(value); 4942 } 4943 depthValues[i] = (value >> 8) * scale; 4944 } 4945 } 4946 break; 4947 case GL_FLOAT: 4948 DEPTH_VALUES(GLfloat, 1*); 4949 needClamp = GL_TRUE; 4950 break; 4951 case GL_HALF_FLOAT_ARB: 4952 { 4953 GLuint i; 4954 const GLhalfARB *src = (const GLhalfARB *) source; 4955 for (i = 0; i < n; i++) { 4956 GLhalfARB value = src[i]; 4957 if (srcPacking->SwapBytes) { 4958 SWAP2BYTE(value); 4959 } 4960 depthValues[i] = _mesa_half_to_float(value); 4961 } 4962 needClamp = GL_TRUE; 4963 } 4964 break; 4965 default: 4966 _mesa_problem(NULL, "bad type in _mesa_unpack_depth_span()"); 4967 return; 4968 } 4969 4970 /* apply depth scale and bias */ 4971 { 4972 const GLfloat scale = ctx->Pixel.DepthScale; 4973 const GLfloat bias = ctx->Pixel.DepthBias; 4974 if (scale != 1.0 || bias != 0.0) { 4975 GLuint i; 4976 for (i = 0; i < n; i++) { 4977 depthValues[i] = depthValues[i] * scale + bias; 4978 } 4979 needClamp = GL_TRUE; 4980 } 4981 } 4982 4983 /* clamp to [0, 1] */ 4984 if (needClamp) { 4985 GLuint i; 4986 for (i = 0; i < n; i++) { 4987 depthValues[i] = (GLfloat)CLAMP(depthValues[i], 0.0, 1.0); 4988 } 4989 } 4990 4991 /* 4992 * Convert values to dstType 4993 */ 4994 if (dstType == GL_UNSIGNED_INT) { 4995 GLuint *zValues = (GLuint *) dest; 4996 GLuint i; 4997 if (depthMax <= 0xffffff) { 4998 /* no overflow worries */ 4999 for (i = 0; i < n; i++) { 5000 zValues[i] = (GLuint) (depthValues[i] * (GLfloat) depthMax); 5001 } 5002 } 5003 else { 5004 /* need to use double precision to prevent overflow problems */ 5005 for (i = 0; i < n; i++) { 5006 GLdouble z = depthValues[i] * (GLfloat) depthMax; 5007 if (z >= (GLdouble) 0xffffffff) 5008 zValues[i] = 0xffffffff; 5009 else 5010 zValues[i] = (GLuint) z; 5011 } 5012 } 5013 } 5014 else if (dstType == GL_UNSIGNED_SHORT) { 5015 GLushort *zValues = (GLushort *) dest; 5016 GLuint i; 5017 ASSERT(depthMax <= 0xffff); 5018 for (i = 0; i < n; i++) { 5019 zValues[i] = (GLushort) (depthValues[i] * (GLfloat) depthMax); 5020 } 5021 } 5022 else { 5023 ASSERT(dstType == GL_FLOAT); 5024 /*ASSERT(depthMax == 1.0F);*/ 5025 } 5026} 5027 5028 5029/* 5030 * Pack an array of depth values. The values are floats in [0,1]. 5031 */ 5032void 5033_mesa_pack_depth_span( const GLcontext *ctx, GLuint n, GLvoid *dest, 5034 GLenum dstType, const GLfloat *depthSpan, 5035 const struct gl_pixelstore_attrib *dstPacking ) 5036{ 5037 GLfloat depthCopy[MAX_WIDTH]; 5038 5039 ASSERT(n <= MAX_WIDTH); 5040 5041 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) { 5042 memcpy(depthCopy, depthSpan, n * sizeof(GLfloat)); 5043 _mesa_scale_and_bias_depth(ctx, n, depthCopy); 5044 depthSpan = depthCopy; 5045 } 5046 5047 switch (dstType) { 5048 case GL_UNSIGNED_BYTE: 5049 { 5050 GLubyte *dst = (GLubyte *) dest; 5051 GLuint i; 5052 for (i = 0; i < n; i++) { 5053 dst[i] = FLOAT_TO_UBYTE( depthSpan[i] ); 5054 } 5055 } 5056 break; 5057 case GL_BYTE: 5058 { 5059 GLbyte *dst = (GLbyte *) dest; 5060 GLuint i; 5061 for (i = 0; i < n; i++) { 5062 dst[i] = FLOAT_TO_BYTE( depthSpan[i] ); 5063 } 5064 } 5065 break; 5066 case GL_UNSIGNED_SHORT: 5067 { 5068 GLushort *dst = (GLushort *) dest; 5069 GLuint i; 5070 for (i = 0; i < n; i++) { 5071 CLAMPED_FLOAT_TO_USHORT(dst[i], depthSpan[i]); 5072 } 5073 if (dstPacking->SwapBytes) { 5074 _mesa_swap2( (GLushort *) dst, n ); 5075 } 5076 } 5077 break; 5078 case GL_SHORT: 5079 { 5080 GLshort *dst = (GLshort *) dest; 5081 GLuint i; 5082 for (i = 0; i < n; i++) { 5083 dst[i] = FLOAT_TO_SHORT( depthSpan[i] ); 5084 } 5085 if (dstPacking->SwapBytes) { 5086 _mesa_swap2( (GLushort *) dst, n ); 5087 } 5088 } 5089 break; 5090 case GL_UNSIGNED_INT: 5091 { 5092 GLuint *dst = (GLuint *) dest; 5093 GLuint i; 5094 for (i = 0; i < n; i++) { 5095 dst[i] = FLOAT_TO_UINT( depthSpan[i] ); 5096 } 5097 if (dstPacking->SwapBytes) { 5098 _mesa_swap4( (GLuint *) dst, n ); 5099 } 5100 } 5101 break; 5102 case GL_INT: 5103 { 5104 GLint *dst = (GLint *) dest; 5105 GLuint i; 5106 for (i = 0; i < n; i++) { 5107 dst[i] = FLOAT_TO_INT( depthSpan[i] ); 5108 } 5109 if (dstPacking->SwapBytes) { 5110 _mesa_swap4( (GLuint *) dst, n ); 5111 } 5112 } 5113 break; 5114 case GL_FLOAT: 5115 { 5116 GLfloat *dst = (GLfloat *) dest; 5117 GLuint i; 5118 for (i = 0; i < n; i++) { 5119 dst[i] = depthSpan[i]; 5120 } 5121 if (dstPacking->SwapBytes) { 5122 _mesa_swap4( (GLuint *) dst, n ); 5123 } 5124 } 5125 break; 5126 case GL_HALF_FLOAT_ARB: 5127 { 5128 GLhalfARB *dst = (GLhalfARB *) dest; 5129 GLuint i; 5130 for (i = 0; i < n; i++) { 5131 dst[i] = _mesa_float_to_half(depthSpan[i]); 5132 } 5133 if (dstPacking->SwapBytes) { 5134 _mesa_swap2( (GLushort *) dst, n ); 5135 } 5136 } 5137 break; 5138 default: 5139 _mesa_problem(ctx, "bad type in _mesa_pack_depth_span"); 5140 } 5141} 5142 5143 5144 5145/** 5146 * Pack depth and stencil values as GL_DEPTH_STENCIL/GL_UNSIGNED_INT_24_8. 5147 */ 5148void 5149_mesa_pack_depth_stencil_span(const GLcontext *ctx, GLuint n, GLuint *dest, 5150 const GLfloat *depthVals, 5151 const GLstencil *stencilVals, 5152 const struct gl_pixelstore_attrib *dstPacking) 5153{ 5154 GLfloat depthCopy[MAX_WIDTH]; 5155 GLstencil stencilCopy[MAX_WIDTH]; 5156 GLuint i; 5157 5158 ASSERT(n <= MAX_WIDTH); 5159 5160 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) { 5161 memcpy(depthCopy, depthVals, n * sizeof(GLfloat)); 5162 _mesa_scale_and_bias_depth(ctx, n, depthCopy); 5163 depthVals = depthCopy; 5164 } 5165 5166 if (ctx->Pixel.IndexShift || 5167 ctx->Pixel.IndexOffset || 5168 ctx->Pixel.MapStencilFlag) { 5169 memcpy(stencilCopy, stencilVals, n * sizeof(GLstencil)); 5170 _mesa_apply_stencil_transfer_ops(ctx, n, stencilCopy); 5171 stencilVals = stencilCopy; 5172 } 5173 5174 for (i = 0; i < n; i++) { 5175 GLuint z = (GLuint) (depthVals[i] * 0xffffff); 5176 dest[i] = (z << 8) | (stencilVals[i] & 0xff); 5177 } 5178 5179 if (dstPacking->SwapBytes) { 5180 _mesa_swap4(dest, n); 5181 } 5182} 5183 5184 5185 5186 5187/** 5188 * Unpack image data. Apply byte swapping, byte flipping (bitmap). 5189 * Return all image data in a contiguous block. This is used when we 5190 * compile glDrawPixels, glTexImage, etc into a display list. We 5191 * need a copy of the data in a standard format. 5192 */ 5193void * 5194_mesa_unpack_image( GLuint dimensions, 5195 GLsizei width, GLsizei height, GLsizei depth, 5196 GLenum format, GLenum type, const GLvoid *pixels, 5197 const struct gl_pixelstore_attrib *unpack ) 5198{ 5199 GLint bytesPerRow, compsPerRow; 5200 GLboolean flipBytes, swap2, swap4; 5201 5202 if (!pixels) 5203 return NULL; /* not necessarily an error */ 5204 5205 if (width <= 0 || height <= 0 || depth <= 0) 5206 return NULL; /* generate error later */ 5207 5208 if (type == GL_BITMAP) { 5209 bytesPerRow = (width + 7) >> 3; 5210 flipBytes = unpack->LsbFirst; 5211 swap2 = swap4 = GL_FALSE; 5212 compsPerRow = 0; 5213 } 5214 else { 5215 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type); 5216 GLint components = _mesa_components_in_format(format); 5217 GLint bytesPerComp; 5218 5219 if (_mesa_type_is_packed(type)) 5220 components = 1; 5221 5222 if (bytesPerPixel <= 0 || components <= 0) 5223 return NULL; /* bad format or type. generate error later */ 5224 bytesPerRow = bytesPerPixel * width; 5225 bytesPerComp = bytesPerPixel / components; 5226 flipBytes = GL_FALSE; 5227 swap2 = (bytesPerComp == 2) && unpack->SwapBytes; 5228 swap4 = (bytesPerComp == 4) && unpack->SwapBytes; 5229 compsPerRow = components * width; 5230 assert(compsPerRow >= width); 5231 } 5232 5233 { 5234 GLubyte *destBuffer 5235 = (GLubyte *) _mesa_malloc(bytesPerRow * height * depth); 5236 GLubyte *dst; 5237 GLint img, row; 5238 if (!destBuffer) 5239 return NULL; /* generate GL_OUT_OF_MEMORY later */ 5240 5241 dst = destBuffer; 5242 for (img = 0; img < depth; img++) { 5243 for (row = 0; row < height; row++) { 5244 const GLvoid *src = _mesa_image_address(dimensions, unpack, pixels, 5245 width, height, format, type, img, row, 0); 5246 5247 if ((type == GL_BITMAP) && (unpack->SkipPixels & 0x7)) { 5248 GLint i; 5249 flipBytes = GL_FALSE; 5250 if (unpack->LsbFirst) { 5251 GLubyte srcMask = 1 << (unpack->SkipPixels & 0x7); 5252 GLubyte dstMask = 128; 5253 const GLubyte *s = src; 5254 GLubyte *d = dst; 5255 *d = 0; 5256 for (i = 0; i < width; i++) { 5257 if (*s & srcMask) { 5258 *d |= dstMask; 5259 } 5260 if (srcMask == 128) { 5261 srcMask = 1; 5262 s++; 5263 } 5264 else { 5265 srcMask = srcMask << 1; 5266 } 5267 if (dstMask == 1) { 5268 dstMask = 128; 5269 d++; 5270 *d = 0; 5271 } 5272 else { 5273 dstMask = dstMask >> 1; 5274 } 5275 } 5276 } 5277 else { 5278 GLubyte srcMask = 128 >> (unpack->SkipPixels & 0x7); 5279 GLubyte dstMask = 128; 5280 const GLubyte *s = src; 5281 GLubyte *d = dst; 5282 *d = 0; 5283 for (i = 0; i < width; i++) { 5284 if (*s & srcMask) { 5285 *d |= dstMask; 5286 } 5287 if (srcMask == 1) { 5288 srcMask = 128; 5289 s++; 5290 } 5291 else { 5292 srcMask = srcMask >> 1; 5293 } 5294 if (dstMask == 1) { 5295 dstMask = 128; 5296 d++; 5297 *d = 0; 5298 } 5299 else { 5300 dstMask = dstMask >> 1; 5301 } 5302 } 5303 } 5304 } 5305 else { 5306 memcpy(dst, src, bytesPerRow); 5307 } 5308 5309 /* byte flipping/swapping */ 5310 if (flipBytes) { 5311 flip_bytes((GLubyte *) dst, bytesPerRow); 5312 } 5313 else if (swap2) { 5314 _mesa_swap2((GLushort*) dst, compsPerRow); 5315 } 5316 else if (swap4) { 5317 _mesa_swap4((GLuint*) dst, compsPerRow); 5318 } 5319 dst += bytesPerRow; 5320 } 5321 } 5322 return destBuffer; 5323 } 5324} 5325 5326#endif /* _HAVE_FULL_GL */ 5327 5328 5329 5330/** 5331 * Convert an array of RGBA colors from one datatype to another. 5332 * NOTE: src may equal dst. In that case, we use a temporary buffer. 5333 */ 5334void 5335_mesa_convert_colors(GLenum srcType, const GLvoid *src, 5336 GLenum dstType, GLvoid *dst, 5337 GLuint count, const GLubyte mask[]) 5338{ 5339 GLuint tempBuffer[MAX_WIDTH][4]; 5340 const GLboolean useTemp = (src == dst); 5341 5342 ASSERT(srcType != dstType); 5343 5344 switch (srcType) { 5345 case GL_UNSIGNED_BYTE: 5346 if (dstType == GL_UNSIGNED_SHORT) { 5347 const GLubyte (*src1)[4] = (const GLubyte (*)[4]) src; 5348 GLushort (*dst2)[4] = (GLushort (*)[4]) (useTemp ? tempBuffer : dst); 5349 GLuint i; 5350 for (i = 0; i < count; i++) { 5351 if (!mask || mask[i]) { 5352 dst2[i][RCOMP] = UBYTE_TO_USHORT(src1[i][RCOMP]); 5353 dst2[i][GCOMP] = UBYTE_TO_USHORT(src1[i][GCOMP]); 5354 dst2[i][BCOMP] = UBYTE_TO_USHORT(src1[i][BCOMP]); 5355 dst2[i][ACOMP] = UBYTE_TO_USHORT(src1[i][ACOMP]); 5356 } 5357 } 5358 if (useTemp) 5359 memcpy(dst, tempBuffer, count * 4 * sizeof(GLushort)); 5360 } 5361 else { 5362 const GLubyte (*src1)[4] = (const GLubyte (*)[4]) src; 5363 GLfloat (*dst4)[4] = (GLfloat (*)[4]) (useTemp ? tempBuffer : dst); 5364 GLuint i; 5365 ASSERT(dstType == GL_FLOAT); 5366 for (i = 0; i < count; i++) { 5367 if (!mask || mask[i]) { 5368 dst4[i][RCOMP] = UBYTE_TO_FLOAT(src1[i][RCOMP]); 5369 dst4[i][GCOMP] = UBYTE_TO_FLOAT(src1[i][GCOMP]); 5370 dst4[i][BCOMP] = UBYTE_TO_FLOAT(src1[i][BCOMP]); 5371 dst4[i][ACOMP] = UBYTE_TO_FLOAT(src1[i][ACOMP]); 5372 } 5373 } 5374 if (useTemp) 5375 memcpy(dst, tempBuffer, count * 4 * sizeof(GLfloat)); 5376 } 5377 break; 5378 case GL_UNSIGNED_SHORT: 5379 if (dstType == GL_UNSIGNED_BYTE) { 5380 const GLushort (*src2)[4] = (const GLushort (*)[4]) src; 5381 GLubyte (*dst1)[4] = (GLubyte (*)[4]) (useTemp ? tempBuffer : dst); 5382 GLuint i; 5383 for (i = 0; i < count; i++) { 5384 if (!mask || mask[i]) { 5385 dst1[i][RCOMP] = USHORT_TO_UBYTE(src2[i][RCOMP]); 5386 dst1[i][GCOMP] = USHORT_TO_UBYTE(src2[i][GCOMP]); 5387 dst1[i][BCOMP] = USHORT_TO_UBYTE(src2[i][BCOMP]); 5388 dst1[i][ACOMP] = USHORT_TO_UBYTE(src2[i][ACOMP]); 5389 } 5390 } 5391 if (useTemp) 5392 memcpy(dst, tempBuffer, count * 4 * sizeof(GLubyte)); 5393 } 5394 else { 5395 const GLushort (*src2)[4] = (const GLushort (*)[4]) src; 5396 GLfloat (*dst4)[4] = (GLfloat (*)[4]) (useTemp ? tempBuffer : dst); 5397 GLuint i; 5398 ASSERT(dstType == GL_FLOAT); 5399 for (i = 0; i < count; i++) { 5400 if (!mask || mask[i]) { 5401 dst4[i][RCOMP] = USHORT_TO_FLOAT(src2[i][RCOMP]); 5402 dst4[i][GCOMP] = USHORT_TO_FLOAT(src2[i][GCOMP]); 5403 dst4[i][BCOMP] = USHORT_TO_FLOAT(src2[i][BCOMP]); 5404 dst4[i][ACOMP] = USHORT_TO_FLOAT(src2[i][ACOMP]); 5405 } 5406 } 5407 if (useTemp) 5408 memcpy(dst, tempBuffer, count * 4 * sizeof(GLfloat)); 5409 } 5410 break; 5411 case GL_FLOAT: 5412 if (dstType == GL_UNSIGNED_BYTE) { 5413 const GLfloat (*src4)[4] = (const GLfloat (*)[4]) src; 5414 GLubyte (*dst1)[4] = (GLubyte (*)[4]) (useTemp ? tempBuffer : dst); 5415 GLuint i; 5416 for (i = 0; i < count; i++) { 5417 if (!mask || mask[i]) { 5418 UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][RCOMP], src4[i][RCOMP]); 5419 UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][GCOMP], src4[i][GCOMP]); 5420 UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][BCOMP], src4[i][BCOMP]); 5421 UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][ACOMP], src4[i][ACOMP]); 5422 } 5423 } 5424 if (useTemp) 5425 memcpy(dst, tempBuffer, count * 4 * sizeof(GLubyte)); 5426 } 5427 else { 5428 const GLfloat (*src4)[4] = (const GLfloat (*)[4]) src; 5429 GLushort (*dst2)[4] = (GLushort (*)[4]) (useTemp ? tempBuffer : dst); 5430 GLuint i; 5431 ASSERT(dstType == GL_UNSIGNED_SHORT); 5432 for (i = 0; i < count; i++) { 5433 if (!mask || mask[i]) { 5434 UNCLAMPED_FLOAT_TO_USHORT(dst2[i][RCOMP], src4[i][RCOMP]); 5435 UNCLAMPED_FLOAT_TO_USHORT(dst2[i][GCOMP], src4[i][GCOMP]); 5436 UNCLAMPED_FLOAT_TO_USHORT(dst2[i][BCOMP], src4[i][BCOMP]); 5437 UNCLAMPED_FLOAT_TO_USHORT(dst2[i][ACOMP], src4[i][ACOMP]); 5438 } 5439 } 5440 if (useTemp) 5441 memcpy(dst, tempBuffer, count * 4 * sizeof(GLushort)); 5442 } 5443 break; 5444 default: 5445 _mesa_problem(NULL, "Invalid datatype in _mesa_convert_colors"); 5446 } 5447} 5448 5449 5450 5451 5452/** 5453 * Perform basic clipping for glDrawPixels. The image's position and size 5454 * and the unpack SkipPixels and SkipRows are adjusted so that the image 5455 * region is entirely within the window and scissor bounds. 5456 * NOTE: this will only work when glPixelZoom is (1, 1) or (1, -1). 5457 * If Pixel.ZoomY is -1, *destY will be changed to be the first row which 5458 * we'll actually write. Beforehand, *destY-1 is the first drawing row. 5459 * 5460 * \return GL_TRUE if image is ready for drawing or 5461 * GL_FALSE if image was completely clipped away (draw nothing) 5462 */ 5463GLboolean 5464_mesa_clip_drawpixels(const GLcontext *ctx, 5465 GLint *destX, GLint *destY, 5466 GLsizei *width, GLsizei *height, 5467 struct gl_pixelstore_attrib *unpack) 5468{ 5469 const GLframebuffer *buffer = ctx->DrawBuffer; 5470 5471 if (unpack->RowLength == 0) { 5472 unpack->RowLength = *width; 5473 } 5474 5475 ASSERT(ctx->Pixel.ZoomX == 1.0F); 5476 ASSERT(ctx->Pixel.ZoomY == 1.0F || ctx->Pixel.ZoomY == -1.0F); 5477 5478 /* left clipping */ 5479 if (*destX < buffer->_Xmin) { 5480 unpack->SkipPixels += (buffer->_Xmin - *destX); 5481 *width -= (buffer->_Xmin - *destX); 5482 *destX = buffer->_Xmin; 5483 } 5484 /* right clipping */ 5485 if (*destX + *width > buffer->_Xmax) 5486 *width -= (*destX + *width - buffer->_Xmax); 5487 5488 if (*width <= 0) 5489 return GL_FALSE; 5490 5491 if (ctx->Pixel.ZoomY == 1.0F) { 5492 /* bottom clipping */ 5493 if (*destY < buffer->_Ymin) { 5494 unpack->SkipRows += (buffer->_Ymin - *destY); 5495 *height -= (buffer->_Ymin - *destY); 5496 *destY = buffer->_Ymin; 5497 } 5498 /* top clipping */ 5499 if (*destY + *height > buffer->_Ymax) 5500 *height -= (*destY + *height - buffer->_Ymax); 5501 } 5502 else { /* upside down */ 5503 /* top clipping */ 5504 if (*destY > buffer->_Ymax) { 5505 unpack->SkipRows += (*destY - buffer->_Ymax); 5506 *height -= (*destY - buffer->_Ymax); 5507 *destY = buffer->_Ymax; 5508 } 5509 /* bottom clipping */ 5510 if (*destY - *height < buffer->_Ymin) 5511 *height -= (buffer->_Ymin - (*destY - *height)); 5512 /* adjust destY so it's the first row to write to */ 5513 (*destY)--; 5514 } 5515 5516 if (*height <= 0) 5517 return GL_FALSE; 5518 5519 return GL_TRUE; 5520} 5521 5522 5523/** 5524 * Perform clipping for glReadPixels. The image's window position 5525 * and size, and the pack skipPixels, skipRows and rowLength are adjusted 5526 * so that the image region is entirely within the window bounds. 5527 * Note: this is different from _mesa_clip_drawpixels() in that the 5528 * scissor box is ignored, and we use the bounds of the current readbuffer 5529 * surface. 5530 * 5531 * \return GL_TRUE if image is ready for drawing or 5532 * GL_FALSE if image was completely clipped away (draw nothing) 5533 */ 5534GLboolean 5535_mesa_clip_readpixels(const GLcontext *ctx, 5536 GLint *srcX, GLint *srcY, 5537 GLsizei *width, GLsizei *height, 5538 struct gl_pixelstore_attrib *pack) 5539{ 5540 const GLframebuffer *buffer = ctx->ReadBuffer; 5541 5542 if (pack->RowLength == 0) { 5543 pack->RowLength = *width; 5544 } 5545 5546 /* left clipping */ 5547 if (*srcX < 0) { 5548 pack->SkipPixels += (0 - *srcX); 5549 *width -= (0 - *srcX); 5550 *srcX = 0; 5551 } 5552 /* right clipping */ 5553 if (*srcX + *width > (GLsizei) buffer->Width) 5554 *width -= (*srcX + *width - buffer->Width); 5555 5556 if (*width <= 0) 5557 return GL_FALSE; 5558 5559 /* bottom clipping */ 5560 if (*srcY < 0) { 5561 pack->SkipRows += (0 - *srcY); 5562 *height -= (0 - *srcY); 5563 *srcY = 0; 5564 } 5565 /* top clipping */ 5566 if (*srcY + *height > (GLsizei) buffer->Height) 5567 *height -= (*srcY + *height - buffer->Height); 5568 5569 if (*height <= 0) 5570 return GL_FALSE; 5571 5572 return GL_TRUE; 5573} 5574 5575 5576/** 5577 * Do clipping for a glCopyTexSubImage call. 5578 * The framebuffer source region might extend outside the framebuffer 5579 * bounds. Clip the source region against the framebuffer bounds and 5580 * adjust the texture/dest position and size accordingly. 5581 * 5582 * \return GL_FALSE if region is totally clipped, GL_TRUE otherwise. 5583 */ 5584GLboolean 5585_mesa_clip_copytexsubimage(const GLcontext *ctx, 5586 GLint *destX, GLint *destY, 5587 GLint *srcX, GLint *srcY, 5588 GLsizei *width, GLsizei *height) 5589{ 5590 const struct gl_framebuffer *fb = ctx->ReadBuffer; 5591 const GLint srcX0 = *srcX, srcY0 = *srcY; 5592 5593 if (_mesa_clip_to_region(0, 0, fb->Width, fb->Height, 5594 srcX, srcY, width, height)) { 5595 *destX = *destX + *srcX - srcX0; 5596 *destY = *destY + *srcY - srcY0; 5597 5598 return GL_TRUE; 5599 } 5600 else { 5601 return GL_FALSE; 5602 } 5603} 5604 5605 5606 5607/** 5608 * Clip the rectangle defined by (x, y, width, height) against the bounds 5609 * specified by [xmin, xmax) and [ymin, ymax). 5610 * \return GL_FALSE if rect is totally clipped, GL_TRUE otherwise. 5611 */ 5612GLboolean 5613_mesa_clip_to_region(GLint xmin, GLint ymin, 5614 GLint xmax, GLint ymax, 5615 GLint *x, GLint *y, 5616 GLsizei *width, GLsizei *height ) 5617{ 5618 /* left clipping */ 5619 if (*x < xmin) { 5620 *width -= (xmin - *x); 5621 *x = xmin; 5622 } 5623 5624 /* right clipping */ 5625 if (*x + *width > xmax) 5626 *width -= (*x + *width - xmax); 5627 5628 if (*width <= 0) 5629 return GL_FALSE; 5630 5631 /* bottom (or top) clipping */ 5632 if (*y < ymin) { 5633 *height -= (ymin - *y); 5634 *y = ymin; 5635 } 5636 5637 /* top (or bottom) clipping */ 5638 if (*y + *height > ymax) 5639 *height -= (*y + *height - ymax); 5640 5641 if (*height <= 0) 5642 return GL_FALSE; 5643 5644 return GL_TRUE; 5645} 5646 5647 5648/** 5649 * Clip dst coords against Xmax (or Ymax). 5650 */ 5651static INLINE void 5652clip_right_or_top(GLint *srcX0, GLint *srcX1, 5653 GLint *dstX0, GLint *dstX1, 5654 GLint maxValue) 5655{ 5656 GLfloat t, bias; 5657 5658 if (*dstX1 > maxValue) { 5659 /* X1 outside right edge */ 5660 ASSERT(*dstX0 < maxValue); /* X0 should be inside right edge */ 5661 t = (GLfloat) (maxValue - *dstX0) / (GLfloat) (*dstX1 - *dstX0); 5662 /* chop off [t, 1] part */ 5663 ASSERT(t >= 0.0 && t <= 1.0); 5664 *dstX1 = maxValue; 5665 bias = (*srcX0 < *srcX1) ? 0.5F : -0.5F; 5666 *srcX1 = *srcX0 + (GLint) (t * (*srcX1 - *srcX0) + bias); 5667 } 5668 else if (*dstX0 > maxValue) { 5669 /* X0 outside right edge */ 5670 ASSERT(*dstX1 < maxValue); /* X1 should be inside right edge */ 5671 t = (GLfloat) (maxValue - *dstX1) / (GLfloat) (*dstX0 - *dstX1); 5672 /* chop off [t, 1] part */ 5673 ASSERT(t >= 0.0 && t <= 1.0); 5674 *dstX0 = maxValue; 5675 bias = (*srcX0 < *srcX1) ? -0.5F : 0.5F; 5676 *srcX0 = *srcX1 + (GLint) (t * (*srcX0 - *srcX1) + bias); 5677 } 5678} 5679 5680 5681/** 5682 * Clip dst coords against Xmin (or Ymin). 5683 */ 5684static INLINE void 5685clip_left_or_bottom(GLint *srcX0, GLint *srcX1, 5686 GLint *dstX0, GLint *dstX1, 5687 GLint minValue) 5688{ 5689 GLfloat t, bias; 5690 5691 if (*dstX0 < minValue) { 5692 /* X0 outside left edge */ 5693 ASSERT(*dstX1 > minValue); /* X1 should be inside left edge */ 5694 t = (GLfloat) (minValue - *dstX0) / (GLfloat) (*dstX1 - *dstX0); 5695 /* chop off [0, t] part */ 5696 ASSERT(t >= 0.0 && t <= 1.0); 5697 *dstX0 = minValue; 5698 bias = (*srcX0 < *srcX1) ? 0.5F : -0.5F; /* flipped??? */ 5699 *srcX0 = *srcX0 + (GLint) (t * (*srcX1 - *srcX0) + bias); 5700 } 5701 else if (*dstX1 < minValue) { 5702 /* X1 outside left edge */ 5703 ASSERT(*dstX0 > minValue); /* X0 should be inside left edge */ 5704 t = (GLfloat) (minValue - *dstX1) / (GLfloat) (*dstX0 - *dstX1); 5705 /* chop off [0, t] part */ 5706 ASSERT(t >= 0.0 && t <= 1.0); 5707 *dstX1 = minValue; 5708 bias = (*srcX0 < *srcX1) ? 0.5F : -0.5F; 5709 *srcX1 = *srcX1 + (GLint) (t * (*srcX0 - *srcX1) + bias); 5710 } 5711} 5712 5713 5714/** 5715 * Do clipping of blit src/dest rectangles. 5716 * The dest rect is clipped against both the buffer bounds and scissor bounds. 5717 * The src rect is just clipped against the buffer bounds. 5718 * 5719 * When either the src or dest rect is clipped, the other is also clipped 5720 * proportionately! 5721 * 5722 * Note that X0 need not be less than X1 (same for Y) for either the source 5723 * and dest rects. That makes the clipping a little trickier. 5724 * 5725 * \return GL_TRUE if anything is left to draw, GL_FALSE if totally clipped 5726 */ 5727GLboolean 5728_mesa_clip_blit(GLcontext *ctx, 5729 GLint *srcX0, GLint *srcY0, GLint *srcX1, GLint *srcY1, 5730 GLint *dstX0, GLint *dstY0, GLint *dstX1, GLint *dstY1) 5731{ 5732 const GLint srcXmin = 0; 5733 const GLint srcXmax = ctx->ReadBuffer->Width; 5734 const GLint srcYmin = 0; 5735 const GLint srcYmax = ctx->ReadBuffer->Height; 5736 5737 /* these include scissor bounds */ 5738 const GLint dstXmin = ctx->DrawBuffer->_Xmin; 5739 const GLint dstXmax = ctx->DrawBuffer->_Xmax; 5740 const GLint dstYmin = ctx->DrawBuffer->_Ymin; 5741 const GLint dstYmax = ctx->DrawBuffer->_Ymax; 5742 5743 /* 5744 printf("PreClipX: src: %d .. %d dst: %d .. %d\n", 5745 *srcX0, *srcX1, *dstX0, *dstX1); 5746 printf("PreClipY: src: %d .. %d dst: %d .. %d\n", 5747 *srcY0, *srcY1, *dstY0, *dstY1); 5748 */ 5749 5750 /* trivial rejection tests */ 5751 if (*dstX0 == *dstX1) 5752 return GL_FALSE; /* no width */ 5753 if (*dstX0 <= dstXmin && *dstX1 <= dstXmin) 5754 return GL_FALSE; /* totally out (left) of bounds */ 5755 if (*dstX0 >= dstXmax && *dstX1 >= dstXmax) 5756 return GL_FALSE; /* totally out (right) of bounds */ 5757 5758 if (*dstY0 == *dstY1) 5759 return GL_FALSE; 5760 if (*dstY0 <= dstYmin && *dstY1 <= dstYmin) 5761 return GL_FALSE; 5762 if (*dstY0 >= dstYmax && *dstY1 >= dstYmax) 5763 return GL_FALSE; 5764 5765 if (*srcX0 == *srcX1) 5766 return GL_FALSE; 5767 if (*srcX0 <= srcXmin && *srcX1 <= srcXmin) 5768 return GL_FALSE; 5769 if (*srcX0 >= srcXmax && *srcX1 >= srcXmax) 5770 return GL_FALSE; 5771 5772 if (*srcY0 == *srcY1) 5773 return GL_FALSE; 5774 if (*srcY0 <= srcYmin && *srcY1 <= srcYmin) 5775 return GL_FALSE; 5776 if (*srcY0 >= srcYmax && *srcY1 >= srcYmax) 5777 return GL_FALSE; 5778 5779 /* 5780 * dest clip 5781 */ 5782 clip_right_or_top(srcX0, srcX1, dstX0, dstX1, dstXmax); 5783 clip_right_or_top(srcY0, srcY1, dstY0, dstY1, dstYmax); 5784 clip_left_or_bottom(srcX0, srcX1, dstX0, dstX1, dstXmin); 5785 clip_left_or_bottom(srcY0, srcY1, dstY0, dstY1, dstYmin); 5786 5787 /* 5788 * src clip (just swap src/dst values from above) 5789 */ 5790 clip_right_or_top(dstX0, dstX1, srcX0, srcX1, srcXmax); 5791 clip_right_or_top(dstY0, dstY1, srcY0, srcY1, srcYmax); 5792 clip_left_or_bottom(dstX0, dstX1, srcX0, srcX1, srcXmin); 5793 clip_left_or_bottom(dstY0, dstY1, srcY0, srcY1, srcYmin); 5794 5795 /* 5796 printf("PostClipX: src: %d .. %d dst: %d .. %d\n", 5797 *srcX0, *srcX1, *dstX0, *dstX1); 5798 printf("PostClipY: src: %d .. %d dst: %d .. %d\n", 5799 *srcY0, *srcY1, *dstY0, *dstY1); 5800 */ 5801 5802 ASSERT(*dstX0 >= dstXmin); 5803 ASSERT(*dstX0 <= dstXmax); 5804 ASSERT(*dstX1 >= dstXmin); 5805 ASSERT(*dstX1 <= dstXmax); 5806 5807 ASSERT(*dstY0 >= dstYmin); 5808 ASSERT(*dstY0 <= dstYmax); 5809 ASSERT(*dstY1 >= dstYmin); 5810 ASSERT(*dstY1 <= dstYmax); 5811 5812 ASSERT(*srcX0 >= srcXmin); 5813 ASSERT(*srcX0 <= srcXmax); 5814 ASSERT(*srcX1 >= srcXmin); 5815 ASSERT(*srcX1 <= srcXmax); 5816 5817 ASSERT(*srcY0 >= srcYmin); 5818 ASSERT(*srcY0 <= srcYmax); 5819 ASSERT(*srcY1 >= srcYmin); 5820 ASSERT(*srcY1 <= srcYmax); 5821 5822 return GL_TRUE; 5823} 5824