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