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