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