2 * Mesa 3-D graphics library
4 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved.
5 * Copyright (C) 2009-2010 VMware, Inc. 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 * THEA AUTHORS 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.
28 * Image and pixel span packing and unpacking.
40 #include "pixeltransfer.h"
42 #include "../../gallium/auxiliary/util/u_format_rgb9e5.h"
43 #include "../../gallium/auxiliary/util/u_format_r11g11b10f.h"
47 * Flip the 8 bits in each byte of the given array.
50 * \param n number of bytes.
52 * \todo try this trick to flip bytes someday:
54 * v = ((v & 0x55555555) << 1) | ((v >> 1) & 0x55555555);
55 * v = ((v & 0x33333333) << 2) | ((v >> 2) & 0x33333333);
56 * v = ((v & 0x0f0f0f0f) << 4) | ((v >> 4) & 0x0f0f0f0f);
60 flip_bytes( GLubyte
*p
, GLuint n
)
63 for (i
= 0; i
< n
; i
++) {
64 b
= (GLuint
) p
[i
]; /* words are often faster than bytes */
65 a
= ((b
& 0x01) << 7) |
80 * Unpack a 32x32 pixel polygon stipple from user memory using the
81 * current pixel unpack settings.
84 _mesa_unpack_polygon_stipple( const GLubyte
*pattern
, GLuint dest
[32],
85 const struct gl_pixelstore_attrib
*unpacking
)
87 GLubyte
*ptrn
= (GLubyte
*) _mesa_unpack_bitmap(32, 32, pattern
, unpacking
);
89 /* Convert pattern from GLubytes to GLuints and handle big/little
94 for (i
= 0; i
< 32; i
++) {
95 dest
[i
] = (p
[0] << 24)
107 * Pack polygon stipple into user memory given current pixel packing
111 _mesa_pack_polygon_stipple( const GLuint pattern
[32], GLubyte
*dest
,
112 const struct gl_pixelstore_attrib
*packing
)
114 /* Convert pattern from GLuints to GLubytes to handle big/little
115 * endian differences.
119 for (i
= 0; i
< 32; i
++) {
120 ptrn
[i
* 4 + 0] = (GLubyte
) ((pattern
[i
] >> 24) & 0xff);
121 ptrn
[i
* 4 + 1] = (GLubyte
) ((pattern
[i
] >> 16) & 0xff);
122 ptrn
[i
* 4 + 2] = (GLubyte
) ((pattern
[i
] >> 8 ) & 0xff);
123 ptrn
[i
* 4 + 3] = (GLubyte
) ((pattern
[i
] ) & 0xff);
126 _mesa_pack_bitmap(32, 32, ptrn
, dest
, packing
);
131 * Unpack bitmap data. Resulting data will be in most-significant-bit-first
132 * order with row alignment = 1 byte.
135 _mesa_unpack_bitmap( GLint width
, GLint height
, const GLubyte
*pixels
,
136 const struct gl_pixelstore_attrib
*packing
)
138 GLint bytes
, row
, width_in_bytes
;
139 GLubyte
*buffer
, *dst
;
144 /* Alloc dest storage */
145 bytes
= ((width
+ 7) / 8 * height
);
146 buffer
= (GLubyte
*) malloc( bytes
);
150 width_in_bytes
= CEILING( width
, 8 );
152 for (row
= 0; row
< height
; row
++) {
153 const GLubyte
*src
= (const GLubyte
*)
154 _mesa_image_address2d(packing
, pixels
, width
, height
,
155 GL_COLOR_INDEX
, GL_BITMAP
, row
, 0);
161 if ((packing
->SkipPixels
& 7) == 0) {
162 memcpy( dst
, src
, width_in_bytes
);
163 if (packing
->LsbFirst
) {
164 flip_bytes( dst
, width_in_bytes
);
168 /* handling SkipPixels is a bit tricky (no pun intended!) */
170 if (packing
->LsbFirst
) {
171 GLubyte srcMask
= 1 << (packing
->SkipPixels
& 0x7);
172 GLubyte dstMask
= 128;
173 const GLubyte
*s
= src
;
176 for (i
= 0; i
< width
; i
++) {
180 if (srcMask
== 128) {
185 srcMask
= srcMask
<< 1;
193 dstMask
= dstMask
>> 1;
198 GLubyte srcMask
= 128 >> (packing
->SkipPixels
& 0x7);
199 GLubyte dstMask
= 128;
200 const GLubyte
*s
= src
;
203 for (i
= 0; i
< width
; i
++) {
212 srcMask
= srcMask
>> 1;
220 dstMask
= dstMask
>> 1;
225 dst
+= width_in_bytes
;
236 _mesa_pack_bitmap( GLint width
, GLint height
, const GLubyte
*source
,
237 GLubyte
*dest
, const struct gl_pixelstore_attrib
*packing
)
239 GLint row
, width_in_bytes
;
245 width_in_bytes
= CEILING( width
, 8 );
247 for (row
= 0; row
< height
; row
++) {
248 GLubyte
*dst
= (GLubyte
*) _mesa_image_address2d(packing
, dest
,
249 width
, height
, GL_COLOR_INDEX
, GL_BITMAP
, row
, 0);
253 if ((packing
->SkipPixels
& 7) == 0) {
254 memcpy( dst
, src
, width_in_bytes
);
255 if (packing
->LsbFirst
) {
256 flip_bytes( dst
, width_in_bytes
);
260 /* handling SkipPixels is a bit tricky (no pun intended!) */
262 if (packing
->LsbFirst
) {
263 GLubyte srcMask
= 128;
264 GLubyte dstMask
= 1 << (packing
->SkipPixels
& 0x7);
265 const GLubyte
*s
= src
;
268 for (i
= 0; i
< width
; i
++) {
277 srcMask
= srcMask
>> 1;
279 if (dstMask
== 128) {
285 dstMask
= dstMask
<< 1;
290 GLubyte srcMask
= 128;
291 GLubyte dstMask
= 128 >> (packing
->SkipPixels
& 0x7);
292 const GLubyte
*s
= src
;
295 for (i
= 0; i
< width
; i
++) {
304 srcMask
= srcMask
>> 1;
312 dstMask
= dstMask
>> 1;
317 src
+= width_in_bytes
;
323 * Get indexes of color components for a basic color format, such as
324 * GL_RGBA, GL_RED, GL_LUMINANCE_ALPHA, etc. Return -1 for indexes
328 get_component_indexes(GLenum format
,
333 GLint
*luminanceIndex
,
334 GLint
*intensityIndex
)
340 *luminanceIndex
= -1;
341 *intensityIndex
= -1;
345 case GL_LUMINANCE_INTEGER_EXT
:
348 case GL_LUMINANCE_ALPHA
:
349 case GL_LUMINANCE_ALPHA_INTEGER_EXT
:
357 case GL_RED_INTEGER_EXT
:
361 case GL_GREEN_INTEGER_EXT
:
365 case GL_BLUE_INTEGER_EXT
:
369 case GL_ALPHA_INTEGER_EXT
:
378 case GL_RGB_INTEGER_EXT
:
384 case GL_BGR_INTEGER_EXT
:
390 case GL_RGBA_INTEGER_EXT
:
397 case GL_BGRA_INTEGER
:
415 assert(0 && "bad format in get_component_indexes()");
422 * For small integer types, return the min and max possible values.
423 * Used for clamping floats to unscaled integer types.
424 * \return GL_TRUE if type is handled, GL_FALSE otherwise.
427 get_type_min_max(GLenum type
, GLfloat
*min
, GLfloat
*max
)
434 case GL_UNSIGNED_BYTE
:
442 case GL_UNSIGNED_SHORT
:
451 /* Customization of integer packing. We always treat src as uint, and can pack dst
452 * as any integer type/format combo.
454 #define SRC_TYPE GLuint
456 #define DST_TYPE GLuint
457 #define SRC_CONVERT(x) (x)
458 #define FN_NAME pack_uint_from_uint_rgba
459 #include "pack_tmp.h"
464 #define DST_TYPE GLushort
465 #define SRC_CONVERT(x) MIN2(x, 0xffff)
466 #define FN_NAME pack_ushort_from_uint_rgba
467 #include "pack_tmp.h"
472 #define DST_TYPE GLshort
473 #define SRC_CONVERT(x) CLAMP((int)x, -32768, 32767)
474 #define FN_NAME pack_short_from_uint_rgba
475 #include "pack_tmp.h"
480 #define DST_TYPE GLubyte
481 #define SRC_CONVERT(x) MIN2(x, 0xff)
482 #define FN_NAME pack_ubyte_from_uint_rgba
483 #include "pack_tmp.h"
488 #define DST_TYPE GLbyte
489 #define SRC_CONVERT(x) CLAMP((int)x, -128, 127)
490 #define FN_NAME pack_byte_from_uint_rgba
491 #include "pack_tmp.h"
497 _mesa_pack_rgba_span_int(struct gl_context
*ctx
, GLuint n
, GLuint rgba
[][4],
498 GLenum dstFormat
, GLenum dstType
,
502 case GL_UNSIGNED_INT
:
503 pack_uint_from_uint_rgba(dstAddr
, dstFormat
, rgba
, n
);
506 /* No conversion necessary. */
507 pack_uint_from_uint_rgba(dstAddr
, dstFormat
, rgba
, n
);
509 case GL_UNSIGNED_SHORT
:
510 pack_ushort_from_uint_rgba(dstAddr
, dstFormat
, rgba
, n
);
513 pack_short_from_uint_rgba(dstAddr
, dstFormat
, rgba
, n
);
515 case GL_UNSIGNED_BYTE
:
516 pack_ubyte_from_uint_rgba(dstAddr
, dstFormat
, rgba
, n
);
519 pack_byte_from_uint_rgba(dstAddr
, dstFormat
, rgba
, n
);
529 * Used to pack an array [][4] of RGBA float colors as specified
530 * by the dstFormat, dstType and dstPacking. Used by glReadPixels.
531 * Historically, the RGBA values were in [0,1] and rescaled to fit
532 * into GLubytes, etc. But with new integer formats, the RGBA values
533 * may have any value and we don't always rescale when converting to
536 * Note: the rgba values will be modified by this function when any pixel
537 * transfer ops are enabled.
540 _mesa_pack_rgba_span_float(struct gl_context
*ctx
, GLuint n
, GLfloat rgba
[][4],
541 GLenum dstFormat
, GLenum dstType
,
543 const struct gl_pixelstore_attrib
*dstPacking
,
544 GLbitfield transferOps
)
547 const GLint comps
= _mesa_components_in_format(dstFormat
);
548 const GLboolean intDstFormat
= _mesa_is_integer_format(dstFormat
);
551 if (dstFormat
== GL_LUMINANCE
||
552 dstFormat
== GL_LUMINANCE_ALPHA
||
553 dstFormat
== GL_LUMINANCE_INTEGER_EXT
||
554 dstFormat
== GL_LUMINANCE_ALPHA_INTEGER_EXT
) {
555 luminance
= (GLfloat
*) malloc(n
* sizeof(GLfloat
));
557 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "pixel packing");
565 /* EXT_texture_integer specifies no transfer ops on integer
566 * types in the resolved issues section. Just set them to 0
567 * for integer surfaces.
573 _mesa_apply_rgba_transfer_ops(ctx
, transferOps
, n
, rgba
);
577 * Component clamping (besides clamping to [0,1] in
578 * _mesa_apply_rgba_transfer_ops()).
581 /* clamping to dest type's min/max values */
583 if (get_type_min_max(dstType
, &min
, &max
)) {
584 for (i
= 0; i
< n
; i
++) {
585 rgba
[i
][RCOMP
] = CLAMP(rgba
[i
][RCOMP
], min
, max
);
586 rgba
[i
][GCOMP
] = CLAMP(rgba
[i
][GCOMP
], min
, max
);
587 rgba
[i
][BCOMP
] = CLAMP(rgba
[i
][BCOMP
], min
, max
);
588 rgba
[i
][ACOMP
] = CLAMP(rgba
[i
][ACOMP
], min
, max
);
592 else if (dstFormat
== GL_LUMINANCE
|| dstFormat
== GL_LUMINANCE_ALPHA
) {
593 /* compute luminance values */
594 if (transferOps
& IMAGE_CLAMP_BIT
) {
595 for (i
= 0; i
< n
; i
++) {
596 GLfloat sum
= rgba
[i
][RCOMP
] + rgba
[i
][GCOMP
] + rgba
[i
][BCOMP
];
597 luminance
[i
] = CLAMP(sum
, 0.0F
, 1.0F
);
601 for (i
= 0; i
< n
; i
++) {
602 luminance
[i
] = rgba
[i
][RCOMP
] + rgba
[i
][GCOMP
] + rgba
[i
][BCOMP
];
608 * Pack/store the pixels. Ugh! Lots of cases!!!
611 case GL_UNSIGNED_BYTE
:
613 GLubyte
*dst
= (GLubyte
*) dstAddr
;
617 dst
[i
] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
621 dst
[i
] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
625 dst
[i
] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
629 dst
[i
] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
633 dst
[i
] = FLOAT_TO_UBYTE(luminance
[i
]);
635 case GL_LUMINANCE_ALPHA
:
637 dst
[i
*2+0] = FLOAT_TO_UBYTE(luminance
[i
]);
638 dst
[i
*2+1] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
643 dst
[i
*2+0] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
644 dst
[i
*2+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
649 dst
[i
*3+0] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
650 dst
[i
*3+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
651 dst
[i
*3+2] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
656 dst
[i
*4+0] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
657 dst
[i
*4+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
658 dst
[i
*4+2] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
659 dst
[i
*4+3] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
664 dst
[i
*3+0] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
665 dst
[i
*3+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
666 dst
[i
*3+2] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
671 dst
[i
*4+0] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
672 dst
[i
*4+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
673 dst
[i
*4+2] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
674 dst
[i
*4+3] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
679 dst
[i
*4+0] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
680 dst
[i
*4+1] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
681 dst
[i
*4+2] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
682 dst
[i
*4+3] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
685 case GL_RED_INTEGER_EXT
:
687 dst
[i
] = (GLubyte
) rgba
[i
][RCOMP
];
690 case GL_GREEN_INTEGER_EXT
:
692 dst
[i
] = (GLubyte
) rgba
[i
][GCOMP
];
695 case GL_BLUE_INTEGER_EXT
:
697 dst
[i
] = (GLubyte
) rgba
[i
][BCOMP
];
700 case GL_ALPHA_INTEGER_EXT
:
702 dst
[i
] = (GLubyte
) rgba
[i
][ACOMP
];
707 dst
[i
*2+0] = (GLubyte
) rgba
[i
][RCOMP
];
708 dst
[i
*2+1] = (GLubyte
) rgba
[i
][GCOMP
];
711 case GL_RGB_INTEGER_EXT
:
713 dst
[i
*3+0] = (GLubyte
) rgba
[i
][RCOMP
];
714 dst
[i
*3+1] = (GLubyte
) rgba
[i
][GCOMP
];
715 dst
[i
*3+2] = (GLubyte
) rgba
[i
][BCOMP
];
718 case GL_RGBA_INTEGER_EXT
:
720 dst
[i
*4+0] = (GLubyte
) rgba
[i
][RCOMP
];
721 dst
[i
*4+1] = (GLubyte
) rgba
[i
][GCOMP
];
722 dst
[i
*4+2] = (GLubyte
) rgba
[i
][BCOMP
];
723 dst
[i
*4+3] = (GLubyte
) rgba
[i
][ACOMP
];
726 case GL_BGR_INTEGER_EXT
:
728 dst
[i
*3+0] = (GLubyte
) rgba
[i
][BCOMP
];
729 dst
[i
*3+1] = (GLubyte
) rgba
[i
][GCOMP
];
730 dst
[i
*3+2] = (GLubyte
) rgba
[i
][RCOMP
];
733 case GL_BGRA_INTEGER_EXT
:
735 dst
[i
*4+0] = (GLubyte
) rgba
[i
][BCOMP
];
736 dst
[i
*4+1] = (GLubyte
) rgba
[i
][GCOMP
];
737 dst
[i
*4+2] = (GLubyte
) rgba
[i
][RCOMP
];
738 dst
[i
*4+3] = (GLubyte
) rgba
[i
][ACOMP
];
741 case GL_LUMINANCE_INTEGER_EXT
:
743 dst
[i
*2+0] = (GLubyte
) (rgba
[i
][RCOMP
] +
746 dst
[i
*2+1] = (GLubyte
) rgba
[i
][ACOMP
];
749 case GL_LUMINANCE_ALPHA_INTEGER_EXT
:
751 dst
[i
] = (GLubyte
) (rgba
[i
][RCOMP
] +
759 dst
[i
*2+0] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
760 dst
[i
*2+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
764 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
770 GLbyte
*dst
= (GLbyte
*) dstAddr
;
774 dst
[i
] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
778 dst
[i
] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
782 dst
[i
] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
786 dst
[i
] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
790 dst
[i
] = FLOAT_TO_BYTE(luminance
[i
]);
792 case GL_LUMINANCE_ALPHA
:
794 dst
[i
*2+0] = FLOAT_TO_BYTE(luminance
[i
]);
795 dst
[i
*2+1] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
800 dst
[i
*2+0] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
801 dst
[i
*2+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
806 dst
[i
*3+0] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
807 dst
[i
*3+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
808 dst
[i
*3+2] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
813 dst
[i
*4+0] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
814 dst
[i
*4+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
815 dst
[i
*4+2] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
816 dst
[i
*4+3] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
821 dst
[i
*3+0] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
822 dst
[i
*3+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
823 dst
[i
*3+2] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
828 dst
[i
*4+0] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
829 dst
[i
*4+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
830 dst
[i
*4+2] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
831 dst
[i
*4+3] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
836 dst
[i
*4+0] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
837 dst
[i
*4+1] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
838 dst
[i
*4+2] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
839 dst
[i
*4+3] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
842 case GL_RED_INTEGER_EXT
:
844 dst
[i
] = (GLbyte
) rgba
[i
][RCOMP
];
847 case GL_GREEN_INTEGER_EXT
:
849 dst
[i
] = (GLbyte
) rgba
[i
][GCOMP
];
852 case GL_BLUE_INTEGER_EXT
:
854 dst
[i
] = (GLbyte
) rgba
[i
][BCOMP
];
857 case GL_ALPHA_INTEGER_EXT
:
859 dst
[i
] = (GLbyte
) rgba
[i
][ACOMP
];
864 dst
[i
*2+0] = (GLbyte
) rgba
[i
][RCOMP
];
865 dst
[i
*2+1] = (GLbyte
) rgba
[i
][GCOMP
];
868 case GL_RGB_INTEGER_EXT
:
870 dst
[i
*3+0] = (GLbyte
) rgba
[i
][RCOMP
];
871 dst
[i
*3+1] = (GLbyte
) rgba
[i
][GCOMP
];
872 dst
[i
*3+2] = (GLbyte
) rgba
[i
][BCOMP
];
875 case GL_RGBA_INTEGER_EXT
:
877 dst
[i
*4+0] = (GLbyte
) rgba
[i
][RCOMP
];
878 dst
[i
*4+1] = (GLbyte
) rgba
[i
][GCOMP
];
879 dst
[i
*4+2] = (GLbyte
) rgba
[i
][BCOMP
];
880 dst
[i
*4+3] = (GLbyte
) rgba
[i
][ACOMP
];
883 case GL_BGR_INTEGER_EXT
:
885 dst
[i
*3+0] = (GLbyte
) rgba
[i
][BCOMP
];
886 dst
[i
*3+1] = (GLbyte
) rgba
[i
][GCOMP
];
887 dst
[i
*3+2] = (GLbyte
) rgba
[i
][RCOMP
];
890 case GL_BGRA_INTEGER_EXT
:
892 dst
[i
*4+0] = (GLbyte
) rgba
[i
][BCOMP
];
893 dst
[i
*4+1] = (GLbyte
) rgba
[i
][GCOMP
];
894 dst
[i
*4+2] = (GLbyte
) rgba
[i
][RCOMP
];
895 dst
[i
*4+3] = (GLbyte
) rgba
[i
][ACOMP
];
898 case GL_LUMINANCE_INTEGER_EXT
:
900 dst
[i
*2+0] = (GLbyte
) (rgba
[i
][RCOMP
] +
903 dst
[i
*2+1] = (GLbyte
) rgba
[i
][ACOMP
];
906 case GL_LUMINANCE_ALPHA_INTEGER_EXT
:
908 dst
[i
] = (GLbyte
) (rgba
[i
][RCOMP
] +
916 dst
[i
*2+0] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
917 dst
[i
*2+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
921 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
925 case GL_UNSIGNED_SHORT
:
927 GLushort
*dst
= (GLushort
*) dstAddr
;
931 CLAMPED_FLOAT_TO_USHORT(dst
[i
], rgba
[i
][RCOMP
]);
935 CLAMPED_FLOAT_TO_USHORT(dst
[i
], rgba
[i
][GCOMP
]);
939 CLAMPED_FLOAT_TO_USHORT(dst
[i
], rgba
[i
][BCOMP
]);
943 CLAMPED_FLOAT_TO_USHORT(dst
[i
], rgba
[i
][ACOMP
]);
947 UNCLAMPED_FLOAT_TO_USHORT(dst
[i
], luminance
[i
]);
949 case GL_LUMINANCE_ALPHA
:
951 UNCLAMPED_FLOAT_TO_USHORT(dst
[i
*2+0], luminance
[i
]);
952 CLAMPED_FLOAT_TO_USHORT(dst
[i
*2+1], rgba
[i
][ACOMP
]);
957 CLAMPED_FLOAT_TO_USHORT(dst
[i
*2+0], rgba
[i
][RCOMP
]);
958 CLAMPED_FLOAT_TO_USHORT(dst
[i
*2+1], rgba
[i
][GCOMP
]);
963 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+0], rgba
[i
][RCOMP
]);
964 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+1], rgba
[i
][GCOMP
]);
965 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+2], rgba
[i
][BCOMP
]);
970 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+0], rgba
[i
][RCOMP
]);
971 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+1], rgba
[i
][GCOMP
]);
972 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+2], rgba
[i
][BCOMP
]);
973 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+3], rgba
[i
][ACOMP
]);
978 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+0], rgba
[i
][BCOMP
]);
979 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+1], rgba
[i
][GCOMP
]);
980 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+2], rgba
[i
][RCOMP
]);
985 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+0], rgba
[i
][BCOMP
]);
986 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+1], rgba
[i
][GCOMP
]);
987 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+2], rgba
[i
][RCOMP
]);
988 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+3], rgba
[i
][ACOMP
]);
993 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+0], rgba
[i
][ACOMP
]);
994 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+1], rgba
[i
][BCOMP
]);
995 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+2], rgba
[i
][GCOMP
]);
996 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+3], rgba
[i
][RCOMP
]);
999 case GL_RED_INTEGER_EXT
:
1001 dst
[i
] = (GLushort
) rgba
[i
][RCOMP
];
1004 case GL_GREEN_INTEGER_EXT
:
1006 dst
[i
] = (GLushort
) rgba
[i
][GCOMP
];
1009 case GL_BLUE_INTEGER_EXT
:
1011 dst
[i
] = (GLushort
) rgba
[i
][BCOMP
];
1014 case GL_ALPHA_INTEGER_EXT
:
1016 dst
[i
] = (GLushort
) rgba
[i
][ACOMP
];
1021 dst
[i
*2+0] = (GLushort
) rgba
[i
][RCOMP
];
1022 dst
[i
*2+1] = (GLushort
) rgba
[i
][GCOMP
];
1025 case GL_RGB_INTEGER_EXT
:
1027 dst
[i
*3+0] = (GLushort
) rgba
[i
][RCOMP
];
1028 dst
[i
*3+1] = (GLushort
) rgba
[i
][GCOMP
];
1029 dst
[i
*3+2] = (GLushort
) rgba
[i
][BCOMP
];
1032 case GL_RGBA_INTEGER_EXT
:
1034 dst
[i
*4+0] = (GLushort
) rgba
[i
][RCOMP
];
1035 dst
[i
*4+1] = (GLushort
) rgba
[i
][GCOMP
];
1036 dst
[i
*4+2] = (GLushort
) rgba
[i
][BCOMP
];
1037 dst
[i
*4+3] = (GLushort
) rgba
[i
][ACOMP
];
1040 case GL_BGR_INTEGER_EXT
:
1042 dst
[i
*3+0] = (GLushort
) rgba
[i
][BCOMP
];
1043 dst
[i
*3+1] = (GLushort
) rgba
[i
][GCOMP
];
1044 dst
[i
*3+2] = (GLushort
) rgba
[i
][RCOMP
];
1047 case GL_BGRA_INTEGER_EXT
:
1049 dst
[i
*4+0] = (GLushort
) rgba
[i
][BCOMP
];
1050 dst
[i
*4+1] = (GLushort
) rgba
[i
][GCOMP
];
1051 dst
[i
*4+2] = (GLushort
) rgba
[i
][RCOMP
];
1052 dst
[i
*4+3] = (GLushort
) rgba
[i
][ACOMP
];
1055 case GL_LUMINANCE_INTEGER_EXT
:
1057 dst
[i
*2+0] = (GLushort
) (rgba
[i
][RCOMP
] +
1060 dst
[i
*2+1] = (GLushort
) rgba
[i
][ACOMP
];
1063 case GL_LUMINANCE_ALPHA_INTEGER_EXT
:
1065 dst
[i
] = (GLushort
) (rgba
[i
][RCOMP
] +
1073 dst
[i
*2+0] = FLOAT_TO_USHORT(rgba
[i
][RCOMP
]);
1074 dst
[i
*2+1] = FLOAT_TO_USHORT(rgba
[i
][GCOMP
]);
1078 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1084 GLshort
*dst
= (GLshort
*) dstAddr
;
1085 switch (dstFormat
) {
1088 dst
[i
] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1092 dst
[i
] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1096 dst
[i
] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1100 dst
[i
] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
1104 dst
[i
] = FLOAT_TO_SHORT(luminance
[i
]);
1106 case GL_LUMINANCE_ALPHA
:
1108 dst
[i
*2+0] = FLOAT_TO_SHORT(luminance
[i
]);
1109 dst
[i
*2+1] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
1114 dst
[i
*2+0] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1115 dst
[i
*2+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1120 dst
[i
*3+0] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1121 dst
[i
*3+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1122 dst
[i
*3+2] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1127 dst
[i
*4+0] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1128 dst
[i
*4+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1129 dst
[i
*4+2] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1130 dst
[i
*4+3] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
1135 dst
[i
*3+0] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1136 dst
[i
*3+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1137 dst
[i
*3+2] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1142 dst
[i
*4+0] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1143 dst
[i
*4+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1144 dst
[i
*4+2] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1145 dst
[i
*4+3] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
1150 dst
[i
*4+0] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
1151 dst
[i
*4+1] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1152 dst
[i
*4+2] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1153 dst
[i
*4+3] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1156 case GL_RED_INTEGER_EXT
:
1158 dst
[i
] = (GLshort
) rgba
[i
][RCOMP
];
1161 case GL_GREEN_INTEGER_EXT
:
1163 dst
[i
] = (GLshort
) rgba
[i
][GCOMP
];
1166 case GL_BLUE_INTEGER_EXT
:
1168 dst
[i
] = (GLshort
) rgba
[i
][BCOMP
];
1171 case GL_ALPHA_INTEGER_EXT
:
1173 dst
[i
] = (GLshort
) rgba
[i
][ACOMP
];
1178 dst
[i
*2+0] = (GLshort
) rgba
[i
][RCOMP
];
1179 dst
[i
*2+1] = (GLshort
) rgba
[i
][GCOMP
];
1182 case GL_RGB_INTEGER_EXT
:
1184 dst
[i
*3+0] = (GLshort
) rgba
[i
][RCOMP
];
1185 dst
[i
*3+1] = (GLshort
) rgba
[i
][GCOMP
];
1186 dst
[i
*3+2] = (GLshort
) rgba
[i
][BCOMP
];
1189 case GL_RGBA_INTEGER_EXT
:
1191 dst
[i
*4+0] = (GLshort
) rgba
[i
][RCOMP
];
1192 dst
[i
*4+1] = (GLshort
) rgba
[i
][GCOMP
];
1193 dst
[i
*4+2] = (GLshort
) rgba
[i
][BCOMP
];
1194 dst
[i
*4+3] = (GLshort
) rgba
[i
][ACOMP
];
1197 case GL_BGR_INTEGER_EXT
:
1199 dst
[i
*3+0] = (GLshort
) rgba
[i
][BCOMP
];
1200 dst
[i
*3+1] = (GLshort
) rgba
[i
][GCOMP
];
1201 dst
[i
*3+2] = (GLshort
) rgba
[i
][RCOMP
];
1204 case GL_BGRA_INTEGER_EXT
:
1206 dst
[i
*4+0] = (GLshort
) rgba
[i
][BCOMP
];
1207 dst
[i
*4+1] = (GLshort
) rgba
[i
][GCOMP
];
1208 dst
[i
*4+2] = (GLshort
) rgba
[i
][RCOMP
];
1209 dst
[i
*4+3] = (GLshort
) rgba
[i
][ACOMP
];
1212 case GL_LUMINANCE_INTEGER_EXT
:
1214 dst
[i
*2+0] = (GLshort
) (rgba
[i
][RCOMP
] +
1217 dst
[i
*2+1] = (GLshort
) rgba
[i
][ACOMP
];
1220 case GL_LUMINANCE_ALPHA_INTEGER_EXT
:
1222 dst
[i
] = (GLshort
) (rgba
[i
][RCOMP
] +
1230 dst
[i
*2+0] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1231 dst
[i
*2+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1235 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1239 case GL_UNSIGNED_INT
:
1241 GLuint
*dst
= (GLuint
*) dstAddr
;
1242 switch (dstFormat
) {
1245 dst
[i
] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1249 dst
[i
] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1253 dst
[i
] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1257 dst
[i
] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
1261 dst
[i
] = FLOAT_TO_UINT(luminance
[i
]);
1263 case GL_LUMINANCE_ALPHA
:
1265 dst
[i
*2+0] = FLOAT_TO_UINT(luminance
[i
]);
1266 dst
[i
*2+1] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
1271 dst
[i
*2+0] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1272 dst
[i
*2+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1277 dst
[i
*3+0] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1278 dst
[i
*3+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1279 dst
[i
*3+2] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1284 dst
[i
*4+0] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1285 dst
[i
*4+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1286 dst
[i
*4+2] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1287 dst
[i
*4+3] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
1292 dst
[i
*3+0] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1293 dst
[i
*3+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1294 dst
[i
*3+2] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1299 dst
[i
*4+0] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1300 dst
[i
*4+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1301 dst
[i
*4+2] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1302 dst
[i
*4+3] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
1307 dst
[i
*4+0] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
1308 dst
[i
*4+1] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1309 dst
[i
*4+2] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1310 dst
[i
*4+3] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1313 case GL_RED_INTEGER_EXT
:
1315 dst
[i
] = (GLuint
) rgba
[i
][RCOMP
];
1318 case GL_GREEN_INTEGER_EXT
:
1320 dst
[i
] = (GLuint
) rgba
[i
][GCOMP
];
1323 case GL_BLUE_INTEGER_EXT
:
1325 dst
[i
] = (GLuint
) rgba
[i
][BCOMP
];
1328 case GL_ALPHA_INTEGER_EXT
:
1330 dst
[i
] = (GLuint
) rgba
[i
][ACOMP
];
1335 dst
[i
*2+0] = (GLuint
) rgba
[i
][RCOMP
];
1336 dst
[i
*2+1] = (GLuint
) rgba
[i
][GCOMP
];
1339 case GL_RGB_INTEGER_EXT
:
1341 dst
[i
*3+0] = (GLuint
) rgba
[i
][RCOMP
];
1342 dst
[i
*3+1] = (GLuint
) rgba
[i
][GCOMP
];
1343 dst
[i
*3+2] = (GLuint
) rgba
[i
][BCOMP
];
1346 case GL_RGBA_INTEGER_EXT
:
1348 dst
[i
*4+0] = (GLuint
) rgba
[i
][RCOMP
];
1349 dst
[i
*4+1] = (GLuint
) rgba
[i
][GCOMP
];
1350 dst
[i
*4+2] = (GLuint
) rgba
[i
][BCOMP
];
1351 dst
[i
*4+3] = (GLuint
) rgba
[i
][ACOMP
];
1354 case GL_BGR_INTEGER_EXT
:
1356 dst
[i
*3+0] = (GLuint
) rgba
[i
][BCOMP
];
1357 dst
[i
*3+1] = (GLuint
) rgba
[i
][GCOMP
];
1358 dst
[i
*3+2] = (GLuint
) rgba
[i
][RCOMP
];
1361 case GL_BGRA_INTEGER_EXT
:
1363 dst
[i
*4+0] = (GLuint
) rgba
[i
][BCOMP
];
1364 dst
[i
*4+1] = (GLuint
) rgba
[i
][GCOMP
];
1365 dst
[i
*4+2] = (GLuint
) rgba
[i
][RCOMP
];
1366 dst
[i
*4+3] = (GLuint
) rgba
[i
][ACOMP
];
1369 case GL_LUMINANCE_INTEGER_EXT
:
1371 dst
[i
*2+0] = (GLuint
) (rgba
[i
][RCOMP
] +
1374 dst
[i
*2+1] = (GLuint
) rgba
[i
][ACOMP
];
1377 case GL_LUMINANCE_ALPHA_INTEGER_EXT
:
1379 dst
[i
] = (GLuint
) (rgba
[i
][RCOMP
] +
1387 dst
[i
*2+0] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1388 dst
[i
*2+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1392 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1398 GLint
*dst
= (GLint
*) dstAddr
;
1399 switch (dstFormat
) {
1402 dst
[i
] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1406 dst
[i
] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1410 dst
[i
] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1414 dst
[i
] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
1418 dst
[i
] = FLOAT_TO_INT(luminance
[i
]);
1420 case GL_LUMINANCE_ALPHA
:
1422 dst
[i
*2+0] = FLOAT_TO_INT(luminance
[i
]);
1423 dst
[i
*2+1] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
1428 dst
[i
*2+0] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1429 dst
[i
*2+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1434 dst
[i
*3+0] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1435 dst
[i
*3+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1436 dst
[i
*3+2] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1441 dst
[i
*4+0] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1442 dst
[i
*4+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1443 dst
[i
*4+2] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1444 dst
[i
*4+3] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
1449 dst
[i
*3+0] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1450 dst
[i
*3+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1451 dst
[i
*3+2] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1456 dst
[i
*4+0] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1457 dst
[i
*4+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1458 dst
[i
*4+2] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1459 dst
[i
*4+3] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
1464 dst
[i
*4+0] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
1465 dst
[i
*4+1] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1466 dst
[i
*4+2] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1467 dst
[i
*4+3] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1473 dst
[i
*2+0] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1474 dst
[i
*2+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1477 case GL_RED_INTEGER_EXT
:
1479 dst
[i
] = (GLint
) rgba
[i
][RCOMP
];
1482 case GL_GREEN_INTEGER_EXT
:
1484 dst
[i
] = (GLint
) rgba
[i
][GCOMP
];
1487 case GL_BLUE_INTEGER_EXT
:
1489 dst
[i
] = (GLint
) rgba
[i
][BCOMP
];
1492 case GL_ALPHA_INTEGER_EXT
:
1494 dst
[i
] = (GLint
) rgba
[i
][ACOMP
];
1499 dst
[i
*2+0] = (GLint
) rgba
[i
][RCOMP
];
1500 dst
[i
*2+1] = (GLint
) rgba
[i
][GCOMP
];
1503 case GL_RGB_INTEGER_EXT
:
1505 dst
[i
*3+0] = (GLint
) rgba
[i
][RCOMP
];
1506 dst
[i
*3+1] = (GLint
) rgba
[i
][GCOMP
];
1507 dst
[i
*3+2] = (GLint
) rgba
[i
][BCOMP
];
1510 case GL_RGBA_INTEGER_EXT
:
1512 dst
[i
*4+0] = (GLint
) rgba
[i
][RCOMP
];
1513 dst
[i
*4+1] = (GLint
) rgba
[i
][GCOMP
];
1514 dst
[i
*4+2] = (GLint
) rgba
[i
][BCOMP
];
1515 dst
[i
*4+3] = (GLint
) rgba
[i
][ACOMP
];
1518 case GL_BGR_INTEGER_EXT
:
1520 dst
[i
*3+0] = (GLint
) rgba
[i
][BCOMP
];
1521 dst
[i
*3+1] = (GLint
) rgba
[i
][GCOMP
];
1522 dst
[i
*3+2] = (GLint
) rgba
[i
][RCOMP
];
1525 case GL_BGRA_INTEGER_EXT
:
1527 dst
[i
*4+0] = (GLint
) rgba
[i
][BCOMP
];
1528 dst
[i
*4+1] = (GLint
) rgba
[i
][GCOMP
];
1529 dst
[i
*4+2] = (GLint
) rgba
[i
][RCOMP
];
1530 dst
[i
*4+3] = (GLint
) rgba
[i
][ACOMP
];
1533 case GL_LUMINANCE_INTEGER_EXT
:
1535 dst
[i
*2+0] = (GLint
) (rgba
[i
][RCOMP
] +
1538 dst
[i
*2+1] = (GLint
) rgba
[i
][ACOMP
];
1541 case GL_LUMINANCE_ALPHA_INTEGER_EXT
:
1543 dst
[i
] = (GLint
) (rgba
[i
][RCOMP
] +
1549 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1555 GLfloat
*dst
= (GLfloat
*) dstAddr
;
1556 switch (dstFormat
) {
1559 dst
[i
] = rgba
[i
][RCOMP
];
1563 dst
[i
] = rgba
[i
][GCOMP
];
1567 dst
[i
] = rgba
[i
][BCOMP
];
1571 dst
[i
] = rgba
[i
][ACOMP
];
1575 dst
[i
] = luminance
[i
];
1577 case GL_LUMINANCE_ALPHA
:
1579 dst
[i
*2+0] = luminance
[i
];
1580 dst
[i
*2+1] = rgba
[i
][ACOMP
];
1585 dst
[i
*2+0] = rgba
[i
][RCOMP
];
1586 dst
[i
*2+1] = rgba
[i
][GCOMP
];
1591 dst
[i
*3+0] = rgba
[i
][RCOMP
];
1592 dst
[i
*3+1] = rgba
[i
][GCOMP
];
1593 dst
[i
*3+2] = rgba
[i
][BCOMP
];
1598 dst
[i
*4+0] = rgba
[i
][RCOMP
];
1599 dst
[i
*4+1] = rgba
[i
][GCOMP
];
1600 dst
[i
*4+2] = rgba
[i
][BCOMP
];
1601 dst
[i
*4+3] = rgba
[i
][ACOMP
];
1606 dst
[i
*3+0] = rgba
[i
][BCOMP
];
1607 dst
[i
*3+1] = rgba
[i
][GCOMP
];
1608 dst
[i
*3+2] = rgba
[i
][RCOMP
];
1613 dst
[i
*4+0] = rgba
[i
][BCOMP
];
1614 dst
[i
*4+1] = rgba
[i
][GCOMP
];
1615 dst
[i
*4+2] = rgba
[i
][RCOMP
];
1616 dst
[i
*4+3] = rgba
[i
][ACOMP
];
1621 dst
[i
*4+0] = rgba
[i
][ACOMP
];
1622 dst
[i
*4+1] = rgba
[i
][BCOMP
];
1623 dst
[i
*4+2] = rgba
[i
][GCOMP
];
1624 dst
[i
*4+3] = rgba
[i
][RCOMP
];
1630 dst
[i
*2+0] = rgba
[i
][RCOMP
];
1631 dst
[i
*2+1] = rgba
[i
][GCOMP
];
1635 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1639 case GL_HALF_FLOAT_ARB
:
1641 GLhalfARB
*dst
= (GLhalfARB
*) dstAddr
;
1642 switch (dstFormat
) {
1645 dst
[i
] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1649 dst
[i
] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1653 dst
[i
] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1657 dst
[i
] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
1661 dst
[i
] = _mesa_float_to_half(luminance
[i
]);
1663 case GL_LUMINANCE_ALPHA
:
1665 dst
[i
*2+0] = _mesa_float_to_half(luminance
[i
]);
1666 dst
[i
*2+1] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
1671 dst
[i
*2+0] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1672 dst
[i
*2+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1677 dst
[i
*3+0] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1678 dst
[i
*3+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1679 dst
[i
*3+2] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1684 dst
[i
*4+0] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1685 dst
[i
*4+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1686 dst
[i
*4+2] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1687 dst
[i
*4+3] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
1692 dst
[i
*3+0] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1693 dst
[i
*3+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1694 dst
[i
*3+2] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1699 dst
[i
*4+0] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1700 dst
[i
*4+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1701 dst
[i
*4+2] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1702 dst
[i
*4+3] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
1707 dst
[i
*4+0] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
1708 dst
[i
*4+1] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1709 dst
[i
*4+2] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1710 dst
[i
*4+3] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1716 dst
[i
*2+0] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1717 dst
[i
*2+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1721 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1725 case GL_UNSIGNED_BYTE_3_3_2
:
1726 if (dstFormat
== GL_RGB
) {
1727 GLubyte
*dst
= (GLubyte
*) dstAddr
;
1729 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 7.0F
) << 5)
1730 | (IROUND(rgba
[i
][GCOMP
] * 7.0F
) << 2)
1731 | (IROUND(rgba
[i
][BCOMP
] * 3.0F
) );
1735 case GL_UNSIGNED_BYTE_2_3_3_REV
:
1736 if (dstFormat
== GL_RGB
) {
1737 GLubyte
*dst
= (GLubyte
*) dstAddr
;
1739 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 7.0F
) )
1740 | (IROUND(rgba
[i
][GCOMP
] * 7.0F
) << 3)
1741 | (IROUND(rgba
[i
][BCOMP
] * 3.0F
) << 6);
1745 case GL_UNSIGNED_SHORT_5_6_5
:
1746 if (dstFormat
== GL_RGB
) {
1747 GLushort
*dst
= (GLushort
*) dstAddr
;
1749 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 31.0F
) << 11)
1750 | (IROUND(rgba
[i
][GCOMP
] * 63.0F
) << 5)
1751 | (IROUND(rgba
[i
][BCOMP
] * 31.0F
) );
1755 case GL_UNSIGNED_SHORT_5_6_5_REV
:
1756 if (dstFormat
== GL_RGB
) {
1757 GLushort
*dst
= (GLushort
*) dstAddr
;
1759 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 31.0F
) )
1760 | (IROUND(rgba
[i
][GCOMP
] * 63.0F
) << 5)
1761 | (IROUND(rgba
[i
][BCOMP
] * 31.0F
) << 11);
1765 case GL_UNSIGNED_SHORT_4_4_4_4
:
1766 if (dstFormat
== GL_RGBA
) {
1767 GLushort
*dst
= (GLushort
*) dstAddr
;
1769 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 15.0F
) << 12)
1770 | (IROUND(rgba
[i
][GCOMP
] * 15.0F
) << 8)
1771 | (IROUND(rgba
[i
][BCOMP
] * 15.0F
) << 4)
1772 | (IROUND(rgba
[i
][ACOMP
] * 15.0F
) );
1775 else if (dstFormat
== GL_BGRA
) {
1776 GLushort
*dst
= (GLushort
*) dstAddr
;
1778 dst
[i
] = (IROUND(rgba
[i
][BCOMP
] * 15.0F
) << 12)
1779 | (IROUND(rgba
[i
][GCOMP
] * 15.0F
) << 8)
1780 | (IROUND(rgba
[i
][RCOMP
] * 15.0F
) << 4)
1781 | (IROUND(rgba
[i
][ACOMP
] * 15.0F
) );
1784 else if (dstFormat
== GL_ABGR_EXT
) {
1785 GLushort
*dst
= (GLushort
*) dstAddr
;
1787 dst
[i
] = (IROUND(rgba
[i
][ACOMP
] * 15.0F
) << 12)
1788 | (IROUND(rgba
[i
][BCOMP
] * 15.0F
) << 8)
1789 | (IROUND(rgba
[i
][GCOMP
] * 15.0F
) << 4)
1790 | (IROUND(rgba
[i
][RCOMP
] * 15.0F
) );
1794 case GL_UNSIGNED_SHORT_4_4_4_4_REV
:
1795 if (dstFormat
== GL_RGBA
) {
1796 GLushort
*dst
= (GLushort
*) dstAddr
;
1798 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 15.0F
) )
1799 | (IROUND(rgba
[i
][GCOMP
] * 15.0F
) << 4)
1800 | (IROUND(rgba
[i
][BCOMP
] * 15.0F
) << 8)
1801 | (IROUND(rgba
[i
][ACOMP
] * 15.0F
) << 12);
1804 else if (dstFormat
== GL_BGRA
) {
1805 GLushort
*dst
= (GLushort
*) dstAddr
;
1807 dst
[i
] = (IROUND(rgba
[i
][BCOMP
] * 15.0F
) )
1808 | (IROUND(rgba
[i
][GCOMP
] * 15.0F
) << 4)
1809 | (IROUND(rgba
[i
][RCOMP
] * 15.0F
) << 8)
1810 | (IROUND(rgba
[i
][ACOMP
] * 15.0F
) << 12);
1813 else if (dstFormat
== GL_ABGR_EXT
) {
1814 GLushort
*dst
= (GLushort
*) dstAddr
;
1816 dst
[i
] = (IROUND(rgba
[i
][ACOMP
] * 15.0F
) )
1817 | (IROUND(rgba
[i
][BCOMP
] * 15.0F
) << 4)
1818 | (IROUND(rgba
[i
][GCOMP
] * 15.0F
) << 8)
1819 | (IROUND(rgba
[i
][RCOMP
] * 15.0F
) << 12);
1823 case GL_UNSIGNED_SHORT_5_5_5_1
:
1824 if (dstFormat
== GL_RGBA
) {
1825 GLushort
*dst
= (GLushort
*) dstAddr
;
1827 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 31.0F
) << 11)
1828 | (IROUND(rgba
[i
][GCOMP
] * 31.0F
) << 6)
1829 | (IROUND(rgba
[i
][BCOMP
] * 31.0F
) << 1)
1830 | (IROUND(rgba
[i
][ACOMP
] * 1.0F
) );
1833 else if (dstFormat
== GL_BGRA
) {
1834 GLushort
*dst
= (GLushort
*) dstAddr
;
1836 dst
[i
] = (IROUND(rgba
[i
][BCOMP
] * 31.0F
) << 11)
1837 | (IROUND(rgba
[i
][GCOMP
] * 31.0F
) << 6)
1838 | (IROUND(rgba
[i
][RCOMP
] * 31.0F
) << 1)
1839 | (IROUND(rgba
[i
][ACOMP
] * 1.0F
) );
1842 else if (dstFormat
== GL_ABGR_EXT
) {
1843 GLushort
*dst
= (GLushort
*) dstAddr
;
1845 dst
[i
] = (IROUND(rgba
[i
][ACOMP
] * 31.0F
) << 11)
1846 | (IROUND(rgba
[i
][BCOMP
] * 31.0F
) << 6)
1847 | (IROUND(rgba
[i
][GCOMP
] * 31.0F
) << 1)
1848 | (IROUND(rgba
[i
][RCOMP
] * 1.0F
) );
1852 case GL_UNSIGNED_SHORT_1_5_5_5_REV
:
1853 if (dstFormat
== GL_RGBA
) {
1854 GLushort
*dst
= (GLushort
*) dstAddr
;
1856 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 31.0F
) )
1857 | (IROUND(rgba
[i
][GCOMP
] * 31.0F
) << 5)
1858 | (IROUND(rgba
[i
][BCOMP
] * 31.0F
) << 10)
1859 | (IROUND(rgba
[i
][ACOMP
] * 1.0F
) << 15);
1862 else if (dstFormat
== GL_BGRA
) {
1863 GLushort
*dst
= (GLushort
*) dstAddr
;
1865 dst
[i
] = (IROUND(rgba
[i
][BCOMP
] * 31.0F
) )
1866 | (IROUND(rgba
[i
][GCOMP
] * 31.0F
) << 5)
1867 | (IROUND(rgba
[i
][RCOMP
] * 31.0F
) << 10)
1868 | (IROUND(rgba
[i
][ACOMP
] * 1.0F
) << 15);
1871 else if (dstFormat
== GL_ABGR_EXT
) {
1872 GLushort
*dst
= (GLushort
*) dstAddr
;
1874 dst
[i
] = (IROUND(rgba
[i
][ACOMP
] * 31.0F
) )
1875 | (IROUND(rgba
[i
][BCOMP
] * 31.0F
) << 5)
1876 | (IROUND(rgba
[i
][GCOMP
] * 31.0F
) << 10)
1877 | (IROUND(rgba
[i
][RCOMP
] * 1.0F
) << 15);
1881 case GL_UNSIGNED_INT_8_8_8_8
:
1882 if (dstFormat
== GL_RGBA
) {
1883 GLuint
*dst
= (GLuint
*) dstAddr
;
1885 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 255.F
) << 24)
1886 | (IROUND(rgba
[i
][GCOMP
] * 255.F
) << 16)
1887 | (IROUND(rgba
[i
][BCOMP
] * 255.F
) << 8)
1888 | (IROUND(rgba
[i
][ACOMP
] * 255.F
) );
1891 else if (dstFormat
== GL_BGRA
) {
1892 GLuint
*dst
= (GLuint
*) dstAddr
;
1894 dst
[i
] = (IROUND(rgba
[i
][BCOMP
] * 255.F
) << 24)
1895 | (IROUND(rgba
[i
][GCOMP
] * 255.F
) << 16)
1896 | (IROUND(rgba
[i
][RCOMP
] * 255.F
) << 8)
1897 | (IROUND(rgba
[i
][ACOMP
] * 255.F
) );
1900 else if (dstFormat
== GL_ABGR_EXT
) {
1901 GLuint
*dst
= (GLuint
*) dstAddr
;
1903 dst
[i
] = (IROUND(rgba
[i
][ACOMP
] * 255.F
) << 24)
1904 | (IROUND(rgba
[i
][BCOMP
] * 255.F
) << 16)
1905 | (IROUND(rgba
[i
][GCOMP
] * 255.F
) << 8)
1906 | (IROUND(rgba
[i
][RCOMP
] * 255.F
) );
1910 case GL_UNSIGNED_INT_8_8_8_8_REV
:
1911 if (dstFormat
== GL_RGBA
) {
1912 GLuint
*dst
= (GLuint
*) dstAddr
;
1914 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 255.0F
) )
1915 | (IROUND(rgba
[i
][GCOMP
] * 255.0F
) << 8)
1916 | (IROUND(rgba
[i
][BCOMP
] * 255.0F
) << 16)
1917 | (IROUND(rgba
[i
][ACOMP
] * 255.0F
) << 24);
1920 else if (dstFormat
== GL_BGRA
) {
1921 GLuint
*dst
= (GLuint
*) dstAddr
;
1923 dst
[i
] = (IROUND(rgba
[i
][BCOMP
] * 255.0F
) )
1924 | (IROUND(rgba
[i
][GCOMP
] * 255.0F
) << 8)
1925 | (IROUND(rgba
[i
][RCOMP
] * 255.0F
) << 16)
1926 | (IROUND(rgba
[i
][ACOMP
] * 255.0F
) << 24);
1929 else if (dstFormat
== GL_ABGR_EXT
) {
1930 GLuint
*dst
= (GLuint
*) dstAddr
;
1932 dst
[i
] = (IROUND(rgba
[i
][ACOMP
] * 255.0F
) )
1933 | (IROUND(rgba
[i
][BCOMP
] * 255.0F
) << 8)
1934 | (IROUND(rgba
[i
][GCOMP
] * 255.0F
) << 16)
1935 | (IROUND(rgba
[i
][RCOMP
] * 255.0F
) << 24);
1939 case GL_UNSIGNED_INT_10_10_10_2
:
1940 if (dstFormat
== GL_RGBA
) {
1941 GLuint
*dst
= (GLuint
*) dstAddr
;
1943 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 1023.0F
) << 22)
1944 | (IROUND(rgba
[i
][GCOMP
] * 1023.0F
) << 12)
1945 | (IROUND(rgba
[i
][BCOMP
] * 1023.0F
) << 2)
1946 | (IROUND(rgba
[i
][ACOMP
] * 3.0F
) );
1949 else if (dstFormat
== GL_BGRA
) {
1950 GLuint
*dst
= (GLuint
*) dstAddr
;
1952 dst
[i
] = (IROUND(rgba
[i
][BCOMP
] * 1023.0F
) << 22)
1953 | (IROUND(rgba
[i
][GCOMP
] * 1023.0F
) << 12)
1954 | (IROUND(rgba
[i
][RCOMP
] * 1023.0F
) << 2)
1955 | (IROUND(rgba
[i
][ACOMP
] * 3.0F
) );
1958 else if (dstFormat
== GL_ABGR_EXT
) {
1959 GLuint
*dst
= (GLuint
*) dstAddr
;
1961 dst
[i
] = (IROUND(rgba
[i
][ACOMP
] * 1023.0F
) << 22)
1962 | (IROUND(rgba
[i
][BCOMP
] * 1023.0F
) << 12)
1963 | (IROUND(rgba
[i
][GCOMP
] * 1023.0F
) << 2)
1964 | (IROUND(rgba
[i
][RCOMP
] * 3.0F
) );
1968 case GL_UNSIGNED_INT_2_10_10_10_REV
:
1969 if (dstFormat
== GL_RGBA
) {
1970 GLuint
*dst
= (GLuint
*) dstAddr
;
1972 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 1023.0F
) )
1973 | (IROUND(rgba
[i
][GCOMP
] * 1023.0F
) << 10)
1974 | (IROUND(rgba
[i
][BCOMP
] * 1023.0F
) << 20)
1975 | (IROUND(rgba
[i
][ACOMP
] * 3.0F
) << 30);
1978 else if (dstFormat
== GL_BGRA
) {
1979 GLuint
*dst
= (GLuint
*) dstAddr
;
1981 dst
[i
] = (IROUND(rgba
[i
][BCOMP
] * 1023.0F
) )
1982 | (IROUND(rgba
[i
][GCOMP
] * 1023.0F
) << 10)
1983 | (IROUND(rgba
[i
][RCOMP
] * 1023.0F
) << 20)
1984 | (IROUND(rgba
[i
][ACOMP
] * 3.0F
) << 30);
1987 else if (dstFormat
== GL_ABGR_EXT
) {
1988 GLuint
*dst
= (GLuint
*) dstAddr
;
1990 dst
[i
] = (IROUND(rgba
[i
][ACOMP
] * 1023.0F
) )
1991 | (IROUND(rgba
[i
][BCOMP
] * 1023.0F
) << 10)
1992 | (IROUND(rgba
[i
][GCOMP
] * 1023.0F
) << 20)
1993 | (IROUND(rgba
[i
][RCOMP
] * 3.0F
) << 30);
1997 case GL_UNSIGNED_INT_5_9_9_9_REV
:
1999 GLuint
*dst
= (GLuint
*) dstAddr
;
2000 for (i
= 0; i
< n
; i
++) {
2001 dst
[i
] = float3_to_rgb9e5(rgba
[i
]);
2005 case GL_UNSIGNED_INT_10F_11F_11F_REV
:
2007 GLuint
*dst
= (GLuint
*) dstAddr
;
2008 for (i
= 0; i
< n
; i
++) {
2009 dst
[i
] = float3_to_r11g11b10f(rgba
[i
]);
2014 _mesa_problem(ctx
, "bad type in _mesa_pack_rgba_span_float");
2019 if (dstPacking
->SwapBytes
) {
2020 GLint swapSize
= _mesa_sizeof_packed_type(dstType
);
2021 if (swapSize
== 2) {
2022 _mesa_swap2((GLushort
*) dstAddr
, n
* comps
);
2024 else if (swapSize
== 4) {
2025 _mesa_swap4((GLuint
*) dstAddr
, n
* comps
);
2034 #define SWAP2BYTE(VALUE) \
2036 GLubyte *bytes = (GLubyte *) &(VALUE); \
2037 GLubyte tmp = bytes[0]; \
2038 bytes[0] = bytes[1]; \
2042 #define SWAP4BYTE(VALUE) \
2044 GLubyte *bytes = (GLubyte *) &(VALUE); \
2045 GLubyte tmp = bytes[0]; \
2046 bytes[0] = bytes[3]; \
2049 bytes[1] = bytes[2]; \
2055 extract_uint_indexes(GLuint n
, GLuint indexes
[],
2056 GLenum srcFormat
, GLenum srcType
, const GLvoid
*src
,
2057 const struct gl_pixelstore_attrib
*unpack
)
2059 ASSERT(srcFormat
== GL_COLOR_INDEX
|| srcFormat
== GL_STENCIL_INDEX
);
2061 ASSERT(srcType
== GL_BITMAP
||
2062 srcType
== GL_UNSIGNED_BYTE
||
2063 srcType
== GL_BYTE
||
2064 srcType
== GL_UNSIGNED_SHORT
||
2065 srcType
== GL_SHORT
||
2066 srcType
== GL_UNSIGNED_INT
||
2067 srcType
== GL_INT
||
2068 srcType
== GL_UNSIGNED_INT_24_8_EXT
||
2069 srcType
== GL_HALF_FLOAT_ARB
||
2070 srcType
== GL_FLOAT
||
2071 srcType
== GL_FLOAT_32_UNSIGNED_INT_24_8_REV
);
2076 GLubyte
*ubsrc
= (GLubyte
*) src
;
2077 if (unpack
->LsbFirst
) {
2078 GLubyte mask
= 1 << (unpack
->SkipPixels
& 0x7);
2080 for (i
= 0; i
< n
; i
++) {
2081 indexes
[i
] = (*ubsrc
& mask
) ? 1 : 0;
2092 GLubyte mask
= 128 >> (unpack
->SkipPixels
& 0x7);
2094 for (i
= 0; i
< n
; i
++) {
2095 indexes
[i
] = (*ubsrc
& mask
) ? 1 : 0;
2107 case GL_UNSIGNED_BYTE
:
2110 const GLubyte
*s
= (const GLubyte
*) src
;
2111 for (i
= 0; i
< n
; i
++)
2118 const GLbyte
*s
= (const GLbyte
*) src
;
2119 for (i
= 0; i
< n
; i
++)
2123 case GL_UNSIGNED_SHORT
:
2126 const GLushort
*s
= (const GLushort
*) src
;
2127 if (unpack
->SwapBytes
) {
2128 for (i
= 0; i
< n
; i
++) {
2129 GLushort value
= s
[i
];
2135 for (i
= 0; i
< n
; i
++)
2143 const GLshort
*s
= (const GLshort
*) src
;
2144 if (unpack
->SwapBytes
) {
2145 for (i
= 0; i
< n
; i
++) {
2146 GLshort value
= s
[i
];
2152 for (i
= 0; i
< n
; i
++)
2157 case GL_UNSIGNED_INT
:
2160 const GLuint
*s
= (const GLuint
*) src
;
2161 if (unpack
->SwapBytes
) {
2162 for (i
= 0; i
< n
; i
++) {
2163 GLuint value
= s
[i
];
2169 for (i
= 0; i
< n
; i
++)
2177 const GLint
*s
= (const GLint
*) src
;
2178 if (unpack
->SwapBytes
) {
2179 for (i
= 0; i
< n
; i
++) {
2186 for (i
= 0; i
< n
; i
++)
2194 const GLfloat
*s
= (const GLfloat
*) src
;
2195 if (unpack
->SwapBytes
) {
2196 for (i
= 0; i
< n
; i
++) {
2197 GLfloat value
= s
[i
];
2199 indexes
[i
] = (GLuint
) value
;
2203 for (i
= 0; i
< n
; i
++)
2204 indexes
[i
] = (GLuint
) s
[i
];
2208 case GL_HALF_FLOAT_ARB
:
2211 const GLhalfARB
*s
= (const GLhalfARB
*) src
;
2212 if (unpack
->SwapBytes
) {
2213 for (i
= 0; i
< n
; i
++) {
2214 GLhalfARB value
= s
[i
];
2216 indexes
[i
] = (GLuint
) _mesa_half_to_float(value
);
2220 for (i
= 0; i
< n
; i
++)
2221 indexes
[i
] = (GLuint
) _mesa_half_to_float(s
[i
]);
2225 case GL_UNSIGNED_INT_24_8_EXT
:
2228 const GLuint
*s
= (const GLuint
*) src
;
2229 if (unpack
->SwapBytes
) {
2230 for (i
= 0; i
< n
; i
++) {
2231 GLuint value
= s
[i
];
2233 indexes
[i
] = value
& 0xff; /* lower 8 bits */
2237 for (i
= 0; i
< n
; i
++)
2238 indexes
[i
] = s
[i
] & 0xff; /* lower 8 bits */
2242 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV
:
2245 const GLuint
*s
= (const GLuint
*) src
;
2246 if (unpack
->SwapBytes
) {
2247 for (i
= 0; i
< n
; i
++) {
2248 GLuint value
= s
[i
*2+1];
2250 indexes
[i
] = value
& 0xff; /* lower 8 bits */
2254 for (i
= 0; i
< n
; i
++)
2255 indexes
[i
] = s
[i
*2+1] & 0xff; /* lower 8 bits */
2261 _mesa_problem(NULL
, "bad srcType in extract_uint_indexes");
2268 * Return source/dest RGBA indexes for unpacking pixels.
2271 get_component_mapping(GLenum format
,
2283 case GL_RED_INTEGER_EXT
:
2285 *gSrc
= *bSrc
= *aSrc
= -1;
2288 case GL_GREEN_INTEGER_EXT
:
2290 *rSrc
= *bSrc
= *aSrc
= -1;
2293 case GL_BLUE_INTEGER_EXT
:
2295 *rSrc
= *gSrc
= *aSrc
= -1;
2298 case GL_ALPHA_INTEGER_EXT
:
2299 *rSrc
= *gSrc
= *bSrc
= -1;
2303 case GL_LUMINANCE_INTEGER_EXT
:
2304 *rSrc
= *gSrc
= *bSrc
= 0;
2307 case GL_LUMINANCE_ALPHA
:
2308 case GL_LUMINANCE_ALPHA_INTEGER_EXT
:
2309 *rSrc
= *gSrc
= *bSrc
= 0;
2313 *rSrc
= *gSrc
= *bSrc
= *aSrc
= 0;
2327 case GL_RGB_INTEGER
:
2338 case GL_BGR_INTEGER
:
2349 case GL_RGBA_INTEGER
:
2360 case GL_BGRA_INTEGER
:
2388 _mesa_problem(NULL
, "bad srcFormat %s in get_component_mapping",
2389 _mesa_lookup_enum_by_nr(format
));
2397 * This function extracts floating point RGBA values from arbitrary
2398 * image data. srcFormat and srcType are the format and type parameters
2399 * passed to glDrawPixels, glTexImage[123]D, glTexSubImage[123]D, etc.
2401 * Refering to section 3.6.4 of the OpenGL 1.2 spec, this function
2402 * implements the "Conversion to floating point", "Conversion to RGB",
2403 * and "Final Expansion to RGBA" operations.
2405 * Args: n - number of pixels
2406 * rgba - output colors
2407 * srcFormat - format of incoming data
2408 * srcType - data type of incoming data
2409 * src - source data pointer
2410 * swapBytes - perform byteswapping of incoming data?
2413 extract_float_rgba(GLuint n
, GLfloat rgba
[][4],
2414 GLenum srcFormat
, GLenum srcType
, const GLvoid
*src
,
2415 GLboolean swapBytes
)
2417 GLint rSrc
, gSrc
, bSrc
, aSrc
;
2419 GLint rDst
, bDst
, gDst
, aDst
;
2420 GLboolean intFormat
;
2421 GLfloat rs
= 1.0f
, gs
= 1.0f
, bs
= 1.0f
, as
= 1.0f
; /* scale factors */
2423 ASSERT(srcFormat
== GL_RED
||
2424 srcFormat
== GL_GREEN
||
2425 srcFormat
== GL_BLUE
||
2426 srcFormat
== GL_ALPHA
||
2427 srcFormat
== GL_LUMINANCE
||
2428 srcFormat
== GL_LUMINANCE_ALPHA
||
2429 srcFormat
== GL_INTENSITY
||
2430 srcFormat
== GL_RG
||
2431 srcFormat
== GL_RGB
||
2432 srcFormat
== GL_BGR
||
2433 srcFormat
== GL_RGBA
||
2434 srcFormat
== GL_BGRA
||
2435 srcFormat
== GL_ABGR_EXT
||
2436 srcFormat
== GL_DU8DV8_ATI
||
2437 srcFormat
== GL_DUDV_ATI
||
2438 srcFormat
== GL_RED_INTEGER_EXT
||
2439 srcFormat
== GL_GREEN_INTEGER_EXT
||
2440 srcFormat
== GL_BLUE_INTEGER_EXT
||
2441 srcFormat
== GL_ALPHA_INTEGER_EXT
||
2442 srcFormat
== GL_RG_INTEGER
||
2443 srcFormat
== GL_RGB_INTEGER_EXT
||
2444 srcFormat
== GL_RGBA_INTEGER_EXT
||
2445 srcFormat
== GL_BGR_INTEGER_EXT
||
2446 srcFormat
== GL_BGRA_INTEGER_EXT
||
2447 srcFormat
== GL_LUMINANCE_INTEGER_EXT
||
2448 srcFormat
== GL_LUMINANCE_ALPHA_INTEGER_EXT
);
2450 ASSERT(srcType
== GL_UNSIGNED_BYTE
||
2451 srcType
== GL_BYTE
||
2452 srcType
== GL_UNSIGNED_SHORT
||
2453 srcType
== GL_SHORT
||
2454 srcType
== GL_UNSIGNED_INT
||
2455 srcType
== GL_INT
||
2456 srcType
== GL_HALF_FLOAT_ARB
||
2457 srcType
== GL_FLOAT
||
2458 srcType
== GL_UNSIGNED_BYTE_3_3_2
||
2459 srcType
== GL_UNSIGNED_BYTE_2_3_3_REV
||
2460 srcType
== GL_UNSIGNED_SHORT_5_6_5
||
2461 srcType
== GL_UNSIGNED_SHORT_5_6_5_REV
||
2462 srcType
== GL_UNSIGNED_SHORT_4_4_4_4
||
2463 srcType
== GL_UNSIGNED_SHORT_4_4_4_4_REV
||
2464 srcType
== GL_UNSIGNED_SHORT_5_5_5_1
||
2465 srcType
== GL_UNSIGNED_SHORT_1_5_5_5_REV
||
2466 srcType
== GL_UNSIGNED_INT_8_8_8_8
||
2467 srcType
== GL_UNSIGNED_INT_8_8_8_8_REV
||
2468 srcType
== GL_UNSIGNED_INT_10_10_10_2
||
2469 srcType
== GL_UNSIGNED_INT_2_10_10_10_REV
||
2470 srcType
== GL_UNSIGNED_INT_5_9_9_9_REV
||
2471 srcType
== GL_UNSIGNED_INT_10F_11F_11F_REV
);
2473 get_component_mapping(srcFormat
,
2474 &rSrc
, &gSrc
, &bSrc
, &aSrc
,
2475 &rDst
, &gDst
, &bDst
, &aDst
);
2477 stride
= _mesa_components_in_format(srcFormat
);
2479 intFormat
= _mesa_is_integer_format(srcFormat
);
2481 #define PROCESS(SRC_INDEX, DST_INDEX, DEFAULT_FLT, DEFAULT_INT, TYPE, CONVERSION) \
2482 if ((SRC_INDEX) < 0) { \
2485 for (i = 0; i < n; i++) { \
2486 rgba[i][DST_INDEX] = DEFAULT_INT; \
2490 for (i = 0; i < n; i++) { \
2491 rgba[i][DST_INDEX] = DEFAULT_FLT; \
2495 else if (swapBytes) { \
2496 const TYPE *s = (const TYPE *) src; \
2498 for (i = 0; i < n; i++) { \
2499 TYPE value = s[SRC_INDEX]; \
2500 if (sizeof(TYPE) == 2) { \
2503 else if (sizeof(TYPE) == 4) { \
2507 rgba[i][DST_INDEX] = (GLfloat) value; \
2509 rgba[i][DST_INDEX] = (GLfloat) CONVERSION(value); \
2514 const TYPE *s = (const TYPE *) src; \
2517 for (i = 0; i < n; i++) { \
2518 rgba[i][DST_INDEX] = (GLfloat) s[SRC_INDEX]; \
2523 for (i = 0; i < n; i++) { \
2524 rgba[i][DST_INDEX] = (GLfloat) CONVERSION(s[SRC_INDEX]); \
2531 case GL_UNSIGNED_BYTE
:
2532 PROCESS(rSrc
, RCOMP
, 0.0F
, 0, GLubyte
, UBYTE_TO_FLOAT
);
2533 PROCESS(gSrc
, GCOMP
, 0.0F
, 0, GLubyte
, UBYTE_TO_FLOAT
);
2534 PROCESS(bSrc
, BCOMP
, 0.0F
, 0, GLubyte
, UBYTE_TO_FLOAT
);
2535 PROCESS(aSrc
, ACOMP
, 1.0F
, 255, GLubyte
, UBYTE_TO_FLOAT
);
2538 PROCESS(rSrc
, RCOMP
, 0.0F
, 0, GLbyte
, BYTE_TO_FLOATZ
);
2539 PROCESS(gSrc
, GCOMP
, 0.0F
, 0, GLbyte
, BYTE_TO_FLOATZ
);
2540 PROCESS(bSrc
, BCOMP
, 0.0F
, 0, GLbyte
, BYTE_TO_FLOATZ
);
2541 PROCESS(aSrc
, ACOMP
, 1.0F
, 127, GLbyte
, BYTE_TO_FLOATZ
);
2543 case GL_UNSIGNED_SHORT
:
2544 PROCESS(rSrc
, RCOMP
, 0.0F
, 0, GLushort
, USHORT_TO_FLOAT
);
2545 PROCESS(gSrc
, GCOMP
, 0.0F
, 0, GLushort
, USHORT_TO_FLOAT
);
2546 PROCESS(bSrc
, BCOMP
, 0.0F
, 0, GLushort
, USHORT_TO_FLOAT
);
2547 PROCESS(aSrc
, ACOMP
, 1.0F
, 0xffff, GLushort
, USHORT_TO_FLOAT
);
2550 PROCESS(rSrc
, RCOMP
, 0.0F
, 0, GLshort
, SHORT_TO_FLOATZ
);
2551 PROCESS(gSrc
, GCOMP
, 0.0F
, 0, GLshort
, SHORT_TO_FLOATZ
);
2552 PROCESS(bSrc
, BCOMP
, 0.0F
, 0, GLshort
, SHORT_TO_FLOATZ
);
2553 PROCESS(aSrc
, ACOMP
, 1.0F
, 32767, GLshort
, SHORT_TO_FLOATZ
);
2555 case GL_UNSIGNED_INT
:
2556 PROCESS(rSrc
, RCOMP
, 0.0F
, 0, GLuint
, UINT_TO_FLOAT
);
2557 PROCESS(gSrc
, GCOMP
, 0.0F
, 0, GLuint
, UINT_TO_FLOAT
);
2558 PROCESS(bSrc
, BCOMP
, 0.0F
, 0, GLuint
, UINT_TO_FLOAT
);
2559 PROCESS(aSrc
, ACOMP
, 1.0F
, 0xffffffff, GLuint
, UINT_TO_FLOAT
);
2562 PROCESS(rSrc
, RCOMP
, 0.0F
, 0, GLint
, INT_TO_FLOAT
);
2563 PROCESS(gSrc
, GCOMP
, 0.0F
, 0, GLint
, INT_TO_FLOAT
);
2564 PROCESS(bSrc
, BCOMP
, 0.0F
, 0, GLint
, INT_TO_FLOAT
);
2565 PROCESS(aSrc
, ACOMP
, 1.0F
, 2147483647, GLint
, INT_TO_FLOAT
);
2568 PROCESS(rSrc
, RCOMP
, 0.0F
, 0.0F
, GLfloat
, (GLfloat
));
2569 PROCESS(gSrc
, GCOMP
, 0.0F
, 0.0F
, GLfloat
, (GLfloat
));
2570 PROCESS(bSrc
, BCOMP
, 0.0F
, 0.0F
, GLfloat
, (GLfloat
));
2571 PROCESS(aSrc
, ACOMP
, 1.0F
, 1.0F
, GLfloat
, (GLfloat
));
2573 case GL_HALF_FLOAT_ARB
:
2574 PROCESS(rSrc
, RCOMP
, 0.0F
, 0.0F
, GLhalfARB
, _mesa_half_to_float
);
2575 PROCESS(gSrc
, GCOMP
, 0.0F
, 0.0F
, GLhalfARB
, _mesa_half_to_float
);
2576 PROCESS(bSrc
, BCOMP
, 0.0F
, 0.0F
, GLhalfARB
, _mesa_half_to_float
);
2577 PROCESS(aSrc
, ACOMP
, 1.0F
, 1.0F
, GLhalfARB
, _mesa_half_to_float
);
2579 case GL_UNSIGNED_BYTE_3_3_2
:
2581 const GLubyte
*ubsrc
= (const GLubyte
*) src
;
2588 for (i
= 0; i
< n
; i
++) {
2589 GLubyte p
= ubsrc
[i
];
2590 rgba
[i
][rDst
] = ((p
>> 5) ) * rs
;
2591 rgba
[i
][gDst
] = ((p
>> 2) & 0x7) * gs
;
2592 rgba
[i
][bDst
] = ((p
) & 0x3) * bs
;
2593 rgba
[i
][aDst
] = 1.0F
;
2597 case GL_UNSIGNED_BYTE_2_3_3_REV
:
2599 const GLubyte
*ubsrc
= (const GLubyte
*) src
;
2606 for (i
= 0; i
< n
; i
++) {
2607 GLubyte p
= ubsrc
[i
];
2608 rgba
[i
][rDst
] = ((p
) & 0x7) * rs
;
2609 rgba
[i
][gDst
] = ((p
>> 3) & 0x7) * gs
;
2610 rgba
[i
][bDst
] = ((p
>> 6) ) * bs
;
2611 rgba
[i
][aDst
] = 1.0F
;
2615 case GL_UNSIGNED_SHORT_5_6_5
:
2622 const GLushort
*ussrc
= (const GLushort
*) src
;
2624 for (i
= 0; i
< n
; i
++) {
2625 GLushort p
= ussrc
[i
];
2627 rgba
[i
][rDst
] = ((p
>> 11) ) * rs
;
2628 rgba
[i
][gDst
] = ((p
>> 5) & 0x3f) * gs
;
2629 rgba
[i
][bDst
] = ((p
) & 0x1f) * bs
;
2630 rgba
[i
][aDst
] = 1.0F
;
2634 const GLushort
*ussrc
= (const GLushort
*) src
;
2636 for (i
= 0; i
< n
; i
++) {
2637 GLushort p
= ussrc
[i
];
2638 rgba
[i
][rDst
] = ((p
>> 11) ) * rs
;
2639 rgba
[i
][gDst
] = ((p
>> 5) & 0x3f) * gs
;
2640 rgba
[i
][bDst
] = ((p
) & 0x1f) * bs
;
2641 rgba
[i
][aDst
] = 1.0F
;
2645 case GL_UNSIGNED_SHORT_5_6_5_REV
:
2652 const GLushort
*ussrc
= (const GLushort
*) src
;
2654 for (i
= 0; i
< n
; i
++) {
2655 GLushort p
= ussrc
[i
];
2657 rgba
[i
][rDst
] = ((p
) & 0x1f) * rs
;
2658 rgba
[i
][gDst
] = ((p
>> 5) & 0x3f) * gs
;
2659 rgba
[i
][bDst
] = ((p
>> 11) ) * bs
;
2660 rgba
[i
][aDst
] = 1.0F
;
2664 const GLushort
*ussrc
= (const GLushort
*) src
;
2666 for (i
= 0; i
< n
; i
++) {
2667 GLushort p
= ussrc
[i
];
2668 rgba
[i
][rDst
] = ((p
) & 0x1f) * rs
;
2669 rgba
[i
][gDst
] = ((p
>> 5) & 0x3f) * gs
;
2670 rgba
[i
][bDst
] = ((p
>> 11) ) * bs
;
2671 rgba
[i
][aDst
] = 1.0F
;
2675 case GL_UNSIGNED_SHORT_4_4_4_4
:
2677 rs
= gs
= bs
= as
= 1.0F
/ 15.0F
;
2680 const GLushort
*ussrc
= (const GLushort
*) src
;
2682 for (i
= 0; i
< n
; i
++) {
2683 GLushort p
= ussrc
[i
];
2685 rgba
[i
][rDst
] = ((p
>> 12) ) * rs
;
2686 rgba
[i
][gDst
] = ((p
>> 8) & 0xf) * gs
;
2687 rgba
[i
][bDst
] = ((p
>> 4) & 0xf) * bs
;
2688 rgba
[i
][aDst
] = ((p
) & 0xf) * as
;
2692 const GLushort
*ussrc
= (const GLushort
*) src
;
2694 for (i
= 0; i
< n
; i
++) {
2695 GLushort p
= ussrc
[i
];
2696 rgba
[i
][rDst
] = ((p
>> 12) ) * rs
;
2697 rgba
[i
][gDst
] = ((p
>> 8) & 0xf) * gs
;
2698 rgba
[i
][bDst
] = ((p
>> 4) & 0xf) * bs
;
2699 rgba
[i
][aDst
] = ((p
) & 0xf) * as
;
2703 case GL_UNSIGNED_SHORT_4_4_4_4_REV
:
2705 rs
= gs
= bs
= as
= 1.0F
/ 15.0F
;
2708 const GLushort
*ussrc
= (const GLushort
*) src
;
2710 for (i
= 0; i
< n
; i
++) {
2711 GLushort p
= ussrc
[i
];
2713 rgba
[i
][rDst
] = ((p
) & 0xf) * rs
;
2714 rgba
[i
][gDst
] = ((p
>> 4) & 0xf) * gs
;
2715 rgba
[i
][bDst
] = ((p
>> 8) & 0xf) * bs
;
2716 rgba
[i
][aDst
] = ((p
>> 12) ) * as
;
2720 const GLushort
*ussrc
= (const GLushort
*) src
;
2722 for (i
= 0; i
< n
; i
++) {
2723 GLushort p
= ussrc
[i
];
2724 rgba
[i
][rDst
] = ((p
) & 0xf) * rs
;
2725 rgba
[i
][gDst
] = ((p
>> 4) & 0xf) * gs
;
2726 rgba
[i
][bDst
] = ((p
>> 8) & 0xf) * bs
;
2727 rgba
[i
][aDst
] = ((p
>> 12) ) * as
;
2731 case GL_UNSIGNED_SHORT_5_5_5_1
:
2733 rs
= gs
= bs
= 1.0F
/ 31.0F
;
2736 const GLushort
*ussrc
= (const GLushort
*) src
;
2738 for (i
= 0; i
< n
; i
++) {
2739 GLushort p
= ussrc
[i
];
2741 rgba
[i
][rDst
] = ((p
>> 11) ) * rs
;
2742 rgba
[i
][gDst
] = ((p
>> 6) & 0x1f) * gs
;
2743 rgba
[i
][bDst
] = ((p
>> 1) & 0x1f) * bs
;
2744 rgba
[i
][aDst
] = ((p
) & 0x1) * as
;
2748 const GLushort
*ussrc
= (const GLushort
*) src
;
2750 for (i
= 0; i
< n
; i
++) {
2751 GLushort p
= ussrc
[i
];
2752 rgba
[i
][rDst
] = ((p
>> 11) ) * rs
;
2753 rgba
[i
][gDst
] = ((p
>> 6) & 0x1f) * gs
;
2754 rgba
[i
][bDst
] = ((p
>> 1) & 0x1f) * bs
;
2755 rgba
[i
][aDst
] = ((p
) & 0x1) * as
;
2759 case GL_UNSIGNED_SHORT_1_5_5_5_REV
:
2761 rs
= gs
= bs
= 1.0F
/ 31.0F
;
2764 const GLushort
*ussrc
= (const GLushort
*) src
;
2766 for (i
= 0; i
< n
; i
++) {
2767 GLushort p
= ussrc
[i
];
2769 rgba
[i
][rDst
] = ((p
) & 0x1f) * rs
;
2770 rgba
[i
][gDst
] = ((p
>> 5) & 0x1f) * gs
;
2771 rgba
[i
][bDst
] = ((p
>> 10) & 0x1f) * bs
;
2772 rgba
[i
][aDst
] = ((p
>> 15) ) * as
;
2776 const GLushort
*ussrc
= (const GLushort
*) src
;
2778 for (i
= 0; i
< n
; i
++) {
2779 GLushort p
= ussrc
[i
];
2780 rgba
[i
][rDst
] = ((p
) & 0x1f) * rs
;
2781 rgba
[i
][gDst
] = ((p
>> 5) & 0x1f) * gs
;
2782 rgba
[i
][bDst
] = ((p
>> 10) & 0x1f) * bs
;
2783 rgba
[i
][aDst
] = ((p
>> 15) ) * as
;
2787 case GL_UNSIGNED_INT_8_8_8_8
:
2789 const GLuint
*uisrc
= (const GLuint
*) src
;
2792 for (i
= 0; i
< n
; i
++) {
2793 GLuint p
= uisrc
[i
];
2794 rgba
[i
][rDst
] = (GLfloat
) ((p
) & 0xff);
2795 rgba
[i
][gDst
] = (GLfloat
) ((p
>> 8) & 0xff);
2796 rgba
[i
][bDst
] = (GLfloat
) ((p
>> 16) & 0xff);
2797 rgba
[i
][aDst
] = (GLfloat
) ((p
>> 24) );
2801 for (i
= 0; i
< n
; i
++) {
2802 GLuint p
= uisrc
[i
];
2803 rgba
[i
][rDst
] = UBYTE_TO_FLOAT((p
) & 0xff);
2804 rgba
[i
][gDst
] = UBYTE_TO_FLOAT((p
>> 8) & 0xff);
2805 rgba
[i
][bDst
] = UBYTE_TO_FLOAT((p
>> 16) & 0xff);
2806 rgba
[i
][aDst
] = UBYTE_TO_FLOAT((p
>> 24) );
2811 const GLuint
*uisrc
= (const GLuint
*) src
;
2814 for (i
= 0; i
< n
; i
++) {
2815 GLuint p
= uisrc
[i
];
2816 rgba
[i
][rDst
] = (GLfloat
) ((p
>> 24) );
2817 rgba
[i
][gDst
] = (GLfloat
) ((p
>> 16) & 0xff);
2818 rgba
[i
][bDst
] = (GLfloat
) ((p
>> 8) & 0xff);
2819 rgba
[i
][aDst
] = (GLfloat
) ((p
) & 0xff);
2823 for (i
= 0; i
< n
; i
++) {
2824 GLuint p
= uisrc
[i
];
2825 rgba
[i
][rDst
] = UBYTE_TO_FLOAT((p
>> 24) );
2826 rgba
[i
][gDst
] = UBYTE_TO_FLOAT((p
>> 16) & 0xff);
2827 rgba
[i
][bDst
] = UBYTE_TO_FLOAT((p
>> 8) & 0xff);
2828 rgba
[i
][aDst
] = UBYTE_TO_FLOAT((p
) & 0xff);
2833 case GL_UNSIGNED_INT_8_8_8_8_REV
:
2835 const GLuint
*uisrc
= (const GLuint
*) src
;
2838 for (i
= 0; i
< n
; i
++) {
2839 GLuint p
= uisrc
[i
];
2840 rgba
[i
][rDst
] = (GLfloat
) ((p
>> 24) );
2841 rgba
[i
][gDst
] = (GLfloat
) ((p
>> 16) & 0xff);
2842 rgba
[i
][bDst
] = (GLfloat
) ((p
>> 8) & 0xff);
2843 rgba
[i
][aDst
] = (GLfloat
) ((p
) & 0xff);
2847 for (i
= 0; i
< n
; i
++) {
2848 GLuint p
= uisrc
[i
];
2849 rgba
[i
][rDst
] = UBYTE_TO_FLOAT((p
>> 24) );
2850 rgba
[i
][gDst
] = UBYTE_TO_FLOAT((p
>> 16) & 0xff);
2851 rgba
[i
][bDst
] = UBYTE_TO_FLOAT((p
>> 8) & 0xff);
2852 rgba
[i
][aDst
] = UBYTE_TO_FLOAT((p
) & 0xff);
2857 const GLuint
*uisrc
= (const GLuint
*) src
;
2860 for (i
= 0; i
< n
; i
++) {
2861 GLuint p
= uisrc
[i
];
2862 rgba
[i
][rDst
] = (GLfloat
) ((p
) & 0xff);
2863 rgba
[i
][gDst
] = (GLfloat
) ((p
>> 8) & 0xff);
2864 rgba
[i
][bDst
] = (GLfloat
) ((p
>> 16) & 0xff);
2865 rgba
[i
][aDst
] = (GLfloat
) ((p
>> 24) );
2869 for (i
= 0; i
< n
; i
++) {
2870 GLuint p
= uisrc
[i
];
2871 rgba
[i
][rDst
] = UBYTE_TO_FLOAT((p
) & 0xff);
2872 rgba
[i
][gDst
] = UBYTE_TO_FLOAT((p
>> 8) & 0xff);
2873 rgba
[i
][bDst
] = UBYTE_TO_FLOAT((p
>> 16) & 0xff);
2874 rgba
[i
][aDst
] = UBYTE_TO_FLOAT((p
>> 24) );
2879 case GL_UNSIGNED_INT_10_10_10_2
:
2881 rs
= 1.0F
/ 1023.0F
;
2882 gs
= 1.0F
/ 1023.0F
;
2883 bs
= 1.0F
/ 1023.0F
;
2887 const GLuint
*uisrc
= (const GLuint
*) src
;
2889 for (i
= 0; i
< n
; i
++) {
2890 GLuint p
= uisrc
[i
];
2892 rgba
[i
][rDst
] = ((p
>> 22) ) * rs
;
2893 rgba
[i
][gDst
] = ((p
>> 12) & 0x3ff) * gs
;
2894 rgba
[i
][bDst
] = ((p
>> 2) & 0x3ff) * bs
;
2895 rgba
[i
][aDst
] = ((p
) & 0x3 ) * as
;
2899 const GLuint
*uisrc
= (const GLuint
*) src
;
2901 for (i
= 0; i
< n
; i
++) {
2902 GLuint p
= uisrc
[i
];
2903 rgba
[i
][rDst
] = ((p
>> 22) ) * rs
;
2904 rgba
[i
][gDst
] = ((p
>> 12) & 0x3ff) * gs
;
2905 rgba
[i
][bDst
] = ((p
>> 2) & 0x3ff) * bs
;
2906 rgba
[i
][aDst
] = ((p
) & 0x3 ) * as
;
2910 case GL_UNSIGNED_INT_2_10_10_10_REV
:
2912 rs
= 1.0F
/ 1023.0F
;
2913 gs
= 1.0F
/ 1023.0F
;
2914 bs
= 1.0F
/ 1023.0F
;
2918 const GLuint
*uisrc
= (const GLuint
*) src
;
2920 for (i
= 0; i
< n
; i
++) {
2921 GLuint p
= uisrc
[i
];
2923 rgba
[i
][rDst
] = ((p
) & 0x3ff) * rs
;
2924 rgba
[i
][gDst
] = ((p
>> 10) & 0x3ff) * gs
;
2925 rgba
[i
][bDst
] = ((p
>> 20) & 0x3ff) * bs
;
2926 rgba
[i
][aDst
] = ((p
>> 30) ) * as
;
2930 const GLuint
*uisrc
= (const GLuint
*) src
;
2932 for (i
= 0; i
< n
; i
++) {
2933 GLuint p
= uisrc
[i
];
2934 rgba
[i
][rDst
] = ((p
) & 0x3ff) * rs
;
2935 rgba
[i
][gDst
] = ((p
>> 10) & 0x3ff) * gs
;
2936 rgba
[i
][bDst
] = ((p
>> 20) & 0x3ff) * bs
;
2937 rgba
[i
][aDst
] = ((p
>> 30) ) * as
;
2941 case GL_UNSIGNED_INT_5_9_9_9_REV
:
2943 const GLuint
*uisrc
= (const GLuint
*) src
;
2946 for (i
= 0; i
< n
; i
++) {
2947 GLuint p
= uisrc
[i
];
2949 rgb9e5_to_float3(p
, f
);
2950 rgba
[i
][rDst
] = f
[0];
2951 rgba
[i
][gDst
] = f
[1];
2952 rgba
[i
][bDst
] = f
[2];
2953 rgba
[i
][aDst
] = 1.0F
;
2957 const GLuint
*uisrc
= (const GLuint
*) src
;
2960 for (i
= 0; i
< n
; i
++) {
2961 rgb9e5_to_float3(uisrc
[i
], f
);
2962 rgba
[i
][rDst
] = f
[0];
2963 rgba
[i
][gDst
] = f
[1];
2964 rgba
[i
][bDst
] = f
[2];
2965 rgba
[i
][aDst
] = 1.0F
;
2969 case GL_UNSIGNED_INT_10F_11F_11F_REV
:
2971 const GLuint
*uisrc
= (const GLuint
*) src
;
2974 for (i
= 0; i
< n
; i
++) {
2975 GLuint p
= uisrc
[i
];
2977 r11g11b10f_to_float3(p
, f
);
2978 rgba
[i
][rDst
] = f
[0];
2979 rgba
[i
][gDst
] = f
[1];
2980 rgba
[i
][bDst
] = f
[2];
2981 rgba
[i
][aDst
] = 1.0F
;
2985 const GLuint
*uisrc
= (const GLuint
*) src
;
2988 for (i
= 0; i
< n
; i
++) {
2989 r11g11b10f_to_float3(uisrc
[i
], f
);
2990 rgba
[i
][rDst
] = f
[0];
2991 rgba
[i
][gDst
] = f
[1];
2992 rgba
[i
][bDst
] = f
[2];
2993 rgba
[i
][aDst
] = 1.0F
;
2998 _mesa_problem(NULL
, "bad srcType in extract float data");
3005 static inline GLuint
3006 clamp_float_to_uint(GLfloat f
)
3008 return f
< 0.0F
? 0 : IROUND(f
);
3012 static inline GLuint
3013 clamp_half_to_uint(GLhalfARB h
)
3015 GLfloat f
= _mesa_half_to_float(h
);
3016 return f
< 0.0F
? 0 : IROUND(f
);
3021 * \sa extract_float_rgba()
3024 extract_uint_rgba(GLuint n
, GLuint rgba
[][4],
3025 GLenum srcFormat
, GLenum srcType
, const GLvoid
*src
,
3026 GLboolean swapBytes
)
3028 GLint rSrc
, gSrc
, bSrc
, aSrc
;
3030 GLint rDst
, bDst
, gDst
, aDst
;
3032 ASSERT(srcFormat
== GL_RED
||
3033 srcFormat
== GL_GREEN
||
3034 srcFormat
== GL_BLUE
||
3035 srcFormat
== GL_ALPHA
||
3036 srcFormat
== GL_LUMINANCE
||
3037 srcFormat
== GL_LUMINANCE_ALPHA
||
3038 srcFormat
== GL_INTENSITY
||
3039 srcFormat
== GL_RG
||
3040 srcFormat
== GL_RGB
||
3041 srcFormat
== GL_BGR
||
3042 srcFormat
== GL_RGBA
||
3043 srcFormat
== GL_BGRA
||
3044 srcFormat
== GL_ABGR_EXT
||
3045 srcFormat
== GL_DU8DV8_ATI
||
3046 srcFormat
== GL_DUDV_ATI
||
3047 srcFormat
== GL_RED_INTEGER_EXT
||
3048 srcFormat
== GL_RG_INTEGER
||
3049 srcFormat
== GL_GREEN_INTEGER_EXT
||
3050 srcFormat
== GL_BLUE_INTEGER_EXT
||
3051 srcFormat
== GL_ALPHA_INTEGER_EXT
||
3052 srcFormat
== GL_RGB_INTEGER_EXT
||
3053 srcFormat
== GL_RGBA_INTEGER_EXT
||
3054 srcFormat
== GL_BGR_INTEGER_EXT
||
3055 srcFormat
== GL_BGRA_INTEGER_EXT
||
3056 srcFormat
== GL_LUMINANCE_INTEGER_EXT
||
3057 srcFormat
== GL_LUMINANCE_ALPHA_INTEGER_EXT
);
3059 ASSERT(srcType
== GL_UNSIGNED_BYTE
||
3060 srcType
== GL_BYTE
||
3061 srcType
== GL_UNSIGNED_SHORT
||
3062 srcType
== GL_SHORT
||
3063 srcType
== GL_UNSIGNED_INT
||
3064 srcType
== GL_INT
||
3065 srcType
== GL_HALF_FLOAT_ARB
||
3066 srcType
== GL_FLOAT
||
3067 srcType
== GL_UNSIGNED_BYTE_3_3_2
||
3068 srcType
== GL_UNSIGNED_BYTE_2_3_3_REV
||
3069 srcType
== GL_UNSIGNED_SHORT_5_6_5
||
3070 srcType
== GL_UNSIGNED_SHORT_5_6_5_REV
||
3071 srcType
== GL_UNSIGNED_SHORT_4_4_4_4
||
3072 srcType
== GL_UNSIGNED_SHORT_4_4_4_4_REV
||
3073 srcType
== GL_UNSIGNED_SHORT_5_5_5_1
||
3074 srcType
== GL_UNSIGNED_SHORT_1_5_5_5_REV
||
3075 srcType
== GL_UNSIGNED_INT_8_8_8_8
||
3076 srcType
== GL_UNSIGNED_INT_8_8_8_8_REV
||
3077 srcType
== GL_UNSIGNED_INT_10_10_10_2
||
3078 srcType
== GL_UNSIGNED_INT_2_10_10_10_REV
||
3079 srcType
== GL_UNSIGNED_INT_5_9_9_9_REV
||
3080 srcType
== GL_UNSIGNED_INT_10F_11F_11F_REV
);
3082 get_component_mapping(srcFormat
,
3083 &rSrc
, &gSrc
, &bSrc
, &aSrc
,
3084 &rDst
, &gDst
, &bDst
, &aDst
);
3086 stride
= _mesa_components_in_format(srcFormat
);
3088 #define PROCESS(SRC_INDEX, DST_INDEX, DEFAULT, TYPE, CONVERSION) \
3089 if ((SRC_INDEX) < 0) { \
3091 for (i = 0; i < n; i++) { \
3092 rgba[i][DST_INDEX] = DEFAULT; \
3095 else if (swapBytes) { \
3096 const TYPE *s = (const TYPE *) src; \
3098 for (i = 0; i < n; i++) { \
3099 TYPE value = s[SRC_INDEX]; \
3100 if (sizeof(TYPE) == 2) { \
3103 else if (sizeof(TYPE) == 4) { \
3106 rgba[i][DST_INDEX] = CONVERSION(value); \
3111 const TYPE *s = (const TYPE *) src; \
3113 for (i = 0; i < n; i++) { \
3114 rgba[i][DST_INDEX] = CONVERSION(s[SRC_INDEX]); \
3120 case GL_UNSIGNED_BYTE
:
3121 PROCESS(rSrc
, RCOMP
, 0, GLubyte
, (GLuint
));
3122 PROCESS(gSrc
, GCOMP
, 0, GLubyte
, (GLuint
));
3123 PROCESS(bSrc
, BCOMP
, 0, GLubyte
, (GLuint
));
3124 PROCESS(aSrc
, ACOMP
, 1, GLubyte
, (GLuint
));
3127 PROCESS(rSrc
, RCOMP
, 0, GLbyte
, (GLuint
));
3128 PROCESS(gSrc
, GCOMP
, 0, GLbyte
, (GLuint
));
3129 PROCESS(bSrc
, BCOMP
, 0, GLbyte
, (GLuint
));
3130 PROCESS(aSrc
, ACOMP
, 1, GLbyte
, (GLuint
));
3132 case GL_UNSIGNED_SHORT
:
3133 PROCESS(rSrc
, RCOMP
, 0, GLushort
, (GLuint
));
3134 PROCESS(gSrc
, GCOMP
, 0, GLushort
, (GLuint
));
3135 PROCESS(bSrc
, BCOMP
, 0, GLushort
, (GLuint
));
3136 PROCESS(aSrc
, ACOMP
, 1, GLushort
, (GLuint
));
3139 PROCESS(rSrc
, RCOMP
, 0, GLshort
, (GLuint
));
3140 PROCESS(gSrc
, GCOMP
, 0, GLshort
, (GLuint
));
3141 PROCESS(bSrc
, BCOMP
, 0, GLshort
, (GLuint
));
3142 PROCESS(aSrc
, ACOMP
, 1, GLshort
, (GLuint
));
3144 case GL_UNSIGNED_INT
:
3145 PROCESS(rSrc
, RCOMP
, 0, GLuint
, (GLuint
));
3146 PROCESS(gSrc
, GCOMP
, 0, GLuint
, (GLuint
));
3147 PROCESS(bSrc
, BCOMP
, 0, GLuint
, (GLuint
));
3148 PROCESS(aSrc
, ACOMP
, 1, GLuint
, (GLuint
));
3151 PROCESS(rSrc
, RCOMP
, 0, GLint
, (GLuint
));
3152 PROCESS(gSrc
, GCOMP
, 0, GLint
, (GLuint
));
3153 PROCESS(bSrc
, BCOMP
, 0, GLint
, (GLuint
));
3154 PROCESS(aSrc
, ACOMP
, 1, GLint
, (GLuint
));
3157 PROCESS(rSrc
, RCOMP
, 0, GLfloat
, clamp_float_to_uint
);
3158 PROCESS(gSrc
, GCOMP
, 0, GLfloat
, clamp_float_to_uint
);
3159 PROCESS(bSrc
, BCOMP
, 0, GLfloat
, clamp_float_to_uint
);
3160 PROCESS(aSrc
, ACOMP
, 1, GLfloat
, clamp_float_to_uint
);
3162 case GL_HALF_FLOAT_ARB
:
3163 PROCESS(rSrc
, RCOMP
, 0, GLhalfARB
, clamp_half_to_uint
);
3164 PROCESS(gSrc
, GCOMP
, 0, GLhalfARB
, clamp_half_to_uint
);
3165 PROCESS(bSrc
, BCOMP
, 0, GLhalfARB
, clamp_half_to_uint
);
3166 PROCESS(aSrc
, ACOMP
, 1, GLhalfARB
, clamp_half_to_uint
);
3168 case GL_UNSIGNED_BYTE_3_3_2
:
3170 const GLubyte
*ubsrc
= (const GLubyte
*) src
;
3172 for (i
= 0; i
< n
; i
++) {
3173 GLubyte p
= ubsrc
[i
];
3174 rgba
[i
][rDst
] = ((p
>> 5) );
3175 rgba
[i
][gDst
] = ((p
>> 2) & 0x7);
3176 rgba
[i
][bDst
] = ((p
) & 0x3);
3181 case GL_UNSIGNED_BYTE_2_3_3_REV
:
3183 const GLubyte
*ubsrc
= (const GLubyte
*) src
;
3185 for (i
= 0; i
< n
; i
++) {
3186 GLubyte p
= ubsrc
[i
];
3187 rgba
[i
][rDst
] = ((p
) & 0x7);
3188 rgba
[i
][gDst
] = ((p
>> 3) & 0x7);
3189 rgba
[i
][bDst
] = ((p
>> 6) );
3194 case GL_UNSIGNED_SHORT_5_6_5
:
3196 const GLushort
*ussrc
= (const GLushort
*) src
;
3198 for (i
= 0; i
< n
; i
++) {
3199 GLushort p
= ussrc
[i
];
3201 rgba
[i
][rDst
] = ((p
>> 11) );
3202 rgba
[i
][gDst
] = ((p
>> 5) & 0x3f);
3203 rgba
[i
][bDst
] = ((p
) & 0x1f);
3208 const GLushort
*ussrc
= (const GLushort
*) src
;
3210 for (i
= 0; i
< n
; i
++) {
3211 GLushort p
= ussrc
[i
];
3212 rgba
[i
][rDst
] = ((p
>> 11) );
3213 rgba
[i
][gDst
] = ((p
>> 5) & 0x3f);
3214 rgba
[i
][bDst
] = ((p
) & 0x1f);
3219 case GL_UNSIGNED_SHORT_5_6_5_REV
:
3221 const GLushort
*ussrc
= (const GLushort
*) src
;
3223 for (i
= 0; i
< n
; i
++) {
3224 GLushort p
= ussrc
[i
];
3226 rgba
[i
][rDst
] = ((p
) & 0x1f);
3227 rgba
[i
][gDst
] = ((p
>> 5) & 0x3f);
3228 rgba
[i
][bDst
] = ((p
>> 11) );
3233 const GLushort
*ussrc
= (const GLushort
*) src
;
3235 for (i
= 0; i
< n
; i
++) {
3236 GLushort p
= ussrc
[i
];
3237 rgba
[i
][rDst
] = ((p
) & 0x1f);
3238 rgba
[i
][gDst
] = ((p
>> 5) & 0x3f);
3239 rgba
[i
][bDst
] = ((p
>> 11) );
3244 case GL_UNSIGNED_SHORT_4_4_4_4
:
3246 const GLushort
*ussrc
= (const GLushort
*) src
;
3248 for (i
= 0; i
< n
; i
++) {
3249 GLushort p
= ussrc
[i
];
3251 rgba
[i
][rDst
] = ((p
>> 12) );
3252 rgba
[i
][gDst
] = ((p
>> 8) & 0xf);
3253 rgba
[i
][bDst
] = ((p
>> 4) & 0xf);
3254 rgba
[i
][aDst
] = ((p
) & 0xf);
3258 const GLushort
*ussrc
= (const GLushort
*) src
;
3260 for (i
= 0; i
< n
; i
++) {
3261 GLushort p
= ussrc
[i
];
3262 rgba
[i
][rDst
] = ((p
>> 12) );
3263 rgba
[i
][gDst
] = ((p
>> 8) & 0xf);
3264 rgba
[i
][bDst
] = ((p
>> 4) & 0xf);
3265 rgba
[i
][aDst
] = ((p
) & 0xf);
3269 case GL_UNSIGNED_SHORT_4_4_4_4_REV
:
3271 const GLushort
*ussrc
= (const GLushort
*) src
;
3273 for (i
= 0; i
< n
; i
++) {
3274 GLushort p
= ussrc
[i
];
3276 rgba
[i
][rDst
] = ((p
) & 0xf);
3277 rgba
[i
][gDst
] = ((p
>> 4) & 0xf);
3278 rgba
[i
][bDst
] = ((p
>> 8) & 0xf);
3279 rgba
[i
][aDst
] = ((p
>> 12) );
3283 const GLushort
*ussrc
= (const GLushort
*) src
;
3285 for (i
= 0; i
< n
; i
++) {
3286 GLushort p
= ussrc
[i
];
3287 rgba
[i
][rDst
] = ((p
) & 0xf);
3288 rgba
[i
][gDst
] = ((p
>> 4) & 0xf);
3289 rgba
[i
][bDst
] = ((p
>> 8) & 0xf);
3290 rgba
[i
][aDst
] = ((p
>> 12) );
3294 case GL_UNSIGNED_SHORT_5_5_5_1
:
3296 const GLushort
*ussrc
= (const GLushort
*) src
;
3298 for (i
= 0; i
< n
; i
++) {
3299 GLushort p
= ussrc
[i
];
3301 rgba
[i
][rDst
] = ((p
>> 11) );
3302 rgba
[i
][gDst
] = ((p
>> 6) & 0x1f);
3303 rgba
[i
][bDst
] = ((p
>> 1) & 0x1f);
3304 rgba
[i
][aDst
] = ((p
) & 0x1 );
3308 const GLushort
*ussrc
= (const GLushort
*) src
;
3310 for (i
= 0; i
< n
; i
++) {
3311 GLushort p
= ussrc
[i
];
3312 rgba
[i
][rDst
] = ((p
>> 11) );
3313 rgba
[i
][gDst
] = ((p
>> 6) & 0x1f);
3314 rgba
[i
][bDst
] = ((p
>> 1) & 0x1f);
3315 rgba
[i
][aDst
] = ((p
) & 0x1 );
3319 case GL_UNSIGNED_SHORT_1_5_5_5_REV
:
3321 const GLushort
*ussrc
= (const GLushort
*) src
;
3323 for (i
= 0; i
< n
; i
++) {
3324 GLushort p
= ussrc
[i
];
3326 rgba
[i
][rDst
] = ((p
) & 0x1f);
3327 rgba
[i
][gDst
] = ((p
>> 5) & 0x1f);
3328 rgba
[i
][bDst
] = ((p
>> 10) & 0x1f);
3329 rgba
[i
][aDst
] = ((p
>> 15) );
3333 const GLushort
*ussrc
= (const GLushort
*) src
;
3335 for (i
= 0; i
< n
; i
++) {
3336 GLushort p
= ussrc
[i
];
3337 rgba
[i
][rDst
] = ((p
) & 0x1f);
3338 rgba
[i
][gDst
] = ((p
>> 5) & 0x1f);
3339 rgba
[i
][bDst
] = ((p
>> 10) & 0x1f);
3340 rgba
[i
][aDst
] = ((p
>> 15) );
3344 case GL_UNSIGNED_INT_8_8_8_8
:
3346 const GLuint
*uisrc
= (const GLuint
*) src
;
3348 for (i
= 0; i
< n
; i
++) {
3349 GLuint p
= uisrc
[i
];
3350 rgba
[i
][rDst
] = ((p
) & 0xff);
3351 rgba
[i
][gDst
] = ((p
>> 8) & 0xff);
3352 rgba
[i
][bDst
] = ((p
>> 16) & 0xff);
3353 rgba
[i
][aDst
] = ((p
>> 24) );
3357 const GLuint
*uisrc
= (const GLuint
*) src
;
3359 for (i
= 0; i
< n
; i
++) {
3360 GLuint p
= uisrc
[i
];
3361 rgba
[i
][rDst
] = ((p
>> 24) );
3362 rgba
[i
][gDst
] = ((p
>> 16) & 0xff);
3363 rgba
[i
][bDst
] = ((p
>> 8) & 0xff);
3364 rgba
[i
][aDst
] = ((p
) & 0xff);
3368 case GL_UNSIGNED_INT_8_8_8_8_REV
:
3370 const GLuint
*uisrc
= (const GLuint
*) src
;
3372 for (i
= 0; i
< n
; i
++) {
3373 GLuint p
= uisrc
[i
];
3374 rgba
[i
][rDst
] = ((p
>> 24) );
3375 rgba
[i
][gDst
] = ((p
>> 16) & 0xff);
3376 rgba
[i
][bDst
] = ((p
>> 8) & 0xff);
3377 rgba
[i
][aDst
] = ((p
) & 0xff);
3381 const GLuint
*uisrc
= (const GLuint
*) src
;
3383 for (i
= 0; i
< n
; i
++) {
3384 GLuint p
= uisrc
[i
];
3385 rgba
[i
][rDst
] = ((p
) & 0xff);
3386 rgba
[i
][gDst
] = ((p
>> 8) & 0xff);
3387 rgba
[i
][bDst
] = ((p
>> 16) & 0xff);
3388 rgba
[i
][aDst
] = ((p
>> 24) );
3392 case GL_UNSIGNED_INT_10_10_10_2
:
3394 const GLuint
*uisrc
= (const GLuint
*) src
;
3396 for (i
= 0; i
< n
; i
++) {
3397 GLuint p
= uisrc
[i
];
3399 rgba
[i
][rDst
] = ((p
>> 22) );
3400 rgba
[i
][gDst
] = ((p
>> 12) & 0x3ff);
3401 rgba
[i
][bDst
] = ((p
>> 2) & 0x3ff);
3402 rgba
[i
][aDst
] = ((p
) & 0x3 );
3406 const GLuint
*uisrc
= (const GLuint
*) src
;
3408 for (i
= 0; i
< n
; i
++) {
3409 GLuint p
= uisrc
[i
];
3410 rgba
[i
][rDst
] = ((p
>> 22) );
3411 rgba
[i
][gDst
] = ((p
>> 12) & 0x3ff);
3412 rgba
[i
][bDst
] = ((p
>> 2) & 0x3ff);
3413 rgba
[i
][aDst
] = ((p
) & 0x3 );
3417 case GL_UNSIGNED_INT_2_10_10_10_REV
:
3419 const GLuint
*uisrc
= (const GLuint
*) src
;
3421 for (i
= 0; i
< n
; i
++) {
3422 GLuint p
= uisrc
[i
];
3424 rgba
[i
][rDst
] = ((p
) & 0x3ff);
3425 rgba
[i
][gDst
] = ((p
>> 10) & 0x3ff);
3426 rgba
[i
][bDst
] = ((p
>> 20) & 0x3ff);
3427 rgba
[i
][aDst
] = ((p
>> 30) );
3431 const GLuint
*uisrc
= (const GLuint
*) src
;
3433 for (i
= 0; i
< n
; i
++) {
3434 GLuint p
= uisrc
[i
];
3435 rgba
[i
][rDst
] = ((p
) & 0x3ff);
3436 rgba
[i
][gDst
] = ((p
>> 10) & 0x3ff);
3437 rgba
[i
][bDst
] = ((p
>> 20) & 0x3ff);
3438 rgba
[i
][aDst
] = ((p
>> 30) );
3442 case GL_UNSIGNED_INT_5_9_9_9_REV
:
3444 const GLuint
*uisrc
= (const GLuint
*) src
;
3447 for (i
= 0; i
< n
; i
++) {
3448 GLuint p
= uisrc
[i
];
3450 rgb9e5_to_float3(p
, f
);
3451 rgba
[i
][rDst
] = clamp_float_to_uint(f
[0]);
3452 rgba
[i
][gDst
] = clamp_float_to_uint(f
[1]);
3453 rgba
[i
][bDst
] = clamp_float_to_uint(f
[2]);
3458 const GLuint
*uisrc
= (const GLuint
*) src
;
3461 for (i
= 0; i
< n
; i
++) {
3462 GLuint p
= uisrc
[i
];
3463 rgb9e5_to_float3(p
, f
);
3464 rgba
[i
][rDst
] = clamp_float_to_uint(f
[0]);
3465 rgba
[i
][gDst
] = clamp_float_to_uint(f
[1]);
3466 rgba
[i
][bDst
] = clamp_float_to_uint(f
[2]);
3471 case GL_UNSIGNED_INT_10F_11F_11F_REV
:
3473 const GLuint
*uisrc
= (const GLuint
*) src
;
3476 for (i
= 0; i
< n
; i
++) {
3477 GLuint p
= uisrc
[i
];
3479 r11g11b10f_to_float3(p
, f
);
3480 rgba
[i
][rDst
] = clamp_float_to_uint(f
[0]);
3481 rgba
[i
][gDst
] = clamp_float_to_uint(f
[1]);
3482 rgba
[i
][bDst
] = clamp_float_to_uint(f
[2]);
3487 const GLuint
*uisrc
= (const GLuint
*) src
;
3490 for (i
= 0; i
< n
; i
++) {
3491 GLuint p
= uisrc
[i
];
3492 r11g11b10f_to_float3(p
, f
);
3493 rgba
[i
][rDst
] = clamp_float_to_uint(f
[0]);
3494 rgba
[i
][gDst
] = clamp_float_to_uint(f
[1]);
3495 rgba
[i
][bDst
] = clamp_float_to_uint(f
[2]);
3501 _mesa_problem(NULL
, "bad srcType in extract uint data");
3510 * Unpack a row of color image data from a client buffer according to
3511 * the pixel unpacking parameters.
3512 * Return GLubyte values in the specified dest image format.
3513 * This is used by glDrawPixels and glTexImage?D().
3514 * \param ctx - the context
3515 * n - number of pixels in the span
3516 * dstFormat - format of destination color array
3517 * dest - the destination color array
3518 * srcFormat - source image format
3519 * srcType - source image data type
3520 * source - source image pointer
3521 * srcPacking - pixel unpacking parameters
3522 * transferOps - bitmask of IMAGE_*_BIT values of operations to apply
3524 * XXX perhaps expand this to process whole images someday.
3527 _mesa_unpack_color_span_ubyte(struct gl_context
*ctx
,
3528 GLuint n
, GLenum dstFormat
, GLubyte dest
[],
3529 GLenum srcFormat
, GLenum srcType
,
3530 const GLvoid
*source
,
3531 const struct gl_pixelstore_attrib
*srcPacking
,
3532 GLbitfield transferOps
)
3534 GLboolean intFormat
= _mesa_is_integer_format(srcFormat
);
3535 ASSERT(dstFormat
== GL_ALPHA
||
3536 dstFormat
== GL_LUMINANCE
||
3537 dstFormat
== GL_LUMINANCE_ALPHA
||
3538 dstFormat
== GL_INTENSITY
||
3539 dstFormat
== GL_RED
||
3540 dstFormat
== GL_RG
||
3541 dstFormat
== GL_RGB
||
3542 dstFormat
== GL_RGBA
);
3544 ASSERT(srcFormat
== GL_RED
||
3545 srcFormat
== GL_GREEN
||
3546 srcFormat
== GL_BLUE
||
3547 srcFormat
== GL_ALPHA
||
3548 srcFormat
== GL_LUMINANCE
||
3549 srcFormat
== GL_LUMINANCE_ALPHA
||
3550 srcFormat
== GL_INTENSITY
||
3551 srcFormat
== GL_RG
||
3552 srcFormat
== GL_RGB
||
3553 srcFormat
== GL_BGR
||
3554 srcFormat
== GL_RGBA
||
3555 srcFormat
== GL_BGRA
||
3556 srcFormat
== GL_ABGR_EXT
||
3557 srcFormat
== GL_COLOR_INDEX
);
3559 ASSERT(srcType
== GL_BITMAP
||
3560 srcType
== GL_UNSIGNED_BYTE
||
3561 srcType
== GL_BYTE
||
3562 srcType
== GL_UNSIGNED_SHORT
||
3563 srcType
== GL_SHORT
||
3564 srcType
== GL_UNSIGNED_INT
||
3565 srcType
== GL_INT
||
3566 srcType
== GL_HALF_FLOAT_ARB
||
3567 srcType
== GL_FLOAT
||
3568 srcType
== GL_UNSIGNED_BYTE_3_3_2
||
3569 srcType
== GL_UNSIGNED_BYTE_2_3_3_REV
||
3570 srcType
== GL_UNSIGNED_SHORT_5_6_5
||
3571 srcType
== GL_UNSIGNED_SHORT_5_6_5_REV
||
3572 srcType
== GL_UNSIGNED_SHORT_4_4_4_4
||
3573 srcType
== GL_UNSIGNED_SHORT_4_4_4_4_REV
||
3574 srcType
== GL_UNSIGNED_SHORT_5_5_5_1
||
3575 srcType
== GL_UNSIGNED_SHORT_1_5_5_5_REV
||
3576 srcType
== GL_UNSIGNED_INT_8_8_8_8
||
3577 srcType
== GL_UNSIGNED_INT_8_8_8_8_REV
||
3578 srcType
== GL_UNSIGNED_INT_10_10_10_2
||
3579 srcType
== GL_UNSIGNED_INT_2_10_10_10_REV
||
3580 srcType
== GL_UNSIGNED_INT_5_9_9_9_REV
||
3581 srcType
== GL_UNSIGNED_INT_10F_11F_11F_REV
);
3583 /* EXT_texture_integer specifies no transfer ops on integer
3584 * types in the resolved issues section. Just set them to 0
3585 * for integer surfaces.
3590 /* Try simple cases first */
3591 if (transferOps
== 0) {
3592 if (srcType
== GL_UNSIGNED_BYTE
) {
3593 if (dstFormat
== GL_RGBA
) {
3594 if (srcFormat
== GL_RGBA
) {
3595 memcpy( dest
, source
, n
* 4 * sizeof(GLubyte
) );
3598 else if (srcFormat
== GL_RGB
) {
3600 const GLubyte
*src
= (const GLubyte
*) source
;
3601 GLubyte
*dst
= dest
;
3602 for (i
= 0; i
< n
; i
++) {
3613 else if (dstFormat
== GL_RGB
) {
3614 if (srcFormat
== GL_RGB
) {
3615 memcpy( dest
, source
, n
* 3 * sizeof(GLubyte
) );
3618 else if (srcFormat
== GL_RGBA
) {
3620 const GLubyte
*src
= (const GLubyte
*) source
;
3621 GLubyte
*dst
= dest
;
3622 for (i
= 0; i
< n
; i
++) {
3632 else if (dstFormat
== srcFormat
) {
3633 GLint comps
= _mesa_components_in_format(srcFormat
);
3635 memcpy( dest
, source
, n
* comps
* sizeof(GLubyte
) );
3642 /* general solution begins here */
3644 GLint dstComponents
;
3645 GLint rDst
, gDst
, bDst
, aDst
, lDst
, iDst
;
3646 GLfloat (*rgba
)[4] = (GLfloat (*)[4]) malloc(4 * n
* sizeof(GLfloat
));
3649 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "pixel unpacking");
3653 dstComponents
= _mesa_components_in_format( dstFormat
);
3654 /* source & dest image formats should have been error checked by now */
3655 assert(dstComponents
> 0);
3658 * Extract image data and convert to RGBA floats
3660 if (srcFormat
== GL_COLOR_INDEX
) {
3661 GLuint
*indexes
= (GLuint
*) malloc(n
* sizeof(GLuint
));
3664 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "pixel unpacking");
3669 extract_uint_indexes(n
, indexes
, srcFormat
, srcType
, source
,
3672 /* Convert indexes to RGBA */
3673 if (transferOps
& IMAGE_SHIFT_OFFSET_BIT
) {
3674 _mesa_shift_and_offset_ci(ctx
, n
, indexes
);
3676 _mesa_map_ci_to_rgba(ctx
, n
, indexes
, rgba
);
3678 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
3679 * with color indexes.
3681 transferOps
&= ~(IMAGE_SCALE_BIAS_BIT
| IMAGE_MAP_COLOR_BIT
);
3686 /* non-color index data */
3687 extract_float_rgba(n
, rgba
, srcFormat
, srcType
, source
,
3688 srcPacking
->SwapBytes
);
3691 /* Need to clamp if returning GLubytes */
3692 transferOps
|= IMAGE_CLAMP_BIT
;
3695 _mesa_apply_rgba_transfer_ops(ctx
, transferOps
, n
, rgba
);
3698 get_component_indexes(dstFormat
,
3699 &rDst
, &gDst
, &bDst
, &aDst
, &lDst
, &iDst
);
3701 /* Now return the GLubyte data in the requested dstFormat */
3703 GLubyte
*dst
= dest
;
3705 for (i
= 0; i
< n
; i
++) {
3706 CLAMPED_FLOAT_TO_UBYTE(dst
[rDst
], rgba
[i
][RCOMP
]);
3707 dst
+= dstComponents
;
3712 GLubyte
*dst
= dest
;
3714 for (i
= 0; i
< n
; i
++) {
3715 CLAMPED_FLOAT_TO_UBYTE(dst
[gDst
], rgba
[i
][GCOMP
]);
3716 dst
+= dstComponents
;
3721 GLubyte
*dst
= dest
;
3723 for (i
= 0; i
< n
; i
++) {
3724 CLAMPED_FLOAT_TO_UBYTE(dst
[bDst
], rgba
[i
][BCOMP
]);
3725 dst
+= dstComponents
;
3730 GLubyte
*dst
= dest
;
3732 for (i
= 0; i
< n
; i
++) {
3733 CLAMPED_FLOAT_TO_UBYTE(dst
[aDst
], rgba
[i
][ACOMP
]);
3734 dst
+= dstComponents
;
3739 GLubyte
*dst
= dest
;
3742 assert(dstComponents
== 1);
3743 for (i
= 0; i
< n
; i
++) {
3744 /* Intensity comes from red channel */
3745 CLAMPED_FLOAT_TO_UBYTE(dst
[i
], rgba
[i
][RCOMP
]);
3750 GLubyte
*dst
= dest
;
3753 for (i
= 0; i
< n
; i
++) {
3754 /* Luminance comes from red channel */
3755 CLAMPED_FLOAT_TO_UBYTE(dst
[0], rgba
[i
][RCOMP
]);
3756 dst
+= dstComponents
;
3766 * Same as _mesa_unpack_color_span_ubyte(), but return GLfloat data
3767 * instead of GLubyte.
3770 _mesa_unpack_color_span_float( struct gl_context
*ctx
,
3771 GLuint n
, GLenum dstFormat
, GLfloat dest
[],
3772 GLenum srcFormat
, GLenum srcType
,
3773 const GLvoid
*source
,
3774 const struct gl_pixelstore_attrib
*srcPacking
,
3775 GLbitfield transferOps
)
3777 ASSERT(dstFormat
== GL_ALPHA
||
3778 dstFormat
== GL_LUMINANCE
||
3779 dstFormat
== GL_LUMINANCE_ALPHA
||
3780 dstFormat
== GL_INTENSITY
||
3781 dstFormat
== GL_RED
||
3782 dstFormat
== GL_RG
||
3783 dstFormat
== GL_RGB
||
3784 dstFormat
== GL_RGBA
);
3786 ASSERT(srcFormat
== GL_RED
||
3787 srcFormat
== GL_GREEN
||
3788 srcFormat
== GL_BLUE
||
3789 srcFormat
== GL_ALPHA
||
3790 srcFormat
== GL_LUMINANCE
||
3791 srcFormat
== GL_LUMINANCE_ALPHA
||
3792 srcFormat
== GL_INTENSITY
||
3793 srcFormat
== GL_RG
||
3794 srcFormat
== GL_RGB
||
3795 srcFormat
== GL_BGR
||
3796 srcFormat
== GL_RGBA
||
3797 srcFormat
== GL_BGRA
||
3798 srcFormat
== GL_ABGR_EXT
||
3799 srcFormat
== GL_RED_INTEGER_EXT
||
3800 srcFormat
== GL_GREEN_INTEGER_EXT
||
3801 srcFormat
== GL_BLUE_INTEGER_EXT
||
3802 srcFormat
== GL_ALPHA_INTEGER_EXT
||
3803 srcFormat
== GL_RG_INTEGER
||
3804 srcFormat
== GL_RGB_INTEGER_EXT
||
3805 srcFormat
== GL_RGBA_INTEGER_EXT
||
3806 srcFormat
== GL_BGR_INTEGER_EXT
||
3807 srcFormat
== GL_BGRA_INTEGER_EXT
||
3808 srcFormat
== GL_LUMINANCE_INTEGER_EXT
||
3809 srcFormat
== GL_LUMINANCE_ALPHA_INTEGER_EXT
||
3810 srcFormat
== GL_COLOR_INDEX
);
3812 ASSERT(srcType
== GL_BITMAP
||
3813 srcType
== GL_UNSIGNED_BYTE
||
3814 srcType
== GL_BYTE
||
3815 srcType
== GL_UNSIGNED_SHORT
||
3816 srcType
== GL_SHORT
||
3817 srcType
== GL_UNSIGNED_INT
||
3818 srcType
== GL_INT
||
3819 srcType
== GL_HALF_FLOAT_ARB
||
3820 srcType
== GL_FLOAT
||
3821 srcType
== GL_UNSIGNED_BYTE_3_3_2
||
3822 srcType
== GL_UNSIGNED_BYTE_2_3_3_REV
||
3823 srcType
== GL_UNSIGNED_SHORT_5_6_5
||
3824 srcType
== GL_UNSIGNED_SHORT_5_6_5_REV
||
3825 srcType
== GL_UNSIGNED_SHORT_4_4_4_4
||
3826 srcType
== GL_UNSIGNED_SHORT_4_4_4_4_REV
||
3827 srcType
== GL_UNSIGNED_SHORT_5_5_5_1
||
3828 srcType
== GL_UNSIGNED_SHORT_1_5_5_5_REV
||
3829 srcType
== GL_UNSIGNED_INT_8_8_8_8
||
3830 srcType
== GL_UNSIGNED_INT_8_8_8_8_REV
||
3831 srcType
== GL_UNSIGNED_INT_10_10_10_2
||
3832 srcType
== GL_UNSIGNED_INT_2_10_10_10_REV
||
3833 srcType
== GL_UNSIGNED_INT_5_9_9_9_REV
||
3834 srcType
== GL_UNSIGNED_INT_10F_11F_11F_REV
);
3836 /* general solution, no special cases, yet */
3838 GLint dstComponents
;
3839 GLint rDst
, gDst
, bDst
, aDst
, lDst
, iDst
;
3840 GLfloat (*rgba
)[4] = (GLfloat (*)[4]) malloc(4 * n
* sizeof(GLfloat
));
3841 GLboolean intFormat
= _mesa_is_integer_format(srcFormat
);
3844 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "pixel unpacking");
3848 dstComponents
= _mesa_components_in_format( dstFormat
);
3849 /* source & dest image formats should have been error checked by now */
3850 assert(dstComponents
> 0);
3852 /* EXT_texture_integer specifies no transfer ops on integer
3853 * types in the resolved issues section. Just set them to 0
3854 * for integer surfaces.
3860 * Extract image data and convert to RGBA floats
3862 if (srcFormat
== GL_COLOR_INDEX
) {
3863 GLuint
*indexes
= (GLuint
*) malloc(n
* sizeof(GLuint
));
3866 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "pixel unpacking");
3871 extract_uint_indexes(n
, indexes
, srcFormat
, srcType
, source
,
3874 /* Convert indexes to RGBA */
3875 if (transferOps
& IMAGE_SHIFT_OFFSET_BIT
) {
3876 _mesa_shift_and_offset_ci(ctx
, n
, indexes
);
3878 _mesa_map_ci_to_rgba(ctx
, n
, indexes
, rgba
);
3880 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
3881 * with color indexes.
3883 transferOps
&= ~(IMAGE_SCALE_BIAS_BIT
| IMAGE_MAP_COLOR_BIT
);
3888 /* non-color index data */
3889 extract_float_rgba(n
, rgba
, srcFormat
, srcType
, source
,
3890 srcPacking
->SwapBytes
);
3894 _mesa_apply_rgba_transfer_ops(ctx
, transferOps
, n
, rgba
);
3897 get_component_indexes(dstFormat
,
3898 &rDst
, &gDst
, &bDst
, &aDst
, &lDst
, &iDst
);
3900 /* Now pack results in the requested dstFormat */
3902 GLfloat
*dst
= dest
;
3904 for (i
= 0; i
< n
; i
++) {
3905 dst
[rDst
] = rgba
[i
][RCOMP
];
3906 dst
+= dstComponents
;
3911 GLfloat
*dst
= dest
;
3913 for (i
= 0; i
< n
; i
++) {
3914 dst
[gDst
] = rgba
[i
][GCOMP
];
3915 dst
+= dstComponents
;
3920 GLfloat
*dst
= dest
;
3922 for (i
= 0; i
< n
; i
++) {
3923 dst
[bDst
] = rgba
[i
][BCOMP
];
3924 dst
+= dstComponents
;
3929 GLfloat
*dst
= dest
;
3931 for (i
= 0; i
< n
; i
++) {
3932 dst
[aDst
] = rgba
[i
][ACOMP
];
3933 dst
+= dstComponents
;
3938 GLfloat
*dst
= dest
;
3941 assert(dstComponents
== 1);
3942 for (i
= 0; i
< n
; i
++) {
3943 /* Intensity comes from red channel */
3944 dst
[i
] = rgba
[i
][RCOMP
];
3949 GLfloat
*dst
= dest
;
3952 for (i
= 0; i
< n
; i
++) {
3953 /* Luminance comes from red channel */
3954 dst
[0] = rgba
[i
][RCOMP
];
3955 dst
+= dstComponents
;
3965 * Same as _mesa_unpack_color_span_ubyte(), but return GLuint data
3966 * instead of GLubyte.
3967 * No pixel transfer ops are applied.
3970 _mesa_unpack_color_span_uint(struct gl_context
*ctx
,
3971 GLuint n
, GLenum dstFormat
, GLuint
*dest
,
3972 GLenum srcFormat
, GLenum srcType
,
3973 const GLvoid
*source
,
3974 const struct gl_pixelstore_attrib
*srcPacking
)
3976 GLuint (*rgba
)[4] = (GLuint (*)[4]) malloc(n
* 4 * sizeof(GLfloat
));
3979 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "pixel unpacking");
3983 ASSERT(dstFormat
== GL_ALPHA
||
3984 dstFormat
== GL_LUMINANCE
||
3985 dstFormat
== GL_LUMINANCE_ALPHA
||
3986 dstFormat
== GL_INTENSITY
||
3987 dstFormat
== GL_RED
||
3988 dstFormat
== GL_RG
||
3989 dstFormat
== GL_RGB
||
3990 dstFormat
== GL_RGBA
);
3992 ASSERT(srcFormat
== GL_RED
||
3993 srcFormat
== GL_GREEN
||
3994 srcFormat
== GL_BLUE
||
3995 srcFormat
== GL_ALPHA
||
3996 srcFormat
== GL_LUMINANCE
||
3997 srcFormat
== GL_LUMINANCE_ALPHA
||
3998 srcFormat
== GL_INTENSITY
||
3999 srcFormat
== GL_RG
||
4000 srcFormat
== GL_RGB
||
4001 srcFormat
== GL_BGR
||
4002 srcFormat
== GL_RGBA
||
4003 srcFormat
== GL_BGRA
||
4004 srcFormat
== GL_ABGR_EXT
||
4005 srcFormat
== GL_RED_INTEGER_EXT
||
4006 srcFormat
== GL_GREEN_INTEGER_EXT
||
4007 srcFormat
== GL_BLUE_INTEGER_EXT
||
4008 srcFormat
== GL_ALPHA_INTEGER_EXT
||
4009 srcFormat
== GL_RG_INTEGER
||
4010 srcFormat
== GL_RGB_INTEGER_EXT
||
4011 srcFormat
== GL_RGBA_INTEGER_EXT
||
4012 srcFormat
== GL_BGR_INTEGER_EXT
||
4013 srcFormat
== GL_BGRA_INTEGER_EXT
||
4014 srcFormat
== GL_LUMINANCE_INTEGER_EXT
||
4015 srcFormat
== GL_LUMINANCE_ALPHA_INTEGER_EXT
);
4017 ASSERT(srcType
== GL_UNSIGNED_BYTE
||
4018 srcType
== GL_BYTE
||
4019 srcType
== GL_UNSIGNED_SHORT
||
4020 srcType
== GL_SHORT
||
4021 srcType
== GL_UNSIGNED_INT
||
4022 srcType
== GL_INT
||
4023 srcType
== GL_HALF_FLOAT_ARB
||
4024 srcType
== GL_FLOAT
||
4025 srcType
== GL_UNSIGNED_BYTE_3_3_2
||
4026 srcType
== GL_UNSIGNED_BYTE_2_3_3_REV
||
4027 srcType
== GL_UNSIGNED_SHORT_5_6_5
||
4028 srcType
== GL_UNSIGNED_SHORT_5_6_5_REV
||
4029 srcType
== GL_UNSIGNED_SHORT_4_4_4_4
||
4030 srcType
== GL_UNSIGNED_SHORT_4_4_4_4_REV
||
4031 srcType
== GL_UNSIGNED_SHORT_5_5_5_1
||
4032 srcType
== GL_UNSIGNED_SHORT_1_5_5_5_REV
||
4033 srcType
== GL_UNSIGNED_INT_8_8_8_8
||
4034 srcType
== GL_UNSIGNED_INT_8_8_8_8_REV
||
4035 srcType
== GL_UNSIGNED_INT_10_10_10_2
||
4036 srcType
== GL_UNSIGNED_INT_2_10_10_10_REV
||
4037 srcType
== GL_UNSIGNED_INT_5_9_9_9_REV
||
4038 srcType
== GL_UNSIGNED_INT_10F_11F_11F_REV
);
4041 /* Extract image data as uint[4] pixels */
4042 extract_uint_rgba(n
, rgba
, srcFormat
, srcType
, source
,
4043 srcPacking
->SwapBytes
);
4045 if (dstFormat
== GL_RGBA
) {
4047 memcpy(dest
, rgba
, 4 * sizeof(GLuint
) * n
);
4051 GLint rDst
, gDst
, bDst
, aDst
, lDst
, iDst
;
4052 GLint dstComponents
= _mesa_components_in_format( dstFormat
);
4054 assert(dstComponents
> 0);
4056 get_component_indexes(dstFormat
,
4057 &rDst
, &gDst
, &bDst
, &aDst
, &lDst
, &iDst
);
4059 /* Now pack values in the requested dest format */
4063 for (i
= 0; i
< n
; i
++) {
4064 dst
[rDst
] = rgba
[i
][RCOMP
];
4065 dst
+= dstComponents
;
4072 for (i
= 0; i
< n
; i
++) {
4073 dst
[gDst
] = rgba
[i
][GCOMP
];
4074 dst
+= dstComponents
;
4081 for (i
= 0; i
< n
; i
++) {
4082 dst
[bDst
] = rgba
[i
][BCOMP
];
4083 dst
+= dstComponents
;
4090 for (i
= 0; i
< n
; i
++) {
4091 dst
[aDst
] = rgba
[i
][ACOMP
];
4092 dst
+= dstComponents
;
4100 assert(dstComponents
== 1);
4101 for (i
= 0; i
< n
; i
++) {
4102 /* Intensity comes from red channel */
4103 dst
[i
] = rgba
[i
][RCOMP
];
4111 for (i
= 0; i
< n
; i
++) {
4112 /* Luminance comes from red channel */
4113 dst
[0] = rgba
[i
][RCOMP
];
4114 dst
+= dstComponents
;
4125 * Similar to _mesa_unpack_color_span_float(), but for dudv data instead of rgba,
4126 * directly return GLbyte data, no transfer ops apply.
4129 _mesa_unpack_dudv_span_byte( struct gl_context
*ctx
,
4130 GLuint n
, GLenum dstFormat
, GLbyte dest
[],
4131 GLenum srcFormat
, GLenum srcType
,
4132 const GLvoid
*source
,
4133 const struct gl_pixelstore_attrib
*srcPacking
,
4134 GLbitfield transferOps
)
4136 ASSERT(dstFormat
== GL_DUDV_ATI
);
4137 ASSERT(srcFormat
== GL_DUDV_ATI
||
4138 srcFormat
== GL_DU8DV8_ATI
);
4140 ASSERT(srcType
== GL_UNSIGNED_BYTE
||
4141 srcType
== GL_BYTE
||
4142 srcType
== GL_UNSIGNED_SHORT
||
4143 srcType
== GL_SHORT
||
4144 srcType
== GL_UNSIGNED_INT
||
4145 srcType
== GL_INT
||
4146 srcType
== GL_HALF_FLOAT_ARB
||
4147 srcType
== GL_FLOAT
);
4149 /* general solution */
4151 GLint dstComponents
;
4154 GLfloat (*rgba
)[4] = (GLfloat (*)[4]) malloc(4 * n
* sizeof(GLfloat
));
4157 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "pixel unpacking");
4161 dstComponents
= _mesa_components_in_format( dstFormat
);
4162 /* source & dest image formats should have been error checked by now */
4163 assert(dstComponents
> 0);
4166 * Extract image data and convert to RGBA floats
4168 extract_float_rgba(n
, rgba
, srcFormat
, srcType
, source
,
4169 srcPacking
->SwapBytes
);
4172 /* Now determine which color channels we need to produce.
4173 * And determine the dest index (offset) within each color tuple.
4176 /* Now pack results in the requested dstFormat */
4177 for (i
= 0; i
< n
; i
++) {
4178 /* not sure - need clamp[-1,1] here? */
4179 dst
[0] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
4180 dst
[1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
4181 dst
+= dstComponents
;
4189 * Unpack a row of color index data from a client buffer according to
4190 * the pixel unpacking parameters.
4191 * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.
4193 * Args: ctx - the context
4194 * n - number of pixels
4195 * dstType - destination data type
4196 * dest - destination array
4197 * srcType - source pixel type
4198 * source - source data pointer
4199 * srcPacking - pixel unpacking parameters
4200 * transferOps - the pixel transfer operations to apply
4203 _mesa_unpack_index_span( struct gl_context
*ctx
, GLuint n
,
4204 GLenum dstType
, GLvoid
*dest
,
4205 GLenum srcType
, const GLvoid
*source
,
4206 const struct gl_pixelstore_attrib
*srcPacking
,
4207 GLbitfield transferOps
)
4209 ASSERT(srcType
== GL_BITMAP
||
4210 srcType
== GL_UNSIGNED_BYTE
||
4211 srcType
== GL_BYTE
||
4212 srcType
== GL_UNSIGNED_SHORT
||
4213 srcType
== GL_SHORT
||
4214 srcType
== GL_UNSIGNED_INT
||
4215 srcType
== GL_INT
||
4216 srcType
== GL_HALF_FLOAT_ARB
||
4217 srcType
== GL_FLOAT
);
4219 ASSERT(dstType
== GL_UNSIGNED_BYTE
||
4220 dstType
== GL_UNSIGNED_SHORT
||
4221 dstType
== GL_UNSIGNED_INT
);
4224 transferOps
&= (IMAGE_MAP_COLOR_BIT
| IMAGE_SHIFT_OFFSET_BIT
);
4227 * Try simple cases first
4229 if (transferOps
== 0 && srcType
== GL_UNSIGNED_BYTE
4230 && dstType
== GL_UNSIGNED_BYTE
) {
4231 memcpy(dest
, source
, n
* sizeof(GLubyte
));
4233 else if (transferOps
== 0 && srcType
== GL_UNSIGNED_INT
4234 && dstType
== GL_UNSIGNED_INT
&& !srcPacking
->SwapBytes
) {
4235 memcpy(dest
, source
, n
* sizeof(GLuint
));
4241 GLuint
*indexes
= (GLuint
*) malloc(n
* sizeof(GLuint
));
4244 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "pixel unpacking");
4248 extract_uint_indexes(n
, indexes
, GL_COLOR_INDEX
, srcType
, source
,
4252 _mesa_apply_ci_transfer_ops(ctx
, transferOps
, n
, indexes
);
4254 /* convert to dest type */
4256 case GL_UNSIGNED_BYTE
:
4258 GLubyte
*dst
= (GLubyte
*) dest
;
4260 for (i
= 0; i
< n
; i
++) {
4261 dst
[i
] = (GLubyte
) (indexes
[i
] & 0xff);
4265 case GL_UNSIGNED_SHORT
:
4267 GLuint
*dst
= (GLuint
*) dest
;
4269 for (i
= 0; i
< n
; i
++) {
4270 dst
[i
] = (GLushort
) (indexes
[i
] & 0xffff);
4274 case GL_UNSIGNED_INT
:
4275 memcpy(dest
, indexes
, n
* sizeof(GLuint
));
4278 _mesa_problem(ctx
, "bad dstType in _mesa_unpack_index_span");
4287 _mesa_pack_index_span( struct gl_context
*ctx
, GLuint n
,
4288 GLenum dstType
, GLvoid
*dest
, const GLuint
*source
,
4289 const struct gl_pixelstore_attrib
*dstPacking
,
4290 GLbitfield transferOps
)
4292 GLuint
*indexes
= (GLuint
*) malloc(n
* sizeof(GLuint
));
4295 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "pixel packing");
4299 transferOps
&= (IMAGE_MAP_COLOR_BIT
| IMAGE_SHIFT_OFFSET_BIT
);
4301 if (transferOps
& (IMAGE_MAP_COLOR_BIT
| IMAGE_SHIFT_OFFSET_BIT
)) {
4302 /* make a copy of input */
4303 memcpy(indexes
, source
, n
* sizeof(GLuint
));
4304 _mesa_apply_ci_transfer_ops(ctx
, transferOps
, n
, indexes
);
4309 case GL_UNSIGNED_BYTE
:
4311 GLubyte
*dst
= (GLubyte
*) dest
;
4313 for (i
= 0; i
< n
; i
++) {
4314 *dst
++ = (GLubyte
) source
[i
];
4320 GLbyte
*dst
= (GLbyte
*) dest
;
4322 for (i
= 0; i
< n
; i
++) {
4323 dst
[i
] = (GLbyte
) source
[i
];
4327 case GL_UNSIGNED_SHORT
:
4329 GLushort
*dst
= (GLushort
*) dest
;
4331 for (i
= 0; i
< n
; i
++) {
4332 dst
[i
] = (GLushort
) source
[i
];
4334 if (dstPacking
->SwapBytes
) {
4335 _mesa_swap2( (GLushort
*) dst
, n
);
4341 GLshort
*dst
= (GLshort
*) dest
;
4343 for (i
= 0; i
< n
; i
++) {
4344 dst
[i
] = (GLshort
) source
[i
];
4346 if (dstPacking
->SwapBytes
) {
4347 _mesa_swap2( (GLushort
*) dst
, n
);
4351 case GL_UNSIGNED_INT
:
4353 GLuint
*dst
= (GLuint
*) dest
;
4355 for (i
= 0; i
< n
; i
++) {
4356 dst
[i
] = (GLuint
) source
[i
];
4358 if (dstPacking
->SwapBytes
) {
4359 _mesa_swap4( (GLuint
*) dst
, n
);
4365 GLint
*dst
= (GLint
*) dest
;
4367 for (i
= 0; i
< n
; i
++) {
4368 dst
[i
] = (GLint
) source
[i
];
4370 if (dstPacking
->SwapBytes
) {
4371 _mesa_swap4( (GLuint
*) dst
, n
);
4377 GLfloat
*dst
= (GLfloat
*) dest
;
4379 for (i
= 0; i
< n
; i
++) {
4380 dst
[i
] = (GLfloat
) source
[i
];
4382 if (dstPacking
->SwapBytes
) {
4383 _mesa_swap4( (GLuint
*) dst
, n
);
4387 case GL_HALF_FLOAT_ARB
:
4389 GLhalfARB
*dst
= (GLhalfARB
*) dest
;
4391 for (i
= 0; i
< n
; i
++) {
4392 dst
[i
] = _mesa_float_to_half((GLfloat
) source
[i
]);
4394 if (dstPacking
->SwapBytes
) {
4395 _mesa_swap2( (GLushort
*) dst
, n
);
4400 _mesa_problem(ctx
, "bad type in _mesa_pack_index_span");
4408 * Unpack a row of stencil data from a client buffer according to
4409 * the pixel unpacking parameters.
4410 * This is (or will be) used by glDrawPixels
4412 * Args: ctx - the context
4413 * n - number of pixels
4414 * dstType - destination data type
4415 * dest - destination array
4416 * srcType - source pixel type
4417 * source - source data pointer
4418 * srcPacking - pixel unpacking parameters
4419 * transferOps - apply offset/bias/lookup ops?
4422 _mesa_unpack_stencil_span( struct gl_context
*ctx
, GLuint n
,
4423 GLenum dstType
, GLvoid
*dest
,
4424 GLenum srcType
, const GLvoid
*source
,
4425 const struct gl_pixelstore_attrib
*srcPacking
,
4426 GLbitfield transferOps
)
4428 ASSERT(srcType
== GL_BITMAP
||
4429 srcType
== GL_UNSIGNED_BYTE
||
4430 srcType
== GL_BYTE
||
4431 srcType
== GL_UNSIGNED_SHORT
||
4432 srcType
== GL_SHORT
||
4433 srcType
== GL_UNSIGNED_INT
||
4434 srcType
== GL_INT
||
4435 srcType
== GL_UNSIGNED_INT_24_8_EXT
||
4436 srcType
== GL_HALF_FLOAT_ARB
||
4437 srcType
== GL_FLOAT
||
4438 srcType
== GL_FLOAT_32_UNSIGNED_INT_24_8_REV
);
4440 ASSERT(dstType
== GL_UNSIGNED_BYTE
||
4441 dstType
== GL_UNSIGNED_SHORT
||
4442 dstType
== GL_UNSIGNED_INT
||
4443 dstType
== GL_FLOAT_32_UNSIGNED_INT_24_8_REV
);
4445 /* only shift and offset apply to stencil */
4446 transferOps
&= IMAGE_SHIFT_OFFSET_BIT
;
4449 * Try simple cases first
4451 if (transferOps
== 0 &&
4452 !ctx
->Pixel
.MapStencilFlag
&&
4453 srcType
== GL_UNSIGNED_BYTE
&&
4454 dstType
== GL_UNSIGNED_BYTE
) {
4455 memcpy(dest
, source
, n
* sizeof(GLubyte
));
4457 else if (transferOps
== 0 &&
4458 !ctx
->Pixel
.MapStencilFlag
&&
4459 srcType
== GL_UNSIGNED_INT
&&
4460 dstType
== GL_UNSIGNED_INT
&&
4461 !srcPacking
->SwapBytes
) {
4462 memcpy(dest
, source
, n
* sizeof(GLuint
));
4468 GLuint
*indexes
= (GLuint
*) malloc(n
* sizeof(GLuint
));
4471 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "stencil unpacking");
4475 extract_uint_indexes(n
, indexes
, GL_STENCIL_INDEX
, srcType
, source
,
4478 if (transferOps
& IMAGE_SHIFT_OFFSET_BIT
) {
4479 /* shift and offset indexes */
4480 _mesa_shift_and_offset_ci(ctx
, n
, indexes
);
4483 if (ctx
->Pixel
.MapStencilFlag
) {
4484 /* Apply stencil lookup table */
4485 const GLuint mask
= ctx
->PixelMaps
.StoS
.Size
- 1;
4487 for (i
= 0; i
< n
; i
++) {
4488 indexes
[i
] = (GLuint
)ctx
->PixelMaps
.StoS
.Map
[ indexes
[i
] & mask
];
4492 /* convert to dest type */
4494 case GL_UNSIGNED_BYTE
:
4496 GLubyte
*dst
= (GLubyte
*) dest
;
4498 for (i
= 0; i
< n
; i
++) {
4499 dst
[i
] = (GLubyte
) (indexes
[i
] & 0xff);
4503 case GL_UNSIGNED_SHORT
:
4505 GLuint
*dst
= (GLuint
*) dest
;
4507 for (i
= 0; i
< n
; i
++) {
4508 dst
[i
] = (GLushort
) (indexes
[i
] & 0xffff);
4512 case GL_UNSIGNED_INT
:
4513 memcpy(dest
, indexes
, n
* sizeof(GLuint
));
4515 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV
:
4517 GLuint
*dst
= (GLuint
*) dest
;
4519 for (i
= 0; i
< n
; i
++) {
4520 dst
[i
*2+1] = indexes
[i
] & 0xff; /* lower 8 bits */
4525 _mesa_problem(ctx
, "bad dstType in _mesa_unpack_stencil_span");
4534 _mesa_pack_stencil_span( struct gl_context
*ctx
, GLuint n
,
4535 GLenum dstType
, GLvoid
*dest
, const GLubyte
*source
,
4536 const struct gl_pixelstore_attrib
*dstPacking
)
4538 GLubyte
*stencil
= (GLubyte
*) malloc(n
* sizeof(GLubyte
));
4541 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "stencil packing");
4545 if (ctx
->Pixel
.IndexShift
|| ctx
->Pixel
.IndexOffset
||
4546 ctx
->Pixel
.MapStencilFlag
) {
4547 /* make a copy of input */
4548 memcpy(stencil
, source
, n
* sizeof(GLubyte
));
4549 _mesa_apply_stencil_transfer_ops(ctx
, n
, stencil
);
4554 case GL_UNSIGNED_BYTE
:
4555 memcpy(dest
, source
, n
);
4559 GLbyte
*dst
= (GLbyte
*) dest
;
4562 dst
[i
] = (GLbyte
) (source
[i
] & 0x7f);
4566 case GL_UNSIGNED_SHORT
:
4568 GLushort
*dst
= (GLushort
*) dest
;
4571 dst
[i
] = (GLushort
) source
[i
];
4573 if (dstPacking
->SwapBytes
) {
4574 _mesa_swap2( (GLushort
*) dst
, n
);
4580 GLshort
*dst
= (GLshort
*) dest
;
4583 dst
[i
] = (GLshort
) source
[i
];
4585 if (dstPacking
->SwapBytes
) {
4586 _mesa_swap2( (GLushort
*) dst
, n
);
4590 case GL_UNSIGNED_INT
:
4592 GLuint
*dst
= (GLuint
*) dest
;
4595 dst
[i
] = (GLuint
) source
[i
];
4597 if (dstPacking
->SwapBytes
) {
4598 _mesa_swap4( (GLuint
*) dst
, n
);
4604 GLint
*dst
= (GLint
*) dest
;
4607 dst
[i
] = (GLint
) source
[i
];
4609 if (dstPacking
->SwapBytes
) {
4610 _mesa_swap4( (GLuint
*) dst
, n
);
4616 GLfloat
*dst
= (GLfloat
*) dest
;
4619 dst
[i
] = (GLfloat
) source
[i
];
4621 if (dstPacking
->SwapBytes
) {
4622 _mesa_swap4( (GLuint
*) dst
, n
);
4626 case GL_HALF_FLOAT_ARB
:
4628 GLhalfARB
*dst
= (GLhalfARB
*) dest
;
4631 dst
[i
] = _mesa_float_to_half( (float) source
[i
] );
4633 if (dstPacking
->SwapBytes
) {
4634 _mesa_swap2( (GLushort
*) dst
, n
);
4639 if (dstPacking
->LsbFirst
) {
4640 GLubyte
*dst
= (GLubyte
*) dest
;
4643 for (i
= 0; i
< n
; i
++) {
4646 *dst
|= ((source
[i
] != 0) << shift
);
4655 GLubyte
*dst
= (GLubyte
*) dest
;
4658 for (i
= 0; i
< n
; i
++) {
4661 *dst
|= ((source
[i
] != 0) << shift
);
4671 _mesa_problem(ctx
, "bad type in _mesa_pack_index_span");
4677 #define DEPTH_VALUES(GLTYPE, GLTYPE2FLOAT) \
4680 const GLTYPE *src = (const GLTYPE *)source; \
4681 for (i = 0; i < n; i++) { \
4682 GLTYPE value = src[i]; \
4683 if (srcPacking->SwapBytes) { \
4684 if (sizeof(GLTYPE) == 2) { \
4686 } else if (sizeof(GLTYPE) == 4) { \
4690 depthValues[i] = GLTYPE2FLOAT(value); \
4696 * Unpack a row of depth/z values from memory, returning GLushort, GLuint
4697 * or GLfloat values.
4698 * The glPixelTransfer (scale/bias) params will be applied.
4700 * \param dstType one of GL_UNSIGNED_SHORT, GL_UNSIGNED_INT, GL_FLOAT
4701 * \param depthMax max value for returned GLushort or GLuint values
4702 * (ignored for GLfloat).
4705 _mesa_unpack_depth_span( struct gl_context
*ctx
, GLuint n
,
4706 GLenum dstType
, GLvoid
*dest
, GLuint depthMax
,
4707 GLenum srcType
, const GLvoid
*source
,
4708 const struct gl_pixelstore_attrib
*srcPacking
)
4710 GLfloat
*depthTemp
= NULL
, *depthValues
;
4711 GLboolean needClamp
= GL_FALSE
;
4713 /* Look for special cases first.
4714 * Not only are these faster, they're less prone to numeric conversion
4715 * problems. Otherwise, converting from an int type to a float then
4716 * back to an int type can introduce errors that will show up as
4717 * artifacts in things like depth peeling which uses glCopyTexImage.
4719 if (ctx
->Pixel
.DepthScale
== 1.0 && ctx
->Pixel
.DepthBias
== 0.0) {
4720 if (srcType
== GL_UNSIGNED_INT
&& dstType
== GL_UNSIGNED_SHORT
) {
4721 const GLuint
*src
= (const GLuint
*) source
;
4722 GLushort
*dst
= (GLushort
*) dest
;
4724 for (i
= 0; i
< n
; i
++) {
4725 dst
[i
] = src
[i
] >> 16;
4729 if (srcType
== GL_UNSIGNED_SHORT
4730 && dstType
== GL_UNSIGNED_INT
4731 && depthMax
== 0xffffffff) {
4732 const GLushort
*src
= (const GLushort
*) source
;
4733 GLuint
*dst
= (GLuint
*) dest
;
4735 for (i
= 0; i
< n
; i
++) {
4736 dst
[i
] = src
[i
] | (src
[i
] << 16);
4740 if (srcType
== GL_UNSIGNED_INT_24_8
4741 && dstType
== GL_UNSIGNED_INT
4742 && depthMax
== 0xffffff) {
4743 const GLuint
*src
= (const GLuint
*) source
;
4744 GLuint
*dst
= (GLuint
*) dest
;
4746 for (i
= 0; i
< n
; i
++) {
4747 dst
[i
] = src
[i
] >> 8;
4751 /* XXX may want to add additional cases here someday */
4754 /* general case path follows */
4756 if (dstType
== GL_FLOAT
) {
4757 depthValues
= (GLfloat
*) dest
;
4760 depthTemp
= (GLfloat
*) malloc(n
* sizeof(GLfloat
));
4762 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "pixel unpacking");
4766 depthValues
= depthTemp
;
4769 /* Convert incoming values to GLfloat. Some conversions will require
4774 DEPTH_VALUES(GLbyte
, BYTE_TO_FLOATZ
);
4775 needClamp
= GL_TRUE
;
4777 case GL_UNSIGNED_BYTE
:
4778 DEPTH_VALUES(GLubyte
, UBYTE_TO_FLOAT
);
4781 DEPTH_VALUES(GLshort
, SHORT_TO_FLOATZ
);
4782 needClamp
= GL_TRUE
;
4784 case GL_UNSIGNED_SHORT
:
4785 DEPTH_VALUES(GLushort
, USHORT_TO_FLOAT
);
4788 DEPTH_VALUES(GLint
, INT_TO_FLOAT
);
4789 needClamp
= GL_TRUE
;
4791 case GL_UNSIGNED_INT
:
4792 DEPTH_VALUES(GLuint
, UINT_TO_FLOAT
);
4794 case GL_UNSIGNED_INT_24_8_EXT
: /* GL_EXT_packed_depth_stencil */
4795 if (dstType
== GL_UNSIGNED_INT_24_8_EXT
&&
4796 depthMax
== 0xffffff &&
4797 ctx
->Pixel
.DepthScale
== 1.0 &&
4798 ctx
->Pixel
.DepthBias
== 0.0) {
4799 const GLuint
*src
= (const GLuint
*) source
;
4800 GLuint
*zValues
= (GLuint
*) dest
;
4802 for (i
= 0; i
< n
; i
++) {
4803 GLuint value
= src
[i
];
4804 if (srcPacking
->SwapBytes
) {
4807 zValues
[i
] = value
& 0xffffff00;
4813 const GLuint
*src
= (const GLuint
*) source
;
4814 const GLfloat scale
= 1.0f
/ 0xffffff;
4816 for (i
= 0; i
< n
; i
++) {
4817 GLuint value
= src
[i
];
4818 if (srcPacking
->SwapBytes
) {
4821 depthValues
[i
] = (value
>> 8) * scale
;
4825 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV
:
4828 const GLfloat
*src
= (const GLfloat
*)source
;
4829 for (i
= 0; i
< n
; i
++) {
4830 GLfloat value
= src
[i
* 2];
4831 if (srcPacking
->SwapBytes
) {
4834 depthValues
[i
] = value
;
4836 needClamp
= GL_TRUE
;
4840 DEPTH_VALUES(GLfloat
, 1*);
4841 needClamp
= GL_TRUE
;
4843 case GL_HALF_FLOAT_ARB
:
4846 const GLhalfARB
*src
= (const GLhalfARB
*) source
;
4847 for (i
= 0; i
< n
; i
++) {
4848 GLhalfARB value
= src
[i
];
4849 if (srcPacking
->SwapBytes
) {
4852 depthValues
[i
] = _mesa_half_to_float(value
);
4854 needClamp
= GL_TRUE
;
4858 _mesa_problem(NULL
, "bad type in _mesa_unpack_depth_span()");
4863 /* apply depth scale and bias */
4865 const GLfloat scale
= ctx
->Pixel
.DepthScale
;
4866 const GLfloat bias
= ctx
->Pixel
.DepthBias
;
4867 if (scale
!= 1.0 || bias
!= 0.0) {
4869 for (i
= 0; i
< n
; i
++) {
4870 depthValues
[i
] = depthValues
[i
] * scale
+ bias
;
4872 needClamp
= GL_TRUE
;
4876 /* clamp to [0, 1] */
4879 for (i
= 0; i
< n
; i
++) {
4880 depthValues
[i
] = (GLfloat
)CLAMP(depthValues
[i
], 0.0, 1.0);
4885 * Convert values to dstType
4887 if (dstType
== GL_UNSIGNED_INT
) {
4888 GLuint
*zValues
= (GLuint
*) dest
;
4890 if (depthMax
<= 0xffffff) {
4891 /* no overflow worries */
4892 for (i
= 0; i
< n
; i
++) {
4893 zValues
[i
] = (GLuint
) (depthValues
[i
] * (GLfloat
) depthMax
);
4897 /* need to use double precision to prevent overflow problems */
4898 for (i
= 0; i
< n
; i
++) {
4899 GLdouble z
= depthValues
[i
] * (GLfloat
) depthMax
;
4900 if (z
>= (GLdouble
) 0xffffffff)
4901 zValues
[i
] = 0xffffffff;
4903 zValues
[i
] = (GLuint
) z
;
4907 else if (dstType
== GL_UNSIGNED_SHORT
) {
4908 GLushort
*zValues
= (GLushort
*) dest
;
4910 ASSERT(depthMax
<= 0xffff);
4911 for (i
= 0; i
< n
; i
++) {
4912 zValues
[i
] = (GLushort
) (depthValues
[i
] * (GLfloat
) depthMax
);
4915 else if (dstType
== GL_FLOAT
) {
4916 /* Nothing to do. depthValues is pointing to dest. */
4918 else if (dstType
== GL_FLOAT_32_UNSIGNED_INT_24_8_REV
) {
4919 GLfloat
*zValues
= (GLfloat
*) dest
;
4921 for (i
= 0; i
< n
; i
++) {
4922 zValues
[i
*2] = depthValues
[i
];
4934 * Pack an array of depth values. The values are floats in [0,1].
4937 _mesa_pack_depth_span( struct gl_context
*ctx
, GLuint n
, GLvoid
*dest
,
4938 GLenum dstType
, const GLfloat
*depthSpan
,
4939 const struct gl_pixelstore_attrib
*dstPacking
)
4941 GLfloat
*depthCopy
= (GLfloat
*) malloc(n
* sizeof(GLfloat
));
4943 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "pixel packing");
4947 if (ctx
->Pixel
.DepthScale
!= 1.0 || ctx
->Pixel
.DepthBias
!= 0.0) {
4948 memcpy(depthCopy
, depthSpan
, n
* sizeof(GLfloat
));
4949 _mesa_scale_and_bias_depth(ctx
, n
, depthCopy
);
4950 depthSpan
= depthCopy
;
4954 case GL_UNSIGNED_BYTE
:
4956 GLubyte
*dst
= (GLubyte
*) dest
;
4958 for (i
= 0; i
< n
; i
++) {
4959 dst
[i
] = FLOAT_TO_UBYTE( depthSpan
[i
] );
4965 GLbyte
*dst
= (GLbyte
*) dest
;
4967 for (i
= 0; i
< n
; i
++) {
4968 dst
[i
] = FLOAT_TO_BYTE( depthSpan
[i
] );
4972 case GL_UNSIGNED_SHORT
:
4974 GLushort
*dst
= (GLushort
*) dest
;
4976 for (i
= 0; i
< n
; i
++) {
4977 CLAMPED_FLOAT_TO_USHORT(dst
[i
], depthSpan
[i
]);
4979 if (dstPacking
->SwapBytes
) {
4980 _mesa_swap2( (GLushort
*) dst
, n
);
4986 GLshort
*dst
= (GLshort
*) dest
;
4988 for (i
= 0; i
< n
; i
++) {
4989 dst
[i
] = FLOAT_TO_SHORT( depthSpan
[i
] );
4991 if (dstPacking
->SwapBytes
) {
4992 _mesa_swap2( (GLushort
*) dst
, n
);
4996 case GL_UNSIGNED_INT
:
4998 GLuint
*dst
= (GLuint
*) dest
;
5000 for (i
= 0; i
< n
; i
++) {
5001 dst
[i
] = FLOAT_TO_UINT( depthSpan
[i
] );
5003 if (dstPacking
->SwapBytes
) {
5004 _mesa_swap4( (GLuint
*) dst
, n
);
5010 GLint
*dst
= (GLint
*) dest
;
5012 for (i
= 0; i
< n
; i
++) {
5013 dst
[i
] = FLOAT_TO_INT( depthSpan
[i
] );
5015 if (dstPacking
->SwapBytes
) {
5016 _mesa_swap4( (GLuint
*) dst
, n
);
5022 GLfloat
*dst
= (GLfloat
*) dest
;
5024 for (i
= 0; i
< n
; i
++) {
5025 dst
[i
] = depthSpan
[i
];
5027 if (dstPacking
->SwapBytes
) {
5028 _mesa_swap4( (GLuint
*) dst
, n
);
5032 case GL_HALF_FLOAT_ARB
:
5034 GLhalfARB
*dst
= (GLhalfARB
*) dest
;
5036 for (i
= 0; i
< n
; i
++) {
5037 dst
[i
] = _mesa_float_to_half(depthSpan
[i
]);
5039 if (dstPacking
->SwapBytes
) {
5040 _mesa_swap2( (GLushort
*) dst
, n
);
5045 _mesa_problem(ctx
, "bad type in _mesa_pack_depth_span");
5054 * Pack depth and stencil values as GL_DEPTH_STENCIL (GL_UNSIGNED_INT_24_8 etc)
5057 _mesa_pack_depth_stencil_span(struct gl_context
*ctx
,GLuint n
,
5058 GLenum dstType
, GLuint
*dest
,
5059 const GLfloat
*depthVals
,
5060 const GLubyte
*stencilVals
,
5061 const struct gl_pixelstore_attrib
*dstPacking
)
5063 GLfloat
*depthCopy
= (GLfloat
*) malloc(n
* sizeof(GLfloat
));
5064 GLubyte
*stencilCopy
= (GLubyte
*) malloc(n
* sizeof(GLubyte
));
5067 if (!depthCopy
|| !stencilCopy
) {
5068 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "pixel packing");
5074 if (ctx
->Pixel
.DepthScale
!= 1.0 || ctx
->Pixel
.DepthBias
!= 0.0) {
5075 memcpy(depthCopy
, depthVals
, n
* sizeof(GLfloat
));
5076 _mesa_scale_and_bias_depth(ctx
, n
, depthCopy
);
5077 depthVals
= depthCopy
;
5080 if (ctx
->Pixel
.IndexShift
||
5081 ctx
->Pixel
.IndexOffset
||
5082 ctx
->Pixel
.MapStencilFlag
) {
5083 memcpy(stencilCopy
, stencilVals
, n
* sizeof(GLubyte
));
5084 _mesa_apply_stencil_transfer_ops(ctx
, n
, stencilCopy
);
5085 stencilVals
= stencilCopy
;
5089 case GL_UNSIGNED_INT_24_8
:
5090 for (i
= 0; i
< n
; i
++) {
5091 GLuint z
= (GLuint
) (depthVals
[i
] * 0xffffff);
5092 dest
[i
] = (z
<< 8) | (stencilVals
[i
] & 0xff);
5095 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV
:
5096 for (i
= 0; i
< n
; i
++) {
5097 ((GLfloat
*)dest
)[i
*2] = depthVals
[i
];
5098 dest
[i
*2+1] = stencilVals
[i
] & 0xff;
5103 if (dstPacking
->SwapBytes
) {
5104 _mesa_swap4(dest
, n
);
5115 * Unpack image data. Apply byte swapping, byte flipping (bitmap).
5116 * Return all image data in a contiguous block. This is used when we
5117 * compile glDrawPixels, glTexImage, etc into a display list. We
5118 * need a copy of the data in a standard format.
5121 _mesa_unpack_image( GLuint dimensions
,
5122 GLsizei width
, GLsizei height
, GLsizei depth
,
5123 GLenum format
, GLenum type
, const GLvoid
*pixels
,
5124 const struct gl_pixelstore_attrib
*unpack
)
5126 GLint bytesPerRow
, compsPerRow
;
5127 GLboolean flipBytes
, swap2
, swap4
;
5130 return NULL
; /* not necessarily an error */
5132 if (width
<= 0 || height
<= 0 || depth
<= 0)
5133 return NULL
; /* generate error later */
5135 if (type
== GL_BITMAP
) {
5136 bytesPerRow
= (width
+ 7) >> 3;
5137 flipBytes
= unpack
->LsbFirst
;
5138 swap2
= swap4
= GL_FALSE
;
5142 const GLint bytesPerPixel
= _mesa_bytes_per_pixel(format
, type
);
5143 GLint components
= _mesa_components_in_format(format
);
5146 if (_mesa_type_is_packed(type
))
5149 if (bytesPerPixel
<= 0 || components
<= 0)
5150 return NULL
; /* bad format or type. generate error later */
5151 bytesPerRow
= bytesPerPixel
* width
;
5152 bytesPerComp
= bytesPerPixel
/ components
;
5153 flipBytes
= GL_FALSE
;
5154 swap2
= (bytesPerComp
== 2) && unpack
->SwapBytes
;
5155 swap4
= (bytesPerComp
== 4) && unpack
->SwapBytes
;
5156 compsPerRow
= components
* width
;
5157 assert(compsPerRow
>= width
);
5162 = (GLubyte
*) malloc(bytesPerRow
* height
* depth
);
5166 return NULL
; /* generate GL_OUT_OF_MEMORY later */
5169 for (img
= 0; img
< depth
; img
++) {
5170 for (row
= 0; row
< height
; row
++) {
5171 const GLvoid
*src
= _mesa_image_address(dimensions
, unpack
, pixels
,
5172 width
, height
, format
, type
, img
, row
, 0);
5174 if ((type
== GL_BITMAP
) && (unpack
->SkipPixels
& 0x7)) {
5176 flipBytes
= GL_FALSE
;
5177 if (unpack
->LsbFirst
) {
5178 GLubyte srcMask
= 1 << (unpack
->SkipPixels
& 0x7);
5179 GLubyte dstMask
= 128;
5180 const GLubyte
*s
= src
;
5183 for (i
= 0; i
< width
; i
++) {
5187 if (srcMask
== 128) {
5192 srcMask
= srcMask
<< 1;
5200 dstMask
= dstMask
>> 1;
5205 GLubyte srcMask
= 128 >> (unpack
->SkipPixels
& 0x7);
5206 GLubyte dstMask
= 128;
5207 const GLubyte
*s
= src
;
5210 for (i
= 0; i
< width
; i
++) {
5219 srcMask
= srcMask
>> 1;
5227 dstMask
= dstMask
>> 1;
5233 memcpy(dst
, src
, bytesPerRow
);
5236 /* byte flipping/swapping */
5238 flip_bytes((GLubyte
*) dst
, bytesPerRow
);
5241 _mesa_swap2((GLushort
*) dst
, compsPerRow
);
5244 _mesa_swap4((GLuint
*) dst
, compsPerRow
);
5256 * If we unpack colors from a luminance surface, we'll get pixel colors
5257 * such as (l, l, l, a).
5258 * When we call _mesa_pack_rgba_span_float(format=GL_LUMINANCE), that
5259 * function will compute L=R+G+B before packing. The net effect is we'll
5260 * accidentally store luminance values = 3*l.
5261 * This function compensates for that by converting (aka rebasing) (l,l,l,a)
5263 * It's a similar story for other formats such as LUMINANCE_ALPHA, ALPHA
5266 * Finally, we also need to do this when the actual surface format does
5267 * not match the logical surface format. For example, suppose the user
5268 * requests a GL_LUMINANCE texture but the driver stores it as RGBA.
5269 * Again, we'll get pixel values like (l,l,l,a).
5272 _mesa_rebase_rgba_float(GLuint n
, GLfloat rgba
[][4], GLenum baseFormat
)
5276 switch (baseFormat
) {
5278 for (i
= 0; i
< n
; i
++) {
5279 rgba
[i
][RCOMP
] = 0.0F
;
5280 rgba
[i
][GCOMP
] = 0.0F
;
5281 rgba
[i
][BCOMP
] = 0.0F
;
5287 for (i
= 0; i
< n
; i
++) {
5288 rgba
[i
][GCOMP
] = 0.0F
;
5289 rgba
[i
][BCOMP
] = 0.0F
;
5290 rgba
[i
][ACOMP
] = 1.0F
;
5293 case GL_LUMINANCE_ALPHA
:
5294 for (i
= 0; i
< n
; i
++) {
5295 rgba
[i
][GCOMP
] = 0.0F
;
5296 rgba
[i
][BCOMP
] = 0.0F
;
5307 * As above, but GLuint components.
5310 _mesa_rebase_rgba_uint(GLuint n
, GLuint rgba
[][4], GLenum baseFormat
)
5314 switch (baseFormat
) {
5316 for (i
= 0; i
< n
; i
++) {
5325 for (i
= 0; i
< n
; i
++) {
5331 case GL_LUMINANCE_ALPHA
:
5332 for (i
= 0; i
< n
; i
++) {