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