projects / reactos.git / blob
? search:


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