projects / mesa.git / blob
? search:


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