projects / mesa.git / blob
? search:


de6ab2717cbd8e5886b0af2d97fa69bb44aaebab
[mesa.git] / src / mesa / main / pack.c
1 /*
2 * Mesa 3-D graphics library
3 *
4 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved.
5 * Copyright (C) 2009-2010 VMware, Inc. All Rights Reserved.
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THEA AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 */
24
25
26 /**
27 * \file pack.c
28 * Image and pixel span packing and unpacking.
29 */
30
31
32 /*
33 * XXX: MSVC takes forever to compile this module for x86_64 unless we disable
34 * this global optimization.
35 *
36 * See also:
37 * - http://msdn.microsoft.com/en-us/library/1yk3ydd7.aspx
38 * - http://msdn.microsoft.com/en-us/library/chh3fb0k.aspx
39 */
40 #if defined(_MSC_VER) && defined(_M_X64)
41 # pragma optimize( "g", off )
42 #endif
43
44
45 #include "glheader.h"
46 #include "colormac.h"
47 #include "enums.h"
48 #include "image.h"
49 #include "imports.h"
50 #include "macros.h"
51 #include "mtypes.h"
52 #include "pack.h"
53 #include "pixeltransfer.h"
54 #include "imports.h"
55 #include "glformats.h"
56 #include "../../gallium/auxiliary/util/u_format_rgb9e5.h"
57 #include "../../gallium/auxiliary/util/u_format_r11g11b10f.h"
58 #include "format_utils.h"
59 #include "format_pack.h"
60
61
62 /**
63 * Flip the 8 bits in each byte of the given array.
64 *
65 * \param p array.
66 * \param n number of bytes.
67 *
68 * \todo try this trick to flip bytes someday:
69 * \code
70 * v = ((v & 0x55555555) << 1) | ((v >> 1) & 0x55555555);
71 * v = ((v & 0x33333333) << 2) | ((v >> 2) & 0x33333333);
72 * v = ((v & 0x0f0f0f0f) << 4) | ((v >> 4) & 0x0f0f0f0f);
73 * \endcode
74 */
75 static void
76 flip_bytes( GLubyte *p, GLuint n )
77 {
78 GLuint i, a, b;
79 for (i = 0; i < n; i++) {
80 b = (GLuint) p[i]; /* words are often faster than bytes */
81 a = ((b & 0x01) << 7) |
82 ((b & 0x02) << 5) |
83 ((b & 0x04) << 3) |
84 ((b & 0x08) << 1) |
85 ((b & 0x10) >> 1) |
86 ((b & 0x20) >> 3) |
87 ((b & 0x40) >> 5) |
88 ((b & 0x80) >> 7);
89 p[i] = (GLubyte) a;
90 }
91 }
92
93
94
95 /*
96 * Unpack a 32x32 pixel polygon stipple from user memory using the
97 * current pixel unpack settings.
98 */
99 void
100 _mesa_unpack_polygon_stipple( const GLubyte *pattern, GLuint dest[32],
101 const struct gl_pixelstore_attrib *unpacking )
102 {
103 GLubyte *ptrn = (GLubyte *) _mesa_unpack_bitmap(32, 32, pattern, unpacking);
104 if (ptrn) {
105 /* Convert pattern from GLubytes to GLuints and handle big/little
106 * endian differences
107 */
108 GLubyte *p = ptrn;
109 GLint i;
110 for (i = 0; i < 32; i++) {
111 dest[i] = (p[0] << 24)
112 | (p[1] << 16)
113 | (p[2] << 8)
114 | (p[3] );
115 p += 4;
116 }
117 free(ptrn);
118 }
119 }
120
121
122 /*
123 * Pack polygon stipple into user memory given current pixel packing
124 * settings.
125 */
126 void
127 _mesa_pack_polygon_stipple( const GLuint pattern[32], GLubyte *dest,
128 const struct gl_pixelstore_attrib *packing )
129 {
130 /* Convert pattern from GLuints to GLubytes to handle big/little
131 * endian differences.
132 */
133 GLubyte ptrn[32*4];
134 GLint i;
135 for (i = 0; i < 32; i++) {
136 ptrn[i * 4 + 0] = (GLubyte) ((pattern[i] >> 24) & 0xff);
137 ptrn[i * 4 + 1] = (GLubyte) ((pattern[i] >> 16) & 0xff);
138 ptrn[i * 4 + 2] = (GLubyte) ((pattern[i] >> 8 ) & 0xff);
139 ptrn[i * 4 + 3] = (GLubyte) ((pattern[i] ) & 0xff);
140 }
141
142 _mesa_pack_bitmap(32, 32, ptrn, dest, packing);
143 }
144
145
146 /*
147 * Unpack bitmap data. Resulting data will be in most-significant-bit-first
148 * order with row alignment = 1 byte.
149 */
150 GLvoid *
151 _mesa_unpack_bitmap( GLint width, GLint height, const GLubyte *pixels,
152 const struct gl_pixelstore_attrib *packing )
153 {
154 GLint bytes, row, width_in_bytes;
155 GLubyte *buffer, *dst;
156
157 if (!pixels)
158 return NULL;
159
160 /* Alloc dest storage */
161 bytes = ((width + 7) / 8 * height);
162 buffer = malloc( bytes );
163 if (!buffer)
164 return NULL;
165
166 width_in_bytes = CEILING( width, 8 );
167 dst = buffer;
168 for (row = 0; row < height; row++) {
169 const GLubyte *src = (const GLubyte *)
170 _mesa_image_address2d(packing, pixels, width, height,
171 GL_COLOR_INDEX, GL_BITMAP, row, 0);
172 if (!src) {
173 free(buffer);
174 return NULL;
175 }
176
177 if ((packing->SkipPixels & 7) == 0) {
178 memcpy( dst, src, width_in_bytes );
179 if (packing->LsbFirst) {
180 flip_bytes( dst, width_in_bytes );
181 }
182 }
183 else {
184 /* handling SkipPixels is a bit tricky (no pun intended!) */
185 GLint i;
186 if (packing->LsbFirst) {
187 GLubyte srcMask = 1 << (packing->SkipPixels & 0x7);
188 GLubyte dstMask = 128;
189 const GLubyte *s = src;
190 GLubyte *d = dst;
191 *d = 0;
192 for (i = 0; i < width; i++) {
193 if (*s & srcMask) {
194 *d |= dstMask;
195 }
196 if (srcMask == 128) {
197 srcMask = 1;
198 s++;
199 }
200 else {
201 srcMask = srcMask << 1;
202 }
203 if (dstMask == 1) {
204 dstMask = 128;
205 d++;
206 *d = 0;
207 }
208 else {
209 dstMask = dstMask >> 1;
210 }
211 }
212 }
213 else {
214 GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7);
215 GLubyte dstMask = 128;
216 const GLubyte *s = src;
217 GLubyte *d = dst;
218 *d = 0;
219 for (i = 0; i < width; i++) {
220 if (*s & srcMask) {
221 *d |= dstMask;
222 }
223 if (srcMask == 1) {
224 srcMask = 128;
225 s++;
226 }
227 else {
228 srcMask = srcMask >> 1;
229 }
230 if (dstMask == 1) {
231 dstMask = 128;
232 d++;
233 *d = 0;
234 }
235 else {
236 dstMask = dstMask >> 1;
237 }
238 }
239 }
240 }
241 dst += width_in_bytes;
242 }
243
244 return buffer;
245 }
246
247
248 /*
249 * Pack bitmap data.
250 */
251 void
252 _mesa_pack_bitmap( GLint width, GLint height, const GLubyte *source,
253 GLubyte *dest, const struct gl_pixelstore_attrib *packing )
254 {
255 GLint row, width_in_bytes;
256 const GLubyte *src;
257
258 if (!source)
259 return;
260
261 width_in_bytes = CEILING( width, 8 );
262 src = source;
263 for (row = 0; row < height; row++) {
264 GLubyte *dst = (GLubyte *) _mesa_image_address2d(packing, dest,
265 width, height, GL_COLOR_INDEX, GL_BITMAP, row, 0);
266 if (!dst)
267 return;
268
269 if ((packing->SkipPixels & 7) == 0) {
270 memcpy( dst, src, width_in_bytes );
271 if (packing->LsbFirst) {
272 flip_bytes( dst, width_in_bytes );
273 }
274 }
275 else {
276 /* handling SkipPixels is a bit tricky (no pun intended!) */
277 GLint i;
278 if (packing->LsbFirst) {
279 GLubyte srcMask = 128;
280 GLubyte dstMask = 1 << (packing->SkipPixels & 0x7);
281 const GLubyte *s = src;
282 GLubyte *d = dst;
283 *d = 0;
284 for (i = 0; i < width; i++) {
285 if (*s & srcMask) {
286 *d |= dstMask;
287 }
288 if (srcMask == 1) {
289 srcMask = 128;
290 s++;
291 }
292 else {
293 srcMask = srcMask >> 1;
294 }
295 if (dstMask == 128) {
296 dstMask = 1;
297 d++;
298 *d = 0;
299 }
300 else {
301 dstMask = dstMask << 1;
302 }
303 }
304 }
305 else {
306 GLubyte srcMask = 128;
307 GLubyte dstMask = 128 >> (packing->SkipPixels & 0x7);
308 const GLubyte *s = src;
309 GLubyte *d = dst;
310 *d = 0;
311 for (i = 0; i < width; i++) {
312 if (*s & srcMask) {
313 *d |= dstMask;
314 }
315 if (srcMask == 1) {
316 srcMask = 128;
317 s++;
318 }
319 else {
320 srcMask = srcMask >> 1;
321 }
322 if (dstMask == 1) {
323 dstMask = 128;
324 d++;
325 *d = 0;
326 }
327 else {
328 dstMask = dstMask >> 1;
329 }
330 }
331 }
332 }
333 src += width_in_bytes;
334 }
335 }
336
337
338 /**
339 * Get indexes of color components for a basic color format, such as
340 * GL_RGBA, GL_RED, GL_LUMINANCE_ALPHA, etc. Return -1 for indexes
341 * that do not apply.
342 */
343 static void
344 get_component_indexes(GLenum format,
345 GLint *redIndex,
346 GLint *greenIndex,
347 GLint *blueIndex,
348 GLint *alphaIndex,
349 GLint *luminanceIndex,
350 GLint *intensityIndex)
351 {
352 *redIndex = -1;
353 *greenIndex = -1;
354 *blueIndex = -1;
355 *alphaIndex = -1;
356 *luminanceIndex = -1;
357 *intensityIndex = -1;
358
359 switch (format) {
360 case GL_LUMINANCE:
361 case GL_LUMINANCE_INTEGER_EXT:
362 *luminanceIndex = 0;
363 break;
364 case GL_LUMINANCE_ALPHA:
365 case GL_LUMINANCE_ALPHA_INTEGER_EXT:
366 *luminanceIndex = 0;
367 *alphaIndex = 1;
368 break;
369 case GL_INTENSITY:
370 *intensityIndex = 0;
371 break;
372 case GL_RED:
373 case GL_RED_INTEGER_EXT:
374 *redIndex = 0;
375 break;
376 case GL_GREEN:
377 case GL_GREEN_INTEGER_EXT:
378 *greenIndex = 0;
379 break;
380 case GL_BLUE:
381 case GL_BLUE_INTEGER_EXT:
382 *blueIndex = 0;
383 break;
384 case GL_ALPHA:
385 case GL_ALPHA_INTEGER_EXT:
386 *alphaIndex = 0;
387 break;
388 case GL_RG:
389 case GL_RG_INTEGER:
390 *redIndex = 0;
391 *greenIndex = 1;
392 break;
393 case GL_RGB:
394 case GL_RGB_INTEGER_EXT:
395 *redIndex = 0;
396 *greenIndex = 1;
397 *blueIndex = 2;
398 break;
399 case GL_BGR:
400 case GL_BGR_INTEGER_EXT:
401 *blueIndex = 0;
402 *greenIndex = 1;
403 *redIndex = 2;
404 break;
405 case GL_RGBA:
406 case GL_RGBA_INTEGER_EXT:
407 *redIndex = 0;
408 *greenIndex = 1;
409 *blueIndex = 2;
410 *alphaIndex = 3;
411 break;
412 case GL_BGRA:
413 case GL_BGRA_INTEGER:
414 *redIndex = 2;
415 *greenIndex = 1;
416 *blueIndex = 0;
417 *alphaIndex = 3;
418 break;
419 case GL_ABGR_EXT:
420 *redIndex = 3;
421 *greenIndex = 2;
422 *blueIndex = 1;
423 *alphaIndex = 0;
424 break;
425 default:
426 assert(0 && "bad format in get_component_indexes()");
427 }
428 }
429
430
431
432 /**
433 * For small integer types, return the min and max possible values.
434 * Used for clamping floats to unscaled integer types.
435 * \return GL_TRUE if type is handled, GL_FALSE otherwise.
436 */
437 static GLboolean
438 get_type_min_max(GLenum type, GLfloat *min, GLfloat *max)
439 {
440 switch (type) {
441 case GL_BYTE:
442 *min = -128.0;
443 *max = 127.0;
444 return GL_TRUE;
445 case GL_UNSIGNED_BYTE:
446 *min = 0.0;
447 *max = 255.0;
448 return GL_TRUE;
449 case GL_SHORT:
450 *min = -32768.0;
451 *max = 32767.0;
452 return GL_TRUE;
453 case GL_UNSIGNED_SHORT:
454 *min = 0.0;
455 *max = 65535.0;
456 return GL_TRUE;
457 default:
458 return GL_FALSE;
459 }
460 }
461
462 /* Customization of unsigned integer packing.
463 */
464 #define SRC_TYPE GLuint
465
466 #define DST_TYPE GLuint
467 #define SRC_CONVERT(x) (x)
468 #define FN_NAME pack_uint_from_uint_rgba
469 #include "pack_tmp.h"
470 #undef DST_TYPE
471 #undef SRC_CONVERT
472 #undef FN_NAME
473
474 #define DST_TYPE GLint
475 #define SRC_CONVERT(x) MIN2(x, 0x7fffffff)
476 #define FN_NAME pack_int_from_uint_rgba
477 #include "pack_tmp.h"
478 #undef DST_TYPE
479 #undef SRC_CONVERT
480 #undef FN_NAME
481
482 #define DST_TYPE GLushort
483 #define SRC_CONVERT(x) MIN2(x, 0xffff)
484 #define FN_NAME pack_ushort_from_uint_rgba
485 #include "pack_tmp.h"
486 #undef DST_TYPE
487 #undef SRC_CONVERT
488 #undef FN_NAME
489
490 #define DST_TYPE GLshort
491 #define SRC_CONVERT(x) CLAMP((int)x, -32768, 32767)
492 #define FN_NAME pack_short_from_uint_rgba
493 #include "pack_tmp.h"
494 #undef DST_TYPE
495 #undef SRC_CONVERT
496 #undef FN_NAME
497
498 #define DST_TYPE GLubyte
499 #define SRC_CONVERT(x) MIN2(x, 0xff)
500 #define FN_NAME pack_ubyte_from_uint_rgba
501 #include "pack_tmp.h"
502 #undef DST_TYPE
503 #undef SRC_CONVERT
504 #undef FN_NAME
505
506 #define DST_TYPE GLbyte
507 #define SRC_CONVERT(x) CLAMP((int)x, -128, 127)
508 #define FN_NAME pack_byte_from_uint_rgba
509 #include "pack_tmp.h"
510 #undef DST_TYPE
511 #undef SRC_CONVERT
512 #undef FN_NAME
513
514 #undef SRC_TYPE
515
516 static void
517 _pack_rgba_span_from_uints_problem(struct gl_context *ctx,
518 GLenum dstFormat, GLenum dstType)
519 {
520 _mesa_problem(ctx,
521 "Unsupported type (%s) / format (%s) "
522 "in _mesa_pack_rgba_span_from_uints",
523 _mesa_lookup_enum_by_nr(dstType),
524 _mesa_lookup_enum_by_nr(dstFormat));
525 }
526
527 void
528 _mesa_pack_rgba_span_from_uints(struct gl_context *ctx, GLuint n, GLuint rgba[][4],
529 GLenum dstFormat, GLenum dstType,
530 GLvoid *dstAddr)
531 {
532 uint32_t dstMesaFormat;
533
534 switch(dstType) {
535 case GL_UNSIGNED_INT:
536 pack_uint_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, NULL, n);
537 break;
538 case GL_INT:
539 pack_int_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, NULL, n);
540 break;
541 case GL_UNSIGNED_SHORT:
542 pack_ushort_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, NULL, n);
543 break;
544 case GL_SHORT:
545 pack_short_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, NULL, n);
546 break;
547 case GL_UNSIGNED_BYTE:
548 pack_ubyte_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, NULL, n);
549 break;
550 case GL_BYTE:
551 pack_byte_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, NULL, n);
552 break;
553 case GL_UNSIGNED_BYTE_3_3_2:
554 case GL_UNSIGNED_BYTE_2_3_3_REV:
555 case GL_UNSIGNED_SHORT_5_6_5:
556 case GL_UNSIGNED_SHORT_5_6_5_REV:
557 case GL_UNSIGNED_SHORT_4_4_4_4:
558 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
559 case GL_UNSIGNED_SHORT_5_5_5_1:
560 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
561 case GL_UNSIGNED_INT_8_8_8_8:
562 case GL_UNSIGNED_INT_8_8_8_8_REV:
563 case GL_UNSIGNED_INT_10_10_10_2:
564 case GL_UNSIGNED_INT_2_10_10_10_REV:
565 dstMesaFormat = _mesa_format_from_format_and_type(dstFormat, dstType);
566 if (!(dstMesaFormat & MESA_ARRAY_FORMAT_BIT)) {
567 _mesa_pack_uint_rgba_row(dstMesaFormat, n, (void *)rgba[0], (void *)dstAddr);
568 break;
569 } else {
570 /* Fall through */
571 }
572 default:
573 _pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
574 return;
575 }
576 }
577
578 /* Customization of signed integer packing.
579 */
580 #define SRC_TYPE GLint
581
582 #define DST_TYPE GLuint
583 #define SRC_CONVERT(x) MAX2(x, 0)
584 #define FN_NAME pack_uint_from_int_rgba
585 #include "pack_tmp.h"
586 #undef DST_TYPE
587 #undef SRC_CONVERT
588 #undef FN_NAME
589
590 #define DST_TYPE GLushort
591 #define SRC_CONVERT(x) MAX2(x, 0)
592 #define FN_NAME pack_ushort_from_int_rgba
593 #include "pack_tmp.h"
594 #undef DST_TYPE
595 #undef SRC_CONVERT
596 #undef FN_NAME
597
598 #define DST_TYPE GLshort
599 #define SRC_CONVERT(x) CLAMP(x, -0x8000, 0x7fff)
600 #define FN_NAME pack_short_from_int_rgba
601 #include "pack_tmp.h"
602 #undef DST_TYPE
603 #undef SRC_CONVERT
604 #undef FN_NAME
605
606 #define DST_TYPE GLubyte
607 #define SRC_CONVERT(x) MAX2(x, 0)
608 #define FN_NAME pack_ubyte_from_int_rgba
609 #include "pack_tmp.h"
610 #undef DST_TYPE
611 #undef SRC_CONVERT
612 #undef FN_NAME
613
614 #define DST_TYPE GLbyte
615 #define SRC_CONVERT(x) CLAMP(x, -0x80, 0x7f)
616 #define FN_NAME pack_byte_from_int_rgba
617 #include "pack_tmp.h"
618 #undef DST_TYPE
619 #undef SRC_CONVERT
620 #undef FN_NAME
621
622 #undef SRC_TYPE
623
624 static void
625 _pack_rgba_span_from_ints_problem(struct gl_context *ctx,
626 GLenum dstFormat, GLenum dstType)
627 {
628 _mesa_problem(ctx,
629 "Unsupported type (%s) / format (%s) "
630 "in _mesa_pack_rgba_span_from_ints",
631 _mesa_lookup_enum_by_nr(dstType),
632 _mesa_lookup_enum_by_nr(dstFormat));
633 }
634
635 void
636 _mesa_pack_rgba_span_from_ints(struct gl_context *ctx, GLuint n, GLint rgba[][4],
637 GLenum dstFormat, GLenum dstType,
638 GLvoid *dstAddr)
639 {
640 uint32_t dstMesaFormat;
641
642 switch(dstType) {
643 case GL_UNSIGNED_INT:
644 pack_uint_from_int_rgba(ctx, dstAddr, dstFormat, rgba, NULL, n);
645 break;
646 case GL_INT:
647 /* No conversion necessary. */
648 pack_uint_from_uint_rgba(ctx, dstAddr, dstFormat, (GLuint (*)[4]) rgba, NULL, n);
649 break;
650 case GL_UNSIGNED_SHORT:
651 pack_ushort_from_int_rgba(ctx, dstAddr, dstFormat, rgba, NULL, n);
652 break;
653 case GL_SHORT:
654 pack_short_from_int_rgba(ctx, dstAddr, dstFormat, rgba, NULL, n);
655 break;
656 case GL_UNSIGNED_BYTE:
657 pack_ubyte_from_int_rgba(ctx, dstAddr, dstFormat, rgba, NULL, n);
658 break;
659 case GL_BYTE:
660 pack_byte_from_int_rgba(ctx, dstAddr, dstFormat, rgba, NULL, n);
661 break;
662 case GL_UNSIGNED_BYTE_3_3_2:
663 case GL_UNSIGNED_BYTE_2_3_3_REV:
664 case GL_UNSIGNED_SHORT_5_6_5:
665 case GL_UNSIGNED_SHORT_5_6_5_REV:
666 case GL_UNSIGNED_SHORT_4_4_4_4:
667 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
668 case GL_UNSIGNED_SHORT_5_5_5_1:
669 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
670 case GL_UNSIGNED_INT_8_8_8_8:
671 case GL_UNSIGNED_INT_8_8_8_8_REV:
672 case GL_UNSIGNED_INT_10_10_10_2:
673 case GL_UNSIGNED_INT_2_10_10_10_REV:
674 dstMesaFormat = _mesa_format_from_format_and_type(dstFormat, dstType);
675 if (!(dstMesaFormat & MESA_ARRAY_FORMAT_BIT)) {
676 _mesa_pack_int_rgba_row(dstMesaFormat, n, (void *)rgba[0], (void *)dstAddr);
677 break;
678 } else {
679 /* Fall through */
680 }
681 default:
682 _pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
683 return;
684 }
685 }
686
687 /* Customization of float packing.
688 */
689 #define SRC_TYPE GLfloat
690
691 #define DST_TYPE GLuint
692 #define FLOAT_SRC_CONVERT(x) FLOAT_TO_UINT(x)
693 #define SRC_CONVERT(x) (GLuint) x
694 #define FN_NAME pack_uint_from_float_rgba
695 #include "pack_tmp.h"
696 #undef DST_TYPE
697 #undef SRC_CONVERT
698 #undef FLOAT_SRC_CONVERT
699 #undef FN_NAME
700
701 #define DST_TYPE GLint
702 #define FLOAT_SRC_CONVERT(x) FLOAT_TO_INT(x)
703 #define SRC_CONVERT(x) (GLint) x
704 #define FN_NAME pack_int_from_float_rgba
705 #include "pack_tmp.h"
706 #undef DST_TYPE
707 #undef SRC_CONVERT
708 #undef FLOAT_SRC_CONVERT
709 #undef FN_NAME
710
711 #define DST_TYPE GLshort
712 #define FLOAT_SRC_CONVERT(x) FLOAT_TO_SHORT_TEX(x)
713 #define SRC_CONVERT(x) (GLshort) x
714 #define FN_NAME pack_short_from_float_rgba
715 #include "pack_tmp.h"
716 #undef DST_TYPE
717 #undef SRC_CONVERT
718 #undef FLOAT_SRC_CONVERT
719 #undef FN_NAME
720
721 #define DST_TYPE GLubyte
722 #define FLOAT_SRC_CONVERT(x) FLOAT_TO_UBYTE(x)
723 #define SRC_CONVERT(x) (GLubyte) x
724 #define FN_NAME pack_ubyte_from_float_rgba
725 #include "pack_tmp.h"
726 #undef DST_TYPE
727 #undef SRC_CONVERT
728 #undef FLOAT_SRC_CONVERT
729 #undef FN_NAME
730
731 #define DST_TYPE GLbyte
732 #define FLOAT_SRC_CONVERT(x) FLOAT_TO_BYTE_TEX(x)
733 #define SRC_CONVERT(x) (GLbyte) x
734 #define FN_NAME pack_byte_from_float_rgba
735 #include "pack_tmp.h"
736 #undef DST_TYPE
737 #undef SRC_CONVERT
738 #undef FLOAT_SRC_CONVERT
739 #undef FN_NAME
740
741 #define DST_TYPE GLfloat
742 #define FLOAT_SRC_CONVERT(x) x
743 #define SRC_CONVERT(x) x
744 #define FN_NAME pack_float_from_float_rgba
745 #include "pack_tmp.h"
746 #undef DST_TYPE
747 #undef SRC_CONVERT
748 #undef FLOAT_SRC_CONVERT
749 #undef FN_NAME
750
751 #define DST_TYPE GLhalfARB
752 #define FLOAT_SRC_CONVERT(x) _mesa_float_to_half(x)
753 #define FN_NAME pack_half_float_from_float_rgba
754 #include "pack_tmp.h"
755 #undef DST_TYPE
756 #undef SRC_CONVERT
757 #undef FLOAT_SRC_CONVERT
758 #undef FN_NAME
759
760 #undef SRC_TYPE
761
762 /**
763 * Used to pack an array [][4] of RGBA float colors as specified
764 * by the dstFormat, dstType and dstPacking. Used by glReadPixels.
765 * Historically, the RGBA values were in [0,1] and rescaled to fit
766 * into GLubytes, etc. But with new integer formats, the RGBA values
767 * may have any value and we don't always rescale when converting to
768 * integers.
769 *
770 * Note: the rgba values will be modified by this function when any pixel
771 * transfer ops are enabled.
772 */
773 void
774 _mesa_pack_rgba_span_float(struct gl_context *ctx, GLuint n, GLfloat rgba[][4],
775 GLenum dstFormat, GLenum dstType,
776 GLvoid *dstAddr,
777 const struct gl_pixelstore_attrib *dstPacking,
778 GLbitfield transferOps)
779 {
780 GLfloat *luminance;
781 const GLint comps = _mesa_components_in_format(dstFormat);
782 const GLboolean intDstFormat = _mesa_is_enum_format_integer(dstFormat);
783 GLuint i;
784 uint32_t dstMesaFormat;
785
786 if (dstFormat == GL_LUMINANCE ||
787 dstFormat == GL_LUMINANCE_ALPHA ||
788 dstFormat == GL_LUMINANCE_INTEGER_EXT ||
789 dstFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT) {
790 luminance = malloc(n * sizeof(GLfloat));
791 if (!luminance) {
792 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
793 return;
794 }
795 }
796 else {
797 luminance = NULL;
798 }
799
800 /* EXT_texture_integer specifies no transfer ops on integer
801 * types in the resolved issues section. Just set them to 0
802 * for integer surfaces.
803 */
804 if (intDstFormat)
805 transferOps = 0;
806
807 if (transferOps) {
808 _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
809 }
810
811 /*
812 * Component clamping (besides clamping to [0,1] in
813 * _mesa_apply_rgba_transfer_ops()).
814 */
815 if (intDstFormat) {
816 /* clamping to dest type's min/max values */
817 GLfloat min, max;
818 if (get_type_min_max(dstType, &min, &max)) {
819 for (i = 0; i < n; i++) {
820 rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], min, max);
821 rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], min, max);
822 rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], min, max);
823 rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], min, max);
824 }
825 }
826 }
827 else if (dstFormat == GL_LUMINANCE || dstFormat == GL_LUMINANCE_ALPHA) {
828 /* compute luminance values */
829 if (transferOps & IMAGE_CLAMP_BIT) {
830 for (i = 0; i < n; i++) {
831 GLfloat sum = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
832 luminance[i] = CLAMP(sum, 0.0F, 1.0F);
833 }
834 }
835 else {
836 for (i = 0; i < n; i++) {
837 luminance[i] = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
838 }
839 }
840 }
841
842 /*
843 * Pack/store the pixels. Ugh! Lots of cases!!!
844 */
845 switch (dstType) {
846 case GL_UNSIGNED_BYTE:
847 pack_ubyte_from_float_rgba(ctx, dstAddr, dstFormat, rgba, luminance, n);
848 break;
849 case GL_BYTE:
850 pack_byte_from_float_rgba(ctx, dstAddr, dstFormat, rgba, luminance, n);
851 break;
852 case GL_UNSIGNED_SHORT:
853 {
854 GLushort *dst = (GLushort *) dstAddr;
855 switch (dstFormat) {
856 case GL_RED:
857 for (i=0;i<n;i++)
858 CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][RCOMP]);
859 break;
860 case GL_GREEN:
861 for (i=0;i<n;i++)
862 CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][GCOMP]);
863 break;
864 case GL_BLUE:
865 for (i=0;i<n;i++)
866 CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][BCOMP]);
867 break;
868 case GL_ALPHA:
869 for (i=0;i<n;i++)
870 CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][ACOMP]);
871 break;
872 case GL_LUMINANCE:
873 for (i=0;i<n;i++)
874 UNCLAMPED_FLOAT_TO_USHORT(dst[i], luminance[i]);
875 break;
876 case GL_LUMINANCE_ALPHA:
877 for (i=0;i<n;i++) {
878 UNCLAMPED_FLOAT_TO_USHORT(dst[i*2+0], luminance[i]);
879 CLAMPED_FLOAT_TO_USHORT(dst[i*2+1], rgba[i][ACOMP]);
880 }
881 break;
882 case GL_RG:
883 for (i=0;i<n;i++) {
884 CLAMPED_FLOAT_TO_USHORT(dst[i*2+0], rgba[i][RCOMP]);
885 CLAMPED_FLOAT_TO_USHORT(dst[i*2+1], rgba[i][GCOMP]);
886 }
887 break;
888 case GL_RGB:
889 for (i=0;i<n;i++) {
890 CLAMPED_FLOAT_TO_USHORT(dst[i*3+0], rgba[i][RCOMP]);
891 CLAMPED_FLOAT_TO_USHORT(dst[i*3+1], rgba[i][GCOMP]);
892 CLAMPED_FLOAT_TO_USHORT(dst[i*3+2], rgba[i][BCOMP]);
893 }
894 break;
895 case GL_RGBA:
896 for (i=0;i<n;i++) {
897 CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][RCOMP]);
898 CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][GCOMP]);
899 CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][BCOMP]);
900 CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][ACOMP]);
901 }
902 break;
903 case GL_BGR:
904 for (i=0;i<n;i++) {
905 CLAMPED_FLOAT_TO_USHORT(dst[i*3+0], rgba[i][BCOMP]);
906 CLAMPED_FLOAT_TO_USHORT(dst[i*3+1], rgba[i][GCOMP]);
907 CLAMPED_FLOAT_TO_USHORT(dst[i*3+2], rgba[i][RCOMP]);
908 }
909 break;
910 case GL_BGRA:
911 for (i=0;i<n;i++) {
912 CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][BCOMP]);
913 CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][GCOMP]);
914 CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][RCOMP]);
915 CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][ACOMP]);
916 }
917 break;
918 case GL_ABGR_EXT:
919 for (i=0;i<n;i++) {
920 CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][ACOMP]);
921 CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][BCOMP]);
922 CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][GCOMP]);
923 CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][RCOMP]);
924 }
925 break;
926 case GL_RED_INTEGER_EXT:
927 for (i=0;i<n;i++) {
928 dst[i] = (GLushort) rgba[i][RCOMP];
929 }
930 break;
931 case GL_GREEN_INTEGER_EXT:
932 for (i=0;i<n;i++) {
933 dst[i] = (GLushort) rgba[i][GCOMP];
934 }
935 break;
936 case GL_BLUE_INTEGER_EXT:
937 for (i=0;i<n;i++) {
938 dst[i] = (GLushort) rgba[i][BCOMP];
939 }
940 break;
941 case GL_ALPHA_INTEGER_EXT:
942 for (i=0;i<n;i++) {
943 dst[i] = (GLushort) rgba[i][ACOMP];
944 }
945 break;
946 case GL_RG_INTEGER:
947 for (i=0;i<n;i++) {
948 dst[i*2+0] = (GLushort) rgba[i][RCOMP];
949 dst[i*2+1] = (GLushort) rgba[i][GCOMP];
950 }
951 break;
952 case GL_RGB_INTEGER_EXT:
953 for (i=0;i<n;i++) {
954 dst[i*3+0] = (GLushort) rgba[i][RCOMP];
955 dst[i*3+1] = (GLushort) rgba[i][GCOMP];
956 dst[i*3+2] = (GLushort) rgba[i][BCOMP];
957 }
958 break;
959 case GL_RGBA_INTEGER_EXT:
960 for (i=0;i<n;i++) {
961 dst[i*4+0] = (GLushort) rgba[i][RCOMP];
962 dst[i*4+1] = (GLushort) rgba[i][GCOMP];
963 dst[i*4+2] = (GLushort) rgba[i][BCOMP];
964 dst[i*4+3] = (GLushort) rgba[i][ACOMP];
965 }
966 break;
967 case GL_BGR_INTEGER_EXT:
968 for (i=0;i<n;i++) {
969 dst[i*3+0] = (GLushort) rgba[i][BCOMP];
970 dst[i*3+1] = (GLushort) rgba[i][GCOMP];
971 dst[i*3+2] = (GLushort) rgba[i][RCOMP];
972 }
973 break;
974 case GL_BGRA_INTEGER_EXT:
975 for (i=0;i<n;i++) {
976 dst[i*4+0] = (GLushort) rgba[i][BCOMP];
977 dst[i*4+1] = (GLushort) rgba[i][GCOMP];
978 dst[i*4+2] = (GLushort) rgba[i][RCOMP];
979 dst[i*4+3] = (GLushort) rgba[i][ACOMP];
980 }
981 break;
982 case GL_LUMINANCE_INTEGER_EXT:
983 for (i=0;i<n;i++) {
984 dst[i*2+0] = (GLushort) (rgba[i][RCOMP] +
985 rgba[i][GCOMP] +
986 rgba[i][BCOMP]);
987 dst[i*2+1] = (GLushort) rgba[i][ACOMP];
988 }
989 break;
990 case GL_LUMINANCE_ALPHA_INTEGER_EXT:
991 for (i=0;i<n;i++) {
992 dst[i] = (GLushort) (rgba[i][RCOMP] +
993 rgba[i][GCOMP] +
994 rgba[i][BCOMP]);
995 }
996 break;
997 default:
998 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
999 }
1000 }
1001 break;
1002 case GL_SHORT:
1003 pack_short_from_float_rgba(ctx, dstAddr, dstFormat, rgba, luminance, n);
1004 break;
1005 case GL_UNSIGNED_INT:
1006 pack_uint_from_float_rgba(ctx, dstAddr, dstFormat, rgba, luminance, n);
1007 break;
1008 case GL_INT:
1009 pack_int_from_float_rgba(ctx, dstAddr, dstFormat, rgba, luminance, n);
1010 break;
1011 case GL_FLOAT:
1012 /* No conversion necessary. */
1013 pack_float_from_float_rgba(ctx, dstAddr, dstFormat, rgba, luminance, n);
1014 break;
1015 case GL_HALF_FLOAT_ARB:
1016 pack_half_float_from_float_rgba(ctx, dstAddr, dstFormat, rgba, luminance, n);
1017 break;
1018 case GL_UNSIGNED_BYTE_3_3_2:
1019 case GL_UNSIGNED_BYTE_2_3_3_REV:
1020 case GL_UNSIGNED_SHORT_5_6_5:
1021 case GL_UNSIGNED_SHORT_5_6_5_REV:
1022 case GL_UNSIGNED_SHORT_4_4_4_4:
1023 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1024 case GL_UNSIGNED_SHORT_5_5_5_1:
1025 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1026 case GL_UNSIGNED_INT_8_8_8_8:
1027 case GL_UNSIGNED_INT_8_8_8_8_REV:
1028 case GL_UNSIGNED_INT_10_10_10_2:
1029 case GL_UNSIGNED_INT_2_10_10_10_REV:
1030 case GL_UNSIGNED_INT_5_9_9_9_REV:
1031 case GL_UNSIGNED_INT_10F_11F_11F_REV:
1032 dstMesaFormat = _mesa_format_from_format_and_type(dstFormat, dstType);
1033 if (!(dstMesaFormat & MESA_ARRAY_FORMAT_BIT)) {
1034 _mesa_pack_float_rgba_row(dstMesaFormat, n, (void *)rgba[0], (void *)dstAddr);
1035 break;
1036 } else {
1037 /* Fall through */
1038 }
1039 default:
1040 _mesa_problem(ctx, "bad type in _mesa_pack_rgba_span_float");
1041 free(luminance);
1042 return;
1043 }
1044
1045 if (dstPacking->SwapBytes) {
1046 GLint swapSize = _mesa_sizeof_packed_type(dstType);
1047 if (swapSize == 2) {
1048 _mesa_swap2((GLushort *) dstAddr, n * comps);
1049 }
1050 else if (swapSize == 4) {
1051 _mesa_swap4((GLuint *) dstAddr, n * comps);
1052 }
1053 }
1054
1055 free(luminance);
1056 }
1057
1058
1059
1060 #define SWAP2BYTE(VALUE) \
1061 { \
1062 GLubyte *bytes = (GLubyte *) &(VALUE); \
1063 GLubyte tmp = bytes[0]; \
1064 bytes[0] = bytes[1]; \
1065 bytes[1] = tmp; \
1066 }
1067
1068 #define SWAP4BYTE(VALUE) \
1069 { \
1070 GLubyte *bytes = (GLubyte *) &(VALUE); \
1071 GLubyte tmp = bytes[0]; \
1072 bytes[0] = bytes[3]; \
1073 bytes[3] = tmp; \
1074 tmp = bytes[1]; \
1075 bytes[1] = bytes[2]; \
1076 bytes[2] = tmp; \
1077 }
1078
1079
1080 static void
1081 extract_uint_indexes(GLuint n, GLuint indexes[],
1082 GLenum srcFormat, GLenum srcType, const GLvoid *src,
1083 const struct gl_pixelstore_attrib *unpack )
1084 {
1085 ASSERT(srcFormat == GL_COLOR_INDEX || srcFormat == GL_STENCIL_INDEX);
1086
1087 ASSERT(srcType == GL_BITMAP ||
1088 srcType == GL_UNSIGNED_BYTE ||
1089 srcType == GL_BYTE ||
1090 srcType == GL_UNSIGNED_SHORT ||
1091 srcType == GL_SHORT ||
1092 srcType == GL_UNSIGNED_INT ||
1093 srcType == GL_INT ||
1094 srcType == GL_UNSIGNED_INT_24_8_EXT ||
1095 srcType == GL_HALF_FLOAT_ARB ||
1096 srcType == GL_FLOAT ||
1097 srcType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
1098
1099 switch (srcType) {
1100 case GL_BITMAP:
1101 {
1102 GLubyte *ubsrc = (GLubyte *) src;
1103 if (unpack->LsbFirst) {
1104 GLubyte mask = 1 << (unpack->SkipPixels & 0x7);
1105 GLuint i;
1106 for (i = 0; i < n; i++) {
1107 indexes[i] = (*ubsrc & mask) ? 1 : 0;
1108 if (mask == 128) {
1109 mask = 1;
1110 ubsrc++;
1111 }
1112 else {
1113 mask = mask << 1;
1114 }
1115 }
1116 }
1117 else {
1118 GLubyte mask = 128 >> (unpack->SkipPixels & 0x7);
1119 GLuint i;
1120 for (i = 0; i < n; i++) {
1121 indexes[i] = (*ubsrc & mask) ? 1 : 0;
1122 if (mask == 1) {
1123 mask = 128;
1124 ubsrc++;
1125 }
1126 else {
1127 mask = mask >> 1;
1128 }
1129 }
1130 }
1131 }
1132 break;
1133 case GL_UNSIGNED_BYTE:
1134 {
1135 GLuint i;
1136 const GLubyte *s = (const GLubyte *) src;
1137 for (i = 0; i < n; i++)
1138 indexes[i] = s[i];
1139 }
1140 break;
1141 case GL_BYTE:
1142 {
1143 GLuint i;
1144 const GLbyte *s = (const GLbyte *) src;
1145 for (i = 0; i < n; i++)
1146 indexes[i] = s[i];
1147 }
1148 break;
1149 case GL_UNSIGNED_SHORT:
1150 {
1151 GLuint i;
1152 const GLushort *s = (const GLushort *) src;
1153 if (unpack->SwapBytes) {
1154 for (i = 0; i < n; i++) {
1155 GLushort value = s[i];
1156 SWAP2BYTE(value);
1157 indexes[i] = value;
1158 }
1159 }
1160 else {
1161 for (i = 0; i < n; i++)
1162 indexes[i] = s[i];
1163 }
1164 }
1165 break;
1166 case GL_SHORT:
1167 {
1168 GLuint i;
1169 const GLshort *s = (const GLshort *) src;
1170 if (unpack->SwapBytes) {
1171 for (i = 0; i < n; i++) {
1172 GLshort value = s[i];
1173 SWAP2BYTE(value);
1174 indexes[i] = value;
1175 }
1176 }
1177 else {
1178 for (i = 0; i < n; i++)
1179 indexes[i] = s[i];
1180 }
1181 }
1182 break;
1183 case GL_UNSIGNED_INT:
1184 {
1185 GLuint i;
1186 const GLuint *s = (const GLuint *) src;
1187 if (unpack->SwapBytes) {
1188 for (i = 0; i < n; i++) {
1189 GLuint value = s[i];
1190 SWAP4BYTE(value);
1191 indexes[i] = value;
1192 }
1193 }
1194 else {
1195 for (i = 0; i < n; i++)
1196 indexes[i] = s[i];
1197 }
1198 }
1199 break;
1200 case GL_INT:
1201 {
1202 GLuint i;
1203 const GLint *s = (const GLint *) src;
1204 if (unpack->SwapBytes) {
1205 for (i = 0; i < n; i++) {
1206 GLint value = s[i];
1207 SWAP4BYTE(value);
1208 indexes[i] = value;
1209 }
1210 }
1211 else {
1212 for (i = 0; i < n; i++)
1213 indexes[i] = s[i];
1214 }
1215 }
1216 break;
1217 case GL_FLOAT:
1218 {
1219 GLuint i;
1220 const GLfloat *s = (const GLfloat *) src;
1221 if (unpack->SwapBytes) {
1222 for (i = 0; i < n; i++) {
1223 GLfloat value = s[i];
1224 SWAP4BYTE(value);
1225 indexes[i] = (GLuint) value;
1226 }
1227 }
1228 else {
1229 for (i = 0; i < n; i++)
1230 indexes[i] = (GLuint) s[i];
1231 }
1232 }
1233 break;
1234 case GL_HALF_FLOAT_ARB:
1235 {
1236 GLuint i;
1237 const GLhalfARB *s = (const GLhalfARB *) src;
1238 if (unpack->SwapBytes) {
1239 for (i = 0; i < n; i++) {
1240 GLhalfARB value = s[i];
1241 SWAP2BYTE(value);
1242 indexes[i] = (GLuint) _mesa_half_to_float(value);
1243 }
1244 }
1245 else {
1246 for (i = 0; i < n; i++)
1247 indexes[i] = (GLuint) _mesa_half_to_float(s[i]);
1248 }
1249 }
1250 break;
1251 case GL_UNSIGNED_INT_24_8_EXT:
1252 {
1253 GLuint i;
1254 const GLuint *s = (const GLuint *) src;
1255 if (unpack->SwapBytes) {
1256 for (i = 0; i < n; i++) {
1257 GLuint value = s[i];
1258 SWAP4BYTE(value);
1259 indexes[i] = value & 0xff; /* lower 8 bits */
1260 }
1261 }
1262 else {
1263 for (i = 0; i < n; i++)
1264 indexes[i] = s[i] & 0xff; /* lower 8 bits */
1265 }
1266 }
1267 break;
1268 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
1269 {
1270 GLuint i;
1271 const GLuint *s = (const GLuint *) src;
1272 if (unpack->SwapBytes) {
1273 for (i = 0; i < n; i++) {
1274 GLuint value = s[i*2+1];
1275 SWAP4BYTE(value);
1276 indexes[i] = value & 0xff; /* lower 8 bits */
1277 }
1278 }
1279 else {
1280 for (i = 0; i < n; i++)
1281 indexes[i] = s[i*2+1] & 0xff; /* lower 8 bits */
1282 }
1283 }
1284 break;
1285
1286 default:
1287 _mesa_problem(NULL, "bad srcType in extract_uint_indexes");
1288 return;
1289 }
1290 }
1291
1292
1293 /**
1294 * Return source/dest RGBA indexes for unpacking pixels.
1295 */
1296 static void
1297 get_component_mapping(GLenum format,
1298 GLint *rSrc,
1299 GLint *gSrc,
1300 GLint *bSrc,
1301 GLint *aSrc,
1302 GLint *rDst,
1303 GLint *gDst,
1304 GLint *bDst,
1305 GLint *aDst)
1306 {
1307 switch (format) {
1308 case GL_RED:
1309 case GL_RED_INTEGER_EXT:
1310 *rSrc = 0;
1311 *gSrc = *bSrc = *aSrc = -1;
1312 break;
1313 case GL_GREEN:
1314 case GL_GREEN_INTEGER_EXT:
1315 *gSrc = 0;
1316 *rSrc = *bSrc = *aSrc = -1;
1317 break;
1318 case GL_BLUE:
1319 case GL_BLUE_INTEGER_EXT:
1320 *bSrc = 0;
1321 *rSrc = *gSrc = *aSrc = -1;
1322 break;
1323 case GL_ALPHA:
1324 case GL_ALPHA_INTEGER_EXT:
1325 *rSrc = *gSrc = *bSrc = -1;
1326 *aSrc = 0;
1327 break;
1328 case GL_LUMINANCE:
1329 case GL_LUMINANCE_INTEGER_EXT:
1330 *rSrc = *gSrc = *bSrc = 0;
1331 *aSrc = -1;
1332 break;
1333 case GL_LUMINANCE_ALPHA:
1334 case GL_LUMINANCE_ALPHA_INTEGER_EXT:
1335 *rSrc = *gSrc = *bSrc = 0;
1336 *aSrc = 1;
1337 break;
1338 case GL_INTENSITY:
1339 *rSrc = *gSrc = *bSrc = *aSrc = 0;
1340 break;
1341 case GL_RG:
1342 case GL_RG_INTEGER:
1343 *rSrc = 0;
1344 *gSrc = 1;
1345 *bSrc = -1;
1346 *aSrc = -1;
1347 *rDst = 0;
1348 *gDst = 1;
1349 *bDst = 2;
1350 *aDst = 3;
1351 break;
1352 case GL_RGB:
1353 case GL_RGB_INTEGER:
1354 *rSrc = 0;
1355 *gSrc = 1;
1356 *bSrc = 2;
1357 *aSrc = -1;
1358 *rDst = 0;
1359 *gDst = 1;
1360 *bDst = 2;
1361 *aDst = 3;
1362 break;
1363 case GL_BGR:
1364 case GL_BGR_INTEGER:
1365 *rSrc = 2;
1366 *gSrc = 1;
1367 *bSrc = 0;
1368 *aSrc = -1;
1369 *rDst = 2;
1370 *gDst = 1;
1371 *bDst = 0;
1372 *aDst = 3;
1373 break;
1374 case GL_RGBA:
1375 case GL_RGBA_INTEGER:
1376 *rSrc = 0;
1377 *gSrc = 1;
1378 *bSrc = 2;
1379 *aSrc = 3;
1380 *rDst = 0;
1381 *gDst = 1;
1382 *bDst = 2;
1383 *aDst = 3;
1384 break;
1385 case GL_BGRA:
1386 case GL_BGRA_INTEGER:
1387 *rSrc = 2;
1388 *gSrc = 1;
1389 *bSrc = 0;
1390 *aSrc = 3;
1391 *rDst = 2;
1392 *gDst = 1;
1393 *bDst = 0;
1394 *aDst = 3;
1395 break;
1396 case GL_ABGR_EXT:
1397 *rSrc = 3;
1398 *gSrc = 2;
1399 *bSrc = 1;
1400 *aSrc = 0;
1401 *rDst = 3;
1402 *gDst = 2;
1403 *bDst = 1;
1404 *aDst = 0;
1405 break;
1406 default:
1407 _mesa_problem(NULL, "bad srcFormat %s in get_component_mapping",
1408 _mesa_lookup_enum_by_nr(format));
1409 return;
1410 }
1411 }
1412
1413
1414
1415 /*
1416 * This function extracts floating point RGBA values from arbitrary
1417 * image data. srcFormat and srcType are the format and type parameters
1418 * passed to glDrawPixels, glTexImage[123]D, glTexSubImage[123]D, etc.
1419 *
1420 * Refering to section 3.6.4 of the OpenGL 1.2 spec, this function
1421 * implements the "Conversion to floating point", "Conversion to RGB",
1422 * and "Final Expansion to RGBA" operations.
1423 *
1424 * Args: n - number of pixels
1425 * rgba - output colors
1426 * srcFormat - format of incoming data
1427 * srcType - data type of incoming data
1428 * src - source data pointer
1429 * swapBytes - perform byteswapping of incoming data?
1430 */
1431 static void
1432 extract_float_rgba(GLuint n, GLfloat rgba[][4],
1433 GLenum srcFormat, GLenum srcType, const GLvoid *src,
1434 GLboolean swapBytes)
1435 {
1436 GLint rSrc, gSrc, bSrc, aSrc;
1437 GLint stride;
1438 GLint rDst, bDst, gDst, aDst;
1439 GLboolean intFormat;
1440 GLfloat rs = 1.0f, gs = 1.0f, bs = 1.0f, as = 1.0f; /* scale factors */
1441
1442 ASSERT(srcFormat == GL_RED ||
1443 srcFormat == GL_GREEN ||
1444 srcFormat == GL_BLUE ||
1445 srcFormat == GL_ALPHA ||
1446 srcFormat == GL_LUMINANCE ||
1447 srcFormat == GL_LUMINANCE_ALPHA ||
1448 srcFormat == GL_INTENSITY ||
1449 srcFormat == GL_RG ||
1450 srcFormat == GL_RGB ||
1451 srcFormat == GL_BGR ||
1452 srcFormat == GL_RGBA ||
1453 srcFormat == GL_BGRA ||
1454 srcFormat == GL_ABGR_EXT ||
1455 srcFormat == GL_RED_INTEGER_EXT ||
1456 srcFormat == GL_GREEN_INTEGER_EXT ||
1457 srcFormat == GL_BLUE_INTEGER_EXT ||
1458 srcFormat == GL_ALPHA_INTEGER_EXT ||
1459 srcFormat == GL_RG_INTEGER ||
1460 srcFormat == GL_RGB_INTEGER_EXT ||
1461 srcFormat == GL_RGBA_INTEGER_EXT ||
1462 srcFormat == GL_BGR_INTEGER_EXT ||
1463 srcFormat == GL_BGRA_INTEGER_EXT ||
1464 srcFormat == GL_LUMINANCE_INTEGER_EXT ||
1465 srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);
1466
1467 ASSERT(srcType == GL_UNSIGNED_BYTE ||
1468 srcType == GL_BYTE ||
1469 srcType == GL_UNSIGNED_SHORT ||
1470 srcType == GL_SHORT ||
1471 srcType == GL_UNSIGNED_INT ||
1472 srcType == GL_INT ||
1473 srcType == GL_HALF_FLOAT_ARB ||
1474 srcType == GL_FLOAT ||
1475 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
1476 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
1477 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
1478 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
1479 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
1480 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
1481 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
1482 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
1483 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
1484 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
1485 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
1486 srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
1487 srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
1488 srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
1489
1490 get_component_mapping(srcFormat,
1491 &rSrc, &gSrc, &bSrc, &aSrc,
1492 &rDst, &gDst, &bDst, &aDst);
1493
1494 stride = _mesa_components_in_format(srcFormat);
1495
1496 intFormat = _mesa_is_enum_format_integer(srcFormat);
1497
1498 #define PROCESS(SRC_INDEX, DST_INDEX, DEFAULT_FLT, DEFAULT_INT, TYPE, CONVERSION) \
1499 if ((SRC_INDEX) < 0) { \
1500 GLuint i; \
1501 if (intFormat) { \
1502 for (i = 0; i < n; i++) { \
1503 rgba[i][DST_INDEX] = DEFAULT_INT; \
1504 } \
1505 } \
1506 else { \
1507 for (i = 0; i < n; i++) { \
1508 rgba[i][DST_INDEX] = DEFAULT_FLT; \
1509 } \
1510 } \
1511 } \
1512 else if (swapBytes) { \
1513 const TYPE *s = (const TYPE *) src; \
1514 GLuint i; \
1515 for (i = 0; i < n; i++) { \
1516 TYPE value = s[SRC_INDEX]; \
1517 if (sizeof(TYPE) == 2) { \
1518 SWAP2BYTE(value); \
1519 } \
1520 else if (sizeof(TYPE) == 4) { \
1521 SWAP4BYTE(value); \
1522 } \
1523 if (intFormat) \
1524 rgba[i][DST_INDEX] = (GLfloat) value; \
1525 else \
1526 rgba[i][DST_INDEX] = (GLfloat) CONVERSION(value); \
1527 s += stride; \
1528 } \
1529 } \
1530 else { \
1531 const TYPE *s = (const TYPE *) src; \
1532 GLuint i; \
1533 if (intFormat) { \
1534 for (i = 0; i < n; i++) { \
1535 rgba[i][DST_INDEX] = (GLfloat) s[SRC_INDEX]; \
1536 s += stride; \
1537 } \
1538 } \
1539 else { \
1540 for (i = 0; i < n; i++) { \
1541 rgba[i][DST_INDEX] = (GLfloat) CONVERSION(s[SRC_INDEX]); \
1542 s += stride; \
1543 } \
1544 } \
1545 }
1546
1547 switch (srcType) {
1548 case GL_UNSIGNED_BYTE:
1549 PROCESS(rSrc, RCOMP, 0.0F, 0, GLubyte, UBYTE_TO_FLOAT);
1550 PROCESS(gSrc, GCOMP, 0.0F, 0, GLubyte, UBYTE_TO_FLOAT);
1551 PROCESS(bSrc, BCOMP, 0.0F, 0, GLubyte, UBYTE_TO_FLOAT);
1552 PROCESS(aSrc, ACOMP, 1.0F, 255, GLubyte, UBYTE_TO_FLOAT);
1553 break;
1554 case GL_BYTE:
1555 PROCESS(rSrc, RCOMP, 0.0F, 0, GLbyte, BYTE_TO_FLOAT_TEX);
1556 PROCESS(gSrc, GCOMP, 0.0F, 0, GLbyte, BYTE_TO_FLOAT_TEX);
1557 PROCESS(bSrc, BCOMP, 0.0F, 0, GLbyte, BYTE_TO_FLOAT_TEX);
1558 PROCESS(aSrc, ACOMP, 1.0F, 127, GLbyte, BYTE_TO_FLOAT_TEX);
1559 break;
1560 case GL_UNSIGNED_SHORT:
1561 PROCESS(rSrc, RCOMP, 0.0F, 0, GLushort, USHORT_TO_FLOAT);
1562 PROCESS(gSrc, GCOMP, 0.0F, 0, GLushort, USHORT_TO_FLOAT);
1563 PROCESS(bSrc, BCOMP, 0.0F, 0, GLushort, USHORT_TO_FLOAT);
1564 PROCESS(aSrc, ACOMP, 1.0F, 0xffff, GLushort, USHORT_TO_FLOAT);
1565 break;
1566 case GL_SHORT:
1567 PROCESS(rSrc, RCOMP, 0.0F, 0, GLshort, SHORT_TO_FLOAT_TEX);
1568 PROCESS(gSrc, GCOMP, 0.0F, 0, GLshort, SHORT_TO_FLOAT_TEX);
1569 PROCESS(bSrc, BCOMP, 0.0F, 0, GLshort, SHORT_TO_FLOAT_TEX);
1570 PROCESS(aSrc, ACOMP, 1.0F, 32767, GLshort, SHORT_TO_FLOAT_TEX);
1571 break;
1572 case GL_UNSIGNED_INT:
1573 PROCESS(rSrc, RCOMP, 0.0F, 0, GLuint, UINT_TO_FLOAT);
1574 PROCESS(gSrc, GCOMP, 0.0F, 0, GLuint, UINT_TO_FLOAT);
1575 PROCESS(bSrc, BCOMP, 0.0F, 0, GLuint, UINT_TO_FLOAT);
1576 PROCESS(aSrc, ACOMP, 1.0F, 0xffffffff, GLuint, UINT_TO_FLOAT);
1577 break;
1578 case GL_INT:
1579 PROCESS(rSrc, RCOMP, 0.0F, 0, GLint, INT_TO_FLOAT);
1580 PROCESS(gSrc, GCOMP, 0.0F, 0, GLint, INT_TO_FLOAT);
1581 PROCESS(bSrc, BCOMP, 0.0F, 0, GLint, INT_TO_FLOAT);
1582 PROCESS(aSrc, ACOMP, 1.0F, 2147483647, GLint, INT_TO_FLOAT);
1583 break;
1584 case GL_FLOAT:
1585 PROCESS(rSrc, RCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
1586 PROCESS(gSrc, GCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
1587 PROCESS(bSrc, BCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
1588 PROCESS(aSrc, ACOMP, 1.0F, 1.0F, GLfloat, (GLfloat));
1589 break;
1590 case GL_HALF_FLOAT_ARB:
1591 PROCESS(rSrc, RCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
1592 PROCESS(gSrc, GCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
1593 PROCESS(bSrc, BCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
1594 PROCESS(aSrc, ACOMP, 1.0F, 1.0F, GLhalfARB, _mesa_half_to_float);
1595 break;
1596 case GL_UNSIGNED_BYTE_3_3_2:
1597 {
1598 const GLubyte *ubsrc = (const GLubyte *) src;
1599 GLuint i;
1600 if (!intFormat) {
1601 rs = 1.0F / 7.0F;
1602 gs = 1.0F / 7.0F;
1603 bs = 1.0F / 3.0F;
1604 }
1605 for (i = 0; i < n; i ++) {
1606 GLubyte p = ubsrc[i];
1607 rgba[i][rDst] = ((p >> 5) ) * rs;
1608 rgba[i][gDst] = ((p >> 2) & 0x7) * gs;
1609 rgba[i][bDst] = ((p ) & 0x3) * bs;
1610 rgba[i][aDst] = 1.0F;
1611 }
1612 }
1613 break;
1614 case GL_UNSIGNED_BYTE_2_3_3_REV:
1615 {
1616 const GLubyte *ubsrc = (const GLubyte *) src;
1617 GLuint i;
1618 if (!intFormat) {
1619 rs = 1.0F / 7.0F;
1620 gs = 1.0F / 7.0F;
1621 bs = 1.0F / 3.0F;
1622 }
1623 for (i = 0; i < n; i ++) {
1624 GLubyte p = ubsrc[i];
1625 rgba[i][rDst] = ((p ) & 0x7) * rs;
1626 rgba[i][gDst] = ((p >> 3) & 0x7) * gs;
1627 rgba[i][bDst] = ((p >> 6) ) * bs;
1628 rgba[i][aDst] = 1.0F;
1629 }
1630 }
1631 break;
1632 case GL_UNSIGNED_SHORT_5_6_5:
1633 if (!intFormat) {
1634 rs = 1.0F / 31.0F;
1635 gs = 1.0F / 63.0F;
1636 bs = 1.0F / 31.0F;
1637 }
1638 if (swapBytes) {
1639 const GLushort *ussrc = (const GLushort *) src;
1640 GLuint i;
1641 for (i = 0; i < n; i ++) {
1642 GLushort p = ussrc[i];
1643 SWAP2BYTE(p);
1644 rgba[i][rDst] = ((p >> 11) ) * rs;
1645 rgba[i][gDst] = ((p >> 5) & 0x3f) * gs;
1646 rgba[i][bDst] = ((p ) & 0x1f) * bs;
1647 rgba[i][aDst] = 1.0F;
1648 }
1649 }
1650 else {
1651 const GLushort *ussrc = (const GLushort *) src;
1652 GLuint i;
1653 for (i = 0; i < n; i ++) {
1654 GLushort p = ussrc[i];
1655 rgba[i][rDst] = ((p >> 11) ) * rs;
1656 rgba[i][gDst] = ((p >> 5) & 0x3f) * gs;
1657 rgba[i][bDst] = ((p ) & 0x1f) * bs;
1658 rgba[i][aDst] = 1.0F;
1659 }
1660 }
1661 break;
1662 case GL_UNSIGNED_SHORT_5_6_5_REV:
1663 if (!intFormat) {
1664 rs = 1.0F / 31.0F;
1665 gs = 1.0F / 63.0F;
1666 bs = 1.0F / 31.0F;
1667 }
1668 if (swapBytes) {
1669 const GLushort *ussrc = (const GLushort *) src;
1670 GLuint i;
1671 for (i = 0; i < n; i ++) {
1672 GLushort p = ussrc[i];
1673 SWAP2BYTE(p);
1674 rgba[i][rDst] = ((p ) & 0x1f) * rs;
1675 rgba[i][gDst] = ((p >> 5) & 0x3f) * gs;
1676 rgba[i][bDst] = ((p >> 11) ) * bs;
1677 rgba[i][aDst] = 1.0F;
1678 }
1679 }
1680 else {
1681 const GLushort *ussrc = (const GLushort *) src;
1682 GLuint i;
1683 for (i = 0; i < n; i ++) {
1684 GLushort p = ussrc[i];
1685 rgba[i][rDst] = ((p ) & 0x1f) * rs;
1686 rgba[i][gDst] = ((p >> 5) & 0x3f) * gs;
1687 rgba[i][bDst] = ((p >> 11) ) * bs;
1688 rgba[i][aDst] = 1.0F;
1689 }
1690 }
1691 break;
1692 case GL_UNSIGNED_SHORT_4_4_4_4:
1693 if (!intFormat) {
1694 rs = gs = bs = as = 1.0F / 15.0F;
1695 }
1696 if (swapBytes) {
1697 const GLushort *ussrc = (const GLushort *) src;
1698 GLuint i;
1699 for (i = 0; i < n; i ++) {
1700 GLushort p = ussrc[i];
1701 SWAP2BYTE(p);
1702 rgba[i][rDst] = ((p >> 12) ) * rs;
1703 rgba[i][gDst] = ((p >> 8) & 0xf) * gs;
1704 rgba[i][bDst] = ((p >> 4) & 0xf) * bs;
1705 rgba[i][aDst] = ((p ) & 0xf) * as;
1706 }
1707 }
1708 else {
1709 const GLushort *ussrc = (const GLushort *) src;
1710 GLuint i;
1711 for (i = 0; i < n; i ++) {
1712 GLushort p = ussrc[i];
1713 rgba[i][rDst] = ((p >> 12) ) * rs;
1714 rgba[i][gDst] = ((p >> 8) & 0xf) * gs;
1715 rgba[i][bDst] = ((p >> 4) & 0xf) * bs;
1716 rgba[i][aDst] = ((p ) & 0xf) * as;
1717 }
1718 }
1719 break;
1720 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1721 if (!intFormat) {
1722 rs = gs = bs = as = 1.0F / 15.0F;
1723 }
1724 if (swapBytes) {
1725 const GLushort *ussrc = (const GLushort *) src;
1726 GLuint i;
1727 for (i = 0; i < n; i ++) {
1728 GLushort p = ussrc[i];
1729 SWAP2BYTE(p);
1730 rgba[i][rDst] = ((p ) & 0xf) * rs;
1731 rgba[i][gDst] = ((p >> 4) & 0xf) * gs;
1732 rgba[i][bDst] = ((p >> 8) & 0xf) * bs;
1733 rgba[i][aDst] = ((p >> 12) ) * as;
1734 }
1735 }
1736 else {
1737 const GLushort *ussrc = (const GLushort *) src;
1738 GLuint i;
1739 for (i = 0; i < n; i ++) {
1740 GLushort p = ussrc[i];
1741 rgba[i][rDst] = ((p ) & 0xf) * rs;
1742 rgba[i][gDst] = ((p >> 4) & 0xf) * gs;
1743 rgba[i][bDst] = ((p >> 8) & 0xf) * bs;
1744 rgba[i][aDst] = ((p >> 12) ) * as;
1745 }
1746 }
1747 break;
1748 case GL_UNSIGNED_SHORT_5_5_5_1:
1749 if (!intFormat) {
1750 rs = gs = bs = 1.0F / 31.0F;
1751 }
1752 if (swapBytes) {
1753 const GLushort *ussrc = (const GLushort *) src;
1754 GLuint i;
1755 for (i = 0; i < n; i ++) {
1756 GLushort p = ussrc[i];
1757 SWAP2BYTE(p);
1758 rgba[i][rDst] = ((p >> 11) ) * rs;
1759 rgba[i][gDst] = ((p >> 6) & 0x1f) * gs;
1760 rgba[i][bDst] = ((p >> 1) & 0x1f) * bs;
1761 rgba[i][aDst] = ((p ) & 0x1) * as;
1762 }
1763 }
1764 else {
1765 const GLushort *ussrc = (const GLushort *) src;
1766 GLuint i;
1767 for (i = 0; i < n; i ++) {
1768 GLushort p = ussrc[i];
1769 rgba[i][rDst] = ((p >> 11) ) * rs;
1770 rgba[i][gDst] = ((p >> 6) & 0x1f) * gs;
1771 rgba[i][bDst] = ((p >> 1) & 0x1f) * bs;
1772 rgba[i][aDst] = ((p ) & 0x1) * as;
1773 }
1774 }
1775 break;
1776 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1777 if (!intFormat) {
1778 rs = gs = bs = 1.0F / 31.0F;
1779 }
1780 if (swapBytes) {
1781 const GLushort *ussrc = (const GLushort *) src;
1782 GLuint i;
1783 for (i = 0; i < n; i ++) {
1784 GLushort p = ussrc[i];
1785 SWAP2BYTE(p);
1786 rgba[i][rDst] = ((p ) & 0x1f) * rs;
1787 rgba[i][gDst] = ((p >> 5) & 0x1f) * gs;
1788 rgba[i][bDst] = ((p >> 10) & 0x1f) * bs;
1789 rgba[i][aDst] = ((p >> 15) ) * as;
1790 }
1791 }
1792 else {
1793 const GLushort *ussrc = (const GLushort *) src;
1794 GLuint i;
1795 for (i = 0; i < n; i ++) {
1796 GLushort p = ussrc[i];
1797 rgba[i][rDst] = ((p ) & 0x1f) * rs;
1798 rgba[i][gDst] = ((p >> 5) & 0x1f) * gs;
1799 rgba[i][bDst] = ((p >> 10) & 0x1f) * bs;
1800 rgba[i][aDst] = ((p >> 15) ) * as;
1801 }
1802 }
1803 break;
1804 case GL_UNSIGNED_INT_8_8_8_8:
1805 if (swapBytes) {
1806 const GLuint *uisrc = (const GLuint *) src;
1807 GLuint i;
1808 if (intFormat) {
1809 for (i = 0; i < n; i ++) {
1810 GLuint p = uisrc[i];
1811 rgba[i][rDst] = (GLfloat) ((p ) & 0xff);
1812 rgba[i][gDst] = (GLfloat) ((p >> 8) & 0xff);
1813 rgba[i][bDst] = (GLfloat) ((p >> 16) & 0xff);
1814 rgba[i][aDst] = (GLfloat) ((p >> 24) );
1815 }
1816 }
1817 else {
1818 for (i = 0; i < n; i ++) {
1819 GLuint p = uisrc[i];
1820 rgba[i][rDst] = UBYTE_TO_FLOAT((p ) & 0xff);
1821 rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
1822 rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
1823 rgba[i][aDst] = UBYTE_TO_FLOAT((p >> 24) );
1824 }
1825 }
1826 }
1827 else {
1828 const GLuint *uisrc = (const GLuint *) src;
1829 GLuint i;
1830 if (intFormat) {
1831 for (i = 0; i < n; i ++) {
1832 GLuint p = uisrc[i];
1833 rgba[i][rDst] = (GLfloat) ((p >> 24) );
1834 rgba[i][gDst] = (GLfloat) ((p >> 16) & 0xff);
1835 rgba[i][bDst] = (GLfloat) ((p >> 8) & 0xff);
1836 rgba[i][aDst] = (GLfloat) ((p ) & 0xff);
1837 }
1838 }
1839 else {
1840 for (i = 0; i < n; i ++) {
1841 GLuint p = uisrc[i];
1842 rgba[i][rDst] = UBYTE_TO_FLOAT((p >> 24) );
1843 rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
1844 rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
1845 rgba[i][aDst] = UBYTE_TO_FLOAT((p ) & 0xff);
1846 }
1847 }
1848 }
1849 break;
1850 case GL_UNSIGNED_INT_8_8_8_8_REV:
1851 if (swapBytes) {
1852 const GLuint *uisrc = (const GLuint *) src;
1853 GLuint i;
1854 if (intFormat) {
1855 for (i = 0; i < n; i ++) {
1856 GLuint p = uisrc[i];
1857 rgba[i][rDst] = (GLfloat) ((p >> 24) );
1858 rgba[i][gDst] = (GLfloat) ((p >> 16) & 0xff);
1859 rgba[i][bDst] = (GLfloat) ((p >> 8) & 0xff);
1860 rgba[i][aDst] = (GLfloat) ((p ) & 0xff);
1861 }
1862 }
1863 else {
1864 for (i = 0; i < n; i ++) {
1865 GLuint p = uisrc[i];
1866 rgba[i][rDst] = UBYTE_TO_FLOAT((p >> 24) );
1867 rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
1868 rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
1869 rgba[i][aDst] = UBYTE_TO_FLOAT((p ) & 0xff);
1870 }
1871 }
1872 }
1873 else {
1874 const GLuint *uisrc = (const GLuint *) src;
1875 GLuint i;
1876 if (intFormat) {
1877 for (i = 0; i < n; i ++) {
1878 GLuint p = uisrc[i];
1879 rgba[i][rDst] = (GLfloat) ((p ) & 0xff);
1880 rgba[i][gDst] = (GLfloat) ((p >> 8) & 0xff);
1881 rgba[i][bDst] = (GLfloat) ((p >> 16) & 0xff);
1882 rgba[i][aDst] = (GLfloat) ((p >> 24) );
1883 }
1884 }
1885 else {
1886 for (i = 0; i < n; i ++) {
1887 GLuint p = uisrc[i];
1888 rgba[i][rDst] = UBYTE_TO_FLOAT((p ) & 0xff);
1889 rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
1890 rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
1891 rgba[i][aDst] = UBYTE_TO_FLOAT((p >> 24) );
1892 }
1893 }
1894 }
1895 break;
1896 case GL_UNSIGNED_INT_10_10_10_2:
1897 if (!intFormat) {
1898 rs = 1.0F / 1023.0F;
1899 gs = 1.0F / 1023.0F;
1900 bs = 1.0F / 1023.0F;
1901 as = 1.0F / 3.0F;
1902 }
1903 if (swapBytes) {
1904 const GLuint *uisrc = (const GLuint *) src;
1905 GLuint i;
1906 for (i = 0; i < n; i ++) {
1907 GLuint p = uisrc[i];
1908 SWAP4BYTE(p);
1909 rgba[i][rDst] = ((p >> 22) ) * rs;
1910 rgba[i][gDst] = ((p >> 12) & 0x3ff) * gs;
1911 rgba[i][bDst] = ((p >> 2) & 0x3ff) * bs;
1912 rgba[i][aDst] = ((p ) & 0x3 ) * as;
1913 }
1914 }
1915 else {
1916 const GLuint *uisrc = (const GLuint *) src;
1917 GLuint i;
1918 for (i = 0; i < n; i ++) {
1919 GLuint p = uisrc[i];
1920 rgba[i][rDst] = ((p >> 22) ) * rs;
1921 rgba[i][gDst] = ((p >> 12) & 0x3ff) * gs;
1922 rgba[i][bDst] = ((p >> 2) & 0x3ff) * bs;
1923 rgba[i][aDst] = ((p ) & 0x3 ) * as;
1924 }
1925 }
1926 break;
1927 case GL_UNSIGNED_INT_2_10_10_10_REV:
1928 if (!intFormat) {
1929 rs = 1.0F / 1023.0F;
1930 gs = 1.0F / 1023.0F;
1931 bs = 1.0F / 1023.0F;
1932 as = 1.0F / 3.0F;
1933 }
1934 if (swapBytes) {
1935 const GLuint *uisrc = (const GLuint *) src;
1936 GLuint i;
1937 for (i = 0; i < n; i ++) {
1938 GLuint p = uisrc[i];
1939 SWAP4BYTE(p);
1940 rgba[i][rDst] = ((p ) & 0x3ff) * rs;
1941 rgba[i][gDst] = ((p >> 10) & 0x3ff) * gs;
1942 rgba[i][bDst] = ((p >> 20) & 0x3ff) * bs;
1943 if (aSrc < 0) {
1944 rgba[i][aDst] = 1.0F;
1945 } else {
1946 rgba[i][aDst] = (p >> 30) * as;
1947 }
1948 }
1949 }
1950 else {
1951 const GLuint *uisrc = (const GLuint *) src;
1952 GLuint i;
1953 for (i = 0; i < n; i ++) {
1954 GLuint p = uisrc[i];
1955 rgba[i][rDst] = ((p ) & 0x3ff) * rs;
1956 rgba[i][gDst] = ((p >> 10) & 0x3ff) * gs;
1957 rgba[i][bDst] = ((p >> 20) & 0x3ff) * bs;
1958 if (aSrc < 0) {
1959 rgba[i][aDst] = 1.0F;
1960 } else {
1961 rgba[i][aDst] = (p >> 30) * as;
1962 }
1963 }
1964 }
1965 break;
1966 case GL_UNSIGNED_INT_5_9_9_9_REV:
1967 if (swapBytes) {
1968 const GLuint *uisrc = (const GLuint *) src;
1969 GLuint i;
1970 GLfloat f[3];
1971 for (i = 0; i < n; i ++) {
1972 GLuint p = uisrc[i];
1973 SWAP4BYTE(p);
1974 rgb9e5_to_float3(p, f);
1975 rgba[i][rDst] = f[0];
1976 rgba[i][gDst] = f[1];
1977 rgba[i][bDst] = f[2];
1978 rgba[i][aDst] = 1.0F;
1979 }
1980 }
1981 else {
1982 const GLuint *uisrc = (const GLuint *) src;
1983 GLuint i;
1984 GLfloat f[3];
1985 for (i = 0; i < n; i ++) {
1986 rgb9e5_to_float3(uisrc[i], f);
1987 rgba[i][rDst] = f[0];
1988 rgba[i][gDst] = f[1];
1989 rgba[i][bDst] = f[2];
1990 rgba[i][aDst] = 1.0F;
1991 }
1992 }
1993 break;
1994 case GL_UNSIGNED_INT_10F_11F_11F_REV:
1995 if (swapBytes) {
1996 const GLuint *uisrc = (const GLuint *) src;
1997 GLuint i;
1998 GLfloat f[3];
1999 for (i = 0; i < n; i ++) {
2000 GLuint p = uisrc[i];
2001 SWAP4BYTE(p);
2002 r11g11b10f_to_float3(p, f);
2003 rgba[i][rDst] = f[0];
2004 rgba[i][gDst] = f[1];
2005 rgba[i][bDst] = f[2];
2006 rgba[i][aDst] = 1.0F;
2007 }
2008 }
2009 else {
2010 const GLuint *uisrc = (const GLuint *) src;
2011 GLuint i;
2012 GLfloat f[3];
2013 for (i = 0; i < n; i ++) {
2014 r11g11b10f_to_float3(uisrc[i], f);
2015 rgba[i][rDst] = f[0];
2016 rgba[i][gDst] = f[1];
2017 rgba[i][bDst] = f[2];
2018 rgba[i][aDst] = 1.0F;
2019 }
2020 }
2021 break;
2022 default:
2023 _mesa_problem(NULL, "bad srcType in extract float data");
2024 break;
2025 }
2026 #undef PROCESS
2027 }
2028
2029
2030 static inline GLuint
2031 clamp_float_to_uint(GLfloat f)
2032 {
2033 return f < 0.0F ? 0 : F_TO_I(f);
2034 }
2035
2036
2037 static inline GLuint
2038 clamp_half_to_uint(GLhalfARB h)
2039 {
2040 GLfloat f = _mesa_half_to_float(h);
2041 return f < 0.0F ? 0 : F_TO_I(f);
2042 }
2043
2044
2045 /**
2046 * \sa extract_float_rgba()
2047 */
2048 static void
2049 extract_uint_rgba(GLuint n, GLuint rgba[][4],
2050 GLenum srcFormat, GLenum srcType, const GLvoid *src,
2051 GLboolean swapBytes)
2052 {
2053 GLint rSrc, gSrc, bSrc, aSrc;
2054 GLint stride;
2055 GLint rDst, bDst, gDst, aDst;
2056
2057 ASSERT(srcFormat == GL_RED ||
2058 srcFormat == GL_GREEN ||
2059 srcFormat == GL_BLUE ||
2060 srcFormat == GL_ALPHA ||
2061 srcFormat == GL_LUMINANCE ||
2062 srcFormat == GL_LUMINANCE_ALPHA ||
2063 srcFormat == GL_INTENSITY ||
2064 srcFormat == GL_RG ||
2065 srcFormat == GL_RGB ||
2066 srcFormat == GL_BGR ||
2067 srcFormat == GL_RGBA ||
2068 srcFormat == GL_BGRA ||
2069 srcFormat == GL_ABGR_EXT ||
2070 srcFormat == GL_RED_INTEGER_EXT ||
2071 srcFormat == GL_RG_INTEGER ||
2072 srcFormat == GL_GREEN_INTEGER_EXT ||
2073 srcFormat == GL_BLUE_INTEGER_EXT ||
2074 srcFormat == GL_ALPHA_INTEGER_EXT ||
2075 srcFormat == GL_RGB_INTEGER_EXT ||
2076 srcFormat == GL_RGBA_INTEGER_EXT ||
2077 srcFormat == GL_BGR_INTEGER_EXT ||
2078 srcFormat == GL_BGRA_INTEGER_EXT ||
2079 srcFormat == GL_LUMINANCE_INTEGER_EXT ||
2080 srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);
2081
2082 ASSERT(srcType == GL_UNSIGNED_BYTE ||
2083 srcType == GL_BYTE ||
2084 srcType == GL_UNSIGNED_SHORT ||
2085 srcType == GL_SHORT ||
2086 srcType == GL_UNSIGNED_INT ||
2087 srcType == GL_INT ||
2088 srcType == GL_HALF_FLOAT_ARB ||
2089 srcType == GL_FLOAT ||
2090 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
2091 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
2092 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
2093 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
2094 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
2095 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
2096 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
2097 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
2098 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
2099 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
2100 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
2101 srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
2102 srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
2103 srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
2104
2105 get_component_mapping(srcFormat,
2106 &rSrc, &gSrc, &bSrc, &aSrc,
2107 &rDst, &gDst, &bDst, &aDst);
2108
2109 stride = _mesa_components_in_format(srcFormat);
2110
2111 #define PROCESS(SRC_INDEX, DST_INDEX, DEFAULT, TYPE, CONVERSION) \
2112 if ((SRC_INDEX) < 0) { \
2113 GLuint i; \
2114 for (i = 0; i < n; i++) { \
2115 rgba[i][DST_INDEX] = DEFAULT; \
2116 } \
2117 } \
2118 else if (swapBytes) { \
2119 const TYPE *s = (const TYPE *) src; \
2120 GLuint i; \
2121 for (i = 0; i < n; i++) { \
2122 TYPE value = s[SRC_INDEX]; \
2123 if (sizeof(TYPE) == 2) { \
2124 SWAP2BYTE(value); \
2125 } \
2126 else if (sizeof(TYPE) == 4) { \
2127 SWAP4BYTE(value); \
2128 } \
2129 rgba[i][DST_INDEX] = CONVERSION(value); \
2130 s += stride; \
2131 } \
2132 } \
2133 else { \
2134 const TYPE *s = (const TYPE *) src; \
2135 GLuint i; \
2136 for (i = 0; i < n; i++) { \
2137 rgba[i][DST_INDEX] = CONVERSION(s[SRC_INDEX]); \
2138 s += stride; \
2139 } \
2140 }
2141
2142 switch (srcType) {
2143 case GL_UNSIGNED_BYTE:
2144 PROCESS(rSrc, RCOMP, 0, GLubyte, (GLuint));
2145 PROCESS(gSrc, GCOMP, 0, GLubyte, (GLuint));
2146 PROCESS(bSrc, BCOMP, 0, GLubyte, (GLuint));
2147 PROCESS(aSrc, ACOMP, 1, GLubyte, (GLuint));
2148 break;
2149 case GL_BYTE:
2150 PROCESS(rSrc, RCOMP, 0, GLbyte, (GLuint));
2151 PROCESS(gSrc, GCOMP, 0, GLbyte, (GLuint));
2152 PROCESS(bSrc, BCOMP, 0, GLbyte, (GLuint));
2153 PROCESS(aSrc, ACOMP, 1, GLbyte, (GLuint));
2154 break;
2155 case GL_UNSIGNED_SHORT:
2156 PROCESS(rSrc, RCOMP, 0, GLushort, (GLuint));
2157 PROCESS(gSrc, GCOMP, 0, GLushort, (GLuint));
2158 PROCESS(bSrc, BCOMP, 0, GLushort, (GLuint));
2159 PROCESS(aSrc, ACOMP, 1, GLushort, (GLuint));
2160 break;
2161 case GL_SHORT:
2162 PROCESS(rSrc, RCOMP, 0, GLshort, (GLuint));
2163 PROCESS(gSrc, GCOMP, 0, GLshort, (GLuint));
2164 PROCESS(bSrc, BCOMP, 0, GLshort, (GLuint));
2165 PROCESS(aSrc, ACOMP, 1, GLshort, (GLuint));
2166 break;
2167 case GL_UNSIGNED_INT:
2168 PROCESS(rSrc, RCOMP, 0, GLuint, (GLuint));
2169 PROCESS(gSrc, GCOMP, 0, GLuint, (GLuint));
2170 PROCESS(bSrc, BCOMP, 0, GLuint, (GLuint));
2171 PROCESS(aSrc, ACOMP, 1, GLuint, (GLuint));
2172 break;
2173 case GL_INT:
2174 PROCESS(rSrc, RCOMP, 0, GLint, (GLuint));
2175 PROCESS(gSrc, GCOMP, 0, GLint, (GLuint));
2176 PROCESS(bSrc, BCOMP, 0, GLint, (GLuint));
2177 PROCESS(aSrc, ACOMP, 1, GLint, (GLuint));
2178 break;
2179 case GL_FLOAT:
2180 PROCESS(rSrc, RCOMP, 0, GLfloat, clamp_float_to_uint);
2181 PROCESS(gSrc, GCOMP, 0, GLfloat, clamp_float_to_uint);
2182 PROCESS(bSrc, BCOMP, 0, GLfloat, clamp_float_to_uint);
2183 PROCESS(aSrc, ACOMP, 1, GLfloat, clamp_float_to_uint);
2184 break;
2185 case GL_HALF_FLOAT_ARB:
2186 PROCESS(rSrc, RCOMP, 0, GLhalfARB, clamp_half_to_uint);
2187 PROCESS(gSrc, GCOMP, 0, GLhalfARB, clamp_half_to_uint);
2188 PROCESS(bSrc, BCOMP, 0, GLhalfARB, clamp_half_to_uint);
2189 PROCESS(aSrc, ACOMP, 1, GLhalfARB, clamp_half_to_uint);
2190 break;
2191 case GL_UNSIGNED_BYTE_3_3_2:
2192 {
2193 const GLubyte *ubsrc = (const GLubyte *) src;
2194 GLuint i;
2195 for (i = 0; i < n; i ++) {
2196 GLubyte p = ubsrc[i];
2197 rgba[i][rDst] = ((p >> 5) );
2198 rgba[i][gDst] = ((p >> 2) & 0x7);
2199 rgba[i][bDst] = ((p ) & 0x3);
2200 rgba[i][aDst] = 1;
2201 }
2202 }
2203 break;
2204 case GL_UNSIGNED_BYTE_2_3_3_REV:
2205 {
2206 const GLubyte *ubsrc = (const GLubyte *) src;
2207 GLuint i;
2208 for (i = 0; i < n; i ++) {
2209 GLubyte p = ubsrc[i];
2210 rgba[i][rDst] = ((p ) & 0x7);
2211 rgba[i][gDst] = ((p >> 3) & 0x7);
2212 rgba[i][bDst] = ((p >> 6) );
2213 rgba[i][aDst] = 1;
2214 }
2215 }
2216 break;
2217 case GL_UNSIGNED_SHORT_5_6_5:
2218 if (swapBytes) {
2219 const GLushort *ussrc = (const GLushort *) src;
2220 GLuint i;
2221 for (i = 0; i < n; i ++) {
2222 GLushort p = ussrc[i];
2223 SWAP2BYTE(p);
2224 rgba[i][rDst] = ((p >> 11) );
2225 rgba[i][gDst] = ((p >> 5) & 0x3f);
2226 rgba[i][bDst] = ((p ) & 0x1f);
2227 rgba[i][aDst] = 1;
2228 }
2229 }
2230 else {
2231 const GLushort *ussrc = (const GLushort *) src;
2232 GLuint i;
2233 for (i = 0; i < n; i ++) {
2234 GLushort p = ussrc[i];
2235 rgba[i][rDst] = ((p >> 11) );
2236 rgba[i][gDst] = ((p >> 5) & 0x3f);
2237 rgba[i][bDst] = ((p ) & 0x1f);
2238 rgba[i][aDst] = 1;
2239 }
2240 }
2241 break;
2242 case GL_UNSIGNED_SHORT_5_6_5_REV:
2243 if (swapBytes) {
2244 const GLushort *ussrc = (const GLushort *) src;
2245 GLuint i;
2246 for (i = 0; i < n; i ++) {
2247 GLushort p = ussrc[i];
2248 SWAP2BYTE(p);
2249 rgba[i][rDst] = ((p ) & 0x1f);
2250 rgba[i][gDst] = ((p >> 5) & 0x3f);
2251 rgba[i][bDst] = ((p >> 11) );
2252 rgba[i][aDst] = 1;
2253 }
2254 }
2255 else {
2256 const GLushort *ussrc = (const GLushort *) src;
2257 GLuint i;
2258 for (i = 0; i < n; i ++) {
2259 GLushort p = ussrc[i];
2260 rgba[i][rDst] = ((p ) & 0x1f);
2261 rgba[i][gDst] = ((p >> 5) & 0x3f);
2262 rgba[i][bDst] = ((p >> 11) );
2263 rgba[i][aDst] = 1;
2264 }
2265 }
2266 break;
2267 case GL_UNSIGNED_SHORT_4_4_4_4:
2268 if (swapBytes) {
2269 const GLushort *ussrc = (const GLushort *) src;
2270 GLuint i;
2271 for (i = 0; i < n; i ++) {
2272 GLushort p = ussrc[i];
2273 SWAP2BYTE(p);
2274 rgba[i][rDst] = ((p >> 12) );
2275 rgba[i][gDst] = ((p >> 8) & 0xf);
2276 rgba[i][bDst] = ((p >> 4) & 0xf);
2277 rgba[i][aDst] = ((p ) & 0xf);
2278 }
2279 }
2280 else {
2281 const GLushort *ussrc = (const GLushort *) src;
2282 GLuint i;
2283 for (i = 0; i < n; i ++) {
2284 GLushort p = ussrc[i];
2285 rgba[i][rDst] = ((p >> 12) );
2286 rgba[i][gDst] = ((p >> 8) & 0xf);
2287 rgba[i][bDst] = ((p >> 4) & 0xf);
2288 rgba[i][aDst] = ((p ) & 0xf);
2289 }
2290 }
2291 break;
2292 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
2293 if (swapBytes) {
2294 const GLushort *ussrc = (const GLushort *) src;
2295 GLuint i;
2296 for (i = 0; i < n; i ++) {
2297 GLushort p = ussrc[i];
2298 SWAP2BYTE(p);
2299 rgba[i][rDst] = ((p ) & 0xf);
2300 rgba[i][gDst] = ((p >> 4) & 0xf);
2301 rgba[i][bDst] = ((p >> 8) & 0xf);
2302 rgba[i][aDst] = ((p >> 12) );
2303 }
2304 }
2305 else {
2306 const GLushort *ussrc = (const GLushort *) src;
2307 GLuint i;
2308 for (i = 0; i < n; i ++) {
2309 GLushort p = ussrc[i];
2310 rgba[i][rDst] = ((p ) & 0xf);
2311 rgba[i][gDst] = ((p >> 4) & 0xf);
2312 rgba[i][bDst] = ((p >> 8) & 0xf);
2313 rgba[i][aDst] = ((p >> 12) );
2314 }
2315 }
2316 break;
2317 case GL_UNSIGNED_SHORT_5_5_5_1:
2318 if (swapBytes) {
2319 const GLushort *ussrc = (const GLushort *) src;
2320 GLuint i;
2321 for (i = 0; i < n; i ++) {
2322 GLushort p = ussrc[i];
2323 SWAP2BYTE(p);
2324 rgba[i][rDst] = ((p >> 11) );
2325 rgba[i][gDst] = ((p >> 6) & 0x1f);
2326 rgba[i][bDst] = ((p >> 1) & 0x1f);
2327 rgba[i][aDst] = ((p ) & 0x1 );
2328 }
2329 }
2330 else {
2331 const GLushort *ussrc = (const GLushort *) src;
2332 GLuint i;
2333 for (i = 0; i < n; i ++) {
2334 GLushort p = ussrc[i];
2335 rgba[i][rDst] = ((p >> 11) );
2336 rgba[i][gDst] = ((p >> 6) & 0x1f);
2337 rgba[i][bDst] = ((p >> 1) & 0x1f);
2338 rgba[i][aDst] = ((p ) & 0x1 );
2339 }
2340 }
2341 break;
2342 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
2343 if (swapBytes) {
2344 const GLushort *ussrc = (const GLushort *) src;
2345 GLuint i;
2346 for (i = 0; i < n; i ++) {
2347 GLushort p = ussrc[i];
2348 SWAP2BYTE(p);
2349 rgba[i][rDst] = ((p ) & 0x1f);
2350 rgba[i][gDst] = ((p >> 5) & 0x1f);
2351 rgba[i][bDst] = ((p >> 10) & 0x1f);
2352 rgba[i][aDst] = ((p >> 15) );
2353 }
2354 }
2355 else {
2356 const GLushort *ussrc = (const GLushort *) src;
2357 GLuint i;
2358 for (i = 0; i < n; i ++) {
2359 GLushort p = ussrc[i];
2360 rgba[i][rDst] = ((p ) & 0x1f);
2361 rgba[i][gDst] = ((p >> 5) & 0x1f);
2362 rgba[i][bDst] = ((p >> 10) & 0x1f);
2363 rgba[i][aDst] = ((p >> 15) );
2364 }
2365 }
2366 break;
2367 case GL_UNSIGNED_INT_8_8_8_8:
2368 if (swapBytes) {
2369 const GLuint *uisrc = (const GLuint *) src;
2370 GLuint i;
2371 for (i = 0; i < n; i ++) {
2372 GLuint p = uisrc[i];
2373 rgba[i][rDst] = ((p ) & 0xff);
2374 rgba[i][gDst] = ((p >> 8) & 0xff);
2375 rgba[i][bDst] = ((p >> 16) & 0xff);
2376 rgba[i][aDst] = ((p >> 24) );
2377 }
2378 }
2379 else {
2380 const GLuint *uisrc = (const GLuint *) src;
2381 GLuint i;
2382 for (i = 0; i < n; i ++) {
2383 GLuint p = uisrc[i];
2384 rgba[i][rDst] = ((p >> 24) );
2385 rgba[i][gDst] = ((p >> 16) & 0xff);
2386 rgba[i][bDst] = ((p >> 8) & 0xff);
2387 rgba[i][aDst] = ((p ) & 0xff);
2388 }
2389 }
2390 break;
2391 case GL_UNSIGNED_INT_8_8_8_8_REV:
2392 if (swapBytes) {
2393 const GLuint *uisrc = (const GLuint *) src;
2394 GLuint i;
2395 for (i = 0; i < n; i ++) {
2396 GLuint p = uisrc[i];
2397 rgba[i][rDst] = ((p >> 24) );
2398 rgba[i][gDst] = ((p >> 16) & 0xff);
2399 rgba[i][bDst] = ((p >> 8) & 0xff);
2400 rgba[i][aDst] = ((p ) & 0xff);
2401 }
2402 }
2403 else {
2404 const GLuint *uisrc = (const GLuint *) src;
2405 GLuint i;
2406 for (i = 0; i < n; i ++) {
2407 GLuint p = uisrc[i];
2408 rgba[i][rDst] = ((p ) & 0xff);
2409 rgba[i][gDst] = ((p >> 8) & 0xff);
2410 rgba[i][bDst] = ((p >> 16) & 0xff);
2411 rgba[i][aDst] = ((p >> 24) );
2412 }
2413 }
2414 break;
2415 case GL_UNSIGNED_INT_10_10_10_2:
2416 if (swapBytes) {
2417 const GLuint *uisrc = (const GLuint *) src;
2418 GLuint i;
2419 for (i = 0; i < n; i ++) {
2420 GLuint p = uisrc[i];
2421 SWAP4BYTE(p);
2422 rgba[i][rDst] = ((p >> 22) );
2423 rgba[i][gDst] = ((p >> 12) & 0x3ff);
2424 rgba[i][bDst] = ((p >> 2) & 0x3ff);
2425 rgba[i][aDst] = ((p ) & 0x3 );
2426 }
2427 }
2428 else {
2429 const GLuint *uisrc = (const GLuint *) src;
2430 GLuint i;
2431 for (i = 0; i < n; i ++) {
2432 GLuint p = uisrc[i];
2433 rgba[i][rDst] = ((p >> 22) );
2434 rgba[i][gDst] = ((p >> 12) & 0x3ff);
2435 rgba[i][bDst] = ((p >> 2) & 0x3ff);
2436 rgba[i][aDst] = ((p ) & 0x3 );
2437 }
2438 }
2439 break;
2440 case GL_UNSIGNED_INT_2_10_10_10_REV:
2441 if (swapBytes) {
2442 const GLuint *uisrc = (const GLuint *) src;
2443 GLuint i;
2444 for (i = 0; i < n; i ++) {
2445 GLuint p = uisrc[i];
2446 SWAP4BYTE(p);
2447 rgba[i][rDst] = ((p ) & 0x3ff);
2448 rgba[i][gDst] = ((p >> 10) & 0x3ff);
2449 rgba[i][bDst] = ((p >> 20) & 0x3ff);
2450 rgba[i][aDst] = ((p >> 30) );
2451 }
2452 }
2453 else {
2454 const GLuint *uisrc = (const GLuint *) src;
2455 GLuint i;
2456 for (i = 0; i < n; i ++) {
2457 GLuint p = uisrc[i];
2458 rgba[i][rDst] = ((p ) & 0x3ff);
2459 rgba[i][gDst] = ((p >> 10) & 0x3ff);
2460 rgba[i][bDst] = ((p >> 20) & 0x3ff);
2461 rgba[i][aDst] = ((p >> 30) );
2462 }
2463 }
2464 break;
2465 case GL_UNSIGNED_INT_5_9_9_9_REV:
2466 if (swapBytes) {
2467 const GLuint *uisrc = (const GLuint *) src;
2468 GLuint i;
2469 float f[3];
2470 for (i = 0; i < n; i ++) {
2471 GLuint p = uisrc[i];
2472 SWAP4BYTE(p);
2473 rgb9e5_to_float3(p, f);
2474 rgba[i][rDst] = clamp_float_to_uint(f[0]);
2475 rgba[i][gDst] = clamp_float_to_uint(f[1]);
2476 rgba[i][bDst] = clamp_float_to_uint(f[2]);
2477 rgba[i][aDst] = 1;
2478 }
2479 }
2480 else {
2481 const GLuint *uisrc = (const GLuint *) src;
2482 GLuint i;
2483 float f[3];
2484 for (i = 0; i < n; i ++) {
2485 GLuint p = uisrc[i];
2486 rgb9e5_to_float3(p, f);
2487 rgba[i][rDst] = clamp_float_to_uint(f[0]);
2488 rgba[i][gDst] = clamp_float_to_uint(f[1]);
2489 rgba[i][bDst] = clamp_float_to_uint(f[2]);
2490 rgba[i][aDst] = 1;
2491 }
2492 }
2493 break;
2494 case GL_UNSIGNED_INT_10F_11F_11F_REV:
2495 if (swapBytes) {
2496 const GLuint *uisrc = (const GLuint *) src;
2497 GLuint i;
2498 float f[3];
2499 for (i = 0; i < n; i ++) {
2500 GLuint p = uisrc[i];
2501 SWAP4BYTE(p);
2502 r11g11b10f_to_float3(p, f);
2503 rgba[i][rDst] = clamp_float_to_uint(f[0]);
2504 rgba[i][gDst] = clamp_float_to_uint(f[1]);
2505 rgba[i][bDst] = clamp_float_to_uint(f[2]);
2506 rgba[i][aDst] = 1;
2507 }
2508 }
2509 else {
2510 const GLuint *uisrc = (const GLuint *) src;
2511 GLuint i;
2512 float f[3];
2513 for (i = 0; i < n; i ++) {
2514 GLuint p = uisrc[i];
2515 r11g11b10f_to_float3(p, f);
2516 rgba[i][rDst] = clamp_float_to_uint(f[0]);
2517 rgba[i][gDst] = clamp_float_to_uint(f[1]);
2518 rgba[i][bDst] = clamp_float_to_uint(f[2]);
2519 rgba[i][aDst] = 1;
2520 }
2521 }
2522 break;
2523 default:
2524 _mesa_problem(NULL, "bad srcType in extract uint data");
2525 break;
2526 }
2527 #undef PROCESS
2528 }
2529
2530
2531
2532 /*
2533 * Unpack a row of color image data from a client buffer according to
2534 * the pixel unpacking parameters.
2535 * Return GLubyte values in the specified dest image format.
2536 * This is used by glDrawPixels and glTexImage?D().
2537 * \param ctx - the context
2538 * n - number of pixels in the span
2539 * dstFormat - format of destination color array
2540 * dest - the destination color array
2541 * srcFormat - source image format
2542 * srcType - source image data type
2543 * source - source image pointer
2544 * srcPacking - pixel unpacking parameters
2545 * transferOps - bitmask of IMAGE_*_BIT values of operations to apply
2546 *
2547 * XXX perhaps expand this to process whole images someday.
2548 */
2549 void
2550 _mesa_unpack_color_span_ubyte(struct gl_context *ctx,
2551 GLuint n, GLenum dstFormat, GLubyte dest[],
2552 GLenum srcFormat, GLenum srcType,
2553 const GLvoid *source,
2554 const struct gl_pixelstore_attrib *srcPacking,
2555 GLbitfield transferOps )
2556 {
2557 GLboolean intFormat = _mesa_is_enum_format_integer(srcFormat);
2558 ASSERT(dstFormat == GL_ALPHA ||
2559 dstFormat == GL_LUMINANCE ||
2560 dstFormat == GL_LUMINANCE_ALPHA ||
2561 dstFormat == GL_INTENSITY ||
2562 dstFormat == GL_RED ||
2563 dstFormat == GL_RG ||
2564 dstFormat == GL_RGB ||
2565 dstFormat == GL_RGBA);
2566
2567 ASSERT(srcFormat == GL_RED ||
2568 srcFormat == GL_GREEN ||
2569 srcFormat == GL_BLUE ||
2570 srcFormat == GL_ALPHA ||
2571 srcFormat == GL_LUMINANCE ||
2572 srcFormat == GL_LUMINANCE_ALPHA ||
2573 srcFormat == GL_INTENSITY ||
2574 srcFormat == GL_RG ||
2575 srcFormat == GL_RGB ||
2576 srcFormat == GL_BGR ||
2577 srcFormat == GL_RGBA ||
2578 srcFormat == GL_BGRA ||
2579 srcFormat == GL_ABGR_EXT ||
2580 srcFormat == GL_COLOR_INDEX);
2581
2582 ASSERT(srcType == GL_BITMAP ||
2583 srcType == GL_UNSIGNED_BYTE ||
2584 srcType == GL_BYTE ||
2585 srcType == GL_UNSIGNED_SHORT ||
2586 srcType == GL_SHORT ||
2587 srcType == GL_UNSIGNED_INT ||
2588 srcType == GL_INT ||
2589 srcType == GL_HALF_FLOAT_ARB ||
2590 srcType == GL_FLOAT ||
2591 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
2592 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
2593 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
2594 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
2595 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
2596 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
2597 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
2598 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
2599 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
2600 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
2601 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
2602 srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
2603 srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
2604 srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
2605
2606 /* EXT_texture_integer specifies no transfer ops on integer
2607 * types in the resolved issues section. Just set them to 0
2608 * for integer surfaces.
2609 */
2610 if (intFormat)
2611 transferOps = 0;
2612
2613 /* Try simple cases first */
2614 if (transferOps == 0) {
2615 if (srcType == GL_UNSIGNED_BYTE) {
2616 if (dstFormat == GL_RGBA) {
2617 if (srcFormat == GL_RGBA) {
2618 memcpy( dest, source, n * 4 * sizeof(GLubyte) );
2619 return;
2620 }
2621 else if (srcFormat == GL_RGB) {
2622 GLuint i;
2623 const GLubyte *src = (const GLubyte *) source;
2624 GLubyte *dst = dest;
2625 for (i = 0; i < n; i++) {
2626 dst[0] = src[0];
2627 dst[1] = src[1];
2628 dst[2] = src[2];
2629 dst[3] = 255;
2630 src += 3;
2631 dst += 4;
2632 }
2633 return;
2634 }
2635 }
2636 else if (dstFormat == GL_RGB) {
2637 if (srcFormat == GL_RGB) {
2638 memcpy( dest, source, n * 3 * sizeof(GLubyte) );
2639 return;
2640 }
2641 else if (srcFormat == GL_RGBA) {
2642 GLuint i;
2643 const GLubyte *src = (const GLubyte *) source;
2644 GLubyte *dst = dest;
2645 for (i = 0; i < n; i++) {
2646 dst[0] = src[0];
2647 dst[1] = src[1];
2648 dst[2] = src[2];
2649 src += 4;
2650 dst += 3;
2651 }
2652 return;
2653 }
2654 }
2655 else if (dstFormat == srcFormat) {
2656 GLint comps = _mesa_components_in_format(srcFormat);
2657 assert(comps > 0);
2658 memcpy( dest, source, n * comps * sizeof(GLubyte) );
2659 return;
2660 }
2661 }
2662 }
2663
2664
2665 /* general solution begins here */
2666 {
2667 GLint dstComponents;
2668 GLint rDst, gDst, bDst, aDst, lDst, iDst;
2669 GLfloat (*rgba)[4] = malloc(4 * n * sizeof(GLfloat));
2670
2671 if (!rgba) {
2672 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
2673 return;
2674 }
2675
2676 dstComponents = _mesa_components_in_format( dstFormat );
2677 /* source & dest image formats should have been error checked by now */
2678 assert(dstComponents > 0);
2679
2680 /*
2681 * Extract image data and convert to RGBA floats
2682 */
2683 if (srcFormat == GL_COLOR_INDEX) {
2684 GLuint *indexes = malloc(n * sizeof(GLuint));
2685
2686 if (!indexes) {
2687 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
2688 free(rgba);
2689 return;
2690 }
2691
2692 extract_uint_indexes(n, indexes, srcFormat, srcType, source,
2693 srcPacking);
2694
2695 /* Convert indexes to RGBA */
2696 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
2697 _mesa_shift_and_offset_ci(ctx, n, indexes);
2698 }
2699 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
2700
2701 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
2702 * with color indexes.
2703 */
2704 transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT);
2705
2706 free(indexes);
2707 }
2708 else {
2709 /* non-color index data */
2710 extract_float_rgba(n, rgba, srcFormat, srcType, source,
2711 srcPacking->SwapBytes);
2712 }
2713
2714 /* Need to clamp if returning GLubytes */
2715 transferOps |= IMAGE_CLAMP_BIT;
2716
2717 if (transferOps) {
2718 _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
2719 }
2720
2721 get_component_indexes(dstFormat,
2722 &rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
2723
2724 /* Now return the GLubyte data in the requested dstFormat */
2725 if (rDst >= 0) {
2726 GLubyte *dst = dest;
2727 GLuint i;
2728 for (i = 0; i < n; i++) {
2729 CLAMPED_FLOAT_TO_UBYTE(dst[rDst], rgba[i][RCOMP]);
2730 dst += dstComponents;
2731 }
2732 }
2733
2734 if (gDst >= 0) {
2735 GLubyte *dst = dest;
2736 GLuint i;
2737 for (i = 0; i < n; i++) {
2738 CLAMPED_FLOAT_TO_UBYTE(dst[gDst], rgba[i][GCOMP]);
2739 dst += dstComponents;
2740 }
2741 }
2742
2743 if (bDst >= 0) {
2744 GLubyte *dst = dest;
2745 GLuint i;
2746 for (i = 0; i < n; i++) {
2747 CLAMPED_FLOAT_TO_UBYTE(dst[bDst], rgba[i][BCOMP]);
2748 dst += dstComponents;
2749 }
2750 }
2751
2752 if (aDst >= 0) {
2753 GLubyte *dst = dest;
2754 GLuint i;
2755 for (i = 0; i < n; i++) {
2756 CLAMPED_FLOAT_TO_UBYTE(dst[aDst], rgba[i][ACOMP]);
2757 dst += dstComponents;
2758 }
2759 }
2760
2761 if (iDst >= 0) {
2762 GLubyte *dst = dest;
2763 GLuint i;
2764 assert(iDst == 0);
2765 assert(dstComponents == 1);
2766 for (i = 0; i < n; i++) {
2767 /* Intensity comes from red channel */
2768 CLAMPED_FLOAT_TO_UBYTE(dst[i], rgba[i][RCOMP]);
2769 }
2770 }
2771
2772 if (lDst >= 0) {
2773 GLubyte *dst = dest;
2774 GLuint i;
2775 assert(lDst == 0);
2776 for (i = 0; i < n; i++) {
2777 /* Luminance comes from red channel */
2778 CLAMPED_FLOAT_TO_UBYTE(dst[0], rgba[i][RCOMP]);
2779 dst += dstComponents;
2780 }
2781 }
2782
2783 free(rgba);
2784 }
2785 }
2786
2787
2788 /**
2789 * Same as _mesa_unpack_color_span_ubyte(), but return GLfloat data
2790 * instead of GLubyte.
2791 */
2792 void
2793 _mesa_unpack_color_span_float( struct gl_context *ctx,
2794 GLuint n, GLenum dstFormat, GLfloat dest[],
2795 GLenum srcFormat, GLenum srcType,
2796 const GLvoid *source,
2797 const struct gl_pixelstore_attrib *srcPacking,
2798 GLbitfield transferOps )
2799 {
2800 ASSERT(dstFormat == GL_ALPHA ||
2801 dstFormat == GL_LUMINANCE ||
2802 dstFormat == GL_LUMINANCE_ALPHA ||
2803 dstFormat == GL_INTENSITY ||
2804 dstFormat == GL_RED ||
2805 dstFormat == GL_RG ||
2806 dstFormat == GL_RGB ||
2807 dstFormat == GL_RGBA);
2808
2809 ASSERT(srcFormat == GL_RED ||
2810 srcFormat == GL_GREEN ||
2811 srcFormat == GL_BLUE ||
2812 srcFormat == GL_ALPHA ||
2813 srcFormat == GL_LUMINANCE ||
2814 srcFormat == GL_LUMINANCE_ALPHA ||
2815 srcFormat == GL_INTENSITY ||
2816 srcFormat == GL_RG ||
2817 srcFormat == GL_RGB ||
2818 srcFormat == GL_BGR ||
2819 srcFormat == GL_RGBA ||
2820 srcFormat == GL_BGRA ||
2821 srcFormat == GL_ABGR_EXT ||
2822 srcFormat == GL_RED_INTEGER_EXT ||
2823 srcFormat == GL_GREEN_INTEGER_EXT ||
2824 srcFormat == GL_BLUE_INTEGER_EXT ||
2825 srcFormat == GL_ALPHA_INTEGER_EXT ||
2826 srcFormat == GL_RG_INTEGER ||
2827 srcFormat == GL_RGB_INTEGER_EXT ||
2828 srcFormat == GL_RGBA_INTEGER_EXT ||
2829 srcFormat == GL_BGR_INTEGER_EXT ||
2830 srcFormat == GL_BGRA_INTEGER_EXT ||
2831 srcFormat == GL_LUMINANCE_INTEGER_EXT ||
2832 srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT ||
2833 srcFormat == GL_COLOR_INDEX);
2834
2835 ASSERT(srcType == GL_BITMAP ||
2836 srcType == GL_UNSIGNED_BYTE ||
2837 srcType == GL_BYTE ||
2838 srcType == GL_UNSIGNED_SHORT ||
2839 srcType == GL_SHORT ||
2840 srcType == GL_UNSIGNED_INT ||
2841 srcType == GL_INT ||
2842 srcType == GL_HALF_FLOAT_ARB ||
2843 srcType == GL_FLOAT ||
2844 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
2845 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
2846 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
2847 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
2848 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
2849 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
2850 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
2851 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
2852 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
2853 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
2854 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
2855 srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
2856 srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
2857 srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
2858
2859 /* general solution, no special cases, yet */
2860 {
2861 GLint dstComponents;
2862 GLint rDst, gDst, bDst, aDst, lDst, iDst;
2863 GLfloat (*rgba)[4] = malloc(4 * n * sizeof(GLfloat));
2864 GLboolean intFormat = _mesa_is_enum_format_integer(srcFormat);
2865
2866 if (!rgba) {
2867 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
2868 return;
2869 }
2870
2871 dstComponents = _mesa_components_in_format( dstFormat );
2872 /* source & dest image formats should have been error checked by now */
2873 assert(dstComponents > 0);
2874
2875 /* EXT_texture_integer specifies no transfer ops on integer
2876 * types in the resolved issues section. Just set them to 0
2877 * for integer surfaces.
2878 */
2879 if (intFormat)
2880 transferOps = 0;
2881
2882 /*
2883 * Extract image data and convert to RGBA floats
2884 */
2885 if (srcFormat == GL_COLOR_INDEX) {
2886 GLuint *indexes = malloc(n * sizeof(GLuint));
2887
2888 if (!indexes) {
2889 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
2890 free(rgba);
2891 return;
2892 }
2893
2894 extract_uint_indexes(n, indexes, srcFormat, srcType, source,
2895 srcPacking);
2896
2897 /* Convert indexes to RGBA */
2898 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
2899 _mesa_shift_and_offset_ci(ctx, n, indexes);
2900 }
2901 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
2902
2903 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
2904 * with color indexes.
2905 */
2906 transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT);
2907
2908 free(indexes);
2909 }
2910 else {
2911 /* non-color index data */
2912 extract_float_rgba(n, rgba, srcFormat, srcType, source,
2913 srcPacking->SwapBytes);
2914 }
2915
2916 if (transferOps) {
2917 _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
2918 }
2919
2920 get_component_indexes(dstFormat,
2921 &rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
2922
2923 /* Now pack results in the requested dstFormat */
2924 if (rDst >= 0) {
2925 GLfloat *dst = dest;
2926 GLuint i;
2927 for (i = 0; i < n; i++) {
2928 dst[rDst] = rgba[i][RCOMP];
2929 dst += dstComponents;
2930 }
2931 }
2932
2933 if (gDst >= 0) {
2934 GLfloat *dst = dest;
2935 GLuint i;
2936 for (i = 0; i < n; i++) {
2937 dst[gDst] = rgba[i][GCOMP];
2938 dst += dstComponents;
2939 }
2940 }
2941
2942 if (bDst >= 0) {
2943 GLfloat *dst = dest;
2944 GLuint i;
2945 for (i = 0; i < n; i++) {
2946 dst[bDst] = rgba[i][BCOMP];
2947 dst += dstComponents;
2948 }
2949 }
2950
2951 if (aDst >= 0) {
2952 GLfloat *dst = dest;
2953 GLuint i;
2954 for (i = 0; i < n; i++) {
2955 dst[aDst] = rgba[i][ACOMP];
2956 dst += dstComponents;
2957 }
2958 }
2959
2960 if (iDst >= 0) {
2961 GLfloat *dst = dest;
2962 GLuint i;
2963 assert(iDst == 0);
2964 assert(dstComponents == 1);
2965 for (i = 0; i < n; i++) {
2966 /* Intensity comes from red channel */
2967 dst[i] = rgba[i][RCOMP];
2968 }
2969 }
2970
2971 if (lDst >= 0) {
2972 GLfloat *dst = dest;
2973 GLuint i;
2974 assert(lDst == 0);
2975 for (i = 0; i < n; i++) {
2976 /* Luminance comes from red channel */
2977 dst[0] = rgba[i][RCOMP];
2978 dst += dstComponents;
2979 }
2980 }
2981
2982 free(rgba);
2983 }
2984 }
2985
2986
2987 /**
2988 * Same as _mesa_unpack_color_span_ubyte(), but return GLuint data
2989 * instead of GLubyte.
2990 * No pixel transfer ops are applied.
2991 */
2992 void
2993 _mesa_unpack_color_span_uint(struct gl_context *ctx,
2994 GLuint n, GLenum dstFormat, GLuint *dest,
2995 GLenum srcFormat, GLenum srcType,
2996 const GLvoid *source,
2997 const struct gl_pixelstore_attrib *srcPacking)
2998 {
2999 GLuint (*rgba)[4] = malloc(n * 4 * sizeof(GLfloat));
3000
3001 if (!rgba) {
3002 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3003 return;
3004 }
3005
3006 ASSERT(dstFormat == GL_ALPHA ||
3007 dstFormat == GL_LUMINANCE ||
3008 dstFormat == GL_LUMINANCE_ALPHA ||
3009 dstFormat == GL_INTENSITY ||
3010 dstFormat == GL_RED ||
3011 dstFormat == GL_RG ||
3012 dstFormat == GL_RGB ||
3013 dstFormat == GL_RGBA);
3014
3015 ASSERT(srcFormat == GL_RED ||
3016 srcFormat == GL_GREEN ||
3017 srcFormat == GL_BLUE ||
3018 srcFormat == GL_ALPHA ||
3019 srcFormat == GL_LUMINANCE ||
3020 srcFormat == GL_LUMINANCE_ALPHA ||
3021 srcFormat == GL_INTENSITY ||
3022 srcFormat == GL_RG ||
3023 srcFormat == GL_RGB ||
3024 srcFormat == GL_BGR ||
3025 srcFormat == GL_RGBA ||
3026 srcFormat == GL_BGRA ||
3027 srcFormat == GL_ABGR_EXT ||
3028 srcFormat == GL_RED_INTEGER_EXT ||
3029 srcFormat == GL_GREEN_INTEGER_EXT ||
3030 srcFormat == GL_BLUE_INTEGER_EXT ||
3031 srcFormat == GL_ALPHA_INTEGER_EXT ||
3032 srcFormat == GL_RG_INTEGER ||
3033 srcFormat == GL_RGB_INTEGER_EXT ||
3034 srcFormat == GL_RGBA_INTEGER_EXT ||
3035 srcFormat == GL_BGR_INTEGER_EXT ||
3036 srcFormat == GL_BGRA_INTEGER_EXT ||
3037 srcFormat == GL_LUMINANCE_INTEGER_EXT ||
3038 srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);
3039
3040 ASSERT(srcType == GL_UNSIGNED_BYTE ||
3041 srcType == GL_BYTE ||
3042 srcType == GL_UNSIGNED_SHORT ||
3043 srcType == GL_SHORT ||
3044 srcType == GL_UNSIGNED_INT ||
3045 srcType == GL_INT ||
3046 srcType == GL_HALF_FLOAT_ARB ||
3047 srcType == GL_FLOAT ||
3048 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
3049 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
3050 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
3051 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
3052 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
3053 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
3054 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
3055 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
3056 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
3057 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
3058 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
3059 srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
3060 srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
3061 srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
3062
3063
3064 /* Extract image data as uint[4] pixels */
3065 extract_uint_rgba(n, rgba, srcFormat, srcType, source,
3066 srcPacking->SwapBytes);
3067
3068 if (dstFormat == GL_RGBA) {
3069 /* simple case */
3070 memcpy(dest, rgba, 4 * sizeof(GLuint) * n);
3071 }
3072 else {
3073 /* general case */
3074 GLint rDst, gDst, bDst, aDst, lDst, iDst;
3075 GLint dstComponents = _mesa_components_in_format( dstFormat );
3076
3077 assert(dstComponents > 0);
3078
3079 get_component_indexes(dstFormat,
3080 &rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
3081
3082 /* Now pack values in the requested dest format */
3083 if (rDst >= 0) {
3084 GLuint *dst = dest;
3085 GLuint i;
3086 for (i = 0; i < n; i++) {
3087 dst[rDst] = rgba[i][RCOMP];
3088 dst += dstComponents;
3089 }
3090 }
3091
3092 if (gDst >= 0) {
3093 GLuint *dst = dest;
3094 GLuint i;
3095 for (i = 0; i < n; i++) {
3096 dst[gDst] = rgba[i][GCOMP];
3097 dst += dstComponents;
3098 }
3099 }
3100
3101 if (bDst >= 0) {
3102 GLuint *dst = dest;
3103 GLuint i;
3104 for (i = 0; i < n; i++) {
3105 dst[bDst] = rgba[i][BCOMP];
3106 dst += dstComponents;
3107 }
3108 }
3109
3110 if (aDst >= 0) {
3111 GLuint *dst = dest;
3112 GLuint i;
3113 for (i = 0; i < n; i++) {
3114 dst[aDst] = rgba[i][ACOMP];
3115 dst += dstComponents;
3116 }
3117 }
3118
3119 if (iDst >= 0) {
3120 GLuint *dst = dest;
3121 GLuint i;
3122 assert(iDst == 0);
3123 assert(dstComponents == 1);
3124 for (i = 0; i < n; i++) {
3125 /* Intensity comes from red channel */
3126 dst[i] = rgba[i][RCOMP];
3127 }
3128 }
3129
3130 if (lDst >= 0) {
3131 GLuint *dst = dest;
3132 GLuint i;
3133 assert(lDst == 0);
3134 for (i = 0; i < n; i++) {
3135 /* Luminance comes from red channel */
3136 dst[0] = rgba[i][RCOMP];
3137 dst += dstComponents;
3138 }
3139 }
3140 }
3141
3142 free(rgba);
3143 }
3144
3145
3146 /*
3147 * Unpack a row of color index data from a client buffer according to
3148 * the pixel unpacking parameters.
3149 * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.
3150 *
3151 * Args: ctx - the context
3152 * n - number of pixels
3153 * dstType - destination data type
3154 * dest - destination array
3155 * srcType - source pixel type
3156 * source - source data pointer
3157 * srcPacking - pixel unpacking parameters
3158 * transferOps - the pixel transfer operations to apply
3159 */
3160 void
3161 _mesa_unpack_index_span( struct gl_context *ctx, GLuint n,
3162 GLenum dstType, GLvoid *dest,
3163 GLenum srcType, const GLvoid *source,
3164 const struct gl_pixelstore_attrib *srcPacking,
3165 GLbitfield transferOps )
3166 {
3167 ASSERT(srcType == GL_BITMAP ||
3168 srcType == GL_UNSIGNED_BYTE ||
3169 srcType == GL_BYTE ||
3170 srcType == GL_UNSIGNED_SHORT ||
3171 srcType == GL_SHORT ||
3172 srcType == GL_UNSIGNED_INT ||
3173 srcType == GL_INT ||
3174 srcType == GL_HALF_FLOAT_ARB ||
3175 srcType == GL_FLOAT);
3176
3177 ASSERT(dstType == GL_UNSIGNED_BYTE ||
3178 dstType == GL_UNSIGNED_SHORT ||
3179 dstType == GL_UNSIGNED_INT);
3180
3181
3182 transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
3183
3184 /*
3185 * Try simple cases first
3186 */
3187 if (transferOps == 0 && srcType == GL_UNSIGNED_BYTE
3188 && dstType == GL_UNSIGNED_BYTE) {
3189 memcpy(dest, source, n * sizeof(GLubyte));
3190 }
3191 else if (transferOps == 0 && srcType == GL_UNSIGNED_INT
3192 && dstType == GL_UNSIGNED_INT && !srcPacking->SwapBytes) {
3193 memcpy(dest, source, n * sizeof(GLuint));
3194 }
3195 else {
3196 /*
3197 * general solution
3198 */
3199 GLuint *indexes = malloc(n * sizeof(GLuint));
3200
3201 if (!indexes) {
3202 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3203 return;
3204 }
3205
3206 extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
3207 srcPacking);
3208
3209 if (transferOps)
3210 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
3211
3212 /* convert to dest type */
3213 switch (dstType) {
3214 case GL_UNSIGNED_BYTE:
3215 {
3216 GLubyte *dst = (GLubyte *) dest;
3217 GLuint i;
3218 for (i = 0; i < n; i++) {
3219 dst[i] = (GLubyte) (indexes[i] & 0xff);
3220 }
3221 }
3222 break;
3223 case GL_UNSIGNED_SHORT:
3224 {
3225 GLuint *dst = (GLuint *) dest;
3226 GLuint i;
3227 for (i = 0; i < n; i++) {
3228 dst[i] = (GLushort) (indexes[i] & 0xffff);
3229 }
3230 }
3231 break;
3232 case GL_UNSIGNED_INT:
3233 memcpy(dest, indexes, n * sizeof(GLuint));
3234 break;
3235 default:
3236 _mesa_problem(ctx, "bad dstType in _mesa_unpack_index_span");
3237 }
3238
3239 free(indexes);
3240 }
3241 }
3242
3243
3244 void
3245 _mesa_pack_index_span( struct gl_context *ctx, GLuint n,
3246 GLenum dstType, GLvoid *dest, const GLuint *source,
3247 const struct gl_pixelstore_attrib *dstPacking,
3248 GLbitfield transferOps )
3249 {
3250 GLuint *indexes = malloc(n * sizeof(GLuint));
3251
3252 if (!indexes) {
3253 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
3254 return;
3255 }
3256
3257 transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
3258
3259 if (transferOps & (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT)) {
3260 /* make a copy of input */
3261 memcpy(indexes, source, n * sizeof(GLuint));
3262 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
3263 source = indexes;
3264 }
3265
3266 switch (dstType) {
3267 case GL_UNSIGNED_BYTE:
3268 {
3269 GLubyte *dst = (GLubyte *) dest;
3270 GLuint i;
3271 for (i = 0; i < n; i++) {
3272 *dst++ = (GLubyte) source[i];
3273 }
3274 }
3275 break;
3276 case GL_BYTE:
3277 {
3278 GLbyte *dst = (GLbyte *) dest;
3279 GLuint i;
3280 for (i = 0; i < n; i++) {
3281 dst[i] = (GLbyte) source[i];
3282 }
3283 }
3284 break;
3285 case GL_UNSIGNED_SHORT:
3286 {
3287 GLushort *dst = (GLushort *) dest;
3288 GLuint i;
3289 for (i = 0; i < n; i++) {
3290 dst[i] = (GLushort) source[i];
3291 }
3292 if (dstPacking->SwapBytes) {
3293 _mesa_swap2( (GLushort *) dst, n );
3294 }
3295 }
3296 break;
3297 case GL_SHORT:
3298 {
3299 GLshort *dst = (GLshort *) dest;
3300 GLuint i;
3301 for (i = 0; i < n; i++) {
3302 dst[i] = (GLshort) source[i];
3303 }
3304 if (dstPacking->SwapBytes) {
3305 _mesa_swap2( (GLushort *) dst, n );
3306 }
3307 }
3308 break;
3309 case GL_UNSIGNED_INT:
3310 {
3311 GLuint *dst = (GLuint *) dest;
3312 GLuint i;
3313 for (i = 0; i < n; i++) {
3314 dst[i] = (GLuint) source[i];
3315 }
3316 if (dstPacking->SwapBytes) {
3317 _mesa_swap4( (GLuint *) dst, n );
3318 }
3319 }
3320 break;
3321 case GL_INT:
3322 {
3323 GLint *dst = (GLint *) dest;
3324 GLuint i;
3325 for (i = 0; i < n; i++) {
3326 dst[i] = (GLint) source[i];
3327 }
3328 if (dstPacking->SwapBytes) {
3329 _mesa_swap4( (GLuint *) dst, n );
3330 }
3331 }
3332 break;
3333 case GL_FLOAT:
3334 {
3335 GLfloat *dst = (GLfloat *) dest;
3336 GLuint i;
3337 for (i = 0; i < n; i++) {
3338 dst[i] = (GLfloat) source[i];
3339 }
3340 if (dstPacking->SwapBytes) {
3341 _mesa_swap4( (GLuint *) dst, n );
3342 }
3343 }
3344 break;
3345 case GL_HALF_FLOAT_ARB:
3346 {
3347 GLhalfARB *dst = (GLhalfARB *) dest;
3348 GLuint i;
3349 for (i = 0; i < n; i++) {
3350 dst[i] = _mesa_float_to_half((GLfloat) source[i]);
3351 }
3352 if (dstPacking->SwapBytes) {
3353 _mesa_swap2( (GLushort *) dst, n );
3354 }
3355 }
3356 break;
3357 default:
3358 _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
3359 }
3360
3361 free(indexes);
3362 }
3363
3364
3365 /*
3366 * Unpack a row of stencil data from a client buffer according to
3367 * the pixel unpacking parameters.
3368 * This is (or will be) used by glDrawPixels
3369 *
3370 * Args: ctx - the context
3371 * n - number of pixels
3372 * dstType - destination data type
3373 * dest - destination array
3374 * srcType - source pixel type
3375 * source - source data pointer
3376 * srcPacking - pixel unpacking parameters
3377 * transferOps - apply offset/bias/lookup ops?
3378 */
3379 void
3380 _mesa_unpack_stencil_span( struct gl_context *ctx, GLuint n,
3381 GLenum dstType, GLvoid *dest,
3382 GLenum srcType, const GLvoid *source,
3383 const struct gl_pixelstore_attrib *srcPacking,
3384 GLbitfield transferOps )
3385 {
3386 ASSERT(srcType == GL_BITMAP ||
3387 srcType == GL_UNSIGNED_BYTE ||
3388 srcType == GL_BYTE ||
3389 srcType == GL_UNSIGNED_SHORT ||
3390 srcType == GL_SHORT ||
3391 srcType == GL_UNSIGNED_INT ||
3392 srcType == GL_INT ||
3393 srcType == GL_UNSIGNED_INT_24_8_EXT ||
3394 srcType == GL_HALF_FLOAT_ARB ||
3395 srcType == GL_FLOAT ||
3396 srcType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
3397
3398 ASSERT(dstType == GL_UNSIGNED_BYTE ||
3399 dstType == GL_UNSIGNED_SHORT ||
3400 dstType == GL_UNSIGNED_INT ||
3401 dstType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
3402
3403 /* only shift and offset apply to stencil */
3404 transferOps &= IMAGE_SHIFT_OFFSET_BIT;
3405
3406 /*
3407 * Try simple cases first
3408 */
3409 if (transferOps == 0 &&
3410 !ctx->Pixel.MapStencilFlag &&
3411 srcType == GL_UNSIGNED_BYTE &&
3412 dstType == GL_UNSIGNED_BYTE) {
3413 memcpy(dest, source, n * sizeof(GLubyte));
3414 }
3415 else if (transferOps == 0 &&
3416 !ctx->Pixel.MapStencilFlag &&
3417 srcType == GL_UNSIGNED_INT &&
3418 dstType == GL_UNSIGNED_INT &&
3419 !srcPacking->SwapBytes) {
3420 memcpy(dest, source, n * sizeof(GLuint));
3421 }
3422 else {
3423 /*
3424 * general solution
3425 */
3426 GLuint *indexes = malloc(n * sizeof(GLuint));
3427
3428 if (!indexes) {
3429 _mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil unpacking");
3430 return;
3431 }
3432
3433 extract_uint_indexes(n, indexes, GL_STENCIL_INDEX, srcType, source,
3434 srcPacking);
3435
3436 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
3437 /* shift and offset indexes */
3438 _mesa_shift_and_offset_ci(ctx, n, indexes);
3439 }
3440
3441 if (ctx->Pixel.MapStencilFlag) {
3442 /* Apply stencil lookup table */
3443 const GLuint mask = ctx->PixelMaps.StoS.Size - 1;
3444 GLuint i;
3445 for (i = 0; i < n; i++) {
3446 indexes[i] = (GLuint)ctx->PixelMaps.StoS.Map[ indexes[i] & mask ];
3447 }
3448 }
3449
3450 /* convert to dest type */
3451 switch (dstType) {
3452 case GL_UNSIGNED_BYTE:
3453 {
3454 GLubyte *dst = (GLubyte *) dest;
3455 GLuint i;
3456 for (i = 0; i < n; i++) {
3457 dst[i] = (GLubyte) (indexes[i] & 0xff);
3458 }
3459 }
3460 break;
3461 case GL_UNSIGNED_SHORT:
3462 {
3463 GLuint *dst = (GLuint *) dest;
3464 GLuint i;
3465 for (i = 0; i < n; i++) {
3466 dst[i] = (GLushort) (indexes[i] & 0xffff);
3467 }
3468 }
3469 break;
3470 case GL_UNSIGNED_INT:
3471 memcpy(dest, indexes, n * sizeof(GLuint));
3472 break;
3473 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
3474 {
3475 GLuint *dst = (GLuint *) dest;
3476 GLuint i;
3477 for (i = 0; i < n; i++) {
3478 dst[i*2+1] = indexes[i] & 0xff; /* lower 8 bits */
3479 }
3480 }
3481 break;
3482 default:
3483 _mesa_problem(ctx, "bad dstType in _mesa_unpack_stencil_span");
3484 }
3485
3486 free(indexes);
3487 }
3488 }
3489
3490
3491 void
3492 _mesa_pack_stencil_span( struct gl_context *ctx, GLuint n,
3493 GLenum dstType, GLvoid *dest, const GLubyte *source,
3494 const struct gl_pixelstore_attrib *dstPacking )
3495 {
3496 GLubyte *stencil = malloc(n * sizeof(GLubyte));
3497
3498 if (!stencil) {
3499 _mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil packing");
3500 return;
3501 }
3502
3503 if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset ||
3504 ctx->Pixel.MapStencilFlag) {
3505 /* make a copy of input */
3506 memcpy(stencil, source, n * sizeof(GLubyte));
3507 _mesa_apply_stencil_transfer_ops(ctx, n, stencil);
3508 source = stencil;
3509 }
3510
3511 switch (dstType) {
3512 case GL_UNSIGNED_BYTE:
3513 memcpy(dest, source, n);
3514 break;
3515 case GL_BYTE:
3516 {
3517 GLbyte *dst = (GLbyte *) dest;
3518 GLuint i;
3519 for (i=0;i<n;i++) {
3520 dst[i] = (GLbyte) (source[i] & 0x7f);
3521 }
3522 }
3523 break;
3524 case GL_UNSIGNED_SHORT:
3525 {
3526 GLushort *dst = (GLushort *) dest;
3527 GLuint i;
3528 for (i=0;i<n;i++) {
3529 dst[i] = (GLushort) source[i];
3530 }
3531 if (dstPacking->SwapBytes) {
3532 _mesa_swap2( (GLushort *) dst, n );
3533 }
3534 }
3535 break;
3536 case GL_SHORT:
3537 {
3538 GLshort *dst = (GLshort *) dest;
3539 GLuint i;
3540 for (i=0;i<n;i++) {
3541 dst[i] = (GLshort) source[i];
3542 }
3543 if (dstPacking->SwapBytes) {
3544 _mesa_swap2( (GLushort *) dst, n );
3545 }
3546 }
3547 break;
3548 case GL_UNSIGNED_INT:
3549 {
3550 GLuint *dst = (GLuint *) dest;
3551 GLuint i;
3552 for (i=0;i<n;i++) {
3553 dst[i] = (GLuint) source[i];
3554 }
3555 if (dstPacking->SwapBytes) {
3556 _mesa_swap4( (GLuint *) dst, n );
3557 }
3558 }
3559 break;
3560 case GL_INT:
3561 {
3562 GLint *dst = (GLint *) dest;
3563 GLuint i;
3564 for (i=0;i<n;i++) {
3565 dst[i] = (GLint) source[i];
3566 }
3567 if (dstPacking->SwapBytes) {
3568 _mesa_swap4( (GLuint *) dst, n );
3569 }
3570 }
3571 break;
3572 case GL_FLOAT:
3573 {
3574 GLfloat *dst = (GLfloat *) dest;
3575 GLuint i;
3576 for (i=0;i<n;i++) {
3577 dst[i] = (GLfloat) source[i];
3578 }
3579 if (dstPacking->SwapBytes) {
3580 _mesa_swap4( (GLuint *) dst, n );
3581 }
3582 }
3583 break;
3584 case GL_HALF_FLOAT_ARB:
3585 {
3586 GLhalfARB *dst = (GLhalfARB *) dest;
3587 GLuint i;
3588 for (i=0;i<n;i++) {
3589 dst[i] = _mesa_float_to_half( (float) source[i] );
3590 }
3591 if (dstPacking->SwapBytes) {
3592 _mesa_swap2( (GLushort *) dst, n );
3593 }
3594 }
3595 break;
3596 case GL_BITMAP:
3597 if (dstPacking->LsbFirst) {
3598 GLubyte *dst = (GLubyte *) dest;
3599 GLint shift = 0;
3600 GLuint i;
3601 for (i = 0; i < n; i++) {
3602 if (shift == 0)
3603 *dst = 0;
3604 *dst |= ((source[i] != 0) << shift);
3605 shift++;
3606 if (shift == 8) {
3607 shift = 0;
3608 dst++;
3609 }
3610 }
3611 }
3612 else {
3613 GLubyte *dst = (GLubyte *) dest;
3614 GLint shift = 7;
3615 GLuint i;
3616 for (i = 0; i < n; i++) {
3617 if (shift == 7)
3618 *dst = 0;
3619 *dst |= ((source[i] != 0) << shift);
3620 shift--;
3621 if (shift < 0) {
3622 shift = 7;
3623 dst++;
3624 }
3625 }
3626 }
3627 break;
3628 default:
3629 _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
3630 }
3631
3632 free(stencil);
3633 }
3634
3635 #define DEPTH_VALUES(GLTYPE, GLTYPE2FLOAT) \
3636 do { \
3637 GLuint i; \
3638 const GLTYPE *src = (const GLTYPE *)source; \
3639 for (i = 0; i < n; i++) { \
3640 GLTYPE value = src[i]; \
3641 if (srcPacking->SwapBytes) { \
3642 if (sizeof(GLTYPE) == 2) { \
3643 SWAP2BYTE(value); \
3644 } else if (sizeof(GLTYPE) == 4) { \
3645 SWAP4BYTE(value); \
3646 } \
3647 } \
3648 depthValues[i] = GLTYPE2FLOAT(value); \
3649 } \
3650 } while (0)
3651
3652
3653 /**
3654 * Unpack a row of depth/z values from memory, returning GLushort, GLuint
3655 * or GLfloat values.
3656 * The glPixelTransfer (scale/bias) params will be applied.
3657 *
3658 * \param dstType one of GL_UNSIGNED_SHORT, GL_UNSIGNED_INT, GL_FLOAT
3659 * \param depthMax max value for returned GLushort or GLuint values
3660 * (ignored for GLfloat).
3661 */
3662 void
3663 _mesa_unpack_depth_span( struct gl_context *ctx, GLuint n,
3664 GLenum dstType, GLvoid *dest, GLuint depthMax,
3665 GLenum srcType, const GLvoid *source,
3666 const struct gl_pixelstore_attrib *srcPacking )
3667 {
3668 GLfloat *depthTemp = NULL, *depthValues;
3669 GLboolean needClamp = GL_FALSE;
3670
3671 /* Look for special cases first.
3672 * Not only are these faster, they're less prone to numeric conversion
3673 * problems. Otherwise, converting from an int type to a float then
3674 * back to an int type can introduce errors that will show up as
3675 * artifacts in things like depth peeling which uses glCopyTexImage.
3676 */
3677 if (ctx->Pixel.DepthScale == 1.0 && ctx->Pixel.DepthBias == 0.0) {
3678 if (srcType == GL_UNSIGNED_INT && dstType == GL_UNSIGNED_SHORT) {
3679 const GLuint *src = (const GLuint *) source;
3680 GLushort *dst = (GLushort *) dest;
3681 GLuint i;
3682 for (i = 0; i < n; i++) {
3683 dst[i] = src[i] >> 16;
3684 }
3685 return;
3686 }
3687 if (srcType == GL_UNSIGNED_SHORT
3688 && dstType == GL_UNSIGNED_INT
3689 && depthMax == 0xffffffff) {
3690 const GLushort *src = (const GLushort *) source;
3691 GLuint *dst = (GLuint *) dest;
3692 GLuint i;
3693 for (i = 0; i < n; i++) {
3694 dst[i] = src[i] | (src[i] << 16);
3695 }
3696 return;
3697 }
3698 if (srcType == GL_UNSIGNED_INT_24_8
3699 && dstType == GL_UNSIGNED_INT
3700 && depthMax == 0xffffff) {
3701 const GLuint *src = (const GLuint *) source;
3702 GLuint *dst = (GLuint *) dest;
3703 GLuint i;
3704 for (i = 0; i < n; i++) {
3705 dst[i] = src[i] >> 8;
3706 }
3707 return;
3708 }
3709 /* XXX may want to add additional cases here someday */
3710 }
3711
3712 /* general case path follows */
3713
3714 if (dstType == GL_FLOAT) {
3715 depthValues = (GLfloat *) dest;
3716 }
3717 else {
3718 depthTemp = malloc(n * sizeof(GLfloat));
3719 if (!depthTemp) {
3720 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3721 return;
3722 }
3723
3724 depthValues = depthTemp;
3725 }
3726
3727 /* Convert incoming values to GLfloat. Some conversions will require
3728 * clamping, below.
3729 */
3730 switch (srcType) {
3731 case GL_BYTE:
3732 DEPTH_VALUES(GLbyte, BYTE_TO_FLOATZ);
3733 needClamp = GL_TRUE;
3734 break;
3735 case GL_UNSIGNED_BYTE:
3736 DEPTH_VALUES(GLubyte, UBYTE_TO_FLOAT);
3737 break;
3738 case GL_SHORT:
3739 DEPTH_VALUES(GLshort, SHORT_TO_FLOATZ);
3740 needClamp = GL_TRUE;
3741 break;
3742 case GL_UNSIGNED_SHORT:
3743 DEPTH_VALUES(GLushort, USHORT_TO_FLOAT);
3744 break;
3745 case GL_INT:
3746 DEPTH_VALUES(GLint, INT_TO_FLOAT);
3747 needClamp = GL_TRUE;
3748 break;
3749 case GL_UNSIGNED_INT:
3750 DEPTH_VALUES(GLuint, UINT_TO_FLOAT);
3751 break;
3752 case GL_UNSIGNED_INT_24_8_EXT: /* GL_EXT_packed_depth_stencil */
3753 if (dstType == GL_UNSIGNED_INT_24_8_EXT &&
3754 depthMax == 0xffffff &&
3755 ctx->Pixel.DepthScale == 1.0 &&
3756 ctx->Pixel.DepthBias == 0.0) {
3757 const GLuint *src = (const GLuint *) source;
3758 GLuint *zValues = (GLuint *) dest;
3759 GLuint i;
3760 for (i = 0; i < n; i++) {
3761 GLuint value = src[i];
3762 if (srcPacking->SwapBytes) {
3763 SWAP4BYTE(value);
3764 }
3765 zValues[i] = value & 0xffffff00;
3766 }
3767 free(depthTemp);
3768 return;
3769 }
3770 else {
3771 const GLuint *src = (const GLuint *) source;
3772 const GLfloat scale = 1.0f / 0xffffff;
3773 GLuint i;
3774 for (i = 0; i < n; i++) {
3775 GLuint value = src[i];
3776 if (srcPacking->SwapBytes) {
3777 SWAP4BYTE(value);
3778 }
3779 depthValues[i] = (value >> 8) * scale;
3780 }
3781 }
3782 break;
3783 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
3784 {
3785 GLuint i;
3786 const GLfloat *src = (const GLfloat *)source;
3787 for (i = 0; i < n; i++) {
3788 GLfloat value = src[i * 2];
3789 if (srcPacking->SwapBytes) {
3790 SWAP4BYTE(value);
3791 }
3792 depthValues[i] = value;
3793 }
3794 needClamp = GL_TRUE;
3795 }
3796 break;
3797 case GL_FLOAT:
3798 DEPTH_VALUES(GLfloat, 1*);
3799 needClamp = GL_TRUE;
3800 break;
3801 case GL_HALF_FLOAT_ARB:
3802 {
3803 GLuint i;
3804 const GLhalfARB *src = (const GLhalfARB *) source;
3805 for (i = 0; i < n; i++) {
3806 GLhalfARB value = src[i];
3807 if (srcPacking->SwapBytes) {
3808 SWAP2BYTE(value);
3809 }
3810 depthValues[i] = _mesa_half_to_float(value);
3811 }
3812 needClamp = GL_TRUE;
3813 }
3814 break;
3815 default:
3816 _mesa_problem(NULL, "bad type in _mesa_unpack_depth_span()");
3817 free(depthTemp);
3818 return;
3819 }
3820
3821 /* apply depth scale and bias */
3822 {
3823 const GLfloat scale = ctx->Pixel.DepthScale;
3824 const GLfloat bias = ctx->Pixel.DepthBias;
3825 if (scale != 1.0 || bias != 0.0) {
3826 GLuint i;
3827 for (i = 0; i < n; i++) {
3828 depthValues[i] = depthValues[i] * scale + bias;
3829 }
3830 needClamp = GL_TRUE;
3831 }
3832 }
3833
3834 /* clamp to [0, 1] */
3835 if (needClamp) {
3836 GLuint i;
3837 for (i = 0; i < n; i++) {
3838 depthValues[i] = (GLfloat)CLAMP(depthValues[i], 0.0, 1.0);
3839 }
3840 }
3841
3842 /*
3843 * Convert values to dstType
3844 */
3845 if (dstType == GL_UNSIGNED_INT) {
3846 GLuint *zValues = (GLuint *) dest;
3847 GLuint i;
3848 if (depthMax <= 0xffffff) {
3849 /* no overflow worries */
3850 for (i = 0; i < n; i++) {
3851 zValues[i] = (GLuint) (depthValues[i] * (GLfloat) depthMax);
3852 }
3853 }
3854 else {
3855 /* need to use double precision to prevent overflow problems */
3856 for (i = 0; i < n; i++) {
3857 GLdouble z = depthValues[i] * (GLdouble) depthMax;
3858 if (z >= (GLdouble) 0xffffffff)
3859 zValues[i] = 0xffffffff;
3860 else
3861 zValues[i] = (GLuint) z;
3862 }
3863 }
3864 }
3865 else if (dstType == GL_UNSIGNED_SHORT) {
3866 GLushort *zValues = (GLushort *) dest;
3867 GLuint i;
3868 ASSERT(depthMax <= 0xffff);
3869 for (i = 0; i < n; i++) {
3870 zValues[i] = (GLushort) (depthValues[i] * (GLfloat) depthMax);
3871 }
3872 }
3873 else if (dstType == GL_FLOAT) {
3874 /* Nothing to do. depthValues is pointing to dest. */
3875 }
3876 else if (dstType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV) {
3877 GLfloat *zValues = (GLfloat*) dest;
3878 GLuint i;
3879 for (i = 0; i < n; i++) {
3880 zValues[i*2] = depthValues[i];
3881 }
3882 }
3883 else {
3884 ASSERT(0);
3885 }
3886
3887 free(depthTemp);
3888 }
3889
3890
3891 /*
3892 * Pack an array of depth values. The values are floats in [0,1].
3893 */
3894 void
3895 _mesa_pack_depth_span( struct gl_context *ctx, GLuint n, GLvoid *dest,
3896 GLenum dstType, const GLfloat *depthSpan,
3897 const struct gl_pixelstore_attrib *dstPacking )
3898 {
3899 GLfloat *depthCopy = malloc(n * sizeof(GLfloat));
3900 if (!depthCopy) {
3901 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
3902 return;
3903 }
3904
3905 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
3906 memcpy(depthCopy, depthSpan, n * sizeof(GLfloat));
3907 _mesa_scale_and_bias_depth(ctx, n, depthCopy);
3908 depthSpan = depthCopy;
3909 }
3910
3911 switch (dstType) {
3912 case GL_UNSIGNED_BYTE:
3913 {
3914 GLubyte *dst = (GLubyte *) dest;
3915 GLuint i;
3916 for (i = 0; i < n; i++) {
3917 dst[i] = FLOAT_TO_UBYTE( depthSpan[i] );
3918 }
3919 }
3920 break;
3921 case GL_BYTE:
3922 {
3923 GLbyte *dst = (GLbyte *) dest;
3924 GLuint i;
3925 for (i = 0; i < n; i++) {
3926 dst[i] = FLOAT_TO_BYTE( depthSpan[i] );
3927 }
3928 }
3929 break;
3930 case GL_UNSIGNED_SHORT:
3931 {
3932 GLushort *dst = (GLushort *) dest;
3933 GLuint i;
3934 for (i = 0; i < n; i++) {
3935 CLAMPED_FLOAT_TO_USHORT(dst[i], depthSpan[i]);
3936 }
3937 if (dstPacking->SwapBytes) {
3938 _mesa_swap2( (GLushort *) dst, n );
3939 }
3940 }
3941 break;
3942 case GL_SHORT:
3943 {
3944 GLshort *dst = (GLshort *) dest;
3945 GLuint i;
3946 for (i = 0; i < n; i++) {
3947 dst[i] = FLOAT_TO_SHORT( depthSpan[i] );
3948 }
3949 if (dstPacking->SwapBytes) {
3950 _mesa_swap2( (GLushort *) dst, n );
3951 }
3952 }
3953 break;
3954 case GL_UNSIGNED_INT:
3955 {
3956 GLuint *dst = (GLuint *) dest;
3957 GLuint i;
3958 for (i = 0; i < n; i++) {
3959 dst[i] = FLOAT_TO_UINT( depthSpan[i] );
3960 }
3961 if (dstPacking->SwapBytes) {
3962 _mesa_swap4( (GLuint *) dst, n );
3963 }
3964 }
3965 break;
3966 case GL_INT:
3967 {
3968 GLint *dst = (GLint *) dest;
3969 GLuint i;
3970 for (i = 0; i < n; i++) {
3971 dst[i] = FLOAT_TO_INT( depthSpan[i] );
3972 }
3973 if (dstPacking->SwapBytes) {
3974 _mesa_swap4( (GLuint *) dst, n );
3975 }
3976 }
3977 break;
3978 case GL_FLOAT:
3979 {
3980 GLfloat *dst = (GLfloat *) dest;
3981 GLuint i;
3982 for (i = 0; i < n; i++) {
3983 dst[i] = depthSpan[i];
3984 }
3985 if (dstPacking->SwapBytes) {
3986 _mesa_swap4( (GLuint *) dst, n );
3987 }
3988 }
3989 break;
3990 case GL_HALF_FLOAT_ARB:
3991 {
3992 GLhalfARB *dst = (GLhalfARB *) dest;
3993 GLuint i;
3994 for (i = 0; i < n; i++) {
3995 dst[i] = _mesa_float_to_half(depthSpan[i]);
3996 }
3997 if (dstPacking->SwapBytes) {
3998 _mesa_swap2( (GLushort *) dst, n );
3999 }
4000 }
4001 break;
4002 default:
4003 _mesa_problem(ctx, "bad type in _mesa_pack_depth_span");
4004 }
4005
4006 free(depthCopy);
4007 }
4008
4009
4010
4011 /**
4012 * Pack depth and stencil values as GL_DEPTH_STENCIL (GL_UNSIGNED_INT_24_8 etc)
4013 */
4014 void
4015 _mesa_pack_depth_stencil_span(struct gl_context *ctx,GLuint n,
4016 GLenum dstType, GLuint *dest,
4017 const GLfloat *depthVals,
4018 const GLubyte *stencilVals,
4019 const struct gl_pixelstore_attrib *dstPacking)
4020 {
4021 GLfloat *depthCopy = malloc(n * sizeof(GLfloat));
4022 GLubyte *stencilCopy = malloc(n * sizeof(GLubyte));
4023 GLuint i;
4024
4025 if (!depthCopy || !stencilCopy) {
4026 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
4027 free(depthCopy);
4028 free(stencilCopy);
4029 return;
4030 }
4031
4032 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
4033 memcpy(depthCopy, depthVals, n * sizeof(GLfloat));
4034 _mesa_scale_and_bias_depth(ctx, n, depthCopy);
4035 depthVals = depthCopy;
4036 }
4037
4038 if (ctx->Pixel.IndexShift ||
4039 ctx->Pixel.IndexOffset ||
4040 ctx->Pixel.MapStencilFlag) {
4041 memcpy(stencilCopy, stencilVals, n * sizeof(GLubyte));
4042 _mesa_apply_stencil_transfer_ops(ctx, n, stencilCopy);
4043 stencilVals = stencilCopy;
4044 }
4045
4046 switch (dstType) {
4047 case GL_UNSIGNED_INT_24_8:
4048 for (i = 0; i < n; i++) {
4049 GLuint z = (GLuint) (depthVals[i] * 0xffffff);
4050 dest[i] = (z << 8) | (stencilVals[i] & 0xff);
4051 }
4052 break;
4053 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
4054 for (i = 0; i < n; i++) {
4055 ((GLfloat*)dest)[i*2] = depthVals[i];
4056 dest[i*2+1] = stencilVals[i] & 0xff;
4057 }
4058 break;
4059 }
4060
4061 if (dstPacking->SwapBytes) {
4062 _mesa_swap4(dest, n);
4063 }
4064
4065 free(depthCopy);
4066 free(stencilCopy);
4067 }
4068
4069
4070
4071
4072 /**
4073 * Unpack image data. Apply byte swapping, byte flipping (bitmap).
4074 * Return all image data in a contiguous block. This is used when we
4075 * compile glDrawPixels, glTexImage, etc into a display list. We
4076 * need a copy of the data in a standard format.
4077 */
4078 void *
4079 _mesa_unpack_image( GLuint dimensions,
4080 GLsizei width, GLsizei height, GLsizei depth,
4081 GLenum format, GLenum type, const GLvoid *pixels,
4082 const struct gl_pixelstore_attrib *unpack )
4083 {
4084 GLint bytesPerRow, compsPerRow;
4085 GLboolean flipBytes, swap2, swap4;
4086
4087 if (!pixels)
4088 return NULL; /* not necessarily an error */
4089
4090 if (width <= 0 || height <= 0 || depth <= 0)
4091 return NULL; /* generate error later */
4092
4093 if (type == GL_BITMAP) {
4094 bytesPerRow = (width + 7) >> 3;
4095 flipBytes = unpack->LsbFirst;
4096 swap2 = swap4 = GL_FALSE;
4097 compsPerRow = 0;
4098 }
4099 else {
4100 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
4101 GLint components = _mesa_components_in_format(format);
4102 GLint bytesPerComp;
4103
4104 if (_mesa_type_is_packed(type))
4105 components = 1;
4106
4107 if (bytesPerPixel <= 0 || components <= 0)
4108 return NULL; /* bad format or type. generate error later */
4109 bytesPerRow = bytesPerPixel * width;
4110 bytesPerComp = bytesPerPixel / components;
4111 flipBytes = GL_FALSE;
4112 swap2 = (bytesPerComp == 2) && unpack->SwapBytes;
4113 swap4 = (bytesPerComp == 4) && unpack->SwapBytes;
4114 compsPerRow = components * width;
4115 assert(compsPerRow >= width);
4116 }
4117
4118 {
4119 GLubyte *destBuffer
4120 = malloc(bytesPerRow * height * depth);
4121 GLubyte *dst;
4122 GLint img, row;
4123 if (!destBuffer)
4124 return NULL; /* generate GL_OUT_OF_MEMORY later */
4125
4126 dst = destBuffer;
4127 for (img = 0; img < depth; img++) {
4128 for (row = 0; row < height; row++) {
4129 const GLvoid *src = _mesa_image_address(dimensions, unpack, pixels,
4130 width, height, format, type, img, row, 0);
4131
4132 if ((type == GL_BITMAP) && (unpack->SkipPixels & 0x7)) {
4133 GLint i;
4134 flipBytes = GL_FALSE;
4135 if (unpack->LsbFirst) {
4136 GLubyte srcMask = 1 << (unpack->SkipPixels & 0x7);
4137 GLubyte dstMask = 128;
4138 const GLubyte *s = src;
4139 GLubyte *d = dst;
4140 *d = 0;
4141 for (i = 0; i < width; i++) {
4142 if (*s & srcMask) {
4143 *d |= dstMask;
4144 }
4145 if (srcMask == 128) {
4146 srcMask = 1;
4147 s++;
4148 }
4149 else {
4150 srcMask = srcMask << 1;
4151 }
4152 if (dstMask == 1) {
4153 dstMask = 128;
4154 d++;
4155 *d = 0;
4156 }
4157 else {
4158 dstMask = dstMask >> 1;
4159 }
4160 }
4161 }
4162 else {
4163 GLubyte srcMask = 128 >> (unpack->SkipPixels & 0x7);
4164 GLubyte dstMask = 128;
4165 const GLubyte *s = src;
4166 GLubyte *d = dst;
4167 *d = 0;
4168 for (i = 0; i < width; i++) {
4169 if (*s & srcMask) {
4170 *d |= dstMask;
4171 }
4172 if (srcMask == 1) {
4173 srcMask = 128;
4174 s++;
4175 }
4176 else {
4177 srcMask = srcMask >> 1;
4178 }
4179 if (dstMask == 1) {
4180 dstMask = 128;
4181 d++;
4182 *d = 0;
4183 }
4184 else {
4185 dstMask = dstMask >> 1;
4186 }
4187 }
4188 }
4189 }
4190 else {
4191 memcpy(dst, src, bytesPerRow);
4192 }
4193
4194 /* byte flipping/swapping */
4195 if (flipBytes) {
4196 flip_bytes((GLubyte *) dst, bytesPerRow);
4197 }
4198 else if (swap2) {
4199 _mesa_swap2((GLushort*) dst, compsPerRow);
4200 }
4201 else if (swap4) {
4202 _mesa_swap4((GLuint*) dst, compsPerRow);
4203 }
4204 dst += bytesPerRow;
4205 }
4206 }
4207 return destBuffer;
4208 }
4209 }
4210
4211
4212
4213 /**
4214 * If we unpack colors from a luminance surface, we'll get pixel colors
4215 * such as (l, l, l, a).
4216 * When we call _mesa_pack_rgba_span_float(format=GL_LUMINANCE), that
4217 * function will compute L=R+G+B before packing. The net effect is we'll
4218 * accidentally store luminance values = 3*l.
4219 * This function compensates for that by converting (aka rebasing) (l,l,l,a)
4220 * to be (l,0,0,a).
4221 * It's a similar story for other formats such as LUMINANCE_ALPHA, ALPHA
4222 * and INTENSITY.
4223 *
4224 * Finally, we also need to do this when the actual surface format does
4225 * not match the logical surface format. For example, suppose the user
4226 * requests a GL_LUMINANCE texture but the driver stores it as RGBA.
4227 * Again, we'll get pixel values like (l,l,l,a).
4228 */
4229 void
4230 _mesa_rebase_rgba_float(GLuint n, GLfloat rgba[][4], GLenum baseFormat)
4231 {
4232 GLuint i;
4233
4234 switch (baseFormat) {
4235 case GL_ALPHA:
4236 for (i = 0; i < n; i++) {
4237 rgba[i][RCOMP] = 0.0F;
4238 rgba[i][GCOMP] = 0.0F;
4239 rgba[i][BCOMP] = 0.0F;
4240 }
4241 break;
4242 case GL_INTENSITY:
4243 /* fall-through */
4244 case GL_LUMINANCE:
4245 for (i = 0; i < n; i++) {
4246 rgba[i][GCOMP] = 0.0F;
4247 rgba[i][BCOMP] = 0.0F;
4248 rgba[i][ACOMP] = 1.0F;
4249 }
4250 break;
4251 case GL_LUMINANCE_ALPHA:
4252 for (i = 0; i < n; i++) {
4253 rgba[i][GCOMP] = 0.0F;
4254 rgba[i][BCOMP] = 0.0F;
4255 }
4256 break;
4257 case GL_RGB:
4258 for (i = 0; i < n; i++) {
4259 rgba[i][ACOMP] = 1.0F;
4260 }
4261 break;
4262 case GL_RG:
4263 for (i = 0; i < n; i++) {
4264 rgba[i][BCOMP] = 0.0F;
4265 rgba[i][ACOMP] = 1.0F;
4266 }
4267 break;
4268 case GL_RED:
4269 for (i = 0; i < n; i++) {
4270 rgba[i][GCOMP] = 0.0F;
4271 rgba[i][BCOMP] = 0.0F;
4272 rgba[i][ACOMP] = 1.0F;
4273 }
4274 break;
4275
4276 default:
4277 /* no-op */
4278 ;
4279 }
4280 }
4281
4282
4283 /**
4284 * As above, but GLuint components.
4285 */
4286 void
4287 _mesa_rebase_rgba_uint(GLuint n, GLuint rgba[][4], GLenum baseFormat)
4288 {
4289 GLuint i;
4290
4291 switch (baseFormat) {
4292 case GL_ALPHA:
4293 for (i = 0; i < n; i++) {
4294 rgba[i][RCOMP] = 0;
4295 rgba[i][GCOMP] = 0;
4296 rgba[i][BCOMP] = 0;
4297 }
4298 break;
4299 case GL_INTENSITY:
4300 /* fall-through */
4301 case GL_LUMINANCE:
4302 for (i = 0; i < n; i++) {
4303 rgba[i][GCOMP] = 0;
4304 rgba[i][BCOMP] = 0;
4305 rgba[i][ACOMP] = 1;
4306 }
4307 break;
4308 case GL_LUMINANCE_ALPHA:
4309 for (i = 0; i < n; i++) {
4310 rgba[i][GCOMP] = 0;
4311 rgba[i][BCOMP] = 0;
4312 }
4313 break;
4314 case GL_RGB:
4315 for (i = 0; i < n; i++) {
4316 rgba[i][ACOMP] = 1;
4317 }
4318 break;
4319 case GL_RG:
4320 for (i = 0; i < n; i++) {
4321 rgba[i][BCOMP] = 0;
4322 rgba[i][ACOMP] = 1;
4323 }
4324 break;
4325 case GL_RED:
4326 for (i = 0; i < n; i++) {
4327 rgba[i][GCOMP] = 0;
4328 rgba[i][BCOMP] = 0;
4329 rgba[i][ACOMP] = 1;
4330 }
4331 default:
4332 /* no-op */
4333 ;
4334 }
4335 }
4336
4337