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