2 * Mesa 3-D graphics library
5 * Copyright (C) 1999-2006 Brian Paul All Rights Reserved.
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
37 #include "histogram.h"
44 * Normally, BYTE_TO_FLOAT(0) returns 0.00392 That causes problems when
45 * we later convert the float to a packed integer value (such as for
46 * GL_RGB5_A1) because we'll wind up with a non-zero value.
48 * We redefine the macros here so zero is handled correctly.
51 #define BYTE_TO_FLOAT(B) ((B) == 0 ? 0.0F : ((2.0F * (B) + 1.0F) * (1.0F/255.0F)))
54 #define SHORT_TO_FLOAT(S) ((S) == 0 ? 0.0F : ((2.0F * (S) + 1.0F) * (1.0F/65535.0F)))
58 /** Compute ceiling of integer quotient of A divided by B. */
59 #define CEILING( A, B ) ( (A) % (B) == 0 ? (A)/(B) : (A)/(B)+1 )
63 * Flip the 8 bits in each byte of the given array.
66 * \param n number of bytes.
68 * \todo try this trick to flip bytes someday:
70 * v = ((v & 0x55555555) << 1) | ((v >> 1) & 0x55555555);
71 * v = ((v & 0x33333333) << 2) | ((v >> 2) & 0x33333333);
72 * v = ((v & 0x0f0f0f0f) << 4) | ((v >> 4) & 0x0f0f0f0f);
76 flip_bytes( GLubyte
*p
, GLuint n
)
78 register GLuint i
, a
, b
;
81 b
= (GLuint
) p
[i
]; /* words are often faster than bytes */
82 a
= ((b
& 0x01) << 7) |
96 * Flip the order of the 2 bytes in each word in the given array.
99 * \param n number of words.
102 _mesa_swap2( GLushort
*p
, GLuint n
)
107 p
[i
] = (p
[i
] >> 8) | ((p
[i
] << 8) & 0xff00);
114 * Flip the order of the 4 bytes in each word in the given array.
117 _mesa_swap4( GLuint
*p
, GLuint n
)
119 register GLuint i
, a
, b
;
124 | ((b
>> 8) & 0xff00)
125 | ((b
<< 8) & 0xff0000)
126 | ((b
<< 24) & 0xff000000);
133 * Get the size of a GL data type.
135 * \param type GL data type.
137 * \return the size, in bytes, of the given data type, 0 if a GL_BITMAP, or -1
138 * if an invalid type enum.
141 _mesa_sizeof_type( GLenum type
)
146 case GL_UNSIGNED_BYTE
:
147 return sizeof(GLubyte
);
149 return sizeof(GLbyte
);
150 case GL_UNSIGNED_SHORT
:
151 return sizeof(GLushort
);
153 return sizeof(GLshort
);
154 case GL_UNSIGNED_INT
:
155 return sizeof(GLuint
);
157 return sizeof(GLint
);
159 return sizeof(GLfloat
);
160 case GL_HALF_FLOAT_ARB
:
161 return sizeof(GLhalfARB
);
169 * Same as _mesa_sizeof_type() but also accepting the packed pixel
173 _mesa_sizeof_packed_type( GLenum type
)
178 case GL_UNSIGNED_BYTE
:
179 return sizeof(GLubyte
);
181 return sizeof(GLbyte
);
182 case GL_UNSIGNED_SHORT
:
183 return sizeof(GLushort
);
185 return sizeof(GLshort
);
186 case GL_UNSIGNED_INT
:
187 return sizeof(GLuint
);
189 return sizeof(GLint
);
190 case GL_HALF_FLOAT_ARB
:
191 return sizeof(GLhalfARB
);
193 return sizeof(GLfloat
);
194 case GL_UNSIGNED_BYTE_3_3_2
:
195 return sizeof(GLubyte
);
196 case GL_UNSIGNED_BYTE_2_3_3_REV
:
197 return sizeof(GLubyte
);
198 case GL_UNSIGNED_SHORT_5_6_5
:
199 return sizeof(GLushort
);
200 case GL_UNSIGNED_SHORT_5_6_5_REV
:
201 return sizeof(GLushort
);
202 case GL_UNSIGNED_SHORT_4_4_4_4
:
203 return sizeof(GLushort
);
204 case GL_UNSIGNED_SHORT_4_4_4_4_REV
:
205 return sizeof(GLushort
);
206 case GL_UNSIGNED_SHORT_5_5_5_1
:
207 return sizeof(GLushort
);
208 case GL_UNSIGNED_SHORT_1_5_5_5_REV
:
209 return sizeof(GLushort
);
210 case GL_UNSIGNED_INT_8_8_8_8
:
211 return sizeof(GLuint
);
212 case GL_UNSIGNED_INT_8_8_8_8_REV
:
213 return sizeof(GLuint
);
214 case GL_UNSIGNED_INT_10_10_10_2
:
215 return sizeof(GLuint
);
216 case GL_UNSIGNED_INT_2_10_10_10_REV
:
217 return sizeof(GLuint
);
218 case GL_UNSIGNED_SHORT_8_8_MESA
:
219 case GL_UNSIGNED_SHORT_8_8_REV_MESA
:
220 return sizeof(GLushort
);
221 case GL_UNSIGNED_INT_24_8_EXT
:
222 return sizeof(GLuint
);
230 * Get the number of components in a pixel format.
232 * \param format pixel format.
234 * \return the number of components in the given format, or -1 if a bad format.
237 _mesa_components_in_format( GLenum format
)
241 case GL_COLOR_INDEX1_EXT
:
242 case GL_COLOR_INDEX2_EXT
:
243 case GL_COLOR_INDEX4_EXT
:
244 case GL_COLOR_INDEX8_EXT
:
245 case GL_COLOR_INDEX12_EXT
:
246 case GL_COLOR_INDEX16_EXT
:
247 case GL_STENCIL_INDEX
:
248 case GL_DEPTH_COMPONENT
:
256 case GL_LUMINANCE_ALPHA
:
270 case GL_DEPTH_STENCIL_EXT
:
279 * Get the bytes per pixel of pixel format type pair.
281 * \param format pixel format.
282 * \param type pixel type.
284 * \return bytes per pixel, or -1 if a bad format or type was given.
287 _mesa_bytes_per_pixel( GLenum format
, GLenum type
)
289 GLint comps
= _mesa_components_in_format( format
);
295 return 0; /* special case */
297 case GL_UNSIGNED_BYTE
:
298 return comps
* sizeof(GLubyte
);
300 case GL_UNSIGNED_SHORT
:
301 return comps
* sizeof(GLshort
);
303 case GL_UNSIGNED_INT
:
304 return comps
* sizeof(GLint
);
306 return comps
* sizeof(GLfloat
);
307 case GL_HALF_FLOAT_ARB
:
308 return comps
* sizeof(GLhalfARB
);
309 case GL_UNSIGNED_BYTE_3_3_2
:
310 case GL_UNSIGNED_BYTE_2_3_3_REV
:
311 if (format
== GL_RGB
|| format
== GL_BGR
)
312 return sizeof(GLubyte
);
314 return -1; /* error */
315 case GL_UNSIGNED_SHORT_5_6_5
:
316 case GL_UNSIGNED_SHORT_5_6_5_REV
:
317 if (format
== GL_RGB
|| format
== GL_BGR
)
318 return sizeof(GLushort
);
320 return -1; /* error */
321 case GL_UNSIGNED_SHORT_4_4_4_4
:
322 case GL_UNSIGNED_SHORT_4_4_4_4_REV
:
323 case GL_UNSIGNED_SHORT_5_5_5_1
:
324 case GL_UNSIGNED_SHORT_1_5_5_5_REV
:
325 if (format
== GL_RGBA
|| format
== GL_BGRA
|| format
== GL_ABGR_EXT
)
326 return sizeof(GLushort
);
329 case GL_UNSIGNED_INT_8_8_8_8
:
330 case GL_UNSIGNED_INT_8_8_8_8_REV
:
331 case GL_UNSIGNED_INT_10_10_10_2
:
332 case GL_UNSIGNED_INT_2_10_10_10_REV
:
333 if (format
== GL_RGBA
|| format
== GL_BGRA
|| format
== GL_ABGR_EXT
)
334 return sizeof(GLuint
);
337 case GL_UNSIGNED_SHORT_8_8_MESA
:
338 case GL_UNSIGNED_SHORT_8_8_REV_MESA
:
339 if (format
== GL_YCBCR_MESA
)
340 return sizeof(GLushort
);
343 case GL_UNSIGNED_INT_24_8_EXT
:
344 if (format
== GL_DEPTH_STENCIL_EXT
)
345 return sizeof(GLuint
);
355 * Test for a legal pixel format and type.
357 * \param format pixel format.
358 * \param type pixel type.
360 * \return GL_TRUE if the given pixel format and type are legal, or GL_FALSE
364 _mesa_is_legal_format_and_type( GLcontext
*ctx
, GLenum format
, GLenum type
)
368 case GL_STENCIL_INDEX
:
372 case GL_UNSIGNED_BYTE
:
374 case GL_UNSIGNED_SHORT
:
376 case GL_UNSIGNED_INT
:
379 case GL_HALF_FLOAT_ARB
:
380 return ctx
->Extensions
.ARB_half_float_pixel
;
388 #if 0 /* not legal! see table 3.6 of the 1.5 spec */
392 case GL_LUMINANCE_ALPHA
:
393 case GL_DEPTH_COMPONENT
:
396 case GL_UNSIGNED_BYTE
:
398 case GL_UNSIGNED_SHORT
:
400 case GL_UNSIGNED_INT
:
403 case GL_HALF_FLOAT_ARB
:
404 return ctx
->Extensions
.ARB_half_float_pixel
;
411 case GL_UNSIGNED_BYTE
:
413 case GL_UNSIGNED_SHORT
:
415 case GL_UNSIGNED_INT
:
417 case GL_UNSIGNED_BYTE_3_3_2
:
418 case GL_UNSIGNED_BYTE_2_3_3_REV
:
419 case GL_UNSIGNED_SHORT_5_6_5
:
420 case GL_UNSIGNED_SHORT_5_6_5_REV
:
422 case GL_HALF_FLOAT_ARB
:
423 return ctx
->Extensions
.ARB_half_float_pixel
;
429 /* NOTE: no packed types are supported with BGR. That's
430 * intentional, according to the GL spec.
433 case GL_UNSIGNED_BYTE
:
435 case GL_UNSIGNED_SHORT
:
437 case GL_UNSIGNED_INT
:
440 case GL_HALF_FLOAT_ARB
:
441 return ctx
->Extensions
.ARB_half_float_pixel
;
450 case GL_UNSIGNED_BYTE
:
452 case GL_UNSIGNED_SHORT
:
454 case GL_UNSIGNED_INT
:
456 case GL_UNSIGNED_SHORT_4_4_4_4
:
457 case GL_UNSIGNED_SHORT_4_4_4_4_REV
:
458 case GL_UNSIGNED_SHORT_5_5_5_1
:
459 case GL_UNSIGNED_SHORT_1_5_5_5_REV
:
460 case GL_UNSIGNED_INT_8_8_8_8
:
461 case GL_UNSIGNED_INT_8_8_8_8_REV
:
462 case GL_UNSIGNED_INT_10_10_10_2
:
463 case GL_UNSIGNED_INT_2_10_10_10_REV
:
465 case GL_HALF_FLOAT_ARB
:
466 return ctx
->Extensions
.ARB_half_float_pixel
;
471 if (type
== GL_UNSIGNED_SHORT_8_8_MESA
||
472 type
== GL_UNSIGNED_SHORT_8_8_REV_MESA
)
476 case GL_DEPTH_STENCIL_EXT
:
477 if (ctx
->Extensions
.EXT_packed_depth_stencil
478 && type
== GL_UNSIGNED_INT_24_8_EXT
)
490 * Return the address of a specific pixel in an image (1D, 2D or 3D).
492 * Pixel unpacking/packing parameters are observed according to \p packing.
494 * \param dimensions either 1, 2 or 3 to indicate dimensionality of image
495 * \param image starting address of image data
496 * \param width the image width
497 * \param height theimage height
498 * \param format the pixel format
499 * \param type the pixel data type
500 * \param packing the pixelstore attributes
501 * \param img which image in the volume (0 for 1D or 2D images)
502 * \param row row of pixel in the image (0 for 1D images)
503 * \param column column of pixel in the image
505 * \return address of pixel on success, or NULL on error.
507 * \sa gl_pixelstore_attrib.
510 _mesa_image_address( GLuint dimensions
,
511 const struct gl_pixelstore_attrib
*packing
,
513 GLsizei width
, GLsizei height
,
514 GLenum format
, GLenum type
,
515 GLint img
, GLint row
, GLint column
)
517 GLint alignment
; /* 1, 2 or 4 */
518 GLint pixels_per_row
;
519 GLint rows_per_image
;
522 GLint skipimages
; /* for 3-D volume images */
525 ASSERT(dimensions
>= 1 && dimensions
<= 3);
527 alignment
= packing
->Alignment
;
528 if (packing
->RowLength
> 0) {
529 pixels_per_row
= packing
->RowLength
;
532 pixels_per_row
= width
;
534 if (packing
->ImageHeight
> 0) {
535 rows_per_image
= packing
->ImageHeight
;
538 rows_per_image
= height
;
541 skippixels
= packing
->SkipPixels
;
542 /* Note: SKIP_ROWS _is_ used for 1D images */
543 skiprows
= packing
->SkipRows
;
544 /* Note: SKIP_IMAGES is only used for 3D images */
545 skipimages
= (dimensions
== 3) ? packing
->SkipImages
: 0;
547 if (type
== GL_BITMAP
) {
549 GLint comp_per_pixel
; /* components per pixel */
550 GLint bytes_per_comp
; /* bytes per component */
552 GLint bytes_per_image
;
554 /* Compute bytes per component */
555 bytes_per_comp
= _mesa_sizeof_packed_type( type
);
556 if (bytes_per_comp
< 0) {
560 /* Compute number of components per pixel */
561 comp_per_pixel
= _mesa_components_in_format( format
);
562 if (comp_per_pixel
< 0) {
566 bytes_per_row
= alignment
567 * CEILING( comp_per_pixel
*pixels_per_row
, 8*alignment
);
569 bytes_per_image
= bytes_per_row
* rows_per_image
;
571 pixel_addr
= (GLubyte
*) image
572 + (skipimages
+ img
) * bytes_per_image
573 + (skiprows
+ row
) * bytes_per_row
574 + (skippixels
+ column
) / 8;
577 /* Non-BITMAP data */
578 GLint bytes_per_pixel
, bytes_per_row
, remainder
, bytes_per_image
;
581 bytes_per_pixel
= _mesa_bytes_per_pixel( format
, type
);
583 /* The pixel type and format should have been error checked earlier */
584 assert(bytes_per_pixel
> 0);
586 bytes_per_row
= pixels_per_row
* bytes_per_pixel
;
587 remainder
= bytes_per_row
% alignment
;
589 bytes_per_row
+= (alignment
- remainder
);
591 ASSERT(bytes_per_row
% alignment
== 0);
593 bytes_per_image
= bytes_per_row
* rows_per_image
;
595 if (packing
->Invert
) {
596 /* set pixel_addr to the last row */
597 topOfImage
= bytes_per_row
* (height
- 1);
598 bytes_per_row
= -bytes_per_row
;
604 /* compute final pixel address */
605 pixel_addr
= (GLubyte
*) image
606 + (skipimages
+ img
) * bytes_per_image
608 + (skiprows
+ row
) * bytes_per_row
609 + (skippixels
+ column
) * bytes_per_pixel
;
612 return (GLvoid
*) pixel_addr
;
617 _mesa_image_address1d( const struct gl_pixelstore_attrib
*packing
,
620 GLenum format
, GLenum type
,
623 return _mesa_image_address(1, packing
, image
, width
, 1,
624 format
, type
, 0, 0, column
);
629 _mesa_image_address2d( const struct gl_pixelstore_attrib
*packing
,
631 GLsizei width
, GLsizei height
,
632 GLenum format
, GLenum type
,
633 GLint row
, GLint column
)
635 return _mesa_image_address(2, packing
, image
, width
, height
,
636 format
, type
, 0, row
, column
);
641 _mesa_image_address3d( const struct gl_pixelstore_attrib
*packing
,
643 GLsizei width
, GLsizei height
,
644 GLenum format
, GLenum type
,
645 GLint img
, GLint row
, GLint column
)
647 return _mesa_image_address(3, packing
, image
, width
, height
,
648 format
, type
, img
, row
, column
);
654 * Compute the stride between image rows.
656 * \param packing the pixelstore attributes
657 * \param width image width.
658 * \param format pixel format.
659 * \param type pixel data type.
661 * \return the stride in bytes for the given parameters.
664 _mesa_image_row_stride( const struct gl_pixelstore_attrib
*packing
,
665 GLint width
, GLenum format
, GLenum type
)
668 if (type
== GL_BITMAP
) {
671 if (packing
->RowLength
== 0) {
672 bytes
= (width
+ 7) / 8;
675 bytes
= (packing
->RowLength
+ 7) / 8;
677 if (packing
->Invert
) {
678 /* negate the bytes per row (negative row stride) */
684 /* Non-BITMAP data */
685 const GLint bytesPerPixel
= _mesa_bytes_per_pixel(format
, type
);
686 GLint bytesPerRow
, remainder
;
687 if (bytesPerPixel
<= 0)
688 return -1; /* error */
689 if (packing
->RowLength
== 0) {
690 bytesPerRow
= bytesPerPixel
* width
;
693 bytesPerRow
= bytesPerPixel
* packing
->RowLength
;
695 remainder
= bytesPerRow
% packing
->Alignment
;
697 bytesPerRow
+= (packing
->Alignment
- remainder
);
699 bytesPerRow
= -bytesPerRow
;
708 * Compute the stride between images in a 3D texture (in bytes) for the given
709 * pixel packing parameters and image width, format and type.
712 _mesa_image_image_stride( const struct gl_pixelstore_attrib
*packing
,
713 GLint width
, GLint height
,
714 GLenum format
, GLenum type
)
717 ASSERT(type
!= GL_BITMAP
);
720 const GLint bytesPerPixel
= _mesa_bytes_per_pixel(format
, type
);
721 GLint bytesPerRow
, bytesPerImage
, remainder
;
723 if (bytesPerPixel
<= 0)
724 return -1; /* error */
725 if (packing
->RowLength
== 0) {
726 bytesPerRow
= bytesPerPixel
* width
;
729 bytesPerRow
= bytesPerPixel
* packing
->RowLength
;
731 remainder
= bytesPerRow
% packing
->Alignment
;
733 bytesPerRow
+= (packing
->Alignment
- remainder
);
735 if (packing
->ImageHeight
== 0)
736 bytesPerImage
= bytesPerRow
* height
;
738 bytesPerImage
= bytesPerRow
* packing
->ImageHeight
;
740 return bytesPerImage
;
746 * Unpack a 32x32 pixel polygon stipple from user memory using the
747 * current pixel unpack settings.
750 _mesa_unpack_polygon_stipple( const GLubyte
*pattern
, GLuint dest
[32],
751 const struct gl_pixelstore_attrib
*unpacking
)
753 GLubyte
*ptrn
= (GLubyte
*) _mesa_unpack_bitmap(32, 32, pattern
, unpacking
);
755 /* Convert pattern from GLubytes to GLuints and handle big/little
760 for (i
= 0; i
< 32; i
++) {
761 dest
[i
] = (p
[0] << 24)
773 * Pack polygon stipple into user memory given current pixel packing
777 _mesa_pack_polygon_stipple( const GLuint pattern
[32], GLubyte
*dest
,
778 const struct gl_pixelstore_attrib
*packing
)
780 /* Convert pattern from GLuints to GLubytes to handle big/little
781 * endian differences.
785 for (i
= 0; i
< 32; i
++) {
786 ptrn
[i
* 4 + 0] = (GLubyte
) ((pattern
[i
] >> 24) & 0xff);
787 ptrn
[i
* 4 + 1] = (GLubyte
) ((pattern
[i
] >> 16) & 0xff);
788 ptrn
[i
* 4 + 2] = (GLubyte
) ((pattern
[i
] >> 8 ) & 0xff);
789 ptrn
[i
* 4 + 3] = (GLubyte
) ((pattern
[i
] ) & 0xff);
792 _mesa_pack_bitmap(32, 32, ptrn
, dest
, packing
);
797 * Unpack bitmap data. Resulting data will be in most-significant-bit-first
798 * order with row alignment = 1 byte.
801 _mesa_unpack_bitmap( GLint width
, GLint height
, const GLubyte
*pixels
,
802 const struct gl_pixelstore_attrib
*packing
)
804 GLint bytes
, row
, width_in_bytes
;
805 GLubyte
*buffer
, *dst
;
810 /* Alloc dest storage */
811 bytes
= ((width
+ 7) / 8 * height
);
812 buffer
= (GLubyte
*) _mesa_malloc( bytes
);
816 width_in_bytes
= CEILING( width
, 8 );
818 for (row
= 0; row
< height
; row
++) {
819 const GLubyte
*src
= (const GLubyte
*)
820 _mesa_image_address2d(packing
, pixels
, width
, height
,
821 GL_COLOR_INDEX
, GL_BITMAP
, row
, 0);
827 if (packing
->SkipPixels
== 0) {
828 _mesa_memcpy( dst
, src
, width_in_bytes
);
829 if (packing
->LsbFirst
) {
830 flip_bytes( dst
, width_in_bytes
);
834 /* handling SkipPixels is a bit tricky (no pun intended!) */
836 if (packing
->LsbFirst
) {
837 GLubyte srcMask
= 1 << (packing
->SkipPixels
& 0x7);
838 GLubyte dstMask
= 128;
839 const GLubyte
*s
= src
;
842 for (i
= 0; i
< width
; i
++) {
846 if (srcMask
== 128) {
851 srcMask
= srcMask
<< 1;
859 dstMask
= dstMask
>> 1;
864 GLubyte srcMask
= 128 >> (packing
->SkipPixels
& 0x7);
865 GLubyte dstMask
= 128;
866 const GLubyte
*s
= src
;
869 for (i
= 0; i
< width
; i
++) {
878 srcMask
= srcMask
>> 1;
886 dstMask
= dstMask
>> 1;
891 dst
+= width_in_bytes
;
902 _mesa_pack_bitmap( GLint width
, GLint height
, const GLubyte
*source
,
903 GLubyte
*dest
, const struct gl_pixelstore_attrib
*packing
)
905 GLint row
, width_in_bytes
;
911 width_in_bytes
= CEILING( width
, 8 );
913 for (row
= 0; row
< height
; row
++) {
914 GLubyte
*dst
= (GLubyte
*) _mesa_image_address2d(packing
, dest
,
915 width
, height
, GL_COLOR_INDEX
, GL_BITMAP
, row
, 0);
919 if (packing
->SkipPixels
== 0) {
920 _mesa_memcpy( dst
, src
, width_in_bytes
);
921 if (packing
->LsbFirst
) {
922 flip_bytes( dst
, width_in_bytes
);
926 /* handling SkipPixels is a bit tricky (no pun intended!) */
928 if (packing
->LsbFirst
) {
929 GLubyte srcMask
= 1 << (packing
->SkipPixels
& 0x7);
930 GLubyte dstMask
= 128;
931 const GLubyte
*s
= src
;
934 for (i
= 0; i
< width
; i
++) {
938 if (srcMask
== 128) {
943 srcMask
= srcMask
<< 1;
951 dstMask
= dstMask
>> 1;
956 GLubyte srcMask
= 128 >> (packing
->SkipPixels
& 0x7);
957 GLubyte dstMask
= 128;
958 const GLubyte
*s
= src
;
961 for (i
= 0; i
< width
; i
++) {
970 srcMask
= srcMask
>> 1;
978 dstMask
= dstMask
>> 1;
983 src
+= width_in_bytes
;
989 * Apply various pixel transfer operations to an array of RGBA pixels
990 * as indicated by the transferOps bitmask
993 _mesa_apply_rgba_transfer_ops(GLcontext
*ctx
, GLbitfield transferOps
,
994 GLuint n
, GLfloat rgba
[][4])
997 if (transferOps
& IMAGE_SCALE_BIAS_BIT
) {
998 _mesa_scale_and_bias_rgba(n
, rgba
,
999 ctx
->Pixel
.RedScale
, ctx
->Pixel
.GreenScale
,
1000 ctx
->Pixel
.BlueScale
, ctx
->Pixel
.AlphaScale
,
1001 ctx
->Pixel
.RedBias
, ctx
->Pixel
.GreenBias
,
1002 ctx
->Pixel
.BlueBias
, ctx
->Pixel
.AlphaBias
);
1004 /* color map lookup */
1005 if (transferOps
& IMAGE_MAP_COLOR_BIT
) {
1006 _mesa_map_rgba( ctx
, n
, rgba
);
1008 /* GL_COLOR_TABLE lookup */
1009 if (transferOps
& IMAGE_COLOR_TABLE_BIT
) {
1010 _mesa_lookup_rgba_float(&ctx
->ColorTable
, n
, rgba
);
1013 if (transferOps
& IMAGE_CONVOLUTION_BIT
) {
1014 /* this has to be done in the calling code */
1015 _mesa_problem(ctx
, "IMAGE_CONVOLUTION_BIT set in _mesa_apply_transfer_ops");
1017 /* GL_POST_CONVOLUTION_RED/GREEN/BLUE/ALPHA_SCALE/BIAS */
1018 if (transferOps
& IMAGE_POST_CONVOLUTION_SCALE_BIAS
) {
1019 _mesa_scale_and_bias_rgba(n
, rgba
,
1020 ctx
->Pixel
.PostConvolutionScale
[RCOMP
],
1021 ctx
->Pixel
.PostConvolutionScale
[GCOMP
],
1022 ctx
->Pixel
.PostConvolutionScale
[BCOMP
],
1023 ctx
->Pixel
.PostConvolutionScale
[ACOMP
],
1024 ctx
->Pixel
.PostConvolutionBias
[RCOMP
],
1025 ctx
->Pixel
.PostConvolutionBias
[GCOMP
],
1026 ctx
->Pixel
.PostConvolutionBias
[BCOMP
],
1027 ctx
->Pixel
.PostConvolutionBias
[ACOMP
]);
1029 /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
1030 if (transferOps
& IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT
) {
1031 _mesa_lookup_rgba_float(&ctx
->PostConvolutionColorTable
, n
, rgba
);
1033 /* color matrix transform */
1034 if (transferOps
& IMAGE_COLOR_MATRIX_BIT
) {
1035 _mesa_transform_rgba(ctx
, n
, rgba
);
1037 /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
1038 if (transferOps
& IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT
) {
1039 _mesa_lookup_rgba_float(&ctx
->PostColorMatrixColorTable
, n
, rgba
);
1041 /* update histogram count */
1042 if (transferOps
& IMAGE_HISTOGRAM_BIT
) {
1043 _mesa_update_histogram(ctx
, n
, (CONST
GLfloat (*)[4]) rgba
);
1045 /* update min/max values */
1046 if (transferOps
& IMAGE_MIN_MAX_BIT
) {
1047 _mesa_update_minmax(ctx
, n
, (CONST
GLfloat (*)[4]) rgba
);
1049 /* clamping to [0,1] */
1050 if (transferOps
& IMAGE_CLAMP_BIT
) {
1052 for (i
= 0; i
< n
; i
++) {
1053 rgba
[i
][RCOMP
] = CLAMP(rgba
[i
][RCOMP
], 0.0F
, 1.0F
);
1054 rgba
[i
][GCOMP
] = CLAMP(rgba
[i
][GCOMP
], 0.0F
, 1.0F
);
1055 rgba
[i
][BCOMP
] = CLAMP(rgba
[i
][BCOMP
], 0.0F
, 1.0F
);
1056 rgba
[i
][ACOMP
] = CLAMP(rgba
[i
][ACOMP
], 0.0F
, 1.0F
);
1063 * Apply color index shift and offset to an array of pixels.
1066 shift_and_offset_ci( const GLcontext
*ctx
, GLuint n
, GLuint indexes
[] )
1068 GLint shift
= ctx
->Pixel
.IndexShift
;
1069 GLint offset
= ctx
->Pixel
.IndexOffset
;
1073 indexes
[i
] = (indexes
[i
] << shift
) + offset
;
1076 else if (shift
< 0) {
1079 indexes
[i
] = (indexes
[i
] >> shift
) + offset
;
1084 indexes
[i
] = indexes
[i
] + offset
;
1092 * Apply color index shift, offset and table lookup to an array
1096 _mesa_apply_ci_transfer_ops(const GLcontext
*ctx
, GLbitfield transferOps
,
1097 GLuint n
, GLuint indexes
[])
1099 if (transferOps
& IMAGE_SHIFT_OFFSET_BIT
) {
1100 shift_and_offset_ci(ctx
, n
, indexes
);
1102 if (transferOps
& IMAGE_MAP_COLOR_BIT
) {
1103 const GLuint mask
= ctx
->Pixel
.MapItoIsize
- 1;
1105 for (i
= 0; i
< n
; i
++) {
1106 const GLuint j
= indexes
[i
] & mask
;
1107 indexes
[i
] = IROUND(ctx
->Pixel
.MapItoI
[j
]);
1114 * Apply stencil index shift, offset and table lookup to an array
1115 * of stencil values.
1118 _mesa_apply_stencil_transfer_ops(const GLcontext
*ctx
, GLuint n
,
1119 GLstencil stencil
[])
1121 if (ctx
->Pixel
.IndexShift
!= 0 || ctx
->Pixel
.IndexOffset
!= 0) {
1122 const GLint offset
= ctx
->Pixel
.IndexOffset
;
1123 GLint shift
= ctx
->Pixel
.IndexShift
;
1126 for (i
= 0; i
< n
; i
++) {
1127 stencil
[i
] = (stencil
[i
] << shift
) + offset
;
1130 else if (shift
< 0) {
1132 for (i
= 0; i
< n
; i
++) {
1133 stencil
[i
] = (stencil
[i
] >> shift
) + offset
;
1137 for (i
= 0; i
< n
; i
++) {
1138 stencil
[i
] = stencil
[i
] + offset
;
1142 if (ctx
->Pixel
.MapStencilFlag
) {
1143 GLuint mask
= ctx
->Pixel
.MapStoSsize
- 1;
1145 for (i
= 0; i
< n
; i
++) {
1146 stencil
[i
] = ctx
->Pixel
.MapStoS
[ stencil
[i
] & mask
];
1153 * Used to pack an array [][4] of RGBA float colors as specified
1154 * by the dstFormat, dstType and dstPacking. Used by glReadPixels,
1155 * glGetConvolutionFilter(), etc.
1156 * Incoming colors will be clamped to [0,1] if needed.
1157 * Note: the rgba values will be modified by this function when any pixel
1158 * transfer ops are enabled.
1161 _mesa_pack_rgba_span_float(GLcontext
*ctx
, GLuint n
, GLfloat rgba
[][4],
1162 GLenum dstFormat
, GLenum dstType
,
1164 const struct gl_pixelstore_attrib
*dstPacking
,
1165 GLbitfield transferOps
)
1167 GLfloat luminance
[MAX_WIDTH
];
1168 const GLint comps
= _mesa_components_in_format(dstFormat
);
1171 if (dstType
!= GL_FLOAT
|| ctx
->Color
.ClampReadColor
== GL_TRUE
) {
1172 /* need to clamp to [0, 1] */
1173 transferOps
|= IMAGE_CLAMP_BIT
;
1177 _mesa_apply_rgba_transfer_ops(ctx
, transferOps
, n
, rgba
);
1178 if ((transferOps
& IMAGE_MIN_MAX_BIT
) && ctx
->MinMax
.Sink
) {
1183 if (dstFormat
== GL_LUMINANCE
|| dstFormat
== GL_LUMINANCE_ALPHA
) {
1184 /* compute luminance values */
1185 if (dstType
!= GL_FLOAT
|| ctx
->Color
.ClampReadColor
== GL_TRUE
) {
1186 for (i
= 0; i
< n
; i
++) {
1187 GLfloat sum
= rgba
[i
][RCOMP
] + rgba
[i
][GCOMP
] + rgba
[i
][BCOMP
];
1188 luminance
[i
] = CLAMP(sum
, 0.0F
, 1.0F
);
1192 for (i
= 0; i
< n
; i
++) {
1193 luminance
[i
] = rgba
[i
][RCOMP
] + rgba
[i
][GCOMP
] + rgba
[i
][BCOMP
];
1199 * Pack/store the pixels. Ugh! Lots of cases!!!
1202 case GL_UNSIGNED_BYTE
:
1204 GLubyte
*dst
= (GLubyte
*) dstAddr
;
1205 switch (dstFormat
) {
1208 dst
[i
] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
1212 dst
[i
] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
1216 dst
[i
] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
1220 dst
[i
] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
1224 dst
[i
] = FLOAT_TO_UBYTE(luminance
[i
]);
1226 case GL_LUMINANCE_ALPHA
:
1228 dst
[i
*2+0] = FLOAT_TO_UBYTE(luminance
[i
]);
1229 dst
[i
*2+1] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
1234 dst
[i
*3+0] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
1235 dst
[i
*3+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
1236 dst
[i
*3+2] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
1241 dst
[i
*4+0] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
1242 dst
[i
*4+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
1243 dst
[i
*4+2] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
1244 dst
[i
*4+3] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
1249 dst
[i
*3+0] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
1250 dst
[i
*3+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
1251 dst
[i
*3+2] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
1256 dst
[i
*4+0] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
1257 dst
[i
*4+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
1258 dst
[i
*4+2] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
1259 dst
[i
*4+3] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
1264 dst
[i
*4+0] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
1265 dst
[i
*4+1] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
1266 dst
[i
*4+2] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
1267 dst
[i
*4+3] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
1271 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1277 GLbyte
*dst
= (GLbyte
*) dstAddr
;
1278 switch (dstFormat
) {
1281 dst
[i
] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
1285 dst
[i
] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
1289 dst
[i
] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
1293 dst
[i
] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
1297 dst
[i
] = FLOAT_TO_BYTE(luminance
[i
]);
1299 case GL_LUMINANCE_ALPHA
:
1301 dst
[i
*2+0] = FLOAT_TO_BYTE(luminance
[i
]);
1302 dst
[i
*2+1] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
1307 dst
[i
*3+0] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
1308 dst
[i
*3+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
1309 dst
[i
*3+2] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
1314 dst
[i
*4+0] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
1315 dst
[i
*4+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
1316 dst
[i
*4+2] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
1317 dst
[i
*4+3] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
1322 dst
[i
*3+0] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
1323 dst
[i
*3+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
1324 dst
[i
*3+2] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
1329 dst
[i
*4+0] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
1330 dst
[i
*4+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
1331 dst
[i
*4+2] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
1332 dst
[i
*4+3] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
1336 dst
[i
*4+0] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
1337 dst
[i
*4+1] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
1338 dst
[i
*4+2] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
1339 dst
[i
*4+3] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
1343 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1347 case GL_UNSIGNED_SHORT
:
1349 GLushort
*dst
= (GLushort
*) dstAddr
;
1350 switch (dstFormat
) {
1353 CLAMPED_FLOAT_TO_USHORT(dst
[i
], rgba
[i
][RCOMP
]);
1357 CLAMPED_FLOAT_TO_USHORT(dst
[i
], rgba
[i
][GCOMP
]);
1361 CLAMPED_FLOAT_TO_USHORT(dst
[i
], rgba
[i
][BCOMP
]);
1365 CLAMPED_FLOAT_TO_USHORT(dst
[i
], rgba
[i
][ACOMP
]);
1369 UNCLAMPED_FLOAT_TO_USHORT(dst
[i
], luminance
[i
]);
1371 case GL_LUMINANCE_ALPHA
:
1373 UNCLAMPED_FLOAT_TO_USHORT(dst
[i
*2+0], luminance
[i
]);
1374 CLAMPED_FLOAT_TO_USHORT(dst
[i
*2+1], rgba
[i
][ACOMP
]);
1379 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+0], rgba
[i
][RCOMP
]);
1380 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+1], rgba
[i
][GCOMP
]);
1381 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+2], rgba
[i
][BCOMP
]);
1386 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+0], rgba
[i
][RCOMP
]);
1387 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+1], rgba
[i
][GCOMP
]);
1388 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+2], rgba
[i
][BCOMP
]);
1389 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+3], rgba
[i
][ACOMP
]);
1394 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+0], rgba
[i
][BCOMP
]);
1395 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+1], rgba
[i
][GCOMP
]);
1396 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+2], rgba
[i
][RCOMP
]);
1401 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+0], rgba
[i
][BCOMP
]);
1402 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+1], rgba
[i
][GCOMP
]);
1403 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+2], rgba
[i
][RCOMP
]);
1404 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+3], rgba
[i
][ACOMP
]);
1409 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+0], rgba
[i
][ACOMP
]);
1410 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+1], rgba
[i
][BCOMP
]);
1411 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+2], rgba
[i
][GCOMP
]);
1412 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+3], rgba
[i
][RCOMP
]);
1416 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1418 if (dstPacking
->SwapBytes
) {
1419 _mesa_swap2( (GLushort
*) dst
, n
* comps
);
1425 GLshort
*dst
= (GLshort
*) dstAddr
;
1426 switch (dstFormat
) {
1429 dst
[i
] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1433 dst
[i
] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1437 dst
[i
] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1441 dst
[i
] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
1445 dst
[i
] = FLOAT_TO_SHORT(luminance
[i
]);
1447 case GL_LUMINANCE_ALPHA
:
1449 dst
[i
*2+0] = FLOAT_TO_SHORT(luminance
[i
]);
1450 dst
[i
*2+1] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
1455 dst
[i
*3+0] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1456 dst
[i
*3+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1457 dst
[i
*3+2] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1462 dst
[i
*4+0] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1463 dst
[i
*4+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1464 dst
[i
*4+2] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1465 dst
[i
*4+3] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
1470 dst
[i
*3+0] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1471 dst
[i
*3+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1472 dst
[i
*3+2] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1477 dst
[i
*4+0] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1478 dst
[i
*4+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1479 dst
[i
*4+2] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1480 dst
[i
*4+3] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
1484 dst
[i
*4+0] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
1485 dst
[i
*4+1] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1486 dst
[i
*4+2] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1487 dst
[i
*4+3] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1491 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1493 if (dstPacking
->SwapBytes
) {
1494 _mesa_swap2( (GLushort
*) dst
, n
* comps
);
1498 case GL_UNSIGNED_INT
:
1500 GLuint
*dst
= (GLuint
*) dstAddr
;
1501 switch (dstFormat
) {
1504 dst
[i
] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1508 dst
[i
] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1512 dst
[i
] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1516 dst
[i
] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
1520 dst
[i
] = FLOAT_TO_UINT(luminance
[i
]);
1522 case GL_LUMINANCE_ALPHA
:
1524 dst
[i
*2+0] = FLOAT_TO_UINT(luminance
[i
]);
1525 dst
[i
*2+1] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
1530 dst
[i
*3+0] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1531 dst
[i
*3+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1532 dst
[i
*3+2] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1537 dst
[i
*4+0] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1538 dst
[i
*4+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1539 dst
[i
*4+2] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1540 dst
[i
*4+3] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
1545 dst
[i
*3+0] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1546 dst
[i
*3+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1547 dst
[i
*3+2] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1552 dst
[i
*4+0] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1553 dst
[i
*4+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1554 dst
[i
*4+2] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1555 dst
[i
*4+3] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
1560 dst
[i
*4+0] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
1561 dst
[i
*4+1] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1562 dst
[i
*4+2] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1563 dst
[i
*4+3] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1567 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1569 if (dstPacking
->SwapBytes
) {
1570 _mesa_swap4( (GLuint
*) dst
, n
* comps
);
1576 GLint
*dst
= (GLint
*) dstAddr
;
1577 switch (dstFormat
) {
1580 dst
[i
] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1584 dst
[i
] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1588 dst
[i
] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1592 dst
[i
] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
1596 dst
[i
] = FLOAT_TO_INT(luminance
[i
]);
1598 case GL_LUMINANCE_ALPHA
:
1600 dst
[i
*2+0] = FLOAT_TO_INT(luminance
[i
]);
1601 dst
[i
*2+1] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
1606 dst
[i
*3+0] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1607 dst
[i
*3+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1608 dst
[i
*3+2] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1613 dst
[i
*4+0] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1614 dst
[i
*4+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1615 dst
[i
*4+2] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1616 dst
[i
*4+3] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
1621 dst
[i
*3+0] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1622 dst
[i
*3+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1623 dst
[i
*3+2] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1628 dst
[i
*4+0] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1629 dst
[i
*4+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1630 dst
[i
*4+2] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1631 dst
[i
*4+3] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
1636 dst
[i
*4+0] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
1637 dst
[i
*4+1] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1638 dst
[i
*4+2] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1639 dst
[i
*4+3] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1643 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1645 if (dstPacking
->SwapBytes
) {
1646 _mesa_swap4( (GLuint
*) dst
, n
* comps
);
1652 GLfloat
*dst
= (GLfloat
*) dstAddr
;
1653 switch (dstFormat
) {
1656 dst
[i
] = rgba
[i
][RCOMP
];
1660 dst
[i
] = rgba
[i
][GCOMP
];
1664 dst
[i
] = rgba
[i
][BCOMP
];
1668 dst
[i
] = rgba
[i
][ACOMP
];
1672 dst
[i
] = luminance
[i
];
1674 case GL_LUMINANCE_ALPHA
:
1676 dst
[i
*2+0] = luminance
[i
];
1677 dst
[i
*2+1] = rgba
[i
][ACOMP
];
1682 dst
[i
*3+0] = rgba
[i
][RCOMP
];
1683 dst
[i
*3+1] = rgba
[i
][GCOMP
];
1684 dst
[i
*3+2] = rgba
[i
][BCOMP
];
1689 dst
[i
*4+0] = rgba
[i
][RCOMP
];
1690 dst
[i
*4+1] = rgba
[i
][GCOMP
];
1691 dst
[i
*4+2] = rgba
[i
][BCOMP
];
1692 dst
[i
*4+3] = rgba
[i
][ACOMP
];
1697 dst
[i
*3+0] = rgba
[i
][BCOMP
];
1698 dst
[i
*3+1] = rgba
[i
][GCOMP
];
1699 dst
[i
*3+2] = rgba
[i
][RCOMP
];
1704 dst
[i
*4+0] = rgba
[i
][BCOMP
];
1705 dst
[i
*4+1] = rgba
[i
][GCOMP
];
1706 dst
[i
*4+2] = rgba
[i
][RCOMP
];
1707 dst
[i
*4+3] = rgba
[i
][ACOMP
];
1712 dst
[i
*4+0] = rgba
[i
][ACOMP
];
1713 dst
[i
*4+1] = rgba
[i
][BCOMP
];
1714 dst
[i
*4+2] = rgba
[i
][GCOMP
];
1715 dst
[i
*4+3] = rgba
[i
][RCOMP
];
1719 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1721 if (dstPacking
->SwapBytes
) {
1722 _mesa_swap4( (GLuint
*) dst
, n
* comps
);
1726 case GL_HALF_FLOAT_ARB
:
1728 GLhalfARB
*dst
= (GLhalfARB
*) dstAddr
;
1729 switch (dstFormat
) {
1732 dst
[i
] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1736 dst
[i
] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1740 dst
[i
] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1744 dst
[i
] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
1748 dst
[i
] = _mesa_float_to_half(luminance
[i
]);
1750 case GL_LUMINANCE_ALPHA
:
1752 dst
[i
*2+0] = _mesa_float_to_half(luminance
[i
]);
1753 dst
[i
*2+1] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
1758 dst
[i
*3+0] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1759 dst
[i
*3+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1760 dst
[i
*3+2] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1765 dst
[i
*4+0] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1766 dst
[i
*4+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1767 dst
[i
*4+2] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1768 dst
[i
*4+3] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
1773 dst
[i
*3+0] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1774 dst
[i
*3+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1775 dst
[i
*3+2] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1780 dst
[i
*4+0] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1781 dst
[i
*4+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1782 dst
[i
*4+2] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1783 dst
[i
*4+3] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
1788 dst
[i
*4+0] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
1789 dst
[i
*4+1] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1790 dst
[i
*4+2] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1791 dst
[i
*4+3] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1795 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1797 if (dstPacking
->SwapBytes
) {
1798 _mesa_swap2( (GLushort
*) dst
, n
* comps
);
1802 case GL_UNSIGNED_BYTE_3_3_2
:
1803 if (dstFormat
== GL_RGB
) {
1804 GLubyte
*dst
= (GLubyte
*) dstAddr
;
1806 dst
[i
] = (((GLint
) (rgba
[i
][RCOMP
] * 7.0F
)) << 5)
1807 | (((GLint
) (rgba
[i
][GCOMP
] * 7.0F
)) << 2)
1808 | (((GLint
) (rgba
[i
][BCOMP
] * 3.0F
)) );
1812 case GL_UNSIGNED_BYTE_2_3_3_REV
:
1813 if (dstFormat
== GL_RGB
) {
1814 GLubyte
*dst
= (GLubyte
*) dstAddr
;
1816 dst
[i
] = (((GLint
) (rgba
[i
][RCOMP
] * 7.0F
)) )
1817 | (((GLint
) (rgba
[i
][GCOMP
] * 7.0F
)) << 3)
1818 | (((GLint
) (rgba
[i
][BCOMP
] * 3.0F
)) << 5);
1822 case GL_UNSIGNED_SHORT_5_6_5
:
1823 if (dstFormat
== GL_RGB
) {
1824 GLushort
*dst
= (GLushort
*) dstAddr
;
1826 dst
[i
] = (((GLint
) (rgba
[i
][RCOMP
] * 31.0F
)) << 11)
1827 | (((GLint
) (rgba
[i
][GCOMP
] * 63.0F
)) << 5)
1828 | (((GLint
) (rgba
[i
][BCOMP
] * 31.0F
)) );
1832 case GL_UNSIGNED_SHORT_5_6_5_REV
:
1833 if (dstFormat
== GL_RGB
) {
1834 GLushort
*dst
= (GLushort
*) dstAddr
;
1836 dst
[i
] = (((GLint
) (rgba
[i
][RCOMP
] * 31.0F
)) )
1837 | (((GLint
) (rgba
[i
][GCOMP
] * 63.0F
)) << 5)
1838 | (((GLint
) (rgba
[i
][BCOMP
] * 31.0F
)) << 11);
1842 case GL_UNSIGNED_SHORT_4_4_4_4
:
1843 if (dstFormat
== GL_RGBA
) {
1844 GLushort
*dst
= (GLushort
*) dstAddr
;
1846 dst
[i
] = (((GLint
) (rgba
[i
][RCOMP
] * 15.0F
)) << 12)
1847 | (((GLint
) (rgba
[i
][GCOMP
] * 15.0F
)) << 8)
1848 | (((GLint
) (rgba
[i
][BCOMP
] * 15.0F
)) << 4)
1849 | (((GLint
) (rgba
[i
][ACOMP
] * 15.0F
)) );
1852 else if (dstFormat
== GL_BGRA
) {
1853 GLushort
*dst
= (GLushort
*) dstAddr
;
1855 dst
[i
] = (((GLint
) (rgba
[i
][BCOMP
] * 15.0F
)) << 12)
1856 | (((GLint
) (rgba
[i
][GCOMP
] * 15.0F
)) << 8)
1857 | (((GLint
) (rgba
[i
][RCOMP
] * 15.0F
)) << 4)
1858 | (((GLint
) (rgba
[i
][ACOMP
] * 15.0F
)) );
1861 else if (dstFormat
== GL_ABGR_EXT
) {
1862 GLushort
*dst
= (GLushort
*) dstAddr
;
1864 dst
[i
] = (((GLint
) (rgba
[i
][ACOMP
] * 15.0F
)) << 4)
1865 | (((GLint
) (rgba
[i
][BCOMP
] * 15.0F
)) << 8)
1866 | (((GLint
) (rgba
[i
][GCOMP
] * 15.0F
)) << 12)
1867 | (((GLint
) (rgba
[i
][RCOMP
] * 15.0F
)) );
1871 case GL_UNSIGNED_SHORT_4_4_4_4_REV
:
1872 if (dstFormat
== GL_RGBA
) {
1873 GLushort
*dst
= (GLushort
*) dstAddr
;
1875 dst
[i
] = (((GLint
) (rgba
[i
][RCOMP
] * 15.0F
)) )
1876 | (((GLint
) (rgba
[i
][GCOMP
] * 15.0F
)) << 4)
1877 | (((GLint
) (rgba
[i
][BCOMP
] * 15.0F
)) << 8)
1878 | (((GLint
) (rgba
[i
][ACOMP
] * 15.0F
)) << 12);
1881 else if (dstFormat
== GL_BGRA
) {
1882 GLushort
*dst
= (GLushort
*) dstAddr
;
1884 dst
[i
] = (((GLint
) (rgba
[i
][BCOMP
] * 15.0F
)) )
1885 | (((GLint
) (rgba
[i
][GCOMP
] * 15.0F
)) << 4)
1886 | (((GLint
) (rgba
[i
][RCOMP
] * 15.0F
)) << 8)
1887 | (((GLint
) (rgba
[i
][ACOMP
] * 15.0F
)) << 12);
1890 else if (dstFormat
== GL_ABGR_EXT
) {
1891 GLushort
*dst
= (GLushort
*) dstAddr
;
1893 dst
[i
] = (((GLint
) (rgba
[i
][ACOMP
] * 15.0F
)) )
1894 | (((GLint
) (rgba
[i
][BCOMP
] * 15.0F
)) << 4)
1895 | (((GLint
) (rgba
[i
][GCOMP
] * 15.0F
)) << 8)
1896 | (((GLint
) (rgba
[i
][RCOMP
] * 15.0F
)) << 12);
1900 case GL_UNSIGNED_SHORT_5_5_5_1
:
1901 if (dstFormat
== GL_RGBA
) {
1902 GLushort
*dst
= (GLushort
*) dstAddr
;
1904 dst
[i
] = (((GLint
) (rgba
[i
][RCOMP
] * 31.0F
)) << 11)
1905 | (((GLint
) (rgba
[i
][GCOMP
] * 31.0F
)) << 6)
1906 | (((GLint
) (rgba
[i
][BCOMP
] * 31.0F
)) << 1)
1907 | (((GLint
) (rgba
[i
][ACOMP
] * 1.0F
)) );
1910 else if (dstFormat
== GL_BGRA
) {
1911 GLushort
*dst
= (GLushort
*) dstAddr
;
1913 dst
[i
] = (((GLint
) (rgba
[i
][BCOMP
] * 31.0F
)) << 11)
1914 | (((GLint
) (rgba
[i
][GCOMP
] * 31.0F
)) << 6)
1915 | (((GLint
) (rgba
[i
][RCOMP
] * 31.0F
)) << 1)
1916 | (((GLint
) (rgba
[i
][ACOMP
] * 1.0F
)) );
1919 else if (dstFormat
== GL_ABGR_EXT
) {
1920 GLushort
*dst
= (GLushort
*) dstAddr
;
1922 dst
[i
] = (((GLint
) (rgba
[i
][ACOMP
] * 31.0F
)) << 11)
1923 | (((GLint
) (rgba
[i
][BCOMP
] * 31.0F
)) << 6)
1924 | (((GLint
) (rgba
[i
][GCOMP
] * 31.0F
)) << 1)
1925 | (((GLint
) (rgba
[i
][RCOMP
] * 1.0F
)) );
1929 case GL_UNSIGNED_SHORT_1_5_5_5_REV
:
1930 if (dstFormat
== GL_RGBA
) {
1931 GLushort
*dst
= (GLushort
*) dstAddr
;
1933 dst
[i
] = (((GLint
) (rgba
[i
][RCOMP
] * 31.0F
)) )
1934 | (((GLint
) (rgba
[i
][GCOMP
] * 31.0F
)) << 5)
1935 | (((GLint
) (rgba
[i
][BCOMP
] * 31.0F
)) << 10)
1936 | (((GLint
) (rgba
[i
][ACOMP
] * 1.0F
)) << 15);
1939 else if (dstFormat
== GL_BGRA
) {
1940 GLushort
*dst
= (GLushort
*) dstAddr
;
1942 dst
[i
] = (((GLint
) (rgba
[i
][BCOMP
] * 31.0F
)) )
1943 | (((GLint
) (rgba
[i
][GCOMP
] * 31.0F
)) << 5)
1944 | (((GLint
) (rgba
[i
][RCOMP
] * 31.0F
)) << 10)
1945 | (((GLint
) (rgba
[i
][ACOMP
] * 1.0F
)) << 15);
1948 else if (dstFormat
== GL_ABGR_EXT
) {
1949 GLushort
*dst
= (GLushort
*) dstAddr
;
1951 dst
[i
] = (((GLint
) (rgba
[i
][ACOMP
] * 31.0F
)) )
1952 | (((GLint
) (rgba
[i
][BCOMP
] * 31.0F
)) << 5)
1953 | (((GLint
) (rgba
[i
][GCOMP
] * 31.0F
)) << 10)
1954 | (((GLint
) (rgba
[i
][RCOMP
] * 1.0F
)) << 15);
1958 case GL_UNSIGNED_INT_8_8_8_8
:
1959 if (dstFormat
== GL_RGBA
) {
1960 GLuint
*dst
= (GLuint
*) dstAddr
;
1962 dst
[i
] = (((GLuint
) (rgba
[i
][RCOMP
] * 255.0F
)) << 24)
1963 | (((GLuint
) (rgba
[i
][GCOMP
] * 255.0F
)) << 16)
1964 | (((GLuint
) (rgba
[i
][BCOMP
] * 255.0F
)) << 8)
1965 | (((GLuint
) (rgba
[i
][ACOMP
] * 255.0F
)) );
1968 else if (dstFormat
== GL_BGRA
) {
1969 GLuint
*dst
= (GLuint
*) dstAddr
;
1971 dst
[i
] = (((GLuint
) (rgba
[i
][BCOMP
] * 255.0F
)) << 24)
1972 | (((GLuint
) (rgba
[i
][GCOMP
] * 255.0F
)) << 16)
1973 | (((GLuint
) (rgba
[i
][RCOMP
] * 255.0F
)) << 8)
1974 | (((GLuint
) (rgba
[i
][ACOMP
] * 255.0F
)) );
1977 else if (dstFormat
== GL_ABGR_EXT
) {
1978 GLuint
*dst
= (GLuint
*) dstAddr
;
1980 dst
[i
] = (((GLuint
) (rgba
[i
][ACOMP
] * 255.0F
)) << 24)
1981 | (((GLuint
) (rgba
[i
][BCOMP
] * 255.0F
)) << 16)
1982 | (((GLuint
) (rgba
[i
][GCOMP
] * 255.0F
)) << 8)
1983 | (((GLuint
) (rgba
[i
][RCOMP
] * 255.0F
)) );
1987 case GL_UNSIGNED_INT_8_8_8_8_REV
:
1988 if (dstFormat
== GL_RGBA
) {
1989 GLuint
*dst
= (GLuint
*) dstAddr
;
1991 dst
[i
] = (((GLuint
) (rgba
[i
][RCOMP
] * 255.0F
)) )
1992 | (((GLuint
) (rgba
[i
][GCOMP
] * 255.0F
)) << 8)
1993 | (((GLuint
) (rgba
[i
][BCOMP
] * 255.0F
)) << 16)
1994 | (((GLuint
) (rgba
[i
][ACOMP
] * 255.0F
)) << 24);
1997 else if (dstFormat
== GL_BGRA
) {
1998 GLuint
*dst
= (GLuint
*) dstAddr
;
2000 dst
[i
] = (((GLuint
) (rgba
[i
][BCOMP
] * 255.0F
)) )
2001 | (((GLuint
) (rgba
[i
][GCOMP
] * 255.0F
)) << 8)
2002 | (((GLuint
) (rgba
[i
][RCOMP
] * 255.0F
)) << 16)
2003 | (((GLuint
) (rgba
[i
][ACOMP
] * 255.0F
)) << 24);
2006 else if (dstFormat
== GL_ABGR_EXT
) {
2007 GLuint
*dst
= (GLuint
*) dstAddr
;
2009 dst
[i
] = (((GLuint
) (rgba
[i
][ACOMP
] * 255.0F
)) )
2010 | (((GLuint
) (rgba
[i
][BCOMP
] * 255.0F
)) << 8)
2011 | (((GLuint
) (rgba
[i
][GCOMP
] * 255.0F
)) << 16)
2012 | (((GLuint
) (rgba
[i
][RCOMP
] * 255.0F
)) << 24);
2016 case GL_UNSIGNED_INT_10_10_10_2
:
2017 if (dstFormat
== GL_RGBA
) {
2018 GLuint
*dst
= (GLuint
*) dstAddr
;
2020 dst
[i
] = (((GLuint
) (rgba
[i
][RCOMP
] * 1023.0F
)) << 22)
2021 | (((GLuint
) (rgba
[i
][GCOMP
] * 1023.0F
)) << 12)
2022 | (((GLuint
) (rgba
[i
][BCOMP
] * 1023.0F
)) << 2)
2023 | (((GLuint
) (rgba
[i
][ACOMP
] * 3.0F
)) );
2026 else if (dstFormat
== GL_BGRA
) {
2027 GLuint
*dst
= (GLuint
*) dstAddr
;
2029 dst
[i
] = (((GLuint
) (rgba
[i
][BCOMP
] * 1023.0F
)) << 22)
2030 | (((GLuint
) (rgba
[i
][GCOMP
] * 1023.0F
)) << 12)
2031 | (((GLuint
) (rgba
[i
][RCOMP
] * 1023.0F
)) << 2)
2032 | (((GLuint
) (rgba
[i
][ACOMP
] * 3.0F
)) );
2035 else if (dstFormat
== GL_ABGR_EXT
) {
2036 GLuint
*dst
= (GLuint
*) dstAddr
;
2038 dst
[i
] = (((GLuint
) (rgba
[i
][ACOMP
] * 1023.0F
)) << 22)
2039 | (((GLuint
) (rgba
[i
][BCOMP
] * 1023.0F
)) << 12)
2040 | (((GLuint
) (rgba
[i
][GCOMP
] * 1023.0F
)) << 2)
2041 | (((GLuint
) (rgba
[i
][RCOMP
] * 3.0F
)) );
2045 case GL_UNSIGNED_INT_2_10_10_10_REV
:
2046 if (dstFormat
== GL_RGBA
) {
2047 GLuint
*dst
= (GLuint
*) dstAddr
;
2049 dst
[i
] = (((GLuint
) (rgba
[i
][RCOMP
] * 1023.0F
)) )
2050 | (((GLuint
) (rgba
[i
][GCOMP
] * 1023.0F
)) << 10)
2051 | (((GLuint
) (rgba
[i
][BCOMP
] * 1023.0F
)) << 20)
2052 | (((GLuint
) (rgba
[i
][ACOMP
] * 3.0F
)) << 30);
2055 else if (dstFormat
== GL_BGRA
) {
2056 GLuint
*dst
= (GLuint
*) dstAddr
;
2058 dst
[i
] = (((GLuint
) (rgba
[i
][BCOMP
] * 1023.0F
)) )
2059 | (((GLuint
) (rgba
[i
][GCOMP
] * 1023.0F
)) << 10)
2060 | (((GLuint
) (rgba
[i
][RCOMP
] * 1023.0F
)) << 20)
2061 | (((GLuint
) (rgba
[i
][ACOMP
] * 3.0F
)) << 30);
2064 else if (dstFormat
== GL_ABGR_EXT
) {
2065 GLuint
*dst
= (GLuint
*) dstAddr
;
2067 dst
[i
] = (((GLuint
) (rgba
[i
][ACOMP
] * 1023.0F
)) )
2068 | (((GLuint
) (rgba
[i
][BCOMP
] * 1023.0F
)) << 10)
2069 | (((GLuint
) (rgba
[i
][GCOMP
] * 1023.0F
)) << 20)
2070 | (((GLuint
) (rgba
[i
][RCOMP
] * 3.0F
)) << 30);
2075 _mesa_problem(ctx
, "bad type in _mesa_pack_rgba_span_float");
2080 #define SWAP2BYTE(VALUE) \
2082 GLubyte *bytes = (GLubyte *) &(VALUE); \
2083 GLubyte tmp = bytes[0]; \
2084 bytes[0] = bytes[1]; \
2088 #define SWAP4BYTE(VALUE) \
2090 GLubyte *bytes = (GLubyte *) &(VALUE); \
2091 GLubyte tmp = bytes[0]; \
2092 bytes[0] = bytes[3]; \
2095 bytes[1] = bytes[2]; \
2101 extract_uint_indexes(GLuint n
, GLuint indexes
[],
2102 GLenum srcFormat
, GLenum srcType
, const GLvoid
*src
,
2103 const struct gl_pixelstore_attrib
*unpack
)
2105 ASSERT(srcFormat
== GL_COLOR_INDEX
|| srcFormat
== GL_STENCIL_INDEX
);
2107 ASSERT(srcType
== GL_BITMAP
||
2108 srcType
== GL_UNSIGNED_BYTE
||
2109 srcType
== GL_BYTE
||
2110 srcType
== GL_UNSIGNED_SHORT
||
2111 srcType
== GL_SHORT
||
2112 srcType
== GL_UNSIGNED_INT
||
2113 srcType
== GL_INT
||
2114 srcType
== GL_UNSIGNED_INT_24_8_EXT
||
2115 srcType
== GL_HALF_FLOAT_ARB
||
2116 srcType
== GL_FLOAT
);
2121 GLubyte
*ubsrc
= (GLubyte
*) src
;
2122 if (unpack
->LsbFirst
) {
2123 GLubyte mask
= 1 << (unpack
->SkipPixels
& 0x7);
2125 for (i
= 0; i
< n
; i
++) {
2126 indexes
[i
] = (*ubsrc
& mask
) ? 1 : 0;
2137 GLubyte mask
= 128 >> (unpack
->SkipPixels
& 0x7);
2139 for (i
= 0; i
< n
; i
++) {
2140 indexes
[i
] = (*ubsrc
& mask
) ? 1 : 0;
2152 case GL_UNSIGNED_BYTE
:
2155 const GLubyte
*s
= (const GLubyte
*) src
;
2156 for (i
= 0; i
< n
; i
++)
2163 const GLbyte
*s
= (const GLbyte
*) src
;
2164 for (i
= 0; i
< n
; i
++)
2168 case GL_UNSIGNED_SHORT
:
2171 const GLushort
*s
= (const GLushort
*) src
;
2172 if (unpack
->SwapBytes
) {
2173 for (i
= 0; i
< n
; i
++) {
2174 GLushort value
= s
[i
];
2180 for (i
= 0; i
< n
; i
++)
2188 const GLshort
*s
= (const GLshort
*) src
;
2189 if (unpack
->SwapBytes
) {
2190 for (i
= 0; i
< n
; i
++) {
2191 GLshort value
= s
[i
];
2197 for (i
= 0; i
< n
; i
++)
2202 case GL_UNSIGNED_INT
:
2205 const GLuint
*s
= (const GLuint
*) src
;
2206 if (unpack
->SwapBytes
) {
2207 for (i
= 0; i
< n
; i
++) {
2208 GLuint value
= s
[i
];
2214 for (i
= 0; i
< n
; i
++)
2222 const GLint
*s
= (const GLint
*) src
;
2223 if (unpack
->SwapBytes
) {
2224 for (i
= 0; i
< n
; i
++) {
2231 for (i
= 0; i
< n
; i
++)
2239 const GLfloat
*s
= (const GLfloat
*) src
;
2240 if (unpack
->SwapBytes
) {
2241 for (i
= 0; i
< n
; i
++) {
2242 GLfloat value
= s
[i
];
2244 indexes
[i
] = (GLuint
) value
;
2248 for (i
= 0; i
< n
; i
++)
2249 indexes
[i
] = (GLuint
) s
[i
];
2253 case GL_HALF_FLOAT_ARB
:
2256 const GLhalfARB
*s
= (const GLhalfARB
*) src
;
2257 if (unpack
->SwapBytes
) {
2258 for (i
= 0; i
< n
; i
++) {
2259 GLhalfARB value
= s
[i
];
2261 indexes
[i
] = (GLuint
) _mesa_half_to_float(value
);
2265 for (i
= 0; i
< n
; i
++)
2266 indexes
[i
] = (GLuint
) _mesa_half_to_float(s
[i
]);
2270 case GL_UNSIGNED_INT_24_8_EXT
:
2273 const GLuint
*s
= (const GLuint
*) src
;
2274 if (unpack
->SwapBytes
) {
2275 for (i
= 0; i
< n
; i
++) {
2276 GLuint value
= s
[i
];
2278 indexes
[i
] = value
& 0xff; /* lower 8 bits */
2282 for (i
= 0; i
< n
; i
++)
2283 indexes
[i
] = s
[i
] & 0xfff; /* lower 8 bits */
2289 _mesa_problem(NULL
, "bad srcType in extract_uint_indexes");
2296 * This function extracts floating point RGBA values from arbitrary
2297 * image data. srcFormat and srcType are the format and type parameters
2298 * passed to glDrawPixels, glTexImage[123]D, glTexSubImage[123]D, etc.
2300 * Refering to section 3.6.4 of the OpenGL 1.2 spec, this function
2301 * implements the "Conversion to floating point", "Conversion to RGB",
2302 * and "Final Expansion to RGBA" operations.
2304 * Args: n - number of pixels
2305 * rgba - output colors
2306 * srcFormat - format of incoming data
2307 * srcType - data type of incoming data
2308 * src - source data pointer
2309 * swapBytes - perform byteswapping of incoming data?
2312 extract_float_rgba(GLuint n
, GLfloat rgba
[][4],
2313 GLenum srcFormat
, GLenum srcType
, const GLvoid
*src
,
2314 GLboolean swapBytes
)
2316 GLint redIndex
, greenIndex
, blueIndex
, alphaIndex
;
2318 GLint rComp
, bComp
, gComp
, aComp
;
2320 ASSERT(srcFormat
== GL_RED
||
2321 srcFormat
== GL_GREEN
||
2322 srcFormat
== GL_BLUE
||
2323 srcFormat
== GL_ALPHA
||
2324 srcFormat
== GL_LUMINANCE
||
2325 srcFormat
== GL_LUMINANCE_ALPHA
||
2326 srcFormat
== GL_INTENSITY
||
2327 srcFormat
== GL_RGB
||
2328 srcFormat
== GL_BGR
||
2329 srcFormat
== GL_RGBA
||
2330 srcFormat
== GL_BGRA
||
2331 srcFormat
== GL_ABGR_EXT
);
2333 ASSERT(srcType
== GL_UNSIGNED_BYTE
||
2334 srcType
== GL_BYTE
||
2335 srcType
== GL_UNSIGNED_SHORT
||
2336 srcType
== GL_SHORT
||
2337 srcType
== GL_UNSIGNED_INT
||
2338 srcType
== GL_INT
||
2339 srcType
== GL_HALF_FLOAT_ARB
||
2340 srcType
== GL_FLOAT
||
2341 srcType
== GL_UNSIGNED_BYTE_3_3_2
||
2342 srcType
== GL_UNSIGNED_BYTE_2_3_3_REV
||
2343 srcType
== GL_UNSIGNED_SHORT_5_6_5
||
2344 srcType
== GL_UNSIGNED_SHORT_5_6_5_REV
||
2345 srcType
== GL_UNSIGNED_SHORT_4_4_4_4
||
2346 srcType
== GL_UNSIGNED_SHORT_4_4_4_4_REV
||
2347 srcType
== GL_UNSIGNED_SHORT_5_5_5_1
||
2348 srcType
== GL_UNSIGNED_SHORT_1_5_5_5_REV
||
2349 srcType
== GL_UNSIGNED_INT_8_8_8_8
||
2350 srcType
== GL_UNSIGNED_INT_8_8_8_8_REV
||
2351 srcType
== GL_UNSIGNED_INT_10_10_10_2
||
2352 srcType
== GL_UNSIGNED_INT_2_10_10_10_REV
);
2354 rComp
= gComp
= bComp
= aComp
= -1;
2356 switch (srcFormat
) {
2359 greenIndex
= blueIndex
= alphaIndex
= -1;
2364 redIndex
= blueIndex
= alphaIndex
= -1;
2369 redIndex
= greenIndex
= alphaIndex
= -1;
2373 redIndex
= greenIndex
= blueIndex
= -1;
2378 redIndex
= greenIndex
= blueIndex
= 0;
2382 case GL_LUMINANCE_ALPHA
:
2383 redIndex
= greenIndex
= blueIndex
= 0;
2388 redIndex
= greenIndex
= blueIndex
= alphaIndex
= 0;
2447 _mesa_problem(NULL
, "bad srcFormat in extract float data");
2452 #define PROCESS(INDEX, CHANNEL, DEFAULT, TYPE, CONVERSION) \
2453 if ((INDEX) < 0) { \
2455 for (i = 0; i < n; i++) { \
2456 rgba[i][CHANNEL] = DEFAULT; \
2459 else if (swapBytes) { \
2460 const TYPE *s = (const TYPE *) src; \
2462 for (i = 0; i < n; i++) { \
2463 TYPE value = s[INDEX]; \
2464 if (sizeof(TYPE) == 2) { \
2467 else if (sizeof(TYPE) == 4) { \
2470 rgba[i][CHANNEL] = (GLfloat) CONVERSION(value); \
2475 const TYPE *s = (const TYPE *) src; \
2477 for (i = 0; i < n; i++) { \
2478 rgba[i][CHANNEL] = (GLfloat) CONVERSION(s[INDEX]); \
2484 case GL_UNSIGNED_BYTE
:
2485 PROCESS(redIndex
, RCOMP
, 0.0F
, GLubyte
, UBYTE_TO_FLOAT
);
2486 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLubyte
, UBYTE_TO_FLOAT
);
2487 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLubyte
, UBYTE_TO_FLOAT
);
2488 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLubyte
, UBYTE_TO_FLOAT
);
2491 PROCESS(redIndex
, RCOMP
, 0.0F
, GLbyte
, BYTE_TO_FLOAT
);
2492 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLbyte
, BYTE_TO_FLOAT
);
2493 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLbyte
, BYTE_TO_FLOAT
);
2494 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLbyte
, BYTE_TO_FLOAT
);
2496 case GL_UNSIGNED_SHORT
:
2497 PROCESS(redIndex
, RCOMP
, 0.0F
, GLushort
, USHORT_TO_FLOAT
);
2498 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLushort
, USHORT_TO_FLOAT
);
2499 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLushort
, USHORT_TO_FLOAT
);
2500 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLushort
, USHORT_TO_FLOAT
);
2503 PROCESS(redIndex
, RCOMP
, 0.0F
, GLshort
, SHORT_TO_FLOAT
);
2504 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLshort
, SHORT_TO_FLOAT
);
2505 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLshort
, SHORT_TO_FLOAT
);
2506 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLshort
, SHORT_TO_FLOAT
);
2508 case GL_UNSIGNED_INT
:
2509 PROCESS(redIndex
, RCOMP
, 0.0F
, GLuint
, UINT_TO_FLOAT
);
2510 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLuint
, UINT_TO_FLOAT
);
2511 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLuint
, UINT_TO_FLOAT
);
2512 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLuint
, UINT_TO_FLOAT
);
2515 PROCESS(redIndex
, RCOMP
, 0.0F
, GLint
, INT_TO_FLOAT
);
2516 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLint
, INT_TO_FLOAT
);
2517 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLint
, INT_TO_FLOAT
);
2518 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLint
, INT_TO_FLOAT
);
2521 PROCESS(redIndex
, RCOMP
, 0.0F
, GLfloat
, (GLfloat
));
2522 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLfloat
, (GLfloat
));
2523 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLfloat
, (GLfloat
));
2524 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLfloat
, (GLfloat
));
2526 case GL_HALF_FLOAT_ARB
:
2527 PROCESS(redIndex
, RCOMP
, 0.0F
, GLhalfARB
, _mesa_half_to_float
);
2528 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLhalfARB
, _mesa_half_to_float
);
2529 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLhalfARB
, _mesa_half_to_float
);
2530 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLhalfARB
, _mesa_half_to_float
);
2532 case GL_UNSIGNED_BYTE_3_3_2
:
2534 const GLubyte
*ubsrc
= (const GLubyte
*) src
;
2536 for (i
= 0; i
< n
; i
++) {
2537 GLubyte p
= ubsrc
[i
];
2538 rgba
[i
][rComp
] = ((p
>> 5) ) * (1.0F
/ 7.0F
);
2539 rgba
[i
][gComp
] = ((p
>> 2) & 0x7) * (1.0F
/ 7.0F
);
2540 rgba
[i
][bComp
] = ((p
) & 0x3) * (1.0F
/ 3.0F
);
2541 rgba
[i
][aComp
] = 1.0F
;
2545 case GL_UNSIGNED_BYTE_2_3_3_REV
:
2547 const GLubyte
*ubsrc
= (const GLubyte
*) src
;
2549 for (i
= 0; i
< n
; i
++) {
2550 GLubyte p
= ubsrc
[i
];
2551 rgba
[i
][rComp
] = ((p
) & 0x7) * (1.0F
/ 7.0F
);
2552 rgba
[i
][gComp
] = ((p
>> 3) & 0x7) * (1.0F
/ 7.0F
);
2553 rgba
[i
][bComp
] = ((p
>> 6) ) * (1.0F
/ 3.0F
);
2554 rgba
[i
][aComp
] = 1.0F
;
2558 case GL_UNSIGNED_SHORT_5_6_5
:
2560 const GLushort
*ussrc
= (const GLushort
*) src
;
2562 for (i
= 0; i
< n
; i
++) {
2563 GLushort p
= ussrc
[i
];
2565 rgba
[i
][rComp
] = ((p
>> 11) ) * (1.0F
/ 31.0F
);
2566 rgba
[i
][gComp
] = ((p
>> 5) & 0x3f) * (1.0F
/ 63.0F
);
2567 rgba
[i
][bComp
] = ((p
) & 0x1f) * (1.0F
/ 31.0F
);
2568 rgba
[i
][aComp
] = 1.0F
;
2572 const GLushort
*ussrc
= (const GLushort
*) src
;
2574 for (i
= 0; i
< n
; i
++) {
2575 GLushort p
= ussrc
[i
];
2576 rgba
[i
][rComp
] = ((p
>> 11) ) * (1.0F
/ 31.0F
);
2577 rgba
[i
][gComp
] = ((p
>> 5) & 0x3f) * (1.0F
/ 63.0F
);
2578 rgba
[i
][bComp
] = ((p
) & 0x1f) * (1.0F
/ 31.0F
);
2579 rgba
[i
][aComp
] = 1.0F
;
2583 case GL_UNSIGNED_SHORT_5_6_5_REV
:
2585 const GLushort
*ussrc
= (const GLushort
*) src
;
2587 for (i
= 0; i
< n
; i
++) {
2588 GLushort p
= ussrc
[i
];
2590 rgba
[i
][rComp
] = ((p
) & 0x1f) * (1.0F
/ 31.0F
);
2591 rgba
[i
][gComp
] = ((p
>> 5) & 0x3f) * (1.0F
/ 63.0F
);
2592 rgba
[i
][bComp
] = ((p
>> 11) ) * (1.0F
/ 31.0F
);
2593 rgba
[i
][aComp
] = 1.0F
;
2597 const GLushort
*ussrc
= (const GLushort
*) src
;
2599 for (i
= 0; i
< n
; i
++) {
2600 GLushort p
= ussrc
[i
];
2601 rgba
[i
][rComp
] = ((p
) & 0x1f) * (1.0F
/ 31.0F
);
2602 rgba
[i
][gComp
] = ((p
>> 5) & 0x3f) * (1.0F
/ 63.0F
);
2603 rgba
[i
][bComp
] = ((p
>> 11) ) * (1.0F
/ 31.0F
);
2604 rgba
[i
][aComp
] = 1.0F
;
2608 case GL_UNSIGNED_SHORT_4_4_4_4
:
2610 const GLushort
*ussrc
= (const GLushort
*) src
;
2612 for (i
= 0; i
< n
; i
++) {
2613 GLushort p
= ussrc
[i
];
2615 rgba
[i
][rComp
] = ((p
>> 12) ) * (1.0F
/ 15.0F
);
2616 rgba
[i
][gComp
] = ((p
>> 8) & 0xf) * (1.0F
/ 15.0F
);
2617 rgba
[i
][bComp
] = ((p
>> 4) & 0xf) * (1.0F
/ 15.0F
);
2618 rgba
[i
][aComp
] = ((p
) & 0xf) * (1.0F
/ 15.0F
);
2622 const GLushort
*ussrc
= (const GLushort
*) src
;
2624 for (i
= 0; i
< n
; i
++) {
2625 GLushort p
= ussrc
[i
];
2626 rgba
[i
][rComp
] = ((p
>> 12) ) * (1.0F
/ 15.0F
);
2627 rgba
[i
][gComp
] = ((p
>> 8) & 0xf) * (1.0F
/ 15.0F
);
2628 rgba
[i
][bComp
] = ((p
>> 4) & 0xf) * (1.0F
/ 15.0F
);
2629 rgba
[i
][aComp
] = ((p
) & 0xf) * (1.0F
/ 15.0F
);
2633 case GL_UNSIGNED_SHORT_4_4_4_4_REV
:
2635 const GLushort
*ussrc
= (const GLushort
*) src
;
2637 for (i
= 0; i
< n
; i
++) {
2638 GLushort p
= ussrc
[i
];
2640 rgba
[i
][rComp
] = ((p
) & 0xf) * (1.0F
/ 15.0F
);
2641 rgba
[i
][gComp
] = ((p
>> 4) & 0xf) * (1.0F
/ 15.0F
);
2642 rgba
[i
][bComp
] = ((p
>> 8) & 0xf) * (1.0F
/ 15.0F
);
2643 rgba
[i
][aComp
] = ((p
>> 12) ) * (1.0F
/ 15.0F
);
2647 const GLushort
*ussrc
= (const GLushort
*) src
;
2649 for (i
= 0; i
< n
; i
++) {
2650 GLushort p
= ussrc
[i
];
2651 rgba
[i
][rComp
] = ((p
) & 0xf) * (1.0F
/ 15.0F
);
2652 rgba
[i
][gComp
] = ((p
>> 4) & 0xf) * (1.0F
/ 15.0F
);
2653 rgba
[i
][bComp
] = ((p
>> 8) & 0xf) * (1.0F
/ 15.0F
);
2654 rgba
[i
][aComp
] = ((p
>> 12) ) * (1.0F
/ 15.0F
);
2658 case GL_UNSIGNED_SHORT_5_5_5_1
:
2660 const GLushort
*ussrc
= (const GLushort
*) src
;
2662 for (i
= 0; i
< n
; i
++) {
2663 GLushort p
= ussrc
[i
];
2665 rgba
[i
][rComp
] = ((p
>> 11) ) * (1.0F
/ 31.0F
);
2666 rgba
[i
][gComp
] = ((p
>> 6) & 0x1f) * (1.0F
/ 31.0F
);
2667 rgba
[i
][bComp
] = ((p
>> 1) & 0x1f) * (1.0F
/ 31.0F
);
2668 rgba
[i
][aComp
] = ((p
) & 0x1) * (1.0F
/ 1.0F
);
2672 const GLushort
*ussrc
= (const GLushort
*) src
;
2674 for (i
= 0; i
< n
; i
++) {
2675 GLushort p
= ussrc
[i
];
2676 rgba
[i
][rComp
] = ((p
>> 11) ) * (1.0F
/ 31.0F
);
2677 rgba
[i
][gComp
] = ((p
>> 6) & 0x1f) * (1.0F
/ 31.0F
);
2678 rgba
[i
][bComp
] = ((p
>> 1) & 0x1f) * (1.0F
/ 31.0F
);
2679 rgba
[i
][aComp
] = ((p
) & 0x1) * (1.0F
/ 1.0F
);
2683 case GL_UNSIGNED_SHORT_1_5_5_5_REV
:
2685 const GLushort
*ussrc
= (const GLushort
*) src
;
2687 for (i
= 0; i
< n
; i
++) {
2688 GLushort p
= ussrc
[i
];
2690 rgba
[i
][rComp
] = ((p
) & 0x1f) * (1.0F
/ 31.0F
);
2691 rgba
[i
][gComp
] = ((p
>> 5) & 0x1f) * (1.0F
/ 31.0F
);
2692 rgba
[i
][bComp
] = ((p
>> 10) & 0x1f) * (1.0F
/ 31.0F
);
2693 rgba
[i
][aComp
] = ((p
>> 15) ) * (1.0F
/ 1.0F
);
2697 const GLushort
*ussrc
= (const GLushort
*) src
;
2699 for (i
= 0; i
< n
; i
++) {
2700 GLushort p
= ussrc
[i
];
2701 rgba
[i
][rComp
] = ((p
) & 0x1f) * (1.0F
/ 31.0F
);
2702 rgba
[i
][gComp
] = ((p
>> 5) & 0x1f) * (1.0F
/ 31.0F
);
2703 rgba
[i
][bComp
] = ((p
>> 10) & 0x1f) * (1.0F
/ 31.0F
);
2704 rgba
[i
][aComp
] = ((p
>> 15) ) * (1.0F
/ 1.0F
);
2708 case GL_UNSIGNED_INT_8_8_8_8
:
2710 const GLuint
*uisrc
= (const GLuint
*) src
;
2712 for (i
= 0; i
< n
; i
++) {
2713 GLuint p
= uisrc
[i
];
2714 rgba
[i
][rComp
] = UBYTE_TO_FLOAT((p
) & 0xff);
2715 rgba
[i
][gComp
] = UBYTE_TO_FLOAT((p
>> 8) & 0xff);
2716 rgba
[i
][bComp
] = UBYTE_TO_FLOAT((p
>> 16) & 0xff);
2717 rgba
[i
][aComp
] = UBYTE_TO_FLOAT((p
>> 24) );
2721 const GLuint
*uisrc
= (const GLuint
*) src
;
2723 for (i
= 0; i
< n
; i
++) {
2724 GLuint p
= uisrc
[i
];
2725 rgba
[i
][rComp
] = UBYTE_TO_FLOAT((p
>> 24) );
2726 rgba
[i
][gComp
] = UBYTE_TO_FLOAT((p
>> 16) & 0xff);
2727 rgba
[i
][bComp
] = UBYTE_TO_FLOAT((p
>> 8) & 0xff);
2728 rgba
[i
][aComp
] = UBYTE_TO_FLOAT((p
) & 0xff);
2732 case GL_UNSIGNED_INT_8_8_8_8_REV
:
2734 const GLuint
*uisrc
= (const GLuint
*) src
;
2736 for (i
= 0; i
< n
; i
++) {
2737 GLuint p
= uisrc
[i
];
2738 rgba
[i
][rComp
] = UBYTE_TO_FLOAT((p
>> 24) );
2739 rgba
[i
][gComp
] = UBYTE_TO_FLOAT((p
>> 16) & 0xff);
2740 rgba
[i
][bComp
] = UBYTE_TO_FLOAT((p
>> 8) & 0xff);
2741 rgba
[i
][aComp
] = UBYTE_TO_FLOAT((p
) & 0xff);
2745 const GLuint
*uisrc
= (const GLuint
*) src
;
2747 for (i
= 0; i
< n
; i
++) {
2748 GLuint p
= uisrc
[i
];
2749 rgba
[i
][rComp
] = UBYTE_TO_FLOAT((p
) & 0xff);
2750 rgba
[i
][gComp
] = UBYTE_TO_FLOAT((p
>> 8) & 0xff);
2751 rgba
[i
][bComp
] = UBYTE_TO_FLOAT((p
>> 16) & 0xff);
2752 rgba
[i
][aComp
] = UBYTE_TO_FLOAT((p
>> 24) );
2756 case GL_UNSIGNED_INT_10_10_10_2
:
2758 const GLuint
*uisrc
= (const GLuint
*) src
;
2760 for (i
= 0; i
< n
; i
++) {
2761 GLuint p
= uisrc
[i
];
2763 rgba
[i
][rComp
] = ((p
>> 22) ) * (1.0F
/ 1023.0F
);
2764 rgba
[i
][gComp
] = ((p
>> 12) & 0x3ff) * (1.0F
/ 1023.0F
);
2765 rgba
[i
][bComp
] = ((p
>> 2) & 0x3ff) * (1.0F
/ 1023.0F
);
2766 rgba
[i
][aComp
] = ((p
) & 0x3 ) * (1.0F
/ 3.0F
);
2770 const GLuint
*uisrc
= (const GLuint
*) src
;
2772 for (i
= 0; i
< n
; i
++) {
2773 GLuint p
= uisrc
[i
];
2774 rgba
[i
][rComp
] = ((p
>> 22) ) * (1.0F
/ 1023.0F
);
2775 rgba
[i
][gComp
] = ((p
>> 12) & 0x3ff) * (1.0F
/ 1023.0F
);
2776 rgba
[i
][bComp
] = ((p
>> 2) & 0x3ff) * (1.0F
/ 1023.0F
);
2777 rgba
[i
][aComp
] = ((p
) & 0x3 ) * (1.0F
/ 3.0F
);
2781 case GL_UNSIGNED_INT_2_10_10_10_REV
:
2783 const GLuint
*uisrc
= (const GLuint
*) src
;
2785 for (i
= 0; i
< n
; i
++) {
2786 GLuint p
= uisrc
[i
];
2788 rgba
[i
][rComp
] = ((p
) & 0x3ff) * (1.0F
/ 1023.0F
);
2789 rgba
[i
][gComp
] = ((p
>> 10) & 0x3ff) * (1.0F
/ 1023.0F
);
2790 rgba
[i
][bComp
] = ((p
>> 20) & 0x3ff) * (1.0F
/ 1023.0F
);
2791 rgba
[i
][aComp
] = ((p
>> 30) ) * (1.0F
/ 3.0F
);
2795 const GLuint
*uisrc
= (const GLuint
*) src
;
2797 for (i
= 0; i
< n
; i
++) {
2798 GLuint p
= uisrc
[i
];
2799 rgba
[i
][rComp
] = ((p
) & 0x3ff) * (1.0F
/ 1023.0F
);
2800 rgba
[i
][gComp
] = ((p
>> 10) & 0x3ff) * (1.0F
/ 1023.0F
);
2801 rgba
[i
][bComp
] = ((p
>> 20) & 0x3ff) * (1.0F
/ 1023.0F
);
2802 rgba
[i
][aComp
] = ((p
>> 30) ) * (1.0F
/ 3.0F
);
2807 _mesa_problem(NULL
, "bad srcType in extract float data");
2814 * Unpack a row of color image data from a client buffer according to
2815 * the pixel unpacking parameters.
2816 * Return GLchan values in the specified dest image format.
2817 * This is used by glDrawPixels and glTexImage?D().
2818 * \param ctx - the context
2819 * n - number of pixels in the span
2820 * dstFormat - format of destination color array
2821 * dest - the destination color array
2822 * srcFormat - source image format
2823 * srcType - source image data type
2824 * source - source image pointer
2825 * srcPacking - pixel unpacking parameters
2826 * transferOps - bitmask of IMAGE_*_BIT values of operations to apply
2828 * XXX perhaps expand this to process whole images someday.
2831 _mesa_unpack_color_span_chan( GLcontext
*ctx
,
2832 GLuint n
, GLenum dstFormat
, GLchan dest
[],
2833 GLenum srcFormat
, GLenum srcType
,
2834 const GLvoid
*source
,
2835 const struct gl_pixelstore_attrib
*srcPacking
,
2836 GLbitfield transferOps
)
2838 ASSERT(dstFormat
== GL_ALPHA
||
2839 dstFormat
== GL_LUMINANCE
||
2840 dstFormat
== GL_LUMINANCE_ALPHA
||
2841 dstFormat
== GL_INTENSITY
||
2842 dstFormat
== GL_RGB
||
2843 dstFormat
== GL_RGBA
||
2844 dstFormat
== GL_COLOR_INDEX
);
2846 ASSERT(srcFormat
== GL_RED
||
2847 srcFormat
== GL_GREEN
||
2848 srcFormat
== GL_BLUE
||
2849 srcFormat
== GL_ALPHA
||
2850 srcFormat
== GL_LUMINANCE
||
2851 srcFormat
== GL_LUMINANCE_ALPHA
||
2852 srcFormat
== GL_INTENSITY
||
2853 srcFormat
== GL_RGB
||
2854 srcFormat
== GL_BGR
||
2855 srcFormat
== GL_RGBA
||
2856 srcFormat
== GL_BGRA
||
2857 srcFormat
== GL_ABGR_EXT
||
2858 srcFormat
== GL_COLOR_INDEX
);
2860 ASSERT(srcType
== GL_BITMAP
||
2861 srcType
== GL_UNSIGNED_BYTE
||
2862 srcType
== GL_BYTE
||
2863 srcType
== GL_UNSIGNED_SHORT
||
2864 srcType
== GL_SHORT
||
2865 srcType
== GL_UNSIGNED_INT
||
2866 srcType
== GL_INT
||
2867 srcType
== GL_HALF_FLOAT_ARB
||
2868 srcType
== GL_FLOAT
||
2869 srcType
== GL_UNSIGNED_BYTE_3_3_2
||
2870 srcType
== GL_UNSIGNED_BYTE_2_3_3_REV
||
2871 srcType
== GL_UNSIGNED_SHORT_5_6_5
||
2872 srcType
== GL_UNSIGNED_SHORT_5_6_5_REV
||
2873 srcType
== GL_UNSIGNED_SHORT_4_4_4_4
||
2874 srcType
== GL_UNSIGNED_SHORT_4_4_4_4_REV
||
2875 srcType
== GL_UNSIGNED_SHORT_5_5_5_1
||
2876 srcType
== GL_UNSIGNED_SHORT_1_5_5_5_REV
||
2877 srcType
== GL_UNSIGNED_INT_8_8_8_8
||
2878 srcType
== GL_UNSIGNED_INT_8_8_8_8_REV
||
2879 srcType
== GL_UNSIGNED_INT_10_10_10_2
||
2880 srcType
== GL_UNSIGNED_INT_2_10_10_10_REV
);
2882 /* Try simple cases first */
2883 if (transferOps
== 0) {
2884 if (srcType
== CHAN_TYPE
) {
2885 if (dstFormat
== GL_RGBA
) {
2886 if (srcFormat
== GL_RGBA
) {
2887 _mesa_memcpy( dest
, source
, n
* 4 * sizeof(GLchan
) );
2890 else if (srcFormat
== GL_RGB
) {
2892 const GLchan
*src
= (const GLchan
*) source
;
2894 for (i
= 0; i
< n
; i
++) {
2905 else if (dstFormat
== GL_RGB
) {
2906 if (srcFormat
== GL_RGB
) {
2907 _mesa_memcpy( dest
, source
, n
* 3 * sizeof(GLchan
) );
2910 else if (srcFormat
== GL_RGBA
) {
2912 const GLchan
*src
= (const GLchan
*) source
;
2914 for (i
= 0; i
< n
; i
++) {
2924 else if (dstFormat
== srcFormat
) {
2925 GLint comps
= _mesa_components_in_format(srcFormat
);
2927 _mesa_memcpy( dest
, source
, n
* comps
* sizeof(GLchan
) );
2932 * Common situation, loading 8bit RGBA/RGB source images
2933 * into 16/32 bit destination. (OSMesa16/32)
2935 else if (srcType
== GL_UNSIGNED_BYTE
) {
2936 if (dstFormat
== GL_RGBA
) {
2937 if (srcFormat
== GL_RGB
) {
2939 const GLubyte
*src
= (const GLubyte
*) source
;
2941 for (i
= 0; i
< n
; i
++) {
2942 dst
[0] = UBYTE_TO_CHAN(src
[0]);
2943 dst
[1] = UBYTE_TO_CHAN(src
[1]);
2944 dst
[2] = UBYTE_TO_CHAN(src
[2]);
2951 else if (srcFormat
== GL_RGBA
) {
2953 const GLubyte
*src
= (const GLubyte
*) source
;
2955 for (i
= 0; i
< n
; i
++) {
2956 dst
[0] = UBYTE_TO_CHAN(src
[0]);
2957 dst
[1] = UBYTE_TO_CHAN(src
[1]);
2958 dst
[2] = UBYTE_TO_CHAN(src
[2]);
2959 dst
[3] = UBYTE_TO_CHAN(src
[3]);
2966 else if (dstFormat
== GL_RGB
) {
2967 if (srcFormat
== GL_RGB
) {
2969 const GLubyte
*src
= (const GLubyte
*) source
;
2971 for (i
= 0; i
< n
; i
++) {
2972 dst
[0] = UBYTE_TO_CHAN(src
[0]);
2973 dst
[1] = UBYTE_TO_CHAN(src
[1]);
2974 dst
[2] = UBYTE_TO_CHAN(src
[2]);
2980 else if (srcFormat
== GL_RGBA
) {
2982 const GLubyte
*src
= (const GLubyte
*) source
;
2984 for (i
= 0; i
< n
; i
++) {
2985 dst
[0] = UBYTE_TO_CHAN(src
[0]);
2986 dst
[1] = UBYTE_TO_CHAN(src
[1]);
2987 dst
[2] = UBYTE_TO_CHAN(src
[2]);
2998 /* general solution begins here */
3000 GLint dstComponents
;
3001 GLint dstRedIndex
, dstGreenIndex
, dstBlueIndex
, dstAlphaIndex
;
3002 GLint dstLuminanceIndex
, dstIntensityIndex
;
3003 GLfloat rgba
[MAX_WIDTH
][4];
3005 dstComponents
= _mesa_components_in_format( dstFormat
);
3006 /* source & dest image formats should have been error checked by now */
3007 assert(dstComponents
> 0);
3010 * Extract image data and convert to RGBA floats
3012 assert(n
<= MAX_WIDTH
);
3013 if (srcFormat
== GL_COLOR_INDEX
) {
3014 GLuint indexes
[MAX_WIDTH
];
3015 extract_uint_indexes(n
, indexes
, srcFormat
, srcType
, source
,
3018 if (dstFormat
== GL_COLOR_INDEX
) {
3020 _mesa_apply_ci_transfer_ops(ctx
, transferOps
, n
, indexes
);
3021 /* convert to GLchan and return */
3022 for (i
= 0; i
< n
; i
++) {
3023 dest
[i
] = (GLchan
) (indexes
[i
] & 0xff);
3028 /* Convert indexes to RGBA */
3029 if (transferOps
& IMAGE_SHIFT_OFFSET_BIT
) {
3030 shift_and_offset_ci(ctx
, n
, indexes
);
3032 _mesa_map_ci_to_rgba(ctx
, n
, indexes
, rgba
);
3035 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
3036 * with color indexes.
3038 transferOps
&= ~(IMAGE_SCALE_BIAS_BIT
| IMAGE_MAP_COLOR_BIT
);
3041 /* non-color index data */
3042 extract_float_rgba(n
, rgba
, srcFormat
, srcType
, source
,
3043 srcPacking
->SwapBytes
);
3046 /* Need to clamp if returning GLubytes or GLushorts */
3047 #if CHAN_TYPE != GL_FLOAT
3048 transferOps
|= IMAGE_CLAMP_BIT
;
3052 _mesa_apply_rgba_transfer_ops(ctx
, transferOps
, n
, rgba
);
3055 /* Now determine which color channels we need to produce.
3056 * And determine the dest index (offset) within each color tuple.
3058 switch (dstFormat
) {
3061 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= -1;
3062 dstLuminanceIndex
= dstIntensityIndex
= -1;
3065 dstLuminanceIndex
= 0;
3066 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= dstAlphaIndex
= -1;
3067 dstIntensityIndex
= -1;
3069 case GL_LUMINANCE_ALPHA
:
3070 dstLuminanceIndex
= 0;
3072 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= -1;
3073 dstIntensityIndex
= -1;
3076 dstIntensityIndex
= 0;
3077 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= dstAlphaIndex
= -1;
3078 dstLuminanceIndex
= -1;
3084 dstAlphaIndex
= dstLuminanceIndex
= dstIntensityIndex
= -1;
3091 dstLuminanceIndex
= dstIntensityIndex
= -1;
3094 _mesa_problem(ctx
, "bad dstFormat in _mesa_unpack_chan_span()");
3099 /* Now return the GLchan data in the requested dstFormat */
3101 if (dstRedIndex
>= 0) {
3104 for (i
= 0; i
< n
; i
++) {
3105 CLAMPED_FLOAT_TO_CHAN(dst
[dstRedIndex
], rgba
[i
][RCOMP
]);
3106 dst
+= dstComponents
;
3110 if (dstGreenIndex
>= 0) {
3113 for (i
= 0; i
< n
; i
++) {
3114 CLAMPED_FLOAT_TO_CHAN(dst
[dstGreenIndex
], rgba
[i
][GCOMP
]);
3115 dst
+= dstComponents
;
3119 if (dstBlueIndex
>= 0) {
3122 for (i
= 0; i
< n
; i
++) {
3123 CLAMPED_FLOAT_TO_CHAN(dst
[dstBlueIndex
], rgba
[i
][BCOMP
]);
3124 dst
+= dstComponents
;
3128 if (dstAlphaIndex
>= 0) {
3131 for (i
= 0; i
< n
; i
++) {
3132 CLAMPED_FLOAT_TO_CHAN(dst
[dstAlphaIndex
], rgba
[i
][ACOMP
]);
3133 dst
+= dstComponents
;
3137 if (dstIntensityIndex
>= 0) {
3140 assert(dstIntensityIndex
== 0);
3141 assert(dstComponents
== 1);
3142 for (i
= 0; i
< n
; i
++) {
3143 /* Intensity comes from red channel */
3144 CLAMPED_FLOAT_TO_CHAN(dst
[i
], rgba
[i
][RCOMP
]);
3148 if (dstLuminanceIndex
>= 0) {
3151 assert(dstLuminanceIndex
== 0);
3152 for (i
= 0; i
< n
; i
++) {
3153 /* Luminance comes from red channel */
3154 CLAMPED_FLOAT_TO_CHAN(dst
[0], rgba
[i
][RCOMP
]);
3155 dst
+= dstComponents
;
3163 * Same as _mesa_unpack_color_span_chan(), but return GLfloat data
3164 * instead of GLchan.
3167 _mesa_unpack_color_span_float( GLcontext
*ctx
,
3168 GLuint n
, GLenum dstFormat
, GLfloat dest
[],
3169 GLenum srcFormat
, GLenum srcType
,
3170 const GLvoid
*source
,
3171 const struct gl_pixelstore_attrib
*srcPacking
,
3172 GLbitfield transferOps
)
3174 ASSERT(dstFormat
== GL_ALPHA
||
3175 dstFormat
== GL_LUMINANCE
||
3176 dstFormat
== GL_LUMINANCE_ALPHA
||
3177 dstFormat
== GL_INTENSITY
||
3178 dstFormat
== GL_RGB
||
3179 dstFormat
== GL_RGBA
||
3180 dstFormat
== GL_COLOR_INDEX
);
3182 ASSERT(srcFormat
== GL_RED
||
3183 srcFormat
== GL_GREEN
||
3184 srcFormat
== GL_BLUE
||
3185 srcFormat
== GL_ALPHA
||
3186 srcFormat
== GL_LUMINANCE
||
3187 srcFormat
== GL_LUMINANCE_ALPHA
||
3188 srcFormat
== GL_INTENSITY
||
3189 srcFormat
== GL_RGB
||
3190 srcFormat
== GL_BGR
||
3191 srcFormat
== GL_RGBA
||
3192 srcFormat
== GL_BGRA
||
3193 srcFormat
== GL_ABGR_EXT
||
3194 srcFormat
== GL_COLOR_INDEX
);
3196 ASSERT(srcType
== GL_BITMAP
||
3197 srcType
== GL_UNSIGNED_BYTE
||
3198 srcType
== GL_BYTE
||
3199 srcType
== GL_UNSIGNED_SHORT
||
3200 srcType
== GL_SHORT
||
3201 srcType
== GL_UNSIGNED_INT
||
3202 srcType
== GL_INT
||
3203 srcType
== GL_HALF_FLOAT_ARB
||
3204 srcType
== GL_FLOAT
||
3205 srcType
== GL_UNSIGNED_BYTE_3_3_2
||
3206 srcType
== GL_UNSIGNED_BYTE_2_3_3_REV
||
3207 srcType
== GL_UNSIGNED_SHORT_5_6_5
||
3208 srcType
== GL_UNSIGNED_SHORT_5_6_5_REV
||
3209 srcType
== GL_UNSIGNED_SHORT_4_4_4_4
||
3210 srcType
== GL_UNSIGNED_SHORT_4_4_4_4_REV
||
3211 srcType
== GL_UNSIGNED_SHORT_5_5_5_1
||
3212 srcType
== GL_UNSIGNED_SHORT_1_5_5_5_REV
||
3213 srcType
== GL_UNSIGNED_INT_8_8_8_8
||
3214 srcType
== GL_UNSIGNED_INT_8_8_8_8_REV
||
3215 srcType
== GL_UNSIGNED_INT_10_10_10_2
||
3216 srcType
== GL_UNSIGNED_INT_2_10_10_10_REV
);
3218 /* general solution, no special cases, yet */
3220 GLint dstComponents
;
3221 GLint dstRedIndex
, dstGreenIndex
, dstBlueIndex
, dstAlphaIndex
;
3222 GLint dstLuminanceIndex
, dstIntensityIndex
;
3223 GLfloat rgba
[MAX_WIDTH
][4];
3225 dstComponents
= _mesa_components_in_format( dstFormat
);
3226 /* source & dest image formats should have been error checked by now */
3227 assert(dstComponents
> 0);
3230 * Extract image data and convert to RGBA floats
3232 assert(n
<= MAX_WIDTH
);
3233 if (srcFormat
== GL_COLOR_INDEX
) {
3234 GLuint indexes
[MAX_WIDTH
];
3235 extract_uint_indexes(n
, indexes
, srcFormat
, srcType
, source
,
3238 if (dstFormat
== GL_COLOR_INDEX
) {
3240 _mesa_apply_ci_transfer_ops(ctx
, transferOps
, n
, indexes
);
3241 /* convert to GLchan and return */
3242 for (i
= 0; i
< n
; i
++) {
3243 dest
[i
] = (GLchan
) (indexes
[i
] & 0xff);
3248 /* Convert indexes to RGBA */
3249 if (transferOps
& IMAGE_SHIFT_OFFSET_BIT
) {
3250 shift_and_offset_ci(ctx
, n
, indexes
);
3252 _mesa_map_ci_to_rgba(ctx
, n
, indexes
, rgba
);
3255 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
3256 * with color indexes.
3258 transferOps
&= ~(IMAGE_SCALE_BIAS_BIT
| IMAGE_MAP_COLOR_BIT
);
3261 /* non-color index data */
3262 extract_float_rgba(n
, rgba
, srcFormat
, srcType
, source
,
3263 srcPacking
->SwapBytes
);
3267 _mesa_apply_rgba_transfer_ops(ctx
, transferOps
, n
, rgba
);
3270 /* Now determine which color channels we need to produce.
3271 * And determine the dest index (offset) within each color tuple.
3273 switch (dstFormat
) {
3276 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= -1;
3277 dstLuminanceIndex
= dstIntensityIndex
= -1;
3280 dstLuminanceIndex
= 0;
3281 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= dstAlphaIndex
= -1;
3282 dstIntensityIndex
= -1;
3284 case GL_LUMINANCE_ALPHA
:
3285 dstLuminanceIndex
= 0;
3287 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= -1;
3288 dstIntensityIndex
= -1;
3291 dstIntensityIndex
= 0;
3292 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= dstAlphaIndex
= -1;
3293 dstLuminanceIndex
= -1;
3299 dstAlphaIndex
= dstLuminanceIndex
= dstIntensityIndex
= -1;
3306 dstLuminanceIndex
= dstIntensityIndex
= -1;
3309 _mesa_problem(ctx
, "bad dstFormat in _mesa_unpack_color_span_float()");
3313 /* Now pack results in the requested dstFormat */
3314 if (dstRedIndex
>= 0) {
3315 GLfloat
*dst
= dest
;
3317 for (i
= 0; i
< n
; i
++) {
3318 dst
[dstRedIndex
] = rgba
[i
][RCOMP
];
3319 dst
+= dstComponents
;
3323 if (dstGreenIndex
>= 0) {
3324 GLfloat
*dst
= dest
;
3326 for (i
= 0; i
< n
; i
++) {
3327 dst
[dstGreenIndex
] = rgba
[i
][GCOMP
];
3328 dst
+= dstComponents
;
3332 if (dstBlueIndex
>= 0) {
3333 GLfloat
*dst
= dest
;
3335 for (i
= 0; i
< n
; i
++) {
3336 dst
[dstBlueIndex
] = rgba
[i
][BCOMP
];
3337 dst
+= dstComponents
;
3341 if (dstAlphaIndex
>= 0) {
3342 GLfloat
*dst
= dest
;
3344 for (i
= 0; i
< n
; i
++) {
3345 dst
[dstAlphaIndex
] = rgba
[i
][ACOMP
];
3346 dst
+= dstComponents
;
3350 if (dstIntensityIndex
>= 0) {
3351 GLfloat
*dst
= dest
;
3353 assert(dstIntensityIndex
== 0);
3354 assert(dstComponents
== 1);
3355 for (i
= 0; i
< n
; i
++) {
3356 /* Intensity comes from red channel */
3357 dst
[i
] = rgba
[i
][RCOMP
];
3361 if (dstLuminanceIndex
>= 0) {
3362 GLfloat
*dst
= dest
;
3364 assert(dstLuminanceIndex
== 0);
3365 for (i
= 0; i
< n
; i
++) {
3366 /* Luminance comes from red channel */
3367 dst
[0] = rgba
[i
][RCOMP
];
3368 dst
+= dstComponents
;
3376 * Unpack a row of color index data from a client buffer according to
3377 * the pixel unpacking parameters.
3378 * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.
3380 * Args: ctx - the context
3381 * n - number of pixels
3382 * dstType - destination data type
3383 * dest - destination array
3384 * srcType - source pixel type
3385 * source - source data pointer
3386 * srcPacking - pixel unpacking parameters
3387 * transferOps - the pixel transfer operations to apply
3390 _mesa_unpack_index_span( const GLcontext
*ctx
, GLuint n
,
3391 GLenum dstType
, GLvoid
*dest
,
3392 GLenum srcType
, const GLvoid
*source
,
3393 const struct gl_pixelstore_attrib
*srcPacking
,
3394 GLbitfield transferOps
)
3396 ASSERT(srcType
== GL_BITMAP
||
3397 srcType
== GL_UNSIGNED_BYTE
||
3398 srcType
== GL_BYTE
||
3399 srcType
== GL_UNSIGNED_SHORT
||
3400 srcType
== GL_SHORT
||
3401 srcType
== GL_UNSIGNED_INT
||
3402 srcType
== GL_INT
||
3403 srcType
== GL_HALF_FLOAT_ARB
||
3404 srcType
== GL_FLOAT
);
3406 ASSERT(dstType
== GL_UNSIGNED_BYTE
||
3407 dstType
== GL_UNSIGNED_SHORT
||
3408 dstType
== GL_UNSIGNED_INT
);
3411 transferOps
&= (IMAGE_MAP_COLOR_BIT
| IMAGE_SHIFT_OFFSET_BIT
);
3414 * Try simple cases first
3416 if (transferOps
== 0 && srcType
== GL_UNSIGNED_BYTE
3417 && dstType
== GL_UNSIGNED_BYTE
) {
3418 _mesa_memcpy(dest
, source
, n
* sizeof(GLubyte
));
3420 else if (transferOps
== 0 && srcType
== GL_UNSIGNED_INT
3421 && dstType
== GL_UNSIGNED_INT
&& !srcPacking
->SwapBytes
) {
3422 _mesa_memcpy(dest
, source
, n
* sizeof(GLuint
));
3428 GLuint indexes
[MAX_WIDTH
];
3429 assert(n
<= MAX_WIDTH
);
3431 extract_uint_indexes(n
, indexes
, GL_COLOR_INDEX
, srcType
, source
,
3435 _mesa_apply_ci_transfer_ops(ctx
, transferOps
, n
, indexes
);
3437 /* convert to dest type */
3439 case GL_UNSIGNED_BYTE
:
3441 GLubyte
*dst
= (GLubyte
*) dest
;
3443 for (i
= 0; i
< n
; i
++) {
3444 dst
[i
] = (GLubyte
) (indexes
[i
] & 0xff);
3448 case GL_UNSIGNED_SHORT
:
3450 GLuint
*dst
= (GLuint
*) dest
;
3452 for (i
= 0; i
< n
; i
++) {
3453 dst
[i
] = (GLushort
) (indexes
[i
] & 0xffff);
3457 case GL_UNSIGNED_INT
:
3458 _mesa_memcpy(dest
, indexes
, n
* sizeof(GLuint
));
3461 _mesa_problem(ctx
, "bad dstType in _mesa_unpack_index_span");
3468 _mesa_pack_index_span( const GLcontext
*ctx
, GLuint n
,
3469 GLenum dstType
, GLvoid
*dest
, const GLuint
*source
,
3470 const struct gl_pixelstore_attrib
*dstPacking
,
3471 GLbitfield transferOps
)
3473 GLuint indexes
[MAX_WIDTH
];
3475 ASSERT(n
<= MAX_WIDTH
);
3477 transferOps
&= (IMAGE_MAP_COLOR_BIT
| IMAGE_SHIFT_OFFSET_BIT
);
3479 if (transferOps
& (IMAGE_MAP_COLOR_BIT
| IMAGE_SHIFT_OFFSET_BIT
)) {
3480 /* make a copy of input */
3481 _mesa_memcpy(indexes
, source
, n
* sizeof(GLuint
));
3482 _mesa_apply_ci_transfer_ops(ctx
, transferOps
, n
, indexes
);
3487 case GL_UNSIGNED_BYTE
:
3489 GLubyte
*dst
= (GLubyte
*) dest
;
3491 for (i
= 0; i
< n
; i
++) {
3492 *dst
++ = (GLubyte
) source
[i
];
3498 GLbyte
*dst
= (GLbyte
*) dest
;
3500 for (i
= 0; i
< n
; i
++) {
3501 dst
[i
] = (GLbyte
) source
[i
];
3505 case GL_UNSIGNED_SHORT
:
3507 GLushort
*dst
= (GLushort
*) dest
;
3509 for (i
= 0; i
< n
; i
++) {
3510 dst
[i
] = (GLushort
) source
[i
];
3512 if (dstPacking
->SwapBytes
) {
3513 _mesa_swap2( (GLushort
*) dst
, n
);
3519 GLshort
*dst
= (GLshort
*) dest
;
3521 for (i
= 0; i
< n
; i
++) {
3522 dst
[i
] = (GLshort
) source
[i
];
3524 if (dstPacking
->SwapBytes
) {
3525 _mesa_swap2( (GLushort
*) dst
, n
);
3529 case GL_UNSIGNED_INT
:
3531 GLuint
*dst
= (GLuint
*) dest
;
3533 for (i
= 0; i
< n
; i
++) {
3534 dst
[i
] = (GLuint
) source
[i
];
3536 if (dstPacking
->SwapBytes
) {
3537 _mesa_swap4( (GLuint
*) dst
, n
);
3543 GLint
*dst
= (GLint
*) dest
;
3545 for (i
= 0; i
< n
; i
++) {
3546 dst
[i
] = (GLint
) source
[i
];
3548 if (dstPacking
->SwapBytes
) {
3549 _mesa_swap4( (GLuint
*) dst
, n
);
3555 GLfloat
*dst
= (GLfloat
*) dest
;
3557 for (i
= 0; i
< n
; i
++) {
3558 dst
[i
] = (GLfloat
) source
[i
];
3560 if (dstPacking
->SwapBytes
) {
3561 _mesa_swap4( (GLuint
*) dst
, n
);
3565 case GL_HALF_FLOAT_ARB
:
3567 GLhalfARB
*dst
= (GLhalfARB
*) dest
;
3569 for (i
= 0; i
< n
; i
++) {
3570 dst
[i
] = _mesa_float_to_half((GLfloat
) source
[i
]);
3572 if (dstPacking
->SwapBytes
) {
3573 _mesa_swap2( (GLushort
*) dst
, n
);
3578 _mesa_problem(ctx
, "bad type in _mesa_pack_index_span");
3584 * Unpack a row of stencil data from a client buffer according to
3585 * the pixel unpacking parameters.
3586 * This is (or will be) used by glDrawPixels
3588 * Args: ctx - the context
3589 * n - number of pixels
3590 * dstType - destination data type
3591 * dest - destination array
3592 * srcType - source pixel type
3593 * source - source data pointer
3594 * srcPacking - pixel unpacking parameters
3595 * transferOps - apply offset/bias/lookup ops?
3598 _mesa_unpack_stencil_span( const GLcontext
*ctx
, GLuint n
,
3599 GLenum dstType
, GLvoid
*dest
,
3600 GLenum srcType
, const GLvoid
*source
,
3601 const struct gl_pixelstore_attrib
*srcPacking
,
3602 GLbitfield transferOps
)
3604 ASSERT(srcType
== GL_BITMAP
||
3605 srcType
== GL_UNSIGNED_BYTE
||
3606 srcType
== GL_BYTE
||
3607 srcType
== GL_UNSIGNED_SHORT
||
3608 srcType
== GL_SHORT
||
3609 srcType
== GL_UNSIGNED_INT
||
3610 srcType
== GL_INT
||
3611 srcType
== GL_UNSIGNED_INT_24_8_EXT
||
3612 srcType
== GL_HALF_FLOAT_ARB
||
3613 srcType
== GL_FLOAT
);
3615 ASSERT(dstType
== GL_UNSIGNED_BYTE
||
3616 dstType
== GL_UNSIGNED_SHORT
||
3617 dstType
== GL_UNSIGNED_INT
);
3619 /* only shift and offset apply to stencil */
3620 transferOps
&= IMAGE_SHIFT_OFFSET_BIT
;
3623 * Try simple cases first
3625 if (transferOps
== 0 &&
3626 srcType
== GL_UNSIGNED_BYTE
&&
3627 dstType
== GL_UNSIGNED_BYTE
) {
3628 _mesa_memcpy(dest
, source
, n
* sizeof(GLubyte
));
3630 else if (transferOps
== 0 &&
3631 srcType
== GL_UNSIGNED_INT
&&
3632 dstType
== GL_UNSIGNED_INT
&&
3633 !srcPacking
->SwapBytes
) {
3634 _mesa_memcpy(dest
, source
, n
* sizeof(GLuint
));
3640 GLuint indexes
[MAX_WIDTH
];
3641 assert(n
<= MAX_WIDTH
);
3643 extract_uint_indexes(n
, indexes
, GL_STENCIL_INDEX
, srcType
, source
,
3647 if (transferOps
& IMAGE_SHIFT_OFFSET_BIT
) {
3648 /* shift and offset indexes */
3649 shift_and_offset_ci(ctx
, n
, indexes
);
3652 if (ctx
->Pixel
.MapStencilFlag
) {
3653 /* Apply stencil lookup table */
3654 GLuint mask
= ctx
->Pixel
.MapStoSsize
- 1;
3657 indexes
[i
] = ctx
->Pixel
.MapStoS
[ indexes
[i
] & mask
];
3662 /* convert to dest type */
3664 case GL_UNSIGNED_BYTE
:
3666 GLubyte
*dst
= (GLubyte
*) dest
;
3668 for (i
= 0; i
< n
; i
++) {
3669 dst
[i
] = (GLubyte
) (indexes
[i
] & 0xff);
3673 case GL_UNSIGNED_SHORT
:
3675 GLuint
*dst
= (GLuint
*) dest
;
3677 for (i
= 0; i
< n
; i
++) {
3678 dst
[i
] = (GLushort
) (indexes
[i
] & 0xffff);
3682 case GL_UNSIGNED_INT
:
3683 _mesa_memcpy(dest
, indexes
, n
* sizeof(GLuint
));
3686 _mesa_problem(ctx
, "bad dstType in _mesa_unpack_stencil_span");
3693 _mesa_pack_stencil_span( const GLcontext
*ctx
, GLuint n
,
3694 GLenum dstType
, GLvoid
*dest
, const GLstencil
*source
,
3695 const struct gl_pixelstore_attrib
*dstPacking
)
3697 GLstencil stencil
[MAX_WIDTH
];
3699 ASSERT(n
<= MAX_WIDTH
);
3701 if (ctx
->Pixel
.IndexShift
|| ctx
->Pixel
.IndexOffset
||
3702 ctx
->Pixel
.MapStencilFlag
) {
3703 /* make a copy of input */
3704 _mesa_memcpy(stencil
, source
, n
* sizeof(GLstencil
));
3705 _mesa_apply_stencil_transfer_ops(ctx
, n
, stencil
);
3710 case GL_UNSIGNED_BYTE
:
3711 if (sizeof(GLstencil
) == 8) {
3712 _mesa_memcpy( dest
, source
, n
);
3715 GLubyte
*dst
= (GLubyte
*) dest
;
3718 dst
[i
] = (GLubyte
) source
[i
];
3723 if (sizeof(GLstencil
) == 8) {
3724 _mesa_memcpy( dest
, source
, n
);
3727 GLbyte
*dst
= (GLbyte
*) dest
;
3730 dst
[i
] = (GLbyte
) source
[i
];
3734 case GL_UNSIGNED_SHORT
:
3736 GLushort
*dst
= (GLushort
*) dest
;
3739 dst
[i
] = (GLushort
) source
[i
];
3741 if (dstPacking
->SwapBytes
) {
3742 _mesa_swap2( (GLushort
*) dst
, n
);
3748 GLshort
*dst
= (GLshort
*) dest
;
3751 dst
[i
] = (GLshort
) source
[i
];
3753 if (dstPacking
->SwapBytes
) {
3754 _mesa_swap2( (GLushort
*) dst
, n
);
3758 case GL_UNSIGNED_INT
:
3760 GLuint
*dst
= (GLuint
*) dest
;
3763 dst
[i
] = (GLuint
) source
[i
];
3765 if (dstPacking
->SwapBytes
) {
3766 _mesa_swap4( (GLuint
*) dst
, n
);
3772 GLint
*dst
= (GLint
*) dest
;
3775 *dst
++ = (GLint
) source
[i
];
3777 if (dstPacking
->SwapBytes
) {
3778 _mesa_swap4( (GLuint
*) dst
, n
);
3784 GLfloat
*dst
= (GLfloat
*) dest
;
3787 dst
[i
] = (GLfloat
) source
[i
];
3789 if (dstPacking
->SwapBytes
) {
3790 _mesa_swap4( (GLuint
*) dst
, n
);
3794 case GL_HALF_FLOAT_ARB
:
3796 GLhalfARB
*dst
= (GLhalfARB
*) dest
;
3799 dst
[i
] = _mesa_float_to_half( (float) source
[i
] );
3801 if (dstPacking
->SwapBytes
) {
3802 _mesa_swap2( (GLushort
*) dst
, n
);
3807 if (dstPacking
->LsbFirst
) {
3808 GLubyte
*dst
= (GLubyte
*) dest
;
3811 for (i
= 0; i
< n
; i
++) {
3814 *dst
|= ((source
[i
] != 0) << shift
);
3823 GLubyte
*dst
= (GLubyte
*) dest
;
3826 for (i
= 0; i
< n
; i
++) {
3829 *dst
|= ((source
[i
] != 0) << shift
);
3839 _mesa_problem(ctx
, "bad type in _mesa_pack_index_span");
3845 _mesa_unpack_depth_span( const GLcontext
*ctx
, GLuint n
,
3846 GLenum dstType
, GLvoid
*dest
, GLfloat depthScale
,
3847 GLenum srcType
, const GLvoid
*source
,
3848 const struct gl_pixelstore_attrib
*srcPacking
)
3850 GLfloat depthTemp
[MAX_WIDTH
], *depthValues
;
3852 if (dstType
== GL_FLOAT
) {
3853 depthValues
= (GLfloat
*) dest
;
3856 depthValues
= depthTemp
;
3859 /* XXX we need to obey srcPacking->SwapBytes here!!! */
3866 const GLubyte
*src
= (const GLubyte
*) source
;
3867 for (i
= 0; i
< n
; i
++) {
3868 depthValues
[i
] = BYTE_TO_FLOAT(src
[i
]);
3872 case GL_UNSIGNED_BYTE
:
3875 const GLubyte
*src
= (const GLubyte
*) source
;
3876 for (i
= 0; i
< n
; i
++) {
3877 depthValues
[i
] = UBYTE_TO_FLOAT(src
[i
]);
3884 const GLshort
*src
= (const GLshort
*) source
;
3885 for (i
= 0; i
< n
; i
++) {
3886 depthValues
[i
] = SHORT_TO_FLOAT(src
[i
]);
3890 case GL_UNSIGNED_SHORT
:
3893 const GLushort
*src
= (const GLushort
*) source
;
3894 for (i
= 0; i
< n
; i
++) {
3895 depthValues
[i
] = USHORT_TO_FLOAT(src
[i
]);
3902 const GLint
*src
= (const GLint
*) source
;
3903 for (i
= 0; i
< n
; i
++) {
3904 depthValues
[i
] = INT_TO_FLOAT(src
[i
]);
3908 case GL_UNSIGNED_INT
:
3911 const GLuint
*src
= (const GLuint
*) source
;
3912 for (i
= 0; i
< n
; i
++) {
3913 depthValues
[i
] = UINT_TO_FLOAT(src
[i
]);
3917 case GL_UNSIGNED_INT_24_8_EXT
: /* GL_EXT_packed_depth_stencil */
3918 if (dstType
== GL_UNSIGNED_INT
&&
3919 depthScale
== (GLfloat
) 0xffffff &&
3920 ctx
->Pixel
.DepthScale
== 1.0 &&
3921 ctx
->Pixel
.DepthBias
== 0.0) {
3922 const GLuint
*src
= (const GLuint
*) source
;
3923 GLuint
*zValues
= (GLuint
*) dest
;
3925 for (i
= 0; i
< n
; i
++) {
3926 zValues
[i
] = src
[i
] & 0xffffff00;
3931 const GLuint
*src
= (const GLuint
*) source
;
3932 const GLfloat scale
= 1.0f
/ 0xffffff;
3934 for (i
= 0; i
< n
; i
++) {
3935 depthValues
[i
] = (src
[i
] >> 8) * scale
;
3940 _mesa_memcpy(depthValues
, source
, n
* sizeof(GLfloat
));
3942 case GL_HALF_FLOAT_ARB
:
3945 const GLhalfARB
*src
= (const GLhalfARB
*) source
;
3946 for (i
= 0; i
< n
; i
++) {
3947 depthValues
[i
] = _mesa_half_to_float(src
[i
]);
3952 _mesa_problem(NULL
, "bad type in _mesa_unpack_depth_span()");
3957 /* apply depth scale and bias and clamp to [0,1] */
3958 if (ctx
->Pixel
.DepthScale
!= 1.0 || ctx
->Pixel
.DepthBias
!= 0.0) {
3959 _mesa_scale_and_bias_depth(ctx
, n
, depthValues
);
3962 if (dstType
== GL_UNSIGNED_INT
) {
3963 GLuint
*zValues
= (GLuint
*) dest
;
3965 if (depthScale
<= (GLfloat
) 0xffffff) {
3966 /* no overflow worries */
3967 for (i
= 0; i
< n
; i
++) {
3968 zValues
[i
] = (GLuint
) (depthValues
[i
] * depthScale
);
3972 /* need to use double precision to prevent overflow problems */
3973 for (i
= 0; i
< n
; i
++) {
3974 GLdouble z
= depthValues
[i
] * depthScale
;
3975 if (z
>= (GLdouble
) 0xffffffff)
3976 zValues
[i
] = 0xffffffff;
3978 zValues
[i
] = (GLuint
) z
;
3982 else if (dstType
== GL_UNSIGNED_SHORT
) {
3983 GLushort
*zValues
= (GLushort
*) dest
;
3985 ASSERT(depthScale
<= 65535.0);
3986 for (i
= 0; i
< n
; i
++) {
3987 zValues
[i
] = (GLushort
) (depthValues
[i
] * depthScale
);
3991 ASSERT(dstType
== GL_FLOAT
);
3992 ASSERT(depthScale
== 1.0F
);
3998 * Pack an array of depth values. The values are floats in [0,1].
4001 _mesa_pack_depth_span( const GLcontext
*ctx
, GLuint n
, GLvoid
*dest
,
4002 GLenum dstType
, const GLfloat
*depthSpan
,
4003 const struct gl_pixelstore_attrib
*dstPacking
)
4005 GLfloat depthCopy
[MAX_WIDTH
];
4007 ASSERT(n
<= MAX_WIDTH
);
4009 if (ctx
->Pixel
.DepthScale
!= 1.0 || ctx
->Pixel
.DepthBias
!= 0.0) {
4010 _mesa_memcpy(depthCopy
, depthSpan
, n
* sizeof(GLfloat
));
4011 _mesa_scale_and_bias_depth(ctx
, n
, depthCopy
);
4012 depthSpan
= depthCopy
;
4016 case GL_UNSIGNED_BYTE
:
4018 GLubyte
*dst
= (GLubyte
*) dest
;
4020 for (i
= 0; i
< n
; i
++) {
4021 dst
[i
] = FLOAT_TO_UBYTE( depthSpan
[i
] );
4027 GLbyte
*dst
= (GLbyte
*) dest
;
4029 for (i
= 0; i
< n
; i
++) {
4030 dst
[i
] = FLOAT_TO_BYTE( depthSpan
[i
] );
4034 case GL_UNSIGNED_SHORT
:
4036 GLushort
*dst
= (GLushort
*) dest
;
4038 for (i
= 0; i
< n
; i
++) {
4039 CLAMPED_FLOAT_TO_USHORT(dst
[i
], depthSpan
[i
]);
4041 if (dstPacking
->SwapBytes
) {
4042 _mesa_swap2( (GLushort
*) dst
, n
);
4048 GLshort
*dst
= (GLshort
*) dest
;
4050 for (i
= 0; i
< n
; i
++) {
4051 dst
[i
] = FLOAT_TO_SHORT( depthSpan
[i
] );
4053 if (dstPacking
->SwapBytes
) {
4054 _mesa_swap2( (GLushort
*) dst
, n
);
4058 case GL_UNSIGNED_INT
:
4060 GLuint
*dst
= (GLuint
*) dest
;
4062 for (i
= 0; i
< n
; i
++) {
4063 dst
[i
] = FLOAT_TO_UINT( depthSpan
[i
] );
4065 if (dstPacking
->SwapBytes
) {
4066 _mesa_swap4( (GLuint
*) dst
, n
);
4072 GLint
*dst
= (GLint
*) dest
;
4074 for (i
= 0; i
< n
; i
++) {
4075 dst
[i
] = FLOAT_TO_INT( depthSpan
[i
] );
4077 if (dstPacking
->SwapBytes
) {
4078 _mesa_swap4( (GLuint
*) dst
, n
);
4084 GLfloat
*dst
= (GLfloat
*) dest
;
4086 for (i
= 0; i
< n
; i
++) {
4087 dst
[i
] = depthSpan
[i
];
4089 if (dstPacking
->SwapBytes
) {
4090 _mesa_swap4( (GLuint
*) dst
, n
);
4094 case GL_HALF_FLOAT_ARB
:
4096 GLhalfARB
*dst
= (GLhalfARB
*) dest
;
4098 for (i
= 0; i
< n
; i
++) {
4099 dst
[i
] = _mesa_float_to_half(depthSpan
[i
]);
4101 if (dstPacking
->SwapBytes
) {
4102 _mesa_swap2( (GLushort
*) dst
, n
);
4107 _mesa_problem(ctx
, "bad type in _mesa_pack_depth_span");
4114 * Pack depth and stencil values as GL_DEPTH_STENCIL/GL_UNSIGNED_INT_24_8.
4117 _mesa_pack_depth_stencil_span(const GLcontext
*ctx
, GLuint n
, GLuint
*dest
,
4118 const GLfloat
*depthVals
,
4119 const GLstencil
*stencilVals
,
4120 const struct gl_pixelstore_attrib
*dstPacking
)
4122 GLfloat depthCopy
[MAX_WIDTH
];
4123 GLstencil stencilCopy
[MAX_WIDTH
];
4126 ASSERT(n
<= MAX_WIDTH
);
4128 if (ctx
->Pixel
.DepthScale
!= 1.0 || ctx
->Pixel
.DepthBias
!= 0.0) {
4129 _mesa_memcpy(depthCopy
, depthVals
, n
* sizeof(GLfloat
));
4130 _mesa_scale_and_bias_depth(ctx
, n
, depthCopy
);
4131 depthVals
= depthCopy
;
4134 if (ctx
->Pixel
.IndexShift
||
4135 ctx
->Pixel
.IndexOffset
||
4136 ctx
->Pixel
.MapStencilFlag
) {
4137 _mesa_memcpy(stencilCopy
, stencilVals
, n
* sizeof(GLstencil
));
4138 _mesa_apply_stencil_transfer_ops(ctx
, n
, stencilCopy
);
4139 stencilVals
= stencilCopy
;
4142 for (i
= 0; i
< n
; i
++) {
4143 GLuint z
= (GLuint
) (depthVals
[i
] * 0xffffff);
4144 dest
[i
] = (z
<< 8) | (stencilVals
[i
] & 0xff);
4147 if (dstPacking
->SwapBytes
) {
4148 _mesa_swap4(dest
, n
);
4156 * Unpack image data. Apply byte swapping, byte flipping (bitmap).
4157 * Return all image data in a contiguous block. This is used when we
4158 * compile glDrawPixels, glTexImage, etc into a display list. We
4159 * need a copy of the data in a standard format.
4162 _mesa_unpack_image( GLuint dimensions
,
4163 GLsizei width
, GLsizei height
, GLsizei depth
,
4164 GLenum format
, GLenum type
, const GLvoid
*pixels
,
4165 const struct gl_pixelstore_attrib
*unpack
)
4167 GLint bytesPerRow
, compsPerRow
;
4168 GLboolean flipBytes
, swap2
, swap4
;
4171 return NULL
; /* not necessarily an error */
4173 if (width
<= 0 || height
<= 0 || depth
<= 0)
4174 return NULL
; /* generate error later */
4176 if (type
== GL_BITMAP
) {
4177 bytesPerRow
= (width
+ 7) >> 3;
4178 flipBytes
= !unpack
->LsbFirst
;
4179 swap2
= swap4
= GL_FALSE
;
4183 const GLint bytesPerPixel
= _mesa_bytes_per_pixel(format
, type
);
4184 const GLint components
= _mesa_components_in_format(format
);
4186 if (bytesPerPixel
<= 0 || components
<= 0)
4187 return NULL
; /* bad format or type. generate error later */
4188 bytesPerRow
= bytesPerPixel
* width
;
4189 bytesPerComp
= bytesPerPixel
/ components
;
4190 flipBytes
= GL_FALSE
;
4191 swap2
= (bytesPerComp
== 2) && unpack
->SwapBytes
;
4192 swap4
= (bytesPerComp
== 4) && unpack
->SwapBytes
;
4193 compsPerRow
= components
* width
;
4194 assert(compsPerRow
>= width
);
4199 = (GLubyte
*) _mesa_malloc(bytesPerRow
* height
* depth
);
4203 return NULL
; /* generate GL_OUT_OF_MEMORY later */
4206 for (img
= 0; img
< depth
; img
++) {
4207 for (row
= 0; row
< height
; row
++) {
4208 const GLvoid
*src
= _mesa_image_address(dimensions
, unpack
, pixels
,
4209 width
, height
, format
, type
, img
, row
, 0);
4210 _mesa_memcpy(dst
, src
, bytesPerRow
);
4211 /* byte flipping/swapping */
4213 flip_bytes((GLubyte
*) dst
, bytesPerRow
);
4216 _mesa_swap2((GLushort
*) dst
, compsPerRow
);
4219 _mesa_swap4((GLuint
*) dst
, compsPerRow
);
4228 #endif /* _HAVE_FULL_GL */
4233 * Convert an array of RGBA colors from one datatype to another.
4234 * NOTE: src may equal dst. In that case, we use a temporary buffer.
4237 _mesa_convert_colors(GLenum srcType
, const GLvoid
*src
,
4238 GLenum dstType
, GLvoid
*dst
,
4239 GLuint count
, const GLubyte mask
[])
4241 GLuint tempBuffer
[MAX_WIDTH
][4];
4242 const GLboolean useTemp
= (src
== dst
);
4244 ASSERT(srcType
!= dstType
);
4247 case GL_UNSIGNED_BYTE
:
4248 if (dstType
== GL_UNSIGNED_SHORT
) {
4249 const GLubyte (*src1
)[4] = (const GLubyte (*)[4]) src
;
4250 GLushort (*dst2
)[4] = (GLushort (*)[4]) (useTemp
? tempBuffer
: dst
);
4252 for (i
= 0; i
< count
; i
++) {
4253 if (!mask
|| mask
[i
]) {
4254 dst2
[i
][RCOMP
] = UBYTE_TO_USHORT(src1
[i
][RCOMP
]);
4255 dst2
[i
][GCOMP
] = UBYTE_TO_USHORT(src1
[i
][GCOMP
]);
4256 dst2
[i
][BCOMP
] = UBYTE_TO_USHORT(src1
[i
][BCOMP
]);
4257 dst2
[i
][ACOMP
] = UBYTE_TO_USHORT(src1
[i
][ACOMP
]);
4261 _mesa_memcpy(dst
, tempBuffer
, count
* 4 * sizeof(GLushort
));
4264 const GLubyte (*src1
)[4] = (const GLubyte (*)[4]) src
;
4265 GLfloat (*dst4
)[4] = (GLfloat (*)[4]) (useTemp
? tempBuffer
: dst
);
4267 ASSERT(dstType
== GL_FLOAT
);
4268 for (i
= 0; i
< count
; i
++) {
4269 if (!mask
|| mask
[i
]) {
4270 dst4
[i
][RCOMP
] = UBYTE_TO_FLOAT(src1
[i
][RCOMP
]);
4271 dst4
[i
][GCOMP
] = UBYTE_TO_FLOAT(src1
[i
][GCOMP
]);
4272 dst4
[i
][BCOMP
] = UBYTE_TO_FLOAT(src1
[i
][BCOMP
]);
4273 dst4
[i
][ACOMP
] = UBYTE_TO_FLOAT(src1
[i
][ACOMP
]);
4277 _mesa_memcpy(dst
, tempBuffer
, count
* 4 * sizeof(GLfloat
));
4280 case GL_UNSIGNED_SHORT
:
4281 if (dstType
== GL_UNSIGNED_BYTE
) {
4282 const GLushort (*src2
)[4] = (const GLushort (*)[4]) src
;
4283 GLubyte (*dst1
)[4] = (GLubyte (*)[4]) (useTemp
? tempBuffer
: dst
);
4285 for (i
= 0; i
< count
; i
++) {
4286 if (!mask
|| mask
[i
]) {
4287 dst1
[i
][RCOMP
] = USHORT_TO_UBYTE(src2
[i
][RCOMP
]);
4288 dst1
[i
][GCOMP
] = USHORT_TO_UBYTE(src2
[i
][GCOMP
]);
4289 dst1
[i
][BCOMP
] = USHORT_TO_UBYTE(src2
[i
][BCOMP
]);
4290 dst1
[i
][ACOMP
] = USHORT_TO_UBYTE(src2
[i
][ACOMP
]);
4294 _mesa_memcpy(dst
, tempBuffer
, count
* 4 * sizeof(GLubyte
));
4297 const GLushort (*src2
)[4] = (const GLushort (*)[4]) src
;
4298 GLfloat (*dst4
)[4] = (GLfloat (*)[4]) (useTemp
? tempBuffer
: dst
);
4300 ASSERT(dstType
== GL_FLOAT
);
4301 for (i
= 0; i
< count
; i
++) {
4302 if (!mask
|| mask
[i
]) {
4303 dst4
[i
][RCOMP
] = USHORT_TO_FLOAT(src2
[i
][RCOMP
]);
4304 dst4
[i
][GCOMP
] = USHORT_TO_FLOAT(src2
[i
][GCOMP
]);
4305 dst4
[i
][BCOMP
] = USHORT_TO_FLOAT(src2
[i
][BCOMP
]);
4306 dst4
[i
][ACOMP
] = USHORT_TO_FLOAT(src2
[i
][ACOMP
]);
4310 _mesa_memcpy(dst
, tempBuffer
, count
* 4 * sizeof(GLfloat
));
4314 if (dstType
== GL_UNSIGNED_BYTE
) {
4315 const GLfloat (*src4
)[4] = (const GLfloat (*)[4]) src
;
4316 GLubyte (*dst1
)[4] = (GLubyte (*)[4]) (useTemp
? tempBuffer
: dst
);
4318 for (i
= 0; i
< count
; i
++) {
4319 if (!mask
|| mask
[i
]) {
4320 UNCLAMPED_FLOAT_TO_UBYTE(dst1
[i
][RCOMP
], src4
[i
][RCOMP
]);
4321 UNCLAMPED_FLOAT_TO_UBYTE(dst1
[i
][GCOMP
], src4
[i
][GCOMP
]);
4322 UNCLAMPED_FLOAT_TO_UBYTE(dst1
[i
][BCOMP
], src4
[i
][BCOMP
]);
4323 UNCLAMPED_FLOAT_TO_UBYTE(dst1
[i
][ACOMP
], src4
[i
][ACOMP
]);
4327 _mesa_memcpy(dst
, tempBuffer
, count
* 4 * sizeof(GLubyte
));
4330 const GLfloat (*src4
)[4] = (const GLfloat (*)[4]) src
;
4331 GLushort (*dst2
)[4] = (GLushort (*)[4]) (useTemp
? tempBuffer
: dst
);
4333 ASSERT(dstType
== GL_UNSIGNED_SHORT
);
4334 for (i
= 0; i
< count
; i
++) {
4335 if (!mask
|| mask
[i
]) {
4336 UNCLAMPED_FLOAT_TO_USHORT(dst2
[i
][RCOMP
], src4
[i
][RCOMP
]);
4337 UNCLAMPED_FLOAT_TO_USHORT(dst2
[i
][GCOMP
], src4
[i
][GCOMP
]);
4338 UNCLAMPED_FLOAT_TO_USHORT(dst2
[i
][BCOMP
], src4
[i
][BCOMP
]);
4339 UNCLAMPED_FLOAT_TO_USHORT(dst2
[i
][ACOMP
], src4
[i
][ACOMP
]);
4343 _mesa_memcpy(dst
, tempBuffer
, count
* 4 * sizeof(GLushort
));
4347 _mesa_problem(NULL
, "Invalid datatype in _mesa_convert_colors");
4355 * Perform basic clipping for glDrawPixels. The image's position and size
4356 * and the unpack SkipPixels and SkipRows are adjusted so that the image
4357 * region is entirely within the window and scissor bounds.
4358 * NOTE: this will only work when glPixelZoom is (1, 1) or (1, -1).
4359 * If Pixel.ZoomY is -1, *destY will be changed to be the first row which
4360 * we'll actually write. Beforehand, *destY-1 is the first drawing row.
4362 * \return GL_TRUE if image is ready for drawing or
4363 * GL_FALSE if image was completely clipped away (draw nothing)
4366 _mesa_clip_drawpixels(const GLcontext
*ctx
,
4367 GLint
*destX
, GLint
*destY
,
4368 GLsizei
*width
, GLsizei
*height
,
4369 struct gl_pixelstore_attrib
*unpack
)
4371 const GLframebuffer
*buffer
= ctx
->DrawBuffer
;
4373 if (unpack
->RowLength
== 0) {
4374 unpack
->RowLength
= *width
;
4377 ASSERT(ctx
->Pixel
.ZoomX
== 1.0F
);
4378 ASSERT(ctx
->Pixel
.ZoomY
== 1.0F
|| ctx
->Pixel
.ZoomY
== -1.0F
);
4381 if (*destX
< buffer
->_Xmin
) {
4382 unpack
->SkipPixels
+= (buffer
->_Xmin
- *destX
);
4383 *width
-= (buffer
->_Xmin
- *destX
);
4384 *destX
= buffer
->_Xmin
;
4386 /* right clipping */
4387 if (*destX
+ *width
> buffer
->_Xmax
)
4388 *width
-= (*destX
+ *width
- buffer
->_Xmax
);
4393 if (ctx
->Pixel
.ZoomY
== 1.0F
) {
4394 /* bottom clipping */
4395 if (*destY
< buffer
->_Ymin
) {
4396 unpack
->SkipRows
+= (buffer
->_Ymin
- *destY
);
4397 *height
-= (buffer
->_Ymin
- *destY
);
4398 *destY
= buffer
->_Ymin
;
4401 if (*destY
+ *height
> buffer
->_Ymax
)
4402 *height
-= (*destY
+ *height
- buffer
->_Ymax
);
4404 else { /* upside down */
4406 if (*destY
> buffer
->_Ymax
) {
4407 unpack
->SkipRows
+= (*destY
- buffer
->_Ymax
);
4408 *height
-= (*destY
- buffer
->_Ymax
);
4409 *destY
= buffer
->_Ymax
;
4411 /* bottom clipping */
4412 if (*destY
- *height
< buffer
->_Ymin
)
4413 *height
-= (buffer
->_Ymin
- (*destY
- *height
));
4414 /* adjust destY so it's the first row to write to */
4426 * Perform clipping for glReadPixels. The image's window position
4427 * and size, and the pack skipPixels, skipRows and rowLength are adjusted
4428 * so that the image region is entirely within the window bounds.
4429 * Note: this is different from _mesa_clip_drawpixels() in that the
4430 * scissor box is ignored, and we use the bounds of the current readbuffer
4433 * \return GL_TRUE if image is ready for drawing or
4434 * GL_FALSE if image was completely clipped away (draw nothing)
4437 _mesa_clip_readpixels(const GLcontext
*ctx
,
4438 GLint
*srcX
, GLint
*srcY
,
4439 GLsizei
*width
, GLsizei
*height
,
4440 struct gl_pixelstore_attrib
*pack
)
4442 const GLframebuffer
*buffer
= ctx
->ReadBuffer
;
4444 if (pack
->RowLength
== 0) {
4445 pack
->RowLength
= *width
;
4450 pack
->SkipPixels
+= (0 - *srcX
);
4451 *width
-= (0 - *srcX
);
4454 /* right clipping */
4455 if (*srcX
+ *width
> (GLsizei
) buffer
->Width
)
4456 *width
-= (*srcX
+ *width
- buffer
->Width
);
4461 /* bottom clipping */
4463 pack
->SkipRows
+= (0 - *srcY
);
4464 *height
-= (0 - *srcY
);
4468 if (*srcY
+ *height
> (GLsizei
) buffer
->Height
)
4469 *height
-= (*srcY
+ *height
- buffer
->Height
);
4479 * Clip the rectangle defined by (x, y, width, height) against the bounds
4480 * specified by [xmin, xmax) and [ymin, ymax).
4481 * \return GL_FALSE if rect is totally clipped, GL_TRUE otherwise.
4484 _mesa_clip_to_region(GLint xmin
, GLint ymin
,
4485 GLint xmax
, GLint ymax
,
4487 GLsizei
*width
, GLsizei
*height
)
4491 *width
-= (xmin
- *x
);
4495 /* right clipping */
4496 if (*x
+ *width
> xmax
)
4497 *width
-= (*x
+ *width
- xmax
- 1);
4502 /* bottom (or top) clipping */
4504 *height
-= (ymin
- *y
);
4508 /* top (or bottom) clipping */
4509 if (*y
+ *height
> ymax
)
4510 *height
-= (*y
+ *height
- ymax
- 1);