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