ReactOS Development > Doxygen
image.c
Go to the documentation of this file.
00001 /* 00002 * Mesa 3-D graphics library 00003 * Version: 7.1 00004 * 00005 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. 00006 * 00007 * Permission is hereby granted, free of charge, to any person obtaining a 00008 * copy of this software and associated documentation files (the "Software"), 00009 * to deal in the Software without restriction, including without limitation 00010 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 00011 * and/or sell copies of the Software, and to permit persons to whom the 00012 * Software is furnished to do so, subject to the following conditions: 00013 * 00014 * The above copyright notice and this permission notice shall be included 00015 * in all copies or substantial portions of the Software. 00016 * 00017 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 00018 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 00019 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 00020 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN 00021 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 00022 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 00023 */ 00024 00025 00032 #include "glheader.h" 00033 #include "colormac.h" 00034 #include "context.h" 00035 #include "image.h" 00036 #include "imports.h" 00037 #include "macros.h" 00038 #include "pixel.h" 00039 00040 00049 #undef BYTE_TO_FLOAT 00050 #define BYTE_TO_FLOAT(B) ((B) == 0 ? 0.0F : ((2.0F * (B) + 1.0F) * (1.0F/255.0F))) 00051 00052 #undef SHORT_TO_FLOAT 00053 #define SHORT_TO_FLOAT(S) ((S) == 0 ? 0.0F : ((2.0F * (S) + 1.0F) * (1.0F/65535.0F))) 00054 00055 00056 00058 #define CEILING( A, B ) ( (A) % (B) == 0 ? (A)/(B) : (A)/(B)+1 ) 00059 00060 00064 GLboolean 00065 _mesa_type_is_packed(GLenum type) 00066 { 00067 switch (type) { 00068 case GL_UNSIGNED_BYTE_3_3_2: 00069 case GL_UNSIGNED_BYTE_2_3_3_REV: 00070 case GL_UNSIGNED_SHORT_5_6_5: 00071 case GL_UNSIGNED_SHORT_5_6_5_REV: 00072 case GL_UNSIGNED_SHORT_4_4_4_4: 00073 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 00074 case GL_UNSIGNED_SHORT_5_5_5_1: 00075 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 00076 case GL_UNSIGNED_INT_8_8_8_8: 00077 case GL_UNSIGNED_INT_8_8_8_8_REV: 00078 case GL_UNSIGNED_INT_10_10_10_2: 00079 case GL_UNSIGNED_INT_2_10_10_10_REV: 00080 case GL_UNSIGNED_SHORT_8_8_MESA: 00081 case GL_UNSIGNED_SHORT_8_8_REV_MESA: 00082 case GL_UNSIGNED_INT_24_8_EXT: 00083 return GL_TRUE; 00084 } 00085 00086 return GL_FALSE; 00087 } 00088 00102 static void 00103 flip_bytes( GLubyte *p, GLuint n ) 00104 { 00105 GLuint i, a, b; 00106 for (i = 0; i < n; i++) { 00107 b = (GLuint) p[i]; /* words are often faster than bytes */ 00108 a = ((b & 0x01) << 7) | 00109 ((b & 0x02) << 5) | 00110 ((b & 0x04) << 3) | 00111 ((b & 0x08) << 1) | 00112 ((b & 0x10) >> 1) | 00113 ((b & 0x20) >> 3) | 00114 ((b & 0x40) >> 5) | 00115 ((b & 0x80) >> 7); 00116 p[i] = (GLubyte) a; 00117 } 00118 } 00119 00120 00127 void 00128 _mesa_swap2( GLushort *p, GLuint n ) 00129 { 00130 GLuint i; 00131 for (i = 0; i < n; i++) { 00132 p[i] = (p[i] >> 8) | ((p[i] << 8) & 0xff00); 00133 } 00134 } 00135 00136 00137 00138 /* 00139 * Flip the order of the 4 bytes in each word in the given array. 00140 */ 00141 void 00142 _mesa_swap4( GLuint *p, GLuint n ) 00143 { 00144 GLuint i, a, b; 00145 for (i = 0; i < n; i++) { 00146 b = p[i]; 00147 a = (b >> 24) 00148 | ((b >> 8) & 0xff00) 00149 | ((b << 8) & 0xff0000) 00150 | ((b << 24) & 0xff000000); 00151 p[i] = a; 00152 } 00153 } 00154 00155 00164 GLint 00165 _mesa_sizeof_type( GLenum type ) 00166 { 00167 switch (type) { 00168 case GL_BITMAP: 00169 return 0; 00170 case GL_UNSIGNED_BYTE: 00171 return sizeof(GLubyte); 00172 case GL_BYTE: 00173 return sizeof(GLbyte); 00174 case GL_UNSIGNED_SHORT: 00175 return sizeof(GLushort); 00176 case GL_SHORT: 00177 return sizeof(GLshort); 00178 case GL_UNSIGNED_INT: 00179 return sizeof(GLuint); 00180 case GL_INT: 00181 return sizeof(GLint); 00182 case GL_FLOAT: 00183 return sizeof(GLfloat); 00184 case GL_HALF_FLOAT_ARB: 00185 return sizeof(GLhalfARB); 00186 default: 00187 return -1; 00188 } 00189 } 00190 00191 00196 GLint 00197 _mesa_sizeof_packed_type( GLenum type ) 00198 { 00199 switch (type) { 00200 case GL_BITMAP: 00201 return 0; 00202 case GL_UNSIGNED_BYTE: 00203 return sizeof(GLubyte); 00204 case GL_BYTE: 00205 return sizeof(GLbyte); 00206 case GL_UNSIGNED_SHORT: 00207 return sizeof(GLushort); 00208 case GL_SHORT: 00209 return sizeof(GLshort); 00210 case GL_UNSIGNED_INT: 00211 return sizeof(GLuint); 00212 case GL_INT: 00213 return sizeof(GLint); 00214 case GL_HALF_FLOAT_ARB: 00215 return sizeof(GLhalfARB); 00216 case GL_FLOAT: 00217 return sizeof(GLfloat); 00218 case GL_UNSIGNED_BYTE_3_3_2: 00219 return sizeof(GLubyte); 00220 case GL_UNSIGNED_BYTE_2_3_3_REV: 00221 return sizeof(GLubyte); 00222 case GL_UNSIGNED_SHORT_5_6_5: 00223 return sizeof(GLushort); 00224 case GL_UNSIGNED_SHORT_5_6_5_REV: 00225 return sizeof(GLushort); 00226 case GL_UNSIGNED_SHORT_4_4_4_4: 00227 return sizeof(GLushort); 00228 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 00229 return sizeof(GLushort); 00230 case GL_UNSIGNED_SHORT_5_5_5_1: 00231 return sizeof(GLushort); 00232 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 00233 return sizeof(GLushort); 00234 case GL_UNSIGNED_INT_8_8_8_8: 00235 return sizeof(GLuint); 00236 case GL_UNSIGNED_INT_8_8_8_8_REV: 00237 return sizeof(GLuint); 00238 case GL_UNSIGNED_INT_10_10_10_2: 00239 return sizeof(GLuint); 00240 case GL_UNSIGNED_INT_2_10_10_10_REV: 00241 return sizeof(GLuint); 00242 case GL_UNSIGNED_SHORT_8_8_MESA: 00243 case GL_UNSIGNED_SHORT_8_8_REV_MESA: 00244 return sizeof(GLushort); 00245 case GL_UNSIGNED_INT_24_8_EXT: 00246 return sizeof(GLuint); 00247 default: 00248 return -1; 00249 } 00250 } 00251 00252 00260 GLint 00261 _mesa_components_in_format( GLenum format ) 00262 { 00263 switch (format) { 00264 case GL_COLOR_INDEX: 00265 case GL_COLOR_INDEX1_EXT: 00266 case GL_COLOR_INDEX2_EXT: 00267 case GL_COLOR_INDEX4_EXT: 00268 case GL_COLOR_INDEX8_EXT: 00269 case GL_COLOR_INDEX12_EXT: 00270 case GL_COLOR_INDEX16_EXT: 00271 case GL_STENCIL_INDEX: 00272 case GL_DEPTH_COMPONENT: 00273 case GL_RED: 00274 case GL_GREEN: 00275 case GL_BLUE: 00276 case GL_ALPHA: 00277 case GL_LUMINANCE: 00278 case GL_INTENSITY: 00279 return 1; 00280 case GL_LUMINANCE_ALPHA: 00281 return 2; 00282 case GL_RGB: 00283 return 3; 00284 case GL_RGBA: 00285 return 4; 00286 case GL_BGR: 00287 return 3; 00288 case GL_BGRA: 00289 return 4; 00290 case GL_ABGR_EXT: 00291 return 4; 00292 case GL_YCBCR_MESA: 00293 return 2; 00294 case GL_DEPTH_STENCIL_EXT: 00295 return 2; 00296 default: 00297 return -1; 00298 } 00299 } 00300 00301 00310 GLint 00311 _mesa_bytes_per_pixel( GLenum format, GLenum type ) 00312 { 00313 GLint comps = _mesa_components_in_format( format ); 00314 if (comps < 0) 00315 return -1; 00316 00317 switch (type) { 00318 case GL_BITMAP: 00319 return 0; /* special case */ 00320 case GL_BYTE: 00321 case GL_UNSIGNED_BYTE: 00322 return comps * sizeof(GLubyte); 00323 case GL_SHORT: 00324 case GL_UNSIGNED_SHORT: 00325 return comps * sizeof(GLshort); 00326 case GL_INT: 00327 case GL_UNSIGNED_INT: 00328 return comps * sizeof(GLint); 00329 case GL_FLOAT: 00330 return comps * sizeof(GLfloat); 00331 case GL_HALF_FLOAT_ARB: 00332 return comps * sizeof(GLhalfARB); 00333 case GL_UNSIGNED_BYTE_3_3_2: 00334 case GL_UNSIGNED_BYTE_2_3_3_REV: 00335 if (format == GL_RGB || format == GL_BGR) 00336 return sizeof(GLubyte); 00337 else 00338 return -1; /* error */ 00339 case GL_UNSIGNED_SHORT_5_6_5: 00340 case GL_UNSIGNED_SHORT_5_6_5_REV: 00341 if (format == GL_RGB || format == GL_BGR) 00342 return sizeof(GLushort); 00343 else 00344 return -1; /* error */ 00345 case GL_UNSIGNED_SHORT_4_4_4_4: 00346 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 00347 case GL_UNSIGNED_SHORT_5_5_5_1: 00348 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 00349 if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT) 00350 return sizeof(GLushort); 00351 else 00352 return -1; 00353 case GL_UNSIGNED_INT_8_8_8_8: 00354 case GL_UNSIGNED_INT_8_8_8_8_REV: 00355 case GL_UNSIGNED_INT_10_10_10_2: 00356 case GL_UNSIGNED_INT_2_10_10_10_REV: 00357 if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT) 00358 return sizeof(GLuint); 00359 else 00360 return -1; 00361 case GL_UNSIGNED_SHORT_8_8_MESA: 00362 case GL_UNSIGNED_SHORT_8_8_REV_MESA: 00363 if (format == GL_YCBCR_MESA) 00364 return sizeof(GLushort); 00365 else 00366 return -1; 00367 case GL_UNSIGNED_INT_24_8_EXT: 00368 if (format == GL_DEPTH_STENCIL_EXT) 00369 return sizeof(GLuint); 00370 else 00371 return -1; 00372 default: 00373 return -1; 00374 } 00375 } 00376 00377 00387 GLboolean 00388 _mesa_is_legal_format_and_type( GLcontext *ctx, GLenum format, GLenum type ) 00389 { 00390 switch (format) { 00391 case GL_COLOR_INDEX: 00392 case GL_STENCIL_INDEX: 00393 switch (type) { 00394 case GL_BITMAP: 00395 case GL_BYTE: 00396 case GL_UNSIGNED_BYTE: 00397 case GL_SHORT: 00398 case GL_UNSIGNED_SHORT: 00399 case GL_INT: 00400 case GL_UNSIGNED_INT: 00401 case GL_FLOAT: 00402 return GL_TRUE; 00403 case GL_HALF_FLOAT_ARB: 00404 return ctx->Extensions.ARB_half_float_pixel; 00405 default: 00406 return GL_FALSE; 00407 } 00408 case GL_RED: 00409 case GL_GREEN: 00410 case GL_BLUE: 00411 case GL_ALPHA: 00412 #if 0 /* not legal! see table 3.6 of the 1.5 spec */ 00413 case GL_INTENSITY: 00414 #endif 00415 case GL_LUMINANCE: 00416 case GL_LUMINANCE_ALPHA: 00417 case GL_DEPTH_COMPONENT: 00418 switch (type) { 00419 case GL_BYTE: 00420 case GL_UNSIGNED_BYTE: 00421 case GL_SHORT: 00422 case GL_UNSIGNED_SHORT: 00423 case GL_INT: 00424 case GL_UNSIGNED_INT: 00425 case GL_FLOAT: 00426 return GL_TRUE; 00427 case GL_HALF_FLOAT_ARB: 00428 return ctx->Extensions.ARB_half_float_pixel; 00429 default: 00430 return GL_FALSE; 00431 } 00432 case GL_RGB: 00433 switch (type) { 00434 case GL_BYTE: 00435 case GL_UNSIGNED_BYTE: 00436 case GL_SHORT: 00437 case GL_UNSIGNED_SHORT: 00438 case GL_INT: 00439 case GL_UNSIGNED_INT: 00440 case GL_FLOAT: 00441 case GL_UNSIGNED_BYTE_3_3_2: 00442 case GL_UNSIGNED_BYTE_2_3_3_REV: 00443 case GL_UNSIGNED_SHORT_5_6_5: 00444 case GL_UNSIGNED_SHORT_5_6_5_REV: 00445 return GL_TRUE; 00446 case GL_HALF_FLOAT_ARB: 00447 return ctx->Extensions.ARB_half_float_pixel; 00448 default: 00449 return GL_FALSE; 00450 } 00451 case GL_BGR: 00452 switch (type) { 00453 /* NOTE: no packed types are supported with BGR. That's 00454 * intentional, according to the GL spec. 00455 */ 00456 case GL_BYTE: 00457 case GL_UNSIGNED_BYTE: 00458 case GL_SHORT: 00459 case GL_UNSIGNED_SHORT: 00460 case GL_INT: 00461 case GL_UNSIGNED_INT: 00462 case GL_FLOAT: 00463 return GL_TRUE; 00464 case GL_HALF_FLOAT_ARB: 00465 return ctx->Extensions.ARB_half_float_pixel; 00466 default: 00467 return GL_FALSE; 00468 } 00469 case GL_RGBA: 00470 case GL_BGRA: 00471 case GL_ABGR_EXT: 00472 switch (type) { 00473 case GL_BYTE: 00474 case GL_UNSIGNED_BYTE: 00475 case GL_SHORT: 00476 case GL_UNSIGNED_SHORT: 00477 case GL_INT: 00478 case GL_UNSIGNED_INT: 00479 case GL_FLOAT: 00480 case GL_UNSIGNED_SHORT_4_4_4_4: 00481 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 00482 case GL_UNSIGNED_SHORT_5_5_5_1: 00483 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 00484 case GL_UNSIGNED_INT_8_8_8_8: 00485 case GL_UNSIGNED_INT_8_8_8_8_REV: 00486 case GL_UNSIGNED_INT_10_10_10_2: 00487 case GL_UNSIGNED_INT_2_10_10_10_REV: 00488 return GL_TRUE; 00489 case GL_HALF_FLOAT_ARB: 00490 return ctx->Extensions.ARB_half_float_pixel; 00491 default: 00492 return GL_FALSE; 00493 } 00494 case GL_YCBCR_MESA: 00495 if (type == GL_UNSIGNED_SHORT_8_8_MESA || 00496 type == GL_UNSIGNED_SHORT_8_8_REV_MESA) 00497 return GL_TRUE; 00498 else 00499 return GL_FALSE; 00500 case GL_DEPTH_STENCIL_EXT: 00501 if (ctx->Extensions.EXT_packed_depth_stencil 00502 && type == GL_UNSIGNED_INT_24_8_EXT) 00503 return GL_TRUE; 00504 else 00505 return GL_FALSE; 00506 default: 00507 ; /* fall-through */ 00508 } 00509 return GL_FALSE; 00510 } 00511 00512 00533 GLvoid * 00534 _mesa_image_address( GLuint dimensions, 00535 const struct gl_pixelstore_attrib *packing, 00536 const GLvoid *image, 00537 GLsizei width, GLsizei height, 00538 GLenum format, GLenum type, 00539 GLint img, GLint row, GLint column ) 00540 { 00541 GLint alignment; /* 1, 2 or 4 */ 00542 GLint pixels_per_row; 00543 GLint rows_per_image; 00544 GLint skiprows; 00545 GLint skippixels; 00546 GLint skipimages; /* for 3-D volume images */ 00547 GLubyte *pixel_addr; 00548 00549 ASSERT(dimensions >= 1 && dimensions <= 3); 00550 00551 alignment = packing->Alignment; 00552 if (packing->RowLength > 0) { 00553 pixels_per_row = packing->RowLength; 00554 } 00555 else { 00556 pixels_per_row = width; 00557 } 00558 if (packing->ImageHeight > 0) { 00559 rows_per_image = packing->ImageHeight; 00560 } 00561 else { 00562 rows_per_image = height; 00563 } 00564 00565 skippixels = packing->SkipPixels; 00566 /* Note: SKIP_ROWS _is_ used for 1D images */ 00567 skiprows = packing->SkipRows; 00568 /* Note: SKIP_IMAGES is only used for 3D images */ 00569 skipimages = (dimensions == 3) ? packing->SkipImages : 0; 00570 00571 if (type == GL_BITMAP) { 00572 /* BITMAP data */ 00573 GLint comp_per_pixel; /* components per pixel */ 00574 GLint bytes_per_comp; /* bytes per component */ 00575 GLint bytes_per_row; 00576 GLint bytes_per_image; 00577 00578 /* Compute bytes per component */ 00579 bytes_per_comp = _mesa_sizeof_packed_type( type ); 00580 if (bytes_per_comp < 0) { 00581 return NULL; 00582 } 00583 00584 /* Compute number of components per pixel */ 00585 comp_per_pixel = _mesa_components_in_format( format ); 00586 if (comp_per_pixel < 0) { 00587 return NULL; 00588 } 00589 00590 bytes_per_row = alignment 00591 * CEILING( comp_per_pixel*pixels_per_row, 8*alignment ); 00592 00593 bytes_per_image = bytes_per_row * rows_per_image; 00594 00595 pixel_addr = (GLubyte *) image 00596 + (skipimages + img) * bytes_per_image 00597 + (skiprows + row) * bytes_per_row 00598 + (skippixels + column) / 8; 00599 } 00600 else { 00601 /* Non-BITMAP data */ 00602 GLint bytes_per_pixel, bytes_per_row, remainder, bytes_per_image; 00603 GLint topOfImage; 00604 00605 bytes_per_pixel = _mesa_bytes_per_pixel( format, type ); 00606 00607 /* The pixel type and format should have been error checked earlier */ 00608 assert(bytes_per_pixel > 0); 00609 00610 bytes_per_row = pixels_per_row * bytes_per_pixel; 00611 remainder = bytes_per_row % alignment; 00612 if (remainder > 0) 00613 bytes_per_row += (alignment - remainder); 00614 00615 ASSERT(bytes_per_row % alignment == 0); 00616 00617 bytes_per_image = bytes_per_row * rows_per_image; 00618 00619 if (packing->Invert) { 00620 /* set pixel_addr to the last row */ 00621 topOfImage = bytes_per_row * (height - 1); 00622 bytes_per_row = -bytes_per_row; 00623 } 00624 else { 00625 topOfImage = 0; 00626 } 00627 00628 /* compute final pixel address */ 00629 pixel_addr = (GLubyte *) image 00630 + (skipimages + img) * bytes_per_image 00631 + topOfImage 00632 + (skiprows + row) * bytes_per_row 00633 + (skippixels + column) * bytes_per_pixel; 00634 } 00635 00636 return (GLvoid *) pixel_addr; 00637 } 00638 00639 00640 GLvoid * 00641 _mesa_image_address1d( const struct gl_pixelstore_attrib *packing, 00642 const GLvoid *image, 00643 GLsizei width, 00644 GLenum format, GLenum type, 00645 GLint column ) 00646 { 00647 return _mesa_image_address(1, packing, image, width, 1, 00648 format, type, 0, 0, column); 00649 } 00650 00651 00652 GLvoid * 00653 _mesa_image_address2d( const struct gl_pixelstore_attrib *packing, 00654 const GLvoid *image, 00655 GLsizei width, GLsizei height, 00656 GLenum format, GLenum type, 00657 GLint row, GLint column ) 00658 { 00659 return _mesa_image_address(2, packing, image, width, height, 00660 format, type, 0, row, column); 00661 } 00662 00663 00664 GLvoid * 00665 _mesa_image_address3d( const struct gl_pixelstore_attrib *packing, 00666 const GLvoid *image, 00667 GLsizei width, GLsizei height, 00668 GLenum format, GLenum type, 00669 GLint img, GLint row, GLint column ) 00670 { 00671 return _mesa_image_address(3, packing, image, width, height, 00672 format, type, img, row, column); 00673 } 00674 00675 00676 00687 GLint 00688 _mesa_image_row_stride( const struct gl_pixelstore_attrib *packing, 00689 GLint width, GLenum format, GLenum type ) 00690 { 00691 GLint bytesPerRow, remainder; 00692 00693 ASSERT(packing); 00694 00695 if (type == GL_BITMAP) { 00696 if (packing->RowLength == 0) { 00697 bytesPerRow = (width + 7) / 8; 00698 } 00699 else { 00700 bytesPerRow = (packing->RowLength + 7) / 8; 00701 } 00702 } 00703 else { 00704 /* Non-BITMAP data */ 00705 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type); 00706 if (bytesPerPixel <= 0) 00707 return -1; /* error */ 00708 if (packing->RowLength == 0) { 00709 bytesPerRow = bytesPerPixel * width; 00710 } 00711 else { 00712 bytesPerRow = bytesPerPixel * packing->RowLength; 00713 } 00714 } 00715 00716 remainder = bytesPerRow % packing->Alignment; 00717 if (remainder > 0) { 00718 bytesPerRow += (packing->Alignment - remainder); 00719 } 00720 00721 if (packing->Invert) { 00722 /* negate the bytes per row (negative row stride) */ 00723 bytesPerRow = -bytesPerRow; 00724 } 00725 00726 return bytesPerRow; 00727 } 00728 00729 00730 #if _HAVE_FULL_GL 00731 00732 /* 00733 * Compute the stride between images in a 3D texture (in bytes) for the given 00734 * pixel packing parameters and image width, format and type. 00735 */ 00736 GLint 00737 _mesa_image_image_stride( const struct gl_pixelstore_attrib *packing, 00738 GLint width, GLint height, 00739 GLenum format, GLenum type ) 00740 { 00741 ASSERT(packing); 00742 ASSERT(type != GL_BITMAP); 00743 00744 { 00745 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type); 00746 GLint bytesPerRow, bytesPerImage, remainder; 00747 00748 if (bytesPerPixel <= 0) 00749 return -1; /* error */ 00750 if (packing->RowLength == 0) { 00751 bytesPerRow = bytesPerPixel * width; 00752 } 00753 else { 00754 bytesPerRow = bytesPerPixel * packing->RowLength; 00755 } 00756 remainder = bytesPerRow % packing->Alignment; 00757 if (remainder > 0) 00758 bytesPerRow += (packing->Alignment - remainder); 00759 00760 if (packing->ImageHeight == 0) 00761 bytesPerImage = bytesPerRow * height; 00762 else 00763 bytesPerImage = bytesPerRow * packing->ImageHeight; 00764 00765 return bytesPerImage; 00766 } 00767 } 00768 00769 00770 /* 00771 * Unpack a 32x32 pixel polygon stipple from user memory using the 00772 * current pixel unpack settings. 00773 */ 00774 void 00775 _mesa_unpack_polygon_stipple( const GLubyte *pattern, GLuint dest[32], 00776 const struct gl_pixelstore_attrib *unpacking ) 00777 { 00778 GLubyte *ptrn = (GLubyte *) _mesa_unpack_bitmap(32, 32, pattern, unpacking); 00779 if (ptrn) { 00780 /* Convert pattern from GLubytes to GLuints and handle big/little 00781 * endian differences 00782 */ 00783 GLubyte *p = ptrn; 00784 GLint i; 00785 for (i = 0; i < 32; i++) { 00786 dest[i] = (p[0] << 24) 00787 | (p[1] << 16) 00788 | (p[2] << 8) 00789 | (p[3] ); 00790 p += 4; 00791 } 00792 _mesa_free(ptrn); 00793 } 00794 } 00795 00796 00797 /* 00798 * Pack polygon stipple into user memory given current pixel packing 00799 * settings. 00800 */ 00801 void 00802 _mesa_pack_polygon_stipple( const GLuint pattern[32], GLubyte *dest, 00803 const struct gl_pixelstore_attrib *packing ) 00804 { 00805 /* Convert pattern from GLuints to GLubytes to handle big/little 00806 * endian differences. 00807 */ 00808 GLubyte ptrn[32*4]; 00809 GLint i; 00810 for (i = 0; i < 32; i++) { 00811 ptrn[i * 4 + 0] = (GLubyte) ((pattern[i] >> 24) & 0xff); 00812 ptrn[i * 4 + 1] = (GLubyte) ((pattern[i] >> 16) & 0xff); 00813 ptrn[i * 4 + 2] = (GLubyte) ((pattern[i] >> 8 ) & 0xff); 00814 ptrn[i * 4 + 3] = (GLubyte) ((pattern[i] ) & 0xff); 00815 } 00816 00817 _mesa_pack_bitmap(32, 32, ptrn, dest, packing); 00818 } 00819 00820 00821 /* 00822 * Unpack bitmap data. Resulting data will be in most-significant-bit-first 00823 * order with row alignment = 1 byte. 00824 */ 00825 GLvoid * 00826 _mesa_unpack_bitmap( GLint width, GLint height, const GLubyte *pixels, 00827 const struct gl_pixelstore_attrib *packing ) 00828 { 00829 GLint bytes, row, width_in_bytes; 00830 GLubyte *buffer, *dst; 00831 00832 if (!pixels) 00833 return NULL; 00834 00835 /* Alloc dest storage */ 00836 bytes = ((width + 7) / 8 * height); 00837 buffer = (GLubyte *) _mesa_malloc( bytes ); 00838 if (!buffer) 00839 return NULL; 00840 00841 width_in_bytes = CEILING( width, 8 ); 00842 dst = buffer; 00843 for (row = 0; row < height; row++) { 00844 const GLubyte *src = (const GLubyte *) 00845 _mesa_image_address2d(packing, pixels, width, height, 00846 GL_COLOR_INDEX, GL_BITMAP, row, 0); 00847 if (!src) { 00848 _mesa_free(buffer); 00849 return NULL; 00850 } 00851 00852 if ((packing->SkipPixels & 7) == 0) { 00853 _mesa_memcpy( dst, src, width_in_bytes ); 00854 if (packing->LsbFirst) { 00855 flip_bytes( dst, width_in_bytes ); 00856 } 00857 } 00858 else { 00859 /* handling SkipPixels is a bit tricky (no pun intended!) */ 00860 GLint i; 00861 if (packing->LsbFirst) { 00862 GLubyte srcMask = 1 << (packing->SkipPixels & 0x7); 00863 GLubyte dstMask = 128; 00864 const GLubyte *s = src; 00865 GLubyte *d = dst; 00866 *d = 0; 00867 for (i = 0; i < width; i++) { 00868 if (*s & srcMask) { 00869 *d |= dstMask; 00870 } 00871 if (srcMask == 128) { 00872 srcMask = 1; 00873 s++; 00874 } 00875 else { 00876 srcMask = srcMask << 1; 00877 } 00878 if (dstMask == 1) { 00879 dstMask = 128; 00880 d++; 00881 *d = 0; 00882 } 00883 else { 00884 dstMask = dstMask >> 1; 00885 } 00886 } 00887 } 00888 else { 00889 GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7); 00890 GLubyte dstMask = 128; 00891 const GLubyte *s = src; 00892 GLubyte *d = dst; 00893 *d = 0; 00894 for (i = 0; i < width; i++) { 00895 if (*s & srcMask) { 00896 *d |= dstMask; 00897 } 00898 if (srcMask == 1) { 00899 srcMask = 128; 00900 s++; 00901 } 00902 else { 00903 srcMask = srcMask >> 1; 00904 } 00905 if (dstMask == 1) { 00906 dstMask = 128; 00907 d++; 00908 *d = 0; 00909 } 00910 else { 00911 dstMask = dstMask >> 1; 00912 } 00913 } 00914 } 00915 } 00916 dst += width_in_bytes; 00917 } 00918 00919 return buffer; 00920 } 00921 00922 00923 /* 00924 * Pack bitmap data. 00925 */ 00926 void 00927 _mesa_pack_bitmap( GLint width, GLint height, const GLubyte *source, 00928 GLubyte *dest, const struct gl_pixelstore_attrib *packing ) 00929 { 00930 GLint row, width_in_bytes; 00931 const GLubyte *src; 00932 00933 if (!source) 00934 return; 00935 00936 width_in_bytes = CEILING( width, 8 ); 00937 src = source; 00938 for (row = 0; row < height; row++) { 00939 GLubyte *dst = (GLubyte *) _mesa_image_address2d(packing, dest, 00940 width, height, GL_COLOR_INDEX, GL_BITMAP, row, 0); 00941 if (!dst) 00942 return; 00943 00944 if ((packing->SkipPixels & 7) == 0) { 00945 _mesa_memcpy( dst, src, width_in_bytes ); 00946 if (packing->LsbFirst) { 00947 flip_bytes( dst, width_in_bytes ); 00948 } 00949 } 00950 else { 00951 /* handling SkipPixels is a bit tricky (no pun intended!) */ 00952 GLint i; 00953 if (packing->LsbFirst) { 00954 GLubyte srcMask = 128; 00955 GLubyte dstMask = 1 << (packing->SkipPixels & 0x7); 00956 const GLubyte *s = src; 00957 GLubyte *d = dst; 00958 *d = 0; 00959 for (i = 0; i < width; i++) { 00960 if (*s & srcMask) { 00961 *d |= dstMask; 00962 } 00963 if (srcMask == 1) { 00964 srcMask = 128; 00965 s++; 00966 } 00967 else { 00968 srcMask = srcMask >> 1; 00969 } 00970 if (dstMask == 128) { 00971 dstMask = 1; 00972 d++; 00973 *d = 0; 00974 } 00975 else { 00976 dstMask = dstMask << 1; 00977 } 00978 } 00979 } 00980 else { 00981 GLubyte srcMask = 128; 00982 GLubyte dstMask = 128 >> (packing->SkipPixels & 0x7); 00983 const GLubyte *s = src; 00984 GLubyte *d = dst; 00985 *d = 0; 00986 for (i = 0; i < width; i++) { 00987 if (*s & srcMask) { 00988 *d |= dstMask; 00989 } 00990 if (srcMask == 1) { 00991 srcMask = 128; 00992 s++; 00993 } 00994 else { 00995 srcMask = srcMask >> 1; 00996 } 00997 if (dstMask == 1) { 00998 dstMask = 128; 00999 d++; 01000 *d = 0; 01001 } 01002 else { 01003 dstMask = dstMask >> 1; 01004 } 01005 } 01006 } 01007 } 01008 src += width_in_bytes; 01009 } 01010 } 01011 01012 01013 /**********************************************************************/ 01014 /***** Pixel processing functions ******/ 01015 /**********************************************************************/ 01016 01017 /* 01018 * Apply scale and bias factors to an array of RGBA pixels. 01019 */ 01020 void 01021 _mesa_scale_and_bias_rgba(GLuint n, GLfloat rgba[][4], 01022 GLfloat rScale, GLfloat gScale, 01023 GLfloat bScale, GLfloat aScale, 01024 GLfloat rBias, GLfloat gBias, 01025 GLfloat bBias, GLfloat aBias) 01026 { 01027 if (rScale != 1.0 || rBias != 0.0) { 01028 GLuint i; 01029 for (i = 0; i < n; i++) { 01030 rgba[i][RCOMP] = rgba[i][RCOMP] * rScale + rBias; 01031 } 01032 } 01033 if (gScale != 1.0 || gBias != 0.0) { 01034 GLuint i; 01035 for (i = 0; i < n; i++) { 01036 rgba[i][GCOMP] = rgba[i][GCOMP] * gScale + gBias; 01037 } 01038 } 01039 if (bScale != 1.0 || bBias != 0.0) { 01040 GLuint i; 01041 for (i = 0; i < n; i++) { 01042 rgba[i][BCOMP] = rgba[i][BCOMP] * bScale + bBias; 01043 } 01044 } 01045 if (aScale != 1.0 || aBias != 0.0) { 01046 GLuint i; 01047 for (i = 0; i < n; i++) { 01048 rgba[i][ACOMP] = rgba[i][ACOMP] * aScale + aBias; 01049 } 01050 } 01051 } 01052 01053 01054 /* 01055 * Apply pixel mapping to an array of floating point RGBA pixels. 01056 */ 01057 void 01058 _mesa_map_rgba( const GLcontext *ctx, GLuint n, GLfloat rgba[][4] ) 01059 { 01060 const GLfloat rscale = (GLfloat) (ctx->PixelMaps.RtoR.Size - 1); 01061 const GLfloat gscale = (GLfloat) (ctx->PixelMaps.GtoG.Size - 1); 01062 const GLfloat bscale = (GLfloat) (ctx->PixelMaps.BtoB.Size - 1); 01063 const GLfloat ascale = (GLfloat) (ctx->PixelMaps.AtoA.Size - 1); 01064 const GLfloat *rMap = ctx->PixelMaps.RtoR.Map; 01065 const GLfloat *gMap = ctx->PixelMaps.GtoG.Map; 01066 const GLfloat *bMap = ctx->PixelMaps.BtoB.Map; 01067 const GLfloat *aMap = ctx->PixelMaps.AtoA.Map; 01068 GLuint i; 01069 for (i=0;i<n;i++) { 01070 GLfloat r = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F); 01071 GLfloat g = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F); 01072 GLfloat b = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F); 01073 GLfloat a = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F); 01074 rgba[i][RCOMP] = rMap[IROUND(r * rscale)]; 01075 rgba[i][GCOMP] = gMap[IROUND(g * gscale)]; 01076 rgba[i][BCOMP] = bMap[IROUND(b * bscale)]; 01077 rgba[i][ACOMP] = aMap[IROUND(a * ascale)]; 01078 } 01079 } 01080 01081 01082 /* 01083 * Apply the color matrix and post color matrix scaling and biasing. 01084 */ 01085 void 01086 _mesa_transform_rgba(const GLcontext *ctx, GLuint n, GLfloat rgba[][4]) 01087 { 01088 const GLfloat rs = ctx->Pixel.PostColorMatrixScale[0]; 01089 const GLfloat rb = ctx->Pixel.PostColorMatrixBias[0]; 01090 const GLfloat gs = ctx->Pixel.PostColorMatrixScale[1]; 01091 const GLfloat gb = ctx->Pixel.PostColorMatrixBias[1]; 01092 const GLfloat bs = ctx->Pixel.PostColorMatrixScale[2]; 01093 const GLfloat bb = ctx->Pixel.PostColorMatrixBias[2]; 01094 const GLfloat as = ctx->Pixel.PostColorMatrixScale[3]; 01095 const GLfloat ab = ctx->Pixel.PostColorMatrixBias[3]; 01096 const GLfloat *m = ctx->ColorMatrixStack.Top->m; 01097 GLuint i; 01098 for (i = 0; i < n; i++) { 01099 const GLfloat r = rgba[i][RCOMP]; 01100 const GLfloat g = rgba[i][GCOMP]; 01101 const GLfloat b = rgba[i][BCOMP]; 01102 const GLfloat a = rgba[i][ACOMP]; 01103 rgba[i][RCOMP] = (m[0] * r + m[4] * g + m[ 8] * b + m[12] * a) * rs + rb; 01104 rgba[i][GCOMP] = (m[1] * r + m[5] * g + m[ 9] * b + m[13] * a) * gs + gb; 01105 rgba[i][BCOMP] = (m[2] * r + m[6] * g + m[10] * b + m[14] * a) * bs + bb; 01106 rgba[i][ACOMP] = (m[3] * r + m[7] * g + m[11] * b + m[15] * a) * as + ab; 01107 } 01108 } 01109 01110 01114 void 01115 _mesa_lookup_rgba_float(const struct gl_color_table *table, 01116 GLuint n, GLfloat rgba[][4]) 01117 { 01118 const GLint max = table->Size - 1; 01119 const GLfloat scale = (GLfloat) max; 01120 const GLfloat *lut = table->TableF; 01121 GLuint i; 01122 01123 if (!table->TableF || table->Size == 0) 01124 return; 01125 01126 switch (table->_BaseFormat) { 01127 case GL_INTENSITY: 01128 /* replace RGBA with I */ 01129 for (i = 0; i < n; i++) { 01130 GLint j = IROUND(rgba[i][RCOMP] * scale); 01131 GLfloat c = lut[CLAMP(j, 0, max)]; 01132 rgba[i][RCOMP] = 01133 rgba[i][GCOMP] = 01134 rgba[i][BCOMP] = 01135 rgba[i][ACOMP] = c; 01136 } 01137 break; 01138 case GL_LUMINANCE: 01139 /* replace RGB with L */ 01140 for (i = 0; i < n; i++) { 01141 GLint j = IROUND(rgba[i][RCOMP] * scale); 01142 GLfloat c = lut[CLAMP(j, 0, max)]; 01143 rgba[i][RCOMP] = 01144 rgba[i][GCOMP] = 01145 rgba[i][BCOMP] = c; 01146 } 01147 break; 01148 case GL_ALPHA: 01149 /* replace A with A */ 01150 for (i = 0; i < n; i++) { 01151 GLint j = IROUND(rgba[i][ACOMP] * scale); 01152 rgba[i][ACOMP] = lut[CLAMP(j, 0, max)]; 01153 } 01154 break; 01155 case GL_LUMINANCE_ALPHA: 01156 /* replace RGBA with LLLA */ 01157 for (i = 0; i < n; i++) { 01158 GLint jL = IROUND(rgba[i][RCOMP] * scale); 01159 GLint jA = IROUND(rgba[i][ACOMP] * scale); 01160 GLfloat luminance, alpha; 01161 jL = CLAMP(jL, 0, max); 01162 jA = CLAMP(jA, 0, max); 01163 luminance = lut[jL * 2 + 0]; 01164 alpha = lut[jA * 2 + 1]; 01165 rgba[i][RCOMP] = 01166 rgba[i][GCOMP] = 01167 rgba[i][BCOMP] = luminance; 01168 rgba[i][ACOMP] = alpha;; 01169 } 01170 break; 01171 case GL_RGB: 01172 /* replace RGB with RGB */ 01173 for (i = 0; i < n; i++) { 01174 GLint jR = IROUND(rgba[i][RCOMP] * scale); 01175 GLint jG = IROUND(rgba[i][GCOMP] * scale); 01176 GLint jB = IROUND(rgba[i][BCOMP] * scale); 01177 jR = CLAMP(jR, 0, max); 01178 jG = CLAMP(jG, 0, max); 01179 jB = CLAMP(jB, 0, max); 01180 rgba[i][RCOMP] = lut[jR * 3 + 0]; 01181 rgba[i][GCOMP] = lut[jG * 3 + 1]; 01182 rgba[i][BCOMP] = lut[jB * 3 + 2]; 01183 } 01184 break; 01185 case GL_RGBA: 01186 /* replace RGBA with RGBA */ 01187 for (i = 0; i < n; i++) { 01188 GLint jR = IROUND(rgba[i][RCOMP] * scale); 01189 GLint jG = IROUND(rgba[i][GCOMP] * scale); 01190 GLint jB = IROUND(rgba[i][BCOMP] * scale); 01191 GLint jA = IROUND(rgba[i][ACOMP] * scale); 01192 jR = CLAMP(jR, 0, max); 01193 jG = CLAMP(jG, 0, max); 01194 jB = CLAMP(jB, 0, max); 01195 jA = CLAMP(jA, 0, max); 01196 rgba[i][RCOMP] = lut[jR * 4 + 0]; 01197 rgba[i][GCOMP] = lut[jG * 4 + 1]; 01198 rgba[i][BCOMP] = lut[jB * 4 + 2]; 01199 rgba[i][ACOMP] = lut[jA * 4 + 3]; 01200 } 01201 break; 01202 default: 01203 _mesa_problem(NULL, "Bad format in _mesa_lookup_rgba_float"); 01204 return; 01205 } 01206 } 01207 01208 01209 01213 void 01214 _mesa_lookup_rgba_ubyte(const struct gl_color_table *table, 01215 GLuint n, GLubyte rgba[][4]) 01216 { 01217 const GLubyte *lut = table->TableUB; 01218 const GLfloat scale = (GLfloat) (table->Size - 1) / (GLfloat)255.0; 01219 GLuint i; 01220 01221 if (!table->TableUB || table->Size == 0) 01222 return; 01223 01224 switch (table->_BaseFormat) { 01225 case GL_INTENSITY: 01226 /* replace RGBA with I */ 01227 if (table->Size == 256) { 01228 for (i = 0; i < n; i++) { 01229 const GLubyte c = lut[rgba[i][RCOMP]]; 01230 rgba[i][RCOMP] = 01231 rgba[i][GCOMP] = 01232 rgba[i][BCOMP] = 01233 rgba[i][ACOMP] = c; 01234 } 01235 } 01236 else { 01237 for (i = 0; i < n; i++) { 01238 GLint j = IROUND((GLfloat) rgba[i][RCOMP] * scale); 01239 rgba[i][RCOMP] = 01240 rgba[i][GCOMP] = 01241 rgba[i][BCOMP] = 01242 rgba[i][ACOMP] = lut[j]; 01243 } 01244 } 01245 break; 01246 case GL_LUMINANCE: 01247 /* replace RGB with L */ 01248 if (table->Size == 256) { 01249 for (i = 0; i < n; i++) { 01250 const GLubyte c = lut[rgba[i][RCOMP]]; 01251 rgba[i][RCOMP] = 01252 rgba[i][GCOMP] = 01253 rgba[i][BCOMP] = c; 01254 } 01255 } 01256 else { 01257 for (i = 0; i < n; i++) { 01258 GLint j = IROUND((GLfloat) rgba[i][RCOMP] * scale); 01259 rgba[i][RCOMP] = 01260 rgba[i][GCOMP] = 01261 rgba[i][BCOMP] = lut[j]; 01262 } 01263 } 01264 break; 01265 case GL_ALPHA: 01266 /* replace A with A */ 01267 if (table->Size == 256) { 01268 for (i = 0; i < n; i++) { 01269 rgba[i][ACOMP] = lut[rgba[i][ACOMP]]; 01270 } 01271 } 01272 else { 01273 for (i = 0; i < n; i++) { 01274 GLint j = IROUND((GLfloat) rgba[i][ACOMP] * scale); 01275 rgba[i][ACOMP] = lut[j]; 01276 } 01277 } 01278 break; 01279 case GL_LUMINANCE_ALPHA: 01280 /* replace RGBA with LLLA */ 01281 if (table->Size == 256) { 01282 for (i = 0; i < n; i++) { 01283 GLubyte l = lut[rgba[i][RCOMP] * 2 + 0]; 01284 GLubyte a = lut[rgba[i][ACOMP] * 2 + 1];; 01285 rgba[i][RCOMP] = 01286 rgba[i][GCOMP] = 01287 rgba[i][BCOMP] = l; 01288 rgba[i][ACOMP] = a; 01289 } 01290 } 01291 else { 01292 for (i = 0; i < n; i++) { 01293 GLint jL = IROUND((GLfloat) rgba[i][RCOMP] * scale); 01294 GLint jA = IROUND((GLfloat) rgba[i][ACOMP] * scale); 01295 GLubyte luminance = lut[jL * 2 + 0]; 01296 GLubyte alpha = lut[jA * 2 + 1]; 01297 rgba[i][RCOMP] = 01298 rgba[i][GCOMP] = 01299 rgba[i][BCOMP] = luminance; 01300 rgba[i][ACOMP] = alpha; 01301 } 01302 } 01303 break; 01304 case GL_RGB: 01305 if (table->Size == 256) { 01306 for (i = 0; i < n; i++) { 01307 rgba[i][RCOMP] = lut[rgba[i][RCOMP] * 3 + 0]; 01308 rgba[i][GCOMP] = lut[rgba[i][GCOMP] * 3 + 1]; 01309 rgba[i][BCOMP] = lut[rgba[i][BCOMP] * 3 + 2]; 01310 } 01311 } 01312 else { 01313 for (i = 0; i < n; i++) { 01314 GLint jR = IROUND((GLfloat) rgba[i][RCOMP] * scale); 01315 GLint jG = IROUND((GLfloat) rgba[i][GCOMP] * scale); 01316 GLint jB = IROUND((GLfloat) rgba[i][BCOMP] * scale); 01317 rgba[i][RCOMP] = lut[jR * 3 + 0]; 01318 rgba[i][GCOMP] = lut[jG * 3 + 1]; 01319 rgba[i][BCOMP] = lut[jB * 3 + 2]; 01320 } 01321 } 01322 break; 01323 case GL_RGBA: 01324 if (table->Size == 256) { 01325 for (i = 0; i < n; i++) { 01326 rgba[i][RCOMP] = lut[rgba[i][RCOMP] * 4 + 0]; 01327 rgba[i][GCOMP] = lut[rgba[i][GCOMP] * 4 + 1]; 01328 rgba[i][BCOMP] = lut[rgba[i][BCOMP] * 4 + 2]; 01329 rgba[i][ACOMP] = lut[rgba[i][ACOMP] * 4 + 3]; 01330 } 01331 } 01332 else { 01333 for (i = 0; i < n; i++) { 01334 GLint jR = IROUND((GLfloat) rgba[i][RCOMP] * scale); 01335 GLint jG = IROUND((GLfloat) rgba[i][GCOMP] * scale); 01336 GLint jB = IROUND((GLfloat) rgba[i][BCOMP] * scale); 01337 GLint jA = IROUND((GLfloat) rgba[i][ACOMP] * scale); 01338 CLAMPED_FLOAT_TO_CHAN(rgba[i][RCOMP], lut[jR * 4 + 0]); 01339 CLAMPED_FLOAT_TO_CHAN(rgba[i][GCOMP], lut[jG * 4 + 1]); 01340 CLAMPED_FLOAT_TO_CHAN(rgba[i][BCOMP], lut[jB * 4 + 2]); 01341 CLAMPED_FLOAT_TO_CHAN(rgba[i][ACOMP], lut[jA * 4 + 3]); 01342 } 01343 } 01344 break; 01345 default: 01346 _mesa_problem(NULL, "Bad format in _mesa_lookup_rgba_chan"); 01347 return; 01348 } 01349 } 01350 01351 01352 01353 /* 01354 * Map color indexes to float rgba values. 01355 */ 01356 void 01357 _mesa_map_ci_to_rgba( const GLcontext *ctx, GLuint n, 01358 const GLuint index[], GLfloat rgba[][4] ) 01359 { 01360 GLuint rmask = ctx->PixelMaps.ItoR.Size - 1; 01361 GLuint gmask = ctx->PixelMaps.ItoG.Size - 1; 01362 GLuint bmask = ctx->PixelMaps.ItoB.Size - 1; 01363 GLuint amask = ctx->PixelMaps.ItoA.Size - 1; 01364 const GLfloat *rMap = ctx->PixelMaps.ItoR.Map; 01365 const GLfloat *gMap = ctx->PixelMaps.ItoG.Map; 01366 const GLfloat *bMap = ctx->PixelMaps.ItoB.Map; 01367 const GLfloat *aMap = ctx->PixelMaps.ItoA.Map; 01368 GLuint i; 01369 for (i=0;i<n;i++) { 01370 rgba[i][RCOMP] = rMap[index[i] & rmask]; 01371 rgba[i][GCOMP] = gMap[index[i] & gmask]; 01372 rgba[i][BCOMP] = bMap[index[i] & bmask]; 01373 rgba[i][ACOMP] = aMap[index[i] & amask]; 01374 } 01375 } 01376 01377 01381 void 01382 _mesa_map_ci8_to_rgba8(const GLcontext *ctx, GLuint n, const GLubyte index[], 01383 GLubyte rgba[][4]) 01384 { 01385 GLuint rmask = ctx->PixelMaps.ItoR.Size - 1; 01386 GLuint gmask = ctx->PixelMaps.ItoG.Size - 1; 01387 GLuint bmask = ctx->PixelMaps.ItoB.Size - 1; 01388 GLuint amask = ctx->PixelMaps.ItoA.Size - 1; 01389 const GLubyte *rMap = ctx->PixelMaps.ItoR.Map8; 01390 const GLubyte *gMap = ctx->PixelMaps.ItoG.Map8; 01391 const GLubyte *bMap = ctx->PixelMaps.ItoB.Map8; 01392 const GLubyte *aMap = ctx->PixelMaps.ItoA.Map8; 01393 GLuint i; 01394 for (i=0;i<n;i++) { 01395 rgba[i][RCOMP] = rMap[index[i] & rmask]; 01396 rgba[i][GCOMP] = gMap[index[i] & gmask]; 01397 rgba[i][BCOMP] = bMap[index[i] & bmask]; 01398 rgba[i][ACOMP] = aMap[index[i] & amask]; 01399 } 01400 } 01401 01402 01403 void 01404 _mesa_scale_and_bias_depth(const GLcontext *ctx, GLuint n, 01405 GLfloat depthValues[]) 01406 { 01407 const GLfloat scale = ctx->Pixel.DepthScale; 01408 const GLfloat bias = ctx->Pixel.DepthBias; 01409 GLuint i; 01410 for (i = 0; i < n; i++) { 01411 GLfloat d = depthValues[i] * scale + bias; 01412 depthValues[i] = CLAMP(d, 0.0F, 1.0F); 01413 } 01414 } 01415 01416 01417 void 01418 _mesa_scale_and_bias_depth_uint(const GLcontext *ctx, GLuint n, 01419 GLuint depthValues[]) 01420 { 01421 const GLdouble max = (double) 0xffffffff; 01422 const GLdouble scale = ctx->Pixel.DepthScale; 01423 const GLdouble bias = ctx->Pixel.DepthBias * max; 01424 GLuint i; 01425 for (i = 0; i < n; i++) { 01426 GLdouble d = (GLdouble) depthValues[i] * scale + bias; 01427 d = CLAMP(d, 0.0, max); 01428 depthValues[i] = (GLuint) d; 01429 } 01430 } 01431 01432 01433 01434 /* 01435 * Update the min/max values from an array of fragment colors. 01436 */ 01437 static void 01438 update_minmax(GLcontext *ctx, GLuint n, const GLfloat rgba[][4]) 01439 { 01440 GLuint i; 01441 for (i = 0; i < n; i++) { 01442 /* update mins */ 01443 if (rgba[i][RCOMP] < ctx->MinMax.Min[RCOMP]) 01444 ctx->MinMax.Min[RCOMP] = rgba[i][RCOMP]; 01445 if (rgba[i][GCOMP] < ctx->MinMax.Min[GCOMP]) 01446 ctx->MinMax.Min[GCOMP] = rgba[i][GCOMP]; 01447 if (rgba[i][BCOMP] < ctx->MinMax.Min[BCOMP]) 01448 ctx->MinMax.Min[BCOMP] = rgba[i][BCOMP]; 01449 if (rgba[i][ACOMP] < ctx->MinMax.Min[ACOMP]) 01450 ctx->MinMax.Min[ACOMP] = rgba[i][ACOMP]; 01451 01452 /* update maxs */ 01453 if (rgba[i][RCOMP] > ctx->MinMax.Max[RCOMP]) 01454 ctx->MinMax.Max[RCOMP] = rgba[i][RCOMP]; 01455 if (rgba[i][GCOMP] > ctx->MinMax.Max[GCOMP]) 01456 ctx->MinMax.Max[GCOMP] = rgba[i][GCOMP]; 01457 if (rgba[i][BCOMP] > ctx->MinMax.Max[BCOMP]) 01458 ctx->MinMax.Max[BCOMP] = rgba[i][BCOMP]; 01459 if (rgba[i][ACOMP] > ctx->MinMax.Max[ACOMP]) 01460 ctx->MinMax.Max[ACOMP] = rgba[i][ACOMP]; 01461 } 01462 } 01463 01464 01465 /* 01466 * Update the histogram values from an array of fragment colors. 01467 */ 01468 static void 01469 update_histogram(GLcontext *ctx, GLuint n, const GLfloat rgba[][4]) 01470 { 01471 const GLint max = ctx->Histogram.Width - 1; 01472 GLfloat w = (GLfloat) max; 01473 GLuint i; 01474 01475 if (ctx->Histogram.Width == 0) 01476 return; 01477 01478 for (i = 0; i < n; i++) { 01479 GLint ri = IROUND(rgba[i][RCOMP] * w); 01480 GLint gi = IROUND(rgba[i][GCOMP] * w); 01481 GLint bi = IROUND(rgba[i][BCOMP] * w); 01482 GLint ai = IROUND(rgba[i][ACOMP] * w); 01483 ri = CLAMP(ri, 0, max); 01484 gi = CLAMP(gi, 0, max); 01485 bi = CLAMP(bi, 0, max); 01486 ai = CLAMP(ai, 0, max); 01487 ctx->Histogram.Count[ri][RCOMP]++; 01488 ctx->Histogram.Count[gi][GCOMP]++; 01489 ctx->Histogram.Count[bi][BCOMP]++; 01490 ctx->Histogram.Count[ai][ACOMP]++; 01491 } 01492 } 01493 01494 01499 void 01500 _mesa_apply_rgba_transfer_ops(GLcontext *ctx, GLbitfield transferOps, 01501 GLuint n, GLfloat rgba[][4]) 01502 { 01503 /* scale & bias */ 01504 if (transferOps & IMAGE_SCALE_BIAS_BIT) { 01505 _mesa_scale_and_bias_rgba(n, rgba, 01506 ctx->Pixel.RedScale, ctx->Pixel.GreenScale, 01507 ctx->Pixel.BlueScale, ctx->Pixel.AlphaScale, 01508 ctx->Pixel.RedBias, ctx->Pixel.GreenBias, 01509 ctx->Pixel.BlueBias, ctx->Pixel.AlphaBias); 01510 } 01511 /* color map lookup */ 01512 if (transferOps & IMAGE_MAP_COLOR_BIT) { 01513 _mesa_map_rgba( ctx, n, rgba ); 01514 } 01515 /* GL_COLOR_TABLE lookup */ 01516 if (transferOps & IMAGE_COLOR_TABLE_BIT) { 01517 _mesa_lookup_rgba_float(&ctx->ColorTable[COLORTABLE_PRECONVOLUTION], n, rgba); 01518 } 01519 /* convolution */ 01520 if (transferOps & IMAGE_CONVOLUTION_BIT) { 01521 /* this has to be done in the calling code */ 01522 _mesa_problem(ctx, "IMAGE_CONVOLUTION_BIT set in _mesa_apply_transfer_ops"); 01523 } 01524 /* GL_POST_CONVOLUTION_RED/GREEN/BLUE/ALPHA_SCALE/BIAS */ 01525 if (transferOps & IMAGE_POST_CONVOLUTION_SCALE_BIAS) { 01526 _mesa_scale_and_bias_rgba(n, rgba, 01527 ctx->Pixel.PostConvolutionScale[RCOMP], 01528 ctx->Pixel.PostConvolutionScale[GCOMP], 01529 ctx->Pixel.PostConvolutionScale[BCOMP], 01530 ctx->Pixel.PostConvolutionScale[ACOMP], 01531 ctx->Pixel.PostConvolutionBias[RCOMP], 01532 ctx->Pixel.PostConvolutionBias[GCOMP], 01533 ctx->Pixel.PostConvolutionBias[BCOMP], 01534 ctx->Pixel.PostConvolutionBias[ACOMP]); 01535 } 01536 /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */ 01537 if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) { 01538 _mesa_lookup_rgba_float(&ctx->ColorTable[COLORTABLE_POSTCONVOLUTION], n, rgba); 01539 } 01540 /* color matrix transform */ 01541 if (transferOps & IMAGE_COLOR_MATRIX_BIT) { 01542 _mesa_transform_rgba(ctx, n, rgba); 01543 } 01544 /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */ 01545 if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) { 01546 _mesa_lookup_rgba_float(&ctx->ColorTable[COLORTABLE_POSTCOLORMATRIX], n, rgba); 01547 } 01548 /* update histogram count */ 01549 if (transferOps & IMAGE_HISTOGRAM_BIT) { 01550 update_histogram(ctx, n, (CONST GLfloat (*)[4]) rgba); 01551 } 01552 /* update min/max values */ 01553 if (transferOps & IMAGE_MIN_MAX_BIT) { 01554 update_minmax(ctx, n, (CONST GLfloat (*)[4]) rgba); 01555 } 01556 /* clamping to [0,1] */ 01557 if (transferOps & IMAGE_CLAMP_BIT) { 01558 GLuint i; 01559 for (i = 0; i < n; i++) { 01560 rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F); 01561 rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F); 01562 rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F); 01563 rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F); 01564 } 01565 } 01566 } 01567 01568 01569 /* 01570 * Apply color index shift and offset to an array of pixels. 01571 */ 01572 static void 01573 shift_and_offset_ci( const GLcontext *ctx, GLuint n, GLuint indexes[] ) 01574 { 01575 GLint shift = ctx->Pixel.IndexShift; 01576 GLint offset = ctx->Pixel.IndexOffset; 01577 GLuint i; 01578 if (shift > 0) { 01579 for (i=0;i<n;i++) { 01580 indexes[i] = (indexes[i] << shift) + offset; 01581 } 01582 } 01583 else if (shift < 0) { 01584 shift = -shift; 01585 for (i=0;i<n;i++) { 01586 indexes[i] = (indexes[i] >> shift) + offset; 01587 } 01588 } 01589 else { 01590 for (i=0;i<n;i++) { 01591 indexes[i] = indexes[i] + offset; 01592 } 01593 } 01594 } 01595 01596 01597 01602 void 01603 _mesa_apply_ci_transfer_ops(const GLcontext *ctx, GLbitfield transferOps, 01604 GLuint n, GLuint indexes[]) 01605 { 01606 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) { 01607 shift_and_offset_ci(ctx, n, indexes); 01608 } 01609 if (transferOps & IMAGE_MAP_COLOR_BIT) { 01610 const GLuint mask = ctx->PixelMaps.ItoI.Size - 1; 01611 GLuint i; 01612 for (i = 0; i < n; i++) { 01613 const GLuint j = indexes[i] & mask; 01614 indexes[i] = IROUND(ctx->PixelMaps.ItoI.Map[j]); 01615 } 01616 } 01617 } 01618 01619 01624 void 01625 _mesa_apply_stencil_transfer_ops(const GLcontext *ctx, GLuint n, 01626 GLstencil stencil[]) 01627 { 01628 if (ctx->Pixel.IndexShift != 0 || ctx->Pixel.IndexOffset != 0) { 01629 const GLint offset = ctx->Pixel.IndexOffset; 01630 GLint shift = ctx->Pixel.IndexShift; 01631 GLuint i; 01632 if (shift > 0) { 01633 for (i = 0; i < n; i++) { 01634 stencil[i] = (stencil[i] << shift) + offset; 01635 } 01636 } 01637 else if (shift < 0) { 01638 shift = -shift; 01639 for (i = 0; i < n; i++) { 01640 stencil[i] = (stencil[i] >> shift) + offset; 01641 } 01642 } 01643 else { 01644 for (i = 0; i < n; i++) { 01645 stencil[i] = stencil[i] + offset; 01646 } 01647 } 01648 } 01649 if (ctx->Pixel.MapStencilFlag) { 01650 GLuint mask = ctx->PixelMaps.StoS.Size - 1; 01651 GLuint i; 01652 for (i = 0; i < n; i++) { 01653 stencil[i] = (GLstencil)ctx->PixelMaps.StoS.Map[ stencil[i] & mask ]; 01654 } 01655 } 01656 } 01657 01658 01667 void 01668 _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4], 01669 GLenum dstFormat, GLenum dstType, 01670 GLvoid *dstAddr, 01671 const struct gl_pixelstore_attrib *dstPacking, 01672 GLbitfield transferOps) 01673 { 01674 GLfloat luminance[MAX_WIDTH]; 01675 const GLint comps = _mesa_components_in_format(dstFormat); 01676 GLuint i; 01677 01678 if (dstType != GL_FLOAT || ctx->Color.ClampReadColor == GL_TRUE) { 01679 /* need to clamp to [0, 1] */ 01680 transferOps |= IMAGE_CLAMP_BIT; 01681 } 01682 01683 if (transferOps) { 01684 _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba); 01685 if ((transferOps & IMAGE_MIN_MAX_BIT) && ctx->MinMax.Sink) { 01686 return; 01687 } 01688 } 01689 01690 if (dstFormat == GL_LUMINANCE || dstFormat == GL_LUMINANCE_ALPHA) { 01691 /* compute luminance values */ 01692 if (transferOps & IMAGE_CLAMP_BIT) { 01693 for (i = 0; i < n; i++) { 01694 GLfloat sum = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP]; 01695 luminance[i] = CLAMP(sum, 0.0F, 1.0F); 01696 } 01697 } 01698 else { 01699 for (i = 0; i < n; i++) { 01700 luminance[i] = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP]; 01701 } 01702 } 01703 } 01704 01705 /* 01706 * Pack/store the pixels. Ugh! Lots of cases!!! 01707 */ 01708 switch (dstType) { 01709 case GL_UNSIGNED_BYTE: 01710 { 01711 GLubyte *dst = (GLubyte *) dstAddr; 01712 switch (dstFormat) { 01713 case GL_RED: 01714 for (i=0;i<n;i++) 01715 dst[i] = FLOAT_TO_UBYTE(rgba[i][RCOMP]); 01716 break; 01717 case GL_GREEN: 01718 for (i=0;i<n;i++) 01719 dst[i] = FLOAT_TO_UBYTE(rgba[i][GCOMP]); 01720 break; 01721 case GL_BLUE: 01722 for (i=0;i<n;i++) 01723 dst[i] = FLOAT_TO_UBYTE(rgba[i][BCOMP]); 01724 break; 01725 case GL_ALPHA: 01726 for (i=0;i<n;i++) 01727 dst[i] = FLOAT_TO_UBYTE(rgba[i][ACOMP]); 01728 break; 01729 case GL_LUMINANCE: 01730 for (i=0;i<n;i++) 01731 dst[i] = FLOAT_TO_UBYTE(luminance[i]); 01732 break; 01733 case GL_LUMINANCE_ALPHA: 01734 for (i=0;i<n;i++) { 01735 dst[i*2+0] = FLOAT_TO_UBYTE(luminance[i]); 01736 dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][ACOMP]); 01737 } 01738 break; 01739 case GL_RGB: 01740 for (i=0;i<n;i++) { 01741 dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]); 01742 dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]); 01743 dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]); 01744 } 01745 break; 01746 case GL_RGBA: 01747 for (i=0;i<n;i++) { 01748 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]); 01749 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]); 01750 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]); 01751 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]); 01752 } 01753 break; 01754 case GL_BGR: 01755 for (i=0;i<n;i++) { 01756 dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]); 01757 dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]); 01758 dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]); 01759 } 01760 break; 01761 case GL_BGRA: 01762 for (i=0;i<n;i++) { 01763 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]); 01764 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]); 01765 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]); 01766 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]); 01767 } 01768 break; 01769 case GL_ABGR_EXT: 01770 for (i=0;i<n;i++) { 01771 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][ACOMP]); 01772 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][BCOMP]); 01773 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][GCOMP]); 01774 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][RCOMP]); 01775 } 01776 break; 01777 default: 01778 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); 01779 } 01780 } 01781 break; 01782 case GL_BYTE: 01783 { 01784 GLbyte *dst = (GLbyte *) dstAddr; 01785 switch (dstFormat) { 01786 case GL_RED: 01787 for (i=0;i<n;i++) 01788 dst[i] = FLOAT_TO_BYTE(rgba[i][RCOMP]); 01789 break; 01790 case GL_GREEN: 01791 for (i=0;i<n;i++) 01792 dst[i] = FLOAT_TO_BYTE(rgba[i][GCOMP]); 01793 break; 01794 case GL_BLUE: 01795 for (i=0;i<n;i++) 01796 dst[i] = FLOAT_TO_BYTE(rgba[i][BCOMP]); 01797 break; 01798 case GL_ALPHA: 01799 for (i=0;i<n;i++) 01800 dst[i] = FLOAT_TO_BYTE(rgba[i][ACOMP]); 01801 break; 01802 case GL_LUMINANCE: 01803 for (i=0;i<n;i++) 01804 dst[i] = FLOAT_TO_BYTE(luminance[i]); 01805 break; 01806 case GL_LUMINANCE_ALPHA: 01807 for (i=0;i<n;i++) { 01808 dst[i*2+0] = FLOAT_TO_BYTE(luminance[i]); 01809 dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][ACOMP]); 01810 } 01811 break; 01812 case GL_RGB: 01813 for (i=0;i<n;i++) { 01814 dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]); 01815 dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]); 01816 dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]); 01817 } 01818 break; 01819 case GL_RGBA: 01820 for (i=0;i<n;i++) { 01821 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]); 01822 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]); 01823 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]); 01824 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]); 01825 } 01826 break; 01827 case GL_BGR: 01828 for (i=0;i<n;i++) { 01829 dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]); 01830 dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]); 01831 dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]); 01832 } 01833 break; 01834 case GL_BGRA: 01835 for (i=0;i<n;i++) { 01836 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]); 01837 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]); 01838 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]); 01839 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]); 01840 } 01841 break; 01842 case GL_ABGR_EXT: 01843 for (i=0;i<n;i++) { 01844 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][ACOMP]); 01845 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][BCOMP]); 01846 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][GCOMP]); 01847 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][RCOMP]); 01848 } 01849 break; 01850 default: 01851 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); 01852 } 01853 } 01854 break; 01855 case GL_UNSIGNED_SHORT: 01856 { 01857 GLushort *dst = (GLushort *) dstAddr; 01858 switch (dstFormat) { 01859 case GL_RED: 01860 for (i=0;i<n;i++) 01861 CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][RCOMP]); 01862 break; 01863 case GL_GREEN: 01864 for (i=0;i<n;i++) 01865 CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][GCOMP]); 01866 break; 01867 case GL_BLUE: 01868 for (i=0;i<n;i++) 01869 CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][BCOMP]); 01870 break; 01871 case GL_ALPHA: 01872 for (i=0;i<n;i++) 01873 CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][ACOMP]); 01874 break; 01875 case GL_LUMINANCE: 01876 for (i=0;i<n;i++) 01877 UNCLAMPED_FLOAT_TO_USHORT(dst[i], luminance[i]); 01878 break; 01879 case GL_LUMINANCE_ALPHA: 01880 for (i=0;i<n;i++) { 01881 UNCLAMPED_FLOAT_TO_USHORT(dst[i*2+0], luminance[i]); 01882 CLAMPED_FLOAT_TO_USHORT(dst[i*2+1], rgba[i][ACOMP]); 01883 } 01884 break; 01885 case GL_RGB: 01886 for (i=0;i<n;i++) { 01887 CLAMPED_FLOAT_TO_USHORT(dst[i*3+0], rgba[i][RCOMP]); 01888 CLAMPED_FLOAT_TO_USHORT(dst[i*3+1], rgba[i][GCOMP]); 01889 CLAMPED_FLOAT_TO_USHORT(dst[i*3+2], rgba[i][BCOMP]); 01890 } 01891 break; 01892 case GL_RGBA: 01893 for (i=0;i<n;i++) { 01894 CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][RCOMP]); 01895 CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][GCOMP]); 01896 CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][BCOMP]); 01897 CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][ACOMP]); 01898 } 01899 break; 01900 case GL_BGR: 01901 for (i=0;i<n;i++) { 01902 CLAMPED_FLOAT_TO_USHORT(dst[i*3+0], rgba[i][BCOMP]); 01903 CLAMPED_FLOAT_TO_USHORT(dst[i*3+1], rgba[i][GCOMP]); 01904 CLAMPED_FLOAT_TO_USHORT(dst[i*3+2], rgba[i][RCOMP]); 01905 } 01906 break; 01907 case GL_BGRA: 01908 for (i=0;i<n;i++) { 01909 CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][BCOMP]); 01910 CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][GCOMP]); 01911 CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][RCOMP]); 01912 CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][ACOMP]); 01913 } 01914 break; 01915 case GL_ABGR_EXT: 01916 for (i=0;i<n;i++) { 01917 CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][ACOMP]); 01918 CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][BCOMP]); 01919 CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][GCOMP]); 01920 CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][RCOMP]); 01921 } 01922 break; 01923 default: 01924 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); 01925 } 01926 } 01927 break; 01928 case GL_SHORT: 01929 { 01930 GLshort *dst = (GLshort *) dstAddr; 01931 switch (dstFormat) { 01932 case GL_RED: 01933 for (i=0;i<n;i++) 01934 dst[i] = FLOAT_TO_SHORT(rgba[i][RCOMP]); 01935 break; 01936 case GL_GREEN: 01937 for (i=0;i<n;i++) 01938 dst[i] = FLOAT_TO_SHORT(rgba[i][GCOMP]); 01939 break; 01940 case GL_BLUE: 01941 for (i=0;i<n;i++) 01942 dst[i] = FLOAT_TO_SHORT(rgba[i][BCOMP]); 01943 break; 01944 case GL_ALPHA: 01945 for (i=0;i<n;i++) 01946 dst[i] = FLOAT_TO_SHORT(rgba[i][ACOMP]); 01947 break; 01948 case GL_LUMINANCE: 01949 for (i=0;i<n;i++) 01950 dst[i] = FLOAT_TO_SHORT(luminance[i]); 01951 break; 01952 case GL_LUMINANCE_ALPHA: 01953 for (i=0;i<n;i++) { 01954 dst[i*2+0] = FLOAT_TO_SHORT(luminance[i]); 01955 dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][ACOMP]); 01956 } 01957 break; 01958 case GL_RGB: 01959 for (i=0;i<n;i++) { 01960 dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]); 01961 dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]); 01962 dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]); 01963 } 01964 break; 01965 case GL_RGBA: 01966 for (i=0;i<n;i++) { 01967 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]); 01968 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]); 01969 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]); 01970 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]); 01971 } 01972 break; 01973 case GL_BGR: 01974 for (i=0;i<n;i++) { 01975 dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]); 01976 dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]); 01977 dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]); 01978 } 01979 break; 01980 case GL_BGRA: 01981 for (i=0;i<n;i++) { 01982 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]); 01983 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]); 01984 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]); 01985 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]); 01986 } 01987 break; 01988 case GL_ABGR_EXT: 01989 for (i=0;i<n;i++) { 01990 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][ACOMP]); 01991 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][BCOMP]); 01992 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][GCOMP]); 01993 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][RCOMP]); 01994 } 01995 break; 01996 default: 01997 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); 01998 } 01999 } 02000 break; 02001 case GL_UNSIGNED_INT: 02002 { 02003 GLuint *dst = (GLuint *) dstAddr; 02004 switch (dstFormat) { 02005 case GL_RED: 02006 for (i=0;i<n;i++) 02007 dst[i] = FLOAT_TO_UINT(rgba[i][RCOMP]); 02008 break; 02009 case GL_GREEN: 02010 for (i=0;i<n;i++) 02011 dst[i] = FLOAT_TO_UINT(rgba[i][GCOMP]); 02012 break; 02013 case GL_BLUE: 02014 for (i=0;i<n;i++) 02015 dst[i] = FLOAT_TO_UINT(rgba[i][BCOMP]); 02016 break; 02017 case GL_ALPHA: 02018 for (i=0;i<n;i++) 02019 dst[i] = FLOAT_TO_UINT(rgba[i][ACOMP]); 02020 break; 02021 case GL_LUMINANCE: 02022 for (i=0;i<n;i++) 02023 dst[i] = FLOAT_TO_UINT(luminance[i]); 02024 break; 02025 case GL_LUMINANCE_ALPHA: 02026 for (i=0;i<n;i++) { 02027 dst[i*2+0] = FLOAT_TO_UINT(luminance[i]); 02028 dst[i*2+1] = FLOAT_TO_UINT(rgba[i][ACOMP]); 02029 } 02030 break; 02031 case GL_RGB: 02032 for (i=0;i<n;i++) { 02033 dst[i*3+0] = FLOAT_TO_UINT(rgba[i][RCOMP]); 02034 dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]); 02035 dst[i*3+2] = FLOAT_TO_UINT(rgba[i][BCOMP]); 02036 } 02037 break; 02038 case GL_RGBA: 02039 for (i=0;i<n;i++) { 02040 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][RCOMP]); 02041 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]); 02042 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][BCOMP]); 02043 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]); 02044 } 02045 break; 02046 case GL_BGR: 02047 for (i=0;i<n;i++) { 02048 dst[i*3+0] = FLOAT_TO_UINT(rgba[i][BCOMP]); 02049 dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]); 02050 dst[i*3+2] = FLOAT_TO_UINT(rgba[i][RCOMP]); 02051 } 02052 break; 02053 case GL_BGRA: 02054 for (i=0;i<n;i++) { 02055 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][BCOMP]); 02056 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]); 02057 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][RCOMP]); 02058 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]); 02059 } 02060 break; 02061 case GL_ABGR_EXT: 02062 for (i=0;i<n;i++) { 02063 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][ACOMP]); 02064 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][BCOMP]); 02065 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][GCOMP]); 02066 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][RCOMP]); 02067 } 02068 break; 02069 default: 02070 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); 02071 } 02072 } 02073 break; 02074 case GL_INT: 02075 { 02076 GLint *dst = (GLint *) dstAddr; 02077 switch (dstFormat) { 02078 case GL_RED: 02079 for (i=0;i<n;i++) 02080 dst[i] = FLOAT_TO_INT(rgba[i][RCOMP]); 02081 break; 02082 case GL_GREEN: 02083 for (i=0;i<n;i++) 02084 dst[i] = FLOAT_TO_INT(rgba[i][GCOMP]); 02085 break; 02086 case GL_BLUE: 02087 for (i=0;i<n;i++) 02088 dst[i] = FLOAT_TO_INT(rgba[i][BCOMP]); 02089 break; 02090 case GL_ALPHA: 02091 for (i=0;i<n;i++) 02092 dst[i] = FLOAT_TO_INT(rgba[i][ACOMP]); 02093 break; 02094 case GL_LUMINANCE: 02095 for (i=0;i<n;i++) 02096 dst[i] = FLOAT_TO_INT(luminance[i]); 02097 break; 02098 case GL_LUMINANCE_ALPHA: 02099 for (i=0;i<n;i++) { 02100 dst[i*2+0] = FLOAT_TO_INT(luminance[i]); 02101 dst[i*2+1] = FLOAT_TO_INT(rgba[i][ACOMP]); 02102 } 02103 break; 02104 case GL_RGB: 02105 for (i=0;i<n;i++) { 02106 dst[i*3+0] = FLOAT_TO_INT(rgba[i][RCOMP]); 02107 dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]); 02108 dst[i*3+2] = FLOAT_TO_INT(rgba[i][BCOMP]); 02109 } 02110 break; 02111 case GL_RGBA: 02112 for (i=0;i<n;i++) { 02113 dst[i*4+0] = FLOAT_TO_INT(rgba[i][RCOMP]); 02114 dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]); 02115 dst[i*4+2] = FLOAT_TO_INT(rgba[i][BCOMP]); 02116 dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]); 02117 } 02118 break; 02119 case GL_BGR: 02120 for (i=0;i<n;i++) { 02121 dst[i*3+0] = FLOAT_TO_INT(rgba[i][BCOMP]); 02122 dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]); 02123 dst[i*3+2] = FLOAT_TO_INT(rgba[i][RCOMP]); 02124 } 02125 break; 02126 case GL_BGRA: 02127 for (i=0;i<n;i++) { 02128 dst[i*4+0] = FLOAT_TO_INT(rgba[i][BCOMP]); 02129 dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]); 02130 dst[i*4+2] = FLOAT_TO_INT(rgba[i][RCOMP]); 02131 dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]); 02132 } 02133 break; 02134 case GL_ABGR_EXT: 02135 for (i=0;i<n;i++) { 02136 dst[i*4+0] = FLOAT_TO_INT(rgba[i][ACOMP]); 02137 dst[i*4+1] = FLOAT_TO_INT(rgba[i][BCOMP]); 02138 dst[i*4+2] = FLOAT_TO_INT(rgba[i][GCOMP]); 02139 dst[i*4+3] = FLOAT_TO_INT(rgba[i][RCOMP]); 02140 } 02141 break; 02142 default: 02143 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); 02144 } 02145 } 02146 break; 02147 case GL_FLOAT: 02148 { 02149 GLfloat *dst = (GLfloat *) dstAddr; 02150 switch (dstFormat) { 02151 case GL_RED: 02152 for (i=0;i<n;i++) 02153 dst[i] = rgba[i][RCOMP]; 02154 break; 02155 case GL_GREEN: 02156 for (i=0;i<n;i++) 02157 dst[i] = rgba[i][GCOMP]; 02158 break; 02159 case GL_BLUE: 02160 for (i=0;i<n;i++) 02161 dst[i] = rgba[i][BCOMP]; 02162 break; 02163 case GL_ALPHA: 02164 for (i=0;i<n;i++) 02165 dst[i] = rgba[i][ACOMP]; 02166 break; 02167 case GL_LUMINANCE: 02168 for (i=0;i<n;i++) 02169 dst[i] = luminance[i]; 02170 break; 02171 case GL_LUMINANCE_ALPHA: 02172 for (i=0;i<n;i++) { 02173 dst[i*2+0] = luminance[i]; 02174 dst[i*2+1] = rgba[i][ACOMP]; 02175 } 02176 break; 02177 case GL_RGB: 02178 for (i=0;i<n;i++) { 02179 dst[i*3+0] = rgba[i][RCOMP]; 02180 dst[i*3+1] = rgba[i][GCOMP]; 02181 dst[i*3+2] = rgba[i][BCOMP]; 02182 } 02183 break; 02184 case GL_RGBA: 02185 for (i=0;i<n;i++) { 02186 dst[i*4+0] = rgba[i][RCOMP]; 02187 dst[i*4+1] = rgba[i][GCOMP]; 02188 dst[i*4+2] = rgba[i][BCOMP]; 02189 dst[i*4+3] = rgba[i][ACOMP]; 02190 } 02191 break; 02192 case GL_BGR: 02193 for (i=0;i<n;i++) { 02194 dst[i*3+0] = rgba[i][BCOMP]; 02195 dst[i*3+1] = rgba[i][GCOMP]; 02196 dst[i*3+2] = rgba[i][RCOMP]; 02197 } 02198 break; 02199 case GL_BGRA: 02200 for (i=0;i<n;i++) { 02201 dst[i*4+0] = rgba[i][BCOMP]; 02202 dst[i*4+1] = rgba[i][GCOMP]; 02203 dst[i*4+2] = rgba[i][RCOMP]; 02204 dst[i*4+3] = rgba[i][ACOMP]; 02205 } 02206 break; 02207 case GL_ABGR_EXT: 02208 for (i=0;i<n;i++) { 02209 dst[i*4+0] = rgba[i][ACOMP]; 02210 dst[i*4+1] = rgba[i][BCOMP]; 02211 dst[i*4+2] = rgba[i][GCOMP]; 02212 dst[i*4+3] = rgba[i][RCOMP]; 02213 } 02214 break; 02215 default: 02216 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); 02217 } 02218 } 02219 break; 02220 case GL_HALF_FLOAT_ARB: 02221 { 02222 GLhalfARB *dst = (GLhalfARB *) dstAddr; 02223 switch (dstFormat) { 02224 case GL_RED: 02225 for (i=0;i<n;i++) 02226 dst[i] = _mesa_float_to_half(rgba[i][RCOMP]); 02227 break; 02228 case GL_GREEN: 02229 for (i=0;i<n;i++) 02230 dst[i] = _mesa_float_to_half(rgba[i][GCOMP]); 02231 break; 02232 case GL_BLUE: 02233 for (i=0;i<n;i++) 02234 dst[i] = _mesa_float_to_half(rgba[i][BCOMP]); 02235 break; 02236 case GL_ALPHA: 02237 for (i=0;i<n;i++) 02238 dst[i] = _mesa_float_to_half(rgba[i][ACOMP]); 02239 break; 02240 case GL_LUMINANCE: 02241 for (i=0;i<n;i++) 02242 dst[i] = _mesa_float_to_half(luminance[i]); 02243 break; 02244 case GL_LUMINANCE_ALPHA: 02245 for (i=0;i<n;i++) { 02246 dst[i*2+0] = _mesa_float_to_half(luminance[i]); 02247 dst[i*2+1] = _mesa_float_to_half(rgba[i][ACOMP]); 02248 } 02249 break; 02250 case GL_RGB: 02251 for (i=0;i<n;i++) { 02252 dst[i*3+0] = _mesa_float_to_half(rgba[i][RCOMP]); 02253 dst[i*3+1] = _mesa_float_to_half(rgba[i][GCOMP]); 02254 dst[i*3+2] = _mesa_float_to_half(rgba[i][BCOMP]); 02255 } 02256 break; 02257 case GL_RGBA: 02258 for (i=0;i<n;i++) { 02259 dst[i*4+0] = _mesa_float_to_half(rgba[i][RCOMP]); 02260 dst[i*4+1] = _mesa_float_to_half(rgba[i][GCOMP]); 02261 dst[i*4+2] = _mesa_float_to_half(rgba[i][BCOMP]); 02262 dst[i*4+3] = _mesa_float_to_half(rgba[i][ACOMP]); 02263 } 02264 break; 02265 case GL_BGR: 02266 for (i=0;i<n;i++) { 02267 dst[i*3+0] = _mesa_float_to_half(rgba[i][BCOMP]); 02268 dst[i*3+1] = _mesa_float_to_half(rgba[i][GCOMP]); 02269 dst[i*3+2] = _mesa_float_to_half(rgba[i][RCOMP]); 02270 } 02271 break; 02272 case GL_BGRA: 02273 for (i=0;i<n;i++) { 02274 dst[i*4+0] = _mesa_float_to_half(rgba[i][BCOMP]); 02275 dst[i*4+1] = _mesa_float_to_half(rgba[i][GCOMP]); 02276 dst[i*4+2] = _mesa_float_to_half(rgba[i][RCOMP]); 02277 dst[i*4+3] = _mesa_float_to_half(rgba[i][ACOMP]); 02278 } 02279 break; 02280 case GL_ABGR_EXT: 02281 for (i=0;i<n;i++) { 02282 dst[i*4+0] = _mesa_float_to_half(rgba[i][ACOMP]); 02283 dst[i*4+1] = _mesa_float_to_half(rgba[i][BCOMP]); 02284 dst[i*4+2] = _mesa_float_to_half(rgba[i][GCOMP]); 02285 dst[i*4+3] = _mesa_float_to_half(rgba[i][RCOMP]); 02286 } 02287 break; 02288 default: 02289 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); 02290 } 02291 } 02292 break; 02293 case GL_UNSIGNED_BYTE_3_3_2: 02294 if (dstFormat == GL_RGB) { 02295 GLubyte *dst = (GLubyte *) dstAddr; 02296 for (i=0;i<n;i++) { 02297 dst[i] = (((GLint) (rgba[i][RCOMP] * 7.0F)) << 5) 02298 | (((GLint) (rgba[i][GCOMP] * 7.0F)) << 2) 02299 | (((GLint) (rgba[i][BCOMP] * 3.0F)) ); 02300 } 02301 } 02302 break; 02303 case GL_UNSIGNED_BYTE_2_3_3_REV: 02304 if (dstFormat == GL_RGB) { 02305 GLubyte *dst = (GLubyte *) dstAddr; 02306 for (i=0;i<n;i++) { 02307 dst[i] = (((GLint) (rgba[i][RCOMP] * 7.0F)) ) 02308 | (((GLint) (rgba[i][GCOMP] * 7.0F)) << 3) 02309 | (((GLint) (rgba[i][BCOMP] * 3.0F)) << 6); 02310 } 02311 } 02312 break; 02313 case GL_UNSIGNED_SHORT_5_6_5: 02314 if (dstFormat == GL_RGB) { 02315 GLushort *dst = (GLushort *) dstAddr; 02316 for (i=0;i<n;i++) { 02317 dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) << 11) 02318 | (((GLint) (rgba[i][GCOMP] * 63.0F)) << 5) 02319 | (((GLint) (rgba[i][BCOMP] * 31.0F)) ); 02320 } 02321 } 02322 break; 02323 case GL_UNSIGNED_SHORT_5_6_5_REV: 02324 if (dstFormat == GL_RGB) { 02325 GLushort *dst = (GLushort *) dstAddr; 02326 for (i=0;i<n;i++) { 02327 dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) ) 02328 | (((GLint) (rgba[i][GCOMP] * 63.0F)) << 5) 02329 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 11); 02330 } 02331 } 02332 break; 02333 case GL_UNSIGNED_SHORT_4_4_4_4: 02334 if (dstFormat == GL_RGBA) { 02335 GLushort *dst = (GLushort *) dstAddr; 02336 for (i=0;i<n;i++) { 02337 dst[i] = (((GLint) (rgba[i][RCOMP] * 15.0F)) << 12) 02338 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 8) 02339 | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 4) 02340 | (((GLint) (rgba[i][ACOMP] * 15.0F)) ); 02341 } 02342 } 02343 else if (dstFormat == GL_BGRA) { 02344 GLushort *dst = (GLushort *) dstAddr; 02345 for (i=0;i<n;i++) { 02346 dst[i] = (((GLint) (rgba[i][BCOMP] * 15.0F)) << 12) 02347 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 8) 02348 | (((GLint) (rgba[i][RCOMP] * 15.0F)) << 4) 02349 | (((GLint) (rgba[i][ACOMP] * 15.0F)) ); 02350 } 02351 } 02352 else if (dstFormat == GL_ABGR_EXT) { 02353 GLushort *dst = (GLushort *) dstAddr; 02354 for (i=0;i<n;i++) { 02355 dst[i] = (((GLint) (rgba[i][ACOMP] * 15.0F)) << 12) 02356 | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 8) 02357 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 4) 02358 | (((GLint) (rgba[i][RCOMP] * 15.0F)) ); 02359 } 02360 } 02361 break; 02362 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 02363 if (dstFormat == GL_RGBA) { 02364 GLushort *dst = (GLushort *) dstAddr; 02365 for (i=0;i<n;i++) { 02366 dst[i] = (((GLint) (rgba[i][RCOMP] * 15.0F)) ) 02367 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 4) 02368 | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 8) 02369 | (((GLint) (rgba[i][ACOMP] * 15.0F)) << 12); 02370 } 02371 } 02372 else if (dstFormat == GL_BGRA) { 02373 GLushort *dst = (GLushort *) dstAddr; 02374 for (i=0;i<n;i++) { 02375 dst[i] = (((GLint) (rgba[i][BCOMP] * 15.0F)) ) 02376 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 4) 02377 | (((GLint) (rgba[i][RCOMP] * 15.0F)) << 8) 02378 | (((GLint) (rgba[i][ACOMP] * 15.0F)) << 12); 02379 } 02380 } 02381 else if (dstFormat == GL_ABGR_EXT) { 02382 GLushort *dst = (GLushort *) dstAddr; 02383 for (i=0;i<n;i++) { 02384 dst[i] = (((GLint) (rgba[i][ACOMP] * 15.0F)) ) 02385 | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 4) 02386 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 8) 02387 | (((GLint) (rgba[i][RCOMP] * 15.0F)) << 12); 02388 } 02389 } 02390 break; 02391 case GL_UNSIGNED_SHORT_5_5_5_1: 02392 if (dstFormat == GL_RGBA) { 02393 GLushort *dst = (GLushort *) dstAddr; 02394 for (i=0;i<n;i++) { 02395 dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) << 11) 02396 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 6) 02397 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 1) 02398 | (((GLint) (rgba[i][ACOMP] * 1.0F)) ); 02399 } 02400 } 02401 else if (dstFormat == GL_BGRA) { 02402 GLushort *dst = (GLushort *) dstAddr; 02403 for (i=0;i<n;i++) { 02404 dst[i] = (((GLint) (rgba[i][BCOMP] * 31.0F)) << 11) 02405 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 6) 02406 | (((GLint) (rgba[i][RCOMP] * 31.0F)) << 1) 02407 | (((GLint) (rgba[i][ACOMP] * 1.0F)) ); 02408 } 02409 } 02410 else if (dstFormat == GL_ABGR_EXT) { 02411 GLushort *dst = (GLushort *) dstAddr; 02412 for (i=0;i<n;i++) { 02413 dst[i] = (((GLint) (rgba[i][ACOMP] * 31.0F)) << 11) 02414 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 6) 02415 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 1) 02416 | (((GLint) (rgba[i][RCOMP] * 1.0F)) ); 02417 } 02418 } 02419 break; 02420 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 02421 if (dstFormat == GL_RGBA) { 02422 GLushort *dst = (GLushort *) dstAddr; 02423 for (i=0;i<n;i++) { 02424 dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) ) 02425 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 5) 02426 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 10) 02427 | (((GLint) (rgba[i][ACOMP] * 1.0F)) << 15); 02428 } 02429 } 02430 else if (dstFormat == GL_BGRA) { 02431 GLushort *dst = (GLushort *) dstAddr; 02432 for (i=0;i<n;i++) { 02433 dst[i] = (((GLint) (rgba[i][BCOMP] * 31.0F)) ) 02434 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 5) 02435 | (((GLint) (rgba[i][RCOMP] * 31.0F)) << 10) 02436 | (((GLint) (rgba[i][ACOMP] * 1.0F)) << 15); 02437 } 02438 } 02439 else if (dstFormat == GL_ABGR_EXT) { 02440 GLushort *dst = (GLushort *) dstAddr; 02441 for (i=0;i<n;i++) { 02442 dst[i] = (((GLint) (rgba[i][ACOMP] * 31.0F)) ) 02443 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 5) 02444 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 10) 02445 | (((GLint) (rgba[i][RCOMP] * 1.0F)) << 15); 02446 } 02447 } 02448 break; 02449 case GL_UNSIGNED_INT_8_8_8_8: 02450 if (dstFormat == GL_RGBA) { 02451 GLuint *dst = (GLuint *) dstAddr; 02452 for (i=0;i<n;i++) { 02453 dst[i] = (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 24) 02454 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16) 02455 | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 8) 02456 | (((GLuint) (rgba[i][ACOMP] * 255.0F)) ); 02457 } 02458 } 02459 else if (dstFormat == GL_BGRA) { 02460 GLuint *dst = (GLuint *) dstAddr; 02461 for (i=0;i<n;i++) { 02462 dst[i] = (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 24) 02463 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16) 02464 | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 8) 02465 | (((GLuint) (rgba[i][ACOMP] * 255.0F)) ); 02466 } 02467 } 02468 else if (dstFormat == GL_ABGR_EXT) { 02469 GLuint *dst = (GLuint *) dstAddr; 02470 for (i=0;i<n;i++) { 02471 dst[i] = (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24) 02472 | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 16) 02473 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 8) 02474 | (((GLuint) (rgba[i][RCOMP] * 255.0F)) ); 02475 } 02476 } 02477 break; 02478 case GL_UNSIGNED_INT_8_8_8_8_REV: 02479 if (dstFormat == GL_RGBA) { 02480 GLuint *dst = (GLuint *) dstAddr; 02481 for (i=0;i<n;i++) { 02482 dst[i] = (((GLuint) (rgba[i][RCOMP] * 255.0F)) ) 02483 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 8) 02484 | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 16) 02485 | (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24); 02486 } 02487 } 02488 else if (dstFormat == GL_BGRA) { 02489 GLuint *dst = (GLuint *) dstAddr; 02490 for (i=0;i<n;i++) { 02491 dst[i] = (((GLuint) (rgba[i][BCOMP] * 255.0F)) ) 02492 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 8) 02493 | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 16) 02494 | (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24); 02495 } 02496 } 02497 else if (dstFormat == GL_ABGR_EXT) { 02498 GLuint *dst = (GLuint *) dstAddr; 02499 for (i=0;i<n;i++) { 02500 dst[i] = (((GLuint) (rgba[i][ACOMP] * 255.0F)) ) 02501 | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 8) 02502 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16) 02503 | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 24); 02504 } 02505 } 02506 break; 02507 case GL_UNSIGNED_INT_10_10_10_2: 02508 if (dstFormat == GL_RGBA) { 02509 GLuint *dst = (GLuint *) dstAddr; 02510 for (i=0;i<n;i++) { 02511 dst[i] = (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 22) 02512 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 12) 02513 | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 2) 02514 | (((GLuint) (rgba[i][ACOMP] * 3.0F)) ); 02515 } 02516 } 02517 else if (dstFormat == GL_BGRA) { 02518 GLuint *dst = (GLuint *) dstAddr; 02519 for (i=0;i<n;i++) { 02520 dst[i] = (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 22) 02521 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 12) 02522 | (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 2) 02523 | (((GLuint) (rgba[i][ACOMP] * 3.0F)) ); 02524 } 02525 } 02526 else if (dstFormat == GL_ABGR_EXT) { 02527 GLuint *dst = (GLuint *) dstAddr; 02528 for (i=0;i<n;i++) { 02529 dst[i] = (((GLuint) (rgba[i][ACOMP] * 1023.0F)) << 22) 02530 | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 12) 02531 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 2) 02532 | (((GLuint) (rgba[i][RCOMP] * 3.0F)) ); 02533 } 02534 } 02535 break; 02536 case GL_UNSIGNED_INT_2_10_10_10_REV: 02537 if (dstFormat == GL_RGBA) { 02538 GLuint *dst = (GLuint *) dstAddr; 02539 for (i=0;i<n;i++) { 02540 dst[i] = (((GLuint) (rgba[i][RCOMP] * 1023.0F)) ) 02541 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 10) 02542 | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 20) 02543 | (((GLuint) (rgba[i][ACOMP] * 3.0F)) << 30); 02544 } 02545 } 02546 else if (dstFormat == GL_BGRA) { 02547 GLuint *dst = (GLuint *) dstAddr; 02548 for (i=0;i<n;i++) { 02549 dst[i] = (((GLuint) (rgba[i][BCOMP] * 1023.0F)) ) 02550 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 10) 02551 | (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 20) 02552 | (((GLuint) (rgba[i][ACOMP] * 3.0F)) << 30); 02553 } 02554 } 02555 else if (dstFormat == GL_ABGR_EXT) { 02556 GLuint *dst = (GLuint *) dstAddr; 02557 for (i=0;i<n;i++) { 02558 dst[i] = (((GLuint) (rgba[i][ACOMP] * 1023.0F)) ) 02559 | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 10) 02560 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 20) 02561 | (((GLuint) (rgba[i][RCOMP] * 3.0F)) << 30); 02562 } 02563 } 02564 break; 02565 default: 02566 _mesa_problem(ctx, "bad type in _mesa_pack_rgba_span_float"); 02567 return; 02568 } 02569 02570 if (dstPacking->SwapBytes) { 02571 GLint swapSize = _mesa_sizeof_packed_type(dstType); 02572 if (swapSize == 2) { 02573 if (dstPacking->SwapBytes) { 02574 _mesa_swap2((GLushort *) dstAddr, n * comps); 02575 } 02576 } 02577 else if (swapSize == 4) { 02578 if (dstPacking->SwapBytes) { 02579 _mesa_swap4((GLuint *) dstAddr, n * comps); 02580 } 02581 } 02582 } 02583 } 02584 02585 02586 #define SWAP2BYTE(VALUE) \ 02587 { \ 02588 GLubyte *bytes = (GLubyte *) &(VALUE); \ 02589 GLubyte tmp = bytes[0]; \ 02590 bytes[0] = bytes[1]; \ 02591 bytes[1] = tmp; \ 02592 } 02593 02594 #define SWAP4BYTE(VALUE) \ 02595 { \ 02596 GLubyte *bytes = (GLubyte *) &(VALUE); \ 02597 GLubyte tmp = bytes[0]; \ 02598 bytes[0] = bytes[3]; \ 02599 bytes[3] = tmp; \ 02600 tmp = bytes[1]; \ 02601 bytes[1] = bytes[2]; \ 02602 bytes[2] = tmp; \ 02603 } 02604 02605 02606 static void 02607 extract_uint_indexes(GLuint n, GLuint indexes[], 02608 GLenum srcFormat, GLenum srcType, const GLvoid *src, 02609 const struct gl_pixelstore_attrib *unpack ) 02610 { 02611 ASSERT(srcFormat == GL_COLOR_INDEX || srcFormat == GL_STENCIL_INDEX); 02612 02613 ASSERT(srcType == GL_BITMAP || 02614 srcType == GL_UNSIGNED_BYTE || 02615 srcType == GL_BYTE || 02616 srcType == GL_UNSIGNED_SHORT || 02617 srcType == GL_SHORT || 02618 srcType == GL_UNSIGNED_INT || 02619 srcType == GL_INT || 02620 srcType == GL_UNSIGNED_INT_24_8_EXT || 02621 srcType == GL_HALF_FLOAT_ARB || 02622 srcType == GL_FLOAT); 02623 02624 switch (srcType) { 02625 case GL_BITMAP: 02626 { 02627 GLubyte *ubsrc = (GLubyte *) src; 02628 if (unpack->LsbFirst) { 02629 GLubyte mask = 1 << (unpack->SkipPixels & 0x7); 02630 GLuint i; 02631 for (i = 0; i < n; i++) { 02632 indexes[i] = (*ubsrc & mask) ? 1 : 0; 02633 if (mask == 128) { 02634 mask = 1; 02635 ubsrc++; 02636 } 02637 else { 02638 mask = mask << 1; 02639 } 02640 } 02641 } 02642 else { 02643 GLubyte mask = 128 >> (unpack->SkipPixels & 0x7); 02644 GLuint i; 02645 for (i = 0; i < n; i++) { 02646 indexes[i] = (*ubsrc & mask) ? 1 : 0; 02647 if (mask == 1) { 02648 mask = 128; 02649 ubsrc++; 02650 } 02651 else { 02652 mask = mask >> 1; 02653 } 02654 } 02655 } 02656 } 02657 break; 02658 case GL_UNSIGNED_BYTE: 02659 { 02660 GLuint i; 02661 const GLubyte *s = (const GLubyte *) src; 02662 for (i = 0; i < n; i++) 02663 indexes[i] = s[i]; 02664 } 02665 break; 02666 case GL_BYTE: 02667 { 02668 GLuint i; 02669 const GLbyte *s = (const GLbyte *) src; 02670 for (i = 0; i < n; i++) 02671 indexes[i] = s[i]; 02672 } 02673 break; 02674 case GL_UNSIGNED_SHORT: 02675 { 02676 GLuint i; 02677 const GLushort *s = (const GLushort *) src; 02678 if (unpack->SwapBytes) { 02679 for (i = 0; i < n; i++) { 02680 GLushort value = s[i]; 02681 SWAP2BYTE(value); 02682 indexes[i] = value; 02683 } 02684 } 02685 else { 02686 for (i = 0; i < n; i++) 02687 indexes[i] = s[i]; 02688 } 02689 } 02690 break; 02691 case GL_SHORT: 02692 { 02693 GLuint i; 02694 const GLshort *s = (const GLshort *) src; 02695 if (unpack->SwapBytes) { 02696 for (i = 0; i < n; i++) { 02697 GLshort value = s[i]; 02698 SWAP2BYTE(value); 02699 indexes[i] = value; 02700 } 02701 } 02702 else { 02703 for (i = 0; i < n; i++) 02704 indexes[i] = s[i]; 02705 } 02706 } 02707 break; 02708 case GL_UNSIGNED_INT: 02709 { 02710 GLuint i; 02711 const GLuint *s = (const GLuint *) src; 02712 if (unpack->SwapBytes) { 02713 for (i = 0; i < n; i++) { 02714 GLuint value = s[i]; 02715 SWAP4BYTE(value); 02716 indexes[i] = value; 02717 } 02718 } 02719 else { 02720 for (i = 0; i < n; i++) 02721 indexes[i] = s[i]; 02722 } 02723 } 02724 break; 02725 case GL_INT: 02726 { 02727 GLuint i; 02728 const GLint *s = (const GLint *) src; 02729 if (unpack->SwapBytes) { 02730 for (i = 0; i < n; i++) { 02731 GLint value = s[i]; 02732 SWAP4BYTE(value); 02733 indexes[i] = value; 02734 } 02735 } 02736 else { 02737 for (i = 0; i < n; i++) 02738 indexes[i] = s[i]; 02739 } 02740 } 02741 break; 02742 case GL_FLOAT: 02743 { 02744 GLuint i; 02745 const GLfloat *s = (const GLfloat *) src; 02746 if (unpack->SwapBytes) { 02747 for (i = 0; i < n; i++) { 02748 GLfloat value = s[i]; 02749 SWAP4BYTE(value); 02750 indexes[i] = (GLuint) value; 02751 } 02752 } 02753 else { 02754 for (i = 0; i < n; i++) 02755 indexes[i] = (GLuint) s[i]; 02756 } 02757 } 02758 break; 02759 case GL_HALF_FLOAT_ARB: 02760 { 02761 GLuint i; 02762 const GLhalfARB *s = (const GLhalfARB *) src; 02763 if (unpack->SwapBytes) { 02764 for (i = 0; i < n; i++) { 02765 GLhalfARB value = s[i]; 02766 SWAP2BYTE(value); 02767 indexes[i] = (GLuint) _mesa_half_to_float(value); 02768 } 02769 } 02770 else { 02771 for (i = 0; i < n; i++) 02772 indexes[i] = (GLuint) _mesa_half_to_float(s[i]); 02773 } 02774 } 02775 break; 02776 case GL_UNSIGNED_INT_24_8_EXT: 02777 { 02778 GLuint i; 02779 const GLuint *s = (const GLuint *) src; 02780 if (unpack->SwapBytes) { 02781 for (i = 0; i < n; i++) { 02782 GLuint value = s[i]; 02783 SWAP4BYTE(value); 02784 indexes[i] = value & 0xff; /* lower 8 bits */ 02785 } 02786 } 02787 else { 02788 for (i = 0; i < n; i++) 02789 indexes[i] = s[i] & 0xfff; /* lower 8 bits */ 02790 } 02791 } 02792 break; 02793 02794 default: 02795 _mesa_problem(NULL, "bad srcType in extract_uint_indexes"); 02796 return; 02797 } 02798 } 02799 02800 02801 /* 02802 * This function extracts floating point RGBA values from arbitrary 02803 * image data. srcFormat and srcType are the format and type parameters 02804 * passed to glDrawPixels, glTexImage[123]D, glTexSubImage[123]D, etc. 02805 * 02806 * Refering to section 3.6.4 of the OpenGL 1.2 spec, this function 02807 * implements the "Conversion to floating point", "Conversion to RGB", 02808 * and "Final Expansion to RGBA" operations. 02809 * 02810 * Args: n - number of pixels 02811 * rgba - output colors 02812 * srcFormat - format of incoming data 02813 * srcType - data type of incoming data 02814 * src - source data pointer 02815 * swapBytes - perform byteswapping of incoming data? 02816 */ 02817 static void 02818 extract_float_rgba(GLuint n, GLfloat rgba[][4], 02819 GLenum srcFormat, GLenum srcType, const GLvoid *src, 02820 GLboolean swapBytes) 02821 { 02822 GLint redIndex, greenIndex, blueIndex, alphaIndex; 02823 GLint stride; 02824 GLint rComp, bComp, gComp, aComp; 02825 02826 ASSERT(srcFormat == GL_RED || 02827 srcFormat == GL_GREEN || 02828 srcFormat == GL_BLUE || 02829 srcFormat == GL_ALPHA || 02830 srcFormat == GL_LUMINANCE || 02831 srcFormat == GL_LUMINANCE_ALPHA || 02832 srcFormat == GL_INTENSITY || 02833 srcFormat == GL_RGB || 02834 srcFormat == GL_BGR || 02835 srcFormat == GL_RGBA || 02836 srcFormat == GL_BGRA || 02837 srcFormat == GL_ABGR_EXT); 02838 02839 ASSERT(srcType == GL_UNSIGNED_BYTE || 02840 srcType == GL_BYTE || 02841 srcType == GL_UNSIGNED_SHORT || 02842 srcType == GL_SHORT || 02843 srcType == GL_UNSIGNED_INT || 02844 srcType == GL_INT || 02845 srcType == GL_HALF_FLOAT_ARB || 02846 srcType == GL_FLOAT || 02847 srcType == GL_UNSIGNED_BYTE_3_3_2 || 02848 srcType == GL_UNSIGNED_BYTE_2_3_3_REV || 02849 srcType == GL_UNSIGNED_SHORT_5_6_5 || 02850 srcType == GL_UNSIGNED_SHORT_5_6_5_REV || 02851 srcType == GL_UNSIGNED_SHORT_4_4_4_4 || 02852 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV || 02853 srcType == GL_UNSIGNED_SHORT_5_5_5_1 || 02854 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV || 02855 srcType == GL_UNSIGNED_INT_8_8_8_8 || 02856 srcType == GL_UNSIGNED_INT_8_8_8_8_REV || 02857 srcType == GL_UNSIGNED_INT_10_10_10_2 || 02858 srcType == GL_UNSIGNED_INT_2_10_10_10_REV); 02859 02860 rComp = gComp = bComp = aComp = -1; 02861 02862 switch (srcFormat) { 02863 case GL_RED: 02864 redIndex = 0; 02865 greenIndex = blueIndex = alphaIndex = -1; 02866 stride = 1; 02867 break; 02868 case GL_GREEN: 02869 greenIndex = 0; 02870 redIndex = blueIndex = alphaIndex = -1; 02871 stride = 1; 02872 break; 02873 case GL_BLUE: 02874 blueIndex = 0; 02875 redIndex = greenIndex = alphaIndex = -1; 02876 stride = 1; 02877 break; 02878 case GL_ALPHA: 02879 redIndex = greenIndex = blueIndex = -1; 02880 alphaIndex = 0; 02881 stride = 1; 02882 break; 02883 case GL_LUMINANCE: 02884 redIndex = greenIndex = blueIndex = 0; 02885 alphaIndex = -1; 02886 stride = 1; 02887 break; 02888 case GL_LUMINANCE_ALPHA: 02889 redIndex = greenIndex = blueIndex = 0; 02890 alphaIndex = 1; 02891 stride = 2; 02892 break; 02893 case GL_INTENSITY: 02894 redIndex = greenIndex = blueIndex = alphaIndex = 0; 02895 stride = 1; 02896 break; 02897 case GL_RGB: 02898 redIndex = 0; 02899 greenIndex = 1; 02900 blueIndex = 2; 02901 alphaIndex = -1; 02902 rComp = 0; 02903 gComp = 1; 02904 bComp = 2; 02905 aComp = 3; 02906 stride = 3; 02907 break; 02908 case GL_BGR: 02909 redIndex = 2; 02910 greenIndex = 1; 02911 blueIndex = 0; 02912 alphaIndex = -1; 02913 rComp = 2; 02914 gComp = 1; 02915 bComp = 0; 02916 aComp = 3; 02917 stride = 3; 02918 break; 02919 case GL_RGBA: 02920 redIndex = 0; 02921 greenIndex = 1; 02922 blueIndex = 2; 02923 alphaIndex = 3; 02924 rComp = 0; 02925 gComp = 1; 02926 bComp = 2; 02927 aComp = 3; 02928 stride = 4; 02929 break; 02930 case GL_BGRA: 02931 redIndex = 2; 02932 greenIndex = 1; 02933 blueIndex = 0; 02934 alphaIndex = 3; 02935 rComp = 2; 02936 gComp = 1; 02937 bComp = 0; 02938 aComp = 3; 02939 stride = 4; 02940 break; 02941 case GL_ABGR_EXT: 02942 redIndex = 3; 02943 greenIndex = 2; 02944 blueIndex = 1; 02945 alphaIndex = 0; 02946 rComp = 3; 02947 gComp = 2; 02948 bComp = 1; 02949 aComp = 0; 02950 stride = 4; 02951 break; 02952 default: 02953 _mesa_problem(NULL, "bad srcFormat in extract float data"); 02954 return; 02955 } 02956 02957 02958 #define PROCESS(INDEX, CHANNEL, DEFAULT, TYPE, CONVERSION) \ 02959 if ((INDEX) < 0) { \ 02960 GLuint i; \ 02961 for (i = 0; i < n; i++) { \ 02962 rgba[i][CHANNEL] = DEFAULT; \ 02963 } \ 02964 } \ 02965 else if (swapBytes) { \ 02966 const TYPE *s = (const TYPE *) src; \ 02967 GLuint i; \ 02968 for (i = 0; i < n; i++) { \ 02969 TYPE value = s[INDEX]; \ 02970 if (sizeof(TYPE) == 2) { \ 02971 SWAP2BYTE(value); \ 02972 } \ 02973 else if (sizeof(TYPE) == 4) { \ 02974 SWAP4BYTE(value); \ 02975 } \ 02976 rgba[i][CHANNEL] = (GLfloat) CONVERSION(value); \ 02977 s += stride; \ 02978 } \ 02979 } \ 02980 else { \ 02981 const TYPE *s = (const TYPE *) src; \ 02982 GLuint i; \ 02983 for (i = 0; i < n; i++) { \ 02984 rgba[i][CHANNEL] = (GLfloat) CONVERSION(s[INDEX]); \ 02985 s += stride; \ 02986 } \ 02987 } 02988 02989 switch (srcType) { 02990 case GL_UNSIGNED_BYTE: 02991 PROCESS(redIndex, RCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT); 02992 PROCESS(greenIndex, GCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT); 02993 PROCESS(blueIndex, BCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT); 02994 PROCESS(alphaIndex, ACOMP, 1.0F, GLubyte, UBYTE_TO_FLOAT); 02995 break; 02996 case GL_BYTE: 02997 PROCESS(redIndex, RCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT); 02998 PROCESS(greenIndex, GCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT); 02999 PROCESS(blueIndex, BCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT); 03000 PROCESS(alphaIndex, ACOMP, 1.0F, GLbyte, BYTE_TO_FLOAT); 03001 break; 03002 case GL_UNSIGNED_SHORT: 03003 PROCESS(redIndex, RCOMP, 0.0F, GLushort, USHORT_TO_FLOAT); 03004 PROCESS(greenIndex, GCOMP, 0.0F, GLushort, USHORT_TO_FLOAT); 03005 PROCESS(blueIndex, BCOMP, 0.0F, GLushort, USHORT_TO_FLOAT); 03006 PROCESS(alphaIndex, ACOMP, 1.0F, GLushort, USHORT_TO_FLOAT); 03007 break; 03008 case GL_SHORT: 03009 PROCESS(redIndex, RCOMP, 0.0F, GLshort, SHORT_TO_FLOAT); 03010 PROCESS(greenIndex, GCOMP, 0.0F, GLshort, SHORT_TO_FLOAT); 03011 PROCESS(blueIndex, BCOMP, 0.0F, GLshort, SHORT_TO_FLOAT); 03012 PROCESS(alphaIndex, ACOMP, 1.0F, GLshort, SHORT_TO_FLOAT); 03013 break; 03014 case GL_UNSIGNED_INT: 03015 PROCESS(redIndex, RCOMP, 0.0F, GLuint, UINT_TO_FLOAT); 03016 PROCESS(greenIndex, GCOMP, 0.0F, GLuint, UINT_TO_FLOAT); 03017 PROCESS(blueIndex, BCOMP, 0.0F, GLuint, UINT_TO_FLOAT); 03018 PROCESS(alphaIndex, ACOMP, 1.0F, GLuint, UINT_TO_FLOAT); 03019 break; 03020 case GL_INT: 03021 PROCESS(redIndex, RCOMP, 0.0F, GLint, INT_TO_FLOAT); 03022 PROCESS(greenIndex, GCOMP, 0.0F, GLint, INT_TO_FLOAT); 03023 PROCESS(blueIndex, BCOMP, 0.0F, GLint, INT_TO_FLOAT); 03024 PROCESS(alphaIndex, ACOMP, 1.0F, GLint, INT_TO_FLOAT); 03025 break; 03026 case GL_FLOAT: 03027 PROCESS(redIndex, RCOMP, 0.0F, GLfloat, (GLfloat)); 03028 PROCESS(greenIndex, GCOMP, 0.0F, GLfloat, (GLfloat)); 03029 PROCESS(blueIndex, BCOMP, 0.0F, GLfloat, (GLfloat)); 03030 PROCESS(alphaIndex, ACOMP, 1.0F, GLfloat, (GLfloat)); 03031 break; 03032 case GL_HALF_FLOAT_ARB: 03033 PROCESS(redIndex, RCOMP, 0.0F, GLhalfARB, _mesa_half_to_float); 03034 PROCESS(greenIndex, GCOMP, 0.0F, GLhalfARB, _mesa_half_to_float); 03035 PROCESS(blueIndex, BCOMP, 0.0F, GLhalfARB, _mesa_half_to_float); 03036 PROCESS(alphaIndex, ACOMP, 1.0F, GLhalfARB, _mesa_half_to_float); 03037 break; 03038 case GL_UNSIGNED_BYTE_3_3_2: 03039 { 03040 const GLubyte *ubsrc = (const GLubyte *) src; 03041 GLuint i; 03042 for (i = 0; i < n; i ++) { 03043 GLubyte p = ubsrc[i]; 03044 rgba[i][rComp] = ((p >> 5) ) * (1.0F / 7.0F); 03045 rgba[i][gComp] = ((p >> 2) & 0x7) * (1.0F / 7.0F); 03046 rgba[i][bComp] = ((p ) & 0x3) * (1.0F / 3.0F); 03047 rgba[i][aComp] = 1.0F; 03048 } 03049 } 03050 break; 03051 case GL_UNSIGNED_BYTE_2_3_3_REV: 03052 { 03053 const GLubyte *ubsrc = (const GLubyte *) src; 03054 GLuint i; 03055 for (i = 0; i < n; i ++) { 03056 GLubyte p = ubsrc[i]; 03057 rgba[i][rComp] = ((p ) & 0x7) * (1.0F / 7.0F); 03058 rgba[i][gComp] = ((p >> 3) & 0x7) * (1.0F / 7.0F); 03059 rgba[i][bComp] = ((p >> 6) ) * (1.0F / 3.0F); 03060 rgba[i][aComp] = 1.0F; 03061 } 03062 } 03063 break; 03064 case GL_UNSIGNED_SHORT_5_6_5: 03065 if (swapBytes) { 03066 const GLushort *ussrc = (const GLushort *) src; 03067 GLuint i; 03068 for (i = 0; i < n; i ++) { 03069 GLushort p = ussrc[i]; 03070 SWAP2BYTE(p); 03071 rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F); 03072 rgba[i][gComp] = ((p >> 5) & 0x3f) * (1.0F / 63.0F); 03073 rgba[i][bComp] = ((p ) & 0x1f) * (1.0F / 31.0F); 03074 rgba[i][aComp] = 1.0F; 03075 } 03076 } 03077 else { 03078 const GLushort *ussrc = (const GLushort *) src; 03079 GLuint i; 03080 for (i = 0; i < n; i ++) { 03081 GLushort p = ussrc[i]; 03082 rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F); 03083 rgba[i][gComp] = ((p >> 5) & 0x3f) * (1.0F / 63.0F); 03084 rgba[i][bComp] = ((p ) & 0x1f) * (1.0F / 31.0F); 03085 rgba[i][aComp] = 1.0F; 03086 } 03087 } 03088 break; 03089 case GL_UNSIGNED_SHORT_5_6_5_REV: 03090 if (swapBytes) { 03091 const GLushort *ussrc = (const GLushort *) src; 03092 GLuint i; 03093 for (i = 0; i < n; i ++) { 03094 GLushort p = ussrc[i]; 03095 SWAP2BYTE(p); 03096 rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F); 03097 rgba[i][gComp] = ((p >> 5) & 0x3f) * (1.0F / 63.0F); 03098 rgba[i][bComp] = ((p >> 11) ) * (1.0F / 31.0F); 03099 rgba[i][aComp] = 1.0F; 03100 } 03101 } 03102 else { 03103 const GLushort *ussrc = (const GLushort *) src; 03104 GLuint i; 03105 for (i = 0; i < n; i ++) { 03106 GLushort p = ussrc[i]; 03107 rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F); 03108 rgba[i][gComp] = ((p >> 5) & 0x3f) * (1.0F / 63.0F); 03109 rgba[i][bComp] = ((p >> 11) ) * (1.0F / 31.0F); 03110 rgba[i][aComp] = 1.0F; 03111 } 03112 } 03113 break; 03114 case GL_UNSIGNED_SHORT_4_4_4_4: 03115 if (swapBytes) { 03116 const GLushort *ussrc = (const GLushort *) src; 03117 GLuint i; 03118 for (i = 0; i < n; i ++) { 03119 GLushort p = ussrc[i]; 03120 SWAP2BYTE(p); 03121 rgba[i][rComp] = ((p >> 12) ) * (1.0F / 15.0F); 03122 rgba[i][gComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F); 03123 rgba[i][bComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F); 03124 rgba[i][aComp] = ((p ) & 0xf) * (1.0F / 15.0F); 03125 } 03126 } 03127 else { 03128 const GLushort *ussrc = (const GLushort *) src; 03129 GLuint i; 03130 for (i = 0; i < n; i ++) { 03131 GLushort p = ussrc[i]; 03132 rgba[i][rComp] = ((p >> 12) ) * (1.0F / 15.0F); 03133 rgba[i][gComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F); 03134 rgba[i][bComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F); 03135 rgba[i][aComp] = ((p ) & 0xf) * (1.0F / 15.0F); 03136 } 03137 } 03138 break; 03139 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 03140 if (swapBytes) { 03141 const GLushort *ussrc = (const GLushort *) src; 03142 GLuint i; 03143 for (i = 0; i < n; i ++) { 03144 GLushort p = ussrc[i]; 03145 SWAP2BYTE(p); 03146 rgba[i][rComp] = ((p ) & 0xf) * (1.0F / 15.0F); 03147 rgba[i][gComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F); 03148 rgba[i][bComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F); 03149 rgba[i][aComp] = ((p >> 12) ) * (1.0F / 15.0F); 03150 } 03151 } 03152 else { 03153 const GLushort *ussrc = (const GLushort *) src; 03154 GLuint i; 03155 for (i = 0; i < n; i ++) { 03156 GLushort p = ussrc[i]; 03157 rgba[i][rComp] = ((p ) & 0xf) * (1.0F / 15.0F); 03158 rgba[i][gComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F); 03159 rgba[i][bComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F); 03160 rgba[i][aComp] = ((p >> 12) ) * (1.0F / 15.0F); 03161 } 03162 } 03163 break; 03164 case GL_UNSIGNED_SHORT_5_5_5_1: 03165 if (swapBytes) { 03166 const GLushort *ussrc = (const GLushort *) src; 03167 GLuint i; 03168 for (i = 0; i < n; i ++) { 03169 GLushort p = ussrc[i]; 03170 SWAP2BYTE(p); 03171 rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F); 03172 rgba[i][gComp] = ((p >> 6) & 0x1f) * (1.0F / 31.0F); 03173 rgba[i][bComp] = ((p >> 1) & 0x1f) * (1.0F / 31.0F); 03174 rgba[i][aComp] = ((p ) & 0x1) * (1.0F / 1.0F); 03175 } 03176 } 03177 else { 03178 const GLushort *ussrc = (const GLushort *) src; 03179 GLuint i; 03180 for (i = 0; i < n; i ++) { 03181 GLushort p = ussrc[i]; 03182 rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F); 03183 rgba[i][gComp] = ((p >> 6) & 0x1f) * (1.0F / 31.0F); 03184 rgba[i][bComp] = ((p >> 1) & 0x1f) * (1.0F / 31.0F); 03185 rgba[i][aComp] = ((p ) & 0x1) * (1.0F / 1.0F); 03186 } 03187 } 03188 break; 03189 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 03190 if (swapBytes) { 03191 const GLushort *ussrc = (const GLushort *) src; 03192 GLuint i; 03193 for (i = 0; i < n; i ++) { 03194 GLushort p = ussrc[i]; 03195 SWAP2BYTE(p); 03196 rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F); 03197 rgba[i][gComp] = ((p >> 5) & 0x1f) * (1.0F / 31.0F); 03198 rgba[i][bComp] = ((p >> 10) & 0x1f) * (1.0F / 31.0F); 03199 rgba[i][aComp] = ((p >> 15) ) * (1.0F / 1.0F); 03200 } 03201 } 03202 else { 03203 const GLushort *ussrc = (const GLushort *) src; 03204 GLuint i; 03205 for (i = 0; i < n; i ++) { 03206 GLushort p = ussrc[i]; 03207 rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F); 03208 rgba[i][gComp] = ((p >> 5) & 0x1f) * (1.0F / 31.0F); 03209 rgba[i][bComp] = ((p >> 10) & 0x1f) * (1.0F / 31.0F); 03210 rgba[i][aComp] = ((p >> 15) ) * (1.0F / 1.0F); 03211 } 03212 } 03213 break; 03214 case GL_UNSIGNED_INT_8_8_8_8: 03215 if (swapBytes) { 03216 const GLuint *uisrc = (const GLuint *) src; 03217 GLuint i; 03218 for (i = 0; i < n; i ++) { 03219 GLuint p = uisrc[i]; 03220 rgba[i][rComp] = UBYTE_TO_FLOAT((p ) & 0xff); 03221 rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 8) & 0xff); 03222 rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff); 03223 rgba[i][aComp] = UBYTE_TO_FLOAT((p >> 24) ); 03224 } 03225 } 03226 else { 03227 const GLuint *uisrc = (const GLuint *) src; 03228 GLuint i; 03229 for (i = 0; i < n; i ++) { 03230 GLuint p = uisrc[i]; 03231 rgba[i][rComp] = UBYTE_TO_FLOAT((p >> 24) ); 03232 rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff); 03233 rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 8) & 0xff); 03234 rgba[i][aComp] = UBYTE_TO_FLOAT((p ) & 0xff); 03235 } 03236 } 03237 break; 03238 case GL_UNSIGNED_INT_8_8_8_8_REV: 03239 if (swapBytes) { 03240 const GLuint *uisrc = (const GLuint *) src; 03241 GLuint i; 03242 for (i = 0; i < n; i ++) { 03243 GLuint p = uisrc[i]; 03244 rgba[i][rComp] = UBYTE_TO_FLOAT((p >> 24) ); 03245 rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff); 03246 rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 8) & 0xff); 03247 rgba[i][aComp] = UBYTE_TO_FLOAT((p ) & 0xff); 03248 } 03249 } 03250 else { 03251 const GLuint *uisrc = (const GLuint *) src; 03252 GLuint i; 03253 for (i = 0; i < n; i ++) { 03254 GLuint p = uisrc[i]; 03255 rgba[i][rComp] = UBYTE_TO_FLOAT((p ) & 0xff); 03256 rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 8) & 0xff); 03257 rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff); 03258 rgba[i][aComp] = UBYTE_TO_FLOAT((p >> 24) ); 03259 } 03260 } 03261 break; 03262 case GL_UNSIGNED_INT_10_10_10_2: 03263 if (swapBytes) { 03264 const GLuint *uisrc = (const GLuint *) src; 03265 GLuint i; 03266 for (i = 0; i < n; i ++) { 03267 GLuint p = uisrc[i]; 03268 SWAP4BYTE(p); 03269 rgba[i][rComp] = ((p >> 22) ) * (1.0F / 1023.0F); 03270 rgba[i][gComp] = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F); 03271 rgba[i][bComp] = ((p >> 2) & 0x3ff) * (1.0F / 1023.0F); 03272 rgba[i][aComp] = ((p ) & 0x3 ) * (1.0F / 3.0F); 03273 } 03274 } 03275 else { 03276 const GLuint *uisrc = (const GLuint *) src; 03277 GLuint i; 03278 for (i = 0; i < n; i ++) { 03279 GLuint p = uisrc[i]; 03280 rgba[i][rComp] = ((p >> 22) ) * (1.0F / 1023.0F); 03281 rgba[i][gComp] = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F); 03282 rgba[i][bComp] = ((p >> 2) & 0x3ff) * (1.0F / 1023.0F); 03283 rgba[i][aComp] = ((p ) & 0x3 ) * (1.0F / 3.0F); 03284 } 03285 } 03286 break; 03287 case GL_UNSIGNED_INT_2_10_10_10_REV: 03288 if (swapBytes) { 03289 const GLuint *uisrc = (const GLuint *) src; 03290 GLuint i; 03291 for (i = 0; i < n; i ++) { 03292 GLuint p = uisrc[i]; 03293 SWAP4BYTE(p); 03294 rgba[i][rComp] = ((p ) & 0x3ff) * (1.0F / 1023.0F); 03295 rgba[i][gComp] = ((p >> 10) & 0x3ff) * (1.0F / 1023.0F); 03296 rgba[i][bComp] = ((p >> 20) & 0x3ff) * (1.0F / 1023.0F); 03297 rgba[i][aComp] = ((p >> 30) ) * (1.0F / 3.0F); 03298 } 03299 } 03300 else { 03301 const GLuint *uisrc = (const GLuint *) src; 03302 GLuint i; 03303 for (i = 0; i < n; i ++) { 03304 GLuint p = uisrc[i]; 03305 rgba[i][rComp] = ((p ) & 0x3ff) * (1.0F / 1023.0F); 03306 rgba[i][gComp] = ((p >> 10) & 0x3ff) * (1.0F / 1023.0F); 03307 rgba[i][bComp] = ((p >> 20) & 0x3ff) * (1.0F / 1023.0F); 03308 rgba[i][aComp] = ((p >> 30) ) * (1.0F / 3.0F); 03309 } 03310 } 03311 break; 03312 default: 03313 _mesa_problem(NULL, "bad srcType in extract float data"); 03314 break; 03315 } 03316 } 03317 03318 03319 /* 03320 * Unpack a row of color image data from a client buffer according to 03321 * the pixel unpacking parameters. 03322 * Return GLchan values in the specified dest image format. 03323 * This is used by glDrawPixels and glTexImage?D(). 03324 * \param ctx - the context 03325 * n - number of pixels in the span 03326 * dstFormat - format of destination color array 03327 * dest - the destination color array 03328 * srcFormat - source image format 03329 * srcType - source image data type 03330 * source - source image pointer 03331 * srcPacking - pixel unpacking parameters 03332 * transferOps - bitmask of IMAGE_*_BIT values of operations to apply 03333 * 03334 * XXX perhaps expand this to process whole images someday. 03335 */ 03336 void 03337 _mesa_unpack_color_span_chan( GLcontext *ctx, 03338 GLuint n, GLenum dstFormat, GLchan dest[], 03339 GLenum srcFormat, GLenum srcType, 03340 const GLvoid *source, 03341 const struct gl_pixelstore_attrib *srcPacking, 03342 GLbitfield transferOps ) 03343 { 03344 ASSERT(dstFormat == GL_ALPHA || 03345 dstFormat == GL_LUMINANCE || 03346 dstFormat == GL_LUMINANCE_ALPHA || 03347 dstFormat == GL_INTENSITY || 03348 dstFormat == GL_RGB || 03349 dstFormat == GL_RGBA || 03350 dstFormat == GL_COLOR_INDEX); 03351 03352 ASSERT(srcFormat == GL_RED || 03353 srcFormat == GL_GREEN || 03354 srcFormat == GL_BLUE || 03355 srcFormat == GL_ALPHA || 03356 srcFormat == GL_LUMINANCE || 03357 srcFormat == GL_LUMINANCE_ALPHA || 03358 srcFormat == GL_INTENSITY || 03359 srcFormat == GL_RGB || 03360 srcFormat == GL_BGR || 03361 srcFormat == GL_RGBA || 03362 srcFormat == GL_BGRA || 03363 srcFormat == GL_ABGR_EXT || 03364 srcFormat == GL_COLOR_INDEX); 03365 03366 ASSERT(srcType == GL_BITMAP || 03367 srcType == GL_UNSIGNED_BYTE || 03368 srcType == GL_BYTE || 03369 srcType == GL_UNSIGNED_SHORT || 03370 srcType == GL_SHORT || 03371 srcType == GL_UNSIGNED_INT || 03372 srcType == GL_INT || 03373 srcType == GL_HALF_FLOAT_ARB || 03374 srcType == GL_FLOAT || 03375 srcType == GL_UNSIGNED_BYTE_3_3_2 || 03376 srcType == GL_UNSIGNED_BYTE_2_3_3_REV || 03377 srcType == GL_UNSIGNED_SHORT_5_6_5 || 03378 srcType == GL_UNSIGNED_SHORT_5_6_5_REV || 03379 srcType == GL_UNSIGNED_SHORT_4_4_4_4 || 03380 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV || 03381 srcType == GL_UNSIGNED_SHORT_5_5_5_1 || 03382 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV || 03383 srcType == GL_UNSIGNED_INT_8_8_8_8 || 03384 srcType == GL_UNSIGNED_INT_8_8_8_8_REV || 03385 srcType == GL_UNSIGNED_INT_10_10_10_2 || 03386 srcType == GL_UNSIGNED_INT_2_10_10_10_REV); 03387 03388 /* Try simple cases first */ 03389 if (transferOps == 0) { 03390 if (srcType == CHAN_TYPE) { 03391 if (dstFormat == GL_RGBA) { 03392 if (srcFormat == GL_RGBA) { 03393 _mesa_memcpy( dest, source, n * 4 * sizeof(GLchan) ); 03394 return; 03395 } 03396 else if (srcFormat == GL_RGB) { 03397 GLuint i; 03398 const GLchan *src = (const GLchan *) source; 03399 GLchan *dst = dest; 03400 for (i = 0; i < n; i++) { 03401 dst[0] = src[0]; 03402 dst[1] = src[1]; 03403 dst[2] = src[2]; 03404 dst[3] = CHAN_MAX; 03405 src += 3; 03406 dst += 4; 03407 } 03408 return; 03409 } 03410 } 03411 else if (dstFormat == GL_RGB) { 03412 if (srcFormat == GL_RGB) { 03413 _mesa_memcpy( dest, source, n * 3 * sizeof(GLchan) ); 03414 return; 03415 } 03416 else if (srcFormat == GL_RGBA) { 03417 GLuint i; 03418 const GLchan *src = (const GLchan *) source; 03419 GLchan *dst = dest; 03420 for (i = 0; i < n; i++) { 03421 dst[0] = src[0]; 03422 dst[1] = src[1]; 03423 dst[2] = src[2]; 03424 src += 4; 03425 dst += 3; 03426 } 03427 return; 03428 } 03429 } 03430 else if (dstFormat == srcFormat) { 03431 GLint comps = _mesa_components_in_format(srcFormat); 03432 assert(comps > 0); 03433 _mesa_memcpy( dest, source, n * comps * sizeof(GLchan) ); 03434 return; 03435 } 03436 } 03437 /* 03438 * Common situation, loading 8bit RGBA/RGB source images 03439 * into 16/32 bit destination. (OSMesa16/32) 03440 */ 03441 else if (srcType == GL_UNSIGNED_BYTE) { 03442 if (dstFormat == GL_RGBA) { 03443 if (srcFormat == GL_RGB) { 03444 GLuint i; 03445 const GLubyte *src = (const GLubyte *) source; 03446 GLchan *dst = dest; 03447 for (i = 0; i < n; i++) { 03448 dst[0] = UBYTE_TO_CHAN(src[0]); 03449 dst[1] = UBYTE_TO_CHAN(src[1]); 03450 dst[2] = UBYTE_TO_CHAN(src[2]); 03451 dst[3] = CHAN_MAX; 03452 src += 3; 03453 dst += 4; 03454 } 03455 return; 03456 } 03457 else if (srcFormat == GL_RGBA) { 03458 GLuint i; 03459 const GLubyte *src = (const GLubyte *) source; 03460 GLchan *dst = dest; 03461 for (i = 0; i < n; i++) { 03462 dst[0] = UBYTE_TO_CHAN(src[0]); 03463 dst[1] = UBYTE_TO_CHAN(src[1]); 03464 dst[2] = UBYTE_TO_CHAN(src[2]); 03465 dst[3] = UBYTE_TO_CHAN(src[3]); 03466 src += 4; 03467 dst += 4; 03468 } 03469 return; 03470 } 03471 } 03472 else if (dstFormat == GL_RGB) { 03473 if (srcFormat == GL_RGB) { 03474 GLuint i; 03475 const GLubyte *src = (const GLubyte *) source; 03476 GLchan *dst = dest; 03477 for (i = 0; i < n; i++) { 03478 dst[0] = UBYTE_TO_CHAN(src[0]); 03479 dst[1] = UBYTE_TO_CHAN(src[1]); 03480 dst[2] = UBYTE_TO_CHAN(src[2]); 03481 src += 3; 03482 dst += 3; 03483 } 03484 return; 03485 } 03486 else if (srcFormat == GL_RGBA) { 03487 GLuint i; 03488 const GLubyte *src = (const GLubyte *) source; 03489 GLchan *dst = dest; 03490 for (i = 0; i < n; i++) { 03491 dst[0] = UBYTE_TO_CHAN(src[0]); 03492 dst[1] = UBYTE_TO_CHAN(src[1]); 03493 dst[2] = UBYTE_TO_CHAN(src[2]); 03494 src += 4; 03495 dst += 3; 03496 } 03497 return; 03498 } 03499 } 03500 } 03501 } 03502 03503 03504 /* general solution begins here */ 03505 { 03506 GLint dstComponents; 03507 GLint dstRedIndex, dstGreenIndex, dstBlueIndex, dstAlphaIndex; 03508 GLint dstLuminanceIndex, dstIntensityIndex; 03509 GLfloat rgba[MAX_WIDTH][4]; 03510 03511 dstComponents = _mesa_components_in_format( dstFormat ); 03512 /* source & dest image formats should have been error checked by now */ 03513 assert(dstComponents > 0); 03514 03515 /* 03516 * Extract image data and convert to RGBA floats 03517 */ 03518 assert(n <= MAX_WIDTH); 03519 if (srcFormat == GL_COLOR_INDEX) { 03520 GLuint indexes[MAX_WIDTH]; 03521 extract_uint_indexes(n, indexes, srcFormat, srcType, source, 03522 srcPacking); 03523 03524 if (dstFormat == GL_COLOR_INDEX) { 03525 GLuint i; 03526 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes); 03527 /* convert to GLchan and return */ 03528 for (i = 0; i < n; i++) { 03529 dest[i] = (GLchan) (indexes[i] & 0xff); 03530 } 03531 return; 03532 } 03533 else { 03534 /* Convert indexes to RGBA */ 03535 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) { 03536 shift_and_offset_ci(ctx, n, indexes); 03537 } 03538 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba); 03539 } 03540 03541 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting 03542 * with color indexes. 03543 */ 03544 transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT); 03545 } 03546 else { 03547 /* non-color index data */ 03548 extract_float_rgba(n, rgba, srcFormat, srcType, source, 03549 srcPacking->SwapBytes); 03550 } 03551 03552 /* Need to clamp if returning GLubytes or GLushorts */ 03553 #if CHAN_TYPE != GL_FLOAT 03554 transferOps |= IMAGE_CLAMP_BIT; 03555 #endif 03556 03557 if (transferOps) { 03558 _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba); 03559 } 03560 03561 /* Now determine which color channels we need to produce. 03562 * And determine the dest index (offset) within each color tuple. 03563 */ 03564 switch (dstFormat) { 03565 case GL_ALPHA: 03566 dstAlphaIndex = 0; 03567 dstRedIndex = dstGreenIndex = dstBlueIndex = -1; 03568 dstLuminanceIndex = dstIntensityIndex = -1; 03569 break; 03570 case GL_LUMINANCE: 03571 dstLuminanceIndex = 0; 03572 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1; 03573 dstIntensityIndex = -1; 03574 break; 03575 case GL_LUMINANCE_ALPHA: 03576 dstLuminanceIndex = 0; 03577 dstAlphaIndex = 1; 03578 dstRedIndex = dstGreenIndex = dstBlueIndex = -1; 03579 dstIntensityIndex = -1; 03580 break; 03581 case GL_INTENSITY: 03582 dstIntensityIndex = 0; 03583 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1; 03584 dstLuminanceIndex = -1; 03585 break; 03586 case GL_RGB: 03587 dstRedIndex = 0; 03588 dstGreenIndex = 1; 03589 dstBlueIndex = 2; 03590 dstAlphaIndex = dstLuminanceIndex = dstIntensityIndex = -1; 03591 break; 03592 case GL_RGBA: 03593 dstRedIndex = 0; 03594 dstGreenIndex = 1; 03595 dstBlueIndex = 2; 03596 dstAlphaIndex = 3; 03597 dstLuminanceIndex = dstIntensityIndex = -1; 03598 break; 03599 default: 03600 _mesa_problem(ctx, "bad dstFormat in _mesa_unpack_chan_span()"); 03601 return; 03602 } 03603 03604 03605 /* Now return the GLchan data in the requested dstFormat */ 03606 03607 if (dstRedIndex >= 0) { 03608 GLchan *dst = dest; 03609 GLuint i; 03610 for (i = 0; i < n; i++) { 03611 CLAMPED_FLOAT_TO_CHAN(dst[dstRedIndex], rgba[i][RCOMP]); 03612 dst += dstComponents; 03613 } 03614 } 03615 03616 if (dstGreenIndex >= 0) { 03617 GLchan *dst = dest; 03618 GLuint i; 03619 for (i = 0; i < n; i++) { 03620 CLAMPED_FLOAT_TO_CHAN(dst[dstGreenIndex], rgba[i][GCOMP]); 03621 dst += dstComponents; 03622 } 03623 } 03624 03625 if (dstBlueIndex >= 0) { 03626 GLchan *dst = dest; 03627 GLuint i; 03628 for (i = 0; i < n; i++) { 03629 CLAMPED_FLOAT_TO_CHAN(dst[dstBlueIndex], rgba[i][BCOMP]); 03630 dst += dstComponents; 03631 } 03632 } 03633 03634 if (dstAlphaIndex >= 0) { 03635 GLchan *dst = dest; 03636 GLuint i; 03637 for (i = 0; i < n; i++) { 03638 CLAMPED_FLOAT_TO_CHAN(dst[dstAlphaIndex], rgba[i][ACOMP]); 03639 dst += dstComponents; 03640 } 03641 } 03642 03643 if (dstIntensityIndex >= 0) { 03644 GLchan *dst = dest; 03645 GLuint i; 03646 assert(dstIntensityIndex == 0); 03647 assert(dstComponents == 1); 03648 for (i = 0; i < n; i++) { 03649 /* Intensity comes from red channel */ 03650 CLAMPED_FLOAT_TO_CHAN(dst[i], rgba[i][RCOMP]); 03651 } 03652 } 03653 03654 if (dstLuminanceIndex >= 0) { 03655 GLchan *dst = dest; 03656 GLuint i; 03657 assert(dstLuminanceIndex == 0); 03658 for (i = 0; i < n; i++) { 03659 /* Luminance comes from red channel */ 03660 CLAMPED_FLOAT_TO_CHAN(dst[0], rgba[i][RCOMP]); 03661 dst += dstComponents; 03662 } 03663 } 03664 } 03665 } 03666 03667 03672 void 03673 _mesa_unpack_color_span_float( GLcontext *ctx, 03674 GLuint n, GLenum dstFormat, GLfloat dest[], 03675 GLenum srcFormat, GLenum srcType, 03676 const GLvoid *source, 03677 const struct gl_pixelstore_attrib *srcPacking, 03678 GLbitfield transferOps ) 03679 { 03680 ASSERT(dstFormat == GL_ALPHA || 03681 dstFormat == GL_LUMINANCE || 03682 dstFormat == GL_LUMINANCE_ALPHA || 03683 dstFormat == GL_INTENSITY || 03684 dstFormat == GL_RGB || 03685 dstFormat == GL_RGBA || 03686 dstFormat == GL_COLOR_INDEX); 03687 03688 ASSERT(srcFormat == GL_RED || 03689 srcFormat == GL_GREEN || 03690 srcFormat == GL_BLUE || 03691 srcFormat == GL_ALPHA || 03692 srcFormat == GL_LUMINANCE || 03693 srcFormat == GL_LUMINANCE_ALPHA || 03694 srcFormat == GL_INTENSITY || 03695 srcFormat == GL_RGB || 03696 srcFormat == GL_BGR || 03697 srcFormat == GL_RGBA || 03698 srcFormat == GL_BGRA || 03699 srcFormat == GL_ABGR_EXT || 03700 srcFormat == GL_COLOR_INDEX); 03701 03702 ASSERT(srcType == GL_BITMAP || 03703 srcType == GL_UNSIGNED_BYTE || 03704 srcType == GL_BYTE || 03705 srcType == GL_UNSIGNED_SHORT || 03706 srcType == GL_SHORT || 03707 srcType == GL_UNSIGNED_INT || 03708 srcType == GL_INT || 03709 srcType == GL_HALF_FLOAT_ARB || 03710 srcType == GL_FLOAT || 03711 srcType == GL_UNSIGNED_BYTE_3_3_2 || 03712 srcType == GL_UNSIGNED_BYTE_2_3_3_REV || 03713 srcType == GL_UNSIGNED_SHORT_5_6_5 || 03714 srcType == GL_UNSIGNED_SHORT_5_6_5_REV || 03715 srcType == GL_UNSIGNED_SHORT_4_4_4_4 || 03716 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV || 03717 srcType == GL_UNSIGNED_SHORT_5_5_5_1 || 03718 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV || 03719 srcType == GL_UNSIGNED_INT_8_8_8_8 || 03720 srcType == GL_UNSIGNED_INT_8_8_8_8_REV || 03721 srcType == GL_UNSIGNED_INT_10_10_10_2 || 03722 srcType == GL_UNSIGNED_INT_2_10_10_10_REV); 03723 03724 /* general solution, no special cases, yet */ 03725 { 03726 GLint dstComponents; 03727 GLint dstRedIndex, dstGreenIndex, dstBlueIndex, dstAlphaIndex; 03728 GLint dstLuminanceIndex, dstIntensityIndex; 03729 GLfloat rgba[MAX_WIDTH][4]; 03730 03731 dstComponents = _mesa_components_in_format( dstFormat ); 03732 /* source & dest image formats should have been error checked by now */ 03733 assert(dstComponents > 0); 03734 03735 /* 03736 * Extract image data and convert to RGBA floats 03737 */ 03738 assert(n <= MAX_WIDTH); 03739 if (srcFormat == GL_COLOR_INDEX) { 03740 GLuint indexes[MAX_WIDTH]; 03741 extract_uint_indexes(n, indexes, srcFormat, srcType, source, 03742 srcPacking); 03743 03744 if (dstFormat == GL_COLOR_INDEX) { 03745 GLuint i; 03746 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes); 03747 /* convert to GLchan and return */ 03748 for (i = 0; i < n; i++) { 03749 dest[i] = (GLchan) (indexes[i] & 0xff); 03750 } 03751 return; 03752 } 03753 else { 03754 /* Convert indexes to RGBA */ 03755 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) { 03756 shift_and_offset_ci(ctx, n, indexes); 03757 } 03758 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba); 03759 } 03760 03761 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting 03762 * with color indexes. 03763 */ 03764 transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT); 03765 } 03766 else { 03767 /* non-color index data */ 03768 extract_float_rgba(n, rgba, srcFormat, srcType, source, 03769 srcPacking->SwapBytes); 03770 } 03771 03772 if (transferOps) { 03773 _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba); 03774 } 03775 03776 /* Now determine which color channels we need to produce. 03777 * And determine the dest index (offset) within each color tuple. 03778 */ 03779 switch (dstFormat) { 03780 case GL_ALPHA: 03781 dstAlphaIndex = 0; 03782 dstRedIndex = dstGreenIndex = dstBlueIndex = -1; 03783 dstLuminanceIndex = dstIntensityIndex = -1; 03784 break; 03785 case GL_LUMINANCE: 03786 dstLuminanceIndex = 0; 03787 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1; 03788 dstIntensityIndex = -1; 03789 break; 03790 case GL_LUMINANCE_ALPHA: 03791 dstLuminanceIndex = 0; 03792 dstAlphaIndex = 1; 03793 dstRedIndex = dstGreenIndex = dstBlueIndex = -1; 03794 dstIntensityIndex = -1; 03795 break; 03796 case GL_INTENSITY: 03797 dstIntensityIndex = 0; 03798 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1; 03799 dstLuminanceIndex = -1; 03800 break; 03801 case GL_RGB: 03802 dstRedIndex = 0; 03803 dstGreenIndex = 1; 03804 dstBlueIndex = 2; 03805 dstAlphaIndex = dstLuminanceIndex = dstIntensityIndex = -1; 03806 break; 03807 case GL_RGBA: 03808 dstRedIndex = 0; 03809 dstGreenIndex = 1; 03810 dstBlueIndex = 2; 03811 dstAlphaIndex = 3; 03812 dstLuminanceIndex = dstIntensityIndex = -1; 03813 break; 03814 default: 03815 _mesa_problem(ctx, "bad dstFormat in _mesa_unpack_color_span_float()"); 03816 return; 03817 } 03818 03819 /* Now pack results in the requested dstFormat */ 03820 if (dstRedIndex >= 0) { 03821 GLfloat *dst = dest; 03822 GLuint i; 03823 for (i = 0; i < n; i++) { 03824 dst[dstRedIndex] = rgba[i][RCOMP]; 03825 dst += dstComponents; 03826 } 03827 } 03828 03829 if (dstGreenIndex >= 0) { 03830 GLfloat *dst = dest; 03831 GLuint i; 03832 for (i = 0; i < n; i++) { 03833 dst[dstGreenIndex] = rgba[i][GCOMP]; 03834 dst += dstComponents; 03835 } 03836 } 03837 03838 if (dstBlueIndex >= 0) { 03839 GLfloat *dst = dest; 03840 GLuint i; 03841 for (i = 0; i < n; i++) { 03842 dst[dstBlueIndex] = rgba[i][BCOMP]; 03843 dst += dstComponents; 03844 } 03845 } 03846 03847 if (dstAlphaIndex >= 0) { 03848 GLfloat *dst = dest; 03849 GLuint i; 03850 for (i = 0; i < n; i++) { 03851 dst[dstAlphaIndex] = rgba[i][ACOMP]; 03852 dst += dstComponents; 03853 } 03854 } 03855 03856 if (dstIntensityIndex >= 0) { 03857 GLfloat *dst = dest; 03858 GLuint i; 03859 assert(dstIntensityIndex == 0); 03860 assert(dstComponents == 1); 03861 for (i = 0; i < n; i++) { 03862 /* Intensity comes from red channel */ 03863 dst[i] = rgba[i][RCOMP]; 03864 } 03865 } 03866 03867 if (dstLuminanceIndex >= 0) { 03868 GLfloat *dst = dest; 03869 GLuint i; 03870 assert(dstLuminanceIndex == 0); 03871 for (i = 0; i < n; i++) { 03872 /* Luminance comes from red channel */ 03873 dst[0] = rgba[i][RCOMP]; 03874 dst += dstComponents; 03875 } 03876 } 03877 } 03878 } 03879 03880 03881 /* 03882 * Unpack a row of color index data from a client buffer according to 03883 * the pixel unpacking parameters. 03884 * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc. 03885 * 03886 * Args: ctx - the context 03887 * n - number of pixels 03888 * dstType - destination data type 03889 * dest - destination array 03890 * srcType - source pixel type 03891 * source - source data pointer 03892 * srcPacking - pixel unpacking parameters 03893 * transferOps - the pixel transfer operations to apply 03894 */ 03895 void 03896 _mesa_unpack_index_span( const GLcontext *ctx, GLuint n, 03897 GLenum dstType, GLvoid *dest, 03898 GLenum srcType, const GLvoid *source, 03899 const struct gl_pixelstore_attrib *srcPacking, 03900 GLbitfield transferOps ) 03901 { 03902 ASSERT(srcType == GL_BITMAP || 03903 srcType == GL_UNSIGNED_BYTE || 03904 srcType == GL_BYTE || 03905 srcType == GL_UNSIGNED_SHORT || 03906 srcType == GL_SHORT || 03907 srcType == GL_UNSIGNED_INT || 03908 srcType == GL_INT || 03909 srcType == GL_HALF_FLOAT_ARB || 03910 srcType == GL_FLOAT); 03911 03912 ASSERT(dstType == GL_UNSIGNED_BYTE || 03913 dstType == GL_UNSIGNED_SHORT || 03914 dstType == GL_UNSIGNED_INT); 03915 03916 03917 transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT); 03918 03919 /* 03920 * Try simple cases first 03921 */ 03922 if (transferOps == 0 && srcType == GL_UNSIGNED_BYTE 03923 && dstType == GL_UNSIGNED_BYTE) { 03924 _mesa_memcpy(dest, source, n * sizeof(GLubyte)); 03925 } 03926 else if (transferOps == 0 && srcType == GL_UNSIGNED_INT 03927 && dstType == GL_UNSIGNED_INT && !srcPacking->SwapBytes) { 03928 _mesa_memcpy(dest, source, n * sizeof(GLuint)); 03929 } 03930 else { 03931 /* 03932 * general solution 03933 */ 03934 GLuint indexes[MAX_WIDTH]; 03935 assert(n <= MAX_WIDTH); 03936 03937 extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source, 03938 srcPacking); 03939 03940 if (transferOps) 03941 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes); 03942 03943 /* convert to dest type */ 03944 switch (dstType) { 03945 case GL_UNSIGNED_BYTE: 03946 { 03947 GLubyte *dst = (GLubyte *) dest; 03948 GLuint i; 03949 for (i = 0; i < n; i++) { 03950 dst[i] = (GLubyte) (indexes[i] & 0xff); 03951 } 03952 } 03953 break; 03954 case GL_UNSIGNED_SHORT: 03955 { 03956 GLuint *dst = (GLuint *) dest; 03957 GLuint i; 03958 for (i = 0; i < n; i++) { 03959 dst[i] = (GLushort) (indexes[i] & 0xffff); 03960 } 03961 } 03962 break; 03963 case GL_UNSIGNED_INT: 03964 _mesa_memcpy(dest, indexes, n * sizeof(GLuint)); 03965 break; 03966 default: 03967 _mesa_problem(ctx, "bad dstType in _mesa_unpack_index_span"); 03968 } 03969 } 03970 } 03971 03972 03973 void 03974 _mesa_pack_index_span( const GLcontext *ctx, GLuint n, 03975 GLenum dstType, GLvoid *dest, const GLuint *source, 03976 const struct gl_pixelstore_attrib *dstPacking, 03977 GLbitfield transferOps ) 03978 { 03979 GLuint indexes[MAX_WIDTH]; 03980 03981 ASSERT(n <= MAX_WIDTH); 03982 03983 transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT); 03984 03985 if (transferOps & (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT)) { 03986 /* make a copy of input */ 03987 _mesa_memcpy(indexes, source, n * sizeof(GLuint)); 03988 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes); 03989 source = indexes; 03990 } 03991 03992 switch (dstType) { 03993 case GL_UNSIGNED_BYTE: 03994 { 03995 GLubyte *dst = (GLubyte *) dest; 03996 GLuint i; 03997 for (i = 0; i < n; i++) { 03998 *dst++ = (GLubyte) source[i]; 03999 } 04000 } 04001 break; 04002 case GL_BYTE: 04003 { 04004 GLbyte *dst = (GLbyte *) dest; 04005 GLuint i; 04006 for (i = 0; i < n; i++) { 04007 dst[i] = (GLbyte) source[i]; 04008 } 04009 } 04010 break; 04011 case GL_UNSIGNED_SHORT: 04012 { 04013 GLushort *dst = (GLushort *) dest; 04014 GLuint i; 04015 for (i = 0; i < n; i++) { 04016 dst[i] = (GLushort) source[i]; 04017 } 04018 if (dstPacking->SwapBytes) { 04019 _mesa_swap2( (GLushort *) dst, n ); 04020 } 04021 } 04022 break; 04023 case GL_SHORT: 04024 { 04025 GLshort *dst = (GLshort *) dest; 04026 GLuint i; 04027 for (i = 0; i < n; i++) { 04028 dst[i] = (GLshort) source[i]; 04029 } 04030 if (dstPacking->SwapBytes) { 04031 _mesa_swap2( (GLushort *) dst, n ); 04032 } 04033 } 04034 break; 04035 case GL_UNSIGNED_INT: 04036 { 04037 GLuint *dst = (GLuint *) dest; 04038 GLuint i; 04039 for (i = 0; i < n; i++) { 04040 dst[i] = (GLuint) source[i]; 04041 } 04042 if (dstPacking->SwapBytes) { 04043 _mesa_swap4( (GLuint *) dst, n ); 04044 } 04045 } 04046 break; 04047 case GL_INT: 04048 { 04049 GLint *dst = (GLint *) dest; 04050 GLuint i; 04051 for (i = 0; i < n; i++) { 04052 dst[i] = (GLint) source[i]; 04053 } 04054 if (dstPacking->SwapBytes) { 04055 _mesa_swap4( (GLuint *) dst, n ); 04056 } 04057 } 04058 break; 04059 case GL_FLOAT: 04060 { 04061 GLfloat *dst = (GLfloat *) dest; 04062 GLuint i; 04063 for (i = 0; i < n; i++) { 04064 dst[i] = (GLfloat) source[i]; 04065 } 04066 if (dstPacking->SwapBytes) { 04067 _mesa_swap4( (GLuint *) dst, n ); 04068 } 04069 } 04070 break; 04071 case GL_HALF_FLOAT_ARB: 04072 { 04073 GLhalfARB *dst = (GLhalfARB *) dest; 04074 GLuint i; 04075 for (i = 0; i < n; i++) { 04076 dst[i] = _mesa_float_to_half((GLfloat) source[i]); 04077 } 04078 if (dstPacking->SwapBytes) { 04079 _mesa_swap2( (GLushort *) dst, n ); 04080 } 04081 } 04082 break; 04083 default: 04084 _mesa_problem(ctx, "bad type in _mesa_pack_index_span"); 04085 } 04086 } 04087 04088 04089 /* 04090 * Unpack a row of stencil data from a client buffer according to 04091 * the pixel unpacking parameters. 04092 * This is (or will be) used by glDrawPixels 04093 * 04094 * Args: ctx - the context 04095 * n - number of pixels 04096 * dstType - destination data type 04097 * dest - destination array 04098 * srcType - source pixel type 04099 * source - source data pointer 04100 * srcPacking - pixel unpacking parameters 04101 * transferOps - apply offset/bias/lookup ops? 04102 */ 04103 void 04104 _mesa_unpack_stencil_span( const GLcontext *ctx, GLuint n, 04105 GLenum dstType, GLvoid *dest, 04106 GLenum srcType, const GLvoid *source, 04107 const struct gl_pixelstore_attrib *srcPacking, 04108 GLbitfield transferOps ) 04109 { 04110 ASSERT(srcType == GL_BITMAP || 04111 srcType == GL_UNSIGNED_BYTE || 04112 srcType == GL_BYTE || 04113 srcType == GL_UNSIGNED_SHORT || 04114 srcType == GL_SHORT || 04115 srcType == GL_UNSIGNED_INT || 04116 srcType == GL_INT || 04117 srcType == GL_UNSIGNED_INT_24_8_EXT || 04118 srcType == GL_HALF_FLOAT_ARB || 04119 srcType == GL_FLOAT); 04120 04121 ASSERT(dstType == GL_UNSIGNED_BYTE || 04122 dstType == GL_UNSIGNED_SHORT || 04123 dstType == GL_UNSIGNED_INT); 04124 04125 /* only shift and offset apply to stencil */ 04126 transferOps &= IMAGE_SHIFT_OFFSET_BIT; 04127 04128 /* 04129 * Try simple cases first 04130 */ 04131 if (transferOps == 0 && 04132 !ctx->Pixel.MapStencilFlag && 04133 srcType == GL_UNSIGNED_BYTE && 04134 dstType == GL_UNSIGNED_BYTE) { 04135 _mesa_memcpy(dest, source, n * sizeof(GLubyte)); 04136 } 04137 else if (transferOps == 0 && 04138 !ctx->Pixel.MapStencilFlag && 04139 srcType == GL_UNSIGNED_INT && 04140 dstType == GL_UNSIGNED_INT && 04141 !srcPacking->SwapBytes) { 04142 _mesa_memcpy(dest, source, n * sizeof(GLuint)); 04143 } 04144 else { 04145 /* 04146 * general solution 04147 */ 04148 GLuint indexes[MAX_WIDTH]; 04149 assert(n <= MAX_WIDTH); 04150 04151 extract_uint_indexes(n, indexes, GL_STENCIL_INDEX, srcType, source, 04152 srcPacking); 04153 04154 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) { 04155 /* shift and offset indexes */ 04156 shift_and_offset_ci(ctx, n, indexes); 04157 } 04158 04159 if (ctx->Pixel.MapStencilFlag) { 04160 /* Apply stencil lookup table */ 04161 const GLuint mask = ctx->PixelMaps.StoS.Size - 1; 04162 GLuint i; 04163 for (i = 0; i < n; i++) { 04164 indexes[i] = (GLuint)ctx->PixelMaps.StoS.Map[ indexes[i] & mask ]; 04165 } 04166 } 04167 04168 /* convert to dest type */ 04169 switch (dstType) { 04170 case GL_UNSIGNED_BYTE: 04171 { 04172 GLubyte *dst = (GLubyte *) dest; 04173 GLuint i; 04174 for (i = 0; i < n; i++) { 04175 dst[i] = (GLubyte) (indexes[i] & 0xff); 04176 } 04177 } 04178 break; 04179 case GL_UNSIGNED_SHORT: 04180 { 04181 GLuint *dst = (GLuint *) dest; 04182 GLuint i; 04183 for (i = 0; i < n; i++) { 04184 dst[i] = (GLushort) (indexes[i] & 0xffff); 04185 } 04186 } 04187 break; 04188 case GL_UNSIGNED_INT: 04189 _mesa_memcpy(dest, indexes, n * sizeof(GLuint)); 04190 break; 04191 default: 04192 _mesa_problem(ctx, "bad dstType in _mesa_unpack_stencil_span"); 04193 } 04194 } 04195 } 04196 04197 04198 void 04199 _mesa_pack_stencil_span( const GLcontext *ctx, GLuint n, 04200 GLenum dstType, GLvoid *dest, const GLstencil *source, 04201 const struct gl_pixelstore_attrib *dstPacking ) 04202 { 04203 GLstencil stencil[MAX_WIDTH]; 04204 04205 ASSERT(n <= MAX_WIDTH); 04206 04207 if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset || 04208 ctx->Pixel.MapStencilFlag) { 04209 /* make a copy of input */ 04210 _mesa_memcpy(stencil, source, n * sizeof(GLstencil)); 04211 _mesa_apply_stencil_transfer_ops(ctx, n, stencil); 04212 source = stencil; 04213 } 04214 04215 switch (dstType) { 04216 case GL_UNSIGNED_BYTE: 04217 if (sizeof(GLstencil) == 1) { 04218 _mesa_memcpy( dest, source, n ); 04219 } 04220 else { 04221 GLubyte *dst = (GLubyte *) dest; 04222 GLuint i; 04223 for (i=0;i<n;i++) { 04224 dst[i] = (GLubyte) source[i]; 04225 } 04226 } 04227 break; 04228 case GL_BYTE: 04229 { 04230 GLbyte *dst = (GLbyte *) dest; 04231 GLuint i; 04232 for (i=0;i<n;i++) { 04233 dst[i] = (GLbyte) (source[i] & 0x7f); 04234 } 04235 } 04236 break; 04237 case GL_UNSIGNED_SHORT: 04238 { 04239 GLushort *dst = (GLushort *) dest; 04240 GLuint i; 04241 for (i=0;i<n;i++) { 04242 dst[i] = (GLushort) source[i]; 04243 } 04244 if (dstPacking->SwapBytes) { 04245 _mesa_swap2( (GLushort *) dst, n ); 04246 } 04247 } 04248 break; 04249 case GL_SHORT: 04250 { 04251 GLshort *dst = (GLshort *) dest; 04252 GLuint i; 04253 for (i=0;i<n;i++) { 04254 dst[i] = (GLshort) source[i]; 04255 } 04256 if (dstPacking->SwapBytes) { 04257 _mesa_swap2( (GLushort *) dst, n ); 04258 } 04259 } 04260 break; 04261 case GL_UNSIGNED_INT: 04262 { 04263 GLuint *dst = (GLuint *) dest; 04264 GLuint i; 04265 for (i=0;i<n;i++) { 04266 dst[i] = (GLuint) source[i]; 04267 } 04268 if (dstPacking->SwapBytes) { 04269 _mesa_swap4( (GLuint *) dst, n ); 04270 } 04271 } 04272 break; 04273 case GL_INT: 04274 { 04275 GLint *dst = (GLint *) dest; 04276 GLuint i; 04277 for (i=0;i<n;i++) { 04278 dst[i] = (GLint) source[i]; 04279 } 04280 if (dstPacking->SwapBytes) { 04281 _mesa_swap4( (GLuint *) dst, n ); 04282 } 04283 } 04284 break; 04285 case GL_FLOAT: 04286 { 04287 GLfloat *dst = (GLfloat *) dest; 04288 GLuint i; 04289 for (i=0;i<n;i++) { 04290 dst[i] = (GLfloat) source[i]; 04291 } 04292 if (dstPacking->SwapBytes) { 04293 _mesa_swap4( (GLuint *) dst, n ); 04294 } 04295 } 04296 break; 04297 case GL_HALF_FLOAT_ARB: 04298 { 04299 GLhalfARB *dst = (GLhalfARB *) dest; 04300 GLuint i; 04301 for (i=0;i<n;i++) { 04302 dst[i] = _mesa_float_to_half( (float) source[i] ); 04303 } 04304 if (dstPacking->SwapBytes) { 04305 _mesa_swap2( (GLushort *) dst, n ); 04306 } 04307 } 04308 break; 04309 case GL_BITMAP: 04310 if (dstPacking->LsbFirst) { 04311 GLubyte *dst = (GLubyte *) dest; 04312 GLint shift = 0; 04313 GLuint i; 04314 for (i = 0; i < n; i++) { 04315 if (shift == 0) 04316 *dst = 0; 04317 *dst |= ((source[i] != 0) << shift); 04318 shift++; 04319 if (shift == 8) { 04320 shift = 0; 04321 dst++; 04322 } 04323 } 04324 } 04325 else { 04326 GLubyte *dst = (GLubyte *) dest; 04327 GLint shift = 7; 04328 GLuint i; 04329 for (i = 0; i < n; i++) { 04330 if (shift == 7) 04331 *dst = 0; 04332 *dst |= ((source[i] != 0) << shift); 04333 shift--; 04334 if (shift < 0) { 04335 shift = 7; 04336 dst++; 04337 } 04338 } 04339 } 04340 break; 04341 default: 04342 _mesa_problem(ctx, "bad type in _mesa_pack_index_span"); 04343 } 04344 } 04345 04346 #define DEPTH_VALUES(GLTYPE, GLTYPE2FLOAT) \ 04347 do { \ 04348 GLuint i; \ 04349 const GLTYPE *src = (const GLTYPE *)source; \ 04350 for (i = 0; i < n; i++) { \ 04351 GLTYPE value = src[i]; \ 04352 if (srcPacking->SwapBytes) { \ 04353 if (sizeof(GLTYPE) == 2) { \ 04354 SWAP2BYTE(value); \ 04355 } else if (sizeof(GLTYPE) == 4) { \ 04356 SWAP4BYTE(value); \ 04357 } \ 04358 } \ 04359 depthValues[i] = GLTYPE2FLOAT(value); \ 04360 } \ 04361 } while (0) 04362 04363 04373 void 04374 _mesa_unpack_depth_span( const GLcontext *ctx, GLuint n, 04375 GLenum dstType, GLvoid *dest, GLuint depthMax, 04376 GLenum srcType, const GLvoid *source, 04377 const struct gl_pixelstore_attrib *srcPacking ) 04378 { 04379 GLfloat depthTemp[MAX_WIDTH], *depthValues; 04380 GLboolean needClamp = GL_FALSE; 04381 04382 /* Look for special cases first. 04383 * Not only are these faster, they're less prone to numeric conversion 04384 * problems. Otherwise, converting from an int type to a float then 04385 * back to an int type can introduce errors that will show up as 04386 * artifacts in things like depth peeling which uses glCopyTexImage. 04387 */ 04388 if (ctx->Pixel.DepthScale == 1.0 && ctx->Pixel.DepthBias == 0.0) { 04389 if (srcType == GL_UNSIGNED_INT && dstType == GL_UNSIGNED_SHORT) { 04390 const GLuint *src = (const GLuint *) source; 04391 GLushort *dst = (GLushort *) dest; 04392 GLuint i; 04393 for (i = 0; i < n; i++) { 04394 dst[i] = src[i] >> 16; 04395 } 04396 return; 04397 } 04398 if (srcType == GL_UNSIGNED_SHORT 04399 && dstType == GL_UNSIGNED_INT 04400 && depthMax == 0xffffffff) { 04401 const GLushort *src = (const GLushort *) source; 04402 GLuint *dst = (GLuint *) dest; 04403 GLuint i; 04404 for (i = 0; i < n; i++) { 04405 dst[i] = src[i] | (src[i] << 16); 04406 } 04407 return; 04408 } 04409 /* XXX may want to add additional cases here someday */ 04410 } 04411 04412 /* general case path follows */ 04413 04414 if (dstType == GL_FLOAT) { 04415 depthValues = (GLfloat *) dest; 04416 } 04417 else { 04418 depthValues = depthTemp; 04419 } 04420 04421 /* Convert incoming values to GLfloat. Some conversions will require 04422 * clamping, below. 04423 */ 04424 switch (srcType) { 04425 case GL_BYTE: 04426 DEPTH_VALUES(GLbyte, BYTE_TO_FLOAT); 04427 needClamp = GL_TRUE; 04428 break; 04429 case GL_UNSIGNED_BYTE: 04430 DEPTH_VALUES(GLubyte, UBYTE_TO_FLOAT); 04431 break; 04432 case GL_SHORT: 04433 DEPTH_VALUES(GLshort, SHORT_TO_FLOAT); 04434 needClamp = GL_TRUE; 04435 break; 04436 case GL_UNSIGNED_SHORT: 04437 DEPTH_VALUES(GLushort, USHORT_TO_FLOAT); 04438 break; 04439 case GL_INT: 04440 DEPTH_VALUES(GLint, INT_TO_FLOAT); 04441 needClamp = GL_TRUE; 04442 break; 04443 case GL_UNSIGNED_INT: 04444 DEPTH_VALUES(GLuint, UINT_TO_FLOAT); 04445 break; 04446 case GL_UNSIGNED_INT_24_8_EXT: /* GL_EXT_packed_depth_stencil */ 04447 if (dstType == GL_UNSIGNED_INT_24_8_EXT && 04448 depthMax == 0xffffff && 04449 ctx->Pixel.DepthScale == 1.0 && 04450 ctx->Pixel.DepthBias == 0.0) { 04451 const GLuint *src = (const GLuint *) source; 04452 GLuint *zValues = (GLuint *) dest; 04453 GLuint i; 04454 for (i = 0; i < n; i++) { 04455 GLuint value = src[i]; 04456 if (srcPacking->SwapBytes) { 04457 SWAP4BYTE(value); 04458 } 04459 zValues[i] = value & 0xffffff00; 04460 } 04461 return; 04462 } 04463 else { 04464 const GLuint *src = (const GLuint *) source; 04465 const GLfloat scale = 1.0f / 0xffffff; 04466 GLuint i; 04467 for (i = 0; i < n; i++) { 04468 GLuint value = src[i]; 04469 if (srcPacking->SwapBytes) { 04470 SWAP4BYTE(value); 04471 } 04472 depthValues[i] = (value >> 8) * scale; 04473 } 04474 } 04475 break; 04476 case GL_FLOAT: 04477 DEPTH_VALUES(GLfloat, 1*); 04478 needClamp = GL_TRUE; 04479 break; 04480 case GL_HALF_FLOAT_ARB: 04481 { 04482 GLuint i; 04483 const GLhalfARB *src = (const GLhalfARB *) source; 04484 for (i = 0; i < n; i++) { 04485 GLhalfARB value = src[i]; 04486 if (srcPacking->SwapBytes) { 04487 SWAP2BYTE(value); 04488 } 04489 depthValues[i] = _mesa_half_to_float(value); 04490 } 04491 needClamp = GL_TRUE; 04492 } 04493 break; 04494 default: 04495 _mesa_problem(NULL, "bad type in _mesa_unpack_depth_span()"); 04496 return; 04497 } 04498 04499 /* apply depth scale and bias */ 04500 { 04501 const GLfloat scale = ctx->Pixel.DepthScale; 04502 const GLfloat bias = ctx->Pixel.DepthBias; 04503 if (scale != 1.0 || bias != 0.0) { 04504 GLuint i; 04505 for (i = 0; i < n; i++) { 04506 depthValues[i] = depthValues[i] * scale + bias; 04507 } 04508 needClamp = GL_TRUE; 04509 } 04510 } 04511 04512 /* clamp to [0, 1] */ 04513 if (needClamp) { 04514 GLuint i; 04515 for (i = 0; i < n; i++) { 04516 depthValues[i] = (GLfloat)CLAMP(depthValues[i], 0.0, 1.0); 04517 } 04518 } 04519 04520 /* 04521 * Convert values to dstType 04522 */ 04523 if (dstType == GL_UNSIGNED_INT) { 04524 GLuint *zValues = (GLuint *) dest; 04525 GLuint i; 04526 if (depthMax <= 0xffffff) { 04527 /* no overflow worries */ 04528 for (i = 0; i < n; i++) { 04529 zValues[i] = (GLuint) (depthValues[i] * (GLfloat) depthMax); 04530 } 04531 } 04532 else { 04533 /* need to use double precision to prevent overflow problems */ 04534 for (i = 0; i < n; i++) { 04535 GLdouble z = depthValues[i] * (GLfloat) depthMax; 04536 if (z >= (GLdouble) 0xffffffff) 04537 zValues[i] = 0xffffffff; 04538 else 04539 zValues[i] = (GLuint) z; 04540 } 04541 } 04542 } 04543 else if (dstType == GL_UNSIGNED_SHORT) { 04544 GLushort *zValues = (GLushort *) dest; 04545 GLuint i; 04546 ASSERT(depthMax <= 0xffff); 04547 for (i = 0; i < n; i++) { 04548 zValues[i] = (GLushort) (depthValues[i] * (GLfloat) depthMax); 04549 } 04550 } 04551 else { 04552 ASSERT(dstType == GL_FLOAT); 04553 /*ASSERT(depthMax == 1.0F);*/ 04554 } 04555 } 04556 04557 04558 /* 04559 * Pack an array of depth values. The values are floats in [0,1]. 04560 */ 04561 void 04562 _mesa_pack_depth_span( const GLcontext *ctx, GLuint n, GLvoid *dest, 04563 GLenum dstType, const GLfloat *depthSpan, 04564 const struct gl_pixelstore_attrib *dstPacking ) 04565 { 04566 GLfloat depthCopy[MAX_WIDTH]; 04567 04568 ASSERT(n <= MAX_WIDTH); 04569 04570 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) { 04571 _mesa_memcpy(depthCopy, depthSpan, n * sizeof(GLfloat)); 04572 _mesa_scale_and_bias_depth(ctx, n, depthCopy); 04573 depthSpan = depthCopy; 04574 } 04575 04576 switch (dstType) { 04577 case GL_UNSIGNED_BYTE: 04578 { 04579 GLubyte *dst = (GLubyte *) dest; 04580 GLuint i; 04581 for (i = 0; i < n; i++) { 04582 dst[i] = FLOAT_TO_UBYTE( depthSpan[i] ); 04583 } 04584 } 04585 break; 04586 case GL_BYTE: 04587 { 04588 GLbyte *dst = (GLbyte *) dest; 04589 GLuint i; 04590 for (i = 0; i < n; i++) { 04591 dst[i] = FLOAT_TO_BYTE( depthSpan[i] ); 04592 } 04593 } 04594 break; 04595 case GL_UNSIGNED_SHORT: 04596 { 04597 GLushort *dst = (GLushort *) dest; 04598 GLuint i; 04599 for (i = 0; i < n; i++) { 04600 CLAMPED_FLOAT_TO_USHORT(dst[i], depthSpan[i]); 04601 } 04602 if (dstPacking->SwapBytes) { 04603 _mesa_swap2( (GLushort *) dst, n ); 04604 } 04605 } 04606 break; 04607 case GL_SHORT: 04608 { 04609 GLshort *dst = (GLshort *) dest; 04610 GLuint i; 04611 for (i = 0; i < n; i++) { 04612 dst[i] = FLOAT_TO_SHORT( depthSpan[i] ); 04613 } 04614 if (dstPacking->SwapBytes) { 04615 _mesa_swap2( (GLushort *) dst, n ); 04616 } 04617 } 04618 break; 04619 case GL_UNSIGNED_INT: 04620 { 04621 GLuint *dst = (GLuint *) dest; 04622 GLuint i; 04623 for (i = 0; i < n; i++) { 04624 dst[i] = FLOAT_TO_UINT( depthSpan[i] ); 04625 } 04626 if (dstPacking->SwapBytes) { 04627 _mesa_swap4( (GLuint *) dst, n ); 04628 } 04629 } 04630 break; 04631 case GL_INT: 04632 { 04633 GLint *dst = (GLint *) dest; 04634 GLuint i; 04635 for (i = 0; i < n; i++) { 04636 dst[i] = FLOAT_TO_INT( depthSpan[i] ); 04637 } 04638 if (dstPacking->SwapBytes) { 04639 _mesa_swap4( (GLuint *) dst, n ); 04640 } 04641 } 04642 break; 04643 case GL_FLOAT: 04644 { 04645 GLfloat *dst = (GLfloat *) dest; 04646 GLuint i; 04647 for (i = 0; i < n; i++) { 04648 dst[i] = depthSpan[i]; 04649 } 04650 if (dstPacking->SwapBytes) { 04651 _mesa_swap4( (GLuint *) dst, n ); 04652 } 04653 } 04654 break; 04655 case GL_HALF_FLOAT_ARB: 04656 { 04657 GLhalfARB *dst = (GLhalfARB *) dest; 04658 GLuint i; 04659 for (i = 0; i < n; i++) { 04660 dst[i] = _mesa_float_to_half(depthSpan[i]); 04661 } 04662 if (dstPacking->SwapBytes) { 04663 _mesa_swap2( (GLushort *) dst, n ); 04664 } 04665 } 04666 break; 04667 default: 04668 _mesa_problem(ctx, "bad type in _mesa_pack_depth_span"); 04669 } 04670 } 04671 04672 04673 04677 void 04678 _mesa_pack_depth_stencil_span(const GLcontext *ctx, GLuint n, GLuint *dest, 04679 const GLfloat *depthVals, 04680 const GLstencil *stencilVals, 04681 const struct gl_pixelstore_attrib *dstPacking) 04682 { 04683 GLfloat depthCopy[MAX_WIDTH]; 04684 GLstencil stencilCopy[MAX_WIDTH]; 04685 GLuint i; 04686 04687 ASSERT(n <= MAX_WIDTH); 04688 04689 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) { 04690 _mesa_memcpy(depthCopy, depthVals, n * sizeof(GLfloat)); 04691 _mesa_scale_and_bias_depth(ctx, n, depthCopy); 04692 depthVals = depthCopy; 04693 } 04694 04695 if (ctx->Pixel.IndexShift || 04696 ctx->Pixel.IndexOffset || 04697 ctx->Pixel.MapStencilFlag) { 04698 _mesa_memcpy(stencilCopy, stencilVals, n * sizeof(GLstencil)); 04699 _mesa_apply_stencil_transfer_ops(ctx, n, stencilCopy); 04700 stencilVals = stencilCopy; 04701 } 04702 04703 for (i = 0; i < n; i++) { 04704 GLuint z = (GLuint) (depthVals[i] * 0xffffff); 04705 dest[i] = (z << 8) | (stencilVals[i] & 0xff); 04706 } 04707 04708 if (dstPacking->SwapBytes) { 04709 _mesa_swap4(dest, n); 04710 } 04711 } 04712 04713 04714 04715 04722 void * 04723 _mesa_unpack_image( GLuint dimensions, 04724 GLsizei width, GLsizei height, GLsizei depth, 04725 GLenum format, GLenum type, const GLvoid *pixels, 04726 const struct gl_pixelstore_attrib *unpack ) 04727 { 04728 GLint bytesPerRow, compsPerRow; 04729 GLboolean flipBytes, swap2, swap4; 04730 04731 if (!pixels) 04732 return NULL; /* not necessarily an error */ 04733 04734 if (width <= 0 || height <= 0 || depth <= 0) 04735 return NULL; /* generate error later */ 04736 04737 if (type == GL_BITMAP) { 04738 bytesPerRow = (width + 7) >> 3; 04739 flipBytes = unpack->LsbFirst; 04740 swap2 = swap4 = GL_FALSE; 04741 compsPerRow = 0; 04742 } 04743 else { 04744 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type); 04745 GLint components = _mesa_components_in_format(format); 04746 GLint bytesPerComp; 04747 04748 if (_mesa_type_is_packed(type)) 04749 components = 1; 04750 04751 if (bytesPerPixel <= 0 || components <= 0) 04752 return NULL; /* bad format or type. generate error later */ 04753 bytesPerRow = bytesPerPixel * width; 04754 bytesPerComp = bytesPerPixel / components; 04755 flipBytes = GL_FALSE; 04756 swap2 = (bytesPerComp == 2) && unpack->SwapBytes; 04757 swap4 = (bytesPerComp == 4) && unpack->SwapBytes; 04758 compsPerRow = components * width; 04759 assert(compsPerRow >= width); 04760 } 04761 04762 { 04763 GLubyte *destBuffer 04764 = (GLubyte *) _mesa_malloc(bytesPerRow * height * depth); 04765 GLubyte *dst; 04766 GLint img, row; 04767 if (!destBuffer) 04768 return NULL; /* generate GL_OUT_OF_MEMORY later */ 04769 04770 dst = destBuffer; 04771 for (img = 0; img < depth; img++) { 04772 for (row = 0; row < height; row++) { 04773 const GLvoid *src = _mesa_image_address(dimensions, unpack, pixels, 04774 width, height, format, type, img, row, 0); 04775 04776 if ((type == GL_BITMAP) && (unpack->SkipPixels & 0x7)) { 04777 GLint i; 04778 flipBytes = GL_FALSE; 04779 if (unpack->LsbFirst) { 04780 GLubyte srcMask = 1 << (unpack->SkipPixels & 0x7); 04781 GLubyte dstMask = 128; 04782 const GLubyte *s = src; 04783 GLubyte *d = dst; 04784 *d = 0; 04785 for (i = 0; i < width; i++) { 04786 if (*s & srcMask) { 04787 *d |= dstMask; 04788 } 04789 if (srcMask == 128) { 04790 srcMask = 1; 04791 s++; 04792 } 04793 else { 04794 srcMask = srcMask << 1; 04795 } 04796 if (dstMask == 1) { 04797 dstMask = 128; 04798 d++; 04799 *d = 0; 04800 } 04801 else { 04802 dstMask = dstMask >> 1; 04803 } 04804 } 04805 } 04806 else { 04807 GLubyte srcMask = 128 >> (unpack->SkipPixels & 0x7); 04808 GLubyte dstMask = 128; 04809 const GLubyte *s = src; 04810 GLubyte *d = dst; 04811 *d = 0; 04812 for (i = 0; i < width; i++) { 04813 if (*s & srcMask) { 04814 *d |= dstMask; 04815 } 04816 if (srcMask == 1) { 04817 srcMask = 128; 04818 s++; 04819 } 04820 else { 04821 srcMask = srcMask >> 1; 04822 } 04823 if (dstMask == 1) { 04824 dstMask = 128; 04825 d++; 04826 *d = 0; 04827 } 04828 else { 04829 dstMask = dstMask >> 1; 04830 } 04831 } 04832 } 04833 } 04834 else { 04835 _mesa_memcpy(dst, src, bytesPerRow); 04836 } 04837 04838 /* byte flipping/swapping */ 04839 if (flipBytes) { 04840 flip_bytes((GLubyte *) dst, bytesPerRow); 04841 } 04842 else if (swap2) { 04843 _mesa_swap2((GLushort*) dst, compsPerRow); 04844 } 04845 else if (swap4) { 04846 _mesa_swap4((GLuint*) dst, compsPerRow); 04847 } 04848 dst += bytesPerRow; 04849 } 04850 } 04851 return destBuffer; 04852 } 04853 } 04854 04855 #endif /* _HAVE_FULL_GL */ 04856 04857 04858 04863 void 04864 _mesa_convert_colors(GLenum srcType, const GLvoid *src, 04865 GLenum dstType, GLvoid *dst, 04866 GLuint count, const GLubyte mask[]) 04867 { 04868 GLuint tempBuffer[MAX_WIDTH][4]; 04869 const GLboolean useTemp = (src == dst); 04870 04871 ASSERT(srcType != dstType); 04872 04873 switch (srcType) { 04874 case GL_UNSIGNED_BYTE: 04875 if (dstType == GL_UNSIGNED_SHORT) { 04876 const GLubyte (*src1)[4] = (const GLubyte (*)[4]) src; 04877 GLushort (*dst2)[4] = (GLushort (*)[4]) (useTemp ? tempBuffer : dst); 04878 GLuint i; 04879 for (i = 0; i < count; i++) { 04880 if (!mask || mask[i]) { 04881 dst2[i][RCOMP] = UBYTE_TO_USHORT(src1[i][RCOMP]); 04882 dst2[i][GCOMP] = UBYTE_TO_USHORT(src1[i][GCOMP]); 04883 dst2[i][BCOMP] = UBYTE_TO_USHORT(src1[i][BCOMP]); 04884 dst2[i][ACOMP] = UBYTE_TO_USHORT(src1[i][ACOMP]); 04885 } 04886 } 04887 if (useTemp) 04888 _mesa_memcpy(dst, tempBuffer, count * 4 * sizeof(GLushort)); 04889 } 04890 else { 04891 const GLubyte (*src1)[4] = (const GLubyte (*)[4]) src; 04892 GLfloat (*dst4)[4] = (GLfloat (*)[4]) (useTemp ? tempBuffer : dst); 04893 GLuint i; 04894 ASSERT(dstType == GL_FLOAT); 04895 for (i = 0; i < count; i++) { 04896 if (!mask || mask[i]) { 04897 dst4[i][RCOMP] = UBYTE_TO_FLOAT(src1[i][RCOMP]); 04898 dst4[i][GCOMP] = UBYTE_TO_FLOAT(src1[i][GCOMP]); 04899 dst4[i][BCOMP] = UBYTE_TO_FLOAT(src1[i][BCOMP]); 04900 dst4[i][ACOMP] = UBYTE_TO_FLOAT(src1[i][ACOMP]); 04901 } 04902 } 04903 if (useTemp) 04904 _mesa_memcpy(dst, tempBuffer, count * 4 * sizeof(GLfloat)); 04905 } 04906 break; 04907 case GL_UNSIGNED_SHORT: 04908 if (dstType == GL_UNSIGNED_BYTE) { 04909 const GLushort (*src2)[4] = (const GLushort (*)[4]) src; 04910 GLubyte (*dst1)[4] = (GLubyte (*)[4]) (useTemp ? tempBuffer : dst); 04911 GLuint i; 04912 for (i = 0; i < count; i++) { 04913 if (!mask || mask[i]) { 04914 dst1[i][RCOMP] = USHORT_TO_UBYTE(src2[i][RCOMP]); 04915 dst1[i][GCOMP] = USHORT_TO_UBYTE(src2[i][GCOMP]); 04916 dst1[i][BCOMP] = USHORT_TO_UBYTE(src2[i][BCOMP]); 04917 dst1[i][ACOMP] = USHORT_TO_UBYTE(src2[i][ACOMP]); 04918 } 04919 } 04920 if (useTemp) 04921 _mesa_memcpy(dst, tempBuffer, count * 4 * sizeof(GLubyte)); 04922 } 04923 else { 04924 const GLushort (*src2)[4] = (const GLushort (*)[4]) src; 04925 GLfloat (*dst4)[4] = (GLfloat (*)[4]) (useTemp ? tempBuffer : dst); 04926 GLuint i; 04927 ASSERT(dstType == GL_FLOAT); 04928 for (i = 0; i < count; i++) { 04929 if (!mask || mask[i]) { 04930 dst4[i][RCOMP] = USHORT_TO_FLOAT(src2[i][RCOMP]); 04931 dst4[i][GCOMP] = USHORT_TO_FLOAT(src2[i][GCOMP]); 04932 dst4[i][BCOMP] = USHORT_TO_FLOAT(src2[i][BCOMP]); 04933 dst4[i][ACOMP] = USHORT_TO_FLOAT(src2[i][ACOMP]); 04934 } 04935 } 04936 if (useTemp) 04937 _mesa_memcpy(dst, tempBuffer, count * 4 * sizeof(GLfloat)); 04938 } 04939 break; 04940 case GL_FLOAT: 04941 if (dstType == GL_UNSIGNED_BYTE) { 04942 const GLfloat (*src4)[4] = (const GLfloat (*)[4]) src; 04943 GLubyte (*dst1)[4] = (GLubyte (*)[4]) (useTemp ? tempBuffer : dst); 04944 GLuint i; 04945 for (i = 0; i < count; i++) { 04946 if (!mask || mask[i]) { 04947 UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][RCOMP], src4[i][RCOMP]); 04948 UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][GCOMP], src4[i][GCOMP]); 04949 UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][BCOMP], src4[i][BCOMP]); 04950 UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][ACOMP], src4[i][ACOMP]); 04951 } 04952 } 04953 if (useTemp) 04954 _mesa_memcpy(dst, tempBuffer, count * 4 * sizeof(GLubyte)); 04955 } 04956 else { 04957 const GLfloat (*src4)[4] = (const GLfloat (*)[4]) src; 04958 GLushort (*dst2)[4] = (GLushort (*)[4]) (useTemp ? tempBuffer : dst); 04959 GLuint i; 04960 ASSERT(dstType == GL_UNSIGNED_SHORT); 04961 for (i = 0; i < count; i++) { 04962 if (!mask || mask[i]) { 04963 UNCLAMPED_FLOAT_TO_USHORT(dst2[i][RCOMP], src4[i][RCOMP]); 04964 UNCLAMPED_FLOAT_TO_USHORT(dst2[i][GCOMP], src4[i][GCOMP]); 04965 UNCLAMPED_FLOAT_TO_USHORT(dst2[i][BCOMP], src4[i][BCOMP]); 04966 UNCLAMPED_FLOAT_TO_USHORT(dst2[i][ACOMP], src4[i][ACOMP]); 04967 } 04968 } 04969 if (useTemp) 04970 _mesa_memcpy(dst, tempBuffer, count * 4 * sizeof(GLushort)); 04971 } 04972 break; 04973 default: 04974 _mesa_problem(NULL, "Invalid datatype in _mesa_convert_colors"); 04975 } 04976 } 04977 04978 04979 04980 04992 GLboolean 04993 _mesa_clip_drawpixels(const GLcontext *ctx, 04994 GLint *destX, GLint *destY, 04995 GLsizei *width, GLsizei *height, 04996 struct gl_pixelstore_attrib *unpack) 04997 { 04998 const GLframebuffer *buffer = ctx->DrawBuffer; 04999 05000 if (unpack->RowLength == 0) { 05001 unpack->RowLength = *width; 05002 } 05003 05004 ASSERT(ctx->Pixel.ZoomX == 1.0F); 05005 ASSERT(ctx->Pixel.ZoomY == 1.0F || ctx->Pixel.ZoomY == -1.0F); 05006 05007 /* left clipping */ 05008 if (*destX < buffer->_Xmin) { 05009 unpack->SkipPixels += (buffer->_Xmin - *destX); 05010 *width -= (buffer->_Xmin - *destX); 05011 *destX = buffer->_Xmin; 05012 } 05013 /* right clipping */ 05014 if (*destX + *width > buffer->_Xmax) 05015 *width -= (*destX + *width - buffer->_Xmax); 05016 05017 if (*width <= 0) 05018 return GL_FALSE; 05019 05020 if (ctx->Pixel.ZoomY == 1.0F) { 05021 /* bottom clipping */ 05022 if (*destY < buffer->_Ymin) { 05023 unpack->SkipRows += (buffer->_Ymin - *destY); 05024 *height -= (buffer->_Ymin - *destY); 05025 *destY = buffer->_Ymin; 05026 } 05027 /* top clipping */ 05028 if (*destY + *height > buffer->_Ymax) 05029 *height -= (*destY + *height - buffer->_Ymax); 05030 } 05031 else { /* upside down */ 05032 /* top clipping */ 05033 if (*destY > buffer->_Ymax) { 05034 unpack->SkipRows += (*destY - buffer->_Ymax); 05035 *height -= (*destY - buffer->_Ymax); 05036 *destY = buffer->_Ymax; 05037 } 05038 /* bottom clipping */ 05039 if (*destY - *height < buffer->_Ymin) 05040 *height -= (buffer->_Ymin - (*destY - *height)); 05041 /* adjust destY so it's the first row to write to */ 05042 (*destY)--; 05043 } 05044 05045 if (*height <= 0) 05046 return GL_TRUE; 05047 05048 return GL_TRUE; 05049 } 05050 05051 05063 GLboolean 05064 _mesa_clip_readpixels(const GLcontext *ctx, 05065 GLint *srcX, GLint *srcY, 05066 GLsizei *width, GLsizei *height, 05067 struct gl_pixelstore_attrib *pack) 05068 { 05069 const GLframebuffer *buffer = ctx->ReadBuffer; 05070 05071 if (pack->RowLength == 0) { 05072 pack->RowLength = *width; 05073 } 05074 05075 /* left clipping */ 05076 if (*srcX < 0) { 05077 pack->SkipPixels += (0 - *srcX); 05078 *width -= (0 - *srcX); 05079 *srcX = 0; 05080 } 05081 /* right clipping */ 05082 if (*srcX + *width > (GLsizei) buffer->Width) 05083 *width -= (*srcX + *width - buffer->Width); 05084 05085 if (*width <= 0) 05086 return GL_FALSE; 05087 05088 /* bottom clipping */ 05089 if (*srcY < 0) { 05090 pack->SkipRows += (0 - *srcY); 05091 *height -= (0 - *srcY); 05092 *srcY = 0; 05093 } 05094 /* top clipping */ 05095 if (*srcY + *height > (GLsizei) buffer->Height) 05096 *height -= (*srcY + *height - buffer->Height); 05097 05098 if (*height <= 0) 05099 return GL_TRUE; 05100 05101 return GL_TRUE; 05102 } 05103 05104 05113 GLboolean 05114 _mesa_clip_copytexsubimage(const GLcontext *ctx, 05115 GLint *destX, GLint *destY, 05116 GLint *srcX, GLint *srcY, 05117 GLsizei *width, GLsizei *height) 05118 { 05119 const struct gl_framebuffer *fb = ctx->ReadBuffer; 05120 const GLint srcX0 = *srcX, srcY0 = *srcY; 05121 05122 if (_mesa_clip_to_region(0, 0, fb->Width, fb->Height, 05123 srcX, srcY, width, height)) { 05124 *destX = *destX + *srcX - srcX0; 05125 *destY = *destY + *srcY - srcY0; 05126 05127 return GL_TRUE; 05128 } 05129 else { 05130 return GL_FALSE; 05131 } 05132 } 05133 05134 05135 05141 GLboolean 05142 _mesa_clip_to_region(GLint xmin, GLint ymin, 05143 GLint xmax, GLint ymax, 05144 GLint *x, GLint *y, 05145 GLsizei *width, GLsizei *height ) 05146 { 05147 /* left clipping */ 05148 if (*x < xmin) { 05149 *width -= (xmin - *x); 05150 *x = xmin; 05151 } 05152 05153 /* right clipping */ 05154 if (*x + *width > xmax) 05155 *width -= (*x + *width - xmax); 05156 05157 if (*width <= 0) 05158 return GL_FALSE; 05159 05160 /* bottom (or top) clipping */ 05161 if (*y < ymin) { 05162 *height -= (ymin - *y); 05163 *y = ymin; 05164 } 05165 05166 /* top (or bottom) clipping */ 05167 if (*y + *height > ymax) 05168 *height -= (*y + *height - ymax); 05169 05170 if (*height <= 0) 05171 return GL_FALSE; 05172 05173 return GL_TRUE; 05174 }
Generated on Sun May 27 2012 04:20:19 for ReactOS by
1.7.6.1
