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