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