projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
mesa: implement clamping controls (ARB_color_buffer_float)
[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
3978 ASSERT(srcType == GL_UNSIGNED_BYTE ||
3979 srcType == GL_BYTE ||
3980 srcType == GL_UNSIGNED_SHORT ||
3981 srcType == GL_SHORT ||
3982 srcType == GL_UNSIGNED_INT ||
3983 srcType == GL_INT ||
3984 srcType == GL_HALF_FLOAT_ARB ||
3985 srcType == GL_FLOAT);
3986
3987 /* general solution */
3988 {
3989 GLint dstComponents;
3990 GLbyte *dst = dest;
3991 GLuint i;
3992 GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));
3993
3994 if (!rgba) {
3995 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3996 return;
3997 }
3998
3999 dstComponents = _mesa_components_in_format( dstFormat );
4000 /* source & dest image formats should have been error checked by now */
4001 assert(dstComponents > 0);
4002
4003 /*
4004 * Extract image data and convert to RGBA floats
4005 */
4006 extract_float_rgba(n, rgba, srcFormat, srcType, source,
4007 srcPacking->SwapBytes);
4008
4009
4010 /* Now determine which color channels we need to produce.
4011 * And determine the dest index (offset) within each color tuple.
4012 */
4013
4014 /* Now pack results in the requested dstFormat */
4015 for (i = 0; i < n; i++) {
4016 /* not sure - need clamp[-1,1] here? */
4017 dst[0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
4018 dst[1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
4019 dst += dstComponents;
4020 }
4021
4022 free(rgba);
4023 }
4024 }
4025
4026 /*
4027 * Unpack a row of color index data from a client buffer according to
4028 * the pixel unpacking parameters.
4029 * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.
4030 *
4031 * Args: ctx - the context
4032 * n - number of pixels
4033 * dstType - destination data type
4034 * dest - destination array
4035 * srcType - source pixel type
4036 * source - source data pointer
4037 * srcPacking - pixel unpacking parameters
4038 * transferOps - the pixel transfer operations to apply
4039 */
4040 void
4041 _mesa_unpack_index_span( struct gl_context *ctx, GLuint n,
4042 GLenum dstType, GLvoid *dest,
4043 GLenum srcType, const GLvoid *source,
4044 const struct gl_pixelstore_attrib *srcPacking,
4045 GLbitfield transferOps )
4046 {
4047 ASSERT(srcType == GL_BITMAP ||
4048 srcType == GL_UNSIGNED_BYTE ||
4049 srcType == GL_BYTE ||
4050 srcType == GL_UNSIGNED_SHORT ||
4051 srcType == GL_SHORT ||
4052 srcType == GL_UNSIGNED_INT ||
4053 srcType == GL_INT ||
4054 srcType == GL_HALF_FLOAT_ARB ||
4055 srcType == GL_FLOAT);
4056
4057 ASSERT(dstType == GL_UNSIGNED_BYTE ||
4058 dstType == GL_UNSIGNED_SHORT ||
4059 dstType == GL_UNSIGNED_INT);
4060
4061
4062 transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
4063
4064 /*
4065 * Try simple cases first
4066 */
4067 if (transferOps == 0 && srcType == GL_UNSIGNED_BYTE
4068 && dstType == GL_UNSIGNED_BYTE) {
4069 memcpy(dest, source, n * sizeof(GLubyte));
4070 }
4071 else if (transferOps == 0 && srcType == GL_UNSIGNED_INT
4072 && dstType == GL_UNSIGNED_INT && !srcPacking->SwapBytes) {
4073 memcpy(dest, source, n * sizeof(GLuint));
4074 }
4075 else {
4076 /*
4077 * general solution
4078 */
4079 GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
4080
4081 if (!indexes) {
4082 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
4083 return;
4084 }
4085
4086 extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
4087 srcPacking);
4088
4089 if (transferOps)
4090 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
4091
4092 /* convert to dest type */
4093 switch (dstType) {
4094 case GL_UNSIGNED_BYTE:
4095 {
4096 GLubyte *dst = (GLubyte *) dest;
4097 GLuint i;
4098 for (i = 0; i < n; i++) {
4099 dst[i] = (GLubyte) (indexes[i] & 0xff);
4100 }
4101 }
4102 break;
4103 case GL_UNSIGNED_SHORT:
4104 {
4105 GLuint *dst = (GLuint *) dest;
4106 GLuint i;
4107 for (i = 0; i < n; i++) {
4108 dst[i] = (GLushort) (indexes[i] & 0xffff);
4109 }
4110 }
4111 break;
4112 case GL_UNSIGNED_INT:
4113 memcpy(dest, indexes, n * sizeof(GLuint));
4114 break;
4115 default:
4116 _mesa_problem(ctx, "bad dstType in _mesa_unpack_index_span");
4117 }
4118
4119 free(indexes);
4120 }
4121 }
4122
4123
4124 void
4125 _mesa_pack_index_span( struct gl_context *ctx, GLuint n,
4126 GLenum dstType, GLvoid *dest, const GLuint *source,
4127 const struct gl_pixelstore_attrib *dstPacking,
4128 GLbitfield transferOps )
4129 {
4130 GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
4131
4132 if (!indexes) {
4133 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
4134 return;
4135 }
4136
4137 transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
4138
4139 if (transferOps & (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT)) {
4140 /* make a copy of input */
4141 memcpy(indexes, source, n * sizeof(GLuint));
4142 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
4143 source = indexes;
4144 }
4145
4146 switch (dstType) {
4147 case GL_UNSIGNED_BYTE:
4148 {
4149 GLubyte *dst = (GLubyte *) dest;
4150 GLuint i;
4151 for (i = 0; i < n; i++) {
4152 *dst++ = (GLubyte) source[i];
4153 }
4154 }
4155 break;
4156 case GL_BYTE:
4157 {
4158 GLbyte *dst = (GLbyte *) dest;
4159 GLuint i;
4160 for (i = 0; i < n; i++) {
4161 dst[i] = (GLbyte) source[i];
4162 }
4163 }
4164 break;
4165 case GL_UNSIGNED_SHORT:
4166 {
4167 GLushort *dst = (GLushort *) dest;
4168 GLuint i;
4169 for (i = 0; i < n; i++) {
4170 dst[i] = (GLushort) source[i];
4171 }
4172 if (dstPacking->SwapBytes) {
4173 _mesa_swap2( (GLushort *) dst, n );
4174 }
4175 }
4176 break;
4177 case GL_SHORT:
4178 {
4179 GLshort *dst = (GLshort *) dest;
4180 GLuint i;
4181 for (i = 0; i < n; i++) {
4182 dst[i] = (GLshort) source[i];
4183 }
4184 if (dstPacking->SwapBytes) {
4185 _mesa_swap2( (GLushort *) dst, n );
4186 }
4187 }
4188 break;
4189 case GL_UNSIGNED_INT:
4190 {
4191 GLuint *dst = (GLuint *) dest;
4192 GLuint i;
4193 for (i = 0; i < n; i++) {
4194 dst[i] = (GLuint) source[i];
4195 }
4196 if (dstPacking->SwapBytes) {
4197 _mesa_swap4( (GLuint *) dst, n );
4198 }
4199 }
4200 break;
4201 case GL_INT:
4202 {
4203 GLint *dst = (GLint *) dest;
4204 GLuint i;
4205 for (i = 0; i < n; i++) {
4206 dst[i] = (GLint) source[i];
4207 }
4208 if (dstPacking->SwapBytes) {
4209 _mesa_swap4( (GLuint *) dst, n );
4210 }
4211 }
4212 break;
4213 case GL_FLOAT:
4214 {
4215 GLfloat *dst = (GLfloat *) dest;
4216 GLuint i;
4217 for (i = 0; i < n; i++) {
4218 dst[i] = (GLfloat) source[i];
4219 }
4220 if (dstPacking->SwapBytes) {
4221 _mesa_swap4( (GLuint *) dst, n );
4222 }
4223 }
4224 break;
4225 case GL_HALF_FLOAT_ARB:
4226 {
4227 GLhalfARB *dst = (GLhalfARB *) dest;
4228 GLuint i;
4229 for (i = 0; i < n; i++) {
4230 dst[i] = _mesa_float_to_half((GLfloat) source[i]);
4231 }
4232 if (dstPacking->SwapBytes) {
4233 _mesa_swap2( (GLushort *) dst, n );
4234 }
4235 }
4236 break;
4237 default:
4238 _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
4239 }
4240
4241 free(indexes);
4242 }
4243
4244
4245 /*
4246 * Unpack a row of stencil data from a client buffer according to
4247 * the pixel unpacking parameters.
4248 * This is (or will be) used by glDrawPixels
4249 *
4250 * Args: ctx - the context
4251 * n - number of pixels
4252 * dstType - destination data type
4253 * dest - destination array
4254 * srcType - source pixel type
4255 * source - source data pointer
4256 * srcPacking - pixel unpacking parameters
4257 * transferOps - apply offset/bias/lookup ops?
4258 */
4259 void
4260 _mesa_unpack_stencil_span( struct gl_context *ctx, GLuint n,
4261 GLenum dstType, GLvoid *dest,
4262 GLenum srcType, const GLvoid *source,
4263 const struct gl_pixelstore_attrib *srcPacking,
4264 GLbitfield transferOps )
4265 {
4266 ASSERT(srcType == GL_BITMAP ||
4267 srcType == GL_UNSIGNED_BYTE ||
4268 srcType == GL_BYTE ||
4269 srcType == GL_UNSIGNED_SHORT ||
4270 srcType == GL_SHORT ||
4271 srcType == GL_UNSIGNED_INT ||
4272 srcType == GL_INT ||
4273 srcType == GL_UNSIGNED_INT_24_8_EXT ||
4274 srcType == GL_HALF_FLOAT_ARB ||
4275 srcType == GL_FLOAT);
4276
4277 ASSERT(dstType == GL_UNSIGNED_BYTE ||
4278 dstType == GL_UNSIGNED_SHORT ||
4279 dstType == GL_UNSIGNED_INT);
4280
4281 /* only shift and offset apply to stencil */
4282 transferOps &= IMAGE_SHIFT_OFFSET_BIT;
4283
4284 /*
4285 * Try simple cases first
4286 */
4287 if (transferOps == 0 &&
4288 !ctx->Pixel.MapStencilFlag &&
4289 srcType == GL_UNSIGNED_BYTE &&
4290 dstType == GL_UNSIGNED_BYTE) {
4291 memcpy(dest, source, n * sizeof(GLubyte));
4292 }
4293 else if (transferOps == 0 &&
4294 !ctx->Pixel.MapStencilFlag &&
4295 srcType == GL_UNSIGNED_INT &&
4296 dstType == GL_UNSIGNED_INT &&
4297 !srcPacking->SwapBytes) {
4298 memcpy(dest, source, n * sizeof(GLuint));
4299 }
4300 else {
4301 /*
4302 * general solution
4303 */
4304 GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
4305
4306 if (!indexes) {
4307 _mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil unpacking");
4308 return;
4309 }
4310
4311 extract_uint_indexes(n, indexes, GL_STENCIL_INDEX, srcType, source,
4312 srcPacking);
4313
4314 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
4315 /* shift and offset indexes */
4316 _mesa_shift_and_offset_ci(ctx, n, indexes);
4317 }
4318
4319 if (ctx->Pixel.MapStencilFlag) {
4320 /* Apply stencil lookup table */
4321 const GLuint mask = ctx->PixelMaps.StoS.Size - 1;
4322 GLuint i;
4323 for (i = 0; i < n; i++) {
4324 indexes[i] = (GLuint)ctx->PixelMaps.StoS.Map[ indexes[i] & mask ];
4325 }
4326 }
4327
4328 /* convert to dest type */
4329 switch (dstType) {
4330 case GL_UNSIGNED_BYTE:
4331 {
4332 GLubyte *dst = (GLubyte *) dest;
4333 GLuint i;
4334 for (i = 0; i < n; i++) {
4335 dst[i] = (GLubyte) (indexes[i] & 0xff);
4336 }
4337 }
4338 break;
4339 case GL_UNSIGNED_SHORT:
4340 {
4341 GLuint *dst = (GLuint *) dest;
4342 GLuint i;
4343 for (i = 0; i < n; i++) {
4344 dst[i] = (GLushort) (indexes[i] & 0xffff);
4345 }
4346 }
4347 break;
4348 case GL_UNSIGNED_INT:
4349 memcpy(dest, indexes, n * sizeof(GLuint));
4350 break;
4351 default:
4352 _mesa_problem(ctx, "bad dstType in _mesa_unpack_stencil_span");
4353 }
4354
4355 free(indexes);
4356 }
4357 }
4358
4359
4360 void
4361 _mesa_pack_stencil_span( struct gl_context *ctx, GLuint n,
4362 GLenum dstType, GLvoid *dest, const GLstencil *source,
4363 const struct gl_pixelstore_attrib *dstPacking )
4364 {
4365 GLstencil *stencil = (GLstencil *) malloc(n * sizeof(GLstencil));
4366
4367 if (!stencil) {
4368 _mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil packing");
4369 return;
4370 }
4371
4372 if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset ||
4373 ctx->Pixel.MapStencilFlag) {
4374 /* make a copy of input */
4375 memcpy(stencil, source, n * sizeof(GLstencil));
4376 _mesa_apply_stencil_transfer_ops(ctx, n, stencil);
4377 source = stencil;
4378 }
4379
4380 switch (dstType) {
4381 case GL_UNSIGNED_BYTE:
4382 if (sizeof(GLstencil) == 1) {
4383 memcpy( dest, source, n );
4384 }
4385 else {
4386 GLubyte *dst = (GLubyte *) dest;
4387 GLuint i;
4388 for (i=0;i<n;i++) {
4389 dst[i] = (GLubyte) source[i];
4390 }
4391 }
4392 break;
4393 case GL_BYTE:
4394 {
4395 GLbyte *dst = (GLbyte *) dest;
4396 GLuint i;
4397 for (i=0;i<n;i++) {
4398 dst[i] = (GLbyte) (source[i] & 0x7f);
4399 }
4400 }
4401 break;
4402 case GL_UNSIGNED_SHORT:
4403 {
4404 GLushort *dst = (GLushort *) dest;
4405 GLuint i;
4406 for (i=0;i<n;i++) {
4407 dst[i] = (GLushort) source[i];
4408 }
4409 if (dstPacking->SwapBytes) {
4410 _mesa_swap2( (GLushort *) dst, n );
4411 }
4412 }
4413 break;
4414 case GL_SHORT:
4415 {
4416 GLshort *dst = (GLshort *) dest;
4417 GLuint i;
4418 for (i=0;i<n;i++) {
4419 dst[i] = (GLshort) source[i];
4420 }
4421 if (dstPacking->SwapBytes) {
4422 _mesa_swap2( (GLushort *) dst, n );
4423 }
4424 }
4425 break;
4426 case GL_UNSIGNED_INT:
4427 {
4428 GLuint *dst = (GLuint *) dest;
4429 GLuint i;
4430 for (i=0;i<n;i++) {
4431 dst[i] = (GLuint) source[i];
4432 }
4433 if (dstPacking->SwapBytes) {
4434 _mesa_swap4( (GLuint *) dst, n );
4435 }
4436 }
4437 break;
4438 case GL_INT:
4439 {
4440 GLint *dst = (GLint *) dest;
4441 GLuint i;
4442 for (i=0;i<n;i++) {
4443 dst[i] = (GLint) source[i];
4444 }
4445 if (dstPacking->SwapBytes) {
4446 _mesa_swap4( (GLuint *) dst, n );
4447 }
4448 }
4449 break;
4450 case GL_FLOAT:
4451 {
4452 GLfloat *dst = (GLfloat *) dest;
4453 GLuint i;
4454 for (i=0;i<n;i++) {
4455 dst[i] = (GLfloat) source[i];
4456 }
4457 if (dstPacking->SwapBytes) {
4458 _mesa_swap4( (GLuint *) dst, n );
4459 }
4460 }
4461 break;
4462 case GL_HALF_FLOAT_ARB:
4463 {
4464 GLhalfARB *dst = (GLhalfARB *) dest;
4465 GLuint i;
4466 for (i=0;i<n;i++) {
4467 dst[i] = _mesa_float_to_half( (float) source[i] );
4468 }
4469 if (dstPacking->SwapBytes) {
4470 _mesa_swap2( (GLushort *) dst, n );
4471 }
4472 }
4473 break;
4474 case GL_BITMAP:
4475 if (dstPacking->LsbFirst) {
4476 GLubyte *dst = (GLubyte *) dest;
4477 GLint shift = 0;
4478 GLuint i;
4479 for (i = 0; i < n; i++) {
4480 if (shift == 0)
4481 *dst = 0;
4482 *dst |= ((source[i] != 0) << shift);
4483 shift++;
4484 if (shift == 8) {
4485 shift = 0;
4486 dst++;
4487 }
4488 }
4489 }
4490 else {
4491 GLubyte *dst = (GLubyte *) dest;
4492 GLint shift = 7;
4493 GLuint i;
4494 for (i = 0; i < n; i++) {
4495 if (shift == 7)
4496 *dst = 0;
4497 *dst |= ((source[i] != 0) << shift);
4498 shift--;
4499 if (shift < 0) {
4500 shift = 7;
4501 dst++;
4502 }
4503 }
4504 }
4505 break;
4506 default:
4507 _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
4508 }
4509
4510 free(stencil);
4511 }
4512
4513 #define DEPTH_VALUES(GLTYPE, GLTYPE2FLOAT) \
4514 do { \
4515 GLuint i; \
4516 const GLTYPE *src = (const GLTYPE *)source; \
4517 for (i = 0; i < n; i++) { \
4518 GLTYPE value = src[i]; \
4519 if (srcPacking->SwapBytes) { \
4520 if (sizeof(GLTYPE) == 2) { \
4521 SWAP2BYTE(value); \
4522 } else if (sizeof(GLTYPE) == 4) { \
4523 SWAP4BYTE(value); \
4524 } \
4525 } \
4526 depthValues[i] = GLTYPE2FLOAT(value); \
4527 } \
4528 } while (0)
4529
4530
4531 /**
4532 * Unpack a row of depth/z values from memory, returning GLushort, GLuint
4533 * or GLfloat values.
4534 * The glPixelTransfer (scale/bias) params will be applied.
4535 *
4536 * \param dstType one of GL_UNSIGNED_SHORT, GL_UNSIGNED_INT, GL_FLOAT
4537 * \param depthMax max value for returned GLushort or GLuint values
4538 * (ignored for GLfloat).
4539 */
4540 void
4541 _mesa_unpack_depth_span( struct gl_context *ctx, GLuint n,
4542 GLenum dstType, GLvoid *dest, GLuint depthMax,
4543 GLenum srcType, const GLvoid *source,
4544 const struct gl_pixelstore_attrib *srcPacking )
4545 {
4546 GLfloat *depthTemp, *depthValues;
4547 GLboolean needClamp = GL_FALSE;
4548
4549 /* Look for special cases first.
4550 * Not only are these faster, they're less prone to numeric conversion
4551 * problems. Otherwise, converting from an int type to a float then
4552 * back to an int type can introduce errors that will show up as
4553 * artifacts in things like depth peeling which uses glCopyTexImage.
4554 */
4555 if (ctx->Pixel.DepthScale == 1.0 && ctx->Pixel.DepthBias == 0.0) {
4556 if (srcType == GL_UNSIGNED_INT && dstType == GL_UNSIGNED_SHORT) {
4557 const GLuint *src = (const GLuint *) source;
4558 GLushort *dst = (GLushort *) dest;
4559 GLuint i;
4560 for (i = 0; i < n; i++) {
4561 dst[i] = src[i] >> 16;
4562 }
4563 return;
4564 }
4565 if (srcType == GL_UNSIGNED_SHORT
4566 && dstType == GL_UNSIGNED_INT
4567 && depthMax == 0xffffffff) {
4568 const GLushort *src = (const GLushort *) source;
4569 GLuint *dst = (GLuint *) dest;
4570 GLuint i;
4571 for (i = 0; i < n; i++) {
4572 dst[i] = src[i] | (src[i] << 16);
4573 }
4574 return;
4575 }
4576 if (srcType == GL_UNSIGNED_INT_24_8
4577 && dstType == GL_UNSIGNED_INT
4578 && depthMax == 0xffffff) {
4579 const GLuint *src = (const GLuint *) source;
4580 GLuint *dst = (GLuint *) dest;
4581 GLuint i;
4582 for (i = 0; i < n; i++) {
4583 dst[i] = src[i] >> 8;
4584 }
4585 return;
4586 }
4587 /* XXX may want to add additional cases here someday */
4588 }
4589
4590 /* general case path follows */
4591
4592 depthTemp = (GLfloat *) malloc(n * sizeof(GLfloat));
4593 if (!depthTemp) {
4594 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
4595 return;
4596 }
4597
4598 if (dstType == GL_FLOAT) {
4599 depthValues = (GLfloat *) dest;
4600 }
4601 else {
4602 depthValues = depthTemp;
4603 }
4604
4605 /* Convert incoming values to GLfloat. Some conversions will require
4606 * clamping, below.
4607 */
4608 switch (srcType) {
4609 case GL_BYTE:
4610 DEPTH_VALUES(GLbyte, BYTE_TO_FLOAT);
4611 needClamp = GL_TRUE;
4612 break;
4613 case GL_UNSIGNED_BYTE:
4614 DEPTH_VALUES(GLubyte, UBYTE_TO_FLOAT);
4615 break;
4616 case GL_SHORT:
4617 DEPTH_VALUES(GLshort, SHORT_TO_FLOAT);
4618 needClamp = GL_TRUE;
4619 break;
4620 case GL_UNSIGNED_SHORT:
4621 DEPTH_VALUES(GLushort, USHORT_TO_FLOAT);
4622 break;
4623 case GL_INT:
4624 DEPTH_VALUES(GLint, INT_TO_FLOAT);
4625 needClamp = GL_TRUE;
4626 break;
4627 case GL_UNSIGNED_INT:
4628 DEPTH_VALUES(GLuint, UINT_TO_FLOAT);
4629 break;
4630 case GL_UNSIGNED_INT_24_8_EXT: /* GL_EXT_packed_depth_stencil */
4631 if (dstType == GL_UNSIGNED_INT_24_8_EXT &&
4632 depthMax == 0xffffff &&
4633 ctx->Pixel.DepthScale == 1.0 &&
4634 ctx->Pixel.DepthBias == 0.0) {
4635 const GLuint *src = (const GLuint *) source;
4636 GLuint *zValues = (GLuint *) dest;
4637 GLuint i;
4638 for (i = 0; i < n; i++) {
4639 GLuint value = src[i];
4640 if (srcPacking->SwapBytes) {
4641 SWAP4BYTE(value);
4642 }
4643 zValues[i] = value & 0xffffff00;
4644 }
4645 return;
4646 }
4647 else {
4648 const GLuint *src = (const GLuint *) source;
4649 const GLfloat scale = 1.0f / 0xffffff;
4650 GLuint i;
4651 for (i = 0; i < n; i++) {
4652 GLuint value = src[i];
4653 if (srcPacking->SwapBytes) {
4654 SWAP4BYTE(value);
4655 }
4656 depthValues[i] = (value >> 8) * scale;
4657 }
4658 }
4659 break;
4660 case GL_FLOAT:
4661 DEPTH_VALUES(GLfloat, 1*);
4662 needClamp = GL_TRUE;
4663 break;
4664 case GL_HALF_FLOAT_ARB:
4665 {
4666 GLuint i;
4667 const GLhalfARB *src = (const GLhalfARB *) source;
4668 for (i = 0; i < n; i++) {
4669 GLhalfARB value = src[i];
4670 if (srcPacking->SwapBytes) {
4671 SWAP2BYTE(value);
4672 }
4673 depthValues[i] = _mesa_half_to_float(value);
4674 }
4675 needClamp = GL_TRUE;
4676 }
4677 break;
4678 default:
4679 _mesa_problem(NULL, "bad type in _mesa_unpack_depth_span()");
4680 free(depthTemp);
4681 return;
4682 }
4683
4684 /* apply depth scale and bias */
4685 {
4686 const GLfloat scale = ctx->Pixel.DepthScale;
4687 const GLfloat bias = ctx->Pixel.DepthBias;
4688 if (scale != 1.0 || bias != 0.0) {
4689 GLuint i;
4690 for (i = 0; i < n; i++) {
4691 depthValues[i] = depthValues[i] * scale + bias;
4692 }
4693 needClamp = GL_TRUE;
4694 }
4695 }
4696
4697 /* clamp to [0, 1] */
4698 if (needClamp) {
4699 GLuint i;
4700 for (i = 0; i < n; i++) {
4701 depthValues[i] = (GLfloat)CLAMP(depthValues[i], 0.0, 1.0);
4702 }
4703 }
4704
4705 /*
4706 * Convert values to dstType
4707 */
4708 if (dstType == GL_UNSIGNED_INT) {
4709 GLuint *zValues = (GLuint *) dest;
4710 GLuint i;
4711 if (depthMax <= 0xffffff) {
4712 /* no overflow worries */
4713 for (i = 0; i < n; i++) {
4714 zValues[i] = (GLuint) (depthValues[i] * (GLfloat) depthMax);
4715 }
4716 }
4717 else {
4718 /* need to use double precision to prevent overflow problems */
4719 for (i = 0; i < n; i++) {
4720 GLdouble z = depthValues[i] * (GLfloat) depthMax;
4721 if (z >= (GLdouble) 0xffffffff)
4722 zValues[i] = 0xffffffff;
4723 else
4724 zValues[i] = (GLuint) z;
4725 }
4726 }
4727 }
4728 else if (dstType == GL_UNSIGNED_SHORT) {
4729 GLushort *zValues = (GLushort *) dest;
4730 GLuint i;
4731 ASSERT(depthMax <= 0xffff);
4732 for (i = 0; i < n; i++) {
4733 zValues[i] = (GLushort) (depthValues[i] * (GLfloat) depthMax);
4734 }
4735 }
4736 else {
4737 ASSERT(dstType == GL_FLOAT);
4738 /*ASSERT(depthMax == 1.0F);*/
4739 }
4740
4741 free(depthTemp);
4742 }
4743
4744
4745 /*
4746 * Pack an array of depth values. The values are floats in [0,1].
4747 */
4748 void
4749 _mesa_pack_depth_span( struct gl_context *ctx, GLuint n, GLvoid *dest,
4750 GLenum dstType, const GLfloat *depthSpan,
4751 const struct gl_pixelstore_attrib *dstPacking )
4752 {
4753 GLfloat *depthCopy = (GLfloat *) malloc(n * sizeof(GLfloat));
4754 if (!depthCopy) {
4755 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
4756 return;
4757 }
4758
4759 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
4760 memcpy(depthCopy, depthSpan, n * sizeof(GLfloat));
4761 _mesa_scale_and_bias_depth(ctx, n, depthCopy);
4762 depthSpan = depthCopy;
4763 }
4764
4765 switch (dstType) {
4766 case GL_UNSIGNED_BYTE:
4767 {
4768 GLubyte *dst = (GLubyte *) dest;
4769 GLuint i;
4770 for (i = 0; i < n; i++) {
4771 dst[i] = FLOAT_TO_UBYTE( depthSpan[i] );
4772 }
4773 }
4774 break;
4775 case GL_BYTE:
4776 {
4777 GLbyte *dst = (GLbyte *) dest;
4778 GLuint i;
4779 for (i = 0; i < n; i++) {
4780 dst[i] = FLOAT_TO_BYTE( depthSpan[i] );
4781 }
4782 }
4783 break;
4784 case GL_UNSIGNED_SHORT:
4785 {
4786 GLushort *dst = (GLushort *) dest;
4787 GLuint i;
4788 for (i = 0; i < n; i++) {
4789 CLAMPED_FLOAT_TO_USHORT(dst[i], depthSpan[i]);
4790 }
4791 if (dstPacking->SwapBytes) {
4792 _mesa_swap2( (GLushort *) dst, n );
4793 }
4794 }
4795 break;
4796 case GL_SHORT:
4797 {
4798 GLshort *dst = (GLshort *) dest;
4799 GLuint i;
4800 for (i = 0; i < n; i++) {
4801 dst[i] = FLOAT_TO_SHORT( depthSpan[i] );
4802 }
4803 if (dstPacking->SwapBytes) {
4804 _mesa_swap2( (GLushort *) dst, n );
4805 }
4806 }
4807 break;
4808 case GL_UNSIGNED_INT:
4809 {
4810 GLuint *dst = (GLuint *) dest;
4811 GLuint i;
4812 for (i = 0; i < n; i++) {
4813 dst[i] = FLOAT_TO_UINT( depthSpan[i] );
4814 }
4815 if (dstPacking->SwapBytes) {
4816 _mesa_swap4( (GLuint *) dst, n );
4817 }
4818 }
4819 break;
4820 case GL_INT:
4821 {
4822 GLint *dst = (GLint *) dest;
4823 GLuint i;
4824 for (i = 0; i < n; i++) {
4825 dst[i] = FLOAT_TO_INT( depthSpan[i] );
4826 }
4827 if (dstPacking->SwapBytes) {
4828 _mesa_swap4( (GLuint *) dst, n );
4829 }
4830 }
4831 break;
4832 case GL_FLOAT:
4833 {
4834 GLfloat *dst = (GLfloat *) dest;
4835 GLuint i;
4836 for (i = 0; i < n; i++) {
4837 dst[i] = depthSpan[i];
4838 }
4839 if (dstPacking->SwapBytes) {
4840 _mesa_swap4( (GLuint *) dst, n );
4841 }
4842 }
4843 break;
4844 case GL_HALF_FLOAT_ARB:
4845 {
4846 GLhalfARB *dst = (GLhalfARB *) dest;
4847 GLuint i;
4848 for (i = 0; i < n; i++) {
4849 dst[i] = _mesa_float_to_half(depthSpan[i]);
4850 }
4851 if (dstPacking->SwapBytes) {
4852 _mesa_swap2( (GLushort *) dst, n );
4853 }
4854 }
4855 break;
4856 default:
4857 _mesa_problem(ctx, "bad type in _mesa_pack_depth_span");
4858 }
4859
4860 free(depthCopy);
4861 }
4862
4863
4864
4865 /**
4866 * Pack depth and stencil values as GL_DEPTH_STENCIL/GL_UNSIGNED_INT_24_8.
4867 */
4868 void
4869 _mesa_pack_depth_stencil_span(struct gl_context *ctx, GLuint n, GLuint *dest,
4870 const GLfloat *depthVals,
4871 const GLstencil *stencilVals,
4872 const struct gl_pixelstore_attrib *dstPacking)
4873 {
4874 GLfloat *depthCopy = (GLfloat *) malloc(n * sizeof(GLfloat));
4875 GLstencil *stencilCopy = (GLstencil *) malloc(n * sizeof(GLstencil));
4876 GLuint i;
4877
4878 if (!depthCopy || !stencilCopy) {
4879 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
4880 free(depthCopy);
4881 free(stencilCopy);
4882 return;
4883 }
4884
4885 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
4886 memcpy(depthCopy, depthVals, n * sizeof(GLfloat));
4887 _mesa_scale_and_bias_depth(ctx, n, depthCopy);
4888 depthVals = depthCopy;
4889 }
4890
4891 if (ctx->Pixel.IndexShift ||
4892 ctx->Pixel.IndexOffset ||
4893 ctx->Pixel.MapStencilFlag) {
4894 memcpy(stencilCopy, stencilVals, n * sizeof(GLstencil));
4895 _mesa_apply_stencil_transfer_ops(ctx, n, stencilCopy);
4896 stencilVals = stencilCopy;
4897 }
4898
4899 for (i = 0; i < n; i++) {
4900 GLuint z = (GLuint) (depthVals[i] * 0xffffff);
4901 dest[i] = (z << 8) | (stencilVals[i] & 0xff);
4902 }
4903
4904 if (dstPacking->SwapBytes) {
4905 _mesa_swap4(dest, n);
4906 }
4907
4908 free(depthCopy);
4909 free(stencilCopy);
4910 }
4911
4912
4913
4914
4915 /**
4916 * Unpack image data. Apply byte swapping, byte flipping (bitmap).
4917 * Return all image data in a contiguous block. This is used when we
4918 * compile glDrawPixels, glTexImage, etc into a display list. We
4919 * need a copy of the data in a standard format.
4920 */
4921 void *
4922 _mesa_unpack_image( GLuint dimensions,
4923 GLsizei width, GLsizei height, GLsizei depth,
4924 GLenum format, GLenum type, const GLvoid *pixels,
4925 const struct gl_pixelstore_attrib *unpack )
4926 {
4927 GLint bytesPerRow, compsPerRow;
4928 GLboolean flipBytes, swap2, swap4;
4929
4930 if (!pixels)
4931 return NULL; /* not necessarily an error */
4932
4933 if (width <= 0 || height <= 0 || depth <= 0)
4934 return NULL; /* generate error later */
4935
4936 if (type == GL_BITMAP) {
4937 bytesPerRow = (width + 7) >> 3;
4938 flipBytes = unpack->LsbFirst;
4939 swap2 = swap4 = GL_FALSE;
4940 compsPerRow = 0;
4941 }
4942 else {
4943 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
4944 GLint components = _mesa_components_in_format(format);
4945 GLint bytesPerComp;
4946
4947 if (_mesa_type_is_packed(type))
4948 components = 1;
4949
4950 if (bytesPerPixel <= 0 || components <= 0)
4951 return NULL; /* bad format or type. generate error later */
4952 bytesPerRow = bytesPerPixel * width;
4953 bytesPerComp = bytesPerPixel / components;
4954 flipBytes = GL_FALSE;
4955 swap2 = (bytesPerComp == 2) && unpack->SwapBytes;
4956 swap4 = (bytesPerComp == 4) && unpack->SwapBytes;
4957 compsPerRow = components * width;
4958 assert(compsPerRow >= width);
4959 }
4960
4961 {
4962 GLubyte *destBuffer
4963 = (GLubyte *) malloc(bytesPerRow * height * depth);
4964 GLubyte *dst;
4965 GLint img, row;
4966 if (!destBuffer)
4967 return NULL; /* generate GL_OUT_OF_MEMORY later */
4968
4969 dst = destBuffer;
4970 for (img = 0; img < depth; img++) {
4971 for (row = 0; row < height; row++) {
4972 const GLvoid *src = _mesa_image_address(dimensions, unpack, pixels,
4973 width, height, format, type, img, row, 0);
4974
4975 if ((type == GL_BITMAP) && (unpack->SkipPixels & 0x7)) {
4976 GLint i;
4977 flipBytes = GL_FALSE;
4978 if (unpack->LsbFirst) {
4979 GLubyte srcMask = 1 << (unpack->SkipPixels & 0x7);
4980 GLubyte dstMask = 128;
4981 const GLubyte *s = src;
4982 GLubyte *d = dst;
4983 *d = 0;
4984 for (i = 0; i < width; i++) {
4985 if (*s & srcMask) {
4986 *d |= dstMask;
4987 }
4988 if (srcMask == 128) {
4989 srcMask = 1;
4990 s++;
4991 }
4992 else {
4993 srcMask = srcMask << 1;
4994 }
4995 if (dstMask == 1) {
4996 dstMask = 128;
4997 d++;
4998 *d = 0;
4999 }
5000 else {
5001 dstMask = dstMask >> 1;
5002 }
5003 }
5004 }
5005 else {
5006 GLubyte srcMask = 128 >> (unpack->SkipPixels & 0x7);
5007 GLubyte dstMask = 128;
5008 const GLubyte *s = src;
5009 GLubyte *d = dst;
5010 *d = 0;
5011 for (i = 0; i < width; i++) {
5012 if (*s & srcMask) {
5013 *d |= dstMask;
5014 }
5015 if (srcMask == 1) {
5016 srcMask = 128;
5017 s++;
5018 }
5019 else {
5020 srcMask = srcMask >> 1;
5021 }
5022 if (dstMask == 1) {
5023 dstMask = 128;
5024 d++;
5025 *d = 0;
5026 }
5027 else {
5028 dstMask = dstMask >> 1;
5029 }
5030 }
5031 }
5032 }
5033 else {
5034 memcpy(dst, src, bytesPerRow);
5035 }
5036
5037 /* byte flipping/swapping */
5038 if (flipBytes) {
5039 flip_bytes((GLubyte *) dst, bytesPerRow);
5040 }
5041 else if (swap2) {
5042 _mesa_swap2((GLushort*) dst, compsPerRow);
5043 }
5044 else if (swap4) {
5045 _mesa_swap4((GLuint*) dst, compsPerRow);
5046 }
5047 dst += bytesPerRow;
5048 }
5049 }
5050 return destBuffer;
5051 }
5052 }
5053