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