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