projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
image/pack: fix missing GL_BGR(A)_INTEGER support.
[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 * Common situation, loading 8bit RGBA/RGB source images
3616 * into 16/32 bit destination. (OSMesa16/32)
3617 */
3618 else if (srcType == GL_UNSIGNED_BYTE) {
3619 if (dstFormat == GL_RGBA) {
3620 if (srcFormat == GL_RGB) {
3621 GLuint i;
3622 const GLubyte *src = (const GLubyte *) source;
3623 GLubyte *dst = dest;
3624 for (i = 0; i < n; i++) {
3625 dst[0] = src[0];
3626 dst[1] = src[1];
3627 dst[2] = src[2];
3628 dst[3] = 255;
3629 src += 3;
3630 dst += 4;
3631 }
3632 return;
3633 }
3634 else if (srcFormat == GL_RGBA) {
3635 GLuint i;
3636 const GLubyte *src = (const GLubyte *) source;
3637 GLubyte *dst = dest;
3638 for (i = 0; i < n; i++) {
3639 dst[0] = src[0];
3640 dst[1] = src[1];
3641 dst[2] = src[2];
3642 dst[3] = src[3];
3643 src += 4;
3644 dst += 4;
3645 }
3646 return;
3647 }
3648 }
3649 else if (dstFormat == GL_RGB) {
3650 if (srcFormat == GL_RGB) {
3651 GLuint i;
3652 const GLubyte *src = (const GLubyte *) source;
3653 GLubyte *dst = dest;
3654 for (i = 0; i < n; i++) {
3655 dst[0] = src[0];
3656 dst[1] = src[1];
3657 dst[2] = src[2];
3658 src += 3;
3659 dst += 3;
3660 }
3661 return;
3662 }
3663 else if (srcFormat == GL_RGBA) {
3664 GLuint i;
3665 const GLubyte *src = (const GLubyte *) source;
3666 GLubyte *dst = dest;
3667 for (i = 0; i < n; i++) {
3668 dst[0] = src[0];
3669 dst[1] = src[1];
3670 dst[2] = src[2];
3671 src += 4;
3672 dst += 3;
3673 }
3674 return;
3675 }
3676 }
3677 }
3678 }
3679
3680
3681 /* general solution begins here */
3682 {
3683 GLint dstComponents;
3684 GLint rDst, gDst, bDst, aDst, lDst, iDst;
3685 GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));
3686
3687 if (!rgba) {
3688 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3689 return;
3690 }
3691
3692 dstComponents = _mesa_components_in_format( dstFormat );
3693 /* source & dest image formats should have been error checked by now */
3694 assert(dstComponents > 0);
3695
3696 /*
3697 * Extract image data and convert to RGBA floats
3698 */
3699 if (srcFormat == GL_COLOR_INDEX) {
3700 GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
3701
3702 if (!indexes) {
3703 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3704 free(rgba);
3705 return;
3706 }
3707
3708 extract_uint_indexes(n, indexes, srcFormat, srcType, source,
3709 srcPacking);
3710
3711 /* Convert indexes to RGBA */
3712 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
3713 _mesa_shift_and_offset_ci(ctx, n, indexes);
3714 }
3715 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
3716
3717 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
3718 * with color indexes.
3719 */
3720 transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT);
3721
3722 free(indexes);
3723 }
3724 else {
3725 /* non-color index data */
3726 extract_float_rgba(n, rgba, srcFormat, srcType, source,
3727 srcPacking->SwapBytes);
3728 }
3729
3730 /* Need to clamp if returning GLubytes */
3731 transferOps |= IMAGE_CLAMP_BIT;
3732
3733 if (transferOps) {
3734 _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
3735 }
3736
3737 get_component_indexes(dstFormat,
3738 &rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
3739
3740 /* Now return the GLubyte data in the requested dstFormat */
3741 if (rDst >= 0) {
3742 GLubyte *dst = dest;
3743 GLuint i;
3744 for (i = 0; i < n; i++) {
3745 CLAMPED_FLOAT_TO_UBYTE(dst[rDst], rgba[i][RCOMP]);
3746 dst += dstComponents;
3747 }
3748 }
3749
3750 if (gDst >= 0) {
3751 GLubyte *dst = dest;
3752 GLuint i;
3753 for (i = 0; i < n; i++) {
3754 CLAMPED_FLOAT_TO_UBYTE(dst[gDst], rgba[i][GCOMP]);
3755 dst += dstComponents;
3756 }
3757 }
3758
3759 if (bDst >= 0) {
3760 GLubyte *dst = dest;
3761 GLuint i;
3762 for (i = 0; i < n; i++) {
3763 CLAMPED_FLOAT_TO_UBYTE(dst[bDst], rgba[i][BCOMP]);
3764 dst += dstComponents;
3765 }
3766 }
3767
3768 if (aDst >= 0) {
3769 GLubyte *dst = dest;
3770 GLuint i;
3771 for (i = 0; i < n; i++) {
3772 CLAMPED_FLOAT_TO_UBYTE(dst[aDst], rgba[i][ACOMP]);
3773 dst += dstComponents;
3774 }
3775 }
3776
3777 if (iDst >= 0) {
3778 GLubyte *dst = dest;
3779 GLuint i;
3780 assert(iDst == 0);
3781 assert(dstComponents == 1);
3782 for (i = 0; i < n; i++) {
3783 /* Intensity comes from red channel */
3784 CLAMPED_FLOAT_TO_UBYTE(dst[i], rgba[i][RCOMP]);
3785 }
3786 }
3787
3788 if (lDst >= 0) {
3789 GLubyte *dst = dest;
3790 GLuint i;
3791 assert(lDst == 0);
3792 for (i = 0; i < n; i++) {
3793 /* Luminance comes from red channel */
3794 CLAMPED_FLOAT_TO_UBYTE(dst[0], rgba[i][RCOMP]);
3795 dst += dstComponents;
3796 }
3797 }
3798
3799 free(rgba);
3800 }
3801 }
3802
3803
3804 /**
3805 * Same as _mesa_unpack_color_span_ubyte(), but return GLfloat data
3806 * instead of GLubyte.
3807 */
3808 void
3809 _mesa_unpack_color_span_float( struct gl_context *ctx,
3810 GLuint n, GLenum dstFormat, GLfloat dest[],
3811 GLenum srcFormat, GLenum srcType,
3812 const GLvoid *source,
3813 const struct gl_pixelstore_attrib *srcPacking,
3814 GLbitfield transferOps )
3815 {
3816 ASSERT(dstFormat == GL_ALPHA ||
3817 dstFormat == GL_LUMINANCE ||
3818 dstFormat == GL_LUMINANCE_ALPHA ||
3819 dstFormat == GL_INTENSITY ||
3820 dstFormat == GL_RED ||
3821 dstFormat == GL_RG ||
3822 dstFormat == GL_RGB ||
3823 dstFormat == GL_RGBA);
3824
3825 ASSERT(srcFormat == GL_RED ||
3826 srcFormat == GL_GREEN ||
3827 srcFormat == GL_BLUE ||
3828 srcFormat == GL_ALPHA ||
3829 srcFormat == GL_LUMINANCE ||
3830 srcFormat == GL_LUMINANCE_ALPHA ||
3831 srcFormat == GL_INTENSITY ||
3832 srcFormat == GL_RG ||
3833 srcFormat == GL_RGB ||
3834 srcFormat == GL_BGR ||
3835 srcFormat == GL_RGBA ||
3836 srcFormat == GL_BGRA ||
3837 srcFormat == GL_ABGR_EXT ||
3838 srcFormat == GL_RED_INTEGER_EXT ||
3839 srcFormat == GL_GREEN_INTEGER_EXT ||
3840 srcFormat == GL_BLUE_INTEGER_EXT ||
3841 srcFormat == GL_ALPHA_INTEGER_EXT ||
3842 srcFormat == GL_RGB_INTEGER_EXT ||
3843 srcFormat == GL_RGBA_INTEGER_EXT ||
3844 srcFormat == GL_BGR_INTEGER_EXT ||
3845 srcFormat == GL_BGRA_INTEGER_EXT ||
3846 srcFormat == GL_LUMINANCE_INTEGER_EXT ||
3847 srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT ||
3848 srcFormat == GL_COLOR_INDEX);
3849
3850 ASSERT(srcType == GL_BITMAP ||
3851 srcType == GL_UNSIGNED_BYTE ||
3852 srcType == GL_BYTE ||
3853 srcType == GL_UNSIGNED_SHORT ||
3854 srcType == GL_SHORT ||
3855 srcType == GL_UNSIGNED_INT ||
3856 srcType == GL_INT ||
3857 srcType == GL_HALF_FLOAT_ARB ||
3858 srcType == GL_FLOAT ||
3859 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
3860 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
3861 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
3862 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
3863 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
3864 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
3865 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
3866 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
3867 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
3868 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
3869 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
3870 srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
3871 srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
3872 srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
3873
3874 /* general solution, no special cases, yet */
3875 {
3876 GLint dstComponents;
3877 GLint rDst, gDst, bDst, aDst, lDst, iDst;
3878 GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));
3879 GLboolean intFormat = _mesa_is_integer_format(srcFormat);
3880
3881 if (!rgba) {
3882 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3883 return;
3884 }
3885
3886 dstComponents = _mesa_components_in_format( dstFormat );
3887 /* source & dest image formats should have been error checked by now */
3888 assert(dstComponents > 0);
3889
3890 /* EXT_texture_integer specifies no transfer ops on integer
3891 * types in the resolved issues section. Just set them to 0
3892 * for integer surfaces.
3893 */
3894 if (intFormat)
3895 transferOps = 0;
3896
3897 /*
3898 * Extract image data and convert to RGBA floats
3899 */
3900 if (srcFormat == GL_COLOR_INDEX) {
3901 GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
3902
3903 if (!indexes) {
3904 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3905 free(rgba);
3906 return;
3907 }
3908
3909 extract_uint_indexes(n, indexes, srcFormat, srcType, source,
3910 srcPacking);
3911
3912 /* Convert indexes to RGBA */
3913 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
3914 _mesa_shift_and_offset_ci(ctx, n, indexes);
3915 }
3916 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
3917
3918 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
3919 * with color indexes.
3920 */
3921 transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT);
3922
3923 free(indexes);
3924 }
3925 else {
3926 /* non-color index data */
3927 extract_float_rgba(n, rgba, srcFormat, srcType, source,
3928 srcPacking->SwapBytes);
3929 }
3930
3931 if (transferOps) {
3932 _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
3933 }
3934
3935 get_component_indexes(dstFormat,
3936 &rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
3937
3938 /* Now pack results in the requested dstFormat */
3939 if (rDst >= 0) {
3940 GLfloat *dst = dest;
3941 GLuint i;
3942 for (i = 0; i < n; i++) {
3943 dst[rDst] = rgba[i][RCOMP];
3944 dst += dstComponents;
3945 }
3946 }
3947
3948 if (gDst >= 0) {
3949 GLfloat *dst = dest;
3950 GLuint i;
3951 for (i = 0; i < n; i++) {
3952 dst[gDst] = rgba[i][GCOMP];
3953 dst += dstComponents;
3954 }
3955 }
3956
3957 if (bDst >= 0) {
3958 GLfloat *dst = dest;
3959 GLuint i;
3960 for (i = 0; i < n; i++) {
3961 dst[bDst] = rgba[i][BCOMP];
3962 dst += dstComponents;
3963 }
3964 }
3965
3966 if (aDst >= 0) {
3967 GLfloat *dst = dest;
3968 GLuint i;
3969 for (i = 0; i < n; i++) {
3970 dst[aDst] = rgba[i][ACOMP];
3971 dst += dstComponents;
3972 }
3973 }
3974
3975 if (iDst >= 0) {
3976 GLfloat *dst = dest;
3977 GLuint i;
3978 assert(iDst == 0);
3979 assert(dstComponents == 1);
3980 for (i = 0; i < n; i++) {
3981 /* Intensity comes from red channel */
3982 dst[i] = rgba[i][RCOMP];
3983 }
3984 }
3985
3986 if (lDst >= 0) {
3987 GLfloat *dst = dest;
3988 GLuint i;
3989 assert(lDst == 0);
3990 for (i = 0; i < n; i++) {
3991 /* Luminance comes from red channel */
3992 dst[0] = rgba[i][RCOMP];
3993 dst += dstComponents;
3994 }
3995 }
3996
3997 free(rgba);
3998 }
3999 }
4000
4001
4002 /**
4003 * Same as _mesa_unpack_color_span_ubyte(), but return GLuint data
4004 * instead of GLubyte.
4005 * No pixel transfer ops are applied.
4006 */
4007 void
4008 _mesa_unpack_color_span_uint(struct gl_context *ctx,
4009 GLuint n, GLenum dstFormat, GLuint *dest,
4010 GLenum srcFormat, GLenum srcType,
4011 const GLvoid *source,
4012 const struct gl_pixelstore_attrib *srcPacking)
4013 {
4014 GLuint (*rgba)[4] = (GLuint (*)[4]) malloc(n * 4 * sizeof(GLfloat));
4015
4016 if (!rgba) {
4017 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
4018 return;
4019 }
4020
4021 ASSERT(dstFormat == GL_ALPHA ||
4022 dstFormat == GL_LUMINANCE ||
4023 dstFormat == GL_LUMINANCE_ALPHA ||
4024 dstFormat == GL_INTENSITY ||
4025 dstFormat == GL_RED ||
4026 dstFormat == GL_RG ||
4027 dstFormat == GL_RGB ||
4028 dstFormat == GL_RGBA);
4029
4030 ASSERT(srcFormat == GL_RED ||
4031 srcFormat == GL_GREEN ||
4032 srcFormat == GL_BLUE ||
4033 srcFormat == GL_ALPHA ||
4034 srcFormat == GL_LUMINANCE ||
4035 srcFormat == GL_LUMINANCE_ALPHA ||
4036 srcFormat == GL_INTENSITY ||
4037 srcFormat == GL_RG ||
4038 srcFormat == GL_RGB ||
4039 srcFormat == GL_BGR ||
4040 srcFormat == GL_RGBA ||
4041 srcFormat == GL_BGRA ||
4042 srcFormat == GL_ABGR_EXT ||
4043 srcFormat == GL_RED_INTEGER_EXT ||
4044 srcFormat == GL_GREEN_INTEGER_EXT ||
4045 srcFormat == GL_BLUE_INTEGER_EXT ||
4046 srcFormat == GL_ALPHA_INTEGER_EXT ||
4047 srcFormat == GL_RGB_INTEGER_EXT ||
4048 srcFormat == GL_RGBA_INTEGER_EXT ||
4049 srcFormat == GL_BGR_INTEGER_EXT ||
4050 srcFormat == GL_BGRA_INTEGER_EXT ||
4051 srcFormat == GL_LUMINANCE_INTEGER_EXT ||
4052 srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);
4053
4054 ASSERT(srcType == GL_UNSIGNED_BYTE ||
4055 srcType == GL_BYTE ||
4056 srcType == GL_UNSIGNED_SHORT ||
4057 srcType == GL_SHORT ||
4058 srcType == GL_UNSIGNED_INT ||
4059 srcType == GL_INT ||
4060 srcType == GL_HALF_FLOAT_ARB ||
4061 srcType == GL_FLOAT ||
4062 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
4063 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
4064 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
4065 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
4066 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
4067 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
4068 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
4069 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
4070 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
4071 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
4072 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
4073 srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
4074 srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
4075 srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
4076
4077
4078 /* Extract image data as uint[4] pixels */
4079 extract_uint_rgba(n, rgba, srcFormat, srcType, source,
4080 srcPacking->SwapBytes);
4081
4082 if (dstFormat == GL_RGBA) {
4083 /* simple case */
4084 memcpy(dest, rgba, 4 * sizeof(GLuint) * n);
4085 }
4086 else {
4087 /* general case */
4088 GLint rDst, gDst, bDst, aDst, lDst, iDst;
4089 GLint dstComponents = _mesa_components_in_format( dstFormat );
4090
4091 assert(dstComponents > 0);
4092
4093 get_component_indexes(dstFormat,
4094 &rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
4095
4096 /* Now pack values in the requested dest format */
4097 if (rDst >= 0) {
4098 GLuint *dst = dest;
4099 GLuint i;
4100 for (i = 0; i < n; i++) {
4101 dst[rDst] = rgba[i][RCOMP];
4102 dst += dstComponents;
4103 }
4104 }
4105
4106 if (gDst >= 0) {
4107 GLuint *dst = dest;
4108 GLuint i;
4109 for (i = 0; i < n; i++) {
4110 dst[gDst] = rgba[i][GCOMP];
4111 dst += dstComponents;
4112 }
4113 }
4114
4115 if (bDst >= 0) {
4116 GLuint *dst = dest;
4117 GLuint i;
4118 for (i = 0; i < n; i++) {
4119 dst[bDst] = rgba[i][BCOMP];
4120 dst += dstComponents;
4121 }
4122 }
4123
4124 if (aDst >= 0) {
4125 GLuint *dst = dest;
4126 GLuint i;
4127 for (i = 0; i < n; i++) {
4128 dst[aDst] = rgba[i][ACOMP];
4129 dst += dstComponents;
4130 }
4131 }
4132
4133 if (iDst >= 0) {
4134 GLuint *dst = dest;
4135 GLuint i;
4136 assert(iDst == 0);
4137 assert(dstComponents == 1);
4138 for (i = 0; i < n; i++) {
4139 /* Intensity comes from red channel */
4140 dst[i] = rgba[i][RCOMP];
4141 }
4142 }
4143
4144 if (lDst >= 0) {
4145 GLuint *dst = dest;
4146 GLuint i;
4147 assert(lDst == 0);
4148 for (i = 0; i < n; i++) {
4149 /* Luminance comes from red channel */
4150 dst[0] = rgba[i][RCOMP];
4151 dst += dstComponents;
4152 }
4153 }
4154 }
4155
4156 free(rgba);
4157 }
4158
4159
4160
4161 /**
4162 * Similar to _mesa_unpack_color_span_float(), but for dudv data instead of rgba,
4163 * directly return GLbyte data, no transfer ops apply.
4164 */
4165 void
4166 _mesa_unpack_dudv_span_byte( struct gl_context *ctx,
4167 GLuint n, GLenum dstFormat, GLbyte dest[],
4168 GLenum srcFormat, GLenum srcType,
4169 const GLvoid *source,
4170 const struct gl_pixelstore_attrib *srcPacking,
4171 GLbitfield transferOps )
4172 {
4173 ASSERT(dstFormat == GL_DUDV_ATI);
4174 ASSERT(srcFormat == GL_DUDV_ATI ||
4175 srcFormat == GL_DU8DV8_ATI);
4176
4177 ASSERT(srcType == GL_UNSIGNED_BYTE ||
4178 srcType == GL_BYTE ||
4179 srcType == GL_UNSIGNED_SHORT ||
4180 srcType == GL_SHORT ||
4181 srcType == GL_UNSIGNED_INT ||
4182 srcType == GL_INT ||
4183 srcType == GL_HALF_FLOAT_ARB ||
4184 srcType == GL_FLOAT);
4185
4186 /* general solution */
4187 {
4188 GLint dstComponents;
4189 GLbyte *dst = dest;
4190 GLuint i;
4191 GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));
4192
4193 if (!rgba) {
4194 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
4195 return;
4196 }
4197
4198 dstComponents = _mesa_components_in_format( dstFormat );
4199 /* source & dest image formats should have been error checked by now */
4200 assert(dstComponents > 0);
4201
4202 /*
4203 * Extract image data and convert to RGBA floats
4204 */
4205 extract_float_rgba(n, rgba, srcFormat, srcType, source,
4206 srcPacking->SwapBytes);
4207
4208
4209 /* Now determine which color channels we need to produce.
4210 * And determine the dest index (offset) within each color tuple.
4211 */
4212
4213 /* Now pack results in the requested dstFormat */
4214 for (i = 0; i < n; i++) {
4215 /* not sure - need clamp[-1,1] here? */
4216 dst[0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
4217 dst[1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
4218 dst += dstComponents;
4219 }
4220
4221 free(rgba);
4222 }
4223 }
4224
4225 /*
4226 * Unpack a row of color index data from a client buffer according to
4227 * the pixel unpacking parameters.
4228 * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.
4229 *
4230 * Args: ctx - the context
4231 * n - number of pixels
4232 * dstType - destination data type
4233 * dest - destination array
4234 * srcType - source pixel type
4235 * source - source data pointer
4236 * srcPacking - pixel unpacking parameters
4237 * transferOps - the pixel transfer operations to apply
4238 */
4239 void
4240 _mesa_unpack_index_span( struct gl_context *ctx, GLuint n,
4241 GLenum dstType, GLvoid *dest,
4242 GLenum srcType, const GLvoid *source,
4243 const struct gl_pixelstore_attrib *srcPacking,
4244 GLbitfield transferOps )
4245 {
4246 ASSERT(srcType == GL_BITMAP ||
4247 srcType == GL_UNSIGNED_BYTE ||
4248 srcType == GL_BYTE ||
4249 srcType == GL_UNSIGNED_SHORT ||
4250 srcType == GL_SHORT ||
4251 srcType == GL_UNSIGNED_INT ||
4252 srcType == GL_INT ||
4253 srcType == GL_HALF_FLOAT_ARB ||
4254 srcType == GL_FLOAT);
4255
4256 ASSERT(dstType == GL_UNSIGNED_BYTE ||
4257 dstType == GL_UNSIGNED_SHORT ||
4258 dstType == GL_UNSIGNED_INT);
4259
4260
4261 transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
4262
4263 /*
4264 * Try simple cases first
4265 */
4266 if (transferOps == 0 && srcType == GL_UNSIGNED_BYTE
4267 && dstType == GL_UNSIGNED_BYTE) {
4268 memcpy(dest, source, n * sizeof(GLubyte));
4269 }
4270 else if (transferOps == 0 && srcType == GL_UNSIGNED_INT
4271 && dstType == GL_UNSIGNED_INT && !srcPacking->SwapBytes) {
4272 memcpy(dest, source, n * sizeof(GLuint));
4273 }
4274 else {
4275 /*
4276 * general solution
4277 */
4278 GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
4279
4280 if (!indexes) {
4281 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
4282 return;
4283 }
4284
4285 extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
4286 srcPacking);
4287
4288 if (transferOps)
4289 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
4290
4291 /* convert to dest type */
4292 switch (dstType) {
4293 case GL_UNSIGNED_BYTE:
4294 {
4295 GLubyte *dst = (GLubyte *) dest;
4296 GLuint i;
4297 for (i = 0; i < n; i++) {
4298 dst[i] = (GLubyte) (indexes[i] & 0xff);
4299 }
4300 }
4301 break;
4302 case GL_UNSIGNED_SHORT:
4303 {
4304 GLuint *dst = (GLuint *) dest;
4305 GLuint i;
4306 for (i = 0; i < n; i++) {
4307 dst[i] = (GLushort) (indexes[i] & 0xffff);
4308 }
4309 }
4310 break;
4311 case GL_UNSIGNED_INT:
4312 memcpy(dest, indexes, n * sizeof(GLuint));
4313 break;
4314 default:
4315 _mesa_problem(ctx, "bad dstType in _mesa_unpack_index_span");
4316 }
4317
4318 free(indexes);
4319 }
4320 }
4321
4322
4323 void
4324 _mesa_pack_index_span( struct gl_context *ctx, GLuint n,
4325 GLenum dstType, GLvoid *dest, const GLuint *source,
4326 const struct gl_pixelstore_attrib *dstPacking,
4327 GLbitfield transferOps )
4328 {
4329 GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
4330
4331 if (!indexes) {
4332 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
4333 return;
4334 }
4335
4336 transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
4337
4338 if (transferOps & (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT)) {
4339 /* make a copy of input */
4340 memcpy(indexes, source, n * sizeof(GLuint));
4341 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
4342 source = indexes;
4343 }
4344
4345 switch (dstType) {
4346 case GL_UNSIGNED_BYTE:
4347 {
4348 GLubyte *dst = (GLubyte *) dest;
4349 GLuint i;
4350 for (i = 0; i < n; i++) {
4351 *dst++ = (GLubyte) source[i];
4352 }
4353 }
4354 break;
4355 case GL_BYTE:
4356 {
4357 GLbyte *dst = (GLbyte *) dest;
4358 GLuint i;
4359 for (i = 0; i < n; i++) {
4360 dst[i] = (GLbyte) source[i];
4361 }
4362 }
4363 break;
4364 case GL_UNSIGNED_SHORT:
4365 {
4366 GLushort *dst = (GLushort *) dest;
4367 GLuint i;
4368 for (i = 0; i < n; i++) {
4369 dst[i] = (GLushort) source[i];
4370 }
4371 if (dstPacking->SwapBytes) {
4372 _mesa_swap2( (GLushort *) dst, n );
4373 }
4374 }
4375 break;
4376 case GL_SHORT:
4377 {
4378 GLshort *dst = (GLshort *) dest;
4379 GLuint i;
4380 for (i = 0; i < n; i++) {
4381 dst[i] = (GLshort) source[i];
4382 }
4383 if (dstPacking->SwapBytes) {
4384 _mesa_swap2( (GLushort *) dst, n );
4385 }
4386 }
4387 break;
4388 case GL_UNSIGNED_INT:
4389 {
4390 GLuint *dst = (GLuint *) dest;
4391 GLuint i;
4392 for (i = 0; i < n; i++) {
4393 dst[i] = (GLuint) source[i];
4394 }
4395 if (dstPacking->SwapBytes) {
4396 _mesa_swap4( (GLuint *) dst, n );
4397 }
4398 }
4399 break;
4400 case GL_INT:
4401 {
4402 GLint *dst = (GLint *) dest;
4403 GLuint i;
4404 for (i = 0; i < n; i++) {
4405 dst[i] = (GLint) source[i];
4406 }
4407 if (dstPacking->SwapBytes) {
4408 _mesa_swap4( (GLuint *) dst, n );
4409 }
4410 }
4411 break;
4412 case GL_FLOAT:
4413 {
4414 GLfloat *dst = (GLfloat *) dest;
4415 GLuint i;
4416 for (i = 0; i < n; i++) {
4417 dst[i] = (GLfloat) source[i];
4418 }
4419 if (dstPacking->SwapBytes) {
4420 _mesa_swap4( (GLuint *) dst, n );
4421 }
4422 }
4423 break;
4424 case GL_HALF_FLOAT_ARB:
4425 {
4426 GLhalfARB *dst = (GLhalfARB *) dest;
4427 GLuint i;
4428 for (i = 0; i < n; i++) {
4429 dst[i] = _mesa_float_to_half((GLfloat) source[i]);
4430 }
4431 if (dstPacking->SwapBytes) {
4432 _mesa_swap2( (GLushort *) dst, n );
4433 }
4434 }
4435 break;
4436 default:
4437 _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
4438 }
4439
4440 free(indexes);
4441 }
4442
4443
4444 /*
4445 * Unpack a row of stencil data from a client buffer according to
4446 * the pixel unpacking parameters.
4447 * This is (or will be) used by glDrawPixels
4448 *
4449 * Args: ctx - the context
4450 * n - number of pixels
4451 * dstType - destination data type
4452 * dest - destination array
4453 * srcType - source pixel type
4454 * source - source data pointer
4455 * srcPacking - pixel unpacking parameters
4456 * transferOps - apply offset/bias/lookup ops?
4457 */
4458 void
4459 _mesa_unpack_stencil_span( struct gl_context *ctx, GLuint n,
4460 GLenum dstType, GLvoid *dest,
4461 GLenum srcType, const GLvoid *source,
4462 const struct gl_pixelstore_attrib *srcPacking,
4463 GLbitfield transferOps )
4464 {
4465 ASSERT(srcType == GL_BITMAP ||
4466 srcType == GL_UNSIGNED_BYTE ||
4467 srcType == GL_BYTE ||
4468 srcType == GL_UNSIGNED_SHORT ||
4469 srcType == GL_SHORT ||
4470 srcType == GL_UNSIGNED_INT ||
4471 srcType == GL_INT ||
4472 srcType == GL_UNSIGNED_INT_24_8_EXT ||
4473 srcType == GL_HALF_FLOAT_ARB ||
4474 srcType == GL_FLOAT ||
4475 srcType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
4476
4477 ASSERT(dstType == GL_UNSIGNED_BYTE ||
4478 dstType == GL_UNSIGNED_SHORT ||
4479 dstType == GL_UNSIGNED_INT ||
4480 dstType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
4481
4482 /* only shift and offset apply to stencil */
4483 transferOps &= IMAGE_SHIFT_OFFSET_BIT;
4484
4485 /*
4486 * Try simple cases first
4487 */
4488 if (transferOps == 0 &&
4489 !ctx->Pixel.MapStencilFlag &&
4490 srcType == GL_UNSIGNED_BYTE &&
4491 dstType == GL_UNSIGNED_BYTE) {
4492 memcpy(dest, source, n * sizeof(GLubyte));
4493 }
4494 else if (transferOps == 0 &&
4495 !ctx->Pixel.MapStencilFlag &&
4496 srcType == GL_UNSIGNED_INT &&
4497 dstType == GL_UNSIGNED_INT &&
4498 !srcPacking->SwapBytes) {
4499 memcpy(dest, source, n * sizeof(GLuint));
4500 }
4501 else {
4502 /*
4503 * general solution
4504 */
4505 GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
4506
4507 if (!indexes) {
4508 _mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil unpacking");
4509 return;
4510 }
4511
4512 extract_uint_indexes(n, indexes, GL_STENCIL_INDEX, srcType, source,
4513 srcPacking);
4514
4515 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
4516 /* shift and offset indexes */
4517 _mesa_shift_and_offset_ci(ctx, n, indexes);
4518 }
4519
4520 if (ctx->Pixel.MapStencilFlag) {
4521 /* Apply stencil lookup table */
4522 const GLuint mask = ctx->PixelMaps.StoS.Size - 1;
4523 GLuint i;
4524 for (i = 0; i < n; i++) {
4525 indexes[i] = (GLuint)ctx->PixelMaps.StoS.Map[ indexes[i] & mask ];
4526 }
4527 }
4528
4529 /* convert to dest type */
4530 switch (dstType) {
4531 case GL_UNSIGNED_BYTE:
4532 {
4533 GLubyte *dst = (GLubyte *) dest;
4534 GLuint i;
4535 for (i = 0; i < n; i++) {
4536 dst[i] = (GLubyte) (indexes[i] & 0xff);
4537 }
4538 }
4539 break;
4540 case GL_UNSIGNED_SHORT:
4541 {
4542 GLuint *dst = (GLuint *) dest;
4543 GLuint i;
4544 for (i = 0; i < n; i++) {
4545 dst[i] = (GLushort) (indexes[i] & 0xffff);
4546 }
4547 }
4548 break;
4549 case GL_UNSIGNED_INT:
4550 memcpy(dest, indexes, n * sizeof(GLuint));
4551 break;
4552 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
4553 {
4554 GLuint *dst = (GLuint *) dest;
4555 GLuint i;
4556 for (i = 0; i < n; i++) {
4557 dst[i*2+1] = indexes[i] & 0xff; /* lower 8 bits */
4558 }
4559 }
4560 break;
4561 default:
4562 _mesa_problem(ctx, "bad dstType in _mesa_unpack_stencil_span");
4563 }
4564
4565 free(indexes);
4566 }
4567 }
4568
4569
4570 void
4571 _mesa_pack_stencil_span( struct gl_context *ctx, GLuint n,
4572 GLenum dstType, GLvoid *dest, const GLubyte *source,
4573 const struct gl_pixelstore_attrib *dstPacking )
4574 {
4575 GLubyte *stencil = (GLubyte *) malloc(n * sizeof(GLubyte));
4576
4577 if (!stencil) {
4578 _mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil packing");
4579 return;
4580 }
4581
4582 if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset ||
4583 ctx->Pixel.MapStencilFlag) {
4584 /* make a copy of input */
4585 memcpy(stencil, source, n * sizeof(GLubyte));
4586 _mesa_apply_stencil_transfer_ops(ctx, n, stencil);
4587 source = stencil;
4588 }
4589
4590 switch (dstType) {
4591 case GL_UNSIGNED_BYTE:
4592 memcpy(dest, source, n);
4593 break;
4594 case GL_BYTE:
4595 {
4596 GLbyte *dst = (GLbyte *) dest;
4597 GLuint i;
4598 for (i=0;i<n;i++) {
4599 dst[i] = (GLbyte) (source[i] & 0x7f);
4600 }
4601 }
4602 break;
4603 case GL_UNSIGNED_SHORT:
4604 {
4605 GLushort *dst = (GLushort *) dest;
4606 GLuint i;
4607 for (i=0;i<n;i++) {
4608 dst[i] = (GLushort) source[i];
4609 }
4610 if (dstPacking->SwapBytes) {
4611 _mesa_swap2( (GLushort *) dst, n );
4612 }
4613 }
4614 break;
4615 case GL_SHORT:
4616 {
4617 GLshort *dst = (GLshort *) dest;
4618 GLuint i;
4619 for (i=0;i<n;i++) {
4620 dst[i] = (GLshort) source[i];
4621 }
4622 if (dstPacking->SwapBytes) {
4623 _mesa_swap2( (GLushort *) dst, n );
4624 }
4625 }
4626 break;
4627 case GL_UNSIGNED_INT:
4628 {
4629 GLuint *dst = (GLuint *) dest;
4630 GLuint i;
4631 for (i=0;i<n;i++) {
4632 dst[i] = (GLuint) source[i];
4633 }
4634 if (dstPacking->SwapBytes) {
4635 _mesa_swap4( (GLuint *) dst, n );
4636 }
4637 }
4638 break;
4639 case GL_INT:
4640 {
4641 GLint *dst = (GLint *) dest;
4642 GLuint i;
4643 for (i=0;i<n;i++) {
4644 dst[i] = (GLint) source[i];
4645 }
4646 if (dstPacking->SwapBytes) {
4647 _mesa_swap4( (GLuint *) dst, n );
4648 }
4649 }
4650 break;
4651 case GL_FLOAT:
4652 {
4653 GLfloat *dst = (GLfloat *) dest;
4654 GLuint i;
4655 for (i=0;i<n;i++) {
4656 dst[i] = (GLfloat) source[i];
4657 }
4658 if (dstPacking->SwapBytes) {
4659 _mesa_swap4( (GLuint *) dst, n );
4660 }
4661 }
4662 break;
4663 case GL_HALF_FLOAT_ARB:
4664 {
4665 GLhalfARB *dst = (GLhalfARB *) dest;
4666 GLuint i;
4667 for (i=0;i<n;i++) {
4668 dst[i] = _mesa_float_to_half( (float) source[i] );
4669 }
4670 if (dstPacking->SwapBytes) {
4671 _mesa_swap2( (GLushort *) dst, n );
4672 }
4673 }
4674 break;
4675 case GL_BITMAP:
4676 if (dstPacking->LsbFirst) {
4677 GLubyte *dst = (GLubyte *) dest;
4678 GLint shift = 0;
4679 GLuint i;
4680 for (i = 0; i < n; i++) {
4681 if (shift == 0)
4682 *dst = 0;
4683 *dst |= ((source[i] != 0) << shift);
4684 shift++;
4685 if (shift == 8) {
4686 shift = 0;
4687 dst++;
4688 }
4689 }
4690 }
4691 else {
4692 GLubyte *dst = (GLubyte *) dest;
4693 GLint shift = 7;
4694 GLuint i;
4695 for (i = 0; i < n; i++) {
4696 if (shift == 7)
4697 *dst = 0;
4698 *dst |= ((source[i] != 0) << shift);
4699 shift--;
4700 if (shift < 0) {
4701 shift = 7;
4702 dst++;
4703 }
4704 }
4705 }
4706 break;
4707 default:
4708 _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
4709 }
4710
4711 free(stencil);
4712 }
4713
4714 #define DEPTH_VALUES(GLTYPE, GLTYPE2FLOAT) \
4715 do { \
4716 GLuint i; \
4717 const GLTYPE *src = (const GLTYPE *)source; \
4718 for (i = 0; i < n; i++) { \
4719 GLTYPE value = src[i]; \
4720 if (srcPacking->SwapBytes) { \
4721 if (sizeof(GLTYPE) == 2) { \
4722 SWAP2BYTE(value); \
4723 } else if (sizeof(GLTYPE) == 4) { \
4724 SWAP4BYTE(value); \
4725 } \
4726 } \
4727 depthValues[i] = GLTYPE2FLOAT(value); \
4728 } \
4729 } while (0)
4730
4731
4732 /**
4733 * Unpack a row of depth/z values from memory, returning GLushort, GLuint
4734 * or GLfloat values.
4735 * The glPixelTransfer (scale/bias) params will be applied.
4736 *
4737 * \param dstType one of GL_UNSIGNED_SHORT, GL_UNSIGNED_INT, GL_FLOAT
4738 * \param depthMax max value for returned GLushort or GLuint values
4739 * (ignored for GLfloat).
4740 */
4741 void
4742 _mesa_unpack_depth_span( struct gl_context *ctx, GLuint n,
4743 GLenum dstType, GLvoid *dest, GLuint depthMax,
4744 GLenum srcType, const GLvoid *source,
4745 const struct gl_pixelstore_attrib *srcPacking )
4746 {
4747 GLfloat *depthTemp = NULL, *depthValues;
4748 GLboolean needClamp = GL_FALSE;
4749
4750 /* Look for special cases first.
4751 * Not only are these faster, they're less prone to numeric conversion
4752 * problems. Otherwise, converting from an int type to a float then
4753 * back to an int type can introduce errors that will show up as
4754 * artifacts in things like depth peeling which uses glCopyTexImage.
4755 */
4756 if (ctx->Pixel.DepthScale == 1.0 && ctx->Pixel.DepthBias == 0.0) {
4757 if (srcType == GL_UNSIGNED_INT && dstType == GL_UNSIGNED_SHORT) {
4758 const GLuint *src = (const GLuint *) source;
4759 GLushort *dst = (GLushort *) dest;
4760 GLuint i;
4761 for (i = 0; i < n; i++) {
4762 dst[i] = src[i] >> 16;
4763 }
4764 return;
4765 }
4766 if (srcType == GL_UNSIGNED_SHORT
4767 && dstType == GL_UNSIGNED_INT
4768 && depthMax == 0xffffffff) {
4769 const GLushort *src = (const GLushort *) source;
4770 GLuint *dst = (GLuint *) dest;
4771 GLuint i;
4772 for (i = 0; i < n; i++) {
4773 dst[i] = src[i] | (src[i] << 16);
4774 }
4775 return;
4776 }
4777 if (srcType == GL_UNSIGNED_INT_24_8
4778 && dstType == GL_UNSIGNED_INT
4779 && depthMax == 0xffffff) {
4780 const GLuint *src = (const GLuint *) source;
4781 GLuint *dst = (GLuint *) dest;
4782 GLuint i;
4783 for (i = 0; i < n; i++) {
4784 dst[i] = src[i] >> 8;
4785 }
4786 return;
4787 }
4788 /* XXX may want to add additional cases here someday */
4789 }
4790
4791 /* general case path follows */
4792
4793 if (dstType == GL_FLOAT) {
4794 depthValues = (GLfloat *) dest;
4795 }
4796 else {
4797 depthTemp = (GLfloat *) malloc(n * sizeof(GLfloat));
4798 if (!depthTemp) {
4799 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
4800 return;
4801 }
4802
4803 depthValues = depthTemp;
4804 }
4805
4806 /* Convert incoming values to GLfloat. Some conversions will require
4807 * clamping, below.
4808 */
4809 switch (srcType) {
4810 case GL_BYTE:
4811 DEPTH_VALUES(GLbyte, BYTE_TO_FLOATZ);
4812 needClamp = GL_TRUE;
4813 break;
4814 case GL_UNSIGNED_BYTE:
4815 DEPTH_VALUES(GLubyte, UBYTE_TO_FLOAT);
4816 break;
4817 case GL_SHORT:
4818 DEPTH_VALUES(GLshort, SHORT_TO_FLOATZ);
4819 needClamp = GL_TRUE;
4820 break;
4821 case GL_UNSIGNED_SHORT:
4822 DEPTH_VALUES(GLushort, USHORT_TO_FLOAT);
4823 break;
4824 case GL_INT:
4825 DEPTH_VALUES(GLint, INT_TO_FLOAT);
4826 needClamp = GL_TRUE;
4827 break;
4828 case GL_UNSIGNED_INT:
4829 DEPTH_VALUES(GLuint, UINT_TO_FLOAT);
4830 break;
4831 case GL_UNSIGNED_INT_24_8_EXT: /* GL_EXT_packed_depth_stencil */
4832 if (dstType == GL_UNSIGNED_INT_24_8_EXT &&
4833 depthMax == 0xffffff &&
4834 ctx->Pixel.DepthScale == 1.0 &&
4835 ctx->Pixel.DepthBias == 0.0) {
4836 const GLuint *src = (const GLuint *) source;
4837 GLuint *zValues = (GLuint *) dest;
4838 GLuint i;
4839 for (i = 0; i < n; i++) {
4840 GLuint value = src[i];
4841 if (srcPacking->SwapBytes) {
4842 SWAP4BYTE(value);
4843 }
4844 zValues[i] = value & 0xffffff00;
4845 }
4846 free(depthTemp);
4847 return;
4848 }
4849 else {
4850 const GLuint *src = (const GLuint *) source;
4851 const GLfloat scale = 1.0f / 0xffffff;
4852 GLuint i;
4853 for (i = 0; i < n; i++) {
4854 GLuint value = src[i];
4855 if (srcPacking->SwapBytes) {
4856 SWAP4BYTE(value);
4857 }
4858 depthValues[i] = (value >> 8) * scale;
4859 }
4860 }
4861 break;
4862 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
4863 {
4864 GLuint i;
4865 const GLfloat *src = (const GLfloat *)source;
4866 for (i = 0; i < n; i++) {
4867 GLfloat value = src[i * 2];
4868 if (srcPacking->SwapBytes) {
4869 SWAP4BYTE(value);
4870 }
4871 depthValues[i] = value;
4872 }
4873 needClamp = GL_TRUE;
4874 }
4875 break;
4876 case GL_FLOAT:
4877 DEPTH_VALUES(GLfloat, 1*);
4878 needClamp = GL_TRUE;
4879 break;
4880 case GL_HALF_FLOAT_ARB:
4881 {
4882 GLuint i;
4883 const GLhalfARB *src = (const GLhalfARB *) source;
4884 for (i = 0; i < n; i++) {
4885 GLhalfARB value = src[i];
4886 if (srcPacking->SwapBytes) {
4887 SWAP2BYTE(value);
4888 }
4889 depthValues[i] = _mesa_half_to_float(value);
4890 }
4891 needClamp = GL_TRUE;
4892 }
4893 break;
4894 default:
4895 _mesa_problem(NULL, "bad type in _mesa_unpack_depth_span()");
4896 free(depthTemp);
4897 return;
4898 }
4899
4900 /* apply depth scale and bias */
4901 {
4902 const GLfloat scale = ctx->Pixel.DepthScale;
4903 const GLfloat bias = ctx->Pixel.DepthBias;
4904 if (scale != 1.0 || bias != 0.0) {
4905 GLuint i;
4906 for (i = 0; i < n; i++) {
4907 depthValues[i] = depthValues[i] * scale + bias;
4908 }
4909 needClamp = GL_TRUE;
4910 }
4911 }
4912
4913 /* clamp to [0, 1] */
4914 if (needClamp) {
4915 GLuint i;
4916 for (i = 0; i < n; i++) {
4917 depthValues[i] = (GLfloat)CLAMP(depthValues[i], 0.0, 1.0);
4918 }
4919 }
4920
4921 /*
4922 * Convert values to dstType
4923 */
4924 if (dstType == GL_UNSIGNED_INT) {
4925 GLuint *zValues = (GLuint *) dest;
4926 GLuint i;
4927 if (depthMax <= 0xffffff) {
4928 /* no overflow worries */
4929 for (i = 0; i < n; i++) {
4930 zValues[i] = (GLuint) (depthValues[i] * (GLfloat) depthMax);
4931 }
4932 }
4933 else {
4934 /* need to use double precision to prevent overflow problems */
4935 for (i = 0; i < n; i++) {
4936 GLdouble z = depthValues[i] * (GLfloat) depthMax;
4937 if (z >= (GLdouble) 0xffffffff)
4938 zValues[i] = 0xffffffff;
4939 else
4940 zValues[i] = (GLuint) z;
4941 }
4942 }
4943 }
4944 else if (dstType == GL_UNSIGNED_SHORT) {
4945 GLushort *zValues = (GLushort *) dest;
4946 GLuint i;
4947 ASSERT(depthMax <= 0xffff);
4948 for (i = 0; i < n; i++) {
4949 zValues[i] = (GLushort) (depthValues[i] * (GLfloat) depthMax);
4950 }
4951 }
4952 else if (dstType == GL_FLOAT) {
4953 /* Nothing to do. depthValues is pointing to dest. */
4954 }
4955 else if (dstType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV) {
4956 GLfloat *zValues = (GLfloat*) dest;
4957 GLuint i;
4958 for (i = 0; i < n; i++) {
4959 zValues[i*2] = depthValues[i];
4960 }
4961 }
4962 else {
4963 ASSERT(0);
4964 }
4965
4966 free(depthTemp);
4967 }
4968
4969
4970 /*
4971 * Pack an array of depth values. The values are floats in [0,1].
4972 */
4973 void
4974 _mesa_pack_depth_span( struct gl_context *ctx, GLuint n, GLvoid *dest,
4975 GLenum dstType, const GLfloat *depthSpan,
4976 const struct gl_pixelstore_attrib *dstPacking )
4977 {
4978 GLfloat *depthCopy = (GLfloat *) malloc(n * sizeof(GLfloat));
4979 if (!depthCopy) {
4980 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
4981 return;
4982 }
4983
4984 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
4985 memcpy(depthCopy, depthSpan, n * sizeof(GLfloat));
4986 _mesa_scale_and_bias_depth(ctx, n, depthCopy);
4987 depthSpan = depthCopy;
4988 }
4989
4990 switch (dstType) {
4991 case GL_UNSIGNED_BYTE:
4992 {
4993 GLubyte *dst = (GLubyte *) dest;
4994 GLuint i;
4995 for (i = 0; i < n; i++) {
4996 dst[i] = FLOAT_TO_UBYTE( depthSpan[i] );
4997 }
4998 }
4999 break;
5000 case GL_BYTE:
5001 {
5002 GLbyte *dst = (GLbyte *) dest;
5003 GLuint i;
5004 for (i = 0; i < n; i++) {
5005 dst[i] = FLOAT_TO_BYTE( depthSpan[i] );
5006 }
5007 }
5008 break;
5009 case GL_UNSIGNED_SHORT:
5010 {
5011 GLushort *dst = (GLushort *) dest;
5012 GLuint i;
5013 for (i = 0; i < n; i++) {
5014 CLAMPED_FLOAT_TO_USHORT(dst[i], depthSpan[i]);
5015 }
5016 if (dstPacking->SwapBytes) {
5017 _mesa_swap2( (GLushort *) dst, n );
5018 }
5019 }
5020 break;
5021 case GL_SHORT:
5022 {
5023 GLshort *dst = (GLshort *) dest;
5024 GLuint i;
5025 for (i = 0; i < n; i++) {
5026 dst[i] = FLOAT_TO_SHORT( depthSpan[i] );
5027 }
5028 if (dstPacking->SwapBytes) {
5029 _mesa_swap2( (GLushort *) dst, n );
5030 }
5031 }
5032 break;
5033 case GL_UNSIGNED_INT:
5034 {
5035 GLuint *dst = (GLuint *) dest;
5036 GLuint i;
5037 for (i = 0; i < n; i++) {
5038 dst[i] = FLOAT_TO_UINT( depthSpan[i] );
5039 }
5040 if (dstPacking->SwapBytes) {
5041 _mesa_swap4( (GLuint *) dst, n );
5042 }
5043 }
5044 break;
5045 case GL_INT:
5046 {
5047 GLint *dst = (GLint *) dest;
5048 GLuint i;
5049 for (i = 0; i < n; i++) {
5050 dst[i] = FLOAT_TO_INT( depthSpan[i] );
5051 }
5052 if (dstPacking->SwapBytes) {
5053 _mesa_swap4( (GLuint *) dst, n );
5054 }
5055 }
5056 break;
5057 case GL_FLOAT:
5058 {
5059 GLfloat *dst = (GLfloat *) dest;
5060 GLuint i;
5061 for (i = 0; i < n; i++) {
5062 dst[i] = depthSpan[i];
5063 }
5064 if (dstPacking->SwapBytes) {
5065 _mesa_swap4( (GLuint *) dst, n );
5066 }
5067 }
5068 break;
5069 case GL_HALF_FLOAT_ARB:
5070 {
5071 GLhalfARB *dst = (GLhalfARB *) dest;
5072 GLuint i;
5073 for (i = 0; i < n; i++) {
5074 dst[i] = _mesa_float_to_half(depthSpan[i]);
5075 }
5076 if (dstPacking->SwapBytes) {
5077 _mesa_swap2( (GLushort *) dst, n );
5078 }
5079 }
5080 break;
5081 default:
5082 _mesa_problem(ctx, "bad type in _mesa_pack_depth_span");
5083 }
5084
5085 free(depthCopy);
5086 }
5087
5088
5089
5090 /**
5091 * Pack depth and stencil values as GL_DEPTH_STENCIL (GL_UNSIGNED_INT_24_8 etc)
5092 */
5093 void
5094 _mesa_pack_depth_stencil_span(struct gl_context *ctx,GLuint n,
5095 GLenum dstType, GLuint *dest,
5096 const GLfloat *depthVals,
5097 const GLubyte *stencilVals,
5098 const struct gl_pixelstore_attrib *dstPacking)
5099 {
5100 GLfloat *depthCopy = (GLfloat *) malloc(n * sizeof(GLfloat));
5101 GLubyte *stencilCopy = (GLubyte *) malloc(n * sizeof(GLubyte));
5102 GLuint i;
5103
5104 if (!depthCopy || !stencilCopy) {
5105 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
5106 free(depthCopy);
5107 free(stencilCopy);
5108 return;
5109 }
5110
5111 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
5112 memcpy(depthCopy, depthVals, n * sizeof(GLfloat));
5113 _mesa_scale_and_bias_depth(ctx, n, depthCopy);
5114 depthVals = depthCopy;
5115 }
5116
5117 if (ctx->Pixel.IndexShift ||
5118 ctx->Pixel.IndexOffset ||
5119 ctx->Pixel.MapStencilFlag) {
5120 memcpy(stencilCopy, stencilVals, n * sizeof(GLubyte));
5121 _mesa_apply_stencil_transfer_ops(ctx, n, stencilCopy);
5122 stencilVals = stencilCopy;
5123 }
5124
5125 switch (dstType) {
5126 case GL_UNSIGNED_INT_24_8:
5127 for (i = 0; i < n; i++) {
5128 GLuint z = (GLuint) (depthVals[i] * 0xffffff);
5129 dest[i] = (z << 8) | (stencilVals[i] & 0xff);
5130 }
5131 break;
5132 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
5133 for (i = 0; i < n; i++) {
5134 ((GLfloat*)dest)[i*2] = depthVals[i];
5135 dest[i*2+1] = stencilVals[i] & 0xff;
5136 }
5137 break;
5138 }
5139
5140 if (dstPacking->SwapBytes) {
5141 _mesa_swap4(dest, n);
5142 }
5143
5144 free(depthCopy);
5145 free(stencilCopy);
5146 }
5147
5148
5149
5150
5151 /**
5152 * Unpack image data. Apply byte swapping, byte flipping (bitmap).
5153 * Return all image data in a contiguous block. This is used when we
5154 * compile glDrawPixels, glTexImage, etc into a display list. We
5155 * need a copy of the data in a standard format.
5156 */
5157 void *
5158 _mesa_unpack_image( GLuint dimensions,
5159 GLsizei width, GLsizei height, GLsizei depth,
5160 GLenum format, GLenum type, const GLvoid *pixels,
5161 const struct gl_pixelstore_attrib *unpack )
5162 {
5163 GLint bytesPerRow, compsPerRow;
5164 GLboolean flipBytes, swap2, swap4;
5165
5166 if (!pixels)
5167 return NULL; /* not necessarily an error */
5168
5169 if (width <= 0 || height <= 0 || depth <= 0)
5170 return NULL; /* generate error later */
5171
5172 if (type == GL_BITMAP) {
5173 bytesPerRow = (width + 7) >> 3;
5174 flipBytes = unpack->LsbFirst;
5175 swap2 = swap4 = GL_FALSE;
5176 compsPerRow = 0;
5177 }
5178 else {
5179 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
5180 GLint components = _mesa_components_in_format(format);
5181 GLint bytesPerComp;
5182
5183 if (_mesa_type_is_packed(type))
5184 components = 1;
5185
5186 if (bytesPerPixel <= 0 || components <= 0)
5187 return NULL; /* bad format or type. generate error later */
5188 bytesPerRow = bytesPerPixel * width;
5189 bytesPerComp = bytesPerPixel / components;
5190 flipBytes = GL_FALSE;
5191 swap2 = (bytesPerComp == 2) && unpack->SwapBytes;
5192 swap4 = (bytesPerComp == 4) && unpack->SwapBytes;
5193 compsPerRow = components * width;
5194 assert(compsPerRow >= width);
5195 }
5196
5197 {
5198 GLubyte *destBuffer
5199 = (GLubyte *) malloc(bytesPerRow * height * depth);
5200 GLubyte *dst;
5201 GLint img, row;
5202 if (!destBuffer)
5203 return NULL; /* generate GL_OUT_OF_MEMORY later */
5204
5205 dst = destBuffer;
5206 for (img = 0; img < depth; img++) {
5207 for (row = 0; row < height; row++) {
5208 const GLvoid *src = _mesa_image_address(dimensions, unpack, pixels,
5209 width, height, format, type, img, row, 0);
5210
5211 if ((type == GL_BITMAP) && (unpack->SkipPixels & 0x7)) {
5212 GLint i;
5213 flipBytes = GL_FALSE;
5214 if (unpack->LsbFirst) {
5215 GLubyte srcMask = 1 << (unpack->SkipPixels & 0x7);
5216 GLubyte dstMask = 128;
5217 const GLubyte *s = src;
5218 GLubyte *d = dst;
5219 *d = 0;
5220 for (i = 0; i < width; i++) {
5221 if (*s & srcMask) {
5222 *d |= dstMask;
5223 }
5224 if (srcMask == 128) {
5225 srcMask = 1;
5226 s++;
5227 }
5228 else {
5229 srcMask = srcMask << 1;
5230 }
5231 if (dstMask == 1) {
5232 dstMask = 128;
5233 d++;
5234 *d = 0;
5235 }
5236 else {
5237 dstMask = dstMask >> 1;
5238 }
5239 }
5240 }
5241 else {
5242 GLubyte srcMask = 128 >> (unpack->SkipPixels & 0x7);
5243 GLubyte dstMask = 128;
5244 const GLubyte *s = src;
5245 GLubyte *d = dst;
5246 *d = 0;
5247 for (i = 0; i < width; i++) {
5248 if (*s & srcMask) {
5249 *d |= dstMask;
5250 }
5251 if (srcMask == 1) {
5252 srcMask = 128;
5253 s++;
5254 }
5255 else {
5256 srcMask = srcMask >> 1;
5257 }
5258 if (dstMask == 1) {
5259 dstMask = 128;
5260 d++;
5261 *d = 0;
5262 }
5263 else {
5264 dstMask = dstMask >> 1;
5265 }
5266 }
5267 }
5268 }
5269 else {
5270 memcpy(dst, src, bytesPerRow);
5271 }
5272
5273 /* byte flipping/swapping */
5274 if (flipBytes) {
5275 flip_bytes((GLubyte *) dst, bytesPerRow);
5276 }
5277 else if (swap2) {
5278 _mesa_swap2((GLushort*) dst, compsPerRow);
5279 }
5280 else if (swap4) {
5281 _mesa_swap4((GLuint*) dst, compsPerRow);
5282 }
5283 dst += bytesPerRow;
5284 }
5285 }
5286 return destBuffer;
5287 }
5288 }
5289