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