2 * Mesa 3-D graphics library
5 * Copyright (C) 1999-2005 Brian Paul All Rights Reserved.
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
37 #include "histogram.h"
42 /** Compute ceiling of integer quotient of A divided by B. */
43 #define CEILING( A, B ) ( (A) % (B) == 0 ? (A)/(B) : (A)/(B)+1 )
47 * Flip the 8 bits in each byte of the given array.
50 * \param n number of bytes.
52 * \todo try this trick to flip bytes someday:
54 * v = ((v & 0x55555555) << 1) | ((v >> 1) & 0x55555555);
55 * v = ((v & 0x33333333) << 2) | ((v >> 2) & 0x33333333);
56 * v = ((v & 0x0f0f0f0f) << 4) | ((v >> 4) & 0x0f0f0f0f);
60 flip_bytes( GLubyte
*p
, GLuint n
)
62 register GLuint i
, a
, b
;
65 b
= (GLuint
) p
[i
]; /* words are often faster than bytes */
66 a
= ((b
& 0x01) << 7) |
80 * Flip the order of the 2 bytes in each word in the given array.
83 * \param n number of words.
86 _mesa_swap2( GLushort
*p
, GLuint n
)
91 p
[i
] = (p
[i
] >> 8) | ((p
[i
] << 8) & 0xff00);
98 * Flip the order of the 4 bytes in each word in the given array.
101 _mesa_swap4( GLuint
*p
, GLuint n
)
103 register GLuint i
, a
, b
;
108 | ((b
>> 8) & 0xff00)
109 | ((b
<< 8) & 0xff0000)
110 | ((b
<< 24) & 0xff000000);
117 * Get the size of a GL data type.
119 * \param type GL data type.
121 * \return the size, in bytes, of the given data type, 0 if a GL_BITMAP, or -1
122 * if an invalid type enum.
124 GLint
_mesa_sizeof_type( GLenum type
)
129 case GL_UNSIGNED_BYTE
:
130 return sizeof(GLubyte
);
132 return sizeof(GLbyte
);
133 case GL_UNSIGNED_SHORT
:
134 return sizeof(GLushort
);
136 return sizeof(GLshort
);
137 case GL_UNSIGNED_INT
:
138 return sizeof(GLuint
);
140 return sizeof(GLint
);
142 return sizeof(GLfloat
);
143 case GL_HALF_FLOAT_ARB
:
144 return sizeof(GLhalfARB
);
152 * Same as _mesa_sizeof_type() but also accepting the packed pixel
155 GLint
_mesa_sizeof_packed_type( GLenum type
)
160 case GL_UNSIGNED_BYTE
:
161 return sizeof(GLubyte
);
163 return sizeof(GLbyte
);
164 case GL_UNSIGNED_SHORT
:
165 return sizeof(GLushort
);
167 return sizeof(GLshort
);
168 case GL_UNSIGNED_INT
:
169 return sizeof(GLuint
);
171 return sizeof(GLint
);
172 case GL_HALF_FLOAT_ARB
:
173 return sizeof(GLhalfARB
);
175 return sizeof(GLfloat
);
176 case GL_UNSIGNED_BYTE_3_3_2
:
177 return sizeof(GLubyte
);
178 case GL_UNSIGNED_BYTE_2_3_3_REV
:
179 return sizeof(GLubyte
);
180 case GL_UNSIGNED_SHORT_5_6_5
:
181 return sizeof(GLushort
);
182 case GL_UNSIGNED_SHORT_5_6_5_REV
:
183 return sizeof(GLushort
);
184 case GL_UNSIGNED_SHORT_4_4_4_4
:
185 return sizeof(GLushort
);
186 case GL_UNSIGNED_SHORT_4_4_4_4_REV
:
187 return sizeof(GLushort
);
188 case GL_UNSIGNED_SHORT_5_5_5_1
:
189 return sizeof(GLushort
);
190 case GL_UNSIGNED_SHORT_1_5_5_5_REV
:
191 return sizeof(GLushort
);
192 case GL_UNSIGNED_INT_8_8_8_8
:
193 return sizeof(GLuint
);
194 case GL_UNSIGNED_INT_8_8_8_8_REV
:
195 return sizeof(GLuint
);
196 case GL_UNSIGNED_INT_10_10_10_2
:
197 return sizeof(GLuint
);
198 case GL_UNSIGNED_INT_2_10_10_10_REV
:
199 return sizeof(GLuint
);
200 case GL_UNSIGNED_SHORT_8_8_MESA
:
201 case GL_UNSIGNED_SHORT_8_8_REV_MESA
:
202 return sizeof(GLushort
);
203 case GL_UNSIGNED_INT_24_8_EXT
:
204 return sizeof(GLuint
);
212 * Get the number of components in a pixel format.
214 * \param format pixel format.
216 * \return the number of components in the given format, or -1 if a bad format.
218 GLint
_mesa_components_in_format( GLenum format
)
222 case GL_COLOR_INDEX1_EXT
:
223 case GL_COLOR_INDEX2_EXT
:
224 case GL_COLOR_INDEX4_EXT
:
225 case GL_COLOR_INDEX8_EXT
:
226 case GL_COLOR_INDEX12_EXT
:
227 case GL_COLOR_INDEX16_EXT
:
228 case GL_STENCIL_INDEX
:
229 case GL_DEPTH_COMPONENT
:
237 case GL_LUMINANCE_ALPHA
:
251 case GL_DEPTH_STENCIL_EXT
:
260 * Get the bytes per pixel of pixel format type pair.
262 * \param format pixel format.
263 * \param type pixel type.
265 * \return bytes per pixel, or -1 if a bad format or type was given.
267 GLint
_mesa_bytes_per_pixel( GLenum format
, GLenum type
)
269 GLint comps
= _mesa_components_in_format( format
);
275 return 0; /* special case */
277 case GL_UNSIGNED_BYTE
:
278 return comps
* sizeof(GLubyte
);
280 case GL_UNSIGNED_SHORT
:
281 return comps
* sizeof(GLshort
);
283 case GL_UNSIGNED_INT
:
284 return comps
* sizeof(GLint
);
286 return comps
* sizeof(GLfloat
);
287 case GL_HALF_FLOAT_ARB
:
288 return comps
* sizeof(GLhalfARB
);
289 case GL_UNSIGNED_BYTE_3_3_2
:
290 case GL_UNSIGNED_BYTE_2_3_3_REV
:
291 if (format
== GL_RGB
|| format
== GL_BGR
)
292 return sizeof(GLubyte
);
294 return -1; /* error */
295 case GL_UNSIGNED_SHORT_5_6_5
:
296 case GL_UNSIGNED_SHORT_5_6_5_REV
:
297 if (format
== GL_RGB
|| format
== GL_BGR
)
298 return sizeof(GLushort
);
300 return -1; /* error */
301 case GL_UNSIGNED_SHORT_4_4_4_4
:
302 case GL_UNSIGNED_SHORT_4_4_4_4_REV
:
303 case GL_UNSIGNED_SHORT_5_5_5_1
:
304 case GL_UNSIGNED_SHORT_1_5_5_5_REV
:
305 if (format
== GL_RGBA
|| format
== GL_BGRA
|| format
== GL_ABGR_EXT
)
306 return sizeof(GLushort
);
309 case GL_UNSIGNED_INT_8_8_8_8
:
310 case GL_UNSIGNED_INT_8_8_8_8_REV
:
311 case GL_UNSIGNED_INT_10_10_10_2
:
312 case GL_UNSIGNED_INT_2_10_10_10_REV
:
313 if (format
== GL_RGBA
|| format
== GL_BGRA
|| format
== GL_ABGR_EXT
)
314 return sizeof(GLuint
);
317 case GL_UNSIGNED_SHORT_8_8_MESA
:
318 case GL_UNSIGNED_SHORT_8_8_REV_MESA
:
319 if (format
== GL_YCBCR_MESA
)
320 return sizeof(GLushort
);
323 case GL_UNSIGNED_INT_24_8_EXT
:
324 if (format
== GL_DEPTH_STENCIL_EXT
)
325 return sizeof(GLuint
);
335 * Test for a legal pixel format and type.
337 * \param format pixel format.
338 * \param type pixel type.
340 * \return GL_TRUE if the given pixel format and type are legal, or GL_FALSE
344 _mesa_is_legal_format_and_type( GLcontext
*ctx
, GLenum format
, GLenum type
)
348 case GL_STENCIL_INDEX
:
352 case GL_UNSIGNED_BYTE
:
354 case GL_UNSIGNED_SHORT
:
356 case GL_UNSIGNED_INT
:
359 case GL_HALF_FLOAT_ARB
:
360 return ctx
->Extensions
.ARB_half_float_pixel
;
368 #if 0 /* not legal! see table 3.6 of the 1.5 spec */
372 case GL_LUMINANCE_ALPHA
:
373 case GL_DEPTH_COMPONENT
:
376 case GL_UNSIGNED_BYTE
:
378 case GL_UNSIGNED_SHORT
:
380 case GL_UNSIGNED_INT
:
383 case GL_HALF_FLOAT_ARB
:
384 return ctx
->Extensions
.ARB_half_float_pixel
;
391 case GL_UNSIGNED_BYTE
:
393 case GL_UNSIGNED_SHORT
:
395 case GL_UNSIGNED_INT
:
397 case GL_UNSIGNED_BYTE_3_3_2
:
398 case GL_UNSIGNED_BYTE_2_3_3_REV
:
399 case GL_UNSIGNED_SHORT_5_6_5
:
400 case GL_UNSIGNED_SHORT_5_6_5_REV
:
402 case GL_HALF_FLOAT_ARB
:
403 return ctx
->Extensions
.ARB_half_float_pixel
;
410 case GL_UNSIGNED_BYTE
:
412 case GL_UNSIGNED_SHORT
:
414 case GL_UNSIGNED_INT
:
417 case GL_HALF_FLOAT_ARB
:
418 return ctx
->Extensions
.ARB_half_float_pixel
;
427 case GL_UNSIGNED_BYTE
:
429 case GL_UNSIGNED_SHORT
:
431 case GL_UNSIGNED_INT
:
433 case GL_UNSIGNED_SHORT_4_4_4_4
:
434 case GL_UNSIGNED_SHORT_4_4_4_4_REV
:
435 case GL_UNSIGNED_SHORT_5_5_5_1
:
436 case GL_UNSIGNED_SHORT_1_5_5_5_REV
:
437 case GL_UNSIGNED_INT_8_8_8_8
:
438 case GL_UNSIGNED_INT_8_8_8_8_REV
:
439 case GL_UNSIGNED_INT_10_10_10_2
:
440 case GL_UNSIGNED_INT_2_10_10_10_REV
:
442 case GL_HALF_FLOAT_ARB
:
443 return ctx
->Extensions
.ARB_half_float_pixel
;
448 if (type
== GL_UNSIGNED_SHORT_8_8_MESA
||
449 type
== GL_UNSIGNED_SHORT_8_8_REV_MESA
)
453 case GL_DEPTH_STENCIL_EXT
:
454 if (ctx
->Extensions
.EXT_packed_depth_stencil
455 && type
== GL_UNSIGNED_INT_24_8_EXT
)
467 * Return the address of a specific pixel in an image (1D, 2D or 3D).
469 * Pixel unpacking/packing parameters are observed according to \p packing.
471 * \param dimensions either 1, 2 or 3 to indicate dimensionality of image
472 * \param image starting address of image data
473 * \param width the image width
474 * \param height theimage height
475 * \param format the pixel format
476 * \param type the pixel data type
477 * \param packing the pixelstore attributes
478 * \param img which image in the volume (0 for 1D or 2D images)
479 * \param row row of pixel in the image (0 for 1D images)
480 * \param column column of pixel in the image
482 * \return address of pixel on success, or NULL on error.
484 * \sa gl_pixelstore_attrib.
487 _mesa_image_address( GLuint dimensions
,
488 const struct gl_pixelstore_attrib
*packing
,
490 GLsizei width
, GLsizei height
,
491 GLenum format
, GLenum type
,
492 GLint img
, GLint row
, GLint column
)
494 GLint alignment
; /* 1, 2 or 4 */
495 GLint pixels_per_row
;
496 GLint rows_per_image
;
499 GLint skipimages
; /* for 3-D volume images */
502 ASSERT(dimensions
>= 1 && dimensions
<= 3);
504 alignment
= packing
->Alignment
;
505 if (packing
->RowLength
> 0) {
506 pixels_per_row
= packing
->RowLength
;
509 pixels_per_row
= width
;
511 if (packing
->ImageHeight
> 0) {
512 rows_per_image
= packing
->ImageHeight
;
515 rows_per_image
= height
;
518 skippixels
= packing
->SkipPixels
;
519 /* Note: SKIP_ROWS _is_ used for 1D images */
520 skiprows
= packing
->SkipRows
;
521 /* Note: SKIP_IMAGES is only used for 3D images */
522 skipimages
= (dimensions
== 3) ? packing
->SkipImages
: 0;
524 if (type
== GL_BITMAP
) {
526 GLint comp_per_pixel
; /* components per pixel */
527 GLint bytes_per_comp
; /* bytes per component */
529 GLint bytes_per_image
;
531 /* Compute bytes per component */
532 bytes_per_comp
= _mesa_sizeof_packed_type( type
);
533 if (bytes_per_comp
< 0) {
537 /* Compute number of components per pixel */
538 comp_per_pixel
= _mesa_components_in_format( format
);
539 if (comp_per_pixel
< 0) {
543 bytes_per_row
= alignment
544 * CEILING( comp_per_pixel
*pixels_per_row
, 8*alignment
);
546 bytes_per_image
= bytes_per_row
* rows_per_image
;
548 pixel_addr
= (GLubyte
*) image
549 + (skipimages
+ img
) * bytes_per_image
550 + (skiprows
+ row
) * bytes_per_row
551 + (skippixels
+ column
) / 8;
554 /* Non-BITMAP data */
555 GLint bytes_per_pixel
, bytes_per_row
, remainder
, bytes_per_image
;
558 bytes_per_pixel
= _mesa_bytes_per_pixel( format
, type
);
560 /* The pixel type and format should have been error checked earlier */
561 assert(bytes_per_pixel
> 0);
563 bytes_per_row
= pixels_per_row
* bytes_per_pixel
;
564 remainder
= bytes_per_row
% alignment
;
566 bytes_per_row
+= (alignment
- remainder
);
568 ASSERT(bytes_per_row
% alignment
== 0);
570 bytes_per_image
= bytes_per_row
* rows_per_image
;
572 if (packing
->Invert
) {
573 /* set pixel_addr to the last row */
574 topOfImage
= bytes_per_row
* (height
- 1);
575 bytes_per_row
= -bytes_per_row
;
581 /* compute final pixel address */
582 pixel_addr
= (GLubyte
*) image
583 + (skipimages
+ img
) * bytes_per_image
585 + (skiprows
+ row
) * bytes_per_row
586 + (skippixels
+ column
) * bytes_per_pixel
;
589 return (GLvoid
*) pixel_addr
;
594 _mesa_image_address1d( const struct gl_pixelstore_attrib
*packing
,
597 GLenum format
, GLenum type
,
600 return _mesa_image_address(1, packing
, image
, width
, 1,
601 format
, type
, 0, 0, column
);
606 _mesa_image_address2d( const struct gl_pixelstore_attrib
*packing
,
608 GLsizei width
, GLsizei height
,
609 GLenum format
, GLenum type
,
610 GLint row
, GLint column
)
612 return _mesa_image_address(2, packing
, image
, width
, height
,
613 format
, type
, 0, row
, column
);
618 _mesa_image_address3d( const struct gl_pixelstore_attrib
*packing
,
620 GLsizei width
, GLsizei height
,
621 GLenum format
, GLenum type
,
622 GLint img
, GLint row
, GLint column
)
624 return _mesa_image_address(3, packing
, image
, width
, height
,
625 format
, type
, img
, row
, column
);
631 * Compute the stride between image rows.
633 * \param packing the pixelstore attributes
634 * \param width image width.
635 * \param format pixel format.
636 * \param type pixel data type.
638 * \return the stride in bytes for the given parameters.
640 * Computes the number of bytes per pixel and row and compensates for alignment.
642 * \sa gl_pixelstore_attrib.
645 _mesa_image_row_stride( const struct gl_pixelstore_attrib
*packing
,
646 GLint width
, GLenum format
, GLenum type
)
649 if (type
== GL_BITMAP
) {
652 if (packing
->RowLength
== 0) {
653 bytes
= (width
+ 7) / 8;
656 bytes
= (packing
->RowLength
+ 7) / 8;
658 if (packing
->Invert
) {
659 /* negate the bytes per row (negative row stride) */
665 /* Non-BITMAP data */
666 const GLint bytesPerPixel
= _mesa_bytes_per_pixel(format
, type
);
667 GLint bytesPerRow
, remainder
;
668 if (bytesPerPixel
<= 0)
669 return -1; /* error */
670 if (packing
->RowLength
== 0) {
671 bytesPerRow
= bytesPerPixel
* width
;
674 bytesPerRow
= bytesPerPixel
* packing
->RowLength
;
676 remainder
= bytesPerRow
% packing
->Alignment
;
678 bytesPerRow
+= (packing
->Alignment
- remainder
);
680 bytesPerRow
= -bytesPerRow
;
689 * Compute the stride between images in a 3D texture (in bytes) for the given
690 * pixel packing parameters and image width, format and type.
693 _mesa_image_image_stride( const struct gl_pixelstore_attrib
*packing
,
694 GLint width
, GLint height
,
695 GLenum format
, GLenum type
)
698 ASSERT(type
!= GL_BITMAP
);
701 const GLint bytesPerPixel
= _mesa_bytes_per_pixel(format
, type
);
702 GLint bytesPerRow
, bytesPerImage
, remainder
;
704 if (bytesPerPixel
<= 0)
705 return -1; /* error */
706 if (packing
->RowLength
== 0) {
707 bytesPerRow
= bytesPerPixel
* width
;
710 bytesPerRow
= bytesPerPixel
* packing
->RowLength
;
712 remainder
= bytesPerRow
% packing
->Alignment
;
714 bytesPerRow
+= (packing
->Alignment
- remainder
);
716 if (packing
->ImageHeight
== 0)
717 bytesPerImage
= bytesPerRow
* height
;
719 bytesPerImage
= bytesPerRow
* packing
->ImageHeight
;
721 return bytesPerImage
;
727 * Unpack a 32x32 pixel polygon stipple from user memory using the
728 * current pixel unpack settings.
731 _mesa_unpack_polygon_stipple( const GLubyte
*pattern
, GLuint dest
[32],
732 const struct gl_pixelstore_attrib
*unpacking
)
734 GLubyte
*ptrn
= (GLubyte
*) _mesa_unpack_bitmap( 32, 32, pattern
, unpacking
);
736 /* Convert pattern from GLubytes to GLuints and handle big/little
741 for (i
= 0; i
< 32; i
++) {
742 dest
[i
] = (p
[0] << 24)
754 * Pack polygon stipple into user memory given current pixel packing
758 _mesa_pack_polygon_stipple( const GLuint pattern
[32], GLubyte
*dest
,
759 const struct gl_pixelstore_attrib
*packing
)
761 /* Convert pattern from GLuints to GLubytes to handle big/little
762 * endian differences.
766 for (i
= 0; i
< 32; i
++) {
767 ptrn
[i
* 4 + 0] = (GLubyte
) ((pattern
[i
] >> 24) & 0xff);
768 ptrn
[i
* 4 + 1] = (GLubyte
) ((pattern
[i
] >> 16) & 0xff);
769 ptrn
[i
* 4 + 2] = (GLubyte
) ((pattern
[i
] >> 8 ) & 0xff);
770 ptrn
[i
* 4 + 3] = (GLubyte
) ((pattern
[i
] ) & 0xff);
773 _mesa_pack_bitmap(32, 32, ptrn
, dest
, packing
);
778 * Unpack bitmap data. Resulting data will be in most-significant-bit-first
779 * order with row alignment = 1 byte.
782 _mesa_unpack_bitmap( GLint width
, GLint height
, const GLubyte
*pixels
,
783 const struct gl_pixelstore_attrib
*packing
)
785 GLint bytes
, row
, width_in_bytes
;
786 GLubyte
*buffer
, *dst
;
791 /* Alloc dest storage */
792 bytes
= ((width
+ 7) / 8 * height
);
793 buffer
= (GLubyte
*) MALLOC( bytes
);
798 width_in_bytes
= CEILING( width
, 8 );
800 for (row
= 0; row
< height
; row
++) {
801 const GLubyte
*src
= (const GLubyte
*)
802 _mesa_image_address2d(packing
, pixels
, width
, height
,
803 GL_COLOR_INDEX
, GL_BITMAP
, row
, 0);
809 if (packing
->SkipPixels
== 0) {
810 MEMCPY( dst
, src
, width_in_bytes
);
811 if (packing
->LsbFirst
) {
812 flip_bytes( dst
, width_in_bytes
);
816 /* handling SkipPixels is a bit tricky (no pun intended!) */
818 if (packing
->LsbFirst
) {
819 GLubyte srcMask
= 1 << (packing
->SkipPixels
& 0x7);
820 GLubyte dstMask
= 128;
821 const GLubyte
*s
= src
;
824 for (i
= 0; i
< width
; i
++) {
828 if (srcMask
== 128) {
833 srcMask
= srcMask
<< 1;
841 dstMask
= dstMask
>> 1;
846 GLubyte srcMask
= 128 >> (packing
->SkipPixels
& 0x7);
847 GLubyte dstMask
= 128;
848 const GLubyte
*s
= src
;
851 for (i
= 0; i
< width
; i
++) {
860 srcMask
= srcMask
>> 1;
868 dstMask
= dstMask
>> 1;
873 dst
+= width_in_bytes
;
884 _mesa_pack_bitmap( GLint width
, GLint height
, const GLubyte
*source
,
885 GLubyte
*dest
, const struct gl_pixelstore_attrib
*packing
)
887 GLint row
, width_in_bytes
;
893 width_in_bytes
= CEILING( width
, 8 );
895 for (row
= 0; row
< height
; row
++) {
896 GLubyte
*dst
= (GLubyte
*) _mesa_image_address2d(packing
, dest
,
897 width
, height
, GL_COLOR_INDEX
, GL_BITMAP
, row
, 0);
901 if (packing
->SkipPixels
== 0) {
902 MEMCPY( dst
, src
, width_in_bytes
);
903 if (packing
->LsbFirst
) {
904 flip_bytes( dst
, width_in_bytes
);
908 /* handling SkipPixels is a bit tricky (no pun intended!) */
910 if (packing
->LsbFirst
) {
911 GLubyte srcMask
= 1 << (packing
->SkipPixels
& 0x7);
912 GLubyte dstMask
= 128;
913 const GLubyte
*s
= src
;
916 for (i
= 0; i
< width
; i
++) {
920 if (srcMask
== 128) {
925 srcMask
= srcMask
<< 1;
933 dstMask
= dstMask
>> 1;
938 GLubyte srcMask
= 128 >> (packing
->SkipPixels
& 0x7);
939 GLubyte dstMask
= 128;
940 const GLubyte
*s
= src
;
943 for (i
= 0; i
< width
; i
++) {
952 srcMask
= srcMask
>> 1;
960 dstMask
= dstMask
>> 1;
965 src
+= width_in_bytes
;
971 * Apply various pixel transfer operations to an array of RGBA pixels
972 * as indicated by the transferOps bitmask
975 _mesa_apply_rgba_transfer_ops(GLcontext
*ctx
, GLuint transferOps
,
976 GLuint n
, GLfloat rgba
[][4])
979 if (transferOps
& IMAGE_SCALE_BIAS_BIT
) {
980 _mesa_scale_and_bias_rgba(n
, rgba
,
981 ctx
->Pixel
.RedScale
, ctx
->Pixel
.GreenScale
,
982 ctx
->Pixel
.BlueScale
, ctx
->Pixel
.AlphaScale
,
983 ctx
->Pixel
.RedBias
, ctx
->Pixel
.GreenBias
,
984 ctx
->Pixel
.BlueBias
, ctx
->Pixel
.AlphaBias
);
986 /* color map lookup */
987 if (transferOps
& IMAGE_MAP_COLOR_BIT
) {
988 _mesa_map_rgba( ctx
, n
, rgba
);
990 /* GL_COLOR_TABLE lookup */
991 if (transferOps
& IMAGE_COLOR_TABLE_BIT
) {
992 _mesa_lookup_rgba_float(&ctx
->ColorTable
, n
, rgba
);
995 if (transferOps
& IMAGE_CONVOLUTION_BIT
) {
996 /* this has to be done in the calling code */
997 _mesa_problem(ctx
, "IMAGE_CONVOLUTION_BIT set in _mesa_apply_transfer_ops");
999 /* GL_POST_CONVOLUTION_RED/GREEN/BLUE/ALPHA_SCALE/BIAS */
1000 if (transferOps
& IMAGE_POST_CONVOLUTION_SCALE_BIAS
) {
1001 _mesa_scale_and_bias_rgba(n
, rgba
,
1002 ctx
->Pixel
.PostConvolutionScale
[RCOMP
],
1003 ctx
->Pixel
.PostConvolutionScale
[GCOMP
],
1004 ctx
->Pixel
.PostConvolutionScale
[BCOMP
],
1005 ctx
->Pixel
.PostConvolutionScale
[ACOMP
],
1006 ctx
->Pixel
.PostConvolutionBias
[RCOMP
],
1007 ctx
->Pixel
.PostConvolutionBias
[GCOMP
],
1008 ctx
->Pixel
.PostConvolutionBias
[BCOMP
],
1009 ctx
->Pixel
.PostConvolutionBias
[ACOMP
]);
1011 /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
1012 if (transferOps
& IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT
) {
1013 _mesa_lookup_rgba_float(&ctx
->PostConvolutionColorTable
, n
, rgba
);
1015 /* color matrix transform */
1016 if (transferOps
& IMAGE_COLOR_MATRIX_BIT
) {
1017 _mesa_transform_rgba(ctx
, n
, rgba
);
1019 /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
1020 if (transferOps
& IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT
) {
1021 _mesa_lookup_rgba_float(&ctx
->PostColorMatrixColorTable
, n
, rgba
);
1023 /* update histogram count */
1024 if (transferOps
& IMAGE_HISTOGRAM_BIT
) {
1025 _mesa_update_histogram(ctx
, n
, (CONST
GLfloat (*)[4]) rgba
);
1027 /* update min/max values */
1028 if (transferOps
& IMAGE_MIN_MAX_BIT
) {
1029 _mesa_update_minmax(ctx
, n
, (CONST
GLfloat (*)[4]) rgba
);
1031 /* clamping to [0,1] */
1032 if (transferOps
& IMAGE_CLAMP_BIT
) {
1034 for (i
= 0; i
< n
; i
++) {
1035 rgba
[i
][RCOMP
] = CLAMP(rgba
[i
][RCOMP
], 0.0F
, 1.0F
);
1036 rgba
[i
][GCOMP
] = CLAMP(rgba
[i
][GCOMP
], 0.0F
, 1.0F
);
1037 rgba
[i
][BCOMP
] = CLAMP(rgba
[i
][BCOMP
], 0.0F
, 1.0F
);
1038 rgba
[i
][ACOMP
] = CLAMP(rgba
[i
][ACOMP
], 0.0F
, 1.0F
);
1046 * Used to pack an array [][4] of RGBA float colors as specified
1047 * by the dstFormat, dstType and dstPacking. Used by glReadPixels,
1048 * glGetConvolutionFilter(), etc.
1049 * NOTE: it's assumed the incoming float colors are all in [0,1].
1052 _mesa_pack_rgba_span_float( GLcontext
*ctx
,
1053 GLuint n
, CONST GLfloat rgbaIn
[][4],
1054 GLenum dstFormat
, GLenum dstType
,
1056 const struct gl_pixelstore_attrib
*dstPacking
,
1057 GLuint transferOps
)
1059 const GLint comps
= _mesa_components_in_format(dstFormat
);
1060 GLfloat luminance
[MAX_WIDTH
];
1061 const GLfloat (*rgba
)[4];
1065 /* make copy of incoming data */
1066 GLfloat rgbaCopy
[MAX_WIDTH
][4];
1067 _mesa_memcpy(rgbaCopy
, rgbaIn
, n
* 4 * sizeof(GLfloat
));
1068 _mesa_apply_rgba_transfer_ops(ctx
, transferOps
, n
, rgbaCopy
);
1069 rgba
= (const GLfloat (*)[4]) rgbaCopy
;
1071 if ((transferOps
& IMAGE_MIN_MAX_BIT
) && ctx
->MinMax
.Sink
) {
1076 /* use incoming data, not a copy */
1077 rgba
= (const GLfloat (*)[4]) rgbaIn
;
1080 if (dstFormat
== GL_LUMINANCE
|| dstFormat
== GL_LUMINANCE_ALPHA
) {
1081 /* compute luminance values */
1082 if (ctx
->Color
.ClampReadColor
== GL_TRUE
) {
1083 for (i
= 0; i
< n
; i
++) {
1084 GLfloat sum
= rgba
[i
][RCOMP
] + rgba
[i
][GCOMP
] + rgba
[i
][BCOMP
];
1085 luminance
[i
] = CLAMP(sum
, 0.0F
, 1.0F
);
1089 for (i
= 0; i
< n
; i
++) {
1090 luminance
[i
] = rgba
[i
][RCOMP
] + rgba
[i
][GCOMP
] + rgba
[i
][BCOMP
];
1096 * Pack/store the pixels. Ugh! Lots of cases!!!
1099 case GL_UNSIGNED_BYTE
:
1101 GLubyte
*dst
= (GLubyte
*) dstAddr
;
1102 switch (dstFormat
) {
1105 dst
[i
] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
1109 dst
[i
] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
1113 dst
[i
] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
1117 dst
[i
] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
1121 dst
[i
] = FLOAT_TO_UBYTE(luminance
[i
]);
1123 case GL_LUMINANCE_ALPHA
:
1125 dst
[i
*2+0] = FLOAT_TO_UBYTE(luminance
[i
]);
1126 dst
[i
*2+1] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
1131 dst
[i
*3+0] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
1132 dst
[i
*3+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
1133 dst
[i
*3+2] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
1138 dst
[i
*4+0] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
1139 dst
[i
*4+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
1140 dst
[i
*4+2] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
1141 dst
[i
*4+3] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
1146 dst
[i
*3+0] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
1147 dst
[i
*3+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
1148 dst
[i
*3+2] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
1153 dst
[i
*4+0] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
1154 dst
[i
*4+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
1155 dst
[i
*4+2] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
1156 dst
[i
*4+3] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
1161 dst
[i
*4+0] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
1162 dst
[i
*4+1] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
1163 dst
[i
*4+2] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
1164 dst
[i
*4+3] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
1168 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1174 GLbyte
*dst
= (GLbyte
*) dstAddr
;
1175 switch (dstFormat
) {
1178 dst
[i
] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
1182 dst
[i
] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
1186 dst
[i
] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
1190 dst
[i
] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
1194 dst
[i
] = FLOAT_TO_BYTE(luminance
[i
]);
1196 case GL_LUMINANCE_ALPHA
:
1198 dst
[i
*2+0] = FLOAT_TO_BYTE(luminance
[i
]);
1199 dst
[i
*2+1] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
1204 dst
[i
*3+0] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
1205 dst
[i
*3+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
1206 dst
[i
*3+2] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
1211 dst
[i
*4+0] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
1212 dst
[i
*4+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
1213 dst
[i
*4+2] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
1214 dst
[i
*4+3] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
1219 dst
[i
*3+0] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
1220 dst
[i
*3+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
1221 dst
[i
*3+2] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
1226 dst
[i
*4+0] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
1227 dst
[i
*4+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
1228 dst
[i
*4+2] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
1229 dst
[i
*4+3] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
1233 dst
[i
*4+0] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
1234 dst
[i
*4+1] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
1235 dst
[i
*4+2] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
1236 dst
[i
*4+3] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
1240 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1244 case GL_UNSIGNED_SHORT
:
1246 GLushort
*dst
= (GLushort
*) dstAddr
;
1247 switch (dstFormat
) {
1250 CLAMPED_FLOAT_TO_USHORT(dst
[i
], rgba
[i
][RCOMP
]);
1254 CLAMPED_FLOAT_TO_USHORT(dst
[i
], rgba
[i
][GCOMP
]);
1258 CLAMPED_FLOAT_TO_USHORT(dst
[i
], rgba
[i
][BCOMP
]);
1262 CLAMPED_FLOAT_TO_USHORT(dst
[i
], rgba
[i
][ACOMP
]);
1266 UNCLAMPED_FLOAT_TO_USHORT(dst
[i
], luminance
[i
]);
1268 case GL_LUMINANCE_ALPHA
:
1270 UNCLAMPED_FLOAT_TO_USHORT(dst
[i
*2+0], luminance
[i
]);
1271 CLAMPED_FLOAT_TO_USHORT(dst
[i
*2+1], rgba
[i
][ACOMP
]);
1276 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+0], rgba
[i
][RCOMP
]);
1277 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+1], rgba
[i
][GCOMP
]);
1278 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+2], rgba
[i
][BCOMP
]);
1283 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+0], rgba
[i
][RCOMP
]);
1284 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+1], rgba
[i
][GCOMP
]);
1285 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+2], rgba
[i
][BCOMP
]);
1286 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+3], rgba
[i
][ACOMP
]);
1291 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+0], rgba
[i
][BCOMP
]);
1292 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+1], rgba
[i
][GCOMP
]);
1293 CLAMPED_FLOAT_TO_USHORT(dst
[i
*3+2], rgba
[i
][RCOMP
]);
1298 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+0], rgba
[i
][BCOMP
]);
1299 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+1], rgba
[i
][GCOMP
]);
1300 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+2], rgba
[i
][RCOMP
]);
1301 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+3], rgba
[i
][ACOMP
]);
1306 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+0], rgba
[i
][ACOMP
]);
1307 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+1], rgba
[i
][BCOMP
]);
1308 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+2], rgba
[i
][GCOMP
]);
1309 CLAMPED_FLOAT_TO_USHORT(dst
[i
*4+3], rgba
[i
][RCOMP
]);
1313 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1315 if (dstPacking
->SwapBytes
) {
1316 _mesa_swap2( (GLushort
*) dst
, n
* comps
);
1322 GLshort
*dst
= (GLshort
*) dstAddr
;
1323 switch (dstFormat
) {
1326 dst
[i
] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1330 dst
[i
] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1334 dst
[i
] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1338 dst
[i
] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
1342 dst
[i
] = FLOAT_TO_SHORT(luminance
[i
]);
1344 case GL_LUMINANCE_ALPHA
:
1346 dst
[i
*2+0] = FLOAT_TO_SHORT(luminance
[i
]);
1347 dst
[i
*2+1] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
1352 dst
[i
*3+0] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1353 dst
[i
*3+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1354 dst
[i
*3+2] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1359 dst
[i
*4+0] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1360 dst
[i
*4+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1361 dst
[i
*4+2] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1362 dst
[i
*4+3] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
1367 dst
[i
*3+0] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1368 dst
[i
*3+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1369 dst
[i
*3+2] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1374 dst
[i
*4+0] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1375 dst
[i
*4+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1376 dst
[i
*4+2] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1377 dst
[i
*4+3] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
1381 dst
[i
*4+0] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
1382 dst
[i
*4+1] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1383 dst
[i
*4+2] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1384 dst
[i
*4+3] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1388 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1390 if (dstPacking
->SwapBytes
) {
1391 _mesa_swap2( (GLushort
*) dst
, n
* comps
);
1395 case GL_UNSIGNED_INT
:
1397 GLuint
*dst
= (GLuint
*) dstAddr
;
1398 switch (dstFormat
) {
1401 dst
[i
] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1405 dst
[i
] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1409 dst
[i
] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1413 dst
[i
] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
1417 dst
[i
] = FLOAT_TO_UINT(luminance
[i
]);
1419 case GL_LUMINANCE_ALPHA
:
1421 dst
[i
*2+0] = FLOAT_TO_UINT(luminance
[i
]);
1422 dst
[i
*2+1] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
1427 dst
[i
*3+0] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1428 dst
[i
*3+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1429 dst
[i
*3+2] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1434 dst
[i
*4+0] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1435 dst
[i
*4+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1436 dst
[i
*4+2] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1437 dst
[i
*4+3] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
1442 dst
[i
*3+0] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1443 dst
[i
*3+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1444 dst
[i
*3+2] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1449 dst
[i
*4+0] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1450 dst
[i
*4+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1451 dst
[i
*4+2] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1452 dst
[i
*4+3] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
1457 dst
[i
*4+0] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
1458 dst
[i
*4+1] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1459 dst
[i
*4+2] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1460 dst
[i
*4+3] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1464 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1466 if (dstPacking
->SwapBytes
) {
1467 _mesa_swap4( (GLuint
*) dst
, n
* comps
);
1473 GLint
*dst
= (GLint
*) dstAddr
;
1474 switch (dstFormat
) {
1477 dst
[i
] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1481 dst
[i
] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1485 dst
[i
] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1489 dst
[i
] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
1493 dst
[i
] = FLOAT_TO_INT(luminance
[i
]);
1495 case GL_LUMINANCE_ALPHA
:
1497 dst
[i
*2+0] = FLOAT_TO_INT(luminance
[i
]);
1498 dst
[i
*2+1] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
1503 dst
[i
*3+0] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1504 dst
[i
*3+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1505 dst
[i
*3+2] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1510 dst
[i
*4+0] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1511 dst
[i
*4+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1512 dst
[i
*4+2] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1513 dst
[i
*4+3] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
1518 dst
[i
*3+0] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1519 dst
[i
*3+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1520 dst
[i
*3+2] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1525 dst
[i
*4+0] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1526 dst
[i
*4+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1527 dst
[i
*4+2] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1528 dst
[i
*4+3] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
1533 dst
[i
*4+0] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
1534 dst
[i
*4+1] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1535 dst
[i
*4+2] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1536 dst
[i
*4+3] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1540 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1542 if (dstPacking
->SwapBytes
) {
1543 _mesa_swap4( (GLuint
*) dst
, n
* comps
);
1549 GLfloat
*dst
= (GLfloat
*) dstAddr
;
1550 switch (dstFormat
) {
1553 dst
[i
] = rgba
[i
][RCOMP
];
1557 dst
[i
] = rgba
[i
][GCOMP
];
1561 dst
[i
] = rgba
[i
][BCOMP
];
1565 dst
[i
] = rgba
[i
][ACOMP
];
1569 dst
[i
] = luminance
[i
];
1571 case GL_LUMINANCE_ALPHA
:
1573 dst
[i
*2+0] = luminance
[i
];
1574 dst
[i
*2+1] = rgba
[i
][ACOMP
];
1579 dst
[i
*3+0] = rgba
[i
][RCOMP
];
1580 dst
[i
*3+1] = rgba
[i
][GCOMP
];
1581 dst
[i
*3+2] = rgba
[i
][BCOMP
];
1586 dst
[i
*4+0] = rgba
[i
][RCOMP
];
1587 dst
[i
*4+1] = rgba
[i
][GCOMP
];
1588 dst
[i
*4+2] = rgba
[i
][BCOMP
];
1589 dst
[i
*4+3] = rgba
[i
][ACOMP
];
1594 dst
[i
*3+0] = rgba
[i
][BCOMP
];
1595 dst
[i
*3+1] = rgba
[i
][GCOMP
];
1596 dst
[i
*3+2] = rgba
[i
][RCOMP
];
1601 dst
[i
*4+0] = rgba
[i
][BCOMP
];
1602 dst
[i
*4+1] = rgba
[i
][GCOMP
];
1603 dst
[i
*4+2] = rgba
[i
][RCOMP
];
1604 dst
[i
*4+3] = rgba
[i
][ACOMP
];
1609 dst
[i
*4+0] = rgba
[i
][ACOMP
];
1610 dst
[i
*4+1] = rgba
[i
][BCOMP
];
1611 dst
[i
*4+2] = rgba
[i
][GCOMP
];
1612 dst
[i
*4+3] = rgba
[i
][RCOMP
];
1616 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1618 if (dstPacking
->SwapBytes
) {
1619 _mesa_swap4( (GLuint
*) dst
, n
* comps
);
1623 case GL_HALF_FLOAT_ARB
:
1625 GLhalfARB
*dst
= (GLhalfARB
*) dstAddr
;
1626 switch (dstFormat
) {
1629 dst
[i
] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1633 dst
[i
] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1637 dst
[i
] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1641 dst
[i
] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
1645 dst
[i
] = _mesa_float_to_half(luminance
[i
]);
1647 case GL_LUMINANCE_ALPHA
:
1649 dst
[i
*2+0] = _mesa_float_to_half(luminance
[i
]);
1650 dst
[i
*2+1] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
1655 dst
[i
*3+0] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1656 dst
[i
*3+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1657 dst
[i
*3+2] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1662 dst
[i
*4+0] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1663 dst
[i
*4+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1664 dst
[i
*4+2] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1665 dst
[i
*4+3] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
1670 dst
[i
*3+0] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1671 dst
[i
*3+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1672 dst
[i
*3+2] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1677 dst
[i
*4+0] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1678 dst
[i
*4+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1679 dst
[i
*4+2] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1680 dst
[i
*4+3] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
1685 dst
[i
*4+0] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
1686 dst
[i
*4+1] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1687 dst
[i
*4+2] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1688 dst
[i
*4+3] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1692 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1694 if (dstPacking
->SwapBytes
) {
1695 _mesa_swap2( (GLushort
*) dst
, n
* comps
);
1699 case GL_UNSIGNED_BYTE_3_3_2
:
1700 if (dstFormat
== GL_RGB
) {
1701 GLubyte
*dst
= (GLubyte
*) dstAddr
;
1703 dst
[i
] = (((GLint
) (rgba
[i
][RCOMP
] * 7.0F
)) << 5)
1704 | (((GLint
) (rgba
[i
][GCOMP
] * 7.0F
)) << 2)
1705 | (((GLint
) (rgba
[i
][BCOMP
] * 3.0F
)) );
1709 case GL_UNSIGNED_BYTE_2_3_3_REV
:
1710 if (dstFormat
== GL_RGB
) {
1711 GLubyte
*dst
= (GLubyte
*) dstAddr
;
1713 dst
[i
] = (((GLint
) (rgba
[i
][RCOMP
] * 7.0F
)) )
1714 | (((GLint
) (rgba
[i
][GCOMP
] * 7.0F
)) << 3)
1715 | (((GLint
) (rgba
[i
][BCOMP
] * 3.0F
)) << 5);
1719 case GL_UNSIGNED_SHORT_5_6_5
:
1720 if (dstFormat
== GL_RGB
) {
1721 GLushort
*dst
= (GLushort
*) dstAddr
;
1723 dst
[i
] = (((GLint
) (rgba
[i
][RCOMP
] * 31.0F
)) << 11)
1724 | (((GLint
) (rgba
[i
][GCOMP
] * 63.0F
)) << 5)
1725 | (((GLint
) (rgba
[i
][BCOMP
] * 31.0F
)) );
1729 case GL_UNSIGNED_SHORT_5_6_5_REV
:
1730 if (dstFormat
== GL_RGB
) {
1731 GLushort
*dst
= (GLushort
*) dstAddr
;
1733 dst
[i
] = (((GLint
) (rgba
[i
][RCOMP
] * 31.0F
)) )
1734 | (((GLint
) (rgba
[i
][GCOMP
] * 63.0F
)) << 5)
1735 | (((GLint
) (rgba
[i
][BCOMP
] * 31.0F
)) << 11);
1739 case GL_UNSIGNED_SHORT_4_4_4_4
:
1740 if (dstFormat
== GL_RGBA
) {
1741 GLushort
*dst
= (GLushort
*) dstAddr
;
1743 dst
[i
] = (((GLint
) (rgba
[i
][RCOMP
] * 15.0F
)) << 12)
1744 | (((GLint
) (rgba
[i
][GCOMP
] * 15.0F
)) << 8)
1745 | (((GLint
) (rgba
[i
][BCOMP
] * 15.0F
)) << 4)
1746 | (((GLint
) (rgba
[i
][ACOMP
] * 15.0F
)) );
1749 else if (dstFormat
== GL_BGRA
) {
1750 GLushort
*dst
= (GLushort
*) dstAddr
;
1752 dst
[i
] = (((GLint
) (rgba
[i
][BCOMP
] * 15.0F
)) << 12)
1753 | (((GLint
) (rgba
[i
][GCOMP
] * 15.0F
)) << 8)
1754 | (((GLint
) (rgba
[i
][RCOMP
] * 15.0F
)) << 4)
1755 | (((GLint
) (rgba
[i
][ACOMP
] * 15.0F
)) );
1758 else if (dstFormat
== GL_ABGR_EXT
) {
1759 GLushort
*dst
= (GLushort
*) dstAddr
;
1761 dst
[i
] = (((GLint
) (rgba
[i
][ACOMP
] * 15.0F
)) << 4)
1762 | (((GLint
) (rgba
[i
][BCOMP
] * 15.0F
)) << 8)
1763 | (((GLint
) (rgba
[i
][GCOMP
] * 15.0F
)) << 12)
1764 | (((GLint
) (rgba
[i
][RCOMP
] * 15.0F
)) );
1768 case GL_UNSIGNED_SHORT_4_4_4_4_REV
:
1769 if (dstFormat
== GL_RGBA
) {
1770 GLushort
*dst
= (GLushort
*) dstAddr
;
1772 dst
[i
] = (((GLint
) (rgba
[i
][RCOMP
] * 15.0F
)) )
1773 | (((GLint
) (rgba
[i
][GCOMP
] * 15.0F
)) << 4)
1774 | (((GLint
) (rgba
[i
][BCOMP
] * 15.0F
)) << 8)
1775 | (((GLint
) (rgba
[i
][ACOMP
] * 15.0F
)) << 12);
1778 else if (dstFormat
== GL_BGRA
) {
1779 GLushort
*dst
= (GLushort
*) dstAddr
;
1781 dst
[i
] = (((GLint
) (rgba
[i
][BCOMP
] * 15.0F
)) )
1782 | (((GLint
) (rgba
[i
][GCOMP
] * 15.0F
)) << 4)
1783 | (((GLint
) (rgba
[i
][RCOMP
] * 15.0F
)) << 8)
1784 | (((GLint
) (rgba
[i
][ACOMP
] * 15.0F
)) << 12);
1787 else if (dstFormat
== GL_ABGR_EXT
) {
1788 GLushort
*dst
= (GLushort
*) dstAddr
;
1790 dst
[i
] = (((GLint
) (rgba
[i
][ACOMP
] * 15.0F
)) )
1791 | (((GLint
) (rgba
[i
][BCOMP
] * 15.0F
)) << 4)
1792 | (((GLint
) (rgba
[i
][GCOMP
] * 15.0F
)) << 8)
1793 | (((GLint
) (rgba
[i
][RCOMP
] * 15.0F
)) << 12);
1797 case GL_UNSIGNED_SHORT_5_5_5_1
:
1798 if (dstFormat
== GL_RGBA
) {
1799 GLushort
*dst
= (GLushort
*) dstAddr
;
1801 dst
[i
] = (((GLint
) (rgba
[i
][RCOMP
] * 31.0F
)) << 11)
1802 | (((GLint
) (rgba
[i
][GCOMP
] * 31.0F
)) << 6)
1803 | (((GLint
) (rgba
[i
][BCOMP
] * 31.0F
)) << 1)
1804 | (((GLint
) (rgba
[i
][ACOMP
] * 1.0F
)) );
1807 else if (dstFormat
== GL_BGRA
) {
1808 GLushort
*dst
= (GLushort
*) dstAddr
;
1810 dst
[i
] = (((GLint
) (rgba
[i
][BCOMP
] * 31.0F
)) << 11)
1811 | (((GLint
) (rgba
[i
][GCOMP
] * 31.0F
)) << 6)
1812 | (((GLint
) (rgba
[i
][RCOMP
] * 31.0F
)) << 1)
1813 | (((GLint
) (rgba
[i
][ACOMP
] * 1.0F
)) );
1816 else if (dstFormat
== GL_ABGR_EXT
) {
1817 GLushort
*dst
= (GLushort
*) dstAddr
;
1819 dst
[i
] = (((GLint
) (rgba
[i
][ACOMP
] * 31.0F
)) << 11)
1820 | (((GLint
) (rgba
[i
][BCOMP
] * 31.0F
)) << 6)
1821 | (((GLint
) (rgba
[i
][GCOMP
] * 31.0F
)) << 1)
1822 | (((GLint
) (rgba
[i
][RCOMP
] * 1.0F
)) );
1826 case GL_UNSIGNED_SHORT_1_5_5_5_REV
:
1827 if (dstFormat
== GL_RGBA
) {
1828 GLushort
*dst
= (GLushort
*) dstAddr
;
1830 dst
[i
] = (((GLint
) (rgba
[i
][RCOMP
] * 31.0F
)) )
1831 | (((GLint
) (rgba
[i
][GCOMP
] * 31.0F
)) << 5)
1832 | (((GLint
) (rgba
[i
][BCOMP
] * 31.0F
)) << 10)
1833 | (((GLint
) (rgba
[i
][ACOMP
] * 1.0F
)) << 15);
1836 else if (dstFormat
== GL_BGRA
) {
1837 GLushort
*dst
= (GLushort
*) dstAddr
;
1839 dst
[i
] = (((GLint
) (rgba
[i
][BCOMP
] * 31.0F
)) )
1840 | (((GLint
) (rgba
[i
][GCOMP
] * 31.0F
)) << 5)
1841 | (((GLint
) (rgba
[i
][RCOMP
] * 31.0F
)) << 10)
1842 | (((GLint
) (rgba
[i
][ACOMP
] * 1.0F
)) << 15);
1845 else if (dstFormat
== GL_ABGR_EXT
) {
1846 GLushort
*dst
= (GLushort
*) dstAddr
;
1848 dst
[i
] = (((GLint
) (rgba
[i
][ACOMP
] * 31.0F
)) )
1849 | (((GLint
) (rgba
[i
][BCOMP
] * 31.0F
)) << 5)
1850 | (((GLint
) (rgba
[i
][GCOMP
] * 31.0F
)) << 10)
1851 | (((GLint
) (rgba
[i
][RCOMP
] * 1.0F
)) << 15);
1855 case GL_UNSIGNED_INT_8_8_8_8
:
1856 if (dstFormat
== GL_RGBA
) {
1857 GLuint
*dst
= (GLuint
*) dstAddr
;
1859 dst
[i
] = (((GLuint
) (rgba
[i
][RCOMP
] * 255.0F
)) << 24)
1860 | (((GLuint
) (rgba
[i
][GCOMP
] * 255.0F
)) << 16)
1861 | (((GLuint
) (rgba
[i
][BCOMP
] * 255.0F
)) << 8)
1862 | (((GLuint
) (rgba
[i
][ACOMP
] * 255.0F
)) );
1865 else if (dstFormat
== GL_BGRA
) {
1866 GLuint
*dst
= (GLuint
*) dstAddr
;
1868 dst
[i
] = (((GLuint
) (rgba
[i
][BCOMP
] * 255.0F
)) << 24)
1869 | (((GLuint
) (rgba
[i
][GCOMP
] * 255.0F
)) << 16)
1870 | (((GLuint
) (rgba
[i
][RCOMP
] * 255.0F
)) << 8)
1871 | (((GLuint
) (rgba
[i
][ACOMP
] * 255.0F
)) );
1874 else if (dstFormat
== GL_ABGR_EXT
) {
1875 GLuint
*dst
= (GLuint
*) dstAddr
;
1877 dst
[i
] = (((GLuint
) (rgba
[i
][ACOMP
] * 255.0F
)) << 24)
1878 | (((GLuint
) (rgba
[i
][BCOMP
] * 255.0F
)) << 16)
1879 | (((GLuint
) (rgba
[i
][GCOMP
] * 255.0F
)) << 8)
1880 | (((GLuint
) (rgba
[i
][RCOMP
] * 255.0F
)) );
1884 case GL_UNSIGNED_INT_8_8_8_8_REV
:
1885 if (dstFormat
== GL_RGBA
) {
1886 GLuint
*dst
= (GLuint
*) dstAddr
;
1888 dst
[i
] = (((GLuint
) (rgba
[i
][RCOMP
] * 255.0F
)) )
1889 | (((GLuint
) (rgba
[i
][GCOMP
] * 255.0F
)) << 8)
1890 | (((GLuint
) (rgba
[i
][BCOMP
] * 255.0F
)) << 16)
1891 | (((GLuint
) (rgba
[i
][ACOMP
] * 255.0F
)) << 24);
1894 else if (dstFormat
== GL_BGRA
) {
1895 GLuint
*dst
= (GLuint
*) dstAddr
;
1897 dst
[i
] = (((GLuint
) (rgba
[i
][BCOMP
] * 255.0F
)) )
1898 | (((GLuint
) (rgba
[i
][GCOMP
] * 255.0F
)) << 8)
1899 | (((GLuint
) (rgba
[i
][RCOMP
] * 255.0F
)) << 16)
1900 | (((GLuint
) (rgba
[i
][ACOMP
] * 255.0F
)) << 24);
1903 else if (dstFormat
== GL_ABGR_EXT
) {
1904 GLuint
*dst
= (GLuint
*) dstAddr
;
1906 dst
[i
] = (((GLuint
) (rgba
[i
][ACOMP
] * 255.0F
)) )
1907 | (((GLuint
) (rgba
[i
][BCOMP
] * 255.0F
)) << 8)
1908 | (((GLuint
) (rgba
[i
][GCOMP
] * 255.0F
)) << 16)
1909 | (((GLuint
) (rgba
[i
][RCOMP
] * 255.0F
)) << 24);
1913 case GL_UNSIGNED_INT_10_10_10_2
:
1914 if (dstFormat
== GL_RGBA
) {
1915 GLuint
*dst
= (GLuint
*) dstAddr
;
1917 dst
[i
] = (((GLuint
) (rgba
[i
][RCOMP
] * 1023.0F
)) << 22)
1918 | (((GLuint
) (rgba
[i
][GCOMP
] * 1023.0F
)) << 12)
1919 | (((GLuint
) (rgba
[i
][BCOMP
] * 1023.0F
)) << 2)
1920 | (((GLuint
) (rgba
[i
][ACOMP
] * 3.0F
)) );
1923 else if (dstFormat
== GL_BGRA
) {
1924 GLuint
*dst
= (GLuint
*) dstAddr
;
1926 dst
[i
] = (((GLuint
) (rgba
[i
][BCOMP
] * 1023.0F
)) << 22)
1927 | (((GLuint
) (rgba
[i
][GCOMP
] * 1023.0F
)) << 12)
1928 | (((GLuint
) (rgba
[i
][RCOMP
] * 1023.0F
)) << 2)
1929 | (((GLuint
) (rgba
[i
][ACOMP
] * 3.0F
)) );
1932 else if (dstFormat
== GL_ABGR_EXT
) {
1933 GLuint
*dst
= (GLuint
*) dstAddr
;
1935 dst
[i
] = (((GLuint
) (rgba
[i
][ACOMP
] * 1023.0F
)) << 22)
1936 | (((GLuint
) (rgba
[i
][BCOMP
] * 1023.0F
)) << 12)
1937 | (((GLuint
) (rgba
[i
][GCOMP
] * 1023.0F
)) << 2)
1938 | (((GLuint
) (rgba
[i
][RCOMP
] * 3.0F
)) );
1942 case GL_UNSIGNED_INT_2_10_10_10_REV
:
1943 if (dstFormat
== GL_RGBA
) {
1944 GLuint
*dst
= (GLuint
*) dstAddr
;
1946 dst
[i
] = (((GLuint
) (rgba
[i
][RCOMP
] * 1023.0F
)) )
1947 | (((GLuint
) (rgba
[i
][GCOMP
] * 1023.0F
)) << 10)
1948 | (((GLuint
) (rgba
[i
][BCOMP
] * 1023.0F
)) << 20)
1949 | (((GLuint
) (rgba
[i
][ACOMP
] * 3.0F
)) << 30);
1952 else if (dstFormat
== GL_BGRA
) {
1953 GLuint
*dst
= (GLuint
*) dstAddr
;
1955 dst
[i
] = (((GLuint
) (rgba
[i
][BCOMP
] * 1023.0F
)) )
1956 | (((GLuint
) (rgba
[i
][GCOMP
] * 1023.0F
)) << 10)
1957 | (((GLuint
) (rgba
[i
][RCOMP
] * 1023.0F
)) << 20)
1958 | (((GLuint
) (rgba
[i
][ACOMP
] * 3.0F
)) << 30);
1961 else if (dstFormat
== GL_ABGR_EXT
) {
1962 GLuint
*dst
= (GLuint
*) dstAddr
;
1964 dst
[i
] = (((GLuint
) (rgba
[i
][ACOMP
] * 1023.0F
)) )
1965 | (((GLuint
) (rgba
[i
][BCOMP
] * 1023.0F
)) << 10)
1966 | (((GLuint
) (rgba
[i
][GCOMP
] * 1023.0F
)) << 20)
1967 | (((GLuint
) (rgba
[i
][RCOMP
] * 3.0F
)) << 30);
1972 _mesa_problem(ctx
, "bad type in _mesa_pack_rgba_span_float");
1978 * Pack the given RGBA span into client memory at 'dest' address
1979 * in the given pixel format and type.
1980 * Optionally apply the enabled pixel transfer ops.
1981 * Pack into memory using the given packing params struct.
1982 * This is used by glReadPixels and glGetTexImage?D()
1983 * \param ctx - the context
1984 * n - number of pixels in the span
1986 * format - dest packing format
1987 * type - dest packing data type
1988 * destination - destination packing address
1989 * packing - pixel packing parameters
1990 * transferOps - bitmask of IMAGE_*_BIT operations to apply
1993 _mesa_pack_rgba_span_chan( GLcontext
*ctx
,
1994 GLuint n
, CONST GLchan srcRgba
[][4],
1995 GLenum dstFormat
, GLenum dstType
,
1997 const struct gl_pixelstore_attrib
*dstPacking
,
2000 ASSERT((ctx
->NewState
& _NEW_PIXEL
) == 0 || transferOps
== 0);
2002 /* Test for optimized case first */
2003 if (transferOps
== 0 && dstFormat
== GL_RGBA
&& dstType
== CHAN_TYPE
) {
2004 /* common simple case */
2005 MEMCPY(dstAddr
, srcRgba
, n
* 4 * sizeof(GLchan
));
2007 else if (transferOps
== 0 && dstFormat
== GL_RGB
&& dstType
== CHAN_TYPE
) {
2008 /* common simple case */
2010 GLchan
*dest
= (GLchan
*) dstAddr
;
2011 for (i
= 0; i
< n
; i
++) {
2012 dest
[0] = srcRgba
[i
][RCOMP
];
2013 dest
[1] = srcRgba
[i
][GCOMP
];
2014 dest
[2] = srcRgba
[i
][BCOMP
];
2018 else if (transferOps
== 0 && dstFormat
== GL_RGBA
&& dstType
== GL_UNSIGNED_BYTE
) {
2019 /* common simple case */
2021 GLubyte
*dest
= (GLubyte
*) dstAddr
;
2022 for (i
= 0; i
< n
; i
++) {
2023 dest
[0] = CHAN_TO_UBYTE(srcRgba
[i
][RCOMP
]);
2024 dest
[1] = CHAN_TO_UBYTE(srcRgba
[i
][GCOMP
]);
2025 dest
[2] = CHAN_TO_UBYTE(srcRgba
[i
][BCOMP
]);
2026 dest
[3] = CHAN_TO_UBYTE(srcRgba
[i
][ACOMP
]);
2031 /* general solution */
2033 GLfloat rgba
[MAX_WIDTH
][4];
2034 assert(n
<= MAX_WIDTH
);
2035 /* convert color components to floating point */
2036 for (i
= 0; i
< n
; i
++) {
2037 rgba
[i
][RCOMP
] = CHAN_TO_FLOAT(srcRgba
[i
][RCOMP
]);
2038 rgba
[i
][GCOMP
] = CHAN_TO_FLOAT(srcRgba
[i
][GCOMP
]);
2039 rgba
[i
][BCOMP
] = CHAN_TO_FLOAT(srcRgba
[i
][BCOMP
]);
2040 rgba
[i
][ACOMP
] = CHAN_TO_FLOAT(srcRgba
[i
][ACOMP
]);
2042 _mesa_pack_rgba_span_float(ctx
, n
, (const GLfloat (*)[4]) rgba
,
2043 dstFormat
, dstType
, dstAddr
,
2044 dstPacking
, transferOps
);
2049 #define SWAP2BYTE(VALUE) \
2051 GLubyte *bytes = (GLubyte *) &(VALUE); \
2052 GLubyte tmp = bytes[0]; \
2053 bytes[0] = bytes[1]; \
2057 #define SWAP4BYTE(VALUE) \
2059 GLubyte *bytes = (GLubyte *) &(VALUE); \
2060 GLubyte tmp = bytes[0]; \
2061 bytes[0] = bytes[3]; \
2064 bytes[1] = bytes[2]; \
2070 extract_uint_indexes(GLuint n
, GLuint indexes
[],
2071 GLenum srcFormat
, GLenum srcType
, const GLvoid
*src
,
2072 const struct gl_pixelstore_attrib
*unpack
)
2074 assert(srcFormat
== GL_COLOR_INDEX
);
2076 ASSERT(srcType
== GL_BITMAP
||
2077 srcType
== GL_UNSIGNED_BYTE
||
2078 srcType
== GL_BYTE
||
2079 srcType
== GL_UNSIGNED_SHORT
||
2080 srcType
== GL_SHORT
||
2081 srcType
== GL_UNSIGNED_INT
||
2082 srcType
== GL_INT
||
2083 srcType
== GL_UNSIGNED_INT_24_8_EXT
||
2084 srcType
== GL_HALF_FLOAT_ARB
||
2085 srcType
== GL_FLOAT
);
2090 GLubyte
*ubsrc
= (GLubyte
*) src
;
2091 if (unpack
->LsbFirst
) {
2092 GLubyte mask
= 1 << (unpack
->SkipPixels
& 0x7);
2094 for (i
= 0; i
< n
; i
++) {
2095 indexes
[i
] = (*ubsrc
& mask
) ? 1 : 0;
2106 GLubyte mask
= 128 >> (unpack
->SkipPixels
& 0x7);
2108 for (i
= 0; i
< n
; i
++) {
2109 indexes
[i
] = (*ubsrc
& mask
) ? 1 : 0;
2121 case GL_UNSIGNED_BYTE
:
2124 const GLubyte
*s
= (const GLubyte
*) src
;
2125 for (i
= 0; i
< n
; i
++)
2132 const GLbyte
*s
= (const GLbyte
*) src
;
2133 for (i
= 0; i
< n
; i
++)
2137 case GL_UNSIGNED_SHORT
:
2140 const GLushort
*s
= (const GLushort
*) src
;
2141 if (unpack
->SwapBytes
) {
2142 for (i
= 0; i
< n
; i
++) {
2143 GLushort value
= s
[i
];
2149 for (i
= 0; i
< n
; i
++)
2157 const GLshort
*s
= (const GLshort
*) src
;
2158 if (unpack
->SwapBytes
) {
2159 for (i
= 0; i
< n
; i
++) {
2160 GLshort value
= s
[i
];
2166 for (i
= 0; i
< n
; i
++)
2171 case GL_UNSIGNED_INT
:
2174 const GLuint
*s
= (const GLuint
*) src
;
2175 if (unpack
->SwapBytes
) {
2176 for (i
= 0; i
< n
; i
++) {
2177 GLuint value
= s
[i
];
2183 for (i
= 0; i
< n
; i
++)
2191 const GLint
*s
= (const GLint
*) src
;
2192 if (unpack
->SwapBytes
) {
2193 for (i
= 0; i
< n
; i
++) {
2200 for (i
= 0; i
< n
; i
++)
2208 const GLfloat
*s
= (const GLfloat
*) src
;
2209 if (unpack
->SwapBytes
) {
2210 for (i
= 0; i
< n
; i
++) {
2211 GLfloat value
= s
[i
];
2213 indexes
[i
] = (GLuint
) value
;
2217 for (i
= 0; i
< n
; i
++)
2218 indexes
[i
] = (GLuint
) s
[i
];
2222 case GL_HALF_FLOAT_ARB
:
2225 const GLhalfARB
*s
= (const GLhalfARB
*) src
;
2226 if (unpack
->SwapBytes
) {
2227 for (i
= 0; i
< n
; i
++) {
2228 GLhalfARB value
= s
[i
];
2230 indexes
[i
] = (GLuint
) _mesa_half_to_float(value
);
2234 for (i
= 0; i
< n
; i
++)
2235 indexes
[i
] = (GLuint
) _mesa_half_to_float(s
[i
]);
2239 case GL_UNSIGNED_INT_24_8_EXT
:
2242 const GLuint
*s
= (const GLuint
*) src
;
2243 if (unpack
->SwapBytes
) {
2244 for (i
= 0; i
< n
; i
++) {
2245 GLuint value
= s
[i
];
2247 indexes
[i
] = value
& 0xff; /* lower 8 bits */
2251 for (i
= 0; i
< n
; i
++)
2252 indexes
[i
] = s
[i
] & 0xfff; /* lower 8 bits */
2258 _mesa_problem(NULL
, "bad srcType in extract_uint_indexes");
2265 * This function extracts floating point RGBA values from arbitrary
2266 * image data. srcFormat and srcType are the format and type parameters
2267 * passed to glDrawPixels, glTexImage[123]D, glTexSubImage[123]D, etc.
2269 * Refering to section 3.6.4 of the OpenGL 1.2 spec, this function
2270 * implements the "Conversion to floating point", "Conversion to RGB",
2271 * and "Final Expansion to RGBA" operations.
2273 * Args: n - number of pixels
2274 * rgba - output colors
2275 * srcFormat - format of incoming data
2276 * srcType - data type of incoming data
2277 * src - source data pointer
2278 * swapBytes - perform byteswapping of incoming data?
2281 extract_float_rgba(GLuint n
, GLfloat rgba
[][4],
2282 GLenum srcFormat
, GLenum srcType
, const GLvoid
*src
,
2283 GLboolean swapBytes
)
2285 GLint redIndex
, greenIndex
, blueIndex
, alphaIndex
;
2287 GLint rComp
, bComp
, gComp
, aComp
;
2289 ASSERT(srcFormat
== GL_RED
||
2290 srcFormat
== GL_GREEN
||
2291 srcFormat
== GL_BLUE
||
2292 srcFormat
== GL_ALPHA
||
2293 srcFormat
== GL_LUMINANCE
||
2294 srcFormat
== GL_LUMINANCE_ALPHA
||
2295 srcFormat
== GL_INTENSITY
||
2296 srcFormat
== GL_RGB
||
2297 srcFormat
== GL_BGR
||
2298 srcFormat
== GL_RGBA
||
2299 srcFormat
== GL_BGRA
||
2300 srcFormat
== GL_ABGR_EXT
);
2302 ASSERT(srcType
== GL_UNSIGNED_BYTE
||
2303 srcType
== GL_BYTE
||
2304 srcType
== GL_UNSIGNED_SHORT
||
2305 srcType
== GL_SHORT
||
2306 srcType
== GL_UNSIGNED_INT
||
2307 srcType
== GL_INT
||
2308 srcType
== GL_HALF_FLOAT_ARB
||
2309 srcType
== GL_FLOAT
||
2310 srcType
== GL_UNSIGNED_BYTE_3_3_2
||
2311 srcType
== GL_UNSIGNED_BYTE_2_3_3_REV
||
2312 srcType
== GL_UNSIGNED_SHORT_5_6_5
||
2313 srcType
== GL_UNSIGNED_SHORT_5_6_5_REV
||
2314 srcType
== GL_UNSIGNED_SHORT_4_4_4_4
||
2315 srcType
== GL_UNSIGNED_SHORT_4_4_4_4_REV
||
2316 srcType
== GL_UNSIGNED_SHORT_5_5_5_1
||
2317 srcType
== GL_UNSIGNED_SHORT_1_5_5_5_REV
||
2318 srcType
== GL_UNSIGNED_INT_8_8_8_8
||
2319 srcType
== GL_UNSIGNED_INT_8_8_8_8_REV
||
2320 srcType
== GL_UNSIGNED_INT_10_10_10_2
||
2321 srcType
== GL_UNSIGNED_INT_2_10_10_10_REV
);
2323 rComp
= gComp
= bComp
= aComp
= -1;
2325 switch (srcFormat
) {
2328 greenIndex
= blueIndex
= alphaIndex
= -1;
2333 redIndex
= blueIndex
= alphaIndex
= -1;
2338 redIndex
= greenIndex
= alphaIndex
= -1;
2342 redIndex
= greenIndex
= blueIndex
= -1;
2347 redIndex
= greenIndex
= blueIndex
= 0;
2351 case GL_LUMINANCE_ALPHA
:
2352 redIndex
= greenIndex
= blueIndex
= 0;
2357 redIndex
= greenIndex
= blueIndex
= alphaIndex
= 0;
2416 _mesa_problem(NULL
, "bad srcFormat in extract float data");
2421 #define PROCESS(INDEX, CHANNEL, DEFAULT, TYPE, CONVERSION) \
2422 if ((INDEX) < 0) { \
2424 for (i = 0; i < n; i++) { \
2425 rgba[i][CHANNEL] = DEFAULT; \
2428 else if (swapBytes) { \
2429 const TYPE *s = (const TYPE *) src; \
2431 for (i = 0; i < n; i++) { \
2432 TYPE value = s[INDEX]; \
2433 if (sizeof(TYPE) == 2) { \
2436 else if (sizeof(TYPE) == 4) { \
2439 rgba[i][CHANNEL] = (GLfloat) CONVERSION(value); \
2444 const TYPE *s = (const TYPE *) src; \
2446 for (i = 0; i < n; i++) { \
2447 rgba[i][CHANNEL] = (GLfloat) CONVERSION(s[INDEX]); \
2453 case GL_UNSIGNED_BYTE
:
2454 PROCESS(redIndex
, RCOMP
, 0.0F
, GLubyte
, UBYTE_TO_FLOAT
);
2455 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLubyte
, UBYTE_TO_FLOAT
);
2456 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLubyte
, UBYTE_TO_FLOAT
);
2457 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLubyte
, UBYTE_TO_FLOAT
);
2460 PROCESS(redIndex
, RCOMP
, 0.0F
, GLbyte
, BYTE_TO_FLOAT
);
2461 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLbyte
, BYTE_TO_FLOAT
);
2462 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLbyte
, BYTE_TO_FLOAT
);
2463 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLbyte
, BYTE_TO_FLOAT
);
2465 case GL_UNSIGNED_SHORT
:
2466 PROCESS(redIndex
, RCOMP
, 0.0F
, GLushort
, USHORT_TO_FLOAT
);
2467 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLushort
, USHORT_TO_FLOAT
);
2468 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLushort
, USHORT_TO_FLOAT
);
2469 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLushort
, USHORT_TO_FLOAT
);
2472 PROCESS(redIndex
, RCOMP
, 0.0F
, GLshort
, SHORT_TO_FLOAT
);
2473 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLshort
, SHORT_TO_FLOAT
);
2474 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLshort
, SHORT_TO_FLOAT
);
2475 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLshort
, SHORT_TO_FLOAT
);
2477 case GL_UNSIGNED_INT
:
2478 PROCESS(redIndex
, RCOMP
, 0.0F
, GLuint
, UINT_TO_FLOAT
);
2479 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLuint
, UINT_TO_FLOAT
);
2480 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLuint
, UINT_TO_FLOAT
);
2481 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLuint
, UINT_TO_FLOAT
);
2484 PROCESS(redIndex
, RCOMP
, 0.0F
, GLint
, INT_TO_FLOAT
);
2485 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLint
, INT_TO_FLOAT
);
2486 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLint
, INT_TO_FLOAT
);
2487 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLint
, INT_TO_FLOAT
);
2490 PROCESS(redIndex
, RCOMP
, 0.0F
, GLfloat
, (GLfloat
));
2491 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLfloat
, (GLfloat
));
2492 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLfloat
, (GLfloat
));
2493 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLfloat
, (GLfloat
));
2495 case GL_HALF_FLOAT_ARB
:
2496 PROCESS(redIndex
, RCOMP
, 0.0F
, GLhalfARB
, _mesa_half_to_float
);
2497 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLhalfARB
, _mesa_half_to_float
);
2498 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLhalfARB
, _mesa_half_to_float
);
2499 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLhalfARB
, _mesa_half_to_float
);
2501 case GL_UNSIGNED_BYTE_3_3_2
:
2503 const GLubyte
*ubsrc
= (const GLubyte
*) src
;
2505 for (i
= 0; i
< n
; i
++) {
2506 GLubyte p
= ubsrc
[i
];
2507 rgba
[i
][rComp
] = ((p
>> 5) ) * (1.0F
/ 7.0F
);
2508 rgba
[i
][gComp
] = ((p
>> 2) & 0x7) * (1.0F
/ 7.0F
);
2509 rgba
[i
][bComp
] = ((p
) & 0x3) * (1.0F
/ 3.0F
);
2510 rgba
[i
][aComp
] = 1.0F
;
2514 case GL_UNSIGNED_BYTE_2_3_3_REV
:
2516 const GLubyte
*ubsrc
= (const GLubyte
*) src
;
2518 for (i
= 0; i
< n
; i
++) {
2519 GLubyte p
= ubsrc
[i
];
2520 rgba
[i
][rComp
] = ((p
) & 0x7) * (1.0F
/ 7.0F
);
2521 rgba
[i
][gComp
] = ((p
>> 3) & 0x7) * (1.0F
/ 7.0F
);
2522 rgba
[i
][bComp
] = ((p
>> 6) ) * (1.0F
/ 3.0F
);
2523 rgba
[i
][aComp
] = 1.0F
;
2527 case GL_UNSIGNED_SHORT_5_6_5
:
2529 const GLushort
*ussrc
= (const GLushort
*) src
;
2531 for (i
= 0; i
< n
; i
++) {
2532 GLushort p
= ussrc
[i
];
2534 rgba
[i
][rComp
] = ((p
>> 11) ) * (1.0F
/ 31.0F
);
2535 rgba
[i
][gComp
] = ((p
>> 5) & 0x3f) * (1.0F
/ 63.0F
);
2536 rgba
[i
][bComp
] = ((p
) & 0x1f) * (1.0F
/ 31.0F
);
2537 rgba
[i
][aComp
] = 1.0F
;
2541 const GLushort
*ussrc
= (const GLushort
*) src
;
2543 for (i
= 0; i
< n
; i
++) {
2544 GLushort p
= ussrc
[i
];
2545 rgba
[i
][rComp
] = ((p
>> 11) ) * (1.0F
/ 31.0F
);
2546 rgba
[i
][gComp
] = ((p
>> 5) & 0x3f) * (1.0F
/ 63.0F
);
2547 rgba
[i
][bComp
] = ((p
) & 0x1f) * (1.0F
/ 31.0F
);
2548 rgba
[i
][aComp
] = 1.0F
;
2552 case GL_UNSIGNED_SHORT_5_6_5_REV
:
2554 const GLushort
*ussrc
= (const GLushort
*) src
;
2556 for (i
= 0; i
< n
; i
++) {
2557 GLushort p
= ussrc
[i
];
2559 rgba
[i
][rComp
] = ((p
) & 0x1f) * (1.0F
/ 31.0F
);
2560 rgba
[i
][gComp
] = ((p
>> 5) & 0x3f) * (1.0F
/ 63.0F
);
2561 rgba
[i
][bComp
] = ((p
>> 11) ) * (1.0F
/ 31.0F
);
2562 rgba
[i
][aComp
] = 1.0F
;
2566 const GLushort
*ussrc
= (const GLushort
*) src
;
2568 for (i
= 0; i
< n
; i
++) {
2569 GLushort p
= ussrc
[i
];
2570 rgba
[i
][rComp
] = ((p
) & 0x1f) * (1.0F
/ 31.0F
);
2571 rgba
[i
][gComp
] = ((p
>> 5) & 0x3f) * (1.0F
/ 63.0F
);
2572 rgba
[i
][bComp
] = ((p
>> 11) ) * (1.0F
/ 31.0F
);
2573 rgba
[i
][aComp
] = 1.0F
;
2577 case GL_UNSIGNED_SHORT_4_4_4_4
:
2579 const GLushort
*ussrc
= (const GLushort
*) src
;
2581 for (i
= 0; i
< n
; i
++) {
2582 GLushort p
= ussrc
[i
];
2584 rgba
[i
][rComp
] = ((p
>> 12) ) * (1.0F
/ 15.0F
);
2585 rgba
[i
][gComp
] = ((p
>> 8) & 0xf) * (1.0F
/ 15.0F
);
2586 rgba
[i
][bComp
] = ((p
>> 4) & 0xf) * (1.0F
/ 15.0F
);
2587 rgba
[i
][aComp
] = ((p
) & 0xf) * (1.0F
/ 15.0F
);
2591 const GLushort
*ussrc
= (const GLushort
*) src
;
2593 for (i
= 0; i
< n
; i
++) {
2594 GLushort p
= ussrc
[i
];
2595 rgba
[i
][rComp
] = ((p
>> 12) ) * (1.0F
/ 15.0F
);
2596 rgba
[i
][gComp
] = ((p
>> 8) & 0xf) * (1.0F
/ 15.0F
);
2597 rgba
[i
][bComp
] = ((p
>> 4) & 0xf) * (1.0F
/ 15.0F
);
2598 rgba
[i
][aComp
] = ((p
) & 0xf) * (1.0F
/ 15.0F
);
2602 case GL_UNSIGNED_SHORT_4_4_4_4_REV
:
2604 const GLushort
*ussrc
= (const GLushort
*) src
;
2606 for (i
= 0; i
< n
; i
++) {
2607 GLushort p
= ussrc
[i
];
2609 rgba
[i
][rComp
] = ((p
) & 0xf) * (1.0F
/ 15.0F
);
2610 rgba
[i
][gComp
] = ((p
>> 4) & 0xf) * (1.0F
/ 15.0F
);
2611 rgba
[i
][bComp
] = ((p
>> 8) & 0xf) * (1.0F
/ 15.0F
);
2612 rgba
[i
][aComp
] = ((p
>> 12) ) * (1.0F
/ 15.0F
);
2616 const GLushort
*ussrc
= (const GLushort
*) src
;
2618 for (i
= 0; i
< n
; i
++) {
2619 GLushort p
= ussrc
[i
];
2620 rgba
[i
][rComp
] = ((p
) & 0xf) * (1.0F
/ 15.0F
);
2621 rgba
[i
][gComp
] = ((p
>> 4) & 0xf) * (1.0F
/ 15.0F
);
2622 rgba
[i
][bComp
] = ((p
>> 8) & 0xf) * (1.0F
/ 15.0F
);
2623 rgba
[i
][aComp
] = ((p
>> 12) ) * (1.0F
/ 15.0F
);
2627 case GL_UNSIGNED_SHORT_5_5_5_1
:
2629 const GLushort
*ussrc
= (const GLushort
*) src
;
2631 for (i
= 0; i
< n
; i
++) {
2632 GLushort p
= ussrc
[i
];
2634 rgba
[i
][rComp
] = ((p
>> 11) ) * (1.0F
/ 31.0F
);
2635 rgba
[i
][gComp
] = ((p
>> 6) & 0x1f) * (1.0F
/ 31.0F
);
2636 rgba
[i
][bComp
] = ((p
>> 1) & 0x1f) * (1.0F
/ 31.0F
);
2637 rgba
[i
][aComp
] = ((p
) & 0x1) * (1.0F
/ 1.0F
);
2641 const GLushort
*ussrc
= (const GLushort
*) src
;
2643 for (i
= 0; i
< n
; i
++) {
2644 GLushort p
= ussrc
[i
];
2645 rgba
[i
][rComp
] = ((p
>> 11) ) * (1.0F
/ 31.0F
);
2646 rgba
[i
][gComp
] = ((p
>> 6) & 0x1f) * (1.0F
/ 31.0F
);
2647 rgba
[i
][bComp
] = ((p
>> 1) & 0x1f) * (1.0F
/ 31.0F
);
2648 rgba
[i
][aComp
] = ((p
) & 0x1) * (1.0F
/ 1.0F
);
2652 case GL_UNSIGNED_SHORT_1_5_5_5_REV
:
2654 const GLushort
*ussrc
= (const GLushort
*) src
;
2656 for (i
= 0; i
< n
; i
++) {
2657 GLushort p
= ussrc
[i
];
2659 rgba
[i
][rComp
] = ((p
) & 0x1f) * (1.0F
/ 31.0F
);
2660 rgba
[i
][gComp
] = ((p
>> 5) & 0x1f) * (1.0F
/ 31.0F
);
2661 rgba
[i
][bComp
] = ((p
>> 10) & 0x1f) * (1.0F
/ 31.0F
);
2662 rgba
[i
][aComp
] = ((p
>> 15) ) * (1.0F
/ 1.0F
);
2666 const GLushort
*ussrc
= (const GLushort
*) src
;
2668 for (i
= 0; i
< n
; i
++) {
2669 GLushort p
= ussrc
[i
];
2670 rgba
[i
][rComp
] = ((p
) & 0x1f) * (1.0F
/ 31.0F
);
2671 rgba
[i
][gComp
] = ((p
>> 5) & 0x1f) * (1.0F
/ 31.0F
);
2672 rgba
[i
][bComp
] = ((p
>> 10) & 0x1f) * (1.0F
/ 31.0F
);
2673 rgba
[i
][aComp
] = ((p
>> 15) ) * (1.0F
/ 1.0F
);
2677 case GL_UNSIGNED_INT_8_8_8_8
:
2679 const GLuint
*uisrc
= (const GLuint
*) src
;
2681 for (i
= 0; i
< n
; i
++) {
2682 GLuint p
= uisrc
[i
];
2683 rgba
[i
][rComp
] = UBYTE_TO_FLOAT((p
) & 0xff);
2684 rgba
[i
][gComp
] = UBYTE_TO_FLOAT((p
>> 8) & 0xff);
2685 rgba
[i
][bComp
] = UBYTE_TO_FLOAT((p
>> 16) & 0xff);
2686 rgba
[i
][aComp
] = UBYTE_TO_FLOAT((p
>> 24) );
2690 const GLuint
*uisrc
= (const GLuint
*) src
;
2692 for (i
= 0; i
< n
; i
++) {
2693 GLuint p
= uisrc
[i
];
2694 rgba
[i
][rComp
] = UBYTE_TO_FLOAT((p
>> 24) );
2695 rgba
[i
][gComp
] = UBYTE_TO_FLOAT((p
>> 16) & 0xff);
2696 rgba
[i
][bComp
] = UBYTE_TO_FLOAT((p
>> 8) & 0xff);
2697 rgba
[i
][aComp
] = UBYTE_TO_FLOAT((p
) & 0xff);
2701 case GL_UNSIGNED_INT_8_8_8_8_REV
:
2703 const GLuint
*uisrc
= (const GLuint
*) src
;
2705 for (i
= 0; i
< n
; i
++) {
2706 GLuint p
= uisrc
[i
];
2707 rgba
[i
][rComp
] = UBYTE_TO_FLOAT((p
>> 24) );
2708 rgba
[i
][gComp
] = UBYTE_TO_FLOAT((p
>> 16) & 0xff);
2709 rgba
[i
][bComp
] = UBYTE_TO_FLOAT((p
>> 8) & 0xff);
2710 rgba
[i
][aComp
] = UBYTE_TO_FLOAT((p
) & 0xff);
2714 const GLuint
*uisrc
= (const GLuint
*) src
;
2716 for (i
= 0; i
< n
; i
++) {
2717 GLuint p
= uisrc
[i
];
2718 rgba
[i
][rComp
] = UBYTE_TO_FLOAT((p
) & 0xff);
2719 rgba
[i
][gComp
] = UBYTE_TO_FLOAT((p
>> 8) & 0xff);
2720 rgba
[i
][bComp
] = UBYTE_TO_FLOAT((p
>> 16) & 0xff);
2721 rgba
[i
][aComp
] = UBYTE_TO_FLOAT((p
>> 24) );
2725 case GL_UNSIGNED_INT_10_10_10_2
:
2727 const GLuint
*uisrc
= (const GLuint
*) src
;
2729 for (i
= 0; i
< n
; i
++) {
2730 GLuint p
= uisrc
[i
];
2732 rgba
[i
][rComp
] = ((p
>> 22) ) * (1.0F
/ 1023.0F
);
2733 rgba
[i
][gComp
] = ((p
>> 12) & 0x3ff) * (1.0F
/ 1023.0F
);
2734 rgba
[i
][bComp
] = ((p
>> 2) & 0x3ff) * (1.0F
/ 1023.0F
);
2735 rgba
[i
][aComp
] = ((p
) & 0x3 ) * (1.0F
/ 3.0F
);
2739 const GLuint
*uisrc
= (const GLuint
*) src
;
2741 for (i
= 0; i
< n
; i
++) {
2742 GLuint p
= uisrc
[i
];
2743 rgba
[i
][rComp
] = ((p
>> 22) ) * (1.0F
/ 1023.0F
);
2744 rgba
[i
][gComp
] = ((p
>> 12) & 0x3ff) * (1.0F
/ 1023.0F
);
2745 rgba
[i
][bComp
] = ((p
>> 2) & 0x3ff) * (1.0F
/ 1023.0F
);
2746 rgba
[i
][aComp
] = ((p
) & 0x3 ) * (1.0F
/ 3.0F
);
2750 case GL_UNSIGNED_INT_2_10_10_10_REV
:
2752 const GLuint
*uisrc
= (const GLuint
*) src
;
2754 for (i
= 0; i
< n
; i
++) {
2755 GLuint p
= uisrc
[i
];
2757 rgba
[i
][rComp
] = ((p
) & 0x3ff) * (1.0F
/ 1023.0F
);
2758 rgba
[i
][gComp
] = ((p
>> 10) & 0x3ff) * (1.0F
/ 1023.0F
);
2759 rgba
[i
][bComp
] = ((p
>> 20) & 0x3ff) * (1.0F
/ 1023.0F
);
2760 rgba
[i
][aComp
] = ((p
>> 30) ) * (1.0F
/ 3.0F
);
2764 const GLuint
*uisrc
= (const GLuint
*) src
;
2766 for (i
= 0; i
< n
; i
++) {
2767 GLuint p
= uisrc
[i
];
2768 rgba
[i
][rComp
] = ((p
) & 0x3ff) * (1.0F
/ 1023.0F
);
2769 rgba
[i
][gComp
] = ((p
>> 10) & 0x3ff) * (1.0F
/ 1023.0F
);
2770 rgba
[i
][bComp
] = ((p
>> 20) & 0x3ff) * (1.0F
/ 1023.0F
);
2771 rgba
[i
][aComp
] = ((p
>> 30) ) * (1.0F
/ 3.0F
);
2776 _mesa_problem(NULL
, "bad srcType in extract float data");
2783 * Unpack a row of color image data from a client buffer according to
2784 * the pixel unpacking parameters.
2785 * Return GLchan values in the specified dest image format.
2786 * This is used by glDrawPixels and glTexImage?D().
2787 * \param ctx - the context
2788 * n - number of pixels in the span
2789 * dstFormat - format of destination color array
2790 * dest - the destination color array
2791 * srcFormat - source image format
2792 * srcType - source image data type
2793 * source - source image pointer
2794 * srcPacking - pixel unpacking parameters
2795 * transferOps - bitmask of IMAGE_*_BIT values of operations to apply
2797 * XXX perhaps expand this to process whole images someday.
2800 _mesa_unpack_color_span_chan( GLcontext
*ctx
,
2801 GLuint n
, GLenum dstFormat
, GLchan dest
[],
2802 GLenum srcFormat
, GLenum srcType
,
2803 const GLvoid
*source
,
2804 const struct gl_pixelstore_attrib
*srcPacking
,
2805 GLuint transferOps
)
2807 ASSERT(dstFormat
== GL_ALPHA
||
2808 dstFormat
== GL_LUMINANCE
||
2809 dstFormat
== GL_LUMINANCE_ALPHA
||
2810 dstFormat
== GL_INTENSITY
||
2811 dstFormat
== GL_RGB
||
2812 dstFormat
== GL_RGBA
||
2813 dstFormat
== GL_COLOR_INDEX
);
2815 ASSERT(srcFormat
== GL_RED
||
2816 srcFormat
== GL_GREEN
||
2817 srcFormat
== GL_BLUE
||
2818 srcFormat
== GL_ALPHA
||
2819 srcFormat
== GL_LUMINANCE
||
2820 srcFormat
== GL_LUMINANCE_ALPHA
||
2821 srcFormat
== GL_INTENSITY
||
2822 srcFormat
== GL_RGB
||
2823 srcFormat
== GL_BGR
||
2824 srcFormat
== GL_RGBA
||
2825 srcFormat
== GL_BGRA
||
2826 srcFormat
== GL_ABGR_EXT
||
2827 srcFormat
== GL_COLOR_INDEX
);
2829 ASSERT(srcType
== GL_BITMAP
||
2830 srcType
== GL_UNSIGNED_BYTE
||
2831 srcType
== GL_BYTE
||
2832 srcType
== GL_UNSIGNED_SHORT
||
2833 srcType
== GL_SHORT
||
2834 srcType
== GL_UNSIGNED_INT
||
2835 srcType
== GL_INT
||
2836 srcType
== GL_HALF_FLOAT_ARB
||
2837 srcType
== GL_FLOAT
||
2838 srcType
== GL_UNSIGNED_BYTE_3_3_2
||
2839 srcType
== GL_UNSIGNED_BYTE_2_3_3_REV
||
2840 srcType
== GL_UNSIGNED_SHORT_5_6_5
||
2841 srcType
== GL_UNSIGNED_SHORT_5_6_5_REV
||
2842 srcType
== GL_UNSIGNED_SHORT_4_4_4_4
||
2843 srcType
== GL_UNSIGNED_SHORT_4_4_4_4_REV
||
2844 srcType
== GL_UNSIGNED_SHORT_5_5_5_1
||
2845 srcType
== GL_UNSIGNED_SHORT_1_5_5_5_REV
||
2846 srcType
== GL_UNSIGNED_INT_8_8_8_8
||
2847 srcType
== GL_UNSIGNED_INT_8_8_8_8_REV
||
2848 srcType
== GL_UNSIGNED_INT_10_10_10_2
||
2849 srcType
== GL_UNSIGNED_INT_2_10_10_10_REV
);
2851 /* Try simple cases first */
2852 if (transferOps
== 0) {
2853 if (srcType
== CHAN_TYPE
) {
2854 if (dstFormat
== GL_RGBA
) {
2855 if (srcFormat
== GL_RGBA
) {
2856 MEMCPY( dest
, source
, n
* 4 * sizeof(GLchan
) );
2859 else if (srcFormat
== GL_RGB
) {
2861 const GLchan
*src
= (const GLchan
*) source
;
2863 for (i
= 0; i
< n
; i
++) {
2874 else if (dstFormat
== GL_RGB
) {
2875 if (srcFormat
== GL_RGB
) {
2876 MEMCPY( dest
, source
, n
* 3 * sizeof(GLchan
) );
2879 else if (srcFormat
== GL_RGBA
) {
2881 const GLchan
*src
= (const GLchan
*) source
;
2883 for (i
= 0; i
< n
; i
++) {
2893 else if (dstFormat
== srcFormat
) {
2894 GLint comps
= _mesa_components_in_format(srcFormat
);
2896 MEMCPY( dest
, source
, n
* comps
* sizeof(GLchan
) );
2901 * Common situation, loading 8bit RGBA/RGB source images
2902 * into 16/32 bit destination. (OSMesa16/32)
2904 else if (srcType
== GL_UNSIGNED_BYTE
) {
2905 if (dstFormat
== GL_RGBA
) {
2906 if (srcFormat
== GL_RGB
) {
2908 const GLubyte
*src
= (const GLubyte
*) source
;
2910 for (i
= 0; i
< n
; i
++) {
2911 dst
[0] = UBYTE_TO_CHAN(src
[0]);
2912 dst
[1] = UBYTE_TO_CHAN(src
[1]);
2913 dst
[2] = UBYTE_TO_CHAN(src
[2]);
2920 else if (srcFormat
== GL_RGBA
) {
2922 const GLubyte
*src
= (const GLubyte
*) source
;
2924 for (i
= 0; i
< n
; i
++) {
2925 dst
[0] = UBYTE_TO_CHAN(src
[0]);
2926 dst
[1] = UBYTE_TO_CHAN(src
[1]);
2927 dst
[2] = UBYTE_TO_CHAN(src
[2]);
2928 dst
[3] = UBYTE_TO_CHAN(src
[3]);
2935 else if (dstFormat
== GL_RGB
) {
2936 if (srcFormat
== GL_RGB
) {
2938 const GLubyte
*src
= (const GLubyte
*) source
;
2940 for (i
= 0; i
< n
; i
++) {
2941 dst
[0] = UBYTE_TO_CHAN(src
[0]);
2942 dst
[1] = UBYTE_TO_CHAN(src
[1]);
2943 dst
[2] = UBYTE_TO_CHAN(src
[2]);
2949 else if (srcFormat
== GL_RGBA
) {
2951 const GLubyte
*src
= (const GLubyte
*) source
;
2953 for (i
= 0; i
< n
; i
++) {
2954 dst
[0] = UBYTE_TO_CHAN(src
[0]);
2955 dst
[1] = UBYTE_TO_CHAN(src
[1]);
2956 dst
[2] = UBYTE_TO_CHAN(src
[2]);
2967 /* general solution begins here */
2969 GLint dstComponents
;
2970 GLint dstRedIndex
, dstGreenIndex
, dstBlueIndex
, dstAlphaIndex
;
2971 GLint dstLuminanceIndex
, dstIntensityIndex
;
2972 GLfloat rgba
[MAX_WIDTH
][4];
2974 dstComponents
= _mesa_components_in_format( dstFormat
);
2975 /* source & dest image formats should have been error checked by now */
2976 assert(dstComponents
> 0);
2979 * Extract image data and convert to RGBA floats
2981 assert(n
<= MAX_WIDTH
);
2982 if (srcFormat
== GL_COLOR_INDEX
) {
2983 GLuint indexes
[MAX_WIDTH
];
2984 extract_uint_indexes(n
, indexes
, srcFormat
, srcType
, source
,
2987 if (dstFormat
== GL_COLOR_INDEX
2988 && (transferOps
& IMAGE_MAP_COLOR_BIT
)) {
2989 _mesa_map_ci(ctx
, n
, indexes
);
2991 if (transferOps
& IMAGE_SHIFT_OFFSET_BIT
) {
2992 _mesa_shift_and_offset_ci(ctx
, n
, indexes
);
2995 if (dstFormat
== GL_COLOR_INDEX
) {
2996 /* convert to GLchan and return */
2998 for (i
= 0; i
< n
; i
++) {
2999 dest
[i
] = (GLchan
) (indexes
[i
] & 0xff);
3004 /* Convert indexes to RGBA */
3005 _mesa_map_ci_to_rgba(ctx
, n
, indexes
, rgba
);
3008 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
3009 * with color indexes.
3011 transferOps
&= ~(IMAGE_SCALE_BIAS_BIT
| IMAGE_MAP_COLOR_BIT
);
3014 /* non-color index data */
3015 extract_float_rgba(n
, rgba
, srcFormat
, srcType
, source
,
3016 srcPacking
->SwapBytes
);
3019 /* Need to clamp if returning GLubytes or GLushorts */
3020 #if CHAN_TYPE != GL_FLOAT
3021 transferOps
|= IMAGE_CLAMP_BIT
;
3025 _mesa_apply_rgba_transfer_ops(ctx
, transferOps
, n
, rgba
);
3028 /* Now determine which color channels we need to produce.
3029 * And determine the dest index (offset) within each color tuple.
3031 switch (dstFormat
) {
3034 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= -1;
3035 dstLuminanceIndex
= dstIntensityIndex
= -1;
3038 dstLuminanceIndex
= 0;
3039 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= dstAlphaIndex
= -1;
3040 dstIntensityIndex
= -1;
3042 case GL_LUMINANCE_ALPHA
:
3043 dstLuminanceIndex
= 0;
3045 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= -1;
3046 dstIntensityIndex
= -1;
3049 dstIntensityIndex
= 0;
3050 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= dstAlphaIndex
= -1;
3051 dstLuminanceIndex
= -1;
3057 dstAlphaIndex
= dstLuminanceIndex
= dstIntensityIndex
= -1;
3064 dstLuminanceIndex
= dstIntensityIndex
= -1;
3067 _mesa_problem(ctx
, "bad dstFormat in _mesa_unpack_chan_span()");
3072 /* Now return the GLchan data in the requested dstFormat */
3074 if (dstRedIndex
>= 0) {
3077 for (i
= 0; i
< n
; i
++) {
3078 CLAMPED_FLOAT_TO_CHAN(dst
[dstRedIndex
], rgba
[i
][RCOMP
]);
3079 dst
+= dstComponents
;
3083 if (dstGreenIndex
>= 0) {
3086 for (i
= 0; i
< n
; i
++) {
3087 CLAMPED_FLOAT_TO_CHAN(dst
[dstGreenIndex
], rgba
[i
][GCOMP
]);
3088 dst
+= dstComponents
;
3092 if (dstBlueIndex
>= 0) {
3095 for (i
= 0; i
< n
; i
++) {
3096 CLAMPED_FLOAT_TO_CHAN(dst
[dstBlueIndex
], rgba
[i
][BCOMP
]);
3097 dst
+= dstComponents
;
3101 if (dstAlphaIndex
>= 0) {
3104 for (i
= 0; i
< n
; i
++) {
3105 CLAMPED_FLOAT_TO_CHAN(dst
[dstAlphaIndex
], rgba
[i
][ACOMP
]);
3106 dst
+= dstComponents
;
3110 if (dstIntensityIndex
>= 0) {
3113 assert(dstIntensityIndex
== 0);
3114 assert(dstComponents
== 1);
3115 for (i
= 0; i
< n
; i
++) {
3116 /* Intensity comes from red channel */
3117 CLAMPED_FLOAT_TO_CHAN(dst
[i
], rgba
[i
][RCOMP
]);
3121 if (dstLuminanceIndex
>= 0) {
3124 assert(dstLuminanceIndex
== 0);
3125 for (i
= 0; i
< n
; i
++) {
3126 /* Luminance comes from red channel */
3127 CLAMPED_FLOAT_TO_CHAN(dst
[0], rgba
[i
][RCOMP
]);
3128 dst
+= dstComponents
;
3136 * Same as _mesa_unpack_color_span_chan(), but return GLfloat data
3137 * instead of GLchan.
3140 _mesa_unpack_color_span_float( GLcontext
*ctx
,
3141 GLuint n
, GLenum dstFormat
, GLfloat dest
[],
3142 GLenum srcFormat
, GLenum srcType
,
3143 const GLvoid
*source
,
3144 const struct gl_pixelstore_attrib
*srcPacking
,
3145 GLuint transferOps
)
3147 ASSERT(dstFormat
== GL_ALPHA
||
3148 dstFormat
== GL_LUMINANCE
||
3149 dstFormat
== GL_LUMINANCE_ALPHA
||
3150 dstFormat
== GL_INTENSITY
||
3151 dstFormat
== GL_RGB
||
3152 dstFormat
== GL_RGBA
||
3153 dstFormat
== GL_COLOR_INDEX
);
3155 ASSERT(srcFormat
== GL_RED
||
3156 srcFormat
== GL_GREEN
||
3157 srcFormat
== GL_BLUE
||
3158 srcFormat
== GL_ALPHA
||
3159 srcFormat
== GL_LUMINANCE
||
3160 srcFormat
== GL_LUMINANCE_ALPHA
||
3161 srcFormat
== GL_INTENSITY
||
3162 srcFormat
== GL_RGB
||
3163 srcFormat
== GL_BGR
||
3164 srcFormat
== GL_RGBA
||
3165 srcFormat
== GL_BGRA
||
3166 srcFormat
== GL_ABGR_EXT
||
3167 srcFormat
== GL_COLOR_INDEX
);
3169 ASSERT(srcType
== GL_BITMAP
||
3170 srcType
== GL_UNSIGNED_BYTE
||
3171 srcType
== GL_BYTE
||
3172 srcType
== GL_UNSIGNED_SHORT
||
3173 srcType
== GL_SHORT
||
3174 srcType
== GL_UNSIGNED_INT
||
3175 srcType
== GL_INT
||
3176 srcType
== GL_HALF_FLOAT_ARB
||
3177 srcType
== GL_FLOAT
||
3178 srcType
== GL_UNSIGNED_BYTE_3_3_2
||
3179 srcType
== GL_UNSIGNED_BYTE_2_3_3_REV
||
3180 srcType
== GL_UNSIGNED_SHORT_5_6_5
||
3181 srcType
== GL_UNSIGNED_SHORT_5_6_5_REV
||
3182 srcType
== GL_UNSIGNED_SHORT_4_4_4_4
||
3183 srcType
== GL_UNSIGNED_SHORT_4_4_4_4_REV
||
3184 srcType
== GL_UNSIGNED_SHORT_5_5_5_1
||
3185 srcType
== GL_UNSIGNED_SHORT_1_5_5_5_REV
||
3186 srcType
== GL_UNSIGNED_INT_8_8_8_8
||
3187 srcType
== GL_UNSIGNED_INT_8_8_8_8_REV
||
3188 srcType
== GL_UNSIGNED_INT_10_10_10_2
||
3189 srcType
== GL_UNSIGNED_INT_2_10_10_10_REV
);
3191 /* general solution, no special cases, yet */
3193 GLint dstComponents
;
3194 GLint dstRedIndex
, dstGreenIndex
, dstBlueIndex
, dstAlphaIndex
;
3195 GLint dstLuminanceIndex
, dstIntensityIndex
;
3196 GLfloat rgba
[MAX_WIDTH
][4];
3198 dstComponents
= _mesa_components_in_format( dstFormat
);
3199 /* source & dest image formats should have been error checked by now */
3200 assert(dstComponents
> 0);
3203 * Extract image data and convert to RGBA floats
3205 assert(n
<= MAX_WIDTH
);
3206 if (srcFormat
== GL_COLOR_INDEX
) {
3207 GLuint indexes
[MAX_WIDTH
];
3208 extract_uint_indexes(n
, indexes
, srcFormat
, srcType
, source
,
3211 if (dstFormat
== GL_COLOR_INDEX
3212 && (transferOps
& IMAGE_MAP_COLOR_BIT
)) {
3213 _mesa_map_ci(ctx
, n
, indexes
);
3215 if (transferOps
& IMAGE_SHIFT_OFFSET_BIT
) {
3216 _mesa_shift_and_offset_ci(ctx
, n
, indexes
);
3219 if (dstFormat
== GL_COLOR_INDEX
) {
3220 /* convert to GLchan and return */
3222 for (i
= 0; i
< n
; i
++) {
3223 dest
[i
] = (GLchan
) (indexes
[i
] & 0xff);
3228 /* Convert indexes to RGBA */
3229 _mesa_map_ci_to_rgba(ctx
, n
, indexes
, rgba
);
3232 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
3233 * with color indexes.
3235 transferOps
&= ~(IMAGE_SCALE_BIAS_BIT
| IMAGE_MAP_COLOR_BIT
);
3238 /* non-color index data */
3239 extract_float_rgba(n
, rgba
, srcFormat
, srcType
, source
,
3240 srcPacking
->SwapBytes
);
3244 _mesa_apply_rgba_transfer_ops(ctx
, transferOps
, n
, rgba
);
3247 /* Now determine which color channels we need to produce.
3248 * And determine the dest index (offset) within each color tuple.
3250 switch (dstFormat
) {
3253 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= -1;
3254 dstLuminanceIndex
= dstIntensityIndex
= -1;
3257 dstLuminanceIndex
= 0;
3258 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= dstAlphaIndex
= -1;
3259 dstIntensityIndex
= -1;
3261 case GL_LUMINANCE_ALPHA
:
3262 dstLuminanceIndex
= 0;
3264 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= -1;
3265 dstIntensityIndex
= -1;
3268 dstIntensityIndex
= 0;
3269 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= dstAlphaIndex
= -1;
3270 dstLuminanceIndex
= -1;
3276 dstAlphaIndex
= dstLuminanceIndex
= dstIntensityIndex
= -1;
3283 dstLuminanceIndex
= dstIntensityIndex
= -1;
3286 _mesa_problem(ctx
, "bad dstFormat in _mesa_unpack_color_span_float()");
3290 /* Now pack results in the requested dstFormat */
3291 if (dstRedIndex
>= 0) {
3292 GLfloat
*dst
= dest
;
3294 for (i
= 0; i
< n
; i
++) {
3295 dst
[dstRedIndex
] = rgba
[i
][RCOMP
];
3296 dst
+= dstComponents
;
3300 if (dstGreenIndex
>= 0) {
3301 GLfloat
*dst
= dest
;
3303 for (i
= 0; i
< n
; i
++) {
3304 dst
[dstGreenIndex
] = rgba
[i
][GCOMP
];
3305 dst
+= dstComponents
;
3309 if (dstBlueIndex
>= 0) {
3310 GLfloat
*dst
= dest
;
3312 for (i
= 0; i
< n
; i
++) {
3313 dst
[dstBlueIndex
] = rgba
[i
][BCOMP
];
3314 dst
+= dstComponents
;
3318 if (dstAlphaIndex
>= 0) {
3319 GLfloat
*dst
= dest
;
3321 for (i
= 0; i
< n
; i
++) {
3322 dst
[dstAlphaIndex
] = rgba
[i
][ACOMP
];
3323 dst
+= dstComponents
;
3327 if (dstIntensityIndex
>= 0) {
3328 GLfloat
*dst
= dest
;
3330 assert(dstIntensityIndex
== 0);
3331 assert(dstComponents
== 1);
3332 for (i
= 0; i
< n
; i
++) {
3333 /* Intensity comes from red channel */
3334 dst
[i
] = rgba
[i
][RCOMP
];
3338 if (dstLuminanceIndex
>= 0) {
3339 GLfloat
*dst
= dest
;
3341 assert(dstLuminanceIndex
== 0);
3342 for (i
= 0; i
< n
; i
++) {
3343 /* Luminance comes from red channel */
3344 dst
[0] = rgba
[i
][RCOMP
];
3345 dst
+= dstComponents
;
3353 * Unpack a row of color index data from a client buffer according to
3354 * the pixel unpacking parameters.
3355 * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.
3357 * Args: ctx - the context
3358 * n - number of pixels
3359 * dstType - destination data type
3360 * dest - destination array
3361 * srcType - source pixel type
3362 * source - source data pointer
3363 * srcPacking - pixel unpacking parameters
3364 * transferOps - the pixel transfer operations to apply
3367 _mesa_unpack_index_span( const GLcontext
*ctx
, GLuint n
,
3368 GLenum dstType
, GLvoid
*dest
,
3369 GLenum srcType
, const GLvoid
*source
,
3370 const struct gl_pixelstore_attrib
*srcPacking
,
3371 GLuint transferOps
)
3373 ASSERT(srcType
== GL_BITMAP
||
3374 srcType
== GL_UNSIGNED_BYTE
||
3375 srcType
== GL_BYTE
||
3376 srcType
== GL_UNSIGNED_SHORT
||
3377 srcType
== GL_SHORT
||
3378 srcType
== GL_UNSIGNED_INT
||
3379 srcType
== GL_INT
||
3380 srcType
== GL_HALF_FLOAT_ARB
||
3381 srcType
== GL_FLOAT
);
3383 ASSERT(dstType
== GL_UNSIGNED_BYTE
||
3384 dstType
== GL_UNSIGNED_SHORT
||
3385 dstType
== GL_UNSIGNED_INT
);
3388 transferOps
&= (IMAGE_MAP_COLOR_BIT
| IMAGE_SHIFT_OFFSET_BIT
);
3391 * Try simple cases first
3393 if (transferOps
== 0 && srcType
== GL_UNSIGNED_BYTE
3394 && dstType
== GL_UNSIGNED_BYTE
) {
3395 MEMCPY(dest
, source
, n
* sizeof(GLubyte
));
3397 else if (transferOps
== 0 && srcType
== GL_UNSIGNED_INT
3398 && dstType
== GL_UNSIGNED_INT
&& !srcPacking
->SwapBytes
) {
3399 MEMCPY(dest
, source
, n
* sizeof(GLuint
));
3405 GLuint indexes
[MAX_WIDTH
];
3406 assert(n
<= MAX_WIDTH
);
3408 extract_uint_indexes(n
, indexes
, GL_COLOR_INDEX
, srcType
, source
,
3411 if (transferOps
& IMAGE_SHIFT_OFFSET_BIT
) {
3412 /* shift and offset indexes */
3413 _mesa_shift_and_offset_ci(ctx
, n
, indexes
);
3415 if (transferOps
& IMAGE_MAP_COLOR_BIT
) {
3416 /* Apply lookup table */
3417 _mesa_map_ci(ctx
, n
, indexes
);
3420 /* convert to dest type */
3422 case GL_UNSIGNED_BYTE
:
3424 GLubyte
*dst
= (GLubyte
*) dest
;
3426 for (i
= 0; i
< n
; i
++) {
3427 dst
[i
] = (GLubyte
) (indexes
[i
] & 0xff);
3431 case GL_UNSIGNED_SHORT
:
3433 GLuint
*dst
= (GLuint
*) dest
;
3435 for (i
= 0; i
< n
; i
++) {
3436 dst
[i
] = (GLushort
) (indexes
[i
] & 0xffff);
3440 case GL_UNSIGNED_INT
:
3441 MEMCPY(dest
, indexes
, n
* sizeof(GLuint
));
3444 _mesa_problem(ctx
, "bad dstType in _mesa_unpack_index_span");
3451 _mesa_pack_index_span( const GLcontext
*ctx
, GLuint n
,
3452 GLenum dstType
, GLvoid
*dest
, const GLuint
*source
,
3453 const struct gl_pixelstore_attrib
*dstPacking
,
3454 GLuint transferOps
)
3456 GLuint indexes
[MAX_WIDTH
];
3458 ASSERT(n
<= MAX_WIDTH
);
3460 transferOps
&= (IMAGE_MAP_COLOR_BIT
| IMAGE_SHIFT_OFFSET_BIT
);
3462 if (transferOps
& (IMAGE_MAP_COLOR_BIT
| IMAGE_SHIFT_OFFSET_BIT
)) {
3463 /* make a copy of input */
3464 MEMCPY(indexes
, source
, n
* sizeof(GLuint
));
3465 if (transferOps
& IMAGE_SHIFT_OFFSET_BIT
) {
3466 _mesa_shift_and_offset_ci( ctx
, n
, indexes
);
3468 if (transferOps
& IMAGE_MAP_COLOR_BIT
) {
3469 _mesa_map_ci(ctx
, n
, indexes
);
3475 case GL_UNSIGNED_BYTE
:
3477 GLubyte
*dst
= (GLubyte
*) dest
;
3479 for (i
= 0; i
< n
; i
++) {
3480 *dst
++ = (GLubyte
) source
[i
];
3486 GLbyte
*dst
= (GLbyte
*) dest
;
3488 for (i
= 0; i
< n
; i
++) {
3489 dst
[i
] = (GLbyte
) source
[i
];
3493 case GL_UNSIGNED_SHORT
:
3495 GLushort
*dst
= (GLushort
*) dest
;
3497 for (i
= 0; i
< n
; i
++) {
3498 dst
[i
] = (GLushort
) source
[i
];
3500 if (dstPacking
->SwapBytes
) {
3501 _mesa_swap2( (GLushort
*) dst
, n
);
3507 GLshort
*dst
= (GLshort
*) dest
;
3509 for (i
= 0; i
< n
; i
++) {
3510 dst
[i
] = (GLshort
) source
[i
];
3512 if (dstPacking
->SwapBytes
) {
3513 _mesa_swap2( (GLushort
*) dst
, n
);
3517 case GL_UNSIGNED_INT
:
3519 GLuint
*dst
= (GLuint
*) dest
;
3521 for (i
= 0; i
< n
; i
++) {
3522 dst
[i
] = (GLuint
) source
[i
];
3524 if (dstPacking
->SwapBytes
) {
3525 _mesa_swap4( (GLuint
*) dst
, n
);
3531 GLint
*dst
= (GLint
*) dest
;
3533 for (i
= 0; i
< n
; i
++) {
3534 dst
[i
] = (GLint
) source
[i
];
3536 if (dstPacking
->SwapBytes
) {
3537 _mesa_swap4( (GLuint
*) dst
, n
);
3543 GLfloat
*dst
= (GLfloat
*) dest
;
3545 for (i
= 0; i
< n
; i
++) {
3546 dst
[i
] = (GLfloat
) source
[i
];
3548 if (dstPacking
->SwapBytes
) {
3549 _mesa_swap4( (GLuint
*) dst
, n
);
3553 case GL_HALF_FLOAT_ARB
:
3555 GLhalfARB
*dst
= (GLhalfARB
*) dest
;
3557 for (i
= 0; i
< n
; i
++) {
3558 dst
[i
] = _mesa_float_to_half((GLfloat
) source
[i
]);
3560 if (dstPacking
->SwapBytes
) {
3561 _mesa_swap2( (GLushort
*) dst
, n
);
3566 _mesa_problem(ctx
, "bad type in _mesa_pack_index_span");
3572 * Unpack a row of stencil data from a client buffer according to
3573 * the pixel unpacking parameters.
3574 * This is (or will be) used by glDrawPixels
3576 * Args: ctx - the context
3577 * n - number of pixels
3578 * dstType - destination data type
3579 * dest - destination array
3580 * srcType - source pixel type
3581 * source - source data pointer
3582 * srcPacking - pixel unpacking parameters
3583 * transferOps - apply offset/bias/lookup ops?
3586 _mesa_unpack_stencil_span( const GLcontext
*ctx
, GLuint n
,
3587 GLenum dstType
, GLvoid
*dest
,
3588 GLenum srcType
, const GLvoid
*source
,
3589 const struct gl_pixelstore_attrib
*srcPacking
,
3590 GLuint transferOps
)
3592 ASSERT(srcType
== GL_BITMAP
||
3593 srcType
== GL_UNSIGNED_BYTE
||
3594 srcType
== GL_BYTE
||
3595 srcType
== GL_UNSIGNED_SHORT
||
3596 srcType
== GL_SHORT
||
3597 srcType
== GL_UNSIGNED_INT
||
3598 srcType
== GL_INT
||
3599 srcType
== GL_UNSIGNED_INT_24_8_EXT
||
3600 srcType
== GL_HALF_FLOAT_ARB
||
3601 srcType
== GL_FLOAT
);
3603 ASSERT(dstType
== GL_UNSIGNED_BYTE
||
3604 dstType
== GL_UNSIGNED_SHORT
||
3605 dstType
== GL_UNSIGNED_INT
);
3607 /* only shift and offset apply to stencil */
3608 transferOps
&= IMAGE_SHIFT_OFFSET_BIT
;
3611 * Try simple cases first
3613 if (transferOps
== 0 &&
3614 srcType
== GL_UNSIGNED_BYTE
&&
3615 dstType
== GL_UNSIGNED_BYTE
) {
3616 MEMCPY(dest
, source
, n
* sizeof(GLubyte
));
3618 else if (transferOps
== 0 &&
3619 srcType
== GL_UNSIGNED_INT
&&
3620 dstType
== GL_UNSIGNED_INT
&&
3621 !srcPacking
->SwapBytes
) {
3622 MEMCPY(dest
, source
, n
* sizeof(GLuint
));
3628 GLuint indexes
[MAX_WIDTH
];
3629 assert(n
<= MAX_WIDTH
);
3631 extract_uint_indexes(n
, indexes
, GL_COLOR_INDEX
, srcType
, source
,
3635 if (transferOps
& IMAGE_SHIFT_OFFSET_BIT
) {
3636 /* shift and offset indexes */
3637 _mesa_shift_and_offset_ci(ctx
, n
, indexes
);
3640 if (ctx
->Pixel
.MapStencilFlag
) {
3641 /* Apply stencil lookup table */
3642 GLuint mask
= ctx
->Pixel
.MapStoSsize
- 1;
3645 indexes
[i
] = ctx
->Pixel
.MapStoS
[ indexes
[i
] & mask
];
3650 /* convert to dest type */
3652 case GL_UNSIGNED_BYTE
:
3654 GLubyte
*dst
= (GLubyte
*) dest
;
3656 for (i
= 0; i
< n
; i
++) {
3657 dst
[i
] = (GLubyte
) (indexes
[i
] & 0xff);
3661 case GL_UNSIGNED_SHORT
:
3663 GLuint
*dst
= (GLuint
*) dest
;
3665 for (i
= 0; i
< n
; i
++) {
3666 dst
[i
] = (GLushort
) (indexes
[i
] & 0xffff);
3670 case GL_UNSIGNED_INT
:
3671 MEMCPY(dest
, indexes
, n
* sizeof(GLuint
));
3674 _mesa_problem(ctx
, "bad dstType in _mesa_unpack_stencil_span");
3681 _mesa_pack_stencil_span( const GLcontext
*ctx
, GLuint n
,
3682 GLenum dstType
, GLvoid
*dest
, const GLstencil
*source
,
3683 const struct gl_pixelstore_attrib
*dstPacking
)
3685 GLstencil stencil
[MAX_WIDTH
];
3687 ASSERT(n
<= MAX_WIDTH
);
3689 if (ctx
->Pixel
.IndexShift
|| ctx
->Pixel
.IndexOffset
||
3690 ctx
->Pixel
.MapStencilFlag
) {
3691 /* make a copy of input */
3692 MEMCPY(stencil
, source
, n
* sizeof(GLstencil
));
3693 if (ctx
->Pixel
.IndexShift
|| ctx
->Pixel
.IndexOffset
) {
3694 _mesa_shift_and_offset_stencil( ctx
, n
, stencil
);
3696 if (ctx
->Pixel
.MapStencilFlag
) {
3697 _mesa_map_stencil( ctx
, n
, stencil
);
3703 case GL_UNSIGNED_BYTE
:
3704 if (sizeof(GLstencil
) == 8) {
3705 MEMCPY( dest
, source
, n
);
3708 GLubyte
*dst
= (GLubyte
*) dest
;
3711 dst
[i
] = (GLubyte
) source
[i
];
3716 if (sizeof(GLstencil
) == 8) {
3717 MEMCPY( dest
, source
, n
);
3720 GLbyte
*dst
= (GLbyte
*) dest
;
3723 dst
[i
] = (GLbyte
) source
[i
];
3727 case GL_UNSIGNED_SHORT
:
3729 GLushort
*dst
= (GLushort
*) dest
;
3732 dst
[i
] = (GLushort
) source
[i
];
3734 if (dstPacking
->SwapBytes
) {
3735 _mesa_swap2( (GLushort
*) dst
, n
);
3741 GLshort
*dst
= (GLshort
*) dest
;
3744 dst
[i
] = (GLshort
) source
[i
];
3746 if (dstPacking
->SwapBytes
) {
3747 _mesa_swap2( (GLushort
*) dst
, n
);
3751 case GL_UNSIGNED_INT
:
3753 GLuint
*dst
= (GLuint
*) dest
;
3756 dst
[i
] = (GLuint
) source
[i
];
3758 if (dstPacking
->SwapBytes
) {
3759 _mesa_swap4( (GLuint
*) dst
, n
);
3765 GLint
*dst
= (GLint
*) dest
;
3768 *dst
++ = (GLint
) source
[i
];
3770 if (dstPacking
->SwapBytes
) {
3771 _mesa_swap4( (GLuint
*) dst
, n
);
3777 GLfloat
*dst
= (GLfloat
*) dest
;
3780 dst
[i
] = (GLfloat
) source
[i
];
3782 if (dstPacking
->SwapBytes
) {
3783 _mesa_swap4( (GLuint
*) dst
, n
);
3787 case GL_HALF_FLOAT_ARB
:
3789 GLhalfARB
*dst
= (GLhalfARB
*) dest
;
3792 dst
[i
] = _mesa_float_to_half( (float) source
[i
] );
3794 if (dstPacking
->SwapBytes
) {
3795 _mesa_swap2( (GLushort
*) dst
, n
);
3800 if (dstPacking
->LsbFirst
) {
3801 GLubyte
*dst
= (GLubyte
*) dest
;
3804 for (i
= 0; i
< n
; i
++) {
3807 *dst
|= ((source
[i
] != 0) << shift
);
3816 GLubyte
*dst
= (GLubyte
*) dest
;
3819 for (i
= 0; i
< n
; i
++) {
3822 *dst
|= ((source
[i
] != 0) << shift
);
3832 _mesa_problem(ctx
, "bad type in _mesa_pack_index_span");
3838 _mesa_unpack_depth_span( const GLcontext
*ctx
, GLuint n
,
3839 GLenum dstType
, GLvoid
*dest
, GLfloat depthScale
,
3840 GLenum srcType
, const GLvoid
*source
,
3841 const struct gl_pixelstore_attrib
*srcPacking
)
3843 GLfloat depthTemp
[MAX_WIDTH
], *depthValues
;
3845 if (dstType
== GL_FLOAT
) {
3846 depthValues
= (GLfloat
*) dest
;
3849 depthValues
= depthTemp
;
3858 const GLubyte
*src
= (const GLubyte
*) source
;
3859 for (i
= 0; i
< n
; i
++) {
3860 depthValues
[i
] = BYTE_TO_FLOAT(src
[i
]);
3864 case GL_UNSIGNED_BYTE
:
3867 const GLubyte
*src
= (const GLubyte
*) source
;
3868 for (i
= 0; i
< n
; i
++) {
3869 depthValues
[i
] = UBYTE_TO_FLOAT(src
[i
]);
3876 const GLshort
*src
= (const GLshort
*) source
;
3877 for (i
= 0; i
< n
; i
++) {
3878 depthValues
[i
] = SHORT_TO_FLOAT(src
[i
]);
3882 case GL_UNSIGNED_SHORT
:
3885 const GLushort
*src
= (const GLushort
*) source
;
3886 for (i
= 0; i
< n
; i
++) {
3887 depthValues
[i
] = USHORT_TO_FLOAT(src
[i
]);
3894 const GLint
*src
= (const GLint
*) source
;
3895 for (i
= 0; i
< n
; i
++) {
3896 depthValues
[i
] = INT_TO_FLOAT(src
[i
]);
3900 case GL_UNSIGNED_INT
:
3903 const GLuint
*src
= (const GLuint
*) source
;
3904 for (i
= 0; i
< n
; i
++) {
3905 depthValues
[i
] = UINT_TO_FLOAT(src
[i
]);
3909 case GL_UNSIGNED_INT_24_8_EXT
: /* GL_EXT_packed_depth_stencil */
3910 if (dstType
== GL_UNSIGNED_INT
&& ctx
->Pixel
.DepthScale
== 1.0 &&
3911 ctx
->Pixel
.DepthBias
== 0.0 && depthScale
== (GLfloat
) 0xffffff) {
3912 const GLuint
*src
= (const GLuint
*) source
;
3913 GLuint
*zValues
= (GLuint
*) dest
;
3915 for (i
= 0; i
< n
; i
++) {
3916 zValues
[i
] = src
[i
] & 0xffffff00;
3921 const GLuint
*src
= (const GLuint
*) source
;
3922 const GLfloat scale
= 1.0f
/ 0xffffff;
3924 for (i
= 0; i
< n
; i
++) {
3925 depthValues
[i
] = (src
[i
] >> 8) * scale
;
3930 MEMCPY(depthValues
, source
, n
* sizeof(GLfloat
));
3932 case GL_HALF_FLOAT_ARB
:
3935 const GLhalfARB
*src
= (const GLhalfARB
*) source
;
3936 for (i
= 0; i
< n
; i
++) {
3937 depthValues
[i
] = _mesa_half_to_float(src
[i
]);
3942 _mesa_problem(NULL
, "bad type in _mesa_unpack_depth_span()");
3947 /* apply depth scale and bias and clamp to [0,1] */
3948 if (ctx
->Pixel
.DepthScale
!= 1.0 || ctx
->Pixel
.DepthBias
!= 0.0) {
3949 _mesa_scale_and_bias_depth(ctx
, n
, depthValues
);
3952 if (dstType
== GL_UNSIGNED_INT
) {
3953 GLuint
*zValues
= (GLuint
*) dest
;
3955 for (i
= 0; i
< n
; i
++) {
3956 zValues
[i
] = (GLuint
) (depthValues
[i
] * depthScale
);
3959 else if (dstType
== GL_UNSIGNED_SHORT
) {
3960 GLushort
*zValues
= (GLushort
*) dest
;
3962 for (i
= 0; i
< n
; i
++) {
3963 zValues
[i
] = (GLushort
) (depthValues
[i
] * depthScale
);
3967 ASSERT(dstType
== GL_FLOAT
);
3968 ASSERT(depthScale
== 1.0F
);
3974 * Pack an array of depth values. The values are floats in [0,1].
3977 _mesa_pack_depth_span( const GLcontext
*ctx
, GLuint n
, GLvoid
*dest
,
3978 GLenum dstType
, const GLfloat
*depthSpan
,
3979 const struct gl_pixelstore_attrib
*dstPacking
)
3981 GLfloat depthCopy
[MAX_WIDTH
];
3983 ASSERT(n
<= MAX_WIDTH
);
3985 if (ctx
->Pixel
.DepthScale
!= 1.0 || ctx
->Pixel
.DepthBias
!= 0.0) {
3986 _mesa_memcpy(depthCopy
, depthSpan
, n
* sizeof(GLfloat
));
3987 _mesa_scale_and_bias_depth(ctx
, n
, depthCopy
);
3988 depthSpan
= depthCopy
;
3992 case GL_UNSIGNED_BYTE
:
3994 GLubyte
*dst
= (GLubyte
*) dest
;
3996 for (i
= 0; i
< n
; i
++) {
3997 dst
[i
] = FLOAT_TO_UBYTE( depthSpan
[i
] );
4003 GLbyte
*dst
= (GLbyte
*) dest
;
4005 for (i
= 0; i
< n
; i
++) {
4006 dst
[i
] = FLOAT_TO_BYTE( depthSpan
[i
] );
4010 case GL_UNSIGNED_SHORT
:
4012 GLushort
*dst
= (GLushort
*) dest
;
4014 for (i
= 0; i
< n
; i
++) {
4015 CLAMPED_FLOAT_TO_USHORT(dst
[i
], depthSpan
[i
]);
4017 if (dstPacking
->SwapBytes
) {
4018 _mesa_swap2( (GLushort
*) dst
, n
);
4024 GLshort
*dst
= (GLshort
*) dest
;
4026 for (i
= 0; i
< n
; i
++) {
4027 dst
[i
] = FLOAT_TO_SHORT( depthSpan
[i
] );
4029 if (dstPacking
->SwapBytes
) {
4030 _mesa_swap2( (GLushort
*) dst
, n
);
4034 case GL_UNSIGNED_INT
:
4036 GLuint
*dst
= (GLuint
*) dest
;
4038 for (i
= 0; i
< n
; i
++) {
4039 dst
[i
] = FLOAT_TO_UINT( depthSpan
[i
] );
4041 if (dstPacking
->SwapBytes
) {
4042 _mesa_swap4( (GLuint
*) dst
, n
);
4048 GLint
*dst
= (GLint
*) dest
;
4050 for (i
= 0; i
< n
; i
++) {
4051 dst
[i
] = FLOAT_TO_INT( depthSpan
[i
] );
4053 if (dstPacking
->SwapBytes
) {
4054 _mesa_swap4( (GLuint
*) dst
, n
);
4060 GLfloat
*dst
= (GLfloat
*) dest
;
4062 for (i
= 0; i
< n
; i
++) {
4063 dst
[i
] = depthSpan
[i
];
4065 if (dstPacking
->SwapBytes
) {
4066 _mesa_swap4( (GLuint
*) dst
, n
);
4070 case GL_HALF_FLOAT_ARB
:
4072 GLhalfARB
*dst
= (GLhalfARB
*) dest
;
4074 for (i
= 0; i
< n
; i
++) {
4075 dst
[i
] = _mesa_float_to_half(depthSpan
[i
]);
4077 if (dstPacking
->SwapBytes
) {
4078 _mesa_swap2( (GLushort
*) dst
, n
);
4083 _mesa_problem(ctx
, "bad type in _mesa_pack_depth_span");
4090 * Pack depth and stencil values as GL_DEPTH_STENCIL/GL_UNSIGNED_INT_24_8.
4093 _mesa_pack_depth_stencil_span(const GLcontext
*ctx
, GLuint n
, GLuint
*dest
,
4094 const GLfloat
*depthVals
,
4095 const GLstencil
*stencilVals
,
4096 const struct gl_pixelstore_attrib
*dstPacking
)
4098 GLfloat depthCopy
[MAX_WIDTH
];
4099 GLstencil stencilCopy
[MAX_WIDTH
];
4102 ASSERT(n
<= MAX_WIDTH
);
4104 if (ctx
->Pixel
.DepthScale
!= 1.0 || ctx
->Pixel
.DepthBias
!= 0.0) {
4105 _mesa_memcpy(depthCopy
, depthVals
, n
* sizeof(GLfloat
));
4106 _mesa_scale_and_bias_depth(ctx
, n
, depthCopy
);
4107 depthVals
= depthCopy
;
4110 if (ctx
->Pixel
.IndexShift
|| ctx
->Pixel
.IndexOffset
) {
4111 _mesa_memcpy(stencilCopy
, stencilVals
, n
* sizeof(GLstencil
));
4112 _mesa_shift_and_offset_stencil(ctx
, n
, stencilCopy
);
4113 stencilVals
= stencilCopy
;
4115 if (ctx
->Pixel
.MapStencilFlag
) {
4116 if (stencilVals
!= stencilCopy
)
4117 _mesa_memcpy(stencilCopy
, stencilVals
, n
* sizeof(GLstencil
));
4118 _mesa_map_stencil(ctx
, n
, stencilCopy
);
4119 stencilVals
= stencilCopy
;
4122 for (i
= 0; i
< n
; i
++) {
4123 GLuint z
= (GLuint
) (depthVals
[i
] * 0xffffff);
4124 dest
[i
] = (z
<< 8) | (stencilVals
[i
] & 0xff);
4127 if (dstPacking
->SwapBytes
) {
4128 _mesa_swap4(dest
, n
);
4136 * Unpack image data. Apply byte swapping, byte flipping (bitmap).
4137 * Return all image data in a contiguous block. This is used when we
4138 * compile glDrawPixels, glTexImage, etc into a display list. We
4139 * need a copy of the data in a standard format.
4142 _mesa_unpack_image( GLuint dimensions
,
4143 GLsizei width
, GLsizei height
, GLsizei depth
,
4144 GLenum format
, GLenum type
, const GLvoid
*pixels
,
4145 const struct gl_pixelstore_attrib
*unpack
)
4147 GLint bytesPerRow
, compsPerRow
;
4148 GLboolean flipBytes
, swap2
, swap4
;
4151 return NULL
; /* not necessarily an error */
4153 if (width
<= 0 || height
<= 0 || depth
<= 0)
4154 return NULL
; /* generate error later */
4156 if (format
== GL_BITMAP
) {
4157 bytesPerRow
= (width
+ 7) >> 3;
4158 flipBytes
= !unpack
->LsbFirst
;
4159 swap2
= swap4
= GL_FALSE
;
4163 const GLint bytesPerPixel
= _mesa_bytes_per_pixel(format
, type
);
4164 const GLint components
= _mesa_components_in_format(format
);
4166 if (bytesPerPixel
<= 0 || components
<= 0)
4167 return NULL
; /* bad format or type. generate error later */
4168 bytesPerRow
= bytesPerPixel
* width
;
4169 bytesPerComp
= bytesPerPixel
/ components
;
4170 flipBytes
= GL_FALSE
;
4171 swap2
= (bytesPerComp
== 2) && unpack
->SwapBytes
;
4172 swap4
= (bytesPerComp
== 4) && unpack
->SwapBytes
;
4173 compsPerRow
= components
* width
;
4174 assert(compsPerRow
>= width
);
4178 GLubyte
*destBuffer
= (GLubyte
*) MALLOC(bytesPerRow
* height
* depth
);
4182 return NULL
; /* generate GL_OUT_OF_MEMORY later */
4185 for (img
= 0; img
< depth
; img
++) {
4186 for (row
= 0; row
< height
; row
++) {
4187 const GLvoid
*src
= _mesa_image_address(dimensions
, unpack
, pixels
,
4188 width
, height
, format
, type
, img
, row
, 0);
4189 MEMCPY(dst
, src
, bytesPerRow
);
4190 /* byte flipping/swapping */
4192 flip_bytes((GLubyte
*) dst
, bytesPerRow
);
4195 _mesa_swap2((GLushort
*) dst
, compsPerRow
);
4198 _mesa_swap4((GLuint
*) dst
, compsPerRow
);
4211 * Perform clipping for glDrawPixels. The image's window position
4212 * and size, and the unpack SkipPixels and SkipRows are adjusted so
4213 * that the image region is entirely within the window and scissor bounds.
4214 * NOTE: this will only work when glPixelZoom is (1, 1).
4216 * \return GL_TRUE if image is ready for drawing or
4217 * GL_FALSE if image was completely clipped away (draw nothing)
4220 _mesa_clip_drawpixels(const GLcontext
*ctx
,
4221 GLint
*destX
, GLint
*destY
,
4222 GLsizei
*width
, GLsizei
*height
,
4223 struct gl_pixelstore_attrib
*unpack
)
4225 const GLframebuffer
*buffer
= ctx
->DrawBuffer
;
4227 if (unpack
->RowLength
== 0) {
4228 unpack
->RowLength
= *width
;
4231 ASSERT(ctx
->Pixel
.ZoomX
== 1.0F
&& ctx
->Pixel
.ZoomY
== 1.0F
);
4234 if (*destX
< buffer
->_Xmin
) {
4235 unpack
->SkipPixels
+= (buffer
->_Xmin
- *destX
);
4236 *width
-= (buffer
->_Xmin
- *destX
);
4237 *destX
= buffer
->_Xmin
;
4239 /* right clipping */
4240 if (*destX
+ *width
> buffer
->_Xmax
)
4241 *width
-= (*destX
+ *width
- buffer
->_Xmax
);
4246 /* bottom clipping */
4247 if (*destY
< buffer
->_Ymin
) {
4248 unpack
->SkipRows
+= (buffer
->_Ymin
- *destY
);
4249 *height
-= (buffer
->_Ymin
- *destY
);
4250 *destY
= buffer
->_Ymin
;
4253 if (*destY
+ *height
> buffer
->_Ymax
)
4254 *height
-= (*destY
+ *height
- buffer
->_Ymax
);
4264 * Perform clipping for glReadPixels. The image's window position
4265 * and size, and the pack skipPixels, skipRows and rowLength are adjusted
4266 * so that the image region is entirely within the window bounds.
4267 * Note: this is different from _mesa_clip_drawpixels() in that the
4268 * scissor box is ignored, and we use the bounds of the current readbuffer
4271 * \return GL_TRUE if image is ready for drawing or
4272 * GL_FALSE if image was completely clipped away (draw nothing)
4275 _mesa_clip_readpixels(const GLcontext
*ctx
,
4276 GLint
*srcX
, GLint
*srcY
,
4277 GLsizei
*width
, GLsizei
*height
,
4278 struct gl_pixelstore_attrib
*pack
)
4280 const GLframebuffer
*buffer
= ctx
->ReadBuffer
;
4282 if (pack
->RowLength
== 0) {
4283 pack
->RowLength
= *width
;
4288 pack
->SkipPixels
+= (0 - *srcX
);
4289 *width
-= (0 - *srcX
);
4292 /* right clipping */
4293 if (*srcX
+ *width
> (GLsizei
) buffer
->Width
)
4294 *width
-= (*srcX
+ *width
- buffer
->Width
);
4299 /* bottom clipping */
4301 pack
->SkipRows
+= (0 - *srcY
);
4302 *height
-= (0 - *srcY
);
4306 if (*srcY
+ *height
> (GLsizei
) buffer
->Height
)
4307 *height
-= (*srcY
+ *height
- buffer
->Height
);