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