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.
39 #include "pixeltransfer.h"
41 #include "../../gallium/auxiliary/util/u_format_rgb9e5.h"
42 #include "../../gallium/auxiliary/util/u_format_r11g11b10f.h"
47 * Normally, BYTE_TO_FLOAT(0) returns 0.00392 That causes problems when
48 * we later convert the float to a packed integer value (such as for
49 * GL_RGB5_A1) because we'll wind up with a non-zero value.
51 * We redefine the macros here so zero is handled correctly.
54 #define BYTE_TO_FLOAT(B) ((B) == 0 ? 0.0F : ((2.0F * (B) + 1.0F) * (1.0F/255.0F)))
57 #define SHORT_TO_FLOAT(S) ((S) == 0 ? 0.0F : ((2.0F * (S) + 1.0F) * (1.0F/65535.0F)))
61 /** Compute ceiling of integer quotient of A divided by B. */
62 #define CEILING( A, B ) ( (A) % (B) == 0 ? (A)/(B) : (A)/(B)+1 )
66 * Flip the 8 bits in each byte of the given array.
69 * \param n number of bytes.
71 * \todo try this trick to flip bytes someday:
73 * v = ((v & 0x55555555) << 1) | ((v >> 1) & 0x55555555);
74 * v = ((v & 0x33333333) << 2) | ((v >> 2) & 0x33333333);
75 * v = ((v & 0x0f0f0f0f) << 4) | ((v >> 4) & 0x0f0f0f0f);
79 flip_bytes( GLubyte
*p
, GLuint n
)
82 for (i
= 0; i
< n
; i
++) {
83 b
= (GLuint
) p
[i
]; /* words are often faster than bytes */
84 a
= ((b
& 0x01) << 7) |
99 * Unpack a 32x32 pixel polygon stipple from user memory using the
100 * current pixel unpack settings.
103 _mesa_unpack_polygon_stipple( const GLubyte
*pattern
, GLuint dest
[32],
104 const struct gl_pixelstore_attrib
*unpacking
)
106 GLubyte
*ptrn
= (GLubyte
*) _mesa_unpack_bitmap(32, 32, pattern
, unpacking
);
108 /* Convert pattern from GLubytes to GLuints and handle big/little
113 for (i
= 0; i
< 32; i
++) {
114 dest
[i
] = (p
[0] << 24)
126 * Pack polygon stipple into user memory given current pixel packing
130 _mesa_pack_polygon_stipple( const GLuint pattern
[32], GLubyte
*dest
,
131 const struct gl_pixelstore_attrib
*packing
)
133 /* Convert pattern from GLuints to GLubytes to handle big/little
134 * endian differences.
138 for (i
= 0; i
< 32; i
++) {
139 ptrn
[i
* 4 + 0] = (GLubyte
) ((pattern
[i
] >> 24) & 0xff);
140 ptrn
[i
* 4 + 1] = (GLubyte
) ((pattern
[i
] >> 16) & 0xff);
141 ptrn
[i
* 4 + 2] = (GLubyte
) ((pattern
[i
] >> 8 ) & 0xff);
142 ptrn
[i
* 4 + 3] = (GLubyte
) ((pattern
[i
] ) & 0xff);
145 _mesa_pack_bitmap(32, 32, ptrn
, dest
, packing
);
150 * Unpack bitmap data. Resulting data will be in most-significant-bit-first
151 * order with row alignment = 1 byte.
154 _mesa_unpack_bitmap( GLint width
, GLint height
, const GLubyte
*pixels
,
155 const struct gl_pixelstore_attrib
*packing
)
157 GLint bytes
, row
, width_in_bytes
;
158 GLubyte
*buffer
, *dst
;
163 /* Alloc dest storage */
164 bytes
= ((width
+ 7) / 8 * height
);
165 buffer
= (GLubyte
*) malloc( bytes
);
169 width_in_bytes
= CEILING( width
, 8 );
171 for (row
= 0; row
< height
; row
++) {
172 const GLubyte
*src
= (const GLubyte
*)
173 _mesa_image_address2d(packing
, pixels
, width
, height
,
174 GL_COLOR_INDEX
, GL_BITMAP
, row
, 0);
180 if ((packing
->SkipPixels
& 7) == 0) {
181 memcpy( dst
, src
, width_in_bytes
);
182 if (packing
->LsbFirst
) {
183 flip_bytes( dst
, width_in_bytes
);
187 /* handling SkipPixels is a bit tricky (no pun intended!) */
189 if (packing
->LsbFirst
) {
190 GLubyte srcMask
= 1 << (packing
->SkipPixels
& 0x7);
191 GLubyte dstMask
= 128;
192 const GLubyte
*s
= src
;
195 for (i
= 0; i
< width
; i
++) {
199 if (srcMask
== 128) {
204 srcMask
= srcMask
<< 1;
212 dstMask
= dstMask
>> 1;
217 GLubyte srcMask
= 128 >> (packing
->SkipPixels
& 0x7);
218 GLubyte dstMask
= 128;
219 const GLubyte
*s
= src
;
222 for (i
= 0; i
< width
; i
++) {
231 srcMask
= srcMask
>> 1;
239 dstMask
= dstMask
>> 1;
244 dst
+= width_in_bytes
;
255 _mesa_pack_bitmap( GLint width
, GLint height
, const GLubyte
*source
,
256 GLubyte
*dest
, const struct gl_pixelstore_attrib
*packing
)
258 GLint row
, width_in_bytes
;
264 width_in_bytes
= CEILING( width
, 8 );
266 for (row
= 0; row
< height
; row
++) {
267 GLubyte
*dst
= (GLubyte
*) _mesa_image_address2d(packing
, dest
,
268 width
, height
, GL_COLOR_INDEX
, GL_BITMAP
, row
, 0);
272 if ((packing
->SkipPixels
& 7) == 0) {
273 memcpy( dst
, src
, width_in_bytes
);
274 if (packing
->LsbFirst
) {
275 flip_bytes( dst
, width_in_bytes
);
279 /* handling SkipPixels is a bit tricky (no pun intended!) */
281 if (packing
->LsbFirst
) {
282 GLubyte srcMask
= 128;
283 GLubyte dstMask
= 1 << (packing
->SkipPixels
& 0x7);
284 const GLubyte
*s
= src
;
287 for (i
= 0; i
< width
; i
++) {
296 srcMask
= srcMask
>> 1;
298 if (dstMask
== 128) {
304 dstMask
= dstMask
<< 1;
309 GLubyte srcMask
= 128;
310 GLubyte dstMask
= 128 >> (packing
->SkipPixels
& 0x7);
311 const GLubyte
*s
= src
;
314 for (i
= 0; i
< width
; i
++) {
323 srcMask
= srcMask
>> 1;
331 dstMask
= dstMask
>> 1;
336 src
+= width_in_bytes
;
342 * Get indexes of color components for a basic color format, such as
343 * GL_RGBA, GL_RED, GL_LUMINANCE_ALPHA, etc. Return -1 for indexes
347 get_component_indexes(GLenum format
,
352 GLint
*luminanceIndex
,
353 GLint
*intensityIndex
)
359 *luminanceIndex
= -1;
360 *intensityIndex
= -1;
364 case GL_LUMINANCE_INTEGER_EXT
:
367 case GL_LUMINANCE_ALPHA
:
368 case GL_LUMINANCE_ALPHA_INTEGER_EXT
:
376 case GL_RED_INTEGER_EXT
:
380 case GL_GREEN_INTEGER_EXT
:
384 case GL_BLUE_INTEGER_EXT
:
388 case GL_ALPHA_INTEGER_EXT
:
397 case GL_RGB_INTEGER_EXT
:
403 case GL_BGR_INTEGER_EXT
:
409 case GL_RGBA_INTEGER_EXT
:
416 case GL_BGRA_INTEGER
:
434 assert(0 && "bad format in get_component_indexes()");
441 * For small integer types, return the min and max possible values.
442 * Used for clamping floats to unscaled integer types.
443 * \return GL_TRUE if type is handled, GL_FALSE otherwise.
446 get_type_min_max(GLenum type
, GLfloat
*min
, GLfloat
*max
)
453 case GL_UNSIGNED_BYTE
:
461 case GL_UNSIGNED_SHORT
:
471 * integer packing , no transfer operations only packs
472 * to dst of GL_UNSIGNED_INT or GL_INT
475 _mesa_pack_rgba_span_int(struct gl_context
*ctx
, GLuint n
, GLuint rgba
[][4],
476 GLenum dstFormat
, GLenum dstType
,
482 case GL_UNSIGNED_INT
: {
483 GLuint
*dst
= (GLuint
*) dstAddr
;
485 case GL_RED_INTEGER_EXT
:
486 case GL_GREEN_INTEGER_EXT
:
487 case GL_BLUE_INTEGER_EXT
:
488 case GL_ALPHA_INTEGER_EXT
:
489 case GL_RGB_INTEGER_EXT
:
490 case GL_RGBA_INTEGER_EXT
:
491 case GL_BGR_INTEGER_EXT
:
492 case GL_BGRA_INTEGER_EXT
:
493 case GL_LUMINANCE_INTEGER_EXT
:
494 case GL_LUMINANCE_ALPHA_INTEGER_EXT
:
496 dst
[i
*4+0] = (GLuint
) rgba
[i
][RCOMP
];
497 dst
[i
*4+1] = (GLuint
) rgba
[i
][GCOMP
];
498 dst
[i
*4+2] = (GLuint
) rgba
[i
][BCOMP
];
499 dst
[i
*4+3] = (GLuint
) rgba
[i
][ACOMP
];
506 GLint
*dst
= (GLint
*) dstAddr
;
508 case GL_RED_INTEGER_EXT
:
509 case GL_GREEN_INTEGER_EXT
:
510 case GL_BLUE_INTEGER_EXT
:
511 case GL_ALPHA_INTEGER_EXT
:
512 case GL_RGB_INTEGER_EXT
:
513 case GL_RGBA_INTEGER_EXT
:
514 case GL_BGR_INTEGER_EXT
:
515 case GL_BGRA_INTEGER_EXT
:
516 case GL_LUMINANCE_INTEGER_EXT
:
517 case GL_LUMINANCE_ALPHA_INTEGER_EXT
:
519 dst
[i
*4+0] = (GLint
) rgba
[i
][RCOMP
];
520 dst
[i
*4+1] = (GLint
) rgba
[i
][GCOMP
];
521 dst
[i
*4+2] = (GLint
) rgba
[i
][BCOMP
];
522 dst
[i
*4+3] = (GLint
) rgba
[i
][ACOMP
];
536 * Used to pack an array [][4] of RGBA float colors as specified
537 * by the dstFormat, dstType and dstPacking. Used by glReadPixels.
538 * Historically, the RGBA values were in [0,1] and rescaled to fit
539 * into GLubytes, etc. But with new integer formats, the RGBA values
540 * may have any value and we don't always rescale when converting to
543 * Note: the rgba values will be modified by this function when any pixel
544 * transfer ops are enabled.
547 _mesa_pack_rgba_span_float(struct gl_context
*ctx
, GLuint n
, GLfloat rgba
[][4],
548 GLenum dstFormat
, GLenum dstType
,
550 const struct gl_pixelstore_attrib
*dstPacking
,
551 GLbitfield transferOps
)
554 const GLint comps
= _mesa_components_in_format(dstFormat
);
555 const GLboolean intDstFormat
= _mesa_is_integer_format(dstFormat
);
558 if (dstFormat
== GL_LUMINANCE
||
559 dstFormat
== GL_LUMINANCE_ALPHA
||
560 dstFormat
== GL_LUMINANCE_INTEGER_EXT
||
561 dstFormat
== GL_LUMINANCE_ALPHA_INTEGER_EXT
) {
562 luminance
= (GLfloat
*) malloc(n
* sizeof(GLfloat
));
564 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "pixel packing");
572 /* EXT_texture_integer specifies no transfer ops on integer
573 * types in the resolved issues section. Just set them to 0
574 * for integer surfaces.
580 _mesa_apply_rgba_transfer_ops(ctx
, transferOps
, n
, rgba
);
584 * Component clamping (besides clamping to [0,1] in
585 * _mesa_apply_rgba_transfer_ops()).
588 /* clamping to dest type's min/max values */
590 if (get_type_min_max(dstType
, &min
, &max
)) {
591 for (i
= 0; i
< n
; i
++) {
592 rgba
[i
][RCOMP
] = CLAMP(rgba
[i
][RCOMP
], min
, max
);
593 rgba
[i
][GCOMP
] = CLAMP(rgba
[i
][GCOMP
], min
, max
);
594 rgba
[i
][BCOMP
] = CLAMP(rgba
[i
][BCOMP
], min
, max
);
595 rgba
[i
][ACOMP
] = CLAMP(rgba
[i
][ACOMP
], min
, max
);
599 else if (dstFormat
== GL_LUMINANCE
|| dstFormat
== GL_LUMINANCE_ALPHA
) {
600 /* compute luminance values */
601 if (transferOps
& IMAGE_CLAMP_BIT
) {
602 for (i
= 0; i
< n
; i
++) {
603 GLfloat sum
= rgba
[i
][RCOMP
] + rgba
[i
][GCOMP
] + rgba
[i
][BCOMP
];
604 luminance
[i
] = CLAMP(sum
, 0.0F
, 1.0F
);
608 for (i
= 0; i
< n
; i
++) {
609 luminance
[i
] = rgba
[i
][RCOMP
] + rgba
[i
][GCOMP
] + rgba
[i
][BCOMP
];
615 * Pack/store the pixels. Ugh! Lots of cases!!!
618 case GL_UNSIGNED_BYTE
:
620 GLubyte
*dst
= (GLubyte
*) dstAddr
;
624 dst
[i
] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
628 dst
[i
] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
632 dst
[i
] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
636 dst
[i
] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
640 dst
[i
] = FLOAT_TO_UBYTE(luminance
[i
]);
642 case GL_LUMINANCE_ALPHA
:
644 dst
[i
*2+0] = FLOAT_TO_UBYTE(luminance
[i
]);
645 dst
[i
*2+1] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
650 dst
[i
*2+0] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
651 dst
[i
*2+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
656 dst
[i
*3+0] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
657 dst
[i
*3+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
658 dst
[i
*3+2] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
663 dst
[i
*4+0] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
664 dst
[i
*4+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
665 dst
[i
*4+2] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
666 dst
[i
*4+3] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
671 dst
[i
*3+0] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
672 dst
[i
*3+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
673 dst
[i
*3+2] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
678 dst
[i
*4+0] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
679 dst
[i
*4+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
680 dst
[i
*4+2] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
681 dst
[i
*4+3] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
686 dst
[i
*4+0] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
687 dst
[i
*4+1] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
688 dst
[i
*4+2] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
689 dst
[i
*4+3] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
692 case GL_RED_INTEGER_EXT
:
694 dst
[i
] = (GLubyte
) rgba
[i
][RCOMP
];
697 case GL_GREEN_INTEGER_EXT
:
699 dst
[i
] = (GLubyte
) rgba
[i
][GCOMP
];
702 case GL_BLUE_INTEGER_EXT
:
704 dst
[i
] = (GLubyte
) rgba
[i
][BCOMP
];
707 case GL_ALPHA_INTEGER_EXT
:
709 dst
[i
] = (GLubyte
) rgba
[i
][ACOMP
];
712 case GL_RGB_INTEGER_EXT
:
714 dst
[i
*3+0] = (GLubyte
) rgba
[i
][RCOMP
];
715 dst
[i
*3+1] = (GLubyte
) rgba
[i
][GCOMP
];
716 dst
[i
*3+2] = (GLubyte
) rgba
[i
][BCOMP
];
719 case GL_RGBA_INTEGER_EXT
:
721 dst
[i
*4+0] = (GLubyte
) rgba
[i
][RCOMP
];
722 dst
[i
*4+1] = (GLubyte
) rgba
[i
][GCOMP
];
723 dst
[i
*4+2] = (GLubyte
) rgba
[i
][BCOMP
];
724 dst
[i
*4+3] = (GLubyte
) rgba
[i
][ACOMP
];
727 case GL_BGR_INTEGER_EXT
:
729 dst
[i
*3+0] = (GLubyte
) rgba
[i
][BCOMP
];
730 dst
[i
*3+1] = (GLubyte
) rgba
[i
][GCOMP
];
731 dst
[i
*3+2] = (GLubyte
) rgba
[i
][RCOMP
];
734 case GL_BGRA_INTEGER_EXT
:
736 dst
[i
*4+0] = (GLubyte
) rgba
[i
][BCOMP
];
737 dst
[i
*4+1] = (GLubyte
) rgba
[i
][GCOMP
];
738 dst
[i
*4+2] = (GLubyte
) rgba
[i
][RCOMP
];
739 dst
[i
*4+3] = (GLubyte
) rgba
[i
][ACOMP
];
742 case GL_LUMINANCE_INTEGER_EXT
:
744 dst
[i
*2+0] = (GLubyte
) (rgba
[i
][RCOMP
] +
747 dst
[i
*2+1] = (GLubyte
) rgba
[i
][ACOMP
];
750 case GL_LUMINANCE_ALPHA_INTEGER_EXT
:
752 dst
[i
] = (GLubyte
) (rgba
[i
][RCOMP
] +
760 dst
[i
*2+0] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
761 dst
[i
*2+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
765 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
771 GLbyte
*dst
= (GLbyte
*) dstAddr
;
775 dst
[i
] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
779 dst
[i
] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
783 dst
[i
] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
787 dst
[i
] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
791 dst
[i
] = FLOAT_TO_BYTE(luminance
[i
]);
793 case GL_LUMINANCE_ALPHA
:
795 dst
[i
*2+0] = FLOAT_TO_BYTE(luminance
[i
]);
796 dst
[i
*2+1] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
801 dst
[i
*2+0] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
802 dst
[i
*2+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
807 dst
[i
*3+0] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
808 dst
[i
*3+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
809 dst
[i
*3+2] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
814 dst
[i
*4+0] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
815 dst
[i
*4+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
816 dst
[i
*4+2] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
817 dst
[i
*4+3] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
822 dst
[i
*3+0] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
823 dst
[i
*3+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
824 dst
[i
*3+2] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
829 dst
[i
*4+0] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
830 dst
[i
*4+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
831 dst
[i
*4+2] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
832 dst
[i
*4+3] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
837 dst
[i
*4+0] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
838 dst
[i
*4+1] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
839 dst
[i
*4+2] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
840 dst
[i
*4+3] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
843 case GL_RED_INTEGER_EXT
:
845 dst
[i
] = (GLbyte
) rgba
[i
][RCOMP
];
848 case GL_GREEN_INTEGER_EXT
:
850 dst
[i
] = (GLbyte
) rgba
[i
][GCOMP
];
853 case GL_BLUE_INTEGER_EXT
:
855 dst
[i
] = (GLbyte
) rgba
[i
][BCOMP
];
858 case GL_ALPHA_INTEGER_EXT
:
860 dst
[i
] = (GLbyte
) rgba
[i
][ACOMP
];
863 case GL_RGB_INTEGER_EXT
:
865 dst
[i
*3+0] = (GLbyte
) rgba
[i
][RCOMP
];
866 dst
[i
*3+1] = (GLbyte
) rgba
[i
][GCOMP
];
867 dst
[i
*3+2] = (GLbyte
) rgba
[i
][BCOMP
];
870 case GL_RGBA_INTEGER_EXT
:
872 dst
[i
*4+0] = (GLbyte
) rgba
[i
][RCOMP
];
873 dst
[i
*4+1] = (GLbyte
) rgba
[i
][GCOMP
];
874 dst
[i
*4+2] = (GLbyte
) rgba
[i
][BCOMP
];
875 dst
[i
*4+3] = (GLbyte
) rgba
[i
][ACOMP
];
878 case GL_BGR_INTEGER_EXT
:
880 dst
[i
*3+0] = (GLbyte
) rgba
[i
][BCOMP
];
881 dst
[i
*3+1] = (GLbyte
) rgba
[i
][GCOMP
];
882 dst
[i
*3+2] = (GLbyte
) rgba
[i
][RCOMP
];
885 case GL_BGRA_INTEGER_EXT
:
887 dst
[i
*4+0] = (GLbyte
) rgba
[i
][BCOMP
];
888 dst
[i
*4+1] = (GLbyte
) rgba
[i
][GCOMP
];
889 dst
[i
*4+2] = (GLbyte
) rgba
[i
][RCOMP
];
890 dst
[i
*4+3] = (GLbyte
) rgba
[i
][ACOMP
];
893 case GL_LUMINANCE_INTEGER_EXT
:
895 dst
[i
*2+0] = (GLbyte
) (rgba
[i
][RCOMP
] +
898 dst
[i
*2+1] = (GLbyte
) rgba
[i
][ACOMP
];
901 case GL_LUMINANCE_ALPHA_INTEGER_EXT
:
903 dst
[i
] = (GLbyte
) (rgba
[i
][RCOMP
] +
911 dst
[i
*2+0] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
912 dst
[i
*2+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
916 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
920 case GL_UNSIGNED_SHORT
:
922 GLushort
*dst
= (GLushort
*) dstAddr
;
926 CLAMPED_FLOAT_TO_USHORT(dst
[i
], rgba
[i
][RCOMP
]);
930 CLAMPED_FLOAT_TO_USHORT(dst
[i
], rgba
[i
][GCOMP
]);
934 CLAMPED_FLOAT_TO_USHORT(dst
[i
], rgba
[i
][BCOMP
]);
938 CLAMPED_FLOAT_TO_USHORT(dst
[i
], rgba
[i
][ACOMP
]);
942 UNCLAMPED_FLOAT_TO_USHORT(dst
[i
], luminance
[i
]);
944 case GL_LUMINANCE_ALPHA
:
946 UNCLAMPED_FLOAT_TO_USHORT(dst
[i
*2+0], luminance
[i
]);
947 CLAMPED_FLOAT_TO_USHORT(dst
[i
*2+1], rgba
[i
][ACOMP
]);
952 CLAMPED_FLOAT_TO_USHORT(dst
[i
*2+0], rgba
[i
][RCOMP
]);
953 CLAMPED_FLOAT_TO_USHORT(dst
[i
*2+1], rgba
[i
][GCOMP
]);
958 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+0], rgba
[i
][RCOMP
]);
959 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+1], rgba
[i
][GCOMP
]);
960 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+2], rgba
[i
][BCOMP
]);
965 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+0], rgba
[i
][RCOMP
]);
966 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+1], rgba
[i
][GCOMP
]);
967 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+2], rgba
[i
][BCOMP
]);
968 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+3], rgba
[i
][ACOMP
]);
973 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+0], rgba
[i
][BCOMP
]);
974 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+1], rgba
[i
][GCOMP
]);
975 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+2], rgba
[i
][RCOMP
]);
980 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+0], rgba
[i
][BCOMP
]);
981 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+1], rgba
[i
][GCOMP
]);
982 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+2], rgba
[i
][RCOMP
]);
983 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+3], rgba
[i
][ACOMP
]);
988 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+0], rgba
[i
][ACOMP
]);
989 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+1], rgba
[i
][BCOMP
]);
990 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+2], rgba
[i
][GCOMP
]);
991 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+3], rgba
[i
][RCOMP
]);
994 case GL_RED_INTEGER_EXT
:
996 dst
[i
] = (GLushort
) rgba
[i
][RCOMP
];
999 case GL_GREEN_INTEGER_EXT
:
1001 dst
[i
] = (GLushort
) rgba
[i
][GCOMP
];
1004 case GL_BLUE_INTEGER_EXT
:
1006 dst
[i
] = (GLushort
) rgba
[i
][BCOMP
];
1009 case GL_ALPHA_INTEGER_EXT
:
1011 dst
[i
] = (GLushort
) rgba
[i
][ACOMP
];
1014 case GL_RGB_INTEGER_EXT
:
1016 dst
[i
*3+0] = (GLushort
) rgba
[i
][RCOMP
];
1017 dst
[i
*3+1] = (GLushort
) rgba
[i
][GCOMP
];
1018 dst
[i
*3+2] = (GLushort
) rgba
[i
][BCOMP
];
1021 case GL_RGBA_INTEGER_EXT
:
1023 dst
[i
*4+0] = (GLushort
) rgba
[i
][RCOMP
];
1024 dst
[i
*4+1] = (GLushort
) rgba
[i
][GCOMP
];
1025 dst
[i
*4+2] = (GLushort
) rgba
[i
][BCOMP
];
1026 dst
[i
*4+3] = (GLushort
) rgba
[i
][ACOMP
];
1029 case GL_BGR_INTEGER_EXT
:
1031 dst
[i
*3+0] = (GLushort
) rgba
[i
][BCOMP
];
1032 dst
[i
*3+1] = (GLushort
) rgba
[i
][GCOMP
];
1033 dst
[i
*3+2] = (GLushort
) rgba
[i
][RCOMP
];
1036 case GL_BGRA_INTEGER_EXT
:
1038 dst
[i
*4+0] = (GLushort
) rgba
[i
][BCOMP
];
1039 dst
[i
*4+1] = (GLushort
) rgba
[i
][GCOMP
];
1040 dst
[i
*4+2] = (GLushort
) rgba
[i
][RCOMP
];
1041 dst
[i
*4+3] = (GLushort
) rgba
[i
][ACOMP
];
1044 case GL_LUMINANCE_INTEGER_EXT
:
1046 dst
[i
*2+0] = (GLushort
) (rgba
[i
][RCOMP
] +
1049 dst
[i
*2+1] = (GLushort
) rgba
[i
][ACOMP
];
1052 case GL_LUMINANCE_ALPHA_INTEGER_EXT
:
1054 dst
[i
] = (GLushort
) (rgba
[i
][RCOMP
] +
1062 dst
[i
*2+0] = FLOAT_TO_USHORT(rgba
[i
][RCOMP
]);
1063 dst
[i
*2+1] = FLOAT_TO_USHORT(rgba
[i
][GCOMP
]);
1067 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1073 GLshort
*dst
= (GLshort
*) dstAddr
;
1074 switch (dstFormat
) {
1077 dst
[i
] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1081 dst
[i
] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1085 dst
[i
] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1089 dst
[i
] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
1093 dst
[i
] = FLOAT_TO_SHORT(luminance
[i
]);
1095 case GL_LUMINANCE_ALPHA
:
1097 dst
[i
*2+0] = FLOAT_TO_SHORT(luminance
[i
]);
1098 dst
[i
*2+1] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
1103 dst
[i
*2+0] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1104 dst
[i
*2+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1109 dst
[i
*3+0] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1110 dst
[i
*3+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1111 dst
[i
*3+2] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1116 dst
[i
*4+0] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1117 dst
[i
*4+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1118 dst
[i
*4+2] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1119 dst
[i
*4+3] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
1124 dst
[i
*3+0] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1125 dst
[i
*3+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1126 dst
[i
*3+2] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1131 dst
[i
*4+0] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1132 dst
[i
*4+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1133 dst
[i
*4+2] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1134 dst
[i
*4+3] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
1139 dst
[i
*4+0] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
1140 dst
[i
*4+1] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1141 dst
[i
*4+2] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1142 dst
[i
*4+3] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1145 case GL_RED_INTEGER_EXT
:
1147 dst
[i
] = (GLshort
) rgba
[i
][RCOMP
];
1150 case GL_GREEN_INTEGER_EXT
:
1152 dst
[i
] = (GLshort
) rgba
[i
][GCOMP
];
1155 case GL_BLUE_INTEGER_EXT
:
1157 dst
[i
] = (GLshort
) rgba
[i
][BCOMP
];
1160 case GL_ALPHA_INTEGER_EXT
:
1162 dst
[i
] = (GLshort
) rgba
[i
][ACOMP
];
1165 case GL_RGB_INTEGER_EXT
:
1167 dst
[i
*3+0] = (GLshort
) rgba
[i
][RCOMP
];
1168 dst
[i
*3+1] = (GLshort
) rgba
[i
][GCOMP
];
1169 dst
[i
*3+2] = (GLshort
) rgba
[i
][BCOMP
];
1172 case GL_RGBA_INTEGER_EXT
:
1174 dst
[i
*4+0] = (GLshort
) rgba
[i
][RCOMP
];
1175 dst
[i
*4+1] = (GLshort
) rgba
[i
][GCOMP
];
1176 dst
[i
*4+2] = (GLshort
) rgba
[i
][BCOMP
];
1177 dst
[i
*4+3] = (GLshort
) rgba
[i
][ACOMP
];
1180 case GL_BGR_INTEGER_EXT
:
1182 dst
[i
*3+0] = (GLshort
) rgba
[i
][BCOMP
];
1183 dst
[i
*3+1] = (GLshort
) rgba
[i
][GCOMP
];
1184 dst
[i
*3+2] = (GLshort
) rgba
[i
][RCOMP
];
1187 case GL_BGRA_INTEGER_EXT
:
1189 dst
[i
*4+0] = (GLshort
) rgba
[i
][BCOMP
];
1190 dst
[i
*4+1] = (GLshort
) rgba
[i
][GCOMP
];
1191 dst
[i
*4+2] = (GLshort
) rgba
[i
][RCOMP
];
1192 dst
[i
*4+3] = (GLshort
) rgba
[i
][ACOMP
];
1195 case GL_LUMINANCE_INTEGER_EXT
:
1197 dst
[i
*2+0] = (GLshort
) (rgba
[i
][RCOMP
] +
1200 dst
[i
*2+1] = (GLshort
) rgba
[i
][ACOMP
];
1203 case GL_LUMINANCE_ALPHA_INTEGER_EXT
:
1205 dst
[i
] = (GLshort
) (rgba
[i
][RCOMP
] +
1213 dst
[i
*2+0] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1214 dst
[i
*2+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1218 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1222 case GL_UNSIGNED_INT
:
1224 GLuint
*dst
= (GLuint
*) dstAddr
;
1225 switch (dstFormat
) {
1228 dst
[i
] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1232 dst
[i
] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1236 dst
[i
] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1240 dst
[i
] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
1244 dst
[i
] = FLOAT_TO_UINT(luminance
[i
]);
1246 case GL_LUMINANCE_ALPHA
:
1248 dst
[i
*2+0] = FLOAT_TO_UINT(luminance
[i
]);
1249 dst
[i
*2+1] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
1254 dst
[i
*2+0] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1255 dst
[i
*2+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1260 dst
[i
*3+0] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1261 dst
[i
*3+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1262 dst
[i
*3+2] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1267 dst
[i
*4+0] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1268 dst
[i
*4+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1269 dst
[i
*4+2] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1270 dst
[i
*4+3] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
1275 dst
[i
*3+0] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1276 dst
[i
*3+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1277 dst
[i
*3+2] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1282 dst
[i
*4+0] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1283 dst
[i
*4+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1284 dst
[i
*4+2] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1285 dst
[i
*4+3] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
1290 dst
[i
*4+0] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
1291 dst
[i
*4+1] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1292 dst
[i
*4+2] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1293 dst
[i
*4+3] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1296 case GL_RED_INTEGER_EXT
:
1298 dst
[i
] = (GLuint
) rgba
[i
][RCOMP
];
1301 case GL_GREEN_INTEGER_EXT
:
1303 dst
[i
] = (GLuint
) rgba
[i
][GCOMP
];
1306 case GL_BLUE_INTEGER_EXT
:
1308 dst
[i
] = (GLuint
) rgba
[i
][BCOMP
];
1311 case GL_ALPHA_INTEGER_EXT
:
1313 dst
[i
] = (GLuint
) rgba
[i
][ACOMP
];
1316 case GL_RGB_INTEGER_EXT
:
1318 dst
[i
*3+0] = (GLuint
) rgba
[i
][RCOMP
];
1319 dst
[i
*3+1] = (GLuint
) rgba
[i
][GCOMP
];
1320 dst
[i
*3+2] = (GLuint
) rgba
[i
][BCOMP
];
1323 case GL_RGBA_INTEGER_EXT
:
1325 dst
[i
*4+0] = (GLuint
) rgba
[i
][RCOMP
];
1326 dst
[i
*4+1] = (GLuint
) rgba
[i
][GCOMP
];
1327 dst
[i
*4+2] = (GLuint
) rgba
[i
][BCOMP
];
1328 dst
[i
*4+3] = (GLuint
) rgba
[i
][ACOMP
];
1331 case GL_BGR_INTEGER_EXT
:
1333 dst
[i
*3+0] = (GLuint
) rgba
[i
][BCOMP
];
1334 dst
[i
*3+1] = (GLuint
) rgba
[i
][GCOMP
];
1335 dst
[i
*3+2] = (GLuint
) rgba
[i
][RCOMP
];
1338 case GL_BGRA_INTEGER_EXT
:
1340 dst
[i
*4+0] = (GLuint
) rgba
[i
][BCOMP
];
1341 dst
[i
*4+1] = (GLuint
) rgba
[i
][GCOMP
];
1342 dst
[i
*4+2] = (GLuint
) rgba
[i
][RCOMP
];
1343 dst
[i
*4+3] = (GLuint
) rgba
[i
][ACOMP
];
1346 case GL_LUMINANCE_INTEGER_EXT
:
1348 dst
[i
*2+0] = (GLuint
) (rgba
[i
][RCOMP
] +
1351 dst
[i
*2+1] = (GLuint
) rgba
[i
][ACOMP
];
1354 case GL_LUMINANCE_ALPHA_INTEGER_EXT
:
1356 dst
[i
] = (GLuint
) (rgba
[i
][RCOMP
] +
1364 dst
[i
*2+0] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1365 dst
[i
*2+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1369 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1375 GLint
*dst
= (GLint
*) dstAddr
;
1376 switch (dstFormat
) {
1379 dst
[i
] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1383 dst
[i
] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1387 dst
[i
] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1391 dst
[i
] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
1395 dst
[i
] = FLOAT_TO_INT(luminance
[i
]);
1397 case GL_LUMINANCE_ALPHA
:
1399 dst
[i
*2+0] = FLOAT_TO_INT(luminance
[i
]);
1400 dst
[i
*2+1] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
1405 dst
[i
*2+0] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1406 dst
[i
*2+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1411 dst
[i
*3+0] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1412 dst
[i
*3+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1413 dst
[i
*3+2] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1418 dst
[i
*4+0] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1419 dst
[i
*4+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1420 dst
[i
*4+2] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1421 dst
[i
*4+3] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
1426 dst
[i
*3+0] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1427 dst
[i
*3+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1428 dst
[i
*3+2] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1433 dst
[i
*4+0] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1434 dst
[i
*4+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1435 dst
[i
*4+2] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1436 dst
[i
*4+3] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
1441 dst
[i
*4+0] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
1442 dst
[i
*4+1] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1443 dst
[i
*4+2] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1444 dst
[i
*4+3] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1450 dst
[i
*2+0] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1451 dst
[i
*2+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1454 case GL_RED_INTEGER_EXT
:
1456 dst
[i
] = (GLint
) rgba
[i
][RCOMP
];
1459 case GL_GREEN_INTEGER_EXT
:
1461 dst
[i
] = (GLint
) rgba
[i
][GCOMP
];
1464 case GL_BLUE_INTEGER_EXT
:
1466 dst
[i
] = (GLint
) rgba
[i
][BCOMP
];
1469 case GL_ALPHA_INTEGER_EXT
:
1471 dst
[i
] = (GLint
) rgba
[i
][ACOMP
];
1474 case GL_RGB_INTEGER_EXT
:
1476 dst
[i
*3+0] = (GLint
) rgba
[i
][RCOMP
];
1477 dst
[i
*3+1] = (GLint
) rgba
[i
][GCOMP
];
1478 dst
[i
*3+2] = (GLint
) rgba
[i
][BCOMP
];
1481 case GL_RGBA_INTEGER_EXT
:
1483 dst
[i
*4+0] = (GLint
) rgba
[i
][RCOMP
];
1484 dst
[i
*4+1] = (GLint
) rgba
[i
][GCOMP
];
1485 dst
[i
*4+2] = (GLint
) rgba
[i
][BCOMP
];
1486 dst
[i
*4+3] = (GLint
) rgba
[i
][ACOMP
];
1489 case GL_BGR_INTEGER_EXT
:
1491 dst
[i
*3+0] = (GLint
) rgba
[i
][BCOMP
];
1492 dst
[i
*3+1] = (GLint
) rgba
[i
][GCOMP
];
1493 dst
[i
*3+2] = (GLint
) rgba
[i
][RCOMP
];
1496 case GL_BGRA_INTEGER_EXT
:
1498 dst
[i
*4+0] = (GLint
) rgba
[i
][BCOMP
];
1499 dst
[i
*4+1] = (GLint
) rgba
[i
][GCOMP
];
1500 dst
[i
*4+2] = (GLint
) rgba
[i
][RCOMP
];
1501 dst
[i
*4+3] = (GLint
) rgba
[i
][ACOMP
];
1504 case GL_LUMINANCE_INTEGER_EXT
:
1506 dst
[i
*2+0] = (GLint
) (rgba
[i
][RCOMP
] +
1509 dst
[i
*2+1] = (GLint
) rgba
[i
][ACOMP
];
1512 case GL_LUMINANCE_ALPHA_INTEGER_EXT
:
1514 dst
[i
] = (GLint
) (rgba
[i
][RCOMP
] +
1520 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1526 GLfloat
*dst
= (GLfloat
*) dstAddr
;
1527 switch (dstFormat
) {
1530 dst
[i
] = rgba
[i
][RCOMP
];
1534 dst
[i
] = rgba
[i
][GCOMP
];
1538 dst
[i
] = rgba
[i
][BCOMP
];
1542 dst
[i
] = rgba
[i
][ACOMP
];
1546 dst
[i
] = luminance
[i
];
1548 case GL_LUMINANCE_ALPHA
:
1550 dst
[i
*2+0] = luminance
[i
];
1551 dst
[i
*2+1] = rgba
[i
][ACOMP
];
1556 dst
[i
*2+0] = rgba
[i
][RCOMP
];
1557 dst
[i
*2+1] = rgba
[i
][GCOMP
];
1562 dst
[i
*3+0] = rgba
[i
][RCOMP
];
1563 dst
[i
*3+1] = rgba
[i
][GCOMP
];
1564 dst
[i
*3+2] = rgba
[i
][BCOMP
];
1569 dst
[i
*4+0] = rgba
[i
][RCOMP
];
1570 dst
[i
*4+1] = rgba
[i
][GCOMP
];
1571 dst
[i
*4+2] = rgba
[i
][BCOMP
];
1572 dst
[i
*4+3] = rgba
[i
][ACOMP
];
1577 dst
[i
*3+0] = rgba
[i
][BCOMP
];
1578 dst
[i
*3+1] = rgba
[i
][GCOMP
];
1579 dst
[i
*3+2] = rgba
[i
][RCOMP
];
1584 dst
[i
*4+0] = rgba
[i
][BCOMP
];
1585 dst
[i
*4+1] = rgba
[i
][GCOMP
];
1586 dst
[i
*4+2] = rgba
[i
][RCOMP
];
1587 dst
[i
*4+3] = rgba
[i
][ACOMP
];
1592 dst
[i
*4+0] = rgba
[i
][ACOMP
];
1593 dst
[i
*4+1] = rgba
[i
][BCOMP
];
1594 dst
[i
*4+2] = rgba
[i
][GCOMP
];
1595 dst
[i
*4+3] = rgba
[i
][RCOMP
];
1601 dst
[i
*2+0] = rgba
[i
][RCOMP
];
1602 dst
[i
*2+1] = rgba
[i
][GCOMP
];
1606 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1610 case GL_HALF_FLOAT_ARB
:
1612 GLhalfARB
*dst
= (GLhalfARB
*) dstAddr
;
1613 switch (dstFormat
) {
1616 dst
[i
] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1620 dst
[i
] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1624 dst
[i
] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1628 dst
[i
] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
1632 dst
[i
] = _mesa_float_to_half(luminance
[i
]);
1634 case GL_LUMINANCE_ALPHA
:
1636 dst
[i
*2+0] = _mesa_float_to_half(luminance
[i
]);
1637 dst
[i
*2+1] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
1642 dst
[i
*2+0] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1643 dst
[i
*2+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1648 dst
[i
*3+0] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1649 dst
[i
*3+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1650 dst
[i
*3+2] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1655 dst
[i
*4+0] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1656 dst
[i
*4+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1657 dst
[i
*4+2] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1658 dst
[i
*4+3] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
1663 dst
[i
*3+0] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1664 dst
[i
*3+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1665 dst
[i
*3+2] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1670 dst
[i
*4+0] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1671 dst
[i
*4+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1672 dst
[i
*4+2] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1673 dst
[i
*4+3] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
1678 dst
[i
*4+0] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
1679 dst
[i
*4+1] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1680 dst
[i
*4+2] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1681 dst
[i
*4+3] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1687 dst
[i
*2+0] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1688 dst
[i
*2+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1692 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1696 case GL_UNSIGNED_BYTE_3_3_2
:
1697 if (dstFormat
== GL_RGB
) {
1698 GLubyte
*dst
= (GLubyte
*) dstAddr
;
1700 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 7.0F
) << 5)
1701 | (IROUND(rgba
[i
][GCOMP
] * 7.0F
) << 2)
1702 | (IROUND(rgba
[i
][BCOMP
] * 3.0F
) );
1706 case GL_UNSIGNED_BYTE_2_3_3_REV
:
1707 if (dstFormat
== GL_RGB
) {
1708 GLubyte
*dst
= (GLubyte
*) dstAddr
;
1710 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 7.0F
) )
1711 | (IROUND(rgba
[i
][GCOMP
] * 7.0F
) << 3)
1712 | (IROUND(rgba
[i
][BCOMP
] * 3.0F
) << 6);
1716 case GL_UNSIGNED_SHORT_5_6_5
:
1717 if (dstFormat
== GL_RGB
) {
1718 GLushort
*dst
= (GLushort
*) dstAddr
;
1720 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 31.0F
) << 11)
1721 | (IROUND(rgba
[i
][GCOMP
] * 63.0F
) << 5)
1722 | (IROUND(rgba
[i
][BCOMP
] * 31.0F
) );
1726 case GL_UNSIGNED_SHORT_5_6_5_REV
:
1727 if (dstFormat
== GL_RGB
) {
1728 GLushort
*dst
= (GLushort
*) dstAddr
;
1730 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 31.0F
) )
1731 | (IROUND(rgba
[i
][GCOMP
] * 63.0F
) << 5)
1732 | (IROUND(rgba
[i
][BCOMP
] * 31.0F
) << 11);
1736 case GL_UNSIGNED_SHORT_4_4_4_4
:
1737 if (dstFormat
== GL_RGBA
) {
1738 GLushort
*dst
= (GLushort
*) dstAddr
;
1740 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 15.0F
) << 12)
1741 | (IROUND(rgba
[i
][GCOMP
] * 15.0F
) << 8)
1742 | (IROUND(rgba
[i
][BCOMP
] * 15.0F
) << 4)
1743 | (IROUND(rgba
[i
][ACOMP
] * 15.0F
) );
1746 else if (dstFormat
== GL_BGRA
) {
1747 GLushort
*dst
= (GLushort
*) dstAddr
;
1749 dst
[i
] = (IROUND(rgba
[i
][BCOMP
] * 15.0F
) << 12)
1750 | (IROUND(rgba
[i
][GCOMP
] * 15.0F
) << 8)
1751 | (IROUND(rgba
[i
][RCOMP
] * 15.0F
) << 4)
1752 | (IROUND(rgba
[i
][ACOMP
] * 15.0F
) );
1755 else if (dstFormat
== GL_ABGR_EXT
) {
1756 GLushort
*dst
= (GLushort
*) dstAddr
;
1758 dst
[i
] = (IROUND(rgba
[i
][ACOMP
] * 15.0F
) << 12)
1759 | (IROUND(rgba
[i
][BCOMP
] * 15.0F
) << 8)
1760 | (IROUND(rgba
[i
][GCOMP
] * 15.0F
) << 4)
1761 | (IROUND(rgba
[i
][RCOMP
] * 15.0F
) );
1765 case GL_UNSIGNED_SHORT_4_4_4_4_REV
:
1766 if (dstFormat
== GL_RGBA
) {
1767 GLushort
*dst
= (GLushort
*) dstAddr
;
1769 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 15.0F
) )
1770 | (IROUND(rgba
[i
][GCOMP
] * 15.0F
) << 4)
1771 | (IROUND(rgba
[i
][BCOMP
] * 15.0F
) << 8)
1772 | (IROUND(rgba
[i
][ACOMP
] * 15.0F
) << 12);
1775 else if (dstFormat
== GL_BGRA
) {
1776 GLushort
*dst
= (GLushort
*) dstAddr
;
1778 dst
[i
] = (IROUND(rgba
[i
][BCOMP
] * 15.0F
) )
1779 | (IROUND(rgba
[i
][GCOMP
] * 15.0F
) << 4)
1780 | (IROUND(rgba
[i
][RCOMP
] * 15.0F
) << 8)
1781 | (IROUND(rgba
[i
][ACOMP
] * 15.0F
) << 12);
1784 else if (dstFormat
== GL_ABGR_EXT
) {
1785 GLushort
*dst
= (GLushort
*) dstAddr
;
1787 dst
[i
] = (IROUND(rgba
[i
][ACOMP
] * 15.0F
) )
1788 | (IROUND(rgba
[i
][BCOMP
] * 15.0F
) << 4)
1789 | (IROUND(rgba
[i
][GCOMP
] * 15.0F
) << 8)
1790 | (IROUND(rgba
[i
][RCOMP
] * 15.0F
) << 12);
1794 case GL_UNSIGNED_SHORT_5_5_5_1
:
1795 if (dstFormat
== GL_RGBA
) {
1796 GLushort
*dst
= (GLushort
*) dstAddr
;
1798 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 31.0F
) << 11)
1799 | (IROUND(rgba
[i
][GCOMP
] * 31.0F
) << 6)
1800 | (IROUND(rgba
[i
][BCOMP
] * 31.0F
) << 1)
1801 | (IROUND(rgba
[i
][ACOMP
] * 1.0F
) );
1804 else if (dstFormat
== GL_BGRA
) {
1805 GLushort
*dst
= (GLushort
*) dstAddr
;
1807 dst
[i
] = (IROUND(rgba
[i
][BCOMP
] * 31.0F
) << 11)
1808 | (IROUND(rgba
[i
][GCOMP
] * 31.0F
) << 6)
1809 | (IROUND(rgba
[i
][RCOMP
] * 31.0F
) << 1)
1810 | (IROUND(rgba
[i
][ACOMP
] * 1.0F
) );
1813 else if (dstFormat
== GL_ABGR_EXT
) {
1814 GLushort
*dst
= (GLushort
*) dstAddr
;
1816 dst
[i
] = (IROUND(rgba
[i
][ACOMP
] * 31.0F
) << 11)
1817 | (IROUND(rgba
[i
][BCOMP
] * 31.0F
) << 6)
1818 | (IROUND(rgba
[i
][GCOMP
] * 31.0F
) << 1)
1819 | (IROUND(rgba
[i
][RCOMP
] * 1.0F
) );
1823 case GL_UNSIGNED_SHORT_1_5_5_5_REV
:
1824 if (dstFormat
== GL_RGBA
) {
1825 GLushort
*dst
= (GLushort
*) dstAddr
;
1827 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 31.0F
) )
1828 | (IROUND(rgba
[i
][GCOMP
] * 31.0F
) << 5)
1829 | (IROUND(rgba
[i
][BCOMP
] * 31.0F
) << 10)
1830 | (IROUND(rgba
[i
][ACOMP
] * 1.0F
) << 15);
1833 else if (dstFormat
== GL_BGRA
) {
1834 GLushort
*dst
= (GLushort
*) dstAddr
;
1836 dst
[i
] = (IROUND(rgba
[i
][BCOMP
] * 31.0F
) )
1837 | (IROUND(rgba
[i
][GCOMP
] * 31.0F
) << 5)
1838 | (IROUND(rgba
[i
][RCOMP
] * 31.0F
) << 10)
1839 | (IROUND(rgba
[i
][ACOMP
] * 1.0F
) << 15);
1842 else if (dstFormat
== GL_ABGR_EXT
) {
1843 GLushort
*dst
= (GLushort
*) dstAddr
;
1845 dst
[i
] = (IROUND(rgba
[i
][ACOMP
] * 31.0F
) )
1846 | (IROUND(rgba
[i
][BCOMP
] * 31.0F
) << 5)
1847 | (IROUND(rgba
[i
][GCOMP
] * 31.0F
) << 10)
1848 | (IROUND(rgba
[i
][RCOMP
] * 1.0F
) << 15);
1852 case GL_UNSIGNED_INT_8_8_8_8
:
1853 if (dstFormat
== GL_RGBA
) {
1854 GLuint
*dst
= (GLuint
*) dstAddr
;
1856 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 255.F
) << 24)
1857 | (IROUND(rgba
[i
][GCOMP
] * 255.F
) << 16)
1858 | (IROUND(rgba
[i
][BCOMP
] * 255.F
) << 8)
1859 | (IROUND(rgba
[i
][ACOMP
] * 255.F
) );
1862 else if (dstFormat
== GL_BGRA
) {
1863 GLuint
*dst
= (GLuint
*) dstAddr
;
1865 dst
[i
] = (IROUND(rgba
[i
][BCOMP
] * 255.F
) << 24)
1866 | (IROUND(rgba
[i
][GCOMP
] * 255.F
) << 16)
1867 | (IROUND(rgba
[i
][RCOMP
] * 255.F
) << 8)
1868 | (IROUND(rgba
[i
][ACOMP
] * 255.F
) );
1871 else if (dstFormat
== GL_ABGR_EXT
) {
1872 GLuint
*dst
= (GLuint
*) dstAddr
;
1874 dst
[i
] = (IROUND(rgba
[i
][ACOMP
] * 255.F
) << 24)
1875 | (IROUND(rgba
[i
][BCOMP
] * 255.F
) << 16)
1876 | (IROUND(rgba
[i
][GCOMP
] * 255.F
) << 8)
1877 | (IROUND(rgba
[i
][RCOMP
] * 255.F
) );
1881 case GL_UNSIGNED_INT_8_8_8_8_REV
:
1882 if (dstFormat
== GL_RGBA
) {
1883 GLuint
*dst
= (GLuint
*) dstAddr
;
1885 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 255.0F
) )
1886 | (IROUND(rgba
[i
][GCOMP
] * 255.0F
) << 8)
1887 | (IROUND(rgba
[i
][BCOMP
] * 255.0F
) << 16)
1888 | (IROUND(rgba
[i
][ACOMP
] * 255.0F
) << 24);
1891 else if (dstFormat
== GL_BGRA
) {
1892 GLuint
*dst
= (GLuint
*) dstAddr
;
1894 dst
[i
] = (IROUND(rgba
[i
][BCOMP
] * 255.0F
) )
1895 | (IROUND(rgba
[i
][GCOMP
] * 255.0F
) << 8)
1896 | (IROUND(rgba
[i
][RCOMP
] * 255.0F
) << 16)
1897 | (IROUND(rgba
[i
][ACOMP
] * 255.0F
) << 24);
1900 else if (dstFormat
== GL_ABGR_EXT
) {
1901 GLuint
*dst
= (GLuint
*) dstAddr
;
1903 dst
[i
] = (IROUND(rgba
[i
][ACOMP
] * 255.0F
) )
1904 | (IROUND(rgba
[i
][BCOMP
] * 255.0F
) << 8)
1905 | (IROUND(rgba
[i
][GCOMP
] * 255.0F
) << 16)
1906 | (IROUND(rgba
[i
][RCOMP
] * 255.0F
) << 24);
1910 case GL_UNSIGNED_INT_10_10_10_2
:
1911 if (dstFormat
== GL_RGBA
) {
1912 GLuint
*dst
= (GLuint
*) dstAddr
;
1914 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 1023.0F
) << 22)
1915 | (IROUND(rgba
[i
][GCOMP
] * 1023.0F
) << 12)
1916 | (IROUND(rgba
[i
][BCOMP
] * 1023.0F
) << 2)
1917 | (IROUND(rgba
[i
][ACOMP
] * 3.0F
) );
1920 else if (dstFormat
== GL_BGRA
) {
1921 GLuint
*dst
= (GLuint
*) dstAddr
;
1923 dst
[i
] = (IROUND(rgba
[i
][BCOMP
] * 1023.0F
) << 22)
1924 | (IROUND(rgba
[i
][GCOMP
] * 1023.0F
) << 12)
1925 | (IROUND(rgba
[i
][RCOMP
] * 1023.0F
) << 2)
1926 | (IROUND(rgba
[i
][ACOMP
] * 3.0F
) );
1929 else if (dstFormat
== GL_ABGR_EXT
) {
1930 GLuint
*dst
= (GLuint
*) dstAddr
;
1932 dst
[i
] = (IROUND(rgba
[i
][ACOMP
] * 1023.0F
) << 22)
1933 | (IROUND(rgba
[i
][BCOMP
] * 1023.0F
) << 12)
1934 | (IROUND(rgba
[i
][GCOMP
] * 1023.0F
) << 2)
1935 | (IROUND(rgba
[i
][RCOMP
] * 3.0F
) );
1939 case GL_UNSIGNED_INT_2_10_10_10_REV
:
1940 if (dstFormat
== GL_RGBA
) {
1941 GLuint
*dst
= (GLuint
*) dstAddr
;
1943 dst
[i
] = (IROUND(rgba
[i
][RCOMP
] * 1023.0F
) )
1944 | (IROUND(rgba
[i
][GCOMP
] * 1023.0F
) << 10)
1945 | (IROUND(rgba
[i
][BCOMP
] * 1023.0F
) << 20)
1946 | (IROUND(rgba
[i
][ACOMP
] * 3.0F
) << 30);
1949 else if (dstFormat
== GL_BGRA
) {
1950 GLuint
*dst
= (GLuint
*) dstAddr
;
1952 dst
[i
] = (IROUND(rgba
[i
][BCOMP
] * 1023.0F
) )
1953 | (IROUND(rgba
[i
][GCOMP
] * 1023.0F
) << 10)
1954 | (IROUND(rgba
[i
][RCOMP
] * 1023.0F
) << 20)
1955 | (IROUND(rgba
[i
][ACOMP
] * 3.0F
) << 30);
1958 else if (dstFormat
== GL_ABGR_EXT
) {
1959 GLuint
*dst
= (GLuint
*) dstAddr
;
1961 dst
[i
] = (IROUND(rgba
[i
][ACOMP
] * 1023.0F
) )
1962 | (IROUND(rgba
[i
][BCOMP
] * 1023.0F
) << 10)
1963 | (IROUND(rgba
[i
][GCOMP
] * 1023.0F
) << 20)
1964 | (IROUND(rgba
[i
][RCOMP
] * 3.0F
) << 30);
1968 case GL_UNSIGNED_INT_5_9_9_9_REV
:
1970 GLuint
*dst
= (GLuint
*) dstAddr
;
1971 for (i
= 0; i
< n
; i
++) {
1972 dst
[i
] = float3_to_rgb9e5(rgba
[i
]);
1976 case GL_UNSIGNED_INT_10F_11F_11F_REV
:
1978 GLuint
*dst
= (GLuint
*) dstAddr
;
1979 for (i
= 0; i
< n
; i
++) {
1980 dst
[i
] = float3_to_r11g11b10f(rgba
[i
]);
1985 _mesa_problem(ctx
, "bad type in _mesa_pack_rgba_span_float");
1989 if (dstPacking
->SwapBytes
) {
1990 GLint swapSize
= _mesa_sizeof_packed_type(dstType
);
1991 if (swapSize
== 2) {
1992 if (dstPacking
->SwapBytes
) {
1993 _mesa_swap2((GLushort
*) dstAddr
, n
* comps
);
1996 else if (swapSize
== 4) {
1997 if (dstPacking
->SwapBytes
) {
1998 _mesa_swap4((GLuint
*) dstAddr
, n
* comps
);
2008 #define SWAP2BYTE(VALUE) \
2010 GLubyte *bytes = (GLubyte *) &(VALUE); \
2011 GLubyte tmp = bytes[0]; \
2012 bytes[0] = bytes[1]; \
2016 #define SWAP4BYTE(VALUE) \
2018 GLubyte *bytes = (GLubyte *) &(VALUE); \
2019 GLubyte tmp = bytes[0]; \
2020 bytes[0] = bytes[3]; \
2023 bytes[1] = bytes[2]; \
2029 extract_uint_indexes(GLuint n
, GLuint indexes
[],
2030 GLenum srcFormat
, GLenum srcType
, const GLvoid
*src
,
2031 const struct gl_pixelstore_attrib
*unpack
)
2033 ASSERT(srcFormat
== GL_COLOR_INDEX
|| srcFormat
== GL_STENCIL_INDEX
);
2035 ASSERT(srcType
== GL_BITMAP
||
2036 srcType
== GL_UNSIGNED_BYTE
||
2037 srcType
== GL_BYTE
||
2038 srcType
== GL_UNSIGNED_SHORT
||
2039 srcType
== GL_SHORT
||
2040 srcType
== GL_UNSIGNED_INT
||
2041 srcType
== GL_INT
||
2042 srcType
== GL_UNSIGNED_INT_24_8_EXT
||
2043 srcType
== GL_HALF_FLOAT_ARB
||
2044 srcType
== GL_FLOAT
||
2045 srcType
== GL_FLOAT_32_UNSIGNED_INT_24_8_REV
);
2050 GLubyte
*ubsrc
= (GLubyte
*) src
;
2051 if (unpack
->LsbFirst
) {
2052 GLubyte mask
= 1 << (unpack
->SkipPixels
& 0x7);
2054 for (i
= 0; i
< n
; i
++) {
2055 indexes
[i
] = (*ubsrc
& mask
) ? 1 : 0;
2066 GLubyte mask
= 128 >> (unpack
->SkipPixels
& 0x7);
2068 for (i
= 0; i
< n
; i
++) {
2069 indexes
[i
] = (*ubsrc
& mask
) ? 1 : 0;
2081 case GL_UNSIGNED_BYTE
:
2084 const GLubyte
*s
= (const GLubyte
*) src
;
2085 for (i
= 0; i
< n
; i
++)
2092 const GLbyte
*s
= (const GLbyte
*) src
;
2093 for (i
= 0; i
< n
; i
++)
2097 case GL_UNSIGNED_SHORT
:
2100 const GLushort
*s
= (const GLushort
*) src
;
2101 if (unpack
->SwapBytes
) {
2102 for (i
= 0; i
< n
; i
++) {
2103 GLushort value
= s
[i
];
2109 for (i
= 0; i
< n
; i
++)
2117 const GLshort
*s
= (const GLshort
*) src
;
2118 if (unpack
->SwapBytes
) {
2119 for (i
= 0; i
< n
; i
++) {
2120 GLshort value
= s
[i
];
2126 for (i
= 0; i
< n
; i
++)
2131 case GL_UNSIGNED_INT
:
2134 const GLuint
*s
= (const GLuint
*) src
;
2135 if (unpack
->SwapBytes
) {
2136 for (i
= 0; i
< n
; i
++) {
2137 GLuint value
= s
[i
];
2143 for (i
= 0; i
< n
; i
++)
2151 const GLint
*s
= (const GLint
*) src
;
2152 if (unpack
->SwapBytes
) {
2153 for (i
= 0; i
< n
; i
++) {
2160 for (i
= 0; i
< n
; i
++)
2168 const GLfloat
*s
= (const GLfloat
*) src
;
2169 if (unpack
->SwapBytes
) {
2170 for (i
= 0; i
< n
; i
++) {
2171 GLfloat value
= s
[i
];
2173 indexes
[i
] = (GLuint
) value
;
2177 for (i
= 0; i
< n
; i
++)
2178 indexes
[i
] = (GLuint
) s
[i
];
2182 case GL_HALF_FLOAT_ARB
:
2185 const GLhalfARB
*s
= (const GLhalfARB
*) src
;
2186 if (unpack
->SwapBytes
) {
2187 for (i
= 0; i
< n
; i
++) {
2188 GLhalfARB value
= s
[i
];
2190 indexes
[i
] = (GLuint
) _mesa_half_to_float(value
);
2194 for (i
= 0; i
< n
; i
++)
2195 indexes
[i
] = (GLuint
) _mesa_half_to_float(s
[i
]);
2199 case GL_UNSIGNED_INT_24_8_EXT
:
2202 const GLuint
*s
= (const GLuint
*) src
;
2203 if (unpack
->SwapBytes
) {
2204 for (i
= 0; i
< n
; i
++) {
2205 GLuint value
= s
[i
];
2207 indexes
[i
] = value
& 0xff; /* lower 8 bits */
2211 for (i
= 0; i
< n
; i
++)
2212 indexes
[i
] = s
[i
] & 0xff; /* lower 8 bits */
2216 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV
:
2219 const GLuint
*s
= (const GLuint
*) src
;
2220 if (unpack
->SwapBytes
) {
2221 for (i
= 0; i
< n
; i
++) {
2222 GLuint value
= s
[i
*2+1];
2224 indexes
[i
] = value
& 0xff; /* lower 8 bits */
2228 for (i
= 0; i
< n
; i
++)
2229 indexes
[i
] = s
[i
*2+1] & 0xff; /* lower 8 bits */
2235 _mesa_problem(NULL
, "bad srcType in extract_uint_indexes");
2242 * Return source/dest RGBA indexes for unpacking pixels.
2245 get_component_mapping(GLenum format
,
2257 case GL_RED_INTEGER_EXT
:
2259 *gSrc
= *bSrc
= *aSrc
= -1;
2262 case GL_GREEN_INTEGER_EXT
:
2264 *rSrc
= *bSrc
= *aSrc
= -1;
2267 case GL_BLUE_INTEGER_EXT
:
2269 *rSrc
= *gSrc
= *aSrc
= -1;
2272 case GL_ALPHA_INTEGER_EXT
:
2273 *rSrc
= *gSrc
= *bSrc
= -1;
2277 case GL_LUMINANCE_INTEGER_EXT
:
2278 *rSrc
= *gSrc
= *bSrc
= 0;
2281 case GL_LUMINANCE_ALPHA
:
2282 case GL_LUMINANCE_ALPHA_INTEGER_EXT
:
2283 *rSrc
= *gSrc
= *bSrc
= 0;
2287 *rSrc
= *gSrc
= *bSrc
= *aSrc
= 0;
2301 case GL_RGB_INTEGER
:
2322 case GL_RGBA_INTEGER
:
2360 _mesa_problem(NULL
, "bad srcFormat %s in get_component_mapping",
2361 _mesa_lookup_enum_by_nr(format
));
2369 * This function extracts floating point RGBA values from arbitrary
2370 * image data. srcFormat and srcType are the format and type parameters
2371 * passed to glDrawPixels, glTexImage[123]D, glTexSubImage[123]D, etc.
2373 * Refering to section 3.6.4 of the OpenGL 1.2 spec, this function
2374 * implements the "Conversion to floating point", "Conversion to RGB",
2375 * and "Final Expansion to RGBA" operations.
2377 * Args: n - number of pixels
2378 * rgba - output colors
2379 * srcFormat - format of incoming data
2380 * srcType - data type of incoming data
2381 * src - source data pointer
2382 * swapBytes - perform byteswapping of incoming data?
2385 extract_float_rgba(GLuint n
, GLfloat rgba
[][4],
2386 GLenum srcFormat
, GLenum srcType
, const GLvoid
*src
,
2387 GLboolean swapBytes
)
2389 GLint rSrc
, gSrc
, bSrc
, aSrc
;
2391 GLint rDst
, bDst
, gDst
, aDst
;
2392 GLboolean intFormat
;
2393 GLfloat rs
= 1.0f
, gs
= 1.0f
, bs
= 1.0f
, as
= 1.0f
; /* scale factors */
2395 ASSERT(srcFormat
== GL_RED
||
2396 srcFormat
== GL_GREEN
||
2397 srcFormat
== GL_BLUE
||
2398 srcFormat
== GL_ALPHA
||
2399 srcFormat
== GL_LUMINANCE
||
2400 srcFormat
== GL_LUMINANCE_ALPHA
||
2401 srcFormat
== GL_INTENSITY
||
2402 srcFormat
== GL_RG
||
2403 srcFormat
== GL_RGB
||
2404 srcFormat
== GL_BGR
||
2405 srcFormat
== GL_RGBA
||
2406 srcFormat
== GL_BGRA
||
2407 srcFormat
== GL_ABGR_EXT
||
2408 srcFormat
== GL_DU8DV8_ATI
||
2409 srcFormat
== GL_DUDV_ATI
||
2410 srcFormat
== GL_RED_INTEGER_EXT
||
2411 srcFormat
== GL_GREEN_INTEGER_EXT
||
2412 srcFormat
== GL_BLUE_INTEGER_EXT
||
2413 srcFormat
== GL_ALPHA_INTEGER_EXT
||
2414 srcFormat
== GL_RGB_INTEGER_EXT
||
2415 srcFormat
== GL_RGBA_INTEGER_EXT
||
2416 srcFormat
== GL_BGR_INTEGER_EXT
||
2417 srcFormat
== GL_BGRA_INTEGER_EXT
||
2418 srcFormat
== GL_LUMINANCE_INTEGER_EXT
||
2419 srcFormat
== GL_LUMINANCE_ALPHA_INTEGER_EXT
);
2421 ASSERT(srcType
== GL_UNSIGNED_BYTE
||
2422 srcType
== GL_BYTE
||
2423 srcType
== GL_UNSIGNED_SHORT
||
2424 srcType
== GL_SHORT
||
2425 srcType
== GL_UNSIGNED_INT
||
2426 srcType
== GL_INT
||
2427 srcType
== GL_HALF_FLOAT_ARB
||
2428 srcType
== GL_FLOAT
||
2429 srcType
== GL_UNSIGNED_BYTE_3_3_2
||
2430 srcType
== GL_UNSIGNED_BYTE_2_3_3_REV
||
2431 srcType
== GL_UNSIGNED_SHORT_5_6_5
||
2432 srcType
== GL_UNSIGNED_SHORT_5_6_5_REV
||
2433 srcType
== GL_UNSIGNED_SHORT_4_4_4_4
||
2434 srcType
== GL_UNSIGNED_SHORT_4_4_4_4_REV
||
2435 srcType
== GL_UNSIGNED_SHORT_5_5_5_1
||
2436 srcType
== GL_UNSIGNED_SHORT_1_5_5_5_REV
||
2437 srcType
== GL_UNSIGNED_INT_8_8_8_8
||
2438 srcType
== GL_UNSIGNED_INT_8_8_8_8_REV
||
2439 srcType
== GL_UNSIGNED_INT_10_10_10_2
||
2440 srcType
== GL_UNSIGNED_INT_2_10_10_10_REV
||
2441 srcType
== GL_UNSIGNED_INT_5_9_9_9_REV
||
2442 srcType
== GL_UNSIGNED_INT_10F_11F_11F_REV
);
2444 get_component_mapping(srcFormat
,
2445 &rSrc
, &gSrc
, &bSrc
, &aSrc
,
2446 &rDst
, &gDst
, &bDst
, &aDst
);
2448 stride
= _mesa_components_in_format(srcFormat
);
2450 intFormat
= _mesa_is_integer_format(srcFormat
);
2452 #define PROCESS(SRC_INDEX, DST_INDEX, DEFAULT_FLT, DEFAULT_INT, TYPE, CONVERSION) \
2453 if ((SRC_INDEX) < 0) { \
2456 for (i = 0; i < n; i++) { \
2457 rgba[i][DST_INDEX] = DEFAULT_INT; \
2461 for (i = 0; i < n; i++) { \
2462 rgba[i][DST_INDEX] = DEFAULT_FLT; \
2466 else if (swapBytes) { \
2467 const TYPE *s = (const TYPE *) src; \
2469 for (i = 0; i < n; i++) { \
2470 TYPE value = s[SRC_INDEX]; \
2471 if (sizeof(TYPE) == 2) { \
2474 else if (sizeof(TYPE) == 4) { \
2478 rgba[i][DST_INDEX] = (GLfloat) value; \
2480 rgba[i][DST_INDEX] = (GLfloat) CONVERSION(value); \
2485 const TYPE *s = (const TYPE *) src; \
2488 for (i = 0; i < n; i++) { \
2489 rgba[i][DST_INDEX] = (GLfloat) s[SRC_INDEX]; \
2494 for (i = 0; i < n; i++) { \
2495 rgba[i][DST_INDEX] = (GLfloat) CONVERSION(s[SRC_INDEX]); \
2502 case GL_UNSIGNED_BYTE
:
2503 PROCESS(rSrc
, RCOMP
, 0.0F
, 0, GLubyte
, UBYTE_TO_FLOAT
);
2504 PROCESS(gSrc
, GCOMP
, 0.0F
, 0, GLubyte
, UBYTE_TO_FLOAT
);
2505 PROCESS(bSrc
, BCOMP
, 0.0F
, 0, GLubyte
, UBYTE_TO_FLOAT
);
2506 PROCESS(aSrc
, ACOMP
, 1.0F
, 255, GLubyte
, UBYTE_TO_FLOAT
);
2509 PROCESS(rSrc
, RCOMP
, 0.0F
, 0, GLbyte
, BYTE_TO_FLOAT
);
2510 PROCESS(gSrc
, GCOMP
, 0.0F
, 0, GLbyte
, BYTE_TO_FLOAT
);
2511 PROCESS(bSrc
, BCOMP
, 0.0F
, 0, GLbyte
, BYTE_TO_FLOAT
);
2512 PROCESS(aSrc
, ACOMP
, 1.0F
, 127, GLbyte
, BYTE_TO_FLOAT
);
2514 case GL_UNSIGNED_SHORT
:
2515 PROCESS(rSrc
, RCOMP
, 0.0F
, 0, GLushort
, USHORT_TO_FLOAT
);
2516 PROCESS(gSrc
, GCOMP
, 0.0F
, 0, GLushort
, USHORT_TO_FLOAT
);
2517 PROCESS(bSrc
, BCOMP
, 0.0F
, 0, GLushort
, USHORT_TO_FLOAT
);
2518 PROCESS(aSrc
, ACOMP
, 1.0F
, 0xffff, GLushort
, USHORT_TO_FLOAT
);
2521 PROCESS(rSrc
, RCOMP
, 0.0F
, 0, GLshort
, SHORT_TO_FLOAT
);
2522 PROCESS(gSrc
, GCOMP
, 0.0F
, 0, GLshort
, SHORT_TO_FLOAT
);
2523 PROCESS(bSrc
, BCOMP
, 0.0F
, 0, GLshort
, SHORT_TO_FLOAT
);
2524 PROCESS(aSrc
, ACOMP
, 1.0F
, 32767, GLshort
, SHORT_TO_FLOAT
);
2526 case GL_UNSIGNED_INT
:
2527 PROCESS(rSrc
, RCOMP
, 0.0F
, 0, GLuint
, UINT_TO_FLOAT
);
2528 PROCESS(gSrc
, GCOMP
, 0.0F
, 0, GLuint
, UINT_TO_FLOAT
);
2529 PROCESS(bSrc
, BCOMP
, 0.0F
, 0, GLuint
, UINT_TO_FLOAT
);
2530 PROCESS(aSrc
, ACOMP
, 1.0F
, 0xffffffff, GLuint
, UINT_TO_FLOAT
);
2533 PROCESS(rSrc
, RCOMP
, 0.0F
, 0, GLint
, INT_TO_FLOAT
);
2534 PROCESS(gSrc
, GCOMP
, 0.0F
, 0, GLint
, INT_TO_FLOAT
);
2535 PROCESS(bSrc
, BCOMP
, 0.0F
, 0, GLint
, INT_TO_FLOAT
);
2536 PROCESS(aSrc
, ACOMP
, 1.0F
, 2147483647, GLint
, INT_TO_FLOAT
);
2539 PROCESS(rSrc
, RCOMP
, 0.0F
, 0.0F
, GLfloat
, (GLfloat
));
2540 PROCESS(gSrc
, GCOMP
, 0.0F
, 0.0F
, GLfloat
, (GLfloat
));
2541 PROCESS(bSrc
, BCOMP
, 0.0F
, 0.0F
, GLfloat
, (GLfloat
));
2542 PROCESS(aSrc
, ACOMP
, 1.0F
, 1.0F
, GLfloat
, (GLfloat
));
2544 case GL_HALF_FLOAT_ARB
:
2545 PROCESS(rSrc
, RCOMP
, 0.0F
, 0.0F
, GLhalfARB
, _mesa_half_to_float
);
2546 PROCESS(gSrc
, GCOMP
, 0.0F
, 0.0F
, GLhalfARB
, _mesa_half_to_float
);
2547 PROCESS(bSrc
, BCOMP
, 0.0F
, 0.0F
, GLhalfARB
, _mesa_half_to_float
);
2548 PROCESS(aSrc
, ACOMP
, 1.0F
, 1.0F
, GLhalfARB
, _mesa_half_to_float
);
2550 case GL_UNSIGNED_BYTE_3_3_2
:
2552 const GLubyte
*ubsrc
= (const GLubyte
*) src
;
2559 for (i
= 0; i
< n
; i
++) {
2560 GLubyte p
= ubsrc
[i
];
2561 rgba
[i
][rDst
] = ((p
>> 5) ) * rs
;
2562 rgba
[i
][gDst
] = ((p
>> 2) & 0x7) * gs
;
2563 rgba
[i
][bDst
] = ((p
) & 0x3) * bs
;
2564 rgba
[i
][aDst
] = 1.0F
;
2568 case GL_UNSIGNED_BYTE_2_3_3_REV
:
2570 const GLubyte
*ubsrc
= (const GLubyte
*) src
;
2577 for (i
= 0; i
< n
; i
++) {
2578 GLubyte p
= ubsrc
[i
];
2579 rgba
[i
][rDst
] = ((p
) & 0x7) * rs
;
2580 rgba
[i
][gDst
] = ((p
>> 3) & 0x7) * gs
;
2581 rgba
[i
][bDst
] = ((p
>> 6) ) * bs
;
2582 rgba
[i
][aDst
] = 1.0F
;
2586 case GL_UNSIGNED_SHORT_5_6_5
:
2593 const GLushort
*ussrc
= (const GLushort
*) src
;
2595 for (i
= 0; i
< n
; i
++) {
2596 GLushort p
= ussrc
[i
];
2598 rgba
[i
][rDst
] = ((p
>> 11) ) * rs
;
2599 rgba
[i
][gDst
] = ((p
>> 5) & 0x3f) * gs
;
2600 rgba
[i
][bDst
] = ((p
) & 0x1f) * bs
;
2601 rgba
[i
][aDst
] = 1.0F
;
2605 const GLushort
*ussrc
= (const GLushort
*) src
;
2607 for (i
= 0; i
< n
; i
++) {
2608 GLushort p
= ussrc
[i
];
2609 rgba
[i
][rDst
] = ((p
>> 11) ) * rs
;
2610 rgba
[i
][gDst
] = ((p
>> 5) & 0x3f) * gs
;
2611 rgba
[i
][bDst
] = ((p
) & 0x1f) * bs
;
2612 rgba
[i
][aDst
] = 1.0F
;
2616 case GL_UNSIGNED_SHORT_5_6_5_REV
:
2623 const GLushort
*ussrc
= (const GLushort
*) src
;
2625 for (i
= 0; i
< n
; i
++) {
2626 GLushort p
= ussrc
[i
];
2628 rgba
[i
][rDst
] = ((p
) & 0x1f) * rs
;
2629 rgba
[i
][gDst
] = ((p
>> 5) & 0x3f) * gs
;
2630 rgba
[i
][bDst
] = ((p
>> 11) ) * bs
;
2631 rgba
[i
][aDst
] = 1.0F
;
2635 const GLushort
*ussrc
= (const GLushort
*) src
;
2637 for (i
= 0; i
< n
; i
++) {
2638 GLushort p
= ussrc
[i
];
2639 rgba
[i
][rDst
] = ((p
) & 0x1f) * rs
;
2640 rgba
[i
][gDst
] = ((p
>> 5) & 0x3f) * gs
;
2641 rgba
[i
][bDst
] = ((p
>> 11) ) * bs
;
2642 rgba
[i
][aDst
] = 1.0F
;
2646 case GL_UNSIGNED_SHORT_4_4_4_4
:
2648 rs
= gs
= bs
= as
= 1.0F
/ 15.0F
;
2651 const GLushort
*ussrc
= (const GLushort
*) src
;
2653 for (i
= 0; i
< n
; i
++) {
2654 GLushort p
= ussrc
[i
];
2656 rgba
[i
][rDst
] = ((p
>> 12) ) * rs
;
2657 rgba
[i
][gDst
] = ((p
>> 8) & 0xf) * gs
;
2658 rgba
[i
][bDst
] = ((p
>> 4) & 0xf) * bs
;
2659 rgba
[i
][aDst
] = ((p
) & 0xf) * as
;
2663 const GLushort
*ussrc
= (const GLushort
*) src
;
2665 for (i
= 0; i
< n
; i
++) {
2666 GLushort p
= ussrc
[i
];
2667 rgba
[i
][rDst
] = ((p
>> 12) ) * rs
;
2668 rgba
[i
][gDst
] = ((p
>> 8) & 0xf) * gs
;
2669 rgba
[i
][bDst
] = ((p
>> 4) & 0xf) * bs
;
2670 rgba
[i
][aDst
] = ((p
) & 0xf) * as
;
2674 case GL_UNSIGNED_SHORT_4_4_4_4_REV
:
2676 rs
= gs
= bs
= as
= 1.0F
/ 15.0F
;
2679 const GLushort
*ussrc
= (const GLushort
*) src
;
2681 for (i
= 0; i
< n
; i
++) {
2682 GLushort p
= ussrc
[i
];
2684 rgba
[i
][rDst
] = ((p
) & 0xf) * rs
;
2685 rgba
[i
][gDst
] = ((p
>> 4) & 0xf) * gs
;
2686 rgba
[i
][bDst
] = ((p
>> 8) & 0xf) * bs
;
2687 rgba
[i
][aDst
] = ((p
>> 12) ) * as
;
2691 const GLushort
*ussrc
= (const GLushort
*) src
;
2693 for (i
= 0; i
< n
; i
++) {
2694 GLushort p
= ussrc
[i
];
2695 rgba
[i
][rDst
] = ((p
) & 0xf) * rs
;
2696 rgba
[i
][gDst
] = ((p
>> 4) & 0xf) * gs
;
2697 rgba
[i
][bDst
] = ((p
>> 8) & 0xf) * bs
;
2698 rgba
[i
][aDst
] = ((p
>> 12) ) * as
;
2702 case GL_UNSIGNED_SHORT_5_5_5_1
:
2704 rs
= gs
= bs
= 1.0F
/ 31.0F
;
2707 const GLushort
*ussrc
= (const GLushort
*) src
;
2709 for (i
= 0; i
< n
; i
++) {
2710 GLushort p
= ussrc
[i
];
2712 rgba
[i
][rDst
] = ((p
>> 11) ) * rs
;
2713 rgba
[i
][gDst
] = ((p
>> 6) & 0x1f) * gs
;
2714 rgba
[i
][bDst
] = ((p
>> 1) & 0x1f) * bs
;
2715 rgba
[i
][aDst
] = ((p
) & 0x1) * as
;
2719 const GLushort
*ussrc
= (const GLushort
*) src
;
2721 for (i
= 0; i
< n
; i
++) {
2722 GLushort p
= ussrc
[i
];
2723 rgba
[i
][rDst
] = ((p
>> 11) ) * rs
;
2724 rgba
[i
][gDst
] = ((p
>> 6) & 0x1f) * gs
;
2725 rgba
[i
][bDst
] = ((p
>> 1) & 0x1f) * bs
;
2726 rgba
[i
][aDst
] = ((p
) & 0x1) * as
;
2730 case GL_UNSIGNED_SHORT_1_5_5_5_REV
:
2732 rs
= gs
= bs
= 1.0F
/ 31.0F
;
2735 const GLushort
*ussrc
= (const GLushort
*) src
;
2737 for (i
= 0; i
< n
; i
++) {
2738 GLushort p
= ussrc
[i
];
2740 rgba
[i
][rDst
] = ((p
) & 0x1f) * rs
;
2741 rgba
[i
][gDst
] = ((p
>> 5) & 0x1f) * gs
;
2742 rgba
[i
][bDst
] = ((p
>> 10) & 0x1f) * bs
;
2743 rgba
[i
][aDst
] = ((p
>> 15) ) * as
;
2747 const GLushort
*ussrc
= (const GLushort
*) src
;
2749 for (i
= 0; i
< n
; i
++) {
2750 GLushort p
= ussrc
[i
];
2751 rgba
[i
][rDst
] = ((p
) & 0x1f) * rs
;
2752 rgba
[i
][gDst
] = ((p
>> 5) & 0x1f) * gs
;
2753 rgba
[i
][bDst
] = ((p
>> 10) & 0x1f) * bs
;
2754 rgba
[i
][aDst
] = ((p
>> 15) ) * as
;
2758 case GL_UNSIGNED_INT_8_8_8_8
:
2760 const GLuint
*uisrc
= (const GLuint
*) src
;
2763 for (i
= 0; i
< n
; i
++) {
2764 GLuint p
= uisrc
[i
];
2765 rgba
[i
][rDst
] = (GLfloat
) ((p
) & 0xff);
2766 rgba
[i
][gDst
] = (GLfloat
) ((p
>> 8) & 0xff);
2767 rgba
[i
][bDst
] = (GLfloat
) ((p
>> 16) & 0xff);
2768 rgba
[i
][aDst
] = (GLfloat
) ((p
>> 24) );
2772 for (i
= 0; i
< n
; i
++) {
2773 GLuint p
= uisrc
[i
];
2774 rgba
[i
][rDst
] = UBYTE_TO_FLOAT((p
) & 0xff);
2775 rgba
[i
][gDst
] = UBYTE_TO_FLOAT((p
>> 8) & 0xff);
2776 rgba
[i
][bDst
] = UBYTE_TO_FLOAT((p
>> 16) & 0xff);
2777 rgba
[i
][aDst
] = UBYTE_TO_FLOAT((p
>> 24) );
2782 const GLuint
*uisrc
= (const GLuint
*) src
;
2785 for (i
= 0; i
< n
; i
++) {
2786 GLuint p
= uisrc
[i
];
2787 rgba
[i
][rDst
] = (GLfloat
) ((p
>> 24) );
2788 rgba
[i
][gDst
] = (GLfloat
) ((p
>> 16) & 0xff);
2789 rgba
[i
][bDst
] = (GLfloat
) ((p
>> 8) & 0xff);
2790 rgba
[i
][aDst
] = (GLfloat
) ((p
) & 0xff);
2794 for (i
= 0; i
< n
; i
++) {
2795 GLuint p
= uisrc
[i
];
2796 rgba
[i
][rDst
] = UBYTE_TO_FLOAT((p
>> 24) );
2797 rgba
[i
][gDst
] = UBYTE_TO_FLOAT((p
>> 16) & 0xff);
2798 rgba
[i
][bDst
] = UBYTE_TO_FLOAT((p
>> 8) & 0xff);
2799 rgba
[i
][aDst
] = UBYTE_TO_FLOAT((p
) & 0xff);
2804 case GL_UNSIGNED_INT_8_8_8_8_REV
:
2806 const GLuint
*uisrc
= (const GLuint
*) src
;
2809 for (i
= 0; i
< n
; i
++) {
2810 GLuint p
= uisrc
[i
];
2811 rgba
[i
][rDst
] = (GLfloat
) ((p
>> 24) );
2812 rgba
[i
][gDst
] = (GLfloat
) ((p
>> 16) & 0xff);
2813 rgba
[i
][bDst
] = (GLfloat
) ((p
>> 8) & 0xff);
2814 rgba
[i
][aDst
] = (GLfloat
) ((p
) & 0xff);
2818 for (i
= 0; i
< n
; i
++) {
2819 GLuint p
= uisrc
[i
];
2820 rgba
[i
][rDst
] = UBYTE_TO_FLOAT((p
>> 24) );
2821 rgba
[i
][gDst
] = UBYTE_TO_FLOAT((p
>> 16) & 0xff);
2822 rgba
[i
][bDst
] = UBYTE_TO_FLOAT((p
>> 8) & 0xff);
2823 rgba
[i
][aDst
] = UBYTE_TO_FLOAT((p
) & 0xff);
2828 const GLuint
*uisrc
= (const GLuint
*) src
;
2831 for (i
= 0; i
< n
; i
++) {
2832 GLuint p
= uisrc
[i
];
2833 rgba
[i
][rDst
] = (GLfloat
) ((p
) & 0xff);
2834 rgba
[i
][gDst
] = (GLfloat
) ((p
>> 8) & 0xff);
2835 rgba
[i
][bDst
] = (GLfloat
) ((p
>> 16) & 0xff);
2836 rgba
[i
][aDst
] = (GLfloat
) ((p
>> 24) );
2840 for (i
= 0; i
< n
; i
++) {
2841 GLuint p
= uisrc
[i
];
2842 rgba
[i
][rDst
] = UBYTE_TO_FLOAT((p
) & 0xff);
2843 rgba
[i
][gDst
] = UBYTE_TO_FLOAT((p
>> 8) & 0xff);
2844 rgba
[i
][bDst
] = UBYTE_TO_FLOAT((p
>> 16) & 0xff);
2845 rgba
[i
][aDst
] = UBYTE_TO_FLOAT((p
>> 24) );
2850 case GL_UNSIGNED_INT_10_10_10_2
:
2852 rs
= 1.0F
/ 1023.0F
;
2853 gs
= 1.0F
/ 1023.0F
;
2854 bs
= 1.0F
/ 1023.0F
;
2858 const GLuint
*uisrc
= (const GLuint
*) src
;
2860 for (i
= 0; i
< n
; i
++) {
2861 GLuint p
= uisrc
[i
];
2863 rgba
[i
][rDst
] = ((p
>> 22) ) * rs
;
2864 rgba
[i
][gDst
] = ((p
>> 12) & 0x3ff) * gs
;
2865 rgba
[i
][bDst
] = ((p
>> 2) & 0x3ff) * bs
;
2866 rgba
[i
][aDst
] = ((p
) & 0x3 ) * as
;
2870 const GLuint
*uisrc
= (const GLuint
*) src
;
2872 for (i
= 0; i
< n
; i
++) {
2873 GLuint p
= uisrc
[i
];
2874 rgba
[i
][rDst
] = ((p
>> 22) ) * rs
;
2875 rgba
[i
][gDst
] = ((p
>> 12) & 0x3ff) * gs
;
2876 rgba
[i
][bDst
] = ((p
>> 2) & 0x3ff) * bs
;
2877 rgba
[i
][aDst
] = ((p
) & 0x3 ) * as
;
2881 case GL_UNSIGNED_INT_2_10_10_10_REV
:
2883 rs
= 1.0F
/ 1023.0F
;
2884 gs
= 1.0F
/ 1023.0F
;
2885 bs
= 1.0F
/ 1023.0F
;
2889 const GLuint
*uisrc
= (const GLuint
*) src
;
2891 for (i
= 0; i
< n
; i
++) {
2892 GLuint p
= uisrc
[i
];
2894 rgba
[i
][rDst
] = ((p
) & 0x3ff) * rs
;
2895 rgba
[i
][gDst
] = ((p
>> 10) & 0x3ff) * gs
;
2896 rgba
[i
][bDst
] = ((p
>> 20) & 0x3ff) * bs
;
2897 rgba
[i
][aDst
] = ((p
>> 30) ) * as
;
2901 const GLuint
*uisrc
= (const GLuint
*) src
;
2903 for (i
= 0; i
< n
; i
++) {
2904 GLuint p
= uisrc
[i
];
2905 rgba
[i
][rDst
] = ((p
) & 0x3ff) * rs
;
2906 rgba
[i
][gDst
] = ((p
>> 10) & 0x3ff) * gs
;
2907 rgba
[i
][bDst
] = ((p
>> 20) & 0x3ff) * bs
;
2908 rgba
[i
][aDst
] = ((p
>> 30) ) * as
;
2912 case GL_UNSIGNED_INT_5_9_9_9_REV
:
2914 const GLuint
*uisrc
= (const GLuint
*) src
;
2917 for (i
= 0; i
< n
; i
++) {
2918 GLuint p
= uisrc
[i
];
2920 rgb9e5_to_float3(p
, f
);
2921 rgba
[i
][rDst
] = f
[0];
2922 rgba
[i
][gDst
] = f
[1];
2923 rgba
[i
][bDst
] = f
[2];
2924 rgba
[i
][aDst
] = 1.0F
;
2928 const GLuint
*uisrc
= (const GLuint
*) src
;
2931 for (i
= 0; i
< n
; i
++) {
2932 rgb9e5_to_float3(uisrc
[i
], f
);
2933 rgba
[i
][rDst
] = f
[0];
2934 rgba
[i
][gDst
] = f
[1];
2935 rgba
[i
][bDst
] = f
[2];
2936 rgba
[i
][aDst
] = 1.0F
;
2940 case GL_UNSIGNED_INT_10F_11F_11F_REV
:
2942 const GLuint
*uisrc
= (const GLuint
*) src
;
2945 for (i
= 0; i
< n
; i
++) {
2946 GLuint p
= uisrc
[i
];
2948 r11g11b10f_to_float3(p
, f
);
2949 rgba
[i
][rDst
] = f
[0];
2950 rgba
[i
][gDst
] = f
[1];
2951 rgba
[i
][bDst
] = f
[2];
2952 rgba
[i
][aDst
] = 1.0F
;
2956 const GLuint
*uisrc
= (const GLuint
*) src
;
2959 for (i
= 0; i
< n
; i
++) {
2960 r11g11b10f_to_float3(uisrc
[i
], f
);
2961 rgba
[i
][rDst
] = f
[0];
2962 rgba
[i
][gDst
] = f
[1];
2963 rgba
[i
][bDst
] = f
[2];
2964 rgba
[i
][aDst
] = 1.0F
;
2969 _mesa_problem(NULL
, "bad srcType in extract float data");
2976 static inline GLuint
2977 clamp_byte_to_uint(GLbyte b
)
2979 return b
< 0 ? 0 : b
;
2983 static inline GLuint
2984 clamp_short_to_uint(GLshort s
)
2986 return s
< 0 ? 0 : s
;
2990 static inline GLuint
2991 clamp_int_to_uint(GLint i
)
2993 return i
< 0 ? 0 : i
;
2997 static inline GLuint
2998 clamp_float_to_uint(GLfloat f
)
3000 return f
< 0.0F
? 0 : IROUND(f
);
3004 static inline GLuint
3005 clamp_half_to_uint(GLhalfARB h
)
3007 GLfloat f
= _mesa_half_to_float(h
);
3008 return f
< 0.0F
? 0 : IROUND(f
);
3013 * \sa extract_float_rgba()
3016 extract_uint_rgba(GLuint n
, GLuint rgba
[][4],
3017 GLenum srcFormat
, GLenum srcType
, const GLvoid
*src
,
3018 GLboolean swapBytes
)
3020 GLint rSrc
, gSrc
, bSrc
, aSrc
;
3022 GLint rDst
, bDst
, gDst
, aDst
;
3024 ASSERT(srcFormat
== GL_RED
||
3025 srcFormat
== GL_GREEN
||
3026 srcFormat
== GL_BLUE
||
3027 srcFormat
== GL_ALPHA
||
3028 srcFormat
== GL_LUMINANCE
||
3029 srcFormat
== GL_LUMINANCE_ALPHA
||
3030 srcFormat
== GL_INTENSITY
||
3031 srcFormat
== GL_RG
||
3032 srcFormat
== GL_RGB
||
3033 srcFormat
== GL_BGR
||
3034 srcFormat
== GL_RGBA
||
3035 srcFormat
== GL_BGRA
||
3036 srcFormat
== GL_ABGR_EXT
||
3037 srcFormat
== GL_DU8DV8_ATI
||
3038 srcFormat
== GL_DUDV_ATI
||
3039 srcFormat
== GL_RED_INTEGER_EXT
||
3040 srcFormat
== GL_GREEN_INTEGER_EXT
||
3041 srcFormat
== GL_BLUE_INTEGER_EXT
||
3042 srcFormat
== GL_ALPHA_INTEGER_EXT
||
3043 srcFormat
== GL_RGB_INTEGER_EXT
||
3044 srcFormat
== GL_RGBA_INTEGER_EXT
||
3045 srcFormat
== GL_BGR_INTEGER_EXT
||
3046 srcFormat
== GL_BGRA_INTEGER_EXT
||
3047 srcFormat
== GL_LUMINANCE_INTEGER_EXT
||
3048 srcFormat
== GL_LUMINANCE_ALPHA_INTEGER_EXT
);
3050 ASSERT(srcType
== GL_UNSIGNED_BYTE
||
3051 srcType
== GL_BYTE
||
3052 srcType
== GL_UNSIGNED_SHORT
||
3053 srcType
== GL_SHORT
||
3054 srcType
== GL_UNSIGNED_INT
||
3055 srcType
== GL_INT
||
3056 srcType
== GL_HALF_FLOAT_ARB
||
3057 srcType
== GL_FLOAT
||
3058 srcType
== GL_UNSIGNED_BYTE_3_3_2
||
3059 srcType
== GL_UNSIGNED_BYTE_2_3_3_REV
||
3060 srcType
== GL_UNSIGNED_SHORT_5_6_5
||
3061 srcType
== GL_UNSIGNED_SHORT_5_6_5_REV
||
3062 srcType
== GL_UNSIGNED_SHORT_4_4_4_4
||
3063 srcType
== GL_UNSIGNED_SHORT_4_4_4_4_REV
||
3064 srcType
== GL_UNSIGNED_SHORT_5_5_5_1
||
3065 srcType
== GL_UNSIGNED_SHORT_1_5_5_5_REV
||
3066 srcType
== GL_UNSIGNED_INT_8_8_8_8
||
3067 srcType
== GL_UNSIGNED_INT_8_8_8_8_REV
||
3068 srcType
== GL_UNSIGNED_INT_10_10_10_2
||
3069 srcType
== GL_UNSIGNED_INT_2_10_10_10_REV
||
3070 srcType
== GL_UNSIGNED_INT_5_9_9_9_REV
||
3071 srcType
== GL_UNSIGNED_INT_10F_11F_11F_REV
);
3073 get_component_mapping(srcFormat
,
3074 &rSrc
, &gSrc
, &bSrc
, &aSrc
,
3075 &rDst
, &gDst
, &bDst
, &aDst
);
3077 stride
= _mesa_components_in_format(srcFormat
);
3079 #define PROCESS(SRC_INDEX, DST_INDEX, DEFAULT, TYPE, CONVERSION) \
3080 if ((SRC_INDEX) < 0) { \
3082 for (i = 0; i < n; i++) { \
3083 rgba[i][DST_INDEX] = DEFAULT; \
3086 else if (swapBytes) { \
3087 const TYPE *s = (const TYPE *) src; \
3089 for (i = 0; i < n; i++) { \
3090 TYPE value = s[SRC_INDEX]; \
3091 if (sizeof(TYPE) == 2) { \
3094 else if (sizeof(TYPE) == 4) { \
3097 rgba[i][DST_INDEX] = CONVERSION(value); \
3102 const TYPE *s = (const TYPE *) src; \
3104 for (i = 0; i < n; i++) { \
3105 rgba[i][DST_INDEX] = CONVERSION(s[SRC_INDEX]); \
3111 case GL_UNSIGNED_BYTE
:
3112 PROCESS(rSrc
, RCOMP
, 0, GLubyte
, (GLuint
));
3113 PROCESS(gSrc
, GCOMP
, 0, GLubyte
, (GLuint
));
3114 PROCESS(bSrc
, BCOMP
, 0, GLubyte
, (GLuint
));
3115 PROCESS(aSrc
, ACOMP
, 1, GLubyte
, (GLuint
));
3118 PROCESS(rSrc
, RCOMP
, 0, GLbyte
, clamp_byte_to_uint
);
3119 PROCESS(gSrc
, GCOMP
, 0, GLbyte
, clamp_byte_to_uint
);
3120 PROCESS(bSrc
, BCOMP
, 0, GLbyte
, clamp_byte_to_uint
);
3121 PROCESS(aSrc
, ACOMP
, 1, GLbyte
, clamp_byte_to_uint
);
3123 case GL_UNSIGNED_SHORT
:
3124 PROCESS(rSrc
, RCOMP
, 0, GLushort
, (GLuint
));
3125 PROCESS(gSrc
, GCOMP
, 0, GLushort
, (GLuint
));
3126 PROCESS(bSrc
, BCOMP
, 0, GLushort
, (GLuint
));
3127 PROCESS(aSrc
, ACOMP
, 1, GLushort
, (GLuint
));
3130 PROCESS(rSrc
, RCOMP
, 0, GLshort
, clamp_short_to_uint
);
3131 PROCESS(gSrc
, GCOMP
, 0, GLshort
, clamp_short_to_uint
);
3132 PROCESS(bSrc
, BCOMP
, 0, GLshort
, clamp_short_to_uint
);
3133 PROCESS(aSrc
, ACOMP
, 1, GLshort
, clamp_short_to_uint
);
3135 case GL_UNSIGNED_INT
:
3136 PROCESS(rSrc
, RCOMP
, 0, GLuint
, (GLuint
));
3137 PROCESS(gSrc
, GCOMP
, 0, GLuint
, (GLuint
));
3138 PROCESS(bSrc
, BCOMP
, 0, GLuint
, (GLuint
));
3139 PROCESS(aSrc
, ACOMP
, 1, GLuint
, (GLuint
));
3142 PROCESS(rSrc
, RCOMP
, 0, GLint
, clamp_int_to_uint
);
3143 PROCESS(gSrc
, GCOMP
, 0, GLint
, clamp_int_to_uint
);
3144 PROCESS(bSrc
, BCOMP
, 0, GLint
, clamp_int_to_uint
);
3145 PROCESS(aSrc
, ACOMP
, 1, GLint
, clamp_int_to_uint
);
3148 PROCESS(rSrc
, RCOMP
, 0, GLfloat
, clamp_float_to_uint
);
3149 PROCESS(gSrc
, GCOMP
, 0, GLfloat
, clamp_float_to_uint
);
3150 PROCESS(bSrc
, BCOMP
, 0, GLfloat
, clamp_float_to_uint
);
3151 PROCESS(aSrc
, ACOMP
, 1, GLfloat
, clamp_float_to_uint
);
3153 case GL_HALF_FLOAT_ARB
:
3154 PROCESS(rSrc
, RCOMP
, 0, GLhalfARB
, clamp_half_to_uint
);
3155 PROCESS(gSrc
, GCOMP
, 0, GLhalfARB
, clamp_half_to_uint
);
3156 PROCESS(bSrc
, BCOMP
, 0, GLhalfARB
, clamp_half_to_uint
);
3157 PROCESS(aSrc
, ACOMP
, 1, GLhalfARB
, clamp_half_to_uint
);
3159 case GL_UNSIGNED_BYTE_3_3_2
:
3161 const GLubyte
*ubsrc
= (const GLubyte
*) src
;
3163 for (i
= 0; i
< n
; i
++) {
3164 GLubyte p
= ubsrc
[i
];
3165 rgba
[i
][rDst
] = ((p
>> 5) );
3166 rgba
[i
][gDst
] = ((p
>> 2) & 0x7);
3167 rgba
[i
][bDst
] = ((p
) & 0x3);
3172 case GL_UNSIGNED_BYTE_2_3_3_REV
:
3174 const GLubyte
*ubsrc
= (const GLubyte
*) src
;
3176 for (i
= 0; i
< n
; i
++) {
3177 GLubyte p
= ubsrc
[i
];
3178 rgba
[i
][rDst
] = ((p
) & 0x7);
3179 rgba
[i
][gDst
] = ((p
>> 3) & 0x7);
3180 rgba
[i
][bDst
] = ((p
>> 6) );
3185 case GL_UNSIGNED_SHORT_5_6_5
:
3187 const GLushort
*ussrc
= (const GLushort
*) src
;
3189 for (i
= 0; i
< n
; i
++) {
3190 GLushort p
= ussrc
[i
];
3192 rgba
[i
][rDst
] = ((p
>> 11) );
3193 rgba
[i
][gDst
] = ((p
>> 5) & 0x3f);
3194 rgba
[i
][bDst
] = ((p
) & 0x1f);
3199 const GLushort
*ussrc
= (const GLushort
*) src
;
3201 for (i
= 0; i
< n
; i
++) {
3202 GLushort p
= ussrc
[i
];
3203 rgba
[i
][rDst
] = ((p
>> 11) );
3204 rgba
[i
][gDst
] = ((p
>> 5) & 0x3f);
3205 rgba
[i
][bDst
] = ((p
) & 0x1f);
3210 case GL_UNSIGNED_SHORT_5_6_5_REV
:
3212 const GLushort
*ussrc
= (const GLushort
*) src
;
3214 for (i
= 0; i
< n
; i
++) {
3215 GLushort p
= ussrc
[i
];
3217 rgba
[i
][rDst
] = ((p
) & 0x1f);
3218 rgba
[i
][gDst
] = ((p
>> 5) & 0x3f);
3219 rgba
[i
][bDst
] = ((p
>> 11) );
3224 const GLushort
*ussrc
= (const GLushort
*) src
;
3226 for (i
= 0; i
< n
; i
++) {
3227 GLushort p
= ussrc
[i
];
3228 rgba
[i
][rDst
] = ((p
) & 0x1f);
3229 rgba
[i
][gDst
] = ((p
>> 5) & 0x3f);
3230 rgba
[i
][bDst
] = ((p
>> 11) );
3235 case GL_UNSIGNED_SHORT_4_4_4_4
:
3237 const GLushort
*ussrc
= (const GLushort
*) src
;
3239 for (i
= 0; i
< n
; i
++) {
3240 GLushort p
= ussrc
[i
];
3242 rgba
[i
][rDst
] = ((p
>> 12) );
3243 rgba
[i
][gDst
] = ((p
>> 8) & 0xf);
3244 rgba
[i
][bDst
] = ((p
>> 4) & 0xf);
3245 rgba
[i
][aDst
] = ((p
) & 0xf);
3249 const GLushort
*ussrc
= (const GLushort
*) src
;
3251 for (i
= 0; i
< n
; i
++) {
3252 GLushort p
= ussrc
[i
];
3253 rgba
[i
][rDst
] = ((p
>> 12) );
3254 rgba
[i
][gDst
] = ((p
>> 8) & 0xf);
3255 rgba
[i
][bDst
] = ((p
>> 4) & 0xf);
3256 rgba
[i
][aDst
] = ((p
) & 0xf);
3260 case GL_UNSIGNED_SHORT_4_4_4_4_REV
:
3262 const GLushort
*ussrc
= (const GLushort
*) src
;
3264 for (i
= 0; i
< n
; i
++) {
3265 GLushort p
= ussrc
[i
];
3267 rgba
[i
][rDst
] = ((p
) & 0xf);
3268 rgba
[i
][gDst
] = ((p
>> 4) & 0xf);
3269 rgba
[i
][bDst
] = ((p
>> 8) & 0xf);
3270 rgba
[i
][aDst
] = ((p
>> 12) );
3274 const GLushort
*ussrc
= (const GLushort
*) src
;
3276 for (i
= 0; i
< n
; i
++) {
3277 GLushort p
= ussrc
[i
];
3278 rgba
[i
][rDst
] = ((p
) & 0xf);
3279 rgba
[i
][gDst
] = ((p
>> 4) & 0xf);
3280 rgba
[i
][bDst
] = ((p
>> 8) & 0xf);
3281 rgba
[i
][aDst
] = ((p
>> 12) );
3285 case GL_UNSIGNED_SHORT_5_5_5_1
:
3287 const GLushort
*ussrc
= (const GLushort
*) src
;
3289 for (i
= 0; i
< n
; i
++) {
3290 GLushort p
= ussrc
[i
];
3292 rgba
[i
][rDst
] = ((p
>> 11) );
3293 rgba
[i
][gDst
] = ((p
>> 6) & 0x1f);
3294 rgba
[i
][bDst
] = ((p
>> 1) & 0x1f);
3295 rgba
[i
][aDst
] = ((p
) & 0x1 );
3299 const GLushort
*ussrc
= (const GLushort
*) src
;
3301 for (i
= 0; i
< n
; i
++) {
3302 GLushort p
= ussrc
[i
];
3303 rgba
[i
][rDst
] = ((p
>> 11) );
3304 rgba
[i
][gDst
] = ((p
>> 6) & 0x1f);
3305 rgba
[i
][bDst
] = ((p
>> 1) & 0x1f);
3306 rgba
[i
][aDst
] = ((p
) & 0x1 );
3310 case GL_UNSIGNED_SHORT_1_5_5_5_REV
:
3312 const GLushort
*ussrc
= (const GLushort
*) src
;
3314 for (i
= 0; i
< n
; i
++) {
3315 GLushort p
= ussrc
[i
];
3317 rgba
[i
][rDst
] = ((p
) & 0x1f);
3318 rgba
[i
][gDst
] = ((p
>> 5) & 0x1f);
3319 rgba
[i
][bDst
] = ((p
>> 10) & 0x1f);
3320 rgba
[i
][aDst
] = ((p
>> 15) );
3324 const GLushort
*ussrc
= (const GLushort
*) src
;
3326 for (i
= 0; i
< n
; i
++) {
3327 GLushort p
= ussrc
[i
];
3328 rgba
[i
][rDst
] = ((p
) & 0x1f);
3329 rgba
[i
][gDst
] = ((p
>> 5) & 0x1f);
3330 rgba
[i
][bDst
] = ((p
>> 10) & 0x1f);
3331 rgba
[i
][aDst
] = ((p
>> 15) );
3335 case GL_UNSIGNED_INT_8_8_8_8
:
3337 const GLuint
*uisrc
= (const GLuint
*) src
;
3339 for (i
= 0; i
< n
; i
++) {
3340 GLuint p
= uisrc
[i
];
3341 rgba
[i
][rDst
] = ((p
) & 0xff);
3342 rgba
[i
][gDst
] = ((p
>> 8) & 0xff);
3343 rgba
[i
][bDst
] = ((p
>> 16) & 0xff);
3344 rgba
[i
][aDst
] = ((p
>> 24) );
3348 const GLuint
*uisrc
= (const GLuint
*) src
;
3350 for (i
= 0; i
< n
; i
++) {
3351 GLuint p
= uisrc
[i
];
3352 rgba
[i
][rDst
] = ((p
>> 24) );
3353 rgba
[i
][gDst
] = ((p
>> 16) & 0xff);
3354 rgba
[i
][bDst
] = ((p
>> 8) & 0xff);
3355 rgba
[i
][aDst
] = ((p
) & 0xff);
3359 case GL_UNSIGNED_INT_8_8_8_8_REV
:
3361 const GLuint
*uisrc
= (const GLuint
*) src
;
3363 for (i
= 0; i
< n
; i
++) {
3364 GLuint p
= uisrc
[i
];
3365 rgba
[i
][rDst
] = ((p
>> 24) );
3366 rgba
[i
][gDst
] = ((p
>> 16) & 0xff);
3367 rgba
[i
][bDst
] = ((p
>> 8) & 0xff);
3368 rgba
[i
][aDst
] = ((p
) & 0xff);
3372 const GLuint
*uisrc
= (const GLuint
*) src
;
3374 for (i
= 0; i
< n
; i
++) {
3375 GLuint p
= uisrc
[i
];
3376 rgba
[i
][rDst
] = ((p
) & 0xff);
3377 rgba
[i
][gDst
] = ((p
>> 8) & 0xff);
3378 rgba
[i
][bDst
] = ((p
>> 16) & 0xff);
3379 rgba
[i
][aDst
] = ((p
>> 24) );
3383 case GL_UNSIGNED_INT_10_10_10_2
:
3385 const GLuint
*uisrc
= (const GLuint
*) src
;
3387 for (i
= 0; i
< n
; i
++) {
3388 GLuint p
= uisrc
[i
];
3390 rgba
[i
][rDst
] = ((p
>> 22) );
3391 rgba
[i
][gDst
] = ((p
>> 12) & 0x3ff);
3392 rgba
[i
][bDst
] = ((p
>> 2) & 0x3ff);
3393 rgba
[i
][aDst
] = ((p
) & 0x3 );
3397 const GLuint
*uisrc
= (const GLuint
*) src
;
3399 for (i
= 0; i
< n
; i
++) {
3400 GLuint p
= uisrc
[i
];
3401 rgba
[i
][rDst
] = ((p
>> 22) );
3402 rgba
[i
][gDst
] = ((p
>> 12) & 0x3ff);
3403 rgba
[i
][bDst
] = ((p
>> 2) & 0x3ff);
3404 rgba
[i
][aDst
] = ((p
) & 0x3 );
3408 case GL_UNSIGNED_INT_2_10_10_10_REV
:
3410 const GLuint
*uisrc
= (const GLuint
*) src
;
3412 for (i
= 0; i
< n
; i
++) {
3413 GLuint p
= uisrc
[i
];
3415 rgba
[i
][rDst
] = ((p
) & 0x3ff);
3416 rgba
[i
][gDst
] = ((p
>> 10) & 0x3ff);
3417 rgba
[i
][bDst
] = ((p
>> 20) & 0x3ff);
3418 rgba
[i
][aDst
] = ((p
>> 30) );
3422 const GLuint
*uisrc
= (const GLuint
*) src
;
3424 for (i
= 0; i
< n
; i
++) {
3425 GLuint p
= uisrc
[i
];
3426 rgba
[i
][rDst
] = ((p
) & 0x3ff);
3427 rgba
[i
][gDst
] = ((p
>> 10) & 0x3ff);
3428 rgba
[i
][bDst
] = ((p
>> 20) & 0x3ff);
3429 rgba
[i
][aDst
] = ((p
>> 30) );
3433 case GL_UNSIGNED_INT_5_9_9_9_REV
:
3435 const GLuint
*uisrc
= (const GLuint
*) src
;
3438 for (i
= 0; i
< n
; i
++) {
3439 GLuint p
= uisrc
[i
];
3441 rgb9e5_to_float3(p
, f
);
3442 rgba
[i
][rDst
] = clamp_float_to_uint(f
[0]);
3443 rgba
[i
][gDst
] = clamp_float_to_uint(f
[1]);
3444 rgba
[i
][bDst
] = clamp_float_to_uint(f
[2]);
3449 const GLuint
*uisrc
= (const GLuint
*) src
;
3452 for (i
= 0; i
< n
; i
++) {
3453 GLuint p
= uisrc
[i
];
3454 rgb9e5_to_float3(p
, f
);
3455 rgba
[i
][rDst
] = clamp_float_to_uint(f
[0]);
3456 rgba
[i
][gDst
] = clamp_float_to_uint(f
[1]);
3457 rgba
[i
][bDst
] = clamp_float_to_uint(f
[2]);
3462 case GL_UNSIGNED_INT_10F_11F_11F_REV
:
3464 const GLuint
*uisrc
= (const GLuint
*) src
;
3467 for (i
= 0; i
< n
; i
++) {
3468 GLuint p
= uisrc
[i
];
3470 r11g11b10f_to_float3(p
, f
);
3471 rgba
[i
][rDst
] = clamp_float_to_uint(f
[0]);
3472 rgba
[i
][gDst
] = clamp_float_to_uint(f
[1]);
3473 rgba
[i
][bDst
] = clamp_float_to_uint(f
[2]);
3478 const GLuint
*uisrc
= (const GLuint
*) src
;
3481 for (i
= 0; i
< n
; i
++) {
3482 GLuint p
= uisrc
[i
];
3483 r11g11b10f_to_float3(p
, f
);
3484 rgba
[i
][rDst
] = clamp_float_to_uint(f
[0]);
3485 rgba
[i
][gDst
] = clamp_float_to_uint(f
[1]);
3486 rgba
[i
][bDst
] = clamp_float_to_uint(f
[2]);
3492 _mesa_problem(NULL
, "bad srcType in extract uint data");
3501 * Unpack a row of color image data from a client buffer according to
3502 * the pixel unpacking parameters.
3503 * Return GLubyte values in the specified dest image format.
3504 * This is used by glDrawPixels and glTexImage?D().
3505 * \param ctx - the context
3506 * n - number of pixels in the span
3507 * dstFormat - format of destination color array
3508 * dest - the destination color array
3509 * srcFormat - source image format
3510 * srcType - source image data type
3511 * source - source image pointer
3512 * srcPacking - pixel unpacking parameters
3513 * transferOps - bitmask of IMAGE_*_BIT values of operations to apply
3515 * XXX perhaps expand this to process whole images someday.
3518 _mesa_unpack_color_span_ubyte(struct gl_context
*ctx
,
3519 GLuint n
, GLenum dstFormat
, GLubyte dest
[],
3520 GLenum srcFormat
, GLenum srcType
,
3521 const GLvoid
*source
,
3522 const struct gl_pixelstore_attrib
*srcPacking
,
3523 GLbitfield transferOps
)
3525 GLboolean intFormat
= _mesa_is_integer_format(srcFormat
);
3526 ASSERT(dstFormat
== GL_ALPHA
||
3527 dstFormat
== GL_LUMINANCE
||
3528 dstFormat
== GL_LUMINANCE_ALPHA
||
3529 dstFormat
== GL_INTENSITY
||
3530 dstFormat
== GL_RED
||
3531 dstFormat
== GL_RG
||
3532 dstFormat
== GL_RGB
||
3533 dstFormat
== GL_RGBA
);
3535 ASSERT(srcFormat
== GL_RED
||
3536 srcFormat
== GL_GREEN
||
3537 srcFormat
== GL_BLUE
||
3538 srcFormat
== GL_ALPHA
||
3539 srcFormat
== GL_LUMINANCE
||
3540 srcFormat
== GL_LUMINANCE_ALPHA
||
3541 srcFormat
== GL_INTENSITY
||
3542 srcFormat
== GL_RG
||
3543 srcFormat
== GL_RGB
||
3544 srcFormat
== GL_BGR
||
3545 srcFormat
== GL_RGBA
||
3546 srcFormat
== GL_BGRA
||
3547 srcFormat
== GL_ABGR_EXT
||
3548 srcFormat
== GL_COLOR_INDEX
);
3550 ASSERT(srcType
== GL_BITMAP
||
3551 srcType
== GL_UNSIGNED_BYTE
||
3552 srcType
== GL_BYTE
||
3553 srcType
== GL_UNSIGNED_SHORT
||
3554 srcType
== GL_SHORT
||
3555 srcType
== GL_UNSIGNED_INT
||
3556 srcType
== GL_INT
||
3557 srcType
== GL_HALF_FLOAT_ARB
||
3558 srcType
== GL_FLOAT
||
3559 srcType
== GL_UNSIGNED_BYTE_3_3_2
||
3560 srcType
== GL_UNSIGNED_BYTE_2_3_3_REV
||
3561 srcType
== GL_UNSIGNED_SHORT_5_6_5
||
3562 srcType
== GL_UNSIGNED_SHORT_5_6_5_REV
||
3563 srcType
== GL_UNSIGNED_SHORT_4_4_4_4
||
3564 srcType
== GL_UNSIGNED_SHORT_4_4_4_4_REV
||
3565 srcType
== GL_UNSIGNED_SHORT_5_5_5_1
||
3566 srcType
== GL_UNSIGNED_SHORT_1_5_5_5_REV
||
3567 srcType
== GL_UNSIGNED_INT_8_8_8_8
||
3568 srcType
== GL_UNSIGNED_INT_8_8_8_8_REV
||
3569 srcType
== GL_UNSIGNED_INT_10_10_10_2
||
3570 srcType
== GL_UNSIGNED_INT_2_10_10_10_REV
||
3571 srcType
== GL_UNSIGNED_INT_5_9_9_9_REV
||
3572 srcType
== GL_UNSIGNED_INT_10F_11F_11F_REV
);
3574 /* EXT_texture_integer specifies no transfer ops on integer
3575 * types in the resolved issues section. Just set them to 0
3576 * for integer surfaces.
3581 /* Try simple cases first */
3582 if (transferOps
== 0) {
3583 if (srcType
== GL_UNSIGNED_BYTE
) {
3584 if (dstFormat
== GL_RGBA
) {
3585 if (srcFormat
== GL_RGBA
) {
3586 memcpy( dest
, source
, n
* 4 * sizeof(GLubyte
) );
3589 else if (srcFormat
== GL_RGB
) {
3591 const GLubyte
*src
= (const GLubyte
*) source
;
3592 GLubyte
*dst
= dest
;
3593 for (i
= 0; i
< n
; i
++) {
3604 else if (dstFormat
== GL_RGB
) {
3605 if (srcFormat
== GL_RGB
) {
3606 memcpy( dest
, source
, n
* 3 * sizeof(GLubyte
) );
3609 else if (srcFormat
== GL_RGBA
) {
3611 const GLubyte
*src
= (const GLubyte
*) source
;
3612 GLubyte
*dst
= dest
;
3613 for (i
= 0; i
< n
; i
++) {
3623 else if (dstFormat
== srcFormat
) {
3624 GLint comps
= _mesa_components_in_format(srcFormat
);
3626 memcpy( dest
, source
, n
* comps
* sizeof(GLubyte
) );
3631 * Common situation, loading 8bit RGBA/RGB source images
3632 * into 16/32 bit destination. (OSMesa16/32)
3634 else if (srcType
== GL_UNSIGNED_BYTE
) {
3635 if (dstFormat
== GL_RGBA
) {
3636 if (srcFormat
== GL_RGB
) {
3638 const GLubyte
*src
= (const GLubyte
*) source
;
3639 GLubyte
*dst
= dest
;
3640 for (i
= 0; i
< n
; i
++) {
3650 else if (srcFormat
== GL_RGBA
) {
3652 const GLubyte
*src
= (const GLubyte
*) source
;
3653 GLubyte
*dst
= dest
;
3654 for (i
= 0; i
< n
; i
++) {
3665 else if (dstFormat
== GL_RGB
) {
3666 if (srcFormat
== GL_RGB
) {
3668 const GLubyte
*src
= (const GLubyte
*) source
;
3669 GLubyte
*dst
= dest
;
3670 for (i
= 0; i
< n
; i
++) {
3679 else if (srcFormat
== GL_RGBA
) {
3681 const GLubyte
*src
= (const GLubyte
*) source
;
3682 GLubyte
*dst
= dest
;
3683 for (i
= 0; i
< n
; i
++) {
3697 /* general solution begins here */
3699 GLint dstComponents
;
3700 GLint rDst
, gDst
, bDst
, aDst
, lDst
, iDst
;
3701 GLfloat (*rgba
)[4] = (GLfloat (*)[4]) malloc(4 * n
* sizeof(GLfloat
));
3704 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "pixel unpacking");
3708 dstComponents
= _mesa_components_in_format( dstFormat
);
3709 /* source & dest image formats should have been error checked by now */
3710 assert(dstComponents
> 0);
3713 * Extract image data and convert to RGBA floats
3715 if (srcFormat
== GL_COLOR_INDEX
) {
3716 GLuint
*indexes
= (GLuint
*) malloc(n
* sizeof(GLuint
));
3719 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "pixel unpacking");
3724 extract_uint_indexes(n
, indexes
, srcFormat
, srcType
, source
,
3727 /* Convert indexes to RGBA */
3728 if (transferOps
& IMAGE_SHIFT_OFFSET_BIT
) {
3729 _mesa_shift_and_offset_ci(ctx
, n
, indexes
);
3731 _mesa_map_ci_to_rgba(ctx
, n
, indexes
, rgba
);
3733 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
3734 * with color indexes.
3736 transferOps
&= ~(IMAGE_SCALE_BIAS_BIT
| IMAGE_MAP_COLOR_BIT
);
3741 /* non-color index data */
3742 extract_float_rgba(n
, rgba
, srcFormat
, srcType
, source
,
3743 srcPacking
->SwapBytes
);
3746 /* Need to clamp if returning GLubytes */
3747 transferOps
|= IMAGE_CLAMP_BIT
;
3750 _mesa_apply_rgba_transfer_ops(ctx
, transferOps
, n
, rgba
);
3753 get_component_indexes(dstFormat
,
3754 &rDst
, &gDst
, &bDst
, &aDst
, &lDst
, &iDst
);
3756 /* Now return the GLubyte data in the requested dstFormat */
3758 GLubyte
*dst
= dest
;
3760 for (i
= 0; i
< n
; i
++) {
3761 CLAMPED_FLOAT_TO_UBYTE(dst
[rDst
], rgba
[i
][RCOMP
]);
3762 dst
+= dstComponents
;
3767 GLubyte
*dst
= dest
;
3769 for (i
= 0; i
< n
; i
++) {
3770 CLAMPED_FLOAT_TO_UBYTE(dst
[gDst
], rgba
[i
][GCOMP
]);
3771 dst
+= dstComponents
;
3776 GLubyte
*dst
= dest
;
3778 for (i
= 0; i
< n
; i
++) {
3779 CLAMPED_FLOAT_TO_UBYTE(dst
[bDst
], rgba
[i
][BCOMP
]);
3780 dst
+= dstComponents
;
3785 GLubyte
*dst
= dest
;
3787 for (i
= 0; i
< n
; i
++) {
3788 CLAMPED_FLOAT_TO_UBYTE(dst
[aDst
], rgba
[i
][ACOMP
]);
3789 dst
+= dstComponents
;
3794 GLubyte
*dst
= dest
;
3797 assert(dstComponents
== 1);
3798 for (i
= 0; i
< n
; i
++) {
3799 /* Intensity comes from red channel */
3800 CLAMPED_FLOAT_TO_UBYTE(dst
[i
], rgba
[i
][RCOMP
]);
3805 GLubyte
*dst
= dest
;
3808 for (i
= 0; i
< n
; i
++) {
3809 /* Luminance comes from red channel */
3810 CLAMPED_FLOAT_TO_UBYTE(dst
[0], rgba
[i
][RCOMP
]);
3811 dst
+= dstComponents
;
3821 * Same as _mesa_unpack_color_span_ubyte(), but return GLfloat data
3822 * instead of GLubyte.
3825 _mesa_unpack_color_span_float( struct gl_context
*ctx
,
3826 GLuint n
, GLenum dstFormat
, GLfloat dest
[],
3827 GLenum srcFormat
, GLenum srcType
,
3828 const GLvoid
*source
,
3829 const struct gl_pixelstore_attrib
*srcPacking
,
3830 GLbitfield transferOps
)
3832 ASSERT(dstFormat
== GL_ALPHA
||
3833 dstFormat
== GL_LUMINANCE
||
3834 dstFormat
== GL_LUMINANCE_ALPHA
||
3835 dstFormat
== GL_INTENSITY
||
3836 dstFormat
== GL_RED
||
3837 dstFormat
== GL_RG
||
3838 dstFormat
== GL_RGB
||
3839 dstFormat
== GL_RGBA
);
3841 ASSERT(srcFormat
== GL_RED
||
3842 srcFormat
== GL_GREEN
||
3843 srcFormat
== GL_BLUE
||
3844 srcFormat
== GL_ALPHA
||
3845 srcFormat
== GL_LUMINANCE
||
3846 srcFormat
== GL_LUMINANCE_ALPHA
||
3847 srcFormat
== GL_INTENSITY
||
3848 srcFormat
== GL_RG
||
3849 srcFormat
== GL_RGB
||
3850 srcFormat
== GL_BGR
||
3851 srcFormat
== GL_RGBA
||
3852 srcFormat
== GL_BGRA
||
3853 srcFormat
== GL_ABGR_EXT
||
3854 srcFormat
== GL_RED_INTEGER_EXT
||
3855 srcFormat
== GL_GREEN_INTEGER_EXT
||
3856 srcFormat
== GL_BLUE_INTEGER_EXT
||
3857 srcFormat
== GL_ALPHA_INTEGER_EXT
||
3858 srcFormat
== GL_RGB_INTEGER_EXT
||
3859 srcFormat
== GL_RGBA_INTEGER_EXT
||
3860 srcFormat
== GL_BGR_INTEGER_EXT
||
3861 srcFormat
== GL_BGRA_INTEGER_EXT
||
3862 srcFormat
== GL_LUMINANCE_INTEGER_EXT
||
3863 srcFormat
== GL_LUMINANCE_ALPHA_INTEGER_EXT
||
3864 srcFormat
== GL_COLOR_INDEX
);
3866 ASSERT(srcType
== GL_BITMAP
||
3867 srcType
== GL_UNSIGNED_BYTE
||
3868 srcType
== GL_BYTE
||
3869 srcType
== GL_UNSIGNED_SHORT
||
3870 srcType
== GL_SHORT
||
3871 srcType
== GL_UNSIGNED_INT
||
3872 srcType
== GL_INT
||
3873 srcType
== GL_HALF_FLOAT_ARB
||
3874 srcType
== GL_FLOAT
||
3875 srcType
== GL_UNSIGNED_BYTE_3_3_2
||
3876 srcType
== GL_UNSIGNED_BYTE_2_3_3_REV
||
3877 srcType
== GL_UNSIGNED_SHORT_5_6_5
||
3878 srcType
== GL_UNSIGNED_SHORT_5_6_5_REV
||
3879 srcType
== GL_UNSIGNED_SHORT_4_4_4_4
||
3880 srcType
== GL_UNSIGNED_SHORT_4_4_4_4_REV
||
3881 srcType
== GL_UNSIGNED_SHORT_5_5_5_1
||
3882 srcType
== GL_UNSIGNED_SHORT_1_5_5_5_REV
||
3883 srcType
== GL_UNSIGNED_INT_8_8_8_8
||
3884 srcType
== GL_UNSIGNED_INT_8_8_8_8_REV
||
3885 srcType
== GL_UNSIGNED_INT_10_10_10_2
||
3886 srcType
== GL_UNSIGNED_INT_2_10_10_10_REV
||
3887 srcType
== GL_UNSIGNED_INT_5_9_9_9_REV
||
3888 srcType
== GL_UNSIGNED_INT_10F_11F_11F_REV
);
3890 /* general solution, no special cases, yet */
3892 GLint dstComponents
;
3893 GLint rDst
, gDst
, bDst
, aDst
, lDst
, iDst
;
3894 GLfloat (*rgba
)[4] = (GLfloat (*)[4]) malloc(4 * n
* sizeof(GLfloat
));
3895 GLboolean intFormat
= _mesa_is_integer_format(srcFormat
);
3898 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "pixel unpacking");
3902 dstComponents
= _mesa_components_in_format( dstFormat
);
3903 /* source & dest image formats should have been error checked by now */
3904 assert(dstComponents
> 0);
3906 /* EXT_texture_integer specifies no transfer ops on integer
3907 * types in the resolved issues section. Just set them to 0
3908 * for integer surfaces.
3914 * Extract image data and convert to RGBA floats
3916 if (srcFormat
== GL_COLOR_INDEX
) {
3917 GLuint
*indexes
= (GLuint
*) malloc(n
* sizeof(GLuint
));
3920 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "pixel unpacking");
3925 extract_uint_indexes(n
, indexes
, srcFormat
, srcType
, source
,
3928 /* Convert indexes to RGBA */
3929 if (transferOps
& IMAGE_SHIFT_OFFSET_BIT
) {
3930 _mesa_shift_and_offset_ci(ctx
, n
, indexes
);
3932 _mesa_map_ci_to_rgba(ctx
, n
, indexes
, rgba
);
3934 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
3935 * with color indexes.
3937 transferOps
&= ~(IMAGE_SCALE_BIAS_BIT
| IMAGE_MAP_COLOR_BIT
);
3942 /* non-color index data */
3943 extract_float_rgba(n
, rgba
, srcFormat
, srcType
, source
,
3944 srcPacking
->SwapBytes
);
3948 _mesa_apply_rgba_transfer_ops(ctx
, transferOps
, n
, rgba
);
3951 get_component_indexes(dstFormat
,
3952 &rDst
, &gDst
, &bDst
, &aDst
, &lDst
, &iDst
);
3954 /* Now pack results in the requested dstFormat */
3956 GLfloat
*dst
= dest
;
3958 for (i
= 0; i
< n
; i
++) {
3959 dst
[rDst
] = rgba
[i
][RCOMP
];
3960 dst
+= dstComponents
;
3965 GLfloat
*dst
= dest
;
3967 for (i
= 0; i
< n
; i
++) {
3968 dst
[gDst
] = rgba
[i
][GCOMP
];
3969 dst
+= dstComponents
;
3974 GLfloat
*dst
= dest
;
3976 for (i
= 0; i
< n
; i
++) {
3977 dst
[bDst
] = rgba
[i
][BCOMP
];
3978 dst
+= dstComponents
;
3983 GLfloat
*dst
= dest
;
3985 for (i
= 0; i
< n
; i
++) {
3986 dst
[aDst
] = rgba
[i
][ACOMP
];
3987 dst
+= dstComponents
;
3992 GLfloat
*dst
= dest
;
3995 assert(dstComponents
== 1);
3996 for (i
= 0; i
< n
; i
++) {
3997 /* Intensity comes from red channel */
3998 dst
[i
] = rgba
[i
][RCOMP
];
4003 GLfloat
*dst
= dest
;
4006 for (i
= 0; i
< n
; i
++) {
4007 /* Luminance comes from red channel */
4008 dst
[0] = rgba
[i
][RCOMP
];
4009 dst
+= dstComponents
;
4019 * Same as _mesa_unpack_color_span_ubyte(), but return GLuint data
4020 * instead of GLubyte.
4021 * No pixel transfer ops are applied.
4024 _mesa_unpack_color_span_uint(struct gl_context
*ctx
,
4025 GLuint n
, GLenum dstFormat
, GLuint
*dest
,
4026 GLenum srcFormat
, GLenum srcType
,
4027 const GLvoid
*source
,
4028 const struct gl_pixelstore_attrib
*srcPacking
)
4030 GLuint (*rgba
)[4] = (GLuint (*)[4]) malloc(n
* 4 * sizeof(GLfloat
));
4033 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "pixel unpacking");
4037 ASSERT(dstFormat
== GL_ALPHA
||
4038 dstFormat
== GL_LUMINANCE
||
4039 dstFormat
== GL_LUMINANCE_ALPHA
||
4040 dstFormat
== GL_INTENSITY
||
4041 dstFormat
== GL_RED
||
4042 dstFormat
== GL_RG
||
4043 dstFormat
== GL_RGB
||
4044 dstFormat
== GL_RGBA
);
4046 ASSERT(srcFormat
== GL_RED
||
4047 srcFormat
== GL_GREEN
||
4048 srcFormat
== GL_BLUE
||
4049 srcFormat
== GL_ALPHA
||
4050 srcFormat
== GL_LUMINANCE
||
4051 srcFormat
== GL_LUMINANCE_ALPHA
||
4052 srcFormat
== GL_INTENSITY
||
4053 srcFormat
== GL_RG
||
4054 srcFormat
== GL_RGB
||
4055 srcFormat
== GL_BGR
||
4056 srcFormat
== GL_RGBA
||
4057 srcFormat
== GL_BGRA
||
4058 srcFormat
== GL_ABGR_EXT
||
4059 srcFormat
== GL_RED_INTEGER_EXT
||
4060 srcFormat
== GL_GREEN_INTEGER_EXT
||
4061 srcFormat
== GL_BLUE_INTEGER_EXT
||
4062 srcFormat
== GL_ALPHA_INTEGER_EXT
||
4063 srcFormat
== GL_RGB_INTEGER_EXT
||
4064 srcFormat
== GL_RGBA_INTEGER_EXT
||
4065 srcFormat
== GL_BGR_INTEGER_EXT
||
4066 srcFormat
== GL_BGRA_INTEGER_EXT
||
4067 srcFormat
== GL_LUMINANCE_INTEGER_EXT
||
4068 srcFormat
== GL_LUMINANCE_ALPHA_INTEGER_EXT
);
4070 ASSERT(srcType
== GL_UNSIGNED_BYTE
||
4071 srcType
== GL_BYTE
||
4072 srcType
== GL_UNSIGNED_SHORT
||
4073 srcType
== GL_SHORT
||
4074 srcType
== GL_UNSIGNED_INT
||
4075 srcType
== GL_INT
||
4076 srcType
== GL_HALF_FLOAT_ARB
||
4077 srcType
== GL_FLOAT
||
4078 srcType
== GL_UNSIGNED_BYTE_3_3_2
||
4079 srcType
== GL_UNSIGNED_BYTE_2_3_3_REV
||
4080 srcType
== GL_UNSIGNED_SHORT_5_6_5
||
4081 srcType
== GL_UNSIGNED_SHORT_5_6_5_REV
||
4082 srcType
== GL_UNSIGNED_SHORT_4_4_4_4
||
4083 srcType
== GL_UNSIGNED_SHORT_4_4_4_4_REV
||
4084 srcType
== GL_UNSIGNED_SHORT_5_5_5_1
||
4085 srcType
== GL_UNSIGNED_SHORT_1_5_5_5_REV
||
4086 srcType
== GL_UNSIGNED_INT_8_8_8_8
||
4087 srcType
== GL_UNSIGNED_INT_8_8_8_8_REV
||
4088 srcType
== GL_UNSIGNED_INT_10_10_10_2
||
4089 srcType
== GL_UNSIGNED_INT_2_10_10_10_REV
||
4090 srcType
== GL_UNSIGNED_INT_5_9_9_9_REV
||
4091 srcType
== GL_UNSIGNED_INT_10F_11F_11F_REV
);
4094 /* Extract image data as uint[4] pixels */
4095 extract_uint_rgba(n
, rgba
, srcFormat
, srcType
, source
,
4096 srcPacking
->SwapBytes
);
4098 if (dstFormat
== GL_RGBA
) {
4100 memcpy(dest
, rgba
, 4 * sizeof(GLuint
) * n
);
4104 GLint rDst
, gDst
, bDst
, aDst
, lDst
, iDst
;
4105 GLint dstComponents
= _mesa_components_in_format( dstFormat
);
4107 assert(dstComponents
> 0);
4109 get_component_indexes(dstFormat
,
4110 &rDst
, &gDst
, &bDst
, &aDst
, &lDst
, &iDst
);
4112 /* Now pack values in the requested dest format */
4116 for (i
= 0; i
< n
; i
++) {
4117 dst
[rDst
] = rgba
[i
][RCOMP
];
4118 dst
+= dstComponents
;
4125 for (i
= 0; i
< n
; i
++) {
4126 dst
[gDst
] = rgba
[i
][GCOMP
];
4127 dst
+= dstComponents
;
4134 for (i
= 0; i
< n
; i
++) {
4135 dst
[bDst
] = rgba
[i
][BCOMP
];
4136 dst
+= dstComponents
;
4143 for (i
= 0; i
< n
; i
++) {
4144 dst
[aDst
] = rgba
[i
][ACOMP
];
4145 dst
+= dstComponents
;
4153 assert(dstComponents
== 1);
4154 for (i
= 0; i
< n
; i
++) {
4155 /* Intensity comes from red channel */
4156 dst
[i
] = rgba
[i
][RCOMP
];
4164 for (i
= 0; i
< n
; i
++) {
4165 /* Luminance comes from red channel */
4166 dst
[0] = rgba
[i
][RCOMP
];
4167 dst
+= dstComponents
;
4178 * Similar to _mesa_unpack_color_span_float(), but for dudv data instead of rgba,
4179 * directly return GLbyte data, no transfer ops apply.
4182 _mesa_unpack_dudv_span_byte( struct gl_context
*ctx
,
4183 GLuint n
, GLenum dstFormat
, GLbyte dest
[],
4184 GLenum srcFormat
, GLenum srcType
,
4185 const GLvoid
*source
,
4186 const struct gl_pixelstore_attrib
*srcPacking
,
4187 GLbitfield transferOps
)
4189 ASSERT(dstFormat
== GL_DUDV_ATI
);
4190 ASSERT(srcFormat
== GL_DUDV_ATI
||
4191 srcFormat
== GL_DU8DV8_ATI
);
4193 ASSERT(srcType
== GL_UNSIGNED_BYTE
||
4194 srcType
== GL_BYTE
||
4195 srcType
== GL_UNSIGNED_SHORT
||
4196 srcType
== GL_SHORT
||
4197 srcType
== GL_UNSIGNED_INT
||
4198 srcType
== GL_INT
||
4199 srcType
== GL_HALF_FLOAT_ARB
||
4200 srcType
== GL_FLOAT
);
4202 /* general solution */
4204 GLint dstComponents
;
4207 GLfloat (*rgba
)[4] = (GLfloat (*)[4]) malloc(4 * n
* sizeof(GLfloat
));
4210 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "pixel unpacking");
4214 dstComponents
= _mesa_components_in_format( dstFormat
);
4215 /* source & dest image formats should have been error checked by now */
4216 assert(dstComponents
> 0);
4219 * Extract image data and convert to RGBA floats
4221 extract_float_rgba(n
, rgba
, srcFormat
, srcType
, source
,
4222 srcPacking
->SwapBytes
);
4225 /* Now determine which color channels we need to produce.
4226 * And determine the dest index (offset) within each color tuple.
4229 /* Now pack results in the requested dstFormat */
4230 for (i
= 0; i
< n
; i
++) {
4231 /* not sure - need clamp[-1,1] here? */
4232 dst
[0] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
4233 dst
[1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
4234 dst
+= dstComponents
;
4242 * Unpack a row of color index data from a client buffer according to
4243 * the pixel unpacking parameters.
4244 * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.
4246 * Args: ctx - the context
4247 * n - number of pixels
4248 * dstType - destination data type
4249 * dest - destination array
4250 * srcType - source pixel type
4251 * source - source data pointer
4252 * srcPacking - pixel unpacking parameters
4253 * transferOps - the pixel transfer operations to apply
4256 _mesa_unpack_index_span( struct gl_context
*ctx
, GLuint n
,
4257 GLenum dstType
, GLvoid
*dest
,
4258 GLenum srcType
, const GLvoid
*source
,
4259 const struct gl_pixelstore_attrib
*srcPacking
,
4260 GLbitfield transferOps
)
4262 ASSERT(srcType
== GL_BITMAP
||
4263 srcType
== GL_UNSIGNED_BYTE
||
4264 srcType
== GL_BYTE
||
4265 srcType
== GL_UNSIGNED_SHORT
||
4266 srcType
== GL_SHORT
||
4267 srcType
== GL_UNSIGNED_INT
||
4268 srcType
== GL_INT
||
4269 srcType
== GL_HALF_FLOAT_ARB
||
4270 srcType
== GL_FLOAT
);
4272 ASSERT(dstType
== GL_UNSIGNED_BYTE
||
4273 dstType
== GL_UNSIGNED_SHORT
||
4274 dstType
== GL_UNSIGNED_INT
);
4277 transferOps
&= (IMAGE_MAP_COLOR_BIT
| IMAGE_SHIFT_OFFSET_BIT
);
4280 * Try simple cases first
4282 if (transferOps
== 0 && srcType
== GL_UNSIGNED_BYTE
4283 && dstType
== GL_UNSIGNED_BYTE
) {
4284 memcpy(dest
, source
, n
* sizeof(GLubyte
));
4286 else if (transferOps
== 0 && srcType
== GL_UNSIGNED_INT
4287 && dstType
== GL_UNSIGNED_INT
&& !srcPacking
->SwapBytes
) {
4288 memcpy(dest
, source
, n
* sizeof(GLuint
));
4294 GLuint
*indexes
= (GLuint
*) malloc(n
* sizeof(GLuint
));
4297 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "pixel unpacking");
4301 extract_uint_indexes(n
, indexes
, GL_COLOR_INDEX
, srcType
, source
,
4305 _mesa_apply_ci_transfer_ops(ctx
, transferOps
, n
, indexes
);
4307 /* convert to dest type */
4309 case GL_UNSIGNED_BYTE
:
4311 GLubyte
*dst
= (GLubyte
*) dest
;
4313 for (i
= 0; i
< n
; i
++) {
4314 dst
[i
] = (GLubyte
) (indexes
[i
] & 0xff);
4318 case GL_UNSIGNED_SHORT
:
4320 GLuint
*dst
= (GLuint
*) dest
;
4322 for (i
= 0; i
< n
; i
++) {
4323 dst
[i
] = (GLushort
) (indexes
[i
] & 0xffff);
4327 case GL_UNSIGNED_INT
:
4328 memcpy(dest
, indexes
, n
* sizeof(GLuint
));
4331 _mesa_problem(ctx
, "bad dstType in _mesa_unpack_index_span");
4340 _mesa_pack_index_span( struct gl_context
*ctx
, GLuint n
,
4341 GLenum dstType
, GLvoid
*dest
, const GLuint
*source
,
4342 const struct gl_pixelstore_attrib
*dstPacking
,
4343 GLbitfield transferOps
)
4345 GLuint
*indexes
= (GLuint
*) malloc(n
* sizeof(GLuint
));
4348 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "pixel packing");
4352 transferOps
&= (IMAGE_MAP_COLOR_BIT
| IMAGE_SHIFT_OFFSET_BIT
);
4354 if (transferOps
& (IMAGE_MAP_COLOR_BIT
| IMAGE_SHIFT_OFFSET_BIT
)) {
4355 /* make a copy of input */
4356 memcpy(indexes
, source
, n
* sizeof(GLuint
));
4357 _mesa_apply_ci_transfer_ops(ctx
, transferOps
, n
, indexes
);
4362 case GL_UNSIGNED_BYTE
:
4364 GLubyte
*dst
= (GLubyte
*) dest
;
4366 for (i
= 0; i
< n
; i
++) {
4367 *dst
++ = (GLubyte
) source
[i
];
4373 GLbyte
*dst
= (GLbyte
*) dest
;
4375 for (i
= 0; i
< n
; i
++) {
4376 dst
[i
] = (GLbyte
) source
[i
];
4380 case GL_UNSIGNED_SHORT
:
4382 GLushort
*dst
= (GLushort
*) dest
;
4384 for (i
= 0; i
< n
; i
++) {
4385 dst
[i
] = (GLushort
) source
[i
];
4387 if (dstPacking
->SwapBytes
) {
4388 _mesa_swap2( (GLushort
*) dst
, n
);
4394 GLshort
*dst
= (GLshort
*) dest
;
4396 for (i
= 0; i
< n
; i
++) {
4397 dst
[i
] = (GLshort
) source
[i
];
4399 if (dstPacking
->SwapBytes
) {
4400 _mesa_swap2( (GLushort
*) dst
, n
);
4404 case GL_UNSIGNED_INT
:
4406 GLuint
*dst
= (GLuint
*) dest
;
4408 for (i
= 0; i
< n
; i
++) {
4409 dst
[i
] = (GLuint
) source
[i
];
4411 if (dstPacking
->SwapBytes
) {
4412 _mesa_swap4( (GLuint
*) dst
, n
);
4418 GLint
*dst
= (GLint
*) dest
;
4420 for (i
= 0; i
< n
; i
++) {
4421 dst
[i
] = (GLint
) source
[i
];
4423 if (dstPacking
->SwapBytes
) {
4424 _mesa_swap4( (GLuint
*) dst
, n
);
4430 GLfloat
*dst
= (GLfloat
*) dest
;
4432 for (i
= 0; i
< n
; i
++) {
4433 dst
[i
] = (GLfloat
) source
[i
];
4435 if (dstPacking
->SwapBytes
) {
4436 _mesa_swap4( (GLuint
*) dst
, n
);
4440 case GL_HALF_FLOAT_ARB
:
4442 GLhalfARB
*dst
= (GLhalfARB
*) dest
;
4444 for (i
= 0; i
< n
; i
++) {
4445 dst
[i
] = _mesa_float_to_half((GLfloat
) source
[i
]);
4447 if (dstPacking
->SwapBytes
) {
4448 _mesa_swap2( (GLushort
*) dst
, n
);
4453 _mesa_problem(ctx
, "bad type in _mesa_pack_index_span");
4461 * Unpack a row of stencil data from a client buffer according to
4462 * the pixel unpacking parameters.
4463 * This is (or will be) used by glDrawPixels
4465 * Args: ctx - the context
4466 * n - number of pixels
4467 * dstType - destination data type
4468 * dest - destination array
4469 * srcType - source pixel type
4470 * source - source data pointer
4471 * srcPacking - pixel unpacking parameters
4472 * transferOps - apply offset/bias/lookup ops?
4475 _mesa_unpack_stencil_span( struct gl_context
*ctx
, GLuint n
,
4476 GLenum dstType
, GLvoid
*dest
,
4477 GLenum srcType
, const GLvoid
*source
,
4478 const struct gl_pixelstore_attrib
*srcPacking
,
4479 GLbitfield transferOps
)
4481 ASSERT(srcType
== GL_BITMAP
||
4482 srcType
== GL_UNSIGNED_BYTE
||
4483 srcType
== GL_BYTE
||
4484 srcType
== GL_UNSIGNED_SHORT
||
4485 srcType
== GL_SHORT
||
4486 srcType
== GL_UNSIGNED_INT
||
4487 srcType
== GL_INT
||
4488 srcType
== GL_UNSIGNED_INT_24_8_EXT
||
4489 srcType
== GL_HALF_FLOAT_ARB
||
4490 srcType
== GL_FLOAT
||
4491 srcType
== GL_FLOAT_32_UNSIGNED_INT_24_8_REV
);
4493 ASSERT(dstType
== GL_UNSIGNED_BYTE
||
4494 dstType
== GL_UNSIGNED_SHORT
||
4495 dstType
== GL_UNSIGNED_INT
||
4496 dstType
== GL_FLOAT_32_UNSIGNED_INT_24_8_REV
);
4498 /* only shift and offset apply to stencil */
4499 transferOps
&= IMAGE_SHIFT_OFFSET_BIT
;
4502 * Try simple cases first
4504 if (transferOps
== 0 &&
4505 !ctx
->Pixel
.MapStencilFlag
&&
4506 srcType
== GL_UNSIGNED_BYTE
&&
4507 dstType
== GL_UNSIGNED_BYTE
) {
4508 memcpy(dest
, source
, n
* sizeof(GLubyte
));
4510 else if (transferOps
== 0 &&
4511 !ctx
->Pixel
.MapStencilFlag
&&
4512 srcType
== GL_UNSIGNED_INT
&&
4513 dstType
== GL_UNSIGNED_INT
&&
4514 !srcPacking
->SwapBytes
) {
4515 memcpy(dest
, source
, n
* sizeof(GLuint
));
4521 GLuint
*indexes
= (GLuint
*) malloc(n
* sizeof(GLuint
));
4524 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "stencil unpacking");
4528 extract_uint_indexes(n
, indexes
, GL_STENCIL_INDEX
, srcType
, source
,
4531 if (transferOps
& IMAGE_SHIFT_OFFSET_BIT
) {
4532 /* shift and offset indexes */
4533 _mesa_shift_and_offset_ci(ctx
, n
, indexes
);
4536 if (ctx
->Pixel
.MapStencilFlag
) {
4537 /* Apply stencil lookup table */
4538 const GLuint mask
= ctx
->PixelMaps
.StoS
.Size
- 1;
4540 for (i
= 0; i
< n
; i
++) {
4541 indexes
[i
] = (GLuint
)ctx
->PixelMaps
.StoS
.Map
[ indexes
[i
] & mask
];
4545 /* convert to dest type */
4547 case GL_UNSIGNED_BYTE
:
4549 GLubyte
*dst
= (GLubyte
*) dest
;
4551 for (i
= 0; i
< n
; i
++) {
4552 dst
[i
] = (GLubyte
) (indexes
[i
] & 0xff);
4556 case GL_UNSIGNED_SHORT
:
4558 GLuint
*dst
= (GLuint
*) dest
;
4560 for (i
= 0; i
< n
; i
++) {
4561 dst
[i
] = (GLushort
) (indexes
[i
] & 0xffff);
4565 case GL_UNSIGNED_INT
:
4566 memcpy(dest
, indexes
, n
* sizeof(GLuint
));
4568 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV
:
4570 GLuint
*dst
= (GLuint
*) dest
;
4572 for (i
= 0; i
< n
; i
++) {
4573 dst
[i
*2+1] = indexes
[i
] & 0xff; /* lower 8 bits */
4578 _mesa_problem(ctx
, "bad dstType in _mesa_unpack_stencil_span");
4587 _mesa_pack_stencil_span( struct gl_context
*ctx
, GLuint n
,
4588 GLenum dstType
, GLvoid
*dest
, const GLstencil
*source
,
4589 const struct gl_pixelstore_attrib
*dstPacking
)
4591 GLstencil
*stencil
= (GLstencil
*) malloc(n
* sizeof(GLstencil
));
4594 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "stencil packing");
4598 if (ctx
->Pixel
.IndexShift
|| ctx
->Pixel
.IndexOffset
||
4599 ctx
->Pixel
.MapStencilFlag
) {
4600 /* make a copy of input */
4601 memcpy(stencil
, source
, n
* sizeof(GLstencil
));
4602 _mesa_apply_stencil_transfer_ops(ctx
, n
, stencil
);
4607 case GL_UNSIGNED_BYTE
:
4608 if (sizeof(GLstencil
) == 1) {
4609 memcpy( dest
, source
, n
);
4612 GLubyte
*dst
= (GLubyte
*) dest
;
4615 dst
[i
] = (GLubyte
) source
[i
];
4621 GLbyte
*dst
= (GLbyte
*) dest
;
4624 dst
[i
] = (GLbyte
) (source
[i
] & 0x7f);
4628 case GL_UNSIGNED_SHORT
:
4630 GLushort
*dst
= (GLushort
*) dest
;
4633 dst
[i
] = (GLushort
) source
[i
];
4635 if (dstPacking
->SwapBytes
) {
4636 _mesa_swap2( (GLushort
*) dst
, n
);
4642 GLshort
*dst
= (GLshort
*) dest
;
4645 dst
[i
] = (GLshort
) source
[i
];
4647 if (dstPacking
->SwapBytes
) {
4648 _mesa_swap2( (GLushort
*) dst
, n
);
4652 case GL_UNSIGNED_INT
:
4654 GLuint
*dst
= (GLuint
*) dest
;
4657 dst
[i
] = (GLuint
) source
[i
];
4659 if (dstPacking
->SwapBytes
) {
4660 _mesa_swap4( (GLuint
*) dst
, n
);
4666 GLint
*dst
= (GLint
*) dest
;
4669 dst
[i
] = (GLint
) source
[i
];
4671 if (dstPacking
->SwapBytes
) {
4672 _mesa_swap4( (GLuint
*) dst
, n
);
4678 GLfloat
*dst
= (GLfloat
*) dest
;
4681 dst
[i
] = (GLfloat
) source
[i
];
4683 if (dstPacking
->SwapBytes
) {
4684 _mesa_swap4( (GLuint
*) dst
, n
);
4688 case GL_HALF_FLOAT_ARB
:
4690 GLhalfARB
*dst
= (GLhalfARB
*) dest
;
4693 dst
[i
] = _mesa_float_to_half( (float) source
[i
] );
4695 if (dstPacking
->SwapBytes
) {
4696 _mesa_swap2( (GLushort
*) dst
, n
);
4701 if (dstPacking
->LsbFirst
) {
4702 GLubyte
*dst
= (GLubyte
*) dest
;
4705 for (i
= 0; i
< n
; i
++) {
4708 *dst
|= ((source
[i
] != 0) << shift
);
4717 GLubyte
*dst
= (GLubyte
*) dest
;
4720 for (i
= 0; i
< n
; i
++) {
4723 *dst
|= ((source
[i
] != 0) << shift
);
4733 _mesa_problem(ctx
, "bad type in _mesa_pack_index_span");
4739 #define DEPTH_VALUES(GLTYPE, GLTYPE2FLOAT) \
4742 const GLTYPE *src = (const GLTYPE *)source; \
4743 for (i = 0; i < n; i++) { \
4744 GLTYPE value = src[i]; \
4745 if (srcPacking->SwapBytes) { \
4746 if (sizeof(GLTYPE) == 2) { \
4748 } else if (sizeof(GLTYPE) == 4) { \
4752 depthValues[i] = GLTYPE2FLOAT(value); \
4758 * Unpack a row of depth/z values from memory, returning GLushort, GLuint
4759 * or GLfloat values.
4760 * The glPixelTransfer (scale/bias) params will be applied.
4762 * \param dstType one of GL_UNSIGNED_SHORT, GL_UNSIGNED_INT, GL_FLOAT
4763 * \param depthMax max value for returned GLushort or GLuint values
4764 * (ignored for GLfloat).
4767 _mesa_unpack_depth_span( struct gl_context
*ctx
, GLuint n
,
4768 GLenum dstType
, GLvoid
*dest
, GLuint depthMax
,
4769 GLenum srcType
, const GLvoid
*source
,
4770 const struct gl_pixelstore_attrib
*srcPacking
)
4772 GLfloat
*depthTemp
= NULL
, *depthValues
;
4773 GLboolean needClamp
= GL_FALSE
;
4775 /* Look for special cases first.
4776 * Not only are these faster, they're less prone to numeric conversion
4777 * problems. Otherwise, converting from an int type to a float then
4778 * back to an int type can introduce errors that will show up as
4779 * artifacts in things like depth peeling which uses glCopyTexImage.
4781 if (ctx
->Pixel
.DepthScale
== 1.0 && ctx
->Pixel
.DepthBias
== 0.0) {
4782 if (srcType
== GL_UNSIGNED_INT
&& dstType
== GL_UNSIGNED_SHORT
) {
4783 const GLuint
*src
= (const GLuint
*) source
;
4784 GLushort
*dst
= (GLushort
*) dest
;
4786 for (i
= 0; i
< n
; i
++) {
4787 dst
[i
] = src
[i
] >> 16;
4791 if (srcType
== GL_UNSIGNED_SHORT
4792 && dstType
== GL_UNSIGNED_INT
4793 && depthMax
== 0xffffffff) {
4794 const GLushort
*src
= (const GLushort
*) source
;
4795 GLuint
*dst
= (GLuint
*) dest
;
4797 for (i
= 0; i
< n
; i
++) {
4798 dst
[i
] = src
[i
] | (src
[i
] << 16);
4802 if (srcType
== GL_UNSIGNED_INT_24_8
4803 && dstType
== GL_UNSIGNED_INT
4804 && depthMax
== 0xffffff) {
4805 const GLuint
*src
= (const GLuint
*) source
;
4806 GLuint
*dst
= (GLuint
*) dest
;
4808 for (i
= 0; i
< n
; i
++) {
4809 dst
[i
] = src
[i
] >> 8;
4813 /* XXX may want to add additional cases here someday */
4816 /* general case path follows */
4818 if (dstType
== GL_FLOAT
) {
4819 depthValues
= (GLfloat
*) dest
;
4822 depthTemp
= (GLfloat
*) malloc(n
* sizeof(GLfloat
));
4824 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "pixel unpacking");
4828 depthValues
= depthTemp
;
4831 /* Convert incoming values to GLfloat. Some conversions will require
4836 DEPTH_VALUES(GLbyte
, BYTE_TO_FLOAT
);
4837 needClamp
= GL_TRUE
;
4839 case GL_UNSIGNED_BYTE
:
4840 DEPTH_VALUES(GLubyte
, UBYTE_TO_FLOAT
);
4843 DEPTH_VALUES(GLshort
, SHORT_TO_FLOAT
);
4844 needClamp
= GL_TRUE
;
4846 case GL_UNSIGNED_SHORT
:
4847 DEPTH_VALUES(GLushort
, USHORT_TO_FLOAT
);
4850 DEPTH_VALUES(GLint
, INT_TO_FLOAT
);
4851 needClamp
= GL_TRUE
;
4853 case GL_UNSIGNED_INT
:
4854 DEPTH_VALUES(GLuint
, UINT_TO_FLOAT
);
4856 case GL_UNSIGNED_INT_24_8_EXT
: /* GL_EXT_packed_depth_stencil */
4857 if (dstType
== GL_UNSIGNED_INT_24_8_EXT
&&
4858 depthMax
== 0xffffff &&
4859 ctx
->Pixel
.DepthScale
== 1.0 &&
4860 ctx
->Pixel
.DepthBias
== 0.0) {
4861 const GLuint
*src
= (const GLuint
*) source
;
4862 GLuint
*zValues
= (GLuint
*) dest
;
4864 for (i
= 0; i
< n
; i
++) {
4865 GLuint value
= src
[i
];
4866 if (srcPacking
->SwapBytes
) {
4869 zValues
[i
] = value
& 0xffffff00;
4875 const GLuint
*src
= (const GLuint
*) source
;
4876 const GLfloat scale
= 1.0f
/ 0xffffff;
4878 for (i
= 0; i
< n
; i
++) {
4879 GLuint value
= src
[i
];
4880 if (srcPacking
->SwapBytes
) {
4883 depthValues
[i
] = (value
>> 8) * scale
;
4887 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV
:
4890 const GLfloat
*src
= (const GLfloat
*)source
;
4891 for (i
= 0; i
< n
; i
++) {
4892 GLfloat value
= src
[i
* 2];
4893 if (srcPacking
->SwapBytes
) {
4896 depthValues
[i
] = value
;
4898 needClamp
= GL_TRUE
;
4902 DEPTH_VALUES(GLfloat
, 1*);
4903 needClamp
= GL_TRUE
;
4905 case GL_HALF_FLOAT_ARB
:
4908 const GLhalfARB
*src
= (const GLhalfARB
*) source
;
4909 for (i
= 0; i
< n
; i
++) {
4910 GLhalfARB value
= src
[i
];
4911 if (srcPacking
->SwapBytes
) {
4914 depthValues
[i
] = _mesa_half_to_float(value
);
4916 needClamp
= GL_TRUE
;
4920 _mesa_problem(NULL
, "bad type in _mesa_unpack_depth_span()");
4925 /* apply depth scale and bias */
4927 const GLfloat scale
= ctx
->Pixel
.DepthScale
;
4928 const GLfloat bias
= ctx
->Pixel
.DepthBias
;
4929 if (scale
!= 1.0 || bias
!= 0.0) {
4931 for (i
= 0; i
< n
; i
++) {
4932 depthValues
[i
] = depthValues
[i
] * scale
+ bias
;
4934 needClamp
= GL_TRUE
;
4938 /* clamp to [0, 1] */
4941 for (i
= 0; i
< n
; i
++) {
4942 depthValues
[i
] = (GLfloat
)CLAMP(depthValues
[i
], 0.0, 1.0);
4947 * Convert values to dstType
4949 if (dstType
== GL_UNSIGNED_INT
) {
4950 GLuint
*zValues
= (GLuint
*) dest
;
4952 if (depthMax
<= 0xffffff) {
4953 /* no overflow worries */
4954 for (i
= 0; i
< n
; i
++) {
4955 zValues
[i
] = (GLuint
) (depthValues
[i
] * (GLfloat
) depthMax
);
4959 /* need to use double precision to prevent overflow problems */
4960 for (i
= 0; i
< n
; i
++) {
4961 GLdouble z
= depthValues
[i
] * (GLfloat
) depthMax
;
4962 if (z
>= (GLdouble
) 0xffffffff)
4963 zValues
[i
] = 0xffffffff;
4965 zValues
[i
] = (GLuint
) z
;
4969 else if (dstType
== GL_UNSIGNED_SHORT
) {
4970 GLushort
*zValues
= (GLushort
*) dest
;
4972 ASSERT(depthMax
<= 0xffff);
4973 for (i
= 0; i
< n
; i
++) {
4974 zValues
[i
] = (GLushort
) (depthValues
[i
] * (GLfloat
) depthMax
);
4977 else if (dstType
== GL_FLOAT
) {
4978 /* Nothing to do. depthValues is pointing to dest. */
4980 else if (dstType
== GL_FLOAT_32_UNSIGNED_INT_24_8_REV
) {
4981 GLfloat
*zValues
= (GLfloat
*) dest
;
4983 for (i
= 0; i
< n
; i
++) {
4984 zValues
[i
*2] = depthValues
[i
];
4996 * Pack an array of depth values. The values are floats in [0,1].
4999 _mesa_pack_depth_span( struct gl_context
*ctx
, GLuint n
, GLvoid
*dest
,
5000 GLenum dstType
, const GLfloat
*depthSpan
,
5001 const struct gl_pixelstore_attrib
*dstPacking
)
5003 GLfloat
*depthCopy
= (GLfloat
*) malloc(n
* sizeof(GLfloat
));
5005 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "pixel packing");
5009 if (ctx
->Pixel
.DepthScale
!= 1.0 || ctx
->Pixel
.DepthBias
!= 0.0) {
5010 memcpy(depthCopy
, depthSpan
, n
* sizeof(GLfloat
));
5011 _mesa_scale_and_bias_depth(ctx
, n
, depthCopy
);
5012 depthSpan
= depthCopy
;
5016 case GL_UNSIGNED_BYTE
:
5018 GLubyte
*dst
= (GLubyte
*) dest
;
5020 for (i
= 0; i
< n
; i
++) {
5021 dst
[i
] = FLOAT_TO_UBYTE( depthSpan
[i
] );
5027 GLbyte
*dst
= (GLbyte
*) dest
;
5029 for (i
= 0; i
< n
; i
++) {
5030 dst
[i
] = FLOAT_TO_BYTE( depthSpan
[i
] );
5034 case GL_UNSIGNED_SHORT
:
5036 GLushort
*dst
= (GLushort
*) dest
;
5038 for (i
= 0; i
< n
; i
++) {
5039 CLAMPED_FLOAT_TO_USHORT(dst
[i
], depthSpan
[i
]);
5041 if (dstPacking
->SwapBytes
) {
5042 _mesa_swap2( (GLushort
*) dst
, n
);
5048 GLshort
*dst
= (GLshort
*) dest
;
5050 for (i
= 0; i
< n
; i
++) {
5051 dst
[i
] = FLOAT_TO_SHORT( depthSpan
[i
] );
5053 if (dstPacking
->SwapBytes
) {
5054 _mesa_swap2( (GLushort
*) dst
, n
);
5058 case GL_UNSIGNED_INT
:
5060 GLuint
*dst
= (GLuint
*) dest
;
5062 for (i
= 0; i
< n
; i
++) {
5063 dst
[i
] = FLOAT_TO_UINT( depthSpan
[i
] );
5065 if (dstPacking
->SwapBytes
) {
5066 _mesa_swap4( (GLuint
*) dst
, n
);
5072 GLint
*dst
= (GLint
*) dest
;
5074 for (i
= 0; i
< n
; i
++) {
5075 dst
[i
] = FLOAT_TO_INT( depthSpan
[i
] );
5077 if (dstPacking
->SwapBytes
) {
5078 _mesa_swap4( (GLuint
*) dst
, n
);
5084 GLfloat
*dst
= (GLfloat
*) dest
;
5086 for (i
= 0; i
< n
; i
++) {
5087 dst
[i
] = depthSpan
[i
];
5089 if (dstPacking
->SwapBytes
) {
5090 _mesa_swap4( (GLuint
*) dst
, n
);
5094 case GL_HALF_FLOAT_ARB
:
5096 GLhalfARB
*dst
= (GLhalfARB
*) dest
;
5098 for (i
= 0; i
< n
; i
++) {
5099 dst
[i
] = _mesa_float_to_half(depthSpan
[i
]);
5101 if (dstPacking
->SwapBytes
) {
5102 _mesa_swap2( (GLushort
*) dst
, n
);
5107 _mesa_problem(ctx
, "bad type in _mesa_pack_depth_span");
5116 * Pack depth and stencil values as GL_DEPTH_STENCIL (GL_UNSIGNED_INT_24_8 etc)
5119 _mesa_pack_depth_stencil_span(struct gl_context
*ctx
,GLuint n
,
5120 GLenum dstType
, GLuint
*dest
,
5121 const GLfloat
*depthVals
,
5122 const GLstencil
*stencilVals
,
5123 const struct gl_pixelstore_attrib
*dstPacking
)
5125 GLfloat
*depthCopy
= (GLfloat
*) malloc(n
* sizeof(GLfloat
));
5126 GLstencil
*stencilCopy
= (GLstencil
*) malloc(n
* sizeof(GLstencil
));
5129 if (!depthCopy
|| !stencilCopy
) {
5130 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "pixel packing");
5136 if (ctx
->Pixel
.DepthScale
!= 1.0 || ctx
->Pixel
.DepthBias
!= 0.0) {
5137 memcpy(depthCopy
, depthVals
, n
* sizeof(GLfloat
));
5138 _mesa_scale_and_bias_depth(ctx
, n
, depthCopy
);
5139 depthVals
= depthCopy
;
5142 if (ctx
->Pixel
.IndexShift
||
5143 ctx
->Pixel
.IndexOffset
||
5144 ctx
->Pixel
.MapStencilFlag
) {
5145 memcpy(stencilCopy
, stencilVals
, n
* sizeof(GLstencil
));
5146 _mesa_apply_stencil_transfer_ops(ctx
, n
, stencilCopy
);
5147 stencilVals
= stencilCopy
;
5151 case GL_UNSIGNED_INT_24_8
:
5152 for (i
= 0; i
< n
; i
++) {
5153 GLuint z
= (GLuint
) (depthVals
[i
] * 0xffffff);
5154 dest
[i
] = (z
<< 8) | (stencilVals
[i
] & 0xff);
5157 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV
:
5158 for (i
= 0; i
< n
; i
++) {
5159 ((GLfloat
*)dest
)[i
*2] = depthVals
[i
];
5160 dest
[i
*2+1] = stencilVals
[i
] & 0xff;
5165 if (dstPacking
->SwapBytes
) {
5166 _mesa_swap4(dest
, n
);
5177 * Unpack image data. Apply byte swapping, byte flipping (bitmap).
5178 * Return all image data in a contiguous block. This is used when we
5179 * compile glDrawPixels, glTexImage, etc into a display list. We
5180 * need a copy of the data in a standard format.
5183 _mesa_unpack_image( GLuint dimensions
,
5184 GLsizei width
, GLsizei height
, GLsizei depth
,
5185 GLenum format
, GLenum type
, const GLvoid
*pixels
,
5186 const struct gl_pixelstore_attrib
*unpack
)
5188 GLint bytesPerRow
, compsPerRow
;
5189 GLboolean flipBytes
, swap2
, swap4
;
5192 return NULL
; /* not necessarily an error */
5194 if (width
<= 0 || height
<= 0 || depth
<= 0)
5195 return NULL
; /* generate error later */
5197 if (type
== GL_BITMAP
) {
5198 bytesPerRow
= (width
+ 7) >> 3;
5199 flipBytes
= unpack
->LsbFirst
;
5200 swap2
= swap4
= GL_FALSE
;
5204 const GLint bytesPerPixel
= _mesa_bytes_per_pixel(format
, type
);
5205 GLint components
= _mesa_components_in_format(format
);
5208 if (_mesa_type_is_packed(type
))
5211 if (bytesPerPixel
<= 0 || components
<= 0)
5212 return NULL
; /* bad format or type. generate error later */
5213 bytesPerRow
= bytesPerPixel
* width
;
5214 bytesPerComp
= bytesPerPixel
/ components
;
5215 flipBytes
= GL_FALSE
;
5216 swap2
= (bytesPerComp
== 2) && unpack
->SwapBytes
;
5217 swap4
= (bytesPerComp
== 4) && unpack
->SwapBytes
;
5218 compsPerRow
= components
* width
;
5219 assert(compsPerRow
>= width
);
5224 = (GLubyte
*) malloc(bytesPerRow
* height
* depth
);
5228 return NULL
; /* generate GL_OUT_OF_MEMORY later */
5231 for (img
= 0; img
< depth
; img
++) {
5232 for (row
= 0; row
< height
; row
++) {
5233 const GLvoid
*src
= _mesa_image_address(dimensions
, unpack
, pixels
,
5234 width
, height
, format
, type
, img
, row
, 0);
5236 if ((type
== GL_BITMAP
) && (unpack
->SkipPixels
& 0x7)) {
5238 flipBytes
= GL_FALSE
;
5239 if (unpack
->LsbFirst
) {
5240 GLubyte srcMask
= 1 << (unpack
->SkipPixels
& 0x7);
5241 GLubyte dstMask
= 128;
5242 const GLubyte
*s
= src
;
5245 for (i
= 0; i
< width
; i
++) {
5249 if (srcMask
== 128) {
5254 srcMask
= srcMask
<< 1;
5262 dstMask
= dstMask
>> 1;
5267 GLubyte srcMask
= 128 >> (unpack
->SkipPixels
& 0x7);
5268 GLubyte dstMask
= 128;
5269 const GLubyte
*s
= src
;
5272 for (i
= 0; i
< width
; i
++) {
5281 srcMask
= srcMask
>> 1;
5289 dstMask
= dstMask
>> 1;
5295 memcpy(dst
, src
, bytesPerRow
);
5298 /* byte flipping/swapping */
5300 flip_bytes((GLubyte
*) dst
, bytesPerRow
);
5303 _mesa_swap2((GLushort
*) dst
, compsPerRow
);
5306 _mesa_swap4((GLuint
*) dst
, compsPerRow
);