2 * Mesa 3-D graphics library
5 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved.
6 * Copyright (C) 2009 VMware, Inc. All Rights Reserved.
8 * Permission is hereby granted, free of charge, to any person obtaining a
9 * copy of this software and associated documentation files (the "Software"),
10 * to deal in the Software without restriction, including without limitation
11 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
12 * and/or sell copies of the Software, and to permit persons to whom the
13 * Software is furnished to do so, subject to the following conditions:
15 * The above copyright notice and this permission notice shall be included
16 * in all copies or substantial portions of the Software.
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
22 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
23 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
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 * \return GL_TRUE if type is packed pixel type, GL_FALSE otherwise.
66 _mesa_type_is_packed(GLenum type
)
69 case GL_UNSIGNED_BYTE_3_3_2
:
70 case GL_UNSIGNED_BYTE_2_3_3_REV
:
71 case GL_UNSIGNED_SHORT_5_6_5
:
72 case GL_UNSIGNED_SHORT_5_6_5_REV
:
73 case GL_UNSIGNED_SHORT_4_4_4_4
:
74 case GL_UNSIGNED_SHORT_4_4_4_4_REV
:
75 case GL_UNSIGNED_SHORT_5_5_5_1
:
76 case GL_UNSIGNED_SHORT_1_5_5_5_REV
:
77 case GL_UNSIGNED_INT_8_8_8_8
:
78 case GL_UNSIGNED_INT_8_8_8_8_REV
:
79 case GL_UNSIGNED_INT_10_10_10_2
:
80 case GL_UNSIGNED_INT_2_10_10_10_REV
:
81 case GL_UNSIGNED_SHORT_8_8_MESA
:
82 case GL_UNSIGNED_SHORT_8_8_REV_MESA
:
83 case GL_UNSIGNED_INT_24_8_EXT
:
91 * Flip the 8 bits in each byte of the given array.
94 * \param n number of bytes.
96 * \todo try this trick to flip bytes someday:
98 * v = ((v & 0x55555555) << 1) | ((v >> 1) & 0x55555555);
99 * v = ((v & 0x33333333) << 2) | ((v >> 2) & 0x33333333);
100 * v = ((v & 0x0f0f0f0f) << 4) | ((v >> 4) & 0x0f0f0f0f);
104 flip_bytes( GLubyte
*p
, GLuint n
)
107 for (i
= 0; i
< n
; i
++) {
108 b
= (GLuint
) p
[i
]; /* words are often faster than bytes */
109 a
= ((b
& 0x01) << 7) |
123 * Flip the order of the 2 bytes in each word in the given array.
126 * \param n number of words.
129 _mesa_swap2( GLushort
*p
, GLuint n
)
132 for (i
= 0; i
< n
; i
++) {
133 p
[i
] = (p
[i
] >> 8) | ((p
[i
] << 8) & 0xff00);
140 * Flip the order of the 4 bytes in each word in the given array.
143 _mesa_swap4( GLuint
*p
, GLuint n
)
146 for (i
= 0; i
< n
; i
++) {
149 | ((b
>> 8) & 0xff00)
150 | ((b
<< 8) & 0xff0000)
151 | ((b
<< 24) & 0xff000000);
158 * Get the size of a GL data type.
160 * \param type GL data type.
162 * \return the size, in bytes, of the given data type, 0 if a GL_BITMAP, or -1
163 * if an invalid type enum.
166 _mesa_sizeof_type( GLenum type
)
171 case GL_UNSIGNED_BYTE
:
172 return sizeof(GLubyte
);
174 return sizeof(GLbyte
);
175 case GL_UNSIGNED_SHORT
:
176 return sizeof(GLushort
);
178 return sizeof(GLshort
);
179 case GL_UNSIGNED_INT
:
180 return sizeof(GLuint
);
182 return sizeof(GLint
);
184 return sizeof(GLfloat
);
185 case GL_HALF_FLOAT_ARB
:
186 return sizeof(GLhalfARB
);
194 * Same as _mesa_sizeof_type() but also accepting the packed pixel
198 _mesa_sizeof_packed_type( GLenum type
)
203 case GL_UNSIGNED_BYTE
:
204 return sizeof(GLubyte
);
206 return sizeof(GLbyte
);
207 case GL_UNSIGNED_SHORT
:
208 return sizeof(GLushort
);
210 return sizeof(GLshort
);
211 case GL_UNSIGNED_INT
:
212 return sizeof(GLuint
);
214 return sizeof(GLint
);
215 case GL_HALF_FLOAT_ARB
:
216 return sizeof(GLhalfARB
);
218 return sizeof(GLfloat
);
219 case GL_UNSIGNED_BYTE_3_3_2
:
220 return sizeof(GLubyte
);
221 case GL_UNSIGNED_BYTE_2_3_3_REV
:
222 return sizeof(GLubyte
);
223 case GL_UNSIGNED_SHORT_5_6_5
:
224 return sizeof(GLushort
);
225 case GL_UNSIGNED_SHORT_5_6_5_REV
:
226 return sizeof(GLushort
);
227 case GL_UNSIGNED_SHORT_4_4_4_4
:
228 return sizeof(GLushort
);
229 case GL_UNSIGNED_SHORT_4_4_4_4_REV
:
230 return sizeof(GLushort
);
231 case GL_UNSIGNED_SHORT_5_5_5_1
:
232 return sizeof(GLushort
);
233 case GL_UNSIGNED_SHORT_1_5_5_5_REV
:
234 return sizeof(GLushort
);
235 case GL_UNSIGNED_INT_8_8_8_8
:
236 return sizeof(GLuint
);
237 case GL_UNSIGNED_INT_8_8_8_8_REV
:
238 return sizeof(GLuint
);
239 case GL_UNSIGNED_INT_10_10_10_2
:
240 return sizeof(GLuint
);
241 case GL_UNSIGNED_INT_2_10_10_10_REV
:
242 return sizeof(GLuint
);
243 case GL_UNSIGNED_SHORT_8_8_MESA
:
244 case GL_UNSIGNED_SHORT_8_8_REV_MESA
:
245 return sizeof(GLushort
);
246 case GL_UNSIGNED_INT_24_8_EXT
:
247 return sizeof(GLuint
);
255 * Get the number of components in a pixel format.
257 * \param format pixel format.
259 * \return the number of components in the given format, or -1 if a bad format.
262 _mesa_components_in_format( GLenum format
)
266 case GL_COLOR_INDEX1_EXT
:
267 case GL_COLOR_INDEX2_EXT
:
268 case GL_COLOR_INDEX4_EXT
:
269 case GL_COLOR_INDEX8_EXT
:
270 case GL_COLOR_INDEX12_EXT
:
271 case GL_COLOR_INDEX16_EXT
:
272 case GL_STENCIL_INDEX
:
273 case GL_DEPTH_COMPONENT
:
281 case GL_LUMINANCE_ALPHA
:
295 case GL_DEPTH_STENCIL_EXT
:
307 * Get the bytes per pixel of pixel format type pair.
309 * \param format pixel format.
310 * \param type pixel type.
312 * \return bytes per pixel, or -1 if a bad format or type was given.
315 _mesa_bytes_per_pixel( GLenum format
, GLenum type
)
317 GLint comps
= _mesa_components_in_format( format
);
323 return 0; /* special case */
325 case GL_UNSIGNED_BYTE
:
326 return comps
* sizeof(GLubyte
);
328 case GL_UNSIGNED_SHORT
:
329 return comps
* sizeof(GLshort
);
331 case GL_UNSIGNED_INT
:
332 return comps
* sizeof(GLint
);
334 return comps
* sizeof(GLfloat
);
335 case GL_HALF_FLOAT_ARB
:
336 return comps
* sizeof(GLhalfARB
);
337 case GL_UNSIGNED_BYTE_3_3_2
:
338 case GL_UNSIGNED_BYTE_2_3_3_REV
:
339 if (format
== GL_RGB
|| format
== GL_BGR
)
340 return sizeof(GLubyte
);
342 return -1; /* error */
343 case GL_UNSIGNED_SHORT_5_6_5
:
344 case GL_UNSIGNED_SHORT_5_6_5_REV
:
345 if (format
== GL_RGB
|| format
== GL_BGR
)
346 return sizeof(GLushort
);
348 return -1; /* error */
349 case GL_UNSIGNED_SHORT_4_4_4_4
:
350 case GL_UNSIGNED_SHORT_4_4_4_4_REV
:
351 case GL_UNSIGNED_SHORT_5_5_5_1
:
352 case GL_UNSIGNED_SHORT_1_5_5_5_REV
:
353 if (format
== GL_RGBA
|| format
== GL_BGRA
|| format
== GL_ABGR_EXT
)
354 return sizeof(GLushort
);
357 case GL_UNSIGNED_INT_8_8_8_8
:
358 case GL_UNSIGNED_INT_8_8_8_8_REV
:
359 case GL_UNSIGNED_INT_10_10_10_2
:
360 case GL_UNSIGNED_INT_2_10_10_10_REV
:
361 if (format
== GL_RGBA
|| format
== GL_BGRA
|| format
== GL_ABGR_EXT
)
362 return sizeof(GLuint
);
365 case GL_UNSIGNED_SHORT_8_8_MESA
:
366 case GL_UNSIGNED_SHORT_8_8_REV_MESA
:
367 if (format
== GL_YCBCR_MESA
)
368 return sizeof(GLushort
);
371 case GL_UNSIGNED_INT_24_8_EXT
:
372 if (format
== GL_DEPTH_STENCIL_EXT
)
373 return sizeof(GLuint
);
383 * Test for a legal pixel format and type.
385 * \param format pixel format.
386 * \param type pixel type.
388 * \return GL_TRUE if the given pixel format and type are legal, or GL_FALSE
392 _mesa_is_legal_format_and_type( GLcontext
*ctx
, GLenum format
, GLenum type
)
396 case GL_STENCIL_INDEX
:
400 case GL_UNSIGNED_BYTE
:
402 case GL_UNSIGNED_SHORT
:
404 case GL_UNSIGNED_INT
:
407 case GL_HALF_FLOAT_ARB
:
408 return ctx
->Extensions
.ARB_half_float_pixel
;
416 #if 0 /* not legal! see table 3.6 of the 1.5 spec */
420 case GL_LUMINANCE_ALPHA
:
421 case GL_DEPTH_COMPONENT
:
424 case GL_UNSIGNED_BYTE
:
426 case GL_UNSIGNED_SHORT
:
428 case GL_UNSIGNED_INT
:
431 case GL_HALF_FLOAT_ARB
:
432 return ctx
->Extensions
.ARB_half_float_pixel
;
439 case GL_UNSIGNED_BYTE
:
441 case GL_UNSIGNED_SHORT
:
443 case GL_UNSIGNED_INT
:
445 case GL_UNSIGNED_BYTE_3_3_2
:
446 case GL_UNSIGNED_BYTE_2_3_3_REV
:
447 case GL_UNSIGNED_SHORT_5_6_5
:
448 case GL_UNSIGNED_SHORT_5_6_5_REV
:
450 case GL_HALF_FLOAT_ARB
:
451 return ctx
->Extensions
.ARB_half_float_pixel
;
457 /* NOTE: no packed types are supported with BGR. That's
458 * intentional, according to the GL spec.
461 case GL_UNSIGNED_BYTE
:
463 case GL_UNSIGNED_SHORT
:
465 case GL_UNSIGNED_INT
:
468 case GL_HALF_FLOAT_ARB
:
469 return ctx
->Extensions
.ARB_half_float_pixel
;
478 case GL_UNSIGNED_BYTE
:
480 case GL_UNSIGNED_SHORT
:
482 case GL_UNSIGNED_INT
:
484 case GL_UNSIGNED_SHORT_4_4_4_4
:
485 case GL_UNSIGNED_SHORT_4_4_4_4_REV
:
486 case GL_UNSIGNED_SHORT_5_5_5_1
:
487 case GL_UNSIGNED_SHORT_1_5_5_5_REV
:
488 case GL_UNSIGNED_INT_8_8_8_8
:
489 case GL_UNSIGNED_INT_8_8_8_8_REV
:
490 case GL_UNSIGNED_INT_10_10_10_2
:
491 case GL_UNSIGNED_INT_2_10_10_10_REV
:
493 case GL_HALF_FLOAT_ARB
:
494 return ctx
->Extensions
.ARB_half_float_pixel
;
499 if (type
== GL_UNSIGNED_SHORT_8_8_MESA
||
500 type
== GL_UNSIGNED_SHORT_8_8_REV_MESA
)
504 case GL_DEPTH_STENCIL_EXT
:
505 if (ctx
->Extensions
.EXT_packed_depth_stencil
506 && type
== GL_UNSIGNED_INT_24_8_EXT
)
514 case GL_UNSIGNED_BYTE
:
516 case GL_UNSIGNED_SHORT
:
518 case GL_UNSIGNED_INT
:
532 * Return the address of a specific pixel in an image (1D, 2D or 3D).
534 * Pixel unpacking/packing parameters are observed according to \p packing.
536 * \param dimensions either 1, 2 or 3 to indicate dimensionality of image
537 * \param image starting address of image data
538 * \param width the image width
539 * \param height theimage height
540 * \param format the pixel format
541 * \param type the pixel data type
542 * \param packing the pixelstore attributes
543 * \param img which image in the volume (0 for 1D or 2D images)
544 * \param row row of pixel in the image (0 for 1D images)
545 * \param column column of pixel in the image
547 * \return address of pixel on success, or NULL on error.
549 * \sa gl_pixelstore_attrib.
552 _mesa_image_address( GLuint dimensions
,
553 const struct gl_pixelstore_attrib
*packing
,
555 GLsizei width
, GLsizei height
,
556 GLenum format
, GLenum type
,
557 GLint img
, GLint row
, GLint column
)
559 GLint alignment
; /* 1, 2 or 4 */
560 GLint pixels_per_row
;
561 GLint rows_per_image
;
564 GLint skipimages
; /* for 3-D volume images */
567 ASSERT(dimensions
>= 1 && dimensions
<= 3);
569 alignment
= packing
->Alignment
;
570 if (packing
->RowLength
> 0) {
571 pixels_per_row
= packing
->RowLength
;
574 pixels_per_row
= width
;
576 if (packing
->ImageHeight
> 0) {
577 rows_per_image
= packing
->ImageHeight
;
580 rows_per_image
= height
;
583 skippixels
= packing
->SkipPixels
;
584 /* Note: SKIP_ROWS _is_ used for 1D images */
585 skiprows
= packing
->SkipRows
;
586 /* Note: SKIP_IMAGES is only used for 3D images */
587 skipimages
= (dimensions
== 3) ? packing
->SkipImages
: 0;
589 if (type
== GL_BITMAP
) {
591 GLint comp_per_pixel
; /* components per pixel */
592 GLint bytes_per_comp
; /* bytes per component */
594 GLint bytes_per_image
;
596 /* Compute bytes per component */
597 bytes_per_comp
= _mesa_sizeof_packed_type( type
);
598 if (bytes_per_comp
< 0) {
602 /* Compute number of components per pixel */
603 comp_per_pixel
= _mesa_components_in_format( format
);
604 if (comp_per_pixel
< 0) {
608 bytes_per_row
= alignment
609 * CEILING( comp_per_pixel
*pixels_per_row
, 8*alignment
);
611 bytes_per_image
= bytes_per_row
* rows_per_image
;
613 pixel_addr
= (GLubyte
*) image
614 + (skipimages
+ img
) * bytes_per_image
615 + (skiprows
+ row
) * bytes_per_row
616 + (skippixels
+ column
) / 8;
619 /* Non-BITMAP data */
620 GLint bytes_per_pixel
, bytes_per_row
, remainder
, bytes_per_image
;
623 bytes_per_pixel
= _mesa_bytes_per_pixel( format
, type
);
625 /* The pixel type and format should have been error checked earlier */
626 assert(bytes_per_pixel
> 0);
628 bytes_per_row
= pixels_per_row
* bytes_per_pixel
;
629 remainder
= bytes_per_row
% alignment
;
631 bytes_per_row
+= (alignment
- remainder
);
633 ASSERT(bytes_per_row
% alignment
== 0);
635 bytes_per_image
= bytes_per_row
* rows_per_image
;
637 if (packing
->Invert
) {
638 /* set pixel_addr to the last row */
639 topOfImage
= bytes_per_row
* (height
- 1);
640 bytes_per_row
= -bytes_per_row
;
646 /* compute final pixel address */
647 pixel_addr
= (GLubyte
*) image
648 + (skipimages
+ img
) * bytes_per_image
650 + (skiprows
+ row
) * bytes_per_row
651 + (skippixels
+ column
) * bytes_per_pixel
;
654 return (GLvoid
*) pixel_addr
;
659 _mesa_image_address1d( const struct gl_pixelstore_attrib
*packing
,
662 GLenum format
, GLenum type
,
665 return _mesa_image_address(1, packing
, image
, width
, 1,
666 format
, type
, 0, 0, column
);
671 _mesa_image_address2d( const struct gl_pixelstore_attrib
*packing
,
673 GLsizei width
, GLsizei height
,
674 GLenum format
, GLenum type
,
675 GLint row
, GLint column
)
677 return _mesa_image_address(2, packing
, image
, width
, height
,
678 format
, type
, 0, row
, column
);
683 _mesa_image_address3d( const struct gl_pixelstore_attrib
*packing
,
685 GLsizei width
, GLsizei height
,
686 GLenum format
, GLenum type
,
687 GLint img
, GLint row
, GLint column
)
689 return _mesa_image_address(3, packing
, image
, width
, height
,
690 format
, type
, img
, row
, column
);
696 * Compute the stride (in bytes) between image rows.
698 * \param packing the pixelstore attributes
699 * \param width image width.
700 * \param format pixel format.
701 * \param type pixel data type.
703 * \return the stride in bytes for the given parameters, or -1 if error
706 _mesa_image_row_stride( const struct gl_pixelstore_attrib
*packing
,
707 GLint width
, GLenum format
, GLenum type
)
709 GLint bytesPerRow
, remainder
;
713 if (type
== GL_BITMAP
) {
714 if (packing
->RowLength
== 0) {
715 bytesPerRow
= (width
+ 7) / 8;
718 bytesPerRow
= (packing
->RowLength
+ 7) / 8;
722 /* Non-BITMAP data */
723 const GLint bytesPerPixel
= _mesa_bytes_per_pixel(format
, type
);
724 if (bytesPerPixel
<= 0)
725 return -1; /* error */
726 if (packing
->RowLength
== 0) {
727 bytesPerRow
= bytesPerPixel
* width
;
730 bytesPerRow
= bytesPerPixel
* packing
->RowLength
;
734 remainder
= bytesPerRow
% packing
->Alignment
;
736 bytesPerRow
+= (packing
->Alignment
- remainder
);
739 if (packing
->Invert
) {
740 /* negate the bytes per row (negative row stride) */
741 bytesPerRow
= -bytesPerRow
;
751 * Compute the stride between images in a 3D texture (in bytes) for the given
752 * pixel packing parameters and image width, format and type.
755 _mesa_image_image_stride( const struct gl_pixelstore_attrib
*packing
,
756 GLint width
, GLint height
,
757 GLenum format
, GLenum type
)
759 GLint bytesPerRow
, bytesPerImage
, remainder
;
763 if (type
== GL_BITMAP
) {
764 if (packing
->RowLength
== 0) {
765 bytesPerRow
= (width
+ 7) / 8;
768 bytesPerRow
= (packing
->RowLength
+ 7) / 8;
772 const GLint bytesPerPixel
= _mesa_bytes_per_pixel(format
, type
);
774 if (bytesPerPixel
<= 0)
775 return -1; /* error */
776 if (packing
->RowLength
== 0) {
777 bytesPerRow
= bytesPerPixel
* width
;
780 bytesPerRow
= bytesPerPixel
* packing
->RowLength
;
784 remainder
= bytesPerRow
% packing
->Alignment
;
786 bytesPerRow
+= (packing
->Alignment
- remainder
);
788 if (packing
->ImageHeight
== 0)
789 bytesPerImage
= bytesPerRow
* height
;
791 bytesPerImage
= bytesPerRow
* packing
->ImageHeight
;
793 return bytesPerImage
;
798 * Unpack a 32x32 pixel polygon stipple from user memory using the
799 * current pixel unpack settings.
802 _mesa_unpack_polygon_stipple( const GLubyte
*pattern
, GLuint dest
[32],
803 const struct gl_pixelstore_attrib
*unpacking
)
805 GLubyte
*ptrn
= (GLubyte
*) _mesa_unpack_bitmap(32, 32, pattern
, unpacking
);
807 /* Convert pattern from GLubytes to GLuints and handle big/little
812 for (i
= 0; i
< 32; i
++) {
813 dest
[i
] = (p
[0] << 24)
825 * Pack polygon stipple into user memory given current pixel packing
829 _mesa_pack_polygon_stipple( const GLuint pattern
[32], GLubyte
*dest
,
830 const struct gl_pixelstore_attrib
*packing
)
832 /* Convert pattern from GLuints to GLubytes to handle big/little
833 * endian differences.
837 for (i
= 0; i
< 32; i
++) {
838 ptrn
[i
* 4 + 0] = (GLubyte
) ((pattern
[i
] >> 24) & 0xff);
839 ptrn
[i
* 4 + 1] = (GLubyte
) ((pattern
[i
] >> 16) & 0xff);
840 ptrn
[i
* 4 + 2] = (GLubyte
) ((pattern
[i
] >> 8 ) & 0xff);
841 ptrn
[i
* 4 + 3] = (GLubyte
) ((pattern
[i
] ) & 0xff);
844 _mesa_pack_bitmap(32, 32, ptrn
, dest
, packing
);
849 * Unpack bitmap data. Resulting data will be in most-significant-bit-first
850 * order with row alignment = 1 byte.
853 _mesa_unpack_bitmap( GLint width
, GLint height
, const GLubyte
*pixels
,
854 const struct gl_pixelstore_attrib
*packing
)
856 GLint bytes
, row
, width_in_bytes
;
857 GLubyte
*buffer
, *dst
;
862 /* Alloc dest storage */
863 bytes
= ((width
+ 7) / 8 * height
);
864 buffer
= (GLubyte
*) _mesa_malloc( bytes
);
868 width_in_bytes
= CEILING( width
, 8 );
870 for (row
= 0; row
< height
; row
++) {
871 const GLubyte
*src
= (const GLubyte
*)
872 _mesa_image_address2d(packing
, pixels
, width
, height
,
873 GL_COLOR_INDEX
, GL_BITMAP
, row
, 0);
879 if ((packing
->SkipPixels
& 7) == 0) {
880 _mesa_memcpy( dst
, src
, width_in_bytes
);
881 if (packing
->LsbFirst
) {
882 flip_bytes( dst
, width_in_bytes
);
886 /* handling SkipPixels is a bit tricky (no pun intended!) */
888 if (packing
->LsbFirst
) {
889 GLubyte srcMask
= 1 << (packing
->SkipPixels
& 0x7);
890 GLubyte dstMask
= 128;
891 const GLubyte
*s
= src
;
894 for (i
= 0; i
< width
; i
++) {
898 if (srcMask
== 128) {
903 srcMask
= srcMask
<< 1;
911 dstMask
= dstMask
>> 1;
916 GLubyte srcMask
= 128 >> (packing
->SkipPixels
& 0x7);
917 GLubyte dstMask
= 128;
918 const GLubyte
*s
= src
;
921 for (i
= 0; i
< width
; i
++) {
930 srcMask
= srcMask
>> 1;
938 dstMask
= dstMask
>> 1;
943 dst
+= width_in_bytes
;
954 _mesa_pack_bitmap( GLint width
, GLint height
, const GLubyte
*source
,
955 GLubyte
*dest
, const struct gl_pixelstore_attrib
*packing
)
957 GLint row
, width_in_bytes
;
963 width_in_bytes
= CEILING( width
, 8 );
965 for (row
= 0; row
< height
; row
++) {
966 GLubyte
*dst
= (GLubyte
*) _mesa_image_address2d(packing
, dest
,
967 width
, height
, GL_COLOR_INDEX
, GL_BITMAP
, row
, 0);
971 if ((packing
->SkipPixels
& 7) == 0) {
972 _mesa_memcpy( dst
, src
, width_in_bytes
);
973 if (packing
->LsbFirst
) {
974 flip_bytes( dst
, width_in_bytes
);
978 /* handling SkipPixels is a bit tricky (no pun intended!) */
980 if (packing
->LsbFirst
) {
981 GLubyte srcMask
= 128;
982 GLubyte dstMask
= 1 << (packing
->SkipPixels
& 0x7);
983 const GLubyte
*s
= src
;
986 for (i
= 0; i
< width
; i
++) {
995 srcMask
= srcMask
>> 1;
997 if (dstMask
== 128) {
1003 dstMask
= dstMask
<< 1;
1008 GLubyte srcMask
= 128;
1009 GLubyte dstMask
= 128 >> (packing
->SkipPixels
& 0x7);
1010 const GLubyte
*s
= src
;
1013 for (i
= 0; i
< width
; i
++) {
1022 srcMask
= srcMask
>> 1;
1030 dstMask
= dstMask
>> 1;
1035 src
+= width_in_bytes
;
1040 /**********************************************************************/
1041 /***** Pixel processing functions ******/
1042 /**********************************************************************/
1045 * Apply scale and bias factors to an array of RGBA pixels.
1048 _mesa_scale_and_bias_rgba(GLuint n
, GLfloat rgba
[][4],
1049 GLfloat rScale
, GLfloat gScale
,
1050 GLfloat bScale
, GLfloat aScale
,
1051 GLfloat rBias
, GLfloat gBias
,
1052 GLfloat bBias
, GLfloat aBias
)
1054 if (rScale
!= 1.0 || rBias
!= 0.0) {
1056 for (i
= 0; i
< n
; i
++) {
1057 rgba
[i
][RCOMP
] = rgba
[i
][RCOMP
] * rScale
+ rBias
;
1060 if (gScale
!= 1.0 || gBias
!= 0.0) {
1062 for (i
= 0; i
< n
; i
++) {
1063 rgba
[i
][GCOMP
] = rgba
[i
][GCOMP
] * gScale
+ gBias
;
1066 if (bScale
!= 1.0 || bBias
!= 0.0) {
1068 for (i
= 0; i
< n
; i
++) {
1069 rgba
[i
][BCOMP
] = rgba
[i
][BCOMP
] * bScale
+ bBias
;
1072 if (aScale
!= 1.0 || aBias
!= 0.0) {
1074 for (i
= 0; i
< n
; i
++) {
1075 rgba
[i
][ACOMP
] = rgba
[i
][ACOMP
] * aScale
+ aBias
;
1082 * Apply pixel mapping to an array of floating point RGBA pixels.
1085 _mesa_map_rgba( const GLcontext
*ctx
, GLuint n
, GLfloat rgba
[][4] )
1087 const GLfloat rscale
= (GLfloat
) (ctx
->PixelMaps
.RtoR
.Size
- 1);
1088 const GLfloat gscale
= (GLfloat
) (ctx
->PixelMaps
.GtoG
.Size
- 1);
1089 const GLfloat bscale
= (GLfloat
) (ctx
->PixelMaps
.BtoB
.Size
- 1);
1090 const GLfloat ascale
= (GLfloat
) (ctx
->PixelMaps
.AtoA
.Size
- 1);
1091 const GLfloat
*rMap
= ctx
->PixelMaps
.RtoR
.Map
;
1092 const GLfloat
*gMap
= ctx
->PixelMaps
.GtoG
.Map
;
1093 const GLfloat
*bMap
= ctx
->PixelMaps
.BtoB
.Map
;
1094 const GLfloat
*aMap
= ctx
->PixelMaps
.AtoA
.Map
;
1097 GLfloat r
= CLAMP(rgba
[i
][RCOMP
], 0.0F
, 1.0F
);
1098 GLfloat g
= CLAMP(rgba
[i
][GCOMP
], 0.0F
, 1.0F
);
1099 GLfloat b
= CLAMP(rgba
[i
][BCOMP
], 0.0F
, 1.0F
);
1100 GLfloat a
= CLAMP(rgba
[i
][ACOMP
], 0.0F
, 1.0F
);
1101 rgba
[i
][RCOMP
] = rMap
[IROUND(r
* rscale
)];
1102 rgba
[i
][GCOMP
] = gMap
[IROUND(g
* gscale
)];
1103 rgba
[i
][BCOMP
] = bMap
[IROUND(b
* bscale
)];
1104 rgba
[i
][ACOMP
] = aMap
[IROUND(a
* ascale
)];
1110 * Apply the color matrix and post color matrix scaling and biasing.
1113 _mesa_transform_rgba(const GLcontext
*ctx
, GLuint n
, GLfloat rgba
[][4])
1115 const GLfloat rs
= ctx
->Pixel
.PostColorMatrixScale
[0];
1116 const GLfloat rb
= ctx
->Pixel
.PostColorMatrixBias
[0];
1117 const GLfloat gs
= ctx
->Pixel
.PostColorMatrixScale
[1];
1118 const GLfloat gb
= ctx
->Pixel
.PostColorMatrixBias
[1];
1119 const GLfloat bs
= ctx
->Pixel
.PostColorMatrixScale
[2];
1120 const GLfloat bb
= ctx
->Pixel
.PostColorMatrixBias
[2];
1121 const GLfloat as
= ctx
->Pixel
.PostColorMatrixScale
[3];
1122 const GLfloat ab
= ctx
->Pixel
.PostColorMatrixBias
[3];
1123 const GLfloat
*m
= ctx
->ColorMatrixStack
.Top
->m
;
1125 for (i
= 0; i
< n
; i
++) {
1126 const GLfloat r
= rgba
[i
][RCOMP
];
1127 const GLfloat g
= rgba
[i
][GCOMP
];
1128 const GLfloat b
= rgba
[i
][BCOMP
];
1129 const GLfloat a
= rgba
[i
][ACOMP
];
1130 rgba
[i
][RCOMP
] = (m
[0] * r
+ m
[4] * g
+ m
[ 8] * b
+ m
[12] * a
) * rs
+ rb
;
1131 rgba
[i
][GCOMP
] = (m
[1] * r
+ m
[5] * g
+ m
[ 9] * b
+ m
[13] * a
) * gs
+ gb
;
1132 rgba
[i
][BCOMP
] = (m
[2] * r
+ m
[6] * g
+ m
[10] * b
+ m
[14] * a
) * bs
+ bb
;
1133 rgba
[i
][ACOMP
] = (m
[3] * r
+ m
[7] * g
+ m
[11] * b
+ m
[15] * a
) * as
+ ab
;
1139 * Apply a color table lookup to an array of floating point RGBA colors.
1142 _mesa_lookup_rgba_float(const struct gl_color_table
*table
,
1143 GLuint n
, GLfloat rgba
[][4])
1145 const GLint max
= table
->Size
- 1;
1146 const GLfloat scale
= (GLfloat
) max
;
1147 const GLfloat
*lut
= table
->TableF
;
1150 if (!table
->TableF
|| table
->Size
== 0)
1153 switch (table
->_BaseFormat
) {
1155 /* replace RGBA with I */
1156 for (i
= 0; i
< n
; i
++) {
1157 GLint j
= IROUND(rgba
[i
][RCOMP
] * scale
);
1158 GLfloat c
= lut
[CLAMP(j
, 0, max
)];
1166 /* replace RGB with L */
1167 for (i
= 0; i
< n
; i
++) {
1168 GLint j
= IROUND(rgba
[i
][RCOMP
] * scale
);
1169 GLfloat c
= lut
[CLAMP(j
, 0, max
)];
1176 /* replace A with A */
1177 for (i
= 0; i
< n
; i
++) {
1178 GLint j
= IROUND(rgba
[i
][ACOMP
] * scale
);
1179 rgba
[i
][ACOMP
] = lut
[CLAMP(j
, 0, max
)];
1182 case GL_LUMINANCE_ALPHA
:
1183 /* replace RGBA with LLLA */
1184 for (i
= 0; i
< n
; i
++) {
1185 GLint jL
= IROUND(rgba
[i
][RCOMP
] * scale
);
1186 GLint jA
= IROUND(rgba
[i
][ACOMP
] * scale
);
1187 GLfloat luminance
, alpha
;
1188 jL
= CLAMP(jL
, 0, max
);
1189 jA
= CLAMP(jA
, 0, max
);
1190 luminance
= lut
[jL
* 2 + 0];
1191 alpha
= lut
[jA
* 2 + 1];
1194 rgba
[i
][BCOMP
] = luminance
;
1195 rgba
[i
][ACOMP
] = alpha
;;
1199 /* replace RGB with RGB */
1200 for (i
= 0; i
< n
; i
++) {
1201 GLint jR
= IROUND(rgba
[i
][RCOMP
] * scale
);
1202 GLint jG
= IROUND(rgba
[i
][GCOMP
] * scale
);
1203 GLint jB
= IROUND(rgba
[i
][BCOMP
] * scale
);
1204 jR
= CLAMP(jR
, 0, max
);
1205 jG
= CLAMP(jG
, 0, max
);
1206 jB
= CLAMP(jB
, 0, max
);
1207 rgba
[i
][RCOMP
] = lut
[jR
* 3 + 0];
1208 rgba
[i
][GCOMP
] = lut
[jG
* 3 + 1];
1209 rgba
[i
][BCOMP
] = lut
[jB
* 3 + 2];
1213 /* replace RGBA with RGBA */
1214 for (i
= 0; i
< n
; i
++) {
1215 GLint jR
= IROUND(rgba
[i
][RCOMP
] * scale
);
1216 GLint jG
= IROUND(rgba
[i
][GCOMP
] * scale
);
1217 GLint jB
= IROUND(rgba
[i
][BCOMP
] * scale
);
1218 GLint jA
= IROUND(rgba
[i
][ACOMP
] * scale
);
1219 jR
= CLAMP(jR
, 0, max
);
1220 jG
= CLAMP(jG
, 0, max
);
1221 jB
= CLAMP(jB
, 0, max
);
1222 jA
= CLAMP(jA
, 0, max
);
1223 rgba
[i
][RCOMP
] = lut
[jR
* 4 + 0];
1224 rgba
[i
][GCOMP
] = lut
[jG
* 4 + 1];
1225 rgba
[i
][BCOMP
] = lut
[jB
* 4 + 2];
1226 rgba
[i
][ACOMP
] = lut
[jA
* 4 + 3];
1230 _mesa_problem(NULL
, "Bad format in _mesa_lookup_rgba_float");
1238 * Apply a color table lookup to an array of ubyte/RGBA colors.
1241 _mesa_lookup_rgba_ubyte(const struct gl_color_table
*table
,
1242 GLuint n
, GLubyte rgba
[][4])
1244 const GLubyte
*lut
= table
->TableUB
;
1245 const GLfloat scale
= (GLfloat
) (table
->Size
- 1) / (GLfloat
)255.0;
1248 if (!table
->TableUB
|| table
->Size
== 0)
1251 switch (table
->_BaseFormat
) {
1253 /* replace RGBA with I */
1254 if (table
->Size
== 256) {
1255 for (i
= 0; i
< n
; i
++) {
1256 const GLubyte c
= lut
[rgba
[i
][RCOMP
]];
1264 for (i
= 0; i
< n
; i
++) {
1265 GLint j
= IROUND((GLfloat
) rgba
[i
][RCOMP
] * scale
);
1269 rgba
[i
][ACOMP
] = lut
[j
];
1274 /* replace RGB with L */
1275 if (table
->Size
== 256) {
1276 for (i
= 0; i
< n
; i
++) {
1277 const GLubyte c
= lut
[rgba
[i
][RCOMP
]];
1284 for (i
= 0; i
< n
; i
++) {
1285 GLint j
= IROUND((GLfloat
) rgba
[i
][RCOMP
] * scale
);
1288 rgba
[i
][BCOMP
] = lut
[j
];
1293 /* replace A with A */
1294 if (table
->Size
== 256) {
1295 for (i
= 0; i
< n
; i
++) {
1296 rgba
[i
][ACOMP
] = lut
[rgba
[i
][ACOMP
]];
1300 for (i
= 0; i
< n
; i
++) {
1301 GLint j
= IROUND((GLfloat
) rgba
[i
][ACOMP
] * scale
);
1302 rgba
[i
][ACOMP
] = lut
[j
];
1306 case GL_LUMINANCE_ALPHA
:
1307 /* replace RGBA with LLLA */
1308 if (table
->Size
== 256) {
1309 for (i
= 0; i
< n
; i
++) {
1310 GLubyte l
= lut
[rgba
[i
][RCOMP
] * 2 + 0];
1311 GLubyte a
= lut
[rgba
[i
][ACOMP
] * 2 + 1];;
1319 for (i
= 0; i
< n
; i
++) {
1320 GLint jL
= IROUND((GLfloat
) rgba
[i
][RCOMP
] * scale
);
1321 GLint jA
= IROUND((GLfloat
) rgba
[i
][ACOMP
] * scale
);
1322 GLubyte luminance
= lut
[jL
* 2 + 0];
1323 GLubyte alpha
= lut
[jA
* 2 + 1];
1326 rgba
[i
][BCOMP
] = luminance
;
1327 rgba
[i
][ACOMP
] = alpha
;
1332 if (table
->Size
== 256) {
1333 for (i
= 0; i
< n
; i
++) {
1334 rgba
[i
][RCOMP
] = lut
[rgba
[i
][RCOMP
] * 3 + 0];
1335 rgba
[i
][GCOMP
] = lut
[rgba
[i
][GCOMP
] * 3 + 1];
1336 rgba
[i
][BCOMP
] = lut
[rgba
[i
][BCOMP
] * 3 + 2];
1340 for (i
= 0; i
< n
; i
++) {
1341 GLint jR
= IROUND((GLfloat
) rgba
[i
][RCOMP
] * scale
);
1342 GLint jG
= IROUND((GLfloat
) rgba
[i
][GCOMP
] * scale
);
1343 GLint jB
= IROUND((GLfloat
) rgba
[i
][BCOMP
] * scale
);
1344 rgba
[i
][RCOMP
] = lut
[jR
* 3 + 0];
1345 rgba
[i
][GCOMP
] = lut
[jG
* 3 + 1];
1346 rgba
[i
][BCOMP
] = lut
[jB
* 3 + 2];
1351 if (table
->Size
== 256) {
1352 for (i
= 0; i
< n
; i
++) {
1353 rgba
[i
][RCOMP
] = lut
[rgba
[i
][RCOMP
] * 4 + 0];
1354 rgba
[i
][GCOMP
] = lut
[rgba
[i
][GCOMP
] * 4 + 1];
1355 rgba
[i
][BCOMP
] = lut
[rgba
[i
][BCOMP
] * 4 + 2];
1356 rgba
[i
][ACOMP
] = lut
[rgba
[i
][ACOMP
] * 4 + 3];
1360 for (i
= 0; i
< n
; i
++) {
1361 GLint jR
= IROUND((GLfloat
) rgba
[i
][RCOMP
] * scale
);
1362 GLint jG
= IROUND((GLfloat
) rgba
[i
][GCOMP
] * scale
);
1363 GLint jB
= IROUND((GLfloat
) rgba
[i
][BCOMP
] * scale
);
1364 GLint jA
= IROUND((GLfloat
) rgba
[i
][ACOMP
] * scale
);
1365 CLAMPED_FLOAT_TO_CHAN(rgba
[i
][RCOMP
], lut
[jR
* 4 + 0]);
1366 CLAMPED_FLOAT_TO_CHAN(rgba
[i
][GCOMP
], lut
[jG
* 4 + 1]);
1367 CLAMPED_FLOAT_TO_CHAN(rgba
[i
][BCOMP
], lut
[jB
* 4 + 2]);
1368 CLAMPED_FLOAT_TO_CHAN(rgba
[i
][ACOMP
], lut
[jA
* 4 + 3]);
1373 _mesa_problem(NULL
, "Bad format in _mesa_lookup_rgba_chan");
1381 * Map color indexes to float rgba values.
1384 _mesa_map_ci_to_rgba( const GLcontext
*ctx
, GLuint n
,
1385 const GLuint index
[], GLfloat rgba
[][4] )
1387 GLuint rmask
= ctx
->PixelMaps
.ItoR
.Size
- 1;
1388 GLuint gmask
= ctx
->PixelMaps
.ItoG
.Size
- 1;
1389 GLuint bmask
= ctx
->PixelMaps
.ItoB
.Size
- 1;
1390 GLuint amask
= ctx
->PixelMaps
.ItoA
.Size
- 1;
1391 const GLfloat
*rMap
= ctx
->PixelMaps
.ItoR
.Map
;
1392 const GLfloat
*gMap
= ctx
->PixelMaps
.ItoG
.Map
;
1393 const GLfloat
*bMap
= ctx
->PixelMaps
.ItoB
.Map
;
1394 const GLfloat
*aMap
= ctx
->PixelMaps
.ItoA
.Map
;
1397 rgba
[i
][RCOMP
] = rMap
[index
[i
] & rmask
];
1398 rgba
[i
][GCOMP
] = gMap
[index
[i
] & gmask
];
1399 rgba
[i
][BCOMP
] = bMap
[index
[i
] & bmask
];
1400 rgba
[i
][ACOMP
] = aMap
[index
[i
] & amask
];
1406 * Map ubyte color indexes to ubyte/RGBA values.
1409 _mesa_map_ci8_to_rgba8(const GLcontext
*ctx
, GLuint n
, const GLubyte index
[],
1412 GLuint rmask
= ctx
->PixelMaps
.ItoR
.Size
- 1;
1413 GLuint gmask
= ctx
->PixelMaps
.ItoG
.Size
- 1;
1414 GLuint bmask
= ctx
->PixelMaps
.ItoB
.Size
- 1;
1415 GLuint amask
= ctx
->PixelMaps
.ItoA
.Size
- 1;
1416 const GLubyte
*rMap
= ctx
->PixelMaps
.ItoR
.Map8
;
1417 const GLubyte
*gMap
= ctx
->PixelMaps
.ItoG
.Map8
;
1418 const GLubyte
*bMap
= ctx
->PixelMaps
.ItoB
.Map8
;
1419 const GLubyte
*aMap
= ctx
->PixelMaps
.ItoA
.Map8
;
1422 rgba
[i
][RCOMP
] = rMap
[index
[i
] & rmask
];
1423 rgba
[i
][GCOMP
] = gMap
[index
[i
] & gmask
];
1424 rgba
[i
][BCOMP
] = bMap
[index
[i
] & bmask
];
1425 rgba
[i
][ACOMP
] = aMap
[index
[i
] & amask
];
1431 _mesa_scale_and_bias_depth(const GLcontext
*ctx
, GLuint n
,
1432 GLfloat depthValues
[])
1434 const GLfloat scale
= ctx
->Pixel
.DepthScale
;
1435 const GLfloat bias
= ctx
->Pixel
.DepthBias
;
1437 for (i
= 0; i
< n
; i
++) {
1438 GLfloat d
= depthValues
[i
] * scale
+ bias
;
1439 depthValues
[i
] = CLAMP(d
, 0.0F
, 1.0F
);
1445 _mesa_scale_and_bias_depth_uint(const GLcontext
*ctx
, GLuint n
,
1446 GLuint depthValues
[])
1448 const GLdouble max
= (double) 0xffffffff;
1449 const GLdouble scale
= ctx
->Pixel
.DepthScale
;
1450 const GLdouble bias
= ctx
->Pixel
.DepthBias
* max
;
1452 for (i
= 0; i
< n
; i
++) {
1453 GLdouble d
= (GLdouble
) depthValues
[i
] * scale
+ bias
;
1454 d
= CLAMP(d
, 0.0, max
);
1455 depthValues
[i
] = (GLuint
) d
;
1462 * Update the min/max values from an array of fragment colors.
1465 update_minmax(GLcontext
*ctx
, GLuint n
, const GLfloat rgba
[][4])
1468 for (i
= 0; i
< n
; i
++) {
1470 if (rgba
[i
][RCOMP
] < ctx
->MinMax
.Min
[RCOMP
])
1471 ctx
->MinMax
.Min
[RCOMP
] = rgba
[i
][RCOMP
];
1472 if (rgba
[i
][GCOMP
] < ctx
->MinMax
.Min
[GCOMP
])
1473 ctx
->MinMax
.Min
[GCOMP
] = rgba
[i
][GCOMP
];
1474 if (rgba
[i
][BCOMP
] < ctx
->MinMax
.Min
[BCOMP
])
1475 ctx
->MinMax
.Min
[BCOMP
] = rgba
[i
][BCOMP
];
1476 if (rgba
[i
][ACOMP
] < ctx
->MinMax
.Min
[ACOMP
])
1477 ctx
->MinMax
.Min
[ACOMP
] = rgba
[i
][ACOMP
];
1480 if (rgba
[i
][RCOMP
] > ctx
->MinMax
.Max
[RCOMP
])
1481 ctx
->MinMax
.Max
[RCOMP
] = rgba
[i
][RCOMP
];
1482 if (rgba
[i
][GCOMP
] > ctx
->MinMax
.Max
[GCOMP
])
1483 ctx
->MinMax
.Max
[GCOMP
] = rgba
[i
][GCOMP
];
1484 if (rgba
[i
][BCOMP
] > ctx
->MinMax
.Max
[BCOMP
])
1485 ctx
->MinMax
.Max
[BCOMP
] = rgba
[i
][BCOMP
];
1486 if (rgba
[i
][ACOMP
] > ctx
->MinMax
.Max
[ACOMP
])
1487 ctx
->MinMax
.Max
[ACOMP
] = rgba
[i
][ACOMP
];
1493 * Update the histogram values from an array of fragment colors.
1496 update_histogram(GLcontext
*ctx
, GLuint n
, const GLfloat rgba
[][4])
1498 const GLint max
= ctx
->Histogram
.Width
- 1;
1499 GLfloat w
= (GLfloat
) max
;
1502 if (ctx
->Histogram
.Width
== 0)
1505 for (i
= 0; i
< n
; i
++) {
1506 GLint ri
= IROUND(rgba
[i
][RCOMP
] * w
);
1507 GLint gi
= IROUND(rgba
[i
][GCOMP
] * w
);
1508 GLint bi
= IROUND(rgba
[i
][BCOMP
] * w
);
1509 GLint ai
= IROUND(rgba
[i
][ACOMP
] * w
);
1510 ri
= CLAMP(ri
, 0, max
);
1511 gi
= CLAMP(gi
, 0, max
);
1512 bi
= CLAMP(bi
, 0, max
);
1513 ai
= CLAMP(ai
, 0, max
);
1514 ctx
->Histogram
.Count
[ri
][RCOMP
]++;
1515 ctx
->Histogram
.Count
[gi
][GCOMP
]++;
1516 ctx
->Histogram
.Count
[bi
][BCOMP
]++;
1517 ctx
->Histogram
.Count
[ai
][ACOMP
]++;
1523 * Apply various pixel transfer operations to an array of RGBA pixels
1524 * as indicated by the transferOps bitmask
1527 _mesa_apply_rgba_transfer_ops(GLcontext
*ctx
, GLbitfield transferOps
,
1528 GLuint n
, GLfloat rgba
[][4])
1531 if (transferOps
& IMAGE_SCALE_BIAS_BIT
) {
1532 _mesa_scale_and_bias_rgba(n
, rgba
,
1533 ctx
->Pixel
.RedScale
, ctx
->Pixel
.GreenScale
,
1534 ctx
->Pixel
.BlueScale
, ctx
->Pixel
.AlphaScale
,
1535 ctx
->Pixel
.RedBias
, ctx
->Pixel
.GreenBias
,
1536 ctx
->Pixel
.BlueBias
, ctx
->Pixel
.AlphaBias
);
1538 /* color map lookup */
1539 if (transferOps
& IMAGE_MAP_COLOR_BIT
) {
1540 _mesa_map_rgba( ctx
, n
, rgba
);
1542 /* GL_COLOR_TABLE lookup */
1543 if (transferOps
& IMAGE_COLOR_TABLE_BIT
) {
1544 _mesa_lookup_rgba_float(&ctx
->ColorTable
[COLORTABLE_PRECONVOLUTION
], n
, rgba
);
1547 if (transferOps
& IMAGE_CONVOLUTION_BIT
) {
1548 /* this has to be done in the calling code */
1549 _mesa_problem(ctx
, "IMAGE_CONVOLUTION_BIT set in _mesa_apply_transfer_ops");
1551 /* GL_POST_CONVOLUTION_RED/GREEN/BLUE/ALPHA_SCALE/BIAS */
1552 if (transferOps
& IMAGE_POST_CONVOLUTION_SCALE_BIAS
) {
1553 _mesa_scale_and_bias_rgba(n
, rgba
,
1554 ctx
->Pixel
.PostConvolutionScale
[RCOMP
],
1555 ctx
->Pixel
.PostConvolutionScale
[GCOMP
],
1556 ctx
->Pixel
.PostConvolutionScale
[BCOMP
],
1557 ctx
->Pixel
.PostConvolutionScale
[ACOMP
],
1558 ctx
->Pixel
.PostConvolutionBias
[RCOMP
],
1559 ctx
->Pixel
.PostConvolutionBias
[GCOMP
],
1560 ctx
->Pixel
.PostConvolutionBias
[BCOMP
],
1561 ctx
->Pixel
.PostConvolutionBias
[ACOMP
]);
1563 /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
1564 if (transferOps
& IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT
) {
1565 _mesa_lookup_rgba_float(&ctx
->ColorTable
[COLORTABLE_POSTCONVOLUTION
], n
, rgba
);
1567 /* color matrix transform */
1568 if (transferOps
& IMAGE_COLOR_MATRIX_BIT
) {
1569 _mesa_transform_rgba(ctx
, n
, rgba
);
1571 /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
1572 if (transferOps
& IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT
) {
1573 _mesa_lookup_rgba_float(&ctx
->ColorTable
[COLORTABLE_POSTCOLORMATRIX
], n
, rgba
);
1575 /* update histogram count */
1576 if (transferOps
& IMAGE_HISTOGRAM_BIT
) {
1577 update_histogram(ctx
, n
, (CONST
GLfloat (*)[4]) rgba
);
1579 /* update min/max values */
1580 if (transferOps
& IMAGE_MIN_MAX_BIT
) {
1581 update_minmax(ctx
, n
, (CONST
GLfloat (*)[4]) rgba
);
1583 /* clamping to [0,1] */
1584 if (transferOps
& IMAGE_CLAMP_BIT
) {
1586 for (i
= 0; i
< n
; i
++) {
1587 rgba
[i
][RCOMP
] = CLAMP(rgba
[i
][RCOMP
], 0.0F
, 1.0F
);
1588 rgba
[i
][GCOMP
] = CLAMP(rgba
[i
][GCOMP
], 0.0F
, 1.0F
);
1589 rgba
[i
][BCOMP
] = CLAMP(rgba
[i
][BCOMP
], 0.0F
, 1.0F
);
1590 rgba
[i
][ACOMP
] = CLAMP(rgba
[i
][ACOMP
], 0.0F
, 1.0F
);
1597 * Apply color index shift and offset to an array of pixels.
1600 shift_and_offset_ci( const GLcontext
*ctx
, GLuint n
, GLuint indexes
[] )
1602 GLint shift
= ctx
->Pixel
.IndexShift
;
1603 GLint offset
= ctx
->Pixel
.IndexOffset
;
1607 indexes
[i
] = (indexes
[i
] << shift
) + offset
;
1610 else if (shift
< 0) {
1613 indexes
[i
] = (indexes
[i
] >> shift
) + offset
;
1618 indexes
[i
] = indexes
[i
] + offset
;
1626 * Apply color index shift, offset and table lookup to an array
1630 _mesa_apply_ci_transfer_ops(const GLcontext
*ctx
, GLbitfield transferOps
,
1631 GLuint n
, GLuint indexes
[])
1633 if (transferOps
& IMAGE_SHIFT_OFFSET_BIT
) {
1634 shift_and_offset_ci(ctx
, n
, indexes
);
1636 if (transferOps
& IMAGE_MAP_COLOR_BIT
) {
1637 const GLuint mask
= ctx
->PixelMaps
.ItoI
.Size
- 1;
1639 for (i
= 0; i
< n
; i
++) {
1640 const GLuint j
= indexes
[i
] & mask
;
1641 indexes
[i
] = IROUND(ctx
->PixelMaps
.ItoI
.Map
[j
]);
1648 * Apply stencil index shift, offset and table lookup to an array
1649 * of stencil values.
1652 _mesa_apply_stencil_transfer_ops(const GLcontext
*ctx
, GLuint n
,
1653 GLstencil stencil
[])
1655 if (ctx
->Pixel
.IndexShift
!= 0 || ctx
->Pixel
.IndexOffset
!= 0) {
1656 const GLint offset
= ctx
->Pixel
.IndexOffset
;
1657 GLint shift
= ctx
->Pixel
.IndexShift
;
1660 for (i
= 0; i
< n
; i
++) {
1661 stencil
[i
] = (stencil
[i
] << shift
) + offset
;
1664 else if (shift
< 0) {
1666 for (i
= 0; i
< n
; i
++) {
1667 stencil
[i
] = (stencil
[i
] >> shift
) + offset
;
1671 for (i
= 0; i
< n
; i
++) {
1672 stencil
[i
] = stencil
[i
] + offset
;
1676 if (ctx
->Pixel
.MapStencilFlag
) {
1677 GLuint mask
= ctx
->PixelMaps
.StoS
.Size
- 1;
1679 for (i
= 0; i
< n
; i
++) {
1680 stencil
[i
] = (GLstencil
)ctx
->PixelMaps
.StoS
.Map
[ stencil
[i
] & mask
];
1687 * Used to pack an array [][4] of RGBA float colors as specified
1688 * by the dstFormat, dstType and dstPacking. Used by glReadPixels,
1689 * glGetConvolutionFilter(), etc.
1690 * Note: the rgba values will be modified by this function when any pixel
1691 * transfer ops are enabled.
1694 _mesa_pack_rgba_span_float(GLcontext
*ctx
, GLuint n
, GLfloat rgba
[][4],
1695 GLenum dstFormat
, GLenum dstType
,
1697 const struct gl_pixelstore_attrib
*dstPacking
,
1698 GLbitfield transferOps
)
1700 GLfloat luminance
[MAX_WIDTH
];
1701 const GLint comps
= _mesa_components_in_format(dstFormat
);
1705 * This test should probably go away. Have the caller set/clear the
1706 * IMAGE_CLAMP_BIT as needed.
1708 if (dstType
!= GL_FLOAT
|| ctx
->Color
.ClampReadColor
== GL_TRUE
) {
1709 /* need to clamp to [0, 1] */
1710 transferOps
|= IMAGE_CLAMP_BIT
;
1714 _mesa_apply_rgba_transfer_ops(ctx
, transferOps
, n
, rgba
);
1715 if ((transferOps
& IMAGE_MIN_MAX_BIT
) && ctx
->MinMax
.Sink
) {
1720 if (dstFormat
== GL_LUMINANCE
|| dstFormat
== GL_LUMINANCE_ALPHA
) {
1721 /* compute luminance values */
1722 if (transferOps
& IMAGE_CLAMP_BIT
) {
1723 for (i
= 0; i
< n
; i
++) {
1724 GLfloat sum
= rgba
[i
][RCOMP
] + rgba
[i
][GCOMP
] + rgba
[i
][BCOMP
];
1725 luminance
[i
] = CLAMP(sum
, 0.0F
, 1.0F
);
1729 for (i
= 0; i
< n
; i
++) {
1730 luminance
[i
] = rgba
[i
][RCOMP
] + rgba
[i
][GCOMP
] + rgba
[i
][BCOMP
];
1736 * Pack/store the pixels. Ugh! Lots of cases!!!
1739 case GL_UNSIGNED_BYTE
:
1741 GLubyte
*dst
= (GLubyte
*) dstAddr
;
1742 switch (dstFormat
) {
1745 dst
[i
] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
1749 dst
[i
] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
1753 dst
[i
] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
1757 dst
[i
] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
1761 dst
[i
] = FLOAT_TO_UBYTE(luminance
[i
]);
1763 case GL_LUMINANCE_ALPHA
:
1765 dst
[i
*2+0] = FLOAT_TO_UBYTE(luminance
[i
]);
1766 dst
[i
*2+1] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
1771 dst
[i
*3+0] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
1772 dst
[i
*3+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
1773 dst
[i
*3+2] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
1778 dst
[i
*4+0] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
1779 dst
[i
*4+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
1780 dst
[i
*4+2] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
1781 dst
[i
*4+3] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
1786 dst
[i
*3+0] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
1787 dst
[i
*3+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
1788 dst
[i
*3+2] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
1793 dst
[i
*4+0] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
1794 dst
[i
*4+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
1795 dst
[i
*4+2] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
1796 dst
[i
*4+3] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
1801 dst
[i
*4+0] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
1802 dst
[i
*4+1] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
1803 dst
[i
*4+2] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
1804 dst
[i
*4+3] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
1810 dst
[i
*2+0] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
1811 dst
[i
*2+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
1815 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1821 GLbyte
*dst
= (GLbyte
*) dstAddr
;
1822 switch (dstFormat
) {
1825 dst
[i
] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
1829 dst
[i
] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
1833 dst
[i
] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
1837 dst
[i
] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
1841 dst
[i
] = FLOAT_TO_BYTE(luminance
[i
]);
1843 case GL_LUMINANCE_ALPHA
:
1845 dst
[i
*2+0] = FLOAT_TO_BYTE(luminance
[i
]);
1846 dst
[i
*2+1] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
1851 dst
[i
*3+0] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
1852 dst
[i
*3+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
1853 dst
[i
*3+2] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
1858 dst
[i
*4+0] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
1859 dst
[i
*4+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
1860 dst
[i
*4+2] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
1861 dst
[i
*4+3] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
1866 dst
[i
*3+0] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
1867 dst
[i
*3+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
1868 dst
[i
*3+2] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
1873 dst
[i
*4+0] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
1874 dst
[i
*4+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
1875 dst
[i
*4+2] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
1876 dst
[i
*4+3] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
1881 dst
[i
*4+0] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
1882 dst
[i
*4+1] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
1883 dst
[i
*4+2] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
1884 dst
[i
*4+3] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
1890 dst
[i
*2+0] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
1891 dst
[i
*2+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
1895 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1899 case GL_UNSIGNED_SHORT
:
1901 GLushort
*dst
= (GLushort
*) dstAddr
;
1902 switch (dstFormat
) {
1905 CLAMPED_FLOAT_TO_USHORT(dst
[i
], rgba
[i
][RCOMP
]);
1909 CLAMPED_FLOAT_TO_USHORT(dst
[i
], rgba
[i
][GCOMP
]);
1913 CLAMPED_FLOAT_TO_USHORT(dst
[i
], rgba
[i
][BCOMP
]);
1917 CLAMPED_FLOAT_TO_USHORT(dst
[i
], rgba
[i
][ACOMP
]);
1921 UNCLAMPED_FLOAT_TO_USHORT(dst
[i
], luminance
[i
]);
1923 case GL_LUMINANCE_ALPHA
:
1925 UNCLAMPED_FLOAT_TO_USHORT(dst
[i
*2+0], luminance
[i
]);
1926 CLAMPED_FLOAT_TO_USHORT(dst
[i
*2+1], rgba
[i
][ACOMP
]);
1931 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+0], rgba
[i
][RCOMP
]);
1932 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+1], rgba
[i
][GCOMP
]);
1933 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+2], rgba
[i
][BCOMP
]);
1938 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+0], rgba
[i
][RCOMP
]);
1939 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+1], rgba
[i
][GCOMP
]);
1940 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+2], rgba
[i
][BCOMP
]);
1941 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+3], rgba
[i
][ACOMP
]);
1946 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+0], rgba
[i
][BCOMP
]);
1947 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+1], rgba
[i
][GCOMP
]);
1948 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+2], rgba
[i
][RCOMP
]);
1953 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+0], rgba
[i
][BCOMP
]);
1954 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+1], rgba
[i
][GCOMP
]);
1955 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+2], rgba
[i
][RCOMP
]);
1956 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+3], rgba
[i
][ACOMP
]);
1961 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+0], rgba
[i
][ACOMP
]);
1962 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+1], rgba
[i
][BCOMP
]);
1963 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+2], rgba
[i
][GCOMP
]);
1964 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+3], rgba
[i
][RCOMP
]);
1970 dst
[i
*2+0] = FLOAT_TO_USHORT(rgba
[i
][RCOMP
]);
1971 dst
[i
*2+1] = FLOAT_TO_USHORT(rgba
[i
][GCOMP
]);
1975 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1981 GLshort
*dst
= (GLshort
*) dstAddr
;
1982 switch (dstFormat
) {
1985 dst
[i
] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1989 dst
[i
] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1993 dst
[i
] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1997 dst
[i
] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
2001 dst
[i
] = FLOAT_TO_SHORT(luminance
[i
]);
2003 case GL_LUMINANCE_ALPHA
:
2005 dst
[i
*2+0] = FLOAT_TO_SHORT(luminance
[i
]);
2006 dst
[i
*2+1] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
2011 dst
[i
*3+0] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
2012 dst
[i
*3+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
2013 dst
[i
*3+2] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
2018 dst
[i
*4+0] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
2019 dst
[i
*4+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
2020 dst
[i
*4+2] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
2021 dst
[i
*4+3] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
2026 dst
[i
*3+0] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
2027 dst
[i
*3+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
2028 dst
[i
*3+2] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
2033 dst
[i
*4+0] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
2034 dst
[i
*4+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
2035 dst
[i
*4+2] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
2036 dst
[i
*4+3] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
2041 dst
[i
*4+0] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
2042 dst
[i
*4+1] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
2043 dst
[i
*4+2] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
2044 dst
[i
*4+3] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
2050 dst
[i
*2+0] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
2051 dst
[i
*2+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
2055 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
2059 case GL_UNSIGNED_INT
:
2061 GLuint
*dst
= (GLuint
*) dstAddr
;
2062 switch (dstFormat
) {
2065 dst
[i
] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
2069 dst
[i
] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
2073 dst
[i
] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
2077 dst
[i
] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
2081 dst
[i
] = FLOAT_TO_UINT(luminance
[i
]);
2083 case GL_LUMINANCE_ALPHA
:
2085 dst
[i
*2+0] = FLOAT_TO_UINT(luminance
[i
]);
2086 dst
[i
*2+1] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
2091 dst
[i
*3+0] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
2092 dst
[i
*3+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
2093 dst
[i
*3+2] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
2098 dst
[i
*4+0] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
2099 dst
[i
*4+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
2100 dst
[i
*4+2] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
2101 dst
[i
*4+3] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
2106 dst
[i
*3+0] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
2107 dst
[i
*3+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
2108 dst
[i
*3+2] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
2113 dst
[i
*4+0] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
2114 dst
[i
*4+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
2115 dst
[i
*4+2] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
2116 dst
[i
*4+3] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
2121 dst
[i
*4+0] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
2122 dst
[i
*4+1] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
2123 dst
[i
*4+2] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
2124 dst
[i
*4+3] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
2130 dst
[i
*2+0] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
2131 dst
[i
*2+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
2135 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
2141 GLint
*dst
= (GLint
*) dstAddr
;
2142 switch (dstFormat
) {
2145 dst
[i
] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
2149 dst
[i
] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
2153 dst
[i
] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
2157 dst
[i
] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
2161 dst
[i
] = FLOAT_TO_INT(luminance
[i
]);
2163 case GL_LUMINANCE_ALPHA
:
2165 dst
[i
*2+0] = FLOAT_TO_INT(luminance
[i
]);
2166 dst
[i
*2+1] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
2171 dst
[i
*3+0] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
2172 dst
[i
*3+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
2173 dst
[i
*3+2] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
2178 dst
[i
*4+0] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
2179 dst
[i
*4+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
2180 dst
[i
*4+2] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
2181 dst
[i
*4+3] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
2186 dst
[i
*3+0] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
2187 dst
[i
*3+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
2188 dst
[i
*3+2] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
2193 dst
[i
*4+0] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
2194 dst
[i
*4+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
2195 dst
[i
*4+2] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
2196 dst
[i
*4+3] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
2201 dst
[i
*4+0] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
2202 dst
[i
*4+1] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
2203 dst
[i
*4+2] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
2204 dst
[i
*4+3] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
2210 dst
[i
*2+0] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
2211 dst
[i
*2+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
2215 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
2221 GLfloat
*dst
= (GLfloat
*) dstAddr
;
2222 switch (dstFormat
) {
2225 dst
[i
] = rgba
[i
][RCOMP
];
2229 dst
[i
] = rgba
[i
][GCOMP
];
2233 dst
[i
] = rgba
[i
][BCOMP
];
2237 dst
[i
] = rgba
[i
][ACOMP
];
2241 dst
[i
] = luminance
[i
];
2243 case GL_LUMINANCE_ALPHA
:
2245 dst
[i
*2+0] = luminance
[i
];
2246 dst
[i
*2+1] = rgba
[i
][ACOMP
];
2251 dst
[i
*3+0] = rgba
[i
][RCOMP
];
2252 dst
[i
*3+1] = rgba
[i
][GCOMP
];
2253 dst
[i
*3+2] = rgba
[i
][BCOMP
];
2258 dst
[i
*4+0] = rgba
[i
][RCOMP
];
2259 dst
[i
*4+1] = rgba
[i
][GCOMP
];
2260 dst
[i
*4+2] = rgba
[i
][BCOMP
];
2261 dst
[i
*4+3] = rgba
[i
][ACOMP
];
2266 dst
[i
*3+0] = rgba
[i
][BCOMP
];
2267 dst
[i
*3+1] = rgba
[i
][GCOMP
];
2268 dst
[i
*3+2] = rgba
[i
][RCOMP
];
2273 dst
[i
*4+0] = rgba
[i
][BCOMP
];
2274 dst
[i
*4+1] = rgba
[i
][GCOMP
];
2275 dst
[i
*4+2] = rgba
[i
][RCOMP
];
2276 dst
[i
*4+3] = rgba
[i
][ACOMP
];
2281 dst
[i
*4+0] = rgba
[i
][ACOMP
];
2282 dst
[i
*4+1] = rgba
[i
][BCOMP
];
2283 dst
[i
*4+2] = rgba
[i
][GCOMP
];
2284 dst
[i
*4+3] = rgba
[i
][RCOMP
];
2290 dst
[i
*2+0] = rgba
[i
][RCOMP
];
2291 dst
[i
*2+1] = rgba
[i
][GCOMP
];
2295 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
2299 case GL_HALF_FLOAT_ARB
:
2301 GLhalfARB
*dst
= (GLhalfARB
*) dstAddr
;
2302 switch (dstFormat
) {
2305 dst
[i
] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
2309 dst
[i
] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
2313 dst
[i
] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
2317 dst
[i
] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
2321 dst
[i
] = _mesa_float_to_half(luminance
[i
]);
2323 case GL_LUMINANCE_ALPHA
:
2325 dst
[i
*2+0] = _mesa_float_to_half(luminance
[i
]);
2326 dst
[i
*2+1] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
2331 dst
[i
*3+0] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
2332 dst
[i
*3+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
2333 dst
[i
*3+2] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
2338 dst
[i
*4+0] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
2339 dst
[i
*4+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
2340 dst
[i
*4+2] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
2341 dst
[i
*4+3] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
2346 dst
[i
*3+0] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
2347 dst
[i
*3+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
2348 dst
[i
*3+2] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
2353 dst
[i
*4+0] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
2354 dst
[i
*4+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
2355 dst
[i
*4+2] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
2356 dst
[i
*4+3] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
2361 dst
[i
*4+0] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
2362 dst
[i
*4+1] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
2363 dst
[i
*4+2] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
2364 dst
[i
*4+3] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
2370 dst
[i
*2+0] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
2371 dst
[i
*2+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
2375 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
2379 case GL_UNSIGNED_BYTE_3_3_2
:
2380 if (dstFormat
== GL_RGB
) {
2381 GLubyte
*dst
= (GLubyte
*) dstAddr
;
2383 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 7.0F
) << 5)
2384 | (IROUND(rgba
[i
][GCOMP
] * 7.0F
) << 2)
2385 | (IROUND(rgba
[i
][BCOMP
] * 3.0F
) );
2389 case GL_UNSIGNED_BYTE_2_3_3_REV
:
2390 if (dstFormat
== GL_RGB
) {
2391 GLubyte
*dst
= (GLubyte
*) dstAddr
;
2393 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 7.0F
) )
2394 | (IROUND(rgba
[i
][GCOMP
] * 7.0F
) << 3)
2395 | (IROUND(rgba
[i
][BCOMP
] * 3.0F
) << 6);
2399 case GL_UNSIGNED_SHORT_5_6_5
:
2400 if (dstFormat
== GL_RGB
) {
2401 GLushort
*dst
= (GLushort
*) dstAddr
;
2403 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 31.0F
) << 11)
2404 | (IROUND(rgba
[i
][GCOMP
] * 63.0F
) << 5)
2405 | (IROUND(rgba
[i
][BCOMP
] * 31.0F
) );
2409 case GL_UNSIGNED_SHORT_5_6_5_REV
:
2410 if (dstFormat
== GL_RGB
) {
2411 GLushort
*dst
= (GLushort
*) dstAddr
;
2413 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 31.0F
) )
2414 | (IROUND(rgba
[i
][GCOMP
] * 63.0F
) << 5)
2415 | (IROUND(rgba
[i
][BCOMP
] * 31.0F
) << 11);
2419 case GL_UNSIGNED_SHORT_4_4_4_4
:
2420 if (dstFormat
== GL_RGBA
) {
2421 GLushort
*dst
= (GLushort
*) dstAddr
;
2423 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 15.0F
) << 12)
2424 | (IROUND(rgba
[i
][GCOMP
] * 15.0F
) << 8)
2425 | (IROUND(rgba
[i
][BCOMP
] * 15.0F
) << 4)
2426 | (IROUND(rgba
[i
][ACOMP
] * 15.0F
) );
2429 else if (dstFormat
== GL_BGRA
) {
2430 GLushort
*dst
= (GLushort
*) dstAddr
;
2432 dst
[i
] = (IROUND(rgba
[i
][BCOMP
] * 15.0F
) << 12)
2433 | (IROUND(rgba
[i
][GCOMP
] * 15.0F
) << 8)
2434 | (IROUND(rgba
[i
][RCOMP
] * 15.0F
) << 4)
2435 | (IROUND(rgba
[i
][ACOMP
] * 15.0F
) );
2438 else if (dstFormat
== GL_ABGR_EXT
) {
2439 GLushort
*dst
= (GLushort
*) dstAddr
;
2441 dst
[i
] = (IROUND(rgba
[i
][ACOMP
] * 15.0F
) << 12)
2442 | (IROUND(rgba
[i
][BCOMP
] * 15.0F
) << 8)
2443 | (IROUND(rgba
[i
][GCOMP
] * 15.0F
) << 4)
2444 | (IROUND(rgba
[i
][RCOMP
] * 15.0F
) );
2448 case GL_UNSIGNED_SHORT_4_4_4_4_REV
:
2449 if (dstFormat
== GL_RGBA
) {
2450 GLushort
*dst
= (GLushort
*) dstAddr
;
2452 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 15.0F
) )
2453 | (IROUND(rgba
[i
][GCOMP
] * 15.0F
) << 4)
2454 | (IROUND(rgba
[i
][BCOMP
] * 15.0F
) << 8)
2455 | (IROUND(rgba
[i
][ACOMP
] * 15.0F
) << 12);
2458 else if (dstFormat
== GL_BGRA
) {
2459 GLushort
*dst
= (GLushort
*) dstAddr
;
2461 dst
[i
] = (IROUND(rgba
[i
][BCOMP
] * 15.0F
) )
2462 | (IROUND(rgba
[i
][GCOMP
] * 15.0F
) << 4)
2463 | (IROUND(rgba
[i
][RCOMP
] * 15.0F
) << 8)
2464 | (IROUND(rgba
[i
][ACOMP
] * 15.0F
) << 12);
2467 else if (dstFormat
== GL_ABGR_EXT
) {
2468 GLushort
*dst
= (GLushort
*) dstAddr
;
2470 dst
[i
] = (IROUND(rgba
[i
][ACOMP
] * 15.0F
) )
2471 | (IROUND(rgba
[i
][BCOMP
] * 15.0F
) << 4)
2472 | (IROUND(rgba
[i
][GCOMP
] * 15.0F
) << 8)
2473 | (IROUND(rgba
[i
][RCOMP
] * 15.0F
) << 12);
2477 case GL_UNSIGNED_SHORT_5_5_5_1
:
2478 if (dstFormat
== GL_RGBA
) {
2479 GLushort
*dst
= (GLushort
*) dstAddr
;
2481 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 31.0F
) << 11)
2482 | (IROUND(rgba
[i
][GCOMP
] * 31.0F
) << 6)
2483 | (IROUND(rgba
[i
][BCOMP
] * 31.0F
) << 1)
2484 | (IROUND(rgba
[i
][ACOMP
] * 1.0F
) );
2487 else if (dstFormat
== GL_BGRA
) {
2488 GLushort
*dst
= (GLushort
*) dstAddr
;
2490 dst
[i
] = (IROUND(rgba
[i
][BCOMP
] * 31.0F
) << 11)
2491 | (IROUND(rgba
[i
][GCOMP
] * 31.0F
) << 6)
2492 | (IROUND(rgba
[i
][RCOMP
] * 31.0F
) << 1)
2493 | (IROUND(rgba
[i
][ACOMP
] * 1.0F
) );
2496 else if (dstFormat
== GL_ABGR_EXT
) {
2497 GLushort
*dst
= (GLushort
*) dstAddr
;
2499 dst
[i
] = (IROUND(rgba
[i
][ACOMP
] * 31.0F
) << 11)
2500 | (IROUND(rgba
[i
][BCOMP
] * 31.0F
) << 6)
2501 | (IROUND(rgba
[i
][GCOMP
] * 31.0F
) << 1)
2502 | (IROUND(rgba
[i
][RCOMP
] * 1.0F
) );
2506 case GL_UNSIGNED_SHORT_1_5_5_5_REV
:
2507 if (dstFormat
== GL_RGBA
) {
2508 GLushort
*dst
= (GLushort
*) dstAddr
;
2510 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 31.0F
) )
2511 | (IROUND(rgba
[i
][GCOMP
] * 31.0F
) << 5)
2512 | (IROUND(rgba
[i
][BCOMP
] * 31.0F
) << 10)
2513 | (IROUND(rgba
[i
][ACOMP
] * 1.0F
) << 15);
2516 else if (dstFormat
== GL_BGRA
) {
2517 GLushort
*dst
= (GLushort
*) dstAddr
;
2519 dst
[i
] = (IROUND(rgba
[i
][BCOMP
] * 31.0F
) )
2520 | (IROUND(rgba
[i
][GCOMP
] * 31.0F
) << 5)
2521 | (IROUND(rgba
[i
][RCOMP
] * 31.0F
) << 10)
2522 | (IROUND(rgba
[i
][ACOMP
] * 1.0F
) << 15);
2525 else if (dstFormat
== GL_ABGR_EXT
) {
2526 GLushort
*dst
= (GLushort
*) dstAddr
;
2528 dst
[i
] = (IROUND(rgba
[i
][ACOMP
] * 31.0F
) )
2529 | (IROUND(rgba
[i
][BCOMP
] * 31.0F
) << 5)
2530 | (IROUND(rgba
[i
][GCOMP
] * 31.0F
) << 10)
2531 | (IROUND(rgba
[i
][RCOMP
] * 1.0F
) << 15);
2535 case GL_UNSIGNED_INT_8_8_8_8
:
2536 if (dstFormat
== GL_RGBA
) {
2537 GLuint
*dst
= (GLuint
*) dstAddr
;
2539 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 255.F
) << 24)
2540 | (IROUND(rgba
[i
][GCOMP
] * 255.F
) << 16)
2541 | (IROUND(rgba
[i
][BCOMP
] * 255.F
) << 8)
2542 | (IROUND(rgba
[i
][ACOMP
] * 255.F
) );
2545 else if (dstFormat
== GL_BGRA
) {
2546 GLuint
*dst
= (GLuint
*) dstAddr
;
2548 dst
[i
] = (IROUND(rgba
[i
][BCOMP
] * 255.F
) << 24)
2549 | (IROUND(rgba
[i
][GCOMP
] * 255.F
) << 16)
2550 | (IROUND(rgba
[i
][RCOMP
] * 255.F
) << 8)
2551 | (IROUND(rgba
[i
][ACOMP
] * 255.F
) );
2554 else if (dstFormat
== GL_ABGR_EXT
) {
2555 GLuint
*dst
= (GLuint
*) dstAddr
;
2557 dst
[i
] = (IROUND(rgba
[i
][ACOMP
] * 255.F
) << 24)
2558 | (IROUND(rgba
[i
][BCOMP
] * 255.F
) << 16)
2559 | (IROUND(rgba
[i
][GCOMP
] * 255.F
) << 8)
2560 | (IROUND(rgba
[i
][RCOMP
] * 255.F
) );
2564 case GL_UNSIGNED_INT_8_8_8_8_REV
:
2565 if (dstFormat
== GL_RGBA
) {
2566 GLuint
*dst
= (GLuint
*) dstAddr
;
2568 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 255.0F
) )
2569 | (IROUND(rgba
[i
][GCOMP
] * 255.0F
) << 8)
2570 | (IROUND(rgba
[i
][BCOMP
] * 255.0F
) << 16)
2571 | (IROUND(rgba
[i
][ACOMP
] * 255.0F
) << 24);
2574 else if (dstFormat
== GL_BGRA
) {
2575 GLuint
*dst
= (GLuint
*) dstAddr
;
2577 dst
[i
] = (IROUND(rgba
[i
][BCOMP
] * 255.0F
) )
2578 | (IROUND(rgba
[i
][GCOMP
] * 255.0F
) << 8)
2579 | (IROUND(rgba
[i
][RCOMP
] * 255.0F
) << 16)
2580 | (IROUND(rgba
[i
][ACOMP
] * 255.0F
) << 24);
2583 else if (dstFormat
== GL_ABGR_EXT
) {
2584 GLuint
*dst
= (GLuint
*) dstAddr
;
2586 dst
[i
] = (IROUND(rgba
[i
][ACOMP
] * 255.0F
) )
2587 | (IROUND(rgba
[i
][BCOMP
] * 255.0F
) << 8)
2588 | (IROUND(rgba
[i
][GCOMP
] * 255.0F
) << 16)
2589 | (IROUND(rgba
[i
][RCOMP
] * 255.0F
) << 24);
2593 case GL_UNSIGNED_INT_10_10_10_2
:
2594 if (dstFormat
== GL_RGBA
) {
2595 GLuint
*dst
= (GLuint
*) dstAddr
;
2597 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 1023.0F
) << 22)
2598 | (IROUND(rgba
[i
][GCOMP
] * 1023.0F
) << 12)
2599 | (IROUND(rgba
[i
][BCOMP
] * 1023.0F
) << 2)
2600 | (IROUND(rgba
[i
][ACOMP
] * 3.0F
) );
2603 else if (dstFormat
== GL_BGRA
) {
2604 GLuint
*dst
= (GLuint
*) dstAddr
;
2606 dst
[i
] = (IROUND(rgba
[i
][BCOMP
] * 1023.0F
) << 22)
2607 | (IROUND(rgba
[i
][GCOMP
] * 1023.0F
) << 12)
2608 | (IROUND(rgba
[i
][RCOMP
] * 1023.0F
) << 2)
2609 | (IROUND(rgba
[i
][ACOMP
] * 3.0F
) );
2612 else if (dstFormat
== GL_ABGR_EXT
) {
2613 GLuint
*dst
= (GLuint
*) dstAddr
;
2615 dst
[i
] = (IROUND(rgba
[i
][ACOMP
] * 1023.0F
) << 22)
2616 | (IROUND(rgba
[i
][BCOMP
] * 1023.0F
) << 12)
2617 | (IROUND(rgba
[i
][GCOMP
] * 1023.0F
) << 2)
2618 | (IROUND(rgba
[i
][RCOMP
] * 3.0F
) );
2622 case GL_UNSIGNED_INT_2_10_10_10_REV
:
2623 if (dstFormat
== GL_RGBA
) {
2624 GLuint
*dst
= (GLuint
*) dstAddr
;
2626 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 1023.0F
) )
2627 | (IROUND(rgba
[i
][GCOMP
] * 1023.0F
) << 10)
2628 | (IROUND(rgba
[i
][BCOMP
] * 1023.0F
) << 20)
2629 | (IROUND(rgba
[i
][ACOMP
] * 3.0F
) << 30);
2632 else if (dstFormat
== GL_BGRA
) {
2633 GLuint
*dst
= (GLuint
*) dstAddr
;
2635 dst
[i
] = (IROUND(rgba
[i
][BCOMP
] * 1023.0F
) )
2636 | (IROUND(rgba
[i
][GCOMP
] * 1023.0F
) << 10)
2637 | (IROUND(rgba
[i
][RCOMP
] * 1023.0F
) << 20)
2638 | (IROUND(rgba
[i
][ACOMP
] * 3.0F
) << 30);
2641 else if (dstFormat
== GL_ABGR_EXT
) {
2642 GLuint
*dst
= (GLuint
*) dstAddr
;
2644 dst
[i
] = (IROUND(rgba
[i
][ACOMP
] * 1023.0F
) )
2645 | (IROUND(rgba
[i
][BCOMP
] * 1023.0F
) << 10)
2646 | (IROUND(rgba
[i
][GCOMP
] * 1023.0F
) << 20)
2647 | (IROUND(rgba
[i
][RCOMP
] * 3.0F
) << 30);
2652 _mesa_problem(ctx
, "bad type in _mesa_pack_rgba_span_float");
2656 if (dstPacking
->SwapBytes
) {
2657 GLint swapSize
= _mesa_sizeof_packed_type(dstType
);
2658 if (swapSize
== 2) {
2659 if (dstPacking
->SwapBytes
) {
2660 _mesa_swap2((GLushort
*) dstAddr
, n
* comps
);
2663 else if (swapSize
== 4) {
2664 if (dstPacking
->SwapBytes
) {
2665 _mesa_swap4((GLuint
*) dstAddr
, n
* comps
);
2672 #define SWAP2BYTE(VALUE) \
2674 GLubyte *bytes = (GLubyte *) &(VALUE); \
2675 GLubyte tmp = bytes[0]; \
2676 bytes[0] = bytes[1]; \
2680 #define SWAP4BYTE(VALUE) \
2682 GLubyte *bytes = (GLubyte *) &(VALUE); \
2683 GLubyte tmp = bytes[0]; \
2684 bytes[0] = bytes[3]; \
2687 bytes[1] = bytes[2]; \
2693 extract_uint_indexes(GLuint n
, GLuint indexes
[],
2694 GLenum srcFormat
, GLenum srcType
, const GLvoid
*src
,
2695 const struct gl_pixelstore_attrib
*unpack
)
2697 ASSERT(srcFormat
== GL_COLOR_INDEX
|| srcFormat
== GL_STENCIL_INDEX
);
2699 ASSERT(srcType
== GL_BITMAP
||
2700 srcType
== GL_UNSIGNED_BYTE
||
2701 srcType
== GL_BYTE
||
2702 srcType
== GL_UNSIGNED_SHORT
||
2703 srcType
== GL_SHORT
||
2704 srcType
== GL_UNSIGNED_INT
||
2705 srcType
== GL_INT
||
2706 srcType
== GL_UNSIGNED_INT_24_8_EXT
||
2707 srcType
== GL_HALF_FLOAT_ARB
||
2708 srcType
== GL_FLOAT
);
2713 GLubyte
*ubsrc
= (GLubyte
*) src
;
2714 if (unpack
->LsbFirst
) {
2715 GLubyte mask
= 1 << (unpack
->SkipPixels
& 0x7);
2717 for (i
= 0; i
< n
; i
++) {
2718 indexes
[i
] = (*ubsrc
& mask
) ? 1 : 0;
2729 GLubyte mask
= 128 >> (unpack
->SkipPixels
& 0x7);
2731 for (i
= 0; i
< n
; i
++) {
2732 indexes
[i
] = (*ubsrc
& mask
) ? 1 : 0;
2744 case GL_UNSIGNED_BYTE
:
2747 const GLubyte
*s
= (const GLubyte
*) src
;
2748 for (i
= 0; i
< n
; i
++)
2755 const GLbyte
*s
= (const GLbyte
*) src
;
2756 for (i
= 0; i
< n
; i
++)
2760 case GL_UNSIGNED_SHORT
:
2763 const GLushort
*s
= (const GLushort
*) src
;
2764 if (unpack
->SwapBytes
) {
2765 for (i
= 0; i
< n
; i
++) {
2766 GLushort value
= s
[i
];
2772 for (i
= 0; i
< n
; i
++)
2780 const GLshort
*s
= (const GLshort
*) src
;
2781 if (unpack
->SwapBytes
) {
2782 for (i
= 0; i
< n
; i
++) {
2783 GLshort value
= s
[i
];
2789 for (i
= 0; i
< n
; i
++)
2794 case GL_UNSIGNED_INT
:
2797 const GLuint
*s
= (const GLuint
*) src
;
2798 if (unpack
->SwapBytes
) {
2799 for (i
= 0; i
< n
; i
++) {
2800 GLuint value
= s
[i
];
2806 for (i
= 0; i
< n
; i
++)
2814 const GLint
*s
= (const GLint
*) src
;
2815 if (unpack
->SwapBytes
) {
2816 for (i
= 0; i
< n
; i
++) {
2823 for (i
= 0; i
< n
; i
++)
2831 const GLfloat
*s
= (const GLfloat
*) src
;
2832 if (unpack
->SwapBytes
) {
2833 for (i
= 0; i
< n
; i
++) {
2834 GLfloat value
= s
[i
];
2836 indexes
[i
] = (GLuint
) value
;
2840 for (i
= 0; i
< n
; i
++)
2841 indexes
[i
] = (GLuint
) s
[i
];
2845 case GL_HALF_FLOAT_ARB
:
2848 const GLhalfARB
*s
= (const GLhalfARB
*) src
;
2849 if (unpack
->SwapBytes
) {
2850 for (i
= 0; i
< n
; i
++) {
2851 GLhalfARB value
= s
[i
];
2853 indexes
[i
] = (GLuint
) _mesa_half_to_float(value
);
2857 for (i
= 0; i
< n
; i
++)
2858 indexes
[i
] = (GLuint
) _mesa_half_to_float(s
[i
]);
2862 case GL_UNSIGNED_INT_24_8_EXT
:
2865 const GLuint
*s
= (const GLuint
*) src
;
2866 if (unpack
->SwapBytes
) {
2867 for (i
= 0; i
< n
; i
++) {
2868 GLuint value
= s
[i
];
2870 indexes
[i
] = value
& 0xff; /* lower 8 bits */
2874 for (i
= 0; i
< n
; i
++)
2875 indexes
[i
] = s
[i
] & 0xfff; /* lower 8 bits */
2881 _mesa_problem(NULL
, "bad srcType in extract_uint_indexes");
2888 * This function extracts floating point RGBA values from arbitrary
2889 * image data. srcFormat and srcType are the format and type parameters
2890 * passed to glDrawPixels, glTexImage[123]D, glTexSubImage[123]D, etc.
2892 * Refering to section 3.6.4 of the OpenGL 1.2 spec, this function
2893 * implements the "Conversion to floating point", "Conversion to RGB",
2894 * and "Final Expansion to RGBA" operations.
2896 * Args: n - number of pixels
2897 * rgba - output colors
2898 * srcFormat - format of incoming data
2899 * srcType - data type of incoming data
2900 * src - source data pointer
2901 * swapBytes - perform byteswapping of incoming data?
2904 extract_float_rgba(GLuint n
, GLfloat rgba
[][4],
2905 GLenum srcFormat
, GLenum srcType
, const GLvoid
*src
,
2906 GLboolean swapBytes
)
2908 GLint redIndex
, greenIndex
, blueIndex
, alphaIndex
;
2910 GLint rComp
, bComp
, gComp
, aComp
;
2912 ASSERT(srcFormat
== GL_RED
||
2913 srcFormat
== GL_GREEN
||
2914 srcFormat
== GL_BLUE
||
2915 srcFormat
== GL_ALPHA
||
2916 srcFormat
== GL_LUMINANCE
||
2917 srcFormat
== GL_LUMINANCE_ALPHA
||
2918 srcFormat
== GL_INTENSITY
||
2919 srcFormat
== GL_RGB
||
2920 srcFormat
== GL_BGR
||
2921 srcFormat
== GL_RGBA
||
2922 srcFormat
== GL_BGRA
||
2923 srcFormat
== GL_ABGR_EXT
||
2924 srcFormat
== GL_DUDV_ATI
);
2926 ASSERT(srcType
== GL_UNSIGNED_BYTE
||
2927 srcType
== GL_BYTE
||
2928 srcType
== GL_UNSIGNED_SHORT
||
2929 srcType
== GL_SHORT
||
2930 srcType
== GL_UNSIGNED_INT
||
2931 srcType
== GL_INT
||
2932 srcType
== GL_HALF_FLOAT_ARB
||
2933 srcType
== GL_FLOAT
||
2934 srcType
== GL_UNSIGNED_BYTE_3_3_2
||
2935 srcType
== GL_UNSIGNED_BYTE_2_3_3_REV
||
2936 srcType
== GL_UNSIGNED_SHORT_5_6_5
||
2937 srcType
== GL_UNSIGNED_SHORT_5_6_5_REV
||
2938 srcType
== GL_UNSIGNED_SHORT_4_4_4_4
||
2939 srcType
== GL_UNSIGNED_SHORT_4_4_4_4_REV
||
2940 srcType
== GL_UNSIGNED_SHORT_5_5_5_1
||
2941 srcType
== GL_UNSIGNED_SHORT_1_5_5_5_REV
||
2942 srcType
== GL_UNSIGNED_INT_8_8_8_8
||
2943 srcType
== GL_UNSIGNED_INT_8_8_8_8_REV
||
2944 srcType
== GL_UNSIGNED_INT_10_10_10_2
||
2945 srcType
== GL_UNSIGNED_INT_2_10_10_10_REV
);
2947 rComp
= gComp
= bComp
= aComp
= -1;
2949 switch (srcFormat
) {
2952 greenIndex
= blueIndex
= alphaIndex
= -1;
2957 redIndex
= blueIndex
= alphaIndex
= -1;
2962 redIndex
= greenIndex
= alphaIndex
= -1;
2966 redIndex
= greenIndex
= blueIndex
= -1;
2971 redIndex
= greenIndex
= blueIndex
= 0;
2975 case GL_LUMINANCE_ALPHA
:
2976 redIndex
= greenIndex
= blueIndex
= 0;
2981 redIndex
= greenIndex
= blueIndex
= alphaIndex
= 0;
3047 _mesa_problem(NULL
, "bad srcFormat in extract float data");
3052 #define PROCESS(INDEX, CHANNEL, DEFAULT, TYPE, CONVERSION) \
3053 if ((INDEX) < 0) { \
3055 for (i = 0; i < n; i++) { \
3056 rgba[i][CHANNEL] = DEFAULT; \
3059 else if (swapBytes) { \
3060 const TYPE *s = (const TYPE *) src; \
3062 for (i = 0; i < n; i++) { \
3063 TYPE value = s[INDEX]; \
3064 if (sizeof(TYPE) == 2) { \
3067 else if (sizeof(TYPE) == 4) { \
3070 rgba[i][CHANNEL] = (GLfloat) CONVERSION(value); \
3075 const TYPE *s = (const TYPE *) src; \
3077 for (i = 0; i < n; i++) { \
3078 rgba[i][CHANNEL] = (GLfloat) CONVERSION(s[INDEX]); \
3084 case GL_UNSIGNED_BYTE
:
3085 PROCESS(redIndex
, RCOMP
, 0.0F
, GLubyte
, UBYTE_TO_FLOAT
);
3086 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLubyte
, UBYTE_TO_FLOAT
);
3087 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLubyte
, UBYTE_TO_FLOAT
);
3088 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLubyte
, UBYTE_TO_FLOAT
);
3091 PROCESS(redIndex
, RCOMP
, 0.0F
, GLbyte
, BYTE_TO_FLOAT
);
3092 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLbyte
, BYTE_TO_FLOAT
);
3093 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLbyte
, BYTE_TO_FLOAT
);
3094 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLbyte
, BYTE_TO_FLOAT
);
3096 case GL_UNSIGNED_SHORT
:
3097 PROCESS(redIndex
, RCOMP
, 0.0F
, GLushort
, USHORT_TO_FLOAT
);
3098 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLushort
, USHORT_TO_FLOAT
);
3099 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLushort
, USHORT_TO_FLOAT
);
3100 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLushort
, USHORT_TO_FLOAT
);
3103 PROCESS(redIndex
, RCOMP
, 0.0F
, GLshort
, SHORT_TO_FLOAT
);
3104 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLshort
, SHORT_TO_FLOAT
);
3105 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLshort
, SHORT_TO_FLOAT
);
3106 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLshort
, SHORT_TO_FLOAT
);
3108 case GL_UNSIGNED_INT
:
3109 PROCESS(redIndex
, RCOMP
, 0.0F
, GLuint
, UINT_TO_FLOAT
);
3110 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLuint
, UINT_TO_FLOAT
);
3111 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLuint
, UINT_TO_FLOAT
);
3112 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLuint
, UINT_TO_FLOAT
);
3115 PROCESS(redIndex
, RCOMP
, 0.0F
, GLint
, INT_TO_FLOAT
);
3116 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLint
, INT_TO_FLOAT
);
3117 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLint
, INT_TO_FLOAT
);
3118 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLint
, INT_TO_FLOAT
);
3121 PROCESS(redIndex
, RCOMP
, 0.0F
, GLfloat
, (GLfloat
));
3122 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLfloat
, (GLfloat
));
3123 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLfloat
, (GLfloat
));
3124 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLfloat
, (GLfloat
));
3126 case GL_HALF_FLOAT_ARB
:
3127 PROCESS(redIndex
, RCOMP
, 0.0F
, GLhalfARB
, _mesa_half_to_float
);
3128 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLhalfARB
, _mesa_half_to_float
);
3129 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLhalfARB
, _mesa_half_to_float
);
3130 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLhalfARB
, _mesa_half_to_float
);
3132 case GL_UNSIGNED_BYTE_3_3_2
:
3134 const GLubyte
*ubsrc
= (const GLubyte
*) src
;
3136 for (i
= 0; i
< n
; i
++) {
3137 GLubyte p
= ubsrc
[i
];
3138 rgba
[i
][rComp
] = ((p
>> 5) ) * (1.0F
/ 7.0F
);
3139 rgba
[i
][gComp
] = ((p
>> 2) & 0x7) * (1.0F
/ 7.0F
);
3140 rgba
[i
][bComp
] = ((p
) & 0x3) * (1.0F
/ 3.0F
);
3141 rgba
[i
][aComp
] = 1.0F
;
3145 case GL_UNSIGNED_BYTE_2_3_3_REV
:
3147 const GLubyte
*ubsrc
= (const GLubyte
*) src
;
3149 for (i
= 0; i
< n
; i
++) {
3150 GLubyte p
= ubsrc
[i
];
3151 rgba
[i
][rComp
] = ((p
) & 0x7) * (1.0F
/ 7.0F
);
3152 rgba
[i
][gComp
] = ((p
>> 3) & 0x7) * (1.0F
/ 7.0F
);
3153 rgba
[i
][bComp
] = ((p
>> 6) ) * (1.0F
/ 3.0F
);
3154 rgba
[i
][aComp
] = 1.0F
;
3158 case GL_UNSIGNED_SHORT_5_6_5
:
3160 const GLushort
*ussrc
= (const GLushort
*) src
;
3162 for (i
= 0; i
< n
; i
++) {
3163 GLushort p
= ussrc
[i
];
3165 rgba
[i
][rComp
] = ((p
>> 11) ) * (1.0F
/ 31.0F
);
3166 rgba
[i
][gComp
] = ((p
>> 5) & 0x3f) * (1.0F
/ 63.0F
);
3167 rgba
[i
][bComp
] = ((p
) & 0x1f) * (1.0F
/ 31.0F
);
3168 rgba
[i
][aComp
] = 1.0F
;
3172 const GLushort
*ussrc
= (const GLushort
*) src
;
3174 for (i
= 0; i
< n
; i
++) {
3175 GLushort p
= ussrc
[i
];
3176 rgba
[i
][rComp
] = ((p
>> 11) ) * (1.0F
/ 31.0F
);
3177 rgba
[i
][gComp
] = ((p
>> 5) & 0x3f) * (1.0F
/ 63.0F
);
3178 rgba
[i
][bComp
] = ((p
) & 0x1f) * (1.0F
/ 31.0F
);
3179 rgba
[i
][aComp
] = 1.0F
;
3183 case GL_UNSIGNED_SHORT_5_6_5_REV
:
3185 const GLushort
*ussrc
= (const GLushort
*) src
;
3187 for (i
= 0; i
< n
; i
++) {
3188 GLushort p
= ussrc
[i
];
3190 rgba
[i
][rComp
] = ((p
) & 0x1f) * (1.0F
/ 31.0F
);
3191 rgba
[i
][gComp
] = ((p
>> 5) & 0x3f) * (1.0F
/ 63.0F
);
3192 rgba
[i
][bComp
] = ((p
>> 11) ) * (1.0F
/ 31.0F
);
3193 rgba
[i
][aComp
] = 1.0F
;
3197 const GLushort
*ussrc
= (const GLushort
*) src
;
3199 for (i
= 0; i
< n
; i
++) {
3200 GLushort p
= ussrc
[i
];
3201 rgba
[i
][rComp
] = ((p
) & 0x1f) * (1.0F
/ 31.0F
);
3202 rgba
[i
][gComp
] = ((p
>> 5) & 0x3f) * (1.0F
/ 63.0F
);
3203 rgba
[i
][bComp
] = ((p
>> 11) ) * (1.0F
/ 31.0F
);
3204 rgba
[i
][aComp
] = 1.0F
;
3208 case GL_UNSIGNED_SHORT_4_4_4_4
:
3210 const GLushort
*ussrc
= (const GLushort
*) src
;
3212 for (i
= 0; i
< n
; i
++) {
3213 GLushort p
= ussrc
[i
];
3215 rgba
[i
][rComp
] = ((p
>> 12) ) * (1.0F
/ 15.0F
);
3216 rgba
[i
][gComp
] = ((p
>> 8) & 0xf) * (1.0F
/ 15.0F
);
3217 rgba
[i
][bComp
] = ((p
>> 4) & 0xf) * (1.0F
/ 15.0F
);
3218 rgba
[i
][aComp
] = ((p
) & 0xf) * (1.0F
/ 15.0F
);
3222 const GLushort
*ussrc
= (const GLushort
*) src
;
3224 for (i
= 0; i
< n
; i
++) {
3225 GLushort p
= ussrc
[i
];
3226 rgba
[i
][rComp
] = ((p
>> 12) ) * (1.0F
/ 15.0F
);
3227 rgba
[i
][gComp
] = ((p
>> 8) & 0xf) * (1.0F
/ 15.0F
);
3228 rgba
[i
][bComp
] = ((p
>> 4) & 0xf) * (1.0F
/ 15.0F
);
3229 rgba
[i
][aComp
] = ((p
) & 0xf) * (1.0F
/ 15.0F
);
3233 case GL_UNSIGNED_SHORT_4_4_4_4_REV
:
3235 const GLushort
*ussrc
= (const GLushort
*) src
;
3237 for (i
= 0; i
< n
; i
++) {
3238 GLushort p
= ussrc
[i
];
3240 rgba
[i
][rComp
] = ((p
) & 0xf) * (1.0F
/ 15.0F
);
3241 rgba
[i
][gComp
] = ((p
>> 4) & 0xf) * (1.0F
/ 15.0F
);
3242 rgba
[i
][bComp
] = ((p
>> 8) & 0xf) * (1.0F
/ 15.0F
);
3243 rgba
[i
][aComp
] = ((p
>> 12) ) * (1.0F
/ 15.0F
);
3247 const GLushort
*ussrc
= (const GLushort
*) src
;
3249 for (i
= 0; i
< n
; i
++) {
3250 GLushort p
= ussrc
[i
];
3251 rgba
[i
][rComp
] = ((p
) & 0xf) * (1.0F
/ 15.0F
);
3252 rgba
[i
][gComp
] = ((p
>> 4) & 0xf) * (1.0F
/ 15.0F
);
3253 rgba
[i
][bComp
] = ((p
>> 8) & 0xf) * (1.0F
/ 15.0F
);
3254 rgba
[i
][aComp
] = ((p
>> 12) ) * (1.0F
/ 15.0F
);
3258 case GL_UNSIGNED_SHORT_5_5_5_1
:
3260 const GLushort
*ussrc
= (const GLushort
*) src
;
3262 for (i
= 0; i
< n
; i
++) {
3263 GLushort p
= ussrc
[i
];
3265 rgba
[i
][rComp
] = ((p
>> 11) ) * (1.0F
/ 31.0F
);
3266 rgba
[i
][gComp
] = ((p
>> 6) & 0x1f) * (1.0F
/ 31.0F
);
3267 rgba
[i
][bComp
] = ((p
>> 1) & 0x1f) * (1.0F
/ 31.0F
);
3268 rgba
[i
][aComp
] = ((p
) & 0x1) * (1.0F
/ 1.0F
);
3272 const GLushort
*ussrc
= (const GLushort
*) src
;
3274 for (i
= 0; i
< n
; i
++) {
3275 GLushort p
= ussrc
[i
];
3276 rgba
[i
][rComp
] = ((p
>> 11) ) * (1.0F
/ 31.0F
);
3277 rgba
[i
][gComp
] = ((p
>> 6) & 0x1f) * (1.0F
/ 31.0F
);
3278 rgba
[i
][bComp
] = ((p
>> 1) & 0x1f) * (1.0F
/ 31.0F
);
3279 rgba
[i
][aComp
] = ((p
) & 0x1) * (1.0F
/ 1.0F
);
3283 case GL_UNSIGNED_SHORT_1_5_5_5_REV
:
3285 const GLushort
*ussrc
= (const GLushort
*) src
;
3287 for (i
= 0; i
< n
; i
++) {
3288 GLushort p
= ussrc
[i
];
3290 rgba
[i
][rComp
] = ((p
) & 0x1f) * (1.0F
/ 31.0F
);
3291 rgba
[i
][gComp
] = ((p
>> 5) & 0x1f) * (1.0F
/ 31.0F
);
3292 rgba
[i
][bComp
] = ((p
>> 10) & 0x1f) * (1.0F
/ 31.0F
);
3293 rgba
[i
][aComp
] = ((p
>> 15) ) * (1.0F
/ 1.0F
);
3297 const GLushort
*ussrc
= (const GLushort
*) src
;
3299 for (i
= 0; i
< n
; i
++) {
3300 GLushort p
= ussrc
[i
];
3301 rgba
[i
][rComp
] = ((p
) & 0x1f) * (1.0F
/ 31.0F
);
3302 rgba
[i
][gComp
] = ((p
>> 5) & 0x1f) * (1.0F
/ 31.0F
);
3303 rgba
[i
][bComp
] = ((p
>> 10) & 0x1f) * (1.0F
/ 31.0F
);
3304 rgba
[i
][aComp
] = ((p
>> 15) ) * (1.0F
/ 1.0F
);
3308 case GL_UNSIGNED_INT_8_8_8_8
:
3310 const GLuint
*uisrc
= (const GLuint
*) src
;
3312 for (i
= 0; i
< n
; i
++) {
3313 GLuint p
= uisrc
[i
];
3314 rgba
[i
][rComp
] = UBYTE_TO_FLOAT((p
) & 0xff);
3315 rgba
[i
][gComp
] = UBYTE_TO_FLOAT((p
>> 8) & 0xff);
3316 rgba
[i
][bComp
] = UBYTE_TO_FLOAT((p
>> 16) & 0xff);
3317 rgba
[i
][aComp
] = UBYTE_TO_FLOAT((p
>> 24) );
3321 const GLuint
*uisrc
= (const GLuint
*) src
;
3323 for (i
= 0; i
< n
; i
++) {
3324 GLuint p
= uisrc
[i
];
3325 rgba
[i
][rComp
] = UBYTE_TO_FLOAT((p
>> 24) );
3326 rgba
[i
][gComp
] = UBYTE_TO_FLOAT((p
>> 16) & 0xff);
3327 rgba
[i
][bComp
] = UBYTE_TO_FLOAT((p
>> 8) & 0xff);
3328 rgba
[i
][aComp
] = UBYTE_TO_FLOAT((p
) & 0xff);
3332 case GL_UNSIGNED_INT_8_8_8_8_REV
:
3334 const GLuint
*uisrc
= (const GLuint
*) src
;
3336 for (i
= 0; i
< n
; i
++) {
3337 GLuint p
= uisrc
[i
];
3338 rgba
[i
][rComp
] = UBYTE_TO_FLOAT((p
>> 24) );
3339 rgba
[i
][gComp
] = UBYTE_TO_FLOAT((p
>> 16) & 0xff);
3340 rgba
[i
][bComp
] = UBYTE_TO_FLOAT((p
>> 8) & 0xff);
3341 rgba
[i
][aComp
] = UBYTE_TO_FLOAT((p
) & 0xff);
3345 const GLuint
*uisrc
= (const GLuint
*) src
;
3347 for (i
= 0; i
< n
; i
++) {
3348 GLuint p
= uisrc
[i
];
3349 rgba
[i
][rComp
] = UBYTE_TO_FLOAT((p
) & 0xff);
3350 rgba
[i
][gComp
] = UBYTE_TO_FLOAT((p
>> 8) & 0xff);
3351 rgba
[i
][bComp
] = UBYTE_TO_FLOAT((p
>> 16) & 0xff);
3352 rgba
[i
][aComp
] = UBYTE_TO_FLOAT((p
>> 24) );
3356 case GL_UNSIGNED_INT_10_10_10_2
:
3358 const GLuint
*uisrc
= (const GLuint
*) src
;
3360 for (i
= 0; i
< n
; i
++) {
3361 GLuint p
= uisrc
[i
];
3363 rgba
[i
][rComp
] = ((p
>> 22) ) * (1.0F
/ 1023.0F
);
3364 rgba
[i
][gComp
] = ((p
>> 12) & 0x3ff) * (1.0F
/ 1023.0F
);
3365 rgba
[i
][bComp
] = ((p
>> 2) & 0x3ff) * (1.0F
/ 1023.0F
);
3366 rgba
[i
][aComp
] = ((p
) & 0x3 ) * (1.0F
/ 3.0F
);
3370 const GLuint
*uisrc
= (const GLuint
*) src
;
3372 for (i
= 0; i
< n
; i
++) {
3373 GLuint p
= uisrc
[i
];
3374 rgba
[i
][rComp
] = ((p
>> 22) ) * (1.0F
/ 1023.0F
);
3375 rgba
[i
][gComp
] = ((p
>> 12) & 0x3ff) * (1.0F
/ 1023.0F
);
3376 rgba
[i
][bComp
] = ((p
>> 2) & 0x3ff) * (1.0F
/ 1023.0F
);
3377 rgba
[i
][aComp
] = ((p
) & 0x3 ) * (1.0F
/ 3.0F
);
3381 case GL_UNSIGNED_INT_2_10_10_10_REV
:
3383 const GLuint
*uisrc
= (const GLuint
*) src
;
3385 for (i
= 0; i
< n
; i
++) {
3386 GLuint p
= uisrc
[i
];
3388 rgba
[i
][rComp
] = ((p
) & 0x3ff) * (1.0F
/ 1023.0F
);
3389 rgba
[i
][gComp
] = ((p
>> 10) & 0x3ff) * (1.0F
/ 1023.0F
);
3390 rgba
[i
][bComp
] = ((p
>> 20) & 0x3ff) * (1.0F
/ 1023.0F
);
3391 rgba
[i
][aComp
] = ((p
>> 30) ) * (1.0F
/ 3.0F
);
3395 const GLuint
*uisrc
= (const GLuint
*) src
;
3397 for (i
= 0; i
< n
; i
++) {
3398 GLuint p
= uisrc
[i
];
3399 rgba
[i
][rComp
] = ((p
) & 0x3ff) * (1.0F
/ 1023.0F
);
3400 rgba
[i
][gComp
] = ((p
>> 10) & 0x3ff) * (1.0F
/ 1023.0F
);
3401 rgba
[i
][bComp
] = ((p
>> 20) & 0x3ff) * (1.0F
/ 1023.0F
);
3402 rgba
[i
][aComp
] = ((p
>> 30) ) * (1.0F
/ 3.0F
);
3407 _mesa_problem(NULL
, "bad srcType in extract float data");
3414 * Unpack a row of color image data from a client buffer according to
3415 * the pixel unpacking parameters.
3416 * Return GLchan values in the specified dest image format.
3417 * This is used by glDrawPixels and glTexImage?D().
3418 * \param ctx - the context
3419 * n - number of pixels in the span
3420 * dstFormat - format of destination color array
3421 * dest - the destination color array
3422 * srcFormat - source image format
3423 * srcType - source image data type
3424 * source - source image pointer
3425 * srcPacking - pixel unpacking parameters
3426 * transferOps - bitmask of IMAGE_*_BIT values of operations to apply
3428 * XXX perhaps expand this to process whole images someday.
3431 _mesa_unpack_color_span_chan( GLcontext
*ctx
,
3432 GLuint n
, GLenum dstFormat
, GLchan dest
[],
3433 GLenum srcFormat
, GLenum srcType
,
3434 const GLvoid
*source
,
3435 const struct gl_pixelstore_attrib
*srcPacking
,
3436 GLbitfield transferOps
)
3438 ASSERT(dstFormat
== GL_ALPHA
||
3439 dstFormat
== GL_LUMINANCE
||
3440 dstFormat
== GL_LUMINANCE_ALPHA
||
3441 dstFormat
== GL_INTENSITY
||
3442 dstFormat
== GL_RGB
||
3443 dstFormat
== GL_RGBA
||
3444 dstFormat
== GL_COLOR_INDEX
);
3446 ASSERT(srcFormat
== GL_RED
||
3447 srcFormat
== GL_GREEN
||
3448 srcFormat
== GL_BLUE
||
3449 srcFormat
== GL_ALPHA
||
3450 srcFormat
== GL_LUMINANCE
||
3451 srcFormat
== GL_LUMINANCE_ALPHA
||
3452 srcFormat
== GL_INTENSITY
||
3453 srcFormat
== GL_RGB
||
3454 srcFormat
== GL_BGR
||
3455 srcFormat
== GL_RGBA
||
3456 srcFormat
== GL_BGRA
||
3457 srcFormat
== GL_ABGR_EXT
||
3458 srcFormat
== GL_COLOR_INDEX
);
3460 ASSERT(srcType
== GL_BITMAP
||
3461 srcType
== GL_UNSIGNED_BYTE
||
3462 srcType
== GL_BYTE
||
3463 srcType
== GL_UNSIGNED_SHORT
||
3464 srcType
== GL_SHORT
||
3465 srcType
== GL_UNSIGNED_INT
||
3466 srcType
== GL_INT
||
3467 srcType
== GL_HALF_FLOAT_ARB
||
3468 srcType
== GL_FLOAT
||
3469 srcType
== GL_UNSIGNED_BYTE_3_3_2
||
3470 srcType
== GL_UNSIGNED_BYTE_2_3_3_REV
||
3471 srcType
== GL_UNSIGNED_SHORT_5_6_5
||
3472 srcType
== GL_UNSIGNED_SHORT_5_6_5_REV
||
3473 srcType
== GL_UNSIGNED_SHORT_4_4_4_4
||
3474 srcType
== GL_UNSIGNED_SHORT_4_4_4_4_REV
||
3475 srcType
== GL_UNSIGNED_SHORT_5_5_5_1
||
3476 srcType
== GL_UNSIGNED_SHORT_1_5_5_5_REV
||
3477 srcType
== GL_UNSIGNED_INT_8_8_8_8
||
3478 srcType
== GL_UNSIGNED_INT_8_8_8_8_REV
||
3479 srcType
== GL_UNSIGNED_INT_10_10_10_2
||
3480 srcType
== GL_UNSIGNED_INT_2_10_10_10_REV
);
3482 /* Try simple cases first */
3483 if (transferOps
== 0) {
3484 if (srcType
== CHAN_TYPE
) {
3485 if (dstFormat
== GL_RGBA
) {
3486 if (srcFormat
== GL_RGBA
) {
3487 _mesa_memcpy( dest
, source
, n
* 4 * sizeof(GLchan
) );
3490 else if (srcFormat
== GL_RGB
) {
3492 const GLchan
*src
= (const GLchan
*) source
;
3494 for (i
= 0; i
< n
; i
++) {
3505 else if (dstFormat
== GL_RGB
) {
3506 if (srcFormat
== GL_RGB
) {
3507 _mesa_memcpy( dest
, source
, n
* 3 * sizeof(GLchan
) );
3510 else if (srcFormat
== GL_RGBA
) {
3512 const GLchan
*src
= (const GLchan
*) source
;
3514 for (i
= 0; i
< n
; i
++) {
3524 else if (dstFormat
== srcFormat
) {
3525 GLint comps
= _mesa_components_in_format(srcFormat
);
3527 _mesa_memcpy( dest
, source
, n
* comps
* sizeof(GLchan
) );
3532 * Common situation, loading 8bit RGBA/RGB source images
3533 * into 16/32 bit destination. (OSMesa16/32)
3535 else if (srcType
== GL_UNSIGNED_BYTE
) {
3536 if (dstFormat
== GL_RGBA
) {
3537 if (srcFormat
== GL_RGB
) {
3539 const GLubyte
*src
= (const GLubyte
*) source
;
3541 for (i
= 0; i
< n
; i
++) {
3542 dst
[0] = UBYTE_TO_CHAN(src
[0]);
3543 dst
[1] = UBYTE_TO_CHAN(src
[1]);
3544 dst
[2] = UBYTE_TO_CHAN(src
[2]);
3551 else if (srcFormat
== GL_RGBA
) {
3553 const GLubyte
*src
= (const GLubyte
*) source
;
3555 for (i
= 0; i
< n
; i
++) {
3556 dst
[0] = UBYTE_TO_CHAN(src
[0]);
3557 dst
[1] = UBYTE_TO_CHAN(src
[1]);
3558 dst
[2] = UBYTE_TO_CHAN(src
[2]);
3559 dst
[3] = UBYTE_TO_CHAN(src
[3]);
3566 else if (dstFormat
== GL_RGB
) {
3567 if (srcFormat
== GL_RGB
) {
3569 const GLubyte
*src
= (const GLubyte
*) source
;
3571 for (i
= 0; i
< n
; i
++) {
3572 dst
[0] = UBYTE_TO_CHAN(src
[0]);
3573 dst
[1] = UBYTE_TO_CHAN(src
[1]);
3574 dst
[2] = UBYTE_TO_CHAN(src
[2]);
3580 else if (srcFormat
== GL_RGBA
) {
3582 const GLubyte
*src
= (const GLubyte
*) source
;
3584 for (i
= 0; i
< n
; i
++) {
3585 dst
[0] = UBYTE_TO_CHAN(src
[0]);
3586 dst
[1] = UBYTE_TO_CHAN(src
[1]);
3587 dst
[2] = UBYTE_TO_CHAN(src
[2]);
3598 /* general solution begins here */
3600 GLint dstComponents
;
3601 GLint dstRedIndex
, dstGreenIndex
, dstBlueIndex
, dstAlphaIndex
;
3602 GLint dstLuminanceIndex
, dstIntensityIndex
;
3603 GLfloat rgba
[MAX_WIDTH
][4];
3605 dstComponents
= _mesa_components_in_format( dstFormat
);
3606 /* source & dest image formats should have been error checked by now */
3607 assert(dstComponents
> 0);
3610 * Extract image data and convert to RGBA floats
3612 assert(n
<= MAX_WIDTH
);
3613 if (srcFormat
== GL_COLOR_INDEX
) {
3614 GLuint indexes
[MAX_WIDTH
];
3615 extract_uint_indexes(n
, indexes
, srcFormat
, srcType
, source
,
3618 if (dstFormat
== GL_COLOR_INDEX
) {
3620 _mesa_apply_ci_transfer_ops(ctx
, transferOps
, n
, indexes
);
3621 /* convert to GLchan and return */
3622 for (i
= 0; i
< n
; i
++) {
3623 dest
[i
] = (GLchan
) (indexes
[i
] & 0xff);
3628 /* Convert indexes to RGBA */
3629 if (transferOps
& IMAGE_SHIFT_OFFSET_BIT
) {
3630 shift_and_offset_ci(ctx
, n
, indexes
);
3632 _mesa_map_ci_to_rgba(ctx
, n
, indexes
, rgba
);
3635 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
3636 * with color indexes.
3638 transferOps
&= ~(IMAGE_SCALE_BIAS_BIT
| IMAGE_MAP_COLOR_BIT
);
3641 /* non-color index data */
3642 extract_float_rgba(n
, rgba
, srcFormat
, srcType
, source
,
3643 srcPacking
->SwapBytes
);
3646 /* Need to clamp if returning GLubytes or GLushorts */
3647 #if CHAN_TYPE != GL_FLOAT
3648 transferOps
|= IMAGE_CLAMP_BIT
;
3652 _mesa_apply_rgba_transfer_ops(ctx
, transferOps
, n
, rgba
);
3655 /* Now determine which color channels we need to produce.
3656 * And determine the dest index (offset) within each color tuple.
3658 switch (dstFormat
) {
3661 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= -1;
3662 dstLuminanceIndex
= dstIntensityIndex
= -1;
3665 dstLuminanceIndex
= 0;
3666 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= dstAlphaIndex
= -1;
3667 dstIntensityIndex
= -1;
3669 case GL_LUMINANCE_ALPHA
:
3670 dstLuminanceIndex
= 0;
3672 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= -1;
3673 dstIntensityIndex
= -1;
3676 dstIntensityIndex
= 0;
3677 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= dstAlphaIndex
= -1;
3678 dstLuminanceIndex
= -1;
3684 dstAlphaIndex
= dstLuminanceIndex
= dstIntensityIndex
= -1;
3691 dstLuminanceIndex
= dstIntensityIndex
= -1;
3694 _mesa_problem(ctx
, "bad dstFormat in _mesa_unpack_chan_span()");
3699 /* Now return the GLchan data in the requested dstFormat */
3701 if (dstRedIndex
>= 0) {
3704 for (i
= 0; i
< n
; i
++) {
3705 CLAMPED_FLOAT_TO_CHAN(dst
[dstRedIndex
], rgba
[i
][RCOMP
]);
3706 dst
+= dstComponents
;
3710 if (dstGreenIndex
>= 0) {
3713 for (i
= 0; i
< n
; i
++) {
3714 CLAMPED_FLOAT_TO_CHAN(dst
[dstGreenIndex
], rgba
[i
][GCOMP
]);
3715 dst
+= dstComponents
;
3719 if (dstBlueIndex
>= 0) {
3722 for (i
= 0; i
< n
; i
++) {
3723 CLAMPED_FLOAT_TO_CHAN(dst
[dstBlueIndex
], rgba
[i
][BCOMP
]);
3724 dst
+= dstComponents
;
3728 if (dstAlphaIndex
>= 0) {
3731 for (i
= 0; i
< n
; i
++) {
3732 CLAMPED_FLOAT_TO_CHAN(dst
[dstAlphaIndex
], rgba
[i
][ACOMP
]);
3733 dst
+= dstComponents
;
3737 if (dstIntensityIndex
>= 0) {
3740 assert(dstIntensityIndex
== 0);
3741 assert(dstComponents
== 1);
3742 for (i
= 0; i
< n
; i
++) {
3743 /* Intensity comes from red channel */
3744 CLAMPED_FLOAT_TO_CHAN(dst
[i
], rgba
[i
][RCOMP
]);
3748 if (dstLuminanceIndex
>= 0) {
3751 assert(dstLuminanceIndex
== 0);
3752 for (i
= 0; i
< n
; i
++) {
3753 /* Luminance comes from red channel */
3754 CLAMPED_FLOAT_TO_CHAN(dst
[0], rgba
[i
][RCOMP
]);
3755 dst
+= dstComponents
;
3763 * Same as _mesa_unpack_color_span_chan(), but return GLfloat data
3764 * instead of GLchan.
3767 _mesa_unpack_color_span_float( GLcontext
*ctx
,
3768 GLuint n
, GLenum dstFormat
, GLfloat dest
[],
3769 GLenum srcFormat
, GLenum srcType
,
3770 const GLvoid
*source
,
3771 const struct gl_pixelstore_attrib
*srcPacking
,
3772 GLbitfield transferOps
)
3774 ASSERT(dstFormat
== GL_ALPHA
||
3775 dstFormat
== GL_LUMINANCE
||
3776 dstFormat
== GL_LUMINANCE_ALPHA
||
3777 dstFormat
== GL_INTENSITY
||
3778 dstFormat
== GL_RGB
||
3779 dstFormat
== GL_RGBA
||
3780 dstFormat
== GL_COLOR_INDEX
);
3782 ASSERT(srcFormat
== GL_RED
||
3783 srcFormat
== GL_GREEN
||
3784 srcFormat
== GL_BLUE
||
3785 srcFormat
== GL_ALPHA
||
3786 srcFormat
== GL_LUMINANCE
||
3787 srcFormat
== GL_LUMINANCE_ALPHA
||
3788 srcFormat
== GL_INTENSITY
||
3789 srcFormat
== GL_RGB
||
3790 srcFormat
== GL_BGR
||
3791 srcFormat
== GL_RGBA
||
3792 srcFormat
== GL_BGRA
||
3793 srcFormat
== GL_ABGR_EXT
||
3794 srcFormat
== GL_COLOR_INDEX
);
3796 ASSERT(srcType
== GL_BITMAP
||
3797 srcType
== GL_UNSIGNED_BYTE
||
3798 srcType
== GL_BYTE
||
3799 srcType
== GL_UNSIGNED_SHORT
||
3800 srcType
== GL_SHORT
||
3801 srcType
== GL_UNSIGNED_INT
||
3802 srcType
== GL_INT
||
3803 srcType
== GL_HALF_FLOAT_ARB
||
3804 srcType
== GL_FLOAT
||
3805 srcType
== GL_UNSIGNED_BYTE_3_3_2
||
3806 srcType
== GL_UNSIGNED_BYTE_2_3_3_REV
||
3807 srcType
== GL_UNSIGNED_SHORT_5_6_5
||
3808 srcType
== GL_UNSIGNED_SHORT_5_6_5_REV
||
3809 srcType
== GL_UNSIGNED_SHORT_4_4_4_4
||
3810 srcType
== GL_UNSIGNED_SHORT_4_4_4_4_REV
||
3811 srcType
== GL_UNSIGNED_SHORT_5_5_5_1
||
3812 srcType
== GL_UNSIGNED_SHORT_1_5_5_5_REV
||
3813 srcType
== GL_UNSIGNED_INT_8_8_8_8
||
3814 srcType
== GL_UNSIGNED_INT_8_8_8_8_REV
||
3815 srcType
== GL_UNSIGNED_INT_10_10_10_2
||
3816 srcType
== GL_UNSIGNED_INT_2_10_10_10_REV
);
3818 /* general solution, no special cases, yet */
3820 GLint dstComponents
;
3821 GLint dstRedIndex
, dstGreenIndex
, dstBlueIndex
, dstAlphaIndex
;
3822 GLint dstLuminanceIndex
, dstIntensityIndex
;
3823 GLfloat rgba
[MAX_WIDTH
][4];
3825 dstComponents
= _mesa_components_in_format( dstFormat
);
3826 /* source & dest image formats should have been error checked by now */
3827 assert(dstComponents
> 0);
3830 * Extract image data and convert to RGBA floats
3832 assert(n
<= MAX_WIDTH
);
3833 if (srcFormat
== GL_COLOR_INDEX
) {
3834 GLuint indexes
[MAX_WIDTH
];
3835 extract_uint_indexes(n
, indexes
, srcFormat
, srcType
, source
,
3838 if (dstFormat
== GL_COLOR_INDEX
) {
3840 _mesa_apply_ci_transfer_ops(ctx
, transferOps
, n
, indexes
);
3841 /* convert to GLchan and return */
3842 for (i
= 0; i
< n
; i
++) {
3843 dest
[i
] = (GLchan
) (indexes
[i
] & 0xff);
3848 /* Convert indexes to RGBA */
3849 if (transferOps
& IMAGE_SHIFT_OFFSET_BIT
) {
3850 shift_and_offset_ci(ctx
, n
, indexes
);
3852 _mesa_map_ci_to_rgba(ctx
, n
, indexes
, rgba
);
3855 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
3856 * with color indexes.
3858 transferOps
&= ~(IMAGE_SCALE_BIAS_BIT
| IMAGE_MAP_COLOR_BIT
);
3861 /* non-color index data */
3862 extract_float_rgba(n
, rgba
, srcFormat
, srcType
, source
,
3863 srcPacking
->SwapBytes
);
3867 _mesa_apply_rgba_transfer_ops(ctx
, transferOps
, n
, rgba
);
3870 /* Now determine which color channels we need to produce.
3871 * And determine the dest index (offset) within each color tuple.
3873 switch (dstFormat
) {
3876 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= -1;
3877 dstLuminanceIndex
= dstIntensityIndex
= -1;
3880 dstLuminanceIndex
= 0;
3881 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= dstAlphaIndex
= -1;
3882 dstIntensityIndex
= -1;
3884 case GL_LUMINANCE_ALPHA
:
3885 dstLuminanceIndex
= 0;
3887 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= -1;
3888 dstIntensityIndex
= -1;
3891 dstIntensityIndex
= 0;
3892 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= dstAlphaIndex
= -1;
3893 dstLuminanceIndex
= -1;
3899 dstAlphaIndex
= dstLuminanceIndex
= dstIntensityIndex
= -1;
3906 dstLuminanceIndex
= dstIntensityIndex
= -1;
3909 _mesa_problem(ctx
, "bad dstFormat in _mesa_unpack_color_span_float()");
3913 /* Now pack results in the requested dstFormat */
3914 if (dstRedIndex
>= 0) {
3915 GLfloat
*dst
= dest
;
3917 for (i
= 0; i
< n
; i
++) {
3918 dst
[dstRedIndex
] = rgba
[i
][RCOMP
];
3919 dst
+= dstComponents
;
3923 if (dstGreenIndex
>= 0) {
3924 GLfloat
*dst
= dest
;
3926 for (i
= 0; i
< n
; i
++) {
3927 dst
[dstGreenIndex
] = rgba
[i
][GCOMP
];
3928 dst
+= dstComponents
;
3932 if (dstBlueIndex
>= 0) {
3933 GLfloat
*dst
= dest
;
3935 for (i
= 0; i
< n
; i
++) {
3936 dst
[dstBlueIndex
] = rgba
[i
][BCOMP
];
3937 dst
+= dstComponents
;
3941 if (dstAlphaIndex
>= 0) {
3942 GLfloat
*dst
= dest
;
3944 for (i
= 0; i
< n
; i
++) {
3945 dst
[dstAlphaIndex
] = rgba
[i
][ACOMP
];
3946 dst
+= dstComponents
;
3950 if (dstIntensityIndex
>= 0) {
3951 GLfloat
*dst
= dest
;
3953 assert(dstIntensityIndex
== 0);
3954 assert(dstComponents
== 1);
3955 for (i
= 0; i
< n
; i
++) {
3956 /* Intensity comes from red channel */
3957 dst
[i
] = rgba
[i
][RCOMP
];
3961 if (dstLuminanceIndex
>= 0) {
3962 GLfloat
*dst
= dest
;
3964 assert(dstLuminanceIndex
== 0);
3965 for (i
= 0; i
< n
; i
++) {
3966 /* Luminance comes from red channel */
3967 dst
[0] = rgba
[i
][RCOMP
];
3968 dst
+= dstComponents
;
3975 * Similar to _mesa_unpack_color_span_float(), but for dudv data instead of rgba,
3976 * directly return GLbyte data, no transfer ops apply.
3979 _mesa_unpack_dudv_span_byte( GLcontext
*ctx
,
3980 GLuint n
, GLenum dstFormat
, GLbyte dest
[],
3981 GLenum srcFormat
, GLenum srcType
,
3982 const GLvoid
*source
,
3983 const struct gl_pixelstore_attrib
*srcPacking
,
3984 GLbitfield transferOps
)
3986 ASSERT(dstFormat
== GL_DUDV_ATI
);
3987 ASSERT(srcFormat
== GL_DUDV_ATI
);
3989 ASSERT(srcType
== GL_UNSIGNED_BYTE
||
3990 srcType
== GL_BYTE
||
3991 srcType
== GL_UNSIGNED_SHORT
||
3992 srcType
== GL_SHORT
||
3993 srcType
== GL_UNSIGNED_INT
||
3994 srcType
== GL_INT
||
3995 srcType
== GL_HALF_FLOAT_ARB
||
3996 srcType
== GL_FLOAT
);
3998 /* general solution */
4000 GLint dstComponents
;
4001 GLfloat rgba
[MAX_WIDTH
][4];
4005 dstComponents
= _mesa_components_in_format( dstFormat
);
4006 /* source & dest image formats should have been error checked by now */
4007 assert(dstComponents
> 0);
4010 * Extract image data and convert to RGBA floats
4012 assert(n
<= MAX_WIDTH
);
4013 extract_float_rgba(n
, rgba
, srcFormat
, srcType
, source
,
4014 srcPacking
->SwapBytes
);
4017 /* Now determine which color channels we need to produce.
4018 * And determine the dest index (offset) within each color tuple.
4021 /* Now pack results in the requested dstFormat */
4022 for (i
= 0; i
< n
; i
++) {
4023 /* not sure - need clamp[-1,1] here? */
4024 dst
[0] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
4025 dst
[1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
4026 dst
+= dstComponents
;
4032 * Unpack a row of color index data from a client buffer according to
4033 * the pixel unpacking parameters.
4034 * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.
4036 * Args: ctx - the context
4037 * n - number of pixels
4038 * dstType - destination data type
4039 * dest - destination array
4040 * srcType - source pixel type
4041 * source - source data pointer
4042 * srcPacking - pixel unpacking parameters
4043 * transferOps - the pixel transfer operations to apply
4046 _mesa_unpack_index_span( const GLcontext
*ctx
, GLuint n
,
4047 GLenum dstType
, GLvoid
*dest
,
4048 GLenum srcType
, const GLvoid
*source
,
4049 const struct gl_pixelstore_attrib
*srcPacking
,
4050 GLbitfield transferOps
)
4052 ASSERT(srcType
== GL_BITMAP
||
4053 srcType
== GL_UNSIGNED_BYTE
||
4054 srcType
== GL_BYTE
||
4055 srcType
== GL_UNSIGNED_SHORT
||
4056 srcType
== GL_SHORT
||
4057 srcType
== GL_UNSIGNED_INT
||
4058 srcType
== GL_INT
||
4059 srcType
== GL_HALF_FLOAT_ARB
||
4060 srcType
== GL_FLOAT
);
4062 ASSERT(dstType
== GL_UNSIGNED_BYTE
||
4063 dstType
== GL_UNSIGNED_SHORT
||
4064 dstType
== GL_UNSIGNED_INT
);
4067 transferOps
&= (IMAGE_MAP_COLOR_BIT
| IMAGE_SHIFT_OFFSET_BIT
);
4070 * Try simple cases first
4072 if (transferOps
== 0 && srcType
== GL_UNSIGNED_BYTE
4073 && dstType
== GL_UNSIGNED_BYTE
) {
4074 _mesa_memcpy(dest
, source
, n
* sizeof(GLubyte
));
4076 else if (transferOps
== 0 && srcType
== GL_UNSIGNED_INT
4077 && dstType
== GL_UNSIGNED_INT
&& !srcPacking
->SwapBytes
) {
4078 _mesa_memcpy(dest
, source
, n
* sizeof(GLuint
));
4084 GLuint indexes
[MAX_WIDTH
];
4085 assert(n
<= MAX_WIDTH
);
4087 extract_uint_indexes(n
, indexes
, GL_COLOR_INDEX
, srcType
, source
,
4091 _mesa_apply_ci_transfer_ops(ctx
, transferOps
, n
, indexes
);
4093 /* convert to dest type */
4095 case GL_UNSIGNED_BYTE
:
4097 GLubyte
*dst
= (GLubyte
*) dest
;
4099 for (i
= 0; i
< n
; i
++) {
4100 dst
[i
] = (GLubyte
) (indexes
[i
] & 0xff);
4104 case GL_UNSIGNED_SHORT
:
4106 GLuint
*dst
= (GLuint
*) dest
;
4108 for (i
= 0; i
< n
; i
++) {
4109 dst
[i
] = (GLushort
) (indexes
[i
] & 0xffff);
4113 case GL_UNSIGNED_INT
:
4114 _mesa_memcpy(dest
, indexes
, n
* sizeof(GLuint
));
4117 _mesa_problem(ctx
, "bad dstType in _mesa_unpack_index_span");
4124 _mesa_pack_index_span( const GLcontext
*ctx
, GLuint n
,
4125 GLenum dstType
, GLvoid
*dest
, const GLuint
*source
,
4126 const struct gl_pixelstore_attrib
*dstPacking
,
4127 GLbitfield transferOps
)
4129 GLuint indexes
[MAX_WIDTH
];
4131 ASSERT(n
<= MAX_WIDTH
);
4133 transferOps
&= (IMAGE_MAP_COLOR_BIT
| IMAGE_SHIFT_OFFSET_BIT
);
4135 if (transferOps
& (IMAGE_MAP_COLOR_BIT
| IMAGE_SHIFT_OFFSET_BIT
)) {
4136 /* make a copy of input */
4137 _mesa_memcpy(indexes
, source
, n
* sizeof(GLuint
));
4138 _mesa_apply_ci_transfer_ops(ctx
, transferOps
, n
, indexes
);
4143 case GL_UNSIGNED_BYTE
:
4145 GLubyte
*dst
= (GLubyte
*) dest
;
4147 for (i
= 0; i
< n
; i
++) {
4148 *dst
++ = (GLubyte
) source
[i
];
4154 GLbyte
*dst
= (GLbyte
*) dest
;
4156 for (i
= 0; i
< n
; i
++) {
4157 dst
[i
] = (GLbyte
) source
[i
];
4161 case GL_UNSIGNED_SHORT
:
4163 GLushort
*dst
= (GLushort
*) dest
;
4165 for (i
= 0; i
< n
; i
++) {
4166 dst
[i
] = (GLushort
) source
[i
];
4168 if (dstPacking
->SwapBytes
) {
4169 _mesa_swap2( (GLushort
*) dst
, n
);
4175 GLshort
*dst
= (GLshort
*) dest
;
4177 for (i
= 0; i
< n
; i
++) {
4178 dst
[i
] = (GLshort
) source
[i
];
4180 if (dstPacking
->SwapBytes
) {
4181 _mesa_swap2( (GLushort
*) dst
, n
);
4185 case GL_UNSIGNED_INT
:
4187 GLuint
*dst
= (GLuint
*) dest
;
4189 for (i
= 0; i
< n
; i
++) {
4190 dst
[i
] = (GLuint
) source
[i
];
4192 if (dstPacking
->SwapBytes
) {
4193 _mesa_swap4( (GLuint
*) dst
, n
);
4199 GLint
*dst
= (GLint
*) dest
;
4201 for (i
= 0; i
< n
; i
++) {
4202 dst
[i
] = (GLint
) source
[i
];
4204 if (dstPacking
->SwapBytes
) {
4205 _mesa_swap4( (GLuint
*) dst
, n
);
4211 GLfloat
*dst
= (GLfloat
*) dest
;
4213 for (i
= 0; i
< n
; i
++) {
4214 dst
[i
] = (GLfloat
) source
[i
];
4216 if (dstPacking
->SwapBytes
) {
4217 _mesa_swap4( (GLuint
*) dst
, n
);
4221 case GL_HALF_FLOAT_ARB
:
4223 GLhalfARB
*dst
= (GLhalfARB
*) dest
;
4225 for (i
= 0; i
< n
; i
++) {
4226 dst
[i
] = _mesa_float_to_half((GLfloat
) source
[i
]);
4228 if (dstPacking
->SwapBytes
) {
4229 _mesa_swap2( (GLushort
*) dst
, n
);
4234 _mesa_problem(ctx
, "bad type in _mesa_pack_index_span");
4240 * Unpack a row of stencil data from a client buffer according to
4241 * the pixel unpacking parameters.
4242 * This is (or will be) used by glDrawPixels
4244 * Args: ctx - the context
4245 * n - number of pixels
4246 * dstType - destination data type
4247 * dest - destination array
4248 * srcType - source pixel type
4249 * source - source data pointer
4250 * srcPacking - pixel unpacking parameters
4251 * transferOps - apply offset/bias/lookup ops?
4254 _mesa_unpack_stencil_span( const GLcontext
*ctx
, GLuint n
,
4255 GLenum dstType
, GLvoid
*dest
,
4256 GLenum srcType
, const GLvoid
*source
,
4257 const struct gl_pixelstore_attrib
*srcPacking
,
4258 GLbitfield transferOps
)
4260 ASSERT(srcType
== GL_BITMAP
||
4261 srcType
== GL_UNSIGNED_BYTE
||
4262 srcType
== GL_BYTE
||
4263 srcType
== GL_UNSIGNED_SHORT
||
4264 srcType
== GL_SHORT
||
4265 srcType
== GL_UNSIGNED_INT
||
4266 srcType
== GL_INT
||
4267 srcType
== GL_UNSIGNED_INT_24_8_EXT
||
4268 srcType
== GL_HALF_FLOAT_ARB
||
4269 srcType
== GL_FLOAT
);
4271 ASSERT(dstType
== GL_UNSIGNED_BYTE
||
4272 dstType
== GL_UNSIGNED_SHORT
||
4273 dstType
== GL_UNSIGNED_INT
);
4275 /* only shift and offset apply to stencil */
4276 transferOps
&= IMAGE_SHIFT_OFFSET_BIT
;
4279 * Try simple cases first
4281 if (transferOps
== 0 &&
4282 !ctx
->Pixel
.MapStencilFlag
&&
4283 srcType
== GL_UNSIGNED_BYTE
&&
4284 dstType
== GL_UNSIGNED_BYTE
) {
4285 _mesa_memcpy(dest
, source
, n
* sizeof(GLubyte
));
4287 else if (transferOps
== 0 &&
4288 !ctx
->Pixel
.MapStencilFlag
&&
4289 srcType
== GL_UNSIGNED_INT
&&
4290 dstType
== GL_UNSIGNED_INT
&&
4291 !srcPacking
->SwapBytes
) {
4292 _mesa_memcpy(dest
, source
, n
* sizeof(GLuint
));
4298 GLuint indexes
[MAX_WIDTH
];
4299 assert(n
<= MAX_WIDTH
);
4301 extract_uint_indexes(n
, indexes
, GL_STENCIL_INDEX
, srcType
, source
,
4304 if (transferOps
& IMAGE_SHIFT_OFFSET_BIT
) {
4305 /* shift and offset indexes */
4306 shift_and_offset_ci(ctx
, n
, indexes
);
4309 if (ctx
->Pixel
.MapStencilFlag
) {
4310 /* Apply stencil lookup table */
4311 const GLuint mask
= ctx
->PixelMaps
.StoS
.Size
- 1;
4313 for (i
= 0; i
< n
; i
++) {
4314 indexes
[i
] = (GLuint
)ctx
->PixelMaps
.StoS
.Map
[ indexes
[i
] & mask
];
4318 /* convert to dest type */
4320 case GL_UNSIGNED_BYTE
:
4322 GLubyte
*dst
= (GLubyte
*) dest
;
4324 for (i
= 0; i
< n
; i
++) {
4325 dst
[i
] = (GLubyte
) (indexes
[i
] & 0xff);
4329 case GL_UNSIGNED_SHORT
:
4331 GLuint
*dst
= (GLuint
*) dest
;
4333 for (i
= 0; i
< n
; i
++) {
4334 dst
[i
] = (GLushort
) (indexes
[i
] & 0xffff);
4338 case GL_UNSIGNED_INT
:
4339 _mesa_memcpy(dest
, indexes
, n
* sizeof(GLuint
));
4342 _mesa_problem(ctx
, "bad dstType in _mesa_unpack_stencil_span");
4349 _mesa_pack_stencil_span( const GLcontext
*ctx
, GLuint n
,
4350 GLenum dstType
, GLvoid
*dest
, const GLstencil
*source
,
4351 const struct gl_pixelstore_attrib
*dstPacking
)
4353 GLstencil stencil
[MAX_WIDTH
];
4355 ASSERT(n
<= MAX_WIDTH
);
4357 if (ctx
->Pixel
.IndexShift
|| ctx
->Pixel
.IndexOffset
||
4358 ctx
->Pixel
.MapStencilFlag
) {
4359 /* make a copy of input */
4360 _mesa_memcpy(stencil
, source
, n
* sizeof(GLstencil
));
4361 _mesa_apply_stencil_transfer_ops(ctx
, n
, stencil
);
4366 case GL_UNSIGNED_BYTE
:
4367 if (sizeof(GLstencil
) == 1) {
4368 _mesa_memcpy( dest
, source
, n
);
4371 GLubyte
*dst
= (GLubyte
*) dest
;
4374 dst
[i
] = (GLubyte
) source
[i
];
4380 GLbyte
*dst
= (GLbyte
*) dest
;
4383 dst
[i
] = (GLbyte
) (source
[i
] & 0x7f);
4387 case GL_UNSIGNED_SHORT
:
4389 GLushort
*dst
= (GLushort
*) dest
;
4392 dst
[i
] = (GLushort
) source
[i
];
4394 if (dstPacking
->SwapBytes
) {
4395 _mesa_swap2( (GLushort
*) dst
, n
);
4401 GLshort
*dst
= (GLshort
*) dest
;
4404 dst
[i
] = (GLshort
) source
[i
];
4406 if (dstPacking
->SwapBytes
) {
4407 _mesa_swap2( (GLushort
*) dst
, n
);
4411 case GL_UNSIGNED_INT
:
4413 GLuint
*dst
= (GLuint
*) dest
;
4416 dst
[i
] = (GLuint
) source
[i
];
4418 if (dstPacking
->SwapBytes
) {
4419 _mesa_swap4( (GLuint
*) dst
, n
);
4425 GLint
*dst
= (GLint
*) dest
;
4428 dst
[i
] = (GLint
) source
[i
];
4430 if (dstPacking
->SwapBytes
) {
4431 _mesa_swap4( (GLuint
*) dst
, n
);
4437 GLfloat
*dst
= (GLfloat
*) dest
;
4440 dst
[i
] = (GLfloat
) source
[i
];
4442 if (dstPacking
->SwapBytes
) {
4443 _mesa_swap4( (GLuint
*) dst
, n
);
4447 case GL_HALF_FLOAT_ARB
:
4449 GLhalfARB
*dst
= (GLhalfARB
*) dest
;
4452 dst
[i
] = _mesa_float_to_half( (float) source
[i
] );
4454 if (dstPacking
->SwapBytes
) {
4455 _mesa_swap2( (GLushort
*) dst
, n
);
4460 if (dstPacking
->LsbFirst
) {
4461 GLubyte
*dst
= (GLubyte
*) dest
;
4464 for (i
= 0; i
< n
; i
++) {
4467 *dst
|= ((source
[i
] != 0) << shift
);
4476 GLubyte
*dst
= (GLubyte
*) dest
;
4479 for (i
= 0; i
< n
; i
++) {
4482 *dst
|= ((source
[i
] != 0) << shift
);
4492 _mesa_problem(ctx
, "bad type in _mesa_pack_index_span");
4496 #define DEPTH_VALUES(GLTYPE, GLTYPE2FLOAT) \
4499 const GLTYPE *src = (const GLTYPE *)source; \
4500 for (i = 0; i < n; i++) { \
4501 GLTYPE value = src[i]; \
4502 if (srcPacking->SwapBytes) { \
4503 if (sizeof(GLTYPE) == 2) { \
4505 } else if (sizeof(GLTYPE) == 4) { \
4509 depthValues[i] = GLTYPE2FLOAT(value); \
4515 * Unpack a row of depth/z values from memory, returning GLushort, GLuint
4516 * or GLfloat values.
4517 * The glPixelTransfer (scale/bias) params will be applied.
4519 * \param dstType one of GL_UNSIGNED_SHORT, GL_UNSIGNED_INT, GL_FLOAT
4520 * \param depthMax max value for returned GLushort or GLuint values
4521 * (ignored for GLfloat).
4524 _mesa_unpack_depth_span( const GLcontext
*ctx
, GLuint n
,
4525 GLenum dstType
, GLvoid
*dest
, GLuint depthMax
,
4526 GLenum srcType
, const GLvoid
*source
,
4527 const struct gl_pixelstore_attrib
*srcPacking
)
4529 GLfloat depthTemp
[MAX_WIDTH
], *depthValues
;
4530 GLboolean needClamp
= GL_FALSE
;
4532 /* Look for special cases first.
4533 * Not only are these faster, they're less prone to numeric conversion
4534 * problems. Otherwise, converting from an int type to a float then
4535 * back to an int type can introduce errors that will show up as
4536 * artifacts in things like depth peeling which uses glCopyTexImage.
4538 if (ctx
->Pixel
.DepthScale
== 1.0 && ctx
->Pixel
.DepthBias
== 0.0) {
4539 if (srcType
== GL_UNSIGNED_INT
&& dstType
== GL_UNSIGNED_SHORT
) {
4540 const GLuint
*src
= (const GLuint
*) source
;
4541 GLushort
*dst
= (GLushort
*) dest
;
4543 for (i
= 0; i
< n
; i
++) {
4544 dst
[i
] = src
[i
] >> 16;
4548 if (srcType
== GL_UNSIGNED_SHORT
4549 && dstType
== GL_UNSIGNED_INT
4550 && depthMax
== 0xffffffff) {
4551 const GLushort
*src
= (const GLushort
*) source
;
4552 GLuint
*dst
= (GLuint
*) dest
;
4554 for (i
= 0; i
< n
; i
++) {
4555 dst
[i
] = src
[i
] | (src
[i
] << 16);
4559 if (srcType
== GL_UNSIGNED_INT_24_8
4560 && dstType
== GL_UNSIGNED_INT
4561 && depthMax
== 0xffffff) {
4562 const GLuint
*src
= (const GLuint
*) source
;
4563 GLuint
*dst
= (GLuint
*) dest
;
4565 for (i
= 0; i
< n
; i
++) {
4566 dst
[i
] = src
[i
] >> 8;
4570 /* XXX may want to add additional cases here someday */
4573 /* general case path follows */
4575 if (dstType
== GL_FLOAT
) {
4576 depthValues
= (GLfloat
*) dest
;
4579 depthValues
= depthTemp
;
4582 /* Convert incoming values to GLfloat. Some conversions will require
4587 DEPTH_VALUES(GLbyte
, BYTE_TO_FLOAT
);
4588 needClamp
= GL_TRUE
;
4590 case GL_UNSIGNED_BYTE
:
4591 DEPTH_VALUES(GLubyte
, UBYTE_TO_FLOAT
);
4594 DEPTH_VALUES(GLshort
, SHORT_TO_FLOAT
);
4595 needClamp
= GL_TRUE
;
4597 case GL_UNSIGNED_SHORT
:
4598 DEPTH_VALUES(GLushort
, USHORT_TO_FLOAT
);
4601 DEPTH_VALUES(GLint
, INT_TO_FLOAT
);
4602 needClamp
= GL_TRUE
;
4604 case GL_UNSIGNED_INT
:
4605 DEPTH_VALUES(GLuint
, UINT_TO_FLOAT
);
4607 case GL_UNSIGNED_INT_24_8_EXT
: /* GL_EXT_packed_depth_stencil */
4608 if (dstType
== GL_UNSIGNED_INT_24_8_EXT
&&
4609 depthMax
== 0xffffff &&
4610 ctx
->Pixel
.DepthScale
== 1.0 &&
4611 ctx
->Pixel
.DepthBias
== 0.0) {
4612 const GLuint
*src
= (const GLuint
*) source
;
4613 GLuint
*zValues
= (GLuint
*) dest
;
4615 for (i
= 0; i
< n
; i
++) {
4616 GLuint value
= src
[i
];
4617 if (srcPacking
->SwapBytes
) {
4620 zValues
[i
] = value
& 0xffffff00;
4625 const GLuint
*src
= (const GLuint
*) source
;
4626 const GLfloat scale
= 1.0f
/ 0xffffff;
4628 for (i
= 0; i
< n
; i
++) {
4629 GLuint value
= src
[i
];
4630 if (srcPacking
->SwapBytes
) {
4633 depthValues
[i
] = (value
>> 8) * scale
;
4638 DEPTH_VALUES(GLfloat
, 1*);
4639 needClamp
= GL_TRUE
;
4641 case GL_HALF_FLOAT_ARB
:
4644 const GLhalfARB
*src
= (const GLhalfARB
*) source
;
4645 for (i
= 0; i
< n
; i
++) {
4646 GLhalfARB value
= src
[i
];
4647 if (srcPacking
->SwapBytes
) {
4650 depthValues
[i
] = _mesa_half_to_float(value
);
4652 needClamp
= GL_TRUE
;
4656 _mesa_problem(NULL
, "bad type in _mesa_unpack_depth_span()");
4660 /* apply depth scale and bias */
4662 const GLfloat scale
= ctx
->Pixel
.DepthScale
;
4663 const GLfloat bias
= ctx
->Pixel
.DepthBias
;
4664 if (scale
!= 1.0 || bias
!= 0.0) {
4666 for (i
= 0; i
< n
; i
++) {
4667 depthValues
[i
] = depthValues
[i
] * scale
+ bias
;
4669 needClamp
= GL_TRUE
;
4673 /* clamp to [0, 1] */
4676 for (i
= 0; i
< n
; i
++) {
4677 depthValues
[i
] = (GLfloat
)CLAMP(depthValues
[i
], 0.0, 1.0);
4682 * Convert values to dstType
4684 if (dstType
== GL_UNSIGNED_INT
) {
4685 GLuint
*zValues
= (GLuint
*) dest
;
4687 if (depthMax
<= 0xffffff) {
4688 /* no overflow worries */
4689 for (i
= 0; i
< n
; i
++) {
4690 zValues
[i
] = (GLuint
) (depthValues
[i
] * (GLfloat
) depthMax
);
4694 /* need to use double precision to prevent overflow problems */
4695 for (i
= 0; i
< n
; i
++) {
4696 GLdouble z
= depthValues
[i
] * (GLfloat
) depthMax
;
4697 if (z
>= (GLdouble
) 0xffffffff)
4698 zValues
[i
] = 0xffffffff;
4700 zValues
[i
] = (GLuint
) z
;
4704 else if (dstType
== GL_UNSIGNED_SHORT
) {
4705 GLushort
*zValues
= (GLushort
*) dest
;
4707 ASSERT(depthMax
<= 0xffff);
4708 for (i
= 0; i
< n
; i
++) {
4709 zValues
[i
] = (GLushort
) (depthValues
[i
] * (GLfloat
) depthMax
);
4713 ASSERT(dstType
== GL_FLOAT
);
4714 /*ASSERT(depthMax == 1.0F);*/
4720 * Pack an array of depth values. The values are floats in [0,1].
4723 _mesa_pack_depth_span( const GLcontext
*ctx
, GLuint n
, GLvoid
*dest
,
4724 GLenum dstType
, const GLfloat
*depthSpan
,
4725 const struct gl_pixelstore_attrib
*dstPacking
)
4727 GLfloat depthCopy
[MAX_WIDTH
];
4729 ASSERT(n
<= MAX_WIDTH
);
4731 if (ctx
->Pixel
.DepthScale
!= 1.0 || ctx
->Pixel
.DepthBias
!= 0.0) {
4732 _mesa_memcpy(depthCopy
, depthSpan
, n
* sizeof(GLfloat
));
4733 _mesa_scale_and_bias_depth(ctx
, n
, depthCopy
);
4734 depthSpan
= depthCopy
;
4738 case GL_UNSIGNED_BYTE
:
4740 GLubyte
*dst
= (GLubyte
*) dest
;
4742 for (i
= 0; i
< n
; i
++) {
4743 dst
[i
] = FLOAT_TO_UBYTE( depthSpan
[i
] );
4749 GLbyte
*dst
= (GLbyte
*) dest
;
4751 for (i
= 0; i
< n
; i
++) {
4752 dst
[i
] = FLOAT_TO_BYTE( depthSpan
[i
] );
4756 case GL_UNSIGNED_SHORT
:
4758 GLushort
*dst
= (GLushort
*) dest
;
4760 for (i
= 0; i
< n
; i
++) {
4761 CLAMPED_FLOAT_TO_USHORT(dst
[i
], depthSpan
[i
]);
4763 if (dstPacking
->SwapBytes
) {
4764 _mesa_swap2( (GLushort
*) dst
, n
);
4770 GLshort
*dst
= (GLshort
*) dest
;
4772 for (i
= 0; i
< n
; i
++) {
4773 dst
[i
] = FLOAT_TO_SHORT( depthSpan
[i
] );
4775 if (dstPacking
->SwapBytes
) {
4776 _mesa_swap2( (GLushort
*) dst
, n
);
4780 case GL_UNSIGNED_INT
:
4782 GLuint
*dst
= (GLuint
*) dest
;
4784 for (i
= 0; i
< n
; i
++) {
4785 dst
[i
] = FLOAT_TO_UINT( depthSpan
[i
] );
4787 if (dstPacking
->SwapBytes
) {
4788 _mesa_swap4( (GLuint
*) dst
, n
);
4794 GLint
*dst
= (GLint
*) dest
;
4796 for (i
= 0; i
< n
; i
++) {
4797 dst
[i
] = FLOAT_TO_INT( depthSpan
[i
] );
4799 if (dstPacking
->SwapBytes
) {
4800 _mesa_swap4( (GLuint
*) dst
, n
);
4806 GLfloat
*dst
= (GLfloat
*) dest
;
4808 for (i
= 0; i
< n
; i
++) {
4809 dst
[i
] = depthSpan
[i
];
4811 if (dstPacking
->SwapBytes
) {
4812 _mesa_swap4( (GLuint
*) dst
, n
);
4816 case GL_HALF_FLOAT_ARB
:
4818 GLhalfARB
*dst
= (GLhalfARB
*) dest
;
4820 for (i
= 0; i
< n
; i
++) {
4821 dst
[i
] = _mesa_float_to_half(depthSpan
[i
]);
4823 if (dstPacking
->SwapBytes
) {
4824 _mesa_swap2( (GLushort
*) dst
, n
);
4829 _mesa_problem(ctx
, "bad type in _mesa_pack_depth_span");
4836 * Pack depth and stencil values as GL_DEPTH_STENCIL/GL_UNSIGNED_INT_24_8.
4839 _mesa_pack_depth_stencil_span(const GLcontext
*ctx
, GLuint n
, GLuint
*dest
,
4840 const GLfloat
*depthVals
,
4841 const GLstencil
*stencilVals
,
4842 const struct gl_pixelstore_attrib
*dstPacking
)
4844 GLfloat depthCopy
[MAX_WIDTH
];
4845 GLstencil stencilCopy
[MAX_WIDTH
];
4848 ASSERT(n
<= MAX_WIDTH
);
4850 if (ctx
->Pixel
.DepthScale
!= 1.0 || ctx
->Pixel
.DepthBias
!= 0.0) {
4851 _mesa_memcpy(depthCopy
, depthVals
, n
* sizeof(GLfloat
));
4852 _mesa_scale_and_bias_depth(ctx
, n
, depthCopy
);
4853 depthVals
= depthCopy
;
4856 if (ctx
->Pixel
.IndexShift
||
4857 ctx
->Pixel
.IndexOffset
||
4858 ctx
->Pixel
.MapStencilFlag
) {
4859 _mesa_memcpy(stencilCopy
, stencilVals
, n
* sizeof(GLstencil
));
4860 _mesa_apply_stencil_transfer_ops(ctx
, n
, stencilCopy
);
4861 stencilVals
= stencilCopy
;
4864 for (i
= 0; i
< n
; i
++) {
4865 GLuint z
= (GLuint
) (depthVals
[i
] * 0xffffff);
4866 dest
[i
] = (z
<< 8) | (stencilVals
[i
] & 0xff);
4869 if (dstPacking
->SwapBytes
) {
4870 _mesa_swap4(dest
, n
);
4878 * Unpack image data. Apply byte swapping, byte flipping (bitmap).
4879 * Return all image data in a contiguous block. This is used when we
4880 * compile glDrawPixels, glTexImage, etc into a display list. We
4881 * need a copy of the data in a standard format.
4884 _mesa_unpack_image( GLuint dimensions
,
4885 GLsizei width
, GLsizei height
, GLsizei depth
,
4886 GLenum format
, GLenum type
, const GLvoid
*pixels
,
4887 const struct gl_pixelstore_attrib
*unpack
)
4889 GLint bytesPerRow
, compsPerRow
;
4890 GLboolean flipBytes
, swap2
, swap4
;
4893 return NULL
; /* not necessarily an error */
4895 if (width
<= 0 || height
<= 0 || depth
<= 0)
4896 return NULL
; /* generate error later */
4898 if (type
== GL_BITMAP
) {
4899 bytesPerRow
= (width
+ 7) >> 3;
4900 flipBytes
= unpack
->LsbFirst
;
4901 swap2
= swap4
= GL_FALSE
;
4905 const GLint bytesPerPixel
= _mesa_bytes_per_pixel(format
, type
);
4906 GLint components
= _mesa_components_in_format(format
);
4909 if (_mesa_type_is_packed(type
))
4912 if (bytesPerPixel
<= 0 || components
<= 0)
4913 return NULL
; /* bad format or type. generate error later */
4914 bytesPerRow
= bytesPerPixel
* width
;
4915 bytesPerComp
= bytesPerPixel
/ components
;
4916 flipBytes
= GL_FALSE
;
4917 swap2
= (bytesPerComp
== 2) && unpack
->SwapBytes
;
4918 swap4
= (bytesPerComp
== 4) && unpack
->SwapBytes
;
4919 compsPerRow
= components
* width
;
4920 assert(compsPerRow
>= width
);
4925 = (GLubyte
*) _mesa_malloc(bytesPerRow
* height
* depth
);
4929 return NULL
; /* generate GL_OUT_OF_MEMORY later */
4932 for (img
= 0; img
< depth
; img
++) {
4933 for (row
= 0; row
< height
; row
++) {
4934 const GLvoid
*src
= _mesa_image_address(dimensions
, unpack
, pixels
,
4935 width
, height
, format
, type
, img
, row
, 0);
4937 if ((type
== GL_BITMAP
) && (unpack
->SkipPixels
& 0x7)) {
4939 flipBytes
= GL_FALSE
;
4940 if (unpack
->LsbFirst
) {
4941 GLubyte srcMask
= 1 << (unpack
->SkipPixels
& 0x7);
4942 GLubyte dstMask
= 128;
4943 const GLubyte
*s
= src
;
4946 for (i
= 0; i
< width
; i
++) {
4950 if (srcMask
== 128) {
4955 srcMask
= srcMask
<< 1;
4963 dstMask
= dstMask
>> 1;
4968 GLubyte srcMask
= 128 >> (unpack
->SkipPixels
& 0x7);
4969 GLubyte dstMask
= 128;
4970 const GLubyte
*s
= src
;
4973 for (i
= 0; i
< width
; i
++) {
4982 srcMask
= srcMask
>> 1;
4990 dstMask
= dstMask
>> 1;
4996 _mesa_memcpy(dst
, src
, bytesPerRow
);
4999 /* byte flipping/swapping */
5001 flip_bytes((GLubyte
*) dst
, bytesPerRow
);
5004 _mesa_swap2((GLushort
*) dst
, compsPerRow
);
5007 _mesa_swap4((GLuint
*) dst
, compsPerRow
);
5016 #endif /* _HAVE_FULL_GL */
5021 * Convert an array of RGBA colors from one datatype to another.
5022 * NOTE: src may equal dst. In that case, we use a temporary buffer.
5025 _mesa_convert_colors(GLenum srcType
, const GLvoid
*src
,
5026 GLenum dstType
, GLvoid
*dst
,
5027 GLuint count
, const GLubyte mask
[])
5029 GLuint tempBuffer
[MAX_WIDTH
][4];
5030 const GLboolean useTemp
= (src
== dst
);
5032 ASSERT(srcType
!= dstType
);
5035 case GL_UNSIGNED_BYTE
:
5036 if (dstType
== GL_UNSIGNED_SHORT
) {
5037 const GLubyte (*src1
)[4] = (const GLubyte (*)[4]) src
;
5038 GLushort (*dst2
)[4] = (GLushort (*)[4]) (useTemp
? tempBuffer
: dst
);
5040 for (i
= 0; i
< count
; i
++) {
5041 if (!mask
|| mask
[i
]) {
5042 dst2
[i
][RCOMP
] = UBYTE_TO_USHORT(src1
[i
][RCOMP
]);
5043 dst2
[i
][GCOMP
] = UBYTE_TO_USHORT(src1
[i
][GCOMP
]);
5044 dst2
[i
][BCOMP
] = UBYTE_TO_USHORT(src1
[i
][BCOMP
]);
5045 dst2
[i
][ACOMP
] = UBYTE_TO_USHORT(src1
[i
][ACOMP
]);
5049 _mesa_memcpy(dst
, tempBuffer
, count
* 4 * sizeof(GLushort
));
5052 const GLubyte (*src1
)[4] = (const GLubyte (*)[4]) src
;
5053 GLfloat (*dst4
)[4] = (GLfloat (*)[4]) (useTemp
? tempBuffer
: dst
);
5055 ASSERT(dstType
== GL_FLOAT
);
5056 for (i
= 0; i
< count
; i
++) {
5057 if (!mask
|| mask
[i
]) {
5058 dst4
[i
][RCOMP
] = UBYTE_TO_FLOAT(src1
[i
][RCOMP
]);
5059 dst4
[i
][GCOMP
] = UBYTE_TO_FLOAT(src1
[i
][GCOMP
]);
5060 dst4
[i
][BCOMP
] = UBYTE_TO_FLOAT(src1
[i
][BCOMP
]);
5061 dst4
[i
][ACOMP
] = UBYTE_TO_FLOAT(src1
[i
][ACOMP
]);
5065 _mesa_memcpy(dst
, tempBuffer
, count
* 4 * sizeof(GLfloat
));
5068 case GL_UNSIGNED_SHORT
:
5069 if (dstType
== GL_UNSIGNED_BYTE
) {
5070 const GLushort (*src2
)[4] = (const GLushort (*)[4]) src
;
5071 GLubyte (*dst1
)[4] = (GLubyte (*)[4]) (useTemp
? tempBuffer
: dst
);
5073 for (i
= 0; i
< count
; i
++) {
5074 if (!mask
|| mask
[i
]) {
5075 dst1
[i
][RCOMP
] = USHORT_TO_UBYTE(src2
[i
][RCOMP
]);
5076 dst1
[i
][GCOMP
] = USHORT_TO_UBYTE(src2
[i
][GCOMP
]);
5077 dst1
[i
][BCOMP
] = USHORT_TO_UBYTE(src2
[i
][BCOMP
]);
5078 dst1
[i
][ACOMP
] = USHORT_TO_UBYTE(src2
[i
][ACOMP
]);
5082 _mesa_memcpy(dst
, tempBuffer
, count
* 4 * sizeof(GLubyte
));
5085 const GLushort (*src2
)[4] = (const GLushort (*)[4]) src
;
5086 GLfloat (*dst4
)[4] = (GLfloat (*)[4]) (useTemp
? tempBuffer
: dst
);
5088 ASSERT(dstType
== GL_FLOAT
);
5089 for (i
= 0; i
< count
; i
++) {
5090 if (!mask
|| mask
[i
]) {
5091 dst4
[i
][RCOMP
] = USHORT_TO_FLOAT(src2
[i
][RCOMP
]);
5092 dst4
[i
][GCOMP
] = USHORT_TO_FLOAT(src2
[i
][GCOMP
]);
5093 dst4
[i
][BCOMP
] = USHORT_TO_FLOAT(src2
[i
][BCOMP
]);
5094 dst4
[i
][ACOMP
] = USHORT_TO_FLOAT(src2
[i
][ACOMP
]);
5098 _mesa_memcpy(dst
, tempBuffer
, count
* 4 * sizeof(GLfloat
));
5102 if (dstType
== GL_UNSIGNED_BYTE
) {
5103 const GLfloat (*src4
)[4] = (const GLfloat (*)[4]) src
;
5104 GLubyte (*dst1
)[4] = (GLubyte (*)[4]) (useTemp
? tempBuffer
: dst
);
5106 for (i
= 0; i
< count
; i
++) {
5107 if (!mask
|| mask
[i
]) {
5108 UNCLAMPED_FLOAT_TO_UBYTE(dst1
[i
][RCOMP
], src4
[i
][RCOMP
]);
5109 UNCLAMPED_FLOAT_TO_UBYTE(dst1
[i
][GCOMP
], src4
[i
][GCOMP
]);
5110 UNCLAMPED_FLOAT_TO_UBYTE(dst1
[i
][BCOMP
], src4
[i
][BCOMP
]);
5111 UNCLAMPED_FLOAT_TO_UBYTE(dst1
[i
][ACOMP
], src4
[i
][ACOMP
]);
5115 _mesa_memcpy(dst
, tempBuffer
, count
* 4 * sizeof(GLubyte
));
5118 const GLfloat (*src4
)[4] = (const GLfloat (*)[4]) src
;
5119 GLushort (*dst2
)[4] = (GLushort (*)[4]) (useTemp
? tempBuffer
: dst
);
5121 ASSERT(dstType
== GL_UNSIGNED_SHORT
);
5122 for (i
= 0; i
< count
; i
++) {
5123 if (!mask
|| mask
[i
]) {
5124 UNCLAMPED_FLOAT_TO_USHORT(dst2
[i
][RCOMP
], src4
[i
][RCOMP
]);
5125 UNCLAMPED_FLOAT_TO_USHORT(dst2
[i
][GCOMP
], src4
[i
][GCOMP
]);
5126 UNCLAMPED_FLOAT_TO_USHORT(dst2
[i
][BCOMP
], src4
[i
][BCOMP
]);
5127 UNCLAMPED_FLOAT_TO_USHORT(dst2
[i
][ACOMP
], src4
[i
][ACOMP
]);
5131 _mesa_memcpy(dst
, tempBuffer
, count
* 4 * sizeof(GLushort
));
5135 _mesa_problem(NULL
, "Invalid datatype in _mesa_convert_colors");
5143 * Perform basic clipping for glDrawPixels. The image's position and size
5144 * and the unpack SkipPixels and SkipRows are adjusted so that the image
5145 * region is entirely within the window and scissor bounds.
5146 * NOTE: this will only work when glPixelZoom is (1, 1) or (1, -1).
5147 * If Pixel.ZoomY is -1, *destY will be changed to be the first row which
5148 * we'll actually write. Beforehand, *destY-1 is the first drawing row.
5150 * \return GL_TRUE if image is ready for drawing or
5151 * GL_FALSE if image was completely clipped away (draw nothing)
5154 _mesa_clip_drawpixels(const GLcontext
*ctx
,
5155 GLint
*destX
, GLint
*destY
,
5156 GLsizei
*width
, GLsizei
*height
,
5157 struct gl_pixelstore_attrib
*unpack
)
5159 const GLframebuffer
*buffer
= ctx
->DrawBuffer
;
5161 if (unpack
->RowLength
== 0) {
5162 unpack
->RowLength
= *width
;
5165 ASSERT(ctx
->Pixel
.ZoomX
== 1.0F
);
5166 ASSERT(ctx
->Pixel
.ZoomY
== 1.0F
|| ctx
->Pixel
.ZoomY
== -1.0F
);
5169 if (*destX
< buffer
->_Xmin
) {
5170 unpack
->SkipPixels
+= (buffer
->_Xmin
- *destX
);
5171 *width
-= (buffer
->_Xmin
- *destX
);
5172 *destX
= buffer
->_Xmin
;
5174 /* right clipping */
5175 if (*destX
+ *width
> buffer
->_Xmax
)
5176 *width
-= (*destX
+ *width
- buffer
->_Xmax
);
5181 if (ctx
->Pixel
.ZoomY
== 1.0F
) {
5182 /* bottom clipping */
5183 if (*destY
< buffer
->_Ymin
) {
5184 unpack
->SkipRows
+= (buffer
->_Ymin
- *destY
);
5185 *height
-= (buffer
->_Ymin
- *destY
);
5186 *destY
= buffer
->_Ymin
;
5189 if (*destY
+ *height
> buffer
->_Ymax
)
5190 *height
-= (*destY
+ *height
- buffer
->_Ymax
);
5192 else { /* upside down */
5194 if (*destY
> buffer
->_Ymax
) {
5195 unpack
->SkipRows
+= (*destY
- buffer
->_Ymax
);
5196 *height
-= (*destY
- buffer
->_Ymax
);
5197 *destY
= buffer
->_Ymax
;
5199 /* bottom clipping */
5200 if (*destY
- *height
< buffer
->_Ymin
)
5201 *height
-= (buffer
->_Ymin
- (*destY
- *height
));
5202 /* adjust destY so it's the first row to write to */
5214 * Perform clipping for glReadPixels. The image's window position
5215 * and size, and the pack skipPixels, skipRows and rowLength are adjusted
5216 * so that the image region is entirely within the window bounds.
5217 * Note: this is different from _mesa_clip_drawpixels() in that the
5218 * scissor box is ignored, and we use the bounds of the current readbuffer
5221 * \return GL_TRUE if image is ready for drawing or
5222 * GL_FALSE if image was completely clipped away (draw nothing)
5225 _mesa_clip_readpixels(const GLcontext
*ctx
,
5226 GLint
*srcX
, GLint
*srcY
,
5227 GLsizei
*width
, GLsizei
*height
,
5228 struct gl_pixelstore_attrib
*pack
)
5230 const GLframebuffer
*buffer
= ctx
->ReadBuffer
;
5232 if (pack
->RowLength
== 0) {
5233 pack
->RowLength
= *width
;
5238 pack
->SkipPixels
+= (0 - *srcX
);
5239 *width
-= (0 - *srcX
);
5242 /* right clipping */
5243 if (*srcX
+ *width
> (GLsizei
) buffer
->Width
)
5244 *width
-= (*srcX
+ *width
- buffer
->Width
);
5249 /* bottom clipping */
5251 pack
->SkipRows
+= (0 - *srcY
);
5252 *height
-= (0 - *srcY
);
5256 if (*srcY
+ *height
> (GLsizei
) buffer
->Height
)
5257 *height
-= (*srcY
+ *height
- buffer
->Height
);
5267 * Do clipping for a glCopyTexSubImage call.
5268 * The framebuffer source region might extend outside the framebuffer
5269 * bounds. Clip the source region against the framebuffer bounds and
5270 * adjust the texture/dest position and size accordingly.
5272 * \return GL_FALSE if region is totally clipped, GL_TRUE otherwise.
5275 _mesa_clip_copytexsubimage(const GLcontext
*ctx
,
5276 GLint
*destX
, GLint
*destY
,
5277 GLint
*srcX
, GLint
*srcY
,
5278 GLsizei
*width
, GLsizei
*height
)
5280 const struct gl_framebuffer
*fb
= ctx
->ReadBuffer
;
5281 const GLint srcX0
= *srcX
, srcY0
= *srcY
;
5283 if (_mesa_clip_to_region(0, 0, fb
->Width
, fb
->Height
,
5284 srcX
, srcY
, width
, height
)) {
5285 *destX
= *destX
+ *srcX
- srcX0
;
5286 *destY
= *destY
+ *srcY
- srcY0
;
5298 * Clip the rectangle defined by (x, y, width, height) against the bounds
5299 * specified by [xmin, xmax) and [ymin, ymax).
5300 * \return GL_FALSE if rect is totally clipped, GL_TRUE otherwise.
5303 _mesa_clip_to_region(GLint xmin
, GLint ymin
,
5304 GLint xmax
, GLint ymax
,
5306 GLsizei
*width
, GLsizei
*height
)
5310 *width
-= (xmin
- *x
);
5314 /* right clipping */
5315 if (*x
+ *width
> xmax
)
5316 *width
-= (*x
+ *width
- xmax
);
5321 /* bottom (or top) clipping */
5323 *height
-= (ymin
- *y
);
5327 /* top (or bottom) clipping */
5328 if (*y
+ *height
> ymax
)
5329 *height
-= (*y
+ *height
- ymax
);