projects / mesa.git / blob
? search:


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