7 * Mesa 3-D graphics library
10 * Copyright (C) 1999-2003 Brian Paul All Rights Reserved.
12 * Permission is hereby granted, free of charge, to any person obtaining a
13 * copy of this software and associated documentation files (the "Software"),
14 * to deal in the Software without restriction, including without limitation
15 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
16 * and/or sell copies of the Software, and to permit persons to whom the
17 * Software is furnished to do so, subject to the following conditions:
19 * The above copyright notice and this permission notice shall be included
20 * in all copies or substantial portions of the Software.
22 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
23 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
24 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
25 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
26 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
27 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
36 #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 * Image packing parameters for Mesa's internal images.
49 * _mesa_unpack_image() returns image data in this format. When we execute
50 * image commands (glDrawPixels(), glTexImage(), etc) from within display lists
51 * we have to be sure to set the current unpacking parameters to these values!
53 const struct gl_pixelstore_attrib _mesa_native_packing
= {
60 GL_FALSE
, /* SwapBytes */
61 GL_FALSE
, /* LsbFirst */
62 GL_FALSE
, /* ClientStorage */
68 * Flip the 8 bits in each byte of the given array.
71 * \param n number of bytes.
73 * \todo try this trick to flip bytes someday:
75 * v = ((v & 0x55555555) << 1) | ((v >> 1) & 0x55555555);
76 * v = ((v & 0x33333333) << 2) | ((v >> 2) & 0x33333333);
77 * v = ((v & 0x0f0f0f0f) << 4) | ((v >> 4) & 0x0f0f0f0f);
81 flip_bytes( GLubyte
*p
, GLuint n
)
83 register GLuint i
, a
, b
;
86 b
= (GLuint
) p
[i
]; /* words are often faster than bytes */
87 a
= ((b
& 0x01) << 7) |
101 * Flip the order of the 2 bytes in each word in the given array.
104 * \param n number of words.
107 _mesa_swap2( GLushort
*p
, GLuint n
)
112 p
[i
] = (p
[i
] >> 8) | ((p
[i
] << 8) & 0xff00);
119 * Flip the order of the 4 bytes in each word in the given array.
122 _mesa_swap4( GLuint
*p
, GLuint n
)
124 register GLuint i
, a
, b
;
129 | ((b
>> 8) & 0xff00)
130 | ((b
<< 8) & 0xff0000)
131 | ((b
<< 24) & 0xff000000);
138 * Get the size of a GL data type.
140 * \param type GL data type.
142 * \return the size, in bytes, of the given data type, 0 if a GL_BITMAP, or -1
143 * if an invalid type enum.
145 GLint
_mesa_sizeof_type( GLenum type
)
150 case GL_UNSIGNED_BYTE
:
151 return sizeof(GLubyte
);
153 return sizeof(GLbyte
);
154 case GL_UNSIGNED_SHORT
:
155 return sizeof(GLushort
);
157 return sizeof(GLshort
);
158 case GL_UNSIGNED_INT
:
159 return sizeof(GLuint
);
161 return sizeof(GLint
);
163 return sizeof(GLfloat
);
164 case GL_HALF_FLOAT_NV
:
165 return sizeof(GLhalfNV
);
173 * Same as _mesa_sizeof_type() but also accepting the packed pixel
176 GLint
_mesa_sizeof_packed_type( GLenum type
)
181 case GL_UNSIGNED_BYTE
:
182 return sizeof(GLubyte
);
184 return sizeof(GLbyte
);
185 case GL_UNSIGNED_SHORT
:
186 return sizeof(GLushort
);
188 return sizeof(GLshort
);
189 case GL_UNSIGNED_INT
:
190 return sizeof(GLuint
);
192 return sizeof(GLint
);
193 case GL_HALF_FLOAT_NV
:
194 return sizeof(GLhalfNV
);
196 return sizeof(GLfloat
);
197 case GL_UNSIGNED_BYTE_3_3_2
:
198 return sizeof(GLubyte
);
199 case GL_UNSIGNED_BYTE_2_3_3_REV
:
200 return sizeof(GLubyte
);
201 case GL_UNSIGNED_SHORT_5_6_5
:
202 return sizeof(GLushort
);
203 case GL_UNSIGNED_SHORT_5_6_5_REV
:
204 return sizeof(GLushort
);
205 case GL_UNSIGNED_SHORT_4_4_4_4
:
206 return sizeof(GLushort
);
207 case GL_UNSIGNED_SHORT_4_4_4_4_REV
:
208 return sizeof(GLushort
);
209 case GL_UNSIGNED_SHORT_5_5_5_1
:
210 return sizeof(GLushort
);
211 case GL_UNSIGNED_SHORT_1_5_5_5_REV
:
212 return sizeof(GLushort
);
213 case GL_UNSIGNED_INT_8_8_8_8
:
214 return sizeof(GLuint
);
215 case GL_UNSIGNED_INT_8_8_8_8_REV
:
216 return sizeof(GLuint
);
217 case GL_UNSIGNED_INT_10_10_10_2
:
218 return sizeof(GLuint
);
219 case GL_UNSIGNED_INT_2_10_10_10_REV
:
220 return sizeof(GLuint
);
221 case GL_UNSIGNED_SHORT_8_8_MESA
:
222 case GL_UNSIGNED_SHORT_8_8_REV_MESA
:
223 return sizeof(GLushort
);
231 * Get the number of components in a pixel format.
233 * \param format pixel format.
235 * \return the number of components in the given format, or -1 if a bad format.
237 GLint
_mesa_components_in_format( GLenum format
)
241 case GL_COLOR_INDEX1_EXT
:
242 case GL_COLOR_INDEX2_EXT
:
243 case GL_COLOR_INDEX4_EXT
:
244 case GL_COLOR_INDEX8_EXT
:
245 case GL_COLOR_INDEX12_EXT
:
246 case GL_COLOR_INDEX16_EXT
:
247 case GL_STENCIL_INDEX
:
248 case GL_DEPTH_COMPONENT
:
256 case GL_LUMINANCE_ALPHA
:
277 * Get the bytes per pixel of pixel format type pair.
279 * \param format pixel format.
280 * \param type pixel type.
282 * \return bytes per pixel, or -1 if a bad format or type was given.
284 GLint
_mesa_bytes_per_pixel( GLenum format
, GLenum type
)
286 GLint comps
= _mesa_components_in_format( format
);
292 return 0; /* special case */
294 case GL_UNSIGNED_BYTE
:
295 return comps
* sizeof(GLubyte
);
297 case GL_UNSIGNED_SHORT
:
298 return comps
* sizeof(GLshort
);
300 case GL_UNSIGNED_INT
:
301 return comps
* sizeof(GLint
);
303 return comps
* sizeof(GLfloat
);
304 case GL_HALF_FLOAT_NV
:
305 return comps
* sizeof(GLhalfNV
);
306 case GL_UNSIGNED_BYTE_3_3_2
:
307 case GL_UNSIGNED_BYTE_2_3_3_REV
:
308 if (format
== GL_RGB
|| format
== GL_BGR
)
309 return sizeof(GLubyte
);
311 return -1; /* error */
312 case GL_UNSIGNED_SHORT_5_6_5
:
313 case GL_UNSIGNED_SHORT_5_6_5_REV
:
314 if (format
== GL_RGB
|| format
== GL_BGR
)
315 return sizeof(GLushort
);
317 return -1; /* error */
318 case GL_UNSIGNED_SHORT_4_4_4_4
:
319 case GL_UNSIGNED_SHORT_4_4_4_4_REV
:
320 case GL_UNSIGNED_SHORT_5_5_5_1
:
321 case GL_UNSIGNED_SHORT_1_5_5_5_REV
:
322 if (format
== GL_RGBA
|| format
== GL_BGRA
|| format
== GL_ABGR_EXT
)
323 return sizeof(GLushort
);
326 case GL_UNSIGNED_INT_8_8_8_8
:
327 case GL_UNSIGNED_INT_8_8_8_8_REV
:
328 case GL_UNSIGNED_INT_10_10_10_2
:
329 case GL_UNSIGNED_INT_2_10_10_10_REV
:
330 if (format
== GL_RGBA
|| format
== GL_BGRA
|| format
== GL_ABGR_EXT
)
331 return sizeof(GLuint
);
334 case GL_UNSIGNED_SHORT_8_8_MESA
:
335 case GL_UNSIGNED_SHORT_8_8_REV_MESA
:
336 if (format
== GL_YCBCR_MESA
)
337 return sizeof(GLushort
);
347 * Test for a legal pixel format and type.
349 * \param format pixel format.
350 * \param type pixel type.
352 * \return GL_TRUE if the given pixel format and type are legal, or GL_FALSE
356 _mesa_is_legal_format_and_type( GLenum format
, GLenum type
)
360 case GL_STENCIL_INDEX
:
364 case GL_UNSIGNED_BYTE
:
366 case GL_UNSIGNED_SHORT
:
368 case GL_UNSIGNED_INT
:
370 case GL_HALF_FLOAT_NV
:
381 case GL_LUMINANCE_ALPHA
:
382 case GL_DEPTH_COMPONENT
:
385 case GL_UNSIGNED_BYTE
:
387 case GL_UNSIGNED_SHORT
:
389 case GL_UNSIGNED_INT
:
391 case GL_HALF_FLOAT_NV
:
400 case GL_UNSIGNED_BYTE
:
402 case GL_UNSIGNED_SHORT
:
404 case GL_UNSIGNED_INT
:
406 case GL_HALF_FLOAT_NV
:
407 case GL_UNSIGNED_BYTE_3_3_2
:
408 case GL_UNSIGNED_BYTE_2_3_3_REV
:
409 case GL_UNSIGNED_SHORT_5_6_5
:
410 case GL_UNSIGNED_SHORT_5_6_5_REV
:
420 case GL_UNSIGNED_BYTE
:
422 case GL_UNSIGNED_SHORT
:
424 case GL_UNSIGNED_INT
:
426 case GL_HALF_FLOAT_NV
:
427 case GL_UNSIGNED_SHORT_4_4_4_4
:
428 case GL_UNSIGNED_SHORT_4_4_4_4_REV
:
429 case GL_UNSIGNED_SHORT_5_5_5_1
:
430 case GL_UNSIGNED_SHORT_1_5_5_5_REV
:
431 case GL_UNSIGNED_INT_8_8_8_8
:
432 case GL_UNSIGNED_INT_8_8_8_8_REV
:
433 case GL_UNSIGNED_INT_10_10_10_2
:
434 case GL_UNSIGNED_INT_2_10_10_10_REV
:
440 if (type
== GL_UNSIGNED_SHORT_8_8_MESA
||
441 type
== GL_UNSIGNED_SHORT_8_8_REV_MESA
)
453 * Get the address of a pixel in an image (actually a volume).
455 * Pixel unpacking/packing parameters are observed according to \p packing.
457 * \param image start of image data.
458 * \param width image width.
459 * \param height image height.
460 * \param format pixel format.
461 * \param type pixel data type.
462 * \param packing the pixelstore attributes
463 * \param img which image in the volume (0 for 1D or 2D images)
464 * \param row of pixel in the image
465 * \param column of pixel in the image
467 * \return address of pixel on success, or NULL on error.
469 * According to the \p packing information calculates the number of pixel/bytes
470 * per row/image and refers it.
472 * \sa gl_pixelstore_attrib.
475 _mesa_image_address( const struct gl_pixelstore_attrib
*packing
,
476 const GLvoid
*image
, GLsizei width
,
477 GLsizei height
, GLenum format
, GLenum type
,
478 GLint img
, GLint row
, GLint column
)
480 GLint alignment
; /* 1, 2 or 4 */
481 GLint pixels_per_row
;
482 GLint rows_per_image
;
485 GLint skipimages
; /* for 3-D volume images */
488 alignment
= packing
->Alignment
;
489 if (packing
->RowLength
> 0) {
490 pixels_per_row
= packing
->RowLength
;
493 pixels_per_row
= width
;
495 if (packing
->ImageHeight
> 0) {
496 rows_per_image
= packing
->ImageHeight
;
499 rows_per_image
= height
;
501 skiprows
= packing
->SkipRows
;
502 skippixels
= packing
->SkipPixels
;
503 skipimages
= packing
->SkipImages
;
505 if (type
==GL_BITMAP
) {
507 GLint comp_per_pixel
; /* components per pixel */
508 GLint bytes_per_comp
; /* bytes per component */
510 GLint bytes_per_image
;
512 /* Compute bytes per component */
513 bytes_per_comp
= _mesa_sizeof_packed_type( type
);
514 if (bytes_per_comp
<0) {
518 /* Compute number of components per pixel */
519 comp_per_pixel
= _mesa_components_in_format( format
);
520 if (comp_per_pixel
<0 && type
!= GL_BITMAP
) {
524 bytes_per_row
= alignment
525 * CEILING( comp_per_pixel
*pixels_per_row
, 8*alignment
);
527 bytes_per_image
= bytes_per_row
* rows_per_image
;
529 pixel_addr
= (GLubyte
*) image
530 + (skipimages
+ img
) * bytes_per_image
531 + (skiprows
+ row
) * bytes_per_row
532 + (skippixels
+ column
) / 8;
535 /* Non-BITMAP data */
536 GLint bytes_per_pixel
, bytes_per_row
, remainder
, bytes_per_image
;
539 bytes_per_pixel
= _mesa_bytes_per_pixel( format
, type
);
541 /* The pixel type and format should have been error checked earlier */
542 assert(bytes_per_pixel
> 0);
544 bytes_per_row
= pixels_per_row
* bytes_per_pixel
;
545 remainder
= bytes_per_row
% alignment
;
547 bytes_per_row
+= (alignment
- remainder
);
549 ASSERT(bytes_per_row
% alignment
== 0);
551 bytes_per_image
= bytes_per_row
* rows_per_image
;
553 if (packing
->Invert
) {
554 /* set pixel_addr to the last row */
555 topOfImage
= bytes_per_row
* (height
- 1);
556 bytes_per_row
= -bytes_per_row
;
562 /* compute final pixel address */
563 pixel_addr
= (GLubyte
*) image
564 + (skipimages
+ img
) * bytes_per_image
566 + (skiprows
+ row
) * bytes_per_row
567 + (skippixels
+ column
) * bytes_per_pixel
;
570 return (GLvoid
*) pixel_addr
;
575 * Compute the stride between image rows.
577 * \param packing the pixelstore attributes
578 * \param width image width.
579 * \param format pixel format.
580 * \param type pixel data type.
582 * \return the stride in bytes for the given parameters.
584 * Computes the number of bytes per pixel and row and compensates for alignment.
586 * \sa gl_pixelstore_attrib.
589 _mesa_image_row_stride( const struct gl_pixelstore_attrib
*packing
,
590 GLint width
, GLenum format
, GLenum type
)
593 if (type
== GL_BITMAP
) {
596 if (packing
->RowLength
== 0) {
597 bytes
= (width
+ 7) / 8;
600 bytes
= (packing
->RowLength
+ 7) / 8;
602 if (packing
->Invert
) {
603 /* negate the bytes per row (negative row stride) */
609 /* Non-BITMAP data */
610 const GLint bytesPerPixel
= _mesa_bytes_per_pixel(format
, type
);
611 GLint bytesPerRow
, remainder
;
612 if (bytesPerPixel
<= 0)
613 return -1; /* error */
614 if (packing
->RowLength
== 0) {
615 bytesPerRow
= bytesPerPixel
* width
;
618 bytesPerRow
= bytesPerPixel
* packing
->RowLength
;
620 remainder
= bytesPerRow
% packing
->Alignment
;
622 bytesPerRow
+= (packing
->Alignment
- remainder
);
624 bytesPerRow
= -bytesPerRow
;
633 * Compute the stride between images in a 3D texture (in bytes) for the given
634 * pixel packing parameters and image width, format and type.
637 _mesa_image_image_stride( const struct gl_pixelstore_attrib
*packing
,
638 GLint width
, GLint height
,
639 GLenum format
, GLenum type
)
642 ASSERT(type
!= GL_BITMAP
);
645 const GLint bytesPerPixel
= _mesa_bytes_per_pixel(format
, type
);
646 GLint bytesPerRow
, bytesPerImage
, remainder
;
648 if (bytesPerPixel
<= 0)
649 return -1; /* error */
650 if (packing
->RowLength
== 0) {
651 bytesPerRow
= bytesPerPixel
* width
;
654 bytesPerRow
= bytesPerPixel
* packing
->RowLength
;
656 remainder
= bytesPerRow
% packing
->Alignment
;
658 bytesPerRow
+= (packing
->Alignment
- remainder
);
660 if (packing
->ImageHeight
== 0)
661 bytesPerImage
= bytesPerRow
* height
;
663 bytesPerImage
= bytesPerRow
* packing
->ImageHeight
;
665 return bytesPerImage
;
671 * Unpack a 32x32 pixel polygon stipple from user memory using the
672 * current pixel unpack settings.
675 _mesa_unpack_polygon_stipple( const GLubyte
*pattern
, GLuint dest
[32],
676 const struct gl_pixelstore_attrib
*unpacking
)
678 GLubyte
*ptrn
= (GLubyte
*) _mesa_unpack_bitmap( 32, 32, pattern
, unpacking
);
680 /* Convert pattern from GLubytes to GLuints and handle big/little
685 for (i
= 0; i
< 32; i
++) {
686 dest
[i
] = (p
[0] << 24)
698 * Pack polygon stipple into user memory given current pixel packing
702 _mesa_pack_polygon_stipple( const GLuint pattern
[32], GLubyte
*dest
,
703 const struct gl_pixelstore_attrib
*packing
)
705 /* Convert pattern from GLuints to GLubytes to handle big/little
706 * endian differences.
710 for (i
= 0; i
< 32; i
++) {
711 ptrn
[i
* 4 + 0] = (GLubyte
) ((pattern
[i
] >> 24) & 0xff);
712 ptrn
[i
* 4 + 1] = (GLubyte
) ((pattern
[i
] >> 16) & 0xff);
713 ptrn
[i
* 4 + 2] = (GLubyte
) ((pattern
[i
] >> 8 ) & 0xff);
714 ptrn
[i
* 4 + 3] = (GLubyte
) ((pattern
[i
] ) & 0xff);
717 _mesa_pack_bitmap(32, 32, ptrn
, dest
, packing
);
722 * Unpack bitmap data. Resulting data will be in most-significant-bit-first
723 * order with row alignment = 1 byte.
726 _mesa_unpack_bitmap( GLint width
, GLint height
, const GLubyte
*pixels
,
727 const struct gl_pixelstore_attrib
*packing
)
729 GLint bytes
, row
, width_in_bytes
;
730 GLubyte
*buffer
, *dst
;
735 /* Alloc dest storage */
736 bytes
= ((width
+ 7) / 8 * height
);
737 buffer
= (GLubyte
*) MALLOC( bytes
);
742 width_in_bytes
= CEILING( width
, 8 );
744 for (row
= 0; row
< height
; row
++) {
745 const GLubyte
*src
= (const GLubyte
*)
746 _mesa_image_address(packing
, pixels
, width
, height
,
747 GL_COLOR_INDEX
, GL_BITMAP
, 0, row
, 0);
753 if (packing
->SkipPixels
== 0) {
754 MEMCPY( dst
, src
, width_in_bytes
);
755 if (packing
->LsbFirst
) {
756 flip_bytes( dst
, width_in_bytes
);
760 /* handling SkipPixels is a bit tricky (no pun intended!) */
762 if (packing
->LsbFirst
) {
763 GLubyte srcMask
= 1 << (packing
->SkipPixels
& 0x7);
764 GLubyte dstMask
= 128;
765 const GLubyte
*s
= src
;
768 for (i
= 0; i
< width
; i
++) {
772 if (srcMask
== 128) {
777 srcMask
= srcMask
<< 1;
785 dstMask
= dstMask
>> 1;
790 GLubyte srcMask
= 128 >> (packing
->SkipPixels
& 0x7);
791 GLubyte dstMask
= 128;
792 const GLubyte
*s
= src
;
795 for (i
= 0; i
< width
; i
++) {
804 srcMask
= srcMask
>> 1;
812 dstMask
= dstMask
>> 1;
817 dst
+= width_in_bytes
;
828 _mesa_pack_bitmap( GLint width
, GLint height
, const GLubyte
*source
,
829 GLubyte
*dest
, const struct gl_pixelstore_attrib
*packing
)
831 GLint row
, width_in_bytes
;
837 width_in_bytes
= CEILING( width
, 8 );
839 for (row
= 0; row
< height
; row
++) {
840 GLubyte
*dst
= (GLubyte
*) _mesa_image_address( packing
, dest
,
841 width
, height
, GL_COLOR_INDEX
, GL_BITMAP
, 0, row
, 0 );
845 if (packing
->SkipPixels
== 0) {
846 MEMCPY( dst
, src
, width_in_bytes
);
847 if (packing
->LsbFirst
) {
848 flip_bytes( dst
, width_in_bytes
);
852 /* handling SkipPixels is a bit tricky (no pun intended!) */
854 if (packing
->LsbFirst
) {
855 GLubyte srcMask
= 1 << (packing
->SkipPixels
& 0x7);
856 GLubyte dstMask
= 128;
857 const GLubyte
*s
= src
;
860 for (i
= 0; i
< width
; i
++) {
864 if (srcMask
== 128) {
869 srcMask
= srcMask
<< 1;
877 dstMask
= dstMask
>> 1;
882 GLubyte srcMask
= 128 >> (packing
->SkipPixels
& 0x7);
883 GLubyte dstMask
= 128;
884 const GLubyte
*s
= src
;
887 for (i
= 0; i
< width
; i
++) {
896 srcMask
= srcMask
>> 1;
904 dstMask
= dstMask
>> 1;
909 src
+= width_in_bytes
;
915 * Used to pack an array [][4] of RGBA GLchan colors as specified
916 * by the dstFormat, dstType and dstPacking. Used by glReadPixels,
917 * glGetConvolutionFilter(), etc.
920 _mesa_pack_float_rgba_span( GLcontext
*ctx
,
921 GLuint n
, CONST GLfloat rgbaIn
[][4],
922 GLenum dstFormat
, GLenum dstType
,
924 const struct gl_pixelstore_attrib
*dstPacking
,
927 const GLint comps
= _mesa_components_in_format(dstFormat
);
928 GLfloat luminance
[MAX_WIDTH
];
933 /* make copy of incoming data */
934 DEFMARRAY(GLfloat
, rgbaCopy
, MAX_WIDTH
, 4); /* mac 32k limitation */
935 CHECKARRAY(rgbaCopy
, return); /* mac 32k limitation */
937 for (i
= 0; i
< n
; i
++) {
938 rgbaCopy
[i
][0] = rgbaIn
[i
][0];
939 rgbaCopy
[i
][1] = rgbaIn
[i
][1];
940 rgbaCopy
[i
][2] = rgbaIn
[i
][2];
941 rgbaCopy
[i
][3] = rgbaIn
[i
][3];
944 rgba
= (GLfloat (*)[4]) rgbaCopy
;
947 if (transferOps
& IMAGE_SCALE_BIAS_BIT
) {
948 _mesa_scale_and_bias_rgba(ctx
, n
, rgba
,
949 ctx
->Pixel
.RedScale
, ctx
->Pixel
.GreenScale
,
950 ctx
->Pixel
.BlueScale
, ctx
->Pixel
.AlphaScale
,
951 ctx
->Pixel
.RedBias
, ctx
->Pixel
.GreenBias
,
952 ctx
->Pixel
.BlueBias
, ctx
->Pixel
.AlphaBias
);
954 /* color map lookup */
955 if (transferOps
& IMAGE_MAP_COLOR_BIT
) {
956 _mesa_map_rgba( ctx
, n
, rgba
);
958 /* GL_COLOR_TABLE lookup */
959 if (transferOps
& IMAGE_COLOR_TABLE_BIT
) {
960 _mesa_lookup_rgba(&ctx
->ColorTable
, n
, rgba
);
963 if (transferOps
& IMAGE_CONVOLUTION_BIT
) {
964 /* this has to be done in the calling code */
966 /* GL_POST_CONVOLUTION_RED/GREEN/BLUE/ALPHA_SCALE/BIAS */
967 if (transferOps
& IMAGE_POST_CONVOLUTION_SCALE_BIAS
) {
968 _mesa_scale_and_bias_rgba(ctx
, n
, rgba
,
969 ctx
->Pixel
.PostConvolutionScale
[RCOMP
],
970 ctx
->Pixel
.PostConvolutionScale
[GCOMP
],
971 ctx
->Pixel
.PostConvolutionScale
[BCOMP
],
972 ctx
->Pixel
.PostConvolutionScale
[ACOMP
],
973 ctx
->Pixel
.PostConvolutionBias
[RCOMP
],
974 ctx
->Pixel
.PostConvolutionBias
[GCOMP
],
975 ctx
->Pixel
.PostConvolutionBias
[BCOMP
],
976 ctx
->Pixel
.PostConvolutionBias
[ACOMP
]);
978 /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
979 if (transferOps
& IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT
) {
980 _mesa_lookup_rgba(&ctx
->PostConvolutionColorTable
, n
, rgba
);
982 /* color matrix transform */
983 if (transferOps
& IMAGE_COLOR_MATRIX_BIT
) {
984 _mesa_transform_rgba(ctx
, n
, rgba
);
986 /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
987 if (transferOps
& IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT
) {
988 _mesa_lookup_rgba(&ctx
->PostColorMatrixColorTable
, n
, rgba
);
990 /* update histogram count */
991 if (transferOps
& IMAGE_HISTOGRAM_BIT
) {
992 _mesa_update_histogram(ctx
, n
, (CONST
GLfloat (*)[4]) rgba
);
995 if (transferOps
& IMAGE_MIN_MAX_BIT
) {
996 _mesa_update_minmax(ctx
, n
, (CONST
GLfloat (*)[4]) rgba
);
997 if (ctx
->MinMax
.Sink
) {
998 UNDEFARRAY(rgbaCopy
); /* mac 32k limitation */
1002 UNDEFARRAY(rgbaCopy
); /* mac 32k limitation */
1005 /* use incoming data, not a copy */
1006 rgba
= (GLfloat (*)[4]) rgbaIn
;
1009 /* XXX clamp rgba to [0,1]? */
1012 if (dstFormat
== GL_LUMINANCE
|| dstFormat
== GL_LUMINANCE_ALPHA
) {
1013 for (i
= 0; i
< n
; i
++) {
1014 GLfloat sum
= rgba
[i
][RCOMP
] + rgba
[i
][GCOMP
] + rgba
[i
][BCOMP
];
1015 #if CHAN_TYPE == GL_FLOAT
1018 luminance
[i
] = CLAMP(sum
, 0.0F
, 1.0F
);
1024 * Pack/store the pixels. Ugh! Lots of cases!!!
1027 case GL_UNSIGNED_BYTE
:
1029 GLubyte
*dst
= (GLubyte
*) dstAddr
;
1030 switch (dstFormat
) {
1033 dst
[i
] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
1037 dst
[i
] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
1041 dst
[i
] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
1045 dst
[i
] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
1049 dst
[i
] = FLOAT_TO_UBYTE(luminance
[i
]);
1051 case GL_LUMINANCE_ALPHA
:
1053 dst
[i
*2+0] = FLOAT_TO_UBYTE(luminance
[i
]);
1054 dst
[i
*2+1] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
1059 dst
[i
*3+0] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
1060 dst
[i
*3+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
1061 dst
[i
*3+2] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
1066 dst
[i
*4+0] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
1067 dst
[i
*4+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
1068 dst
[i
*4+2] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
1069 dst
[i
*4+3] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
1074 dst
[i
*3+0] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
1075 dst
[i
*3+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
1076 dst
[i
*3+2] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
1081 dst
[i
*4+0] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
1082 dst
[i
*4+1] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
1083 dst
[i
*4+2] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
1084 dst
[i
*4+3] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
1089 dst
[i
*4+0] = FLOAT_TO_UBYTE(rgba
[i
][ACOMP
]);
1090 dst
[i
*4+1] = FLOAT_TO_UBYTE(rgba
[i
][BCOMP
]);
1091 dst
[i
*4+2] = FLOAT_TO_UBYTE(rgba
[i
][GCOMP
]);
1092 dst
[i
*4+3] = FLOAT_TO_UBYTE(rgba
[i
][RCOMP
]);
1096 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1102 GLbyte
*dst
= (GLbyte
*) dstAddr
;
1103 switch (dstFormat
) {
1106 dst
[i
] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
1110 dst
[i
] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
1114 dst
[i
] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
1118 dst
[i
] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
1122 dst
[i
] = FLOAT_TO_BYTE(luminance
[i
]);
1124 case GL_LUMINANCE_ALPHA
:
1126 dst
[i
*2+0] = FLOAT_TO_BYTE(luminance
[i
]);
1127 dst
[i
*2+1] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
1132 dst
[i
*3+0] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
1133 dst
[i
*3+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
1134 dst
[i
*3+2] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
1139 dst
[i
*4+0] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
1140 dst
[i
*4+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
1141 dst
[i
*4+2] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
1142 dst
[i
*4+3] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
1147 dst
[i
*3+0] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
1148 dst
[i
*3+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
1149 dst
[i
*3+2] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
1154 dst
[i
*4+0] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
1155 dst
[i
*4+1] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
1156 dst
[i
*4+2] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
1157 dst
[i
*4+3] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
1161 dst
[i
*4+0] = FLOAT_TO_BYTE(rgba
[i
][ACOMP
]);
1162 dst
[i
*4+1] = FLOAT_TO_BYTE(rgba
[i
][BCOMP
]);
1163 dst
[i
*4+2] = FLOAT_TO_BYTE(rgba
[i
][GCOMP
]);
1164 dst
[i
*4+3] = FLOAT_TO_BYTE(rgba
[i
][RCOMP
]);
1168 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1172 case GL_UNSIGNED_SHORT
:
1174 GLushort
*dst
= (GLushort
*) dstAddr
;
1175 switch (dstFormat
) {
1178 dst
[i
] = FLOAT_TO_USHORT(rgba
[i
][RCOMP
]);
1182 dst
[i
] = FLOAT_TO_USHORT(rgba
[i
][GCOMP
]);
1186 dst
[i
] = FLOAT_TO_USHORT(rgba
[i
][BCOMP
]);
1190 dst
[i
] = FLOAT_TO_USHORT(rgba
[i
][ACOMP
]);
1194 dst
[i
] = FLOAT_TO_USHORT(luminance
[i
]);
1196 case GL_LUMINANCE_ALPHA
:
1198 dst
[i
*2+0] = FLOAT_TO_USHORT(luminance
[i
]);
1199 dst
[i
*2+1] = FLOAT_TO_USHORT(rgba
[i
][ACOMP
]);
1204 dst
[i
*3+0] = FLOAT_TO_USHORT(rgba
[i
][RCOMP
]);
1205 dst
[i
*3+1] = FLOAT_TO_USHORT(rgba
[i
][GCOMP
]);
1206 dst
[i
*3+2] = FLOAT_TO_USHORT(rgba
[i
][BCOMP
]);
1211 dst
[i
*4+0] = FLOAT_TO_USHORT(rgba
[i
][RCOMP
]);
1212 dst
[i
*4+1] = FLOAT_TO_USHORT(rgba
[i
][GCOMP
]);
1213 dst
[i
*4+2] = FLOAT_TO_USHORT(rgba
[i
][BCOMP
]);
1214 dst
[i
*4+3] = FLOAT_TO_USHORT(rgba
[i
][ACOMP
]);
1219 dst
[i
*3+0] = FLOAT_TO_USHORT(rgba
[i
][BCOMP
]);
1220 dst
[i
*3+1] = FLOAT_TO_USHORT(rgba
[i
][GCOMP
]);
1221 dst
[i
*3+2] = FLOAT_TO_USHORT(rgba
[i
][RCOMP
]);
1226 dst
[i
*4+0] = FLOAT_TO_USHORT(rgba
[i
][BCOMP
]);
1227 dst
[i
*4+1] = FLOAT_TO_USHORT(rgba
[i
][GCOMP
]);
1228 dst
[i
*4+2] = FLOAT_TO_USHORT(rgba
[i
][RCOMP
]);
1229 dst
[i
*4+3] = FLOAT_TO_USHORT(rgba
[i
][ACOMP
]);
1234 dst
[i
*4+0] = FLOAT_TO_USHORT(rgba
[i
][ACOMP
]);
1235 dst
[i
*4+1] = FLOAT_TO_USHORT(rgba
[i
][BCOMP
]);
1236 dst
[i
*4+2] = FLOAT_TO_USHORT(rgba
[i
][GCOMP
]);
1237 dst
[i
*4+3] = FLOAT_TO_USHORT(rgba
[i
][RCOMP
]);
1241 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1243 if (dstPacking
->SwapBytes
) {
1244 _mesa_swap2( (GLushort
*) dst
, n
* comps
);
1250 GLshort
*dst
= (GLshort
*) dstAddr
;
1251 switch (dstFormat
) {
1254 dst
[i
] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1258 dst
[i
] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1262 dst
[i
] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1266 dst
[i
] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
1270 dst
[i
] = FLOAT_TO_SHORT(luminance
[i
]);
1272 case GL_LUMINANCE_ALPHA
:
1274 dst
[i
*2+0] = FLOAT_TO_SHORT(luminance
[i
]);
1275 dst
[i
*2+1] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
1280 dst
[i
*3+0] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1281 dst
[i
*3+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1282 dst
[i
*3+2] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1287 dst
[i
*4+0] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1288 dst
[i
*4+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1289 dst
[i
*4+2] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1290 dst
[i
*4+3] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
1295 dst
[i
*3+0] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1296 dst
[i
*3+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1297 dst
[i
*3+2] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1302 dst
[i
*4+0] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1303 dst
[i
*4+1] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1304 dst
[i
*4+2] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1305 dst
[i
*4+3] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
1309 dst
[i
*4+0] = FLOAT_TO_SHORT(rgba
[i
][ACOMP
]);
1310 dst
[i
*4+1] = FLOAT_TO_SHORT(rgba
[i
][BCOMP
]);
1311 dst
[i
*4+2] = FLOAT_TO_SHORT(rgba
[i
][GCOMP
]);
1312 dst
[i
*4+3] = FLOAT_TO_SHORT(rgba
[i
][RCOMP
]);
1316 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1318 if (dstPacking
->SwapBytes
) {
1319 _mesa_swap2( (GLushort
*) dst
, n
* comps
);
1323 case GL_UNSIGNED_INT
:
1325 GLuint
*dst
= (GLuint
*) dstAddr
;
1326 switch (dstFormat
) {
1329 dst
[i
] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1333 dst
[i
] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1337 dst
[i
] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1341 dst
[i
] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
1345 dst
[i
] = FLOAT_TO_UINT(luminance
[i
]);
1347 case GL_LUMINANCE_ALPHA
:
1349 dst
[i
*2+0] = FLOAT_TO_UINT(luminance
[i
]);
1350 dst
[i
*2+1] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
1355 dst
[i
*3+0] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1356 dst
[i
*3+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1357 dst
[i
*3+2] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1362 dst
[i
*4+0] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1363 dst
[i
*4+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1364 dst
[i
*4+2] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1365 dst
[i
*4+3] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
1370 dst
[i
*3+0] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1371 dst
[i
*3+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1372 dst
[i
*3+2] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1377 dst
[i
*4+0] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1378 dst
[i
*4+1] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1379 dst
[i
*4+2] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1380 dst
[i
*4+3] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
1385 dst
[i
*4+0] = FLOAT_TO_UINT(rgba
[i
][ACOMP
]);
1386 dst
[i
*4+1] = FLOAT_TO_UINT(rgba
[i
][BCOMP
]);
1387 dst
[i
*4+2] = FLOAT_TO_UINT(rgba
[i
][GCOMP
]);
1388 dst
[i
*4+3] = FLOAT_TO_UINT(rgba
[i
][RCOMP
]);
1392 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1394 if (dstPacking
->SwapBytes
) {
1395 _mesa_swap4( (GLuint
*) dst
, n
* comps
);
1401 GLint
*dst
= (GLint
*) dstAddr
;
1402 switch (dstFormat
) {
1405 dst
[i
] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1409 dst
[i
] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1413 dst
[i
] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1417 dst
[i
] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
1421 dst
[i
] = FLOAT_TO_INT(luminance
[i
]);
1423 case GL_LUMINANCE_ALPHA
:
1425 dst
[i
*2+0] = FLOAT_TO_INT(luminance
[i
]);
1426 dst
[i
*2+1] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
1431 dst
[i
*3+0] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1432 dst
[i
*3+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1433 dst
[i
*3+2] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1438 dst
[i
*4+0] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1439 dst
[i
*4+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1440 dst
[i
*4+2] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1441 dst
[i
*4+3] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
1446 dst
[i
*3+0] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1447 dst
[i
*3+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1448 dst
[i
*3+2] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1453 dst
[i
*4+0] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1454 dst
[i
*4+1] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1455 dst
[i
*4+2] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1456 dst
[i
*4+3] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
1461 dst
[i
*4+0] = FLOAT_TO_INT(rgba
[i
][ACOMP
]);
1462 dst
[i
*4+1] = FLOAT_TO_INT(rgba
[i
][BCOMP
]);
1463 dst
[i
*4+2] = FLOAT_TO_INT(rgba
[i
][GCOMP
]);
1464 dst
[i
*4+3] = FLOAT_TO_INT(rgba
[i
][RCOMP
]);
1468 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1470 if (dstPacking
->SwapBytes
) {
1471 _mesa_swap4( (GLuint
*) dst
, n
* comps
);
1477 GLfloat
*dst
= (GLfloat
*) dstAddr
;
1478 switch (dstFormat
) {
1481 dst
[i
] = rgba
[i
][RCOMP
];
1485 dst
[i
] = rgba
[i
][GCOMP
];
1489 dst
[i
] = rgba
[i
][BCOMP
];
1493 dst
[i
] = rgba
[i
][ACOMP
];
1497 dst
[i
] = luminance
[i
];
1499 case GL_LUMINANCE_ALPHA
:
1501 dst
[i
*2+0] = luminance
[i
];
1502 dst
[i
*2+1] = rgba
[i
][ACOMP
];
1507 dst
[i
*3+0] = rgba
[i
][RCOMP
];
1508 dst
[i
*3+1] = rgba
[i
][GCOMP
];
1509 dst
[i
*3+2] = rgba
[i
][BCOMP
];
1514 dst
[i
*4+0] = rgba
[i
][RCOMP
];
1515 dst
[i
*4+1] = rgba
[i
][GCOMP
];
1516 dst
[i
*4+2] = rgba
[i
][BCOMP
];
1517 dst
[i
*4+3] = rgba
[i
][ACOMP
];
1522 dst
[i
*3+0] = rgba
[i
][BCOMP
];
1523 dst
[i
*3+1] = rgba
[i
][GCOMP
];
1524 dst
[i
*3+2] = rgba
[i
][RCOMP
];
1529 dst
[i
*4+0] = rgba
[i
][BCOMP
];
1530 dst
[i
*4+1] = rgba
[i
][GCOMP
];
1531 dst
[i
*4+2] = rgba
[i
][RCOMP
];
1532 dst
[i
*4+3] = rgba
[i
][ACOMP
];
1537 dst
[i
*4+0] = rgba
[i
][ACOMP
];
1538 dst
[i
*4+1] = rgba
[i
][BCOMP
];
1539 dst
[i
*4+2] = rgba
[i
][GCOMP
];
1540 dst
[i
*4+3] = rgba
[i
][RCOMP
];
1544 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1546 if (dstPacking
->SwapBytes
) {
1547 _mesa_swap4( (GLuint
*) dst
, n
* comps
);
1551 case GL_HALF_FLOAT_NV
:
1553 GLhalfNV
*dst
= (GLhalfNV
*) dstAddr
;
1554 switch (dstFormat
) {
1557 dst
[i
] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1561 dst
[i
] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1565 dst
[i
] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1569 dst
[i
] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
1573 dst
[i
] = _mesa_float_to_half(luminance
[i
]);
1575 case GL_LUMINANCE_ALPHA
:
1577 dst
[i
*2+0] = _mesa_float_to_half(luminance
[i
]);
1578 dst
[i
*2+1] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
1583 dst
[i
*3+0] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1584 dst
[i
*3+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1585 dst
[i
*3+2] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1590 dst
[i
*4+0] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1591 dst
[i
*4+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1592 dst
[i
*4+2] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1593 dst
[i
*4+3] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
1598 dst
[i
*3+0] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1599 dst
[i
*3+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1600 dst
[i
*3+2] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1605 dst
[i
*4+0] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1606 dst
[i
*4+1] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1607 dst
[i
*4+2] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1608 dst
[i
*4+3] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
1613 dst
[i
*4+0] = _mesa_float_to_half(rgba
[i
][ACOMP
]);
1614 dst
[i
*4+1] = _mesa_float_to_half(rgba
[i
][BCOMP
]);
1615 dst
[i
*4+2] = _mesa_float_to_half(rgba
[i
][GCOMP
]);
1616 dst
[i
*4+3] = _mesa_float_to_half(rgba
[i
][RCOMP
]);
1620 _mesa_problem(ctx
, "bad format in _mesa_pack_rgba_span\n");
1622 if (dstPacking
->SwapBytes
) {
1623 _mesa_swap2( (GLushort
*) dst
, n
* comps
);
1627 case GL_UNSIGNED_BYTE_3_3_2
:
1628 if (dstFormat
== GL_RGB
) {
1629 GLubyte
*dst
= (GLubyte
*) dstAddr
;
1631 dst
[i
] = (((GLint
) (rgba
[i
][RCOMP
] * 7.0F
)) << 5)
1632 | (((GLint
) (rgba
[i
][GCOMP
] * 7.0F
)) << 2)
1633 | (((GLint
) (rgba
[i
][BCOMP
] * 3.0F
)) );
1637 case GL_UNSIGNED_BYTE_2_3_3_REV
:
1638 if (dstFormat
== GL_RGB
) {
1639 GLubyte
*dst
= (GLubyte
*) dstAddr
;
1641 dst
[i
] = (((GLint
) (rgba
[i
][RCOMP
] * 7.0F
)) )
1642 | (((GLint
) (rgba
[i
][GCOMP
] * 7.0F
)) << 3)
1643 | (((GLint
) (rgba
[i
][BCOMP
] * 3.0F
)) << 5);
1647 case GL_UNSIGNED_SHORT_5_6_5
:
1648 if (dstFormat
== GL_RGB
) {
1649 GLushort
*dst
= (GLushort
*) dstAddr
;
1651 dst
[i
] = (((GLint
) (rgba
[i
][RCOMP
] * 31.0F
)) << 11)
1652 | (((GLint
) (rgba
[i
][GCOMP
] * 63.0F
)) << 5)
1653 | (((GLint
) (rgba
[i
][BCOMP
] * 31.0F
)) );
1657 case GL_UNSIGNED_SHORT_5_6_5_REV
:
1658 if (dstFormat
== GL_RGB
) {
1659 GLushort
*dst
= (GLushort
*) dstAddr
;
1661 dst
[i
] = (((GLint
) (rgba
[i
][RCOMP
] * 31.0F
)) )
1662 | (((GLint
) (rgba
[i
][GCOMP
] * 63.0F
)) << 5)
1663 | (((GLint
) (rgba
[i
][BCOMP
] * 31.0F
)) << 11);
1667 case GL_UNSIGNED_SHORT_4_4_4_4
:
1668 if (dstFormat
== GL_RGBA
) {
1669 GLushort
*dst
= (GLushort
*) dstAddr
;
1671 dst
[i
] = (((GLint
) (rgba
[i
][RCOMP
] * 15.0F
)) << 12)
1672 | (((GLint
) (rgba
[i
][GCOMP
] * 15.0F
)) << 8)
1673 | (((GLint
) (rgba
[i
][BCOMP
] * 15.0F
)) << 4)
1674 | (((GLint
) (rgba
[i
][ACOMP
] * 15.0F
)) );
1677 else if (dstFormat
== GL_BGRA
) {
1678 GLushort
*dst
= (GLushort
*) dstAddr
;
1680 dst
[i
] = (((GLint
) (rgba
[i
][BCOMP
] * 15.0F
)) << 12)
1681 | (((GLint
) (rgba
[i
][GCOMP
] * 15.0F
)) << 8)
1682 | (((GLint
) (rgba
[i
][RCOMP
] * 15.0F
)) << 4)
1683 | (((GLint
) (rgba
[i
][ACOMP
] * 15.0F
)) );
1686 else if (dstFormat
== GL_ABGR_EXT
) {
1687 GLushort
*dst
= (GLushort
*) dstAddr
;
1689 dst
[i
] = (((GLint
) (rgba
[i
][ACOMP
] * 15.0F
)) << 4)
1690 | (((GLint
) (rgba
[i
][BCOMP
] * 15.0F
)) << 8)
1691 | (((GLint
) (rgba
[i
][GCOMP
] * 15.0F
)) << 12)
1692 | (((GLint
) (rgba
[i
][RCOMP
] * 15.0F
)) );
1696 case GL_UNSIGNED_SHORT_4_4_4_4_REV
:
1697 if (dstFormat
== GL_RGBA
) {
1698 GLushort
*dst
= (GLushort
*) dstAddr
;
1700 dst
[i
] = (((GLint
) (rgba
[i
][RCOMP
] * 15.0F
)) )
1701 | (((GLint
) (rgba
[i
][GCOMP
] * 15.0F
)) << 4)
1702 | (((GLint
) (rgba
[i
][BCOMP
] * 15.0F
)) << 8)
1703 | (((GLint
) (rgba
[i
][ACOMP
] * 15.0F
)) << 12);
1706 else if (dstFormat
== GL_BGRA
) {
1707 GLushort
*dst
= (GLushort
*) dstAddr
;
1709 dst
[i
] = (((GLint
) (rgba
[i
][BCOMP
] * 15.0F
)) )
1710 | (((GLint
) (rgba
[i
][GCOMP
] * 15.0F
)) << 4)
1711 | (((GLint
) (rgba
[i
][RCOMP
] * 15.0F
)) << 8)
1712 | (((GLint
) (rgba
[i
][ACOMP
] * 15.0F
)) << 12);
1715 else if (dstFormat
== GL_ABGR_EXT
) {
1716 GLushort
*dst
= (GLushort
*) dstAddr
;
1718 dst
[i
] = (((GLint
) (rgba
[i
][ACOMP
] * 15.0F
)) )
1719 | (((GLint
) (rgba
[i
][BCOMP
] * 15.0F
)) << 4)
1720 | (((GLint
) (rgba
[i
][GCOMP
] * 15.0F
)) << 8)
1721 | (((GLint
) (rgba
[i
][RCOMP
] * 15.0F
)) << 12);
1725 case GL_UNSIGNED_SHORT_5_5_5_1
:
1726 if (dstFormat
== GL_RGBA
) {
1727 GLushort
*dst
= (GLushort
*) dstAddr
;
1729 dst
[i
] = (((GLint
) (rgba
[i
][RCOMP
] * 31.0F
)) << 11)
1730 | (((GLint
) (rgba
[i
][GCOMP
] * 31.0F
)) << 6)
1731 | (((GLint
) (rgba
[i
][BCOMP
] * 31.0F
)) << 1)
1732 | (((GLint
) (rgba
[i
][ACOMP
] * 1.0F
)) );
1735 else if (dstFormat
== GL_BGRA
) {
1736 GLushort
*dst
= (GLushort
*) dstAddr
;
1738 dst
[i
] = (((GLint
) (rgba
[i
][BCOMP
] * 31.0F
)) << 11)
1739 | (((GLint
) (rgba
[i
][GCOMP
] * 31.0F
)) << 6)
1740 | (((GLint
) (rgba
[i
][RCOMP
] * 31.0F
)) << 1)
1741 | (((GLint
) (rgba
[i
][ACOMP
] * 1.0F
)) );
1744 else if (dstFormat
== GL_ABGR_EXT
) {
1745 GLushort
*dst
= (GLushort
*) dstAddr
;
1747 dst
[i
] = (((GLint
) (rgba
[i
][ACOMP
] * 31.0F
)) << 11)
1748 | (((GLint
) (rgba
[i
][BCOMP
] * 31.0F
)) << 6)
1749 | (((GLint
) (rgba
[i
][GCOMP
] * 31.0F
)) << 1)
1750 | (((GLint
) (rgba
[i
][RCOMP
] * 1.0F
)) );
1754 case GL_UNSIGNED_SHORT_1_5_5_5_REV
:
1755 if (dstFormat
== GL_RGBA
) {
1756 GLushort
*dst
= (GLushort
*) dstAddr
;
1758 dst
[i
] = (((GLint
) (rgba
[i
][RCOMP
] * 31.0F
)) )
1759 | (((GLint
) (rgba
[i
][GCOMP
] * 31.0F
)) << 5)
1760 | (((GLint
) (rgba
[i
][BCOMP
] * 31.0F
)) << 10)
1761 | (((GLint
) (rgba
[i
][ACOMP
] * 1.0F
)) << 15);
1764 else if (dstFormat
== GL_BGRA
) {
1765 GLushort
*dst
= (GLushort
*) dstAddr
;
1767 dst
[i
] = (((GLint
) (rgba
[i
][BCOMP
] * 31.0F
)) )
1768 | (((GLint
) (rgba
[i
][GCOMP
] * 31.0F
)) << 5)
1769 | (((GLint
) (rgba
[i
][RCOMP
] * 31.0F
)) << 10)
1770 | (((GLint
) (rgba
[i
][ACOMP
] * 1.0F
)) << 15);
1773 else if (dstFormat
== GL_ABGR_EXT
) {
1774 GLushort
*dst
= (GLushort
*) dstAddr
;
1776 dst
[i
] = (((GLint
) (rgba
[i
][ACOMP
] * 31.0F
)) )
1777 | (((GLint
) (rgba
[i
][BCOMP
] * 31.0F
)) << 5)
1778 | (((GLint
) (rgba
[i
][GCOMP
] * 31.0F
)) << 10)
1779 | (((GLint
) (rgba
[i
][RCOMP
] * 1.0F
)) << 15);
1783 case GL_UNSIGNED_INT_8_8_8_8
:
1784 if (dstFormat
== GL_RGBA
) {
1785 GLuint
*dst
= (GLuint
*) dstAddr
;
1787 dst
[i
] = (((GLuint
) (rgba
[i
][RCOMP
] * 255.0F
)) << 24)
1788 | (((GLuint
) (rgba
[i
][GCOMP
] * 255.0F
)) << 16)
1789 | (((GLuint
) (rgba
[i
][BCOMP
] * 255.0F
)) << 8)
1790 | (((GLuint
) (rgba
[i
][ACOMP
] * 255.0F
)) );
1793 else if (dstFormat
== GL_BGRA
) {
1794 GLuint
*dst
= (GLuint
*) dstAddr
;
1796 dst
[i
] = (((GLuint
) (rgba
[i
][BCOMP
] * 255.0F
)) << 24)
1797 | (((GLuint
) (rgba
[i
][GCOMP
] * 255.0F
)) << 16)
1798 | (((GLuint
) (rgba
[i
][RCOMP
] * 255.0F
)) << 8)
1799 | (((GLuint
) (rgba
[i
][ACOMP
] * 255.0F
)) );
1802 else if (dstFormat
== GL_ABGR_EXT
) {
1803 GLuint
*dst
= (GLuint
*) dstAddr
;
1805 dst
[i
] = (((GLuint
) (rgba
[i
][ACOMP
] * 255.0F
)) << 24)
1806 | (((GLuint
) (rgba
[i
][BCOMP
] * 255.0F
)) << 16)
1807 | (((GLuint
) (rgba
[i
][GCOMP
] * 255.0F
)) << 8)
1808 | (((GLuint
) (rgba
[i
][RCOMP
] * 255.0F
)) );
1812 case GL_UNSIGNED_INT_8_8_8_8_REV
:
1813 if (dstFormat
== GL_RGBA
) {
1814 GLuint
*dst
= (GLuint
*) dstAddr
;
1816 dst
[i
] = (((GLuint
) (rgba
[i
][RCOMP
] * 255.0F
)) )
1817 | (((GLuint
) (rgba
[i
][GCOMP
] * 255.0F
)) << 8)
1818 | (((GLuint
) (rgba
[i
][BCOMP
] * 255.0F
)) << 16)
1819 | (((GLuint
) (rgba
[i
][ACOMP
] * 255.0F
)) << 24);
1822 else if (dstFormat
== GL_BGRA
) {
1823 GLuint
*dst
= (GLuint
*) dstAddr
;
1825 dst
[i
] = (((GLuint
) (rgba
[i
][BCOMP
] * 255.0F
)) )
1826 | (((GLuint
) (rgba
[i
][GCOMP
] * 255.0F
)) << 8)
1827 | (((GLuint
) (rgba
[i
][RCOMP
] * 255.0F
)) << 16)
1828 | (((GLuint
) (rgba
[i
][ACOMP
] * 255.0F
)) << 24);
1831 else if (dstFormat
== GL_ABGR_EXT
) {
1832 GLuint
*dst
= (GLuint
*) dstAddr
;
1834 dst
[i
] = (((GLuint
) (rgba
[i
][ACOMP
] * 255.0F
)) )
1835 | (((GLuint
) (rgba
[i
][BCOMP
] * 255.0F
)) << 8)
1836 | (((GLuint
) (rgba
[i
][GCOMP
] * 255.0F
)) << 16)
1837 | (((GLuint
) (rgba
[i
][RCOMP
] * 255.0F
)) << 24);
1841 case GL_UNSIGNED_INT_10_10_10_2
:
1842 if (dstFormat
== GL_RGBA
) {
1843 GLuint
*dst
= (GLuint
*) dstAddr
;
1845 dst
[i
] = (((GLuint
) (rgba
[i
][RCOMP
] * 1023.0F
)) << 22)
1846 | (((GLuint
) (rgba
[i
][GCOMP
] * 1023.0F
)) << 12)
1847 | (((GLuint
) (rgba
[i
][BCOMP
] * 1023.0F
)) << 2)
1848 | (((GLuint
) (rgba
[i
][ACOMP
] * 3.0F
)) );
1851 else if (dstFormat
== GL_BGRA
) {
1852 GLuint
*dst
= (GLuint
*) dstAddr
;
1854 dst
[i
] = (((GLuint
) (rgba
[i
][BCOMP
] * 1023.0F
)) << 22)
1855 | (((GLuint
) (rgba
[i
][GCOMP
] * 1023.0F
)) << 12)
1856 | (((GLuint
) (rgba
[i
][RCOMP
] * 1023.0F
)) << 2)
1857 | (((GLuint
) (rgba
[i
][ACOMP
] * 3.0F
)) );
1860 else if (dstFormat
== GL_ABGR_EXT
) {
1861 GLuint
*dst
= (GLuint
*) dstAddr
;
1863 dst
[i
] = (((GLuint
) (rgba
[i
][ACOMP
] * 1023.0F
)) << 22)
1864 | (((GLuint
) (rgba
[i
][BCOMP
] * 1023.0F
)) << 12)
1865 | (((GLuint
) (rgba
[i
][GCOMP
] * 1023.0F
)) << 2)
1866 | (((GLuint
) (rgba
[i
][RCOMP
] * 3.0F
)) );
1870 case GL_UNSIGNED_INT_2_10_10_10_REV
:
1871 if (dstFormat
== GL_RGBA
) {
1872 GLuint
*dst
= (GLuint
*) dstAddr
;
1874 dst
[i
] = (((GLuint
) (rgba
[i
][RCOMP
] * 1023.0F
)) )
1875 | (((GLuint
) (rgba
[i
][GCOMP
] * 1023.0F
)) << 10)
1876 | (((GLuint
) (rgba
[i
][BCOMP
] * 1023.0F
)) << 20)
1877 | (((GLuint
) (rgba
[i
][ACOMP
] * 3.0F
)) << 30);
1880 else if (dstFormat
== GL_BGRA
) {
1881 GLuint
*dst
= (GLuint
*) dstAddr
;
1883 dst
[i
] = (((GLuint
) (rgba
[i
][BCOMP
] * 1023.0F
)) )
1884 | (((GLuint
) (rgba
[i
][GCOMP
] * 1023.0F
)) << 10)
1885 | (((GLuint
) (rgba
[i
][RCOMP
] * 1023.0F
)) << 20)
1886 | (((GLuint
) (rgba
[i
][ACOMP
] * 3.0F
)) << 30);
1889 else if (dstFormat
== GL_ABGR_EXT
) {
1890 GLuint
*dst
= (GLuint
*) dstAddr
;
1892 dst
[i
] = (((GLuint
) (rgba
[i
][ACOMP
] * 1023.0F
)) )
1893 | (((GLuint
) (rgba
[i
][BCOMP
] * 1023.0F
)) << 10)
1894 | (((GLuint
) (rgba
[i
][GCOMP
] * 1023.0F
)) << 20)
1895 | (((GLuint
) (rgba
[i
][RCOMP
] * 3.0F
)) << 30);
1900 _mesa_problem(ctx
, "bad type in _mesa_pack_float_rgba_span");
1906 * Pack the given RGBA span into client memory at 'dest' address
1907 * in the given pixel format and type.
1908 * Optionally apply the enabled pixel transfer ops.
1909 * Pack into memory using the given packing params struct.
1910 * This is used by glReadPixels and glGetTexImage?D()
1911 * \param ctx - the context
1912 * n - number of pixels in the span
1914 * format - dest packing format
1915 * type - dest packing data type
1916 * destination - destination packing address
1917 * packing - pixel packing parameters
1918 * transferOps - bitmask of IMAGE_*_BIT operations to apply
1921 _mesa_pack_rgba_span( GLcontext
*ctx
,
1922 GLuint n
, CONST GLchan srcRgba
[][4],
1923 GLenum dstFormat
, GLenum dstType
,
1925 const struct gl_pixelstore_attrib
*dstPacking
,
1928 ASSERT((ctx
->NewState
& _NEW_PIXEL
) == 0 || transferOps
== 0);
1930 /* Test for optimized case first */
1931 if (transferOps
== 0 && dstFormat
== GL_RGBA
&& dstType
== CHAN_TYPE
) {
1932 /* common simple case */
1933 MEMCPY(dstAddr
, srcRgba
, n
* 4 * sizeof(GLchan
));
1935 else if (transferOps
== 0 && dstFormat
== GL_RGB
&& dstType
== CHAN_TYPE
) {
1936 /* common simple case */
1938 GLchan
*dest
= (GLchan
*) dstAddr
;
1939 for (i
= 0; i
< n
; i
++) {
1940 dest
[0] = srcRgba
[i
][RCOMP
];
1941 dest
[1] = srcRgba
[i
][GCOMP
];
1942 dest
[2] = srcRgba
[i
][BCOMP
];
1946 else if (transferOps
== 0 && dstFormat
== GL_RGBA
&& dstType
== GL_UNSIGNED_BYTE
) {
1947 /* common simple case */
1949 GLubyte
*dest
= (GLubyte
*) dstAddr
;
1950 for (i
= 0; i
< n
; i
++) {
1951 dest
[0] = CHAN_TO_UBYTE(srcRgba
[i
][RCOMP
]);
1952 dest
[1] = CHAN_TO_UBYTE(srcRgba
[i
][GCOMP
]);
1953 dest
[2] = CHAN_TO_UBYTE(srcRgba
[i
][BCOMP
]);
1954 dest
[3] = CHAN_TO_UBYTE(srcRgba
[i
][ACOMP
]);
1959 /* general solution */
1961 DEFMARRAY(GLfloat
, rgba
, MAX_WIDTH
, 4); /* mac 32k limitation */
1962 CHECKARRAY(rgba
, return); /* mac 32k limitation */
1964 assert(n
<= MAX_WIDTH
);
1965 /* convert color components to floating point */
1967 rgba
[i
][RCOMP
] = CHAN_TO_FLOAT(srcRgba
[i
][RCOMP
]);
1968 rgba
[i
][GCOMP
] = CHAN_TO_FLOAT(srcRgba
[i
][GCOMP
]);
1969 rgba
[i
][BCOMP
] = CHAN_TO_FLOAT(srcRgba
[i
][BCOMP
]);
1970 rgba
[i
][ACOMP
] = CHAN_TO_FLOAT(srcRgba
[i
][ACOMP
]);
1972 _mesa_pack_float_rgba_span(ctx
, n
, (const GLfloat (*)[4]) rgba
,
1973 dstFormat
, dstType
, dstAddr
,
1974 dstPacking
, transferOps
);
1975 UNDEFARRAY(rgba
); /* mac 32k limitation */
1980 #define SWAP2BYTE(VALUE) \
1982 GLubyte *bytes = (GLubyte *) &(VALUE); \
1983 GLubyte tmp = bytes[0]; \
1984 bytes[0] = bytes[1]; \
1988 #define SWAP4BYTE(VALUE) \
1990 GLubyte *bytes = (GLubyte *) &(VALUE); \
1991 GLubyte tmp = bytes[0]; \
1992 bytes[0] = bytes[3]; \
1995 bytes[1] = bytes[2]; \
2001 extract_uint_indexes(GLuint n
, GLuint indexes
[],
2002 GLenum srcFormat
, GLenum srcType
, const GLvoid
*src
,
2003 const struct gl_pixelstore_attrib
*unpack
)
2005 assert(srcFormat
== GL_COLOR_INDEX
);
2007 ASSERT(srcType
== GL_BITMAP
||
2008 srcType
== GL_UNSIGNED_BYTE
||
2009 srcType
== GL_BYTE
||
2010 srcType
== GL_UNSIGNED_SHORT
||
2011 srcType
== GL_SHORT
||
2012 srcType
== GL_UNSIGNED_INT
||
2013 srcType
== GL_INT
||
2014 srcType
== GL_HALF_FLOAT_NV
||
2015 srcType
== GL_FLOAT
);
2020 GLubyte
*ubsrc
= (GLubyte
*) src
;
2021 if (unpack
->LsbFirst
) {
2022 GLubyte mask
= 1 << (unpack
->SkipPixels
& 0x7);
2024 for (i
= 0; i
< n
; i
++) {
2025 indexes
[i
] = (*ubsrc
& mask
) ? 1 : 0;
2036 GLubyte mask
= 128 >> (unpack
->SkipPixels
& 0x7);
2038 for (i
= 0; i
< n
; i
++) {
2039 indexes
[i
] = (*ubsrc
& mask
) ? 1 : 0;
2051 case GL_UNSIGNED_BYTE
:
2054 const GLubyte
*s
= (const GLubyte
*) src
;
2055 for (i
= 0; i
< n
; i
++)
2062 const GLbyte
*s
= (const GLbyte
*) src
;
2063 for (i
= 0; i
< n
; i
++)
2067 case GL_UNSIGNED_SHORT
:
2070 const GLushort
*s
= (const GLushort
*) src
;
2071 if (unpack
->SwapBytes
) {
2072 for (i
= 0; i
< n
; i
++) {
2073 GLushort value
= s
[i
];
2079 for (i
= 0; i
< n
; i
++)
2087 const GLshort
*s
= (const GLshort
*) src
;
2088 if (unpack
->SwapBytes
) {
2089 for (i
= 0; i
< n
; i
++) {
2090 GLshort value
= s
[i
];
2096 for (i
= 0; i
< n
; i
++)
2101 case GL_UNSIGNED_INT
:
2104 const GLuint
*s
= (const GLuint
*) src
;
2105 if (unpack
->SwapBytes
) {
2106 for (i
= 0; i
< n
; i
++) {
2107 GLuint value
= s
[i
];
2113 for (i
= 0; i
< n
; i
++)
2121 const GLint
*s
= (const GLint
*) src
;
2122 if (unpack
->SwapBytes
) {
2123 for (i
= 0; i
< n
; i
++) {
2130 for (i
= 0; i
< n
; i
++)
2138 const GLfloat
*s
= (const GLfloat
*) src
;
2139 if (unpack
->SwapBytes
) {
2140 for (i
= 0; i
< n
; i
++) {
2141 GLfloat value
= s
[i
];
2143 indexes
[i
] = (GLuint
) value
;
2147 for (i
= 0; i
< n
; i
++)
2148 indexes
[i
] = (GLuint
) s
[i
];
2152 case GL_HALF_FLOAT_NV
:
2155 const GLhalfNV
*s
= (const GLhalfNV
*) src
;
2156 if (unpack
->SwapBytes
) {
2157 for (i
= 0; i
< n
; i
++) {
2158 GLhalfNV value
= s
[i
];
2160 indexes
[i
] = (GLuint
) _mesa_half_to_float(value
);
2164 for (i
= 0; i
< n
; i
++)
2165 indexes
[i
] = (GLuint
) _mesa_half_to_float(s
[i
]);
2170 _mesa_problem(NULL
, "bad srcType in extract_uint_indexes");
2177 * This function extracts floating point RGBA values from arbitrary
2178 * image data. srcFormat and srcType are the format and type parameters
2179 * passed to glDrawPixels, glTexImage[123]D, glTexSubImage[123]D, etc.
2181 * Refering to section 3.6.4 of the OpenGL 1.2 spec, this function
2182 * implements the "Conversion to floating point", "Conversion to RGB",
2183 * and "Final Expansion to RGBA" operations.
2185 * Args: n - number of pixels
2186 * rgba - output colors
2187 * srcFormat - format of incoming data
2188 * srcType - data type of incoming data
2189 * src - source data pointer
2190 * swapBytes - perform byteswapping of incoming data?
2193 extract_float_rgba(GLuint n
, GLfloat rgba
[][4],
2194 GLenum srcFormat
, GLenum srcType
, const GLvoid
*src
,
2195 GLboolean swapBytes
)
2197 GLint redIndex
, greenIndex
, blueIndex
, alphaIndex
;
2199 GLint rComp
, bComp
, gComp
, aComp
;
2201 ASSERT(srcFormat
== GL_RED
||
2202 srcFormat
== GL_GREEN
||
2203 srcFormat
== GL_BLUE
||
2204 srcFormat
== GL_ALPHA
||
2205 srcFormat
== GL_LUMINANCE
||
2206 srcFormat
== GL_LUMINANCE_ALPHA
||
2207 srcFormat
== GL_INTENSITY
||
2208 srcFormat
== GL_RGB
||
2209 srcFormat
== GL_BGR
||
2210 srcFormat
== GL_RGBA
||
2211 srcFormat
== GL_BGRA
||
2212 srcFormat
== GL_ABGR_EXT
);
2214 ASSERT(srcType
== GL_UNSIGNED_BYTE
||
2215 srcType
== GL_BYTE
||
2216 srcType
== GL_UNSIGNED_SHORT
||
2217 srcType
== GL_SHORT
||
2218 srcType
== GL_UNSIGNED_INT
||
2219 srcType
== GL_INT
||
2220 srcType
== GL_HALF_FLOAT_NV
||
2221 srcType
== GL_FLOAT
||
2222 srcType
== GL_UNSIGNED_BYTE_3_3_2
||
2223 srcType
== GL_UNSIGNED_BYTE_2_3_3_REV
||
2224 srcType
== GL_UNSIGNED_SHORT_5_6_5
||
2225 srcType
== GL_UNSIGNED_SHORT_5_6_5_REV
||
2226 srcType
== GL_UNSIGNED_SHORT_4_4_4_4
||
2227 srcType
== GL_UNSIGNED_SHORT_4_4_4_4_REV
||
2228 srcType
== GL_UNSIGNED_SHORT_5_5_5_1
||
2229 srcType
== GL_UNSIGNED_SHORT_1_5_5_5_REV
||
2230 srcType
== GL_UNSIGNED_INT_8_8_8_8
||
2231 srcType
== GL_UNSIGNED_INT_8_8_8_8_REV
||
2232 srcType
== GL_UNSIGNED_INT_10_10_10_2
||
2233 srcType
== GL_UNSIGNED_INT_2_10_10_10_REV
);
2235 rComp
= gComp
= bComp
= aComp
= -1;
2237 switch (srcFormat
) {
2240 greenIndex
= blueIndex
= alphaIndex
= -1;
2245 redIndex
= blueIndex
= alphaIndex
= -1;
2250 redIndex
= greenIndex
= alphaIndex
= -1;
2254 redIndex
= greenIndex
= blueIndex
= -1;
2259 redIndex
= greenIndex
= blueIndex
= 0;
2263 case GL_LUMINANCE_ALPHA
:
2264 redIndex
= greenIndex
= blueIndex
= 0;
2269 redIndex
= greenIndex
= blueIndex
= alphaIndex
= 0;
2320 _mesa_problem(NULL
, "bad srcFormat in extract float data");
2325 #define PROCESS(INDEX, CHANNEL, DEFAULT, TYPE, CONVERSION) \
2326 if ((INDEX) < 0) { \
2328 for (i = 0; i < n; i++) { \
2329 rgba[i][CHANNEL] = DEFAULT; \
2332 else if (swapBytes) { \
2333 const TYPE *s = (const TYPE *) src; \
2335 for (i = 0; i < n; i++) { \
2336 TYPE value = s[INDEX]; \
2337 if (sizeof(TYPE) == 2) { \
2340 else if (sizeof(TYPE) == 4) { \
2343 rgba[i][CHANNEL] = (GLfloat) CONVERSION(value); \
2348 const TYPE *s = (const TYPE *) src; \
2350 for (i = 0; i < n; i++) { \
2351 rgba[i][CHANNEL] = (GLfloat) CONVERSION(s[INDEX]); \
2357 case GL_UNSIGNED_BYTE
:
2358 PROCESS(redIndex
, RCOMP
, 0.0F
, GLubyte
, UBYTE_TO_FLOAT
);
2359 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLubyte
, UBYTE_TO_FLOAT
);
2360 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLubyte
, UBYTE_TO_FLOAT
);
2361 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLubyte
, UBYTE_TO_FLOAT
);
2364 PROCESS(redIndex
, RCOMP
, 0.0F
, GLbyte
, BYTE_TO_FLOAT
);
2365 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLbyte
, BYTE_TO_FLOAT
);
2366 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLbyte
, BYTE_TO_FLOAT
);
2367 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLbyte
, BYTE_TO_FLOAT
);
2369 case GL_UNSIGNED_SHORT
:
2370 PROCESS(redIndex
, RCOMP
, 0.0F
, GLushort
, USHORT_TO_FLOAT
);
2371 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLushort
, USHORT_TO_FLOAT
);
2372 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLushort
, USHORT_TO_FLOAT
);
2373 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLushort
, USHORT_TO_FLOAT
);
2376 PROCESS(redIndex
, RCOMP
, 0.0F
, GLshort
, SHORT_TO_FLOAT
);
2377 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLshort
, SHORT_TO_FLOAT
);
2378 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLshort
, SHORT_TO_FLOAT
);
2379 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLshort
, SHORT_TO_FLOAT
);
2381 case GL_UNSIGNED_INT
:
2382 PROCESS(redIndex
, RCOMP
, 0.0F
, GLuint
, UINT_TO_FLOAT
);
2383 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLuint
, UINT_TO_FLOAT
);
2384 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLuint
, UINT_TO_FLOAT
);
2385 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLuint
, UINT_TO_FLOAT
);
2388 PROCESS(redIndex
, RCOMP
, 0.0F
, GLint
, INT_TO_FLOAT
);
2389 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLint
, INT_TO_FLOAT
);
2390 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLint
, INT_TO_FLOAT
);
2391 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLint
, INT_TO_FLOAT
);
2394 PROCESS(redIndex
, RCOMP
, 0.0F
, GLfloat
, (GLfloat
));
2395 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLfloat
, (GLfloat
));
2396 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLfloat
, (GLfloat
));
2397 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLfloat
, (GLfloat
));
2399 case GL_HALF_FLOAT_NV
:
2400 PROCESS(redIndex
, RCOMP
, 0.0F
, GLhalfNV
, _mesa_half_to_float
);
2401 PROCESS(greenIndex
, GCOMP
, 0.0F
, GLhalfNV
, _mesa_half_to_float
);
2402 PROCESS(blueIndex
, BCOMP
, 0.0F
, GLhalfNV
, _mesa_half_to_float
);
2403 PROCESS(alphaIndex
, ACOMP
, 1.0F
, GLhalfNV
, _mesa_half_to_float
);
2405 case GL_UNSIGNED_BYTE_3_3_2
:
2407 const GLubyte
*ubsrc
= (const GLubyte
*) src
;
2409 for (i
= 0; i
< n
; i
++) {
2410 GLubyte p
= ubsrc
[i
];
2411 rgba
[i
][RCOMP
] = ((p
>> 5) ) * (1.0F
/ 7.0F
);
2412 rgba
[i
][GCOMP
] = ((p
>> 2) & 0x7) * (1.0F
/ 7.0F
);
2413 rgba
[i
][BCOMP
] = ((p
) & 0x3) * (1.0F
/ 3.0F
);
2414 rgba
[i
][ACOMP
] = 1.0F
;
2418 case GL_UNSIGNED_BYTE_2_3_3_REV
:
2420 const GLubyte
*ubsrc
= (const GLubyte
*) src
;
2422 for (i
= 0; i
< n
; i
++) {
2423 GLubyte p
= ubsrc
[i
];
2424 rgba
[i
][RCOMP
] = ((p
) & 0x7) * (1.0F
/ 7.0F
);
2425 rgba
[i
][GCOMP
] = ((p
>> 3) & 0x7) * (1.0F
/ 7.0F
);
2426 rgba
[i
][BCOMP
] = ((p
>> 6) ) * (1.0F
/ 3.0F
);
2427 rgba
[i
][ACOMP
] = 1.0F
;
2431 case GL_UNSIGNED_SHORT_5_6_5
:
2433 const GLushort
*ussrc
= (const GLushort
*) src
;
2435 for (i
= 0; i
< n
; i
++) {
2436 GLushort p
= ussrc
[i
];
2438 rgba
[i
][RCOMP
] = ((p
>> 11) ) * (1.0F
/ 31.0F
);
2439 rgba
[i
][GCOMP
] = ((p
>> 5) & 0x3f) * (1.0F
/ 63.0F
);
2440 rgba
[i
][BCOMP
] = ((p
) & 0x1f) * (1.0F
/ 31.0F
);
2441 rgba
[i
][ACOMP
] = 1.0F
;
2445 const GLushort
*ussrc
= (const GLushort
*) src
;
2447 for (i
= 0; i
< n
; i
++) {
2448 GLushort p
= ussrc
[i
];
2449 rgba
[i
][RCOMP
] = ((p
>> 11) ) * (1.0F
/ 31.0F
);
2450 rgba
[i
][GCOMP
] = ((p
>> 5) & 0x3f) * (1.0F
/ 63.0F
);
2451 rgba
[i
][BCOMP
] = ((p
) & 0x1f) * (1.0F
/ 31.0F
);
2452 rgba
[i
][ACOMP
] = 1.0F
;
2456 case GL_UNSIGNED_SHORT_5_6_5_REV
:
2458 const GLushort
*ussrc
= (const GLushort
*) src
;
2460 for (i
= 0; i
< n
; i
++) {
2461 GLushort p
= ussrc
[i
];
2463 rgba
[i
][RCOMP
] = ((p
) & 0x1f) * (1.0F
/ 31.0F
);
2464 rgba
[i
][GCOMP
] = ((p
>> 5) & 0x3f) * (1.0F
/ 63.0F
);
2465 rgba
[i
][BCOMP
] = ((p
>> 11) ) * (1.0F
/ 31.0F
);
2466 rgba
[i
][ACOMP
] = 1.0F
;
2470 const GLushort
*ussrc
= (const GLushort
*) src
;
2472 for (i
= 0; i
< n
; i
++) {
2473 GLushort p
= ussrc
[i
];
2474 rgba
[i
][RCOMP
] = ((p
) & 0x1f) * (1.0F
/ 31.0F
);
2475 rgba
[i
][GCOMP
] = ((p
>> 5) & 0x3f) * (1.0F
/ 63.0F
);
2476 rgba
[i
][BCOMP
] = ((p
>> 11) ) * (1.0F
/ 31.0F
);
2477 rgba
[i
][ACOMP
] = 1.0F
;
2481 case GL_UNSIGNED_SHORT_4_4_4_4
:
2483 const GLushort
*ussrc
= (const GLushort
*) src
;
2485 for (i
= 0; i
< n
; i
++) {
2486 GLushort p
= ussrc
[i
];
2488 rgba
[i
][rComp
] = ((p
>> 12) ) * (1.0F
/ 15.0F
);
2489 rgba
[i
][gComp
] = ((p
>> 8) & 0xf) * (1.0F
/ 15.0F
);
2490 rgba
[i
][bComp
] = ((p
>> 4) & 0xf) * (1.0F
/ 15.0F
);
2491 rgba
[i
][aComp
] = ((p
) & 0xf) * (1.0F
/ 15.0F
);
2495 const GLushort
*ussrc
= (const GLushort
*) src
;
2497 for (i
= 0; i
< n
; i
++) {
2498 GLushort p
= ussrc
[i
];
2499 rgba
[i
][rComp
] = ((p
>> 12) ) * (1.0F
/ 15.0F
);
2500 rgba
[i
][gComp
] = ((p
>> 8) & 0xf) * (1.0F
/ 15.0F
);
2501 rgba
[i
][bComp
] = ((p
>> 4) & 0xf) * (1.0F
/ 15.0F
);
2502 rgba
[i
][aComp
] = ((p
) & 0xf) * (1.0F
/ 15.0F
);
2506 case GL_UNSIGNED_SHORT_4_4_4_4_REV
:
2508 const GLushort
*ussrc
= (const GLushort
*) src
;
2510 for (i
= 0; i
< n
; i
++) {
2511 GLushort p
= ussrc
[i
];
2513 rgba
[i
][rComp
] = ((p
) & 0xf) * (1.0F
/ 15.0F
);
2514 rgba
[i
][gComp
] = ((p
>> 4) & 0xf) * (1.0F
/ 15.0F
);
2515 rgba
[i
][bComp
] = ((p
>> 8) & 0xf) * (1.0F
/ 15.0F
);
2516 rgba
[i
][aComp
] = ((p
>> 12) ) * (1.0F
/ 15.0F
);
2520 const GLushort
*ussrc
= (const GLushort
*) src
;
2522 for (i
= 0; i
< n
; i
++) {
2523 GLushort p
= ussrc
[i
];
2524 rgba
[i
][rComp
] = ((p
) & 0xf) * (1.0F
/ 15.0F
);
2525 rgba
[i
][gComp
] = ((p
>> 4) & 0xf) * (1.0F
/ 15.0F
);
2526 rgba
[i
][bComp
] = ((p
>> 8) & 0xf) * (1.0F
/ 15.0F
);
2527 rgba
[i
][aComp
] = ((p
>> 12) ) * (1.0F
/ 15.0F
);
2531 case GL_UNSIGNED_SHORT_5_5_5_1
:
2533 const GLushort
*ussrc
= (const GLushort
*) src
;
2535 for (i
= 0; i
< n
; i
++) {
2536 GLushort p
= ussrc
[i
];
2538 rgba
[i
][rComp
] = ((p
>> 11) ) * (1.0F
/ 31.0F
);
2539 rgba
[i
][gComp
] = ((p
>> 6) & 0x1f) * (1.0F
/ 31.0F
);
2540 rgba
[i
][bComp
] = ((p
>> 1) & 0x1f) * (1.0F
/ 31.0F
);
2541 rgba
[i
][aComp
] = ((p
) & 0x1) * (1.0F
/ 1.0F
);
2545 const GLushort
*ussrc
= (const GLushort
*) src
;
2547 for (i
= 0; i
< n
; i
++) {
2548 GLushort p
= ussrc
[i
];
2549 rgba
[i
][rComp
] = ((p
>> 11) ) * (1.0F
/ 31.0F
);
2550 rgba
[i
][gComp
] = ((p
>> 6) & 0x1f) * (1.0F
/ 31.0F
);
2551 rgba
[i
][bComp
] = ((p
>> 1) & 0x1f) * (1.0F
/ 31.0F
);
2552 rgba
[i
][aComp
] = ((p
) & 0x1) * (1.0F
/ 1.0F
);
2556 case GL_UNSIGNED_SHORT_1_5_5_5_REV
:
2558 const GLushort
*ussrc
= (const GLushort
*) src
;
2560 for (i
= 0; i
< n
; i
++) {
2561 GLushort p
= ussrc
[i
];
2563 rgba
[i
][rComp
] = ((p
) & 0x1f) * (1.0F
/ 31.0F
);
2564 rgba
[i
][gComp
] = ((p
>> 5) & 0x1f) * (1.0F
/ 31.0F
);
2565 rgba
[i
][bComp
] = ((p
>> 10) & 0x1f) * (1.0F
/ 31.0F
);
2566 rgba
[i
][aComp
] = ((p
>> 15) ) * (1.0F
/ 1.0F
);
2570 const GLushort
*ussrc
= (const GLushort
*) src
;
2572 for (i
= 0; i
< n
; i
++) {
2573 GLushort p
= ussrc
[i
];
2574 rgba
[i
][rComp
] = ((p
) & 0x1f) * (1.0F
/ 31.0F
);
2575 rgba
[i
][gComp
] = ((p
>> 5) & 0x1f) * (1.0F
/ 31.0F
);
2576 rgba
[i
][bComp
] = ((p
>> 10) & 0x1f) * (1.0F
/ 31.0F
);
2577 rgba
[i
][aComp
] = ((p
>> 15) ) * (1.0F
/ 1.0F
);
2581 case GL_UNSIGNED_INT_8_8_8_8
:
2583 const GLuint
*uisrc
= (const GLuint
*) src
;
2585 for (i
= 0; i
< n
; i
++) {
2586 GLuint p
= uisrc
[i
];
2587 rgba
[i
][rComp
] = UBYTE_TO_FLOAT((p
) & 0xff);
2588 rgba
[i
][gComp
] = UBYTE_TO_FLOAT((p
>> 8) & 0xff);
2589 rgba
[i
][bComp
] = UBYTE_TO_FLOAT((p
>> 16) & 0xff);
2590 rgba
[i
][aComp
] = UBYTE_TO_FLOAT((p
>> 24) );
2594 const GLuint
*uisrc
= (const GLuint
*) src
;
2596 for (i
= 0; i
< n
; i
++) {
2597 GLuint p
= uisrc
[i
];
2598 rgba
[i
][rComp
] = UBYTE_TO_FLOAT((p
>> 24) );
2599 rgba
[i
][gComp
] = UBYTE_TO_FLOAT((p
>> 16) & 0xff);
2600 rgba
[i
][bComp
] = UBYTE_TO_FLOAT((p
>> 8) & 0xff);
2601 rgba
[i
][aComp
] = UBYTE_TO_FLOAT((p
) & 0xff);
2605 case GL_UNSIGNED_INT_8_8_8_8_REV
:
2607 const GLuint
*uisrc
= (const GLuint
*) src
;
2609 for (i
= 0; i
< n
; i
++) {
2610 GLuint p
= uisrc
[i
];
2611 rgba
[i
][rComp
] = UBYTE_TO_FLOAT((p
>> 24) );
2612 rgba
[i
][gComp
] = UBYTE_TO_FLOAT((p
>> 16) & 0xff);
2613 rgba
[i
][bComp
] = UBYTE_TO_FLOAT((p
>> 8) & 0xff);
2614 rgba
[i
][aComp
] = UBYTE_TO_FLOAT((p
) & 0xff);
2618 const GLuint
*uisrc
= (const GLuint
*) src
;
2620 for (i
= 0; i
< n
; i
++) {
2621 GLuint p
= uisrc
[i
];
2622 rgba
[i
][rComp
] = UBYTE_TO_FLOAT((p
) & 0xff);
2623 rgba
[i
][gComp
] = UBYTE_TO_FLOAT((p
>> 8) & 0xff);
2624 rgba
[i
][bComp
] = UBYTE_TO_FLOAT((p
>> 16) & 0xff);
2625 rgba
[i
][aComp
] = UBYTE_TO_FLOAT((p
>> 24) );
2629 case GL_UNSIGNED_INT_10_10_10_2
:
2631 const GLuint
*uisrc
= (const GLuint
*) src
;
2633 for (i
= 0; i
< n
; i
++) {
2634 GLuint p
= uisrc
[i
];
2636 rgba
[i
][rComp
] = ((p
>> 22) ) * (1.0F
/ 1023.0F
);
2637 rgba
[i
][gComp
] = ((p
>> 12) & 0x3ff) * (1.0F
/ 1023.0F
);
2638 rgba
[i
][bComp
] = ((p
>> 2) & 0x3ff) * (1.0F
/ 1023.0F
);
2639 rgba
[i
][aComp
] = ((p
) & 0x3 ) * (1.0F
/ 3.0F
);
2643 const GLuint
*uisrc
= (const GLuint
*) src
;
2645 for (i
= 0; i
< n
; i
++) {
2646 GLuint p
= uisrc
[i
];
2647 rgba
[i
][rComp
] = ((p
>> 22) ) * (1.0F
/ 1023.0F
);
2648 rgba
[i
][gComp
] = ((p
>> 12) & 0x3ff) * (1.0F
/ 1023.0F
);
2649 rgba
[i
][bComp
] = ((p
>> 2) & 0x3ff) * (1.0F
/ 1023.0F
);
2650 rgba
[i
][aComp
] = ((p
) & 0x3 ) * (1.0F
/ 3.0F
);
2654 case GL_UNSIGNED_INT_2_10_10_10_REV
:
2656 const GLuint
*uisrc
= (const GLuint
*) src
;
2658 for (i
= 0; i
< n
; i
++) {
2659 GLuint p
= uisrc
[i
];
2661 rgba
[i
][rComp
] = ((p
) & 0x3ff) * (1.0F
/ 1023.0F
);
2662 rgba
[i
][gComp
] = ((p
>> 10) & 0x3ff) * (1.0F
/ 1023.0F
);
2663 rgba
[i
][bComp
] = ((p
>> 20) & 0x3ff) * (1.0F
/ 1023.0F
);
2664 rgba
[i
][aComp
] = ((p
>> 30) ) * (1.0F
/ 3.0F
);
2668 const GLuint
*uisrc
= (const GLuint
*) src
;
2670 for (i
= 0; i
< n
; i
++) {
2671 GLuint p
= uisrc
[i
];
2672 rgba
[i
][rComp
] = ((p
) & 0x3ff) * (1.0F
/ 1023.0F
);
2673 rgba
[i
][gComp
] = ((p
>> 10) & 0x3ff) * (1.0F
/ 1023.0F
);
2674 rgba
[i
][bComp
] = ((p
>> 20) & 0x3ff) * (1.0F
/ 1023.0F
);
2675 rgba
[i
][aComp
] = ((p
>> 30) ) * (1.0F
/ 3.0F
);
2680 _mesa_problem(NULL
, "bad srcType in extract float data");
2687 * Unpack a row of color image data from a client buffer according to
2688 * the pixel unpacking parameters.
2689 * Return GLubyte values in the specified dest image format.
2690 * This is (or will be) used by glDrawPixels and glTexImage?D().
2691 * \param ctx - the context
2692 * n - number of pixels in the span
2693 * dstFormat - format of destination color array
2694 * dest - the destination color array
2695 * srcFormat - source image format
2696 * srcType - source image data type
2697 * source - source image pointer
2698 * srcPacking - pixel unpacking parameters
2699 * transferOps - bitmask of IMAGE_*_BIT values of operations to apply
2701 * XXX perhaps expand this to process whole images someday.
2704 _mesa_unpack_chan_color_span( GLcontext
*ctx
,
2705 GLuint n
, GLenum dstFormat
, GLchan dest
[],
2706 GLenum srcFormat
, GLenum srcType
,
2707 const GLvoid
*source
,
2708 const struct gl_pixelstore_attrib
*srcPacking
,
2709 GLuint transferOps
)
2711 ASSERT(dstFormat
== GL_ALPHA
||
2712 dstFormat
== GL_LUMINANCE
||
2713 dstFormat
== GL_LUMINANCE_ALPHA
||
2714 dstFormat
== GL_INTENSITY
||
2715 dstFormat
== GL_RGB
||
2716 dstFormat
== GL_RGBA
||
2717 dstFormat
== GL_COLOR_INDEX
);
2719 ASSERT(srcFormat
== GL_RED
||
2720 srcFormat
== GL_GREEN
||
2721 srcFormat
== GL_BLUE
||
2722 srcFormat
== GL_ALPHA
||
2723 srcFormat
== GL_LUMINANCE
||
2724 srcFormat
== GL_LUMINANCE_ALPHA
||
2725 srcFormat
== GL_INTENSITY
||
2726 srcFormat
== GL_RGB
||
2727 srcFormat
== GL_BGR
||
2728 srcFormat
== GL_RGBA
||
2729 srcFormat
== GL_BGRA
||
2730 srcFormat
== GL_ABGR_EXT
||
2731 srcFormat
== GL_COLOR_INDEX
);
2733 ASSERT(srcType
== GL_BITMAP
||
2734 srcType
== GL_UNSIGNED_BYTE
||
2735 srcType
== GL_BYTE
||
2736 srcType
== GL_UNSIGNED_SHORT
||
2737 srcType
== GL_SHORT
||
2738 srcType
== GL_UNSIGNED_INT
||
2739 srcType
== GL_INT
||
2740 srcType
== GL_HALF_FLOAT_NV
||
2741 srcType
== GL_FLOAT
||
2742 srcType
== GL_UNSIGNED_BYTE_3_3_2
||
2743 srcType
== GL_UNSIGNED_BYTE_2_3_3_REV
||
2744 srcType
== GL_UNSIGNED_SHORT_5_6_5
||
2745 srcType
== GL_UNSIGNED_SHORT_5_6_5_REV
||
2746 srcType
== GL_UNSIGNED_SHORT_4_4_4_4
||
2747 srcType
== GL_UNSIGNED_SHORT_4_4_4_4_REV
||
2748 srcType
== GL_UNSIGNED_SHORT_5_5_5_1
||
2749 srcType
== GL_UNSIGNED_SHORT_1_5_5_5_REV
||
2750 srcType
== GL_UNSIGNED_INT_8_8_8_8
||
2751 srcType
== GL_UNSIGNED_INT_8_8_8_8_REV
||
2752 srcType
== GL_UNSIGNED_INT_10_10_10_2
||
2753 srcType
== GL_UNSIGNED_INT_2_10_10_10_REV
);
2755 /* Try simple cases first */
2756 if (transferOps
== 0 ){
2757 if (srcType
== CHAN_TYPE
) {
2758 if (dstFormat
== GL_RGBA
) {
2759 if (srcFormat
== GL_RGBA
) {
2760 MEMCPY( dest
, source
, n
* 4 * sizeof(GLchan
) );
2763 else if (srcFormat
== GL_RGB
) {
2765 const GLchan
*src
= (const GLchan
*) source
;
2767 for (i
= 0; i
< n
; i
++) {
2778 else if (dstFormat
== GL_RGB
) {
2779 if (srcFormat
== GL_RGB
) {
2780 MEMCPY( dest
, source
, n
* 3 * sizeof(GLchan
) );
2783 else if (srcFormat
== GL_RGBA
) {
2785 const GLchan
*src
= (const GLchan
*) source
;
2787 for (i
= 0; i
< n
; i
++) {
2797 else if (dstFormat
== srcFormat
) {
2798 GLint comps
= _mesa_components_in_format(srcFormat
);
2800 MEMCPY( dest
, source
, n
* comps
* sizeof(GLchan
) );
2805 * Common situation, loading 8bit RGBA/RGB source images
2806 * into 16/32 bit destination. (OSMesa16/32)
2808 else if (srcType
== GL_UNSIGNED_BYTE
) {
2809 if (dstFormat
== GL_RGBA
) {
2810 if (srcFormat
== GL_RGB
) {
2812 const GLubyte
*src
= (const GLubyte
*) source
;
2814 for (i
= 0; i
< n
; i
++) {
2815 dst
[0] = UBYTE_TO_CHAN(src
[0]);
2816 dst
[1] = UBYTE_TO_CHAN(src
[1]);
2817 dst
[2] = UBYTE_TO_CHAN(src
[2]);
2824 else if (srcFormat
== GL_RGBA
) {
2826 const GLubyte
*src
= (const GLubyte
*) source
;
2828 for (i
= 0; i
< n
; i
++) {
2829 dst
[0] = UBYTE_TO_CHAN(src
[0]);
2830 dst
[1] = UBYTE_TO_CHAN(src
[1]);
2831 dst
[2] = UBYTE_TO_CHAN(src
[2]);
2832 dst
[3] = UBYTE_TO_CHAN(src
[3]);
2839 else if (dstFormat
== GL_RGB
) {
2840 if (srcFormat
== GL_RGB
) {
2842 const GLubyte
*src
= (const GLubyte
*) source
;
2844 for (i
= 0; i
< n
; i
++) {
2845 dst
[0] = UBYTE_TO_CHAN(src
[0]);
2846 dst
[1] = UBYTE_TO_CHAN(src
[1]);
2847 dst
[2] = UBYTE_TO_CHAN(src
[2]);
2853 else if (srcFormat
== GL_RGBA
) {
2855 const GLubyte
*src
= (const GLubyte
*) source
;
2857 for (i
= 0; i
< n
; i
++) {
2858 dst
[0] = UBYTE_TO_CHAN(src
[0]);
2859 dst
[1] = UBYTE_TO_CHAN(src
[1]);
2860 dst
[2] = UBYTE_TO_CHAN(src
[2]);
2871 /* general solution begins here */
2873 GLint dstComponents
;
2874 GLint dstRedIndex
, dstGreenIndex
, dstBlueIndex
, dstAlphaIndex
;
2875 GLint dstLuminanceIndex
, dstIntensityIndex
;
2876 DEFMARRAY(GLfloat
, rgba
, MAX_WIDTH
, 4); /* mac 32k limitation */
2877 CHECKARRAY(rgba
, return); /* mac 32k limitation */
2879 dstComponents
= _mesa_components_in_format( dstFormat
);
2880 /* source & dest image formats should have been error checked by now */
2881 assert(dstComponents
> 0);
2884 * Extract image data and convert to RGBA floats
2886 assert(n
<= MAX_WIDTH
);
2887 if (srcFormat
== GL_COLOR_INDEX
) {
2888 GLuint indexes
[MAX_WIDTH
];
2889 extract_uint_indexes(n
, indexes
, srcFormat
, srcType
, source
,
2892 if (dstFormat
== GL_COLOR_INDEX
2893 && (transferOps
& IMAGE_MAP_COLOR_BIT
)) {
2894 _mesa_map_ci(ctx
, n
, indexes
);
2896 if (transferOps
& IMAGE_SHIFT_OFFSET_BIT
) {
2897 _mesa_shift_and_offset_ci(ctx
, n
, indexes
);
2900 if (dstFormat
== GL_COLOR_INDEX
) {
2901 /* convert to GLchan and return */
2903 for (i
= 0; i
< n
; i
++) {
2904 dest
[i
] = (GLchan
) (indexes
[i
] & 0xff);
2906 UNDEFARRAY(rgba
); /* mac 32k limitation */
2910 /* Convert indexes to RGBA */
2911 _mesa_map_ci_to_rgba(ctx
, n
, indexes
, rgba
);
2915 extract_float_rgba(n
, rgba
, srcFormat
, srcType
, source
,
2916 srcPacking
->SwapBytes
);
2918 /* scale and bias colors */
2919 if (transferOps
& IMAGE_SCALE_BIAS_BIT
) {
2920 _mesa_scale_and_bias_rgba(ctx
, n
, rgba
,
2921 ctx
->Pixel
.RedScale
, ctx
->Pixel
.GreenScale
,
2922 ctx
->Pixel
.BlueScale
, ctx
->Pixel
.AlphaScale
,
2923 ctx
->Pixel
.RedBias
, ctx
->Pixel
.GreenBias
,
2924 ctx
->Pixel
.BlueBias
, ctx
->Pixel
.AlphaBias
);
2926 /* color map lookup */
2927 if (transferOps
& IMAGE_MAP_COLOR_BIT
) {
2928 _mesa_map_rgba(ctx
, n
, rgba
);
2933 /* GL_COLOR_TABLE lookup */
2934 if (transferOps
& IMAGE_COLOR_TABLE_BIT
) {
2935 _mesa_lookup_rgba(&ctx
->ColorTable
, n
, rgba
);
2938 if (transferOps
& IMAGE_CONVOLUTION_BIT
) {
2939 /* this has to be done in the calling code */
2941 /* GL_POST_CONVOLUTION_RED/GREEN/BLUE/ALPHA_SCALE/BIAS */
2942 if (transferOps
& IMAGE_POST_CONVOLUTION_SCALE_BIAS
) {
2943 _mesa_scale_and_bias_rgba(ctx
, n
, rgba
,
2944 ctx
->Pixel
.PostConvolutionScale
[RCOMP
],
2945 ctx
->Pixel
.PostConvolutionScale
[GCOMP
],
2946 ctx
->Pixel
.PostConvolutionScale
[BCOMP
],
2947 ctx
->Pixel
.PostConvolutionScale
[ACOMP
],
2948 ctx
->Pixel
.PostConvolutionBias
[RCOMP
],
2949 ctx
->Pixel
.PostConvolutionBias
[GCOMP
],
2950 ctx
->Pixel
.PostConvolutionBias
[BCOMP
],
2951 ctx
->Pixel
.PostConvolutionBias
[ACOMP
]);
2953 /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
2954 if (transferOps
& IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT
) {
2955 _mesa_lookup_rgba(&ctx
->PostConvolutionColorTable
, n
, rgba
);
2957 /* color matrix transform */
2958 if (transferOps
& IMAGE_COLOR_MATRIX_BIT
) {
2959 _mesa_transform_rgba(ctx
, n
, rgba
);
2961 /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
2962 if (transferOps
& IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT
) {
2963 _mesa_lookup_rgba(&ctx
->PostColorMatrixColorTable
, n
, rgba
);
2965 /* update histogram count */
2966 if (transferOps
& IMAGE_HISTOGRAM_BIT
) {
2967 _mesa_update_histogram(ctx
, n
, (CONST
GLfloat (*)[4]) rgba
);
2970 if (transferOps
& IMAGE_MIN_MAX_BIT
) {
2971 _mesa_update_minmax(ctx
, n
, (CONST
GLfloat (*)[4]) rgba
);
2975 /* clamp to [0,1] */
2976 #if CHAN_TYPE != GL_FLOAT
2979 for (i
= 0; i
< n
; i
++) {
2980 rgba
[i
][RCOMP
] = CLAMP(rgba
[i
][RCOMP
], 0.0F
, 1.0F
);
2981 rgba
[i
][GCOMP
] = CLAMP(rgba
[i
][GCOMP
], 0.0F
, 1.0F
);
2982 rgba
[i
][BCOMP
] = CLAMP(rgba
[i
][BCOMP
], 0.0F
, 1.0F
);
2983 rgba
[i
][ACOMP
] = CLAMP(rgba
[i
][ACOMP
], 0.0F
, 1.0F
);
2988 /* Now determine which color channels we need to produce.
2989 * And determine the dest index (offset) within each color tuple.
2991 switch (dstFormat
) {
2994 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= -1;
2995 dstLuminanceIndex
= dstIntensityIndex
= -1;
2998 dstLuminanceIndex
= 0;
2999 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= dstAlphaIndex
= -1;
3000 dstIntensityIndex
= -1;
3002 case GL_LUMINANCE_ALPHA
:
3003 dstLuminanceIndex
= 0;
3005 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= -1;
3006 dstIntensityIndex
= -1;
3009 dstIntensityIndex
= 0;
3010 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= dstAlphaIndex
= -1;
3011 dstLuminanceIndex
= -1;
3017 dstAlphaIndex
= dstLuminanceIndex
= dstIntensityIndex
= -1;
3024 dstLuminanceIndex
= dstIntensityIndex
= -1;
3027 _mesa_problem(ctx
, "bad dstFormat in _mesa_unpack_chan_span()");
3028 UNDEFARRAY(rgba
); /* mac 32k limitation */
3033 /* Now return the GLchan data in the requested dstFormat */
3035 if (dstRedIndex
>= 0) {
3038 for (i
= 0; i
< n
; i
++) {
3039 CLAMPED_FLOAT_TO_CHAN(dst
[dstRedIndex
], rgba
[i
][RCOMP
]);
3040 dst
+= dstComponents
;
3044 if (dstGreenIndex
>= 0) {
3047 for (i
= 0; i
< n
; i
++) {
3048 CLAMPED_FLOAT_TO_CHAN(dst
[dstGreenIndex
], rgba
[i
][GCOMP
]);
3049 dst
+= dstComponents
;
3053 if (dstBlueIndex
>= 0) {
3056 for (i
= 0; i
< n
; i
++) {
3057 CLAMPED_FLOAT_TO_CHAN(dst
[dstBlueIndex
], rgba
[i
][BCOMP
]);
3058 dst
+= dstComponents
;
3062 if (dstAlphaIndex
>= 0) {
3065 for (i
= 0; i
< n
; i
++) {
3066 CLAMPED_FLOAT_TO_CHAN(dst
[dstAlphaIndex
], rgba
[i
][ACOMP
]);
3067 dst
+= dstComponents
;
3071 if (dstIntensityIndex
>= 0) {
3074 assert(dstIntensityIndex
== 0);
3075 assert(dstComponents
== 1);
3076 for (i
= 0; i
< n
; i
++) {
3077 /* Intensity comes from red channel */
3078 CLAMPED_FLOAT_TO_CHAN(dst
[i
], rgba
[i
][RCOMP
]);
3082 if (dstLuminanceIndex
>= 0) {
3085 assert(dstLuminanceIndex
== 0);
3086 for (i
= 0; i
< n
; i
++) {
3087 /* Luminance comes from red channel */
3088 CLAMPED_FLOAT_TO_CHAN(dst
[0], rgba
[i
][RCOMP
]);
3089 dst
+= dstComponents
;
3092 UNDEFARRAY(rgba
); /* mac 32k limitation */
3098 _mesa_unpack_float_color_span( GLcontext
*ctx
,
3099 GLuint n
, GLenum dstFormat
, GLfloat dest
[],
3100 GLenum srcFormat
, GLenum srcType
,
3101 const GLvoid
*source
,
3102 const struct gl_pixelstore_attrib
*srcPacking
,
3103 GLuint transferOps
, GLboolean clamp
)
3105 ASSERT(dstFormat
== GL_ALPHA
||
3106 dstFormat
== GL_LUMINANCE
||
3107 dstFormat
== GL_LUMINANCE_ALPHA
||
3108 dstFormat
== GL_INTENSITY
||
3109 dstFormat
== GL_RGB
||
3110 dstFormat
== GL_RGBA
||
3111 dstFormat
== GL_COLOR_INDEX
);
3113 ASSERT(srcFormat
== GL_RED
||
3114 srcFormat
== GL_GREEN
||
3115 srcFormat
== GL_BLUE
||
3116 srcFormat
== GL_ALPHA
||
3117 srcFormat
== GL_LUMINANCE
||
3118 srcFormat
== GL_LUMINANCE_ALPHA
||
3119 srcFormat
== GL_INTENSITY
||
3120 srcFormat
== GL_RGB
||
3121 srcFormat
== GL_BGR
||
3122 srcFormat
== GL_RGBA
||
3123 srcFormat
== GL_BGRA
||
3124 srcFormat
== GL_ABGR_EXT
||
3125 srcFormat
== GL_COLOR_INDEX
);
3127 ASSERT(srcType
== GL_BITMAP
||
3128 srcType
== GL_UNSIGNED_BYTE
||
3129 srcType
== GL_BYTE
||
3130 srcType
== GL_UNSIGNED_SHORT
||
3131 srcType
== GL_SHORT
||
3132 srcType
== GL_UNSIGNED_INT
||
3133 srcType
== GL_INT
||
3134 srcType
== GL_HALF_FLOAT_NV
||
3135 srcType
== GL_FLOAT
||
3136 srcType
== GL_UNSIGNED_BYTE_3_3_2
||
3137 srcType
== GL_UNSIGNED_BYTE_2_3_3_REV
||
3138 srcType
== GL_UNSIGNED_SHORT_5_6_5
||
3139 srcType
== GL_UNSIGNED_SHORT_5_6_5_REV
||
3140 srcType
== GL_UNSIGNED_SHORT_4_4_4_4
||
3141 srcType
== GL_UNSIGNED_SHORT_4_4_4_4_REV
||
3142 srcType
== GL_UNSIGNED_SHORT_5_5_5_1
||
3143 srcType
== GL_UNSIGNED_SHORT_1_5_5_5_REV
||
3144 srcType
== GL_UNSIGNED_INT_8_8_8_8
||
3145 srcType
== GL_UNSIGNED_INT_8_8_8_8_REV
||
3146 srcType
== GL_UNSIGNED_INT_10_10_10_2
||
3147 srcType
== GL_UNSIGNED_INT_2_10_10_10_REV
);
3149 /* general solution, no special cases, yet */
3151 GLint dstComponents
;
3152 GLint dstRedIndex
, dstGreenIndex
, dstBlueIndex
, dstAlphaIndex
;
3153 GLint dstLuminanceIndex
, dstIntensityIndex
;
3154 DEFMARRAY(GLfloat
, rgba
, MAX_WIDTH
, 4); /* mac 32k limitation */
3155 CHECKARRAY(rgba
, return); /* mac 32k limitation */
3157 dstComponents
= _mesa_components_in_format( dstFormat
);
3158 /* source & dest image formats should have been error checked by now */
3159 assert(dstComponents
> 0);
3162 * Extract image data and convert to RGBA floats
3164 assert(n
<= MAX_WIDTH
);
3165 if (srcFormat
== GL_COLOR_INDEX
) {
3166 GLuint indexes
[MAX_WIDTH
];
3167 extract_uint_indexes(n
, indexes
, srcFormat
, srcType
, source
,
3170 if (dstFormat
== GL_COLOR_INDEX
3171 && (transferOps
& IMAGE_MAP_COLOR_BIT
)) {
3172 _mesa_map_ci(ctx
, n
, indexes
);
3174 if (transferOps
& IMAGE_SHIFT_OFFSET_BIT
) {
3175 _mesa_shift_and_offset_ci(ctx
, n
, indexes
);
3178 if (dstFormat
== GL_COLOR_INDEX
) {
3179 /* convert to GLchan and return */
3181 for (i
= 0; i
< n
; i
++) {
3182 dest
[i
] = (GLchan
) (indexes
[i
] & 0xff);
3184 UNDEFARRAY(rgba
); /* mac 32k limitation */
3188 /* Convert indexes to RGBA */
3189 _mesa_map_ci_to_rgba(ctx
, n
, indexes
, rgba
);
3193 extract_float_rgba(n
, rgba
, srcFormat
, srcType
, source
,
3194 srcPacking
->SwapBytes
);
3196 /* scale and bias colors */
3197 if (transferOps
& IMAGE_SCALE_BIAS_BIT
) {
3198 _mesa_scale_and_bias_rgba(ctx
, n
, rgba
,
3199 ctx
->Pixel
.RedScale
, ctx
->Pixel
.GreenScale
,
3200 ctx
->Pixel
.BlueScale
, ctx
->Pixel
.AlphaScale
,
3201 ctx
->Pixel
.RedBias
, ctx
->Pixel
.GreenBias
,
3202 ctx
->Pixel
.BlueBias
, ctx
->Pixel
.AlphaBias
);
3204 /* color map lookup */
3205 if (transferOps
& IMAGE_MAP_COLOR_BIT
) {
3206 _mesa_map_rgba(ctx
, n
, rgba
);
3211 /* GL_COLOR_TABLE lookup */
3212 if (transferOps
& IMAGE_COLOR_TABLE_BIT
) {
3213 _mesa_lookup_rgba(&ctx
->ColorTable
, n
, rgba
);
3216 if (transferOps
& IMAGE_CONVOLUTION_BIT
) {
3219 /* GL_POST_CONVOLUTION_RED/GREEN/BLUE/ALPHA_SCALE/BIAS */
3220 if (transferOps
& IMAGE_POST_CONVOLUTION_SCALE_BIAS
) {
3221 _mesa_scale_and_bias_rgba(ctx
, n
, rgba
,
3222 ctx
->Pixel
.PostConvolutionScale
[RCOMP
],
3223 ctx
->Pixel
.PostConvolutionScale
[GCOMP
],
3224 ctx
->Pixel
.PostConvolutionScale
[BCOMP
],
3225 ctx
->Pixel
.PostConvolutionScale
[ACOMP
],
3226 ctx
->Pixel
.PostConvolutionBias
[RCOMP
],
3227 ctx
->Pixel
.PostConvolutionBias
[GCOMP
],
3228 ctx
->Pixel
.PostConvolutionBias
[BCOMP
],
3229 ctx
->Pixel
.PostConvolutionBias
[ACOMP
]);
3231 /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
3232 if (transferOps
& IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT
) {
3233 _mesa_lookup_rgba(&ctx
->PostConvolutionColorTable
, n
, rgba
);
3235 /* color matrix transform */
3236 if (transferOps
& IMAGE_COLOR_MATRIX_BIT
) {
3237 _mesa_transform_rgba(ctx
, n
, rgba
);
3239 /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
3240 if (transferOps
& IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT
) {
3241 _mesa_lookup_rgba(&ctx
->PostColorMatrixColorTable
, n
, rgba
);
3243 /* update histogram count */
3244 if (transferOps
& IMAGE_HISTOGRAM_BIT
) {
3245 _mesa_update_histogram(ctx
, n
, (CONST
GLfloat (*)[4]) rgba
);
3248 if (transferOps
& IMAGE_MIN_MAX_BIT
) {
3249 _mesa_update_minmax(ctx
, n
, (CONST
GLfloat (*)[4]) rgba
);
3253 /* clamp to [0,1] */
3254 #if CHAN_TYPE != GL_FLOAT
3257 for (i
= 0; i
< n
; i
++) {
3258 rgba
[i
][RCOMP
] = CLAMP(rgba
[i
][RCOMP
], 0.0F
, 1.0F
);
3259 rgba
[i
][GCOMP
] = CLAMP(rgba
[i
][GCOMP
], 0.0F
, 1.0F
);
3260 rgba
[i
][BCOMP
] = CLAMP(rgba
[i
][BCOMP
], 0.0F
, 1.0F
);
3261 rgba
[i
][ACOMP
] = CLAMP(rgba
[i
][ACOMP
], 0.0F
, 1.0F
);
3266 /* Now determine which color channels we need to produce.
3267 * And determine the dest index (offset) within each color tuple.
3269 switch (dstFormat
) {
3272 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= -1;
3273 dstLuminanceIndex
= dstIntensityIndex
= -1;
3276 dstLuminanceIndex
= 0;
3277 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= dstAlphaIndex
= -1;
3278 dstIntensityIndex
= -1;
3280 case GL_LUMINANCE_ALPHA
:
3281 dstLuminanceIndex
= 0;
3283 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= -1;
3284 dstIntensityIndex
= -1;
3287 dstIntensityIndex
= 0;
3288 dstRedIndex
= dstGreenIndex
= dstBlueIndex
= dstAlphaIndex
= -1;
3289 dstLuminanceIndex
= -1;
3295 dstAlphaIndex
= dstLuminanceIndex
= dstIntensityIndex
= -1;
3302 dstLuminanceIndex
= dstIntensityIndex
= -1;
3305 _mesa_problem(ctx
, "bad dstFormat in _mesa_unpack_float_color_span()");
3306 UNDEFARRAY(rgba
); /* mac 32k limitation */
3310 /* Now pack results in the requested dstFormat */
3311 if (dstRedIndex
>= 0) {
3312 GLfloat
*dst
= dest
;
3314 for (i
= 0; i
< n
; i
++) {
3315 dst
[dstRedIndex
] = rgba
[i
][RCOMP
];
3316 dst
+= dstComponents
;
3320 if (dstGreenIndex
>= 0) {
3321 GLfloat
*dst
= dest
;
3323 for (i
= 0; i
< n
; i
++) {
3324 dst
[dstGreenIndex
] = rgba
[i
][GCOMP
];
3325 dst
+= dstComponents
;
3329 if (dstBlueIndex
>= 0) {
3330 GLfloat
*dst
= dest
;
3332 for (i
= 0; i
< n
; i
++) {
3333 dst
[dstBlueIndex
] = rgba
[i
][BCOMP
];
3334 dst
+= dstComponents
;
3338 if (dstAlphaIndex
>= 0) {
3339 GLfloat
*dst
= dest
;
3341 for (i
= 0; i
< n
; i
++) {
3342 dst
[dstAlphaIndex
] = rgba
[i
][ACOMP
];
3343 dst
+= dstComponents
;
3347 if (dstIntensityIndex
>= 0) {
3348 GLfloat
*dst
= dest
;
3350 assert(dstIntensityIndex
== 0);
3351 assert(dstComponents
== 1);
3352 for (i
= 0; i
< n
; i
++) {
3353 /* Intensity comes from red channel */
3354 dst
[i
] = rgba
[i
][RCOMP
];
3358 if (dstLuminanceIndex
>= 0) {
3359 GLfloat
*dst
= dest
;
3361 assert(dstLuminanceIndex
== 0);
3362 for (i
= 0; i
< n
; i
++) {
3363 /* Luminance comes from red channel */
3364 dst
[0] = rgba
[i
][RCOMP
];
3365 dst
+= dstComponents
;
3368 UNDEFARRAY(rgba
); /* mac 32k limitation */
3374 * Unpack a row of color index data from a client buffer according to
3375 * the pixel unpacking parameters.
3376 * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.
3378 * Args: ctx - the context
3379 * n - number of pixels
3380 * dstType - destination data type
3381 * dest - destination array
3382 * srcType - source pixel type
3383 * source - source data pointer
3384 * srcPacking - pixel unpacking parameters
3385 * transferOps - the pixel transfer operations to apply
3388 _mesa_unpack_index_span( const GLcontext
*ctx
, GLuint n
,
3389 GLenum dstType
, GLvoid
*dest
,
3390 GLenum srcType
, const GLvoid
*source
,
3391 const struct gl_pixelstore_attrib
*srcPacking
,
3392 GLuint transferOps
)
3394 ASSERT(srcType
== GL_BITMAP
||
3395 srcType
== GL_UNSIGNED_BYTE
||
3396 srcType
== GL_BYTE
||
3397 srcType
== GL_UNSIGNED_SHORT
||
3398 srcType
== GL_SHORT
||
3399 srcType
== GL_UNSIGNED_INT
||
3400 srcType
== GL_INT
||
3401 srcType
== GL_HALF_FLOAT_NV
||
3402 srcType
== GL_FLOAT
);
3404 ASSERT(dstType
== GL_UNSIGNED_BYTE
||
3405 dstType
== GL_UNSIGNED_SHORT
||
3406 dstType
== GL_UNSIGNED_INT
);
3409 transferOps
&= (IMAGE_MAP_COLOR_BIT
| IMAGE_SHIFT_OFFSET_BIT
);
3412 * Try simple cases first
3414 if (transferOps
== 0 && srcType
== GL_UNSIGNED_BYTE
3415 && dstType
== GL_UNSIGNED_BYTE
) {
3416 MEMCPY(dest
, source
, n
* sizeof(GLubyte
));
3418 else if (transferOps
== 0 && srcType
== GL_UNSIGNED_INT
3419 && dstType
== GL_UNSIGNED_INT
&& !srcPacking
->SwapBytes
) {
3420 MEMCPY(dest
, source
, n
* sizeof(GLuint
));
3426 GLuint indexes
[MAX_WIDTH
];
3427 assert(n
<= MAX_WIDTH
);
3429 extract_uint_indexes(n
, indexes
, GL_COLOR_INDEX
, srcType
, source
,
3432 if (transferOps
& IMAGE_SHIFT_OFFSET_BIT
) {
3433 /* shift and offset indexes */
3434 _mesa_shift_and_offset_ci(ctx
, n
, indexes
);
3436 if (transferOps
& IMAGE_MAP_COLOR_BIT
) {
3437 /* Apply lookup table */
3438 _mesa_map_ci(ctx
, n
, indexes
);
3441 /* convert to dest type */
3443 case GL_UNSIGNED_BYTE
:
3445 GLubyte
*dst
= (GLubyte
*) dest
;
3447 for (i
= 0; i
< n
; i
++) {
3448 dst
[i
] = (GLubyte
) (indexes
[i
] & 0xff);
3452 case GL_UNSIGNED_SHORT
:
3454 GLuint
*dst
= (GLuint
*) dest
;
3456 for (i
= 0; i
< n
; i
++) {
3457 dst
[i
] = (GLushort
) (indexes
[i
] & 0xffff);
3461 case GL_UNSIGNED_INT
:
3462 MEMCPY(dest
, indexes
, n
* sizeof(GLuint
));
3465 _mesa_problem(ctx
, "bad dstType in _mesa_unpack_index_span");
3472 _mesa_pack_index_span( const GLcontext
*ctx
, GLuint n
,
3473 GLenum dstType
, GLvoid
*dest
, const GLuint
*source
,
3474 const struct gl_pixelstore_attrib
*dstPacking
,
3475 GLuint transferOps
)
3477 GLuint indexes
[MAX_WIDTH
];
3479 ASSERT(n
<= MAX_WIDTH
);
3481 transferOps
&= (IMAGE_MAP_COLOR_BIT
| IMAGE_SHIFT_OFFSET_BIT
);
3483 if (transferOps
& (IMAGE_MAP_COLOR_BIT
| IMAGE_SHIFT_OFFSET_BIT
)) {
3484 /* make a copy of input */
3485 MEMCPY(indexes
, source
, n
* sizeof(GLuint
));
3486 if (transferOps
& IMAGE_SHIFT_OFFSET_BIT
) {
3487 _mesa_shift_and_offset_ci( ctx
, n
, indexes
);
3489 if (transferOps
& IMAGE_MAP_COLOR_BIT
) {
3490 _mesa_map_ci(ctx
, n
, indexes
);
3496 case GL_UNSIGNED_BYTE
:
3498 GLubyte
*dst
= (GLubyte
*) dest
;
3500 for (i
= 0; i
< n
; i
++) {
3501 *dst
++ = (GLubyte
) source
[i
];
3507 GLbyte
*dst
= (GLbyte
*) dest
;
3509 for (i
= 0; i
< n
; i
++) {
3510 dst
[i
] = (GLbyte
) source
[i
];
3514 case GL_UNSIGNED_SHORT
:
3516 GLushort
*dst
= (GLushort
*) dest
;
3518 for (i
= 0; i
< n
; i
++) {
3519 dst
[i
] = (GLushort
) source
[i
];
3521 if (dstPacking
->SwapBytes
) {
3522 _mesa_swap2( (GLushort
*) dst
, n
);
3528 GLshort
*dst
= (GLshort
*) dest
;
3530 for (i
= 0; i
< n
; i
++) {
3531 dst
[i
] = (GLshort
) source
[i
];
3533 if (dstPacking
->SwapBytes
) {
3534 _mesa_swap2( (GLushort
*) dst
, n
);
3538 case GL_UNSIGNED_INT
:
3540 GLuint
*dst
= (GLuint
*) dest
;
3542 for (i
= 0; i
< n
; i
++) {
3543 dst
[i
] = (GLuint
) source
[i
];
3545 if (dstPacking
->SwapBytes
) {
3546 _mesa_swap4( (GLuint
*) dst
, n
);
3552 GLint
*dst
= (GLint
*) dest
;
3554 for (i
= 0; i
< n
; i
++) {
3555 dst
[i
] = (GLint
) source
[i
];
3557 if (dstPacking
->SwapBytes
) {
3558 _mesa_swap4( (GLuint
*) dst
, n
);
3564 GLfloat
*dst
= (GLfloat
*) dest
;
3566 for (i
= 0; i
< n
; i
++) {
3567 dst
[i
] = (GLfloat
) source
[i
];
3569 if (dstPacking
->SwapBytes
) {
3570 _mesa_swap4( (GLuint
*) dst
, n
);
3574 case GL_HALF_FLOAT_NV
:
3576 GLhalfNV
*dst
= (GLhalfNV
*) dest
;
3578 for (i
= 0; i
< n
; i
++) {
3579 dst
[i
] = _mesa_float_to_half((GLfloat
) source
[i
]);
3581 if (dstPacking
->SwapBytes
) {
3582 _mesa_swap2( (GLushort
*) dst
, n
);
3587 _mesa_problem(ctx
, "bad type in _mesa_pack_index_span");
3593 * Unpack a row of stencil data from a client buffer according to
3594 * the pixel unpacking parameters.
3595 * This is (or will be) used by glDrawPixels
3597 * Args: ctx - the context
3598 * n - number of pixels
3599 * dstType - destination data type
3600 * dest - destination array
3601 * srcType - source pixel type
3602 * source - source data pointer
3603 * srcPacking - pixel unpacking parameters
3604 * transferOps - apply offset/bias/lookup ops?
3607 _mesa_unpack_stencil_span( const GLcontext
*ctx
, GLuint n
,
3608 GLenum dstType
, GLvoid
*dest
,
3609 GLenum srcType
, const GLvoid
*source
,
3610 const struct gl_pixelstore_attrib
*srcPacking
,
3611 GLuint transferOps
)
3613 ASSERT(srcType
== GL_BITMAP
||
3614 srcType
== GL_UNSIGNED_BYTE
||
3615 srcType
== GL_BYTE
||
3616 srcType
== GL_UNSIGNED_SHORT
||
3617 srcType
== GL_SHORT
||
3618 srcType
== GL_UNSIGNED_INT
||
3619 srcType
== GL_INT
||
3620 srcType
== GL_HALF_FLOAT_NV
||
3621 srcType
== GL_FLOAT
);
3623 ASSERT(dstType
== GL_UNSIGNED_BYTE
||
3624 dstType
== GL_UNSIGNED_SHORT
||
3625 dstType
== GL_UNSIGNED_INT
);
3627 /* only shift and offset apply to stencil */
3628 transferOps
&= IMAGE_SHIFT_OFFSET_BIT
;
3631 * Try simple cases first
3633 if (transferOps
== 0 &&
3634 srcType
== GL_UNSIGNED_BYTE
&&
3635 dstType
== GL_UNSIGNED_BYTE
) {
3636 MEMCPY(dest
, source
, n
* sizeof(GLubyte
));
3638 else if (transferOps
== 0 &&
3639 srcType
== GL_UNSIGNED_INT
&&
3640 dstType
== GL_UNSIGNED_INT
&&
3641 !srcPacking
->SwapBytes
) {
3642 MEMCPY(dest
, source
, n
* sizeof(GLuint
));
3648 GLuint indexes
[MAX_WIDTH
];
3649 assert(n
<= MAX_WIDTH
);
3651 extract_uint_indexes(n
, indexes
, GL_COLOR_INDEX
, srcType
, source
,
3655 if (transferOps
& IMAGE_SHIFT_OFFSET_BIT
) {
3656 /* shift and offset indexes */
3657 _mesa_shift_and_offset_ci(ctx
, n
, indexes
);
3660 if (ctx
->Pixel
.MapStencilFlag
) {
3661 /* Apply stencil lookup table */
3662 GLuint mask
= ctx
->Pixel
.MapStoSsize
- 1;
3665 indexes
[i
] = ctx
->Pixel
.MapStoS
[ indexes
[i
] & mask
];
3670 /* convert to dest type */
3672 case GL_UNSIGNED_BYTE
:
3674 GLubyte
*dst
= (GLubyte
*) dest
;
3676 for (i
= 0; i
< n
; i
++) {
3677 dst
[i
] = (GLubyte
) (indexes
[i
] & 0xff);
3681 case GL_UNSIGNED_SHORT
:
3683 GLuint
*dst
= (GLuint
*) dest
;
3685 for (i
= 0; i
< n
; i
++) {
3686 dst
[i
] = (GLushort
) (indexes
[i
] & 0xffff);
3690 case GL_UNSIGNED_INT
:
3691 MEMCPY(dest
, indexes
, n
* sizeof(GLuint
));
3694 _mesa_problem(ctx
, "bad dstType in _mesa_unpack_stencil_span");
3701 _mesa_pack_stencil_span( const GLcontext
*ctx
, GLuint n
,
3702 GLenum dstType
, GLvoid
*dest
, const GLstencil
*source
,
3703 const struct gl_pixelstore_attrib
*dstPacking
)
3705 GLstencil stencil
[MAX_WIDTH
];
3707 ASSERT(n
<= MAX_WIDTH
);
3709 if (ctx
->Pixel
.IndexShift
|| ctx
->Pixel
.IndexOffset
||
3710 ctx
->Pixel
.MapStencilFlag
) {
3711 /* make a copy of input */
3712 MEMCPY(stencil
, source
, n
* sizeof(GLstencil
));
3713 if (ctx
->Pixel
.IndexShift
|| ctx
->Pixel
.IndexOffset
) {
3714 _mesa_shift_and_offset_stencil( ctx
, n
, stencil
);
3716 if (ctx
->Pixel
.MapStencilFlag
) {
3717 _mesa_map_stencil( ctx
, n
, stencil
);
3723 case GL_UNSIGNED_BYTE
:
3724 if (sizeof(GLstencil
) == 8) {
3725 MEMCPY( dest
, source
, n
);
3728 GLubyte
*dst
= (GLubyte
*) dest
;
3731 dst
[i
] = (GLubyte
) source
[i
];
3736 if (sizeof(GLstencil
) == 8) {
3737 MEMCPY( dest
, source
, n
);
3740 GLbyte
*dst
= (GLbyte
*) dest
;
3743 dst
[i
] = (GLbyte
) source
[i
];
3747 case GL_UNSIGNED_SHORT
:
3749 GLushort
*dst
= (GLushort
*) dest
;
3752 dst
[i
] = (GLushort
) source
[i
];
3754 if (dstPacking
->SwapBytes
) {
3755 _mesa_swap2( (GLushort
*) dst
, n
);
3761 GLshort
*dst
= (GLshort
*) dest
;
3764 dst
[i
] = (GLshort
) source
[i
];
3766 if (dstPacking
->SwapBytes
) {
3767 _mesa_swap2( (GLushort
*) dst
, n
);
3771 case GL_UNSIGNED_INT
:
3773 GLuint
*dst
= (GLuint
*) dest
;
3776 dst
[i
] = (GLuint
) source
[i
];
3778 if (dstPacking
->SwapBytes
) {
3779 _mesa_swap4( (GLuint
*) dst
, n
);
3785 GLint
*dst
= (GLint
*) dest
;
3788 *dst
++ = (GLint
) source
[i
];
3790 if (dstPacking
->SwapBytes
) {
3791 _mesa_swap4( (GLuint
*) dst
, n
);
3797 GLfloat
*dst
= (GLfloat
*) dest
;
3800 dst
[i
] = (GLfloat
) source
[i
];
3802 if (dstPacking
->SwapBytes
) {
3803 _mesa_swap4( (GLuint
*) dst
, n
);
3807 case GL_HALF_FLOAT_NV
:
3809 GLhalfNV
*dst
= (GLhalfNV
*) dest
;
3812 dst
[i
] = _mesa_float_to_half( (float) source
[i
] );
3814 if (dstPacking
->SwapBytes
) {
3815 _mesa_swap2( (GLushort
*) dst
, n
);
3820 if (dstPacking
->LsbFirst
) {
3821 GLubyte
*dst
= (GLubyte
*) dest
;
3824 for (i
= 0; i
< n
; i
++) {
3827 *dst
|= ((source
[i
] != 0) << shift
);
3836 GLubyte
*dst
= (GLubyte
*) dest
;
3839 for (i
= 0; i
< n
; i
++) {
3842 *dst
|= ((source
[i
] != 0) << shift
);
3852 _mesa_problem(ctx
, "bad type in _mesa_pack_index_span");
3858 _mesa_unpack_depth_span( const GLcontext
*ctx
, GLuint n
, GLfloat
*dest
,
3859 GLenum srcType
, const GLvoid
*source
,
3860 const struct gl_pixelstore_attrib
*srcPacking
)
3866 const GLubyte
*src
= (const GLubyte
*) source
;
3867 for (i
= 0; i
< n
; i
++) {
3868 dest
[i
] = BYTE_TO_FLOAT(src
[i
]);
3872 case GL_UNSIGNED_BYTE
:
3875 const GLubyte
*src
= (const GLubyte
*) source
;
3876 for (i
= 0; i
< n
; i
++) {
3877 dest
[i
] = UBYTE_TO_FLOAT(src
[i
]);
3884 const GLshort
*src
= (const GLshort
*) source
;
3885 for (i
= 0; i
< n
; i
++) {
3886 dest
[i
] = SHORT_TO_FLOAT(src
[i
]);
3890 case GL_UNSIGNED_SHORT
:
3893 const GLushort
*src
= (const GLushort
*) source
;
3894 for (i
= 0; i
< n
; i
++) {
3895 dest
[i
] = USHORT_TO_FLOAT(src
[i
]);
3902 const GLint
*src
= (const GLint
*) source
;
3903 for (i
= 0; i
< n
; i
++) {
3904 dest
[i
] = INT_TO_FLOAT(src
[i
]);
3908 case GL_UNSIGNED_INT
:
3911 const GLuint
*src
= (const GLuint
*) source
;
3912 for (i
= 0; i
< n
; i
++) {
3913 dest
[i
] = UINT_TO_FLOAT(src
[i
]);
3918 MEMCPY(dest
, source
, n
* sizeof(GLfloat
));
3920 case GL_HALF_FLOAT_NV
:
3923 const GLhalfNV
*src
= (const GLhalfNV
*) source
;
3924 for (i
= 0; i
< n
; i
++) {
3925 dest
[i
] = _mesa_half_to_float(src
[i
]);
3930 _mesa_problem(NULL
, "bad type in _mesa_unpack_depth_span()");
3935 /* apply depth scale and bias and clamp to [0,1] */
3936 if (ctx
->Pixel
.DepthScale
!= 1.0 || ctx
->Pixel
.DepthBias
!= 0.0) {
3938 for (i
= 0; i
< n
; i
++) {
3939 GLfloat d
= dest
[i
] * ctx
->Pixel
.DepthScale
+ ctx
->Pixel
.DepthBias
;
3940 dest
[i
] = CLAMP(d
, 0.0F
, 1.0F
);
3947 * Pack an array of depth values. The values are floats in [0,1].
3950 _mesa_pack_depth_span( const GLcontext
*ctx
, GLuint n
, GLvoid
*dest
,
3951 GLenum dstType
, const GLfloat
*depthSpan
,
3952 const struct gl_pixelstore_attrib
*dstPacking
)
3954 GLfloat depthCopy
[MAX_WIDTH
];
3955 const GLboolean bias_or_scale
= ctx
->Pixel
.DepthBias
!= 0.0 ||
3956 ctx
->Pixel
.DepthScale
!= 1.0;
3958 ASSERT(n
<= MAX_WIDTH
);
3960 if (bias_or_scale
) {
3962 for (i
= 0; i
< n
; i
++) {
3964 d
= depthSpan
[i
] * ctx
->Pixel
.DepthScale
+ ctx
->Pixel
.DepthBias
;
3965 depthCopy
[i
] = CLAMP(d
, 0.0F
, 1.0F
);
3967 depthSpan
= depthCopy
;
3971 case GL_UNSIGNED_BYTE
:
3973 GLubyte
*dst
= (GLubyte
*) dest
;
3975 for (i
= 0; i
< n
; i
++) {
3976 dst
[i
] = FLOAT_TO_UBYTE( depthSpan
[i
] );
3982 GLbyte
*dst
= (GLbyte
*) dest
;
3984 for (i
= 0; i
< n
; i
++) {
3985 dst
[i
] = FLOAT_TO_BYTE( depthSpan
[i
] );
3989 case GL_UNSIGNED_SHORT
:
3991 GLushort
*dst
= (GLushort
*) dest
;
3993 for (i
= 0; i
< n
; i
++) {
3994 dst
[i
] = FLOAT_TO_USHORT( depthSpan
[i
] );
3996 if (dstPacking
->SwapBytes
) {
3997 _mesa_swap2( (GLushort
*) dst
, n
);
4003 GLshort
*dst
= (GLshort
*) dest
;
4005 for (i
= 0; i
< n
; i
++) {
4006 dst
[i
] = FLOAT_TO_SHORT( depthSpan
[i
] );
4008 if (dstPacking
->SwapBytes
) {
4009 _mesa_swap2( (GLushort
*) dst
, n
);
4013 case GL_UNSIGNED_INT
:
4015 GLuint
*dst
= (GLuint
*) dest
;
4017 for (i
= 0; i
< n
; i
++) {
4018 dst
[i
] = FLOAT_TO_UINT( depthSpan
[i
] );
4020 if (dstPacking
->SwapBytes
) {
4021 _mesa_swap4( (GLuint
*) dst
, n
);
4027 GLint
*dst
= (GLint
*) dest
;
4029 for (i
= 0; i
< n
; i
++) {
4030 dst
[i
] = FLOAT_TO_INT( depthSpan
[i
] );
4032 if (dstPacking
->SwapBytes
) {
4033 _mesa_swap4( (GLuint
*) dst
, n
);
4039 GLfloat
*dst
= (GLfloat
*) dest
;
4041 for (i
= 0; i
< n
; i
++) {
4042 dst
[i
] = depthSpan
[i
];
4044 if (dstPacking
->SwapBytes
) {
4045 _mesa_swap4( (GLuint
*) dst
, n
);
4049 case GL_HALF_FLOAT_NV
:
4051 GLhalfNV
*dst
= (GLhalfNV
*) dest
;
4053 for (i
= 0; i
< n
; i
++) {
4054 dst
[i
] = _mesa_float_to_half(depthSpan
[i
]);
4056 if (dstPacking
->SwapBytes
) {
4057 _mesa_swap2( (GLushort
*) dst
, n
);
4062 _mesa_problem(ctx
, "bad type in _mesa_pack_depth_span");
4068 * Unpack image data. Apply byteswapping, byte flipping (bitmap).
4069 * Return all image data in a contiguous block.
4072 _mesa_unpack_image( GLsizei width
, GLsizei height
, GLsizei depth
,
4073 GLenum format
, GLenum type
, const GLvoid
*pixels
,
4074 const struct gl_pixelstore_attrib
*unpack
)
4076 GLint bytesPerRow
, compsPerRow
;
4077 GLboolean flipBytes
, swap2
, swap4
;
4080 return NULL
; /* not necessarily an error */
4082 if (width
<= 0 || height
<= 0 || depth
<= 0)
4083 return NULL
; /* generate error later */
4085 if (format
== GL_BITMAP
) {
4086 bytesPerRow
= (width
+ 7) >> 3;
4087 flipBytes
= !unpack
->LsbFirst
;
4088 swap2
= swap4
= GL_FALSE
;
4092 const GLint bytesPerPixel
= _mesa_bytes_per_pixel(format
, type
);
4093 const GLint components
= _mesa_components_in_format(format
);
4095 if (bytesPerPixel
<= 0 || components
<= 0)
4096 return NULL
; /* bad format or type. generate error later */
4097 bytesPerRow
= bytesPerPixel
* width
;
4098 bytesPerComp
= bytesPerPixel
/ components
;
4099 flipBytes
= GL_FALSE
;
4100 swap2
= (bytesPerComp
== 2) && unpack
->SwapBytes
;
4101 swap4
= (bytesPerComp
== 4) && unpack
->SwapBytes
;
4102 compsPerRow
= components
* width
;
4103 assert(compsPerRow
>= width
);
4107 GLubyte
*destBuffer
= (GLubyte
*) MALLOC(bytesPerRow
* height
* depth
);
4111 return NULL
; /* generate GL_OUT_OF_MEMORY later */
4114 for (img
= 0; img
< depth
; img
++) {
4115 for (row
= 0; row
< height
; row
++) {
4116 const GLvoid
*src
= _mesa_image_address(unpack
, pixels
,
4117 width
, height
, format
, type
, img
, row
, 0);
4118 MEMCPY(dst
, src
, bytesPerRow
);
4119 /* byte flipping/swapping */
4121 flip_bytes((GLubyte
*) dst
, bytesPerRow
);
4124 _mesa_swap2((GLushort
*) dst
, compsPerRow
);
4127 _mesa_swap4((GLuint
*) dst
, compsPerRow
);