image.c revision b1394fa92aaaf859ce9efc8b5fc194397921320c
1/* $Id: image.c,v 1.42 2000/09/26 20:53:53 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 (transferOps & IMAGE_MAP_COLOR_BIT) { 2377 _mesa_map_ci(ctx, n, indexes); 2378 } 2379 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) { 2380 _mesa_shift_and_offset_ci(ctx, n, indexes); 2381 } 2382 2383 if (dstFormat == GL_COLOR_INDEX) { 2384 /* convert to GLubyte and return */ 2385 GLuint i; 2386 for (i = 0; i < n; i++) { 2387 dest[i] = (GLubyte) (indexes[i] & 0xff); 2388 } 2389 return; 2390 } 2391 else { 2392 /* Convert indexes to RGBA */ 2393 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba); 2394 } 2395 } 2396 else { 2397 extract_float_rgba(n, rgba, srcFormat, srcType, source, 2398 srcPacking->SwapBytes); 2399 2400 /* scale and bias colors */ 2401 if (transferOps & IMAGE_SCALE_BIAS_BIT) { 2402 _mesa_scale_and_bias_rgba(ctx, n, rgba); 2403 } 2404 /* color map lookup */ 2405 if (transferOps & IMAGE_MAP_COLOR_BIT) { 2406 _mesa_map_rgba(ctx, n, rgba); 2407 } 2408 } 2409 2410 if (transferOps) { 2411 /* GL_COLOR_TABLE lookup */ 2412 if (transferOps & IMAGE_COLOR_TABLE_BIT) { 2413 _mesa_lookup_rgba(&ctx->ColorTable, n, rgba); 2414 } 2415 /* convolution */ 2416 if (transferOps & IMAGE_CONVOLUTION_BIT) { 2417 /* this has to be done in the calling code */ 2418 } 2419 /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */ 2420 if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) { 2421 _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, n, rgba); 2422 } 2423 /* color matrix transform */ 2424 if (transferOps & IMAGE_COLOR_MATRIX_BIT) { 2425 _mesa_transform_rgba(ctx, n, rgba); 2426 } 2427 /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */ 2428 if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) { 2429 _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, n, rgba); 2430 } 2431 /* update histogram count */ 2432 if (transferOps & IMAGE_HISTOGRAM_BIT) { 2433 _mesa_update_histogram(ctx, n, (CONST GLfloat (*)[4]) rgba); 2434 } 2435 /* min/max here */ 2436 if (transferOps & IMAGE_MIN_MAX_BIT) { 2437 _mesa_update_minmax(ctx, n, (CONST GLfloat (*)[4]) rgba); 2438 } 2439 } 2440 2441 /* clamp to [0,1] */ 2442 { 2443 GLuint i; 2444 for (i = 0; i < n; i++) { 2445 rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F); 2446 rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F); 2447 rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F); 2448 rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F); 2449 } 2450 } 2451 2452 /* Now determine which color channels we need to produce. 2453 * And determine the dest index (offset) within each color tuple. 2454 */ 2455 switch (dstFormat) { 2456 case GL_ALPHA: 2457 dstAlphaIndex = 0; 2458 dstRedIndex = dstGreenIndex = dstBlueIndex = -1; 2459 dstLuminanceIndex = dstIntensityIndex = -1; 2460 break; 2461 case GL_LUMINANCE: 2462 dstLuminanceIndex = 0; 2463 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1; 2464 dstIntensityIndex = -1; 2465 break; 2466 case GL_LUMINANCE_ALPHA: 2467 dstLuminanceIndex = 0; 2468 dstAlphaIndex = 1; 2469 dstRedIndex = dstGreenIndex = dstBlueIndex = -1; 2470 dstIntensityIndex = -1; 2471 break; 2472 case GL_INTENSITY: 2473 dstIntensityIndex = 0; 2474 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1; 2475 dstLuminanceIndex = -1; 2476 break; 2477 case GL_RGB: 2478 dstRedIndex = 0; 2479 dstGreenIndex = 1; 2480 dstBlueIndex = 2; 2481 dstAlphaIndex = dstLuminanceIndex = dstIntensityIndex = -1; 2482 break; 2483 case GL_RGBA: 2484 dstRedIndex = 0; 2485 dstGreenIndex = 1; 2486 dstBlueIndex = 2; 2487 dstAlphaIndex = 3; 2488 dstLuminanceIndex = dstIntensityIndex = -1; 2489 break; 2490 default: 2491 gl_problem(ctx, "bad dstFormat in _mesa_unpack_ubyte_span()"); 2492 return; 2493 } 2494 2495 2496 /* Now return the GLubyte data in the requested dstFormat */ 2497 2498 if (dstRedIndex >= 0) { 2499 GLubyte *dst = dest; 2500 GLuint i; 2501 for (i = 0; i < n; i++) { 2502 dst[dstRedIndex] = FLOAT_TO_UBYTE(rgba[i][RCOMP]); 2503 dst += dstComponents; 2504 } 2505 } 2506 2507 if (dstGreenIndex >= 0) { 2508 GLubyte *dst = dest; 2509 GLuint i; 2510 for (i = 0; i < n; i++) { 2511 dst[dstGreenIndex] = FLOAT_TO_UBYTE(rgba[i][GCOMP]); 2512 dst += dstComponents; 2513 } 2514 } 2515 2516 if (dstBlueIndex >= 0) { 2517 GLubyte *dst = dest; 2518 GLuint i; 2519 for (i = 0; i < n; i++) { 2520 dst[dstBlueIndex] = FLOAT_TO_UBYTE(rgba[i][BCOMP]); 2521 dst += dstComponents; 2522 } 2523 } 2524 2525 if (dstAlphaIndex >= 0) { 2526 GLubyte *dst = dest; 2527 GLuint i; 2528 for (i = 0; i < n; i++) { 2529 dst[dstAlphaIndex] = FLOAT_TO_UBYTE(rgba[i][ACOMP]); 2530 dst += dstComponents; 2531 } 2532 } 2533 2534 if (dstIntensityIndex >= 0) { 2535 GLubyte *dst = dest; 2536 GLuint i; 2537 assert(dstIntensityIndex == 0); 2538 assert(dstComponents == 1); 2539 for (i = 0; i < n; i++) { 2540 /* Intensity comes from red channel */ 2541 dst[i] = FLOAT_TO_UBYTE(rgba[i][RCOMP]); 2542 } 2543 } 2544 2545 if (dstLuminanceIndex >= 0) { 2546 GLubyte *dst = dest; 2547 GLuint i; 2548 assert(dstLuminanceIndex == 0); 2549 for (i = 0; i < n; i++) { 2550 /* Luminance comes from red channel */ 2551 dst[0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]); 2552 dst += dstComponents; 2553 } 2554 } 2555 } 2556} 2557 2558 2559void 2560_mesa_unpack_float_color_span( GLcontext *ctx, 2561 GLuint n, GLenum dstFormat, GLfloat dest[], 2562 GLenum srcFormat, GLenum srcType, 2563 const GLvoid *source, 2564 const struct gl_pixelstore_attrib *srcPacking, 2565 GLuint transferOps, GLboolean clamp ) 2566{ 2567 ASSERT(dstFormat == GL_ALPHA || 2568 dstFormat == GL_LUMINANCE || 2569 dstFormat == GL_LUMINANCE_ALPHA || 2570 dstFormat == GL_INTENSITY || 2571 dstFormat == GL_RGB || 2572 dstFormat == GL_RGBA || 2573 dstFormat == GL_COLOR_INDEX); 2574 2575 ASSERT(srcFormat == GL_RED || 2576 srcFormat == GL_GREEN || 2577 srcFormat == GL_BLUE || 2578 srcFormat == GL_ALPHA || 2579 srcFormat == GL_LUMINANCE || 2580 srcFormat == GL_LUMINANCE_ALPHA || 2581 srcFormat == GL_INTENSITY || 2582 srcFormat == GL_RGB || 2583 srcFormat == GL_BGR || 2584 srcFormat == GL_RGBA || 2585 srcFormat == GL_BGRA || 2586 srcFormat == GL_ABGR_EXT || 2587 srcFormat == GL_COLOR_INDEX); 2588 2589 ASSERT(srcType == GL_BITMAP || 2590 srcType == GL_UNSIGNED_BYTE || 2591 srcType == GL_BYTE || 2592 srcType == GL_UNSIGNED_SHORT || 2593 srcType == GL_SHORT || 2594 srcType == GL_UNSIGNED_INT || 2595 srcType == GL_INT || 2596 srcType == GL_FLOAT || 2597 srcType == GL_UNSIGNED_BYTE_3_3_2 || 2598 srcType == GL_UNSIGNED_BYTE_2_3_3_REV || 2599 srcType == GL_UNSIGNED_SHORT_5_6_5 || 2600 srcType == GL_UNSIGNED_SHORT_5_6_5_REV || 2601 srcType == GL_UNSIGNED_SHORT_4_4_4_4 || 2602 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV || 2603 srcType == GL_UNSIGNED_SHORT_5_5_5_1 || 2604 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV || 2605 srcType == GL_UNSIGNED_INT_8_8_8_8 || 2606 srcType == GL_UNSIGNED_INT_8_8_8_8_REV || 2607 srcType == GL_UNSIGNED_INT_10_10_10_2 || 2608 srcType == GL_UNSIGNED_INT_2_10_10_10_REV); 2609 2610 /* this is intended for RGBA mode only */ 2611 assert(ctx->Visual.RGBAflag); 2612 2613 /* general solution, no special cases, yet */ 2614 { 2615 GLfloat rgba[MAX_WIDTH][4]; 2616 GLint dstComponents; 2617 GLint dstRedIndex, dstGreenIndex, dstBlueIndex, dstAlphaIndex; 2618 GLint dstLuminanceIndex, dstIntensityIndex; 2619 2620 dstComponents = _mesa_components_in_format( dstFormat ); 2621 /* source & dest image formats should have been error checked by now */ 2622 assert(dstComponents > 0); 2623 2624 /* 2625 * Extract image data and convert to RGBA floats 2626 */ 2627 assert(n <= MAX_WIDTH); 2628 if (srcFormat == GL_COLOR_INDEX) { 2629 GLuint indexes[MAX_WIDTH]; 2630 extract_uint_indexes(n, indexes, srcFormat, srcType, source, 2631 srcPacking); 2632 2633 if (transferOps & IMAGE_MAP_COLOR_BIT) { 2634 _mesa_map_ci(ctx, n, indexes); 2635 } 2636 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) { 2637 _mesa_shift_and_offset_ci(ctx, n, indexes); 2638 } 2639 2640 if (dstFormat == GL_COLOR_INDEX) { 2641 /* convert to GLubyte and return */ 2642 GLuint i; 2643 for (i = 0; i < n; i++) { 2644 dest[i] = (GLubyte) (indexes[i] & 0xff); 2645 } 2646 return; 2647 } 2648 else { 2649 /* Convert indexes to RGBA */ 2650 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba); 2651 } 2652 } 2653 else { 2654 extract_float_rgba(n, rgba, srcFormat, srcType, source, 2655 srcPacking->SwapBytes); 2656 2657 /* scale and bias colors */ 2658 if (transferOps & IMAGE_SCALE_BIAS_BIT) { 2659 _mesa_scale_and_bias_rgba(ctx, n, rgba); 2660 } 2661 /* color map lookup */ 2662 if (transferOps & IMAGE_MAP_COLOR_BIT) { 2663 _mesa_map_rgba(ctx, n, rgba); 2664 } 2665 } 2666 2667 if (transferOps) { 2668 /* GL_COLOR_TABLE lookup */ 2669 if (transferOps & IMAGE_COLOR_TABLE_BIT) { 2670 _mesa_lookup_rgba(&ctx->ColorTable, n, rgba); 2671 } 2672 /* convolution */ 2673 if (transferOps & IMAGE_CONVOLUTION_BIT) { 2674 /* XXX to do */ 2675 } 2676 /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */ 2677 if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) { 2678 _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, n, rgba); 2679 } 2680 /* color matrix transform */ 2681 if (transferOps & IMAGE_COLOR_MATRIX_BIT) { 2682 _mesa_transform_rgba(ctx, n, rgba); 2683 } 2684 /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */ 2685 if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) { 2686 _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, n, rgba); 2687 } 2688 /* update histogram count */ 2689 if (transferOps & IMAGE_HISTOGRAM_BIT) { 2690 _mesa_update_histogram(ctx, n, (CONST GLfloat (*)[4]) rgba); 2691 } 2692 /* min/max here */ 2693 if (transferOps & IMAGE_MIN_MAX_BIT) { 2694 _mesa_update_minmax(ctx, n, (CONST GLfloat (*)[4]) rgba); 2695 } 2696 } 2697 2698 /* clamp to [0,1] */ 2699 if (clamp) { 2700 GLuint i; 2701 for (i = 0; i < n; i++) { 2702 rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F); 2703 rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F); 2704 rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F); 2705 rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F); 2706 } 2707 } 2708 2709 /* Now determine which color channels we need to produce. 2710 * And determine the dest index (offset) within each color tuple. 2711 */ 2712 switch (dstFormat) { 2713 case GL_ALPHA: 2714 dstAlphaIndex = 0; 2715 dstRedIndex = dstGreenIndex = dstBlueIndex = -1; 2716 dstLuminanceIndex = dstIntensityIndex = -1; 2717 break; 2718 case GL_LUMINANCE: 2719 dstLuminanceIndex = 0; 2720 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1; 2721 dstIntensityIndex = -1; 2722 break; 2723 case GL_LUMINANCE_ALPHA: 2724 dstLuminanceIndex = 0; 2725 dstAlphaIndex = 1; 2726 dstRedIndex = dstGreenIndex = dstBlueIndex = -1; 2727 dstIntensityIndex = -1; 2728 break; 2729 case GL_INTENSITY: 2730 dstIntensityIndex = 0; 2731 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1; 2732 dstLuminanceIndex = -1; 2733 break; 2734 case GL_RGB: 2735 dstRedIndex = 0; 2736 dstGreenIndex = 1; 2737 dstBlueIndex = 2; 2738 dstAlphaIndex = dstLuminanceIndex = dstIntensityIndex = -1; 2739 break; 2740 case GL_RGBA: 2741 dstRedIndex = 0; 2742 dstGreenIndex = 1; 2743 dstBlueIndex = 2; 2744 dstAlphaIndex = 3; 2745 dstLuminanceIndex = dstIntensityIndex = -1; 2746 break; 2747 default: 2748 gl_problem(ctx, "bad dstFormat in _mesa_unpack_float_color_span()"); 2749 return; 2750 } 2751 2752 /* Now pack results in the requested dstFormat */ 2753 if (dstRedIndex >= 0) { 2754 GLfloat *dst = dest; 2755 GLuint i; 2756 for (i = 0; i < n; i++) { 2757 dst[dstRedIndex] = rgba[i][RCOMP]; 2758 dst += dstComponents; 2759 } 2760 } 2761 2762 if (dstGreenIndex >= 0) { 2763 GLfloat *dst = dest; 2764 GLuint i; 2765 for (i = 0; i < n; i++) { 2766 dst[dstGreenIndex] = rgba[i][GCOMP]; 2767 dst += dstComponents; 2768 } 2769 } 2770 2771 if (dstBlueIndex >= 0) { 2772 GLfloat *dst = dest; 2773 GLuint i; 2774 for (i = 0; i < n; i++) { 2775 dst[dstBlueIndex] = rgba[i][BCOMP]; 2776 dst += dstComponents; 2777 } 2778 } 2779 2780 if (dstAlphaIndex >= 0) { 2781 GLfloat *dst = dest; 2782 GLuint i; 2783 for (i = 0; i < n; i++) { 2784 dst[dstAlphaIndex] = rgba[i][ACOMP]; 2785 dst += dstComponents; 2786 } 2787 } 2788 2789 if (dstIntensityIndex >= 0) { 2790 GLfloat *dst = dest; 2791 GLuint i; 2792 assert(dstIntensityIndex == 0); 2793 assert(dstComponents == 1); 2794 for (i = 0; i < n; i++) { 2795 /* Intensity comes from red channel */ 2796 dst[i] = rgba[i][RCOMP]; 2797 } 2798 } 2799 2800 if (dstLuminanceIndex >= 0) { 2801 GLfloat *dst = dest; 2802 GLuint i; 2803 assert(dstLuminanceIndex == 0); 2804 for (i = 0; i < n; i++) { 2805 /* Luminance comes from red channel */ 2806 dst[0] = rgba[i][RCOMP]; 2807 dst += dstComponents; 2808 } 2809 } 2810 } 2811} 2812 2813 2814 2815 2816/* 2817 * Unpack a row of color index data from a client buffer according to 2818 * the pixel unpacking parameters. 2819 * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc. 2820 * 2821 * Args: ctx - the context 2822 * n - number of pixels 2823 * dstType - destination datatype 2824 * dest - destination array 2825 * srcType - source pixel type 2826 * source - source data pointer 2827 * srcPacking - pixel unpacking parameters 2828 * transferOps - the pixel transfer operations to apply 2829 */ 2830void 2831_mesa_unpack_index_span( const GLcontext *ctx, GLuint n, 2832 GLenum dstType, GLvoid *dest, 2833 GLenum srcType, const GLvoid *source, 2834 const struct gl_pixelstore_attrib *srcPacking, 2835 GLuint transferOps ) 2836{ 2837 ASSERT(srcType == GL_BITMAP || 2838 srcType == GL_UNSIGNED_BYTE || 2839 srcType == GL_BYTE || 2840 srcType == GL_UNSIGNED_SHORT || 2841 srcType == GL_SHORT || 2842 srcType == GL_UNSIGNED_INT || 2843 srcType == GL_INT || 2844 srcType == GL_FLOAT); 2845 2846 ASSERT(dstType == GL_UNSIGNED_BYTE || 2847 dstType == GL_UNSIGNED_SHORT || 2848 dstType == GL_UNSIGNED_INT); 2849 2850 2851 transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT); 2852 2853 /* 2854 * Try simple cases first 2855 */ 2856 if (transferOps == 0 && srcType == GL_UNSIGNED_BYTE 2857 && dstType == GL_UNSIGNED_BYTE) { 2858 MEMCPY(dest, source, n * sizeof(GLubyte)); 2859 } 2860 else if (transferOps == 0 && srcType == GL_UNSIGNED_INT 2861 && dstType == GL_UNSIGNED_INT && !srcPacking->SwapBytes) { 2862 MEMCPY(dest, source, n * sizeof(GLuint)); 2863 } 2864 else { 2865 /* 2866 * general solution 2867 */ 2868 GLuint indexes[MAX_WIDTH]; 2869 assert(n <= MAX_WIDTH); 2870 2871 extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source, 2872 srcPacking); 2873 2874 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) { 2875 /* shift and offset indexes */ 2876 _mesa_shift_and_offset_ci(ctx, n, indexes); 2877 } 2878 if (transferOps & IMAGE_MAP_COLOR_BIT) { 2879 /* Apply lookup table */ 2880 _mesa_map_ci(ctx, n, indexes); 2881 } 2882 2883 /* convert to dest type */ 2884 switch (dstType) { 2885 case GL_UNSIGNED_BYTE: 2886 { 2887 GLubyte *dst = (GLubyte *) dest; 2888 GLuint i; 2889 for (i = 0; i < n; i++) { 2890 dst[i] = (GLubyte) (indexes[i] & 0xff); 2891 } 2892 } 2893 break; 2894 case GL_UNSIGNED_SHORT: 2895 { 2896 GLuint *dst = (GLuint *) dest; 2897 GLuint i; 2898 for (i = 0; i < n; i++) { 2899 dst[i] = (GLushort) (indexes[i] & 0xffff); 2900 } 2901 } 2902 break; 2903 case GL_UNSIGNED_INT: 2904 MEMCPY(dest, indexes, n * sizeof(GLuint)); 2905 break; 2906 default: 2907 gl_problem(ctx, "bad dstType in _mesa_unpack_index_span"); 2908 } 2909 } 2910} 2911 2912 2913/* 2914 * Unpack a row of stencil data from a client buffer according to 2915 * the pixel unpacking parameters. 2916 * This is (or will be) used by glDrawPixels 2917 * 2918 * Args: ctx - the context 2919 * n - number of pixels 2920 * dstType - destination datatype 2921 * dest - destination array 2922 * srcType - source pixel type 2923 * source - source data pointer 2924 * srcPacking - pixel unpacking parameters 2925 * transferOps - apply offset/bias/lookup ops? 2926 */ 2927void 2928_mesa_unpack_stencil_span( const GLcontext *ctx, GLuint n, 2929 GLenum dstType, GLvoid *dest, 2930 GLenum srcType, const GLvoid *source, 2931 const struct gl_pixelstore_attrib *srcPacking, 2932 GLuint transferOps ) 2933{ 2934 ASSERT(srcType == GL_BITMAP || 2935 srcType == GL_UNSIGNED_BYTE || 2936 srcType == GL_BYTE || 2937 srcType == GL_UNSIGNED_SHORT || 2938 srcType == GL_SHORT || 2939 srcType == GL_UNSIGNED_INT || 2940 srcType == GL_INT || 2941 srcType == GL_FLOAT); 2942 2943 ASSERT(dstType == GL_UNSIGNED_BYTE || 2944 dstType == GL_UNSIGNED_SHORT || 2945 dstType == GL_UNSIGNED_INT); 2946 2947 /* only shift and offset apply to stencil */ 2948 transferOps &= IMAGE_SHIFT_OFFSET_BIT; 2949 2950 /* 2951 * Try simple cases first 2952 */ 2953 if (transferOps == 0 && 2954 srcType == GL_UNSIGNED_BYTE && 2955 dstType == GL_UNSIGNED_BYTE) { 2956 MEMCPY(dest, source, n * sizeof(GLubyte)); 2957 } 2958 else if (transferOps == 0 && 2959 srcType == GL_UNSIGNED_INT && 2960 dstType == GL_UNSIGNED_INT && 2961 !srcPacking->SwapBytes) { 2962 MEMCPY(dest, source, n * sizeof(GLuint)); 2963 } 2964 else { 2965 /* 2966 * general solution 2967 */ 2968 GLuint indexes[MAX_WIDTH]; 2969 assert(n <= MAX_WIDTH); 2970 2971 extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source, 2972 srcPacking); 2973 2974 if (transferOps) { 2975 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) { 2976 /* shift and offset indexes */ 2977 _mesa_shift_and_offset_ci(ctx, n, indexes); 2978 } 2979 2980 if (ctx->Pixel.MapStencilFlag) { 2981 /* Apply stencil lookup table */ 2982 GLuint mask = ctx->Pixel.MapStoSsize - 1; 2983 GLuint i; 2984 for (i=0;i<n;i++) { 2985 indexes[i] = ctx->Pixel.MapStoS[ indexes[i] & mask ]; 2986 } 2987 } 2988 } 2989 2990 /* convert to dest type */ 2991 switch (dstType) { 2992 case GL_UNSIGNED_BYTE: 2993 { 2994 GLubyte *dst = (GLubyte *) dest; 2995 GLuint i; 2996 for (i = 0; i < n; i++) { 2997 dst[i] = (GLubyte) (indexes[i] & 0xff); 2998 } 2999 } 3000 break; 3001 case GL_UNSIGNED_SHORT: 3002 { 3003 GLuint *dst = (GLuint *) dest; 3004 GLuint i; 3005 for (i = 0; i < n; i++) { 3006 dst[i] = (GLushort) (indexes[i] & 0xffff); 3007 } 3008 } 3009 break; 3010 case GL_UNSIGNED_INT: 3011 MEMCPY(dest, indexes, n * sizeof(GLuint)); 3012 break; 3013 default: 3014 gl_problem(ctx, "bad dstType in _mesa_unpack_stencil_span"); 3015 } 3016 } 3017} 3018 3019 3020 3021void 3022_mesa_unpack_depth_span( const GLcontext *ctx, GLuint n, GLdepth *dest, 3023 GLenum srcType, const GLvoid *source, 3024 const struct gl_pixelstore_attrib *srcPacking, 3025 GLuint transferOps ) 3026{ 3027 GLfloat *depth = MALLOC(n * sizeof(GLfloat)); 3028 if (!depth) 3029 return; 3030 3031 switch (srcType) { 3032 case GL_BYTE: 3033 { 3034 GLuint i; 3035 const GLubyte *src = (const GLubyte *) source; 3036 for (i = 0; i < n; i++) { 3037 depth[i] = BYTE_TO_FLOAT(src[i]); 3038 } 3039 } 3040 break; 3041 case GL_UNSIGNED_BYTE: 3042 { 3043 GLuint i; 3044 const GLubyte *src = (const GLubyte *) source; 3045 for (i = 0; i < n; i++) { 3046 depth[i] = UBYTE_TO_FLOAT(src[i]); 3047 } 3048 } 3049 break; 3050 case GL_SHORT: 3051 { 3052 GLuint i; 3053 const GLshort *src = (const GLshort *) source; 3054 for (i = 0; i < n; i++) { 3055 depth[i] = SHORT_TO_FLOAT(src[i]); 3056 } 3057 } 3058 break; 3059 case GL_UNSIGNED_SHORT: 3060 { 3061 GLuint i; 3062 const GLushort *src = (const GLushort *) source; 3063 for (i = 0; i < n; i++) { 3064 depth[i] = USHORT_TO_FLOAT(src[i]); 3065 } 3066 } 3067 break; 3068 case GL_INT: 3069 { 3070 GLuint i; 3071 const GLint *src = (const GLint *) source; 3072 for (i = 0; i < n; i++) { 3073 depth[i] = INT_TO_FLOAT(src[i]); 3074 } 3075 } 3076 break; 3077 case GL_UNSIGNED_INT: 3078 { 3079 GLuint i; 3080 const GLuint *src = (const GLuint *) source; 3081 for (i = 0; i < n; i++) { 3082 depth[i] = UINT_TO_FLOAT(src[i]); 3083 } 3084 } 3085 break; 3086 case GL_FLOAT: 3087 MEMCPY(depth, source, n * sizeof(GLfloat)); 3088 break; 3089 default: 3090 gl_problem(NULL, "bad type in _mesa_unpack_depth_span()"); 3091 FREE(depth); 3092 return; 3093 } 3094 3095 3096 /* apply depth scale and bias */ 3097 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) { 3098 GLuint i; 3099 for (i = 0; i < n; i++) { 3100 depth[i] = depth[i] * ctx->Pixel.DepthScale + ctx->Pixel.DepthBias; 3101 } 3102 } 3103 3104 /* clamp depth values to [0,1] and convert from floats to integers */ 3105 { 3106 const GLfloat zs = ctx->Visual.DepthMaxF; 3107 GLuint i; 3108 for (i = 0; i < n; i++) { 3109 dest[i] = (GLdepth) (CLAMP(depth[i], 0.0F, 1.0F) * zs); 3110 } 3111 } 3112 3113 FREE(depth); 3114} 3115 3116 3117 3118/* 3119 * Unpack image data. Apply byteswapping, byte flipping (bitmap). 3120 * Return all image data in a contiguous block. 3121 */ 3122void * 3123_mesa_unpack_image( GLsizei width, GLsizei height, GLsizei depth, 3124 GLenum format, GLenum type, const GLvoid *pixels, 3125 const struct gl_pixelstore_attrib *unpack ) 3126{ 3127 GLint bytesPerRow, compsPerRow; 3128 GLboolean flipBytes, swap2, swap4; 3129 3130 if (!pixels) 3131 return NULL; /* not necessarily an error */ 3132 3133 if (width <= 0 || height <= 0 || depth <= 0) 3134 return NULL; /* generate error later */ 3135 3136 if (format == GL_BITMAP) { 3137 bytesPerRow = (width + 7) >> 3; 3138 flipBytes = !unpack->LsbFirst; 3139 swap2 = swap4 = GL_FALSE; 3140 compsPerRow = 0; 3141 } 3142 else { 3143 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type); 3144 const GLint components = _mesa_components_in_format(format); 3145 GLint bytesPerComp; 3146 if (bytesPerPixel <= 0 || components <= 0) 3147 return NULL; /* bad format or type. generate error later */ 3148 bytesPerRow = bytesPerPixel * width; 3149 bytesPerComp = bytesPerPixel / components; 3150 flipBytes = GL_FALSE; 3151 swap2 = (bytesPerComp == 2) && unpack->SwapBytes; 3152 swap4 = (bytesPerComp == 4) && unpack->SwapBytes; 3153 compsPerRow = components * width; 3154 assert(compsPerRow >= width); 3155 } 3156 3157 { 3158 GLubyte *destBuffer = MALLOC(bytesPerRow * height * depth); 3159 GLubyte *dst; 3160 GLint img, row; 3161 if (!destBuffer) 3162 return NULL; /* generate GL_OUT_OF_MEMORY later */ 3163 3164 dst = destBuffer; 3165 for (img = 0; img < depth; img++) { 3166 for (row = 0; row < height; row++) { 3167 const GLvoid *src = _mesa_image_address(unpack, pixels, 3168 width, height, format, type, img, row, 0); 3169 MEMCPY(dst, src, bytesPerRow); 3170 /* byte flipping/swapping */ 3171 if (flipBytes) { 3172 flip_bytes((GLubyte *) dst, bytesPerRow); 3173 } 3174 else if (swap2) { 3175 _mesa_swap2((GLushort*) dst, compsPerRow); 3176 } 3177 else if (swap4) { 3178 _mesa_swap4((GLuint*) dst, compsPerRow); 3179 } 3180 dst += bytesPerRow; 3181 } 3182 } 3183 return destBuffer; 3184 } 3185} 3186 3187 3188/* 3189 * Unpack bitmap data. Resulting data will be in most-significant-bit-first 3190 * order with row alignment = 1 byte. 3191 */ 3192GLvoid * 3193_mesa_unpack_bitmap( GLint width, GLint height, const GLubyte *pixels, 3194 const struct gl_pixelstore_attrib *packing ) 3195{ 3196 GLint bytes, row, width_in_bytes; 3197 GLubyte *buffer, *dst; 3198 3199 if (!pixels) 3200 return NULL; 3201 3202 /* Alloc dest storage */ 3203 bytes = ((width + 7) / 8 * height); 3204 buffer = (GLubyte *) MALLOC( bytes ); 3205 if (!buffer) 3206 return NULL; 3207 3208 3209 width_in_bytes = CEILING( width, 8 ); 3210 dst = buffer; 3211 for (row = 0; row < height; row++) { 3212 GLubyte *src = _mesa_image_address( packing, pixels, width, height, 3213 GL_COLOR_INDEX, GL_BITMAP, 3214 0, row, 0 ); 3215 if (!src) { 3216 FREE(buffer); 3217 return NULL; 3218 } 3219 3220 if (packing->SkipPixels == 0) { 3221 MEMCPY( dst, src, width_in_bytes ); 3222 if (packing->LsbFirst) { 3223 flip_bytes( dst, width_in_bytes ); 3224 } 3225 } 3226 else { 3227 /* handling SkipPixels is a bit tricky (no pun intended!) */ 3228 GLint i; 3229 if (packing->LsbFirst) { 3230 GLubyte srcMask = 1 << (packing->SkipPixels & 0x7); 3231 GLubyte dstMask = 128; 3232 GLubyte *s = src; 3233 GLubyte *d = dst; 3234 *d = 0; 3235 for (i = 0; i < width; i++) { 3236 if (*s & srcMask) { 3237 *d |= dstMask; 3238 } 3239 if (srcMask == 128) { 3240 srcMask = 1; 3241 s++; 3242 } 3243 else { 3244 srcMask = srcMask << 1; 3245 } 3246 if (dstMask == 1) { 3247 dstMask = 128; 3248 d++; 3249 *d = 0; 3250 } 3251 else { 3252 dstMask = dstMask >> 1; 3253 } 3254 } 3255 } 3256 else { 3257 GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7); 3258 GLubyte dstMask = 128; 3259 GLubyte *s = src; 3260 GLubyte *d = dst; 3261 *d = 0; 3262 for (i = 0; i < width; i++) { 3263 if (*s & srcMask) { 3264 *d |= dstMask; 3265 } 3266 if (srcMask == 1) { 3267 srcMask = 128; 3268 s++; 3269 } 3270 else { 3271 srcMask = srcMask >> 1; 3272 } 3273 if (dstMask == 1) { 3274 dstMask = 128; 3275 d++; 3276 *d = 0; 3277 } 3278 else { 3279 dstMask = dstMask >> 1; 3280 } 3281 } 3282 } 3283 } 3284 dst += width_in_bytes; 3285 } 3286 3287 return buffer; 3288} 3289 3290 3291/* 3292 * Pack bitmap data. 3293 */ 3294void 3295_mesa_pack_bitmap( GLint width, GLint height, const GLubyte *source, 3296 GLubyte *dest, const struct gl_pixelstore_attrib *packing ) 3297{ 3298 GLint row, width_in_bytes; 3299 const GLubyte *src; 3300 3301 if (!source) 3302 return; 3303 3304 width_in_bytes = CEILING( width, 8 ); 3305 src = source; 3306 for (row = 0; row < height; row++) { 3307 GLubyte *dst = _mesa_image_address( packing, dest, width, height, 3308 GL_COLOR_INDEX, GL_BITMAP, 3309 0, row, 0 ); 3310 if (!dst) 3311 return; 3312 3313 if (packing->SkipPixels == 0) { 3314 MEMCPY( dst, src, width_in_bytes ); 3315 if (packing->LsbFirst) { 3316 flip_bytes( dst, width_in_bytes ); 3317 } 3318 } 3319 else { 3320 /* handling SkipPixels is a bit tricky (no pun intended!) */ 3321 GLint i; 3322 if (packing->LsbFirst) { 3323 GLubyte srcMask = 1 << (packing->SkipPixels & 0x7); 3324 GLubyte dstMask = 128; 3325 const GLubyte *s = src; 3326 GLubyte *d = dst; 3327 *d = 0; 3328 for (i = 0; i < width; i++) { 3329 if (*s & srcMask) { 3330 *d |= dstMask; 3331 } 3332 if (srcMask == 128) { 3333 srcMask = 1; 3334 s++; 3335 } 3336 else { 3337 srcMask = srcMask << 1; 3338 } 3339 if (dstMask == 1) { 3340 dstMask = 128; 3341 d++; 3342 *d = 0; 3343 } 3344 else { 3345 dstMask = dstMask >> 1; 3346 } 3347 } 3348 } 3349 else { 3350 GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7); 3351 GLubyte dstMask = 128; 3352 const GLubyte *s = src; 3353 GLubyte *d = dst; 3354 *d = 0; 3355 for (i = 0; i < width; i++) { 3356 if (*s & srcMask) { 3357 *d |= dstMask; 3358 } 3359 if (srcMask == 1) { 3360 srcMask = 128; 3361 s++; 3362 } 3363 else { 3364 srcMask = srcMask >> 1; 3365 } 3366 if (dstMask == 1) { 3367 dstMask = 128; 3368 d++; 3369 *d = 0; 3370 } 3371 else { 3372 dstMask = dstMask >> 1; 3373 } 3374 } 3375 } 3376 } 3377 src += width_in_bytes; 3378 } 3379} 3380