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