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