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