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