projects / mesa.git / blob
? search:


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