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