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