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