projects / mesa.git / blob
? search:


5fd01c2f8ef657812cbb5da8a38ab629ac251c5b
[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 "../../gallium/auxiliary/util/u_format_rgb9e5.h"
56 #include "../../gallium/auxiliary/util/u_format_r11g11b10f.h"
57
58
59 /**
60 * Flip the 8 bits in each byte of the given array.
61 *
62 * \param p array.
63 * \param n number of bytes.
64 *
65 * \todo try this trick to flip bytes someday:
66 * \code
67 * v = ((v & 0x55555555) << 1) | ((v >> 1) & 0x55555555);
68 * v = ((v & 0x33333333) << 2) | ((v >> 2) & 0x33333333);
69 * v = ((v & 0x0f0f0f0f) << 4) | ((v >> 4) & 0x0f0f0f0f);
70 * \endcode
71 */
72 static void
73 flip_bytes( GLubyte *p, GLuint n )
74 {
75 GLuint i, a, b;
76 for (i = 0; i < n; i++) {
77 b = (GLuint) p[i]; /* words are often faster than bytes */
78 a = ((b & 0x01) << 7) |
79 ((b & 0x02) << 5) |
80 ((b & 0x04) << 3) |
81 ((b & 0x08) << 1) |
82 ((b & 0x10) >> 1) |
83 ((b & 0x20) >> 3) |
84 ((b & 0x40) >> 5) |
85 ((b & 0x80) >> 7);
86 p[i] = (GLubyte) a;
87 }
88 }
89
90
91
92 /*
93 * Unpack a 32x32 pixel polygon stipple from user memory using the
94 * current pixel unpack settings.
95 */
96 void
97 _mesa_unpack_polygon_stipple( const GLubyte *pattern, GLuint dest[32],
98 const struct gl_pixelstore_attrib *unpacking )
99 {
100 GLubyte *ptrn = (GLubyte *) _mesa_unpack_bitmap(32, 32, pattern, unpacking);
101 if (ptrn) {
102 /* Convert pattern from GLubytes to GLuints and handle big/little
103 * endian differences
104 */
105 GLubyte *p = ptrn;
106 GLint i;
107 for (i = 0; i < 32; i++) {
108 dest[i] = (p[0] << 24)
109 | (p[1] << 16)
110 | (p[2] << 8)
111 | (p[3] );
112 p += 4;
113 }
114 free(ptrn);
115 }
116 }
117
118
119 /*
120 * Pack polygon stipple into user memory given current pixel packing
121 * settings.
122 */
123 void
124 _mesa_pack_polygon_stipple( const GLuint pattern[32], GLubyte *dest,
125 const struct gl_pixelstore_attrib *packing )
126 {
127 /* Convert pattern from GLuints to GLubytes to handle big/little
128 * endian differences.
129 */
130 GLubyte ptrn[32*4];
131 GLint i;
132 for (i = 0; i < 32; i++) {
133 ptrn[i * 4 + 0] = (GLubyte) ((pattern[i] >> 24) & 0xff);
134 ptrn[i * 4 + 1] = (GLubyte) ((pattern[i] >> 16) & 0xff);
135 ptrn[i * 4 + 2] = (GLubyte) ((pattern[i] >> 8 ) & 0xff);
136 ptrn[i * 4 + 3] = (GLubyte) ((pattern[i] ) & 0xff);
137 }
138
139 _mesa_pack_bitmap(32, 32, ptrn, dest, packing);
140 }
141
142
143 /*
144 * Unpack bitmap data. Resulting data will be in most-significant-bit-first
145 * order with row alignment = 1 byte.
146 */
147 GLvoid *
148 _mesa_unpack_bitmap( GLint width, GLint height, const GLubyte *pixels,
149 const struct gl_pixelstore_attrib *packing )
150 {
151 GLint bytes, row, width_in_bytes;
152 GLubyte *buffer, *dst;
153
154 if (!pixels)
155 return NULL;
156
157 /* Alloc dest storage */
158 bytes = ((width + 7) / 8 * height);
159 buffer = (GLubyte *) malloc( bytes );
160 if (!buffer)
161 return NULL;
162
163 width_in_bytes = CEILING( width, 8 );
164 dst = buffer;
165 for (row = 0; row < height; row++) {
166 const GLubyte *src = (const GLubyte *)
167 _mesa_image_address2d(packing, pixels, width, height,
168 GL_COLOR_INDEX, GL_BITMAP, row, 0);
169 if (!src) {
170 free(buffer);
171 return NULL;
172 }
173
174 if ((packing->SkipPixels & 7) == 0) {
175 memcpy( dst, src, width_in_bytes );
176 if (packing->LsbFirst) {
177 flip_bytes( dst, width_in_bytes );
178 }
179 }
180 else {
181 /* handling SkipPixels is a bit tricky (no pun intended!) */
182 GLint i;
183 if (packing->LsbFirst) {
184 GLubyte srcMask = 1 << (packing->SkipPixels & 0x7);
185 GLubyte dstMask = 128;
186 const GLubyte *s = src;
187 GLubyte *d = dst;
188 *d = 0;
189 for (i = 0; i < width; i++) {
190 if (*s & srcMask) {
191 *d |= dstMask;
192 }
193 if (srcMask == 128) {
194 srcMask = 1;
195 s++;
196 }
197 else {
198 srcMask = srcMask << 1;
199 }
200 if (dstMask == 1) {
201 dstMask = 128;
202 d++;
203 *d = 0;
204 }
205 else {
206 dstMask = dstMask >> 1;
207 }
208 }
209 }
210 else {
211 GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7);
212 GLubyte dstMask = 128;
213 const GLubyte *s = src;
214 GLubyte *d = dst;
215 *d = 0;
216 for (i = 0; i < width; i++) {
217 if (*s & srcMask) {
218 *d |= dstMask;
219 }
220 if (srcMask == 1) {
221 srcMask = 128;
222 s++;
223 }
224 else {
225 srcMask = srcMask >> 1;
226 }
227 if (dstMask == 1) {
228 dstMask = 128;
229 d++;
230 *d = 0;
231 }
232 else {
233 dstMask = dstMask >> 1;
234 }
235 }
236 }
237 }
238 dst += width_in_bytes;
239 }
240
241 return buffer;
242 }
243
244
245 /*
246 * Pack bitmap data.
247 */
248 void
249 _mesa_pack_bitmap( GLint width, GLint height, const GLubyte *source,
250 GLubyte *dest, const struct gl_pixelstore_attrib *packing )
251 {
252 GLint row, width_in_bytes;
253 const GLubyte *src;
254
255 if (!source)
256 return;
257
258 width_in_bytes = CEILING( width, 8 );
259 src = source;
260 for (row = 0; row < height; row++) {
261 GLubyte *dst = (GLubyte *) _mesa_image_address2d(packing, dest,
262 width, height, GL_COLOR_INDEX, GL_BITMAP, row, 0);
263 if (!dst)
264 return;
265
266 if ((packing->SkipPixels & 7) == 0) {
267 memcpy( dst, src, width_in_bytes );
268 if (packing->LsbFirst) {
269 flip_bytes( dst, width_in_bytes );
270 }
271 }
272 else {
273 /* handling SkipPixels is a bit tricky (no pun intended!) */
274 GLint i;
275 if (packing->LsbFirst) {
276 GLubyte srcMask = 128;
277 GLubyte dstMask = 1 << (packing->SkipPixels & 0x7);
278 const GLubyte *s = src;
279 GLubyte *d = dst;
280 *d = 0;
281 for (i = 0; i < width; i++) {
282 if (*s & srcMask) {
283 *d |= dstMask;
284 }
285 if (srcMask == 1) {
286 srcMask = 128;
287 s++;
288 }
289 else {
290 srcMask = srcMask >> 1;
291 }
292 if (dstMask == 128) {
293 dstMask = 1;
294 d++;
295 *d = 0;
296 }
297 else {
298 dstMask = dstMask << 1;
299 }
300 }
301 }
302 else {
303 GLubyte srcMask = 128;
304 GLubyte dstMask = 128 >> (packing->SkipPixels & 0x7);
305 const GLubyte *s = src;
306 GLubyte *d = dst;
307 *d = 0;
308 for (i = 0; i < width; i++) {
309 if (*s & srcMask) {
310 *d |= dstMask;
311 }
312 if (srcMask == 1) {
313 srcMask = 128;
314 s++;
315 }
316 else {
317 srcMask = srcMask >> 1;
318 }
319 if (dstMask == 1) {
320 dstMask = 128;
321 d++;
322 *d = 0;
323 }
324 else {
325 dstMask = dstMask >> 1;
326 }
327 }
328 }
329 }
330 src += width_in_bytes;
331 }
332 }
333
334
335 /**
336 * Get indexes of color components for a basic color format, such as
337 * GL_RGBA, GL_RED, GL_LUMINANCE_ALPHA, etc. Return -1 for indexes
338 * that do not apply.
339 */
340 static void
341 get_component_indexes(GLenum format,
342 GLint *redIndex,
343 GLint *greenIndex,
344 GLint *blueIndex,
345 GLint *alphaIndex,
346 GLint *luminanceIndex,
347 GLint *intensityIndex)
348 {
349 *redIndex = -1;
350 *greenIndex = -1;
351 *blueIndex = -1;
352 *alphaIndex = -1;
353 *luminanceIndex = -1;
354 *intensityIndex = -1;
355
356 switch (format) {
357 case GL_LUMINANCE:
358 case GL_LUMINANCE_INTEGER_EXT:
359 *luminanceIndex = 0;
360 break;
361 case GL_LUMINANCE_ALPHA:
362 case GL_LUMINANCE_ALPHA_INTEGER_EXT:
363 *luminanceIndex = 0;
364 *alphaIndex = 1;
365 break;
366 case GL_INTENSITY:
367 *intensityIndex = 0;
368 break;
369 case GL_RED:
370 case GL_RED_INTEGER_EXT:
371 *redIndex = 0;
372 break;
373 case GL_GREEN:
374 case GL_GREEN_INTEGER_EXT:
375 *greenIndex = 0;
376 break;
377 case GL_BLUE:
378 case GL_BLUE_INTEGER_EXT:
379 *blueIndex = 0;
380 break;
381 case GL_ALPHA:
382 case GL_ALPHA_INTEGER_EXT:
383 *alphaIndex = 0;
384 break;
385 case GL_RG:
386 case GL_RG_INTEGER:
387 *redIndex = 0;
388 *greenIndex = 1;
389 break;
390 case GL_RGB:
391 case GL_RGB_INTEGER_EXT:
392 *redIndex = 0;
393 *greenIndex = 1;
394 *blueIndex = 2;
395 break;
396 case GL_BGR:
397 case GL_BGR_INTEGER_EXT:
398 *blueIndex = 0;
399 *greenIndex = 1;
400 *redIndex = 2;
401 break;
402 case GL_RGBA:
403 case GL_RGBA_INTEGER_EXT:
404 *redIndex = 0;
405 *greenIndex = 1;
406 *blueIndex = 2;
407 *alphaIndex = 3;
408 break;
409 case GL_BGRA:
410 case GL_BGRA_INTEGER:
411 *redIndex = 2;
412 *greenIndex = 1;
413 *blueIndex = 0;
414 *alphaIndex = 3;
415 break;
416 case GL_ABGR_EXT:
417 *redIndex = 3;
418 *greenIndex = 2;
419 *blueIndex = 1;
420 *alphaIndex = 0;
421 break;
422 case GL_DU8DV8_ATI:
423 case GL_DUDV_ATI:
424 *redIndex = 0;
425 *greenIndex = 1;
426 break;
427 default:
428 assert(0 && "bad format in get_component_indexes()");
429 }
430 }
431
432
433
434 /**
435 * For small integer types, return the min and max possible values.
436 * Used for clamping floats to unscaled integer types.
437 * \return GL_TRUE if type is handled, GL_FALSE otherwise.
438 */
439 static GLboolean
440 get_type_min_max(GLenum type, GLfloat *min, GLfloat *max)
441 {
442 switch (type) {
443 case GL_BYTE:
444 *min = -128.0;
445 *max = 127.0;
446 return GL_TRUE;
447 case GL_UNSIGNED_BYTE:
448 *min = 0.0;
449 *max = 255.0;
450 return GL_TRUE;
451 case GL_SHORT:
452 *min = -32768.0;
453 *max = 32767.0;
454 return GL_TRUE;
455 case GL_UNSIGNED_SHORT:
456 *min = 0.0;
457 *max = 65535.0;
458 return GL_TRUE;
459 default:
460 return GL_FALSE;
461 }
462 }
463
464 /* Customization of integer packing. We always treat src as uint, and can pack dst
465 * as any integer type/format combo.
466 */
467 #define SRC_TYPE GLuint
468
469 #define DST_TYPE GLuint
470 #define SRC_CONVERT(x) (x)
471 #define FN_NAME pack_uint_from_uint_rgba
472 #include "pack_tmp.h"
473 #undef DST_TYPE
474 #undef SRC_CONVERT
475 #undef FN_NAME
476
477 #define DST_TYPE GLushort
478 #define SRC_CONVERT(x) MIN2(x, 0xffff)
479 #define FN_NAME pack_ushort_from_uint_rgba
480 #include "pack_tmp.h"
481 #undef DST_TYPE
482 #undef SRC_CONVERT
483 #undef FN_NAME
484
485 #define DST_TYPE GLshort
486 #define SRC_CONVERT(x) CLAMP((int)x, -32768, 32767)
487 #define FN_NAME pack_short_from_uint_rgba
488 #include "pack_tmp.h"
489 #undef DST_TYPE
490 #undef SRC_CONVERT
491 #undef FN_NAME
492
493 #define DST_TYPE GLubyte
494 #define SRC_CONVERT(x) MIN2(x, 0xff)
495 #define FN_NAME pack_ubyte_from_uint_rgba
496 #include "pack_tmp.h"
497 #undef DST_TYPE
498 #undef SRC_CONVERT
499 #undef FN_NAME
500
501 #define DST_TYPE GLbyte
502 #define SRC_CONVERT(x) CLAMP((int)x, -128, 127)
503 #define FN_NAME pack_byte_from_uint_rgba
504 #include "pack_tmp.h"
505 #undef DST_TYPE
506 #undef SRC_CONVERT
507 #undef FN_NAME
508
509 void
510 _mesa_pack_rgba_span_int(struct gl_context *ctx, GLuint n, GLuint rgba[][4],
511 GLenum dstFormat, GLenum dstType,
512 GLvoid *dstAddr)
513 {
514 switch(dstType) {
515 case GL_UNSIGNED_INT:
516 pack_uint_from_uint_rgba(dstAddr, dstFormat, rgba, n);
517 break;
518 case GL_INT:
519 /* No conversion necessary. */
520 pack_uint_from_uint_rgba(dstAddr, dstFormat, rgba, n);
521 break;
522 case GL_UNSIGNED_SHORT:
523 pack_ushort_from_uint_rgba(dstAddr, dstFormat, rgba, n);
524 break;
525 case GL_SHORT:
526 pack_short_from_uint_rgba(dstAddr, dstFormat, rgba, n);
527 break;
528 case GL_UNSIGNED_BYTE:
529 pack_ubyte_from_uint_rgba(dstAddr, dstFormat, rgba, n);
530 break;
531 case GL_BYTE:
532 pack_byte_from_uint_rgba(dstAddr, dstFormat, rgba, n);
533 break;
534 default:
535 assert(0);
536 return;
537 }
538 }
539
540
541 /**
542 * Used to pack an array [][4] of RGBA float colors as specified
543 * by the dstFormat, dstType and dstPacking. Used by glReadPixels.
544 * Historically, the RGBA values were in [0,1] and rescaled to fit
545 * into GLubytes, etc. But with new integer formats, the RGBA values
546 * may have any value and we don't always rescale when converting to
547 * integers.
548 *
549 * Note: the rgba values will be modified by this function when any pixel
550 * transfer ops are enabled.
551 */
552 void
553 _mesa_pack_rgba_span_float(struct gl_context *ctx, GLuint n, GLfloat rgba[][4],
554 GLenum dstFormat, GLenum dstType,
555 GLvoid *dstAddr,
556 const struct gl_pixelstore_attrib *dstPacking,
557 GLbitfield transferOps)
558 {
559 GLfloat *luminance;
560 const GLint comps = _mesa_components_in_format(dstFormat);
561 const GLboolean intDstFormat = _mesa_is_integer_format(dstFormat);
562 GLuint i;
563
564 if (dstFormat == GL_LUMINANCE ||
565 dstFormat == GL_LUMINANCE_ALPHA ||
566 dstFormat == GL_LUMINANCE_INTEGER_EXT ||
567 dstFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT) {
568 luminance = (GLfloat *) malloc(n * sizeof(GLfloat));
569 if (!luminance) {
570 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
571 return;
572 }
573 }
574 else {
575 luminance = NULL;
576 }
577
578 /* EXT_texture_integer specifies no transfer ops on integer
579 * types in the resolved issues section. Just set them to 0
580 * for integer surfaces.
581 */
582 if (intDstFormat)
583 transferOps = 0;
584
585 if (transferOps) {
586 _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
587 }
588
589 /*
590 * Component clamping (besides clamping to [0,1] in
591 * _mesa_apply_rgba_transfer_ops()).
592 */
593 if (intDstFormat) {
594 /* clamping to dest type's min/max values */
595 GLfloat min, max;
596 if (get_type_min_max(dstType, &min, &max)) {
597 for (i = 0; i < n; i++) {
598 rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], min, max);
599 rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], min, max);
600 rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], min, max);
601 rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], min, max);
602 }
603 }
604 }
605 else if (dstFormat == GL_LUMINANCE || dstFormat == GL_LUMINANCE_ALPHA) {
606 /* compute luminance values */
607 if (transferOps & IMAGE_CLAMP_BIT) {
608 for (i = 0; i < n; i++) {
609 GLfloat sum = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
610 luminance[i] = CLAMP(sum, 0.0F, 1.0F);
611 }
612 }
613 else {
614 for (i = 0; i < n; i++) {
615 luminance[i] = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
616 }
617 }
618 }
619
620 /*
621 * Pack/store the pixels. Ugh! Lots of cases!!!
622 */
623 switch (dstType) {
624 case GL_UNSIGNED_BYTE:
625 {
626 GLubyte *dst = (GLubyte *) dstAddr;
627 switch (dstFormat) {
628 case GL_RED:
629 for (i=0;i<n;i++)
630 dst[i] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
631 break;
632 case GL_GREEN:
633 for (i=0;i<n;i++)
634 dst[i] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
635 break;
636 case GL_BLUE:
637 for (i=0;i<n;i++)
638 dst[i] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
639 break;
640 case GL_ALPHA:
641 for (i=0;i<n;i++)
642 dst[i] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
643 break;
644 case GL_LUMINANCE:
645 for (i=0;i<n;i++)
646 dst[i] = FLOAT_TO_UBYTE(luminance[i]);
647 break;
648 case GL_LUMINANCE_ALPHA:
649 for (i=0;i<n;i++) {
650 dst[i*2+0] = FLOAT_TO_UBYTE(luminance[i]);
651 dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
652 }
653 break;
654 case GL_RG:
655 for (i=0;i<n;i++) {
656 dst[i*2+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
657 dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
658 }
659 break;
660 case GL_RGB:
661 for (i=0;i<n;i++) {
662 dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
663 dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
664 dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
665 }
666 break;
667 case GL_RGBA:
668 for (i=0;i<n;i++) {
669 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
670 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
671 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
672 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
673 }
674 break;
675 case GL_BGR:
676 for (i=0;i<n;i++) {
677 dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
678 dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
679 dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
680 }
681 break;
682 case GL_BGRA:
683 for (i=0;i<n;i++) {
684 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
685 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
686 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
687 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
688 }
689 break;
690 case GL_ABGR_EXT:
691 for (i=0;i<n;i++) {
692 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
693 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
694 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
695 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
696 }
697 break;
698 case GL_RED_INTEGER_EXT:
699 for (i=0;i<n;i++) {
700 dst[i] = (GLubyte) rgba[i][RCOMP];
701 }
702 break;
703 case GL_GREEN_INTEGER_EXT:
704 for (i=0;i<n;i++) {
705 dst[i] = (GLubyte) rgba[i][GCOMP];
706 }
707 break;
708 case GL_BLUE_INTEGER_EXT:
709 for (i=0;i<n;i++) {
710 dst[i] = (GLubyte) rgba[i][BCOMP];
711 }
712 break;
713 case GL_ALPHA_INTEGER_EXT:
714 for (i=0;i<n;i++) {
715 dst[i] = (GLubyte) rgba[i][ACOMP];
716 }
717 break;
718 case GL_RG_INTEGER:
719 for (i=0;i<n;i++) {
720 dst[i*2+0] = (GLubyte) rgba[i][RCOMP];
721 dst[i*2+1] = (GLubyte) rgba[i][GCOMP];
722 }
723 break;
724 case GL_RGB_INTEGER_EXT:
725 for (i=0;i<n;i++) {
726 dst[i*3+0] = (GLubyte) rgba[i][RCOMP];
727 dst[i*3+1] = (GLubyte) rgba[i][GCOMP];
728 dst[i*3+2] = (GLubyte) rgba[i][BCOMP];
729 }
730 break;
731 case GL_RGBA_INTEGER_EXT:
732 for (i=0;i<n;i++) {
733 dst[i*4+0] = (GLubyte) rgba[i][RCOMP];
734 dst[i*4+1] = (GLubyte) rgba[i][GCOMP];
735 dst[i*4+2] = (GLubyte) rgba[i][BCOMP];
736 dst[i*4+3] = (GLubyte) rgba[i][ACOMP];
737 }
738 break;
739 case GL_BGR_INTEGER_EXT:
740 for (i=0;i<n;i++) {
741 dst[i*3+0] = (GLubyte) rgba[i][BCOMP];
742 dst[i*3+1] = (GLubyte) rgba[i][GCOMP];
743 dst[i*3+2] = (GLubyte) rgba[i][RCOMP];
744 }
745 break;
746 case GL_BGRA_INTEGER_EXT:
747 for (i=0;i<n;i++) {
748 dst[i*4+0] = (GLubyte) rgba[i][BCOMP];
749 dst[i*4+1] = (GLubyte) rgba[i][GCOMP];
750 dst[i*4+2] = (GLubyte) rgba[i][RCOMP];
751 dst[i*4+3] = (GLubyte) rgba[i][ACOMP];
752 }
753 break;
754 case GL_LUMINANCE_INTEGER_EXT:
755 for (i=0;i<n;i++) {
756 dst[i*2+0] = (GLubyte) (rgba[i][RCOMP] +
757 rgba[i][GCOMP] +
758 rgba[i][BCOMP]);
759 dst[i*2+1] = (GLubyte) rgba[i][ACOMP];
760 }
761 break;
762 case GL_LUMINANCE_ALPHA_INTEGER_EXT:
763 for (i=0;i<n;i++) {
764 dst[i] = (GLubyte) (rgba[i][RCOMP] +
765 rgba[i][GCOMP] +
766 rgba[i][BCOMP]);
767 }
768 break;
769 case GL_DUDV_ATI:
770 case GL_DU8DV8_ATI:
771 for (i=0;i<n;i++) {
772 dst[i*2+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
773 dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
774 }
775 break;
776 default:
777 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
778 }
779 }
780 break;
781 case GL_BYTE:
782 {
783 GLbyte *dst = (GLbyte *) dstAddr;
784 switch (dstFormat) {
785 case GL_RED:
786 for (i=0;i<n;i++)
787 dst[i] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
788 break;
789 case GL_GREEN:
790 for (i=0;i<n;i++)
791 dst[i] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
792 break;
793 case GL_BLUE:
794 for (i=0;i<n;i++)
795 dst[i] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
796 break;
797 case GL_ALPHA:
798 for (i=0;i<n;i++)
799 dst[i] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
800 break;
801 case GL_LUMINANCE:
802 for (i=0;i<n;i++)
803 dst[i] = FLOAT_TO_BYTE(luminance[i]);
804 break;
805 case GL_LUMINANCE_ALPHA:
806 for (i=0;i<n;i++) {
807 dst[i*2+0] = FLOAT_TO_BYTE(luminance[i]);
808 dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
809 }
810 break;
811 case GL_RG:
812 for (i=0;i<n;i++) {
813 dst[i*2+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
814 dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
815 }
816 break;
817 case GL_RGB:
818 for (i=0;i<n;i++) {
819 dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
820 dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
821 dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
822 }
823 break;
824 case GL_RGBA:
825 for (i=0;i<n;i++) {
826 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
827 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
828 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
829 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
830 }
831 break;
832 case GL_BGR:
833 for (i=0;i<n;i++) {
834 dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
835 dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
836 dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
837 }
838 break;
839 case GL_BGRA:
840 for (i=0;i<n;i++) {
841 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
842 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
843 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
844 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
845 }
846 break;
847 case GL_ABGR_EXT:
848 for (i=0;i<n;i++) {
849 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
850 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
851 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
852 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
853 }
854 break;
855 case GL_RED_INTEGER_EXT:
856 for (i=0;i<n;i++) {
857 dst[i] = (GLbyte) rgba[i][RCOMP];
858 }
859 break;
860 case GL_GREEN_INTEGER_EXT:
861 for (i=0;i<n;i++) {
862 dst[i] = (GLbyte) rgba[i][GCOMP];
863 }
864 break;
865 case GL_BLUE_INTEGER_EXT:
866 for (i=0;i<n;i++) {
867 dst[i] = (GLbyte) rgba[i][BCOMP];
868 }
869 break;
870 case GL_ALPHA_INTEGER_EXT:
871 for (i=0;i<n;i++) {
872 dst[i] = (GLbyte) rgba[i][ACOMP];
873 }
874 break;
875 case GL_RG_INTEGER:
876 for (i=0;i<n;i++) {
877 dst[i*2+0] = (GLbyte) rgba[i][RCOMP];
878 dst[i*2+1] = (GLbyte) rgba[i][GCOMP];
879 }
880 break;
881 case GL_RGB_INTEGER_EXT:
882 for (i=0;i<n;i++) {
883 dst[i*3+0] = (GLbyte) rgba[i][RCOMP];
884 dst[i*3+1] = (GLbyte) rgba[i][GCOMP];
885 dst[i*3+2] = (GLbyte) rgba[i][BCOMP];
886 }
887 break;
888 case GL_RGBA_INTEGER_EXT:
889 for (i=0;i<n;i++) {
890 dst[i*4+0] = (GLbyte) rgba[i][RCOMP];
891 dst[i*4+1] = (GLbyte) rgba[i][GCOMP];
892 dst[i*4+2] = (GLbyte) rgba[i][BCOMP];
893 dst[i*4+3] = (GLbyte) rgba[i][ACOMP];
894 }
895 break;
896 case GL_BGR_INTEGER_EXT:
897 for (i=0;i<n;i++) {
898 dst[i*3+0] = (GLbyte) rgba[i][BCOMP];
899 dst[i*3+1] = (GLbyte) rgba[i][GCOMP];
900 dst[i*3+2] = (GLbyte) rgba[i][RCOMP];
901 }
902 break;
903 case GL_BGRA_INTEGER_EXT:
904 for (i=0;i<n;i++) {
905 dst[i*4+0] = (GLbyte) rgba[i][BCOMP];
906 dst[i*4+1] = (GLbyte) rgba[i][GCOMP];
907 dst[i*4+2] = (GLbyte) rgba[i][RCOMP];
908 dst[i*4+3] = (GLbyte) rgba[i][ACOMP];
909 }
910 break;
911 case GL_LUMINANCE_INTEGER_EXT:
912 for (i=0;i<n;i++) {
913 dst[i*2+0] = (GLbyte) (rgba[i][RCOMP] +
914 rgba[i][GCOMP] +
915 rgba[i][BCOMP]);
916 dst[i*2+1] = (GLbyte) rgba[i][ACOMP];
917 }
918 break;
919 case GL_LUMINANCE_ALPHA_INTEGER_EXT:
920 for (i=0;i<n;i++) {
921 dst[i] = (GLbyte) (rgba[i][RCOMP] +
922 rgba[i][GCOMP] +
923 rgba[i][BCOMP]);
924 }
925 break;
926 case GL_DUDV_ATI:
927 case GL_DU8DV8_ATI:
928 for (i=0;i<n;i++) {
929 dst[i*2+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
930 dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
931 }
932 break;
933 default:
934 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
935 }
936 }
937 break;
938 case GL_UNSIGNED_SHORT:
939 {
940 GLushort *dst = (GLushort *) dstAddr;
941 switch (dstFormat) {
942 case GL_RED:
943 for (i=0;i<n;i++)
944 CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][RCOMP]);
945 break;
946 case GL_GREEN:
947 for (i=0;i<n;i++)
948 CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][GCOMP]);
949 break;
950 case GL_BLUE:
951 for (i=0;i<n;i++)
952 CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][BCOMP]);
953 break;
954 case GL_ALPHA:
955 for (i=0;i<n;i++)
956 CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][ACOMP]);
957 break;
958 case GL_LUMINANCE:
959 for (i=0;i<n;i++)
960 UNCLAMPED_FLOAT_TO_USHORT(dst[i], luminance[i]);
961 break;
962 case GL_LUMINANCE_ALPHA:
963 for (i=0;i<n;i++) {
964 UNCLAMPED_FLOAT_TO_USHORT(dst[i*2+0], luminance[i]);
965 CLAMPED_FLOAT_TO_USHORT(dst[i*2+1], rgba[i][ACOMP]);
966 }
967 break;
968 case GL_RG:
969 for (i=0;i<n;i++) {
970 CLAMPED_FLOAT_TO_USHORT(dst[i*2+0], rgba[i][RCOMP]);
971 CLAMPED_FLOAT_TO_USHORT(dst[i*2+1], rgba[i][GCOMP]);
972 }
973 break;
974 case GL_RGB:
975 for (i=0;i<n;i++) {
976 CLAMPED_FLOAT_TO_USHORT(dst[i*3+0], rgba[i][RCOMP]);
977 CLAMPED_FLOAT_TO_USHORT(dst[i*3+1], rgba[i][GCOMP]);
978 CLAMPED_FLOAT_TO_USHORT(dst[i*3+2], rgba[i][BCOMP]);
979 }
980 break;
981 case GL_RGBA:
982 for (i=0;i<n;i++) {
983 CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][RCOMP]);
984 CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][GCOMP]);
985 CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][BCOMP]);
986 CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][ACOMP]);
987 }
988 break;
989 case GL_BGR:
990 for (i=0;i<n;i++) {
991 CLAMPED_FLOAT_TO_USHORT(dst[i*3+0], rgba[i][BCOMP]);
992 CLAMPED_FLOAT_TO_USHORT(dst[i*3+1], rgba[i][GCOMP]);
993 CLAMPED_FLOAT_TO_USHORT(dst[i*3+2], rgba[i][RCOMP]);
994 }
995 break;
996 case GL_BGRA:
997 for (i=0;i<n;i++) {
998 CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][BCOMP]);
999 CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][GCOMP]);
1000 CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][RCOMP]);
1001 CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][ACOMP]);
1002 }
1003 break;
1004 case GL_ABGR_EXT:
1005 for (i=0;i<n;i++) {
1006 CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][ACOMP]);
1007 CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][BCOMP]);
1008 CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][GCOMP]);
1009 CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][RCOMP]);
1010 }
1011 break;
1012 case GL_RED_INTEGER_EXT:
1013 for (i=0;i<n;i++) {
1014 dst[i] = (GLushort) rgba[i][RCOMP];
1015 }
1016 break;
1017 case GL_GREEN_INTEGER_EXT:
1018 for (i=0;i<n;i++) {
1019 dst[i] = (GLushort) rgba[i][GCOMP];
1020 }
1021 break;
1022 case GL_BLUE_INTEGER_EXT:
1023 for (i=0;i<n;i++) {
1024 dst[i] = (GLushort) rgba[i][BCOMP];
1025 }
1026 break;
1027 case GL_ALPHA_INTEGER_EXT:
1028 for (i=0;i<n;i++) {
1029 dst[i] = (GLushort) rgba[i][ACOMP];
1030 }
1031 break;
1032 case GL_RG_INTEGER:
1033 for (i=0;i<n;i++) {
1034 dst[i*2+0] = (GLushort) rgba[i][RCOMP];
1035 dst[i*2+1] = (GLushort) rgba[i][GCOMP];
1036 }
1037 break;
1038 case GL_RGB_INTEGER_EXT:
1039 for (i=0;i<n;i++) {
1040 dst[i*3+0] = (GLushort) rgba[i][RCOMP];
1041 dst[i*3+1] = (GLushort) rgba[i][GCOMP];
1042 dst[i*3+2] = (GLushort) rgba[i][BCOMP];
1043 }
1044 break;
1045 case GL_RGBA_INTEGER_EXT:
1046 for (i=0;i<n;i++) {
1047 dst[i*4+0] = (GLushort) rgba[i][RCOMP];
1048 dst[i*4+1] = (GLushort) rgba[i][GCOMP];
1049 dst[i*4+2] = (GLushort) rgba[i][BCOMP];
1050 dst[i*4+3] = (GLushort) rgba[i][ACOMP];
1051 }
1052 break;
1053 case GL_BGR_INTEGER_EXT:
1054 for (i=0;i<n;i++) {
1055 dst[i*3+0] = (GLushort) rgba[i][BCOMP];
1056 dst[i*3+1] = (GLushort) rgba[i][GCOMP];
1057 dst[i*3+2] = (GLushort) rgba[i][RCOMP];
1058 }
1059 break;
1060 case GL_BGRA_INTEGER_EXT:
1061 for (i=0;i<n;i++) {
1062 dst[i*4+0] = (GLushort) rgba[i][BCOMP];
1063 dst[i*4+1] = (GLushort) rgba[i][GCOMP];
1064 dst[i*4+2] = (GLushort) rgba[i][RCOMP];
1065 dst[i*4+3] = (GLushort) rgba[i][ACOMP];
1066 }
1067 break;
1068 case GL_LUMINANCE_INTEGER_EXT:
1069 for (i=0;i<n;i++) {
1070 dst[i*2+0] = (GLushort) (rgba[i][RCOMP] +
1071 rgba[i][GCOMP] +
1072 rgba[i][BCOMP]);
1073 dst[i*2+1] = (GLushort) rgba[i][ACOMP];
1074 }
1075 break;
1076 case GL_LUMINANCE_ALPHA_INTEGER_EXT:
1077 for (i=0;i<n;i++) {
1078 dst[i] = (GLushort) (rgba[i][RCOMP] +
1079 rgba[i][GCOMP] +
1080 rgba[i][BCOMP]);
1081 }
1082 break;
1083 case GL_DUDV_ATI:
1084 case GL_DU8DV8_ATI:
1085 for (i=0;i<n;i++) {
1086 dst[i*2+0] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
1087 dst[i*2+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
1088 }
1089 break;
1090 default:
1091 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1092 }
1093 }
1094 break;
1095 case GL_SHORT:
1096 {
1097 GLshort *dst = (GLshort *) dstAddr;
1098 switch (dstFormat) {
1099 case GL_RED:
1100 for (i=0;i<n;i++)
1101 dst[i] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1102 break;
1103 case GL_GREEN:
1104 for (i=0;i<n;i++)
1105 dst[i] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1106 break;
1107 case GL_BLUE:
1108 for (i=0;i<n;i++)
1109 dst[i] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1110 break;
1111 case GL_ALPHA:
1112 for (i=0;i<n;i++)
1113 dst[i] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1114 break;
1115 case GL_LUMINANCE:
1116 for (i=0;i<n;i++)
1117 dst[i] = FLOAT_TO_SHORT(luminance[i]);
1118 break;
1119 case GL_LUMINANCE_ALPHA:
1120 for (i=0;i<n;i++) {
1121 dst[i*2+0] = FLOAT_TO_SHORT(luminance[i]);
1122 dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1123 }
1124 break;
1125 case GL_RG:
1126 for (i=0;i<n;i++) {
1127 dst[i*2+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1128 dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1129 }
1130 break;
1131 case GL_RGB:
1132 for (i=0;i<n;i++) {
1133 dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1134 dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1135 dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1136 }
1137 break;
1138 case GL_RGBA:
1139 for (i=0;i<n;i++) {
1140 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1141 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1142 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1143 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1144 }
1145 break;
1146 case GL_BGR:
1147 for (i=0;i<n;i++) {
1148 dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1149 dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1150 dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1151 }
1152 break;
1153 case GL_BGRA:
1154 for (i=0;i<n;i++) {
1155 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1156 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1157 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1158 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1159 }
1160 break;
1161 case GL_ABGR_EXT:
1162 for (i=0;i<n;i++) {
1163 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1164 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1165 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1166 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1167 }
1168 break;
1169 case GL_RED_INTEGER_EXT:
1170 for (i=0;i<n;i++) {
1171 dst[i] = (GLshort) rgba[i][RCOMP];
1172 }
1173 break;
1174 case GL_GREEN_INTEGER_EXT:
1175 for (i=0;i<n;i++) {
1176 dst[i] = (GLshort) rgba[i][GCOMP];
1177 }
1178 break;
1179 case GL_BLUE_INTEGER_EXT:
1180 for (i=0;i<n;i++) {
1181 dst[i] = (GLshort) rgba[i][BCOMP];
1182 }
1183 break;
1184 case GL_ALPHA_INTEGER_EXT:
1185 for (i=0;i<n;i++) {
1186 dst[i] = (GLshort) rgba[i][ACOMP];
1187 }
1188 break;
1189 case GL_RG_INTEGER:
1190 for (i=0;i<n;i++) {
1191 dst[i*2+0] = (GLshort) rgba[i][RCOMP];
1192 dst[i*2+1] = (GLshort) rgba[i][GCOMP];
1193 }
1194 break;
1195 case GL_RGB_INTEGER_EXT:
1196 for (i=0;i<n;i++) {
1197 dst[i*3+0] = (GLshort) rgba[i][RCOMP];
1198 dst[i*3+1] = (GLshort) rgba[i][GCOMP];
1199 dst[i*3+2] = (GLshort) rgba[i][BCOMP];
1200 }
1201 break;
1202 case GL_RGBA_INTEGER_EXT:
1203 for (i=0;i<n;i++) {
1204 dst[i*4+0] = (GLshort) rgba[i][RCOMP];
1205 dst[i*4+1] = (GLshort) rgba[i][GCOMP];
1206 dst[i*4+2] = (GLshort) rgba[i][BCOMP];
1207 dst[i*4+3] = (GLshort) rgba[i][ACOMP];
1208 }
1209 break;
1210 case GL_BGR_INTEGER_EXT:
1211 for (i=0;i<n;i++) {
1212 dst[i*3+0] = (GLshort) rgba[i][BCOMP];
1213 dst[i*3+1] = (GLshort) rgba[i][GCOMP];
1214 dst[i*3+2] = (GLshort) rgba[i][RCOMP];
1215 }
1216 break;
1217 case GL_BGRA_INTEGER_EXT:
1218 for (i=0;i<n;i++) {
1219 dst[i*4+0] = (GLshort) rgba[i][BCOMP];
1220 dst[i*4+1] = (GLshort) rgba[i][GCOMP];
1221 dst[i*4+2] = (GLshort) rgba[i][RCOMP];
1222 dst[i*4+3] = (GLshort) rgba[i][ACOMP];
1223 }
1224 break;
1225 case GL_LUMINANCE_INTEGER_EXT:
1226 for (i=0;i<n;i++) {
1227 dst[i*2+0] = (GLshort) (rgba[i][RCOMP] +
1228 rgba[i][GCOMP] +
1229 rgba[i][BCOMP]);
1230 dst[i*2+1] = (GLshort) rgba[i][ACOMP];
1231 }
1232 break;
1233 case GL_LUMINANCE_ALPHA_INTEGER_EXT:
1234 for (i=0;i<n;i++) {
1235 dst[i] = (GLshort) (rgba[i][RCOMP] +
1236 rgba[i][GCOMP] +
1237 rgba[i][BCOMP]);
1238 }
1239 break;
1240 case GL_DUDV_ATI:
1241 case GL_DU8DV8_ATI:
1242 for (i=0;i<n;i++) {
1243 dst[i*2+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1244 dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1245 }
1246 break;
1247 default:
1248 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1249 }
1250 }
1251 break;
1252 case GL_UNSIGNED_INT:
1253 {
1254 GLuint *dst = (GLuint *) dstAddr;
1255 switch (dstFormat) {
1256 case GL_RED:
1257 for (i=0;i<n;i++)
1258 dst[i] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1259 break;
1260 case GL_GREEN:
1261 for (i=0;i<n;i++)
1262 dst[i] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1263 break;
1264 case GL_BLUE:
1265 for (i=0;i<n;i++)
1266 dst[i] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1267 break;
1268 case GL_ALPHA:
1269 for (i=0;i<n;i++)
1270 dst[i] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1271 break;
1272 case GL_LUMINANCE:
1273 for (i=0;i<n;i++)
1274 dst[i] = FLOAT_TO_UINT(luminance[i]);
1275 break;
1276 case GL_LUMINANCE_ALPHA:
1277 for (i=0;i<n;i++) {
1278 dst[i*2+0] = FLOAT_TO_UINT(luminance[i]);
1279 dst[i*2+1] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1280 }
1281 break;
1282 case GL_RG:
1283 for (i=0;i<n;i++) {
1284 dst[i*2+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1285 dst[i*2+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1286 }
1287 break;
1288 case GL_RGB:
1289 for (i=0;i<n;i++) {
1290 dst[i*3+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1291 dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1292 dst[i*3+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1293 }
1294 break;
1295 case GL_RGBA:
1296 for (i=0;i<n;i++) {
1297 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1298 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1299 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1300 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1301 }
1302 break;
1303 case GL_BGR:
1304 for (i=0;i<n;i++) {
1305 dst[i*3+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1306 dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1307 dst[i*3+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1308 }
1309 break;
1310 case GL_BGRA:
1311 for (i=0;i<n;i++) {
1312 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1313 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1314 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1315 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1316 }
1317 break;
1318 case GL_ABGR_EXT:
1319 for (i=0;i<n;i++) {
1320 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1321 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1322 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1323 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1324 }
1325 break;
1326 case GL_RED_INTEGER_EXT:
1327 for (i=0;i<n;i++) {
1328 dst[i] = (GLuint) rgba[i][RCOMP];
1329 }
1330 break;
1331 case GL_GREEN_INTEGER_EXT:
1332 for (i=0;i<n;i++) {
1333 dst[i] = (GLuint) rgba[i][GCOMP];
1334 }
1335 break;
1336 case GL_BLUE_INTEGER_EXT:
1337 for (i=0;i<n;i++) {
1338 dst[i] = (GLuint) rgba[i][BCOMP];
1339 }
1340 break;
1341 case GL_ALPHA_INTEGER_EXT:
1342 for (i=0;i<n;i++) {
1343 dst[i] = (GLuint) rgba[i][ACOMP];
1344 }
1345 break;
1346 case GL_RG_INTEGER:
1347 for (i=0;i<n;i++) {
1348 dst[i*2+0] = (GLuint) rgba[i][RCOMP];
1349 dst[i*2+1] = (GLuint) rgba[i][GCOMP];
1350 }
1351 break;
1352 case GL_RGB_INTEGER_EXT:
1353 for (i=0;i<n;i++) {
1354 dst[i*3+0] = (GLuint) rgba[i][RCOMP];
1355 dst[i*3+1] = (GLuint) rgba[i][GCOMP];
1356 dst[i*3+2] = (GLuint) rgba[i][BCOMP];
1357 }
1358 break;
1359 case GL_RGBA_INTEGER_EXT:
1360 for (i=0;i<n;i++) {
1361 dst[i*4+0] = (GLuint) rgba[i][RCOMP];
1362 dst[i*4+1] = (GLuint) rgba[i][GCOMP];
1363 dst[i*4+2] = (GLuint) rgba[i][BCOMP];
1364 dst[i*4+3] = (GLuint) rgba[i][ACOMP];
1365 }
1366 break;
1367 case GL_BGR_INTEGER_EXT:
1368 for (i=0;i<n;i++) {
1369 dst[i*3+0] = (GLuint) rgba[i][BCOMP];
1370 dst[i*3+1] = (GLuint) rgba[i][GCOMP];
1371 dst[i*3+2] = (GLuint) rgba[i][RCOMP];
1372 }
1373 break;
1374 case GL_BGRA_INTEGER_EXT:
1375 for (i=0;i<n;i++) {
1376 dst[i*4+0] = (GLuint) rgba[i][BCOMP];
1377 dst[i*4+1] = (GLuint) rgba[i][GCOMP];
1378 dst[i*4+2] = (GLuint) rgba[i][RCOMP];
1379 dst[i*4+3] = (GLuint) rgba[i][ACOMP];
1380 }
1381 break;
1382 case GL_LUMINANCE_INTEGER_EXT:
1383 for (i=0;i<n;i++) {
1384 dst[i*2+0] = (GLuint) (rgba[i][RCOMP] +
1385 rgba[i][GCOMP] +
1386 rgba[i][BCOMP]);
1387 dst[i*2+1] = (GLuint) rgba[i][ACOMP];
1388 }
1389 break;
1390 case GL_LUMINANCE_ALPHA_INTEGER_EXT:
1391 for (i=0;i<n;i++) {
1392 dst[i] = (GLuint) (rgba[i][RCOMP] +
1393 rgba[i][GCOMP] +
1394 rgba[i][BCOMP]);
1395 }
1396 break;
1397 case GL_DUDV_ATI:
1398 case GL_DU8DV8_ATI:
1399 for (i=0;i<n;i++) {
1400 dst[i*2+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1401 dst[i*2+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1402 }
1403 break;
1404 default:
1405 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1406 }
1407 }
1408 break;
1409 case GL_INT:
1410 {
1411 GLint *dst = (GLint *) dstAddr;
1412 switch (dstFormat) {
1413 case GL_RED:
1414 for (i=0;i<n;i++)
1415 dst[i] = FLOAT_TO_INT(rgba[i][RCOMP]);
1416 break;
1417 case GL_GREEN:
1418 for (i=0;i<n;i++)
1419 dst[i] = FLOAT_TO_INT(rgba[i][GCOMP]);
1420 break;
1421 case GL_BLUE:
1422 for (i=0;i<n;i++)
1423 dst[i] = FLOAT_TO_INT(rgba[i][BCOMP]);
1424 break;
1425 case GL_ALPHA:
1426 for (i=0;i<n;i++)
1427 dst[i] = FLOAT_TO_INT(rgba[i][ACOMP]);
1428 break;
1429 case GL_LUMINANCE:
1430 for (i=0;i<n;i++)
1431 dst[i] = FLOAT_TO_INT(luminance[i]);
1432 break;
1433 case GL_LUMINANCE_ALPHA:
1434 for (i=0;i<n;i++) {
1435 dst[i*2+0] = FLOAT_TO_INT(luminance[i]);
1436 dst[i*2+1] = FLOAT_TO_INT(rgba[i][ACOMP]);
1437 }
1438 break;
1439 case GL_RG:
1440 for (i=0;i<n;i++) {
1441 dst[i*2+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
1442 dst[i*2+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1443 }
1444 break;
1445 case GL_RGB:
1446 for (i=0;i<n;i++) {
1447 dst[i*3+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
1448 dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1449 dst[i*3+2] = FLOAT_TO_INT(rgba[i][BCOMP]);
1450 }
1451 break;
1452 case GL_RGBA:
1453 for (i=0;i<n;i++) {
1454 dst[i*4+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
1455 dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1456 dst[i*4+2] = FLOAT_TO_INT(rgba[i][BCOMP]);
1457 dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);
1458 }
1459 break;
1460 case GL_BGR:
1461 for (i=0;i<n;i++) {
1462 dst[i*3+0] = FLOAT_TO_INT(rgba[i][BCOMP]);
1463 dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1464 dst[i*3+2] = FLOAT_TO_INT(rgba[i][RCOMP]);
1465 }
1466 break;
1467 case GL_BGRA:
1468 for (i=0;i<n;i++) {
1469 dst[i*4+0] = FLOAT_TO_INT(rgba[i][BCOMP]);
1470 dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1471 dst[i*4+2] = FLOAT_TO_INT(rgba[i][RCOMP]);
1472 dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);
1473 }
1474 break;
1475 case GL_ABGR_EXT:
1476 for (i=0;i<n;i++) {
1477 dst[i*4+0] = FLOAT_TO_INT(rgba[i][ACOMP]);
1478 dst[i*4+1] = FLOAT_TO_INT(rgba[i][BCOMP]);
1479 dst[i*4+2] = FLOAT_TO_INT(rgba[i][GCOMP]);
1480 dst[i*4+3] = FLOAT_TO_INT(rgba[i][RCOMP]);
1481 }
1482 break;
1483 case GL_DUDV_ATI:
1484 case GL_DU8DV8_ATI:
1485 for (i=0;i<n;i++) {
1486 dst[i*2+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
1487 dst[i*2+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1488 }
1489 break;
1490 case GL_RED_INTEGER_EXT:
1491 for (i=0;i<n;i++) {
1492 dst[i] = (GLint) rgba[i][RCOMP];
1493 }
1494 break;
1495 case GL_GREEN_INTEGER_EXT:
1496 for (i=0;i<n;i++) {
1497 dst[i] = (GLint) rgba[i][GCOMP];
1498 }
1499 break;
1500 case GL_BLUE_INTEGER_EXT:
1501 for (i=0;i<n;i++) {
1502 dst[i] = (GLint) rgba[i][BCOMP];
1503 }
1504 break;
1505 case GL_ALPHA_INTEGER_EXT:
1506 for (i=0;i<n;i++) {
1507 dst[i] = (GLint) rgba[i][ACOMP];
1508 }
1509 break;
1510 case GL_RG_INTEGER:
1511 for (i=0;i<n;i++) {
1512 dst[i*2+0] = (GLint) rgba[i][RCOMP];
1513 dst[i*2+1] = (GLint) rgba[i][GCOMP];
1514 }
1515 break;
1516 case GL_RGB_INTEGER_EXT:
1517 for (i=0;i<n;i++) {
1518 dst[i*3+0] = (GLint) rgba[i][RCOMP];
1519 dst[i*3+1] = (GLint) rgba[i][GCOMP];
1520 dst[i*3+2] = (GLint) rgba[i][BCOMP];
1521 }
1522 break;
1523 case GL_RGBA_INTEGER_EXT:
1524 for (i=0;i<n;i++) {
1525 dst[i*4+0] = (GLint) rgba[i][RCOMP];
1526 dst[i*4+1] = (GLint) rgba[i][GCOMP];
1527 dst[i*4+2] = (GLint) rgba[i][BCOMP];
1528 dst[i*4+3] = (GLint) rgba[i][ACOMP];
1529 }
1530 break;
1531 case GL_BGR_INTEGER_EXT:
1532 for (i=0;i<n;i++) {
1533 dst[i*3+0] = (GLint) rgba[i][BCOMP];
1534 dst[i*3+1] = (GLint) rgba[i][GCOMP];
1535 dst[i*3+2] = (GLint) rgba[i][RCOMP];
1536 }
1537 break;
1538 case GL_BGRA_INTEGER_EXT:
1539 for (i=0;i<n;i++) {
1540 dst[i*4+0] = (GLint) rgba[i][BCOMP];
1541 dst[i*4+1] = (GLint) rgba[i][GCOMP];
1542 dst[i*4+2] = (GLint) rgba[i][RCOMP];
1543 dst[i*4+3] = (GLint) rgba[i][ACOMP];
1544 }
1545 break;
1546 case GL_LUMINANCE_INTEGER_EXT:
1547 for (i=0;i<n;i++) {
1548 dst[i*2+0] = (GLint) (rgba[i][RCOMP] +
1549 rgba[i][GCOMP] +
1550 rgba[i][BCOMP]);
1551 dst[i*2+1] = (GLint) rgba[i][ACOMP];
1552 }
1553 break;
1554 case GL_LUMINANCE_ALPHA_INTEGER_EXT:
1555 for (i=0;i<n;i++) {
1556 dst[i] = (GLint) (rgba[i][RCOMP] +
1557 rgba[i][GCOMP] +
1558 rgba[i][BCOMP]);
1559 }
1560 break;
1561 default:
1562 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1563 }
1564 }
1565 break;
1566 case GL_FLOAT:
1567 {
1568 GLfloat *dst = (GLfloat *) dstAddr;
1569 switch (dstFormat) {
1570 case GL_RED:
1571 for (i=0;i<n;i++)
1572 dst[i] = rgba[i][RCOMP];
1573 break;
1574 case GL_GREEN:
1575 for (i=0;i<n;i++)
1576 dst[i] = rgba[i][GCOMP];
1577 break;
1578 case GL_BLUE:
1579 for (i=0;i<n;i++)
1580 dst[i] = rgba[i][BCOMP];
1581 break;
1582 case GL_ALPHA:
1583 for (i=0;i<n;i++)
1584 dst[i] = rgba[i][ACOMP];
1585 break;
1586 case GL_LUMINANCE:
1587 for (i=0;i<n;i++)
1588 dst[i] = luminance[i];
1589 break;
1590 case GL_LUMINANCE_ALPHA:
1591 for (i=0;i<n;i++) {
1592 dst[i*2+0] = luminance[i];
1593 dst[i*2+1] = rgba[i][ACOMP];
1594 }
1595 break;
1596 case GL_RG:
1597 for (i=0;i<n;i++) {
1598 dst[i*2+0] = rgba[i][RCOMP];
1599 dst[i*2+1] = rgba[i][GCOMP];
1600 }
1601 break;
1602 case GL_RGB:
1603 for (i=0;i<n;i++) {
1604 dst[i*3+0] = rgba[i][RCOMP];
1605 dst[i*3+1] = rgba[i][GCOMP];
1606 dst[i*3+2] = rgba[i][BCOMP];
1607 }
1608 break;
1609 case GL_RGBA:
1610 for (i=0;i<n;i++) {
1611 dst[i*4+0] = rgba[i][RCOMP];
1612 dst[i*4+1] = rgba[i][GCOMP];
1613 dst[i*4+2] = rgba[i][BCOMP];
1614 dst[i*4+3] = rgba[i][ACOMP];
1615 }
1616 break;
1617 case GL_BGR:
1618 for (i=0;i<n;i++) {
1619 dst[i*3+0] = rgba[i][BCOMP];
1620 dst[i*3+1] = rgba[i][GCOMP];
1621 dst[i*3+2] = rgba[i][RCOMP];
1622 }
1623 break;
1624 case GL_BGRA:
1625 for (i=0;i<n;i++) {
1626 dst[i*4+0] = rgba[i][BCOMP];
1627 dst[i*4+1] = rgba[i][GCOMP];
1628 dst[i*4+2] = rgba[i][RCOMP];
1629 dst[i*4+3] = rgba[i][ACOMP];
1630 }
1631 break;
1632 case GL_ABGR_EXT:
1633 for (i=0;i<n;i++) {
1634 dst[i*4+0] = rgba[i][ACOMP];
1635 dst[i*4+1] = rgba[i][BCOMP];
1636 dst[i*4+2] = rgba[i][GCOMP];
1637 dst[i*4+3] = rgba[i][RCOMP];
1638 }
1639 break;
1640 case GL_DUDV_ATI:
1641 case GL_DU8DV8_ATI:
1642 for (i=0;i<n;i++) {
1643 dst[i*2+0] = rgba[i][RCOMP];
1644 dst[i*2+1] = rgba[i][GCOMP];
1645 }
1646 break;
1647 default:
1648 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1649 }
1650 }
1651 break;
1652 case GL_HALF_FLOAT_ARB:
1653 {
1654 GLhalfARB *dst = (GLhalfARB *) dstAddr;
1655 switch (dstFormat) {
1656 case GL_RED:
1657 for (i=0;i<n;i++)
1658 dst[i] = _mesa_float_to_half(rgba[i][RCOMP]);
1659 break;
1660 case GL_GREEN:
1661 for (i=0;i<n;i++)
1662 dst[i] = _mesa_float_to_half(rgba[i][GCOMP]);
1663 break;
1664 case GL_BLUE:
1665 for (i=0;i<n;i++)
1666 dst[i] = _mesa_float_to_half(rgba[i][BCOMP]);
1667 break;
1668 case GL_ALPHA:
1669 for (i=0;i<n;i++)
1670 dst[i] = _mesa_float_to_half(rgba[i][ACOMP]);
1671 break;
1672 case GL_LUMINANCE:
1673 for (i=0;i<n;i++)
1674 dst[i] = _mesa_float_to_half(luminance[i]);
1675 break;
1676 case GL_LUMINANCE_ALPHA:
1677 for (i=0;i<n;i++) {
1678 dst[i*2+0] = _mesa_float_to_half(luminance[i]);
1679 dst[i*2+1] = _mesa_float_to_half(rgba[i][ACOMP]);
1680 }
1681 break;
1682 case GL_RG:
1683 for (i=0;i<n;i++) {
1684 dst[i*2+0] = _mesa_float_to_half(rgba[i][RCOMP]);
1685 dst[i*2+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1686 }
1687 break;
1688 case GL_RGB:
1689 for (i=0;i<n;i++) {
1690 dst[i*3+0] = _mesa_float_to_half(rgba[i][RCOMP]);
1691 dst[i*3+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1692 dst[i*3+2] = _mesa_float_to_half(rgba[i][BCOMP]);
1693 }
1694 break;
1695 case GL_RGBA:
1696 for (i=0;i<n;i++) {
1697 dst[i*4+0] = _mesa_float_to_half(rgba[i][RCOMP]);
1698 dst[i*4+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1699 dst[i*4+2] = _mesa_float_to_half(rgba[i][BCOMP]);
1700 dst[i*4+3] = _mesa_float_to_half(rgba[i][ACOMP]);
1701 }
1702 break;
1703 case GL_BGR:
1704 for (i=0;i<n;i++) {
1705 dst[i*3+0] = _mesa_float_to_half(rgba[i][BCOMP]);
1706 dst[i*3+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1707 dst[i*3+2] = _mesa_float_to_half(rgba[i][RCOMP]);
1708 }
1709 break;
1710 case GL_BGRA:
1711 for (i=0;i<n;i++) {
1712 dst[i*4+0] = _mesa_float_to_half(rgba[i][BCOMP]);
1713 dst[i*4+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1714 dst[i*4+2] = _mesa_float_to_half(rgba[i][RCOMP]);
1715 dst[i*4+3] = _mesa_float_to_half(rgba[i][ACOMP]);
1716 }
1717 break;
1718 case GL_ABGR_EXT:
1719 for (i=0;i<n;i++) {
1720 dst[i*4+0] = _mesa_float_to_half(rgba[i][ACOMP]);
1721 dst[i*4+1] = _mesa_float_to_half(rgba[i][BCOMP]);
1722 dst[i*4+2] = _mesa_float_to_half(rgba[i][GCOMP]);
1723 dst[i*4+3] = _mesa_float_to_half(rgba[i][RCOMP]);
1724 }
1725 break;
1726 case GL_DUDV_ATI:
1727 case GL_DU8DV8_ATI:
1728 for (i=0;i<n;i++) {
1729 dst[i*2+0] = _mesa_float_to_half(rgba[i][RCOMP]);
1730 dst[i*2+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1731 }
1732 break;
1733 default:
1734 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1735 }
1736 }
1737 break;
1738 case GL_UNSIGNED_BYTE_3_3_2:
1739 if (dstFormat == GL_RGB) {
1740 GLubyte *dst = (GLubyte *) dstAddr;
1741 for (i=0;i<n;i++) {
1742 dst[i] = (F_TO_I(rgba[i][RCOMP] * 7.0F) << 5)
1743 | (F_TO_I(rgba[i][GCOMP] * 7.0F) << 2)
1744 | (F_TO_I(rgba[i][BCOMP] * 3.0F) );
1745 }
1746 }
1747 break;
1748 case GL_UNSIGNED_BYTE_2_3_3_REV:
1749 if (dstFormat == GL_RGB) {
1750 GLubyte *dst = (GLubyte *) dstAddr;
1751 for (i=0;i<n;i++) {
1752 dst[i] = (F_TO_I(rgba[i][RCOMP] * 7.0F) )
1753 | (F_TO_I(rgba[i][GCOMP] * 7.0F) << 3)
1754 | (F_TO_I(rgba[i][BCOMP] * 3.0F) << 6);
1755 }
1756 }
1757 break;
1758 case GL_UNSIGNED_SHORT_5_6_5:
1759 if (dstFormat == GL_RGB) {
1760 GLushort *dst = (GLushort *) dstAddr;
1761 for (i=0;i<n;i++) {
1762 dst[i] = (F_TO_I(rgba[i][RCOMP] * 31.0F) << 11)
1763 | (F_TO_I(rgba[i][GCOMP] * 63.0F) << 5)
1764 | (F_TO_I(rgba[i][BCOMP] * 31.0F) );
1765 }
1766 }
1767 break;
1768 case GL_UNSIGNED_SHORT_5_6_5_REV:
1769 if (dstFormat == GL_RGB) {
1770 GLushort *dst = (GLushort *) dstAddr;
1771 for (i=0;i<n;i++) {
1772 dst[i] = (F_TO_I(rgba[i][RCOMP] * 31.0F) )
1773 | (F_TO_I(rgba[i][GCOMP] * 63.0F) << 5)
1774 | (F_TO_I(rgba[i][BCOMP] * 31.0F) << 11);
1775 }
1776 }
1777 break;
1778 case GL_UNSIGNED_SHORT_4_4_4_4:
1779 if (dstFormat == GL_RGBA) {
1780 GLushort *dst = (GLushort *) dstAddr;
1781 for (i=0;i<n;i++) {
1782 dst[i] = (F_TO_I(rgba[i][RCOMP] * 15.0F) << 12)
1783 | (F_TO_I(rgba[i][GCOMP] * 15.0F) << 8)
1784 | (F_TO_I(rgba[i][BCOMP] * 15.0F) << 4)
1785 | (F_TO_I(rgba[i][ACOMP] * 15.0F) );
1786 }
1787 }
1788 else if (dstFormat == GL_BGRA) {
1789 GLushort *dst = (GLushort *) dstAddr;
1790 for (i=0;i<n;i++) {
1791 dst[i] = (F_TO_I(rgba[i][BCOMP] * 15.0F) << 12)
1792 | (F_TO_I(rgba[i][GCOMP] * 15.0F) << 8)
1793 | (F_TO_I(rgba[i][RCOMP] * 15.0F) << 4)
1794 | (F_TO_I(rgba[i][ACOMP] * 15.0F) );
1795 }
1796 }
1797 else if (dstFormat == GL_ABGR_EXT) {
1798 GLushort *dst = (GLushort *) dstAddr;
1799 for (i=0;i<n;i++) {
1800 dst[i] = (F_TO_I(rgba[i][ACOMP] * 15.0F) << 12)
1801 | (F_TO_I(rgba[i][BCOMP] * 15.0F) << 8)
1802 | (F_TO_I(rgba[i][GCOMP] * 15.0F) << 4)
1803 | (F_TO_I(rgba[i][RCOMP] * 15.0F) );
1804 }
1805 }
1806 break;
1807 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1808 if (dstFormat == GL_RGBA) {
1809 GLushort *dst = (GLushort *) dstAddr;
1810 for (i=0;i<n;i++) {
1811 dst[i] = (F_TO_I(rgba[i][RCOMP] * 15.0F) )
1812 | (F_TO_I(rgba[i][GCOMP] * 15.0F) << 4)
1813 | (F_TO_I(rgba[i][BCOMP] * 15.0F) << 8)
1814 | (F_TO_I(rgba[i][ACOMP] * 15.0F) << 12);
1815 }
1816 }
1817 else if (dstFormat == GL_BGRA) {
1818 GLushort *dst = (GLushort *) dstAddr;
1819 for (i=0;i<n;i++) {
1820 dst[i] = (F_TO_I(rgba[i][BCOMP] * 15.0F) )
1821 | (F_TO_I(rgba[i][GCOMP] * 15.0F) << 4)
1822 | (F_TO_I(rgba[i][RCOMP] * 15.0F) << 8)
1823 | (F_TO_I(rgba[i][ACOMP] * 15.0F) << 12);
1824 }
1825 }
1826 else if (dstFormat == GL_ABGR_EXT) {
1827 GLushort *dst = (GLushort *) dstAddr;
1828 for (i=0;i<n;i++) {
1829 dst[i] = (F_TO_I(rgba[i][ACOMP] * 15.0F) )
1830 | (F_TO_I(rgba[i][BCOMP] * 15.0F) << 4)
1831 | (F_TO_I(rgba[i][GCOMP] * 15.0F) << 8)
1832 | (F_TO_I(rgba[i][RCOMP] * 15.0F) << 12);
1833 }
1834 }
1835 break;
1836 case GL_UNSIGNED_SHORT_5_5_5_1:
1837 if (dstFormat == GL_RGBA) {
1838 GLushort *dst = (GLushort *) dstAddr;
1839 for (i=0;i<n;i++) {
1840 dst[i] = (F_TO_I(rgba[i][RCOMP] * 31.0F) << 11)
1841 | (F_TO_I(rgba[i][GCOMP] * 31.0F) << 6)
1842 | (F_TO_I(rgba[i][BCOMP] * 31.0F) << 1)
1843 | (F_TO_I(rgba[i][ACOMP] * 1.0F) );
1844 }
1845 }
1846 else if (dstFormat == GL_BGRA) {
1847 GLushort *dst = (GLushort *) dstAddr;
1848 for (i=0;i<n;i++) {
1849 dst[i] = (F_TO_I(rgba[i][BCOMP] * 31.0F) << 11)
1850 | (F_TO_I(rgba[i][GCOMP] * 31.0F) << 6)
1851 | (F_TO_I(rgba[i][RCOMP] * 31.0F) << 1)
1852 | (F_TO_I(rgba[i][ACOMP] * 1.0F) );
1853 }
1854 }
1855 else if (dstFormat == GL_ABGR_EXT) {
1856 GLushort *dst = (GLushort *) dstAddr;
1857 for (i=0;i<n;i++) {
1858 dst[i] = (F_TO_I(rgba[i][ACOMP] * 31.0F) << 11)
1859 | (F_TO_I(rgba[i][BCOMP] * 31.0F) << 6)
1860 | (F_TO_I(rgba[i][GCOMP] * 31.0F) << 1)
1861 | (F_TO_I(rgba[i][RCOMP] * 1.0F) );
1862 }
1863 }
1864 break;
1865 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1866 if (dstFormat == GL_RGBA) {
1867 GLushort *dst = (GLushort *) dstAddr;
1868 for (i=0;i<n;i++) {
1869 dst[i] = (F_TO_I(rgba[i][RCOMP] * 31.0F) )
1870 | (F_TO_I(rgba[i][GCOMP] * 31.0F) << 5)
1871 | (F_TO_I(rgba[i][BCOMP] * 31.0F) << 10)
1872 | (F_TO_I(rgba[i][ACOMP] * 1.0F) << 15);
1873 }
1874 }
1875 else if (dstFormat == GL_BGRA) {
1876 GLushort *dst = (GLushort *) dstAddr;
1877 for (i=0;i<n;i++) {
1878 dst[i] = (F_TO_I(rgba[i][BCOMP] * 31.0F) )
1879 | (F_TO_I(rgba[i][GCOMP] * 31.0F) << 5)
1880 | (F_TO_I(rgba[i][RCOMP] * 31.0F) << 10)
1881 | (F_TO_I(rgba[i][ACOMP] * 1.0F) << 15);
1882 }
1883 }
1884 else if (dstFormat == GL_ABGR_EXT) {
1885 GLushort *dst = (GLushort *) dstAddr;
1886 for (i=0;i<n;i++) {
1887 dst[i] = (F_TO_I(rgba[i][ACOMP] * 31.0F) )
1888 | (F_TO_I(rgba[i][BCOMP] * 31.0F) << 5)
1889 | (F_TO_I(rgba[i][GCOMP] * 31.0F) << 10)
1890 | (F_TO_I(rgba[i][RCOMP] * 1.0F) << 15);
1891 }
1892 }
1893 break;
1894 case GL_UNSIGNED_INT_8_8_8_8:
1895 if (dstFormat == GL_RGBA) {
1896 GLuint *dst = (GLuint *) dstAddr;
1897 for (i=0;i<n;i++) {
1898 dst[i] = (F_TO_I(rgba[i][RCOMP] * 255.F) << 24)
1899 | (F_TO_I(rgba[i][GCOMP] * 255.F) << 16)
1900 | (F_TO_I(rgba[i][BCOMP] * 255.F) << 8)
1901 | (F_TO_I(rgba[i][ACOMP] * 255.F) );
1902 }
1903 }
1904 else if (dstFormat == GL_BGRA) {
1905 GLuint *dst = (GLuint *) dstAddr;
1906 for (i=0;i<n;i++) {
1907 dst[i] = (F_TO_I(rgba[i][BCOMP] * 255.F) << 24)
1908 | (F_TO_I(rgba[i][GCOMP] * 255.F) << 16)
1909 | (F_TO_I(rgba[i][RCOMP] * 255.F) << 8)
1910 | (F_TO_I(rgba[i][ACOMP] * 255.F) );
1911 }
1912 }
1913 else if (dstFormat == GL_ABGR_EXT) {
1914 GLuint *dst = (GLuint *) dstAddr;
1915 for (i=0;i<n;i++) {
1916 dst[i] = (F_TO_I(rgba[i][ACOMP] * 255.F) << 24)
1917 | (F_TO_I(rgba[i][BCOMP] * 255.F) << 16)
1918 | (F_TO_I(rgba[i][GCOMP] * 255.F) << 8)
1919 | (F_TO_I(rgba[i][RCOMP] * 255.F) );
1920 }
1921 }
1922 break;
1923 case GL_UNSIGNED_INT_8_8_8_8_REV:
1924 if (dstFormat == GL_RGBA) {
1925 GLuint *dst = (GLuint *) dstAddr;
1926 for (i=0;i<n;i++) {
1927 dst[i] = (F_TO_I(rgba[i][RCOMP] * 255.0F) )
1928 | (F_TO_I(rgba[i][GCOMP] * 255.0F) << 8)
1929 | (F_TO_I(rgba[i][BCOMP] * 255.0F) << 16)
1930 | (F_TO_I(rgba[i][ACOMP] * 255.0F) << 24);
1931 }
1932 }
1933 else if (dstFormat == GL_BGRA) {
1934 GLuint *dst = (GLuint *) dstAddr;
1935 for (i=0;i<n;i++) {
1936 dst[i] = (F_TO_I(rgba[i][BCOMP] * 255.0F) )
1937 | (F_TO_I(rgba[i][GCOMP] * 255.0F) << 8)
1938 | (F_TO_I(rgba[i][RCOMP] * 255.0F) << 16)
1939 | (F_TO_I(rgba[i][ACOMP] * 255.0F) << 24);
1940 }
1941 }
1942 else if (dstFormat == GL_ABGR_EXT) {
1943 GLuint *dst = (GLuint *) dstAddr;
1944 for (i=0;i<n;i++) {
1945 dst[i] = (F_TO_I(rgba[i][ACOMP] * 255.0F) )
1946 | (F_TO_I(rgba[i][BCOMP] * 255.0F) << 8)
1947 | (F_TO_I(rgba[i][GCOMP] * 255.0F) << 16)
1948 | (F_TO_I(rgba[i][RCOMP] * 255.0F) << 24);
1949 }
1950 }
1951 break;
1952 case GL_UNSIGNED_INT_10_10_10_2:
1953 if (dstFormat == GL_RGBA) {
1954 GLuint *dst = (GLuint *) dstAddr;
1955 for (i=0;i<n;i++) {
1956 dst[i] = (F_TO_I(rgba[i][RCOMP] * 1023.0F) << 22)
1957 | (F_TO_I(rgba[i][GCOMP] * 1023.0F) << 12)
1958 | (F_TO_I(rgba[i][BCOMP] * 1023.0F) << 2)
1959 | (F_TO_I(rgba[i][ACOMP] * 3.0F) );
1960 }
1961 }
1962 else if (dstFormat == GL_BGRA) {
1963 GLuint *dst = (GLuint *) dstAddr;
1964 for (i=0;i<n;i++) {
1965 dst[i] = (F_TO_I(rgba[i][BCOMP] * 1023.0F) << 22)
1966 | (F_TO_I(rgba[i][GCOMP] * 1023.0F) << 12)
1967 | (F_TO_I(rgba[i][RCOMP] * 1023.0F) << 2)
1968 | (F_TO_I(rgba[i][ACOMP] * 3.0F) );
1969 }
1970 }
1971 else if (dstFormat == GL_ABGR_EXT) {
1972 GLuint *dst = (GLuint *) dstAddr;
1973 for (i=0;i<n;i++) {
1974 dst[i] = (F_TO_I(rgba[i][ACOMP] * 1023.0F) << 22)
1975 | (F_TO_I(rgba[i][BCOMP] * 1023.0F) << 12)
1976 | (F_TO_I(rgba[i][GCOMP] * 1023.0F) << 2)
1977 | (F_TO_I(rgba[i][RCOMP] * 3.0F) );
1978 }
1979 }
1980 break;
1981 case GL_UNSIGNED_INT_2_10_10_10_REV:
1982 if (dstFormat == GL_RGBA) {
1983 GLuint *dst = (GLuint *) dstAddr;
1984 for (i=0;i<n;i++) {
1985 dst[i] = (F_TO_I(rgba[i][RCOMP] * 1023.0F) )
1986 | (F_TO_I(rgba[i][GCOMP] * 1023.0F) << 10)
1987 | (F_TO_I(rgba[i][BCOMP] * 1023.0F) << 20)
1988 | (F_TO_I(rgba[i][ACOMP] * 3.0F) << 30);
1989 }
1990 }
1991 else if (dstFormat == GL_BGRA) {
1992 GLuint *dst = (GLuint *) dstAddr;
1993 for (i=0;i<n;i++) {
1994 dst[i] = (F_TO_I(rgba[i][BCOMP] * 1023.0F) )
1995 | (F_TO_I(rgba[i][GCOMP] * 1023.0F) << 10)
1996 | (F_TO_I(rgba[i][RCOMP] * 1023.0F) << 20)
1997 | (F_TO_I(rgba[i][ACOMP] * 3.0F) << 30);
1998 }
1999 }
2000 else if (dstFormat == GL_ABGR_EXT) {
2001 GLuint *dst = (GLuint *) dstAddr;
2002 for (i=0;i<n;i++) {
2003 dst[i] = (F_TO_I(rgba[i][ACOMP] * 1023.0F) )
2004 | (F_TO_I(rgba[i][BCOMP] * 1023.0F) << 10)
2005 | (F_TO_I(rgba[i][GCOMP] * 1023.0F) << 20)
2006 | (F_TO_I(rgba[i][RCOMP] * 3.0F) << 30);
2007 }
2008 }
2009 break;
2010 case GL_UNSIGNED_INT_5_9_9_9_REV:
2011 {
2012 GLuint *dst = (GLuint *) dstAddr;
2013 for (i = 0; i < n; i++) {
2014 dst[i] = float3_to_rgb9e5(rgba[i]);
2015 }
2016 }
2017 break;
2018 case GL_UNSIGNED_INT_10F_11F_11F_REV:
2019 {
2020 GLuint *dst = (GLuint *) dstAddr;
2021 for (i = 0; i < n; i++) {
2022 dst[i] = float3_to_r11g11b10f(rgba[i]);
2023 }
2024 }
2025 break;
2026 default:
2027 _mesa_problem(ctx, "bad type in _mesa_pack_rgba_span_float");
2028 free(luminance);
2029 return;
2030 }
2031
2032 if (dstPacking->SwapBytes) {
2033 GLint swapSize = _mesa_sizeof_packed_type(dstType);
2034 if (swapSize == 2) {
2035 _mesa_swap2((GLushort *) dstAddr, n * comps);
2036 }
2037 else if (swapSize == 4) {
2038 _mesa_swap4((GLuint *) dstAddr, n * comps);
2039 }
2040 }
2041
2042 free(luminance);
2043 }
2044
2045
2046
2047 #define SWAP2BYTE(VALUE) \
2048 { \
2049 GLubyte *bytes = (GLubyte *) &(VALUE); \
2050 GLubyte tmp = bytes[0]; \
2051 bytes[0] = bytes[1]; \
2052 bytes[1] = tmp; \
2053 }
2054
2055 #define SWAP4BYTE(VALUE) \
2056 { \
2057 GLubyte *bytes = (GLubyte *) &(VALUE); \
2058 GLubyte tmp = bytes[0]; \
2059 bytes[0] = bytes[3]; \
2060 bytes[3] = tmp; \
2061 tmp = bytes[1]; \
2062 bytes[1] = bytes[2]; \
2063 bytes[2] = tmp; \
2064 }
2065
2066
2067 static void
2068 extract_uint_indexes(GLuint n, GLuint indexes[],
2069 GLenum srcFormat, GLenum srcType, const GLvoid *src,
2070 const struct gl_pixelstore_attrib *unpack )
2071 {
2072 ASSERT(srcFormat == GL_COLOR_INDEX || srcFormat == GL_STENCIL_INDEX);
2073
2074 ASSERT(srcType == GL_BITMAP ||
2075 srcType == GL_UNSIGNED_BYTE ||
2076 srcType == GL_BYTE ||
2077 srcType == GL_UNSIGNED_SHORT ||
2078 srcType == GL_SHORT ||
2079 srcType == GL_UNSIGNED_INT ||
2080 srcType == GL_INT ||
2081 srcType == GL_UNSIGNED_INT_24_8_EXT ||
2082 srcType == GL_HALF_FLOAT_ARB ||
2083 srcType == GL_FLOAT ||
2084 srcType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
2085
2086 switch (srcType) {
2087 case GL_BITMAP:
2088 {
2089 GLubyte *ubsrc = (GLubyte *) src;
2090 if (unpack->LsbFirst) {
2091 GLubyte mask = 1 << (unpack->SkipPixels & 0x7);
2092 GLuint i;
2093 for (i = 0; i < n; i++) {
2094 indexes[i] = (*ubsrc & mask) ? 1 : 0;
2095 if (mask == 128) {
2096 mask = 1;
2097 ubsrc++;
2098 }
2099 else {
2100 mask = mask << 1;
2101 }
2102 }
2103 }
2104 else {
2105 GLubyte mask = 128 >> (unpack->SkipPixels & 0x7);
2106 GLuint i;
2107 for (i = 0; i < n; i++) {
2108 indexes[i] = (*ubsrc & mask) ? 1 : 0;
2109 if (mask == 1) {
2110 mask = 128;
2111 ubsrc++;
2112 }
2113 else {
2114 mask = mask >> 1;
2115 }
2116 }
2117 }
2118 }
2119 break;
2120 case GL_UNSIGNED_BYTE:
2121 {
2122 GLuint i;
2123 const GLubyte *s = (const GLubyte *) src;
2124 for (i = 0; i < n; i++)
2125 indexes[i] = s[i];
2126 }
2127 break;
2128 case GL_BYTE:
2129 {
2130 GLuint i;
2131 const GLbyte *s = (const GLbyte *) src;
2132 for (i = 0; i < n; i++)
2133 indexes[i] = s[i];
2134 }
2135 break;
2136 case GL_UNSIGNED_SHORT:
2137 {
2138 GLuint i;
2139 const GLushort *s = (const GLushort *) src;
2140 if (unpack->SwapBytes) {
2141 for (i = 0; i < n; i++) {
2142 GLushort value = s[i];
2143 SWAP2BYTE(value);
2144 indexes[i] = value;
2145 }
2146 }
2147 else {
2148 for (i = 0; i < n; i++)
2149 indexes[i] = s[i];
2150 }
2151 }
2152 break;
2153 case GL_SHORT:
2154 {
2155 GLuint i;
2156 const GLshort *s = (const GLshort *) src;
2157 if (unpack->SwapBytes) {
2158 for (i = 0; i < n; i++) {
2159 GLshort value = s[i];
2160 SWAP2BYTE(value);
2161 indexes[i] = value;
2162 }
2163 }
2164 else {
2165 for (i = 0; i < n; i++)
2166 indexes[i] = s[i];
2167 }
2168 }
2169 break;
2170 case GL_UNSIGNED_INT:
2171 {
2172 GLuint i;
2173 const GLuint *s = (const GLuint *) src;
2174 if (unpack->SwapBytes) {
2175 for (i = 0; i < n; i++) {
2176 GLuint value = s[i];
2177 SWAP4BYTE(value);
2178 indexes[i] = value;
2179 }
2180 }
2181 else {
2182 for (i = 0; i < n; i++)
2183 indexes[i] = s[i];
2184 }
2185 }
2186 break;
2187 case GL_INT:
2188 {
2189 GLuint i;
2190 const GLint *s = (const GLint *) src;
2191 if (unpack->SwapBytes) {
2192 for (i = 0; i < n; i++) {
2193 GLint value = s[i];
2194 SWAP4BYTE(value);
2195 indexes[i] = value;
2196 }
2197 }
2198 else {
2199 for (i = 0; i < n; i++)
2200 indexes[i] = s[i];
2201 }
2202 }
2203 break;
2204 case GL_FLOAT:
2205 {
2206 GLuint i;
2207 const GLfloat *s = (const GLfloat *) src;
2208 if (unpack->SwapBytes) {
2209 for (i = 0; i < n; i++) {
2210 GLfloat value = s[i];
2211 SWAP4BYTE(value);
2212 indexes[i] = (GLuint) value;
2213 }
2214 }
2215 else {
2216 for (i = 0; i < n; i++)
2217 indexes[i] = (GLuint) s[i];
2218 }
2219 }
2220 break;
2221 case GL_HALF_FLOAT_ARB:
2222 {
2223 GLuint i;
2224 const GLhalfARB *s = (const GLhalfARB *) src;
2225 if (unpack->SwapBytes) {
2226 for (i = 0; i < n; i++) {
2227 GLhalfARB value = s[i];
2228 SWAP2BYTE(value);
2229 indexes[i] = (GLuint) _mesa_half_to_float(value);
2230 }
2231 }
2232 else {
2233 for (i = 0; i < n; i++)
2234 indexes[i] = (GLuint) _mesa_half_to_float(s[i]);
2235 }
2236 }
2237 break;
2238 case GL_UNSIGNED_INT_24_8_EXT:
2239 {
2240 GLuint i;
2241 const GLuint *s = (const GLuint *) src;
2242 if (unpack->SwapBytes) {
2243 for (i = 0; i < n; i++) {
2244 GLuint value = s[i];
2245 SWAP4BYTE(value);
2246 indexes[i] = value & 0xff; /* lower 8 bits */
2247 }
2248 }
2249 else {
2250 for (i = 0; i < n; i++)
2251 indexes[i] = s[i] & 0xff; /* lower 8 bits */
2252 }
2253 }
2254 break;
2255 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
2256 {
2257 GLuint i;
2258 const GLuint *s = (const GLuint *) src;
2259 if (unpack->SwapBytes) {
2260 for (i = 0; i < n; i++) {
2261 GLuint value = s[i*2+1];
2262 SWAP4BYTE(value);
2263 indexes[i] = value & 0xff; /* lower 8 bits */
2264 }
2265 }
2266 else {
2267 for (i = 0; i < n; i++)
2268 indexes[i] = s[i*2+1] & 0xff; /* lower 8 bits */
2269 }
2270 }
2271 break;
2272
2273 default:
2274 _mesa_problem(NULL, "bad srcType in extract_uint_indexes");
2275 return;
2276 }
2277 }
2278
2279
2280 /**
2281 * Return source/dest RGBA indexes for unpacking pixels.
2282 */
2283 static void
2284 get_component_mapping(GLenum format,
2285 GLint *rSrc,
2286 GLint *gSrc,
2287 GLint *bSrc,
2288 GLint *aSrc,
2289 GLint *rDst,
2290 GLint *gDst,
2291 GLint *bDst,
2292 GLint *aDst)
2293 {
2294 switch (format) {
2295 case GL_RED:
2296 case GL_RED_INTEGER_EXT:
2297 *rSrc = 0;
2298 *gSrc = *bSrc = *aSrc = -1;
2299 break;
2300 case GL_GREEN:
2301 case GL_GREEN_INTEGER_EXT:
2302 *gSrc = 0;
2303 *rSrc = *bSrc = *aSrc = -1;
2304 break;
2305 case GL_BLUE:
2306 case GL_BLUE_INTEGER_EXT:
2307 *bSrc = 0;
2308 *rSrc = *gSrc = *aSrc = -1;
2309 break;
2310 case GL_ALPHA:
2311 case GL_ALPHA_INTEGER_EXT:
2312 *rSrc = *gSrc = *bSrc = -1;
2313 *aSrc = 0;
2314 break;
2315 case GL_LUMINANCE:
2316 case GL_LUMINANCE_INTEGER_EXT:
2317 *rSrc = *gSrc = *bSrc = 0;
2318 *aSrc = -1;
2319 break;
2320 case GL_LUMINANCE_ALPHA:
2321 case GL_LUMINANCE_ALPHA_INTEGER_EXT:
2322 *rSrc = *gSrc = *bSrc = 0;
2323 *aSrc = 1;
2324 break;
2325 case GL_INTENSITY:
2326 *rSrc = *gSrc = *bSrc = *aSrc = 0;
2327 break;
2328 case GL_RG:
2329 case GL_RG_INTEGER:
2330 *rSrc = 0;
2331 *gSrc = 1;
2332 *bSrc = -1;
2333 *aSrc = -1;
2334 *rDst = 0;
2335 *gDst = 1;
2336 *bDst = 2;
2337 *aDst = 3;
2338 break;
2339 case GL_RGB:
2340 case GL_RGB_INTEGER:
2341 *rSrc = 0;
2342 *gSrc = 1;
2343 *bSrc = 2;
2344 *aSrc = -1;
2345 *rDst = 0;
2346 *gDst = 1;
2347 *bDst = 2;
2348 *aDst = 3;
2349 break;
2350 case GL_BGR:
2351 case GL_BGR_INTEGER:
2352 *rSrc = 2;
2353 *gSrc = 1;
2354 *bSrc = 0;
2355 *aSrc = -1;
2356 *rDst = 2;
2357 *gDst = 1;
2358 *bDst = 0;
2359 *aDst = 3;
2360 break;
2361 case GL_RGBA:
2362 case GL_RGBA_INTEGER:
2363 *rSrc = 0;
2364 *gSrc = 1;
2365 *bSrc = 2;
2366 *aSrc = 3;
2367 *rDst = 0;
2368 *gDst = 1;
2369 *bDst = 2;
2370 *aDst = 3;
2371 break;
2372 case GL_BGRA:
2373 case GL_BGRA_INTEGER:
2374 *rSrc = 2;
2375 *gSrc = 1;
2376 *bSrc = 0;
2377 *aSrc = 3;
2378 *rDst = 2;
2379 *gDst = 1;
2380 *bDst = 0;
2381 *aDst = 3;
2382 break;
2383 case GL_ABGR_EXT:
2384 *rSrc = 3;
2385 *gSrc = 2;
2386 *bSrc = 1;
2387 *aSrc = 0;
2388 *rDst = 3;
2389 *gDst = 2;
2390 *bDst = 1;
2391 *aDst = 0;
2392 break;
2393 case GL_DU8DV8_ATI:
2394 case GL_DUDV_ATI:
2395 *rSrc = 0;
2396 *gSrc = 1;
2397 *bSrc = -1;
2398 *aSrc = -1;
2399 break;
2400 default:
2401 _mesa_problem(NULL, "bad srcFormat %s in get_component_mapping",
2402 _mesa_lookup_enum_by_nr(format));
2403 return;
2404 }
2405 }
2406
2407
2408
2409 /*
2410 * This function extracts floating point RGBA values from arbitrary
2411 * image data. srcFormat and srcType are the format and type parameters
2412 * passed to glDrawPixels, glTexImage[123]D, glTexSubImage[123]D, etc.
2413 *
2414 * Refering to section 3.6.4 of the OpenGL 1.2 spec, this function
2415 * implements the "Conversion to floating point", "Conversion to RGB",
2416 * and "Final Expansion to RGBA" operations.
2417 *
2418 * Args: n - number of pixels
2419 * rgba - output colors
2420 * srcFormat - format of incoming data
2421 * srcType - data type of incoming data
2422 * src - source data pointer
2423 * swapBytes - perform byteswapping of incoming data?
2424 */
2425 static void
2426 extract_float_rgba(GLuint n, GLfloat rgba[][4],
2427 GLenum srcFormat, GLenum srcType, const GLvoid *src,
2428 GLboolean swapBytes)
2429 {
2430 GLint rSrc, gSrc, bSrc, aSrc;
2431 GLint stride;
2432 GLint rDst, bDst, gDst, aDst;
2433 GLboolean intFormat;
2434 GLfloat rs = 1.0f, gs = 1.0f, bs = 1.0f, as = 1.0f; /* scale factors */
2435
2436 ASSERT(srcFormat == GL_RED ||
2437 srcFormat == GL_GREEN ||
2438 srcFormat == GL_BLUE ||
2439 srcFormat == GL_ALPHA ||
2440 srcFormat == GL_LUMINANCE ||
2441 srcFormat == GL_LUMINANCE_ALPHA ||
2442 srcFormat == GL_INTENSITY ||
2443 srcFormat == GL_RG ||
2444 srcFormat == GL_RGB ||
2445 srcFormat == GL_BGR ||
2446 srcFormat == GL_RGBA ||
2447 srcFormat == GL_BGRA ||
2448 srcFormat == GL_ABGR_EXT ||
2449 srcFormat == GL_DU8DV8_ATI ||
2450 srcFormat == GL_DUDV_ATI ||
2451 srcFormat == GL_RED_INTEGER_EXT ||
2452 srcFormat == GL_GREEN_INTEGER_EXT ||
2453 srcFormat == GL_BLUE_INTEGER_EXT ||
2454 srcFormat == GL_ALPHA_INTEGER_EXT ||
2455 srcFormat == GL_RG_INTEGER ||
2456 srcFormat == GL_RGB_INTEGER_EXT ||
2457 srcFormat == GL_RGBA_INTEGER_EXT ||
2458 srcFormat == GL_BGR_INTEGER_EXT ||
2459 srcFormat == GL_BGRA_INTEGER_EXT ||
2460 srcFormat == GL_LUMINANCE_INTEGER_EXT ||
2461 srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);
2462
2463 ASSERT(srcType == GL_UNSIGNED_BYTE ||
2464 srcType == GL_BYTE ||
2465 srcType == GL_UNSIGNED_SHORT ||
2466 srcType == GL_SHORT ||
2467 srcType == GL_UNSIGNED_INT ||
2468 srcType == GL_INT ||
2469 srcType == GL_HALF_FLOAT_ARB ||
2470 srcType == GL_FLOAT ||
2471 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
2472 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
2473 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
2474 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
2475 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
2476 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
2477 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
2478 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
2479 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
2480 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
2481 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
2482 srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
2483 srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
2484 srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
2485
2486 get_component_mapping(srcFormat,
2487 &rSrc, &gSrc, &bSrc, &aSrc,
2488 &rDst, &gDst, &bDst, &aDst);
2489
2490 stride = _mesa_components_in_format(srcFormat);
2491
2492 intFormat = _mesa_is_integer_format(srcFormat);
2493
2494 #define PROCESS(SRC_INDEX, DST_INDEX, DEFAULT_FLT, DEFAULT_INT, TYPE, CONVERSION) \
2495 if ((SRC_INDEX) < 0) { \
2496 GLuint i; \
2497 if (intFormat) { \
2498 for (i = 0; i < n; i++) { \
2499 rgba[i][DST_INDEX] = DEFAULT_INT; \
2500 } \
2501 } \
2502 else { \
2503 for (i = 0; i < n; i++) { \
2504 rgba[i][DST_INDEX] = DEFAULT_FLT; \
2505 } \
2506 } \
2507 } \
2508 else if (swapBytes) { \
2509 const TYPE *s = (const TYPE *) src; \
2510 GLuint i; \
2511 for (i = 0; i < n; i++) { \
2512 TYPE value = s[SRC_INDEX]; \
2513 if (sizeof(TYPE) == 2) { \
2514 SWAP2BYTE(value); \
2515 } \
2516 else if (sizeof(TYPE) == 4) { \
2517 SWAP4BYTE(value); \
2518 } \
2519 if (intFormat) \
2520 rgba[i][DST_INDEX] = (GLfloat) value; \
2521 else \
2522 rgba[i][DST_INDEX] = (GLfloat) CONVERSION(value); \
2523 s += stride; \
2524 } \
2525 } \
2526 else { \
2527 const TYPE *s = (const TYPE *) src; \
2528 GLuint i; \
2529 if (intFormat) { \
2530 for (i = 0; i < n; i++) { \
2531 rgba[i][DST_INDEX] = (GLfloat) s[SRC_INDEX]; \
2532 s += stride; \
2533 } \
2534 } \
2535 else { \
2536 for (i = 0; i < n; i++) { \
2537 rgba[i][DST_INDEX] = (GLfloat) CONVERSION(s[SRC_INDEX]); \
2538 s += stride; \
2539 } \
2540 } \
2541 }
2542
2543 switch (srcType) {
2544 case GL_UNSIGNED_BYTE:
2545 PROCESS(rSrc, RCOMP, 0.0F, 0, GLubyte, UBYTE_TO_FLOAT);
2546 PROCESS(gSrc, GCOMP, 0.0F, 0, GLubyte, UBYTE_TO_FLOAT);
2547 PROCESS(bSrc, BCOMP, 0.0F, 0, GLubyte, UBYTE_TO_FLOAT);
2548 PROCESS(aSrc, ACOMP, 1.0F, 255, GLubyte, UBYTE_TO_FLOAT);
2549 break;
2550 case GL_BYTE:
2551 PROCESS(rSrc, RCOMP, 0.0F, 0, GLbyte, BYTE_TO_FLOATZ);
2552 PROCESS(gSrc, GCOMP, 0.0F, 0, GLbyte, BYTE_TO_FLOATZ);
2553 PROCESS(bSrc, BCOMP, 0.0F, 0, GLbyte, BYTE_TO_FLOATZ);
2554 PROCESS(aSrc, ACOMP, 1.0F, 127, GLbyte, BYTE_TO_FLOATZ);
2555 break;
2556 case GL_UNSIGNED_SHORT:
2557 PROCESS(rSrc, RCOMP, 0.0F, 0, GLushort, USHORT_TO_FLOAT);
2558 PROCESS(gSrc, GCOMP, 0.0F, 0, GLushort, USHORT_TO_FLOAT);
2559 PROCESS(bSrc, BCOMP, 0.0F, 0, GLushort, USHORT_TO_FLOAT);
2560 PROCESS(aSrc, ACOMP, 1.0F, 0xffff, GLushort, USHORT_TO_FLOAT);
2561 break;
2562 case GL_SHORT:
2563 PROCESS(rSrc, RCOMP, 0.0F, 0, GLshort, SHORT_TO_FLOATZ);
2564 PROCESS(gSrc, GCOMP, 0.0F, 0, GLshort, SHORT_TO_FLOATZ);
2565 PROCESS(bSrc, BCOMP, 0.0F, 0, GLshort, SHORT_TO_FLOATZ);
2566 PROCESS(aSrc, ACOMP, 1.0F, 32767, GLshort, SHORT_TO_FLOATZ);
2567 break;
2568 case GL_UNSIGNED_INT:
2569 PROCESS(rSrc, RCOMP, 0.0F, 0, GLuint, UINT_TO_FLOAT);
2570 PROCESS(gSrc, GCOMP, 0.0F, 0, GLuint, UINT_TO_FLOAT);
2571 PROCESS(bSrc, BCOMP, 0.0F, 0, GLuint, UINT_TO_FLOAT);
2572 PROCESS(aSrc, ACOMP, 1.0F, 0xffffffff, GLuint, UINT_TO_FLOAT);
2573 break;
2574 case GL_INT:
2575 PROCESS(rSrc, RCOMP, 0.0F, 0, GLint, INT_TO_FLOAT);
2576 PROCESS(gSrc, GCOMP, 0.0F, 0, GLint, INT_TO_FLOAT);
2577 PROCESS(bSrc, BCOMP, 0.0F, 0, GLint, INT_TO_FLOAT);
2578 PROCESS(aSrc, ACOMP, 1.0F, 2147483647, GLint, INT_TO_FLOAT);
2579 break;
2580 case GL_FLOAT:
2581 PROCESS(rSrc, RCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
2582 PROCESS(gSrc, GCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
2583 PROCESS(bSrc, BCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
2584 PROCESS(aSrc, ACOMP, 1.0F, 1.0F, GLfloat, (GLfloat));
2585 break;
2586 case GL_HALF_FLOAT_ARB:
2587 PROCESS(rSrc, RCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
2588 PROCESS(gSrc, GCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
2589 PROCESS(bSrc, BCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
2590 PROCESS(aSrc, ACOMP, 1.0F, 1.0F, GLhalfARB, _mesa_half_to_float);
2591 break;
2592 case GL_UNSIGNED_BYTE_3_3_2:
2593 {
2594 const GLubyte *ubsrc = (const GLubyte *) src;
2595 GLuint i;
2596 if (!intFormat) {
2597 rs = 1.0F / 7.0F;
2598 gs = 1.0F / 7.0F;
2599 bs = 1.0F / 3.0F;
2600 }
2601 for (i = 0; i < n; i ++) {
2602 GLubyte p = ubsrc[i];
2603 rgba[i][rDst] = ((p >> 5) ) * rs;
2604 rgba[i][gDst] = ((p >> 2) & 0x7) * gs;
2605 rgba[i][bDst] = ((p ) & 0x3) * bs;
2606 rgba[i][aDst] = 1.0F;
2607 }
2608 }
2609 break;
2610 case GL_UNSIGNED_BYTE_2_3_3_REV:
2611 {
2612 const GLubyte *ubsrc = (const GLubyte *) src;
2613 GLuint i;
2614 if (!intFormat) {
2615 rs = 1.0F / 7.0F;
2616 gs = 1.0F / 7.0F;
2617 bs = 1.0F / 3.0F;
2618 }
2619 for (i = 0; i < n; i ++) {
2620 GLubyte p = ubsrc[i];
2621 rgba[i][rDst] = ((p ) & 0x7) * rs;
2622 rgba[i][gDst] = ((p >> 3) & 0x7) * gs;
2623 rgba[i][bDst] = ((p >> 6) ) * bs;
2624 rgba[i][aDst] = 1.0F;
2625 }
2626 }
2627 break;
2628 case GL_UNSIGNED_SHORT_5_6_5:
2629 if (!intFormat) {
2630 rs = 1.0F / 31.0F;
2631 gs = 1.0F / 63.0F;
2632 bs = 1.0F / 31.0F;
2633 }
2634 if (swapBytes) {
2635 const GLushort *ussrc = (const GLushort *) src;
2636 GLuint i;
2637 for (i = 0; i < n; i ++) {
2638 GLushort p = ussrc[i];
2639 SWAP2BYTE(p);
2640 rgba[i][rDst] = ((p >> 11) ) * rs;
2641 rgba[i][gDst] = ((p >> 5) & 0x3f) * gs;
2642 rgba[i][bDst] = ((p ) & 0x1f) * bs;
2643 rgba[i][aDst] = 1.0F;
2644 }
2645 }
2646 else {
2647 const GLushort *ussrc = (const GLushort *) src;
2648 GLuint i;
2649 for (i = 0; i < n; i ++) {
2650 GLushort p = ussrc[i];
2651 rgba[i][rDst] = ((p >> 11) ) * rs;
2652 rgba[i][gDst] = ((p >> 5) & 0x3f) * gs;
2653 rgba[i][bDst] = ((p ) & 0x1f) * bs;
2654 rgba[i][aDst] = 1.0F;
2655 }
2656 }
2657 break;
2658 case GL_UNSIGNED_SHORT_5_6_5_REV:
2659 if (!intFormat) {
2660 rs = 1.0F / 31.0F;
2661 gs = 1.0F / 63.0F;
2662 bs = 1.0F / 31.0F;
2663 }
2664 if (swapBytes) {
2665 const GLushort *ussrc = (const GLushort *) src;
2666 GLuint i;
2667 for (i = 0; i < n; i ++) {
2668 GLushort p = ussrc[i];
2669 SWAP2BYTE(p);
2670 rgba[i][rDst] = ((p ) & 0x1f) * rs;
2671 rgba[i][gDst] = ((p >> 5) & 0x3f) * gs;
2672 rgba[i][bDst] = ((p >> 11) ) * bs;
2673 rgba[i][aDst] = 1.0F;
2674 }
2675 }
2676 else {
2677 const GLushort *ussrc = (const GLushort *) src;
2678 GLuint i;
2679 for (i = 0; i < n; i ++) {
2680 GLushort p = ussrc[i];
2681 rgba[i][rDst] = ((p ) & 0x1f) * rs;
2682 rgba[i][gDst] = ((p >> 5) & 0x3f) * gs;
2683 rgba[i][bDst] = ((p >> 11) ) * bs;
2684 rgba[i][aDst] = 1.0F;
2685 }
2686 }
2687 break;
2688 case GL_UNSIGNED_SHORT_4_4_4_4:
2689 if (!intFormat) {
2690 rs = gs = bs = as = 1.0F / 15.0F;
2691 }
2692 if (swapBytes) {
2693 const GLushort *ussrc = (const GLushort *) src;
2694 GLuint i;
2695 for (i = 0; i < n; i ++) {
2696 GLushort p = ussrc[i];
2697 SWAP2BYTE(p);
2698 rgba[i][rDst] = ((p >> 12) ) * rs;
2699 rgba[i][gDst] = ((p >> 8) & 0xf) * gs;
2700 rgba[i][bDst] = ((p >> 4) & 0xf) * bs;
2701 rgba[i][aDst] = ((p ) & 0xf) * as;
2702 }
2703 }
2704 else {
2705 const GLushort *ussrc = (const GLushort *) src;
2706 GLuint i;
2707 for (i = 0; i < n; i ++) {
2708 GLushort p = ussrc[i];
2709 rgba[i][rDst] = ((p >> 12) ) * rs;
2710 rgba[i][gDst] = ((p >> 8) & 0xf) * gs;
2711 rgba[i][bDst] = ((p >> 4) & 0xf) * bs;
2712 rgba[i][aDst] = ((p ) & 0xf) * as;
2713 }
2714 }
2715 break;
2716 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
2717 if (!intFormat) {
2718 rs = gs = bs = as = 1.0F / 15.0F;
2719 }
2720 if (swapBytes) {
2721 const GLushort *ussrc = (const GLushort *) src;
2722 GLuint i;
2723 for (i = 0; i < n; i ++) {
2724 GLushort p = ussrc[i];
2725 SWAP2BYTE(p);
2726 rgba[i][rDst] = ((p ) & 0xf) * rs;
2727 rgba[i][gDst] = ((p >> 4) & 0xf) * gs;
2728 rgba[i][bDst] = ((p >> 8) & 0xf) * bs;
2729 rgba[i][aDst] = ((p >> 12) ) * as;
2730 }
2731 }
2732 else {
2733 const GLushort *ussrc = (const GLushort *) src;
2734 GLuint i;
2735 for (i = 0; i < n; i ++) {
2736 GLushort p = ussrc[i];
2737 rgba[i][rDst] = ((p ) & 0xf) * rs;
2738 rgba[i][gDst] = ((p >> 4) & 0xf) * gs;
2739 rgba[i][bDst] = ((p >> 8) & 0xf) * bs;
2740 rgba[i][aDst] = ((p >> 12) ) * as;
2741 }
2742 }
2743 break;
2744 case GL_UNSIGNED_SHORT_5_5_5_1:
2745 if (!intFormat) {
2746 rs = gs = bs = 1.0F / 31.0F;
2747 }
2748 if (swapBytes) {
2749 const GLushort *ussrc = (const GLushort *) src;
2750 GLuint i;
2751 for (i = 0; i < n; i ++) {
2752 GLushort p = ussrc[i];
2753 SWAP2BYTE(p);
2754 rgba[i][rDst] = ((p >> 11) ) * rs;
2755 rgba[i][gDst] = ((p >> 6) & 0x1f) * gs;
2756 rgba[i][bDst] = ((p >> 1) & 0x1f) * bs;
2757 rgba[i][aDst] = ((p ) & 0x1) * as;
2758 }
2759 }
2760 else {
2761 const GLushort *ussrc = (const GLushort *) src;
2762 GLuint i;
2763 for (i = 0; i < n; i ++) {
2764 GLushort p = ussrc[i];
2765 rgba[i][rDst] = ((p >> 11) ) * rs;
2766 rgba[i][gDst] = ((p >> 6) & 0x1f) * gs;
2767 rgba[i][bDst] = ((p >> 1) & 0x1f) * bs;
2768 rgba[i][aDst] = ((p ) & 0x1) * as;
2769 }
2770 }
2771 break;
2772 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
2773 if (!intFormat) {
2774 rs = gs = bs = 1.0F / 31.0F;
2775 }
2776 if (swapBytes) {
2777 const GLushort *ussrc = (const GLushort *) src;
2778 GLuint i;
2779 for (i = 0; i < n; i ++) {
2780 GLushort p = ussrc[i];
2781 SWAP2BYTE(p);
2782 rgba[i][rDst] = ((p ) & 0x1f) * rs;
2783 rgba[i][gDst] = ((p >> 5) & 0x1f) * gs;
2784 rgba[i][bDst] = ((p >> 10) & 0x1f) * bs;
2785 rgba[i][aDst] = ((p >> 15) ) * as;
2786 }
2787 }
2788 else {
2789 const GLushort *ussrc = (const GLushort *) src;
2790 GLuint i;
2791 for (i = 0; i < n; i ++) {
2792 GLushort p = ussrc[i];
2793 rgba[i][rDst] = ((p ) & 0x1f) * rs;
2794 rgba[i][gDst] = ((p >> 5) & 0x1f) * gs;
2795 rgba[i][bDst] = ((p >> 10) & 0x1f) * bs;
2796 rgba[i][aDst] = ((p >> 15) ) * as;
2797 }
2798 }
2799 break;
2800 case GL_UNSIGNED_INT_8_8_8_8:
2801 if (swapBytes) {
2802 const GLuint *uisrc = (const GLuint *) src;
2803 GLuint i;
2804 if (intFormat) {
2805 for (i = 0; i < n; i ++) {
2806 GLuint p = uisrc[i];
2807 rgba[i][rDst] = (GLfloat) ((p ) & 0xff);
2808 rgba[i][gDst] = (GLfloat) ((p >> 8) & 0xff);
2809 rgba[i][bDst] = (GLfloat) ((p >> 16) & 0xff);
2810 rgba[i][aDst] = (GLfloat) ((p >> 24) );
2811 }
2812 }
2813 else {
2814 for (i = 0; i < n; i ++) {
2815 GLuint p = uisrc[i];
2816 rgba[i][rDst] = UBYTE_TO_FLOAT((p ) & 0xff);
2817 rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
2818 rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2819 rgba[i][aDst] = UBYTE_TO_FLOAT((p >> 24) );
2820 }
2821 }
2822 }
2823 else {
2824 const GLuint *uisrc = (const GLuint *) src;
2825 GLuint i;
2826 if (intFormat) {
2827 for (i = 0; i < n; i ++) {
2828 GLuint p = uisrc[i];
2829 rgba[i][rDst] = (GLfloat) ((p >> 24) );
2830 rgba[i][gDst] = (GLfloat) ((p >> 16) & 0xff);
2831 rgba[i][bDst] = (GLfloat) ((p >> 8) & 0xff);
2832 rgba[i][aDst] = (GLfloat) ((p ) & 0xff);
2833 }
2834 }
2835 else {
2836 for (i = 0; i < n; i ++) {
2837 GLuint p = uisrc[i];
2838 rgba[i][rDst] = UBYTE_TO_FLOAT((p >> 24) );
2839 rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2840 rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
2841 rgba[i][aDst] = UBYTE_TO_FLOAT((p ) & 0xff);
2842 }
2843 }
2844 }
2845 break;
2846 case GL_UNSIGNED_INT_8_8_8_8_REV:
2847 if (swapBytes) {
2848 const GLuint *uisrc = (const GLuint *) src;
2849 GLuint i;
2850 if (intFormat) {
2851 for (i = 0; i < n; i ++) {
2852 GLuint p = uisrc[i];
2853 rgba[i][rDst] = (GLfloat) ((p >> 24) );
2854 rgba[i][gDst] = (GLfloat) ((p >> 16) & 0xff);
2855 rgba[i][bDst] = (GLfloat) ((p >> 8) & 0xff);
2856 rgba[i][aDst] = (GLfloat) ((p ) & 0xff);
2857 }
2858 }
2859 else {
2860 for (i = 0; i < n; i ++) {
2861 GLuint p = uisrc[i];
2862 rgba[i][rDst] = UBYTE_TO_FLOAT((p >> 24) );
2863 rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2864 rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
2865 rgba[i][aDst] = UBYTE_TO_FLOAT((p ) & 0xff);
2866 }
2867 }
2868 }
2869 else {
2870 const GLuint *uisrc = (const GLuint *) src;
2871 GLuint i;
2872 if (intFormat) {
2873 for (i = 0; i < n; i ++) {
2874 GLuint p = uisrc[i];
2875 rgba[i][rDst] = (GLfloat) ((p ) & 0xff);
2876 rgba[i][gDst] = (GLfloat) ((p >> 8) & 0xff);
2877 rgba[i][bDst] = (GLfloat) ((p >> 16) & 0xff);
2878 rgba[i][aDst] = (GLfloat) ((p >> 24) );
2879 }
2880 }
2881 else {
2882 for (i = 0; i < n; i ++) {
2883 GLuint p = uisrc[i];
2884 rgba[i][rDst] = UBYTE_TO_FLOAT((p ) & 0xff);
2885 rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
2886 rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2887 rgba[i][aDst] = UBYTE_TO_FLOAT((p >> 24) );
2888 }
2889 }
2890 }
2891 break;
2892 case GL_UNSIGNED_INT_10_10_10_2:
2893 if (!intFormat) {
2894 rs = 1.0F / 1023.0F;
2895 gs = 1.0F / 1023.0F;
2896 bs = 1.0F / 1023.0F;
2897 as = 1.0F / 3.0F;
2898 }
2899 if (swapBytes) {
2900 const GLuint *uisrc = (const GLuint *) src;
2901 GLuint i;
2902 for (i = 0; i < n; i ++) {
2903 GLuint p = uisrc[i];
2904 SWAP4BYTE(p);
2905 rgba[i][rDst] = ((p >> 22) ) * rs;
2906 rgba[i][gDst] = ((p >> 12) & 0x3ff) * gs;
2907 rgba[i][bDst] = ((p >> 2) & 0x3ff) * bs;
2908 rgba[i][aDst] = ((p ) & 0x3 ) * as;
2909 }
2910 }
2911 else {
2912 const GLuint *uisrc = (const GLuint *) src;
2913 GLuint i;
2914 for (i = 0; i < n; i ++) {
2915 GLuint p = uisrc[i];
2916 rgba[i][rDst] = ((p >> 22) ) * rs;
2917 rgba[i][gDst] = ((p >> 12) & 0x3ff) * gs;
2918 rgba[i][bDst] = ((p >> 2) & 0x3ff) * bs;
2919 rgba[i][aDst] = ((p ) & 0x3 ) * as;
2920 }
2921 }
2922 break;
2923 case GL_UNSIGNED_INT_2_10_10_10_REV:
2924 if (!intFormat) {
2925 rs = 1.0F / 1023.0F;
2926 gs = 1.0F / 1023.0F;
2927 bs = 1.0F / 1023.0F;
2928 as = 1.0F / 3.0F;
2929 }
2930 if (swapBytes) {
2931 const GLuint *uisrc = (const GLuint *) src;
2932 GLuint i;
2933 for (i = 0; i < n; i ++) {
2934 GLuint p = uisrc[i];
2935 SWAP4BYTE(p);
2936 rgba[i][rDst] = ((p ) & 0x3ff) * rs;
2937 rgba[i][gDst] = ((p >> 10) & 0x3ff) * gs;
2938 rgba[i][bDst] = ((p >> 20) & 0x3ff) * bs;
2939 rgba[i][aDst] = ((p >> 30) ) * as;
2940 }
2941 }
2942 else {
2943 const GLuint *uisrc = (const GLuint *) src;
2944 GLuint i;
2945 for (i = 0; i < n; i ++) {
2946 GLuint p = uisrc[i];
2947 rgba[i][rDst] = ((p ) & 0x3ff) * rs;
2948 rgba[i][gDst] = ((p >> 10) & 0x3ff) * gs;
2949 rgba[i][bDst] = ((p >> 20) & 0x3ff) * bs;
2950 rgba[i][aDst] = ((p >> 30) ) * as;
2951 }
2952 }
2953 break;
2954 case GL_UNSIGNED_INT_5_9_9_9_REV:
2955 if (swapBytes) {
2956 const GLuint *uisrc = (const GLuint *) src;
2957 GLuint i;
2958 GLfloat f[3];
2959 for (i = 0; i < n; i ++) {
2960 GLuint p = uisrc[i];
2961 SWAP4BYTE(p);
2962 rgb9e5_to_float3(p, f);
2963 rgba[i][rDst] = f[0];
2964 rgba[i][gDst] = f[1];
2965 rgba[i][bDst] = f[2];
2966 rgba[i][aDst] = 1.0F;
2967 }
2968 }
2969 else {
2970 const GLuint *uisrc = (const GLuint *) src;
2971 GLuint i;
2972 GLfloat f[3];
2973 for (i = 0; i < n; i ++) {
2974 rgb9e5_to_float3(uisrc[i], f);
2975 rgba[i][rDst] = f[0];
2976 rgba[i][gDst] = f[1];
2977 rgba[i][bDst] = f[2];
2978 rgba[i][aDst] = 1.0F;
2979 }
2980 }
2981 break;
2982 case GL_UNSIGNED_INT_10F_11F_11F_REV:
2983 if (swapBytes) {
2984 const GLuint *uisrc = (const GLuint *) src;
2985 GLuint i;
2986 GLfloat f[3];
2987 for (i = 0; i < n; i ++) {
2988 GLuint p = uisrc[i];
2989 SWAP4BYTE(p);
2990 r11g11b10f_to_float3(p, f);
2991 rgba[i][rDst] = f[0];
2992 rgba[i][gDst] = f[1];
2993 rgba[i][bDst] = f[2];
2994 rgba[i][aDst] = 1.0F;
2995 }
2996 }
2997 else {
2998 const GLuint *uisrc = (const GLuint *) src;
2999 GLuint i;
3000 GLfloat f[3];
3001 for (i = 0; i < n; i ++) {
3002 r11g11b10f_to_float3(uisrc[i], f);
3003 rgba[i][rDst] = f[0];
3004 rgba[i][gDst] = f[1];
3005 rgba[i][bDst] = f[2];
3006 rgba[i][aDst] = 1.0F;
3007 }
3008 }
3009 break;
3010 default:
3011 _mesa_problem(NULL, "bad srcType in extract float data");
3012 break;
3013 }
3014 #undef PROCESS
3015 }
3016
3017
3018 static inline GLuint
3019 clamp_float_to_uint(GLfloat f)
3020 {
3021 return f < 0.0F ? 0 : F_TO_I(f);
3022 }
3023
3024
3025 static inline GLuint
3026 clamp_half_to_uint(GLhalfARB h)
3027 {
3028 GLfloat f = _mesa_half_to_float(h);
3029 return f < 0.0F ? 0 : F_TO_I(f);
3030 }
3031
3032
3033 /**
3034 * \sa extract_float_rgba()
3035 */
3036 static void
3037 extract_uint_rgba(GLuint n, GLuint rgba[][4],
3038 GLenum srcFormat, GLenum srcType, const GLvoid *src,
3039 GLboolean swapBytes)
3040 {
3041 GLint rSrc, gSrc, bSrc, aSrc;
3042 GLint stride;
3043 GLint rDst, bDst, gDst, aDst;
3044
3045 ASSERT(srcFormat == GL_RED ||
3046 srcFormat == GL_GREEN ||
3047 srcFormat == GL_BLUE ||
3048 srcFormat == GL_ALPHA ||
3049 srcFormat == GL_LUMINANCE ||
3050 srcFormat == GL_LUMINANCE_ALPHA ||
3051 srcFormat == GL_INTENSITY ||
3052 srcFormat == GL_RG ||
3053 srcFormat == GL_RGB ||
3054 srcFormat == GL_BGR ||
3055 srcFormat == GL_RGBA ||
3056 srcFormat == GL_BGRA ||
3057 srcFormat == GL_ABGR_EXT ||
3058 srcFormat == GL_DU8DV8_ATI ||
3059 srcFormat == GL_DUDV_ATI ||
3060 srcFormat == GL_RED_INTEGER_EXT ||
3061 srcFormat == GL_RG_INTEGER ||
3062 srcFormat == GL_GREEN_INTEGER_EXT ||
3063 srcFormat == GL_BLUE_INTEGER_EXT ||
3064 srcFormat == GL_ALPHA_INTEGER_EXT ||
3065 srcFormat == GL_RGB_INTEGER_EXT ||
3066 srcFormat == GL_RGBA_INTEGER_EXT ||
3067 srcFormat == GL_BGR_INTEGER_EXT ||
3068 srcFormat == GL_BGRA_INTEGER_EXT ||
3069 srcFormat == GL_LUMINANCE_INTEGER_EXT ||
3070 srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);
3071
3072 ASSERT(srcType == GL_UNSIGNED_BYTE ||
3073 srcType == GL_BYTE ||
3074 srcType == GL_UNSIGNED_SHORT ||
3075 srcType == GL_SHORT ||
3076 srcType == GL_UNSIGNED_INT ||
3077 srcType == GL_INT ||
3078 srcType == GL_HALF_FLOAT_ARB ||
3079 srcType == GL_FLOAT ||
3080 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
3081 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
3082 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
3083 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
3084 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
3085 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
3086 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
3087 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
3088 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
3089 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
3090 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
3091 srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
3092 srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
3093 srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
3094
3095 get_component_mapping(srcFormat,
3096 &rSrc, &gSrc, &bSrc, &aSrc,
3097 &rDst, &gDst, &bDst, &aDst);
3098
3099 stride = _mesa_components_in_format(srcFormat);
3100
3101 #define PROCESS(SRC_INDEX, DST_INDEX, DEFAULT, TYPE, CONVERSION) \
3102 if ((SRC_INDEX) < 0) { \
3103 GLuint i; \
3104 for (i = 0; i < n; i++) { \
3105 rgba[i][DST_INDEX] = DEFAULT; \
3106 } \
3107 } \
3108 else if (swapBytes) { \
3109 const TYPE *s = (const TYPE *) src; \
3110 GLuint i; \
3111 for (i = 0; i < n; i++) { \
3112 TYPE value = s[SRC_INDEX]; \
3113 if (sizeof(TYPE) == 2) { \
3114 SWAP2BYTE(value); \
3115 } \
3116 else if (sizeof(TYPE) == 4) { \
3117 SWAP4BYTE(value); \
3118 } \
3119 rgba[i][DST_INDEX] = CONVERSION(value); \
3120 s += stride; \
3121 } \
3122 } \
3123 else { \
3124 const TYPE *s = (const TYPE *) src; \
3125 GLuint i; \
3126 for (i = 0; i < n; i++) { \
3127 rgba[i][DST_INDEX] = CONVERSION(s[SRC_INDEX]); \
3128 s += stride; \
3129 } \
3130 }
3131
3132 switch (srcType) {
3133 case GL_UNSIGNED_BYTE:
3134 PROCESS(rSrc, RCOMP, 0, GLubyte, (GLuint));
3135 PROCESS(gSrc, GCOMP, 0, GLubyte, (GLuint));
3136 PROCESS(bSrc, BCOMP, 0, GLubyte, (GLuint));
3137 PROCESS(aSrc, ACOMP, 1, GLubyte, (GLuint));
3138 break;
3139 case GL_BYTE:
3140 PROCESS(rSrc, RCOMP, 0, GLbyte, (GLuint));
3141 PROCESS(gSrc, GCOMP, 0, GLbyte, (GLuint));
3142 PROCESS(bSrc, BCOMP, 0, GLbyte, (GLuint));
3143 PROCESS(aSrc, ACOMP, 1, GLbyte, (GLuint));
3144 break;
3145 case GL_UNSIGNED_SHORT:
3146 PROCESS(rSrc, RCOMP, 0, GLushort, (GLuint));
3147 PROCESS(gSrc, GCOMP, 0, GLushort, (GLuint));
3148 PROCESS(bSrc, BCOMP, 0, GLushort, (GLuint));
3149 PROCESS(aSrc, ACOMP, 1, GLushort, (GLuint));
3150 break;
3151 case GL_SHORT:
3152 PROCESS(rSrc, RCOMP, 0, GLshort, (GLuint));
3153 PROCESS(gSrc, GCOMP, 0, GLshort, (GLuint));
3154 PROCESS(bSrc, BCOMP, 0, GLshort, (GLuint));
3155 PROCESS(aSrc, ACOMP, 1, GLshort, (GLuint));
3156 break;
3157 case GL_UNSIGNED_INT:
3158 PROCESS(rSrc, RCOMP, 0, GLuint, (GLuint));
3159 PROCESS(gSrc, GCOMP, 0, GLuint, (GLuint));
3160 PROCESS(bSrc, BCOMP, 0, GLuint, (GLuint));
3161 PROCESS(aSrc, ACOMP, 1, GLuint, (GLuint));
3162 break;
3163 case GL_INT:
3164 PROCESS(rSrc, RCOMP, 0, GLint, (GLuint));
3165 PROCESS(gSrc, GCOMP, 0, GLint, (GLuint));
3166 PROCESS(bSrc, BCOMP, 0, GLint, (GLuint));
3167 PROCESS(aSrc, ACOMP, 1, GLint, (GLuint));
3168 break;
3169 case GL_FLOAT:
3170 PROCESS(rSrc, RCOMP, 0, GLfloat, clamp_float_to_uint);
3171 PROCESS(gSrc, GCOMP, 0, GLfloat, clamp_float_to_uint);
3172 PROCESS(bSrc, BCOMP, 0, GLfloat, clamp_float_to_uint);
3173 PROCESS(aSrc, ACOMP, 1, GLfloat, clamp_float_to_uint);
3174 break;
3175 case GL_HALF_FLOAT_ARB:
3176 PROCESS(rSrc, RCOMP, 0, GLhalfARB, clamp_half_to_uint);
3177 PROCESS(gSrc, GCOMP, 0, GLhalfARB, clamp_half_to_uint);
3178 PROCESS(bSrc, BCOMP, 0, GLhalfARB, clamp_half_to_uint);
3179 PROCESS(aSrc, ACOMP, 1, GLhalfARB, clamp_half_to_uint);
3180 break;
3181 case GL_UNSIGNED_BYTE_3_3_2:
3182 {
3183 const GLubyte *ubsrc = (const GLubyte *) src;
3184 GLuint i;
3185 for (i = 0; i < n; i ++) {
3186 GLubyte p = ubsrc[i];
3187 rgba[i][rDst] = ((p >> 5) );
3188 rgba[i][gDst] = ((p >> 2) & 0x7);
3189 rgba[i][bDst] = ((p ) & 0x3);
3190 rgba[i][aDst] = 1;
3191 }
3192 }
3193 break;
3194 case GL_UNSIGNED_BYTE_2_3_3_REV:
3195 {
3196 const GLubyte *ubsrc = (const GLubyte *) src;
3197 GLuint i;
3198 for (i = 0; i < n; i ++) {
3199 GLubyte p = ubsrc[i];
3200 rgba[i][rDst] = ((p ) & 0x7);
3201 rgba[i][gDst] = ((p >> 3) & 0x7);
3202 rgba[i][bDst] = ((p >> 6) );
3203 rgba[i][aDst] = 1;
3204 }
3205 }
3206 break;
3207 case GL_UNSIGNED_SHORT_5_6_5:
3208 if (swapBytes) {
3209 const GLushort *ussrc = (const GLushort *) src;
3210 GLuint i;
3211 for (i = 0; i < n; i ++) {
3212 GLushort p = ussrc[i];
3213 SWAP2BYTE(p);
3214 rgba[i][rDst] = ((p >> 11) );
3215 rgba[i][gDst] = ((p >> 5) & 0x3f);
3216 rgba[i][bDst] = ((p ) & 0x1f);
3217 rgba[i][aDst] = 1;
3218 }
3219 }
3220 else {
3221 const GLushort *ussrc = (const GLushort *) src;
3222 GLuint i;
3223 for (i = 0; i < n; i ++) {
3224 GLushort p = ussrc[i];
3225 rgba[i][rDst] = ((p >> 11) );
3226 rgba[i][gDst] = ((p >> 5) & 0x3f);
3227 rgba[i][bDst] = ((p ) & 0x1f);
3228 rgba[i][aDst] = 1;
3229 }
3230 }
3231 break;
3232 case GL_UNSIGNED_SHORT_5_6_5_REV:
3233 if (swapBytes) {
3234 const GLushort *ussrc = (const GLushort *) src;
3235 GLuint i;
3236 for (i = 0; i < n; i ++) {
3237 GLushort p = ussrc[i];
3238 SWAP2BYTE(p);
3239 rgba[i][rDst] = ((p ) & 0x1f);
3240 rgba[i][gDst] = ((p >> 5) & 0x3f);
3241 rgba[i][bDst] = ((p >> 11) );
3242 rgba[i][aDst] = 1;
3243 }
3244 }
3245 else {
3246 const GLushort *ussrc = (const GLushort *) src;
3247 GLuint i;
3248 for (i = 0; i < n; i ++) {
3249 GLushort p = ussrc[i];
3250 rgba[i][rDst] = ((p ) & 0x1f);
3251 rgba[i][gDst] = ((p >> 5) & 0x3f);
3252 rgba[i][bDst] = ((p >> 11) );
3253 rgba[i][aDst] = 1;
3254 }
3255 }
3256 break;
3257 case GL_UNSIGNED_SHORT_4_4_4_4:
3258 if (swapBytes) {
3259 const GLushort *ussrc = (const GLushort *) src;
3260 GLuint i;
3261 for (i = 0; i < n; i ++) {
3262 GLushort p = ussrc[i];
3263 SWAP2BYTE(p);
3264 rgba[i][rDst] = ((p >> 12) );
3265 rgba[i][gDst] = ((p >> 8) & 0xf);
3266 rgba[i][bDst] = ((p >> 4) & 0xf);
3267 rgba[i][aDst] = ((p ) & 0xf);
3268 }
3269 }
3270 else {
3271 const GLushort *ussrc = (const GLushort *) src;
3272 GLuint i;
3273 for (i = 0; i < n; i ++) {
3274 GLushort p = ussrc[i];
3275 rgba[i][rDst] = ((p >> 12) );
3276 rgba[i][gDst] = ((p >> 8) & 0xf);
3277 rgba[i][bDst] = ((p >> 4) & 0xf);
3278 rgba[i][aDst] = ((p ) & 0xf);
3279 }
3280 }
3281 break;
3282 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
3283 if (swapBytes) {
3284 const GLushort *ussrc = (const GLushort *) src;
3285 GLuint i;
3286 for (i = 0; i < n; i ++) {
3287 GLushort p = ussrc[i];
3288 SWAP2BYTE(p);
3289 rgba[i][rDst] = ((p ) & 0xf);
3290 rgba[i][gDst] = ((p >> 4) & 0xf);
3291 rgba[i][bDst] = ((p >> 8) & 0xf);
3292 rgba[i][aDst] = ((p >> 12) );
3293 }
3294 }
3295 else {
3296 const GLushort *ussrc = (const GLushort *) src;
3297 GLuint i;
3298 for (i = 0; i < n; i ++) {
3299 GLushort p = ussrc[i];
3300 rgba[i][rDst] = ((p ) & 0xf);
3301 rgba[i][gDst] = ((p >> 4) & 0xf);
3302 rgba[i][bDst] = ((p >> 8) & 0xf);
3303 rgba[i][aDst] = ((p >> 12) );
3304 }
3305 }
3306 break;
3307 case GL_UNSIGNED_SHORT_5_5_5_1:
3308 if (swapBytes) {
3309 const GLushort *ussrc = (const GLushort *) src;
3310 GLuint i;
3311 for (i = 0; i < n; i ++) {
3312 GLushort p = ussrc[i];
3313 SWAP2BYTE(p);
3314 rgba[i][rDst] = ((p >> 11) );
3315 rgba[i][gDst] = ((p >> 6) & 0x1f);
3316 rgba[i][bDst] = ((p >> 1) & 0x1f);
3317 rgba[i][aDst] = ((p ) & 0x1 );
3318 }
3319 }
3320 else {
3321 const GLushort *ussrc = (const GLushort *) src;
3322 GLuint i;
3323 for (i = 0; i < n; i ++) {
3324 GLushort p = ussrc[i];
3325 rgba[i][rDst] = ((p >> 11) );
3326 rgba[i][gDst] = ((p >> 6) & 0x1f);
3327 rgba[i][bDst] = ((p >> 1) & 0x1f);
3328 rgba[i][aDst] = ((p ) & 0x1 );
3329 }
3330 }
3331 break;
3332 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
3333 if (swapBytes) {
3334 const GLushort *ussrc = (const GLushort *) src;
3335 GLuint i;
3336 for (i = 0; i < n; i ++) {
3337 GLushort p = ussrc[i];
3338 SWAP2BYTE(p);
3339 rgba[i][rDst] = ((p ) & 0x1f);
3340 rgba[i][gDst] = ((p >> 5) & 0x1f);
3341 rgba[i][bDst] = ((p >> 10) & 0x1f);
3342 rgba[i][aDst] = ((p >> 15) );
3343 }
3344 }
3345 else {
3346 const GLushort *ussrc = (const GLushort *) src;
3347 GLuint i;
3348 for (i = 0; i < n; i ++) {
3349 GLushort p = ussrc[i];
3350 rgba[i][rDst] = ((p ) & 0x1f);
3351 rgba[i][gDst] = ((p >> 5) & 0x1f);
3352 rgba[i][bDst] = ((p >> 10) & 0x1f);
3353 rgba[i][aDst] = ((p >> 15) );
3354 }
3355 }
3356 break;
3357 case GL_UNSIGNED_INT_8_8_8_8:
3358 if (swapBytes) {
3359 const GLuint *uisrc = (const GLuint *) src;
3360 GLuint i;
3361 for (i = 0; i < n; i ++) {
3362 GLuint p = uisrc[i];
3363 rgba[i][rDst] = ((p ) & 0xff);
3364 rgba[i][gDst] = ((p >> 8) & 0xff);
3365 rgba[i][bDst] = ((p >> 16) & 0xff);
3366 rgba[i][aDst] = ((p >> 24) );
3367 }
3368 }
3369 else {
3370 const GLuint *uisrc = (const GLuint *) src;
3371 GLuint i;
3372 for (i = 0; i < n; i ++) {
3373 GLuint p = uisrc[i];
3374 rgba[i][rDst] = ((p >> 24) );
3375 rgba[i][gDst] = ((p >> 16) & 0xff);
3376 rgba[i][bDst] = ((p >> 8) & 0xff);
3377 rgba[i][aDst] = ((p ) & 0xff);
3378 }
3379 }
3380 break;
3381 case GL_UNSIGNED_INT_8_8_8_8_REV:
3382 if (swapBytes) {
3383 const GLuint *uisrc = (const GLuint *) src;
3384 GLuint i;
3385 for (i = 0; i < n; i ++) {
3386 GLuint p = uisrc[i];
3387 rgba[i][rDst] = ((p >> 24) );
3388 rgba[i][gDst] = ((p >> 16) & 0xff);
3389 rgba[i][bDst] = ((p >> 8) & 0xff);
3390 rgba[i][aDst] = ((p ) & 0xff);
3391 }
3392 }
3393 else {
3394 const GLuint *uisrc = (const GLuint *) src;
3395 GLuint i;
3396 for (i = 0; i < n; i ++) {
3397 GLuint p = uisrc[i];
3398 rgba[i][rDst] = ((p ) & 0xff);
3399 rgba[i][gDst] = ((p >> 8) & 0xff);
3400 rgba[i][bDst] = ((p >> 16) & 0xff);
3401 rgba[i][aDst] = ((p >> 24) );
3402 }
3403 }
3404 break;
3405 case GL_UNSIGNED_INT_10_10_10_2:
3406 if (swapBytes) {
3407 const GLuint *uisrc = (const GLuint *) src;
3408 GLuint i;
3409 for (i = 0; i < n; i ++) {
3410 GLuint p = uisrc[i];
3411 SWAP4BYTE(p);
3412 rgba[i][rDst] = ((p >> 22) );
3413 rgba[i][gDst] = ((p >> 12) & 0x3ff);
3414 rgba[i][bDst] = ((p >> 2) & 0x3ff);
3415 rgba[i][aDst] = ((p ) & 0x3 );
3416 }
3417 }
3418 else {
3419 const GLuint *uisrc = (const GLuint *) src;
3420 GLuint i;
3421 for (i = 0; i < n; i ++) {
3422 GLuint p = uisrc[i];
3423 rgba[i][rDst] = ((p >> 22) );
3424 rgba[i][gDst] = ((p >> 12) & 0x3ff);
3425 rgba[i][bDst] = ((p >> 2) & 0x3ff);
3426 rgba[i][aDst] = ((p ) & 0x3 );
3427 }
3428 }
3429 break;
3430 case GL_UNSIGNED_INT_2_10_10_10_REV:
3431 if (swapBytes) {
3432 const GLuint *uisrc = (const GLuint *) src;
3433 GLuint i;
3434 for (i = 0; i < n; i ++) {
3435 GLuint p = uisrc[i];
3436 SWAP4BYTE(p);
3437 rgba[i][rDst] = ((p ) & 0x3ff);
3438 rgba[i][gDst] = ((p >> 10) & 0x3ff);
3439 rgba[i][bDst] = ((p >> 20) & 0x3ff);
3440 rgba[i][aDst] = ((p >> 30) );
3441 }
3442 }
3443 else {
3444 const GLuint *uisrc = (const GLuint *) src;
3445 GLuint i;
3446 for (i = 0; i < n; i ++) {
3447 GLuint p = uisrc[i];
3448 rgba[i][rDst] = ((p ) & 0x3ff);
3449 rgba[i][gDst] = ((p >> 10) & 0x3ff);
3450 rgba[i][bDst] = ((p >> 20) & 0x3ff);
3451 rgba[i][aDst] = ((p >> 30) );
3452 }
3453 }
3454 break;
3455 case GL_UNSIGNED_INT_5_9_9_9_REV:
3456 if (swapBytes) {
3457 const GLuint *uisrc = (const GLuint *) src;
3458 GLuint i;
3459 float f[3];
3460 for (i = 0; i < n; i ++) {
3461 GLuint p = uisrc[i];
3462 SWAP4BYTE(p);
3463 rgb9e5_to_float3(p, f);
3464 rgba[i][rDst] = clamp_float_to_uint(f[0]);
3465 rgba[i][gDst] = clamp_float_to_uint(f[1]);
3466 rgba[i][bDst] = clamp_float_to_uint(f[2]);
3467 rgba[i][aDst] = 1;
3468 }
3469 }
3470 else {
3471 const GLuint *uisrc = (const GLuint *) src;
3472 GLuint i;
3473 float f[3];
3474 for (i = 0; i < n; i ++) {
3475 GLuint p = uisrc[i];
3476 rgb9e5_to_float3(p, f);
3477 rgba[i][rDst] = clamp_float_to_uint(f[0]);
3478 rgba[i][gDst] = clamp_float_to_uint(f[1]);
3479 rgba[i][bDst] = clamp_float_to_uint(f[2]);
3480 rgba[i][aDst] = 1;
3481 }
3482 }
3483 break;
3484 case GL_UNSIGNED_INT_10F_11F_11F_REV:
3485 if (swapBytes) {
3486 const GLuint *uisrc = (const GLuint *) src;
3487 GLuint i;
3488 float f[3];
3489 for (i = 0; i < n; i ++) {
3490 GLuint p = uisrc[i];
3491 SWAP4BYTE(p);
3492 r11g11b10f_to_float3(p, f);
3493 rgba[i][rDst] = clamp_float_to_uint(f[0]);
3494 rgba[i][gDst] = clamp_float_to_uint(f[1]);
3495 rgba[i][bDst] = clamp_float_to_uint(f[2]);
3496 rgba[i][aDst] = 1;
3497 }
3498 }
3499 else {
3500 const GLuint *uisrc = (const GLuint *) src;
3501 GLuint i;
3502 float f[3];
3503 for (i = 0; i < n; i ++) {
3504 GLuint p = uisrc[i];
3505 r11g11b10f_to_float3(p, f);
3506 rgba[i][rDst] = clamp_float_to_uint(f[0]);
3507 rgba[i][gDst] = clamp_float_to_uint(f[1]);
3508 rgba[i][bDst] = clamp_float_to_uint(f[2]);
3509 rgba[i][aDst] = 1;
3510 }
3511 }
3512 break;
3513 default:
3514 _mesa_problem(NULL, "bad srcType in extract uint data");
3515 break;
3516 }
3517 #undef PROCESS
3518 }
3519
3520
3521
3522 /*
3523 * Unpack a row of color image data from a client buffer according to
3524 * the pixel unpacking parameters.
3525 * Return GLubyte values in the specified dest image format.
3526 * This is used by glDrawPixels and glTexImage?D().
3527 * \param ctx - the context
3528 * n - number of pixels in the span
3529 * dstFormat - format of destination color array
3530 * dest - the destination color array
3531 * srcFormat - source image format
3532 * srcType - source image data type
3533 * source - source image pointer
3534 * srcPacking - pixel unpacking parameters
3535 * transferOps - bitmask of IMAGE_*_BIT values of operations to apply
3536 *
3537 * XXX perhaps expand this to process whole images someday.
3538 */
3539 void
3540 _mesa_unpack_color_span_ubyte(struct gl_context *ctx,
3541 GLuint n, GLenum dstFormat, GLubyte dest[],
3542 GLenum srcFormat, GLenum srcType,
3543 const GLvoid *source,
3544 const struct gl_pixelstore_attrib *srcPacking,
3545 GLbitfield transferOps )
3546 {
3547 GLboolean intFormat = _mesa_is_integer_format(srcFormat);
3548 ASSERT(dstFormat == GL_ALPHA ||
3549 dstFormat == GL_LUMINANCE ||
3550 dstFormat == GL_LUMINANCE_ALPHA ||
3551 dstFormat == GL_INTENSITY ||
3552 dstFormat == GL_RED ||
3553 dstFormat == GL_RG ||
3554 dstFormat == GL_RGB ||
3555 dstFormat == GL_RGBA);
3556
3557 ASSERT(srcFormat == GL_RED ||
3558 srcFormat == GL_GREEN ||
3559 srcFormat == GL_BLUE ||
3560 srcFormat == GL_ALPHA ||
3561 srcFormat == GL_LUMINANCE ||
3562 srcFormat == GL_LUMINANCE_ALPHA ||
3563 srcFormat == GL_INTENSITY ||
3564 srcFormat == GL_RG ||
3565 srcFormat == GL_RGB ||
3566 srcFormat == GL_BGR ||
3567 srcFormat == GL_RGBA ||
3568 srcFormat == GL_BGRA ||
3569 srcFormat == GL_ABGR_EXT ||
3570 srcFormat == GL_COLOR_INDEX);
3571
3572 ASSERT(srcType == GL_BITMAP ||
3573 srcType == GL_UNSIGNED_BYTE ||
3574 srcType == GL_BYTE ||
3575 srcType == GL_UNSIGNED_SHORT ||
3576 srcType == GL_SHORT ||
3577 srcType == GL_UNSIGNED_INT ||
3578 srcType == GL_INT ||
3579 srcType == GL_HALF_FLOAT_ARB ||
3580 srcType == GL_FLOAT ||
3581 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
3582 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
3583 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
3584 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
3585 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
3586 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
3587 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
3588 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
3589 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
3590 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
3591 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
3592 srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
3593 srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
3594 srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
3595
3596 /* EXT_texture_integer specifies no transfer ops on integer
3597 * types in the resolved issues section. Just set them to 0
3598 * for integer surfaces.
3599 */
3600 if (intFormat)
3601 transferOps = 0;
3602
3603 /* Try simple cases first */
3604 if (transferOps == 0) {
3605 if (srcType == GL_UNSIGNED_BYTE) {
3606 if (dstFormat == GL_RGBA) {
3607 if (srcFormat == GL_RGBA) {
3608 memcpy( dest, source, n * 4 * sizeof(GLubyte) );
3609 return;
3610 }
3611 else if (srcFormat == GL_RGB) {
3612 GLuint i;
3613 const GLubyte *src = (const GLubyte *) source;
3614 GLubyte *dst = dest;
3615 for (i = 0; i < n; i++) {
3616 dst[0] = src[0];
3617 dst[1] = src[1];
3618 dst[2] = src[2];
3619 dst[3] = 255;
3620 src += 3;
3621 dst += 4;
3622 }
3623 return;
3624 }
3625 }
3626 else if (dstFormat == GL_RGB) {
3627 if (srcFormat == GL_RGB) {
3628 memcpy( dest, source, n * 3 * sizeof(GLubyte) );
3629 return;
3630 }
3631 else if (srcFormat == GL_RGBA) {
3632 GLuint i;
3633 const GLubyte *src = (const GLubyte *) source;
3634 GLubyte *dst = dest;
3635 for (i = 0; i < n; i++) {
3636 dst[0] = src[0];
3637 dst[1] = src[1];
3638 dst[2] = src[2];
3639 src += 4;
3640 dst += 3;
3641 }
3642 return;
3643 }
3644 }
3645 else if (dstFormat == srcFormat) {
3646 GLint comps = _mesa_components_in_format(srcFormat);
3647 assert(comps > 0);
3648 memcpy( dest, source, n * comps * sizeof(GLubyte) );
3649 return;
3650 }
3651 }
3652 }
3653
3654
3655 /* general solution begins here */
3656 {
3657 GLint dstComponents;
3658 GLint rDst, gDst, bDst, aDst, lDst, iDst;
3659 GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));
3660
3661 if (!rgba) {
3662 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3663 return;
3664 }
3665
3666 dstComponents = _mesa_components_in_format( dstFormat );
3667 /* source & dest image formats should have been error checked by now */
3668 assert(dstComponents > 0);
3669
3670 /*
3671 * Extract image data and convert to RGBA floats
3672 */
3673 if (srcFormat == GL_COLOR_INDEX) {
3674 GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
3675
3676 if (!indexes) {
3677 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3678 free(rgba);
3679 return;
3680 }
3681
3682 extract_uint_indexes(n, indexes, srcFormat, srcType, source,
3683 srcPacking);
3684
3685 /* Convert indexes to RGBA */
3686 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
3687 _mesa_shift_and_offset_ci(ctx, n, indexes);
3688 }
3689 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
3690
3691 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
3692 * with color indexes.
3693 */
3694 transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT);
3695
3696 free(indexes);
3697 }
3698 else {
3699 /* non-color index data */
3700 extract_float_rgba(n, rgba, srcFormat, srcType, source,
3701 srcPacking->SwapBytes);
3702 }
3703
3704 /* Need to clamp if returning GLubytes */
3705 transferOps |= IMAGE_CLAMP_BIT;
3706
3707 if (transferOps) {
3708 _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
3709 }
3710
3711 get_component_indexes(dstFormat,
3712 &rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
3713
3714 /* Now return the GLubyte data in the requested dstFormat */
3715 if (rDst >= 0) {
3716 GLubyte *dst = dest;
3717 GLuint i;
3718 for (i = 0; i < n; i++) {
3719 CLAMPED_FLOAT_TO_UBYTE(dst[rDst], rgba[i][RCOMP]);
3720 dst += dstComponents;
3721 }
3722 }
3723
3724 if (gDst >= 0) {
3725 GLubyte *dst = dest;
3726 GLuint i;
3727 for (i = 0; i < n; i++) {
3728 CLAMPED_FLOAT_TO_UBYTE(dst[gDst], rgba[i][GCOMP]);
3729 dst += dstComponents;
3730 }
3731 }
3732
3733 if (bDst >= 0) {
3734 GLubyte *dst = dest;
3735 GLuint i;
3736 for (i = 0; i < n; i++) {
3737 CLAMPED_FLOAT_TO_UBYTE(dst[bDst], rgba[i][BCOMP]);
3738 dst += dstComponents;
3739 }
3740 }
3741
3742 if (aDst >= 0) {
3743 GLubyte *dst = dest;
3744 GLuint i;
3745 for (i = 0; i < n; i++) {
3746 CLAMPED_FLOAT_TO_UBYTE(dst[aDst], rgba[i][ACOMP]);
3747 dst += dstComponents;
3748 }
3749 }
3750
3751 if (iDst >= 0) {
3752 GLubyte *dst = dest;
3753 GLuint i;
3754 assert(iDst == 0);
3755 assert(dstComponents == 1);
3756 for (i = 0; i < n; i++) {
3757 /* Intensity comes from red channel */
3758 CLAMPED_FLOAT_TO_UBYTE(dst[i], rgba[i][RCOMP]);
3759 }
3760 }
3761
3762 if (lDst >= 0) {
3763 GLubyte *dst = dest;
3764 GLuint i;
3765 assert(lDst == 0);
3766 for (i = 0; i < n; i++) {
3767 /* Luminance comes from red channel */
3768 CLAMPED_FLOAT_TO_UBYTE(dst[0], rgba[i][RCOMP]);
3769 dst += dstComponents;
3770 }
3771 }
3772
3773 free(rgba);
3774 }
3775 }
3776
3777
3778 /**
3779 * Same as _mesa_unpack_color_span_ubyte(), but return GLfloat data
3780 * instead of GLubyte.
3781 */
3782 void
3783 _mesa_unpack_color_span_float( struct gl_context *ctx,
3784 GLuint n, GLenum dstFormat, GLfloat dest[],
3785 GLenum srcFormat, GLenum srcType,
3786 const GLvoid *source,
3787 const struct gl_pixelstore_attrib *srcPacking,
3788 GLbitfield transferOps )
3789 {
3790 ASSERT(dstFormat == GL_ALPHA ||
3791 dstFormat == GL_LUMINANCE ||
3792 dstFormat == GL_LUMINANCE_ALPHA ||
3793 dstFormat == GL_INTENSITY ||
3794 dstFormat == GL_RED ||
3795 dstFormat == GL_RG ||
3796 dstFormat == GL_RGB ||
3797 dstFormat == GL_RGBA);
3798
3799 ASSERT(srcFormat == GL_RED ||
3800 srcFormat == GL_GREEN ||
3801 srcFormat == GL_BLUE ||
3802 srcFormat == GL_ALPHA ||
3803 srcFormat == GL_LUMINANCE ||
3804 srcFormat == GL_LUMINANCE_ALPHA ||
3805 srcFormat == GL_INTENSITY ||
3806 srcFormat == GL_RG ||
3807 srcFormat == GL_RGB ||
3808 srcFormat == GL_BGR ||
3809 srcFormat == GL_RGBA ||
3810 srcFormat == GL_BGRA ||
3811 srcFormat == GL_ABGR_EXT ||
3812 srcFormat == GL_RED_INTEGER_EXT ||
3813 srcFormat == GL_GREEN_INTEGER_EXT ||
3814 srcFormat == GL_BLUE_INTEGER_EXT ||
3815 srcFormat == GL_ALPHA_INTEGER_EXT ||
3816 srcFormat == GL_RG_INTEGER ||
3817 srcFormat == GL_RGB_INTEGER_EXT ||
3818 srcFormat == GL_RGBA_INTEGER_EXT ||
3819 srcFormat == GL_BGR_INTEGER_EXT ||
3820 srcFormat == GL_BGRA_INTEGER_EXT ||
3821 srcFormat == GL_LUMINANCE_INTEGER_EXT ||
3822 srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT ||
3823 srcFormat == GL_COLOR_INDEX);
3824
3825 ASSERT(srcType == GL_BITMAP ||
3826 srcType == GL_UNSIGNED_BYTE ||
3827 srcType == GL_BYTE ||
3828 srcType == GL_UNSIGNED_SHORT ||
3829 srcType == GL_SHORT ||
3830 srcType == GL_UNSIGNED_INT ||
3831 srcType == GL_INT ||
3832 srcType == GL_HALF_FLOAT_ARB ||
3833 srcType == GL_FLOAT ||
3834 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
3835 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
3836 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
3837 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
3838 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
3839 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
3840 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
3841 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
3842 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
3843 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
3844 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
3845 srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
3846 srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
3847 srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
3848
3849 /* general solution, no special cases, yet */
3850 {
3851 GLint dstComponents;
3852 GLint rDst, gDst, bDst, aDst, lDst, iDst;
3853 GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));
3854 GLboolean intFormat = _mesa_is_integer_format(srcFormat);
3855
3856 if (!rgba) {
3857 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3858 return;
3859 }
3860
3861 dstComponents = _mesa_components_in_format( dstFormat );
3862 /* source & dest image formats should have been error checked by now */
3863 assert(dstComponents > 0);
3864
3865 /* EXT_texture_integer specifies no transfer ops on integer
3866 * types in the resolved issues section. Just set them to 0
3867 * for integer surfaces.
3868 */
3869 if (intFormat)
3870 transferOps = 0;
3871
3872 /*
3873 * Extract image data and convert to RGBA floats
3874 */
3875 if (srcFormat == GL_COLOR_INDEX) {
3876 GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
3877
3878 if (!indexes) {
3879 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3880 free(rgba);
3881 return;
3882 }
3883
3884 extract_uint_indexes(n, indexes, srcFormat, srcType, source,
3885 srcPacking);
3886
3887 /* Convert indexes to RGBA */
3888 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
3889 _mesa_shift_and_offset_ci(ctx, n, indexes);
3890 }
3891 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
3892
3893 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
3894 * with color indexes.
3895 */
3896 transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT);
3897
3898 free(indexes);
3899 }
3900 else {
3901 /* non-color index data */
3902 extract_float_rgba(n, rgba, srcFormat, srcType, source,
3903 srcPacking->SwapBytes);
3904 }
3905
3906 if (transferOps) {
3907 _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
3908 }
3909
3910 get_component_indexes(dstFormat,
3911 &rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
3912
3913 /* Now pack results in the requested dstFormat */
3914 if (rDst >= 0) {
3915 GLfloat *dst = dest;
3916 GLuint i;
3917 for (i = 0; i < n; i++) {
3918 dst[rDst] = rgba[i][RCOMP];
3919 dst += dstComponents;
3920 }
3921 }
3922
3923 if (gDst >= 0) {
3924 GLfloat *dst = dest;
3925 GLuint i;
3926 for (i = 0; i < n; i++) {
3927 dst[gDst] = rgba[i][GCOMP];
3928 dst += dstComponents;
3929 }
3930 }
3931
3932 if (bDst >= 0) {
3933 GLfloat *dst = dest;
3934 GLuint i;
3935 for (i = 0; i < n; i++) {
3936 dst[bDst] = rgba[i][BCOMP];
3937 dst += dstComponents;
3938 }
3939 }
3940
3941 if (aDst >= 0) {
3942 GLfloat *dst = dest;
3943 GLuint i;
3944 for (i = 0; i < n; i++) {
3945 dst[aDst] = rgba[i][ACOMP];
3946 dst += dstComponents;
3947 }
3948 }
3949
3950 if (iDst >= 0) {
3951 GLfloat *dst = dest;
3952 GLuint i;
3953 assert(iDst == 0);
3954 assert(dstComponents == 1);
3955 for (i = 0; i < n; i++) {
3956 /* Intensity comes from red channel */
3957 dst[i] = rgba[i][RCOMP];
3958 }
3959 }
3960
3961 if (lDst >= 0) {
3962 GLfloat *dst = dest;
3963 GLuint i;
3964 assert(lDst == 0);
3965 for (i = 0; i < n; i++) {
3966 /* Luminance comes from red channel */
3967 dst[0] = rgba[i][RCOMP];
3968 dst += dstComponents;
3969 }
3970 }
3971
3972 free(rgba);
3973 }
3974 }
3975
3976
3977 /**
3978 * Same as _mesa_unpack_color_span_ubyte(), but return GLuint data
3979 * instead of GLubyte.
3980 * No pixel transfer ops are applied.
3981 */
3982 void
3983 _mesa_unpack_color_span_uint(struct gl_context *ctx,
3984 GLuint n, GLenum dstFormat, GLuint *dest,
3985 GLenum srcFormat, GLenum srcType,
3986 const GLvoid *source,
3987 const struct gl_pixelstore_attrib *srcPacking)
3988 {
3989 GLuint (*rgba)[4] = (GLuint (*)[4]) malloc(n * 4 * sizeof(GLfloat));
3990
3991 if (!rgba) {
3992 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3993 return;
3994 }
3995
3996 ASSERT(dstFormat == GL_ALPHA ||
3997 dstFormat == GL_LUMINANCE ||
3998 dstFormat == GL_LUMINANCE_ALPHA ||
3999 dstFormat == GL_INTENSITY ||
4000 dstFormat == GL_RED ||
4001 dstFormat == GL_RG ||
4002 dstFormat == GL_RGB ||
4003 dstFormat == GL_RGBA);
4004
4005 ASSERT(srcFormat == GL_RED ||
4006 srcFormat == GL_GREEN ||
4007 srcFormat == GL_BLUE ||
4008 srcFormat == GL_ALPHA ||
4009 srcFormat == GL_LUMINANCE ||
4010 srcFormat == GL_LUMINANCE_ALPHA ||
4011 srcFormat == GL_INTENSITY ||
4012 srcFormat == GL_RG ||
4013 srcFormat == GL_RGB ||
4014 srcFormat == GL_BGR ||
4015 srcFormat == GL_RGBA ||
4016 srcFormat == GL_BGRA ||
4017 srcFormat == GL_ABGR_EXT ||
4018 srcFormat == GL_RED_INTEGER_EXT ||
4019 srcFormat == GL_GREEN_INTEGER_EXT ||
4020 srcFormat == GL_BLUE_INTEGER_EXT ||
4021 srcFormat == GL_ALPHA_INTEGER_EXT ||
4022 srcFormat == GL_RG_INTEGER ||
4023 srcFormat == GL_RGB_INTEGER_EXT ||
4024 srcFormat == GL_RGBA_INTEGER_EXT ||
4025 srcFormat == GL_BGR_INTEGER_EXT ||
4026 srcFormat == GL_BGRA_INTEGER_EXT ||
4027 srcFormat == GL_LUMINANCE_INTEGER_EXT ||
4028 srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);
4029
4030 ASSERT(srcType == GL_UNSIGNED_BYTE ||
4031 srcType == GL_BYTE ||
4032 srcType == GL_UNSIGNED_SHORT ||
4033 srcType == GL_SHORT ||
4034 srcType == GL_UNSIGNED_INT ||
4035 srcType == GL_INT ||
4036 srcType == GL_HALF_FLOAT_ARB ||
4037 srcType == GL_FLOAT ||
4038 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
4039 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
4040 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
4041 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
4042 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
4043 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
4044 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
4045 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
4046 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
4047 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
4048 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
4049 srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
4050 srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
4051 srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
4052
4053
4054 /* Extract image data as uint[4] pixels */
4055 extract_uint_rgba(n, rgba, srcFormat, srcType, source,
4056 srcPacking->SwapBytes);
4057
4058 if (dstFormat == GL_RGBA) {
4059 /* simple case */
4060 memcpy(dest, rgba, 4 * sizeof(GLuint) * n);
4061 }
4062 else {
4063 /* general case */
4064 GLint rDst, gDst, bDst, aDst, lDst, iDst;
4065 GLint dstComponents = _mesa_components_in_format( dstFormat );
4066
4067 assert(dstComponents > 0);
4068
4069 get_component_indexes(dstFormat,
4070 &rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
4071
4072 /* Now pack values in the requested dest format */
4073 if (rDst >= 0) {
4074 GLuint *dst = dest;
4075 GLuint i;
4076 for (i = 0; i < n; i++) {
4077 dst[rDst] = rgba[i][RCOMP];
4078 dst += dstComponents;
4079 }
4080 }
4081
4082 if (gDst >= 0) {
4083 GLuint *dst = dest;
4084 GLuint i;
4085 for (i = 0; i < n; i++) {
4086 dst[gDst] = rgba[i][GCOMP];
4087 dst += dstComponents;
4088 }
4089 }
4090
4091 if (bDst >= 0) {
4092 GLuint *dst = dest;
4093 GLuint i;
4094 for (i = 0; i < n; i++) {
4095 dst[bDst] = rgba[i][BCOMP];
4096 dst += dstComponents;
4097 }
4098 }
4099
4100 if (aDst >= 0) {
4101 GLuint *dst = dest;
4102 GLuint i;
4103 for (i = 0; i < n; i++) {
4104 dst[aDst] = rgba[i][ACOMP];
4105 dst += dstComponents;
4106 }
4107 }
4108
4109 if (iDst >= 0) {
4110 GLuint *dst = dest;
4111 GLuint i;
4112 assert(iDst == 0);
4113 assert(dstComponents == 1);
4114 for (i = 0; i < n; i++) {
4115 /* Intensity comes from red channel */
4116 dst[i] = rgba[i][RCOMP];
4117 }
4118 }
4119
4120 if (lDst >= 0) {
4121 GLuint *dst = dest;
4122 GLuint i;
4123 assert(lDst == 0);
4124 for (i = 0; i < n; i++) {
4125 /* Luminance comes from red channel */
4126 dst[0] = rgba[i][RCOMP];
4127 dst += dstComponents;
4128 }
4129 }
4130 }
4131
4132 free(rgba);
4133 }
4134
4135
4136
4137 /**
4138 * Similar to _mesa_unpack_color_span_float(), but for dudv data instead of rgba,
4139 * directly return GLbyte data, no transfer ops apply.
4140 */
4141 void
4142 _mesa_unpack_dudv_span_byte( struct gl_context *ctx,
4143 GLuint n, GLenum dstFormat, GLbyte dest[],
4144 GLenum srcFormat, GLenum srcType,
4145 const GLvoid *source,
4146 const struct gl_pixelstore_attrib *srcPacking,
4147 GLbitfield transferOps )
4148 {
4149 ASSERT(dstFormat == GL_DUDV_ATI);
4150 ASSERT(srcFormat == GL_DUDV_ATI ||
4151 srcFormat == GL_DU8DV8_ATI);
4152
4153 ASSERT(srcType == GL_UNSIGNED_BYTE ||
4154 srcType == GL_BYTE ||
4155 srcType == GL_UNSIGNED_SHORT ||
4156 srcType == GL_SHORT ||
4157 srcType == GL_UNSIGNED_INT ||
4158 srcType == GL_INT ||
4159 srcType == GL_HALF_FLOAT_ARB ||
4160 srcType == GL_FLOAT);
4161
4162 /* general solution */
4163 {
4164 GLint dstComponents;
4165 GLbyte *dst = dest;
4166 GLuint i;
4167 GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));
4168
4169 if (!rgba) {
4170 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
4171 return;
4172 }
4173
4174 dstComponents = _mesa_components_in_format( dstFormat );
4175 /* source & dest image formats should have been error checked by now */
4176 assert(dstComponents > 0);
4177
4178 /*
4179 * Extract image data and convert to RGBA floats
4180 */
4181 extract_float_rgba(n, rgba, srcFormat, srcType, source,
4182 srcPacking->SwapBytes);
4183
4184
4185 /* Now determine which color channels we need to produce.
4186 * And determine the dest index (offset) within each color tuple.
4187 */
4188
4189 /* Now pack results in the requested dstFormat */
4190 for (i = 0; i < n; i++) {
4191 /* not sure - need clamp[-1,1] here? */
4192 dst[0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
4193 dst[1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
4194 dst += dstComponents;
4195 }
4196
4197 free(rgba);
4198 }
4199 }
4200
4201 /*
4202 * Unpack a row of color index data from a client buffer according to
4203 * the pixel unpacking parameters.
4204 * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.
4205 *
4206 * Args: ctx - the context
4207 * n - number of pixels
4208 * dstType - destination data type
4209 * dest - destination array
4210 * srcType - source pixel type
4211 * source - source data pointer
4212 * srcPacking - pixel unpacking parameters
4213 * transferOps - the pixel transfer operations to apply
4214 */
4215 void
4216 _mesa_unpack_index_span( struct gl_context *ctx, GLuint n,
4217 GLenum dstType, GLvoid *dest,
4218 GLenum srcType, const GLvoid *source,
4219 const struct gl_pixelstore_attrib *srcPacking,
4220 GLbitfield transferOps )
4221 {
4222 ASSERT(srcType == GL_BITMAP ||
4223 srcType == GL_UNSIGNED_BYTE ||
4224 srcType == GL_BYTE ||
4225 srcType == GL_UNSIGNED_SHORT ||
4226 srcType == GL_SHORT ||
4227 srcType == GL_UNSIGNED_INT ||
4228 srcType == GL_INT ||
4229 srcType == GL_HALF_FLOAT_ARB ||
4230 srcType == GL_FLOAT);
4231
4232 ASSERT(dstType == GL_UNSIGNED_BYTE ||
4233 dstType == GL_UNSIGNED_SHORT ||
4234 dstType == GL_UNSIGNED_INT);
4235
4236
4237 transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
4238
4239 /*
4240 * Try simple cases first
4241 */
4242 if (transferOps == 0 && srcType == GL_UNSIGNED_BYTE
4243 && dstType == GL_UNSIGNED_BYTE) {
4244 memcpy(dest, source, n * sizeof(GLubyte));
4245 }
4246 else if (transferOps == 0 && srcType == GL_UNSIGNED_INT
4247 && dstType == GL_UNSIGNED_INT && !srcPacking->SwapBytes) {
4248 memcpy(dest, source, n * sizeof(GLuint));
4249 }
4250 else {
4251 /*
4252 * general solution
4253 */
4254 GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
4255
4256 if (!indexes) {
4257 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
4258 return;
4259 }
4260
4261 extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
4262 srcPacking);
4263
4264 if (transferOps)
4265 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
4266
4267 /* convert to dest type */
4268 switch (dstType) {
4269 case GL_UNSIGNED_BYTE:
4270 {
4271 GLubyte *dst = (GLubyte *) dest;
4272 GLuint i;
4273 for (i = 0; i < n; i++) {
4274 dst[i] = (GLubyte) (indexes[i] & 0xff);
4275 }
4276 }
4277 break;
4278 case GL_UNSIGNED_SHORT:
4279 {
4280 GLuint *dst = (GLuint *) dest;
4281 GLuint i;
4282 for (i = 0; i < n; i++) {
4283 dst[i] = (GLushort) (indexes[i] & 0xffff);
4284 }
4285 }
4286 break;
4287 case GL_UNSIGNED_INT:
4288 memcpy(dest, indexes, n * sizeof(GLuint));
4289 break;
4290 default:
4291 _mesa_problem(ctx, "bad dstType in _mesa_unpack_index_span");
4292 }
4293
4294 free(indexes);
4295 }
4296 }
4297
4298
4299 void
4300 _mesa_pack_index_span( struct gl_context *ctx, GLuint n,
4301 GLenum dstType, GLvoid *dest, const GLuint *source,
4302 const struct gl_pixelstore_attrib *dstPacking,
4303 GLbitfield transferOps )
4304 {
4305 GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
4306
4307 if (!indexes) {
4308 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
4309 return;
4310 }
4311
4312 transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
4313
4314 if (transferOps & (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT)) {
4315 /* make a copy of input */
4316 memcpy(indexes, source, n * sizeof(GLuint));
4317 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
4318 source = indexes;
4319 }
4320
4321 switch (dstType) {
4322 case GL_UNSIGNED_BYTE:
4323 {
4324 GLubyte *dst = (GLubyte *) dest;
4325 GLuint i;
4326 for (i = 0; i < n; i++) {
4327 *dst++ = (GLubyte) source[i];
4328 }
4329 }
4330 break;
4331 case GL_BYTE:
4332 {
4333 GLbyte *dst = (GLbyte *) dest;
4334 GLuint i;
4335 for (i = 0; i < n; i++) {
4336 dst[i] = (GLbyte) source[i];
4337 }
4338 }
4339 break;
4340 case GL_UNSIGNED_SHORT:
4341 {
4342 GLushort *dst = (GLushort *) dest;
4343 GLuint i;
4344 for (i = 0; i < n; i++) {
4345 dst[i] = (GLushort) source[i];
4346 }
4347 if (dstPacking->SwapBytes) {
4348 _mesa_swap2( (GLushort *) dst, n );
4349 }
4350 }
4351 break;
4352 case GL_SHORT:
4353 {
4354 GLshort *dst = (GLshort *) dest;
4355 GLuint i;
4356 for (i = 0; i < n; i++) {
4357 dst[i] = (GLshort) source[i];
4358 }
4359 if (dstPacking->SwapBytes) {
4360 _mesa_swap2( (GLushort *) dst, n );
4361 }
4362 }
4363 break;
4364 case GL_UNSIGNED_INT:
4365 {
4366 GLuint *dst = (GLuint *) dest;
4367 GLuint i;
4368 for (i = 0; i < n; i++) {
4369 dst[i] = (GLuint) source[i];
4370 }
4371 if (dstPacking->SwapBytes) {
4372 _mesa_swap4( (GLuint *) dst, n );
4373 }
4374 }
4375 break;
4376 case GL_INT:
4377 {
4378 GLint *dst = (GLint *) dest;
4379 GLuint i;
4380 for (i = 0; i < n; i++) {
4381 dst[i] = (GLint) source[i];
4382 }
4383 if (dstPacking->SwapBytes) {
4384 _mesa_swap4( (GLuint *) dst, n );
4385 }
4386 }
4387 break;
4388 case GL_FLOAT:
4389 {
4390 GLfloat *dst = (GLfloat *) dest;
4391 GLuint i;
4392 for (i = 0; i < n; i++) {
4393 dst[i] = (GLfloat) source[i];
4394 }
4395 if (dstPacking->SwapBytes) {
4396 _mesa_swap4( (GLuint *) dst, n );
4397 }
4398 }
4399 break;
4400 case GL_HALF_FLOAT_ARB:
4401 {
4402 GLhalfARB *dst = (GLhalfARB *) dest;
4403 GLuint i;
4404 for (i = 0; i < n; i++) {
4405 dst[i] = _mesa_float_to_half((GLfloat) source[i]);
4406 }
4407 if (dstPacking->SwapBytes) {
4408 _mesa_swap2( (GLushort *) dst, n );
4409 }
4410 }
4411 break;
4412 default:
4413 _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
4414 }
4415
4416 free(indexes);
4417 }
4418
4419
4420 /*
4421 * Unpack a row of stencil data from a client buffer according to
4422 * the pixel unpacking parameters.
4423 * This is (or will be) used by glDrawPixels
4424 *
4425 * Args: ctx - the context
4426 * n - number of pixels
4427 * dstType - destination data type
4428 * dest - destination array
4429 * srcType - source pixel type
4430 * source - source data pointer
4431 * srcPacking - pixel unpacking parameters
4432 * transferOps - apply offset/bias/lookup ops?
4433 */
4434 void
4435 _mesa_unpack_stencil_span( struct gl_context *ctx, GLuint n,
4436 GLenum dstType, GLvoid *dest,
4437 GLenum srcType, const GLvoid *source,
4438 const struct gl_pixelstore_attrib *srcPacking,
4439 GLbitfield transferOps )
4440 {
4441 ASSERT(srcType == GL_BITMAP ||
4442 srcType == GL_UNSIGNED_BYTE ||
4443 srcType == GL_BYTE ||
4444 srcType == GL_UNSIGNED_SHORT ||
4445 srcType == GL_SHORT ||
4446 srcType == GL_UNSIGNED_INT ||
4447 srcType == GL_INT ||
4448 srcType == GL_UNSIGNED_INT_24_8_EXT ||
4449 srcType == GL_HALF_FLOAT_ARB ||
4450 srcType == GL_FLOAT ||
4451 srcType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
4452
4453 ASSERT(dstType == GL_UNSIGNED_BYTE ||
4454 dstType == GL_UNSIGNED_SHORT ||
4455 dstType == GL_UNSIGNED_INT ||
4456 dstType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
4457
4458 /* only shift and offset apply to stencil */
4459 transferOps &= IMAGE_SHIFT_OFFSET_BIT;
4460
4461 /*
4462 * Try simple cases first
4463 */
4464 if (transferOps == 0 &&
4465 !ctx->Pixel.MapStencilFlag &&
4466 srcType == GL_UNSIGNED_BYTE &&
4467 dstType == GL_UNSIGNED_BYTE) {
4468 memcpy(dest, source, n * sizeof(GLubyte));
4469 }
4470 else if (transferOps == 0 &&
4471 !ctx->Pixel.MapStencilFlag &&
4472 srcType == GL_UNSIGNED_INT &&
4473 dstType == GL_UNSIGNED_INT &&
4474 !srcPacking->SwapBytes) {
4475 memcpy(dest, source, n * sizeof(GLuint));
4476 }
4477 else {
4478 /*
4479 * general solution
4480 */
4481 GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
4482
4483 if (!indexes) {
4484 _mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil unpacking");
4485 return;
4486 }
4487
4488 extract_uint_indexes(n, indexes, GL_STENCIL_INDEX, srcType, source,
4489 srcPacking);
4490
4491 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
4492 /* shift and offset indexes */
4493 _mesa_shift_and_offset_ci(ctx, n, indexes);
4494 }
4495
4496 if (ctx->Pixel.MapStencilFlag) {
4497 /* Apply stencil lookup table */
4498 const GLuint mask = ctx->PixelMaps.StoS.Size - 1;
4499 GLuint i;
4500 for (i = 0; i < n; i++) {
4501 indexes[i] = (GLuint)ctx->PixelMaps.StoS.Map[ indexes[i] & mask ];
4502 }
4503 }
4504
4505 /* convert to dest type */
4506 switch (dstType) {
4507 case GL_UNSIGNED_BYTE:
4508 {
4509 GLubyte *dst = (GLubyte *) dest;
4510 GLuint i;
4511 for (i = 0; i < n; i++) {
4512 dst[i] = (GLubyte) (indexes[i] & 0xff);
4513 }
4514 }
4515 break;
4516 case GL_UNSIGNED_SHORT:
4517 {
4518 GLuint *dst = (GLuint *) dest;
4519 GLuint i;
4520 for (i = 0; i < n; i++) {
4521 dst[i] = (GLushort) (indexes[i] & 0xffff);
4522 }
4523 }
4524 break;
4525 case GL_UNSIGNED_INT:
4526 memcpy(dest, indexes, n * sizeof(GLuint));
4527 break;
4528 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
4529 {
4530 GLuint *dst = (GLuint *) dest;
4531 GLuint i;
4532 for (i = 0; i < n; i++) {
4533 dst[i*2+1] = indexes[i] & 0xff; /* lower 8 bits */
4534 }
4535 }
4536 break;
4537 default:
4538 _mesa_problem(ctx, "bad dstType in _mesa_unpack_stencil_span");
4539 }
4540
4541 free(indexes);
4542 }
4543 }
4544
4545
4546 void
4547 _mesa_pack_stencil_span( struct gl_context *ctx, GLuint n,
4548 GLenum dstType, GLvoid *dest, const GLubyte *source,
4549 const struct gl_pixelstore_attrib *dstPacking )
4550 {
4551 GLubyte *stencil = (GLubyte *) malloc(n * sizeof(GLubyte));
4552
4553 if (!stencil) {
4554 _mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil packing");
4555 return;
4556 }
4557
4558 if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset ||
4559 ctx->Pixel.MapStencilFlag) {
4560 /* make a copy of input */
4561 memcpy(stencil, source, n * sizeof(GLubyte));
4562 _mesa_apply_stencil_transfer_ops(ctx, n, stencil);
4563 source = stencil;
4564 }
4565
4566 switch (dstType) {
4567 case GL_UNSIGNED_BYTE:
4568 memcpy(dest, source, n);
4569 break;
4570 case GL_BYTE:
4571 {
4572 GLbyte *dst = (GLbyte *) dest;
4573 GLuint i;
4574 for (i=0;i<n;i++) {
4575 dst[i] = (GLbyte) (source[i] & 0x7f);
4576 }
4577 }
4578 break;
4579 case GL_UNSIGNED_SHORT:
4580 {
4581 GLushort *dst = (GLushort *) dest;
4582 GLuint i;
4583 for (i=0;i<n;i++) {
4584 dst[i] = (GLushort) source[i];
4585 }
4586 if (dstPacking->SwapBytes) {
4587 _mesa_swap2( (GLushort *) dst, n );
4588 }
4589 }
4590 break;
4591 case GL_SHORT:
4592 {
4593 GLshort *dst = (GLshort *) dest;
4594 GLuint i;
4595 for (i=0;i<n;i++) {
4596 dst[i] = (GLshort) source[i];
4597 }
4598 if (dstPacking->SwapBytes) {
4599 _mesa_swap2( (GLushort *) dst, n );
4600 }
4601 }
4602 break;
4603 case GL_UNSIGNED_INT:
4604 {
4605 GLuint *dst = (GLuint *) dest;
4606 GLuint i;
4607 for (i=0;i<n;i++) {
4608 dst[i] = (GLuint) source[i];
4609 }
4610 if (dstPacking->SwapBytes) {
4611 _mesa_swap4( (GLuint *) dst, n );
4612 }
4613 }
4614 break;
4615 case GL_INT:
4616 {
4617 GLint *dst = (GLint *) dest;
4618 GLuint i;
4619 for (i=0;i<n;i++) {
4620 dst[i] = (GLint) source[i];
4621 }
4622 if (dstPacking->SwapBytes) {
4623 _mesa_swap4( (GLuint *) dst, n );
4624 }
4625 }
4626 break;
4627 case GL_FLOAT:
4628 {
4629 GLfloat *dst = (GLfloat *) dest;
4630 GLuint i;
4631 for (i=0;i<n;i++) {
4632 dst[i] = (GLfloat) source[i];
4633 }
4634 if (dstPacking->SwapBytes) {
4635 _mesa_swap4( (GLuint *) dst, n );
4636 }
4637 }
4638 break;
4639 case GL_HALF_FLOAT_ARB:
4640 {
4641 GLhalfARB *dst = (GLhalfARB *) dest;
4642 GLuint i;
4643 for (i=0;i<n;i++) {
4644 dst[i] = _mesa_float_to_half( (float) source[i] );
4645 }
4646 if (dstPacking->SwapBytes) {
4647 _mesa_swap2( (GLushort *) dst, n );
4648 }
4649 }
4650 break;
4651 case GL_BITMAP:
4652 if (dstPacking->LsbFirst) {
4653 GLubyte *dst = (GLubyte *) dest;
4654 GLint shift = 0;
4655 GLuint i;
4656 for (i = 0; i < n; i++) {
4657 if (shift == 0)
4658 *dst = 0;
4659 *dst |= ((source[i] != 0) << shift);
4660 shift++;
4661 if (shift == 8) {
4662 shift = 0;
4663 dst++;
4664 }
4665 }
4666 }
4667 else {
4668 GLubyte *dst = (GLubyte *) dest;
4669 GLint shift = 7;
4670 GLuint i;
4671 for (i = 0; i < n; i++) {
4672 if (shift == 7)
4673 *dst = 0;
4674 *dst |= ((source[i] != 0) << shift);
4675 shift--;
4676 if (shift < 0) {
4677 shift = 7;
4678 dst++;
4679 }
4680 }
4681 }
4682 break;
4683 default:
4684 _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
4685 }
4686
4687 free(stencil);
4688 }
4689
4690 #define DEPTH_VALUES(GLTYPE, GLTYPE2FLOAT) \
4691 do { \
4692 GLuint i; \
4693 const GLTYPE *src = (const GLTYPE *)source; \
4694 for (i = 0; i < n; i++) { \
4695 GLTYPE value = src[i]; \
4696 if (srcPacking->SwapBytes) { \
4697 if (sizeof(GLTYPE) == 2) { \
4698 SWAP2BYTE(value); \
4699 } else if (sizeof(GLTYPE) == 4) { \
4700 SWAP4BYTE(value); \
4701 } \
4702 } \
4703 depthValues[i] = GLTYPE2FLOAT(value); \
4704 } \
4705 } while (0)
4706
4707
4708 /**
4709 * Unpack a row of depth/z values from memory, returning GLushort, GLuint
4710 * or GLfloat values.
4711 * The glPixelTransfer (scale/bias) params will be applied.
4712 *
4713 * \param dstType one of GL_UNSIGNED_SHORT, GL_UNSIGNED_INT, GL_FLOAT
4714 * \param depthMax max value for returned GLushort or GLuint values
4715 * (ignored for GLfloat).
4716 */
4717 void
4718 _mesa_unpack_depth_span( struct gl_context *ctx, GLuint n,
4719 GLenum dstType, GLvoid *dest, GLuint depthMax,
4720 GLenum srcType, const GLvoid *source,
4721 const struct gl_pixelstore_attrib *srcPacking )
4722 {
4723 GLfloat *depthTemp = NULL, *depthValues;
4724 GLboolean needClamp = GL_FALSE;
4725
4726 /* Look for special cases first.
4727 * Not only are these faster, they're less prone to numeric conversion
4728 * problems. Otherwise, converting from an int type to a float then
4729 * back to an int type can introduce errors that will show up as
4730 * artifacts in things like depth peeling which uses glCopyTexImage.
4731 */
4732 if (ctx->Pixel.DepthScale == 1.0 && ctx->Pixel.DepthBias == 0.0) {
4733 if (srcType == GL_UNSIGNED_INT && dstType == GL_UNSIGNED_SHORT) {
4734 const GLuint *src = (const GLuint *) source;
4735 GLushort *dst = (GLushort *) dest;
4736 GLuint i;
4737 for (i = 0; i < n; i++) {
4738 dst[i] = src[i] >> 16;
4739 }
4740 return;
4741 }
4742 if (srcType == GL_UNSIGNED_SHORT
4743 && dstType == GL_UNSIGNED_INT
4744 && depthMax == 0xffffffff) {
4745 const GLushort *src = (const GLushort *) source;
4746 GLuint *dst = (GLuint *) dest;
4747 GLuint i;
4748 for (i = 0; i < n; i++) {
4749 dst[i] = src[i] | (src[i] << 16);
4750 }
4751 return;
4752 }
4753 if (srcType == GL_UNSIGNED_INT_24_8
4754 && dstType == GL_UNSIGNED_INT
4755 && depthMax == 0xffffff) {
4756 const GLuint *src = (const GLuint *) source;
4757 GLuint *dst = (GLuint *) dest;
4758 GLuint i;
4759 for (i = 0; i < n; i++) {
4760 dst[i] = src[i] >> 8;
4761 }
4762 return;
4763 }
4764 /* XXX may want to add additional cases here someday */
4765 }
4766
4767 /* general case path follows */
4768
4769 if (dstType == GL_FLOAT) {
4770 depthValues = (GLfloat *) dest;
4771 }
4772 else {
4773 depthTemp = (GLfloat *) malloc(n * sizeof(GLfloat));
4774 if (!depthTemp) {
4775 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
4776 return;
4777 }
4778
4779 depthValues = depthTemp;
4780 }
4781
4782 /* Convert incoming values to GLfloat. Some conversions will require
4783 * clamping, below.
4784 */
4785 switch (srcType) {
4786 case GL_BYTE:
4787 DEPTH_VALUES(GLbyte, BYTE_TO_FLOATZ);
4788 needClamp = GL_TRUE;
4789 break;
4790 case GL_UNSIGNED_BYTE:
4791 DEPTH_VALUES(GLubyte, UBYTE_TO_FLOAT);
4792 break;
4793 case GL_SHORT:
4794 DEPTH_VALUES(GLshort, SHORT_TO_FLOATZ);
4795 needClamp = GL_TRUE;
4796 break;
4797 case GL_UNSIGNED_SHORT:
4798 DEPTH_VALUES(GLushort, USHORT_TO_FLOAT);
4799 break;
4800 case GL_INT:
4801 DEPTH_VALUES(GLint, INT_TO_FLOAT);
4802 needClamp = GL_TRUE;
4803 break;
4804 case GL_UNSIGNED_INT:
4805 DEPTH_VALUES(GLuint, UINT_TO_FLOAT);
4806 break;
4807 case GL_UNSIGNED_INT_24_8_EXT: /* GL_EXT_packed_depth_stencil */
4808 if (dstType == GL_UNSIGNED_INT_24_8_EXT &&
4809 depthMax == 0xffffff &&
4810 ctx->Pixel.DepthScale == 1.0 &&
4811 ctx->Pixel.DepthBias == 0.0) {
4812 const GLuint *src = (const GLuint *) source;
4813 GLuint *zValues = (GLuint *) dest;
4814 GLuint i;
4815 for (i = 0; i < n; i++) {
4816 GLuint value = src[i];
4817 if (srcPacking->SwapBytes) {
4818 SWAP4BYTE(value);
4819 }
4820 zValues[i] = value & 0xffffff00;
4821 }
4822 free(depthTemp);
4823 return;
4824 }
4825 else {
4826 const GLuint *src = (const GLuint *) source;
4827 const GLfloat scale = 1.0f / 0xffffff;
4828 GLuint i;
4829 for (i = 0; i < n; i++) {
4830 GLuint value = src[i];
4831 if (srcPacking->SwapBytes) {
4832 SWAP4BYTE(value);
4833 }
4834 depthValues[i] = (value >> 8) * scale;
4835 }
4836 }
4837 break;
4838 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
4839 {
4840 GLuint i;
4841 const GLfloat *src = (const GLfloat *)source;
4842 for (i = 0; i < n; i++) {
4843 GLfloat value = src[i * 2];
4844 if (srcPacking->SwapBytes) {
4845 SWAP4BYTE(value);
4846 }
4847 depthValues[i] = value;
4848 }
4849 needClamp = GL_TRUE;
4850 }
4851 break;
4852 case GL_FLOAT:
4853 DEPTH_VALUES(GLfloat, 1*);
4854 needClamp = GL_TRUE;
4855 break;
4856 case GL_HALF_FLOAT_ARB:
4857 {
4858 GLuint i;
4859 const GLhalfARB *src = (const GLhalfARB *) source;
4860 for (i = 0; i < n; i++) {
4861 GLhalfARB value = src[i];
4862 if (srcPacking->SwapBytes) {
4863 SWAP2BYTE(value);
4864 }
4865 depthValues[i] = _mesa_half_to_float(value);
4866 }
4867 needClamp = GL_TRUE;
4868 }
4869 break;
4870 default:
4871 _mesa_problem(NULL, "bad type in _mesa_unpack_depth_span()");
4872 free(depthTemp);
4873 return;
4874 }
4875
4876 /* apply depth scale and bias */
4877 {
4878 const GLfloat scale = ctx->Pixel.DepthScale;
4879 const GLfloat bias = ctx->Pixel.DepthBias;
4880 if (scale != 1.0 || bias != 0.0) {
4881 GLuint i;
4882 for (i = 0; i < n; i++) {
4883 depthValues[i] = depthValues[i] * scale + bias;
4884 }
4885 needClamp = GL_TRUE;
4886 }
4887 }
4888
4889 /* clamp to [0, 1] */
4890 if (needClamp) {
4891 GLuint i;
4892 for (i = 0; i < n; i++) {
4893 depthValues[i] = (GLfloat)CLAMP(depthValues[i], 0.0, 1.0);
4894 }
4895 }
4896
4897 /*
4898 * Convert values to dstType
4899 */
4900 if (dstType == GL_UNSIGNED_INT) {
4901 GLuint *zValues = (GLuint *) dest;
4902 GLuint i;
4903 if (depthMax <= 0xffffff) {
4904 /* no overflow worries */
4905 for (i = 0; i < n; i++) {
4906 zValues[i] = (GLuint) (depthValues[i] * (GLfloat) depthMax);
4907 }
4908 }
4909 else {
4910 /* need to use double precision to prevent overflow problems */
4911 for (i = 0; i < n; i++) {
4912 GLdouble z = depthValues[i] * (GLfloat) depthMax;
4913 if (z >= (GLdouble) 0xffffffff)
4914 zValues[i] = 0xffffffff;
4915 else
4916 zValues[i] = (GLuint) z;
4917 }
4918 }
4919 }
4920 else if (dstType == GL_UNSIGNED_SHORT) {
4921 GLushort *zValues = (GLushort *) dest;
4922 GLuint i;
4923 ASSERT(depthMax <= 0xffff);
4924 for (i = 0; i < n; i++) {
4925 zValues[i] = (GLushort) (depthValues[i] * (GLfloat) depthMax);
4926 }
4927 }
4928 else if (dstType == GL_FLOAT) {
4929 /* Nothing to do. depthValues is pointing to dest. */
4930 }
4931 else if (dstType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV) {
4932 GLfloat *zValues = (GLfloat*) dest;
4933 GLuint i;
4934 for (i = 0; i < n; i++) {
4935 zValues[i*2] = depthValues[i];
4936 }
4937 }
4938 else {
4939 ASSERT(0);
4940 }
4941
4942 free(depthTemp);
4943 }
4944
4945
4946 /*
4947 * Pack an array of depth values. The values are floats in [0,1].
4948 */
4949 void
4950 _mesa_pack_depth_span( struct gl_context *ctx, GLuint n, GLvoid *dest,
4951 GLenum dstType, const GLfloat *depthSpan,
4952 const struct gl_pixelstore_attrib *dstPacking )
4953 {
4954 GLfloat *depthCopy = (GLfloat *) malloc(n * sizeof(GLfloat));
4955 if (!depthCopy) {
4956 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
4957 return;
4958 }
4959
4960 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
4961 memcpy(depthCopy, depthSpan, n * sizeof(GLfloat));
4962 _mesa_scale_and_bias_depth(ctx, n, depthCopy);
4963 depthSpan = depthCopy;
4964 }
4965
4966 switch (dstType) {
4967 case GL_UNSIGNED_BYTE:
4968 {
4969 GLubyte *dst = (GLubyte *) dest;
4970 GLuint i;
4971 for (i = 0; i < n; i++) {
4972 dst[i] = FLOAT_TO_UBYTE( depthSpan[i] );
4973 }
4974 }
4975 break;
4976 case GL_BYTE:
4977 {
4978 GLbyte *dst = (GLbyte *) dest;
4979 GLuint i;
4980 for (i = 0; i < n; i++) {
4981 dst[i] = FLOAT_TO_BYTE( depthSpan[i] );
4982 }
4983 }
4984 break;
4985 case GL_UNSIGNED_SHORT:
4986 {
4987 GLushort *dst = (GLushort *) dest;
4988 GLuint i;
4989 for (i = 0; i < n; i++) {
4990 CLAMPED_FLOAT_TO_USHORT(dst[i], depthSpan[i]);
4991 }
4992 if (dstPacking->SwapBytes) {
4993 _mesa_swap2( (GLushort *) dst, n );
4994 }
4995 }
4996 break;
4997 case GL_SHORT:
4998 {
4999 GLshort *dst = (GLshort *) dest;
5000 GLuint i;
5001 for (i = 0; i < n; i++) {
5002 dst[i] = FLOAT_TO_SHORT( depthSpan[i] );
5003 }
5004 if (dstPacking->SwapBytes) {
5005 _mesa_swap2( (GLushort *) dst, n );
5006 }
5007 }
5008 break;
5009 case GL_UNSIGNED_INT:
5010 {
5011 GLuint *dst = (GLuint *) dest;
5012 GLuint i;
5013 for (i = 0; i < n; i++) {
5014 dst[i] = FLOAT_TO_UINT( depthSpan[i] );
5015 }
5016 if (dstPacking->SwapBytes) {
5017 _mesa_swap4( (GLuint *) dst, n );
5018 }
5019 }
5020 break;
5021 case GL_INT:
5022 {
5023 GLint *dst = (GLint *) dest;
5024 GLuint i;
5025 for (i = 0; i < n; i++) {
5026 dst[i] = FLOAT_TO_INT( depthSpan[i] );
5027 }
5028 if (dstPacking->SwapBytes) {
5029 _mesa_swap4( (GLuint *) dst, n );
5030 }
5031 }
5032 break;
5033 case GL_FLOAT:
5034 {
5035 GLfloat *dst = (GLfloat *) dest;
5036 GLuint i;
5037 for (i = 0; i < n; i++) {
5038 dst[i] = depthSpan[i];
5039 }
5040 if (dstPacking->SwapBytes) {
5041 _mesa_swap4( (GLuint *) dst, n );
5042 }
5043 }
5044 break;
5045 case GL_HALF_FLOAT_ARB:
5046 {
5047 GLhalfARB *dst = (GLhalfARB *) dest;
5048 GLuint i;
5049 for (i = 0; i < n; i++) {
5050 dst[i] = _mesa_float_to_half(depthSpan[i]);
5051 }
5052 if (dstPacking->SwapBytes) {
5053 _mesa_swap2( (GLushort *) dst, n );
5054 }
5055 }
5056 break;
5057 default:
5058 _mesa_problem(ctx, "bad type in _mesa_pack_depth_span");
5059 }
5060
5061 free(depthCopy);
5062 }
5063
5064
5065
5066 /**
5067 * Pack depth and stencil values as GL_DEPTH_STENCIL (GL_UNSIGNED_INT_24_8 etc)
5068 */
5069 void
5070 _mesa_pack_depth_stencil_span(struct gl_context *ctx,GLuint n,
5071 GLenum dstType, GLuint *dest,
5072 const GLfloat *depthVals,
5073 const GLubyte *stencilVals,
5074 const struct gl_pixelstore_attrib *dstPacking)
5075 {
5076 GLfloat *depthCopy = (GLfloat *) malloc(n * sizeof(GLfloat));
5077 GLubyte *stencilCopy = (GLubyte *) malloc(n * sizeof(GLubyte));
5078 GLuint i;
5079
5080 if (!depthCopy || !stencilCopy) {
5081 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
5082 free(depthCopy);
5083 free(stencilCopy);
5084 return;
5085 }
5086
5087 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
5088 memcpy(depthCopy, depthVals, n * sizeof(GLfloat));
5089 _mesa_scale_and_bias_depth(ctx, n, depthCopy);
5090 depthVals = depthCopy;
5091 }
5092
5093 if (ctx->Pixel.IndexShift ||
5094 ctx->Pixel.IndexOffset ||
5095 ctx->Pixel.MapStencilFlag) {
5096 memcpy(stencilCopy, stencilVals, n * sizeof(GLubyte));
5097 _mesa_apply_stencil_transfer_ops(ctx, n, stencilCopy);
5098 stencilVals = stencilCopy;
5099 }
5100
5101 switch (dstType) {
5102 case GL_UNSIGNED_INT_24_8:
5103 for (i = 0; i < n; i++) {
5104 GLuint z = (GLuint) (depthVals[i] * 0xffffff);
5105 dest[i] = (z << 8) | (stencilVals[i] & 0xff);
5106 }
5107 break;
5108 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
5109 for (i = 0; i < n; i++) {
5110 ((GLfloat*)dest)[i*2] = depthVals[i];
5111 dest[i*2+1] = stencilVals[i] & 0xff;
5112 }
5113 break;
5114 }
5115
5116 if (dstPacking->SwapBytes) {
5117 _mesa_swap4(dest, n);
5118 }
5119
5120 free(depthCopy);
5121 free(stencilCopy);
5122 }
5123
5124
5125
5126
5127 /**
5128 * Unpack image data. Apply byte swapping, byte flipping (bitmap).
5129 * Return all image data in a contiguous block. This is used when we
5130 * compile glDrawPixels, glTexImage, etc into a display list. We
5131 * need a copy of the data in a standard format.
5132 */
5133 void *
5134 _mesa_unpack_image( GLuint dimensions,
5135 GLsizei width, GLsizei height, GLsizei depth,
5136 GLenum format, GLenum type, const GLvoid *pixels,
5137 const struct gl_pixelstore_attrib *unpack )
5138 {
5139 GLint bytesPerRow, compsPerRow;
5140 GLboolean flipBytes, swap2, swap4;
5141
5142 if (!pixels)
5143 return NULL; /* not necessarily an error */
5144
5145 if (width <= 0 || height <= 0 || depth <= 0)
5146 return NULL; /* generate error later */
5147
5148 if (type == GL_BITMAP) {
5149 bytesPerRow = (width + 7) >> 3;
5150 flipBytes = unpack->LsbFirst;
5151 swap2 = swap4 = GL_FALSE;
5152 compsPerRow = 0;
5153 }
5154 else {
5155 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
5156 GLint components = _mesa_components_in_format(format);
5157 GLint bytesPerComp;
5158
5159 if (_mesa_type_is_packed(type))
5160 components = 1;
5161
5162 if (bytesPerPixel <= 0 || components <= 0)
5163 return NULL; /* bad format or type. generate error later */
5164 bytesPerRow = bytesPerPixel * width;
5165 bytesPerComp = bytesPerPixel / components;
5166 flipBytes = GL_FALSE;
5167 swap2 = (bytesPerComp == 2) && unpack->SwapBytes;
5168 swap4 = (bytesPerComp == 4) && unpack->SwapBytes;
5169 compsPerRow = components * width;
5170 assert(compsPerRow >= width);
5171 }
5172
5173 {
5174 GLubyte *destBuffer
5175 = (GLubyte *) malloc(bytesPerRow * height * depth);
5176 GLubyte *dst;
5177 GLint img, row;
5178 if (!destBuffer)
5179 return NULL; /* generate GL_OUT_OF_MEMORY later */
5180
5181 dst = destBuffer;
5182 for (img = 0; img < depth; img++) {
5183 for (row = 0; row < height; row++) {
5184 const GLvoid *src = _mesa_image_address(dimensions, unpack, pixels,
5185 width, height, format, type, img, row, 0);
5186
5187 if ((type == GL_BITMAP) && (unpack->SkipPixels & 0x7)) {
5188 GLint i;
5189 flipBytes = GL_FALSE;
5190 if (unpack->LsbFirst) {
5191 GLubyte srcMask = 1 << (unpack->SkipPixels & 0x7);
5192 GLubyte dstMask = 128;
5193 const GLubyte *s = src;
5194 GLubyte *d = dst;
5195 *d = 0;
5196 for (i = 0; i < width; i++) {
5197 if (*s & srcMask) {
5198 *d |= dstMask;
5199 }
5200 if (srcMask == 128) {
5201 srcMask = 1;
5202 s++;
5203 }
5204 else {
5205 srcMask = srcMask << 1;
5206 }
5207 if (dstMask == 1) {
5208 dstMask = 128;
5209 d++;
5210 *d = 0;
5211 }
5212 else {
5213 dstMask = dstMask >> 1;
5214 }
5215 }
5216 }
5217 else {
5218 GLubyte srcMask = 128 >> (unpack->SkipPixels & 0x7);
5219 GLubyte dstMask = 128;
5220 const GLubyte *s = src;
5221 GLubyte *d = dst;
5222 *d = 0;
5223 for (i = 0; i < width; i++) {
5224 if (*s & srcMask) {
5225 *d |= dstMask;
5226 }
5227 if (srcMask == 1) {
5228 srcMask = 128;
5229 s++;
5230 }
5231 else {
5232 srcMask = srcMask >> 1;
5233 }
5234 if (dstMask == 1) {
5235 dstMask = 128;
5236 d++;
5237 *d = 0;
5238 }
5239 else {
5240 dstMask = dstMask >> 1;
5241 }
5242 }
5243 }
5244 }
5245 else {
5246 memcpy(dst, src, bytesPerRow);
5247 }
5248
5249 /* byte flipping/swapping */
5250 if (flipBytes) {
5251 flip_bytes((GLubyte *) dst, bytesPerRow);
5252 }
5253 else if (swap2) {
5254 _mesa_swap2((GLushort*) dst, compsPerRow);
5255 }
5256 else if (swap4) {
5257 _mesa_swap4((GLuint*) dst, compsPerRow);
5258 }
5259 dst += bytesPerRow;
5260 }
5261 }
5262 return destBuffer;
5263 }
5264 }
5265
5266
5267
5268 /**
5269 * If we unpack colors from a luminance surface, we'll get pixel colors
5270 * such as (l, l, l, a).
5271 * When we call _mesa_pack_rgba_span_float(format=GL_LUMINANCE), that
5272 * function will compute L=R+G+B before packing. The net effect is we'll
5273 * accidentally store luminance values = 3*l.
5274 * This function compensates for that by converting (aka rebasing) (l,l,l,a)
5275 * to be (l,0,0,a).
5276 * It's a similar story for other formats such as LUMINANCE_ALPHA, ALPHA
5277 * and INTENSITY.
5278 *
5279 * Finally, we also need to do this when the actual surface format does
5280 * not match the logical surface format. For example, suppose the user
5281 * requests a GL_LUMINANCE texture but the driver stores it as RGBA.
5282 * Again, we'll get pixel values like (l,l,l,a).
5283 */
5284 void
5285 _mesa_rebase_rgba_float(GLuint n, GLfloat rgba[][4], GLenum baseFormat)
5286 {
5287 GLuint i;
5288
5289 switch (baseFormat) {
5290 case GL_ALPHA:
5291 for (i = 0; i < n; i++) {
5292 rgba[i][RCOMP] = 0.0F;
5293 rgba[i][GCOMP] = 0.0F;
5294 rgba[i][BCOMP] = 0.0F;
5295 }
5296 break;
5297 case GL_INTENSITY:
5298 /* fall-through */
5299 case GL_LUMINANCE:
5300 for (i = 0; i < n; i++) {
5301 rgba[i][GCOMP] = 0.0F;
5302 rgba[i][BCOMP] = 0.0F;
5303 rgba[i][ACOMP] = 1.0F;
5304 }
5305 break;
5306 case GL_LUMINANCE_ALPHA:
5307 for (i = 0; i < n; i++) {
5308 rgba[i][GCOMP] = 0.0F;
5309 rgba[i][BCOMP] = 0.0F;
5310 }
5311 break;
5312 default:
5313 /* no-op */
5314 ;
5315 }
5316 }
5317
5318
5319 /**
5320 * As above, but GLuint components.
5321 */
5322 void
5323 _mesa_rebase_rgba_uint(GLuint n, GLuint rgba[][4], GLenum baseFormat)
5324 {
5325 GLuint i;
5326
5327 switch (baseFormat) {
5328 case GL_ALPHA:
5329 for (i = 0; i < n; i++) {
5330 rgba[i][RCOMP] = 0;
5331 rgba[i][GCOMP] = 0;
5332 rgba[i][BCOMP] = 0;
5333 }
5334 break;
5335 case GL_INTENSITY:
5336 /* fall-through */
5337 case GL_LUMINANCE:
5338 for (i = 0; i < n; i++) {
5339 rgba[i][GCOMP] = 0;
5340 rgba[i][BCOMP] = 0;
5341 rgba[i][ACOMP] = 1;
5342 }
5343 break;
5344 case GL_LUMINANCE_ALPHA:
5345 for (i = 0; i < n; i++) {
5346 rgba[i][GCOMP] = 0;
5347 rgba[i][BCOMP] = 0;
5348 }
5349 break;
5350 default:
5351 /* no-op */
5352 ;
5353 }
5354 }
5355
5356