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