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