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