projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
mesa: remove redundant byte swap check
[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*3+0] = (GLshort) rgba[i][RCOMP];
1179 dst[i*3+1] = (GLshort) rgba[i][GCOMP];
1180 dst[i*3+2] = (GLshort) rgba[i][BCOMP];
1181 }
1182 break;
1183 case GL_RGB_INTEGER_EXT:
1184 for (i=0;i<n;i++) {
1185 dst[i*3+0] = (GLshort) rgba[i][RCOMP];
1186 dst[i*3+1] = (GLshort) rgba[i][GCOMP];
1187 dst[i*3+2] = (GLshort) rgba[i][BCOMP];
1188 }
1189 break;
1190 case GL_RGBA_INTEGER_EXT:
1191 for (i=0;i<n;i++) {
1192 dst[i*4+0] = (GLshort) rgba[i][RCOMP];
1193 dst[i*4+1] = (GLshort) rgba[i][GCOMP];
1194 dst[i*4+2] = (GLshort) rgba[i][BCOMP];
1195 dst[i*4+3] = (GLshort) rgba[i][ACOMP];
1196 }
1197 break;
1198 case GL_BGR_INTEGER_EXT:
1199 for (i=0;i<n;i++) {
1200 dst[i*3+0] = (GLshort) rgba[i][BCOMP];
1201 dst[i*3+1] = (GLshort) rgba[i][GCOMP];
1202 dst[i*3+2] = (GLshort) rgba[i][RCOMP];
1203 }
1204 break;
1205 case GL_BGRA_INTEGER_EXT:
1206 for (i=0;i<n;i++) {
1207 dst[i*4+0] = (GLshort) rgba[i][BCOMP];
1208 dst[i*4+1] = (GLshort) rgba[i][GCOMP];
1209 dst[i*4+2] = (GLshort) rgba[i][RCOMP];
1210 dst[i*4+3] = (GLshort) rgba[i][ACOMP];
1211 }
1212 break;
1213 case GL_LUMINANCE_INTEGER_EXT:
1214 for (i=0;i<n;i++) {
1215 dst[i*2+0] = (GLshort) (rgba[i][RCOMP] +
1216 rgba[i][GCOMP] +
1217 rgba[i][BCOMP]);
1218 dst[i*2+1] = (GLshort) rgba[i][ACOMP];
1219 }
1220 break;
1221 case GL_LUMINANCE_ALPHA_INTEGER_EXT:
1222 for (i=0;i<n;i++) {
1223 dst[i] = (GLshort) (rgba[i][RCOMP] +
1224 rgba[i][GCOMP] +
1225 rgba[i][BCOMP]);
1226 }
1227 break;
1228 case GL_DUDV_ATI:
1229 case GL_DU8DV8_ATI:
1230 for (i=0;i<n;i++) {
1231 dst[i*2+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1232 dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1233 }
1234 break;
1235 default:
1236 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1237 }
1238 }
1239 break;
1240 case GL_UNSIGNED_INT:
1241 {
1242 GLuint *dst = (GLuint *) dstAddr;
1243 switch (dstFormat) {
1244 case GL_RED:
1245 for (i=0;i<n;i++)
1246 dst[i] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1247 break;
1248 case GL_GREEN:
1249 for (i=0;i<n;i++)
1250 dst[i] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1251 break;
1252 case GL_BLUE:
1253 for (i=0;i<n;i++)
1254 dst[i] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1255 break;
1256 case GL_ALPHA:
1257 for (i=0;i<n;i++)
1258 dst[i] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1259 break;
1260 case GL_LUMINANCE:
1261 for (i=0;i<n;i++)
1262 dst[i] = FLOAT_TO_UINT(luminance[i]);
1263 break;
1264 case GL_LUMINANCE_ALPHA:
1265 for (i=0;i<n;i++) {
1266 dst[i*2+0] = FLOAT_TO_UINT(luminance[i]);
1267 dst[i*2+1] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1268 }
1269 break;
1270 case GL_RG:
1271 for (i=0;i<n;i++) {
1272 dst[i*2+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1273 dst[i*2+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1274 }
1275 break;
1276 case GL_RGB:
1277 for (i=0;i<n;i++) {
1278 dst[i*3+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1279 dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1280 dst[i*3+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1281 }
1282 break;
1283 case GL_RGBA:
1284 for (i=0;i<n;i++) {
1285 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1286 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1287 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1288 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1289 }
1290 break;
1291 case GL_BGR:
1292 for (i=0;i<n;i++) {
1293 dst[i*3+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1294 dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1295 dst[i*3+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1296 }
1297 break;
1298 case GL_BGRA:
1299 for (i=0;i<n;i++) {
1300 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1301 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1302 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1303 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1304 }
1305 break;
1306 case GL_ABGR_EXT:
1307 for (i=0;i<n;i++) {
1308 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1309 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1310 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1311 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1312 }
1313 break;
1314 case GL_RED_INTEGER_EXT:
1315 for (i=0;i<n;i++) {
1316 dst[i] = (GLuint) rgba[i][RCOMP];
1317 }
1318 break;
1319 case GL_GREEN_INTEGER_EXT:
1320 for (i=0;i<n;i++) {
1321 dst[i] = (GLuint) rgba[i][GCOMP];
1322 }
1323 break;
1324 case GL_BLUE_INTEGER_EXT:
1325 for (i=0;i<n;i++) {
1326 dst[i] = (GLuint) rgba[i][BCOMP];
1327 }
1328 break;
1329 case GL_ALPHA_INTEGER_EXT:
1330 for (i=0;i<n;i++) {
1331 dst[i] = (GLuint) rgba[i][ACOMP];
1332 }
1333 break;
1334 case GL_RG_INTEGER:
1335 for (i=0;i<n;i++) {
1336 dst[i*2+0] = (GLuint) rgba[i][RCOMP];
1337 dst[i*2+1] = (GLuint) rgba[i][GCOMP];
1338 }
1339 break;
1340 case GL_RGB_INTEGER_EXT:
1341 for (i=0;i<n;i++) {
1342 dst[i*3+0] = (GLuint) rgba[i][RCOMP];
1343 dst[i*3+1] = (GLuint) rgba[i][GCOMP];
1344 dst[i*3+2] = (GLuint) rgba[i][BCOMP];
1345 }
1346 break;
1347 case GL_RGBA_INTEGER_EXT:
1348 for (i=0;i<n;i++) {
1349 dst[i*4+0] = (GLuint) rgba[i][RCOMP];
1350 dst[i*4+1] = (GLuint) rgba[i][GCOMP];
1351 dst[i*4+2] = (GLuint) rgba[i][BCOMP];
1352 dst[i*4+3] = (GLuint) rgba[i][ACOMP];
1353 }
1354 break;
1355 case GL_BGR_INTEGER_EXT:
1356 for (i=0;i<n;i++) {
1357 dst[i*3+0] = (GLuint) rgba[i][BCOMP];
1358 dst[i*3+1] = (GLuint) rgba[i][GCOMP];
1359 dst[i*3+2] = (GLuint) rgba[i][RCOMP];
1360 }
1361 break;
1362 case GL_BGRA_INTEGER_EXT:
1363 for (i=0;i<n;i++) {
1364 dst[i*4+0] = (GLuint) rgba[i][BCOMP];
1365 dst[i*4+1] = (GLuint) rgba[i][GCOMP];
1366 dst[i*4+2] = (GLuint) rgba[i][RCOMP];
1367 dst[i*4+3] = (GLuint) rgba[i][ACOMP];
1368 }
1369 break;
1370 case GL_LUMINANCE_INTEGER_EXT:
1371 for (i=0;i<n;i++) {
1372 dst[i*2+0] = (GLuint) (rgba[i][RCOMP] +
1373 rgba[i][GCOMP] +
1374 rgba[i][BCOMP]);
1375 dst[i*2+1] = (GLuint) rgba[i][ACOMP];
1376 }
1377 break;
1378 case GL_LUMINANCE_ALPHA_INTEGER_EXT:
1379 for (i=0;i<n;i++) {
1380 dst[i] = (GLuint) (rgba[i][RCOMP] +
1381 rgba[i][GCOMP] +
1382 rgba[i][BCOMP]);
1383 }
1384 break;
1385 case GL_DUDV_ATI:
1386 case GL_DU8DV8_ATI:
1387 for (i=0;i<n;i++) {
1388 dst[i*2+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1389 dst[i*2+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1390 }
1391 break;
1392 default:
1393 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1394 }
1395 }
1396 break;
1397 case GL_INT:
1398 {
1399 GLint *dst = (GLint *) dstAddr;
1400 switch (dstFormat) {
1401 case GL_RED:
1402 for (i=0;i<n;i++)
1403 dst[i] = FLOAT_TO_INT(rgba[i][RCOMP]);
1404 break;
1405 case GL_GREEN:
1406 for (i=0;i<n;i++)
1407 dst[i] = FLOAT_TO_INT(rgba[i][GCOMP]);
1408 break;
1409 case GL_BLUE:
1410 for (i=0;i<n;i++)
1411 dst[i] = FLOAT_TO_INT(rgba[i][BCOMP]);
1412 break;
1413 case GL_ALPHA:
1414 for (i=0;i<n;i++)
1415 dst[i] = FLOAT_TO_INT(rgba[i][ACOMP]);
1416 break;
1417 case GL_LUMINANCE:
1418 for (i=0;i<n;i++)
1419 dst[i] = FLOAT_TO_INT(luminance[i]);
1420 break;
1421 case GL_LUMINANCE_ALPHA:
1422 for (i=0;i<n;i++) {
1423 dst[i*2+0] = FLOAT_TO_INT(luminance[i]);
1424 dst[i*2+1] = FLOAT_TO_INT(rgba[i][ACOMP]);
1425 }
1426 break;
1427 case GL_RG:
1428 for (i=0;i<n;i++) {
1429 dst[i*2+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
1430 dst[i*2+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1431 }
1432 break;
1433 case GL_RGB:
1434 for (i=0;i<n;i++) {
1435 dst[i*3+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
1436 dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1437 dst[i*3+2] = FLOAT_TO_INT(rgba[i][BCOMP]);
1438 }
1439 break;
1440 case GL_RGBA:
1441 for (i=0;i<n;i++) {
1442 dst[i*4+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
1443 dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1444 dst[i*4+2] = FLOAT_TO_INT(rgba[i][BCOMP]);
1445 dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);
1446 }
1447 break;
1448 case GL_BGR:
1449 for (i=0;i<n;i++) {
1450 dst[i*3+0] = FLOAT_TO_INT(rgba[i][BCOMP]);
1451 dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1452 dst[i*3+2] = FLOAT_TO_INT(rgba[i][RCOMP]);
1453 }
1454 break;
1455 case GL_BGRA:
1456 for (i=0;i<n;i++) {
1457 dst[i*4+0] = FLOAT_TO_INT(rgba[i][BCOMP]);
1458 dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1459 dst[i*4+2] = FLOAT_TO_INT(rgba[i][RCOMP]);
1460 dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);
1461 }
1462 break;
1463 case GL_ABGR_EXT:
1464 for (i=0;i<n;i++) {
1465 dst[i*4+0] = FLOAT_TO_INT(rgba[i][ACOMP]);
1466 dst[i*4+1] = FLOAT_TO_INT(rgba[i][BCOMP]);
1467 dst[i*4+2] = FLOAT_TO_INT(rgba[i][GCOMP]);
1468 dst[i*4+3] = FLOAT_TO_INT(rgba[i][RCOMP]);
1469 }
1470 break;
1471 case GL_DUDV_ATI:
1472 case GL_DU8DV8_ATI:
1473 for (i=0;i<n;i++) {
1474 dst[i*2+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
1475 dst[i*2+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1476 }
1477 break;
1478 case GL_RED_INTEGER_EXT:
1479 for (i=0;i<n;i++) {
1480 dst[i] = (GLint) rgba[i][RCOMP];
1481 }
1482 break;
1483 case GL_GREEN_INTEGER_EXT:
1484 for (i=0;i<n;i++) {
1485 dst[i] = (GLint) rgba[i][GCOMP];
1486 }
1487 break;
1488 case GL_BLUE_INTEGER_EXT:
1489 for (i=0;i<n;i++) {
1490 dst[i] = (GLint) rgba[i][BCOMP];
1491 }
1492 break;
1493 case GL_ALPHA_INTEGER_EXT:
1494 for (i=0;i<n;i++) {
1495 dst[i] = (GLint) rgba[i][ACOMP];
1496 }
1497 break;
1498 case GL_RG_INTEGER:
1499 for (i=0;i<n;i++) {
1500 dst[i*2+0] = (GLint) rgba[i][RCOMP];
1501 dst[i*2+1] = (GLint) rgba[i][GCOMP];
1502 }
1503 break;
1504 case GL_RGB_INTEGER_EXT:
1505 for (i=0;i<n;i++) {
1506 dst[i*3+0] = (GLint) rgba[i][RCOMP];
1507 dst[i*3+1] = (GLint) rgba[i][GCOMP];
1508 dst[i*3+2] = (GLint) rgba[i][BCOMP];
1509 }
1510 break;
1511 case GL_RGBA_INTEGER_EXT:
1512 for (i=0;i<n;i++) {
1513 dst[i*4+0] = (GLint) rgba[i][RCOMP];
1514 dst[i*4+1] = (GLint) rgba[i][GCOMP];
1515 dst[i*4+2] = (GLint) rgba[i][BCOMP];
1516 dst[i*4+3] = (GLint) rgba[i][ACOMP];
1517 }
1518 break;
1519 case GL_BGR_INTEGER_EXT:
1520 for (i=0;i<n;i++) {
1521 dst[i*3+0] = (GLint) rgba[i][BCOMP];
1522 dst[i*3+1] = (GLint) rgba[i][GCOMP];
1523 dst[i*3+2] = (GLint) rgba[i][RCOMP];
1524 }
1525 break;
1526 case GL_BGRA_INTEGER_EXT:
1527 for (i=0;i<n;i++) {
1528 dst[i*4+0] = (GLint) rgba[i][BCOMP];
1529 dst[i*4+1] = (GLint) rgba[i][GCOMP];
1530 dst[i*4+2] = (GLint) rgba[i][RCOMP];
1531 dst[i*4+3] = (GLint) rgba[i][ACOMP];
1532 }
1533 break;
1534 case GL_LUMINANCE_INTEGER_EXT:
1535 for (i=0;i<n;i++) {
1536 dst[i*2+0] = (GLint) (rgba[i][RCOMP] +
1537 rgba[i][GCOMP] +
1538 rgba[i][BCOMP]);
1539 dst[i*2+1] = (GLint) rgba[i][ACOMP];
1540 }
1541 break;
1542 case GL_LUMINANCE_ALPHA_INTEGER_EXT:
1543 for (i=0;i<n;i++) {
1544 dst[i] = (GLint) (rgba[i][RCOMP] +
1545 rgba[i][GCOMP] +
1546 rgba[i][BCOMP]);
1547 }
1548 break;
1549 default:
1550 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1551 }
1552 }
1553 break;
1554 case GL_FLOAT:
1555 {
1556 GLfloat *dst = (GLfloat *) dstAddr;
1557 switch (dstFormat) {
1558 case GL_RED:
1559 for (i=0;i<n;i++)
1560 dst[i] = rgba[i][RCOMP];
1561 break;
1562 case GL_GREEN:
1563 for (i=0;i<n;i++)
1564 dst[i] = rgba[i][GCOMP];
1565 break;
1566 case GL_BLUE:
1567 for (i=0;i<n;i++)
1568 dst[i] = rgba[i][BCOMP];
1569 break;
1570 case GL_ALPHA:
1571 for (i=0;i<n;i++)
1572 dst[i] = rgba[i][ACOMP];
1573 break;
1574 case GL_LUMINANCE:
1575 for (i=0;i<n;i++)
1576 dst[i] = luminance[i];
1577 break;
1578 case GL_LUMINANCE_ALPHA:
1579 for (i=0;i<n;i++) {
1580 dst[i*2+0] = luminance[i];
1581 dst[i*2+1] = rgba[i][ACOMP];
1582 }
1583 break;
1584 case GL_RG:
1585 for (i=0;i<n;i++) {
1586 dst[i*2+0] = rgba[i][RCOMP];
1587 dst[i*2+1] = rgba[i][GCOMP];
1588 }
1589 break;
1590 case GL_RGB:
1591 for (i=0;i<n;i++) {
1592 dst[i*3+0] = rgba[i][RCOMP];
1593 dst[i*3+1] = rgba[i][GCOMP];
1594 dst[i*3+2] = rgba[i][BCOMP];
1595 }
1596 break;
1597 case GL_RGBA:
1598 for (i=0;i<n;i++) {
1599 dst[i*4+0] = rgba[i][RCOMP];
1600 dst[i*4+1] = rgba[i][GCOMP];
1601 dst[i*4+2] = rgba[i][BCOMP];
1602 dst[i*4+3] = rgba[i][ACOMP];
1603 }
1604 break;
1605 case GL_BGR:
1606 for (i=0;i<n;i++) {
1607 dst[i*3+0] = rgba[i][BCOMP];
1608 dst[i*3+1] = rgba[i][GCOMP];
1609 dst[i*3+2] = rgba[i][RCOMP];
1610 }
1611 break;
1612 case GL_BGRA:
1613 for (i=0;i<n;i++) {
1614 dst[i*4+0] = rgba[i][BCOMP];
1615 dst[i*4+1] = rgba[i][GCOMP];
1616 dst[i*4+2] = rgba[i][RCOMP];
1617 dst[i*4+3] = rgba[i][ACOMP];
1618 }
1619 break;
1620 case GL_ABGR_EXT:
1621 for (i=0;i<n;i++) {
1622 dst[i*4+0] = rgba[i][ACOMP];
1623 dst[i*4+1] = rgba[i][BCOMP];
1624 dst[i*4+2] = rgba[i][GCOMP];
1625 dst[i*4+3] = rgba[i][RCOMP];
1626 }
1627 break;
1628 case GL_DUDV_ATI:
1629 case GL_DU8DV8_ATI:
1630 for (i=0;i<n;i++) {
1631 dst[i*2+0] = rgba[i][RCOMP];
1632 dst[i*2+1] = rgba[i][GCOMP];
1633 }
1634 break;
1635 default:
1636 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1637 }
1638 }
1639 break;
1640 case GL_HALF_FLOAT_ARB:
1641 {
1642 GLhalfARB *dst = (GLhalfARB *) dstAddr;
1643 switch (dstFormat) {
1644 case GL_RED:
1645 for (i=0;i<n;i++)
1646 dst[i] = _mesa_float_to_half(rgba[i][RCOMP]);
1647 break;
1648 case GL_GREEN:
1649 for (i=0;i<n;i++)
1650 dst[i] = _mesa_float_to_half(rgba[i][GCOMP]);
1651 break;
1652 case GL_BLUE:
1653 for (i=0;i<n;i++)
1654 dst[i] = _mesa_float_to_half(rgba[i][BCOMP]);
1655 break;
1656 case GL_ALPHA:
1657 for (i=0;i<n;i++)
1658 dst[i] = _mesa_float_to_half(rgba[i][ACOMP]);
1659 break;
1660 case GL_LUMINANCE:
1661 for (i=0;i<n;i++)
1662 dst[i] = _mesa_float_to_half(luminance[i]);
1663 break;
1664 case GL_LUMINANCE_ALPHA:
1665 for (i=0;i<n;i++) {
1666 dst[i*2+0] = _mesa_float_to_half(luminance[i]);
1667 dst[i*2+1] = _mesa_float_to_half(rgba[i][ACOMP]);
1668 }
1669 break;
1670 case GL_RG:
1671 for (i=0;i<n;i++) {
1672 dst[i*2+0] = _mesa_float_to_half(rgba[i][RCOMP]);
1673 dst[i*2+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1674 }
1675 break;
1676 case GL_RGB:
1677 for (i=0;i<n;i++) {
1678 dst[i*3+0] = _mesa_float_to_half(rgba[i][RCOMP]);
1679 dst[i*3+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1680 dst[i*3+2] = _mesa_float_to_half(rgba[i][BCOMP]);
1681 }
1682 break;
1683 case GL_RGBA:
1684 for (i=0;i<n;i++) {
1685 dst[i*4+0] = _mesa_float_to_half(rgba[i][RCOMP]);
1686 dst[i*4+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1687 dst[i*4+2] = _mesa_float_to_half(rgba[i][BCOMP]);
1688 dst[i*4+3] = _mesa_float_to_half(rgba[i][ACOMP]);
1689 }
1690 break;
1691 case GL_BGR:
1692 for (i=0;i<n;i++) {
1693 dst[i*3+0] = _mesa_float_to_half(rgba[i][BCOMP]);
1694 dst[i*3+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1695 dst[i*3+2] = _mesa_float_to_half(rgba[i][RCOMP]);
1696 }
1697 break;
1698 case GL_BGRA:
1699 for (i=0;i<n;i++) {
1700 dst[i*4+0] = _mesa_float_to_half(rgba[i][BCOMP]);
1701 dst[i*4+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1702 dst[i*4+2] = _mesa_float_to_half(rgba[i][RCOMP]);
1703 dst[i*4+3] = _mesa_float_to_half(rgba[i][ACOMP]);
1704 }
1705 break;
1706 case GL_ABGR_EXT:
1707 for (i=0;i<n;i++) {
1708 dst[i*4+0] = _mesa_float_to_half(rgba[i][ACOMP]);
1709 dst[i*4+1] = _mesa_float_to_half(rgba[i][BCOMP]);
1710 dst[i*4+2] = _mesa_float_to_half(rgba[i][GCOMP]);
1711 dst[i*4+3] = _mesa_float_to_half(rgba[i][RCOMP]);
1712 }
1713 break;
1714 case GL_DUDV_ATI:
1715 case GL_DU8DV8_ATI:
1716 for (i=0;i<n;i++) {
1717 dst[i*2+0] = _mesa_float_to_half(rgba[i][RCOMP]);
1718 dst[i*2+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1719 }
1720 break;
1721 default:
1722 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1723 }
1724 }
1725 break;
1726 case GL_UNSIGNED_BYTE_3_3_2:
1727 if (dstFormat == GL_RGB) {
1728 GLubyte *dst = (GLubyte *) dstAddr;
1729 for (i=0;i<n;i++) {
1730 dst[i] = (IROUND(rgba[i][RCOMP] * 7.0F) << 5)
1731 | (IROUND(rgba[i][GCOMP] * 7.0F) << 2)
1732 | (IROUND(rgba[i][BCOMP] * 3.0F) );
1733 }
1734 }
1735 break;
1736 case GL_UNSIGNED_BYTE_2_3_3_REV:
1737 if (dstFormat == GL_RGB) {
1738 GLubyte *dst = (GLubyte *) dstAddr;
1739 for (i=0;i<n;i++) {
1740 dst[i] = (IROUND(rgba[i][RCOMP] * 7.0F) )
1741 | (IROUND(rgba[i][GCOMP] * 7.0F) << 3)
1742 | (IROUND(rgba[i][BCOMP] * 3.0F) << 6);
1743 }
1744 }
1745 break;
1746 case GL_UNSIGNED_SHORT_5_6_5:
1747 if (dstFormat == GL_RGB) {
1748 GLushort *dst = (GLushort *) dstAddr;
1749 for (i=0;i<n;i++) {
1750 dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F) << 11)
1751 | (IROUND(rgba[i][GCOMP] * 63.0F) << 5)
1752 | (IROUND(rgba[i][BCOMP] * 31.0F) );
1753 }
1754 }
1755 break;
1756 case GL_UNSIGNED_SHORT_5_6_5_REV:
1757 if (dstFormat == GL_RGB) {
1758 GLushort *dst = (GLushort *) dstAddr;
1759 for (i=0;i<n;i++) {
1760 dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F) )
1761 | (IROUND(rgba[i][GCOMP] * 63.0F) << 5)
1762 | (IROUND(rgba[i][BCOMP] * 31.0F) << 11);
1763 }
1764 }
1765 break;
1766 case GL_UNSIGNED_SHORT_4_4_4_4:
1767 if (dstFormat == GL_RGBA) {
1768 GLushort *dst = (GLushort *) dstAddr;
1769 for (i=0;i<n;i++) {
1770 dst[i] = (IROUND(rgba[i][RCOMP] * 15.0F) << 12)
1771 | (IROUND(rgba[i][GCOMP] * 15.0F) << 8)
1772 | (IROUND(rgba[i][BCOMP] * 15.0F) << 4)
1773 | (IROUND(rgba[i][ACOMP] * 15.0F) );
1774 }
1775 }
1776 else if (dstFormat == GL_BGRA) {
1777 GLushort *dst = (GLushort *) dstAddr;
1778 for (i=0;i<n;i++) {
1779 dst[i] = (IROUND(rgba[i][BCOMP] * 15.0F) << 12)
1780 | (IROUND(rgba[i][GCOMP] * 15.0F) << 8)
1781 | (IROUND(rgba[i][RCOMP] * 15.0F) << 4)
1782 | (IROUND(rgba[i][ACOMP] * 15.0F) );
1783 }
1784 }
1785 else if (dstFormat == GL_ABGR_EXT) {
1786 GLushort *dst = (GLushort *) dstAddr;
1787 for (i=0;i<n;i++) {
1788 dst[i] = (IROUND(rgba[i][ACOMP] * 15.0F) << 12)
1789 | (IROUND(rgba[i][BCOMP] * 15.0F) << 8)
1790 | (IROUND(rgba[i][GCOMP] * 15.0F) << 4)
1791 | (IROUND(rgba[i][RCOMP] * 15.0F) );
1792 }
1793 }
1794 break;
1795 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1796 if (dstFormat == GL_RGBA) {
1797 GLushort *dst = (GLushort *) dstAddr;
1798 for (i=0;i<n;i++) {
1799 dst[i] = (IROUND(rgba[i][RCOMP] * 15.0F) )
1800 | (IROUND(rgba[i][GCOMP] * 15.0F) << 4)
1801 | (IROUND(rgba[i][BCOMP] * 15.0F) << 8)
1802 | (IROUND(rgba[i][ACOMP] * 15.0F) << 12);
1803 }
1804 }
1805 else if (dstFormat == GL_BGRA) {
1806 GLushort *dst = (GLushort *) dstAddr;
1807 for (i=0;i<n;i++) {
1808 dst[i] = (IROUND(rgba[i][BCOMP] * 15.0F) )
1809 | (IROUND(rgba[i][GCOMP] * 15.0F) << 4)
1810 | (IROUND(rgba[i][RCOMP] * 15.0F) << 8)
1811 | (IROUND(rgba[i][ACOMP] * 15.0F) << 12);
1812 }
1813 }
1814 else if (dstFormat == GL_ABGR_EXT) {
1815 GLushort *dst = (GLushort *) dstAddr;
1816 for (i=0;i<n;i++) {
1817 dst[i] = (IROUND(rgba[i][ACOMP] * 15.0F) )
1818 | (IROUND(rgba[i][BCOMP] * 15.0F) << 4)
1819 | (IROUND(rgba[i][GCOMP] * 15.0F) << 8)
1820 | (IROUND(rgba[i][RCOMP] * 15.0F) << 12);
1821 }
1822 }
1823 break;
1824 case GL_UNSIGNED_SHORT_5_5_5_1:
1825 if (dstFormat == GL_RGBA) {
1826 GLushort *dst = (GLushort *) dstAddr;
1827 for (i=0;i<n;i++) {
1828 dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F) << 11)
1829 | (IROUND(rgba[i][GCOMP] * 31.0F) << 6)
1830 | (IROUND(rgba[i][BCOMP] * 31.0F) << 1)
1831 | (IROUND(rgba[i][ACOMP] * 1.0F) );
1832 }
1833 }
1834 else if (dstFormat == GL_BGRA) {
1835 GLushort *dst = (GLushort *) dstAddr;
1836 for (i=0;i<n;i++) {
1837 dst[i] = (IROUND(rgba[i][BCOMP] * 31.0F) << 11)
1838 | (IROUND(rgba[i][GCOMP] * 31.0F) << 6)
1839 | (IROUND(rgba[i][RCOMP] * 31.0F) << 1)
1840 | (IROUND(rgba[i][ACOMP] * 1.0F) );
1841 }
1842 }
1843 else if (dstFormat == GL_ABGR_EXT) {
1844 GLushort *dst = (GLushort *) dstAddr;
1845 for (i=0;i<n;i++) {
1846 dst[i] = (IROUND(rgba[i][ACOMP] * 31.0F) << 11)
1847 | (IROUND(rgba[i][BCOMP] * 31.0F) << 6)
1848 | (IROUND(rgba[i][GCOMP] * 31.0F) << 1)
1849 | (IROUND(rgba[i][RCOMP] * 1.0F) );
1850 }
1851 }
1852 break;
1853 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1854 if (dstFormat == GL_RGBA) {
1855 GLushort *dst = (GLushort *) dstAddr;
1856 for (i=0;i<n;i++) {
1857 dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F) )
1858 | (IROUND(rgba[i][GCOMP] * 31.0F) << 5)
1859 | (IROUND(rgba[i][BCOMP] * 31.0F) << 10)
1860 | (IROUND(rgba[i][ACOMP] * 1.0F) << 15);
1861 }
1862 }
1863 else if (dstFormat == GL_BGRA) {
1864 GLushort *dst = (GLushort *) dstAddr;
1865 for (i=0;i<n;i++) {
1866 dst[i] = (IROUND(rgba[i][BCOMP] * 31.0F) )
1867 | (IROUND(rgba[i][GCOMP] * 31.0F) << 5)
1868 | (IROUND(rgba[i][RCOMP] * 31.0F) << 10)
1869 | (IROUND(rgba[i][ACOMP] * 1.0F) << 15);
1870 }
1871 }
1872 else if (dstFormat == GL_ABGR_EXT) {
1873 GLushort *dst = (GLushort *) dstAddr;
1874 for (i=0;i<n;i++) {
1875 dst[i] = (IROUND(rgba[i][ACOMP] * 31.0F) )
1876 | (IROUND(rgba[i][BCOMP] * 31.0F) << 5)
1877 | (IROUND(rgba[i][GCOMP] * 31.0F) << 10)
1878 | (IROUND(rgba[i][RCOMP] * 1.0F) << 15);
1879 }
1880 }
1881 break;
1882 case GL_UNSIGNED_INT_8_8_8_8:
1883 if (dstFormat == GL_RGBA) {
1884 GLuint *dst = (GLuint *) dstAddr;
1885 for (i=0;i<n;i++) {
1886 dst[i] = (IROUND(rgba[i][RCOMP] * 255.F) << 24)
1887 | (IROUND(rgba[i][GCOMP] * 255.F) << 16)
1888 | (IROUND(rgba[i][BCOMP] * 255.F) << 8)
1889 | (IROUND(rgba[i][ACOMP] * 255.F) );
1890 }
1891 }
1892 else if (dstFormat == GL_BGRA) {
1893 GLuint *dst = (GLuint *) dstAddr;
1894 for (i=0;i<n;i++) {
1895 dst[i] = (IROUND(rgba[i][BCOMP] * 255.F) << 24)
1896 | (IROUND(rgba[i][GCOMP] * 255.F) << 16)
1897 | (IROUND(rgba[i][RCOMP] * 255.F) << 8)
1898 | (IROUND(rgba[i][ACOMP] * 255.F) );
1899 }
1900 }
1901 else if (dstFormat == GL_ABGR_EXT) {
1902 GLuint *dst = (GLuint *) dstAddr;
1903 for (i=0;i<n;i++) {
1904 dst[i] = (IROUND(rgba[i][ACOMP] * 255.F) << 24)
1905 | (IROUND(rgba[i][BCOMP] * 255.F) << 16)
1906 | (IROUND(rgba[i][GCOMP] * 255.F) << 8)
1907 | (IROUND(rgba[i][RCOMP] * 255.F) );
1908 }
1909 }
1910 break;
1911 case GL_UNSIGNED_INT_8_8_8_8_REV:
1912 if (dstFormat == GL_RGBA) {
1913 GLuint *dst = (GLuint *) dstAddr;
1914 for (i=0;i<n;i++) {
1915 dst[i] = (IROUND(rgba[i][RCOMP] * 255.0F) )
1916 | (IROUND(rgba[i][GCOMP] * 255.0F) << 8)
1917 | (IROUND(rgba[i][BCOMP] * 255.0F) << 16)
1918 | (IROUND(rgba[i][ACOMP] * 255.0F) << 24);
1919 }
1920 }
1921 else if (dstFormat == GL_BGRA) {
1922 GLuint *dst = (GLuint *) dstAddr;
1923 for (i=0;i<n;i++) {
1924 dst[i] = (IROUND(rgba[i][BCOMP] * 255.0F) )
1925 | (IROUND(rgba[i][GCOMP] * 255.0F) << 8)
1926 | (IROUND(rgba[i][RCOMP] * 255.0F) << 16)
1927 | (IROUND(rgba[i][ACOMP] * 255.0F) << 24);
1928 }
1929 }
1930 else if (dstFormat == GL_ABGR_EXT) {
1931 GLuint *dst = (GLuint *) dstAddr;
1932 for (i=0;i<n;i++) {
1933 dst[i] = (IROUND(rgba[i][ACOMP] * 255.0F) )
1934 | (IROUND(rgba[i][BCOMP] * 255.0F) << 8)
1935 | (IROUND(rgba[i][GCOMP] * 255.0F) << 16)
1936 | (IROUND(rgba[i][RCOMP] * 255.0F) << 24);
1937 }
1938 }
1939 break;
1940 case GL_UNSIGNED_INT_10_10_10_2:
1941 if (dstFormat == GL_RGBA) {
1942 GLuint *dst = (GLuint *) dstAddr;
1943 for (i=0;i<n;i++) {
1944 dst[i] = (IROUND(rgba[i][RCOMP] * 1023.0F) << 22)
1945 | (IROUND(rgba[i][GCOMP] * 1023.0F) << 12)
1946 | (IROUND(rgba[i][BCOMP] * 1023.0F) << 2)
1947 | (IROUND(rgba[i][ACOMP] * 3.0F) );
1948 }
1949 }
1950 else if (dstFormat == GL_BGRA) {
1951 GLuint *dst = (GLuint *) dstAddr;
1952 for (i=0;i<n;i++) {
1953 dst[i] = (IROUND(rgba[i][BCOMP] * 1023.0F) << 22)
1954 | (IROUND(rgba[i][GCOMP] * 1023.0F) << 12)
1955 | (IROUND(rgba[i][RCOMP] * 1023.0F) << 2)
1956 | (IROUND(rgba[i][ACOMP] * 3.0F) );
1957 }
1958 }
1959 else if (dstFormat == GL_ABGR_EXT) {
1960 GLuint *dst = (GLuint *) dstAddr;
1961 for (i=0;i<n;i++) {
1962 dst[i] = (IROUND(rgba[i][ACOMP] * 1023.0F) << 22)
1963 | (IROUND(rgba[i][BCOMP] * 1023.0F) << 12)
1964 | (IROUND(rgba[i][GCOMP] * 1023.0F) << 2)
1965 | (IROUND(rgba[i][RCOMP] * 3.0F) );
1966 }
1967 }
1968 break;
1969 case GL_UNSIGNED_INT_2_10_10_10_REV:
1970 if (dstFormat == GL_RGBA) {
1971 GLuint *dst = (GLuint *) dstAddr;
1972 for (i=0;i<n;i++) {
1973 dst[i] = (IROUND(rgba[i][RCOMP] * 1023.0F) )
1974 | (IROUND(rgba[i][GCOMP] * 1023.0F) << 10)
1975 | (IROUND(rgba[i][BCOMP] * 1023.0F) << 20)
1976 | (IROUND(rgba[i][ACOMP] * 3.0F) << 30);
1977 }
1978 }
1979 else if (dstFormat == GL_BGRA) {
1980 GLuint *dst = (GLuint *) dstAddr;
1981 for (i=0;i<n;i++) {
1982 dst[i] = (IROUND(rgba[i][BCOMP] * 1023.0F) )
1983 | (IROUND(rgba[i][GCOMP] * 1023.0F) << 10)
1984 | (IROUND(rgba[i][RCOMP] * 1023.0F) << 20)
1985 | (IROUND(rgba[i][ACOMP] * 3.0F) << 30);
1986 }
1987 }
1988 else if (dstFormat == GL_ABGR_EXT) {
1989 GLuint *dst = (GLuint *) dstAddr;
1990 for (i=0;i<n;i++) {
1991 dst[i] = (IROUND(rgba[i][ACOMP] * 1023.0F) )
1992 | (IROUND(rgba[i][BCOMP] * 1023.0F) << 10)
1993 | (IROUND(rgba[i][GCOMP] * 1023.0F) << 20)
1994 | (IROUND(rgba[i][RCOMP] * 3.0F) << 30);
1995 }
1996 }
1997 break;
1998 case GL_UNSIGNED_INT_5_9_9_9_REV:
1999 {
2000 GLuint *dst = (GLuint *) dstAddr;
2001 for (i = 0; i < n; i++) {
2002 dst[i] = float3_to_rgb9e5(rgba[i]);
2003 }
2004 }
2005 break;
2006 case GL_UNSIGNED_INT_10F_11F_11F_REV:
2007 {
2008 GLuint *dst = (GLuint *) dstAddr;
2009 for (i = 0; i < n; i++) {
2010 dst[i] = float3_to_r11g11b10f(rgba[i]);
2011 }
2012 }
2013 break;
2014 default:
2015 _mesa_problem(ctx, "bad type in _mesa_pack_rgba_span_float");
2016 free(luminance);
2017 return;
2018 }
2019
2020 if (dstPacking->SwapBytes) {
2021 GLint swapSize = _mesa_sizeof_packed_type(dstType);
2022 if (swapSize == 2) {
2023 _mesa_swap2((GLushort *) dstAddr, n * comps);
2024 }
2025 else if (swapSize == 4) {
2026 _mesa_swap4((GLuint *) dstAddr, n * comps);
2027 }
2028 }
2029
2030 free(luminance);
2031 }
2032
2033
2034
2035 #define SWAP2BYTE(VALUE) \
2036 { \
2037 GLubyte *bytes = (GLubyte *) &(VALUE); \
2038 GLubyte tmp = bytes[0]; \
2039 bytes[0] = bytes[1]; \
2040 bytes[1] = tmp; \
2041 }
2042
2043 #define SWAP4BYTE(VALUE) \
2044 { \
2045 GLubyte *bytes = (GLubyte *) &(VALUE); \
2046 GLubyte tmp = bytes[0]; \
2047 bytes[0] = bytes[3]; \
2048 bytes[3] = tmp; \
2049 tmp = bytes[1]; \
2050 bytes[1] = bytes[2]; \
2051 bytes[2] = tmp; \
2052 }
2053
2054
2055 static void
2056 extract_uint_indexes(GLuint n, GLuint indexes[],
2057 GLenum srcFormat, GLenum srcType, const GLvoid *src,
2058 const struct gl_pixelstore_attrib *unpack )
2059 {
2060 ASSERT(srcFormat == GL_COLOR_INDEX || srcFormat == GL_STENCIL_INDEX);
2061
2062 ASSERT(srcType == GL_BITMAP ||
2063 srcType == GL_UNSIGNED_BYTE ||
2064 srcType == GL_BYTE ||
2065 srcType == GL_UNSIGNED_SHORT ||
2066 srcType == GL_SHORT ||
2067 srcType == GL_UNSIGNED_INT ||
2068 srcType == GL_INT ||
2069 srcType == GL_UNSIGNED_INT_24_8_EXT ||
2070 srcType == GL_HALF_FLOAT_ARB ||
2071 srcType == GL_FLOAT ||
2072 srcType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
2073
2074 switch (srcType) {
2075 case GL_BITMAP:
2076 {
2077 GLubyte *ubsrc = (GLubyte *) src;
2078 if (unpack->LsbFirst) {
2079 GLubyte mask = 1 << (unpack->SkipPixels & 0x7);
2080 GLuint i;
2081 for (i = 0; i < n; i++) {
2082 indexes[i] = (*ubsrc & mask) ? 1 : 0;
2083 if (mask == 128) {
2084 mask = 1;
2085 ubsrc++;
2086 }
2087 else {
2088 mask = mask << 1;
2089 }
2090 }
2091 }
2092 else {
2093 GLubyte mask = 128 >> (unpack->SkipPixels & 0x7);
2094 GLuint i;
2095 for (i = 0; i < n; i++) {
2096 indexes[i] = (*ubsrc & mask) ? 1 : 0;
2097 if (mask == 1) {
2098 mask = 128;
2099 ubsrc++;
2100 }
2101 else {
2102 mask = mask >> 1;
2103 }
2104 }
2105 }
2106 }
2107 break;
2108 case GL_UNSIGNED_BYTE:
2109 {
2110 GLuint i;
2111 const GLubyte *s = (const GLubyte *) src;
2112 for (i = 0; i < n; i++)
2113 indexes[i] = s[i];
2114 }
2115 break;
2116 case GL_BYTE:
2117 {
2118 GLuint i;
2119 const GLbyte *s = (const GLbyte *) src;
2120 for (i = 0; i < n; i++)
2121 indexes[i] = s[i];
2122 }
2123 break;
2124 case GL_UNSIGNED_SHORT:
2125 {
2126 GLuint i;
2127 const GLushort *s = (const GLushort *) src;
2128 if (unpack->SwapBytes) {
2129 for (i = 0; i < n; i++) {
2130 GLushort value = s[i];
2131 SWAP2BYTE(value);
2132 indexes[i] = value;
2133 }
2134 }
2135 else {
2136 for (i = 0; i < n; i++)
2137 indexes[i] = s[i];
2138 }
2139 }
2140 break;
2141 case GL_SHORT:
2142 {
2143 GLuint i;
2144 const GLshort *s = (const GLshort *) src;
2145 if (unpack->SwapBytes) {
2146 for (i = 0; i < n; i++) {
2147 GLshort value = s[i];
2148 SWAP2BYTE(value);
2149 indexes[i] = value;
2150 }
2151 }
2152 else {
2153 for (i = 0; i < n; i++)
2154 indexes[i] = s[i];
2155 }
2156 }
2157 break;
2158 case GL_UNSIGNED_INT:
2159 {
2160 GLuint i;
2161 const GLuint *s = (const GLuint *) src;
2162 if (unpack->SwapBytes) {
2163 for (i = 0; i < n; i++) {
2164 GLuint value = s[i];
2165 SWAP4BYTE(value);
2166 indexes[i] = value;
2167 }
2168 }
2169 else {
2170 for (i = 0; i < n; i++)
2171 indexes[i] = s[i];
2172 }
2173 }
2174 break;
2175 case GL_INT:
2176 {
2177 GLuint i;
2178 const GLint *s = (const GLint *) src;
2179 if (unpack->SwapBytes) {
2180 for (i = 0; i < n; i++) {
2181 GLint value = s[i];
2182 SWAP4BYTE(value);
2183 indexes[i] = value;
2184 }
2185 }
2186 else {
2187 for (i = 0; i < n; i++)
2188 indexes[i] = s[i];
2189 }
2190 }
2191 break;
2192 case GL_FLOAT:
2193 {
2194 GLuint i;
2195 const GLfloat *s = (const GLfloat *) src;
2196 if (unpack->SwapBytes) {
2197 for (i = 0; i < n; i++) {
2198 GLfloat value = s[i];
2199 SWAP4BYTE(value);
2200 indexes[i] = (GLuint) value;
2201 }
2202 }
2203 else {
2204 for (i = 0; i < n; i++)
2205 indexes[i] = (GLuint) s[i];
2206 }
2207 }
2208 break;
2209 case GL_HALF_FLOAT_ARB:
2210 {
2211 GLuint i;
2212 const GLhalfARB *s = (const GLhalfARB *) src;
2213 if (unpack->SwapBytes) {
2214 for (i = 0; i < n; i++) {
2215 GLhalfARB value = s[i];
2216 SWAP2BYTE(value);
2217 indexes[i] = (GLuint) _mesa_half_to_float(value);
2218 }
2219 }
2220 else {
2221 for (i = 0; i < n; i++)
2222 indexes[i] = (GLuint) _mesa_half_to_float(s[i]);
2223 }
2224 }
2225 break;
2226 case GL_UNSIGNED_INT_24_8_EXT:
2227 {
2228 GLuint i;
2229 const GLuint *s = (const GLuint *) src;
2230 if (unpack->SwapBytes) {
2231 for (i = 0; i < n; i++) {
2232 GLuint value = s[i];
2233 SWAP4BYTE(value);
2234 indexes[i] = value & 0xff; /* lower 8 bits */
2235 }
2236 }
2237 else {
2238 for (i = 0; i < n; i++)
2239 indexes[i] = s[i] & 0xff; /* lower 8 bits */
2240 }
2241 }
2242 break;
2243 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
2244 {
2245 GLuint i;
2246 const GLuint *s = (const GLuint *) src;
2247 if (unpack->SwapBytes) {
2248 for (i = 0; i < n; i++) {
2249 GLuint value = s[i*2+1];
2250 SWAP4BYTE(value);
2251 indexes[i] = value & 0xff; /* lower 8 bits */
2252 }
2253 }
2254 else {
2255 for (i = 0; i < n; i++)
2256 indexes[i] = s[i*2+1] & 0xff; /* lower 8 bits */
2257 }
2258 }
2259 break;
2260
2261 default:
2262 _mesa_problem(NULL, "bad srcType in extract_uint_indexes");
2263 return;
2264 }
2265 }
2266
2267
2268 /**
2269 * Return source/dest RGBA indexes for unpacking pixels.
2270 */
2271 static void
2272 get_component_mapping(GLenum format,
2273 GLint *rSrc,
2274 GLint *gSrc,
2275 GLint *bSrc,
2276 GLint *aSrc,
2277 GLint *rDst,
2278 GLint *gDst,
2279 GLint *bDst,
2280 GLint *aDst)
2281 {
2282 switch (format) {
2283 case GL_RED:
2284 case GL_RED_INTEGER_EXT:
2285 *rSrc = 0;
2286 *gSrc = *bSrc = *aSrc = -1;
2287 break;
2288 case GL_GREEN:
2289 case GL_GREEN_INTEGER_EXT:
2290 *gSrc = 0;
2291 *rSrc = *bSrc = *aSrc = -1;
2292 break;
2293 case GL_BLUE:
2294 case GL_BLUE_INTEGER_EXT:
2295 *bSrc = 0;
2296 *rSrc = *gSrc = *aSrc = -1;
2297 break;
2298 case GL_ALPHA:
2299 case GL_ALPHA_INTEGER_EXT:
2300 *rSrc = *gSrc = *bSrc = -1;
2301 *aSrc = 0;
2302 break;
2303 case GL_LUMINANCE:
2304 case GL_LUMINANCE_INTEGER_EXT:
2305 *rSrc = *gSrc = *bSrc = 0;
2306 *aSrc = -1;
2307 break;
2308 case GL_LUMINANCE_ALPHA:
2309 case GL_LUMINANCE_ALPHA_INTEGER_EXT:
2310 *rSrc = *gSrc = *bSrc = 0;
2311 *aSrc = 1;
2312 break;
2313 case GL_INTENSITY:
2314 *rSrc = *gSrc = *bSrc = *aSrc = 0;
2315 break;
2316 case GL_RG:
2317 case GL_RG_INTEGER:
2318 *rSrc = 0;
2319 *gSrc = 1;
2320 *bSrc = -1;
2321 *aSrc = -1;
2322 *rDst = 0;
2323 *gDst = 1;
2324 *bDst = 2;
2325 *aDst = 3;
2326 break;
2327 case GL_RGB:
2328 case GL_RGB_INTEGER:
2329 *rSrc = 0;
2330 *gSrc = 1;
2331 *bSrc = 2;
2332 *aSrc = -1;
2333 *rDst = 0;
2334 *gDst = 1;
2335 *bDst = 2;
2336 *aDst = 3;
2337 break;
2338 case GL_BGR:
2339 case GL_BGR_INTEGER:
2340 *rSrc = 2;
2341 *gSrc = 1;
2342 *bSrc = 0;
2343 *aSrc = -1;
2344 *rDst = 2;
2345 *gDst = 1;
2346 *bDst = 0;
2347 *aDst = 3;
2348 break;
2349 case GL_RGBA:
2350 case GL_RGBA_INTEGER:
2351 *rSrc = 0;
2352 *gSrc = 1;
2353 *bSrc = 2;
2354 *aSrc = 3;
2355 *rDst = 0;
2356 *gDst = 1;
2357 *bDst = 2;
2358 *aDst = 3;
2359 break;
2360 case GL_BGRA:
2361 case GL_BGRA_INTEGER:
2362 *rSrc = 2;
2363 *gSrc = 1;
2364 *bSrc = 0;
2365 *aSrc = 3;
2366 *rDst = 2;
2367 *gDst = 1;
2368 *bDst = 0;
2369 *aDst = 3;
2370 break;
2371 case GL_ABGR_EXT:
2372 *rSrc = 3;
2373 *gSrc = 2;
2374 *bSrc = 1;
2375 *aSrc = 0;
2376 *rDst = 3;
2377 *gDst = 2;
2378 *bDst = 1;
2379 *aDst = 0;
2380 break;
2381 case GL_DU8DV8_ATI:
2382 case GL_DUDV_ATI:
2383 *rSrc = 0;
2384 *gSrc = 1;
2385 *bSrc = -1;
2386 *aSrc = -1;
2387 break;
2388 default:
2389 _mesa_problem(NULL, "bad srcFormat %s in get_component_mapping",
2390 _mesa_lookup_enum_by_nr(format));
2391 return;
2392 }
2393 }
2394
2395
2396
2397 /*
2398 * This function extracts floating point RGBA values from arbitrary
2399 * image data. srcFormat and srcType are the format and type parameters
2400 * passed to glDrawPixels, glTexImage[123]D, glTexSubImage[123]D, etc.
2401 *
2402 * Refering to section 3.6.4 of the OpenGL 1.2 spec, this function
2403 * implements the "Conversion to floating point", "Conversion to RGB",
2404 * and "Final Expansion to RGBA" operations.
2405 *
2406 * Args: n - number of pixels
2407 * rgba - output colors
2408 * srcFormat - format of incoming data
2409 * srcType - data type of incoming data
2410 * src - source data pointer
2411 * swapBytes - perform byteswapping of incoming data?
2412 */
2413 static void
2414 extract_float_rgba(GLuint n, GLfloat rgba[][4],
2415 GLenum srcFormat, GLenum srcType, const GLvoid *src,
2416 GLboolean swapBytes)
2417 {
2418 GLint rSrc, gSrc, bSrc, aSrc;
2419 GLint stride;
2420 GLint rDst, bDst, gDst, aDst;
2421 GLboolean intFormat;
2422 GLfloat rs = 1.0f, gs = 1.0f, bs = 1.0f, as = 1.0f; /* scale factors */
2423
2424 ASSERT(srcFormat == GL_RED ||
2425 srcFormat == GL_GREEN ||
2426 srcFormat == GL_BLUE ||
2427 srcFormat == GL_ALPHA ||
2428 srcFormat == GL_LUMINANCE ||
2429 srcFormat == GL_LUMINANCE_ALPHA ||
2430 srcFormat == GL_INTENSITY ||
2431 srcFormat == GL_RG ||
2432 srcFormat == GL_RGB ||
2433 srcFormat == GL_BGR ||
2434 srcFormat == GL_RGBA ||
2435 srcFormat == GL_BGRA ||
2436 srcFormat == GL_ABGR_EXT ||
2437 srcFormat == GL_DU8DV8_ATI ||
2438 srcFormat == GL_DUDV_ATI ||
2439 srcFormat == GL_RED_INTEGER_EXT ||
2440 srcFormat == GL_GREEN_INTEGER_EXT ||
2441 srcFormat == GL_BLUE_INTEGER_EXT ||
2442 srcFormat == GL_ALPHA_INTEGER_EXT ||
2443 srcFormat == GL_RG_INTEGER ||
2444 srcFormat == GL_RGB_INTEGER_EXT ||
2445 srcFormat == GL_RGBA_INTEGER_EXT ||
2446 srcFormat == GL_BGR_INTEGER_EXT ||
2447 srcFormat == GL_BGRA_INTEGER_EXT ||
2448 srcFormat == GL_LUMINANCE_INTEGER_EXT ||
2449 srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);
2450
2451 ASSERT(srcType == GL_UNSIGNED_BYTE ||
2452 srcType == GL_BYTE ||
2453 srcType == GL_UNSIGNED_SHORT ||
2454 srcType == GL_SHORT ||
2455 srcType == GL_UNSIGNED_INT ||
2456 srcType == GL_INT ||
2457 srcType == GL_HALF_FLOAT_ARB ||
2458 srcType == GL_FLOAT ||
2459 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
2460 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
2461 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
2462 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
2463 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
2464 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
2465 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
2466 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
2467 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
2468 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
2469 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
2470 srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
2471 srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
2472 srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
2473
2474 get_component_mapping(srcFormat,
2475 &rSrc, &gSrc, &bSrc, &aSrc,
2476 &rDst, &gDst, &bDst, &aDst);
2477
2478 stride = _mesa_components_in_format(srcFormat);
2479
2480 intFormat = _mesa_is_integer_format(srcFormat);
2481
2482 #define PROCESS(SRC_INDEX, DST_INDEX, DEFAULT_FLT, DEFAULT_INT, TYPE, CONVERSION) \
2483 if ((SRC_INDEX) < 0) { \
2484 GLuint i; \
2485 if (intFormat) { \
2486 for (i = 0; i < n; i++) { \
2487 rgba[i][DST_INDEX] = DEFAULT_INT; \
2488 } \
2489 } \
2490 else { \
2491 for (i = 0; i < n; i++) { \
2492 rgba[i][DST_INDEX] = DEFAULT_FLT; \
2493 } \
2494 } \
2495 } \
2496 else if (swapBytes) { \
2497 const TYPE *s = (const TYPE *) src; \
2498 GLuint i; \
2499 for (i = 0; i < n; i++) { \
2500 TYPE value = s[SRC_INDEX]; \
2501 if (sizeof(TYPE) == 2) { \
2502 SWAP2BYTE(value); \
2503 } \
2504 else if (sizeof(TYPE) == 4) { \
2505 SWAP4BYTE(value); \
2506 } \
2507 if (intFormat) \
2508 rgba[i][DST_INDEX] = (GLfloat) value; \
2509 else \
2510 rgba[i][DST_INDEX] = (GLfloat) CONVERSION(value); \
2511 s += stride; \
2512 } \
2513 } \
2514 else { \
2515 const TYPE *s = (const TYPE *) src; \
2516 GLuint i; \
2517 if (intFormat) { \
2518 for (i = 0; i < n; i++) { \
2519 rgba[i][DST_INDEX] = (GLfloat) s[SRC_INDEX]; \
2520 s += stride; \
2521 } \
2522 } \
2523 else { \
2524 for (i = 0; i < n; i++) { \
2525 rgba[i][DST_INDEX] = (GLfloat) CONVERSION(s[SRC_INDEX]); \
2526 s += stride; \
2527 } \
2528 } \
2529 }
2530
2531 switch (srcType) {
2532 case GL_UNSIGNED_BYTE:
2533 PROCESS(rSrc, RCOMP, 0.0F, 0, GLubyte, UBYTE_TO_FLOAT);
2534 PROCESS(gSrc, GCOMP, 0.0F, 0, GLubyte, UBYTE_TO_FLOAT);
2535 PROCESS(bSrc, BCOMP, 0.0F, 0, GLubyte, UBYTE_TO_FLOAT);
2536 PROCESS(aSrc, ACOMP, 1.0F, 255, GLubyte, UBYTE_TO_FLOAT);
2537 break;
2538 case GL_BYTE:
2539 PROCESS(rSrc, RCOMP, 0.0F, 0, GLbyte, BYTE_TO_FLOATZ);
2540 PROCESS(gSrc, GCOMP, 0.0F, 0, GLbyte, BYTE_TO_FLOATZ);
2541 PROCESS(bSrc, BCOMP, 0.0F, 0, GLbyte, BYTE_TO_FLOATZ);
2542 PROCESS(aSrc, ACOMP, 1.0F, 127, GLbyte, BYTE_TO_FLOATZ);
2543 break;
2544 case GL_UNSIGNED_SHORT:
2545 PROCESS(rSrc, RCOMP, 0.0F, 0, GLushort, USHORT_TO_FLOAT);
2546 PROCESS(gSrc, GCOMP, 0.0F, 0, GLushort, USHORT_TO_FLOAT);
2547 PROCESS(bSrc, BCOMP, 0.0F, 0, GLushort, USHORT_TO_FLOAT);
2548 PROCESS(aSrc, ACOMP, 1.0F, 0xffff, GLushort, USHORT_TO_FLOAT);
2549 break;
2550 case GL_SHORT:
2551 PROCESS(rSrc, RCOMP, 0.0F, 0, GLshort, SHORT_TO_FLOATZ);
2552 PROCESS(gSrc, GCOMP, 0.0F, 0, GLshort, SHORT_TO_FLOATZ);
2553 PROCESS(bSrc, BCOMP, 0.0F, 0, GLshort, SHORT_TO_FLOATZ);
2554 PROCESS(aSrc, ACOMP, 1.0F, 32767, GLshort, SHORT_TO_FLOATZ);
2555 break;
2556 case GL_UNSIGNED_INT:
2557 PROCESS(rSrc, RCOMP, 0.0F, 0, GLuint, UINT_TO_FLOAT);
2558 PROCESS(gSrc, GCOMP, 0.0F, 0, GLuint, UINT_TO_FLOAT);
2559 PROCESS(bSrc, BCOMP, 0.0F, 0, GLuint, UINT_TO_FLOAT);
2560 PROCESS(aSrc, ACOMP, 1.0F, 0xffffffff, GLuint, UINT_TO_FLOAT);
2561 break;
2562 case GL_INT:
2563 PROCESS(rSrc, RCOMP, 0.0F, 0, GLint, INT_TO_FLOAT);
2564 PROCESS(gSrc, GCOMP, 0.0F, 0, GLint, INT_TO_FLOAT);
2565 PROCESS(bSrc, BCOMP, 0.0F, 0, GLint, INT_TO_FLOAT);
2566 PROCESS(aSrc, ACOMP, 1.0F, 2147483647, GLint, INT_TO_FLOAT);
2567 break;
2568 case GL_FLOAT:
2569 PROCESS(rSrc, RCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
2570 PROCESS(gSrc, GCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
2571 PROCESS(bSrc, BCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
2572 PROCESS(aSrc, ACOMP, 1.0F, 1.0F, GLfloat, (GLfloat));
2573 break;
2574 case GL_HALF_FLOAT_ARB:
2575 PROCESS(rSrc, RCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
2576 PROCESS(gSrc, GCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
2577 PROCESS(bSrc, BCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
2578 PROCESS(aSrc, ACOMP, 1.0F, 1.0F, GLhalfARB, _mesa_half_to_float);
2579 break;
2580 case GL_UNSIGNED_BYTE_3_3_2:
2581 {
2582 const GLubyte *ubsrc = (const GLubyte *) src;
2583 GLuint i;
2584 if (!intFormat) {
2585 rs = 1.0F / 7.0F;
2586 gs = 1.0F / 7.0F;
2587 bs = 1.0F / 3.0F;
2588 }
2589 for (i = 0; i < n; i ++) {
2590 GLubyte p = ubsrc[i];
2591 rgba[i][rDst] = ((p >> 5) ) * rs;
2592 rgba[i][gDst] = ((p >> 2) & 0x7) * gs;
2593 rgba[i][bDst] = ((p ) & 0x3) * bs;
2594 rgba[i][aDst] = 1.0F;
2595 }
2596 }
2597 break;
2598 case GL_UNSIGNED_BYTE_2_3_3_REV:
2599 {
2600 const GLubyte *ubsrc = (const GLubyte *) src;
2601 GLuint i;
2602 if (!intFormat) {
2603 rs = 1.0F / 7.0F;
2604 gs = 1.0F / 7.0F;
2605 bs = 1.0F / 3.0F;
2606 }
2607 for (i = 0; i < n; i ++) {
2608 GLubyte p = ubsrc[i];
2609 rgba[i][rDst] = ((p ) & 0x7) * rs;
2610 rgba[i][gDst] = ((p >> 3) & 0x7) * gs;
2611 rgba[i][bDst] = ((p >> 6) ) * bs;
2612 rgba[i][aDst] = 1.0F;
2613 }
2614 }
2615 break;
2616 case GL_UNSIGNED_SHORT_5_6_5:
2617 if (!intFormat) {
2618 rs = 1.0F / 31.0F;
2619 gs = 1.0F / 63.0F;
2620 bs = 1.0F / 31.0F;
2621 }
2622 if (swapBytes) {
2623 const GLushort *ussrc = (const GLushort *) src;
2624 GLuint i;
2625 for (i = 0; i < n; i ++) {
2626 GLushort p = ussrc[i];
2627 SWAP2BYTE(p);
2628 rgba[i][rDst] = ((p >> 11) ) * rs;
2629 rgba[i][gDst] = ((p >> 5) & 0x3f) * gs;
2630 rgba[i][bDst] = ((p ) & 0x1f) * bs;
2631 rgba[i][aDst] = 1.0F;
2632 }
2633 }
2634 else {
2635 const GLushort *ussrc = (const GLushort *) src;
2636 GLuint i;
2637 for (i = 0; i < n; i ++) {
2638 GLushort p = ussrc[i];
2639 rgba[i][rDst] = ((p >> 11) ) * rs;
2640 rgba[i][gDst] = ((p >> 5) & 0x3f) * gs;
2641 rgba[i][bDst] = ((p ) & 0x1f) * bs;
2642 rgba[i][aDst] = 1.0F;
2643 }
2644 }
2645 break;
2646 case GL_UNSIGNED_SHORT_5_6_5_REV:
2647 if (!intFormat) {
2648 rs = 1.0F / 31.0F;
2649 gs = 1.0F / 63.0F;
2650 bs = 1.0F / 31.0F;
2651 }
2652 if (swapBytes) {
2653 const GLushort *ussrc = (const GLushort *) src;
2654 GLuint i;
2655 for (i = 0; i < n; i ++) {
2656 GLushort p = ussrc[i];
2657 SWAP2BYTE(p);
2658 rgba[i][rDst] = ((p ) & 0x1f) * rs;
2659 rgba[i][gDst] = ((p >> 5) & 0x3f) * gs;
2660 rgba[i][bDst] = ((p >> 11) ) * bs;
2661 rgba[i][aDst] = 1.0F;
2662 }
2663 }
2664 else {
2665 const GLushort *ussrc = (const GLushort *) src;
2666 GLuint i;
2667 for (i = 0; i < n; i ++) {
2668 GLushort p = ussrc[i];
2669 rgba[i][rDst] = ((p ) & 0x1f) * rs;
2670 rgba[i][gDst] = ((p >> 5) & 0x3f) * gs;
2671 rgba[i][bDst] = ((p >> 11) ) * bs;
2672 rgba[i][aDst] = 1.0F;
2673 }
2674 }
2675 break;
2676 case GL_UNSIGNED_SHORT_4_4_4_4:
2677 if (!intFormat) {
2678 rs = gs = bs = as = 1.0F / 15.0F;
2679 }
2680 if (swapBytes) {
2681 const GLushort *ussrc = (const GLushort *) src;
2682 GLuint i;
2683 for (i = 0; i < n; i ++) {
2684 GLushort p = ussrc[i];
2685 SWAP2BYTE(p);
2686 rgba[i][rDst] = ((p >> 12) ) * rs;
2687 rgba[i][gDst] = ((p >> 8) & 0xf) * gs;
2688 rgba[i][bDst] = ((p >> 4) & 0xf) * bs;
2689 rgba[i][aDst] = ((p ) & 0xf) * as;
2690 }
2691 }
2692 else {
2693 const GLushort *ussrc = (const GLushort *) src;
2694 GLuint i;
2695 for (i = 0; i < n; i ++) {
2696 GLushort p = ussrc[i];
2697 rgba[i][rDst] = ((p >> 12) ) * rs;
2698 rgba[i][gDst] = ((p >> 8) & 0xf) * gs;
2699 rgba[i][bDst] = ((p >> 4) & 0xf) * bs;
2700 rgba[i][aDst] = ((p ) & 0xf) * as;
2701 }
2702 }
2703 break;
2704 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
2705 if (!intFormat) {
2706 rs = gs = bs = as = 1.0F / 15.0F;
2707 }
2708 if (swapBytes) {
2709 const GLushort *ussrc = (const GLushort *) src;
2710 GLuint i;
2711 for (i = 0; i < n; i ++) {
2712 GLushort p = ussrc[i];
2713 SWAP2BYTE(p);
2714 rgba[i][rDst] = ((p ) & 0xf) * rs;
2715 rgba[i][gDst] = ((p >> 4) & 0xf) * gs;
2716 rgba[i][bDst] = ((p >> 8) & 0xf) * bs;
2717 rgba[i][aDst] = ((p >> 12) ) * as;
2718 }
2719 }
2720 else {
2721 const GLushort *ussrc = (const GLushort *) src;
2722 GLuint i;
2723 for (i = 0; i < n; i ++) {
2724 GLushort p = ussrc[i];
2725 rgba[i][rDst] = ((p ) & 0xf) * rs;
2726 rgba[i][gDst] = ((p >> 4) & 0xf) * gs;
2727 rgba[i][bDst] = ((p >> 8) & 0xf) * bs;
2728 rgba[i][aDst] = ((p >> 12) ) * as;
2729 }
2730 }
2731 break;
2732 case GL_UNSIGNED_SHORT_5_5_5_1:
2733 if (!intFormat) {
2734 rs = gs = bs = 1.0F / 31.0F;
2735 }
2736 if (swapBytes) {
2737 const GLushort *ussrc = (const GLushort *) src;
2738 GLuint i;
2739 for (i = 0; i < n; i ++) {
2740 GLushort p = ussrc[i];
2741 SWAP2BYTE(p);
2742 rgba[i][rDst] = ((p >> 11) ) * rs;
2743 rgba[i][gDst] = ((p >> 6) & 0x1f) * gs;
2744 rgba[i][bDst] = ((p >> 1) & 0x1f) * bs;
2745 rgba[i][aDst] = ((p ) & 0x1) * as;
2746 }
2747 }
2748 else {
2749 const GLushort *ussrc = (const GLushort *) src;
2750 GLuint i;
2751 for (i = 0; i < n; i ++) {
2752 GLushort p = ussrc[i];
2753 rgba[i][rDst] = ((p >> 11) ) * rs;
2754 rgba[i][gDst] = ((p >> 6) & 0x1f) * gs;
2755 rgba[i][bDst] = ((p >> 1) & 0x1f) * bs;
2756 rgba[i][aDst] = ((p ) & 0x1) * as;
2757 }
2758 }
2759 break;
2760 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
2761 if (!intFormat) {
2762 rs = gs = bs = 1.0F / 31.0F;
2763 }
2764 if (swapBytes) {
2765 const GLushort *ussrc = (const GLushort *) src;
2766 GLuint i;
2767 for (i = 0; i < n; i ++) {
2768 GLushort p = ussrc[i];
2769 SWAP2BYTE(p);
2770 rgba[i][rDst] = ((p ) & 0x1f) * rs;
2771 rgba[i][gDst] = ((p >> 5) & 0x1f) * gs;
2772 rgba[i][bDst] = ((p >> 10) & 0x1f) * bs;
2773 rgba[i][aDst] = ((p >> 15) ) * as;
2774 }
2775 }
2776 else {
2777 const GLushort *ussrc = (const GLushort *) src;
2778 GLuint i;
2779 for (i = 0; i < n; i ++) {
2780 GLushort p = ussrc[i];
2781 rgba[i][rDst] = ((p ) & 0x1f) * rs;
2782 rgba[i][gDst] = ((p >> 5) & 0x1f) * gs;
2783 rgba[i][bDst] = ((p >> 10) & 0x1f) * bs;
2784 rgba[i][aDst] = ((p >> 15) ) * as;
2785 }
2786 }
2787 break;
2788 case GL_UNSIGNED_INT_8_8_8_8:
2789 if (swapBytes) {
2790 const GLuint *uisrc = (const GLuint *) src;
2791 GLuint i;
2792 if (intFormat) {
2793 for (i = 0; i < n; i ++) {
2794 GLuint p = uisrc[i];
2795 rgba[i][rDst] = (GLfloat) ((p ) & 0xff);
2796 rgba[i][gDst] = (GLfloat) ((p >> 8) & 0xff);
2797 rgba[i][bDst] = (GLfloat) ((p >> 16) & 0xff);
2798 rgba[i][aDst] = (GLfloat) ((p >> 24) );
2799 }
2800 }
2801 else {
2802 for (i = 0; i < n; i ++) {
2803 GLuint p = uisrc[i];
2804 rgba[i][rDst] = UBYTE_TO_FLOAT((p ) & 0xff);
2805 rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
2806 rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2807 rgba[i][aDst] = UBYTE_TO_FLOAT((p >> 24) );
2808 }
2809 }
2810 }
2811 else {
2812 const GLuint *uisrc = (const GLuint *) src;
2813 GLuint i;
2814 if (intFormat) {
2815 for (i = 0; i < n; i ++) {
2816 GLuint p = uisrc[i];
2817 rgba[i][rDst] = (GLfloat) ((p >> 24) );
2818 rgba[i][gDst] = (GLfloat) ((p >> 16) & 0xff);
2819 rgba[i][bDst] = (GLfloat) ((p >> 8) & 0xff);
2820 rgba[i][aDst] = (GLfloat) ((p ) & 0xff);
2821 }
2822 }
2823 else {
2824 for (i = 0; i < n; i ++) {
2825 GLuint p = uisrc[i];
2826 rgba[i][rDst] = UBYTE_TO_FLOAT((p >> 24) );
2827 rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2828 rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
2829 rgba[i][aDst] = UBYTE_TO_FLOAT((p ) & 0xff);
2830 }
2831 }
2832 }
2833 break;
2834 case GL_UNSIGNED_INT_8_8_8_8_REV:
2835 if (swapBytes) {
2836 const GLuint *uisrc = (const GLuint *) src;
2837 GLuint i;
2838 if (intFormat) {
2839 for (i = 0; i < n; i ++) {
2840 GLuint p = uisrc[i];
2841 rgba[i][rDst] = (GLfloat) ((p >> 24) );
2842 rgba[i][gDst] = (GLfloat) ((p >> 16) & 0xff);
2843 rgba[i][bDst] = (GLfloat) ((p >> 8) & 0xff);
2844 rgba[i][aDst] = (GLfloat) ((p ) & 0xff);
2845 }
2846 }
2847 else {
2848 for (i = 0; i < n; i ++) {
2849 GLuint p = uisrc[i];
2850 rgba[i][rDst] = UBYTE_TO_FLOAT((p >> 24) );
2851 rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2852 rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
2853 rgba[i][aDst] = UBYTE_TO_FLOAT((p ) & 0xff);
2854 }
2855 }
2856 }
2857 else {
2858 const GLuint *uisrc = (const GLuint *) src;
2859 GLuint i;
2860 if (intFormat) {
2861 for (i = 0; i < n; i ++) {
2862 GLuint p = uisrc[i];
2863 rgba[i][rDst] = (GLfloat) ((p ) & 0xff);
2864 rgba[i][gDst] = (GLfloat) ((p >> 8) & 0xff);
2865 rgba[i][bDst] = (GLfloat) ((p >> 16) & 0xff);
2866 rgba[i][aDst] = (GLfloat) ((p >> 24) );
2867 }
2868 }
2869 else {
2870 for (i = 0; i < n; i ++) {
2871 GLuint p = uisrc[i];
2872 rgba[i][rDst] = UBYTE_TO_FLOAT((p ) & 0xff);
2873 rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
2874 rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2875 rgba[i][aDst] = UBYTE_TO_FLOAT((p >> 24) );
2876 }
2877 }
2878 }
2879 break;
2880 case GL_UNSIGNED_INT_10_10_10_2:
2881 if (!intFormat) {
2882 rs = 1.0F / 1023.0F;
2883 gs = 1.0F / 1023.0F;
2884 bs = 1.0F / 1023.0F;
2885 as = 1.0F / 3.0F;
2886 }
2887 if (swapBytes) {
2888 const GLuint *uisrc = (const GLuint *) src;
2889 GLuint i;
2890 for (i = 0; i < n; i ++) {
2891 GLuint p = uisrc[i];
2892 SWAP4BYTE(p);
2893 rgba[i][rDst] = ((p >> 22) ) * rs;
2894 rgba[i][gDst] = ((p >> 12) & 0x3ff) * gs;
2895 rgba[i][bDst] = ((p >> 2) & 0x3ff) * bs;
2896 rgba[i][aDst] = ((p ) & 0x3 ) * as;
2897 }
2898 }
2899 else {
2900 const GLuint *uisrc = (const GLuint *) src;
2901 GLuint i;
2902 for (i = 0; i < n; i ++) {
2903 GLuint p = uisrc[i];
2904 rgba[i][rDst] = ((p >> 22) ) * rs;
2905 rgba[i][gDst] = ((p >> 12) & 0x3ff) * gs;
2906 rgba[i][bDst] = ((p >> 2) & 0x3ff) * bs;
2907 rgba[i][aDst] = ((p ) & 0x3 ) * as;
2908 }
2909 }
2910 break;
2911 case GL_UNSIGNED_INT_2_10_10_10_REV:
2912 if (!intFormat) {
2913 rs = 1.0F / 1023.0F;
2914 gs = 1.0F / 1023.0F;
2915 bs = 1.0F / 1023.0F;
2916 as = 1.0F / 3.0F;
2917 }
2918 if (swapBytes) {
2919 const GLuint *uisrc = (const GLuint *) src;
2920 GLuint i;
2921 for (i = 0; i < n; i ++) {
2922 GLuint p = uisrc[i];
2923 SWAP4BYTE(p);
2924 rgba[i][rDst] = ((p ) & 0x3ff) * rs;
2925 rgba[i][gDst] = ((p >> 10) & 0x3ff) * gs;
2926 rgba[i][bDst] = ((p >> 20) & 0x3ff) * bs;
2927 rgba[i][aDst] = ((p >> 30) ) * as;
2928 }
2929 }
2930 else {
2931 const GLuint *uisrc = (const GLuint *) src;
2932 GLuint i;
2933 for (i = 0; i < n; i ++) {
2934 GLuint p = uisrc[i];
2935 rgba[i][rDst] = ((p ) & 0x3ff) * rs;
2936 rgba[i][gDst] = ((p >> 10) & 0x3ff) * gs;
2937 rgba[i][bDst] = ((p >> 20) & 0x3ff) * bs;
2938 rgba[i][aDst] = ((p >> 30) ) * as;
2939 }
2940 }
2941 break;
2942 case GL_UNSIGNED_INT_5_9_9_9_REV:
2943 if (swapBytes) {
2944 const GLuint *uisrc = (const GLuint *) src;
2945 GLuint i;
2946 GLfloat f[3];
2947 for (i = 0; i < n; i ++) {
2948 GLuint p = uisrc[i];
2949 SWAP4BYTE(p);
2950 rgb9e5_to_float3(p, f);
2951 rgba[i][rDst] = f[0];
2952 rgba[i][gDst] = f[1];
2953 rgba[i][bDst] = f[2];
2954 rgba[i][aDst] = 1.0F;
2955 }
2956 }
2957 else {
2958 const GLuint *uisrc = (const GLuint *) src;
2959 GLuint i;
2960 GLfloat f[3];
2961 for (i = 0; i < n; i ++) {
2962 rgb9e5_to_float3(uisrc[i], f);
2963 rgba[i][rDst] = f[0];
2964 rgba[i][gDst] = f[1];
2965 rgba[i][bDst] = f[2];
2966 rgba[i][aDst] = 1.0F;
2967 }
2968 }
2969 break;
2970 case GL_UNSIGNED_INT_10F_11F_11F_REV:
2971 if (swapBytes) {
2972 const GLuint *uisrc = (const GLuint *) src;
2973 GLuint i;
2974 GLfloat f[3];
2975 for (i = 0; i < n; i ++) {
2976 GLuint p = uisrc[i];
2977 SWAP4BYTE(p);
2978 r11g11b10f_to_float3(p, f);
2979 rgba[i][rDst] = f[0];
2980 rgba[i][gDst] = f[1];
2981 rgba[i][bDst] = f[2];
2982 rgba[i][aDst] = 1.0F;
2983 }
2984 }
2985 else {
2986 const GLuint *uisrc = (const GLuint *) src;
2987 GLuint i;
2988 GLfloat f[3];
2989 for (i = 0; i < n; i ++) {
2990 r11g11b10f_to_float3(uisrc[i], f);
2991 rgba[i][rDst] = f[0];
2992 rgba[i][gDst] = f[1];
2993 rgba[i][bDst] = f[2];
2994 rgba[i][aDst] = 1.0F;
2995 }
2996 }
2997 break;
2998 default:
2999 _mesa_problem(NULL, "bad srcType in extract float data");
3000 break;
3001 }
3002 #undef PROCESS
3003 }
3004
3005
3006 static inline GLuint
3007 clamp_float_to_uint(GLfloat f)
3008 {
3009 return f < 0.0F ? 0 : IROUND(f);
3010 }
3011
3012
3013 static inline GLuint
3014 clamp_half_to_uint(GLhalfARB h)
3015 {
3016 GLfloat f = _mesa_half_to_float(h);
3017 return f < 0.0F ? 0 : IROUND(f);
3018 }
3019
3020
3021 /**
3022 * \sa extract_float_rgba()
3023 */
3024 static void
3025 extract_uint_rgba(GLuint n, GLuint rgba[][4],
3026 GLenum srcFormat, GLenum srcType, const GLvoid *src,
3027 GLboolean swapBytes)
3028 {
3029 GLint rSrc, gSrc, bSrc, aSrc;
3030 GLint stride;
3031 GLint rDst, bDst, gDst, aDst;
3032
3033 ASSERT(srcFormat == GL_RED ||
3034 srcFormat == GL_GREEN ||
3035 srcFormat == GL_BLUE ||
3036 srcFormat == GL_ALPHA ||
3037 srcFormat == GL_LUMINANCE ||
3038 srcFormat == GL_LUMINANCE_ALPHA ||
3039 srcFormat == GL_INTENSITY ||
3040 srcFormat == GL_RG ||
3041 srcFormat == GL_RGB ||
3042 srcFormat == GL_BGR ||
3043 srcFormat == GL_RGBA ||
3044 srcFormat == GL_BGRA ||
3045 srcFormat == GL_ABGR_EXT ||
3046 srcFormat == GL_DU8DV8_ATI ||
3047 srcFormat == GL_DUDV_ATI ||
3048 srcFormat == GL_RED_INTEGER_EXT ||
3049 srcFormat == GL_RG_INTEGER ||
3050 srcFormat == GL_GREEN_INTEGER_EXT ||
3051 srcFormat == GL_BLUE_INTEGER_EXT ||
3052 srcFormat == GL_ALPHA_INTEGER_EXT ||
3053 srcFormat == GL_RGB_INTEGER_EXT ||
3054 srcFormat == GL_RGBA_INTEGER_EXT ||
3055 srcFormat == GL_BGR_INTEGER_EXT ||
3056 srcFormat == GL_BGRA_INTEGER_EXT ||
3057 srcFormat == GL_LUMINANCE_INTEGER_EXT ||
3058 srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);
3059
3060 ASSERT(srcType == GL_UNSIGNED_BYTE ||
3061 srcType == GL_BYTE ||
3062 srcType == GL_UNSIGNED_SHORT ||
3063 srcType == GL_SHORT ||
3064 srcType == GL_UNSIGNED_INT ||
3065 srcType == GL_INT ||
3066 srcType == GL_HALF_FLOAT_ARB ||
3067 srcType == GL_FLOAT ||
3068 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
3069 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
3070 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
3071 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
3072 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
3073 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
3074 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
3075 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
3076 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
3077 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
3078 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
3079 srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
3080 srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
3081 srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
3082
3083 get_component_mapping(srcFormat,
3084 &rSrc, &gSrc, &bSrc, &aSrc,
3085 &rDst, &gDst, &bDst, &aDst);
3086
3087 stride = _mesa_components_in_format(srcFormat);
3088
3089 #define PROCESS(SRC_INDEX, DST_INDEX, DEFAULT, TYPE, CONVERSION) \
3090 if ((SRC_INDEX) < 0) { \
3091 GLuint i; \
3092 for (i = 0; i < n; i++) { \
3093 rgba[i][DST_INDEX] = DEFAULT; \
3094 } \
3095 } \
3096 else if (swapBytes) { \
3097 const TYPE *s = (const TYPE *) src; \
3098 GLuint i; \
3099 for (i = 0; i < n; i++) { \
3100 TYPE value = s[SRC_INDEX]; \
3101 if (sizeof(TYPE) == 2) { \
3102 SWAP2BYTE(value); \
3103 } \
3104 else if (sizeof(TYPE) == 4) { \
3105 SWAP4BYTE(value); \
3106 } \
3107 rgba[i][DST_INDEX] = CONVERSION(value); \
3108 s += stride; \
3109 } \
3110 } \
3111 else { \
3112 const TYPE *s = (const TYPE *) src; \
3113 GLuint i; \
3114 for (i = 0; i < n; i++) { \
3115 rgba[i][DST_INDEX] = CONVERSION(s[SRC_INDEX]); \
3116 s += stride; \
3117 } \
3118 }
3119
3120 switch (srcType) {
3121 case GL_UNSIGNED_BYTE:
3122 PROCESS(rSrc, RCOMP, 0, GLubyte, (GLuint));
3123 PROCESS(gSrc, GCOMP, 0, GLubyte, (GLuint));
3124 PROCESS(bSrc, BCOMP, 0, GLubyte, (GLuint));
3125 PROCESS(aSrc, ACOMP, 1, GLubyte, (GLuint));
3126 break;
3127 case GL_BYTE:
3128 PROCESS(rSrc, RCOMP, 0, GLbyte, (GLuint));
3129 PROCESS(gSrc, GCOMP, 0, GLbyte, (GLuint));
3130 PROCESS(bSrc, BCOMP, 0, GLbyte, (GLuint));
3131 PROCESS(aSrc, ACOMP, 1, GLbyte, (GLuint));
3132 break;
3133 case GL_UNSIGNED_SHORT:
3134 PROCESS(rSrc, RCOMP, 0, GLushort, (GLuint));
3135 PROCESS(gSrc, GCOMP, 0, GLushort, (GLuint));
3136 PROCESS(bSrc, BCOMP, 0, GLushort, (GLuint));
3137 PROCESS(aSrc, ACOMP, 1, GLushort, (GLuint));
3138 break;
3139 case GL_SHORT:
3140 PROCESS(rSrc, RCOMP, 0, GLshort, (GLuint));
3141 PROCESS(gSrc, GCOMP, 0, GLshort, (GLuint));
3142 PROCESS(bSrc, BCOMP, 0, GLshort, (GLuint));
3143 PROCESS(aSrc, ACOMP, 1, GLshort, (GLuint));
3144 break;
3145 case GL_UNSIGNED_INT:
3146 PROCESS(rSrc, RCOMP, 0, GLuint, (GLuint));
3147 PROCESS(gSrc, GCOMP, 0, GLuint, (GLuint));
3148 PROCESS(bSrc, BCOMP, 0, GLuint, (GLuint));
3149 PROCESS(aSrc, ACOMP, 1, GLuint, (GLuint));
3150 break;
3151 case GL_INT:
3152 PROCESS(rSrc, RCOMP, 0, GLint, (GLuint));
3153 PROCESS(gSrc, GCOMP, 0, GLint, (GLuint));
3154 PROCESS(bSrc, BCOMP, 0, GLint, (GLuint));
3155 PROCESS(aSrc, ACOMP, 1, GLint, (GLuint));
3156 break;
3157 case GL_FLOAT:
3158 PROCESS(rSrc, RCOMP, 0, GLfloat, clamp_float_to_uint);
3159 PROCESS(gSrc, GCOMP, 0, GLfloat, clamp_float_to_uint);
3160 PROCESS(bSrc, BCOMP, 0, GLfloat, clamp_float_to_uint);
3161 PROCESS(aSrc, ACOMP, 1, GLfloat, clamp_float_to_uint);
3162 break;
3163 case GL_HALF_FLOAT_ARB:
3164 PROCESS(rSrc, RCOMP, 0, GLhalfARB, clamp_half_to_uint);
3165 PROCESS(gSrc, GCOMP, 0, GLhalfARB, clamp_half_to_uint);
3166 PROCESS(bSrc, BCOMP, 0, GLhalfARB, clamp_half_to_uint);
3167 PROCESS(aSrc, ACOMP, 1, GLhalfARB, clamp_half_to_uint);
3168 break;
3169 case GL_UNSIGNED_BYTE_3_3_2:
3170 {
3171 const GLubyte *ubsrc = (const GLubyte *) src;
3172 GLuint i;
3173 for (i = 0; i < n; i ++) {
3174 GLubyte p = ubsrc[i];
3175 rgba[i][rDst] = ((p >> 5) );
3176 rgba[i][gDst] = ((p >> 2) & 0x7);
3177 rgba[i][bDst] = ((p ) & 0x3);
3178 rgba[i][aDst] = 1;
3179 }
3180 }
3181 break;
3182 case GL_UNSIGNED_BYTE_2_3_3_REV:
3183 {
3184 const GLubyte *ubsrc = (const GLubyte *) src;
3185 GLuint i;
3186 for (i = 0; i < n; i ++) {
3187 GLubyte p = ubsrc[i];
3188 rgba[i][rDst] = ((p ) & 0x7);
3189 rgba[i][gDst] = ((p >> 3) & 0x7);
3190 rgba[i][bDst] = ((p >> 6) );
3191 rgba[i][aDst] = 1;
3192 }
3193 }
3194 break;
3195 case GL_UNSIGNED_SHORT_5_6_5:
3196 if (swapBytes) {
3197 const GLushort *ussrc = (const GLushort *) src;
3198 GLuint i;
3199 for (i = 0; i < n; i ++) {
3200 GLushort p = ussrc[i];
3201 SWAP2BYTE(p);
3202 rgba[i][rDst] = ((p >> 11) );
3203 rgba[i][gDst] = ((p >> 5) & 0x3f);
3204 rgba[i][bDst] = ((p ) & 0x1f);
3205 rgba[i][aDst] = 1;
3206 }
3207 }
3208 else {
3209 const GLushort *ussrc = (const GLushort *) src;
3210 GLuint i;
3211 for (i = 0; i < n; i ++) {
3212 GLushort p = ussrc[i];
3213 rgba[i][rDst] = ((p >> 11) );
3214 rgba[i][gDst] = ((p >> 5) & 0x3f);
3215 rgba[i][bDst] = ((p ) & 0x1f);
3216 rgba[i][aDst] = 1;
3217 }
3218 }
3219 break;
3220 case GL_UNSIGNED_SHORT_5_6_5_REV:
3221 if (swapBytes) {
3222 const GLushort *ussrc = (const GLushort *) src;
3223 GLuint i;
3224 for (i = 0; i < n; i ++) {
3225 GLushort p = ussrc[i];
3226 SWAP2BYTE(p);
3227 rgba[i][rDst] = ((p ) & 0x1f);
3228 rgba[i][gDst] = ((p >> 5) & 0x3f);
3229 rgba[i][bDst] = ((p >> 11) );
3230 rgba[i][aDst] = 1;
3231 }
3232 }
3233 else {
3234 const GLushort *ussrc = (const GLushort *) src;
3235 GLuint i;
3236 for (i = 0; i < n; i ++) {
3237 GLushort p = ussrc[i];
3238 rgba[i][rDst] = ((p ) & 0x1f);
3239 rgba[i][gDst] = ((p >> 5) & 0x3f);
3240 rgba[i][bDst] = ((p >> 11) );
3241 rgba[i][aDst] = 1;
3242 }
3243 }
3244 break;
3245 case GL_UNSIGNED_SHORT_4_4_4_4:
3246 if (swapBytes) {
3247 const GLushort *ussrc = (const GLushort *) src;
3248 GLuint i;
3249 for (i = 0; i < n; i ++) {
3250 GLushort p = ussrc[i];
3251 SWAP2BYTE(p);
3252 rgba[i][rDst] = ((p >> 12) );
3253 rgba[i][gDst] = ((p >> 8) & 0xf);
3254 rgba[i][bDst] = ((p >> 4) & 0xf);
3255 rgba[i][aDst] = ((p ) & 0xf);
3256 }
3257 }
3258 else {
3259 const GLushort *ussrc = (const GLushort *) src;
3260 GLuint i;
3261 for (i = 0; i < n; i ++) {
3262 GLushort p = ussrc[i];
3263 rgba[i][rDst] = ((p >> 12) );
3264 rgba[i][gDst] = ((p >> 8) & 0xf);
3265 rgba[i][bDst] = ((p >> 4) & 0xf);
3266 rgba[i][aDst] = ((p ) & 0xf);
3267 }
3268 }
3269 break;
3270 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
3271 if (swapBytes) {
3272 const GLushort *ussrc = (const GLushort *) src;
3273 GLuint i;
3274 for (i = 0; i < n; i ++) {
3275 GLushort p = ussrc[i];
3276 SWAP2BYTE(p);
3277 rgba[i][rDst] = ((p ) & 0xf);
3278 rgba[i][gDst] = ((p >> 4) & 0xf);
3279 rgba[i][bDst] = ((p >> 8) & 0xf);
3280 rgba[i][aDst] = ((p >> 12) );
3281 }
3282 }
3283 else {
3284 const GLushort *ussrc = (const GLushort *) src;
3285 GLuint i;
3286 for (i = 0; i < n; i ++) {
3287 GLushort p = ussrc[i];
3288 rgba[i][rDst] = ((p ) & 0xf);
3289 rgba[i][gDst] = ((p >> 4) & 0xf);
3290 rgba[i][bDst] = ((p >> 8) & 0xf);
3291 rgba[i][aDst] = ((p >> 12) );
3292 }
3293 }
3294 break;
3295 case GL_UNSIGNED_SHORT_5_5_5_1:
3296 if (swapBytes) {
3297 const GLushort *ussrc = (const GLushort *) src;
3298 GLuint i;
3299 for (i = 0; i < n; i ++) {
3300 GLushort p = ussrc[i];
3301 SWAP2BYTE(p);
3302 rgba[i][rDst] = ((p >> 11) );
3303 rgba[i][gDst] = ((p >> 6) & 0x1f);
3304 rgba[i][bDst] = ((p >> 1) & 0x1f);
3305 rgba[i][aDst] = ((p ) & 0x1 );
3306 }
3307 }
3308 else {
3309 const GLushort *ussrc = (const GLushort *) src;
3310 GLuint i;
3311 for (i = 0; i < n; i ++) {
3312 GLushort p = ussrc[i];
3313 rgba[i][rDst] = ((p >> 11) );
3314 rgba[i][gDst] = ((p >> 6) & 0x1f);
3315 rgba[i][bDst] = ((p >> 1) & 0x1f);
3316 rgba[i][aDst] = ((p ) & 0x1 );
3317 }
3318 }
3319 break;
3320 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
3321 if (swapBytes) {
3322 const GLushort *ussrc = (const GLushort *) src;
3323 GLuint i;
3324 for (i = 0; i < n; i ++) {
3325 GLushort p = ussrc[i];
3326 SWAP2BYTE(p);
3327 rgba[i][rDst] = ((p ) & 0x1f);
3328 rgba[i][gDst] = ((p >> 5) & 0x1f);
3329 rgba[i][bDst] = ((p >> 10) & 0x1f);
3330 rgba[i][aDst] = ((p >> 15) );
3331 }
3332 }
3333 else {
3334 const GLushort *ussrc = (const GLushort *) src;
3335 GLuint i;
3336 for (i = 0; i < n; i ++) {
3337 GLushort p = ussrc[i];
3338 rgba[i][rDst] = ((p ) & 0x1f);
3339 rgba[i][gDst] = ((p >> 5) & 0x1f);
3340 rgba[i][bDst] = ((p >> 10) & 0x1f);
3341 rgba[i][aDst] = ((p >> 15) );
3342 }
3343 }
3344 break;
3345 case GL_UNSIGNED_INT_8_8_8_8:
3346 if (swapBytes) {
3347 const GLuint *uisrc = (const GLuint *) src;
3348 GLuint i;
3349 for (i = 0; i < n; i ++) {
3350 GLuint p = uisrc[i];
3351 rgba[i][rDst] = ((p ) & 0xff);
3352 rgba[i][gDst] = ((p >> 8) & 0xff);
3353 rgba[i][bDst] = ((p >> 16) & 0xff);
3354 rgba[i][aDst] = ((p >> 24) );
3355 }
3356 }
3357 else {
3358 const GLuint *uisrc = (const GLuint *) src;
3359 GLuint i;
3360 for (i = 0; i < n; i ++) {
3361 GLuint p = uisrc[i];
3362 rgba[i][rDst] = ((p >> 24) );
3363 rgba[i][gDst] = ((p >> 16) & 0xff);
3364 rgba[i][bDst] = ((p >> 8) & 0xff);
3365 rgba[i][aDst] = ((p ) & 0xff);
3366 }
3367 }
3368 break;
3369 case GL_UNSIGNED_INT_8_8_8_8_REV:
3370 if (swapBytes) {
3371 const GLuint *uisrc = (const GLuint *) src;
3372 GLuint i;
3373 for (i = 0; i < n; i ++) {
3374 GLuint p = uisrc[i];
3375 rgba[i][rDst] = ((p >> 24) );
3376 rgba[i][gDst] = ((p >> 16) & 0xff);
3377 rgba[i][bDst] = ((p >> 8) & 0xff);
3378 rgba[i][aDst] = ((p ) & 0xff);
3379 }
3380 }
3381 else {
3382 const GLuint *uisrc = (const GLuint *) src;
3383 GLuint i;
3384 for (i = 0; i < n; i ++) {
3385 GLuint p = uisrc[i];
3386 rgba[i][rDst] = ((p ) & 0xff);
3387 rgba[i][gDst] = ((p >> 8) & 0xff);
3388 rgba[i][bDst] = ((p >> 16) & 0xff);
3389 rgba[i][aDst] = ((p >> 24) );
3390 }
3391 }
3392 break;
3393 case GL_UNSIGNED_INT_10_10_10_2:
3394 if (swapBytes) {
3395 const GLuint *uisrc = (const GLuint *) src;
3396 GLuint i;
3397 for (i = 0; i < n; i ++) {
3398 GLuint p = uisrc[i];
3399 SWAP4BYTE(p);
3400 rgba[i][rDst] = ((p >> 22) );
3401 rgba[i][gDst] = ((p >> 12) & 0x3ff);
3402 rgba[i][bDst] = ((p >> 2) & 0x3ff);
3403 rgba[i][aDst] = ((p ) & 0x3 );
3404 }
3405 }
3406 else {
3407 const GLuint *uisrc = (const GLuint *) src;
3408 GLuint i;
3409 for (i = 0; i < n; i ++) {
3410 GLuint p = uisrc[i];
3411 rgba[i][rDst] = ((p >> 22) );
3412 rgba[i][gDst] = ((p >> 12) & 0x3ff);
3413 rgba[i][bDst] = ((p >> 2) & 0x3ff);
3414 rgba[i][aDst] = ((p ) & 0x3 );
3415 }
3416 }
3417 break;
3418 case GL_UNSIGNED_INT_2_10_10_10_REV:
3419 if (swapBytes) {
3420 const GLuint *uisrc = (const GLuint *) src;
3421 GLuint i;
3422 for (i = 0; i < n; i ++) {
3423 GLuint p = uisrc[i];
3424 SWAP4BYTE(p);
3425 rgba[i][rDst] = ((p ) & 0x3ff);
3426 rgba[i][gDst] = ((p >> 10) & 0x3ff);
3427 rgba[i][bDst] = ((p >> 20) & 0x3ff);
3428 rgba[i][aDst] = ((p >> 30) );
3429 }
3430 }
3431 else {
3432 const GLuint *uisrc = (const GLuint *) src;
3433 GLuint i;
3434 for (i = 0; i < n; i ++) {
3435 GLuint p = uisrc[i];
3436 rgba[i][rDst] = ((p ) & 0x3ff);
3437 rgba[i][gDst] = ((p >> 10) & 0x3ff);
3438 rgba[i][bDst] = ((p >> 20) & 0x3ff);
3439 rgba[i][aDst] = ((p >> 30) );
3440 }
3441 }
3442 break;
3443 case GL_UNSIGNED_INT_5_9_9_9_REV:
3444 if (swapBytes) {
3445 const GLuint *uisrc = (const GLuint *) src;
3446 GLuint i;
3447 float f[3];
3448 for (i = 0; i < n; i ++) {
3449 GLuint p = uisrc[i];
3450 SWAP4BYTE(p);
3451 rgb9e5_to_float3(p, f);
3452 rgba[i][rDst] = clamp_float_to_uint(f[0]);
3453 rgba[i][gDst] = clamp_float_to_uint(f[1]);
3454 rgba[i][bDst] = clamp_float_to_uint(f[2]);
3455 rgba[i][aDst] = 1;
3456 }
3457 }
3458 else {
3459 const GLuint *uisrc = (const GLuint *) src;
3460 GLuint i;
3461 float f[3];
3462 for (i = 0; i < n; i ++) {
3463 GLuint p = uisrc[i];
3464 rgb9e5_to_float3(p, f);
3465 rgba[i][rDst] = clamp_float_to_uint(f[0]);
3466 rgba[i][gDst] = clamp_float_to_uint(f[1]);
3467 rgba[i][bDst] = clamp_float_to_uint(f[2]);
3468 rgba[i][aDst] = 1;
3469 }
3470 }
3471 break;
3472 case GL_UNSIGNED_INT_10F_11F_11F_REV:
3473 if (swapBytes) {
3474 const GLuint *uisrc = (const GLuint *) src;
3475 GLuint i;
3476 float f[3];
3477 for (i = 0; i < n; i ++) {
3478 GLuint p = uisrc[i];
3479 SWAP4BYTE(p);
3480 r11g11b10f_to_float3(p, f);
3481 rgba[i][rDst] = clamp_float_to_uint(f[0]);
3482 rgba[i][gDst] = clamp_float_to_uint(f[1]);
3483 rgba[i][bDst] = clamp_float_to_uint(f[2]);
3484 rgba[i][aDst] = 1;
3485 }
3486 }
3487 else {
3488 const GLuint *uisrc = (const GLuint *) src;
3489 GLuint i;
3490 float f[3];
3491 for (i = 0; i < n; i ++) {
3492 GLuint p = uisrc[i];
3493 r11g11b10f_to_float3(p, f);
3494 rgba[i][rDst] = clamp_float_to_uint(f[0]);
3495 rgba[i][gDst] = clamp_float_to_uint(f[1]);
3496 rgba[i][bDst] = clamp_float_to_uint(f[2]);
3497 rgba[i][aDst] = 1;
3498 }
3499 }
3500 break;
3501 default:
3502 _mesa_problem(NULL, "bad srcType in extract uint data");
3503 break;
3504 }
3505 #undef PROCESS
3506 }
3507
3508
3509
3510 /*
3511 * Unpack a row of color image data from a client buffer according to
3512 * the pixel unpacking parameters.
3513 * Return GLubyte values in the specified dest image format.
3514 * This is used by glDrawPixels and glTexImage?D().
3515 * \param ctx - the context
3516 * n - number of pixels in the span
3517 * dstFormat - format of destination color array
3518 * dest - the destination color array
3519 * srcFormat - source image format
3520 * srcType - source image data type
3521 * source - source image pointer
3522 * srcPacking - pixel unpacking parameters
3523 * transferOps - bitmask of IMAGE_*_BIT values of operations to apply
3524 *
3525 * XXX perhaps expand this to process whole images someday.
3526 */
3527 void
3528 _mesa_unpack_color_span_ubyte(struct gl_context *ctx,
3529 GLuint n, GLenum dstFormat, GLubyte dest[],
3530 GLenum srcFormat, GLenum srcType,
3531 const GLvoid *source,
3532 const struct gl_pixelstore_attrib *srcPacking,
3533 GLbitfield transferOps )
3534 {
3535 GLboolean intFormat = _mesa_is_integer_format(srcFormat);
3536 ASSERT(dstFormat == GL_ALPHA ||
3537 dstFormat == GL_LUMINANCE ||
3538 dstFormat == GL_LUMINANCE_ALPHA ||
3539 dstFormat == GL_INTENSITY ||
3540 dstFormat == GL_RED ||
3541 dstFormat == GL_RG ||
3542 dstFormat == GL_RGB ||
3543 dstFormat == GL_RGBA);
3544
3545 ASSERT(srcFormat == GL_RED ||
3546 srcFormat == GL_GREEN ||
3547 srcFormat == GL_BLUE ||
3548 srcFormat == GL_ALPHA ||
3549 srcFormat == GL_LUMINANCE ||
3550 srcFormat == GL_LUMINANCE_ALPHA ||
3551 srcFormat == GL_INTENSITY ||
3552 srcFormat == GL_RG ||
3553 srcFormat == GL_RGB ||
3554 srcFormat == GL_BGR ||
3555 srcFormat == GL_RGBA ||
3556 srcFormat == GL_BGRA ||
3557 srcFormat == GL_ABGR_EXT ||
3558 srcFormat == GL_COLOR_INDEX);
3559
3560 ASSERT(srcType == GL_BITMAP ||
3561 srcType == GL_UNSIGNED_BYTE ||
3562 srcType == GL_BYTE ||
3563 srcType == GL_UNSIGNED_SHORT ||
3564 srcType == GL_SHORT ||
3565 srcType == GL_UNSIGNED_INT ||
3566 srcType == GL_INT ||
3567 srcType == GL_HALF_FLOAT_ARB ||
3568 srcType == GL_FLOAT ||
3569 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
3570 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
3571 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
3572 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
3573 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
3574 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
3575 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
3576 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
3577 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
3578 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
3579 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
3580 srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
3581 srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
3582 srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
3583
3584 /* EXT_texture_integer specifies no transfer ops on integer
3585 * types in the resolved issues section. Just set them to 0
3586 * for integer surfaces.
3587 */
3588 if (intFormat)
3589 transferOps = 0;
3590
3591 /* Try simple cases first */
3592 if (transferOps == 0) {
3593 if (srcType == GL_UNSIGNED_BYTE) {
3594 if (dstFormat == GL_RGBA) {
3595 if (srcFormat == GL_RGBA) {
3596 memcpy( dest, source, n * 4 * sizeof(GLubyte) );
3597 return;
3598 }
3599 else if (srcFormat == GL_RGB) {
3600 GLuint i;
3601 const GLubyte *src = (const GLubyte *) source;
3602 GLubyte *dst = dest;
3603 for (i = 0; i < n; i++) {
3604 dst[0] = src[0];
3605 dst[1] = src[1];
3606 dst[2] = src[2];
3607 dst[3] = 255;
3608 src += 3;
3609 dst += 4;
3610 }
3611 return;
3612 }
3613 }
3614 else if (dstFormat == GL_RGB) {
3615 if (srcFormat == GL_RGB) {
3616 memcpy( dest, source, n * 3 * sizeof(GLubyte) );
3617 return;
3618 }
3619 else if (srcFormat == GL_RGBA) {
3620 GLuint i;
3621 const GLubyte *src = (const GLubyte *) source;
3622 GLubyte *dst = dest;
3623 for (i = 0; i < n; i++) {
3624 dst[0] = src[0];
3625 dst[1] = src[1];
3626 dst[2] = src[2];
3627 src += 4;
3628 dst += 3;
3629 }
3630 return;
3631 }
3632 }
3633 else if (dstFormat == srcFormat) {
3634 GLint comps = _mesa_components_in_format(srcFormat);
3635 assert(comps > 0);
3636 memcpy( dest, source, n * comps * sizeof(GLubyte) );
3637 return;
3638 }
3639 }
3640 }
3641
3642
3643 /* general solution begins here */
3644 {
3645 GLint dstComponents;
3646 GLint rDst, gDst, bDst, aDst, lDst, iDst;
3647 GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));
3648
3649 if (!rgba) {
3650 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3651 return;
3652 }
3653
3654 dstComponents = _mesa_components_in_format( dstFormat );
3655 /* source & dest image formats should have been error checked by now */
3656 assert(dstComponents > 0);
3657
3658 /*
3659 * Extract image data and convert to RGBA floats
3660 */
3661 if (srcFormat == GL_COLOR_INDEX) {
3662 GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
3663
3664 if (!indexes) {
3665 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3666 free(rgba);
3667 return;
3668 }
3669
3670 extract_uint_indexes(n, indexes, srcFormat, srcType, source,
3671 srcPacking);
3672
3673 /* Convert indexes to RGBA */
3674 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
3675 _mesa_shift_and_offset_ci(ctx, n, indexes);
3676 }
3677 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
3678
3679 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
3680 * with color indexes.
3681 */
3682 transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT);
3683
3684 free(indexes);
3685 }
3686 else {
3687 /* non-color index data */
3688 extract_float_rgba(n, rgba, srcFormat, srcType, source,
3689 srcPacking->SwapBytes);
3690 }
3691
3692 /* Need to clamp if returning GLubytes */
3693 transferOps |= IMAGE_CLAMP_BIT;
3694
3695 if (transferOps) {
3696 _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
3697 }
3698
3699 get_component_indexes(dstFormat,
3700 &rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
3701
3702 /* Now return the GLubyte data in the requested dstFormat */
3703 if (rDst >= 0) {
3704 GLubyte *dst = dest;
3705 GLuint i;
3706 for (i = 0; i < n; i++) {
3707 CLAMPED_FLOAT_TO_UBYTE(dst[rDst], rgba[i][RCOMP]);
3708 dst += dstComponents;
3709 }
3710 }
3711
3712 if (gDst >= 0) {
3713 GLubyte *dst = dest;
3714 GLuint i;
3715 for (i = 0; i < n; i++) {
3716 CLAMPED_FLOAT_TO_UBYTE(dst[gDst], rgba[i][GCOMP]);
3717 dst += dstComponents;
3718 }
3719 }
3720
3721 if (bDst >= 0) {
3722 GLubyte *dst = dest;
3723 GLuint i;
3724 for (i = 0; i < n; i++) {
3725 CLAMPED_FLOAT_TO_UBYTE(dst[bDst], rgba[i][BCOMP]);
3726 dst += dstComponents;
3727 }
3728 }
3729
3730 if (aDst >= 0) {
3731 GLubyte *dst = dest;
3732 GLuint i;
3733 for (i = 0; i < n; i++) {
3734 CLAMPED_FLOAT_TO_UBYTE(dst[aDst], rgba[i][ACOMP]);
3735 dst += dstComponents;
3736 }
3737 }
3738
3739 if (iDst >= 0) {
3740 GLubyte *dst = dest;
3741 GLuint i;
3742 assert(iDst == 0);
3743 assert(dstComponents == 1);
3744 for (i = 0; i < n; i++) {
3745 /* Intensity comes from red channel */
3746 CLAMPED_FLOAT_TO_UBYTE(dst[i], rgba[i][RCOMP]);
3747 }
3748 }
3749
3750 if (lDst >= 0) {
3751 GLubyte *dst = dest;
3752 GLuint i;
3753 assert(lDst == 0);
3754 for (i = 0; i < n; i++) {
3755 /* Luminance comes from red channel */
3756 CLAMPED_FLOAT_TO_UBYTE(dst[0], rgba[i][RCOMP]);
3757 dst += dstComponents;
3758 }
3759 }
3760
3761 free(rgba);
3762 }
3763 }
3764
3765
3766 /**
3767 * Same as _mesa_unpack_color_span_ubyte(), but return GLfloat data
3768 * instead of GLubyte.
3769 */
3770 void
3771 _mesa_unpack_color_span_float( struct gl_context *ctx,
3772 GLuint n, GLenum dstFormat, GLfloat dest[],
3773 GLenum srcFormat, GLenum srcType,
3774 const GLvoid *source,
3775 const struct gl_pixelstore_attrib *srcPacking,
3776 GLbitfield transferOps )
3777 {
3778 ASSERT(dstFormat == GL_ALPHA ||
3779 dstFormat == GL_LUMINANCE ||
3780 dstFormat == GL_LUMINANCE_ALPHA ||
3781 dstFormat == GL_INTENSITY ||
3782 dstFormat == GL_RED ||
3783 dstFormat == GL_RG ||
3784 dstFormat == GL_RGB ||
3785 dstFormat == GL_RGBA);
3786
3787 ASSERT(srcFormat == GL_RED ||
3788 srcFormat == GL_GREEN ||
3789 srcFormat == GL_BLUE ||
3790 srcFormat == GL_ALPHA ||
3791 srcFormat == GL_LUMINANCE ||
3792 srcFormat == GL_LUMINANCE_ALPHA ||
3793 srcFormat == GL_INTENSITY ||
3794 srcFormat == GL_RG ||
3795 srcFormat == GL_RGB ||
3796 srcFormat == GL_BGR ||
3797 srcFormat == GL_RGBA ||
3798 srcFormat == GL_BGRA ||
3799 srcFormat == GL_ABGR_EXT ||
3800 srcFormat == GL_RED_INTEGER_EXT ||
3801 srcFormat == GL_GREEN_INTEGER_EXT ||
3802 srcFormat == GL_BLUE_INTEGER_EXT ||
3803 srcFormat == GL_ALPHA_INTEGER_EXT ||
3804 srcFormat == GL_RG_INTEGER ||
3805 srcFormat == GL_RGB_INTEGER_EXT ||
3806 srcFormat == GL_RGBA_INTEGER_EXT ||
3807 srcFormat == GL_BGR_INTEGER_EXT ||
3808 srcFormat == GL_BGRA_INTEGER_EXT ||
3809 srcFormat == GL_LUMINANCE_INTEGER_EXT ||
3810 srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT ||
3811 srcFormat == GL_COLOR_INDEX);
3812
3813 ASSERT(srcType == GL_BITMAP ||
3814 srcType == GL_UNSIGNED_BYTE ||
3815 srcType == GL_BYTE ||
3816 srcType == GL_UNSIGNED_SHORT ||
3817 srcType == GL_SHORT ||
3818 srcType == GL_UNSIGNED_INT ||
3819 srcType == GL_INT ||
3820 srcType == GL_HALF_FLOAT_ARB ||
3821 srcType == GL_FLOAT ||
3822 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
3823 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
3824 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
3825 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
3826 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
3827 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
3828 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
3829 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
3830 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
3831 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
3832 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
3833 srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
3834 srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
3835 srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
3836
3837 /* general solution, no special cases, yet */
3838 {
3839 GLint dstComponents;
3840 GLint rDst, gDst, bDst, aDst, lDst, iDst;
3841 GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));
3842 GLboolean intFormat = _mesa_is_integer_format(srcFormat);
3843
3844 if (!rgba) {
3845 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3846 return;
3847 }
3848
3849 dstComponents = _mesa_components_in_format( dstFormat );
3850 /* source & dest image formats should have been error checked by now */
3851 assert(dstComponents > 0);
3852
3853 /* EXT_texture_integer specifies no transfer ops on integer
3854 * types in the resolved issues section. Just set them to 0
3855 * for integer surfaces.
3856 */
3857 if (intFormat)
3858 transferOps = 0;
3859
3860 /*
3861 * Extract image data and convert to RGBA floats
3862 */
3863 if (srcFormat == GL_COLOR_INDEX) {
3864 GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
3865
3866 if (!indexes) {
3867 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3868 free(rgba);
3869 return;
3870 }
3871
3872 extract_uint_indexes(n, indexes, srcFormat, srcType, source,
3873 srcPacking);
3874
3875 /* Convert indexes to RGBA */
3876 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
3877 _mesa_shift_and_offset_ci(ctx, n, indexes);
3878 }
3879 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
3880
3881 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
3882 * with color indexes.
3883 */
3884 transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT);
3885
3886 free(indexes);
3887 }
3888 else {
3889 /* non-color index data */
3890 extract_float_rgba(n, rgba, srcFormat, srcType, source,
3891 srcPacking->SwapBytes);
3892 }
3893
3894 if (transferOps) {
3895 _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
3896 }
3897
3898 get_component_indexes(dstFormat,
3899 &rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
3900
3901 /* Now pack results in the requested dstFormat */
3902 if (rDst >= 0) {
3903 GLfloat *dst = dest;
3904 GLuint i;
3905 for (i = 0; i < n; i++) {
3906 dst[rDst] = rgba[i][RCOMP];
3907 dst += dstComponents;
3908 }
3909 }
3910
3911 if (gDst >= 0) {
3912 GLfloat *dst = dest;
3913 GLuint i;
3914 for (i = 0; i < n; i++) {
3915 dst[gDst] = rgba[i][GCOMP];
3916 dst += dstComponents;
3917 }
3918 }
3919
3920 if (bDst >= 0) {
3921 GLfloat *dst = dest;
3922 GLuint i;
3923 for (i = 0; i < n; i++) {
3924 dst[bDst] = rgba[i][BCOMP];
3925 dst += dstComponents;
3926 }
3927 }
3928
3929 if (aDst >= 0) {
3930 GLfloat *dst = dest;
3931 GLuint i;
3932 for (i = 0; i < n; i++) {
3933 dst[aDst] = rgba[i][ACOMP];
3934 dst += dstComponents;
3935 }
3936 }
3937
3938 if (iDst >= 0) {
3939 GLfloat *dst = dest;
3940 GLuint i;
3941 assert(iDst == 0);
3942 assert(dstComponents == 1);
3943 for (i = 0; i < n; i++) {
3944 /* Intensity comes from red channel */
3945 dst[i] = rgba[i][RCOMP];
3946 }
3947 }
3948
3949 if (lDst >= 0) {
3950 GLfloat *dst = dest;
3951 GLuint i;
3952 assert(lDst == 0);
3953 for (i = 0; i < n; i++) {
3954 /* Luminance comes from red channel */
3955 dst[0] = rgba[i][RCOMP];
3956 dst += dstComponents;
3957 }
3958 }
3959
3960 free(rgba);
3961 }
3962 }
3963
3964
3965 /**
3966 * Same as _mesa_unpack_color_span_ubyte(), but return GLuint data
3967 * instead of GLubyte.
3968 * No pixel transfer ops are applied.
3969 */
3970 void
3971 _mesa_unpack_color_span_uint(struct gl_context *ctx,
3972 GLuint n, GLenum dstFormat, GLuint *dest,
3973 GLenum srcFormat, GLenum srcType,
3974 const GLvoid *source,
3975 const struct gl_pixelstore_attrib *srcPacking)
3976 {
3977 GLuint (*rgba)[4] = (GLuint (*)[4]) malloc(n * 4 * sizeof(GLfloat));
3978
3979 if (!rgba) {
3980 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3981 return;
3982 }
3983
3984 ASSERT(dstFormat == GL_ALPHA ||
3985 dstFormat == GL_LUMINANCE ||
3986 dstFormat == GL_LUMINANCE_ALPHA ||
3987 dstFormat == GL_INTENSITY ||
3988 dstFormat == GL_RED ||
3989 dstFormat == GL_RG ||
3990 dstFormat == GL_RGB ||
3991 dstFormat == GL_RGBA);
3992
3993 ASSERT(srcFormat == GL_RED ||
3994 srcFormat == GL_GREEN ||
3995 srcFormat == GL_BLUE ||
3996 srcFormat == GL_ALPHA ||
3997 srcFormat == GL_LUMINANCE ||
3998 srcFormat == GL_LUMINANCE_ALPHA ||
3999 srcFormat == GL_INTENSITY ||
4000 srcFormat == GL_RG ||
4001 srcFormat == GL_RGB ||
4002 srcFormat == GL_BGR ||
4003 srcFormat == GL_RGBA ||
4004 srcFormat == GL_BGRA ||
4005 srcFormat == GL_ABGR_EXT ||
4006 srcFormat == GL_RED_INTEGER_EXT ||
4007 srcFormat == GL_GREEN_INTEGER_EXT ||
4008 srcFormat == GL_BLUE_INTEGER_EXT ||
4009 srcFormat == GL_ALPHA_INTEGER_EXT ||
4010 srcFormat == GL_RG_INTEGER ||
4011 srcFormat == GL_RGB_INTEGER_EXT ||
4012 srcFormat == GL_RGBA_INTEGER_EXT ||
4013 srcFormat == GL_BGR_INTEGER_EXT ||
4014 srcFormat == GL_BGRA_INTEGER_EXT ||
4015 srcFormat == GL_LUMINANCE_INTEGER_EXT ||
4016 srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);
4017
4018 ASSERT(srcType == GL_UNSIGNED_BYTE ||
4019 srcType == GL_BYTE ||
4020 srcType == GL_UNSIGNED_SHORT ||
4021 srcType == GL_SHORT ||
4022 srcType == GL_UNSIGNED_INT ||
4023 srcType == GL_INT ||
4024 srcType == GL_HALF_FLOAT_ARB ||
4025 srcType == GL_FLOAT ||
4026 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
4027 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
4028 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
4029 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
4030 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
4031 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
4032 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
4033 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
4034 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
4035 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
4036 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
4037 srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
4038 srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
4039 srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
4040
4041
4042 /* Extract image data as uint[4] pixels */
4043 extract_uint_rgba(n, rgba, srcFormat, srcType, source,
4044 srcPacking->SwapBytes);
4045
4046 if (dstFormat == GL_RGBA) {
4047 /* simple case */
4048 memcpy(dest, rgba, 4 * sizeof(GLuint) * n);
4049 }
4050 else {
4051 /* general case */
4052 GLint rDst, gDst, bDst, aDst, lDst, iDst;
4053 GLint dstComponents = _mesa_components_in_format( dstFormat );
4054
4055 assert(dstComponents > 0);
4056
4057 get_component_indexes(dstFormat,
4058 &rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
4059
4060 /* Now pack values in the requested dest format */
4061 if (rDst >= 0) {
4062 GLuint *dst = dest;
4063 GLuint i;
4064 for (i = 0; i < n; i++) {
4065 dst[rDst] = rgba[i][RCOMP];
4066 dst += dstComponents;
4067 }
4068 }
4069
4070 if (gDst >= 0) {
4071 GLuint *dst = dest;
4072 GLuint i;
4073 for (i = 0; i < n; i++) {
4074 dst[gDst] = rgba[i][GCOMP];
4075 dst += dstComponents;
4076 }
4077 }
4078
4079 if (bDst >= 0) {
4080 GLuint *dst = dest;
4081 GLuint i;
4082 for (i = 0; i < n; i++) {
4083 dst[bDst] = rgba[i][BCOMP];
4084 dst += dstComponents;
4085 }
4086 }
4087
4088 if (aDst >= 0) {
4089 GLuint *dst = dest;
4090 GLuint i;
4091 for (i = 0; i < n; i++) {
4092 dst[aDst] = rgba[i][ACOMP];
4093 dst += dstComponents;
4094 }
4095 }
4096
4097 if (iDst >= 0) {
4098 GLuint *dst = dest;
4099 GLuint i;
4100 assert(iDst == 0);
4101 assert(dstComponents == 1);
4102 for (i = 0; i < n; i++) {
4103 /* Intensity comes from red channel */
4104 dst[i] = rgba[i][RCOMP];
4105 }
4106 }
4107
4108 if (lDst >= 0) {
4109 GLuint *dst = dest;
4110 GLuint i;
4111 assert(lDst == 0);
4112 for (i = 0; i < n; i++) {
4113 /* Luminance comes from red channel */
4114 dst[0] = rgba[i][RCOMP];
4115 dst += dstComponents;
4116 }
4117 }
4118 }
4119
4120 free(rgba);
4121 }
4122
4123
4124
4125 /**
4126 * Similar to _mesa_unpack_color_span_float(), but for dudv data instead of rgba,
4127 * directly return GLbyte data, no transfer ops apply.
4128 */
4129 void
4130 _mesa_unpack_dudv_span_byte( struct gl_context *ctx,
4131 GLuint n, GLenum dstFormat, GLbyte dest[],
4132 GLenum srcFormat, GLenum srcType,
4133 const GLvoid *source,
4134 const struct gl_pixelstore_attrib *srcPacking,
4135 GLbitfield transferOps )
4136 {
4137 ASSERT(dstFormat == GL_DUDV_ATI);
4138 ASSERT(srcFormat == GL_DUDV_ATI ||
4139 srcFormat == GL_DU8DV8_ATI);
4140
4141 ASSERT(srcType == GL_UNSIGNED_BYTE ||
4142 srcType == GL_BYTE ||
4143 srcType == GL_UNSIGNED_SHORT ||
4144 srcType == GL_SHORT ||
4145 srcType == GL_UNSIGNED_INT ||
4146 srcType == GL_INT ||
4147 srcType == GL_HALF_FLOAT_ARB ||
4148 srcType == GL_FLOAT);
4149
4150 /* general solution */
4151 {
4152 GLint dstComponents;
4153 GLbyte *dst = dest;
4154 GLuint i;
4155 GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));
4156
4157 if (!rgba) {
4158 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
4159 return;
4160 }
4161
4162 dstComponents = _mesa_components_in_format( dstFormat );
4163 /* source & dest image formats should have been error checked by now */
4164 assert(dstComponents > 0);
4165
4166 /*
4167 * Extract image data and convert to RGBA floats
4168 */
4169 extract_float_rgba(n, rgba, srcFormat, srcType, source,
4170 srcPacking->SwapBytes);
4171
4172
4173 /* Now determine which color channels we need to produce.
4174 * And determine the dest index (offset) within each color tuple.
4175 */
4176
4177 /* Now pack results in the requested dstFormat */
4178 for (i = 0; i < n; i++) {
4179 /* not sure - need clamp[-1,1] here? */
4180 dst[0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
4181 dst[1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
4182 dst += dstComponents;
4183 }
4184
4185 free(rgba);
4186 }
4187 }
4188
4189 /*
4190 * Unpack a row of color index data from a client buffer according to
4191 * the pixel unpacking parameters.
4192 * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.
4193 *
4194 * Args: ctx - the context
4195 * n - number of pixels
4196 * dstType - destination data type
4197 * dest - destination array
4198 * srcType - source pixel type
4199 * source - source data pointer
4200 * srcPacking - pixel unpacking parameters
4201 * transferOps - the pixel transfer operations to apply
4202 */
4203 void
4204 _mesa_unpack_index_span( struct gl_context *ctx, GLuint n,
4205 GLenum dstType, GLvoid *dest,
4206 GLenum srcType, const GLvoid *source,
4207 const struct gl_pixelstore_attrib *srcPacking,
4208 GLbitfield transferOps )
4209 {
4210 ASSERT(srcType == GL_BITMAP ||
4211 srcType == GL_UNSIGNED_BYTE ||
4212 srcType == GL_BYTE ||
4213 srcType == GL_UNSIGNED_SHORT ||
4214 srcType == GL_SHORT ||
4215 srcType == GL_UNSIGNED_INT ||
4216 srcType == GL_INT ||
4217 srcType == GL_HALF_FLOAT_ARB ||
4218 srcType == GL_FLOAT);
4219
4220 ASSERT(dstType == GL_UNSIGNED_BYTE ||
4221 dstType == GL_UNSIGNED_SHORT ||
4222 dstType == GL_UNSIGNED_INT);
4223
4224
4225 transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
4226
4227 /*
4228 * Try simple cases first
4229 */
4230 if (transferOps == 0 && srcType == GL_UNSIGNED_BYTE
4231 && dstType == GL_UNSIGNED_BYTE) {
4232 memcpy(dest, source, n * sizeof(GLubyte));
4233 }
4234 else if (transferOps == 0 && srcType == GL_UNSIGNED_INT
4235 && dstType == GL_UNSIGNED_INT && !srcPacking->SwapBytes) {
4236 memcpy(dest, source, n * sizeof(GLuint));
4237 }
4238 else {
4239 /*
4240 * general solution
4241 */
4242 GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
4243
4244 if (!indexes) {
4245 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
4246 return;
4247 }
4248
4249 extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
4250 srcPacking);
4251
4252 if (transferOps)
4253 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
4254
4255 /* convert to dest type */
4256 switch (dstType) {
4257 case GL_UNSIGNED_BYTE:
4258 {
4259 GLubyte *dst = (GLubyte *) dest;
4260 GLuint i;
4261 for (i = 0; i < n; i++) {
4262 dst[i] = (GLubyte) (indexes[i] & 0xff);
4263 }
4264 }
4265 break;
4266 case GL_UNSIGNED_SHORT:
4267 {
4268 GLuint *dst = (GLuint *) dest;
4269 GLuint i;
4270 for (i = 0; i < n; i++) {
4271 dst[i] = (GLushort) (indexes[i] & 0xffff);
4272 }
4273 }
4274 break;
4275 case GL_UNSIGNED_INT:
4276 memcpy(dest, indexes, n * sizeof(GLuint));
4277 break;
4278 default:
4279 _mesa_problem(ctx, "bad dstType in _mesa_unpack_index_span");
4280 }
4281
4282 free(indexes);
4283 }
4284 }
4285
4286
4287 void
4288 _mesa_pack_index_span( struct gl_context *ctx, GLuint n,
4289 GLenum dstType, GLvoid *dest, const GLuint *source,
4290 const struct gl_pixelstore_attrib *dstPacking,
4291 GLbitfield transferOps )
4292 {
4293 GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
4294
4295 if (!indexes) {
4296 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
4297 return;
4298 }
4299
4300 transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
4301
4302 if (transferOps & (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT)) {
4303 /* make a copy of input */
4304 memcpy(indexes, source, n * sizeof(GLuint));
4305 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
4306 source = indexes;
4307 }
4308
4309 switch (dstType) {
4310 case GL_UNSIGNED_BYTE:
4311 {
4312 GLubyte *dst = (GLubyte *) dest;
4313 GLuint i;
4314 for (i = 0; i < n; i++) {
4315 *dst++ = (GLubyte) source[i];
4316 }
4317 }
4318 break;
4319 case GL_BYTE:
4320 {
4321 GLbyte *dst = (GLbyte *) dest;
4322 GLuint i;
4323 for (i = 0; i < n; i++) {
4324 dst[i] = (GLbyte) source[i];
4325 }
4326 }
4327 break;
4328 case GL_UNSIGNED_SHORT:
4329 {
4330 GLushort *dst = (GLushort *) dest;
4331 GLuint i;
4332 for (i = 0; i < n; i++) {
4333 dst[i] = (GLushort) source[i];
4334 }
4335 if (dstPacking->SwapBytes) {
4336 _mesa_swap2( (GLushort *) dst, n );
4337 }
4338 }
4339 break;
4340 case GL_SHORT:
4341 {
4342 GLshort *dst = (GLshort *) dest;
4343 GLuint i;
4344 for (i = 0; i < n; i++) {
4345 dst[i] = (GLshort) source[i];
4346 }
4347 if (dstPacking->SwapBytes) {
4348 _mesa_swap2( (GLushort *) dst, n );
4349 }
4350 }
4351 break;
4352 case GL_UNSIGNED_INT:
4353 {
4354 GLuint *dst = (GLuint *) dest;
4355 GLuint i;
4356 for (i = 0; i < n; i++) {
4357 dst[i] = (GLuint) source[i];
4358 }
4359 if (dstPacking->SwapBytes) {
4360 _mesa_swap4( (GLuint *) dst, n );
4361 }
4362 }
4363 break;
4364 case GL_INT:
4365 {
4366 GLint *dst = (GLint *) dest;
4367 GLuint i;
4368 for (i = 0; i < n; i++) {
4369 dst[i] = (GLint) source[i];
4370 }
4371 if (dstPacking->SwapBytes) {
4372 _mesa_swap4( (GLuint *) dst, n );
4373 }
4374 }
4375 break;
4376 case GL_FLOAT:
4377 {
4378 GLfloat *dst = (GLfloat *) dest;
4379 GLuint i;
4380 for (i = 0; i < n; i++) {
4381 dst[i] = (GLfloat) source[i];
4382 }
4383 if (dstPacking->SwapBytes) {
4384 _mesa_swap4( (GLuint *) dst, n );
4385 }
4386 }
4387 break;
4388 case GL_HALF_FLOAT_ARB:
4389 {
4390 GLhalfARB *dst = (GLhalfARB *) dest;
4391 GLuint i;
4392 for (i = 0; i < n; i++) {
4393 dst[i] = _mesa_float_to_half((GLfloat) source[i]);
4394 }
4395 if (dstPacking->SwapBytes) {
4396 _mesa_swap2( (GLushort *) dst, n );
4397 }
4398 }
4399 break;
4400 default:
4401 _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
4402 }
4403
4404 free(indexes);
4405 }
4406
4407
4408 /*
4409 * Unpack a row of stencil data from a client buffer according to
4410 * the pixel unpacking parameters.
4411 * This is (or will be) used by glDrawPixels
4412 *
4413 * Args: ctx - the context
4414 * n - number of pixels
4415 * dstType - destination data type
4416 * dest - destination array
4417 * srcType - source pixel type
4418 * source - source data pointer
4419 * srcPacking - pixel unpacking parameters
4420 * transferOps - apply offset/bias/lookup ops?
4421 */
4422 void
4423 _mesa_unpack_stencil_span( struct gl_context *ctx, GLuint n,
4424 GLenum dstType, GLvoid *dest,
4425 GLenum srcType, const GLvoid *source,
4426 const struct gl_pixelstore_attrib *srcPacking,
4427 GLbitfield transferOps )
4428 {
4429 ASSERT(srcType == GL_BITMAP ||
4430 srcType == GL_UNSIGNED_BYTE ||
4431 srcType == GL_BYTE ||
4432 srcType == GL_UNSIGNED_SHORT ||
4433 srcType == GL_SHORT ||
4434 srcType == GL_UNSIGNED_INT ||
4435 srcType == GL_INT ||
4436 srcType == GL_UNSIGNED_INT_24_8_EXT ||
4437 srcType == GL_HALF_FLOAT_ARB ||
4438 srcType == GL_FLOAT ||
4439 srcType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
4440
4441 ASSERT(dstType == GL_UNSIGNED_BYTE ||
4442 dstType == GL_UNSIGNED_SHORT ||
4443 dstType == GL_UNSIGNED_INT ||
4444 dstType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
4445
4446 /* only shift and offset apply to stencil */
4447 transferOps &= IMAGE_SHIFT_OFFSET_BIT;
4448
4449 /*
4450 * Try simple cases first
4451 */
4452 if (transferOps == 0 &&
4453 !ctx->Pixel.MapStencilFlag &&
4454 srcType == GL_UNSIGNED_BYTE &&
4455 dstType == GL_UNSIGNED_BYTE) {
4456 memcpy(dest, source, n * sizeof(GLubyte));
4457 }
4458 else if (transferOps == 0 &&
4459 !ctx->Pixel.MapStencilFlag &&
4460 srcType == GL_UNSIGNED_INT &&
4461 dstType == GL_UNSIGNED_INT &&
4462 !srcPacking->SwapBytes) {
4463 memcpy(dest, source, n * sizeof(GLuint));
4464 }
4465 else {
4466 /*
4467 * general solution
4468 */
4469 GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
4470
4471 if (!indexes) {
4472 _mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil unpacking");
4473 return;
4474 }
4475
4476 extract_uint_indexes(n, indexes, GL_STENCIL_INDEX, srcType, source,
4477 srcPacking);
4478
4479 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
4480 /* shift and offset indexes */
4481 _mesa_shift_and_offset_ci(ctx, n, indexes);
4482 }
4483
4484 if (ctx->Pixel.MapStencilFlag) {
4485 /* Apply stencil lookup table */
4486 const GLuint mask = ctx->PixelMaps.StoS.Size - 1;
4487 GLuint i;
4488 for (i = 0; i < n; i++) {
4489 indexes[i] = (GLuint)ctx->PixelMaps.StoS.Map[ indexes[i] & mask ];
4490 }
4491 }
4492
4493 /* convert to dest type */
4494 switch (dstType) {
4495 case GL_UNSIGNED_BYTE:
4496 {
4497 GLubyte *dst = (GLubyte *) dest;
4498 GLuint i;
4499 for (i = 0; i < n; i++) {
4500 dst[i] = (GLubyte) (indexes[i] & 0xff);
4501 }
4502 }
4503 break;
4504 case GL_UNSIGNED_SHORT:
4505 {
4506 GLuint *dst = (GLuint *) dest;
4507 GLuint i;
4508 for (i = 0; i < n; i++) {
4509 dst[i] = (GLushort) (indexes[i] & 0xffff);
4510 }
4511 }
4512 break;
4513 case GL_UNSIGNED_INT:
4514 memcpy(dest, indexes, n * sizeof(GLuint));
4515 break;
4516 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
4517 {
4518 GLuint *dst = (GLuint *) dest;
4519 GLuint i;
4520 for (i = 0; i < n; i++) {
4521 dst[i*2+1] = indexes[i] & 0xff; /* lower 8 bits */
4522 }
4523 }
4524 break;
4525 default:
4526 _mesa_problem(ctx, "bad dstType in _mesa_unpack_stencil_span");
4527 }
4528
4529 free(indexes);
4530 }
4531 }
4532
4533
4534 void
4535 _mesa_pack_stencil_span( struct gl_context *ctx, GLuint n,
4536 GLenum dstType, GLvoid *dest, const GLubyte *source,
4537 const struct gl_pixelstore_attrib *dstPacking )
4538 {
4539 GLubyte *stencil = (GLubyte *) malloc(n * sizeof(GLubyte));
4540
4541 if (!stencil) {
4542 _mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil packing");
4543 return;
4544 }
4545
4546 if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset ||
4547 ctx->Pixel.MapStencilFlag) {
4548 /* make a copy of input */
4549 memcpy(stencil, source, n * sizeof(GLubyte));
4550 _mesa_apply_stencil_transfer_ops(ctx, n, stencil);
4551 source = stencil;
4552 }
4553
4554 switch (dstType) {
4555 case GL_UNSIGNED_BYTE:
4556 memcpy(dest, source, n);
4557 break;
4558 case GL_BYTE:
4559 {
4560 GLbyte *dst = (GLbyte *) dest;
4561 GLuint i;
4562 for (i=0;i<n;i++) {
4563 dst[i] = (GLbyte) (source[i] & 0x7f);
4564 }
4565 }
4566 break;
4567 case GL_UNSIGNED_SHORT:
4568 {
4569 GLushort *dst = (GLushort *) dest;
4570 GLuint i;
4571 for (i=0;i<n;i++) {
4572 dst[i] = (GLushort) source[i];
4573 }
4574 if (dstPacking->SwapBytes) {
4575 _mesa_swap2( (GLushort *) dst, n );
4576 }
4577 }
4578 break;
4579 case GL_SHORT:
4580 {
4581 GLshort *dst = (GLshort *) dest;
4582 GLuint i;
4583 for (i=0;i<n;i++) {
4584 dst[i] = (GLshort) source[i];
4585 }
4586 if (dstPacking->SwapBytes) {
4587 _mesa_swap2( (GLushort *) dst, n );
4588 }
4589 }
4590 break;
4591 case GL_UNSIGNED_INT:
4592 {
4593 GLuint *dst = (GLuint *) dest;
4594 GLuint i;
4595 for (i=0;i<n;i++) {
4596 dst[i] = (GLuint) source[i];
4597 }
4598 if (dstPacking->SwapBytes) {
4599 _mesa_swap4( (GLuint *) dst, n );
4600 }
4601 }
4602 break;
4603 case GL_INT:
4604 {
4605 GLint *dst = (GLint *) dest;
4606 GLuint i;
4607 for (i=0;i<n;i++) {
4608 dst[i] = (GLint) source[i];
4609 }
4610 if (dstPacking->SwapBytes) {
4611 _mesa_swap4( (GLuint *) dst, n );
4612 }
4613 }
4614 break;
4615 case GL_FLOAT:
4616 {
4617 GLfloat *dst = (GLfloat *) dest;
4618 GLuint i;
4619 for (i=0;i<n;i++) {
4620 dst[i] = (GLfloat) source[i];
4621 }
4622 if (dstPacking->SwapBytes) {
4623 _mesa_swap4( (GLuint *) dst, n );
4624 }
4625 }
4626 break;
4627 case GL_HALF_FLOAT_ARB:
4628 {
4629 GLhalfARB *dst = (GLhalfARB *) dest;
4630 GLuint i;
4631 for (i=0;i<n;i++) {
4632 dst[i] = _mesa_float_to_half( (float) source[i] );
4633 }
4634 if (dstPacking->SwapBytes) {
4635 _mesa_swap2( (GLushort *) dst, n );
4636 }
4637 }
4638 break;
4639 case GL_BITMAP:
4640 if (dstPacking->LsbFirst) {
4641 GLubyte *dst = (GLubyte *) dest;
4642 GLint shift = 0;
4643 GLuint i;
4644 for (i = 0; i < n; i++) {
4645 if (shift == 0)
4646 *dst = 0;
4647 *dst |= ((source[i] != 0) << shift);
4648 shift++;
4649 if (shift == 8) {
4650 shift = 0;
4651 dst++;
4652 }
4653 }
4654 }
4655 else {
4656 GLubyte *dst = (GLubyte *) dest;
4657 GLint shift = 7;
4658 GLuint i;
4659 for (i = 0; i < n; i++) {
4660 if (shift == 7)
4661 *dst = 0;
4662 *dst |= ((source[i] != 0) << shift);
4663 shift--;
4664 if (shift < 0) {
4665 shift = 7;
4666 dst++;
4667 }
4668 }
4669 }
4670 break;
4671 default:
4672 _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
4673 }
4674
4675 free(stencil);
4676 }
4677
4678 #define DEPTH_VALUES(GLTYPE, GLTYPE2FLOAT) \
4679 do { \
4680 GLuint i; \
4681 const GLTYPE *src = (const GLTYPE *)source; \
4682 for (i = 0; i < n; i++) { \
4683 GLTYPE value = src[i]; \
4684 if (srcPacking->SwapBytes) { \
4685 if (sizeof(GLTYPE) == 2) { \
4686 SWAP2BYTE(value); \
4687 } else if (sizeof(GLTYPE) == 4) { \
4688 SWAP4BYTE(value); \
4689 } \
4690 } \
4691 depthValues[i] = GLTYPE2FLOAT(value); \
4692 } \
4693 } while (0)
4694
4695
4696 /**
4697 * Unpack a row of depth/z values from memory, returning GLushort, GLuint
4698 * or GLfloat values.
4699 * The glPixelTransfer (scale/bias) params will be applied.
4700 *
4701 * \param dstType one of GL_UNSIGNED_SHORT, GL_UNSIGNED_INT, GL_FLOAT
4702 * \param depthMax max value for returned GLushort or GLuint values
4703 * (ignored for GLfloat).
4704 */
4705 void
4706 _mesa_unpack_depth_span( struct gl_context *ctx, GLuint n,
4707 GLenum dstType, GLvoid *dest, GLuint depthMax,
4708 GLenum srcType, const GLvoid *source,
4709 const struct gl_pixelstore_attrib *srcPacking )
4710 {
4711 GLfloat *depthTemp = NULL, *depthValues;
4712 GLboolean needClamp = GL_FALSE;
4713
4714 /* Look for special cases first.
4715 * Not only are these faster, they're less prone to numeric conversion
4716 * problems. Otherwise, converting from an int type to a float then
4717 * back to an int type can introduce errors that will show up as
4718 * artifacts in things like depth peeling which uses glCopyTexImage.
4719 */
4720 if (ctx->Pixel.DepthScale == 1.0 && ctx->Pixel.DepthBias == 0.0) {
4721 if (srcType == GL_UNSIGNED_INT && dstType == GL_UNSIGNED_SHORT) {
4722 const GLuint *src = (const GLuint *) source;
4723 GLushort *dst = (GLushort *) dest;
4724 GLuint i;
4725 for (i = 0; i < n; i++) {
4726 dst[i] = src[i] >> 16;
4727 }
4728 return;
4729 }
4730 if (srcType == GL_UNSIGNED_SHORT
4731 && dstType == GL_UNSIGNED_INT
4732 && depthMax == 0xffffffff) {
4733 const GLushort *src = (const GLushort *) source;
4734 GLuint *dst = (GLuint *) dest;
4735 GLuint i;
4736 for (i = 0; i < n; i++) {
4737 dst[i] = src[i] | (src[i] << 16);
4738 }
4739 return;
4740 }
4741 if (srcType == GL_UNSIGNED_INT_24_8
4742 && dstType == GL_UNSIGNED_INT
4743 && depthMax == 0xffffff) {
4744 const GLuint *src = (const GLuint *) source;
4745 GLuint *dst = (GLuint *) dest;
4746 GLuint i;
4747 for (i = 0; i < n; i++) {
4748 dst[i] = src[i] >> 8;
4749 }
4750 return;
4751 }
4752 /* XXX may want to add additional cases here someday */
4753 }
4754
4755 /* general case path follows */
4756
4757 if (dstType == GL_FLOAT) {
4758 depthValues = (GLfloat *) dest;
4759 }
4760 else {
4761 depthTemp = (GLfloat *) malloc(n * sizeof(GLfloat));
4762 if (!depthTemp) {
4763 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
4764 return;
4765 }
4766
4767 depthValues = depthTemp;
4768 }
4769
4770 /* Convert incoming values to GLfloat. Some conversions will require
4771 * clamping, below.
4772 */
4773 switch (srcType) {
4774 case GL_BYTE:
4775 DEPTH_VALUES(GLbyte, BYTE_TO_FLOATZ);
4776 needClamp = GL_TRUE;
4777 break;
4778 case GL_UNSIGNED_BYTE:
4779 DEPTH_VALUES(GLubyte, UBYTE_TO_FLOAT);
4780 break;
4781 case GL_SHORT:
4782 DEPTH_VALUES(GLshort, SHORT_TO_FLOATZ);
4783 needClamp = GL_TRUE;
4784 break;
4785 case GL_UNSIGNED_SHORT:
4786 DEPTH_VALUES(GLushort, USHORT_TO_FLOAT);
4787 break;
4788 case GL_INT:
4789 DEPTH_VALUES(GLint, INT_TO_FLOAT);
4790 needClamp = GL_TRUE;
4791 break;
4792 case GL_UNSIGNED_INT:
4793 DEPTH_VALUES(GLuint, UINT_TO_FLOAT);
4794 break;
4795 case GL_UNSIGNED_INT_24_8_EXT: /* GL_EXT_packed_depth_stencil */
4796 if (dstType == GL_UNSIGNED_INT_24_8_EXT &&
4797 depthMax == 0xffffff &&
4798 ctx->Pixel.DepthScale == 1.0 &&
4799 ctx->Pixel.DepthBias == 0.0) {
4800 const GLuint *src = (const GLuint *) source;
4801 GLuint *zValues = (GLuint *) dest;
4802 GLuint i;
4803 for (i = 0; i < n; i++) {
4804 GLuint value = src[i];
4805 if (srcPacking->SwapBytes) {
4806 SWAP4BYTE(value);
4807 }
4808 zValues[i] = value & 0xffffff00;
4809 }
4810 free(depthTemp);
4811 return;
4812 }
4813 else {
4814 const GLuint *src = (const GLuint *) source;
4815 const GLfloat scale = 1.0f / 0xffffff;
4816 GLuint i;
4817 for (i = 0; i < n; i++) {
4818 GLuint value = src[i];
4819 if (srcPacking->SwapBytes) {
4820 SWAP4BYTE(value);
4821 }
4822 depthValues[i] = (value >> 8) * scale;
4823 }
4824 }
4825 break;
4826 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
4827 {
4828 GLuint i;
4829 const GLfloat *src = (const GLfloat *)source;
4830 for (i = 0; i < n; i++) {
4831 GLfloat value = src[i * 2];
4832 if (srcPacking->SwapBytes) {
4833 SWAP4BYTE(value);
4834 }
4835 depthValues[i] = value;
4836 }
4837 needClamp = GL_TRUE;
4838 }
4839 break;
4840 case GL_FLOAT:
4841 DEPTH_VALUES(GLfloat, 1*);
4842 needClamp = GL_TRUE;
4843 break;
4844 case GL_HALF_FLOAT_ARB:
4845 {
4846 GLuint i;
4847 const GLhalfARB *src = (const GLhalfARB *) source;
4848 for (i = 0; i < n; i++) {
4849 GLhalfARB value = src[i];
4850 if (srcPacking->SwapBytes) {
4851 SWAP2BYTE(value);
4852 }
4853 depthValues[i] = _mesa_half_to_float(value);
4854 }
4855 needClamp = GL_TRUE;
4856 }
4857 break;
4858 default:
4859 _mesa_problem(NULL, "bad type in _mesa_unpack_depth_span()");
4860 free(depthTemp);
4861 return;
4862 }
4863
4864 /* apply depth scale and bias */
4865 {
4866 const GLfloat scale = ctx->Pixel.DepthScale;
4867 const GLfloat bias = ctx->Pixel.DepthBias;
4868 if (scale != 1.0 || bias != 0.0) {
4869 GLuint i;
4870 for (i = 0; i < n; i++) {
4871 depthValues[i] = depthValues[i] * scale + bias;
4872 }
4873 needClamp = GL_TRUE;
4874 }
4875 }
4876
4877 /* clamp to [0, 1] */
4878 if (needClamp) {
4879 GLuint i;
4880 for (i = 0; i < n; i++) {
4881 depthValues[i] = (GLfloat)CLAMP(depthValues[i], 0.0, 1.0);
4882 }
4883 }
4884
4885 /*
4886 * Convert values to dstType
4887 */
4888 if (dstType == GL_UNSIGNED_INT) {
4889 GLuint *zValues = (GLuint *) dest;
4890 GLuint i;
4891 if (depthMax <= 0xffffff) {
4892 /* no overflow worries */
4893 for (i = 0; i < n; i++) {
4894 zValues[i] = (GLuint) (depthValues[i] * (GLfloat) depthMax);
4895 }
4896 }
4897 else {
4898 /* need to use double precision to prevent overflow problems */
4899 for (i = 0; i < n; i++) {
4900 GLdouble z = depthValues[i] * (GLfloat) depthMax;
4901 if (z >= (GLdouble) 0xffffffff)
4902 zValues[i] = 0xffffffff;
4903 else
4904 zValues[i] = (GLuint) z;
4905 }
4906 }
4907 }
4908 else if (dstType == GL_UNSIGNED_SHORT) {
4909 GLushort *zValues = (GLushort *) dest;
4910 GLuint i;
4911 ASSERT(depthMax <= 0xffff);
4912 for (i = 0; i < n; i++) {
4913 zValues[i] = (GLushort) (depthValues[i] * (GLfloat) depthMax);
4914 }
4915 }
4916 else if (dstType == GL_FLOAT) {
4917 /* Nothing to do. depthValues is pointing to dest. */
4918 }
4919 else if (dstType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV) {
4920 GLfloat *zValues = (GLfloat*) dest;
4921 GLuint i;
4922 for (i = 0; i < n; i++) {
4923 zValues[i*2] = depthValues[i];
4924 }
4925 }
4926 else {
4927 ASSERT(0);
4928 }
4929
4930 free(depthTemp);
4931 }
4932
4933
4934 /*
4935 * Pack an array of depth values. The values are floats in [0,1].
4936 */
4937 void
4938 _mesa_pack_depth_span( struct gl_context *ctx, GLuint n, GLvoid *dest,
4939 GLenum dstType, const GLfloat *depthSpan,
4940 const struct gl_pixelstore_attrib *dstPacking )
4941 {
4942 GLfloat *depthCopy = (GLfloat *) malloc(n * sizeof(GLfloat));
4943 if (!depthCopy) {
4944 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
4945 return;
4946 }
4947
4948 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
4949 memcpy(depthCopy, depthSpan, n * sizeof(GLfloat));
4950 _mesa_scale_and_bias_depth(ctx, n, depthCopy);
4951 depthSpan = depthCopy;
4952 }
4953
4954 switch (dstType) {
4955 case GL_UNSIGNED_BYTE:
4956 {
4957 GLubyte *dst = (GLubyte *) dest;
4958 GLuint i;
4959 for (i = 0; i < n; i++) {
4960 dst[i] = FLOAT_TO_UBYTE( depthSpan[i] );
4961 }
4962 }
4963 break;
4964 case GL_BYTE:
4965 {
4966 GLbyte *dst = (GLbyte *) dest;
4967 GLuint i;
4968 for (i = 0; i < n; i++) {
4969 dst[i] = FLOAT_TO_BYTE( depthSpan[i] );
4970 }
4971 }
4972 break;
4973 case GL_UNSIGNED_SHORT:
4974 {
4975 GLushort *dst = (GLushort *) dest;
4976 GLuint i;
4977 for (i = 0; i < n; i++) {
4978 CLAMPED_FLOAT_TO_USHORT(dst[i], depthSpan[i]);
4979 }
4980 if (dstPacking->SwapBytes) {
4981 _mesa_swap2( (GLushort *) dst, n );
4982 }
4983 }
4984 break;
4985 case GL_SHORT:
4986 {
4987 GLshort *dst = (GLshort *) dest;
4988 GLuint i;
4989 for (i = 0; i < n; i++) {
4990 dst[i] = FLOAT_TO_SHORT( depthSpan[i] );
4991 }
4992 if (dstPacking->SwapBytes) {
4993 _mesa_swap2( (GLushort *) dst, n );
4994 }
4995 }
4996 break;
4997 case GL_UNSIGNED_INT:
4998 {
4999 GLuint *dst = (GLuint *) dest;
5000 GLuint i;
5001 for (i = 0; i < n; i++) {
5002 dst[i] = FLOAT_TO_UINT( depthSpan[i] );
5003 }
5004 if (dstPacking->SwapBytes) {
5005 _mesa_swap4( (GLuint *) dst, n );
5006 }
5007 }
5008 break;
5009 case GL_INT:
5010 {
5011 GLint *dst = (GLint *) dest;
5012 GLuint i;
5013 for (i = 0; i < n; i++) {
5014 dst[i] = FLOAT_TO_INT( depthSpan[i] );
5015 }
5016 if (dstPacking->SwapBytes) {
5017 _mesa_swap4( (GLuint *) dst, n );
5018 }
5019 }
5020 break;
5021 case GL_FLOAT:
5022 {
5023 GLfloat *dst = (GLfloat *) dest;
5024 GLuint i;
5025 for (i = 0; i < n; i++) {
5026 dst[i] = depthSpan[i];
5027 }
5028 if (dstPacking->SwapBytes) {
5029 _mesa_swap4( (GLuint *) dst, n );
5030 }
5031 }
5032 break;
5033 case GL_HALF_FLOAT_ARB:
5034 {
5035 GLhalfARB *dst = (GLhalfARB *) dest;
5036 GLuint i;
5037 for (i = 0; i < n; i++) {
5038 dst[i] = _mesa_float_to_half(depthSpan[i]);
5039 }
5040 if (dstPacking->SwapBytes) {
5041 _mesa_swap2( (GLushort *) dst, n );
5042 }
5043 }
5044 break;
5045 default:
5046 _mesa_problem(ctx, "bad type in _mesa_pack_depth_span");
5047 }
5048
5049 free(depthCopy);
5050 }
5051
5052
5053
5054 /**
5055 * Pack depth and stencil values as GL_DEPTH_STENCIL (GL_UNSIGNED_INT_24_8 etc)
5056 */
5057 void
5058 _mesa_pack_depth_stencil_span(struct gl_context *ctx,GLuint n,
5059 GLenum dstType, GLuint *dest,
5060 const GLfloat *depthVals,
5061 const GLubyte *stencilVals,
5062 const struct gl_pixelstore_attrib *dstPacking)
5063 {
5064 GLfloat *depthCopy = (GLfloat *) malloc(n * sizeof(GLfloat));
5065 GLubyte *stencilCopy = (GLubyte *) malloc(n * sizeof(GLubyte));
5066 GLuint i;
5067
5068 if (!depthCopy || !stencilCopy) {
5069 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
5070 free(depthCopy);
5071 free(stencilCopy);
5072 return;
5073 }
5074
5075 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
5076 memcpy(depthCopy, depthVals, n * sizeof(GLfloat));
5077 _mesa_scale_and_bias_depth(ctx, n, depthCopy);
5078 depthVals = depthCopy;
5079 }
5080
5081 if (ctx->Pixel.IndexShift ||
5082 ctx->Pixel.IndexOffset ||
5083 ctx->Pixel.MapStencilFlag) {
5084 memcpy(stencilCopy, stencilVals, n * sizeof(GLubyte));
5085 _mesa_apply_stencil_transfer_ops(ctx, n, stencilCopy);
5086 stencilVals = stencilCopy;
5087 }
5088
5089 switch (dstType) {
5090 case GL_UNSIGNED_INT_24_8:
5091 for (i = 0; i < n; i++) {
5092 GLuint z = (GLuint) (depthVals[i] * 0xffffff);
5093 dest[i] = (z << 8) | (stencilVals[i] & 0xff);
5094 }
5095 break;
5096 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
5097 for (i = 0; i < n; i++) {
5098 ((GLfloat*)dest)[i*2] = depthVals[i];
5099 dest[i*2+1] = stencilVals[i] & 0xff;
5100 }
5101 break;
5102 }
5103
5104 if (dstPacking->SwapBytes) {
5105 _mesa_swap4(dest, n);
5106 }
5107
5108 free(depthCopy);
5109 free(stencilCopy);
5110 }
5111
5112
5113
5114
5115 /**
5116 * Unpack image data. Apply byte swapping, byte flipping (bitmap).
5117 * Return all image data in a contiguous block. This is used when we
5118 * compile glDrawPixels, glTexImage, etc into a display list. We
5119 * need a copy of the data in a standard format.
5120 */
5121 void *
5122 _mesa_unpack_image( GLuint dimensions,
5123 GLsizei width, GLsizei height, GLsizei depth,
5124 GLenum format, GLenum type, const GLvoid *pixels,
5125 const struct gl_pixelstore_attrib *unpack )
5126 {
5127 GLint bytesPerRow, compsPerRow;
5128 GLboolean flipBytes, swap2, swap4;
5129
5130 if (!pixels)
5131 return NULL; /* not necessarily an error */
5132
5133 if (width <= 0 || height <= 0 || depth <= 0)
5134 return NULL; /* generate error later */
5135
5136 if (type == GL_BITMAP) {
5137 bytesPerRow = (width + 7) >> 3;
5138 flipBytes = unpack->LsbFirst;
5139 swap2 = swap4 = GL_FALSE;
5140 compsPerRow = 0;
5141 }
5142 else {
5143 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
5144 GLint components = _mesa_components_in_format(format);
5145 GLint bytesPerComp;
5146
5147 if (_mesa_type_is_packed(type))
5148 components = 1;
5149
5150 if (bytesPerPixel <= 0 || components <= 0)
5151 return NULL; /* bad format or type. generate error later */
5152 bytesPerRow = bytesPerPixel * width;
5153 bytesPerComp = bytesPerPixel / components;
5154 flipBytes = GL_FALSE;
5155 swap2 = (bytesPerComp == 2) && unpack->SwapBytes;
5156 swap4 = (bytesPerComp == 4) && unpack->SwapBytes;
5157 compsPerRow = components * width;
5158 assert(compsPerRow >= width);
5159 }
5160
5161 {
5162 GLubyte *destBuffer
5163 = (GLubyte *) malloc(bytesPerRow * height * depth);
5164 GLubyte *dst;
5165 GLint img, row;
5166 if (!destBuffer)
5167 return NULL; /* generate GL_OUT_OF_MEMORY later */
5168
5169 dst = destBuffer;
5170 for (img = 0; img < depth; img++) {
5171 for (row = 0; row < height; row++) {
5172 const GLvoid *src = _mesa_image_address(dimensions, unpack, pixels,
5173 width, height, format, type, img, row, 0);
5174
5175 if ((type == GL_BITMAP) && (unpack->SkipPixels & 0x7)) {
5176 GLint i;
5177 flipBytes = GL_FALSE;
5178 if (unpack->LsbFirst) {
5179 GLubyte srcMask = 1 << (unpack->SkipPixels & 0x7);
5180 GLubyte dstMask = 128;
5181 const GLubyte *s = src;
5182 GLubyte *d = dst;
5183 *d = 0;
5184 for (i = 0; i < width; i++) {
5185 if (*s & srcMask) {
5186 *d |= dstMask;
5187 }
5188 if (srcMask == 128) {
5189 srcMask = 1;
5190 s++;
5191 }
5192 else {
5193 srcMask = srcMask << 1;
5194 }
5195 if (dstMask == 1) {
5196 dstMask = 128;
5197 d++;
5198 *d = 0;
5199 }
5200 else {
5201 dstMask = dstMask >> 1;
5202 }
5203 }
5204 }
5205 else {
5206 GLubyte srcMask = 128 >> (unpack->SkipPixels & 0x7);
5207 GLubyte dstMask = 128;
5208 const GLubyte *s = src;
5209 GLubyte *d = dst;
5210 *d = 0;
5211 for (i = 0; i < width; i++) {
5212 if (*s & srcMask) {
5213 *d |= dstMask;
5214 }
5215 if (srcMask == 1) {
5216 srcMask = 128;
5217 s++;
5218 }
5219 else {
5220 srcMask = srcMask >> 1;
5221 }
5222 if (dstMask == 1) {
5223 dstMask = 128;
5224 d++;
5225 *d = 0;
5226 }
5227 else {
5228 dstMask = dstMask >> 1;
5229 }
5230 }
5231 }
5232 }
5233 else {
5234 memcpy(dst, src, bytesPerRow);
5235 }
5236
5237 /* byte flipping/swapping */
5238 if (flipBytes) {
5239 flip_bytes((GLubyte *) dst, bytesPerRow);
5240 }
5241 else if (swap2) {
5242 _mesa_swap2((GLushort*) dst, compsPerRow);
5243 }
5244 else if (swap4) {
5245 _mesa_swap4((GLuint*) dst, compsPerRow);
5246 }
5247 dst += bytesPerRow;
5248 }
5249 }
5250 return destBuffer;
5251 }
5252 }
5253