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