projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
mesa: new BYTE/SHORT_TO_FLOATZ() macros
[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 *rSrc = 2;
2295 *gSrc = 1;
2296 *bSrc = 0;
2297 *aSrc = -1;
2298 *rDst = 2;
2299 *gDst = 1;
2300 *bDst = 0;
2301 *aDst = 3;
2302 break;
2303 case GL_RGBA:
2304 case GL_RGBA_INTEGER:
2305 *rSrc = 0;
2306 *gSrc = 1;
2307 *bSrc = 2;
2308 *aSrc = 3;
2309 *rDst = 0;
2310 *gDst = 1;
2311 *bDst = 2;
2312 *aDst = 3;
2313 break;
2314 case GL_BGRA:
2315 *rSrc = 2;
2316 *gSrc = 1;
2317 *bSrc = 0;
2318 *aSrc = 3;
2319 *rDst = 2;
2320 *gDst = 1;
2321 *bDst = 0;
2322 *aDst = 3;
2323 break;
2324 case GL_ABGR_EXT:
2325 *rSrc = 3;
2326 *gSrc = 2;
2327 *bSrc = 1;
2328 *aSrc = 0;
2329 *rDst = 3;
2330 *gDst = 2;
2331 *bDst = 1;
2332 *aDst = 0;
2333 break;
2334 case GL_DU8DV8_ATI:
2335 case GL_DUDV_ATI:
2336 *rSrc = 0;
2337 *gSrc = 1;
2338 *bSrc = -1;
2339 *aSrc = -1;
2340 break;
2341 default:
2342 _mesa_problem(NULL, "bad srcFormat %s in get_component_mapping",
2343 _mesa_lookup_enum_by_nr(format));
2344 return;
2345 }
2346 }
2347
2348
2349
2350 /*
2351 * This function extracts floating point RGBA values from arbitrary
2352 * image data. srcFormat and srcType are the format and type parameters
2353 * passed to glDrawPixels, glTexImage[123]D, glTexSubImage[123]D, etc.
2354 *
2355 * Refering to section 3.6.4 of the OpenGL 1.2 spec, this function
2356 * implements the "Conversion to floating point", "Conversion to RGB",
2357 * and "Final Expansion to RGBA" operations.
2358 *
2359 * Args: n - number of pixels
2360 * rgba - output colors
2361 * srcFormat - format of incoming data
2362 * srcType - data type of incoming data
2363 * src - source data pointer
2364 * swapBytes - perform byteswapping of incoming data?
2365 */
2366 static void
2367 extract_float_rgba(GLuint n, GLfloat rgba[][4],
2368 GLenum srcFormat, GLenum srcType, const GLvoid *src,
2369 GLboolean swapBytes)
2370 {
2371 GLint rSrc, gSrc, bSrc, aSrc;
2372 GLint stride;
2373 GLint rDst, bDst, gDst, aDst;
2374 GLboolean intFormat;
2375 GLfloat rs = 1.0f, gs = 1.0f, bs = 1.0f, as = 1.0f; /* scale factors */
2376
2377 ASSERT(srcFormat == GL_RED ||
2378 srcFormat == GL_GREEN ||
2379 srcFormat == GL_BLUE ||
2380 srcFormat == GL_ALPHA ||
2381 srcFormat == GL_LUMINANCE ||
2382 srcFormat == GL_LUMINANCE_ALPHA ||
2383 srcFormat == GL_INTENSITY ||
2384 srcFormat == GL_RG ||
2385 srcFormat == GL_RGB ||
2386 srcFormat == GL_BGR ||
2387 srcFormat == GL_RGBA ||
2388 srcFormat == GL_BGRA ||
2389 srcFormat == GL_ABGR_EXT ||
2390 srcFormat == GL_DU8DV8_ATI ||
2391 srcFormat == GL_DUDV_ATI ||
2392 srcFormat == GL_RED_INTEGER_EXT ||
2393 srcFormat == GL_GREEN_INTEGER_EXT ||
2394 srcFormat == GL_BLUE_INTEGER_EXT ||
2395 srcFormat == GL_ALPHA_INTEGER_EXT ||
2396 srcFormat == GL_RGB_INTEGER_EXT ||
2397 srcFormat == GL_RGBA_INTEGER_EXT ||
2398 srcFormat == GL_BGR_INTEGER_EXT ||
2399 srcFormat == GL_BGRA_INTEGER_EXT ||
2400 srcFormat == GL_LUMINANCE_INTEGER_EXT ||
2401 srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);
2402
2403 ASSERT(srcType == GL_UNSIGNED_BYTE ||
2404 srcType == GL_BYTE ||
2405 srcType == GL_UNSIGNED_SHORT ||
2406 srcType == GL_SHORT ||
2407 srcType == GL_UNSIGNED_INT ||
2408 srcType == GL_INT ||
2409 srcType == GL_HALF_FLOAT_ARB ||
2410 srcType == GL_FLOAT ||
2411 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
2412 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
2413 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
2414 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
2415 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
2416 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
2417 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
2418 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
2419 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
2420 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
2421 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
2422 srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
2423 srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
2424 srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
2425
2426 get_component_mapping(srcFormat,
2427 &rSrc, &gSrc, &bSrc, &aSrc,
2428 &rDst, &gDst, &bDst, &aDst);
2429
2430 stride = _mesa_components_in_format(srcFormat);
2431
2432 intFormat = _mesa_is_integer_format(srcFormat);
2433
2434 #define PROCESS(SRC_INDEX, DST_INDEX, DEFAULT_FLT, DEFAULT_INT, TYPE, CONVERSION) \
2435 if ((SRC_INDEX) < 0) { \
2436 GLuint i; \
2437 if (intFormat) { \
2438 for (i = 0; i < n; i++) { \
2439 rgba[i][DST_INDEX] = DEFAULT_INT; \
2440 } \
2441 } \
2442 else { \
2443 for (i = 0; i < n; i++) { \
2444 rgba[i][DST_INDEX] = DEFAULT_FLT; \
2445 } \
2446 } \
2447 } \
2448 else if (swapBytes) { \
2449 const TYPE *s = (const TYPE *) src; \
2450 GLuint i; \
2451 for (i = 0; i < n; i++) { \
2452 TYPE value = s[SRC_INDEX]; \
2453 if (sizeof(TYPE) == 2) { \
2454 SWAP2BYTE(value); \
2455 } \
2456 else if (sizeof(TYPE) == 4) { \
2457 SWAP4BYTE(value); \
2458 } \
2459 if (intFormat) \
2460 rgba[i][DST_INDEX] = (GLfloat) value; \
2461 else \
2462 rgba[i][DST_INDEX] = (GLfloat) CONVERSION(value); \
2463 s += stride; \
2464 } \
2465 } \
2466 else { \
2467 const TYPE *s = (const TYPE *) src; \
2468 GLuint i; \
2469 if (intFormat) { \
2470 for (i = 0; i < n; i++) { \
2471 rgba[i][DST_INDEX] = (GLfloat) s[SRC_INDEX]; \
2472 s += stride; \
2473 } \
2474 } \
2475 else { \
2476 for (i = 0; i < n; i++) { \
2477 rgba[i][DST_INDEX] = (GLfloat) CONVERSION(s[SRC_INDEX]); \
2478 s += stride; \
2479 } \
2480 } \
2481 }
2482
2483 switch (srcType) {
2484 case GL_UNSIGNED_BYTE:
2485 PROCESS(rSrc, RCOMP, 0.0F, 0, GLubyte, UBYTE_TO_FLOAT);
2486 PROCESS(gSrc, GCOMP, 0.0F, 0, GLubyte, UBYTE_TO_FLOAT);
2487 PROCESS(bSrc, BCOMP, 0.0F, 0, GLubyte, UBYTE_TO_FLOAT);
2488 PROCESS(aSrc, ACOMP, 1.0F, 255, GLubyte, UBYTE_TO_FLOAT);
2489 break;
2490 case GL_BYTE:
2491 PROCESS(rSrc, RCOMP, 0.0F, 0, GLbyte, BYTE_TO_FLOATZ);
2492 PROCESS(gSrc, GCOMP, 0.0F, 0, GLbyte, BYTE_TO_FLOATZ);
2493 PROCESS(bSrc, BCOMP, 0.0F, 0, GLbyte, BYTE_TO_FLOATZ);
2494 PROCESS(aSrc, ACOMP, 1.0F, 127, GLbyte, BYTE_TO_FLOATZ);
2495 break;
2496 case GL_UNSIGNED_SHORT:
2497 PROCESS(rSrc, RCOMP, 0.0F, 0, GLushort, USHORT_TO_FLOAT);
2498 PROCESS(gSrc, GCOMP, 0.0F, 0, GLushort, USHORT_TO_FLOAT);
2499 PROCESS(bSrc, BCOMP, 0.0F, 0, GLushort, USHORT_TO_FLOAT);
2500 PROCESS(aSrc, ACOMP, 1.0F, 0xffff, GLushort, USHORT_TO_FLOAT);
2501 break;
2502 case GL_SHORT:
2503 PROCESS(rSrc, RCOMP, 0.0F, 0, GLshort, SHORT_TO_FLOATZ);
2504 PROCESS(gSrc, GCOMP, 0.0F, 0, GLshort, SHORT_TO_FLOATZ);
2505 PROCESS(bSrc, BCOMP, 0.0F, 0, GLshort, SHORT_TO_FLOATZ);
2506 PROCESS(aSrc, ACOMP, 1.0F, 32767, GLshort, SHORT_TO_FLOATZ);
2507 break;
2508 case GL_UNSIGNED_INT:
2509 PROCESS(rSrc, RCOMP, 0.0F, 0, GLuint, UINT_TO_FLOAT);
2510 PROCESS(gSrc, GCOMP, 0.0F, 0, GLuint, UINT_TO_FLOAT);
2511 PROCESS(bSrc, BCOMP, 0.0F, 0, GLuint, UINT_TO_FLOAT);
2512 PROCESS(aSrc, ACOMP, 1.0F, 0xffffffff, GLuint, UINT_TO_FLOAT);
2513 break;
2514 case GL_INT:
2515 PROCESS(rSrc, RCOMP, 0.0F, 0, GLint, INT_TO_FLOAT);
2516 PROCESS(gSrc, GCOMP, 0.0F, 0, GLint, INT_TO_FLOAT);
2517 PROCESS(bSrc, BCOMP, 0.0F, 0, GLint, INT_TO_FLOAT);
2518 PROCESS(aSrc, ACOMP, 1.0F, 2147483647, GLint, INT_TO_FLOAT);
2519 break;
2520 case GL_FLOAT:
2521 PROCESS(rSrc, RCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
2522 PROCESS(gSrc, GCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
2523 PROCESS(bSrc, BCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
2524 PROCESS(aSrc, ACOMP, 1.0F, 1.0F, GLfloat, (GLfloat));
2525 break;
2526 case GL_HALF_FLOAT_ARB:
2527 PROCESS(rSrc, RCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
2528 PROCESS(gSrc, GCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
2529 PROCESS(bSrc, BCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
2530 PROCESS(aSrc, ACOMP, 1.0F, 1.0F, GLhalfARB, _mesa_half_to_float);
2531 break;
2532 case GL_UNSIGNED_BYTE_3_3_2:
2533 {
2534 const GLubyte *ubsrc = (const GLubyte *) src;
2535 GLuint i;
2536 if (!intFormat) {
2537 rs = 1.0F / 7.0F;
2538 gs = 1.0F / 7.0F;
2539 bs = 1.0F / 3.0F;
2540 }
2541 for (i = 0; i < n; i ++) {
2542 GLubyte p = ubsrc[i];
2543 rgba[i][rDst] = ((p >> 5) ) * rs;
2544 rgba[i][gDst] = ((p >> 2) & 0x7) * gs;
2545 rgba[i][bDst] = ((p ) & 0x3) * bs;
2546 rgba[i][aDst] = 1.0F;
2547 }
2548 }
2549 break;
2550 case GL_UNSIGNED_BYTE_2_3_3_REV:
2551 {
2552 const GLubyte *ubsrc = (const GLubyte *) src;
2553 GLuint i;
2554 if (!intFormat) {
2555 rs = 1.0F / 7.0F;
2556 gs = 1.0F / 7.0F;
2557 bs = 1.0F / 3.0F;
2558 }
2559 for (i = 0; i < n; i ++) {
2560 GLubyte p = ubsrc[i];
2561 rgba[i][rDst] = ((p ) & 0x7) * rs;
2562 rgba[i][gDst] = ((p >> 3) & 0x7) * gs;
2563 rgba[i][bDst] = ((p >> 6) ) * bs;
2564 rgba[i][aDst] = 1.0F;
2565 }
2566 }
2567 break;
2568 case GL_UNSIGNED_SHORT_5_6_5:
2569 if (!intFormat) {
2570 rs = 1.0F / 31.0F;
2571 gs = 1.0F / 63.0F;
2572 bs = 1.0F / 31.0F;
2573 }
2574 if (swapBytes) {
2575 const GLushort *ussrc = (const GLushort *) src;
2576 GLuint i;
2577 for (i = 0; i < n; i ++) {
2578 GLushort p = ussrc[i];
2579 SWAP2BYTE(p);
2580 rgba[i][rDst] = ((p >> 11) ) * rs;
2581 rgba[i][gDst] = ((p >> 5) & 0x3f) * gs;
2582 rgba[i][bDst] = ((p ) & 0x1f) * bs;
2583 rgba[i][aDst] = 1.0F;
2584 }
2585 }
2586 else {
2587 const GLushort *ussrc = (const GLushort *) src;
2588 GLuint i;
2589 for (i = 0; i < n; i ++) {
2590 GLushort p = ussrc[i];
2591 rgba[i][rDst] = ((p >> 11) ) * rs;
2592 rgba[i][gDst] = ((p >> 5) & 0x3f) * gs;
2593 rgba[i][bDst] = ((p ) & 0x1f) * bs;
2594 rgba[i][aDst] = 1.0F;
2595 }
2596 }
2597 break;
2598 case GL_UNSIGNED_SHORT_5_6_5_REV:
2599 if (!intFormat) {
2600 rs = 1.0F / 31.0F;
2601 gs = 1.0F / 63.0F;
2602 bs = 1.0F / 31.0F;
2603 }
2604 if (swapBytes) {
2605 const GLushort *ussrc = (const GLushort *) src;
2606 GLuint i;
2607 for (i = 0; i < n; i ++) {
2608 GLushort p = ussrc[i];
2609 SWAP2BYTE(p);
2610 rgba[i][rDst] = ((p ) & 0x1f) * rs;
2611 rgba[i][gDst] = ((p >> 5) & 0x3f) * gs;
2612 rgba[i][bDst] = ((p >> 11) ) * bs;
2613 rgba[i][aDst] = 1.0F;
2614 }
2615 }
2616 else {
2617 const GLushort *ussrc = (const GLushort *) src;
2618 GLuint i;
2619 for (i = 0; i < n; i ++) {
2620 GLushort p = ussrc[i];
2621 rgba[i][rDst] = ((p ) & 0x1f) * rs;
2622 rgba[i][gDst] = ((p >> 5) & 0x3f) * gs;
2623 rgba[i][bDst] = ((p >> 11) ) * bs;
2624 rgba[i][aDst] = 1.0F;
2625 }
2626 }
2627 break;
2628 case GL_UNSIGNED_SHORT_4_4_4_4:
2629 if (!intFormat) {
2630 rs = gs = bs = as = 1.0F / 15.0F;
2631 }
2632 if (swapBytes) {
2633 const GLushort *ussrc = (const GLushort *) src;
2634 GLuint i;
2635 for (i = 0; i < n; i ++) {
2636 GLushort p = ussrc[i];
2637 SWAP2BYTE(p);
2638 rgba[i][rDst] = ((p >> 12) ) * rs;
2639 rgba[i][gDst] = ((p >> 8) & 0xf) * gs;
2640 rgba[i][bDst] = ((p >> 4) & 0xf) * bs;
2641 rgba[i][aDst] = ((p ) & 0xf) * as;
2642 }
2643 }
2644 else {
2645 const GLushort *ussrc = (const GLushort *) src;
2646 GLuint i;
2647 for (i = 0; i < n; i ++) {
2648 GLushort p = ussrc[i];
2649 rgba[i][rDst] = ((p >> 12) ) * rs;
2650 rgba[i][gDst] = ((p >> 8) & 0xf) * gs;
2651 rgba[i][bDst] = ((p >> 4) & 0xf) * bs;
2652 rgba[i][aDst] = ((p ) & 0xf) * as;
2653 }
2654 }
2655 break;
2656 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
2657 if (!intFormat) {
2658 rs = gs = bs = as = 1.0F / 15.0F;
2659 }
2660 if (swapBytes) {
2661 const GLushort *ussrc = (const GLushort *) src;
2662 GLuint i;
2663 for (i = 0; i < n; i ++) {
2664 GLushort p = ussrc[i];
2665 SWAP2BYTE(p);
2666 rgba[i][rDst] = ((p ) & 0xf) * rs;
2667 rgba[i][gDst] = ((p >> 4) & 0xf) * gs;
2668 rgba[i][bDst] = ((p >> 8) & 0xf) * bs;
2669 rgba[i][aDst] = ((p >> 12) ) * as;
2670 }
2671 }
2672 else {
2673 const GLushort *ussrc = (const GLushort *) src;
2674 GLuint i;
2675 for (i = 0; i < n; i ++) {
2676 GLushort p = ussrc[i];
2677 rgba[i][rDst] = ((p ) & 0xf) * rs;
2678 rgba[i][gDst] = ((p >> 4) & 0xf) * gs;
2679 rgba[i][bDst] = ((p >> 8) & 0xf) * bs;
2680 rgba[i][aDst] = ((p >> 12) ) * as;
2681 }
2682 }
2683 break;
2684 case GL_UNSIGNED_SHORT_5_5_5_1:
2685 if (!intFormat) {
2686 rs = gs = bs = 1.0F / 31.0F;
2687 }
2688 if (swapBytes) {
2689 const GLushort *ussrc = (const GLushort *) src;
2690 GLuint i;
2691 for (i = 0; i < n; i ++) {
2692 GLushort p = ussrc[i];
2693 SWAP2BYTE(p);
2694 rgba[i][rDst] = ((p >> 11) ) * rs;
2695 rgba[i][gDst] = ((p >> 6) & 0x1f) * gs;
2696 rgba[i][bDst] = ((p >> 1) & 0x1f) * bs;
2697 rgba[i][aDst] = ((p ) & 0x1) * as;
2698 }
2699 }
2700 else {
2701 const GLushort *ussrc = (const GLushort *) src;
2702 GLuint i;
2703 for (i = 0; i < n; i ++) {
2704 GLushort p = ussrc[i];
2705 rgba[i][rDst] = ((p >> 11) ) * rs;
2706 rgba[i][gDst] = ((p >> 6) & 0x1f) * gs;
2707 rgba[i][bDst] = ((p >> 1) & 0x1f) * bs;
2708 rgba[i][aDst] = ((p ) & 0x1) * as;
2709 }
2710 }
2711 break;
2712 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
2713 if (!intFormat) {
2714 rs = gs = bs = 1.0F / 31.0F;
2715 }
2716 if (swapBytes) {
2717 const GLushort *ussrc = (const GLushort *) src;
2718 GLuint i;
2719 for (i = 0; i < n; i ++) {
2720 GLushort p = ussrc[i];
2721 SWAP2BYTE(p);
2722 rgba[i][rDst] = ((p ) & 0x1f) * rs;
2723 rgba[i][gDst] = ((p >> 5) & 0x1f) * gs;
2724 rgba[i][bDst] = ((p >> 10) & 0x1f) * bs;
2725 rgba[i][aDst] = ((p >> 15) ) * as;
2726 }
2727 }
2728 else {
2729 const GLushort *ussrc = (const GLushort *) src;
2730 GLuint i;
2731 for (i = 0; i < n; i ++) {
2732 GLushort p = ussrc[i];
2733 rgba[i][rDst] = ((p ) & 0x1f) * rs;
2734 rgba[i][gDst] = ((p >> 5) & 0x1f) * gs;
2735 rgba[i][bDst] = ((p >> 10) & 0x1f) * bs;
2736 rgba[i][aDst] = ((p >> 15) ) * as;
2737 }
2738 }
2739 break;
2740 case GL_UNSIGNED_INT_8_8_8_8:
2741 if (swapBytes) {
2742 const GLuint *uisrc = (const GLuint *) src;
2743 GLuint i;
2744 if (intFormat) {
2745 for (i = 0; i < n; i ++) {
2746 GLuint p = uisrc[i];
2747 rgba[i][rDst] = (GLfloat) ((p ) & 0xff);
2748 rgba[i][gDst] = (GLfloat) ((p >> 8) & 0xff);
2749 rgba[i][bDst] = (GLfloat) ((p >> 16) & 0xff);
2750 rgba[i][aDst] = (GLfloat) ((p >> 24) );
2751 }
2752 }
2753 else {
2754 for (i = 0; i < n; i ++) {
2755 GLuint p = uisrc[i];
2756 rgba[i][rDst] = UBYTE_TO_FLOAT((p ) & 0xff);
2757 rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
2758 rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2759 rgba[i][aDst] = UBYTE_TO_FLOAT((p >> 24) );
2760 }
2761 }
2762 }
2763 else {
2764 const GLuint *uisrc = (const GLuint *) src;
2765 GLuint i;
2766 if (intFormat) {
2767 for (i = 0; i < n; i ++) {
2768 GLuint p = uisrc[i];
2769 rgba[i][rDst] = (GLfloat) ((p >> 24) );
2770 rgba[i][gDst] = (GLfloat) ((p >> 16) & 0xff);
2771 rgba[i][bDst] = (GLfloat) ((p >> 8) & 0xff);
2772 rgba[i][aDst] = (GLfloat) ((p ) & 0xff);
2773 }
2774 }
2775 else {
2776 for (i = 0; i < n; i ++) {
2777 GLuint p = uisrc[i];
2778 rgba[i][rDst] = UBYTE_TO_FLOAT((p >> 24) );
2779 rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2780 rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
2781 rgba[i][aDst] = UBYTE_TO_FLOAT((p ) & 0xff);
2782 }
2783 }
2784 }
2785 break;
2786 case GL_UNSIGNED_INT_8_8_8_8_REV:
2787 if (swapBytes) {
2788 const GLuint *uisrc = (const GLuint *) src;
2789 GLuint i;
2790 if (intFormat) {
2791 for (i = 0; i < n; i ++) {
2792 GLuint p = uisrc[i];
2793 rgba[i][rDst] = (GLfloat) ((p >> 24) );
2794 rgba[i][gDst] = (GLfloat) ((p >> 16) & 0xff);
2795 rgba[i][bDst] = (GLfloat) ((p >> 8) & 0xff);
2796 rgba[i][aDst] = (GLfloat) ((p ) & 0xff);
2797 }
2798 }
2799 else {
2800 for (i = 0; i < n; i ++) {
2801 GLuint p = uisrc[i];
2802 rgba[i][rDst] = UBYTE_TO_FLOAT((p >> 24) );
2803 rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2804 rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
2805 rgba[i][aDst] = UBYTE_TO_FLOAT((p ) & 0xff);
2806 }
2807 }
2808 }
2809 else {
2810 const GLuint *uisrc = (const GLuint *) src;
2811 GLuint i;
2812 if (intFormat) {
2813 for (i = 0; i < n; i ++) {
2814 GLuint p = uisrc[i];
2815 rgba[i][rDst] = (GLfloat) ((p ) & 0xff);
2816 rgba[i][gDst] = (GLfloat) ((p >> 8) & 0xff);
2817 rgba[i][bDst] = (GLfloat) ((p >> 16) & 0xff);
2818 rgba[i][aDst] = (GLfloat) ((p >> 24) );
2819 }
2820 }
2821 else {
2822 for (i = 0; i < n; i ++) {
2823 GLuint p = uisrc[i];
2824 rgba[i][rDst] = UBYTE_TO_FLOAT((p ) & 0xff);
2825 rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
2826 rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2827 rgba[i][aDst] = UBYTE_TO_FLOAT((p >> 24) );
2828 }
2829 }
2830 }
2831 break;
2832 case GL_UNSIGNED_INT_10_10_10_2:
2833 if (!intFormat) {
2834 rs = 1.0F / 1023.0F;
2835 gs = 1.0F / 1023.0F;
2836 bs = 1.0F / 1023.0F;
2837 as = 1.0F / 3.0F;
2838 }
2839 if (swapBytes) {
2840 const GLuint *uisrc = (const GLuint *) src;
2841 GLuint i;
2842 for (i = 0; i < n; i ++) {
2843 GLuint p = uisrc[i];
2844 SWAP4BYTE(p);
2845 rgba[i][rDst] = ((p >> 22) ) * rs;
2846 rgba[i][gDst] = ((p >> 12) & 0x3ff) * gs;
2847 rgba[i][bDst] = ((p >> 2) & 0x3ff) * bs;
2848 rgba[i][aDst] = ((p ) & 0x3 ) * as;
2849 }
2850 }
2851 else {
2852 const GLuint *uisrc = (const GLuint *) src;
2853 GLuint i;
2854 for (i = 0; i < n; i ++) {
2855 GLuint p = uisrc[i];
2856 rgba[i][rDst] = ((p >> 22) ) * rs;
2857 rgba[i][gDst] = ((p >> 12) & 0x3ff) * gs;
2858 rgba[i][bDst] = ((p >> 2) & 0x3ff) * bs;
2859 rgba[i][aDst] = ((p ) & 0x3 ) * as;
2860 }
2861 }
2862 break;
2863 case GL_UNSIGNED_INT_2_10_10_10_REV:
2864 if (!intFormat) {
2865 rs = 1.0F / 1023.0F;
2866 gs = 1.0F / 1023.0F;
2867 bs = 1.0F / 1023.0F;
2868 as = 1.0F / 3.0F;
2869 }
2870 if (swapBytes) {
2871 const GLuint *uisrc = (const GLuint *) src;
2872 GLuint i;
2873 for (i = 0; i < n; i ++) {
2874 GLuint p = uisrc[i];
2875 SWAP4BYTE(p);
2876 rgba[i][rDst] = ((p ) & 0x3ff) * rs;
2877 rgba[i][gDst] = ((p >> 10) & 0x3ff) * gs;
2878 rgba[i][bDst] = ((p >> 20) & 0x3ff) * bs;
2879 rgba[i][aDst] = ((p >> 30) ) * as;
2880 }
2881 }
2882 else {
2883 const GLuint *uisrc = (const GLuint *) src;
2884 GLuint i;
2885 for (i = 0; i < n; i ++) {
2886 GLuint p = uisrc[i];
2887 rgba[i][rDst] = ((p ) & 0x3ff) * rs;
2888 rgba[i][gDst] = ((p >> 10) & 0x3ff) * gs;
2889 rgba[i][bDst] = ((p >> 20) & 0x3ff) * bs;
2890 rgba[i][aDst] = ((p >> 30) ) * as;
2891 }
2892 }
2893 break;
2894 case GL_UNSIGNED_INT_5_9_9_9_REV:
2895 if (swapBytes) {
2896 const GLuint *uisrc = (const GLuint *) src;
2897 GLuint i;
2898 GLfloat f[3];
2899 for (i = 0; i < n; i ++) {
2900 GLuint p = uisrc[i];
2901 SWAP4BYTE(p);
2902 rgb9e5_to_float3(p, f);
2903 rgba[i][rDst] = f[0];
2904 rgba[i][gDst] = f[1];
2905 rgba[i][bDst] = f[2];
2906 rgba[i][aDst] = 1.0F;
2907 }
2908 }
2909 else {
2910 const GLuint *uisrc = (const GLuint *) src;
2911 GLuint i;
2912 GLfloat f[3];
2913 for (i = 0; i < n; i ++) {
2914 rgb9e5_to_float3(uisrc[i], f);
2915 rgba[i][rDst] = f[0];
2916 rgba[i][gDst] = f[1];
2917 rgba[i][bDst] = f[2];
2918 rgba[i][aDst] = 1.0F;
2919 }
2920 }
2921 break;
2922 case GL_UNSIGNED_INT_10F_11F_11F_REV:
2923 if (swapBytes) {
2924 const GLuint *uisrc = (const GLuint *) src;
2925 GLuint i;
2926 GLfloat f[3];
2927 for (i = 0; i < n; i ++) {
2928 GLuint p = uisrc[i];
2929 SWAP4BYTE(p);
2930 r11g11b10f_to_float3(p, f);
2931 rgba[i][rDst] = f[0];
2932 rgba[i][gDst] = f[1];
2933 rgba[i][bDst] = f[2];
2934 rgba[i][aDst] = 1.0F;
2935 }
2936 }
2937 else {
2938 const GLuint *uisrc = (const GLuint *) src;
2939 GLuint i;
2940 GLfloat f[3];
2941 for (i = 0; i < n; i ++) {
2942 r11g11b10f_to_float3(uisrc[i], f);
2943 rgba[i][rDst] = f[0];
2944 rgba[i][gDst] = f[1];
2945 rgba[i][bDst] = f[2];
2946 rgba[i][aDst] = 1.0F;
2947 }
2948 }
2949 break;
2950 default:
2951 _mesa_problem(NULL, "bad srcType in extract float data");
2952 break;
2953 }
2954 #undef PROCESS
2955 }
2956
2957
2958 static inline GLuint
2959 clamp_byte_to_uint(GLbyte b)
2960 {
2961 return b < 0 ? 0 : b;
2962 }
2963
2964
2965 static inline GLuint
2966 clamp_short_to_uint(GLshort s)
2967 {
2968 return s < 0 ? 0 : s;
2969 }
2970
2971
2972 static inline GLuint
2973 clamp_int_to_uint(GLint i)
2974 {
2975 return i < 0 ? 0 : i;
2976 }
2977
2978
2979 static inline GLuint
2980 clamp_float_to_uint(GLfloat f)
2981 {
2982 return f < 0.0F ? 0 : IROUND(f);
2983 }
2984
2985
2986 static inline GLuint
2987 clamp_half_to_uint(GLhalfARB h)
2988 {
2989 GLfloat f = _mesa_half_to_float(h);
2990 return f < 0.0F ? 0 : IROUND(f);
2991 }
2992
2993
2994 /**
2995 * \sa extract_float_rgba()
2996 */
2997 static void
2998 extract_uint_rgba(GLuint n, GLuint rgba[][4],
2999 GLenum srcFormat, GLenum srcType, const GLvoid *src,
3000 GLboolean swapBytes)
3001 {
3002 GLint rSrc, gSrc, bSrc, aSrc;
3003 GLint stride;
3004 GLint rDst, bDst, gDst, aDst;
3005
3006 ASSERT(srcFormat == GL_RED ||
3007 srcFormat == GL_GREEN ||
3008 srcFormat == GL_BLUE ||
3009 srcFormat == GL_ALPHA ||
3010 srcFormat == GL_LUMINANCE ||
3011 srcFormat == GL_LUMINANCE_ALPHA ||
3012 srcFormat == GL_INTENSITY ||
3013 srcFormat == GL_RG ||
3014 srcFormat == GL_RGB ||
3015 srcFormat == GL_BGR ||
3016 srcFormat == GL_RGBA ||
3017 srcFormat == GL_BGRA ||
3018 srcFormat == GL_ABGR_EXT ||
3019 srcFormat == GL_DU8DV8_ATI ||
3020 srcFormat == GL_DUDV_ATI ||
3021 srcFormat == GL_RED_INTEGER_EXT ||
3022 srcFormat == GL_GREEN_INTEGER_EXT ||
3023 srcFormat == GL_BLUE_INTEGER_EXT ||
3024 srcFormat == GL_ALPHA_INTEGER_EXT ||
3025 srcFormat == GL_RGB_INTEGER_EXT ||
3026 srcFormat == GL_RGBA_INTEGER_EXT ||
3027 srcFormat == GL_BGR_INTEGER_EXT ||
3028 srcFormat == GL_BGRA_INTEGER_EXT ||
3029 srcFormat == GL_LUMINANCE_INTEGER_EXT ||
3030 srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);
3031
3032 ASSERT(srcType == GL_UNSIGNED_BYTE ||
3033 srcType == GL_BYTE ||
3034 srcType == GL_UNSIGNED_SHORT ||
3035 srcType == GL_SHORT ||
3036 srcType == GL_UNSIGNED_INT ||
3037 srcType == GL_INT ||
3038 srcType == GL_HALF_FLOAT_ARB ||
3039 srcType == GL_FLOAT ||
3040 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
3041 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
3042 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
3043 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
3044 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
3045 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
3046 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
3047 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
3048 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
3049 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
3050 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
3051 srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
3052 srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
3053 srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
3054
3055 get_component_mapping(srcFormat,
3056 &rSrc, &gSrc, &bSrc, &aSrc,
3057 &rDst, &gDst, &bDst, &aDst);
3058
3059 stride = _mesa_components_in_format(srcFormat);
3060
3061 #define PROCESS(SRC_INDEX, DST_INDEX, DEFAULT, TYPE, CONVERSION) \
3062 if ((SRC_INDEX) < 0) { \
3063 GLuint i; \
3064 for (i = 0; i < n; i++) { \
3065 rgba[i][DST_INDEX] = DEFAULT; \
3066 } \
3067 } \
3068 else if (swapBytes) { \
3069 const TYPE *s = (const TYPE *) src; \
3070 GLuint i; \
3071 for (i = 0; i < n; i++) { \
3072 TYPE value = s[SRC_INDEX]; \
3073 if (sizeof(TYPE) == 2) { \
3074 SWAP2BYTE(value); \
3075 } \
3076 else if (sizeof(TYPE) == 4) { \
3077 SWAP4BYTE(value); \
3078 } \
3079 rgba[i][DST_INDEX] = CONVERSION(value); \
3080 s += stride; \
3081 } \
3082 } \
3083 else { \
3084 const TYPE *s = (const TYPE *) src; \
3085 GLuint i; \
3086 for (i = 0; i < n; i++) { \
3087 rgba[i][DST_INDEX] = CONVERSION(s[SRC_INDEX]); \
3088 s += stride; \
3089 } \
3090 }
3091
3092 switch (srcType) {
3093 case GL_UNSIGNED_BYTE:
3094 PROCESS(rSrc, RCOMP, 0, GLubyte, (GLuint));
3095 PROCESS(gSrc, GCOMP, 0, GLubyte, (GLuint));
3096 PROCESS(bSrc, BCOMP, 0, GLubyte, (GLuint));
3097 PROCESS(aSrc, ACOMP, 1, GLubyte, (GLuint));
3098 break;
3099 case GL_BYTE:
3100 PROCESS(rSrc, RCOMP, 0, GLbyte, clamp_byte_to_uint);
3101 PROCESS(gSrc, GCOMP, 0, GLbyte, clamp_byte_to_uint);
3102 PROCESS(bSrc, BCOMP, 0, GLbyte, clamp_byte_to_uint);
3103 PROCESS(aSrc, ACOMP, 1, GLbyte, clamp_byte_to_uint);
3104 break;
3105 case GL_UNSIGNED_SHORT:
3106 PROCESS(rSrc, RCOMP, 0, GLushort, (GLuint));
3107 PROCESS(gSrc, GCOMP, 0, GLushort, (GLuint));
3108 PROCESS(bSrc, BCOMP, 0, GLushort, (GLuint));
3109 PROCESS(aSrc, ACOMP, 1, GLushort, (GLuint));
3110 break;
3111 case GL_SHORT:
3112 PROCESS(rSrc, RCOMP, 0, GLshort, clamp_short_to_uint);
3113 PROCESS(gSrc, GCOMP, 0, GLshort, clamp_short_to_uint);
3114 PROCESS(bSrc, BCOMP, 0, GLshort, clamp_short_to_uint);
3115 PROCESS(aSrc, ACOMP, 1, GLshort, clamp_short_to_uint);
3116 break;
3117 case GL_UNSIGNED_INT:
3118 PROCESS(rSrc, RCOMP, 0, GLuint, (GLuint));
3119 PROCESS(gSrc, GCOMP, 0, GLuint, (GLuint));
3120 PROCESS(bSrc, BCOMP, 0, GLuint, (GLuint));
3121 PROCESS(aSrc, ACOMP, 1, GLuint, (GLuint));
3122 break;
3123 case GL_INT:
3124 PROCESS(rSrc, RCOMP, 0, GLint, clamp_int_to_uint);
3125 PROCESS(gSrc, GCOMP, 0, GLint, clamp_int_to_uint);
3126 PROCESS(bSrc, BCOMP, 0, GLint, clamp_int_to_uint);
3127 PROCESS(aSrc, ACOMP, 1, GLint, clamp_int_to_uint);
3128 break;
3129 case GL_FLOAT:
3130 PROCESS(rSrc, RCOMP, 0, GLfloat, clamp_float_to_uint);
3131 PROCESS(gSrc, GCOMP, 0, GLfloat, clamp_float_to_uint);
3132 PROCESS(bSrc, BCOMP, 0, GLfloat, clamp_float_to_uint);
3133 PROCESS(aSrc, ACOMP, 1, GLfloat, clamp_float_to_uint);
3134 break;
3135 case GL_HALF_FLOAT_ARB:
3136 PROCESS(rSrc, RCOMP, 0, GLhalfARB, clamp_half_to_uint);
3137 PROCESS(gSrc, GCOMP, 0, GLhalfARB, clamp_half_to_uint);
3138 PROCESS(bSrc, BCOMP, 0, GLhalfARB, clamp_half_to_uint);
3139 PROCESS(aSrc, ACOMP, 1, GLhalfARB, clamp_half_to_uint);
3140 break;
3141 case GL_UNSIGNED_BYTE_3_3_2:
3142 {
3143 const GLubyte *ubsrc = (const GLubyte *) src;
3144 GLuint i;
3145 for (i = 0; i < n; i ++) {
3146 GLubyte p = ubsrc[i];
3147 rgba[i][rDst] = ((p >> 5) );
3148 rgba[i][gDst] = ((p >> 2) & 0x7);
3149 rgba[i][bDst] = ((p ) & 0x3);
3150 rgba[i][aDst] = 1;
3151 }
3152 }
3153 break;
3154 case GL_UNSIGNED_BYTE_2_3_3_REV:
3155 {
3156 const GLubyte *ubsrc = (const GLubyte *) src;
3157 GLuint i;
3158 for (i = 0; i < n; i ++) {
3159 GLubyte p = ubsrc[i];
3160 rgba[i][rDst] = ((p ) & 0x7);
3161 rgba[i][gDst] = ((p >> 3) & 0x7);
3162 rgba[i][bDst] = ((p >> 6) );
3163 rgba[i][aDst] = 1;
3164 }
3165 }
3166 break;
3167 case GL_UNSIGNED_SHORT_5_6_5:
3168 if (swapBytes) {
3169 const GLushort *ussrc = (const GLushort *) src;
3170 GLuint i;
3171 for (i = 0; i < n; i ++) {
3172 GLushort p = ussrc[i];
3173 SWAP2BYTE(p);
3174 rgba[i][rDst] = ((p >> 11) );
3175 rgba[i][gDst] = ((p >> 5) & 0x3f);
3176 rgba[i][bDst] = ((p ) & 0x1f);
3177 rgba[i][aDst] = 1;
3178 }
3179 }
3180 else {
3181 const GLushort *ussrc = (const GLushort *) src;
3182 GLuint i;
3183 for (i = 0; i < n; i ++) {
3184 GLushort p = ussrc[i];
3185 rgba[i][rDst] = ((p >> 11) );
3186 rgba[i][gDst] = ((p >> 5) & 0x3f);
3187 rgba[i][bDst] = ((p ) & 0x1f);
3188 rgba[i][aDst] = 1;
3189 }
3190 }
3191 break;
3192 case GL_UNSIGNED_SHORT_5_6_5_REV:
3193 if (swapBytes) {
3194 const GLushort *ussrc = (const GLushort *) src;
3195 GLuint i;
3196 for (i = 0; i < n; i ++) {
3197 GLushort p = ussrc[i];
3198 SWAP2BYTE(p);
3199 rgba[i][rDst] = ((p ) & 0x1f);
3200 rgba[i][gDst] = ((p >> 5) & 0x3f);
3201 rgba[i][bDst] = ((p >> 11) );
3202 rgba[i][aDst] = 1;
3203 }
3204 }
3205 else {
3206 const GLushort *ussrc = (const GLushort *) src;
3207 GLuint i;
3208 for (i = 0; i < n; i ++) {
3209 GLushort p = ussrc[i];
3210 rgba[i][rDst] = ((p ) & 0x1f);
3211 rgba[i][gDst] = ((p >> 5) & 0x3f);
3212 rgba[i][bDst] = ((p >> 11) );
3213 rgba[i][aDst] = 1;
3214 }
3215 }
3216 break;
3217 case GL_UNSIGNED_SHORT_4_4_4_4:
3218 if (swapBytes) {
3219 const GLushort *ussrc = (const GLushort *) src;
3220 GLuint i;
3221 for (i = 0; i < n; i ++) {
3222 GLushort p = ussrc[i];
3223 SWAP2BYTE(p);
3224 rgba[i][rDst] = ((p >> 12) );
3225 rgba[i][gDst] = ((p >> 8) & 0xf);
3226 rgba[i][bDst] = ((p >> 4) & 0xf);
3227 rgba[i][aDst] = ((p ) & 0xf);
3228 }
3229 }
3230 else {
3231 const GLushort *ussrc = (const GLushort *) src;
3232 GLuint i;
3233 for (i = 0; i < n; i ++) {
3234 GLushort p = ussrc[i];
3235 rgba[i][rDst] = ((p >> 12) );
3236 rgba[i][gDst] = ((p >> 8) & 0xf);
3237 rgba[i][bDst] = ((p >> 4) & 0xf);
3238 rgba[i][aDst] = ((p ) & 0xf);
3239 }
3240 }
3241 break;
3242 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
3243 if (swapBytes) {
3244 const GLushort *ussrc = (const GLushort *) src;
3245 GLuint i;
3246 for (i = 0; i < n; i ++) {
3247 GLushort p = ussrc[i];
3248 SWAP2BYTE(p);
3249 rgba[i][rDst] = ((p ) & 0xf);
3250 rgba[i][gDst] = ((p >> 4) & 0xf);
3251 rgba[i][bDst] = ((p >> 8) & 0xf);
3252 rgba[i][aDst] = ((p >> 12) );
3253 }
3254 }
3255 else {
3256 const GLushort *ussrc = (const GLushort *) src;
3257 GLuint i;
3258 for (i = 0; i < n; i ++) {
3259 GLushort p = ussrc[i];
3260 rgba[i][rDst] = ((p ) & 0xf);
3261 rgba[i][gDst] = ((p >> 4) & 0xf);
3262 rgba[i][bDst] = ((p >> 8) & 0xf);
3263 rgba[i][aDst] = ((p >> 12) );
3264 }
3265 }
3266 break;
3267 case GL_UNSIGNED_SHORT_5_5_5_1:
3268 if (swapBytes) {
3269 const GLushort *ussrc = (const GLushort *) src;
3270 GLuint i;
3271 for (i = 0; i < n; i ++) {
3272 GLushort p = ussrc[i];
3273 SWAP2BYTE(p);
3274 rgba[i][rDst] = ((p >> 11) );
3275 rgba[i][gDst] = ((p >> 6) & 0x1f);
3276 rgba[i][bDst] = ((p >> 1) & 0x1f);
3277 rgba[i][aDst] = ((p ) & 0x1 );
3278 }
3279 }
3280 else {
3281 const GLushort *ussrc = (const GLushort *) src;
3282 GLuint i;
3283 for (i = 0; i < n; i ++) {
3284 GLushort p = ussrc[i];
3285 rgba[i][rDst] = ((p >> 11) );
3286 rgba[i][gDst] = ((p >> 6) & 0x1f);
3287 rgba[i][bDst] = ((p >> 1) & 0x1f);
3288 rgba[i][aDst] = ((p ) & 0x1 );
3289 }
3290 }
3291 break;
3292 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
3293 if (swapBytes) {
3294 const GLushort *ussrc = (const GLushort *) src;
3295 GLuint i;
3296 for (i = 0; i < n; i ++) {
3297 GLushort p = ussrc[i];
3298 SWAP2BYTE(p);
3299 rgba[i][rDst] = ((p ) & 0x1f);
3300 rgba[i][gDst] = ((p >> 5) & 0x1f);
3301 rgba[i][bDst] = ((p >> 10) & 0x1f);
3302 rgba[i][aDst] = ((p >> 15) );
3303 }
3304 }
3305 else {
3306 const GLushort *ussrc = (const GLushort *) src;
3307 GLuint i;
3308 for (i = 0; i < n; i ++) {
3309 GLushort p = ussrc[i];
3310 rgba[i][rDst] = ((p ) & 0x1f);
3311 rgba[i][gDst] = ((p >> 5) & 0x1f);
3312 rgba[i][bDst] = ((p >> 10) & 0x1f);
3313 rgba[i][aDst] = ((p >> 15) );
3314 }
3315 }
3316 break;
3317 case GL_UNSIGNED_INT_8_8_8_8:
3318 if (swapBytes) {
3319 const GLuint *uisrc = (const GLuint *) src;
3320 GLuint i;
3321 for (i = 0; i < n; i ++) {
3322 GLuint p = uisrc[i];
3323 rgba[i][rDst] = ((p ) & 0xff);
3324 rgba[i][gDst] = ((p >> 8) & 0xff);
3325 rgba[i][bDst] = ((p >> 16) & 0xff);
3326 rgba[i][aDst] = ((p >> 24) );
3327 }
3328 }
3329 else {
3330 const GLuint *uisrc = (const GLuint *) src;
3331 GLuint i;
3332 for (i = 0; i < n; i ++) {
3333 GLuint p = uisrc[i];
3334 rgba[i][rDst] = ((p >> 24) );
3335 rgba[i][gDst] = ((p >> 16) & 0xff);
3336 rgba[i][bDst] = ((p >> 8) & 0xff);
3337 rgba[i][aDst] = ((p ) & 0xff);
3338 }
3339 }
3340 break;
3341 case GL_UNSIGNED_INT_8_8_8_8_REV:
3342 if (swapBytes) {
3343 const GLuint *uisrc = (const GLuint *) src;
3344 GLuint i;
3345 for (i = 0; i < n; i ++) {
3346 GLuint p = uisrc[i];
3347 rgba[i][rDst] = ((p >> 24) );
3348 rgba[i][gDst] = ((p >> 16) & 0xff);
3349 rgba[i][bDst] = ((p >> 8) & 0xff);
3350 rgba[i][aDst] = ((p ) & 0xff);
3351 }
3352 }
3353 else {
3354 const GLuint *uisrc = (const GLuint *) src;
3355 GLuint i;
3356 for (i = 0; i < n; i ++) {
3357 GLuint p = uisrc[i];
3358 rgba[i][rDst] = ((p ) & 0xff);
3359 rgba[i][gDst] = ((p >> 8) & 0xff);
3360 rgba[i][bDst] = ((p >> 16) & 0xff);
3361 rgba[i][aDst] = ((p >> 24) );
3362 }
3363 }
3364 break;
3365 case GL_UNSIGNED_INT_10_10_10_2:
3366 if (swapBytes) {
3367 const GLuint *uisrc = (const GLuint *) src;
3368 GLuint i;
3369 for (i = 0; i < n; i ++) {
3370 GLuint p = uisrc[i];
3371 SWAP4BYTE(p);
3372 rgba[i][rDst] = ((p >> 22) );
3373 rgba[i][gDst] = ((p >> 12) & 0x3ff);
3374 rgba[i][bDst] = ((p >> 2) & 0x3ff);
3375 rgba[i][aDst] = ((p ) & 0x3 );
3376 }
3377 }
3378 else {
3379 const GLuint *uisrc = (const GLuint *) src;
3380 GLuint i;
3381 for (i = 0; i < n; i ++) {
3382 GLuint p = uisrc[i];
3383 rgba[i][rDst] = ((p >> 22) );
3384 rgba[i][gDst] = ((p >> 12) & 0x3ff);
3385 rgba[i][bDst] = ((p >> 2) & 0x3ff);
3386 rgba[i][aDst] = ((p ) & 0x3 );
3387 }
3388 }
3389 break;
3390 case GL_UNSIGNED_INT_2_10_10_10_REV:
3391 if (swapBytes) {
3392 const GLuint *uisrc = (const GLuint *) src;
3393 GLuint i;
3394 for (i = 0; i < n; i ++) {
3395 GLuint p = uisrc[i];
3396 SWAP4BYTE(p);
3397 rgba[i][rDst] = ((p ) & 0x3ff);
3398 rgba[i][gDst] = ((p >> 10) & 0x3ff);
3399 rgba[i][bDst] = ((p >> 20) & 0x3ff);
3400 rgba[i][aDst] = ((p >> 30) );
3401 }
3402 }
3403 else {
3404 const GLuint *uisrc = (const GLuint *) src;
3405 GLuint i;
3406 for (i = 0; i < n; i ++) {
3407 GLuint p = uisrc[i];
3408 rgba[i][rDst] = ((p ) & 0x3ff);
3409 rgba[i][gDst] = ((p >> 10) & 0x3ff);
3410 rgba[i][bDst] = ((p >> 20) & 0x3ff);
3411 rgba[i][aDst] = ((p >> 30) );
3412 }
3413 }
3414 break;
3415 case GL_UNSIGNED_INT_5_9_9_9_REV:
3416 if (swapBytes) {
3417 const GLuint *uisrc = (const GLuint *) src;
3418 GLuint i;
3419 float f[3];
3420 for (i = 0; i < n; i ++) {
3421 GLuint p = uisrc[i];
3422 SWAP4BYTE(p);
3423 rgb9e5_to_float3(p, f);
3424 rgba[i][rDst] = clamp_float_to_uint(f[0]);
3425 rgba[i][gDst] = clamp_float_to_uint(f[1]);
3426 rgba[i][bDst] = clamp_float_to_uint(f[2]);
3427 rgba[i][aDst] = 1;
3428 }
3429 }
3430 else {
3431 const GLuint *uisrc = (const GLuint *) src;
3432 GLuint i;
3433 float f[3];
3434 for (i = 0; i < n; i ++) {
3435 GLuint p = uisrc[i];
3436 rgb9e5_to_float3(p, f);
3437 rgba[i][rDst] = clamp_float_to_uint(f[0]);
3438 rgba[i][gDst] = clamp_float_to_uint(f[1]);
3439 rgba[i][bDst] = clamp_float_to_uint(f[2]);
3440 rgba[i][aDst] = 1;
3441 }
3442 }
3443 break;
3444 case GL_UNSIGNED_INT_10F_11F_11F_REV:
3445 if (swapBytes) {
3446 const GLuint *uisrc = (const GLuint *) src;
3447 GLuint i;
3448 float f[3];
3449 for (i = 0; i < n; i ++) {
3450 GLuint p = uisrc[i];
3451 SWAP4BYTE(p);
3452 r11g11b10f_to_float3(p, f);
3453 rgba[i][rDst] = clamp_float_to_uint(f[0]);
3454 rgba[i][gDst] = clamp_float_to_uint(f[1]);
3455 rgba[i][bDst] = clamp_float_to_uint(f[2]);
3456 rgba[i][aDst] = 1;
3457 }
3458 }
3459 else {
3460 const GLuint *uisrc = (const GLuint *) src;
3461 GLuint i;
3462 float f[3];
3463 for (i = 0; i < n; i ++) {
3464 GLuint p = uisrc[i];
3465 r11g11b10f_to_float3(p, f);
3466 rgba[i][rDst] = clamp_float_to_uint(f[0]);
3467 rgba[i][gDst] = clamp_float_to_uint(f[1]);
3468 rgba[i][bDst] = clamp_float_to_uint(f[2]);
3469 rgba[i][aDst] = 1;
3470 }
3471 }
3472 break;
3473 default:
3474 _mesa_problem(NULL, "bad srcType in extract uint data");
3475 break;
3476 }
3477 #undef PROCESS
3478 }
3479
3480
3481
3482 /*
3483 * Unpack a row of color image data from a client buffer according to
3484 * the pixel unpacking parameters.
3485 * Return GLubyte values in the specified dest image format.
3486 * This is used by glDrawPixels and glTexImage?D().
3487 * \param ctx - the context
3488 * n - number of pixels in the span
3489 * dstFormat - format of destination color array
3490 * dest - the destination color array
3491 * srcFormat - source image format
3492 * srcType - source image data type
3493 * source - source image pointer
3494 * srcPacking - pixel unpacking parameters
3495 * transferOps - bitmask of IMAGE_*_BIT values of operations to apply
3496 *
3497 * XXX perhaps expand this to process whole images someday.
3498 */
3499 void
3500 _mesa_unpack_color_span_ubyte(struct gl_context *ctx,
3501 GLuint n, GLenum dstFormat, GLubyte dest[],
3502 GLenum srcFormat, GLenum srcType,
3503 const GLvoid *source,
3504 const struct gl_pixelstore_attrib *srcPacking,
3505 GLbitfield transferOps )
3506 {
3507 GLboolean intFormat = _mesa_is_integer_format(srcFormat);
3508 ASSERT(dstFormat == GL_ALPHA ||
3509 dstFormat == GL_LUMINANCE ||
3510 dstFormat == GL_LUMINANCE_ALPHA ||
3511 dstFormat == GL_INTENSITY ||
3512 dstFormat == GL_RED ||
3513 dstFormat == GL_RG ||
3514 dstFormat == GL_RGB ||
3515 dstFormat == GL_RGBA);
3516
3517 ASSERT(srcFormat == GL_RED ||
3518 srcFormat == GL_GREEN ||
3519 srcFormat == GL_BLUE ||
3520 srcFormat == GL_ALPHA ||
3521 srcFormat == GL_LUMINANCE ||
3522 srcFormat == GL_LUMINANCE_ALPHA ||
3523 srcFormat == GL_INTENSITY ||
3524 srcFormat == GL_RG ||
3525 srcFormat == GL_RGB ||
3526 srcFormat == GL_BGR ||
3527 srcFormat == GL_RGBA ||
3528 srcFormat == GL_BGRA ||
3529 srcFormat == GL_ABGR_EXT ||
3530 srcFormat == GL_COLOR_INDEX);
3531
3532 ASSERT(srcType == GL_BITMAP ||
3533 srcType == GL_UNSIGNED_BYTE ||
3534 srcType == GL_BYTE ||
3535 srcType == GL_UNSIGNED_SHORT ||
3536 srcType == GL_SHORT ||
3537 srcType == GL_UNSIGNED_INT ||
3538 srcType == GL_INT ||
3539 srcType == GL_HALF_FLOAT_ARB ||
3540 srcType == GL_FLOAT ||
3541 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
3542 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
3543 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
3544 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
3545 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
3546 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
3547 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
3548 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
3549 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
3550 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
3551 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
3552 srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
3553 srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
3554 srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
3555
3556 /* EXT_texture_integer specifies no transfer ops on integer
3557 * types in the resolved issues section. Just set them to 0
3558 * for integer surfaces.
3559 */
3560 if (intFormat)
3561 transferOps = 0;
3562
3563 /* Try simple cases first */
3564 if (transferOps == 0) {
3565 if (srcType == GL_UNSIGNED_BYTE) {
3566 if (dstFormat == GL_RGBA) {
3567 if (srcFormat == GL_RGBA) {
3568 memcpy( dest, source, n * 4 * sizeof(GLubyte) );
3569 return;
3570 }
3571 else if (srcFormat == GL_RGB) {
3572 GLuint i;
3573 const GLubyte *src = (const GLubyte *) source;
3574 GLubyte *dst = dest;
3575 for (i = 0; i < n; i++) {
3576 dst[0] = src[0];
3577 dst[1] = src[1];
3578 dst[2] = src[2];
3579 dst[3] = 255;
3580 src += 3;
3581 dst += 4;
3582 }
3583 return;
3584 }
3585 }
3586 else if (dstFormat == GL_RGB) {
3587 if (srcFormat == GL_RGB) {
3588 memcpy( dest, source, n * 3 * sizeof(GLubyte) );
3589 return;
3590 }
3591 else if (srcFormat == GL_RGBA) {
3592 GLuint i;
3593 const GLubyte *src = (const GLubyte *) source;
3594 GLubyte *dst = dest;
3595 for (i = 0; i < n; i++) {
3596 dst[0] = src[0];
3597 dst[1] = src[1];
3598 dst[2] = src[2];
3599 src += 4;
3600 dst += 3;
3601 }
3602 return;
3603 }
3604 }
3605 else if (dstFormat == srcFormat) {
3606 GLint comps = _mesa_components_in_format(srcFormat);
3607 assert(comps > 0);
3608 memcpy( dest, source, n * comps * sizeof(GLubyte) );
3609 return;
3610 }
3611 }
3612 /*
3613 * Common situation, loading 8bit RGBA/RGB source images
3614 * into 16/32 bit destination. (OSMesa16/32)
3615 */
3616 else if (srcType == GL_UNSIGNED_BYTE) {
3617 if (dstFormat == GL_RGBA) {
3618 if (srcFormat == GL_RGB) {
3619 GLuint i;
3620 const GLubyte *src = (const GLubyte *) source;
3621 GLubyte *dst = dest;
3622 for (i = 0; i < n; i++) {
3623 dst[0] = src[0];
3624 dst[1] = src[1];
3625 dst[2] = src[2];
3626 dst[3] = 255;
3627 src += 3;
3628 dst += 4;
3629 }
3630 return;
3631 }
3632 else if (srcFormat == GL_RGBA) {
3633 GLuint i;
3634 const GLubyte *src = (const GLubyte *) source;
3635 GLubyte *dst = dest;
3636 for (i = 0; i < n; i++) {
3637 dst[0] = src[0];
3638 dst[1] = src[1];
3639 dst[2] = src[2];
3640 dst[3] = src[3];
3641 src += 4;
3642 dst += 4;
3643 }
3644 return;
3645 }
3646 }
3647 else if (dstFormat == GL_RGB) {
3648 if (srcFormat == GL_RGB) {
3649 GLuint i;
3650 const GLubyte *src = (const GLubyte *) source;
3651 GLubyte *dst = dest;
3652 for (i = 0; i < n; i++) {
3653 dst[0] = src[0];
3654 dst[1] = src[1];
3655 dst[2] = src[2];
3656 src += 3;
3657 dst += 3;
3658 }
3659 return;
3660 }
3661 else if (srcFormat == GL_RGBA) {
3662 GLuint i;
3663 const GLubyte *src = (const GLubyte *) source;
3664 GLubyte *dst = dest;
3665 for (i = 0; i < n; i++) {
3666 dst[0] = src[0];
3667 dst[1] = src[1];
3668 dst[2] = src[2];
3669 src += 4;
3670 dst += 3;
3671 }
3672 return;
3673 }
3674 }
3675 }
3676 }
3677
3678
3679 /* general solution begins here */
3680 {
3681 GLint dstComponents;
3682 GLint rDst, gDst, bDst, aDst, lDst, iDst;
3683 GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));
3684
3685 if (!rgba) {
3686 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3687 return;
3688 }
3689
3690 dstComponents = _mesa_components_in_format( dstFormat );
3691 /* source & dest image formats should have been error checked by now */
3692 assert(dstComponents > 0);
3693
3694 /*
3695 * Extract image data and convert to RGBA floats
3696 */
3697 if (srcFormat == GL_COLOR_INDEX) {
3698 GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
3699
3700 if (!indexes) {
3701 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3702 free(rgba);
3703 return;
3704 }
3705
3706 extract_uint_indexes(n, indexes, srcFormat, srcType, source,
3707 srcPacking);
3708
3709 /* Convert indexes to RGBA */
3710 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
3711 _mesa_shift_and_offset_ci(ctx, n, indexes);
3712 }
3713 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
3714
3715 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
3716 * with color indexes.
3717 */
3718 transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT);
3719
3720 free(indexes);
3721 }
3722 else {
3723 /* non-color index data */
3724 extract_float_rgba(n, rgba, srcFormat, srcType, source,
3725 srcPacking->SwapBytes);
3726 }
3727
3728 /* Need to clamp if returning GLubytes */
3729 transferOps |= IMAGE_CLAMP_BIT;
3730
3731 if (transferOps) {
3732 _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
3733 }
3734
3735 get_component_indexes(dstFormat,
3736 &rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
3737
3738 /* Now return the GLubyte data in the requested dstFormat */
3739 if (rDst >= 0) {
3740 GLubyte *dst = dest;
3741 GLuint i;
3742 for (i = 0; i < n; i++) {
3743 CLAMPED_FLOAT_TO_UBYTE(dst[rDst], rgba[i][RCOMP]);
3744 dst += dstComponents;
3745 }
3746 }
3747
3748 if (gDst >= 0) {
3749 GLubyte *dst = dest;
3750 GLuint i;
3751 for (i = 0; i < n; i++) {
3752 CLAMPED_FLOAT_TO_UBYTE(dst[gDst], rgba[i][GCOMP]);
3753 dst += dstComponents;
3754 }
3755 }
3756
3757 if (bDst >= 0) {
3758 GLubyte *dst = dest;
3759 GLuint i;
3760 for (i = 0; i < n; i++) {
3761 CLAMPED_FLOAT_TO_UBYTE(dst[bDst], rgba[i][BCOMP]);
3762 dst += dstComponents;
3763 }
3764 }
3765
3766 if (aDst >= 0) {
3767 GLubyte *dst = dest;
3768 GLuint i;
3769 for (i = 0; i < n; i++) {
3770 CLAMPED_FLOAT_TO_UBYTE(dst[aDst], rgba[i][ACOMP]);
3771 dst += dstComponents;
3772 }
3773 }
3774
3775 if (iDst >= 0) {
3776 GLubyte *dst = dest;
3777 GLuint i;
3778 assert(iDst == 0);
3779 assert(dstComponents == 1);
3780 for (i = 0; i < n; i++) {
3781 /* Intensity comes from red channel */
3782 CLAMPED_FLOAT_TO_UBYTE(dst[i], rgba[i][RCOMP]);
3783 }
3784 }
3785
3786 if (lDst >= 0) {
3787 GLubyte *dst = dest;
3788 GLuint i;
3789 assert(lDst == 0);
3790 for (i = 0; i < n; i++) {
3791 /* Luminance comes from red channel */
3792 CLAMPED_FLOAT_TO_UBYTE(dst[0], rgba[i][RCOMP]);
3793 dst += dstComponents;
3794 }
3795 }
3796
3797 free(rgba);
3798 }
3799 }
3800
3801
3802 /**
3803 * Same as _mesa_unpack_color_span_ubyte(), but return GLfloat data
3804 * instead of GLubyte.
3805 */
3806 void
3807 _mesa_unpack_color_span_float( struct gl_context *ctx,
3808 GLuint n, GLenum dstFormat, GLfloat dest[],
3809 GLenum srcFormat, GLenum srcType,
3810 const GLvoid *source,
3811 const struct gl_pixelstore_attrib *srcPacking,
3812 GLbitfield transferOps )
3813 {
3814 ASSERT(dstFormat == GL_ALPHA ||
3815 dstFormat == GL_LUMINANCE ||
3816 dstFormat == GL_LUMINANCE_ALPHA ||
3817 dstFormat == GL_INTENSITY ||
3818 dstFormat == GL_RED ||
3819 dstFormat == GL_RG ||
3820 dstFormat == GL_RGB ||
3821 dstFormat == GL_RGBA);
3822
3823 ASSERT(srcFormat == GL_RED ||
3824 srcFormat == GL_GREEN ||
3825 srcFormat == GL_BLUE ||
3826 srcFormat == GL_ALPHA ||
3827 srcFormat == GL_LUMINANCE ||
3828 srcFormat == GL_LUMINANCE_ALPHA ||
3829 srcFormat == GL_INTENSITY ||
3830 srcFormat == GL_RG ||
3831 srcFormat == GL_RGB ||
3832 srcFormat == GL_BGR ||
3833 srcFormat == GL_RGBA ||
3834 srcFormat == GL_BGRA ||
3835 srcFormat == GL_ABGR_EXT ||
3836 srcFormat == GL_RED_INTEGER_EXT ||
3837 srcFormat == GL_GREEN_INTEGER_EXT ||
3838 srcFormat == GL_BLUE_INTEGER_EXT ||
3839 srcFormat == GL_ALPHA_INTEGER_EXT ||
3840 srcFormat == GL_RGB_INTEGER_EXT ||
3841 srcFormat == GL_RGBA_INTEGER_EXT ||
3842 srcFormat == GL_BGR_INTEGER_EXT ||
3843 srcFormat == GL_BGRA_INTEGER_EXT ||
3844 srcFormat == GL_LUMINANCE_INTEGER_EXT ||
3845 srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT ||
3846 srcFormat == GL_COLOR_INDEX);
3847
3848 ASSERT(srcType == GL_BITMAP ||
3849 srcType == GL_UNSIGNED_BYTE ||
3850 srcType == GL_BYTE ||
3851 srcType == GL_UNSIGNED_SHORT ||
3852 srcType == GL_SHORT ||
3853 srcType == GL_UNSIGNED_INT ||
3854 srcType == GL_INT ||
3855 srcType == GL_HALF_FLOAT_ARB ||
3856 srcType == GL_FLOAT ||
3857 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
3858 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
3859 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
3860 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
3861 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
3862 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
3863 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
3864 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
3865 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
3866 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
3867 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
3868 srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
3869 srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
3870 srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
3871
3872 /* general solution, no special cases, yet */
3873 {
3874 GLint dstComponents;
3875 GLint rDst, gDst, bDst, aDst, lDst, iDst;
3876 GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));
3877 GLboolean intFormat = _mesa_is_integer_format(srcFormat);
3878
3879 if (!rgba) {
3880 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3881 return;
3882 }
3883
3884 dstComponents = _mesa_components_in_format( dstFormat );
3885 /* source & dest image formats should have been error checked by now */
3886 assert(dstComponents > 0);
3887
3888 /* EXT_texture_integer specifies no transfer ops on integer
3889 * types in the resolved issues section. Just set them to 0
3890 * for integer surfaces.
3891 */
3892 if (intFormat)
3893 transferOps = 0;
3894
3895 /*
3896 * Extract image data and convert to RGBA floats
3897 */
3898 if (srcFormat == GL_COLOR_INDEX) {
3899 GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
3900
3901 if (!indexes) {
3902 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3903 free(rgba);
3904 return;
3905 }
3906
3907 extract_uint_indexes(n, indexes, srcFormat, srcType, source,
3908 srcPacking);
3909
3910 /* Convert indexes to RGBA */
3911 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
3912 _mesa_shift_and_offset_ci(ctx, n, indexes);
3913 }
3914 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
3915
3916 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
3917 * with color indexes.
3918 */
3919 transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT);
3920
3921 free(indexes);
3922 }
3923 else {
3924 /* non-color index data */
3925 extract_float_rgba(n, rgba, srcFormat, srcType, source,
3926 srcPacking->SwapBytes);
3927 }
3928
3929 if (transferOps) {
3930 _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
3931 }
3932
3933 get_component_indexes(dstFormat,
3934 &rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
3935
3936 /* Now pack results in the requested dstFormat */
3937 if (rDst >= 0) {
3938 GLfloat *dst = dest;
3939 GLuint i;
3940 for (i = 0; i < n; i++) {
3941 dst[rDst] = rgba[i][RCOMP];
3942 dst += dstComponents;
3943 }
3944 }
3945
3946 if (gDst >= 0) {
3947 GLfloat *dst = dest;
3948 GLuint i;
3949 for (i = 0; i < n; i++) {
3950 dst[gDst] = rgba[i][GCOMP];
3951 dst += dstComponents;
3952 }
3953 }
3954
3955 if (bDst >= 0) {
3956 GLfloat *dst = dest;
3957 GLuint i;
3958 for (i = 0; i < n; i++) {
3959 dst[bDst] = rgba[i][BCOMP];
3960 dst += dstComponents;
3961 }
3962 }
3963
3964 if (aDst >= 0) {
3965 GLfloat *dst = dest;
3966 GLuint i;
3967 for (i = 0; i < n; i++) {
3968 dst[aDst] = rgba[i][ACOMP];
3969 dst += dstComponents;
3970 }
3971 }
3972
3973 if (iDst >= 0) {
3974 GLfloat *dst = dest;
3975 GLuint i;
3976 assert(iDst == 0);
3977 assert(dstComponents == 1);
3978 for (i = 0; i < n; i++) {
3979 /* Intensity comes from red channel */
3980 dst[i] = rgba[i][RCOMP];
3981 }
3982 }
3983
3984 if (lDst >= 0) {
3985 GLfloat *dst = dest;
3986 GLuint i;
3987 assert(lDst == 0);
3988 for (i = 0; i < n; i++) {
3989 /* Luminance comes from red channel */
3990 dst[0] = rgba[i][RCOMP];
3991 dst += dstComponents;
3992 }
3993 }
3994
3995 free(rgba);
3996 }
3997 }
3998
3999
4000 /**
4001 * Same as _mesa_unpack_color_span_ubyte(), but return GLuint data
4002 * instead of GLubyte.
4003 * No pixel transfer ops are applied.
4004 */
4005 void
4006 _mesa_unpack_color_span_uint(struct gl_context *ctx,
4007 GLuint n, GLenum dstFormat, GLuint *dest,
4008 GLenum srcFormat, GLenum srcType,
4009 const GLvoid *source,
4010 const struct gl_pixelstore_attrib *srcPacking)
4011 {
4012 GLuint (*rgba)[4] = (GLuint (*)[4]) malloc(n * 4 * sizeof(GLfloat));
4013
4014 if (!rgba) {
4015 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
4016 return;
4017 }
4018
4019 ASSERT(dstFormat == GL_ALPHA ||
4020 dstFormat == GL_LUMINANCE ||
4021 dstFormat == GL_LUMINANCE_ALPHA ||
4022 dstFormat == GL_INTENSITY ||
4023 dstFormat == GL_RED ||
4024 dstFormat == GL_RG ||
4025 dstFormat == GL_RGB ||
4026 dstFormat == GL_RGBA);
4027
4028 ASSERT(srcFormat == GL_RED ||
4029 srcFormat == GL_GREEN ||
4030 srcFormat == GL_BLUE ||
4031 srcFormat == GL_ALPHA ||
4032 srcFormat == GL_LUMINANCE ||
4033 srcFormat == GL_LUMINANCE_ALPHA ||
4034 srcFormat == GL_INTENSITY ||
4035 srcFormat == GL_RG ||
4036 srcFormat == GL_RGB ||
4037 srcFormat == GL_BGR ||
4038 srcFormat == GL_RGBA ||
4039 srcFormat == GL_BGRA ||
4040 srcFormat == GL_ABGR_EXT ||
4041 srcFormat == GL_RED_INTEGER_EXT ||
4042 srcFormat == GL_GREEN_INTEGER_EXT ||
4043 srcFormat == GL_BLUE_INTEGER_EXT ||
4044 srcFormat == GL_ALPHA_INTEGER_EXT ||
4045 srcFormat == GL_RGB_INTEGER_EXT ||
4046 srcFormat == GL_RGBA_INTEGER_EXT ||
4047 srcFormat == GL_BGR_INTEGER_EXT ||
4048 srcFormat == GL_BGRA_INTEGER_EXT ||
4049 srcFormat == GL_LUMINANCE_INTEGER_EXT ||
4050 srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);
4051
4052 ASSERT(srcType == GL_UNSIGNED_BYTE ||
4053 srcType == GL_BYTE ||
4054 srcType == GL_UNSIGNED_SHORT ||
4055 srcType == GL_SHORT ||
4056 srcType == GL_UNSIGNED_INT ||
4057 srcType == GL_INT ||
4058 srcType == GL_HALF_FLOAT_ARB ||
4059 srcType == GL_FLOAT ||
4060 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
4061 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
4062 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
4063 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
4064 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
4065 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
4066 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
4067 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
4068 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
4069 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
4070 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
4071 srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
4072 srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
4073 srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
4074
4075
4076 /* Extract image data as uint[4] pixels */
4077 extract_uint_rgba(n, rgba, srcFormat, srcType, source,
4078 srcPacking->SwapBytes);
4079
4080 if (dstFormat == GL_RGBA) {
4081 /* simple case */
4082 memcpy(dest, rgba, 4 * sizeof(GLuint) * n);
4083 }
4084 else {
4085 /* general case */
4086 GLint rDst, gDst, bDst, aDst, lDst, iDst;
4087 GLint dstComponents = _mesa_components_in_format( dstFormat );
4088
4089 assert(dstComponents > 0);
4090
4091 get_component_indexes(dstFormat,
4092 &rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
4093
4094 /* Now pack values in the requested dest format */
4095 if (rDst >= 0) {
4096 GLuint *dst = dest;
4097 GLuint i;
4098 for (i = 0; i < n; i++) {
4099 dst[rDst] = rgba[i][RCOMP];
4100 dst += dstComponents;
4101 }
4102 }
4103
4104 if (gDst >= 0) {
4105 GLuint *dst = dest;
4106 GLuint i;
4107 for (i = 0; i < n; i++) {
4108 dst[gDst] = rgba[i][GCOMP];
4109 dst += dstComponents;
4110 }
4111 }
4112
4113 if (bDst >= 0) {
4114 GLuint *dst = dest;
4115 GLuint i;
4116 for (i = 0; i < n; i++) {
4117 dst[bDst] = rgba[i][BCOMP];
4118 dst += dstComponents;
4119 }
4120 }
4121
4122 if (aDst >= 0) {
4123 GLuint *dst = dest;
4124 GLuint i;
4125 for (i = 0; i < n; i++) {
4126 dst[aDst] = rgba[i][ACOMP];
4127 dst += dstComponents;
4128 }
4129 }
4130
4131 if (iDst >= 0) {
4132 GLuint *dst = dest;
4133 GLuint i;
4134 assert(iDst == 0);
4135 assert(dstComponents == 1);
4136 for (i = 0; i < n; i++) {
4137 /* Intensity comes from red channel */
4138 dst[i] = rgba[i][RCOMP];
4139 }
4140 }
4141
4142 if (lDst >= 0) {
4143 GLuint *dst = dest;
4144 GLuint i;
4145 assert(lDst == 0);
4146 for (i = 0; i < n; i++) {
4147 /* Luminance comes from red channel */
4148 dst[0] = rgba[i][RCOMP];
4149 dst += dstComponents;
4150 }
4151 }
4152 }
4153
4154 free(rgba);
4155 }
4156
4157
4158
4159 /**
4160 * Similar to _mesa_unpack_color_span_float(), but for dudv data instead of rgba,
4161 * directly return GLbyte data, no transfer ops apply.
4162 */
4163 void
4164 _mesa_unpack_dudv_span_byte( struct gl_context *ctx,
4165 GLuint n, GLenum dstFormat, GLbyte dest[],
4166 GLenum srcFormat, GLenum srcType,
4167 const GLvoid *source,
4168 const struct gl_pixelstore_attrib *srcPacking,
4169 GLbitfield transferOps )
4170 {
4171 ASSERT(dstFormat == GL_DUDV_ATI);
4172 ASSERT(srcFormat == GL_DUDV_ATI ||
4173 srcFormat == GL_DU8DV8_ATI);
4174
4175 ASSERT(srcType == GL_UNSIGNED_BYTE ||
4176 srcType == GL_BYTE ||
4177 srcType == GL_UNSIGNED_SHORT ||
4178 srcType == GL_SHORT ||
4179 srcType == GL_UNSIGNED_INT ||
4180 srcType == GL_INT ||
4181 srcType == GL_HALF_FLOAT_ARB ||
4182 srcType == GL_FLOAT);
4183
4184 /* general solution */
4185 {
4186 GLint dstComponents;
4187 GLbyte *dst = dest;
4188 GLuint i;
4189 GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));
4190
4191 if (!rgba) {
4192 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
4193 return;
4194 }
4195
4196 dstComponents = _mesa_components_in_format( dstFormat );
4197 /* source & dest image formats should have been error checked by now */
4198 assert(dstComponents > 0);
4199
4200 /*
4201 * Extract image data and convert to RGBA floats
4202 */
4203 extract_float_rgba(n, rgba, srcFormat, srcType, source,
4204 srcPacking->SwapBytes);
4205
4206
4207 /* Now determine which color channels we need to produce.
4208 * And determine the dest index (offset) within each color tuple.
4209 */
4210
4211 /* Now pack results in the requested dstFormat */
4212 for (i = 0; i < n; i++) {
4213 /* not sure - need clamp[-1,1] here? */
4214 dst[0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
4215 dst[1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
4216 dst += dstComponents;
4217 }
4218
4219 free(rgba);
4220 }
4221 }
4222
4223 /*
4224 * Unpack a row of color index data from a client buffer according to
4225 * the pixel unpacking parameters.
4226 * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.
4227 *
4228 * Args: ctx - the context
4229 * n - number of pixels
4230 * dstType - destination data type
4231 * dest - destination array
4232 * srcType - source pixel type
4233 * source - source data pointer
4234 * srcPacking - pixel unpacking parameters
4235 * transferOps - the pixel transfer operations to apply
4236 */
4237 void
4238 _mesa_unpack_index_span( struct gl_context *ctx, GLuint n,
4239 GLenum dstType, GLvoid *dest,
4240 GLenum srcType, const GLvoid *source,
4241 const struct gl_pixelstore_attrib *srcPacking,
4242 GLbitfield transferOps )
4243 {
4244 ASSERT(srcType == GL_BITMAP ||
4245 srcType == GL_UNSIGNED_BYTE ||
4246 srcType == GL_BYTE ||
4247 srcType == GL_UNSIGNED_SHORT ||
4248 srcType == GL_SHORT ||
4249 srcType == GL_UNSIGNED_INT ||
4250 srcType == GL_INT ||
4251 srcType == GL_HALF_FLOAT_ARB ||
4252 srcType == GL_FLOAT);
4253
4254 ASSERT(dstType == GL_UNSIGNED_BYTE ||
4255 dstType == GL_UNSIGNED_SHORT ||
4256 dstType == GL_UNSIGNED_INT);
4257
4258
4259 transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
4260
4261 /*
4262 * Try simple cases first
4263 */
4264 if (transferOps == 0 && srcType == GL_UNSIGNED_BYTE
4265 && dstType == GL_UNSIGNED_BYTE) {
4266 memcpy(dest, source, n * sizeof(GLubyte));
4267 }
4268 else if (transferOps == 0 && srcType == GL_UNSIGNED_INT
4269 && dstType == GL_UNSIGNED_INT && !srcPacking->SwapBytes) {
4270 memcpy(dest, source, n * sizeof(GLuint));
4271 }
4272 else {
4273 /*
4274 * general solution
4275 */
4276 GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
4277
4278 if (!indexes) {
4279 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
4280 return;
4281 }
4282
4283 extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
4284 srcPacking);
4285
4286 if (transferOps)
4287 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
4288
4289 /* convert to dest type */
4290 switch (dstType) {
4291 case GL_UNSIGNED_BYTE:
4292 {
4293 GLubyte *dst = (GLubyte *) dest;
4294 GLuint i;
4295 for (i = 0; i < n; i++) {
4296 dst[i] = (GLubyte) (indexes[i] & 0xff);
4297 }
4298 }
4299 break;
4300 case GL_UNSIGNED_SHORT:
4301 {
4302 GLuint *dst = (GLuint *) dest;
4303 GLuint i;
4304 for (i = 0; i < n; i++) {
4305 dst[i] = (GLushort) (indexes[i] & 0xffff);
4306 }
4307 }
4308 break;
4309 case GL_UNSIGNED_INT:
4310 memcpy(dest, indexes, n * sizeof(GLuint));
4311 break;
4312 default:
4313 _mesa_problem(ctx, "bad dstType in _mesa_unpack_index_span");
4314 }
4315
4316 free(indexes);
4317 }
4318 }
4319
4320
4321 void
4322 _mesa_pack_index_span( struct gl_context *ctx, GLuint n,
4323 GLenum dstType, GLvoid *dest, const GLuint *source,
4324 const struct gl_pixelstore_attrib *dstPacking,
4325 GLbitfield transferOps )
4326 {
4327 GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
4328
4329 if (!indexes) {
4330 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
4331 return;
4332 }
4333
4334 transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
4335
4336 if (transferOps & (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT)) {
4337 /* make a copy of input */
4338 memcpy(indexes, source, n * sizeof(GLuint));
4339 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
4340 source = indexes;
4341 }
4342
4343 switch (dstType) {
4344 case GL_UNSIGNED_BYTE:
4345 {
4346 GLubyte *dst = (GLubyte *) dest;
4347 GLuint i;
4348 for (i = 0; i < n; i++) {
4349 *dst++ = (GLubyte) source[i];
4350 }
4351 }
4352 break;
4353 case GL_BYTE:
4354 {
4355 GLbyte *dst = (GLbyte *) dest;
4356 GLuint i;
4357 for (i = 0; i < n; i++) {
4358 dst[i] = (GLbyte) source[i];
4359 }
4360 }
4361 break;
4362 case GL_UNSIGNED_SHORT:
4363 {
4364 GLushort *dst = (GLushort *) dest;
4365 GLuint i;
4366 for (i = 0; i < n; i++) {
4367 dst[i] = (GLushort) source[i];
4368 }
4369 if (dstPacking->SwapBytes) {
4370 _mesa_swap2( (GLushort *) dst, n );
4371 }
4372 }
4373 break;
4374 case GL_SHORT:
4375 {
4376 GLshort *dst = (GLshort *) dest;
4377 GLuint i;
4378 for (i = 0; i < n; i++) {
4379 dst[i] = (GLshort) source[i];
4380 }
4381 if (dstPacking->SwapBytes) {
4382 _mesa_swap2( (GLushort *) dst, n );
4383 }
4384 }
4385 break;
4386 case GL_UNSIGNED_INT:
4387 {
4388 GLuint *dst = (GLuint *) dest;
4389 GLuint i;
4390 for (i = 0; i < n; i++) {
4391 dst[i] = (GLuint) source[i];
4392 }
4393 if (dstPacking->SwapBytes) {
4394 _mesa_swap4( (GLuint *) dst, n );
4395 }
4396 }
4397 break;
4398 case GL_INT:
4399 {
4400 GLint *dst = (GLint *) dest;
4401 GLuint i;
4402 for (i = 0; i < n; i++) {
4403 dst[i] = (GLint) source[i];
4404 }
4405 if (dstPacking->SwapBytes) {
4406 _mesa_swap4( (GLuint *) dst, n );
4407 }
4408 }
4409 break;
4410 case GL_FLOAT:
4411 {
4412 GLfloat *dst = (GLfloat *) dest;
4413 GLuint i;
4414 for (i = 0; i < n; i++) {
4415 dst[i] = (GLfloat) source[i];
4416 }
4417 if (dstPacking->SwapBytes) {
4418 _mesa_swap4( (GLuint *) dst, n );
4419 }
4420 }
4421 break;
4422 case GL_HALF_FLOAT_ARB:
4423 {
4424 GLhalfARB *dst = (GLhalfARB *) dest;
4425 GLuint i;
4426 for (i = 0; i < n; i++) {
4427 dst[i] = _mesa_float_to_half((GLfloat) source[i]);
4428 }
4429 if (dstPacking->SwapBytes) {
4430 _mesa_swap2( (GLushort *) dst, n );
4431 }
4432 }
4433 break;
4434 default:
4435 _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
4436 }
4437
4438 free(indexes);
4439 }
4440
4441
4442 /*
4443 * Unpack a row of stencil data from a client buffer according to
4444 * the pixel unpacking parameters.
4445 * This is (or will be) used by glDrawPixels
4446 *
4447 * Args: ctx - the context
4448 * n - number of pixels
4449 * dstType - destination data type
4450 * dest - destination array
4451 * srcType - source pixel type
4452 * source - source data pointer
4453 * srcPacking - pixel unpacking parameters
4454 * transferOps - apply offset/bias/lookup ops?
4455 */
4456 void
4457 _mesa_unpack_stencil_span( struct gl_context *ctx, GLuint n,
4458 GLenum dstType, GLvoid *dest,
4459 GLenum srcType, const GLvoid *source,
4460 const struct gl_pixelstore_attrib *srcPacking,
4461 GLbitfield transferOps )
4462 {
4463 ASSERT(srcType == GL_BITMAP ||
4464 srcType == GL_UNSIGNED_BYTE ||
4465 srcType == GL_BYTE ||
4466 srcType == GL_UNSIGNED_SHORT ||
4467 srcType == GL_SHORT ||
4468 srcType == GL_UNSIGNED_INT ||
4469 srcType == GL_INT ||
4470 srcType == GL_UNSIGNED_INT_24_8_EXT ||
4471 srcType == GL_HALF_FLOAT_ARB ||
4472 srcType == GL_FLOAT ||
4473 srcType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
4474
4475 ASSERT(dstType == GL_UNSIGNED_BYTE ||
4476 dstType == GL_UNSIGNED_SHORT ||
4477 dstType == GL_UNSIGNED_INT ||
4478 dstType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
4479
4480 /* only shift and offset apply to stencil */
4481 transferOps &= IMAGE_SHIFT_OFFSET_BIT;
4482
4483 /*
4484 * Try simple cases first
4485 */
4486 if (transferOps == 0 &&
4487 !ctx->Pixel.MapStencilFlag &&
4488 srcType == GL_UNSIGNED_BYTE &&
4489 dstType == GL_UNSIGNED_BYTE) {
4490 memcpy(dest, source, n * sizeof(GLubyte));
4491 }
4492 else if (transferOps == 0 &&
4493 !ctx->Pixel.MapStencilFlag &&
4494 srcType == GL_UNSIGNED_INT &&
4495 dstType == GL_UNSIGNED_INT &&
4496 !srcPacking->SwapBytes) {
4497 memcpy(dest, source, n * sizeof(GLuint));
4498 }
4499 else {
4500 /*
4501 * general solution
4502 */
4503 GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
4504
4505 if (!indexes) {
4506 _mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil unpacking");
4507 return;
4508 }
4509
4510 extract_uint_indexes(n, indexes, GL_STENCIL_INDEX, srcType, source,
4511 srcPacking);
4512
4513 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
4514 /* shift and offset indexes */
4515 _mesa_shift_and_offset_ci(ctx, n, indexes);
4516 }
4517
4518 if (ctx->Pixel.MapStencilFlag) {
4519 /* Apply stencil lookup table */
4520 const GLuint mask = ctx->PixelMaps.StoS.Size - 1;
4521 GLuint i;
4522 for (i = 0; i < n; i++) {
4523 indexes[i] = (GLuint)ctx->PixelMaps.StoS.Map[ indexes[i] & mask ];
4524 }
4525 }
4526
4527 /* convert to dest type */
4528 switch (dstType) {
4529 case GL_UNSIGNED_BYTE:
4530 {
4531 GLubyte *dst = (GLubyte *) dest;
4532 GLuint i;
4533 for (i = 0; i < n; i++) {
4534 dst[i] = (GLubyte) (indexes[i] & 0xff);
4535 }
4536 }
4537 break;
4538 case GL_UNSIGNED_SHORT:
4539 {
4540 GLuint *dst = (GLuint *) dest;
4541 GLuint i;
4542 for (i = 0; i < n; i++) {
4543 dst[i] = (GLushort) (indexes[i] & 0xffff);
4544 }
4545 }
4546 break;
4547 case GL_UNSIGNED_INT:
4548 memcpy(dest, indexes, n * sizeof(GLuint));
4549 break;
4550 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
4551 {
4552 GLuint *dst = (GLuint *) dest;
4553 GLuint i;
4554 for (i = 0; i < n; i++) {
4555 dst[i*2+1] = indexes[i] & 0xff; /* lower 8 bits */
4556 }
4557 }
4558 break;
4559 default:
4560 _mesa_problem(ctx, "bad dstType in _mesa_unpack_stencil_span");
4561 }
4562
4563 free(indexes);
4564 }
4565 }
4566
4567
4568 void
4569 _mesa_pack_stencil_span( struct gl_context *ctx, GLuint n,
4570 GLenum dstType, GLvoid *dest, const GLubyte *source,
4571 const struct gl_pixelstore_attrib *dstPacking )
4572 {
4573 GLubyte *stencil = (GLubyte *) malloc(n * sizeof(GLubyte));
4574
4575 if (!stencil) {
4576 _mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil packing");
4577 return;
4578 }
4579
4580 if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset ||
4581 ctx->Pixel.MapStencilFlag) {
4582 /* make a copy of input */
4583 memcpy(stencil, source, n * sizeof(GLubyte));
4584 _mesa_apply_stencil_transfer_ops(ctx, n, stencil);
4585 source = stencil;
4586 }
4587
4588 switch (dstType) {
4589 case GL_UNSIGNED_BYTE:
4590 memcpy(dest, source, n);
4591 break;
4592 case GL_BYTE:
4593 {
4594 GLbyte *dst = (GLbyte *) dest;
4595 GLuint i;
4596 for (i=0;i<n;i++) {
4597 dst[i] = (GLbyte) (source[i] & 0x7f);
4598 }
4599 }
4600 break;
4601 case GL_UNSIGNED_SHORT:
4602 {
4603 GLushort *dst = (GLushort *) dest;
4604 GLuint i;
4605 for (i=0;i<n;i++) {
4606 dst[i] = (GLushort) source[i];
4607 }
4608 if (dstPacking->SwapBytes) {
4609 _mesa_swap2( (GLushort *) dst, n );
4610 }
4611 }
4612 break;
4613 case GL_SHORT:
4614 {
4615 GLshort *dst = (GLshort *) dest;
4616 GLuint i;
4617 for (i=0;i<n;i++) {
4618 dst[i] = (GLshort) source[i];
4619 }
4620 if (dstPacking->SwapBytes) {
4621 _mesa_swap2( (GLushort *) dst, n );
4622 }
4623 }
4624 break;
4625 case GL_UNSIGNED_INT:
4626 {
4627 GLuint *dst = (GLuint *) dest;
4628 GLuint i;
4629 for (i=0;i<n;i++) {
4630 dst[i] = (GLuint) source[i];
4631 }
4632 if (dstPacking->SwapBytes) {
4633 _mesa_swap4( (GLuint *) dst, n );
4634 }
4635 }
4636 break;
4637 case GL_INT:
4638 {
4639 GLint *dst = (GLint *) dest;
4640 GLuint i;
4641 for (i=0;i<n;i++) {
4642 dst[i] = (GLint) source[i];
4643 }
4644 if (dstPacking->SwapBytes) {
4645 _mesa_swap4( (GLuint *) dst, n );
4646 }
4647 }
4648 break;
4649 case GL_FLOAT:
4650 {
4651 GLfloat *dst = (GLfloat *) dest;
4652 GLuint i;
4653 for (i=0;i<n;i++) {
4654 dst[i] = (GLfloat) source[i];
4655 }
4656 if (dstPacking->SwapBytes) {
4657 _mesa_swap4( (GLuint *) dst, n );
4658 }
4659 }
4660 break;
4661 case GL_HALF_FLOAT_ARB:
4662 {
4663 GLhalfARB *dst = (GLhalfARB *) dest;
4664 GLuint i;
4665 for (i=0;i<n;i++) {
4666 dst[i] = _mesa_float_to_half( (float) source[i] );
4667 }
4668 if (dstPacking->SwapBytes) {
4669 _mesa_swap2( (GLushort *) dst, n );
4670 }
4671 }
4672 break;
4673 case GL_BITMAP:
4674 if (dstPacking->LsbFirst) {
4675 GLubyte *dst = (GLubyte *) dest;
4676 GLint shift = 0;
4677 GLuint i;
4678 for (i = 0; i < n; i++) {
4679 if (shift == 0)
4680 *dst = 0;
4681 *dst |= ((source[i] != 0) << shift);
4682 shift++;
4683 if (shift == 8) {
4684 shift = 0;
4685 dst++;
4686 }
4687 }
4688 }
4689 else {
4690 GLubyte *dst = (GLubyte *) dest;
4691 GLint shift = 7;
4692 GLuint i;
4693 for (i = 0; i < n; i++) {
4694 if (shift == 7)
4695 *dst = 0;
4696 *dst |= ((source[i] != 0) << shift);
4697 shift--;
4698 if (shift < 0) {
4699 shift = 7;
4700 dst++;
4701 }
4702 }
4703 }
4704 break;
4705 default:
4706 _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
4707 }
4708
4709 free(stencil);
4710 }
4711
4712 #define DEPTH_VALUES(GLTYPE, GLTYPE2FLOAT) \
4713 do { \
4714 GLuint i; \
4715 const GLTYPE *src = (const GLTYPE *)source; \
4716 for (i = 0; i < n; i++) { \
4717 GLTYPE value = src[i]; \
4718 if (srcPacking->SwapBytes) { \
4719 if (sizeof(GLTYPE) == 2) { \
4720 SWAP2BYTE(value); \
4721 } else if (sizeof(GLTYPE) == 4) { \
4722 SWAP4BYTE(value); \
4723 } \
4724 } \
4725 depthValues[i] = GLTYPE2FLOAT(value); \
4726 } \
4727 } while (0)
4728
4729
4730 /**
4731 * Unpack a row of depth/z values from memory, returning GLushort, GLuint
4732 * or GLfloat values.
4733 * The glPixelTransfer (scale/bias) params will be applied.
4734 *
4735 * \param dstType one of GL_UNSIGNED_SHORT, GL_UNSIGNED_INT, GL_FLOAT
4736 * \param depthMax max value for returned GLushort or GLuint values
4737 * (ignored for GLfloat).
4738 */
4739 void
4740 _mesa_unpack_depth_span( struct gl_context *ctx, GLuint n,
4741 GLenum dstType, GLvoid *dest, GLuint depthMax,
4742 GLenum srcType, const GLvoid *source,
4743 const struct gl_pixelstore_attrib *srcPacking )
4744 {
4745 GLfloat *depthTemp = NULL, *depthValues;
4746 GLboolean needClamp = GL_FALSE;
4747
4748 /* Look for special cases first.
4749 * Not only are these faster, they're less prone to numeric conversion
4750 * problems. Otherwise, converting from an int type to a float then
4751 * back to an int type can introduce errors that will show up as
4752 * artifacts in things like depth peeling which uses glCopyTexImage.
4753 */
4754 if (ctx->Pixel.DepthScale == 1.0 && ctx->Pixel.DepthBias == 0.0) {
4755 if (srcType == GL_UNSIGNED_INT && dstType == GL_UNSIGNED_SHORT) {
4756 const GLuint *src = (const GLuint *) source;
4757 GLushort *dst = (GLushort *) dest;
4758 GLuint i;
4759 for (i = 0; i < n; i++) {
4760 dst[i] = src[i] >> 16;
4761 }
4762 return;
4763 }
4764 if (srcType == GL_UNSIGNED_SHORT
4765 && dstType == GL_UNSIGNED_INT
4766 && depthMax == 0xffffffff) {
4767 const GLushort *src = (const GLushort *) source;
4768 GLuint *dst = (GLuint *) dest;
4769 GLuint i;
4770 for (i = 0; i < n; i++) {
4771 dst[i] = src[i] | (src[i] << 16);
4772 }
4773 return;
4774 }
4775 if (srcType == GL_UNSIGNED_INT_24_8
4776 && dstType == GL_UNSIGNED_INT
4777 && depthMax == 0xffffff) {
4778 const GLuint *src = (const GLuint *) source;
4779 GLuint *dst = (GLuint *) dest;
4780 GLuint i;
4781 for (i = 0; i < n; i++) {
4782 dst[i] = src[i] >> 8;
4783 }
4784 return;
4785 }
4786 /* XXX may want to add additional cases here someday */
4787 }
4788
4789 /* general case path follows */
4790
4791 if (dstType == GL_FLOAT) {
4792 depthValues = (GLfloat *) dest;
4793 }
4794 else {
4795 depthTemp = (GLfloat *) malloc(n * sizeof(GLfloat));
4796 if (!depthTemp) {
4797 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
4798 return;
4799 }
4800
4801 depthValues = depthTemp;
4802 }
4803
4804 /* Convert incoming values to GLfloat. Some conversions will require
4805 * clamping, below.
4806 */
4807 switch (srcType) {
4808 case GL_BYTE:
4809 DEPTH_VALUES(GLbyte, BYTE_TO_FLOATZ);
4810 needClamp = GL_TRUE;
4811 break;
4812 case GL_UNSIGNED_BYTE:
4813 DEPTH_VALUES(GLubyte, UBYTE_TO_FLOAT);
4814 break;
4815 case GL_SHORT:
4816 DEPTH_VALUES(GLshort, SHORT_TO_FLOATZ);
4817 needClamp = GL_TRUE;
4818 break;
4819 case GL_UNSIGNED_SHORT:
4820 DEPTH_VALUES(GLushort, USHORT_TO_FLOAT);
4821 break;
4822 case GL_INT:
4823 DEPTH_VALUES(GLint, INT_TO_FLOAT);
4824 needClamp = GL_TRUE;
4825 break;
4826 case GL_UNSIGNED_INT:
4827 DEPTH_VALUES(GLuint, UINT_TO_FLOAT);
4828 break;
4829 case GL_UNSIGNED_INT_24_8_EXT: /* GL_EXT_packed_depth_stencil */
4830 if (dstType == GL_UNSIGNED_INT_24_8_EXT &&
4831 depthMax == 0xffffff &&
4832 ctx->Pixel.DepthScale == 1.0 &&
4833 ctx->Pixel.DepthBias == 0.0) {
4834 const GLuint *src = (const GLuint *) source;
4835 GLuint *zValues = (GLuint *) dest;
4836 GLuint i;
4837 for (i = 0; i < n; i++) {
4838 GLuint value = src[i];
4839 if (srcPacking->SwapBytes) {
4840 SWAP4BYTE(value);
4841 }
4842 zValues[i] = value & 0xffffff00;
4843 }
4844 free(depthTemp);
4845 return;
4846 }
4847 else {
4848 const GLuint *src = (const GLuint *) source;
4849 const GLfloat scale = 1.0f / 0xffffff;
4850 GLuint i;
4851 for (i = 0; i < n; i++) {
4852 GLuint value = src[i];
4853 if (srcPacking->SwapBytes) {
4854 SWAP4BYTE(value);
4855 }
4856 depthValues[i] = (value >> 8) * scale;
4857 }
4858 }
4859 break;
4860 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
4861 {
4862 GLuint i;
4863 const GLfloat *src = (const GLfloat *)source;
4864 for (i = 0; i < n; i++) {
4865 GLfloat value = src[i * 2];
4866 if (srcPacking->SwapBytes) {
4867 SWAP4BYTE(value);
4868 }
4869 depthValues[i] = value;
4870 }
4871 needClamp = GL_TRUE;
4872 }
4873 break;
4874 case GL_FLOAT:
4875 DEPTH_VALUES(GLfloat, 1*);
4876 needClamp = GL_TRUE;
4877 break;
4878 case GL_HALF_FLOAT_ARB:
4879 {
4880 GLuint i;
4881 const GLhalfARB *src = (const GLhalfARB *) source;
4882 for (i = 0; i < n; i++) {
4883 GLhalfARB value = src[i];
4884 if (srcPacking->SwapBytes) {
4885 SWAP2BYTE(value);
4886 }
4887 depthValues[i] = _mesa_half_to_float(value);
4888 }
4889 needClamp = GL_TRUE;
4890 }
4891 break;
4892 default:
4893 _mesa_problem(NULL, "bad type in _mesa_unpack_depth_span()");
4894 free(depthTemp);
4895 return;
4896 }
4897
4898 /* apply depth scale and bias */
4899 {
4900 const GLfloat scale = ctx->Pixel.DepthScale;
4901 const GLfloat bias = ctx->Pixel.DepthBias;
4902 if (scale != 1.0 || bias != 0.0) {
4903 GLuint i;
4904 for (i = 0; i < n; i++) {
4905 depthValues[i] = depthValues[i] * scale + bias;
4906 }
4907 needClamp = GL_TRUE;
4908 }
4909 }
4910
4911 /* clamp to [0, 1] */
4912 if (needClamp) {
4913 GLuint i;
4914 for (i = 0; i < n; i++) {
4915 depthValues[i] = (GLfloat)CLAMP(depthValues[i], 0.0, 1.0);
4916 }
4917 }
4918
4919 /*
4920 * Convert values to dstType
4921 */
4922 if (dstType == GL_UNSIGNED_INT) {
4923 GLuint *zValues = (GLuint *) dest;
4924 GLuint i;
4925 if (depthMax <= 0xffffff) {
4926 /* no overflow worries */
4927 for (i = 0; i < n; i++) {
4928 zValues[i] = (GLuint) (depthValues[i] * (GLfloat) depthMax);
4929 }
4930 }
4931 else {
4932 /* need to use double precision to prevent overflow problems */
4933 for (i = 0; i < n; i++) {
4934 GLdouble z = depthValues[i] * (GLfloat) depthMax;
4935 if (z >= (GLdouble) 0xffffffff)
4936 zValues[i] = 0xffffffff;
4937 else
4938 zValues[i] = (GLuint) z;
4939 }
4940 }
4941 }
4942 else if (dstType == GL_UNSIGNED_SHORT) {
4943 GLushort *zValues = (GLushort *) dest;
4944 GLuint i;
4945 ASSERT(depthMax <= 0xffff);
4946 for (i = 0; i < n; i++) {
4947 zValues[i] = (GLushort) (depthValues[i] * (GLfloat) depthMax);
4948 }
4949 }
4950 else if (dstType == GL_FLOAT) {
4951 /* Nothing to do. depthValues is pointing to dest. */
4952 }
4953 else if (dstType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV) {
4954 GLfloat *zValues = (GLfloat*) dest;
4955 GLuint i;
4956 for (i = 0; i < n; i++) {
4957 zValues[i*2] = depthValues[i];
4958 }
4959 }
4960 else {
4961 ASSERT(0);
4962 }
4963
4964 free(depthTemp);
4965 }
4966
4967
4968 /*
4969 * Pack an array of depth values. The values are floats in [0,1].
4970 */
4971 void
4972 _mesa_pack_depth_span( struct gl_context *ctx, GLuint n, GLvoid *dest,
4973 GLenum dstType, const GLfloat *depthSpan,
4974 const struct gl_pixelstore_attrib *dstPacking )
4975 {
4976 GLfloat *depthCopy = (GLfloat *) malloc(n * sizeof(GLfloat));
4977 if (!depthCopy) {
4978 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
4979 return;
4980 }
4981
4982 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
4983 memcpy(depthCopy, depthSpan, n * sizeof(GLfloat));
4984 _mesa_scale_and_bias_depth(ctx, n, depthCopy);
4985 depthSpan = depthCopy;
4986 }
4987
4988 switch (dstType) {
4989 case GL_UNSIGNED_BYTE:
4990 {
4991 GLubyte *dst = (GLubyte *) dest;
4992 GLuint i;
4993 for (i = 0; i < n; i++) {
4994 dst[i] = FLOAT_TO_UBYTE( depthSpan[i] );
4995 }
4996 }
4997 break;
4998 case GL_BYTE:
4999 {
5000 GLbyte *dst = (GLbyte *) dest;
5001 GLuint i;
5002 for (i = 0; i < n; i++) {
5003 dst[i] = FLOAT_TO_BYTE( depthSpan[i] );
5004 }
5005 }
5006 break;
5007 case GL_UNSIGNED_SHORT:
5008 {
5009 GLushort *dst = (GLushort *) dest;
5010 GLuint i;
5011 for (i = 0; i < n; i++) {
5012 CLAMPED_FLOAT_TO_USHORT(dst[i], depthSpan[i]);
5013 }
5014 if (dstPacking->SwapBytes) {
5015 _mesa_swap2( (GLushort *) dst, n );
5016 }
5017 }
5018 break;
5019 case GL_SHORT:
5020 {
5021 GLshort *dst = (GLshort *) dest;
5022 GLuint i;
5023 for (i = 0; i < n; i++) {
5024 dst[i] = FLOAT_TO_SHORT( depthSpan[i] );
5025 }
5026 if (dstPacking->SwapBytes) {
5027 _mesa_swap2( (GLushort *) dst, n );
5028 }
5029 }
5030 break;
5031 case GL_UNSIGNED_INT:
5032 {
5033 GLuint *dst = (GLuint *) dest;
5034 GLuint i;
5035 for (i = 0; i < n; i++) {
5036 dst[i] = FLOAT_TO_UINT( depthSpan[i] );
5037 }
5038 if (dstPacking->SwapBytes) {
5039 _mesa_swap4( (GLuint *) dst, n );
5040 }
5041 }
5042 break;
5043 case GL_INT:
5044 {
5045 GLint *dst = (GLint *) dest;
5046 GLuint i;
5047 for (i = 0; i < n; i++) {
5048 dst[i] = FLOAT_TO_INT( depthSpan[i] );
5049 }
5050 if (dstPacking->SwapBytes) {
5051 _mesa_swap4( (GLuint *) dst, n );
5052 }
5053 }
5054 break;
5055 case GL_FLOAT:
5056 {
5057 GLfloat *dst = (GLfloat *) dest;
5058 GLuint i;
5059 for (i = 0; i < n; i++) {
5060 dst[i] = depthSpan[i];
5061 }
5062 if (dstPacking->SwapBytes) {
5063 _mesa_swap4( (GLuint *) dst, n );
5064 }
5065 }
5066 break;
5067 case GL_HALF_FLOAT_ARB:
5068 {
5069 GLhalfARB *dst = (GLhalfARB *) dest;
5070 GLuint i;
5071 for (i = 0; i < n; i++) {
5072 dst[i] = _mesa_float_to_half(depthSpan[i]);
5073 }
5074 if (dstPacking->SwapBytes) {
5075 _mesa_swap2( (GLushort *) dst, n );
5076 }
5077 }
5078 break;
5079 default:
5080 _mesa_problem(ctx, "bad type in _mesa_pack_depth_span");
5081 }
5082
5083 free(depthCopy);
5084 }
5085
5086
5087
5088 /**
5089 * Pack depth and stencil values as GL_DEPTH_STENCIL (GL_UNSIGNED_INT_24_8 etc)
5090 */
5091 void
5092 _mesa_pack_depth_stencil_span(struct gl_context *ctx,GLuint n,
5093 GLenum dstType, GLuint *dest,
5094 const GLfloat *depthVals,
5095 const GLubyte *stencilVals,
5096 const struct gl_pixelstore_attrib *dstPacking)
5097 {
5098 GLfloat *depthCopy = (GLfloat *) malloc(n * sizeof(GLfloat));
5099 GLubyte *stencilCopy = (GLubyte *) malloc(n * sizeof(GLubyte));
5100 GLuint i;
5101
5102 if (!depthCopy || !stencilCopy) {
5103 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
5104 free(depthCopy);
5105 free(stencilCopy);
5106 return;
5107 }
5108
5109 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
5110 memcpy(depthCopy, depthVals, n * sizeof(GLfloat));
5111 _mesa_scale_and_bias_depth(ctx, n, depthCopy);
5112 depthVals = depthCopy;
5113 }
5114
5115 if (ctx->Pixel.IndexShift ||
5116 ctx->Pixel.IndexOffset ||
5117 ctx->Pixel.MapStencilFlag) {
5118 memcpy(stencilCopy, stencilVals, n * sizeof(GLubyte));
5119 _mesa_apply_stencil_transfer_ops(ctx, n, stencilCopy);
5120 stencilVals = stencilCopy;
5121 }
5122
5123 switch (dstType) {
5124 case GL_UNSIGNED_INT_24_8:
5125 for (i = 0; i < n; i++) {
5126 GLuint z = (GLuint) (depthVals[i] * 0xffffff);
5127 dest[i] = (z << 8) | (stencilVals[i] & 0xff);
5128 }
5129 break;
5130 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
5131 for (i = 0; i < n; i++) {
5132 ((GLfloat*)dest)[i*2] = depthVals[i];
5133 dest[i*2+1] = stencilVals[i] & 0xff;
5134 }
5135 break;
5136 }
5137
5138 if (dstPacking->SwapBytes) {
5139 _mesa_swap4(dest, n);
5140 }
5141
5142 free(depthCopy);
5143 free(stencilCopy);
5144 }
5145
5146
5147
5148
5149 /**
5150 * Unpack image data. Apply byte swapping, byte flipping (bitmap).
5151 * Return all image data in a contiguous block. This is used when we
5152 * compile glDrawPixels, glTexImage, etc into a display list. We
5153 * need a copy of the data in a standard format.
5154 */
5155 void *
5156 _mesa_unpack_image( GLuint dimensions,
5157 GLsizei width, GLsizei height, GLsizei depth,
5158 GLenum format, GLenum type, const GLvoid *pixels,
5159 const struct gl_pixelstore_attrib *unpack )
5160 {
5161 GLint bytesPerRow, compsPerRow;
5162 GLboolean flipBytes, swap2, swap4;
5163
5164 if (!pixels)
5165 return NULL; /* not necessarily an error */
5166
5167 if (width <= 0 || height <= 0 || depth <= 0)
5168 return NULL; /* generate error later */
5169
5170 if (type == GL_BITMAP) {
5171 bytesPerRow = (width + 7) >> 3;
5172 flipBytes = unpack->LsbFirst;
5173 swap2 = swap4 = GL_FALSE;
5174 compsPerRow = 0;
5175 }
5176 else {
5177 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
5178 GLint components = _mesa_components_in_format(format);
5179 GLint bytesPerComp;
5180
5181 if (_mesa_type_is_packed(type))
5182 components = 1;
5183
5184 if (bytesPerPixel <= 0 || components <= 0)
5185 return NULL; /* bad format or type. generate error later */
5186 bytesPerRow = bytesPerPixel * width;
5187 bytesPerComp = bytesPerPixel / components;
5188 flipBytes = GL_FALSE;
5189 swap2 = (bytesPerComp == 2) && unpack->SwapBytes;
5190 swap4 = (bytesPerComp == 4) && unpack->SwapBytes;
5191 compsPerRow = components * width;
5192 assert(compsPerRow >= width);
5193 }
5194
5195 {
5196 GLubyte *destBuffer
5197 = (GLubyte *) malloc(bytesPerRow * height * depth);
5198 GLubyte *dst;
5199 GLint img, row;
5200 if (!destBuffer)
5201 return NULL; /* generate GL_OUT_OF_MEMORY later */
5202
5203 dst = destBuffer;
5204 for (img = 0; img < depth; img++) {
5205 for (row = 0; row < height; row++) {
5206 const GLvoid *src = _mesa_image_address(dimensions, unpack, pixels,
5207 width, height, format, type, img, row, 0);
5208
5209 if ((type == GL_BITMAP) && (unpack->SkipPixels & 0x7)) {
5210 GLint i;
5211 flipBytes = GL_FALSE;
5212 if (unpack->LsbFirst) {
5213 GLubyte srcMask = 1 << (unpack->SkipPixels & 0x7);
5214 GLubyte dstMask = 128;
5215 const GLubyte *s = src;
5216 GLubyte *d = dst;
5217 *d = 0;
5218 for (i = 0; i < width; i++) {
5219 if (*s & srcMask) {
5220 *d |= dstMask;
5221 }
5222 if (srcMask == 128) {
5223 srcMask = 1;
5224 s++;
5225 }
5226 else {
5227 srcMask = srcMask << 1;
5228 }
5229 if (dstMask == 1) {
5230 dstMask = 128;
5231 d++;
5232 *d = 0;
5233 }
5234 else {
5235 dstMask = dstMask >> 1;
5236 }
5237 }
5238 }
5239 else {
5240 GLubyte srcMask = 128 >> (unpack->SkipPixels & 0x7);
5241 GLubyte dstMask = 128;
5242 const GLubyte *s = src;
5243 GLubyte *d = dst;
5244 *d = 0;
5245 for (i = 0; i < width; i++) {
5246 if (*s & srcMask) {
5247 *d |= dstMask;
5248 }
5249 if (srcMask == 1) {
5250 srcMask = 128;
5251 s++;
5252 }
5253 else {
5254 srcMask = srcMask >> 1;
5255 }
5256 if (dstMask == 1) {
5257 dstMask = 128;
5258 d++;
5259 *d = 0;
5260 }
5261 else {
5262 dstMask = dstMask >> 1;
5263 }
5264 }
5265 }
5266 }
5267 else {
5268 memcpy(dst, src, bytesPerRow);
5269 }
5270
5271 /* byte flipping/swapping */
5272 if (flipBytes) {
5273 flip_bytes((GLubyte *) dst, bytesPerRow);
5274 }
5275 else if (swap2) {
5276 _mesa_swap2((GLushort*) dst, compsPerRow);
5277 }
5278 else if (swap4) {
5279 _mesa_swap4((GLuint*) dst, compsPerRow);
5280 }
5281 dst += bytesPerRow;
5282 }
5283 }
5284 return destBuffer;
5285 }
5286 }
5287