2 * Mesa 3-D graphics library
5 * Copyright (C) 1999-2007 Brian Paul All Rights Reserved.
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
37 #include "histogram.h"
44 * Normally, BYTE_TO_FLOAT(0) returns 0.00392 That causes problems when
45 * we later convert the float to a packed integer value (such as for
46 * GL_RGB5_A1) because we'll wind up with a non-zero value.
48 * We redefine the macros here so zero is handled correctly.
51 #define BYTE_TO_FLOAT(B) ((B) == 0 ? 0.0F : ((2.0F * (B) + 1.0F) * (1.0F/255.0F)))
54 #define SHORT_TO_FLOAT(S) ((S) == 0 ? 0.0F : ((2.0F * (S) + 1.0F) * (1.0F/65535.0F)))
58 /** Compute ceiling of integer quotient of A divided by B. */
59 #define CEILING( A, B ) ( (A) % (B) == 0 ? (A)/(B) : (A)/(B)+1 )
63 * \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
:
304 * Get the bytes per pixel of pixel format type pair.
306 * \param format pixel format.
307 * \param type pixel type.
309 * \return bytes per pixel, or -1 if a bad format or type was given.
312 _mesa_bytes_per_pixel( GLenum format
, GLenum type
)
314 GLint comps
= _mesa_components_in_format( format
);
320 return 0; /* special case */
322 case GL_UNSIGNED_BYTE
:
323 return comps
* sizeof(GLubyte
);
325 case GL_UNSIGNED_SHORT
:
326 return comps
* sizeof(GLshort
);
328 case GL_UNSIGNED_INT
:
329 return comps
* sizeof(GLint
);
331 return comps
* sizeof(GLfloat
);
332 case GL_HALF_FLOAT_ARB
:
333 return comps
* sizeof(GLhalfARB
);
334 case GL_UNSIGNED_BYTE_3_3_2
:
335 case GL_UNSIGNED_BYTE_2_3_3_REV
:
336 if (format
== GL_RGB
|| format
== GL_BGR
)
337 return sizeof(GLubyte
);
339 return -1; /* error */
340 case GL_UNSIGNED_SHORT_5_6_5
:
341 case GL_UNSIGNED_SHORT_5_6_5_REV
:
342 if (format
== GL_RGB
|| format
== GL_BGR
)
343 return sizeof(GLushort
);
345 return -1; /* error */
346 case GL_UNSIGNED_SHORT_4_4_4_4
:
347 case GL_UNSIGNED_SHORT_4_4_4_4_REV
:
348 case GL_UNSIGNED_SHORT_5_5_5_1
:
349 case GL_UNSIGNED_SHORT_1_5_5_5_REV
:
350 if (format
== GL_RGBA
|| format
== GL_BGRA
|| format
== GL_ABGR_EXT
)
351 return sizeof(GLushort
);
354 case GL_UNSIGNED_INT_8_8_8_8
:
355 case GL_UNSIGNED_INT_8_8_8_8_REV
:
356 case GL_UNSIGNED_INT_10_10_10_2
:
357 case GL_UNSIGNED_INT_2_10_10_10_REV
:
358 if (format
== GL_RGBA
|| format
== GL_BGRA
|| format
== GL_ABGR_EXT
)
359 return sizeof(GLuint
);
362 case GL_UNSIGNED_SHORT_8_8_MESA
:
363 case GL_UNSIGNED_SHORT_8_8_REV_MESA
:
364 if (format
== GL_YCBCR_MESA
)
365 return sizeof(GLushort
);
368 case GL_UNSIGNED_INT_24_8_EXT
:
369 if (format
== GL_DEPTH_STENCIL_EXT
)
370 return sizeof(GLuint
);
380 * Test for a legal pixel format and type.
382 * \param format pixel format.
383 * \param type pixel type.
385 * \return GL_TRUE if the given pixel format and type are legal, or GL_FALSE
389 _mesa_is_legal_format_and_type( GLcontext
*ctx
, GLenum format
, GLenum type
)
393 case GL_STENCIL_INDEX
:
397 case GL_UNSIGNED_BYTE
:
399 case GL_UNSIGNED_SHORT
:
401 case GL_UNSIGNED_INT
:
404 case GL_HALF_FLOAT_ARB
:
405 return ctx
->Extensions
.ARB_half_float_pixel
;
413 #if 0 /* not legal! see table 3.6 of the 1.5 spec */
417 case GL_LUMINANCE_ALPHA
:
418 case GL_DEPTH_COMPONENT
:
421 case GL_UNSIGNED_BYTE
:
423 case GL_UNSIGNED_SHORT
:
425 case GL_UNSIGNED_INT
:
428 case GL_HALF_FLOAT_ARB
:
429 return ctx
->Extensions
.ARB_half_float_pixel
;
436 case GL_UNSIGNED_BYTE
:
438 case GL_UNSIGNED_SHORT
:
440 case GL_UNSIGNED_INT
:
442 case GL_UNSIGNED_BYTE_3_3_2
:
443 case GL_UNSIGNED_BYTE_2_3_3_REV
:
444 case GL_UNSIGNED_SHORT_5_6_5
:
445 case GL_UNSIGNED_SHORT_5_6_5_REV
:
447 case GL_HALF_FLOAT_ARB
:
448 return ctx
->Extensions
.ARB_half_float_pixel
;
454 /* NOTE: no packed types are supported with BGR. That's
455 * intentional, according to the GL spec.
458 case GL_UNSIGNED_BYTE
:
460 case GL_UNSIGNED_SHORT
:
462 case GL_UNSIGNED_INT
:
465 case GL_HALF_FLOAT_ARB
:
466 return ctx
->Extensions
.ARB_half_float_pixel
;
475 case GL_UNSIGNED_BYTE
:
477 case GL_UNSIGNED_SHORT
:
479 case GL_UNSIGNED_INT
:
481 case GL_UNSIGNED_SHORT_4_4_4_4
:
482 case GL_UNSIGNED_SHORT_4_4_4_4_REV
:
483 case GL_UNSIGNED_SHORT_5_5_5_1
:
484 case GL_UNSIGNED_SHORT_1_5_5_5_REV
:
485 case GL_UNSIGNED_INT_8_8_8_8
:
486 case GL_UNSIGNED_INT_8_8_8_8_REV
:
487 case GL_UNSIGNED_INT_10_10_10_2
:
488 case GL_UNSIGNED_INT_2_10_10_10_REV
:
490 case GL_HALF_FLOAT_ARB
:
491 return ctx
->Extensions
.ARB_half_float_pixel
;
496 if (type
== GL_UNSIGNED_SHORT_8_8_MESA
||
497 type
== GL_UNSIGNED_SHORT_8_8_REV_MESA
)
501 case GL_DEPTH_STENCIL_EXT
:
502 if (ctx
->Extensions
.EXT_packed_depth_stencil
503 && type
== GL_UNSIGNED_INT_24_8_EXT
)
515 * Return the address of a specific pixel in an image (1D, 2D or 3D).
517 * Pixel unpacking/packing parameters are observed according to \p packing.
519 * \param dimensions either 1, 2 or 3 to indicate dimensionality of image
520 * \param image starting address of image data
521 * \param width the image width
522 * \param height theimage height
523 * \param format the pixel format
524 * \param type the pixel data type
525 * \param packing the pixelstore attributes
526 * \param img which image in the volume (0 for 1D or 2D images)
527 * \param row row of pixel in the image (0 for 1D images)
528 * \param column column of pixel in the image
530 * \return address of pixel on success, or NULL on error.
532 * \sa gl_pixelstore_attrib.
535 _mesa_image_address( GLuint dimensions
,
536 const struct gl_pixelstore_attrib
*packing
,
538 GLsizei width
, GLsizei height
,
539 GLenum format
, GLenum type
,
540 GLint img
, GLint row
, GLint column
)
542 GLint alignment
; /* 1, 2 or 4 */
543 GLint pixels_per_row
;
544 GLint rows_per_image
;
547 GLint skipimages
; /* for 3-D volume images */
550 ASSERT(dimensions
>= 1 && dimensions
<= 3);
552 alignment
= packing
->Alignment
;
553 if (packing
->RowLength
> 0) {
554 pixels_per_row
= packing
->RowLength
;
557 pixels_per_row
= width
;
559 if (packing
->ImageHeight
> 0) {
560 rows_per_image
= packing
->ImageHeight
;
563 rows_per_image
= height
;
566 skippixels
= packing
->SkipPixels
;
567 /* Note: SKIP_ROWS _is_ used for 1D images */
568 skiprows
= packing
->SkipRows
;
569 /* Note: SKIP_IMAGES is only used for 3D images */
570 skipimages
= (dimensions
== 3) ? packing
->SkipImages
: 0;
572 if (type
== GL_BITMAP
) {
574 GLint comp_per_pixel
; /* components per pixel */
575 GLint bytes_per_comp
; /* bytes per component */
577 GLint bytes_per_image
;
579 /* Compute bytes per component */
580 bytes_per_comp
= _mesa_sizeof_packed_type( type
);
581 if (bytes_per_comp
< 0) {
585 /* Compute number of components per pixel */
586 comp_per_pixel
= _mesa_components_in_format( format
);
587 if (comp_per_pixel
< 0) {
591 bytes_per_row
= alignment
592 * CEILING( comp_per_pixel
*pixels_per_row
, 8*alignment
);
594 bytes_per_image
= bytes_per_row
* rows_per_image
;
596 pixel_addr
= (GLubyte
*) image
597 + (skipimages
+ img
) * bytes_per_image
598 + (skiprows
+ row
) * bytes_per_row
599 + (skippixels
+ column
) / 8;
602 /* Non-BITMAP data */
603 GLint bytes_per_pixel
, bytes_per_row
, remainder
, bytes_per_image
;
606 bytes_per_pixel
= _mesa_bytes_per_pixel( format
, type
);
608 /* The pixel type and format should have been error checked earlier */
609 assert(bytes_per_pixel
> 0);
611 bytes_per_row
= pixels_per_row
* bytes_per_pixel
;
612 remainder
= bytes_per_row
% alignment
;
614 bytes_per_row
+= (alignment
- remainder
);
616 ASSERT(bytes_per_row
% alignment
== 0);
618 bytes_per_image
= bytes_per_row
* rows_per_image
;
620 if (packing
->Invert
) {
621 /* set pixel_addr to the last row */
622 topOfImage
= bytes_per_row
* (height
- 1);
623 bytes_per_row
= -bytes_per_row
;
629 /* compute final pixel address */
630 pixel_addr
= (GLubyte
*) image
631 + (skipimages
+ img
) * bytes_per_image
633 + (skiprows
+ row
) * bytes_per_row
634 + (skippixels
+ column
) * bytes_per_pixel
;
637 return (GLvoid
*) pixel_addr
;
642 _mesa_image_address1d( const struct gl_pixelstore_attrib
*packing
,
645 GLenum format
, GLenum type
,
648 return _mesa_image_address(1, packing
, image
, width
, 1,
649 format
, type
, 0, 0, column
);
654 _mesa_image_address2d( const struct gl_pixelstore_attrib
*packing
,
656 GLsizei width
, GLsizei height
,
657 GLenum format
, GLenum type
,
658 GLint row
, GLint column
)
660 return _mesa_image_address(2, packing
, image
, width
, height
,
661 format
, type
, 0, row
, column
);
666 _mesa_image_address3d( const struct gl_pixelstore_attrib
*packing
,
668 GLsizei width
, GLsizei height
,
669 GLenum format
, GLenum type
,
670 GLint img
, GLint row
, GLint column
)
672 return _mesa_image_address(3, packing
, image
, width
, height
,
673 format
, type
, img
, row
, column
);
679 * Compute the stride (in bytes) between image rows.
681 * \param packing the pixelstore attributes
682 * \param width image width.
683 * \param format pixel format.
684 * \param type pixel data type.
686 * \return the stride in bytes for the given parameters, or -1 if error
689 _mesa_image_row_stride( const struct gl_pixelstore_attrib
*packing
,
690 GLint width
, GLenum format
, GLenum type
)
692 GLint bytesPerRow
, remainder
;
696 if (type
== GL_BITMAP
) {
697 if (packing
->RowLength
== 0) {
698 bytesPerRow
= (width
+ 7) / 8;
701 bytesPerRow
= (packing
->RowLength
+ 7) / 8;
705 /* Non-BITMAP data */
706 const GLint bytesPerPixel
= _mesa_bytes_per_pixel(format
, type
);
707 if (bytesPerPixel
<= 0)
708 return -1; /* error */
709 if (packing
->RowLength
== 0) {
710 bytesPerRow
= bytesPerPixel
* width
;
713 bytesPerRow
= bytesPerPixel
* packing
->RowLength
;
717 remainder
= bytesPerRow
% packing
->Alignment
;
719 bytesPerRow
+= (packing
->Alignment
- remainder
);
722 if (packing
->Invert
) {
723 /* negate the bytes per row (negative row stride) */
724 bytesPerRow
= -bytesPerRow
;
734 * Compute the stride between images in a 3D texture (in bytes) for the given
735 * pixel packing parameters and image width, format and type.
738 _mesa_image_image_stride( const struct gl_pixelstore_attrib
*packing
,
739 GLint width
, GLint height
,
740 GLenum format
, GLenum type
)
743 ASSERT(type
!= GL_BITMAP
);
746 const GLint bytesPerPixel
= _mesa_bytes_per_pixel(format
, type
);
747 GLint bytesPerRow
, bytesPerImage
, remainder
;
749 if (bytesPerPixel
<= 0)
750 return -1; /* error */
751 if (packing
->RowLength
== 0) {
752 bytesPerRow
= bytesPerPixel
* width
;
755 bytesPerRow
= bytesPerPixel
* packing
->RowLength
;
757 remainder
= bytesPerRow
% packing
->Alignment
;
759 bytesPerRow
+= (packing
->Alignment
- remainder
);
761 if (packing
->ImageHeight
== 0)
762 bytesPerImage
= bytesPerRow
* height
;
764 bytesPerImage
= bytesPerRow
* packing
->ImageHeight
;
766 return bytesPerImage
;
772 * Unpack a 32x32 pixel polygon stipple from user memory using the
773 * current pixel unpack settings.
776 _mesa_unpack_polygon_stipple( const GLubyte
*pattern
, GLuint dest
[32],
777 const struct gl_pixelstore_attrib
*unpacking
)
779 GLubyte
*ptrn
= (GLubyte
*) _mesa_unpack_bitmap(32, 32, pattern
, unpacking
);
781 /* Convert pattern from GLubytes to GLuints and handle big/little
786 for (i
= 0; i
< 32; i
++) {
787 dest
[i
] = (p
[0] << 24)
799 * Pack polygon stipple into user memory given current pixel packing
803 _mesa_pack_polygon_stipple( const GLuint pattern
[32], GLubyte
*dest
,
804 const struct gl_pixelstore_attrib
*packing
)
806 /* Convert pattern from GLuints to GLubytes to handle big/little
807 * endian differences.
811 for (i
= 0; i
< 32; i
++) {
812 ptrn
[i
* 4 + 0] = (GLubyte
) ((pattern
[i
] >> 24) & 0xff);
813 ptrn
[i
* 4 + 1] = (GLubyte
) ((pattern
[i
] >> 16) & 0xff);
814 ptrn
[i
* 4 + 2] = (GLubyte
) ((pattern
[i
] >> 8 ) & 0xff);
815 ptrn
[i
* 4 + 3] = (GLubyte
) ((pattern
[i
] ) & 0xff);
818 _mesa_pack_bitmap(32, 32, ptrn
, dest
, packing
);
823 * Unpack bitmap data. Resulting data will be in most-significant-bit-first
824 * order with row alignment = 1 byte.
827 _mesa_unpack_bitmap( GLint width
, GLint height
, const GLubyte
*pixels
,
828 const struct gl_pixelstore_attrib
*packing
)
830 GLint bytes
, row
, width_in_bytes
;
831 GLubyte
*buffer
, *dst
;
836 /* Alloc dest storage */
837 bytes
= ((width
+ 7) / 8 * height
);
838 buffer
= (GLubyte
*) _mesa_malloc( bytes
);
842 width_in_bytes
= CEILING( width
, 8 );
844 for (row
= 0; row
< height
; row
++) {
845 const GLubyte
*src
= (const GLubyte
*)
846 _mesa_image_address2d(packing
, pixels
, width
, height
,
847 GL_COLOR_INDEX
, GL_BITMAP
, row
, 0);
853 if ((packing
->SkipPixels
& 7) == 0) {
854 _mesa_memcpy( dst
, src
, width_in_bytes
);
855 if (packing
->LsbFirst
) {
856 flip_bytes( dst
, width_in_bytes
);
860 /* handling SkipPixels is a bit tricky (no pun intended!) */
862 if (packing
->LsbFirst
) {
863 GLubyte srcMask
= 1 << (packing
->SkipPixels
& 0x7);
864 GLubyte dstMask
= 128;
865 const GLubyte
*s
= src
;
868 for (i
= 0; i
< width
; i
++) {
872 if (srcMask
== 128) {
877 srcMask
= srcMask
<< 1;
885 dstMask
= dstMask
>> 1;
890 GLubyte srcMask
= 128 >> (packing
->SkipPixels
& 0x7);
891 GLubyte dstMask
= 128;
892 const GLubyte
*s
= src
;
895 for (i
= 0; i
< width
; i
++) {
904 srcMask
= srcMask
>> 1;
912 dstMask
= dstMask
>> 1;
917 dst
+= width_in_bytes
;
928 _mesa_pack_bitmap( GLint width
, GLint height
, const GLubyte
*source
,
929 GLubyte
*dest
, const struct gl_pixelstore_attrib
*packing
)
931 GLint row
, width_in_bytes
;
937 width_in_bytes
= CEILING( width
, 8 );
939 for (row
= 0; row
< height
; row
++) {
940 GLubyte
*dst
= (GLubyte
*) _mesa_image_address2d(packing
, dest
,
941 width
, height
, GL_COLOR_INDEX
, GL_BITMAP
, row
, 0);
945 if ((packing
->SkipPixels
& 7) == 0) {
946 _mesa_memcpy( dst
, src
, width_in_bytes
);
947 if (packing
->LsbFirst
) {
948 flip_bytes( dst
, width_in_bytes
);
952 /* handling SkipPixels is a bit tricky (no pun intended!) */
954 if (packing
->LsbFirst
) {
955 GLubyte srcMask
= 128;
956 GLubyte dstMask
= 1 << (packing
->SkipPixels
& 0x7);
957 const GLubyte
*s
= src
;
960 for (i
= 0; i
< width
; i
++) {
969 srcMask
= srcMask
>> 1;
971 if (dstMask
== 128) {
977 dstMask
= dstMask
<< 1;
982 GLubyte srcMask
= 128;
983 GLubyte dstMask
= 128 >> (packing
->SkipPixels
& 0x7);
984 const GLubyte
*s
= src
;
987 for (i
= 0; i
< width
; i
++) {
996 srcMask
= srcMask
>> 1;
1004 dstMask
= dstMask
>> 1;
1009 src
+= width_in_bytes
;
1015 * Apply various pixel transfer operations to an array of RGBA pixels
1016 * as indicated by the transferOps bitmask
1019 _mesa_apply_rgba_transfer_ops(GLcontext
*ctx
, GLbitfield transferOps
,
1020 GLuint n
, GLfloat rgba
[][4])
1023 if (transferOps
& IMAGE_SCALE_BIAS_BIT
) {
1024 _mesa_scale_and_bias_rgba(n
, rgba
,
1025 ctx
->Pixel
.RedScale
, ctx
->Pixel
.GreenScale
,
1026 ctx
->Pixel
.BlueScale
, ctx
->Pixel
.AlphaScale
,
1027 ctx
->Pixel
.RedBias
, ctx
->Pixel
.GreenBias
,
1028 ctx
->Pixel
.BlueBias
, ctx
->Pixel
.AlphaBias
);
1030 /* color map lookup */
1031 if (transferOps
& IMAGE_MAP_COLOR_BIT
) {
1032 _mesa_map_rgba( ctx
, n
, rgba
);
1034 /* GL_COLOR_TABLE lookup */
1035 if (transferOps
& IMAGE_COLOR_TABLE_BIT
) {
1036 _mesa_lookup_rgba_float(&ctx
->ColorTable
[COLORTABLE_PRECONVOLUTION
], n
, rgba
);
1039 if (transferOps
& IMAGE_CONVOLUTION_BIT
) {
1040 /* this has to be done in the calling code */
1041 _mesa_problem(ctx
, "IMAGE_CONVOLUTION_BIT set in _mesa_apply_transfer_ops");
1043 /* GL_POST_CONVOLUTION_RED/GREEN/BLUE/ALPHA_SCALE/BIAS */
1044 if (transferOps
& IMAGE_POST_CONVOLUTION_SCALE_BIAS
) {
1045 _mesa_scale_and_bias_rgba(n
, rgba
,
1046 ctx
->Pixel
.PostConvolutionScale
[RCOMP
],
1047 ctx
->Pixel
.PostConvolutionScale
[GCOMP
],
1048 ctx
->Pixel
.PostConvolutionScale
[BCOMP
],
1049 ctx
->Pixel
.PostConvolutionScale
[ACOMP
],
1050 ctx
->Pixel
.PostConvolutionBias
[RCOMP
],
1051 ctx
->Pixel
.PostConvolutionBias
[GCOMP
],
1052 ctx
->Pixel
.PostConvolutionBias
[BCOMP
],
1053 ctx
->Pixel
.PostConvolutionBias
[ACOMP
]);
1055 /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
1056 if (transferOps
& IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT
) {
1057 _mesa_lookup_rgba_float(&ctx
->ColorTable
[COLORTABLE_POSTCONVOLUTION
], n
, rgba
);
1059 /* color matrix transform */
1060 if (transferOps
& IMAGE_COLOR_MATRIX_BIT
) {
1061 _mesa_transform_rgba(ctx
, n
, rgba
);
1063 /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
1064 if (transferOps
& IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT
) {
1065 _mesa_lookup_rgba_float(&ctx
->ColorTable
[COLORTABLE_POSTCOLORMATRIX
], n
, rgba
);
1067 /* update histogram count */
1068 if (transferOps
& IMAGE_HISTOGRAM_BIT
) {
1069 _mesa_update_histogram(ctx
, n
, (CONST
GLfloat (*)[4]) rgba
);
1071 /* update min/max values */
1072 if (transferOps
& IMAGE_MIN_MAX_BIT
) {
1073 _mesa_update_minmax(ctx
, n
, (CONST
GLfloat (*)[4]) rgba
);
1075 /* clamping to [0,1] */
1076 if (transferOps
& IMAGE_CLAMP_BIT
) {
1078 for (i
= 0; i
< n
; i
++) {
1079 rgba
[i
][RCOMP
] = CLAMP(rgba
[i
][RCOMP
], 0.0F
, 1.0F
);
1080 rgba
[i
][GCOMP
] = CLAMP(rgba
[i
][GCOMP
], 0.0F
, 1.0F
);
1081 rgba
[i
][BCOMP
] = CLAMP(rgba
[i
][BCOMP
], 0.0F
, 1.0F
);
1082 rgba
[i
][ACOMP
] = CLAMP(rgba
[i
][ACOMP
], 0.0F
, 1.0F
);
1089 * Apply color index shift and offset to an array of pixels.
1092 shift_and_offset_ci( const GLcontext
*ctx
, GLuint n
, GLuint indexes
[] )
1094 GLint shift
= ctx
->Pixel
.IndexShift
;
1095 GLint offset
= ctx
->Pixel
.IndexOffset
;
1099 indexes
[i
] = (indexes
[i
] << shift
) + offset
;
1102 else if (shift
< 0) {
1105 indexes
[i
] = (indexes
[i
] >> shift
) + offset
;
1110 indexes
[i
] = indexes
[i
] + offset
;
1118 * Apply color index shift, offset and table lookup to an array
1122 _mesa_apply_ci_transfer_ops(const GLcontext
*ctx
, GLbitfield transferOps
,
1123 GLuint n
, GLuint indexes
[])
1125 if (transferOps
& IMAGE_SHIFT_OFFSET_BIT
) {
1126 shift_and_offset_ci(ctx
, n
, indexes
);
1128 if (transferOps
& IMAGE_MAP_COLOR_BIT
) {
1129 const GLuint mask
= ctx
->PixelMaps
.ItoI
.Size
- 1;
1131 for (i
= 0; i
< n
; i
++) {
1132 const GLuint j
= indexes
[i
] & mask
;
1133 indexes
[i
] = IROUND(ctx
->PixelMaps
.ItoI
.Map
[j
]);
1140 * Apply stencil index shift, offset and table lookup to an array
1141 * of stencil values.
1144 _mesa_apply_stencil_transfer_ops(const GLcontext
*ctx
, GLuint n
,
1145 GLstencil stencil
[])
1147 if (ctx
->Pixel
.IndexShift
!= 0 || ctx
->Pixel
.IndexOffset
!= 0) {
1148 const GLint offset
= ctx
->Pixel
.IndexOffset
;
1149 GLint shift
= ctx
->Pixel
.IndexShift
;
1152 for (i
= 0; i
< n
; i
++) {
1153 stencil
[i
] = (stencil
[i
] << shift
) + offset
;
1156 else if (shift
< 0) {
1158 for (i
= 0; i
< n
; i
++) {
1159 stencil
[i
] = (stencil
[i
] >> shift
) + offset
;
1163 for (i
= 0; i
< n
; i
++) {
1164 stencil
[i
] = stencil
[i
] + offset
;
1168 if (ctx
->Pixel
.MapStencilFlag
) {
1169 GLuint mask
= ctx
->PixelMaps
.StoS
.Size
- 1;
1171 for (i
= 0; i
< n
; i
++) {
1172 stencil
[i
] = ctx
->PixelMaps
.StoS
.Map
[ stencil
[i
] & mask
];
1179 * Used to pack an array [][4] of RGBA float colors as specified
1180 * by the dstFormat, dstType and dstPacking. Used by glReadPixels,
1181 * glGetConvolutionFilter(), etc.
1182 * Incoming colors will be clamped to [0,1] if needed.
1183 * Note: the rgba values will be modified by this function when any pixel
1184 * transfer ops are enabled.
1187 _mesa_pack_rgba_span_float(GLcontext
*ctx
, GLuint n
, GLfloat rgba
[][4],
1188 GLenum dstFormat
, GLenum dstType
,
1190 const struct gl_pixelstore_attrib
*dstPacking
,
1191 GLbitfield transferOps
)
1193 GLfloat luminance
[MAX_WIDTH
];
1194 const GLint comps
= _mesa_components_in_format(dstFormat
);
1197 if (dstType
!= GL_FLOAT
|| ctx
->Color
.ClampReadColor
== GL_TRUE
) {
1198 /* need to clamp to [0, 1] */
1199 transferOps
|= IMAGE_CLAMP_BIT
;
1203 _mesa_apply_rgba_transfer_ops(ctx
, transferOps
, n
, rgba
);
1204 if ((transferOps
& IMAGE_MIN_MAX_BIT
) && ctx
->MinMax
.Sink
) {
1209 if (dstFormat
== GL_LUMINANCE
|| dstFormat
== GL_LUMINANCE_ALPHA
) {
1210 /* compute luminance values */
1211 if (dstType
!= GL_FLOAT
|| ctx
->Color
.ClampReadColor
== GL_TRUE
) {
1212 for (i
= 0; i
< n
; i
++) {
1213 GLfloat sum
= rgba
[i
][RCOMP
] + rgba
[i
][GCOMP
] + rgba
[i
][BCOMP
];
1214 luminance
[i
] = CLAMP(sum
, 0.0F
, 1.0F
);
1218 for (i
= 0; i
< n
; i
++) {
1219 luminance
[i
] = rgba
[i
][RCOMP
] + rgba
[i
][GCOMP
] + rgba
[i
][BCOMP
];
1225 * Pack/store the pixels. Ugh! Lots of cases!!!
1228 case GL_UNSIGNED_BYTE
:
1230 GLubyte
*dst
= (GLubyte
*) dstAddr
;
1231 switch (dstFormat
) {
1234 dst
[i
] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
1238 dst
[i
] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
1242 dst
[i
] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
1246 dst
[i
] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
1250 dst
[i
] = FLOAT_TO_UBYTE(luminance
[i
]);
1252 case GL_LUMINANCE_ALPHA
:
1254 dst
[i
*2+0] = FLOAT_TO_UBYTE(luminance
[i
]);
1255 dst
[i
*2+1] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
1260 dst
[i
*3+0] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
1261 dst
[i
*3+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
1262 dst
[i
*3+2] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
1267 dst
[i
*4+0] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
1268 dst
[i
*4+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
1269 dst
[i
*4+2] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
1270 dst
[i
*4+3] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
1275 dst
[i
*3+0] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
1276 dst
[i
*3+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
1277 dst
[i
*3+2] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
1282 dst
[i
*4+0] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
1283 dst
[i
*4+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
1284 dst
[i
*4+2] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
1285 dst
[i
*4+3] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
1290 dst
[i
*4+0] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
1291 dst
[i
*4+1] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
1292 dst
[i
*4+2] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
1293 dst
[i
*4+3] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
1297 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1303 GLbyte
*dst
= (GLbyte
*) dstAddr
;
1304 switch (dstFormat
) {
1307 dst
[i
] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
1311 dst
[i
] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
1315 dst
[i
] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
1319 dst
[i
] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
1323 dst
[i
] = FLOAT_TO_BYTE(luminance
[i
]);
1325 case GL_LUMINANCE_ALPHA
:
1327 dst
[i
*2+0] = FLOAT_TO_BYTE(luminance
[i
]);
1328 dst
[i
*2+1] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
1333 dst
[i
*3+0] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
1334 dst
[i
*3+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
1335 dst
[i
*3+2] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
1340 dst
[i
*4+0] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
1341 dst
[i
*4+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
1342 dst
[i
*4+2] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
1343 dst
[i
*4+3] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
1348 dst
[i
*3+0] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
1349 dst
[i
*3+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
1350 dst
[i
*3+2] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
1355 dst
[i
*4+0] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
1356 dst
[i
*4+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
1357 dst
[i
*4+2] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
1358 dst
[i
*4+3] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
1363 dst
[i
*4+0] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
1364 dst
[i
*4+1] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
1365 dst
[i
*4+2] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
1366 dst
[i
*4+3] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
1370 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1374 case GL_UNSIGNED_SHORT
:
1376 GLushort
*dst
= (GLushort
*) dstAddr
;
1377 switch (dstFormat
) {
1380 CLAMPED_FLOAT_TO_USHORT(dst
[i
], rgba
[i
][RCOMP
]);
1384 CLAMPED_FLOAT_TO_USHORT(dst
[i
], rgba
[i
][GCOMP
]);
1388 CLAMPED_FLOAT_TO_USHORT(dst
[i
], rgba
[i
][BCOMP
]);
1392 CLAMPED_FLOAT_TO_USHORT(dst
[i
], rgba
[i
][ACOMP
]);
1396 UNCLAMPED_FLOAT_TO_USHORT(dst
[i
], luminance
[i
]);
1398 case GL_LUMINANCE_ALPHA
:
1400 UNCLAMPED_FLOAT_TO_USHORT(dst
[i
*2+0], luminance
[i
]);
1401 CLAMPED_FLOAT_TO_USHORT(dst
[i
*2+1], rgba
[i
][ACOMP
]);
1406 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+0], rgba
[i
][RCOMP
]);
1407 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+1], rgba
[i
][GCOMP
]);
1408 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+2], rgba
[i
][BCOMP
]);
1413 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+0], rgba
[i
][RCOMP
]);
1414 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+1], rgba
[i
][GCOMP
]);
1415 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+2], rgba
[i
][BCOMP
]);
1416 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+3], rgba
[i
][ACOMP
]);
1421 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+0], rgba
[i
][BCOMP
]);
1422 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+1], rgba
[i
][GCOMP
]);
1423 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+2], rgba
[i
][RCOMP
]);
1428 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+0], rgba
[i
][BCOMP
]);
1429 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+1], rgba
[i
][GCOMP
]);
1430 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+2], rgba
[i
][RCOMP
]);
1431 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+3], rgba
[i
][ACOMP
]);
1436 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+0], rgba
[i
][ACOMP
]);
1437 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+1], rgba
[i
][BCOMP
]);
1438 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+2], rgba
[i
][GCOMP
]);
1439 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+3], rgba
[i
][RCOMP
]);
1443 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1449 GLshort
*dst
= (GLshort
*) dstAddr
;
1450 switch (dstFormat
) {
1453 dst
[i
] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1457 dst
[i
] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1461 dst
[i
] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1465 dst
[i
] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
1469 dst
[i
] = FLOAT_TO_SHORT(luminance
[i
]);
1471 case GL_LUMINANCE_ALPHA
:
1473 dst
[i
*2+0] = FLOAT_TO_SHORT(luminance
[i
]);
1474 dst
[i
*2+1] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
1479 dst
[i
*3+0] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1480 dst
[i
*3+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1481 dst
[i
*3+2] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1486 dst
[i
*4+0] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1487 dst
[i
*4+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1488 dst
[i
*4+2] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1489 dst
[i
*4+3] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
1494 dst
[i
*3+0] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1495 dst
[i
*3+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1496 dst
[i
*3+2] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1501 dst
[i
*4+0] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1502 dst
[i
*4+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1503 dst
[i
*4+2] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1504 dst
[i
*4+3] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
1509 dst
[i
*4+0] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
1510 dst
[i
*4+1] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1511 dst
[i
*4+2] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1512 dst
[i
*4+3] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1516 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1520 case GL_UNSIGNED_INT
:
1522 GLuint
*dst
= (GLuint
*) dstAddr
;
1523 switch (dstFormat
) {
1526 dst
[i
] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1530 dst
[i
] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1534 dst
[i
] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1538 dst
[i
] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
1542 dst
[i
] = FLOAT_TO_UINT(luminance
[i
]);
1544 case GL_LUMINANCE_ALPHA
:
1546 dst
[i
*2+0] = FLOAT_TO_UINT(luminance
[i
]);
1547 dst
[i
*2+1] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
1552 dst
[i
*3+0] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1553 dst
[i
*3+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1554 dst
[i
*3+2] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1559 dst
[i
*4+0] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1560 dst
[i
*4+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1561 dst
[i
*4+2] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1562 dst
[i
*4+3] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
1567 dst
[i
*3+0] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1568 dst
[i
*3+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1569 dst
[i
*3+2] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1574 dst
[i
*4+0] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1575 dst
[i
*4+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1576 dst
[i
*4+2] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1577 dst
[i
*4+3] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
1582 dst
[i
*4+0] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
1583 dst
[i
*4+1] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1584 dst
[i
*4+2] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1585 dst
[i
*4+3] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1589 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1595 GLint
*dst
= (GLint
*) dstAddr
;
1596 switch (dstFormat
) {
1599 dst
[i
] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1603 dst
[i
] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1607 dst
[i
] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1611 dst
[i
] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
1615 dst
[i
] = FLOAT_TO_INT(luminance
[i
]);
1617 case GL_LUMINANCE_ALPHA
:
1619 dst
[i
*2+0] = FLOAT_TO_INT(luminance
[i
]);
1620 dst
[i
*2+1] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
1625 dst
[i
*3+0] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1626 dst
[i
*3+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1627 dst
[i
*3+2] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1632 dst
[i
*4+0] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1633 dst
[i
*4+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1634 dst
[i
*4+2] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1635 dst
[i
*4+3] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
1640 dst
[i
*3+0] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1641 dst
[i
*3+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1642 dst
[i
*3+2] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1647 dst
[i
*4+0] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1648 dst
[i
*4+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1649 dst
[i
*4+2] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1650 dst
[i
*4+3] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
1655 dst
[i
*4+0] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
1656 dst
[i
*4+1] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1657 dst
[i
*4+2] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1658 dst
[i
*4+3] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1662 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1668 GLfloat
*dst
= (GLfloat
*) dstAddr
;
1669 switch (dstFormat
) {
1672 dst
[i
] = rgba
[i
][RCOMP
];
1676 dst
[i
] = rgba
[i
][GCOMP
];
1680 dst
[i
] = rgba
[i
][BCOMP
];
1684 dst
[i
] = rgba
[i
][ACOMP
];
1688 dst
[i
] = luminance
[i
];
1690 case GL_LUMINANCE_ALPHA
:
1692 dst
[i
*2+0] = luminance
[i
];
1693 dst
[i
*2+1] = rgba
[i
][ACOMP
];
1698 dst
[i
*3+0] = rgba
[i
][RCOMP
];
1699 dst
[i
*3+1] = rgba
[i
][GCOMP
];
1700 dst
[i
*3+2] = rgba
[i
][BCOMP
];
1705 dst
[i
*4+0] = rgba
[i
][RCOMP
];
1706 dst
[i
*4+1] = rgba
[i
][GCOMP
];
1707 dst
[i
*4+2] = rgba
[i
][BCOMP
];
1708 dst
[i
*4+3] = rgba
[i
][ACOMP
];
1713 dst
[i
*3+0] = rgba
[i
][BCOMP
];
1714 dst
[i
*3+1] = rgba
[i
][GCOMP
];
1715 dst
[i
*3+2] = rgba
[i
][RCOMP
];
1720 dst
[i
*4+0] = rgba
[i
][BCOMP
];
1721 dst
[i
*4+1] = rgba
[i
][GCOMP
];
1722 dst
[i
*4+2] = rgba
[i
][RCOMP
];
1723 dst
[i
*4+3] = rgba
[i
][ACOMP
];
1728 dst
[i
*4+0] = rgba
[i
][ACOMP
];
1729 dst
[i
*4+1] = rgba
[i
][BCOMP
];
1730 dst
[i
*4+2] = rgba
[i
][GCOMP
];
1731 dst
[i
*4+3] = rgba
[i
][RCOMP
];
1735 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1739 case GL_HALF_FLOAT_ARB
:
1741 GLhalfARB
*dst
= (GLhalfARB
*) dstAddr
;
1742 switch (dstFormat
) {
1745 dst
[i
] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1749 dst
[i
] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1753 dst
[i
] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1757 dst
[i
] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
1761 dst
[i
] = _mesa_float_to_half(luminance
[i
]);
1763 case GL_LUMINANCE_ALPHA
:
1765 dst
[i
*2+0] = _mesa_float_to_half(luminance
[i
]);
1766 dst
[i
*2+1] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
1771 dst
[i
*3+0] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1772 dst
[i
*3+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1773 dst
[i
*3+2] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1778 dst
[i
*4+0] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1779 dst
[i
*4+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1780 dst
[i
*4+2] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1781 dst
[i
*4+3] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
1786 dst
[i
*3+0] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1787 dst
[i
*3+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1788 dst
[i
*3+2] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1793 dst
[i
*4+0] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1794 dst
[i
*4+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1795 dst
[i
*4+2] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1796 dst
[i
*4+3] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
1801 dst
[i
*4+0] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
1802 dst
[i
*4+1] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1803 dst
[i
*4+2] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1804 dst
[i
*4+3] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1808 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1812 case GL_UNSIGNED_BYTE_3_3_2
:
1813 if (dstFormat
== GL_RGB
) {
1814 GLubyte
*dst
= (GLubyte
*) dstAddr
;
1816 dst
[i
] = (((GLint
) (rgba
[i
][RCOMP
] * 7.0F
)) << 5)
1817 | (((GLint
) (rgba
[i
][GCOMP
] * 7.0F
)) << 2)
1818 | (((GLint
) (rgba
[i
][BCOMP
] * 3.0F
)) );
1822 case GL_UNSIGNED_BYTE_2_3_3_REV
:
1823 if (dstFormat
== GL_RGB
) {
1824 GLubyte
*dst
= (GLubyte
*) dstAddr
;
1826 dst
[i
] = (((GLint
) (rgba
[i
][RCOMP
] * 7.0F
)) )
1827 | (((GLint
) (rgba
[i
][GCOMP
] * 7.0F
)) << 3)
1828 | (((GLint
) (rgba
[i
][BCOMP
] * 3.0F
)) << 6);
1832 case GL_UNSIGNED_SHORT_5_6_5
:
1833 if (dstFormat
== GL_RGB
) {
1834 GLushort
*dst
= (GLushort
*) dstAddr
;
1836 dst
[i
] = (((GLint
) (rgba
[i
][RCOMP
] * 31.0F
)) << 11)
1837 | (((GLint
) (rgba
[i
][GCOMP
] * 63.0F
)) << 5)
1838 | (((GLint
) (rgba
[i
][BCOMP
] * 31.0F
)) );
1842 case GL_UNSIGNED_SHORT_5_6_5_REV
:
1843 if (dstFormat
== GL_RGB
) {
1844 GLushort
*dst
= (GLushort
*) dstAddr
;
1846 dst
[i
] = (((GLint
) (rgba
[i
][RCOMP
] * 31.0F
)) )
1847 | (((GLint
) (rgba
[i
][GCOMP
] * 63.0F
)) << 5)
1848 | (((GLint
) (rgba
[i
][BCOMP
] * 31.0F
)) << 11);
1852 case GL_UNSIGNED_SHORT_4_4_4_4
:
1853 if (dstFormat
== GL_RGBA
) {
1854 GLushort
*dst
= (GLushort
*) dstAddr
;
1856 dst
[i
] = (((GLint
) (rgba
[i
][RCOMP
] * 15.0F
)) << 12)
1857 | (((GLint
) (rgba
[i
][GCOMP
] * 15.0F
)) << 8)
1858 | (((GLint
) (rgba
[i
][BCOMP
] * 15.0F
)) << 4)
1859 | (((GLint
) (rgba
[i
][ACOMP
] * 15.0F
)) );
1862 else if (dstFormat
== GL_BGRA
) {
1863 GLushort
*dst
= (GLushort
*) dstAddr
;
1865 dst
[i
] = (((GLint
) (rgba
[i
][BCOMP
] * 15.0F
)) << 12)
1866 | (((GLint
) (rgba
[i
][GCOMP
] * 15.0F
)) << 8)
1867 | (((GLint
) (rgba
[i
][RCOMP
] * 15.0F
)) << 4)
1868 | (((GLint
) (rgba
[i
][ACOMP
] * 15.0F
)) );
1871 else if (dstFormat
== GL_ABGR_EXT
) {
1872 GLushort
*dst
= (GLushort
*) dstAddr
;
1874 dst
[i
] = (((GLint
) (rgba
[i
][ACOMP
] * 15.0F
)) << 12)
1875 | (((GLint
) (rgba
[i
][BCOMP
] * 15.0F
)) << 8)
1876 | (((GLint
) (rgba
[i
][GCOMP
] * 15.0F
)) << 4)
1877 | (((GLint
) (rgba
[i
][RCOMP
] * 15.0F
)) );
1881 case GL_UNSIGNED_SHORT_4_4_4_4_REV
:
1882 if (dstFormat
== GL_RGBA
) {
1883 GLushort
*dst
= (GLushort
*) dstAddr
;
1885 dst
[i
] = (((GLint
) (rgba
[i
][RCOMP
] * 15.0F
)) )
1886 | (((GLint
) (rgba
[i
][GCOMP
] * 15.0F
)) << 4)
1887 | (((GLint
) (rgba
[i
][BCOMP
] * 15.0F
)) << 8)
1888 | (((GLint
) (rgba
[i
][ACOMP
] * 15.0F
)) << 12);
1891 else if (dstFormat
== GL_BGRA
) {
1892 GLushort
*dst
= (GLushort
*) dstAddr
;
1894 dst
[i
] = (((GLint
) (rgba
[i
][BCOMP
] * 15.0F
)) )
1895 | (((GLint
) (rgba
[i
][GCOMP
] * 15.0F
)) << 4)
1896 | (((GLint
) (rgba
[i
][RCOMP
] * 15.0F
)) << 8)
1897 | (((GLint
) (rgba
[i
][ACOMP
] * 15.0F
)) << 12);
1900 else if (dstFormat
== GL_ABGR_EXT
) {
1901 GLushort
*dst
= (GLushort
*) dstAddr
;
1903 dst
[i
] = (((GLint
) (rgba
[i
][ACOMP
] * 15.0F
)) )
1904 | (((GLint
) (rgba
[i
][BCOMP
] * 15.0F
)) << 4)
1905 | (((GLint
) (rgba
[i
][GCOMP
] * 15.0F
)) << 8)
1906 | (((GLint
) (rgba
[i
][RCOMP
] * 15.0F
)) << 12);
1910 case GL_UNSIGNED_SHORT_5_5_5_1
:
1911 if (dstFormat
== GL_RGBA
) {
1912 GLushort
*dst
= (GLushort
*) dstAddr
;
1914 dst
[i
] = (((GLint
) (rgba
[i
][RCOMP
] * 31.0F
)) << 11)
1915 | (((GLint
) (rgba
[i
][GCOMP
] * 31.0F
)) << 6)
1916 | (((GLint
) (rgba
[i
][BCOMP
] * 31.0F
)) << 1)
1917 | (((GLint
) (rgba
[i
][ACOMP
] * 1.0F
)) );
1920 else if (dstFormat
== GL_BGRA
) {
1921 GLushort
*dst
= (GLushort
*) dstAddr
;
1923 dst
[i
] = (((GLint
) (rgba
[i
][BCOMP
] * 31.0F
)) << 11)
1924 | (((GLint
) (rgba
[i
][GCOMP
] * 31.0F
)) << 6)
1925 | (((GLint
) (rgba
[i
][RCOMP
] * 31.0F
)) << 1)
1926 | (((GLint
) (rgba
[i
][ACOMP
] * 1.0F
)) );
1929 else if (dstFormat
== GL_ABGR_EXT
) {
1930 GLushort
*dst
= (GLushort
*) dstAddr
;
1932 dst
[i
] = (((GLint
) (rgba
[i
][ACOMP
] * 31.0F
)) << 11)
1933 | (((GLint
) (rgba
[i
][BCOMP
] * 31.0F
)) << 6)
1934 | (((GLint
) (rgba
[i
][GCOMP
] * 31.0F
)) << 1)
1935 | (((GLint
) (rgba
[i
][RCOMP
] * 1.0F
)) );
1939 case GL_UNSIGNED_SHORT_1_5_5_5_REV
:
1940 if (dstFormat
== GL_RGBA
) {
1941 GLushort
*dst
= (GLushort
*) dstAddr
;
1943 dst
[i
] = (((GLint
) (rgba
[i
][RCOMP
] * 31.0F
)) )
1944 | (((GLint
) (rgba
[i
][GCOMP
] * 31.0F
)) << 5)
1945 | (((GLint
) (rgba
[i
][BCOMP
] * 31.0F
)) << 10)
1946 | (((GLint
) (rgba
[i
][ACOMP
] * 1.0F
)) << 15);
1949 else if (dstFormat
== GL_BGRA
) {
1950 GLushort
*dst
= (GLushort
*) dstAddr
;
1952 dst
[i
] = (((GLint
) (rgba
[i
][BCOMP
] * 31.0F
)) )
1953 | (((GLint
) (rgba
[i
][GCOMP
] * 31.0F
)) << 5)
1954 | (((GLint
) (rgba
[i
][RCOMP
] * 31.0F
)) << 10)
1955 | (((GLint
) (rgba
[i
][ACOMP
] * 1.0F
)) << 15);
1958 else if (dstFormat
== GL_ABGR_EXT
) {
1959 GLushort
*dst
= (GLushort
*) dstAddr
;
1961 dst
[i
] = (((GLint
) (rgba
[i
][ACOMP
] * 31.0F
)) )
1962 | (((GLint
) (rgba
[i
][BCOMP
] * 31.0F
)) << 5)
1963 | (((GLint
) (rgba
[i
][GCOMP
] * 31.0F
)) << 10)
1964 | (((GLint
) (rgba
[i
][RCOMP
] * 1.0F
)) << 15);
1968 case GL_UNSIGNED_INT_8_8_8_8
:
1969 if (dstFormat
== GL_RGBA
) {
1970 GLuint
*dst
= (GLuint
*) dstAddr
;
1972 dst
[i
] = (((GLuint
) (rgba
[i
][RCOMP
] * 255.0F
)) << 24)
1973 | (((GLuint
) (rgba
[i
][GCOMP
] * 255.0F
)) << 16)
1974 | (((GLuint
) (rgba
[i
][BCOMP
] * 255.0F
)) << 8)
1975 | (((GLuint
) (rgba
[i
][ACOMP
] * 255.0F
)) );
1978 else if (dstFormat
== GL_BGRA
) {
1979 GLuint
*dst
= (GLuint
*) dstAddr
;
1981 dst
[i
] = (((GLuint
) (rgba
[i
][BCOMP
] * 255.0F
)) << 24)
1982 | (((GLuint
) (rgba
[i
][GCOMP
] * 255.0F
)) << 16)
1983 | (((GLuint
) (rgba
[i
][RCOMP
] * 255.0F
)) << 8)
1984 | (((GLuint
) (rgba
[i
][ACOMP
] * 255.0F
)) );
1987 else if (dstFormat
== GL_ABGR_EXT
) {
1988 GLuint
*dst
= (GLuint
*) dstAddr
;
1990 dst
[i
] = (((GLuint
) (rgba
[i
][ACOMP
] * 255.0F
)) << 24)
1991 | (((GLuint
) (rgba
[i
][BCOMP
] * 255.0F
)) << 16)
1992 | (((GLuint
) (rgba
[i
][GCOMP
] * 255.0F
)) << 8)
1993 | (((GLuint
) (rgba
[i
][RCOMP
] * 255.0F
)) );
1997 case GL_UNSIGNED_INT_8_8_8_8_REV
:
1998 if (dstFormat
== GL_RGBA
) {
1999 GLuint
*dst
= (GLuint
*) dstAddr
;
2001 dst
[i
] = (((GLuint
) (rgba
[i
][RCOMP
] * 255.0F
)) )
2002 | (((GLuint
) (rgba
[i
][GCOMP
] * 255.0F
)) << 8)
2003 | (((GLuint
) (rgba
[i
][BCOMP
] * 255.0F
)) << 16)
2004 | (((GLuint
) (rgba
[i
][ACOMP
] * 255.0F
)) << 24);
2007 else if (dstFormat
== GL_BGRA
) {
2008 GLuint
*dst
= (GLuint
*) dstAddr
;
2010 dst
[i
] = (((GLuint
) (rgba
[i
][BCOMP
] * 255.0F
)) )
2011 | (((GLuint
) (rgba
[i
][GCOMP
] * 255.0F
)) << 8)
2012 | (((GLuint
) (rgba
[i
][RCOMP
] * 255.0F
)) << 16)
2013 | (((GLuint
) (rgba
[i
][ACOMP
] * 255.0F
)) << 24);
2016 else if (dstFormat
== GL_ABGR_EXT
) {
2017 GLuint
*dst
= (GLuint
*) dstAddr
;
2019 dst
[i
] = (((GLuint
) (rgba
[i
][ACOMP
] * 255.0F
)) )
2020 | (((GLuint
) (rgba
[i
][BCOMP
] * 255.0F
)) << 8)
2021 | (((GLuint
) (rgba
[i
][GCOMP
] * 255.0F
)) << 16)
2022 | (((GLuint
) (rgba
[i
][RCOMP
] * 255.0F
)) << 24);
2026 case GL_UNSIGNED_INT_10_10_10_2
:
2027 if (dstFormat
== GL_RGBA
) {
2028 GLuint
*dst
= (GLuint
*) dstAddr
;
2030 dst
[i
] = (((GLuint
) (rgba
[i
][RCOMP
] * 1023.0F
)) << 22)
2031 | (((GLuint
) (rgba
[i
][GCOMP
] * 1023.0F
)) << 12)
2032 | (((GLuint
) (rgba
[i
][BCOMP
] * 1023.0F
)) << 2)
2033 | (((GLuint
) (rgba
[i
][ACOMP
] * 3.0F
)) );
2036 else if (dstFormat
== GL_BGRA
) {
2037 GLuint
*dst
= (GLuint
*) dstAddr
;
2039 dst
[i
] = (((GLuint
) (rgba
[i
][BCOMP
] * 1023.0F
)) << 22)
2040 | (((GLuint
) (rgba
[i
][GCOMP
] * 1023.0F
)) << 12)
2041 | (((GLuint
) (rgba
[i
][RCOMP
] * 1023.0F
)) << 2)
2042 | (((GLuint
) (rgba
[i
][ACOMP
] * 3.0F
)) );
2045 else if (dstFormat
== GL_ABGR_EXT
) {
2046 GLuint
*dst
= (GLuint
*) dstAddr
;
2048 dst
[i
] = (((GLuint
) (rgba
[i
][ACOMP
] * 1023.0F
)) << 22)
2049 | (((GLuint
) (rgba
[i
][BCOMP
] * 1023.0F
)) << 12)
2050 | (((GLuint
) (rgba
[i
][GCOMP
] * 1023.0F
)) << 2)
2051 | (((GLuint
) (rgba
[i
][RCOMP
] * 3.0F
)) );
2055 case GL_UNSIGNED_INT_2_10_10_10_REV
:
2056 if (dstFormat
== GL_RGBA
) {
2057 GLuint
*dst
= (GLuint
*) dstAddr
;
2059 dst
[i
] = (((GLuint
) (rgba
[i
][RCOMP
] * 1023.0F
)) )
2060 | (((GLuint
) (rgba
[i
][GCOMP
] * 1023.0F
)) << 10)
2061 | (((GLuint
) (rgba
[i
][BCOMP
] * 1023.0F
)) << 20)
2062 | (((GLuint
) (rgba
[i
][ACOMP
] * 3.0F
)) << 30);
2065 else if (dstFormat
== GL_BGRA
) {
2066 GLuint
*dst
= (GLuint
*) dstAddr
;
2068 dst
[i
] = (((GLuint
) (rgba
[i
][BCOMP
] * 1023.0F
)) )
2069 | (((GLuint
) (rgba
[i
][GCOMP
] * 1023.0F
)) << 10)
2070 | (((GLuint
) (rgba
[i
][RCOMP
] * 1023.0F
)) << 20)
2071 | (((GLuint
) (rgba
[i
][ACOMP
] * 3.0F
)) << 30);
2074 else if (dstFormat
== GL_ABGR_EXT
) {
2075 GLuint
*dst
= (GLuint
*) dstAddr
;
2077 dst
[i
] = (((GLuint
) (rgba
[i
][ACOMP
] * 1023.0F
)) )
2078 | (((GLuint
) (rgba
[i
][BCOMP
] * 1023.0F
)) << 10)
2079 | (((GLuint
) (rgba
[i
][GCOMP
] * 1023.0F
)) << 20)
2080 | (((GLuint
) (rgba
[i
][RCOMP
] * 3.0F
)) << 30);
2085 _mesa_problem(ctx
, "bad type in _mesa_pack_rgba_span_float");
2089 if (dstPacking
->SwapBytes
) {
2090 GLint swapSize
= _mesa_sizeof_packed_type(dstType
);
2091 if (swapSize
== 2) {
2092 if (dstPacking
->SwapBytes
) {
2093 _mesa_swap2((GLushort
*) dstAddr
, n
* comps
);
2096 else if (swapSize
== 4) {
2097 if (dstPacking
->SwapBytes
) {
2098 _mesa_swap4((GLuint
*) dstAddr
, n
* comps
);
2105 #define SWAP2BYTE(VALUE) \
2107 GLubyte *bytes = (GLubyte *) &(VALUE); \
2108 GLubyte tmp = bytes[0]; \
2109 bytes[0] = bytes[1]; \
2113 #define SWAP4BYTE(VALUE) \
2115 GLubyte *bytes = (GLubyte *) &(VALUE); \
2116 GLubyte tmp = bytes[0]; \
2117 bytes[0] = bytes[3]; \
2120 bytes[1] = bytes[2]; \
2126 extract_uint_indexes(GLuint n
, GLuint indexes
[],
2127 GLenum srcFormat
, GLenum srcType
, const GLvoid
*src
,
2128 const struct gl_pixelstore_attrib
*unpack
)
2130 ASSERT(srcFormat
== GL_COLOR_INDEX
|| srcFormat
== GL_STENCIL_INDEX
);
2132 ASSERT(srcType
== GL_BITMAP
||
2133 srcType
== GL_UNSIGNED_BYTE
||
2134 srcType
== GL_BYTE
||
2135 srcType
== GL_UNSIGNED_SHORT
||
2136 srcType
== GL_SHORT
||
2137 srcType
== GL_UNSIGNED_INT
||
2138 srcType
== GL_INT
||
2139 srcType
== GL_UNSIGNED_INT_24_8_EXT
||
2140 srcType
== GL_HALF_FLOAT_ARB
||
2141 srcType
== GL_FLOAT
);
2146 GLubyte
*ubsrc
= (GLubyte
*) src
;
2147 if (unpack
->LsbFirst
) {
2148 GLubyte mask
= 1 << (unpack
->SkipPixels
& 0x7);
2150 for (i
= 0; i
< n
; i
++) {
2151 indexes
[i
] = (*ubsrc
& mask
) ? 1 : 0;
2162 GLubyte mask
= 128 >> (unpack
->SkipPixels
& 0x7);
2164 for (i
= 0; i
< n
; i
++) {
2165 indexes
[i
] = (*ubsrc
& mask
) ? 1 : 0;
2177 case GL_UNSIGNED_BYTE
:
2180 const GLubyte
*s
= (const GLubyte
*) src
;
2181 for (i
= 0; i
< n
; i
++)
2188 const GLbyte
*s
= (const GLbyte
*) src
;
2189 for (i
= 0; i
< n
; i
++)
2193 case GL_UNSIGNED_SHORT
:
2196 const GLushort
*s
= (const GLushort
*) src
;
2197 if (unpack
->SwapBytes
) {
2198 for (i
= 0; i
< n
; i
++) {
2199 GLushort value
= s
[i
];
2205 for (i
= 0; i
< n
; i
++)
2213 const GLshort
*s
= (const GLshort
*) src
;
2214 if (unpack
->SwapBytes
) {
2215 for (i
= 0; i
< n
; i
++) {
2216 GLshort value
= s
[i
];
2222 for (i
= 0; i
< n
; i
++)
2227 case GL_UNSIGNED_INT
:
2230 const GLuint
*s
= (const GLuint
*) src
;
2231 if (unpack
->SwapBytes
) {
2232 for (i
= 0; i
< n
; i
++) {
2233 GLuint value
= s
[i
];
2239 for (i
= 0; i
< n
; i
++)
2247 const GLint
*s
= (const GLint
*) src
;
2248 if (unpack
->SwapBytes
) {
2249 for (i
= 0; i
< n
; i
++) {
2256 for (i
= 0; i
< n
; i
++)
2264 const GLfloat
*s
= (const GLfloat
*) src
;
2265 if (unpack
->SwapBytes
) {
2266 for (i
= 0; i
< n
; i
++) {
2267 GLfloat value
= s
[i
];
2269 indexes
[i
] = (GLuint
) value
;
2273 for (i
= 0; i
< n
; i
++)
2274 indexes
[i
] = (GLuint
) s
[i
];
2278 case GL_HALF_FLOAT_ARB
:
2281 const GLhalfARB
*s
= (const GLhalfARB
*) src
;
2282 if (unpack
->SwapBytes
) {
2283 for (i
= 0; i
< n
; i
++) {
2284 GLhalfARB value
= s
[i
];
2286 indexes
[i
] = (GLuint
) _mesa_half_to_float(value
);
2290 for (i
= 0; i
< n
; i
++)
2291 indexes
[i
] = (GLuint
) _mesa_half_to_float(s
[i
]);
2295 case GL_UNSIGNED_INT_24_8_EXT
:
2298 const GLuint
*s
= (const GLuint
*) src
;
2299 if (unpack
->SwapBytes
) {
2300 for (i
= 0; i
< n
; i
++) {
2301 GLuint value
= s
[i
];
2303 indexes
[i
] = value
& 0xff; /* lower 8 bits */
2307 for (i
= 0; i
< n
; i
++)
2308 indexes
[i
] = s
[i
] & 0xfff; /* lower 8 bits */
2314 _mesa_problem(NULL
, "bad srcType in extract_uint_indexes");
2321 * This function extracts floating point RGBA values from arbitrary
2322 * image data. srcFormat and srcType are the format and type parameters
2323 * passed to glDrawPixels, glTexImage[123]D, glTexSubImage[123]D, etc.
2325 * Refering to section 3.6.4 of the OpenGL 1.2 spec, this function
2326 * implements the "Conversion to floating point", "Conversion to RGB",
2327 * and "Final Expansion to RGBA" operations.
2329 * Args: n - number of pixels
2330 * rgba - output colors
2331 * srcFormat - format of incoming data
2332 * srcType - data type of incoming data
2333 * src - source data pointer
2334 * swapBytes - perform byteswapping of incoming data?
2337 extract_float_rgba(GLuint n
, GLfloat rgba
[][4],
2338 GLenum srcFormat
, GLenum srcType
, const GLvoid
*src
,
2339 GLboolean swapBytes
)
2341 GLint redIndex
, greenIndex
, blueIndex
, alphaIndex
;
2343 GLint rComp
, bComp
, gComp
, aComp
;
2345 ASSERT(srcFormat
== GL_RED
||
2346 srcFormat
== GL_GREEN
||
2347 srcFormat
== GL_BLUE
||
2348 srcFormat
== GL_ALPHA
||
2349 srcFormat
== GL_LUMINANCE
||
2350 srcFormat
== GL_LUMINANCE_ALPHA
||
2351 srcFormat
== GL_INTENSITY
||
2352 srcFormat
== GL_RGB
||
2353 srcFormat
== GL_BGR
||
2354 srcFormat
== GL_RGBA
||
2355 srcFormat
== GL_BGRA
||
2356 srcFormat
== GL_ABGR_EXT
);
2358 ASSERT(srcType
== GL_UNSIGNED_BYTE
||
2359 srcType
== GL_BYTE
||
2360 srcType
== GL_UNSIGNED_SHORT
||
2361 srcType
== GL_SHORT
||
2362 srcType
== GL_UNSIGNED_INT
||
2363 srcType
== GL_INT
||
2364 srcType
== GL_HALF_FLOAT_ARB
||
2365 srcType
== GL_FLOAT
||
2366 srcType
== GL_UNSIGNED_BYTE_3_3_2
||
2367 srcType
== GL_UNSIGNED_BYTE_2_3_3_REV
||
2368 srcType
== GL_UNSIGNED_SHORT_5_6_5
||
2369 srcType
== GL_UNSIGNED_SHORT_5_6_5_REV
||
2370 srcType
== GL_UNSIGNED_SHORT_4_4_4_4
||
2371 srcType
== GL_UNSIGNED_SHORT_4_4_4_4_REV
||
2372 srcType
== GL_UNSIGNED_SHORT_5_5_5_1
||
2373 srcType
== GL_UNSIGNED_SHORT_1_5_5_5_REV
||
2374 srcType
== GL_UNSIGNED_INT_8_8_8_8
||
2375 srcType
== GL_UNSIGNED_INT_8_8_8_8_REV
||
2376 srcType
== GL_UNSIGNED_INT_10_10_10_2
||
2377 srcType
== GL_UNSIGNED_INT_2_10_10_10_REV
);
2379 rComp
= gComp
= bComp
= aComp
= -1;
2381 switch (srcFormat
) {
2384 greenIndex
= blueIndex
= alphaIndex
= -1;
2389 redIndex
= blueIndex
= alphaIndex
= -1;
2394 redIndex
= greenIndex
= alphaIndex
= -1;
2398 redIndex
= greenIndex
= blueIndex
= -1;
2403 redIndex
= greenIndex
= blueIndex
= 0;
2407 case GL_LUMINANCE_ALPHA
:
2408 redIndex
= greenIndex
= blueIndex
= 0;
2413 redIndex
= greenIndex
= blueIndex
= alphaIndex
= 0;
2472 _mesa_problem(NULL
, "bad srcFormat in extract float data");
2477 #define PROCESS(INDEX, CHANNEL, DEFAULT, TYPE, CONVERSION) \
2478 if ((INDEX) < 0) { \
2480 for (i = 0; i < n; i++) { \
2481 rgba[i][CHANNEL] = DEFAULT; \
2484 else if (swapBytes) { \
2485 const TYPE *s = (const TYPE *) src; \
2487 for (i = 0; i < n; i++) { \
2488 TYPE value = s[INDEX]; \
2489 if (sizeof(TYPE) == 2) { \
2492 else if (sizeof(TYPE) == 4) { \
2495 rgba[i][CHANNEL] = (GLfloat) CONVERSION(value); \
2500 const TYPE *s = (const TYPE *) src; \
2502 for (i = 0; i < n; i++) { \
2503 rgba[i][CHANNEL] = (GLfloat) CONVERSION(s[INDEX]); \
2509 case GL_UNSIGNED_BYTE
:
2510 PROCESS(redIndex
, RCOMP
, 0.0F
, GLubyte
, UBYTE_TO_FLOAT
);
2511 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLubyte
, UBYTE_TO_FLOAT
);
2512 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLubyte
, UBYTE_TO_FLOAT
);
2513 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLubyte
, UBYTE_TO_FLOAT
);
2516 PROCESS(redIndex
, RCOMP
, 0.0F
, GLbyte
, BYTE_TO_FLOAT
);
2517 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLbyte
, BYTE_TO_FLOAT
);
2518 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLbyte
, BYTE_TO_FLOAT
);
2519 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLbyte
, BYTE_TO_FLOAT
);
2521 case GL_UNSIGNED_SHORT
:
2522 PROCESS(redIndex
, RCOMP
, 0.0F
, GLushort
, USHORT_TO_FLOAT
);
2523 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLushort
, USHORT_TO_FLOAT
);
2524 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLushort
, USHORT_TO_FLOAT
);
2525 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLushort
, USHORT_TO_FLOAT
);
2528 PROCESS(redIndex
, RCOMP
, 0.0F
, GLshort
, SHORT_TO_FLOAT
);
2529 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLshort
, SHORT_TO_FLOAT
);
2530 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLshort
, SHORT_TO_FLOAT
);
2531 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLshort
, SHORT_TO_FLOAT
);
2533 case GL_UNSIGNED_INT
:
2534 PROCESS(redIndex
, RCOMP
, 0.0F
, GLuint
, UINT_TO_FLOAT
);
2535 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLuint
, UINT_TO_FLOAT
);
2536 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLuint
, UINT_TO_FLOAT
);
2537 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLuint
, UINT_TO_FLOAT
);
2540 PROCESS(redIndex
, RCOMP
, 0.0F
, GLint
, INT_TO_FLOAT
);
2541 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLint
, INT_TO_FLOAT
);
2542 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLint
, INT_TO_FLOAT
);
2543 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLint
, INT_TO_FLOAT
);
2546 PROCESS(redIndex
, RCOMP
, 0.0F
, GLfloat
, (GLfloat
));
2547 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLfloat
, (GLfloat
));
2548 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLfloat
, (GLfloat
));
2549 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLfloat
, (GLfloat
));
2551 case GL_HALF_FLOAT_ARB
:
2552 PROCESS(redIndex
, RCOMP
, 0.0F
, GLhalfARB
, _mesa_half_to_float
);
2553 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLhalfARB
, _mesa_half_to_float
);
2554 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLhalfARB
, _mesa_half_to_float
);
2555 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLhalfARB
, _mesa_half_to_float
);
2557 case GL_UNSIGNED_BYTE_3_3_2
:
2559 const GLubyte
*ubsrc
= (const GLubyte
*) src
;
2561 for (i
= 0; i
< n
; i
++) {
2562 GLubyte p
= ubsrc
[i
];
2563 rgba
[i
][rComp
] = ((p
>> 5) ) * (1.0F
/ 7.0F
);
2564 rgba
[i
][gComp
] = ((p
>> 2) & 0x7) * (1.0F
/ 7.0F
);
2565 rgba
[i
][bComp
] = ((p
) & 0x3) * (1.0F
/ 3.0F
);
2566 rgba
[i
][aComp
] = 1.0F
;
2570 case GL_UNSIGNED_BYTE_2_3_3_REV
:
2572 const GLubyte
*ubsrc
= (const GLubyte
*) src
;
2574 for (i
= 0; i
< n
; i
++) {
2575 GLubyte p
= ubsrc
[i
];
2576 rgba
[i
][rComp
] = ((p
) & 0x7) * (1.0F
/ 7.0F
);
2577 rgba
[i
][gComp
] = ((p
>> 3) & 0x7) * (1.0F
/ 7.0F
);
2578 rgba
[i
][bComp
] = ((p
>> 6) ) * (1.0F
/ 3.0F
);
2579 rgba
[i
][aComp
] = 1.0F
;
2583 case GL_UNSIGNED_SHORT_5_6_5
:
2585 const GLushort
*ussrc
= (const GLushort
*) src
;
2587 for (i
= 0; i
< n
; i
++) {
2588 GLushort p
= ussrc
[i
];
2590 rgba
[i
][rComp
] = ((p
>> 11) ) * (1.0F
/ 31.0F
);
2591 rgba
[i
][gComp
] = ((p
>> 5) & 0x3f) * (1.0F
/ 63.0F
);
2592 rgba
[i
][bComp
] = ((p
) & 0x1f) * (1.0F
/ 31.0F
);
2593 rgba
[i
][aComp
] = 1.0F
;
2597 const GLushort
*ussrc
= (const GLushort
*) src
;
2599 for (i
= 0; i
< n
; i
++) {
2600 GLushort p
= ussrc
[i
];
2601 rgba
[i
][rComp
] = ((p
>> 11) ) * (1.0F
/ 31.0F
);
2602 rgba
[i
][gComp
] = ((p
>> 5) & 0x3f) * (1.0F
/ 63.0F
);
2603 rgba
[i
][bComp
] = ((p
) & 0x1f) * (1.0F
/ 31.0F
);
2604 rgba
[i
][aComp
] = 1.0F
;
2608 case GL_UNSIGNED_SHORT_5_6_5_REV
:
2610 const GLushort
*ussrc
= (const GLushort
*) src
;
2612 for (i
= 0; i
< n
; i
++) {
2613 GLushort p
= ussrc
[i
];
2615 rgba
[i
][rComp
] = ((p
) & 0x1f) * (1.0F
/ 31.0F
);
2616 rgba
[i
][gComp
] = ((p
>> 5) & 0x3f) * (1.0F
/ 63.0F
);
2617 rgba
[i
][bComp
] = ((p
>> 11) ) * (1.0F
/ 31.0F
);
2618 rgba
[i
][aComp
] = 1.0F
;
2622 const GLushort
*ussrc
= (const GLushort
*) src
;
2624 for (i
= 0; i
< n
; i
++) {
2625 GLushort p
= ussrc
[i
];
2626 rgba
[i
][rComp
] = ((p
) & 0x1f) * (1.0F
/ 31.0F
);
2627 rgba
[i
][gComp
] = ((p
>> 5) & 0x3f) * (1.0F
/ 63.0F
);
2628 rgba
[i
][bComp
] = ((p
>> 11) ) * (1.0F
/ 31.0F
);
2629 rgba
[i
][aComp
] = 1.0F
;
2633 case GL_UNSIGNED_SHORT_4_4_4_4
:
2635 const GLushort
*ussrc
= (const GLushort
*) src
;
2637 for (i
= 0; i
< n
; i
++) {
2638 GLushort p
= ussrc
[i
];
2640 rgba
[i
][rComp
] = ((p
>> 12) ) * (1.0F
/ 15.0F
);
2641 rgba
[i
][gComp
] = ((p
>> 8) & 0xf) * (1.0F
/ 15.0F
);
2642 rgba
[i
][bComp
] = ((p
>> 4) & 0xf) * (1.0F
/ 15.0F
);
2643 rgba
[i
][aComp
] = ((p
) & 0xf) * (1.0F
/ 15.0F
);
2647 const GLushort
*ussrc
= (const GLushort
*) src
;
2649 for (i
= 0; i
< n
; i
++) {
2650 GLushort p
= ussrc
[i
];
2651 rgba
[i
][rComp
] = ((p
>> 12) ) * (1.0F
/ 15.0F
);
2652 rgba
[i
][gComp
] = ((p
>> 8) & 0xf) * (1.0F
/ 15.0F
);
2653 rgba
[i
][bComp
] = ((p
>> 4) & 0xf) * (1.0F
/ 15.0F
);
2654 rgba
[i
][aComp
] = ((p
) & 0xf) * (1.0F
/ 15.0F
);
2658 case GL_UNSIGNED_SHORT_4_4_4_4_REV
:
2660 const GLushort
*ussrc
= (const GLushort
*) src
;
2662 for (i
= 0; i
< n
; i
++) {
2663 GLushort p
= ussrc
[i
];
2665 rgba
[i
][rComp
] = ((p
) & 0xf) * (1.0F
/ 15.0F
);
2666 rgba
[i
][gComp
] = ((p
>> 4) & 0xf) * (1.0F
/ 15.0F
);
2667 rgba
[i
][bComp
] = ((p
>> 8) & 0xf) * (1.0F
/ 15.0F
);
2668 rgba
[i
][aComp
] = ((p
>> 12) ) * (1.0F
/ 15.0F
);
2672 const GLushort
*ussrc
= (const GLushort
*) src
;
2674 for (i
= 0; i
< n
; i
++) {
2675 GLushort p
= ussrc
[i
];
2676 rgba
[i
][rComp
] = ((p
) & 0xf) * (1.0F
/ 15.0F
);
2677 rgba
[i
][gComp
] = ((p
>> 4) & 0xf) * (1.0F
/ 15.0F
);
2678 rgba
[i
][bComp
] = ((p
>> 8) & 0xf) * (1.0F
/ 15.0F
);
2679 rgba
[i
][aComp
] = ((p
>> 12) ) * (1.0F
/ 15.0F
);
2683 case GL_UNSIGNED_SHORT_5_5_5_1
:
2685 const GLushort
*ussrc
= (const GLushort
*) src
;
2687 for (i
= 0; i
< n
; i
++) {
2688 GLushort p
= ussrc
[i
];
2690 rgba
[i
][rComp
] = ((p
>> 11) ) * (1.0F
/ 31.0F
);
2691 rgba
[i
][gComp
] = ((p
>> 6) & 0x1f) * (1.0F
/ 31.0F
);
2692 rgba
[i
][bComp
] = ((p
>> 1) & 0x1f) * (1.0F
/ 31.0F
);
2693 rgba
[i
][aComp
] = ((p
) & 0x1) * (1.0F
/ 1.0F
);
2697 const GLushort
*ussrc
= (const GLushort
*) src
;
2699 for (i
= 0; i
< n
; i
++) {
2700 GLushort p
= ussrc
[i
];
2701 rgba
[i
][rComp
] = ((p
>> 11) ) * (1.0F
/ 31.0F
);
2702 rgba
[i
][gComp
] = ((p
>> 6) & 0x1f) * (1.0F
/ 31.0F
);
2703 rgba
[i
][bComp
] = ((p
>> 1) & 0x1f) * (1.0F
/ 31.0F
);
2704 rgba
[i
][aComp
] = ((p
) & 0x1) * (1.0F
/ 1.0F
);
2708 case GL_UNSIGNED_SHORT_1_5_5_5_REV
:
2710 const GLushort
*ussrc
= (const GLushort
*) src
;
2712 for (i
= 0; i
< n
; i
++) {
2713 GLushort p
= ussrc
[i
];
2715 rgba
[i
][rComp
] = ((p
) & 0x1f) * (1.0F
/ 31.0F
);
2716 rgba
[i
][gComp
] = ((p
>> 5) & 0x1f) * (1.0F
/ 31.0F
);
2717 rgba
[i
][bComp
] = ((p
>> 10) & 0x1f) * (1.0F
/ 31.0F
);
2718 rgba
[i
][aComp
] = ((p
>> 15) ) * (1.0F
/ 1.0F
);
2722 const GLushort
*ussrc
= (const GLushort
*) src
;
2724 for (i
= 0; i
< n
; i
++) {
2725 GLushort p
= ussrc
[i
];
2726 rgba
[i
][rComp
] = ((p
) & 0x1f) * (1.0F
/ 31.0F
);
2727 rgba
[i
][gComp
] = ((p
>> 5) & 0x1f) * (1.0F
/ 31.0F
);
2728 rgba
[i
][bComp
] = ((p
>> 10) & 0x1f) * (1.0F
/ 31.0F
);
2729 rgba
[i
][aComp
] = ((p
>> 15) ) * (1.0F
/ 1.0F
);
2733 case GL_UNSIGNED_INT_8_8_8_8
:
2735 const GLuint
*uisrc
= (const GLuint
*) src
;
2737 for (i
= 0; i
< n
; i
++) {
2738 GLuint p
= uisrc
[i
];
2739 rgba
[i
][rComp
] = UBYTE_TO_FLOAT((p
) & 0xff);
2740 rgba
[i
][gComp
] = UBYTE_TO_FLOAT((p
>> 8) & 0xff);
2741 rgba
[i
][bComp
] = UBYTE_TO_FLOAT((p
>> 16) & 0xff);
2742 rgba
[i
][aComp
] = UBYTE_TO_FLOAT((p
>> 24) );
2746 const GLuint
*uisrc
= (const GLuint
*) src
;
2748 for (i
= 0; i
< n
; i
++) {
2749 GLuint p
= uisrc
[i
];
2750 rgba
[i
][rComp
] = UBYTE_TO_FLOAT((p
>> 24) );
2751 rgba
[i
][gComp
] = UBYTE_TO_FLOAT((p
>> 16) & 0xff);
2752 rgba
[i
][bComp
] = UBYTE_TO_FLOAT((p
>> 8) & 0xff);
2753 rgba
[i
][aComp
] = UBYTE_TO_FLOAT((p
) & 0xff);
2757 case GL_UNSIGNED_INT_8_8_8_8_REV
:
2759 const GLuint
*uisrc
= (const GLuint
*) src
;
2761 for (i
= 0; i
< n
; i
++) {
2762 GLuint p
= uisrc
[i
];
2763 rgba
[i
][rComp
] = UBYTE_TO_FLOAT((p
>> 24) );
2764 rgba
[i
][gComp
] = UBYTE_TO_FLOAT((p
>> 16) & 0xff);
2765 rgba
[i
][bComp
] = UBYTE_TO_FLOAT((p
>> 8) & 0xff);
2766 rgba
[i
][aComp
] = UBYTE_TO_FLOAT((p
) & 0xff);
2770 const GLuint
*uisrc
= (const GLuint
*) src
;
2772 for (i
= 0; i
< n
; i
++) {
2773 GLuint p
= uisrc
[i
];
2774 rgba
[i
][rComp
] = UBYTE_TO_FLOAT((p
) & 0xff);
2775 rgba
[i
][gComp
] = UBYTE_TO_FLOAT((p
>> 8) & 0xff);
2776 rgba
[i
][bComp
] = UBYTE_TO_FLOAT((p
>> 16) & 0xff);
2777 rgba
[i
][aComp
] = UBYTE_TO_FLOAT((p
>> 24) );
2781 case GL_UNSIGNED_INT_10_10_10_2
:
2783 const GLuint
*uisrc
= (const GLuint
*) src
;
2785 for (i
= 0; i
< n
; i
++) {
2786 GLuint p
= uisrc
[i
];
2788 rgba
[i
][rComp
] = ((p
>> 22) ) * (1.0F
/ 1023.0F
);
2789 rgba
[i
][gComp
] = ((p
>> 12) & 0x3ff) * (1.0F
/ 1023.0F
);
2790 rgba
[i
][bComp
] = ((p
>> 2) & 0x3ff) * (1.0F
/ 1023.0F
);
2791 rgba
[i
][aComp
] = ((p
) & 0x3 ) * (1.0F
/ 3.0F
);
2795 const GLuint
*uisrc
= (const GLuint
*) src
;
2797 for (i
= 0; i
< n
; i
++) {
2798 GLuint p
= uisrc
[i
];
2799 rgba
[i
][rComp
] = ((p
>> 22) ) * (1.0F
/ 1023.0F
);
2800 rgba
[i
][gComp
] = ((p
>> 12) & 0x3ff) * (1.0F
/ 1023.0F
);
2801 rgba
[i
][bComp
] = ((p
>> 2) & 0x3ff) * (1.0F
/ 1023.0F
);
2802 rgba
[i
][aComp
] = ((p
) & 0x3 ) * (1.0F
/ 3.0F
);
2806 case GL_UNSIGNED_INT_2_10_10_10_REV
:
2808 const GLuint
*uisrc
= (const GLuint
*) src
;
2810 for (i
= 0; i
< n
; i
++) {
2811 GLuint p
= uisrc
[i
];
2813 rgba
[i
][rComp
] = ((p
) & 0x3ff) * (1.0F
/ 1023.0F
);
2814 rgba
[i
][gComp
] = ((p
>> 10) & 0x3ff) * (1.0F
/ 1023.0F
);
2815 rgba
[i
][bComp
] = ((p
>> 20) & 0x3ff) * (1.0F
/ 1023.0F
);
2816 rgba
[i
][aComp
] = ((p
>> 30) ) * (1.0F
/ 3.0F
);
2820 const GLuint
*uisrc
= (const GLuint
*) src
;
2822 for (i
= 0; i
< n
; i
++) {
2823 GLuint p
= uisrc
[i
];
2824 rgba
[i
][rComp
] = ((p
) & 0x3ff) * (1.0F
/ 1023.0F
);
2825 rgba
[i
][gComp
] = ((p
>> 10) & 0x3ff) * (1.0F
/ 1023.0F
);
2826 rgba
[i
][bComp
] = ((p
>> 20) & 0x3ff) * (1.0F
/ 1023.0F
);
2827 rgba
[i
][aComp
] = ((p
>> 30) ) * (1.0F
/ 3.0F
);
2832 _mesa_problem(NULL
, "bad srcType in extract float data");
2839 * Unpack a row of color image data from a client buffer according to
2840 * the pixel unpacking parameters.
2841 * Return GLchan values in the specified dest image format.
2842 * This is used by glDrawPixels and glTexImage?D().
2843 * \param ctx - the context
2844 * n - number of pixels in the span
2845 * dstFormat - format of destination color array
2846 * dest - the destination color array
2847 * srcFormat - source image format
2848 * srcType - source image data type
2849 * source - source image pointer
2850 * srcPacking - pixel unpacking parameters
2851 * transferOps - bitmask of IMAGE_*_BIT values of operations to apply
2853 * XXX perhaps expand this to process whole images someday.
2856 _mesa_unpack_color_span_chan( GLcontext
*ctx
,
2857 GLuint n
, GLenum dstFormat
, GLchan dest
[],
2858 GLenum srcFormat
, GLenum srcType
,
2859 const GLvoid
*source
,
2860 const struct gl_pixelstore_attrib
*srcPacking
,
2861 GLbitfield transferOps
)
2863 ASSERT(dstFormat
== GL_ALPHA
||
2864 dstFormat
== GL_LUMINANCE
||
2865 dstFormat
== GL_LUMINANCE_ALPHA
||
2866 dstFormat
== GL_INTENSITY
||
2867 dstFormat
== GL_RGB
||
2868 dstFormat
== GL_RGBA
||
2869 dstFormat
== GL_COLOR_INDEX
);
2871 ASSERT(srcFormat
== GL_RED
||
2872 srcFormat
== GL_GREEN
||
2873 srcFormat
== GL_BLUE
||
2874 srcFormat
== GL_ALPHA
||
2875 srcFormat
== GL_LUMINANCE
||
2876 srcFormat
== GL_LUMINANCE_ALPHA
||
2877 srcFormat
== GL_INTENSITY
||
2878 srcFormat
== GL_RGB
||
2879 srcFormat
== GL_BGR
||
2880 srcFormat
== GL_RGBA
||
2881 srcFormat
== GL_BGRA
||
2882 srcFormat
== GL_ABGR_EXT
||
2883 srcFormat
== GL_COLOR_INDEX
);
2885 ASSERT(srcType
== GL_BITMAP
||
2886 srcType
== GL_UNSIGNED_BYTE
||
2887 srcType
== GL_BYTE
||
2888 srcType
== GL_UNSIGNED_SHORT
||
2889 srcType
== GL_SHORT
||
2890 srcType
== GL_UNSIGNED_INT
||
2891 srcType
== GL_INT
||
2892 srcType
== GL_HALF_FLOAT_ARB
||
2893 srcType
== GL_FLOAT
||
2894 srcType
== GL_UNSIGNED_BYTE_3_3_2
||
2895 srcType
== GL_UNSIGNED_BYTE_2_3_3_REV
||
2896 srcType
== GL_UNSIGNED_SHORT_5_6_5
||
2897 srcType
== GL_UNSIGNED_SHORT_5_6_5_REV
||
2898 srcType
== GL_UNSIGNED_SHORT_4_4_4_4
||
2899 srcType
== GL_UNSIGNED_SHORT_4_4_4_4_REV
||
2900 srcType
== GL_UNSIGNED_SHORT_5_5_5_1
||
2901 srcType
== GL_UNSIGNED_SHORT_1_5_5_5_REV
||
2902 srcType
== GL_UNSIGNED_INT_8_8_8_8
||
2903 srcType
== GL_UNSIGNED_INT_8_8_8_8_REV
||
2904 srcType
== GL_UNSIGNED_INT_10_10_10_2
||
2905 srcType
== GL_UNSIGNED_INT_2_10_10_10_REV
);
2907 /* Try simple cases first */
2908 if (transferOps
== 0) {
2909 if (srcType
== CHAN_TYPE
) {
2910 if (dstFormat
== GL_RGBA
) {
2911 if (srcFormat
== GL_RGBA
) {
2912 _mesa_memcpy( dest
, source
, n
* 4 * sizeof(GLchan
) );
2915 else if (srcFormat
== GL_RGB
) {
2917 const GLchan
*src
= (const GLchan
*) source
;
2919 for (i
= 0; i
< n
; i
++) {
2930 else if (dstFormat
== GL_RGB
) {
2931 if (srcFormat
== GL_RGB
) {
2932 _mesa_memcpy( dest
, source
, n
* 3 * sizeof(GLchan
) );
2935 else if (srcFormat
== GL_RGBA
) {
2937 const GLchan
*src
= (const GLchan
*) source
;
2939 for (i
= 0; i
< n
; i
++) {
2949 else if (dstFormat
== srcFormat
) {
2950 GLint comps
= _mesa_components_in_format(srcFormat
);
2952 _mesa_memcpy( dest
, source
, n
* comps
* sizeof(GLchan
) );
2957 * Common situation, loading 8bit RGBA/RGB source images
2958 * into 16/32 bit destination. (OSMesa16/32)
2960 else if (srcType
== GL_UNSIGNED_BYTE
) {
2961 if (dstFormat
== GL_RGBA
) {
2962 if (srcFormat
== GL_RGB
) {
2964 const GLubyte
*src
= (const GLubyte
*) source
;
2966 for (i
= 0; i
< n
; i
++) {
2967 dst
[0] = UBYTE_TO_CHAN(src
[0]);
2968 dst
[1] = UBYTE_TO_CHAN(src
[1]);
2969 dst
[2] = UBYTE_TO_CHAN(src
[2]);
2976 else if (srcFormat
== GL_RGBA
) {
2978 const GLubyte
*src
= (const GLubyte
*) source
;
2980 for (i
= 0; i
< n
; i
++) {
2981 dst
[0] = UBYTE_TO_CHAN(src
[0]);
2982 dst
[1] = UBYTE_TO_CHAN(src
[1]);
2983 dst
[2] = UBYTE_TO_CHAN(src
[2]);
2984 dst
[3] = UBYTE_TO_CHAN(src
[3]);
2991 else if (dstFormat
== GL_RGB
) {
2992 if (srcFormat
== GL_RGB
) {
2994 const GLubyte
*src
= (const GLubyte
*) source
;
2996 for (i
= 0; i
< n
; i
++) {
2997 dst
[0] = UBYTE_TO_CHAN(src
[0]);
2998 dst
[1] = UBYTE_TO_CHAN(src
[1]);
2999 dst
[2] = UBYTE_TO_CHAN(src
[2]);
3005 else if (srcFormat
== GL_RGBA
) {
3007 const GLubyte
*src
= (const GLubyte
*) source
;
3009 for (i
= 0; i
< n
; i
++) {
3010 dst
[0] = UBYTE_TO_CHAN(src
[0]);
3011 dst
[1] = UBYTE_TO_CHAN(src
[1]);
3012 dst
[2] = UBYTE_TO_CHAN(src
[2]);
3023 /* general solution begins here */
3025 GLint dstComponents
;
3026 GLint dstRedIndex
, dstGreenIndex
, dstBlueIndex
, dstAlphaIndex
;
3027 GLint dstLuminanceIndex
, dstIntensityIndex
;
3028 GLfloat rgba
[MAX_WIDTH
][4];
3030 dstComponents
= _mesa_components_in_format( dstFormat
);
3031 /* source & dest image formats should have been error checked by now */
3032 assert(dstComponents
> 0);
3035 * Extract image data and convert to RGBA floats
3037 assert(n
<= MAX_WIDTH
);
3038 if (srcFormat
== GL_COLOR_INDEX
) {
3039 GLuint indexes
[MAX_WIDTH
];
3040 extract_uint_indexes(n
, indexes
, srcFormat
, srcType
, source
,
3043 if (dstFormat
== GL_COLOR_INDEX
) {
3045 _mesa_apply_ci_transfer_ops(ctx
, transferOps
, n
, indexes
);
3046 /* convert to GLchan and return */
3047 for (i
= 0; i
< n
; i
++) {
3048 dest
[i
] = (GLchan
) (indexes
[i
] & 0xff);
3053 /* Convert indexes to RGBA */
3054 if (transferOps
& IMAGE_SHIFT_OFFSET_BIT
) {
3055 shift_and_offset_ci(ctx
, n
, indexes
);
3057 _mesa_map_ci_to_rgba(ctx
, n
, indexes
, rgba
);
3060 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
3061 * with color indexes.
3063 transferOps
&= ~(IMAGE_SCALE_BIAS_BIT
| IMAGE_MAP_COLOR_BIT
);
3066 /* non-color index data */
3067 extract_float_rgba(n
, rgba
, srcFormat
, srcType
, source
,
3068 srcPacking
->SwapBytes
);
3071 /* Need to clamp if returning GLubytes or GLushorts */
3072 #if CHAN_TYPE != GL_FLOAT
3073 transferOps
|= IMAGE_CLAMP_BIT
;
3077 _mesa_apply_rgba_transfer_ops(ctx
, transferOps
, n
, rgba
);
3080 /* Now determine which color channels we need to produce.
3081 * And determine the dest index (offset) within each color tuple.
3083 switch (dstFormat
) {
3086 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= -1;
3087 dstLuminanceIndex
= dstIntensityIndex
= -1;
3090 dstLuminanceIndex
= 0;
3091 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= dstAlphaIndex
= -1;
3092 dstIntensityIndex
= -1;
3094 case GL_LUMINANCE_ALPHA
:
3095 dstLuminanceIndex
= 0;
3097 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= -1;
3098 dstIntensityIndex
= -1;
3101 dstIntensityIndex
= 0;
3102 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= dstAlphaIndex
= -1;
3103 dstLuminanceIndex
= -1;
3109 dstAlphaIndex
= dstLuminanceIndex
= dstIntensityIndex
= -1;
3116 dstLuminanceIndex
= dstIntensityIndex
= -1;
3119 _mesa_problem(ctx
, "bad dstFormat in _mesa_unpack_chan_span()");
3124 /* Now return the GLchan data in the requested dstFormat */
3126 if (dstRedIndex
>= 0) {
3129 for (i
= 0; i
< n
; i
++) {
3130 CLAMPED_FLOAT_TO_CHAN(dst
[dstRedIndex
], rgba
[i
][RCOMP
]);
3131 dst
+= dstComponents
;
3135 if (dstGreenIndex
>= 0) {
3138 for (i
= 0; i
< n
; i
++) {
3139 CLAMPED_FLOAT_TO_CHAN(dst
[dstGreenIndex
], rgba
[i
][GCOMP
]);
3140 dst
+= dstComponents
;
3144 if (dstBlueIndex
>= 0) {
3147 for (i
= 0; i
< n
; i
++) {
3148 CLAMPED_FLOAT_TO_CHAN(dst
[dstBlueIndex
], rgba
[i
][BCOMP
]);
3149 dst
+= dstComponents
;
3153 if (dstAlphaIndex
>= 0) {
3156 for (i
= 0; i
< n
; i
++) {
3157 CLAMPED_FLOAT_TO_CHAN(dst
[dstAlphaIndex
], rgba
[i
][ACOMP
]);
3158 dst
+= dstComponents
;
3162 if (dstIntensityIndex
>= 0) {
3165 assert(dstIntensityIndex
== 0);
3166 assert(dstComponents
== 1);
3167 for (i
= 0; i
< n
; i
++) {
3168 /* Intensity comes from red channel */
3169 CLAMPED_FLOAT_TO_CHAN(dst
[i
], rgba
[i
][RCOMP
]);
3173 if (dstLuminanceIndex
>= 0) {
3176 assert(dstLuminanceIndex
== 0);
3177 for (i
= 0; i
< n
; i
++) {
3178 /* Luminance comes from red channel */
3179 CLAMPED_FLOAT_TO_CHAN(dst
[0], rgba
[i
][RCOMP
]);
3180 dst
+= dstComponents
;
3188 * Same as _mesa_unpack_color_span_chan(), but return GLfloat data
3189 * instead of GLchan.
3192 _mesa_unpack_color_span_float( GLcontext
*ctx
,
3193 GLuint n
, GLenum dstFormat
, GLfloat dest
[],
3194 GLenum srcFormat
, GLenum srcType
,
3195 const GLvoid
*source
,
3196 const struct gl_pixelstore_attrib
*srcPacking
,
3197 GLbitfield transferOps
)
3199 ASSERT(dstFormat
== GL_ALPHA
||
3200 dstFormat
== GL_LUMINANCE
||
3201 dstFormat
== GL_LUMINANCE_ALPHA
||
3202 dstFormat
== GL_INTENSITY
||
3203 dstFormat
== GL_RGB
||
3204 dstFormat
== GL_RGBA
||
3205 dstFormat
== GL_COLOR_INDEX
);
3207 ASSERT(srcFormat
== GL_RED
||
3208 srcFormat
== GL_GREEN
||
3209 srcFormat
== GL_BLUE
||
3210 srcFormat
== GL_ALPHA
||
3211 srcFormat
== GL_LUMINANCE
||
3212 srcFormat
== GL_LUMINANCE_ALPHA
||
3213 srcFormat
== GL_INTENSITY
||
3214 srcFormat
== GL_RGB
||
3215 srcFormat
== GL_BGR
||
3216 srcFormat
== GL_RGBA
||
3217 srcFormat
== GL_BGRA
||
3218 srcFormat
== GL_ABGR_EXT
||
3219 srcFormat
== GL_COLOR_INDEX
);
3221 ASSERT(srcType
== GL_BITMAP
||
3222 srcType
== GL_UNSIGNED_BYTE
||
3223 srcType
== GL_BYTE
||
3224 srcType
== GL_UNSIGNED_SHORT
||
3225 srcType
== GL_SHORT
||
3226 srcType
== GL_UNSIGNED_INT
||
3227 srcType
== GL_INT
||
3228 srcType
== GL_HALF_FLOAT_ARB
||
3229 srcType
== GL_FLOAT
||
3230 srcType
== GL_UNSIGNED_BYTE_3_3_2
||
3231 srcType
== GL_UNSIGNED_BYTE_2_3_3_REV
||
3232 srcType
== GL_UNSIGNED_SHORT_5_6_5
||
3233 srcType
== GL_UNSIGNED_SHORT_5_6_5_REV
||
3234 srcType
== GL_UNSIGNED_SHORT_4_4_4_4
||
3235 srcType
== GL_UNSIGNED_SHORT_4_4_4_4_REV
||
3236 srcType
== GL_UNSIGNED_SHORT_5_5_5_1
||
3237 srcType
== GL_UNSIGNED_SHORT_1_5_5_5_REV
||
3238 srcType
== GL_UNSIGNED_INT_8_8_8_8
||
3239 srcType
== GL_UNSIGNED_INT_8_8_8_8_REV
||
3240 srcType
== GL_UNSIGNED_INT_10_10_10_2
||
3241 srcType
== GL_UNSIGNED_INT_2_10_10_10_REV
);
3243 /* general solution, no special cases, yet */
3245 GLint dstComponents
;
3246 GLint dstRedIndex
, dstGreenIndex
, dstBlueIndex
, dstAlphaIndex
;
3247 GLint dstLuminanceIndex
, dstIntensityIndex
;
3248 GLfloat rgba
[MAX_WIDTH
][4];
3250 dstComponents
= _mesa_components_in_format( dstFormat
);
3251 /* source & dest image formats should have been error checked by now */
3252 assert(dstComponents
> 0);
3255 * Extract image data and convert to RGBA floats
3257 assert(n
<= MAX_WIDTH
);
3258 if (srcFormat
== GL_COLOR_INDEX
) {
3259 GLuint indexes
[MAX_WIDTH
];
3260 extract_uint_indexes(n
, indexes
, srcFormat
, srcType
, source
,
3263 if (dstFormat
== GL_COLOR_INDEX
) {
3265 _mesa_apply_ci_transfer_ops(ctx
, transferOps
, n
, indexes
);
3266 /* convert to GLchan and return */
3267 for (i
= 0; i
< n
; i
++) {
3268 dest
[i
] = (GLchan
) (indexes
[i
] & 0xff);
3273 /* Convert indexes to RGBA */
3274 if (transferOps
& IMAGE_SHIFT_OFFSET_BIT
) {
3275 shift_and_offset_ci(ctx
, n
, indexes
);
3277 _mesa_map_ci_to_rgba(ctx
, n
, indexes
, rgba
);
3280 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
3281 * with color indexes.
3283 transferOps
&= ~(IMAGE_SCALE_BIAS_BIT
| IMAGE_MAP_COLOR_BIT
);
3286 /* non-color index data */
3287 extract_float_rgba(n
, rgba
, srcFormat
, srcType
, source
,
3288 srcPacking
->SwapBytes
);
3292 _mesa_apply_rgba_transfer_ops(ctx
, transferOps
, n
, rgba
);
3295 /* Now determine which color channels we need to produce.
3296 * And determine the dest index (offset) within each color tuple.
3298 switch (dstFormat
) {
3301 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= -1;
3302 dstLuminanceIndex
= dstIntensityIndex
= -1;
3305 dstLuminanceIndex
= 0;
3306 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= dstAlphaIndex
= -1;
3307 dstIntensityIndex
= -1;
3309 case GL_LUMINANCE_ALPHA
:
3310 dstLuminanceIndex
= 0;
3312 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= -1;
3313 dstIntensityIndex
= -1;
3316 dstIntensityIndex
= 0;
3317 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= dstAlphaIndex
= -1;
3318 dstLuminanceIndex
= -1;
3324 dstAlphaIndex
= dstLuminanceIndex
= dstIntensityIndex
= -1;
3331 dstLuminanceIndex
= dstIntensityIndex
= -1;
3334 _mesa_problem(ctx
, "bad dstFormat in _mesa_unpack_color_span_float()");
3338 /* Now pack results in the requested dstFormat */
3339 if (dstRedIndex
>= 0) {
3340 GLfloat
*dst
= dest
;
3342 for (i
= 0; i
< n
; i
++) {
3343 dst
[dstRedIndex
] = rgba
[i
][RCOMP
];
3344 dst
+= dstComponents
;
3348 if (dstGreenIndex
>= 0) {
3349 GLfloat
*dst
= dest
;
3351 for (i
= 0; i
< n
; i
++) {
3352 dst
[dstGreenIndex
] = rgba
[i
][GCOMP
];
3353 dst
+= dstComponents
;
3357 if (dstBlueIndex
>= 0) {
3358 GLfloat
*dst
= dest
;
3360 for (i
= 0; i
< n
; i
++) {
3361 dst
[dstBlueIndex
] = rgba
[i
][BCOMP
];
3362 dst
+= dstComponents
;
3366 if (dstAlphaIndex
>= 0) {
3367 GLfloat
*dst
= dest
;
3369 for (i
= 0; i
< n
; i
++) {
3370 dst
[dstAlphaIndex
] = rgba
[i
][ACOMP
];
3371 dst
+= dstComponents
;
3375 if (dstIntensityIndex
>= 0) {
3376 GLfloat
*dst
= dest
;
3378 assert(dstIntensityIndex
== 0);
3379 assert(dstComponents
== 1);
3380 for (i
= 0; i
< n
; i
++) {
3381 /* Intensity comes from red channel */
3382 dst
[i
] = rgba
[i
][RCOMP
];
3386 if (dstLuminanceIndex
>= 0) {
3387 GLfloat
*dst
= dest
;
3389 assert(dstLuminanceIndex
== 0);
3390 for (i
= 0; i
< n
; i
++) {
3391 /* Luminance comes from red channel */
3392 dst
[0] = rgba
[i
][RCOMP
];
3393 dst
+= dstComponents
;
3401 * Unpack a row of color index data from a client buffer according to
3402 * the pixel unpacking parameters.
3403 * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.
3405 * Args: ctx - the context
3406 * n - number of pixels
3407 * dstType - destination data type
3408 * dest - destination array
3409 * srcType - source pixel type
3410 * source - source data pointer
3411 * srcPacking - pixel unpacking parameters
3412 * transferOps - the pixel transfer operations to apply
3415 _mesa_unpack_index_span( const GLcontext
*ctx
, GLuint n
,
3416 GLenum dstType
, GLvoid
*dest
,
3417 GLenum srcType
, const GLvoid
*source
,
3418 const struct gl_pixelstore_attrib
*srcPacking
,
3419 GLbitfield transferOps
)
3421 ASSERT(srcType
== GL_BITMAP
||
3422 srcType
== GL_UNSIGNED_BYTE
||
3423 srcType
== GL_BYTE
||
3424 srcType
== GL_UNSIGNED_SHORT
||
3425 srcType
== GL_SHORT
||
3426 srcType
== GL_UNSIGNED_INT
||
3427 srcType
== GL_INT
||
3428 srcType
== GL_HALF_FLOAT_ARB
||
3429 srcType
== GL_FLOAT
);
3431 ASSERT(dstType
== GL_UNSIGNED_BYTE
||
3432 dstType
== GL_UNSIGNED_SHORT
||
3433 dstType
== GL_UNSIGNED_INT
);
3436 transferOps
&= (IMAGE_MAP_COLOR_BIT
| IMAGE_SHIFT_OFFSET_BIT
);
3439 * Try simple cases first
3441 if (transferOps
== 0 && srcType
== GL_UNSIGNED_BYTE
3442 && dstType
== GL_UNSIGNED_BYTE
) {
3443 _mesa_memcpy(dest
, source
, n
* sizeof(GLubyte
));
3445 else if (transferOps
== 0 && srcType
== GL_UNSIGNED_INT
3446 && dstType
== GL_UNSIGNED_INT
&& !srcPacking
->SwapBytes
) {
3447 _mesa_memcpy(dest
, source
, n
* sizeof(GLuint
));
3453 GLuint indexes
[MAX_WIDTH
];
3454 assert(n
<= MAX_WIDTH
);
3456 extract_uint_indexes(n
, indexes
, GL_COLOR_INDEX
, srcType
, source
,
3460 _mesa_apply_ci_transfer_ops(ctx
, transferOps
, n
, indexes
);
3462 /* convert to dest type */
3464 case GL_UNSIGNED_BYTE
:
3466 GLubyte
*dst
= (GLubyte
*) dest
;
3468 for (i
= 0; i
< n
; i
++) {
3469 dst
[i
] = (GLubyte
) (indexes
[i
] & 0xff);
3473 case GL_UNSIGNED_SHORT
:
3475 GLuint
*dst
= (GLuint
*) dest
;
3477 for (i
= 0; i
< n
; i
++) {
3478 dst
[i
] = (GLushort
) (indexes
[i
] & 0xffff);
3482 case GL_UNSIGNED_INT
:
3483 _mesa_memcpy(dest
, indexes
, n
* sizeof(GLuint
));
3486 _mesa_problem(ctx
, "bad dstType in _mesa_unpack_index_span");
3493 _mesa_pack_index_span( const GLcontext
*ctx
, GLuint n
,
3494 GLenum dstType
, GLvoid
*dest
, const GLuint
*source
,
3495 const struct gl_pixelstore_attrib
*dstPacking
,
3496 GLbitfield transferOps
)
3498 GLuint indexes
[MAX_WIDTH
];
3500 ASSERT(n
<= MAX_WIDTH
);
3502 transferOps
&= (IMAGE_MAP_COLOR_BIT
| IMAGE_SHIFT_OFFSET_BIT
);
3504 if (transferOps
& (IMAGE_MAP_COLOR_BIT
| IMAGE_SHIFT_OFFSET_BIT
)) {
3505 /* make a copy of input */
3506 _mesa_memcpy(indexes
, source
, n
* sizeof(GLuint
));
3507 _mesa_apply_ci_transfer_ops(ctx
, transferOps
, n
, indexes
);
3512 case GL_UNSIGNED_BYTE
:
3514 GLubyte
*dst
= (GLubyte
*) dest
;
3516 for (i
= 0; i
< n
; i
++) {
3517 *dst
++ = (GLubyte
) source
[i
];
3523 GLbyte
*dst
= (GLbyte
*) dest
;
3525 for (i
= 0; i
< n
; i
++) {
3526 dst
[i
] = (GLbyte
) source
[i
];
3530 case GL_UNSIGNED_SHORT
:
3532 GLushort
*dst
= (GLushort
*) dest
;
3534 for (i
= 0; i
< n
; i
++) {
3535 dst
[i
] = (GLushort
) source
[i
];
3537 if (dstPacking
->SwapBytes
) {
3538 _mesa_swap2( (GLushort
*) dst
, n
);
3544 GLshort
*dst
= (GLshort
*) dest
;
3546 for (i
= 0; i
< n
; i
++) {
3547 dst
[i
] = (GLshort
) source
[i
];
3549 if (dstPacking
->SwapBytes
) {
3550 _mesa_swap2( (GLushort
*) dst
, n
);
3554 case GL_UNSIGNED_INT
:
3556 GLuint
*dst
= (GLuint
*) dest
;
3558 for (i
= 0; i
< n
; i
++) {
3559 dst
[i
] = (GLuint
) source
[i
];
3561 if (dstPacking
->SwapBytes
) {
3562 _mesa_swap4( (GLuint
*) dst
, n
);
3568 GLint
*dst
= (GLint
*) dest
;
3570 for (i
= 0; i
< n
; i
++) {
3571 dst
[i
] = (GLint
) source
[i
];
3573 if (dstPacking
->SwapBytes
) {
3574 _mesa_swap4( (GLuint
*) dst
, n
);
3580 GLfloat
*dst
= (GLfloat
*) dest
;
3582 for (i
= 0; i
< n
; i
++) {
3583 dst
[i
] = (GLfloat
) source
[i
];
3585 if (dstPacking
->SwapBytes
) {
3586 _mesa_swap4( (GLuint
*) dst
, n
);
3590 case GL_HALF_FLOAT_ARB
:
3592 GLhalfARB
*dst
= (GLhalfARB
*) dest
;
3594 for (i
= 0; i
< n
; i
++) {
3595 dst
[i
] = _mesa_float_to_half((GLfloat
) source
[i
]);
3597 if (dstPacking
->SwapBytes
) {
3598 _mesa_swap2( (GLushort
*) dst
, n
);
3603 _mesa_problem(ctx
, "bad type in _mesa_pack_index_span");
3609 * Unpack a row of stencil data from a client buffer according to
3610 * the pixel unpacking parameters.
3611 * This is (or will be) used by glDrawPixels
3613 * Args: ctx - the context
3614 * n - number of pixels
3615 * dstType - destination data type
3616 * dest - destination array
3617 * srcType - source pixel type
3618 * source - source data pointer
3619 * srcPacking - pixel unpacking parameters
3620 * transferOps - apply offset/bias/lookup ops?
3623 _mesa_unpack_stencil_span( const GLcontext
*ctx
, GLuint n
,
3624 GLenum dstType
, GLvoid
*dest
,
3625 GLenum srcType
, const GLvoid
*source
,
3626 const struct gl_pixelstore_attrib
*srcPacking
,
3627 GLbitfield transferOps
)
3629 ASSERT(srcType
== GL_BITMAP
||
3630 srcType
== GL_UNSIGNED_BYTE
||
3631 srcType
== GL_BYTE
||
3632 srcType
== GL_UNSIGNED_SHORT
||
3633 srcType
== GL_SHORT
||
3634 srcType
== GL_UNSIGNED_INT
||
3635 srcType
== GL_INT
||
3636 srcType
== GL_UNSIGNED_INT_24_8_EXT
||
3637 srcType
== GL_HALF_FLOAT_ARB
||
3638 srcType
== GL_FLOAT
);
3640 ASSERT(dstType
== GL_UNSIGNED_BYTE
||
3641 dstType
== GL_UNSIGNED_SHORT
||
3642 dstType
== GL_UNSIGNED_INT
);
3644 /* only shift and offset apply to stencil */
3645 transferOps
&= IMAGE_SHIFT_OFFSET_BIT
;
3648 * Try simple cases first
3650 if (transferOps
== 0 &&
3651 !ctx
->Pixel
.MapStencilFlag
&&
3652 srcType
== GL_UNSIGNED_BYTE
&&
3653 dstType
== GL_UNSIGNED_BYTE
) {
3654 _mesa_memcpy(dest
, source
, n
* sizeof(GLubyte
));
3656 else if (transferOps
== 0 &&
3657 !ctx
->Pixel
.MapStencilFlag
&&
3658 srcType
== GL_UNSIGNED_INT
&&
3659 dstType
== GL_UNSIGNED_INT
&&
3660 !srcPacking
->SwapBytes
) {
3661 _mesa_memcpy(dest
, source
, n
* sizeof(GLuint
));
3667 GLuint indexes
[MAX_WIDTH
];
3668 assert(n
<= MAX_WIDTH
);
3670 extract_uint_indexes(n
, indexes
, GL_STENCIL_INDEX
, srcType
, source
,
3673 if (transferOps
& IMAGE_SHIFT_OFFSET_BIT
) {
3674 /* shift and offset indexes */
3675 shift_and_offset_ci(ctx
, n
, indexes
);
3678 if (ctx
->Pixel
.MapStencilFlag
) {
3679 /* Apply stencil lookup table */
3680 const GLuint mask
= ctx
->PixelMaps
.StoS
.Size
- 1;
3682 for (i
= 0; i
< n
; i
++) {
3683 indexes
[i
] = ctx
->PixelMaps
.StoS
.Map
[ indexes
[i
] & mask
];
3687 /* convert to dest type */
3689 case GL_UNSIGNED_BYTE
:
3691 GLubyte
*dst
= (GLubyte
*) dest
;
3693 for (i
= 0; i
< n
; i
++) {
3694 dst
[i
] = (GLubyte
) (indexes
[i
] & 0xff);
3698 case GL_UNSIGNED_SHORT
:
3700 GLuint
*dst
= (GLuint
*) dest
;
3702 for (i
= 0; i
< n
; i
++) {
3703 dst
[i
] = (GLushort
) (indexes
[i
] & 0xffff);
3707 case GL_UNSIGNED_INT
:
3708 _mesa_memcpy(dest
, indexes
, n
* sizeof(GLuint
));
3711 _mesa_problem(ctx
, "bad dstType in _mesa_unpack_stencil_span");
3718 _mesa_pack_stencil_span( const GLcontext
*ctx
, GLuint n
,
3719 GLenum dstType
, GLvoid
*dest
, const GLstencil
*source
,
3720 const struct gl_pixelstore_attrib
*dstPacking
)
3722 GLstencil stencil
[MAX_WIDTH
];
3724 ASSERT(n
<= MAX_WIDTH
);
3726 if (ctx
->Pixel
.IndexShift
|| ctx
->Pixel
.IndexOffset
||
3727 ctx
->Pixel
.MapStencilFlag
) {
3728 /* make a copy of input */
3729 _mesa_memcpy(stencil
, source
, n
* sizeof(GLstencil
));
3730 _mesa_apply_stencil_transfer_ops(ctx
, n
, stencil
);
3735 case GL_UNSIGNED_BYTE
:
3736 if (sizeof(GLstencil
) == 1) {
3737 _mesa_memcpy( dest
, source
, n
);
3740 GLubyte
*dst
= (GLubyte
*) dest
;
3743 dst
[i
] = (GLubyte
) source
[i
];
3749 GLbyte
*dst
= (GLbyte
*) dest
;
3752 dst
[i
] = (GLbyte
) (source
[i
] & 0x7f);
3756 case GL_UNSIGNED_SHORT
:
3758 GLushort
*dst
= (GLushort
*) dest
;
3761 dst
[i
] = (GLushort
) source
[i
];
3763 if (dstPacking
->SwapBytes
) {
3764 _mesa_swap2( (GLushort
*) dst
, n
);
3770 GLshort
*dst
= (GLshort
*) dest
;
3773 dst
[i
] = (GLshort
) source
[i
];
3775 if (dstPacking
->SwapBytes
) {
3776 _mesa_swap2( (GLushort
*) dst
, n
);
3780 case GL_UNSIGNED_INT
:
3782 GLuint
*dst
= (GLuint
*) dest
;
3785 dst
[i
] = (GLuint
) source
[i
];
3787 if (dstPacking
->SwapBytes
) {
3788 _mesa_swap4( (GLuint
*) dst
, n
);
3794 GLint
*dst
= (GLint
*) dest
;
3797 dst
[i
] = (GLint
) source
[i
];
3799 if (dstPacking
->SwapBytes
) {
3800 _mesa_swap4( (GLuint
*) dst
, n
);
3806 GLfloat
*dst
= (GLfloat
*) dest
;
3809 dst
[i
] = (GLfloat
) source
[i
];
3811 if (dstPacking
->SwapBytes
) {
3812 _mesa_swap4( (GLuint
*) dst
, n
);
3816 case GL_HALF_FLOAT_ARB
:
3818 GLhalfARB
*dst
= (GLhalfARB
*) dest
;
3821 dst
[i
] = _mesa_float_to_half( (float) source
[i
] );
3823 if (dstPacking
->SwapBytes
) {
3824 _mesa_swap2( (GLushort
*) dst
, n
);
3829 if (dstPacking
->LsbFirst
) {
3830 GLubyte
*dst
= (GLubyte
*) dest
;
3833 for (i
= 0; i
< n
; i
++) {
3836 *dst
|= ((source
[i
] != 0) << shift
);
3845 GLubyte
*dst
= (GLubyte
*) dest
;
3848 for (i
= 0; i
< n
; i
++) {
3851 *dst
|= ((source
[i
] != 0) << shift
);
3861 _mesa_problem(ctx
, "bad type in _mesa_pack_index_span");
3865 #define DEPTH_VALUES(GLTYPE, GLTYPE2FLOAT) \
3868 const GLTYPE *src = (const GLTYPE *)source; \
3869 for (i = 0; i < n; i++) { \
3870 GLTYPE value = src[i]; \
3871 if (srcPacking->SwapBytes) { \
3872 if (sizeof(GLTYPE) == 2) { \
3874 } else if (sizeof(GLTYPE) == 4) { \
3878 depthValues[i] = GLTYPE2FLOAT(value); \
3884 * Unpack a row of depth/z values from memory, returning GLushort, GLuint
3885 * or GLfloat values.
3886 * The glPixelTransfer (scale/bias) params will be applied.
3888 * \param dstType one of GL_UNSIGNED_SHORT, GL_UNSIGNED_INT, GL_FLOAT
3889 * \param depthMax max value for returned GLushort or GLuint values
3890 * (ignored for GLfloat).
3893 _mesa_unpack_depth_span( const GLcontext
*ctx
, GLuint n
,
3894 GLenum dstType
, GLvoid
*dest
, GLuint depthMax
,
3895 GLenum srcType
, const GLvoid
*source
,
3896 const struct gl_pixelstore_attrib
*srcPacking
)
3898 GLfloat depthTemp
[MAX_WIDTH
], *depthValues
;
3899 GLboolean needClamp
= GL_FALSE
;
3901 /* Look for special cases first.
3902 * Not only are these faster, they're less prone to numeric conversion
3903 * problems. Otherwise, converting from an int type to a float then
3904 * back to an int type can introduce errors that will show up as
3905 * artifacts in things like depth peeling which uses glCopyTexImage.
3907 if (ctx
->Pixel
.DepthScale
== 1.0 && ctx
->Pixel
.DepthBias
== 0.0) {
3908 if (srcType
== GL_UNSIGNED_INT
&& dstType
== GL_UNSIGNED_SHORT
) {
3909 const GLuint
*src
= (const GLuint
*) source
;
3910 GLushort
*dst
= (GLushort
*) dest
;
3912 for (i
= 0; i
< n
; i
++) {
3913 dst
[i
] = src
[i
] >> 16;
3917 if (srcType
== GL_UNSIGNED_SHORT
3918 && dstType
== GL_UNSIGNED_INT
3919 && depthMax
== 0xffffffff) {
3920 const GLushort
*src
= (const GLushort
*) source
;
3921 GLuint
*dst
= (GLuint
*) dest
;
3923 for (i
= 0; i
< n
; i
++) {
3924 dst
[i
] = src
[i
] | (src
[i
] << 16);
3928 /* XXX may want to add additional cases here someday */
3931 /* general case path follows */
3933 if (dstType
== GL_FLOAT
) {
3934 depthValues
= (GLfloat
*) dest
;
3937 depthValues
= depthTemp
;
3940 /* Convert incoming values to GLfloat. Some conversions will require
3945 DEPTH_VALUES(GLbyte
, BYTE_TO_FLOAT
);
3946 needClamp
= GL_TRUE
;
3948 case GL_UNSIGNED_BYTE
:
3949 DEPTH_VALUES(GLubyte
, UBYTE_TO_FLOAT
);
3952 DEPTH_VALUES(GLshort
, SHORT_TO_FLOAT
);
3953 needClamp
= GL_TRUE
;
3955 case GL_UNSIGNED_SHORT
:
3956 DEPTH_VALUES(GLushort
, USHORT_TO_FLOAT
);
3959 DEPTH_VALUES(GLint
, INT_TO_FLOAT
);
3960 needClamp
= GL_TRUE
;
3962 case GL_UNSIGNED_INT
:
3963 DEPTH_VALUES(GLuint
, UINT_TO_FLOAT
);
3965 case GL_UNSIGNED_INT_24_8_EXT
: /* GL_EXT_packed_depth_stencil */
3966 if (dstType
== GL_UNSIGNED_INT
&&
3967 depthMax
== 0xffffff &&
3968 ctx
->Pixel
.DepthScale
== 1.0 &&
3969 ctx
->Pixel
.DepthBias
== 0.0) {
3970 const GLuint
*src
= (const GLuint
*) source
;
3971 GLuint
*zValues
= (GLuint
*) dest
;
3973 for (i
= 0; i
< n
; i
++) {
3974 GLuint value
= src
[i
];
3975 if (srcPacking
->SwapBytes
) {
3978 zValues
[i
] = value
& 0xffffff00;
3983 const GLuint
*src
= (const GLuint
*) source
;
3984 const GLfloat scale
= 1.0f
/ 0xffffff;
3986 for (i
= 0; i
< n
; i
++) {
3987 GLuint value
= src
[i
];
3988 if (srcPacking
->SwapBytes
) {
3991 depthValues
[i
] = (value
>> 8) * scale
;
3996 DEPTH_VALUES(GLfloat
, 1*);
3997 needClamp
= GL_TRUE
;
3999 case GL_HALF_FLOAT_ARB
:
4002 const GLhalfARB
*src
= (const GLhalfARB
*) source
;
4003 for (i
= 0; i
< n
; i
++) {
4004 GLhalfARB value
= src
[i
];
4005 if (srcPacking
->SwapBytes
) {
4008 depthValues
[i
] = _mesa_half_to_float(value
);
4010 needClamp
= GL_TRUE
;
4014 _mesa_problem(NULL
, "bad type in _mesa_unpack_depth_span()");
4018 /* apply depth scale and bias */
4020 const GLfloat scale
= ctx
->Pixel
.DepthScale
;
4021 const GLfloat bias
= ctx
->Pixel
.DepthBias
;
4022 if (scale
!= 1.0 || bias
!= 0.0) {
4024 for (i
= 0; i
< n
; i
++) {
4025 depthValues
[i
] = depthValues
[i
] * scale
+ bias
;
4027 needClamp
= GL_TRUE
;
4031 /* clamp to [0, 1] */
4034 for (i
= 0; i
< n
; i
++) {
4035 depthValues
[i
] = CLAMP(depthValues
[i
], 0.0, 1.0);
4040 * Convert values to dstType
4042 if (dstType
== GL_UNSIGNED_INT
) {
4043 GLuint
*zValues
= (GLuint
*) dest
;
4045 if (depthMax
<= 0xffffff) {
4046 /* no overflow worries */
4047 for (i
= 0; i
< n
; i
++) {
4048 zValues
[i
] = (GLuint
) (depthValues
[i
] * (GLfloat
) depthMax
);
4052 /* need to use double precision to prevent overflow problems */
4053 for (i
= 0; i
< n
; i
++) {
4054 GLdouble z
= depthValues
[i
] * (GLfloat
) depthMax
;
4055 if (z
>= (GLdouble
) 0xffffffff)
4056 zValues
[i
] = 0xffffffff;
4058 zValues
[i
] = (GLuint
) z
;
4062 else if (dstType
== GL_UNSIGNED_SHORT
) {
4063 GLushort
*zValues
= (GLushort
*) dest
;
4065 ASSERT(depthMax
<= 0xffff);
4066 for (i
= 0; i
< n
; i
++) {
4067 zValues
[i
] = (GLushort
) (depthValues
[i
] * (GLfloat
) depthMax
);
4071 ASSERT(dstType
== GL_FLOAT
);
4072 /*ASSERT(depthMax == 1.0F);*/
4078 * Pack an array of depth values. The values are floats in [0,1].
4081 _mesa_pack_depth_span( const GLcontext
*ctx
, GLuint n
, GLvoid
*dest
,
4082 GLenum dstType
, const GLfloat
*depthSpan
,
4083 const struct gl_pixelstore_attrib
*dstPacking
)
4085 GLfloat depthCopy
[MAX_WIDTH
];
4087 ASSERT(n
<= MAX_WIDTH
);
4089 if (ctx
->Pixel
.DepthScale
!= 1.0 || ctx
->Pixel
.DepthBias
!= 0.0) {
4090 _mesa_memcpy(depthCopy
, depthSpan
, n
* sizeof(GLfloat
));
4091 _mesa_scale_and_bias_depth(ctx
, n
, depthCopy
);
4092 depthSpan
= depthCopy
;
4096 case GL_UNSIGNED_BYTE
:
4098 GLubyte
*dst
= (GLubyte
*) dest
;
4100 for (i
= 0; i
< n
; i
++) {
4101 dst
[i
] = FLOAT_TO_UBYTE( depthSpan
[i
] );
4107 GLbyte
*dst
= (GLbyte
*) dest
;
4109 for (i
= 0; i
< n
; i
++) {
4110 dst
[i
] = FLOAT_TO_BYTE( depthSpan
[i
] );
4114 case GL_UNSIGNED_SHORT
:
4116 GLushort
*dst
= (GLushort
*) dest
;
4118 for (i
= 0; i
< n
; i
++) {
4119 CLAMPED_FLOAT_TO_USHORT(dst
[i
], depthSpan
[i
]);
4121 if (dstPacking
->SwapBytes
) {
4122 _mesa_swap2( (GLushort
*) dst
, n
);
4128 GLshort
*dst
= (GLshort
*) dest
;
4130 for (i
= 0; i
< n
; i
++) {
4131 dst
[i
] = FLOAT_TO_SHORT( depthSpan
[i
] );
4133 if (dstPacking
->SwapBytes
) {
4134 _mesa_swap2( (GLushort
*) dst
, n
);
4138 case GL_UNSIGNED_INT
:
4140 GLuint
*dst
= (GLuint
*) dest
;
4142 for (i
= 0; i
< n
; i
++) {
4143 dst
[i
] = FLOAT_TO_UINT( depthSpan
[i
] );
4145 if (dstPacking
->SwapBytes
) {
4146 _mesa_swap4( (GLuint
*) dst
, n
);
4152 GLint
*dst
= (GLint
*) dest
;
4154 for (i
= 0; i
< n
; i
++) {
4155 dst
[i
] = FLOAT_TO_INT( depthSpan
[i
] );
4157 if (dstPacking
->SwapBytes
) {
4158 _mesa_swap4( (GLuint
*) dst
, n
);
4164 GLfloat
*dst
= (GLfloat
*) dest
;
4166 for (i
= 0; i
< n
; i
++) {
4167 dst
[i
] = depthSpan
[i
];
4169 if (dstPacking
->SwapBytes
) {
4170 _mesa_swap4( (GLuint
*) dst
, n
);
4174 case GL_HALF_FLOAT_ARB
:
4176 GLhalfARB
*dst
= (GLhalfARB
*) dest
;
4178 for (i
= 0; i
< n
; i
++) {
4179 dst
[i
] = _mesa_float_to_half(depthSpan
[i
]);
4181 if (dstPacking
->SwapBytes
) {
4182 _mesa_swap2( (GLushort
*) dst
, n
);
4187 _mesa_problem(ctx
, "bad type in _mesa_pack_depth_span");
4194 * Pack depth and stencil values as GL_DEPTH_STENCIL/GL_UNSIGNED_INT_24_8.
4197 _mesa_pack_depth_stencil_span(const GLcontext
*ctx
, GLuint n
, GLuint
*dest
,
4198 const GLfloat
*depthVals
,
4199 const GLstencil
*stencilVals
,
4200 const struct gl_pixelstore_attrib
*dstPacking
)
4202 GLfloat depthCopy
[MAX_WIDTH
];
4203 GLstencil stencilCopy
[MAX_WIDTH
];
4206 ASSERT(n
<= MAX_WIDTH
);
4208 if (ctx
->Pixel
.DepthScale
!= 1.0 || ctx
->Pixel
.DepthBias
!= 0.0) {
4209 _mesa_memcpy(depthCopy
, depthVals
, n
* sizeof(GLfloat
));
4210 _mesa_scale_and_bias_depth(ctx
, n
, depthCopy
);
4211 depthVals
= depthCopy
;
4214 if (ctx
->Pixel
.IndexShift
||
4215 ctx
->Pixel
.IndexOffset
||
4216 ctx
->Pixel
.MapStencilFlag
) {
4217 _mesa_memcpy(stencilCopy
, stencilVals
, n
* sizeof(GLstencil
));
4218 _mesa_apply_stencil_transfer_ops(ctx
, n
, stencilCopy
);
4219 stencilVals
= stencilCopy
;
4222 for (i
= 0; i
< n
; i
++) {
4223 GLuint z
= (GLuint
) (depthVals
[i
] * 0xffffff);
4224 dest
[i
] = (z
<< 8) | (stencilVals
[i
] & 0xff);
4227 if (dstPacking
->SwapBytes
) {
4228 _mesa_swap4(dest
, n
);
4236 * Unpack image data. Apply byte swapping, byte flipping (bitmap).
4237 * Return all image data in a contiguous block. This is used when we
4238 * compile glDrawPixels, glTexImage, etc into a display list. We
4239 * need a copy of the data in a standard format.
4242 _mesa_unpack_image( GLuint dimensions
,
4243 GLsizei width
, GLsizei height
, GLsizei depth
,
4244 GLenum format
, GLenum type
, const GLvoid
*pixels
,
4245 const struct gl_pixelstore_attrib
*unpack
)
4247 GLint bytesPerRow
, compsPerRow
;
4248 GLboolean flipBytes
, swap2
, swap4
;
4251 return NULL
; /* not necessarily an error */
4253 if (width
<= 0 || height
<= 0 || depth
<= 0)
4254 return NULL
; /* generate error later */
4256 if (type
== GL_BITMAP
) {
4257 bytesPerRow
= (width
+ 7) >> 3;
4258 flipBytes
= unpack
->LsbFirst
;
4259 swap2
= swap4
= GL_FALSE
;
4263 const GLint bytesPerPixel
= _mesa_bytes_per_pixel(format
, type
);
4264 GLint components
= _mesa_components_in_format(format
);
4267 if (_mesa_type_is_packed(type
))
4270 if (bytesPerPixel
<= 0 || components
<= 0)
4271 return NULL
; /* bad format or type. generate error later */
4272 bytesPerRow
= bytesPerPixel
* width
;
4273 bytesPerComp
= bytesPerPixel
/ components
;
4274 flipBytes
= GL_FALSE
;
4275 swap2
= (bytesPerComp
== 2) && unpack
->SwapBytes
;
4276 swap4
= (bytesPerComp
== 4) && unpack
->SwapBytes
;
4277 compsPerRow
= components
* width
;
4278 assert(compsPerRow
>= width
);
4283 = (GLubyte
*) _mesa_malloc(bytesPerRow
* height
* depth
);
4287 return NULL
; /* generate GL_OUT_OF_MEMORY later */
4290 for (img
= 0; img
< depth
; img
++) {
4291 for (row
= 0; row
< height
; row
++) {
4292 const GLvoid
*src
= _mesa_image_address(dimensions
, unpack
, pixels
,
4293 width
, height
, format
, type
, img
, row
, 0);
4295 if ((type
== GL_BITMAP
) && (unpack
->SkipPixels
& 0x7)) {
4297 flipBytes
= GL_FALSE
;
4298 if (unpack
->LsbFirst
) {
4299 GLubyte srcMask
= 1 << (unpack
->SkipPixels
& 0x7);
4300 GLubyte dstMask
= 128;
4301 const GLubyte
*s
= src
;
4304 for (i
= 0; i
< width
; i
++) {
4308 if (srcMask
== 128) {
4313 srcMask
= srcMask
<< 1;
4321 dstMask
= dstMask
>> 1;
4326 GLubyte srcMask
= 128 >> (unpack
->SkipPixels
& 0x7);
4327 GLubyte dstMask
= 128;
4328 const GLubyte
*s
= src
;
4331 for (i
= 0; i
< width
; i
++) {
4340 srcMask
= srcMask
>> 1;
4348 dstMask
= dstMask
>> 1;
4354 _mesa_memcpy(dst
, src
, bytesPerRow
);
4357 /* byte flipping/swapping */
4359 flip_bytes((GLubyte
*) dst
, bytesPerRow
);
4362 _mesa_swap2((GLushort
*) dst
, compsPerRow
);
4365 _mesa_swap4((GLuint
*) dst
, compsPerRow
);
4374 #endif /* _HAVE_FULL_GL */
4379 * Convert an array of RGBA colors from one datatype to another.
4380 * NOTE: src may equal dst. In that case, we use a temporary buffer.
4383 _mesa_convert_colors(GLenum srcType
, const GLvoid
*src
,
4384 GLenum dstType
, GLvoid
*dst
,
4385 GLuint count
, const GLubyte mask
[])
4387 GLuint tempBuffer
[MAX_WIDTH
][4];
4388 const GLboolean useTemp
= (src
== dst
);
4390 ASSERT(srcType
!= dstType
);
4393 case GL_UNSIGNED_BYTE
:
4394 if (dstType
== GL_UNSIGNED_SHORT
) {
4395 const GLubyte (*src1
)[4] = (const GLubyte (*)[4]) src
;
4396 GLushort (*dst2
)[4] = (GLushort (*)[4]) (useTemp
? tempBuffer
: dst
);
4398 for (i
= 0; i
< count
; i
++) {
4399 if (!mask
|| mask
[i
]) {
4400 dst2
[i
][RCOMP
] = UBYTE_TO_USHORT(src1
[i
][RCOMP
]);
4401 dst2
[i
][GCOMP
] = UBYTE_TO_USHORT(src1
[i
][GCOMP
]);
4402 dst2
[i
][BCOMP
] = UBYTE_TO_USHORT(src1
[i
][BCOMP
]);
4403 dst2
[i
][ACOMP
] = UBYTE_TO_USHORT(src1
[i
][ACOMP
]);
4407 _mesa_memcpy(dst
, tempBuffer
, count
* 4 * sizeof(GLushort
));
4410 const GLubyte (*src1
)[4] = (const GLubyte (*)[4]) src
;
4411 GLfloat (*dst4
)[4] = (GLfloat (*)[4]) (useTemp
? tempBuffer
: dst
);
4413 ASSERT(dstType
== GL_FLOAT
);
4414 for (i
= 0; i
< count
; i
++) {
4415 if (!mask
|| mask
[i
]) {
4416 dst4
[i
][RCOMP
] = UBYTE_TO_FLOAT(src1
[i
][RCOMP
]);
4417 dst4
[i
][GCOMP
] = UBYTE_TO_FLOAT(src1
[i
][GCOMP
]);
4418 dst4
[i
][BCOMP
] = UBYTE_TO_FLOAT(src1
[i
][BCOMP
]);
4419 dst4
[i
][ACOMP
] = UBYTE_TO_FLOAT(src1
[i
][ACOMP
]);
4423 _mesa_memcpy(dst
, tempBuffer
, count
* 4 * sizeof(GLfloat
));
4426 case GL_UNSIGNED_SHORT
:
4427 if (dstType
== GL_UNSIGNED_BYTE
) {
4428 const GLushort (*src2
)[4] = (const GLushort (*)[4]) src
;
4429 GLubyte (*dst1
)[4] = (GLubyte (*)[4]) (useTemp
? tempBuffer
: dst
);
4431 for (i
= 0; i
< count
; i
++) {
4432 if (!mask
|| mask
[i
]) {
4433 dst1
[i
][RCOMP
] = USHORT_TO_UBYTE(src2
[i
][RCOMP
]);
4434 dst1
[i
][GCOMP
] = USHORT_TO_UBYTE(src2
[i
][GCOMP
]);
4435 dst1
[i
][BCOMP
] = USHORT_TO_UBYTE(src2
[i
][BCOMP
]);
4436 dst1
[i
][ACOMP
] = USHORT_TO_UBYTE(src2
[i
][ACOMP
]);
4440 _mesa_memcpy(dst
, tempBuffer
, count
* 4 * sizeof(GLubyte
));
4443 const GLushort (*src2
)[4] = (const GLushort (*)[4]) src
;
4444 GLfloat (*dst4
)[4] = (GLfloat (*)[4]) (useTemp
? tempBuffer
: dst
);
4446 ASSERT(dstType
== GL_FLOAT
);
4447 for (i
= 0; i
< count
; i
++) {
4448 if (!mask
|| mask
[i
]) {
4449 dst4
[i
][RCOMP
] = USHORT_TO_FLOAT(src2
[i
][RCOMP
]);
4450 dst4
[i
][GCOMP
] = USHORT_TO_FLOAT(src2
[i
][GCOMP
]);
4451 dst4
[i
][BCOMP
] = USHORT_TO_FLOAT(src2
[i
][BCOMP
]);
4452 dst4
[i
][ACOMP
] = USHORT_TO_FLOAT(src2
[i
][ACOMP
]);
4456 _mesa_memcpy(dst
, tempBuffer
, count
* 4 * sizeof(GLfloat
));
4460 if (dstType
== GL_UNSIGNED_BYTE
) {
4461 const GLfloat (*src4
)[4] = (const GLfloat (*)[4]) src
;
4462 GLubyte (*dst1
)[4] = (GLubyte (*)[4]) (useTemp
? tempBuffer
: dst
);
4464 for (i
= 0; i
< count
; i
++) {
4465 if (!mask
|| mask
[i
]) {
4466 UNCLAMPED_FLOAT_TO_UBYTE(dst1
[i
][RCOMP
], src4
[i
][RCOMP
]);
4467 UNCLAMPED_FLOAT_TO_UBYTE(dst1
[i
][GCOMP
], src4
[i
][GCOMP
]);
4468 UNCLAMPED_FLOAT_TO_UBYTE(dst1
[i
][BCOMP
], src4
[i
][BCOMP
]);
4469 UNCLAMPED_FLOAT_TO_UBYTE(dst1
[i
][ACOMP
], src4
[i
][ACOMP
]);
4473 _mesa_memcpy(dst
, tempBuffer
, count
* 4 * sizeof(GLubyte
));
4476 const GLfloat (*src4
)[4] = (const GLfloat (*)[4]) src
;
4477 GLushort (*dst2
)[4] = (GLushort (*)[4]) (useTemp
? tempBuffer
: dst
);
4479 ASSERT(dstType
== GL_UNSIGNED_SHORT
);
4480 for (i
= 0; i
< count
; i
++) {
4481 if (!mask
|| mask
[i
]) {
4482 UNCLAMPED_FLOAT_TO_USHORT(dst2
[i
][RCOMP
], src4
[i
][RCOMP
]);
4483 UNCLAMPED_FLOAT_TO_USHORT(dst2
[i
][GCOMP
], src4
[i
][GCOMP
]);
4484 UNCLAMPED_FLOAT_TO_USHORT(dst2
[i
][BCOMP
], src4
[i
][BCOMP
]);
4485 UNCLAMPED_FLOAT_TO_USHORT(dst2
[i
][ACOMP
], src4
[i
][ACOMP
]);
4489 _mesa_memcpy(dst
, tempBuffer
, count
* 4 * sizeof(GLushort
));
4493 _mesa_problem(NULL
, "Invalid datatype in _mesa_convert_colors");
4501 * Perform basic clipping for glDrawPixels. The image's position and size
4502 * and the unpack SkipPixels and SkipRows are adjusted so that the image
4503 * region is entirely within the window and scissor bounds.
4504 * NOTE: this will only work when glPixelZoom is (1, 1) or (1, -1).
4505 * If Pixel.ZoomY is -1, *destY will be changed to be the first row which
4506 * we'll actually write. Beforehand, *destY-1 is the first drawing row.
4508 * \return GL_TRUE if image is ready for drawing or
4509 * GL_FALSE if image was completely clipped away (draw nothing)
4512 _mesa_clip_drawpixels(const GLcontext
*ctx
,
4513 GLint
*destX
, GLint
*destY
,
4514 GLsizei
*width
, GLsizei
*height
,
4515 struct gl_pixelstore_attrib
*unpack
)
4517 const GLframebuffer
*buffer
= ctx
->DrawBuffer
;
4519 if (unpack
->RowLength
== 0) {
4520 unpack
->RowLength
= *width
;
4523 ASSERT(ctx
->Pixel
.ZoomX
== 1.0F
);
4524 ASSERT(ctx
->Pixel
.ZoomY
== 1.0F
|| ctx
->Pixel
.ZoomY
== -1.0F
);
4527 if (*destX
< buffer
->_Xmin
) {
4528 unpack
->SkipPixels
+= (buffer
->_Xmin
- *destX
);
4529 *width
-= (buffer
->_Xmin
- *destX
);
4530 *destX
= buffer
->_Xmin
;
4532 /* right clipping */
4533 if (*destX
+ *width
> buffer
->_Xmax
)
4534 *width
-= (*destX
+ *width
- buffer
->_Xmax
);
4539 if (ctx
->Pixel
.ZoomY
== 1.0F
) {
4540 /* bottom clipping */
4541 if (*destY
< buffer
->_Ymin
) {
4542 unpack
->SkipRows
+= (buffer
->_Ymin
- *destY
);
4543 *height
-= (buffer
->_Ymin
- *destY
);
4544 *destY
= buffer
->_Ymin
;
4547 if (*destY
+ *height
> buffer
->_Ymax
)
4548 *height
-= (*destY
+ *height
- buffer
->_Ymax
);
4550 else { /* upside down */
4552 if (*destY
> buffer
->_Ymax
) {
4553 unpack
->SkipRows
+= (*destY
- buffer
->_Ymax
);
4554 *height
-= (*destY
- buffer
->_Ymax
);
4555 *destY
= buffer
->_Ymax
;
4557 /* bottom clipping */
4558 if (*destY
- *height
< buffer
->_Ymin
)
4559 *height
-= (buffer
->_Ymin
- (*destY
- *height
));
4560 /* adjust destY so it's the first row to write to */
4572 * Perform clipping for glReadPixels. The image's window position
4573 * and size, and the pack skipPixels, skipRows and rowLength are adjusted
4574 * so that the image region is entirely within the window bounds.
4575 * Note: this is different from _mesa_clip_drawpixels() in that the
4576 * scissor box is ignored, and we use the bounds of the current readbuffer
4579 * \return GL_TRUE if image is ready for drawing or
4580 * GL_FALSE if image was completely clipped away (draw nothing)
4583 _mesa_clip_readpixels(const GLcontext
*ctx
,
4584 GLint
*srcX
, GLint
*srcY
,
4585 GLsizei
*width
, GLsizei
*height
,
4586 struct gl_pixelstore_attrib
*pack
)
4588 const GLframebuffer
*buffer
= ctx
->ReadBuffer
;
4590 if (pack
->RowLength
== 0) {
4591 pack
->RowLength
= *width
;
4596 pack
->SkipPixels
+= (0 - *srcX
);
4597 *width
-= (0 - *srcX
);
4600 /* right clipping */
4601 if (*srcX
+ *width
> (GLsizei
) buffer
->Width
)
4602 *width
-= (*srcX
+ *width
- buffer
->Width
);
4607 /* bottom clipping */
4609 pack
->SkipRows
+= (0 - *srcY
);
4610 *height
-= (0 - *srcY
);
4614 if (*srcY
+ *height
> (GLsizei
) buffer
->Height
)
4615 *height
-= (*srcY
+ *height
- buffer
->Height
);
4625 * Clip the rectangle defined by (x, y, width, height) against the bounds
4626 * specified by [xmin, xmax) and [ymin, ymax).
4627 * \return GL_FALSE if rect is totally clipped, GL_TRUE otherwise.
4630 _mesa_clip_to_region(GLint xmin
, GLint ymin
,
4631 GLint xmax
, GLint ymax
,
4633 GLsizei
*width
, GLsizei
*height
)
4637 *width
-= (xmin
- *x
);
4641 /* right clipping */
4642 if (*x
+ *width
> xmax
)
4643 *width
-= (*x
+ *width
- xmax
- 1);
4648 /* bottom (or top) clipping */
4650 *height
-= (ymin
- *y
);
4654 /* top (or bottom) clipping */
4655 if (*y
+ *height
> ymax
)
4656 *height
-= (*y
+ *height
- ymax
- 1);