projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
work on GL_SGI_color_table
[mesa.git] / src / mesa / main / image.c
1 /* $Id: image.c,v 1.28 2000/04/17 15:13:53 brianp Exp $ */
2
3 /*
4 * Mesa 3-D graphics library
5 * Version: 3.3
6 *
7 * Copyright (C) 1999-2000 Brian Paul All Rights Reserved.
8 *
9 * Permission is hereby granted, free of charge, to any person obtaining a
10 * copy of this software and associated documentation files (the "Software"),
11 * to deal in the Software without restriction, including without limitation
12 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
13 * and/or sell copies of the Software, and to permit persons to whom the
14 * Software is furnished to do so, subject to the following conditions:
15 *
16 * The above copyright notice and this permission notice shall be included
17 * in all copies or substantial portions of the Software.
18 *
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
20 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
22 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
23 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
24 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 */
26
27
28 #ifdef PC_HEADER
29 #include "all.h"
30 #else
31 #include "glheader.h"
32 #include "context.h"
33 #include "image.h"
34 #include "macros.h"
35 #include "mem.h"
36 #include "mmath.h"
37 #include "pixel.h"
38 #include "types.h"
39 #endif
40
41
42
43 /*
44 * These are the image packing parameters for Mesa's internal images.
45 * That is, _mesa_unpack_image() returns image data in this format.
46 * When we execute image commands (glDrawPixels, glTexImage, etc)
47 * from within display lists we have to be sure to set the current
48 * unpacking params to these values!
49 */
50 const struct gl_pixelstore_attrib _mesa_native_packing = {
51 1, /* Alignment */
52 0, /* RowLength */
53 0, /* SkipPixels */
54 0, /* SkipRows */
55 0, /* ImageHeight */
56 0, /* SkipImages */
57 GL_FALSE, /* SwapBytes */
58 GL_FALSE /* LsbFirst */
59 };
60
61
62
63 /*
64 * Flip the 8 bits in each byte of the given array.
65 */
66 static void
67 flip_bytes( GLubyte *p, GLuint n )
68 {
69 register GLuint i, a, b;
70
71 for (i=0;i<n;i++) {
72 b = (GLuint) p[i];
73 a = ((b & 0x01) << 7) |
74 ((b & 0x02) << 5) |
75 ((b & 0x04) << 3) |
76 ((b & 0x08) << 1) |
77 ((b & 0x10) >> 1) |
78 ((b & 0x20) >> 3) |
79 ((b & 0x40) >> 5) |
80 ((b & 0x80) >> 7);
81 p[i] = (GLubyte) a;
82 }
83 }
84
85
86 /*
87 * Flip the order of the 2 bytes in each word in the given array.
88 */
89 void
90 _mesa_swap2( GLushort *p, GLuint n )
91 {
92 register GLuint i;
93
94 for (i=0;i<n;i++) {
95 p[i] = (p[i] >> 8) | ((p[i] << 8) & 0xff00);
96 }
97 }
98
99
100
101 /*
102 * Flip the order of the 4 bytes in each word in the given array.
103 */
104 void
105 _mesa_swap4( GLuint *p, GLuint n )
106 {
107 register GLuint i, a, b;
108
109 for (i=0;i<n;i++) {
110 b = p[i];
111 a = (b >> 24)
112 | ((b >> 8) & 0xff00)
113 | ((b << 8) & 0xff0000)
114 | ((b << 24) & 0xff000000);
115 p[i] = a;
116 }
117 }
118
119
120
121
122 /*
123 * Return the size, in bytes, of the given GL datatype.
124 * Return 0 if GL_BITMAP.
125 * Return -1 if invalid type enum.
126 */
127 GLint _mesa_sizeof_type( GLenum type )
128 {
129 switch (type) {
130 case GL_BITMAP:
131 return 0;
132 case GL_UNSIGNED_BYTE:
133 return sizeof(GLubyte);
134 case GL_BYTE:
135 return sizeof(GLbyte);
136 case GL_UNSIGNED_SHORT:
137 return sizeof(GLushort);
138 case GL_SHORT:
139 return sizeof(GLshort);
140 case GL_UNSIGNED_INT:
141 return sizeof(GLuint);
142 case GL_INT:
143 return sizeof(GLint);
144 case GL_FLOAT:
145 return sizeof(GLfloat);
146 default:
147 return -1;
148 }
149 }
150
151
152 /*
153 * Same as _mesa_sizeof_packed_type() but we also accept the
154 * packed pixel format datatypes.
155 */
156 GLint _mesa_sizeof_packed_type( GLenum type )
157 {
158 switch (type) {
159 case GL_BITMAP:
160 return 0;
161 case GL_UNSIGNED_BYTE:
162 return sizeof(GLubyte);
163 case GL_BYTE:
164 return sizeof(GLbyte);
165 case GL_UNSIGNED_SHORT:
166 return sizeof(GLushort);
167 case GL_SHORT:
168 return sizeof(GLshort);
169 case GL_UNSIGNED_INT:
170 return sizeof(GLuint);
171 case GL_INT:
172 return sizeof(GLint);
173 case GL_FLOAT:
174 return sizeof(GLfloat);
175 case GL_UNSIGNED_BYTE_3_3_2:
176 return sizeof(GLubyte);
177 case GL_UNSIGNED_BYTE_2_3_3_REV:
178 return sizeof(GLubyte);
179 case GL_UNSIGNED_SHORT_5_6_5:
180 return sizeof(GLshort);
181 case GL_UNSIGNED_SHORT_5_6_5_REV:
182 return sizeof(GLshort);
183 case GL_UNSIGNED_SHORT_4_4_4_4:
184 return sizeof(GLshort);
185 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
186 return sizeof(GLshort);
187 case GL_UNSIGNED_SHORT_5_5_5_1:
188 return sizeof(GLshort);
189 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
190 return sizeof(GLshort);
191 case GL_UNSIGNED_INT_8_8_8_8:
192 return sizeof(GLuint);
193 case GL_UNSIGNED_INT_8_8_8_8_REV:
194 return sizeof(GLuint);
195 case GL_UNSIGNED_INT_10_10_10_2:
196 return sizeof(GLuint);
197 case GL_UNSIGNED_INT_2_10_10_10_REV:
198 return sizeof(GLuint);
199 default:
200 return -1;
201 }
202 }
203
204
205
206 /*
207 * Return the number of components in a GL enum pixel type.
208 * Return -1 if bad format.
209 */
210 GLint _mesa_components_in_format( GLenum format )
211 {
212 switch (format) {
213 case GL_COLOR_INDEX:
214 case GL_COLOR_INDEX1_EXT:
215 case GL_COLOR_INDEX2_EXT:
216 case GL_COLOR_INDEX4_EXT:
217 case GL_COLOR_INDEX8_EXT:
218 case GL_COLOR_INDEX12_EXT:
219 case GL_COLOR_INDEX16_EXT:
220 case GL_STENCIL_INDEX:
221 case GL_DEPTH_COMPONENT:
222 case GL_RED:
223 case GL_GREEN:
224 case GL_BLUE:
225 case GL_ALPHA:
226 case GL_LUMINANCE:
227 case GL_INTENSITY:
228 return 1;
229 case GL_LUMINANCE_ALPHA:
230 return 2;
231 case GL_RGB:
232 return 3;
233 case GL_RGBA:
234 return 4;
235 case GL_BGR:
236 return 3;
237 case GL_BGRA:
238 return 4;
239 case GL_ABGR_EXT:
240 return 4;
241 default:
242 return -1;
243 }
244 }
245
246
247 /*
248 * Return bytes per pixel for given format and type
249 * Return -1 if bad format or type.
250 */
251 GLint _mesa_bytes_per_pixel( GLenum format, GLenum type )
252 {
253 GLint comps = _mesa_components_in_format( format );
254 if (comps < 0)
255 return -1;
256
257 switch (type) {
258 case GL_BITMAP:
259 return 0; /* special case */
260 case GL_BYTE:
261 case GL_UNSIGNED_BYTE:
262 return comps * sizeof(GLubyte);
263 case GL_SHORT:
264 case GL_UNSIGNED_SHORT:
265 return comps * sizeof(GLshort);
266 case GL_INT:
267 case GL_UNSIGNED_INT:
268 return comps * sizeof(GLint);
269 case GL_FLOAT:
270 return comps * sizeof(GLfloat);
271 case GL_UNSIGNED_BYTE_3_3_2:
272 case GL_UNSIGNED_BYTE_2_3_3_REV:
273 if (format == GL_RGB || format == GL_BGR)
274 return sizeof(GLubyte);
275 else
276 return -1; /* error */
277 case GL_UNSIGNED_SHORT_5_6_5:
278 case GL_UNSIGNED_SHORT_5_6_5_REV:
279 if (format == GL_RGB || format == GL_BGR)
280 return sizeof(GLshort);
281 else
282 return -1; /* error */
283 case GL_UNSIGNED_SHORT_4_4_4_4:
284 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
285 case GL_UNSIGNED_SHORT_5_5_5_1:
286 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
287 if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT)
288 return sizeof(GLushort);
289 else
290 return -1;
291 case GL_UNSIGNED_INT_8_8_8_8:
292 case GL_UNSIGNED_INT_8_8_8_8_REV:
293 case GL_UNSIGNED_INT_10_10_10_2:
294 case GL_UNSIGNED_INT_2_10_10_10_REV:
295 if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT)
296 return sizeof(GLuint);
297 else
298 return -1;
299 default:
300 return -1;
301 }
302 }
303
304
305 /*
306 * Test if the given pixel format and type are legal.
307 * Return GL_TRUE for legal, GL_FALSE for illegal.
308 */
309 GLboolean
310 _mesa_is_legal_format_and_type( GLenum format, GLenum type )
311 {
312 switch (format) {
313 case GL_COLOR_INDEX:
314 case GL_STENCIL_INDEX:
315 switch (type) {
316 case GL_BITMAP:
317 case GL_BYTE:
318 case GL_UNSIGNED_BYTE:
319 case GL_SHORT:
320 case GL_UNSIGNED_SHORT:
321 case GL_INT:
322 case GL_UNSIGNED_INT:
323 case GL_FLOAT:
324 return GL_TRUE;
325 default:
326 return GL_FALSE;
327 }
328 case GL_RED:
329 case GL_GREEN:
330 case GL_BLUE:
331 case GL_ALPHA:
332 case GL_LUMINANCE:
333 case GL_LUMINANCE_ALPHA:
334 case GL_DEPTH_COMPONENT:
335 case GL_BGR:
336 switch (type) {
337 case GL_BYTE:
338 case GL_UNSIGNED_BYTE:
339 case GL_SHORT:
340 case GL_UNSIGNED_SHORT:
341 case GL_INT:
342 case GL_UNSIGNED_INT:
343 case GL_FLOAT:
344 return GL_TRUE;
345 default:
346 return GL_FALSE;
347 }
348 case GL_RGB:
349 switch (type) {
350 case GL_BYTE:
351 case GL_UNSIGNED_BYTE:
352 case GL_SHORT:
353 case GL_UNSIGNED_SHORT:
354 case GL_INT:
355 case GL_UNSIGNED_INT:
356 case GL_FLOAT:
357 case GL_UNSIGNED_BYTE_3_3_2:
358 case GL_UNSIGNED_BYTE_2_3_3_REV:
359 case GL_UNSIGNED_SHORT_5_6_5:
360 case GL_UNSIGNED_SHORT_5_6_5_REV:
361 return GL_TRUE;
362 default:
363 return GL_FALSE;
364 }
365 case GL_RGBA:
366 case GL_BGRA:
367 case GL_ABGR_EXT:
368 switch (type) {
369 case GL_BYTE:
370 case GL_UNSIGNED_BYTE:
371 case GL_SHORT:
372 case GL_UNSIGNED_SHORT:
373 case GL_INT:
374 case GL_UNSIGNED_INT:
375 case GL_FLOAT:
376 case GL_UNSIGNED_SHORT_4_4_4_4:
377 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
378 case GL_UNSIGNED_SHORT_5_5_5_1:
379 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
380 case GL_UNSIGNED_INT_8_8_8_8:
381 case GL_UNSIGNED_INT_8_8_8_8_REV:
382 case GL_UNSIGNED_INT_10_10_10_2:
383 case GL_UNSIGNED_INT_2_10_10_10_REV:
384 return GL_TRUE;
385 default:
386 return GL_FALSE;
387 }
388 default:
389 ; /* fall-through */
390 }
391 return GL_FALSE;
392 }
393
394
395
396 /*
397 * Return the address of a pixel in an image (actually a volume).
398 * Pixel unpacking/packing parameters are observed according to 'packing'.
399 * Input: image - start of image data
400 * width, height - size of image
401 * format - image format
402 * type - pixel component type
403 * packing - the pixelstore attributes
404 * img - which image in the volume (0 for 1D or 2D images)
405 * row, column - location of pixel in the image
406 * Return: address of pixel at (image,row,column) in image or NULL if error.
407 */
408 GLvoid *
409 _mesa_image_address( const struct gl_pixelstore_attrib *packing,
410 const GLvoid *image, GLsizei width,
411 GLsizei height, GLenum format, GLenum type,
412 GLint img, GLint row, GLint column )
413 {
414 GLint alignment; /* 1, 2 or 4 */
415 GLint pixels_per_row;
416 GLint rows_per_image;
417 GLint skiprows;
418 GLint skippixels;
419 GLint skipimages; /* for 3-D volume images */
420 GLubyte *pixel_addr;
421
422 alignment = packing->Alignment;
423 if (packing->RowLength > 0) {
424 pixels_per_row = packing->RowLength;
425 }
426 else {
427 pixels_per_row = width;
428 }
429 if (packing->ImageHeight > 0) {
430 rows_per_image = packing->ImageHeight;
431 }
432 else {
433 rows_per_image = height;
434 }
435 skiprows = packing->SkipRows;
436 skippixels = packing->SkipPixels;
437 skipimages = packing->SkipImages;
438
439 if (type==GL_BITMAP) {
440 /* BITMAP data */
441 GLint comp_per_pixel; /* components per pixel */
442 GLint bytes_per_comp; /* bytes per component */
443 GLint bytes_per_row;
444 GLint bytes_per_image;
445
446 /* Compute bytes per component */
447 bytes_per_comp = _mesa_sizeof_packed_type( type );
448 if (bytes_per_comp<0) {
449 return NULL;
450 }
451
452 /* Compute number of components per pixel */
453 comp_per_pixel = _mesa_components_in_format( format );
454 if (comp_per_pixel<0 && type != GL_BITMAP) {
455 return NULL;
456 }
457
458 bytes_per_row = alignment
459 * CEILING( comp_per_pixel*pixels_per_row, 8*alignment );
460
461 bytes_per_image = bytes_per_row * rows_per_image;
462
463 pixel_addr = (GLubyte *) image
464 + (skipimages + img) * bytes_per_image
465 + (skiprows + row) * bytes_per_row
466 + (skippixels + column) / 8;
467 }
468 else {
469 /* Non-BITMAP data */
470 GLint bytes_per_pixel, bytes_per_row, remainder, bytes_per_image;
471
472 bytes_per_pixel = _mesa_bytes_per_pixel( format, type );
473
474 /* The pixel type and format should have been error checked earlier */
475 assert(bytes_per_pixel > 0);
476
477 bytes_per_row = pixels_per_row * bytes_per_pixel;
478 remainder = bytes_per_row % alignment;
479 if (remainder > 0)
480 bytes_per_row += (alignment - remainder);
481
482 ASSERT(bytes_per_row % alignment == 0);
483
484 bytes_per_image = bytes_per_row * rows_per_image;
485
486 /* compute final pixel address */
487 pixel_addr = (GLubyte *) image
488 + (skipimages + img) * bytes_per_image
489 + (skiprows + row) * bytes_per_row
490 + (skippixels + column) * bytes_per_pixel;
491 }
492
493 return (GLvoid *) pixel_addr;
494 }
495
496
497
498 /*
499 * Compute the stride between image rows (in bytes) for the given
500 * pixel packing parameters and image width, format and type.
501 */
502 GLint
503 _mesa_image_row_stride( const struct gl_pixelstore_attrib *packing,
504 GLint width, GLenum format, GLenum type )
505 {
506 ASSERT(packing);
507 if (type == GL_BITMAP) {
508 /* BITMAP data */
509 if (packing->RowLength == 0) {
510 GLint bytes = (width + 7) / 8;
511 return bytes;
512 }
513 else {
514 GLint bytes = (packing->RowLength + 7) / 8;
515 return bytes;
516 }
517 }
518 else {
519 /* Non-BITMAP data */
520 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
521 if (bytesPerPixel <= 0)
522 return -1; /* error */
523 if (packing->RowLength == 0) {
524 GLint bytes = bytesPerPixel * width;
525 return bytes;
526 }
527 else {
528 GLint bytes = bytesPerPixel * packing->RowLength;
529 return bytes;
530 }
531 }
532 }
533
534
535
536 /*
537 * Unpack a 32x32 pixel polygon stipple from user memory using the
538 * current pixel unpack settings.
539 */
540 void
541 _mesa_unpack_polygon_stipple( const GLubyte *pattern, GLuint dest[32],
542 const struct gl_pixelstore_attrib *unpacking )
543 {
544 GLubyte *ptrn = (GLubyte *) _mesa_unpack_bitmap( 32, 32, pattern, unpacking );
545 if (ptrn) {
546 /* Convert pattern from GLubytes to GLuints and handle big/little
547 * endian differences
548 */
549 GLubyte *p = ptrn;
550 GLint i;
551 for (i = 0; i < 32; i++) {
552 dest[i] = (p[0] << 24)
553 | (p[1] << 16)
554 | (p[2] << 8)
555 | (p[3] );
556 p += 4;
557 }
558 FREE(ptrn);
559 }
560 }
561
562
563
564 /*
565 * Pack polygon stipple into user memory given current pixel packing
566 * settings.
567 */
568 void
569 _mesa_pack_polygon_stipple( const GLuint pattern[32], GLubyte *dest,
570 const struct gl_pixelstore_attrib *packing )
571 {
572 /* Convert pattern from GLuints to GLubytes to handle big/little
573 * endian differences.
574 */
575 GLubyte ptrn[32*4];
576 GLint i;
577 for (i = 0; i < 32; i++) {
578 ptrn[i * 4 + 0] = (GLubyte) ((pattern[i] >> 24) & 0xff);
579 ptrn[i * 4 + 1] = (GLubyte) ((pattern[i] >> 16) & 0xff);
580 ptrn[i * 4 + 2] = (GLubyte) ((pattern[i] >> 8 ) & 0xff);
581 ptrn[i * 4 + 3] = (GLubyte) ((pattern[i] ) & 0xff);
582 }
583
584 _mesa_pack_bitmap(32, 32, ptrn, dest, packing);
585 }
586
587
588
589 /*
590 * Pack the given RGBA span into client memory at 'dest' address
591 * in the given pixel format and type.
592 * Optionally apply the enabled pixel transfer ops.
593 * Pack into memory using the given packing params struct.
594 * This is used by glReadPixels and glGetTexImage?D()
595 * Input: ctx - the context
596 * n - number of pixels in the span
597 * rgba - the pixels
598 * format - dest packing format
599 * type - dest packing datatype
600 * destination - destination packing address
601 * packing - pixel packing parameters
602 * applyTransferOps - apply scale/bias/lookup-table ops?
603 */
604 void
605 _mesa_pack_rgba_span( const GLcontext *ctx,
606 GLuint n, CONST GLubyte srcRgba[][4],
607 GLenum format, GLenum type, GLvoid *destination,
608 const struct gl_pixelstore_attrib *packing,
609 GLboolean applyTransferOps )
610 {
611 applyTransferOps &= (ctx->Pixel.ScaleOrBiasRGBA ||
612 ctx->Pixel.MapColorFlag ||
613 ctx->ColorMatrix.type != MATRIX_IDENTITY ||
614 ctx->Pixel.ScaleOrBiasRGBApcm ||
615 ctx->Pixel.ColorTableEnabled ||
616 ctx->Pixel.PostColorMatrixColorTableEnabled);
617
618 /* Test for optimized case first */
619 if (!applyTransferOps && format == GL_RGBA && type == GL_UNSIGNED_BYTE) {
620 /* common simple case */
621 MEMCPY( destination, srcRgba, n * 4 * sizeof(GLubyte) );
622 }
623 else if (!applyTransferOps && format == GL_RGB && type == GL_UNSIGNED_BYTE) {
624 /* common simple case */
625 GLint i;
626 GLubyte *dest = (GLubyte *) destination;
627 for (i = 0; i < n; i++) {
628 dest[0] = srcRgba[i][RCOMP];
629 dest[1] = srcRgba[i][GCOMP];
630 dest[2] = srcRgba[i][BCOMP];
631 dest += 3;
632 }
633 }
634 else {
635 /* general solution */
636 GLfloat rgba[MAX_WIDTH][4], luminance[MAX_WIDTH];
637 const GLfloat rscale = 1.0F / 255.0F;
638 const GLfloat gscale = 1.0F / 255.0F;
639 const GLfloat bscale = 1.0F / 255.0F;
640 const GLfloat ascale = 1.0F / 255.0F;
641 const GLint comps = _mesa_components_in_format(format);
642 GLuint i;
643
644 assert(n <= MAX_WIDTH);
645
646 /* convert color components to floating point */
647 for (i=0;i<n;i++) {
648 rgba[i][RCOMP] = srcRgba[i][RCOMP] * rscale;
649 rgba[i][GCOMP] = srcRgba[i][GCOMP] * gscale;
650 rgba[i][BCOMP] = srcRgba[i][BCOMP] * bscale;
651 rgba[i][ACOMP] = srcRgba[i][ACOMP] * ascale;
652 }
653
654 /*
655 * Apply scale, bias and lookup-tables if enabled.
656 */
657 if (applyTransferOps) {
658 /* scale & bias */
659 if (ctx->Pixel.ScaleOrBiasRGBA) {
660 _mesa_scale_and_bias_rgba( ctx, n, rgba );
661 }
662 /* color map lookup */
663 if (ctx->Pixel.MapColorFlag) {
664 _mesa_map_rgba( ctx, n, rgba );
665 }
666 /* GL_COLOR_TABLE lookup */
667 if (ctx->Pixel.ColorTableEnabled) {
668 _mesa_lookup_rgba(&ctx->ColorTable, n, rgba);
669 }
670 /* XXX convolution here */
671 /* XXX post-convolution color table look-up here */
672 /* color matrix */
673 if (ctx->ColorMatrix.type != MATRIX_IDENTITY ||
674 ctx->Pixel.ScaleOrBiasRGBApcm) {
675 _mesa_transform_rgba(ctx, n, rgba);
676 }
677 /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
678 if (ctx->Pixel.PostColorMatrixColorTableEnabled) {
679 _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, n, rgba);
680 }
681 /* XXX histogram here */
682 /* XXX min/max here */
683 }
684
685 if (format==GL_LUMINANCE || format==GL_LUMINANCE_ALPHA) {
686 for (i=0;i<n;i++) {
687 GLfloat sum = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
688 luminance[i] = CLAMP( sum, 0.0F, 1.0F );
689 }
690 }
691
692 /*
693 * Pack/store the pixels. Ugh! Lots of cases!!!
694 */
695 switch (type) {
696 case GL_UNSIGNED_BYTE:
697 {
698 GLubyte *dst = (GLubyte *) destination;
699 switch (format) {
700 case GL_RED:
701 for (i=0;i<n;i++)
702 dst[i] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
703 break;
704 case GL_GREEN:
705 for (i=0;i<n;i++)
706 dst[i] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
707 break;
708 case GL_BLUE:
709 for (i=0;i<n;i++)
710 dst[i] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
711 break;
712 case GL_ALPHA:
713 for (i=0;i<n;i++)
714 dst[i] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
715 break;
716 case GL_LUMINANCE:
717 for (i=0;i<n;i++)
718 dst[i] = FLOAT_TO_UBYTE(luminance[i]);
719 break;
720 case GL_LUMINANCE_ALPHA:
721 for (i=0;i<n;i++) {
722 dst[i*2+0] = FLOAT_TO_UBYTE(luminance[i]);
723 dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
724 }
725 break;
726 case GL_RGB:
727 for (i=0;i<n;i++) {
728 dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
729 dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
730 dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
731 }
732 break;
733 case GL_RGBA:
734 for (i=0;i<n;i++) {
735 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
736 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
737 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
738 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
739 }
740 break;
741 case GL_BGR:
742 for (i=0;i<n;i++) {
743 dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
744 dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
745 dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
746 }
747 break;
748 case GL_BGRA:
749 for (i=0;i<n;i++) {
750 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
751 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
752 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
753 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
754 }
755 break;
756 case GL_ABGR_EXT:
757 for (i=0;i<n;i++) {
758 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
759 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
760 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
761 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
762 }
763 break;
764 default:
765 gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
766 }
767 }
768 break;
769 case GL_BYTE:
770 {
771 GLbyte *dst = (GLbyte *) destination;
772 switch (format) {
773 case GL_RED:
774 for (i=0;i<n;i++)
775 dst[i] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
776 break;
777 case GL_GREEN:
778 for (i=0;i<n;i++)
779 dst[i] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
780 break;
781 case GL_BLUE:
782 for (i=0;i<n;i++)
783 dst[i] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
784 break;
785 case GL_ALPHA:
786 for (i=0;i<n;i++)
787 dst[i] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
788 break;
789 case GL_LUMINANCE:
790 for (i=0;i<n;i++)
791 dst[i] = FLOAT_TO_BYTE(luminance[i]);
792 break;
793 case GL_LUMINANCE_ALPHA:
794 for (i=0;i<n;i++) {
795 dst[i*2+0] = FLOAT_TO_BYTE(luminance[i]);
796 dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
797 }
798 break;
799 case GL_RGB:
800 for (i=0;i<n;i++) {
801 dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
802 dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
803 dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
804 }
805 break;
806 case GL_RGBA:
807 for (i=0;i<n;i++) {
808 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
809 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
810 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
811 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
812 }
813 break;
814 case GL_BGR:
815 for (i=0;i<n;i++) {
816 dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
817 dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
818 dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
819 }
820 break;
821 case GL_BGRA:
822 for (i=0;i<n;i++) {
823 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
824 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
825 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
826 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
827 }
828 case GL_ABGR_EXT:
829 for (i=0;i<n;i++) {
830 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
831 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
832 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
833 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
834 }
835 break;
836 default:
837 gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
838 }
839 }
840 break;
841 case GL_UNSIGNED_SHORT:
842 {
843 GLushort *dst = (GLushort *) destination;
844 switch (format) {
845 case GL_RED:
846 for (i=0;i<n;i++)
847 dst[i] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
848 break;
849 case GL_GREEN:
850 for (i=0;i<n;i++)
851 dst[i] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
852 break;
853 case GL_BLUE:
854 for (i=0;i<n;i++)
855 dst[i] = FLOAT_TO_USHORT(rgba[i][BCOMP]);
856 break;
857 case GL_ALPHA:
858 for (i=0;i<n;i++)
859 dst[i] = FLOAT_TO_USHORT(rgba[i][ACOMP]);
860 break;
861 case GL_LUMINANCE:
862 for (i=0;i<n;i++)
863 dst[i] = FLOAT_TO_USHORT(luminance[i]);
864 break;
865 case GL_LUMINANCE_ALPHA:
866 for (i=0;i<n;i++) {
867 dst[i*2+0] = FLOAT_TO_USHORT(luminance[i]);
868 dst[i*2+1] = FLOAT_TO_USHORT(rgba[i][ACOMP]);
869 }
870 break;
871 case GL_RGB:
872 for (i=0;i<n;i++) {
873 dst[i*3+0] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
874 dst[i*3+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
875 dst[i*3+2] = FLOAT_TO_USHORT(rgba[i][BCOMP]);
876 }
877 break;
878 case GL_RGBA:
879 for (i=0;i<n;i++) {
880 dst[i*4+0] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
881 dst[i*4+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
882 dst[i*4+2] = FLOAT_TO_USHORT(rgba[i][BCOMP]);
883 dst[i*4+3] = FLOAT_TO_USHORT(rgba[i][ACOMP]);
884 }
885 break;
886 case GL_BGR:
887 for (i=0;i<n;i++) {
888 dst[i*3+0] = FLOAT_TO_USHORT(rgba[i][BCOMP]);
889 dst[i*3+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
890 dst[i*3+2] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
891 }
892 break;
893 case GL_BGRA:
894 for (i=0;i<n;i++) {
895 dst[i*4+0] = FLOAT_TO_USHORT(rgba[i][BCOMP]);
896 dst[i*4+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
897 dst[i*4+2] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
898 dst[i*4+3] = FLOAT_TO_USHORT(rgba[i][ACOMP]);
899 }
900 break;
901 case GL_ABGR_EXT:
902 for (i=0;i<n;i++) {
903 dst[i*4+0] = FLOAT_TO_USHORT(rgba[i][ACOMP]);
904 dst[i*4+1] = FLOAT_TO_USHORT(rgba[i][BCOMP]);
905 dst[i*4+2] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
906 dst[i*4+3] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
907 }
908 break;
909 default:
910 gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
911 }
912 if (packing->SwapBytes) {
913 _mesa_swap2( (GLushort *) dst, n * comps);
914 }
915 }
916 break;
917 case GL_SHORT:
918 {
919 GLshort *dst = (GLshort *) destination;
920 switch (format) {
921 case GL_RED:
922 for (i=0;i<n;i++)
923 dst[i] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
924 break;
925 case GL_GREEN:
926 for (i=0;i<n;i++)
927 dst[i] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
928 break;
929 case GL_BLUE:
930 for (i=0;i<n;i++)
931 dst[i] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
932 break;
933 case GL_ALPHA:
934 for (i=0;i<n;i++)
935 dst[i] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
936 break;
937 case GL_LUMINANCE:
938 for (i=0;i<n;i++)
939 dst[i] = FLOAT_TO_SHORT(luminance[i]);
940 break;
941 case GL_LUMINANCE_ALPHA:
942 for (i=0;i<n;i++) {
943 dst[i*2+0] = FLOAT_TO_SHORT(luminance[i]);
944 dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
945 }
946 break;
947 case GL_RGB:
948 for (i=0;i<n;i++) {
949 dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
950 dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
951 dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
952 }
953 break;
954 case GL_RGBA:
955 for (i=0;i<n;i++) {
956 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
957 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
958 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
959 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
960 }
961 break;
962 case GL_BGR:
963 for (i=0;i<n;i++) {
964 dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
965 dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
966 dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
967 }
968 break;
969 case GL_BGRA:
970 for (i=0;i<n;i++) {
971 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
972 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
973 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
974 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
975 }
976 case GL_ABGR_EXT:
977 for (i=0;i<n;i++) {
978 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
979 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
980 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
981 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
982 }
983 break;
984 default:
985 gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
986 }
987 if (packing->SwapBytes) {
988 _mesa_swap2( (GLushort *) dst, n * comps );
989 }
990 }
991 break;
992 case GL_UNSIGNED_INT:
993 {
994 GLuint *dst = (GLuint *) destination;
995 switch (format) {
996 case GL_RED:
997 for (i=0;i<n;i++)
998 dst[i] = FLOAT_TO_UINT(rgba[i][RCOMP]);
999 break;
1000 case GL_GREEN:
1001 for (i=0;i<n;i++)
1002 dst[i] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1003 break;
1004 case GL_BLUE:
1005 for (i=0;i<n;i++)
1006 dst[i] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1007 break;
1008 case GL_ALPHA:
1009 for (i=0;i<n;i++)
1010 dst[i] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1011 break;
1012 case GL_LUMINANCE:
1013 for (i=0;i<n;i++)
1014 dst[i] = FLOAT_TO_UINT(luminance[i]);
1015 break;
1016 case GL_LUMINANCE_ALPHA:
1017 for (i=0;i<n;i++) {
1018 dst[i*2+0] = FLOAT_TO_UINT(luminance[i]);
1019 dst[i*2+1] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1020 }
1021 break;
1022 case GL_RGB:
1023 for (i=0;i<n;i++) {
1024 dst[i*3+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1025 dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1026 dst[i*3+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1027 }
1028 break;
1029 case GL_RGBA:
1030 for (i=0;i<n;i++) {
1031 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1032 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1033 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1034 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1035 }
1036 break;
1037 case GL_BGR:
1038 for (i=0;i<n;i++) {
1039 dst[i*3+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1040 dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1041 dst[i*3+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1042 }
1043 break;
1044 case GL_BGRA:
1045 for (i=0;i<n;i++) {
1046 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1047 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1048 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1049 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1050 }
1051 break;
1052 case GL_ABGR_EXT:
1053 for (i=0;i<n;i++) {
1054 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1055 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1056 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1057 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1058 }
1059 break;
1060 default:
1061 gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1062 }
1063 if (packing->SwapBytes) {
1064 _mesa_swap4( (GLuint *) dst, n * comps );
1065 }
1066 }
1067 break;
1068 case GL_INT:
1069 {
1070 GLint *dst = (GLint *) destination;
1071 switch (format) {
1072 case GL_RED:
1073 for (i=0;i<n;i++)
1074 dst[i] = FLOAT_TO_INT(rgba[i][RCOMP]);
1075 break;
1076 case GL_GREEN:
1077 for (i=0;i<n;i++)
1078 dst[i] = FLOAT_TO_INT(rgba[i][GCOMP]);
1079 break;
1080 case GL_BLUE:
1081 for (i=0;i<n;i++)
1082 dst[i] = FLOAT_TO_INT(rgba[i][BCOMP]);
1083 break;
1084 case GL_ALPHA:
1085 for (i=0;i<n;i++)
1086 dst[i] = FLOAT_TO_INT(rgba[i][ACOMP]);
1087 break;
1088 case GL_LUMINANCE:
1089 for (i=0;i<n;i++)
1090 dst[i] = FLOAT_TO_INT(luminance[i]);
1091 break;
1092 case GL_LUMINANCE_ALPHA:
1093 for (i=0;i<n;i++) {
1094 dst[i*2+0] = FLOAT_TO_INT(luminance[i]);
1095 dst[i*2+1] = FLOAT_TO_INT(rgba[i][ACOMP]);
1096 }
1097 break;
1098 case GL_RGB:
1099 for (i=0;i<n;i++) {
1100 dst[i*3+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
1101 dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1102 dst[i*3+2] = FLOAT_TO_INT(rgba[i][BCOMP]);
1103 }
1104 break;
1105 case GL_RGBA:
1106 for (i=0;i<n;i++) {
1107 dst[i*4+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
1108 dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1109 dst[i*4+2] = FLOAT_TO_INT(rgba[i][BCOMP]);
1110 dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);
1111 }
1112 break;
1113 case GL_BGR:
1114 for (i=0;i<n;i++) {
1115 dst[i*3+0] = FLOAT_TO_INT(rgba[i][BCOMP]);
1116 dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1117 dst[i*3+2] = FLOAT_TO_INT(rgba[i][RCOMP]);
1118 }
1119 break;
1120 case GL_BGRA:
1121 for (i=0;i<n;i++) {
1122 dst[i*4+0] = FLOAT_TO_INT(rgba[i][BCOMP]);
1123 dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1124 dst[i*4+2] = FLOAT_TO_INT(rgba[i][RCOMP]);
1125 dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);
1126 }
1127 break;
1128 case GL_ABGR_EXT:
1129 for (i=0;i<n;i++) {
1130 dst[i*4+0] = FLOAT_TO_INT(rgba[i][ACOMP]);
1131 dst[i*4+1] = FLOAT_TO_INT(rgba[i][BCOMP]);
1132 dst[i*4+2] = FLOAT_TO_INT(rgba[i][GCOMP]);
1133 dst[i*4+3] = FLOAT_TO_INT(rgba[i][RCOMP]);
1134 }
1135 break;
1136 default:
1137 gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1138 }
1139 if (packing->SwapBytes) {
1140 _mesa_swap4( (GLuint *) dst, n * comps );
1141 }
1142 }
1143 break;
1144 case GL_FLOAT:
1145 {
1146 GLfloat *dst = (GLfloat *) destination;
1147 switch (format) {
1148 case GL_RED:
1149 for (i=0;i<n;i++)
1150 dst[i] = rgba[i][RCOMP];
1151 break;
1152 case GL_GREEN:
1153 for (i=0;i<n;i++)
1154 dst[i] = rgba[i][GCOMP];
1155 break;
1156 case GL_BLUE:
1157 for (i=0;i<n;i++)
1158 dst[i] = rgba[i][BCOMP];
1159 break;
1160 case GL_ALPHA:
1161 for (i=0;i<n;i++)
1162 dst[i] = rgba[i][ACOMP];
1163 break;
1164 case GL_LUMINANCE:
1165 for (i=0;i<n;i++)
1166 dst[i] = luminance[i];
1167 break;
1168 case GL_LUMINANCE_ALPHA:
1169 for (i=0;i<n;i++) {
1170 dst[i*2+0] = luminance[i];
1171 dst[i*2+1] = rgba[i][ACOMP];
1172 }
1173 break;
1174 case GL_RGB:
1175 for (i=0;i<n;i++) {
1176 dst[i*3+0] = rgba[i][RCOMP];
1177 dst[i*3+1] = rgba[i][GCOMP];
1178 dst[i*3+2] = rgba[i][BCOMP];
1179 }
1180 break;
1181 case GL_RGBA:
1182 for (i=0;i<n;i++) {
1183 dst[i*4+0] = rgba[i][RCOMP];
1184 dst[i*4+1] = rgba[i][GCOMP];
1185 dst[i*4+2] = rgba[i][BCOMP];
1186 dst[i*4+3] = rgba[i][ACOMP];
1187 }
1188 break;
1189 case GL_BGR:
1190 for (i=0;i<n;i++) {
1191 dst[i*3+0] = rgba[i][BCOMP];
1192 dst[i*3+1] = rgba[i][GCOMP];
1193 dst[i*3+2] = rgba[i][RCOMP];
1194 }
1195 break;
1196 case GL_BGRA:
1197 for (i=0;i<n;i++) {
1198 dst[i*4+0] = rgba[i][BCOMP];
1199 dst[i*4+1] = rgba[i][GCOMP];
1200 dst[i*4+2] = rgba[i][RCOMP];
1201 dst[i*4+3] = rgba[i][ACOMP];
1202 }
1203 break;
1204 case GL_ABGR_EXT:
1205 for (i=0;i<n;i++) {
1206 dst[i*4+0] = rgba[i][ACOMP];
1207 dst[i*4+1] = rgba[i][BCOMP];
1208 dst[i*4+2] = rgba[i][GCOMP];
1209 dst[i*4+3] = rgba[i][RCOMP];
1210 }
1211 break;
1212 default:
1213 gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1214 }
1215 if (packing->SwapBytes) {
1216 _mesa_swap4( (GLuint *) dst, n * comps );
1217 }
1218 }
1219 break;
1220 case GL_UNSIGNED_BYTE_3_3_2:
1221 if (format == GL_RGB) {
1222 GLubyte *dst = (GLubyte *) destination;
1223 for (i=0;i<n;i++) {
1224 dst[i] = (((GLint) (rgba[i][RCOMP] * 7.0F)) << 5)
1225 | (((GLint) (rgba[i][GCOMP] * 7.0F)) << 2)
1226 | (((GLint) (rgba[i][BCOMP] * 3.0F)) );
1227 }
1228 }
1229 break;
1230 case GL_UNSIGNED_BYTE_2_3_3_REV:
1231 if (format == GL_RGB) {
1232 GLubyte *dst = (GLubyte *) destination;
1233 for (i=0;i<n;i++) {
1234 dst[i] = (((GLint) (rgba[i][RCOMP] * 7.0F)) )
1235 | (((GLint) (rgba[i][GCOMP] * 7.0F)) << 3)
1236 | (((GLint) (rgba[i][BCOMP] * 3.0F)) << 5);
1237 }
1238 }
1239 break;
1240 case GL_UNSIGNED_SHORT_5_6_5:
1241 if (format == GL_RGB) {
1242 GLushort *dst = (GLushort *) destination;
1243 for (i=0;i<n;i++) {
1244 dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) << 11)
1245 | (((GLint) (rgba[i][GCOMP] * 63.0F)) << 5)
1246 | (((GLint) (rgba[i][BCOMP] * 31.0F)) );
1247 }
1248 }
1249 break;
1250 case GL_UNSIGNED_SHORT_5_6_5_REV:
1251 if (format == GL_RGB) {
1252 GLushort *dst = (GLushort *) destination;
1253 for (i=0;i<n;i++) {
1254 dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) )
1255 | (((GLint) (rgba[i][GCOMP] * 63.0F)) << 5)
1256 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 11);
1257 }
1258 }
1259 break;
1260 case GL_UNSIGNED_SHORT_4_4_4_4:
1261 if (format == GL_RGB) {
1262 GLushort *dst = (GLushort *) destination;
1263 for (i=0;i<n;i++) {
1264 dst[i] = (((GLint) (rgba[i][RCOMP] * 15.0F)) << 12)
1265 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 8)
1266 | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 4)
1267 | (((GLint) (rgba[i][ACOMP] * 15.0F)) );
1268 }
1269 }
1270 break;
1271 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1272 if (format == GL_RGB) {
1273 GLushort *dst = (GLushort *) destination;
1274 for (i=0;i<n;i++) {
1275 dst[i] = (((GLint) (rgba[i][RCOMP] * 15.0F)) )
1276 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 4)
1277 | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 8)
1278 | (((GLint) (rgba[i][ACOMP] * 15.0F)) << 12);
1279 }
1280 }
1281 break;
1282 case GL_UNSIGNED_SHORT_5_5_5_1:
1283 if (format == GL_RGB) {
1284 GLushort *dst = (GLushort *) destination;
1285 for (i=0;i<n;i++) {
1286 dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) << 11)
1287 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 6)
1288 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 1)
1289 | (((GLint) (rgba[i][ACOMP] * 1.0F)) );
1290 }
1291 }
1292 break;
1293 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1294 if (format == GL_RGB) {
1295 GLushort *dst = (GLushort *) destination;
1296 for (i=0;i<n;i++) {
1297 dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) )
1298 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 5)
1299 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 10)
1300 | (((GLint) (rgba[i][ACOMP] * 1.0F)) << 15);
1301 }
1302 }
1303 break;
1304 case GL_UNSIGNED_INT_8_8_8_8:
1305 if (format == GL_RGBA) {
1306 GLuint *dst = (GLuint *) destination;
1307 for (i=0;i<n;i++) {
1308 dst[i] = (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 24)
1309 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16)
1310 | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 8)
1311 | (((GLuint) (rgba[i][ACOMP] * 255.0F)) );
1312 }
1313 }
1314 else if (format == GL_BGRA) {
1315 GLuint *dst = (GLuint *) destination;
1316 for (i=0;i<n;i++) {
1317 dst[i] = (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 24)
1318 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16)
1319 | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 8)
1320 | (((GLuint) (rgba[i][ACOMP] * 255.0F)) );
1321 }
1322 }
1323 else if (format == GL_ABGR_EXT) {
1324 GLuint *dst = (GLuint *) destination;
1325 for (i=0;i<n;i++) {
1326 dst[i] = (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24)
1327 | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 16)
1328 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 8)
1329 | (((GLuint) (rgba[i][RCOMP] * 255.0F)) );
1330 }
1331 }
1332 break;
1333 case GL_UNSIGNED_INT_8_8_8_8_REV:
1334 if (format == GL_RGBA) {
1335 GLuint *dst = (GLuint *) destination;
1336 for (i=0;i<n;i++) {
1337 dst[i] = (((GLuint) (rgba[i][RCOMP] * 255.0F)) )
1338 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 8)
1339 | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 16)
1340 | (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24);
1341 }
1342 }
1343 else if (format == GL_BGRA) {
1344 GLuint *dst = (GLuint *) destination;
1345 for (i=0;i<n;i++) {
1346 dst[i] = (((GLuint) (rgba[i][BCOMP] * 255.0F)) )
1347 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 8)
1348 | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 16)
1349 | (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24);
1350 }
1351 }
1352 else if (format == GL_ABGR_EXT) {
1353 GLuint *dst = (GLuint *) destination;
1354 for (i=0;i<n;i++) {
1355 dst[i] = (((GLuint) (rgba[i][ACOMP] * 255.0F)) )
1356 | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 8)
1357 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16)
1358 | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 24);
1359 }
1360 }
1361 break;
1362 case GL_UNSIGNED_INT_10_10_10_2:
1363 if (format == GL_RGBA) {
1364 GLuint *dst = (GLuint *) destination;
1365 for (i=0;i<n;i++) {
1366 dst[i] = (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 22)
1367 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 12)
1368 | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 2)
1369 | (((GLuint) (rgba[i][ACOMP] * 3.0F)) );
1370 }
1371 }
1372 else if (format == GL_BGRA) {
1373 GLuint *dst = (GLuint *) destination;
1374 for (i=0;i<n;i++) {
1375 dst[i] = (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 22)
1376 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 12)
1377 | (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 2)
1378 | (((GLuint) (rgba[i][ACOMP] * 3.0F)) );
1379 }
1380 }
1381 else if (format == GL_ABGR_EXT) {
1382 GLuint *dst = (GLuint *) destination;
1383 for (i=0;i<n;i++) {
1384 dst[i] = (((GLuint) (rgba[i][ACOMP] * 1023.0F)) << 22)
1385 | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 12)
1386 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 2)
1387 | (((GLuint) (rgba[i][RCOMP] * 3.0F)) );
1388 }
1389 }
1390 break;
1391 case GL_UNSIGNED_INT_2_10_10_10_REV:
1392 if (format == GL_RGBA) {
1393 GLuint *dst = (GLuint *) destination;
1394 for (i=0;i<n;i++) {
1395 dst[i] = (((GLuint) (rgba[i][RCOMP] * 1023.0F)) )
1396 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 10)
1397 | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 20)
1398 | (((GLuint) (rgba[i][ACOMP] * 3.0F)) << 30);
1399 }
1400 }
1401 else if (format == GL_BGRA) {
1402 GLuint *dst = (GLuint *) destination;
1403 for (i=0;i<n;i++) {
1404 dst[i] = (((GLuint) (rgba[i][BCOMP] * 1023.0F)) )
1405 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 10)
1406 | (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 20)
1407 | (((GLuint) (rgba[i][ACOMP] * 3.0F)) << 30);
1408 }
1409 }
1410 else if (format == GL_ABGR_EXT) {
1411 GLuint *dst = (GLuint *) destination;
1412 for (i=0;i<n;i++) {
1413 dst[i] = (((GLuint) (rgba[i][ACOMP] * 1023.0F)) )
1414 | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 10)
1415 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 20)
1416 | (((GLuint) (rgba[i][RCOMP] * 3.0F)) << 30);
1417 }
1418 }
1419 break;
1420 default:
1421 gl_problem( ctx, "bad type in _mesa_pack_rgba_span" );
1422 }
1423 }
1424 }
1425
1426
1427
1428 #define SWAP2BYTE(VALUE) \
1429 { \
1430 GLubyte *bytes = (GLubyte *) &(VALUE); \
1431 GLubyte tmp = bytes[0]; \
1432 bytes[0] = bytes[1]; \
1433 bytes[1] = tmp; \
1434 }
1435
1436 #define SWAP4BYTE(VALUE) \
1437 { \
1438 GLubyte *bytes = (GLubyte *) &(VALUE); \
1439 GLubyte tmp = bytes[0]; \
1440 bytes[0] = bytes[3]; \
1441 bytes[3] = tmp; \
1442 tmp = bytes[1]; \
1443 bytes[1] = bytes[2]; \
1444 bytes[2] = tmp; \
1445 }
1446
1447
1448 static void
1449 extract_uint_indexes(GLuint n, GLuint indexes[],
1450 GLenum srcFormat, GLenum srcType, const GLvoid *src,
1451 const struct gl_pixelstore_attrib *unpack )
1452 {
1453 assert(srcFormat == GL_COLOR_INDEX);
1454
1455 ASSERT(srcType == GL_BITMAP ||
1456 srcType == GL_UNSIGNED_BYTE ||
1457 srcType == GL_BYTE ||
1458 srcType == GL_UNSIGNED_SHORT ||
1459 srcType == GL_SHORT ||
1460 srcType == GL_UNSIGNED_INT ||
1461 srcType == GL_INT ||
1462 srcType == GL_FLOAT);
1463
1464 switch (srcType) {
1465 case GL_BITMAP:
1466 {
1467 GLubyte *ubsrc = (GLubyte *) src;
1468 if (unpack->LsbFirst) {
1469 GLubyte mask = 1 << (unpack->SkipPixels & 0x7);
1470 GLuint i;
1471 for (i = 0; i < n; i++) {
1472 indexes[i] = (*ubsrc & mask) ? 1 : 0;
1473 if (mask == 128) {
1474 mask = 1;
1475 ubsrc++;
1476 }
1477 else {
1478 mask = mask << 1;
1479 }
1480 }
1481 }
1482 else {
1483 GLubyte mask = 128 >> (unpack->SkipPixels & 0x7);
1484 GLuint i;
1485 for (i = 0; i < n; i++) {
1486 indexes[i] = (*ubsrc & mask) ? 1 : 0;
1487 if (mask == 1) {
1488 mask = 128;
1489 ubsrc++;
1490 }
1491 else {
1492 mask = mask >> 1;
1493 }
1494 }
1495 }
1496 }
1497 break;
1498 case GL_UNSIGNED_BYTE:
1499 {
1500 GLuint i;
1501 const GLubyte *s = (const GLubyte *) src;
1502 for (i = 0; i < n; i++)
1503 indexes[i] = s[i];
1504 }
1505 break;
1506 case GL_BYTE:
1507 {
1508 GLuint i;
1509 const GLbyte *s = (const GLbyte *) src;
1510 for (i = 0; i < n; i++)
1511 indexes[i] = s[i];
1512 }
1513 break;
1514 case GL_UNSIGNED_SHORT:
1515 {
1516 GLuint i;
1517 const GLushort *s = (const GLushort *) src;
1518 if (unpack->SwapBytes) {
1519 for (i = 0; i < n; i++) {
1520 GLushort value = s[i];
1521 SWAP2BYTE(value);
1522 indexes[i] = value;
1523 }
1524 }
1525 else {
1526 for (i = 0; i < n; i++)
1527 indexes[i] = s[i];
1528 }
1529 }
1530 break;
1531 case GL_SHORT:
1532 {
1533 GLuint i;
1534 const GLshort *s = (const GLshort *) src;
1535 if (unpack->SwapBytes) {
1536 for (i = 0; i < n; i++) {
1537 GLshort value = s[i];
1538 SWAP2BYTE(value);
1539 indexes[i] = value;
1540 }
1541 }
1542 else {
1543 for (i = 0; i < n; i++)
1544 indexes[i] = s[i];
1545 }
1546 }
1547 break;
1548 case GL_UNSIGNED_INT:
1549 {
1550 GLuint i;
1551 const GLuint *s = (const GLuint *) src;
1552 if (unpack->SwapBytes) {
1553 for (i = 0; i < n; i++) {
1554 GLuint value = s[i];
1555 SWAP4BYTE(value);
1556 indexes[i] = value;
1557 }
1558 }
1559 else {
1560 for (i = 0; i < n; i++)
1561 indexes[i] = s[i];
1562 }
1563 }
1564 break;
1565 case GL_INT:
1566 {
1567 GLuint i;
1568 const GLint *s = (const GLint *) src;
1569 if (unpack->SwapBytes) {
1570 for (i = 0; i < n; i++) {
1571 GLint value = s[i];
1572 SWAP4BYTE(value);
1573 indexes[i] = value;
1574 }
1575 }
1576 else {
1577 for (i = 0; i < n; i++)
1578 indexes[i] = s[i];
1579 }
1580 }
1581 break;
1582 case GL_FLOAT:
1583 {
1584 GLuint i;
1585 const GLfloat *s = (const GLfloat *) src;
1586 if (unpack->SwapBytes) {
1587 for (i = 0; i < n; i++) {
1588 GLfloat value = s[i];
1589 SWAP4BYTE(value);
1590 indexes[i] = (GLuint) value;
1591 }
1592 }
1593 else {
1594 for (i = 0; i < n; i++)
1595 indexes[i] = (GLuint) s[i];
1596 }
1597 }
1598 break;
1599 default:
1600 gl_problem(NULL, "bad srcType in extract_uint_indexes");
1601 return;
1602 }
1603 }
1604
1605
1606
1607 /*
1608 * This function extracts floating point RGBA values from arbitrary
1609 * image data. srcFormat and srcType are the format and type parameters
1610 * passed to glDrawPixels, glTexImage[123]D, glTexSubImage[123]D, etc.
1611 *
1612 * Refering to section 3.6.4 of the OpenGL 1.2 spec, this function
1613 * implements the "Conversion to floating point", "Conversion to RGB",
1614 * and "Final Expansion to RGBA" operations.
1615 *
1616 * Args: n - number of pixels
1617 * rgba - output colors
1618 * srcFormat - format of incoming data
1619 * srcType - datatype of incoming data
1620 * src - source data pointer
1621 * swapBytes - perform byteswapping of incoming data?
1622 */
1623 static void
1624 extract_float_rgba(GLuint n, GLfloat rgba[][4],
1625 GLenum srcFormat, GLenum srcType, const GLvoid *src,
1626 GLboolean swapBytes)
1627 {
1628 GLint redIndex, greenIndex, blueIndex, alphaIndex;
1629 GLint stride;
1630 GLint rComp, bComp, gComp, aComp;
1631
1632 ASSERT(srcFormat == GL_RED ||
1633 srcFormat == GL_GREEN ||
1634 srcFormat == GL_BLUE ||
1635 srcFormat == GL_ALPHA ||
1636 srcFormat == GL_LUMINANCE ||
1637 srcFormat == GL_LUMINANCE_ALPHA ||
1638 srcFormat == GL_INTENSITY ||
1639 srcFormat == GL_RGB ||
1640 srcFormat == GL_BGR ||
1641 srcFormat == GL_RGBA ||
1642 srcFormat == GL_BGRA ||
1643 srcFormat == GL_ABGR_EXT);
1644
1645 ASSERT(srcType == GL_UNSIGNED_BYTE ||
1646 srcType == GL_BYTE ||
1647 srcType == GL_UNSIGNED_SHORT ||
1648 srcType == GL_SHORT ||
1649 srcType == GL_UNSIGNED_INT ||
1650 srcType == GL_INT ||
1651 srcType == GL_FLOAT ||
1652 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
1653 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
1654 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
1655 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
1656 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
1657 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
1658 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
1659 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
1660 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
1661 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
1662 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
1663 srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
1664
1665 rComp = gComp = bComp = aComp = -1;
1666
1667 switch (srcFormat) {
1668 case GL_RED:
1669 redIndex = 0;
1670 greenIndex = blueIndex = alphaIndex = -1;
1671 stride = 1;
1672 break;
1673 case GL_GREEN:
1674 greenIndex = 0;
1675 redIndex = blueIndex = alphaIndex = -1;
1676 stride = 1;
1677 break;
1678 case GL_BLUE:
1679 blueIndex = 0;
1680 redIndex = greenIndex = alphaIndex = -1;
1681 stride = 1;
1682 break;
1683 case GL_ALPHA:
1684 redIndex = greenIndex = blueIndex = -1;
1685 alphaIndex = 0;
1686 stride = 1;
1687 break;
1688 case GL_LUMINANCE:
1689 redIndex = greenIndex = blueIndex = 0;
1690 alphaIndex = -1;
1691 stride = 1;
1692 break;
1693 case GL_LUMINANCE_ALPHA:
1694 redIndex = greenIndex = blueIndex = 0;
1695 alphaIndex = 1;
1696 stride = 2;
1697 break;
1698 case GL_INTENSITY:
1699 redIndex = 0;
1700 greenIndex = blueIndex = alphaIndex = -1;
1701 stride = 1;
1702 break;
1703 case GL_RGB:
1704 redIndex = 0;
1705 greenIndex = 1;
1706 blueIndex = 2;
1707 alphaIndex = -1;
1708 stride = 3;
1709 break;
1710 case GL_BGR:
1711 redIndex = 2;
1712 greenIndex = 1;
1713 blueIndex = 0;
1714 alphaIndex = -1;
1715 stride = 3;
1716 break;
1717 case GL_RGBA:
1718 redIndex = 0;
1719 greenIndex = 1;
1720 blueIndex = 2;
1721 alphaIndex = 3;
1722 rComp = 0;
1723 gComp = 1;
1724 bComp = 2;
1725 aComp = 3;
1726 stride = 4;
1727 break;
1728 case GL_BGRA:
1729 redIndex = 2;
1730 greenIndex = 1;
1731 blueIndex = 0;
1732 alphaIndex = 3;
1733 rComp = 2;
1734 gComp = 1;
1735 bComp = 0;
1736 aComp = 3;
1737 stride = 4;
1738 break;
1739 case GL_ABGR_EXT:
1740 redIndex = 3;
1741 greenIndex = 2;
1742 blueIndex = 1;
1743 alphaIndex = 0;
1744 rComp = 3;
1745 gComp = 2;
1746 bComp = 1;
1747 aComp = 0;
1748 stride = 4;
1749 break;
1750 default:
1751 gl_problem(NULL, "bad srcFormat in extract float data");
1752 return;
1753 }
1754
1755
1756 #define PROCESS(INDEX, CHANNEL, DEFAULT, TYPE, CONVERSION) \
1757 if ((INDEX) < 0) { \
1758 GLuint i; \
1759 for (i = 0; i < n; i++) { \
1760 rgba[i][CHANNEL] = DEFAULT; \
1761 } \
1762 } \
1763 else if (swapBytes) { \
1764 const TYPE *s = (const TYPE *) src; \
1765 GLuint i; \
1766 for (i = 0; i < n; i++) { \
1767 TYPE value = s[INDEX]; \
1768 if (sizeof(TYPE) == 2) { \
1769 SWAP2BYTE(value); \
1770 } \
1771 else if (sizeof(TYPE) == 4) { \
1772 SWAP4BYTE(value); \
1773 } \
1774 rgba[i][CHANNEL] = (GLfloat) CONVERSION(value); \
1775 s += stride; \
1776 } \
1777 } \
1778 else { \
1779 const TYPE *s = (const TYPE *) src; \
1780 GLuint i; \
1781 for (i = 0; i < n; i++) { \
1782 rgba[i][CHANNEL] = (GLfloat) CONVERSION(s[INDEX]); \
1783 s += stride; \
1784 } \
1785 }
1786
1787 switch (srcType) {
1788 case GL_UNSIGNED_BYTE:
1789 PROCESS(redIndex, RCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT);
1790 PROCESS(greenIndex, GCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT);
1791 PROCESS(blueIndex, BCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT);
1792 PROCESS(alphaIndex, ACOMP, 1.0F, GLubyte, UBYTE_TO_FLOAT);
1793 break;
1794 case GL_BYTE:
1795 PROCESS(redIndex, RCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT);
1796 PROCESS(greenIndex, GCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT);
1797 PROCESS(blueIndex, BCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT);
1798 PROCESS(alphaIndex, ACOMP, 1.0F, GLbyte, BYTE_TO_FLOAT);
1799 break;
1800 case GL_UNSIGNED_SHORT:
1801 PROCESS(redIndex, RCOMP, 0.0F, GLushort, USHORT_TO_FLOAT);
1802 PROCESS(greenIndex, GCOMP, 0.0F, GLushort, USHORT_TO_FLOAT);
1803 PROCESS(blueIndex, BCOMP, 0.0F, GLushort, USHORT_TO_FLOAT);
1804 PROCESS(alphaIndex, ACOMP, 1.0F, GLushort, USHORT_TO_FLOAT);
1805 break;
1806 case GL_SHORT:
1807 PROCESS(redIndex, RCOMP, 0.0F, GLshort, SHORT_TO_FLOAT);
1808 PROCESS(greenIndex, GCOMP, 0.0F, GLshort, SHORT_TO_FLOAT);
1809 PROCESS(blueIndex, BCOMP, 0.0F, GLshort, SHORT_TO_FLOAT);
1810 PROCESS(alphaIndex, ACOMP, 1.0F, GLshort, SHORT_TO_FLOAT);
1811 break;
1812 case GL_UNSIGNED_INT:
1813 PROCESS(redIndex, RCOMP, 0.0F, GLuint, UINT_TO_FLOAT);
1814 PROCESS(greenIndex, GCOMP, 0.0F, GLuint, UINT_TO_FLOAT);
1815 PROCESS(blueIndex, BCOMP, 0.0F, GLuint, UINT_TO_FLOAT);
1816 PROCESS(alphaIndex, ACOMP, 1.0F, GLuint, UINT_TO_FLOAT);
1817 break;
1818 case GL_INT:
1819 PROCESS(redIndex, RCOMP, 0.0F, GLint, INT_TO_FLOAT);
1820 PROCESS(greenIndex, GCOMP, 0.0F, GLint, INT_TO_FLOAT);
1821 PROCESS(blueIndex, BCOMP, 0.0F, GLint, INT_TO_FLOAT);
1822 PROCESS(alphaIndex, ACOMP, 1.0F, GLint, INT_TO_FLOAT);
1823 break;
1824 case GL_FLOAT:
1825 PROCESS(redIndex, RCOMP, 0.0F, GLfloat, (GLfloat));
1826 PROCESS(greenIndex, GCOMP, 0.0F, GLfloat, (GLfloat));
1827 PROCESS(blueIndex, BCOMP, 0.0F, GLfloat, (GLfloat));
1828 PROCESS(alphaIndex, ACOMP, 1.0F, GLfloat, (GLfloat));
1829 break;
1830 case GL_UNSIGNED_BYTE_3_3_2:
1831 {
1832 const GLubyte *ubsrc = (const GLubyte *) src;
1833 GLuint i;
1834 for (i = 0; i < n; i ++) {
1835 GLubyte p = ubsrc[i];
1836 rgba[i][RCOMP] = ((p >> 5) ) * (1.0F / 7.0F);
1837 rgba[i][GCOMP] = ((p >> 2) & 0x7) * (1.0F / 7.0F);
1838 rgba[i][BCOMP] = ((p ) & 0x3) * (1.0F / 3.0F);
1839 rgba[i][ACOMP] = 1.0F;
1840 }
1841 }
1842 break;
1843 case GL_UNSIGNED_BYTE_2_3_3_REV:
1844 {
1845 const GLubyte *ubsrc = (const GLubyte *) src;
1846 GLuint i;
1847 for (i = 0; i < n; i ++) {
1848 GLubyte p = ubsrc[i];
1849 rgba[i][RCOMP] = ((p ) & 0x7) * (1.0F / 7.0F);
1850 rgba[i][GCOMP] = ((p >> 3) & 0x7) * (1.0F / 7.0F);
1851 rgba[i][BCOMP] = ((p >> 6) ) * (1.0F / 3.0F);
1852 rgba[i][ACOMP] = 1.0F;
1853 }
1854 }
1855 break;
1856 case GL_UNSIGNED_SHORT_5_6_5:
1857 if (swapBytes) {
1858 const GLushort *ussrc = (const GLushort *) src;
1859 GLuint i;
1860 for (i = 0; i < n; i ++) {
1861 GLushort p = ussrc[i];
1862 SWAP2BYTE(p);
1863 rgba[i][RCOMP] = ((p >> 11) ) * (1.0F / 31.0F);
1864 rgba[i][GCOMP] = ((p >> 5) & 0x3f) * (1.0F / 63.0F);
1865 rgba[i][BCOMP] = ((p ) & 0x1f) * (1.0F / 31.0F);
1866 rgba[i][ACOMP] = 1.0F;
1867 }
1868 }
1869 else {
1870 const GLushort *ussrc = (const GLushort *) src;
1871 GLuint i;
1872 for (i = 0; i < n; i ++) {
1873 GLushort p = ussrc[i];
1874 rgba[i][RCOMP] = ((p >> 11) ) * (1.0F / 31.0F);
1875 rgba[i][GCOMP] = ((p >> 5) & 0x3f) * (1.0F / 63.0F);
1876 rgba[i][BCOMP] = ((p ) & 0x1f) * (1.0F / 31.0F);
1877 rgba[i][ACOMP] = 1.0F;
1878 }
1879 }
1880 break;
1881 case GL_UNSIGNED_SHORT_5_6_5_REV:
1882 if (swapBytes) {
1883 const GLushort *ussrc = (const GLushort *) src;
1884 GLuint i;
1885 for (i = 0; i < n; i ++) {
1886 GLushort p = ussrc[i];
1887 SWAP2BYTE(p);
1888 rgba[i][RCOMP] = ((p ) & 0x1f) * (1.0F / 31.0F);
1889 rgba[i][GCOMP] = ((p >> 5) & 0x3f) * (1.0F / 63.0F);
1890 rgba[i][BCOMP] = ((p >> 11) ) * (1.0F / 31.0F);
1891 rgba[i][ACOMP] = 1.0F;
1892 }
1893 }
1894 else {
1895 const GLushort *ussrc = (const GLushort *) src;
1896 GLuint i;
1897 for (i = 0; i < n; i ++) {
1898 GLushort p = ussrc[i];
1899 rgba[i][RCOMP] = ((p ) & 0x1f) * (1.0F / 31.0F);
1900 rgba[i][GCOMP] = ((p >> 5) & 0x3f) * (1.0F / 63.0F);
1901 rgba[i][BCOMP] = ((p >> 11) ) * (1.0F / 31.0F);
1902 rgba[i][ACOMP] = 1.0F;
1903 }
1904 }
1905 break;
1906 case GL_UNSIGNED_SHORT_4_4_4_4:
1907 if (swapBytes) {
1908 const GLushort *ussrc = (const GLushort *) src;
1909 GLuint i;
1910 for (i = 0; i < n; i ++) {
1911 GLushort p = ussrc[i];
1912 SWAP2BYTE(p);
1913 rgba[i][rComp] = ((p >> 12) ) * (1.0F / 15.0F);
1914 rgba[i][gComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F);
1915 rgba[i][bComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F);
1916 rgba[i][aComp] = ((p ) & 0xf) * (1.0F / 15.0F);
1917 }
1918 }
1919 else {
1920 const GLushort *ussrc = (const GLushort *) src;
1921 GLuint i;
1922 for (i = 0; i < n; i ++) {
1923 GLushort p = ussrc[i];
1924 rgba[i][rComp] = ((p >> 12) ) * (1.0F / 15.0F);
1925 rgba[i][gComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F);
1926 rgba[i][bComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F);
1927 rgba[i][aComp] = ((p ) & 0xf) * (1.0F / 15.0F);
1928 }
1929 }
1930 break;
1931 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1932 if (swapBytes) {
1933 const GLushort *ussrc = (const GLushort *) src;
1934 GLuint i;
1935 for (i = 0; i < n; i ++) {
1936 GLushort p = ussrc[i];
1937 SWAP2BYTE(p);
1938 rgba[i][rComp] = ((p ) & 0xf) * (1.0F / 15.0F);
1939 rgba[i][gComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F);
1940 rgba[i][bComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F);
1941 rgba[i][aComp] = ((p >> 12) ) * (1.0F / 15.0F);
1942 }
1943 }
1944 else {
1945 const GLushort *ussrc = (const GLushort *) src;
1946 GLuint i;
1947 for (i = 0; i < n; i ++) {
1948 GLushort p = ussrc[i];
1949 rgba[i][rComp] = ((p ) & 0xf) * (1.0F / 15.0F);
1950 rgba[i][gComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F);
1951 rgba[i][bComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F);
1952 rgba[i][aComp] = ((p >> 12) ) * (1.0F / 15.0F);
1953 }
1954 }
1955 break;
1956 case GL_UNSIGNED_SHORT_5_5_5_1:
1957 if (swapBytes) {
1958 const GLushort *ussrc = (const GLushort *) src;
1959 GLuint i;
1960 for (i = 0; i < n; i ++) {
1961 GLushort p = ussrc[i];
1962 SWAP2BYTE(p);
1963 rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F);
1964 rgba[i][gComp] = ((p >> 6) & 0x1f) * (1.0F / 31.0F);
1965 rgba[i][bComp] = ((p >> 1) & 0x1f) * (1.0F / 31.0F);
1966 rgba[i][aComp] = ((p ) & 0x1) * (1.0F / 1.0F);
1967 }
1968 }
1969 else {
1970 const GLushort *ussrc = (const GLushort *) src;
1971 GLuint i;
1972 for (i = 0; i < n; i ++) {
1973 GLushort p = ussrc[i];
1974 rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F);
1975 rgba[i][gComp] = ((p >> 6) & 0x1f) * (1.0F / 31.0F);
1976 rgba[i][bComp] = ((p >> 1) & 0x1f) * (1.0F / 31.0F);
1977 rgba[i][aComp] = ((p ) & 0x1) * (1.0F / 1.0F);
1978 }
1979 }
1980 break;
1981 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1982 if (swapBytes) {
1983 const GLushort *ussrc = (const GLushort *) src;
1984 GLuint i;
1985 for (i = 0; i < n; i ++) {
1986 GLushort p = ussrc[i];
1987 SWAP2BYTE(p);
1988 rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F);
1989 rgba[i][gComp] = ((p >> 5) & 0x1f) * (1.0F / 31.0F);
1990 rgba[i][bComp] = ((p >> 10) & 0x1f) * (1.0F / 31.0F);
1991 rgba[i][aComp] = ((p >> 15) ) * (1.0F / 1.0F);
1992 }
1993 }
1994 else {
1995 const GLushort *ussrc = (const GLushort *) src;
1996 GLuint i;
1997 for (i = 0; i < n; i ++) {
1998 GLushort p = ussrc[i];
1999 rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F);
2000 rgba[i][gComp] = ((p >> 5) & 0x1f) * (1.0F / 31.0F);
2001 rgba[i][bComp] = ((p >> 10) & 0x1f) * (1.0F / 31.0F);
2002 rgba[i][aComp] = ((p >> 15) ) * (1.0F / 1.0F);
2003 }
2004 }
2005 break;
2006 case GL_UNSIGNED_INT_8_8_8_8:
2007 if (swapBytes) {
2008 const GLuint *uisrc = (const GLuint *) src;
2009 GLuint i;
2010 for (i = 0; i < n; i ++) {
2011 GLuint p = uisrc[i];
2012 rgba[i][rComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p ) & 0xff);
2013 rgba[i][gComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 8) & 0xff);
2014 rgba[i][bComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 16) & 0xff);
2015 rgba[i][aComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 24) );
2016 }
2017 }
2018 else {
2019 const GLuint *uisrc = (const GLuint *) src;
2020 GLuint i;
2021 for (i = 0; i < n; i ++) {
2022 GLuint p = uisrc[i];
2023 rgba[i][rComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 24) );
2024 rgba[i][gComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 16) & 0xff);
2025 rgba[i][bComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 8) & 0xff);
2026 rgba[i][aComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p ) & 0xff);
2027 }
2028 }
2029 break;
2030 case GL_UNSIGNED_INT_8_8_8_8_REV:
2031 if (swapBytes) {
2032 const GLuint *uisrc = (const GLuint *) src;
2033 GLuint i;
2034 for (i = 0; i < n; i ++) {
2035 GLuint p = uisrc[i];
2036 rgba[i][rComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 24) );
2037 rgba[i][gComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 16) & 0xff);
2038 rgba[i][bComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 8) & 0xff);
2039 rgba[i][aComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p ) & 0xff);
2040 }
2041 }
2042 else {
2043 const GLuint *uisrc = (const GLuint *) src;
2044 GLuint i;
2045 for (i = 0; i < n; i ++) {
2046 GLuint p = uisrc[i];
2047 rgba[i][rComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p ) & 0xff);
2048 rgba[i][gComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 8) & 0xff);
2049 rgba[i][bComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 16) & 0xff);
2050 rgba[i][aComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 24) );
2051 }
2052 }
2053 break;
2054 case GL_UNSIGNED_INT_10_10_10_2:
2055 if (swapBytes) {
2056 const GLuint *uisrc = (const GLuint *) src;
2057 GLuint i;
2058 for (i = 0; i < n; i ++) {
2059 GLuint p = uisrc[i];
2060 SWAP4BYTE(p);
2061 rgba[i][rComp] = ((p >> 22) ) * (1.0F / 1023.0F);
2062 rgba[i][gComp] = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F);
2063 rgba[i][bComp] = ((p >> 2) & 0x3ff) * (1.0F / 1023.0F);
2064 rgba[i][aComp] = ((p ) & 0x3 ) * (1.0F / 3.0F);
2065 }
2066 }
2067 else {
2068 const GLuint *uisrc = (const GLuint *) src;
2069 GLuint i;
2070 for (i = 0; i < n; i ++) {
2071 GLuint p = uisrc[i];
2072 rgba[i][rComp] = ((p >> 22) ) * (1.0F / 1023.0F);
2073 rgba[i][gComp] = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F);
2074 rgba[i][bComp] = ((p >> 2) & 0x3ff) * (1.0F / 1023.0F);
2075 rgba[i][aComp] = ((p ) & 0x3 ) * (1.0F / 3.0F);
2076 }
2077 }
2078 break;
2079 case GL_UNSIGNED_INT_2_10_10_10_REV:
2080 if (swapBytes) {
2081 const GLuint *uisrc = (const GLuint *) src;
2082 GLuint i;
2083 for (i = 0; i < n; i ++) {
2084 GLuint p = uisrc[i];
2085 SWAP4BYTE(p);
2086 rgba[i][rComp] = ((p ) & 0x3ff) * (1.0F / 1023.0F);
2087 rgba[i][gComp] = ((p >> 10) & 0x3ff) * (1.0F / 1023.0F);
2088 rgba[i][bComp] = ((p >> 20) & 0x3ff) * (1.0F / 1023.0F);
2089 rgba[i][aComp] = ((p >> 30) ) * (1.0F / 3.0F);
2090 }
2091 }
2092 else {
2093 const GLuint *uisrc = (const GLuint *) src;
2094 GLuint i;
2095 for (i = 0; i < n; i ++) {
2096 GLuint p = uisrc[i];
2097 rgba[i][rComp] = ((p ) & 0x3ff) * (1.0F / 1023.0F);
2098 rgba[i][gComp] = ((p >> 10) & 0x3ff) * (1.0F / 1023.0F);
2099 rgba[i][bComp] = ((p >> 20) & 0x3ff) * (1.0F / 1023.0F);
2100 rgba[i][aComp] = ((p >> 30) ) * (1.0F / 3.0F);
2101 }
2102 }
2103 break;
2104 default:
2105 gl_problem(NULL, "bad srcType in extract float data");
2106 break;
2107 }
2108 }
2109
2110
2111
2112 /*
2113 * Unpack a row of color image data from a client buffer according to
2114 * the pixel unpacking parameters. Apply any enabled pixel transfer
2115 * ops (PixelMap, scale/bias) if the applyTransferOps flag is enabled.
2116 * Return GLubyte values in the specified dest image format.
2117 * This is (or will be) used by glDrawPixels and glTexImage?D().
2118 * Input: ctx - the context
2119 * n - number of pixels in the span
2120 * dstFormat - format of destination color array
2121 * dest - the destination color array
2122 * srcFormat - source image format
2123 * srcType - source image datatype
2124 * source - source image pointer
2125 * unpacking - pixel unpacking parameters
2126 * applyTransferOps - apply scale/bias/lookup-table ops?
2127 *
2128 * XXX perhaps expand this to process whole images someday.
2129 */
2130 void
2131 _mesa_unpack_ubyte_color_span( const GLcontext *ctx,
2132 GLuint n, GLenum dstFormat, GLubyte dest[],
2133 GLenum srcFormat, GLenum srcType,
2134 const GLvoid *source,
2135 const struct gl_pixelstore_attrib *unpacking,
2136 GLboolean applyTransferOps )
2137 {
2138 ASSERT(dstFormat == GL_ALPHA ||
2139 dstFormat == GL_LUMINANCE ||
2140 dstFormat == GL_LUMINANCE_ALPHA ||
2141 dstFormat == GL_INTENSITY ||
2142 dstFormat == GL_RGB ||
2143 dstFormat == GL_RGBA ||
2144 dstFormat == GL_COLOR_INDEX);
2145
2146 ASSERT(srcFormat == GL_RED ||
2147 srcFormat == GL_GREEN ||
2148 srcFormat == GL_BLUE ||
2149 srcFormat == GL_ALPHA ||
2150 srcFormat == GL_LUMINANCE ||
2151 srcFormat == GL_LUMINANCE_ALPHA ||
2152 srcFormat == GL_INTENSITY ||
2153 srcFormat == GL_RGB ||
2154 srcFormat == GL_BGR ||
2155 srcFormat == GL_RGBA ||
2156 srcFormat == GL_BGRA ||
2157 srcFormat == GL_ABGR_EXT ||
2158 srcFormat == GL_COLOR_INDEX);
2159
2160 ASSERT(srcType == GL_BITMAP ||
2161 srcType == GL_UNSIGNED_BYTE ||
2162 srcType == GL_BYTE ||
2163 srcType == GL_UNSIGNED_SHORT ||
2164 srcType == GL_SHORT ||
2165 srcType == GL_UNSIGNED_INT ||
2166 srcType == GL_INT ||
2167 srcType == GL_FLOAT ||
2168 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
2169 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
2170 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
2171 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
2172 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
2173 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
2174 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
2175 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
2176 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
2177 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
2178 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
2179 srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
2180
2181 /* this is intended for RGBA mode only */
2182 assert(ctx->Visual->RGBAflag);
2183
2184 applyTransferOps &= (ctx->Pixel.ScaleOrBiasRGBA ||
2185 ctx->Pixel.MapColorFlag ||
2186 ctx->ColorMatrix.type != MATRIX_IDENTITY ||
2187 ctx->Pixel.ScaleOrBiasRGBApcm ||
2188 ctx->Pixel.ColorTableEnabled ||
2189 ctx->Pixel.PostColorMatrixColorTableEnabled);
2190
2191 /* Try simple cases first */
2192 if (!applyTransferOps && srcType == GL_UNSIGNED_BYTE) {
2193 if (dstFormat == GL_RGBA) {
2194 if (srcFormat == GL_RGBA) {
2195 MEMCPY( dest, source, n * 4 * sizeof(GLubyte) );
2196 return;
2197 }
2198 else if (srcFormat == GL_RGB) {
2199 GLuint i;
2200 const GLubyte *src = (const GLubyte *) source;
2201 GLubyte *dst = dest;
2202 for (i = 0; i < n; i++) {
2203 dst[0] = src[0];
2204 dst[1] = src[1];
2205 dst[2] = src[2];
2206 dst[3] = 255;
2207 src += 3;
2208 dst += 4;
2209 }
2210 return;
2211 }
2212 }
2213 else if (dstFormat == GL_RGB) {
2214 if (srcFormat == GL_RGB) {
2215 MEMCPY( dest, source, n * 3 * sizeof(GLubyte) );
2216 return;
2217 }
2218 else if (srcFormat == GL_RGBA) {
2219 GLuint i;
2220 const GLubyte *src = (const GLubyte *) source;
2221 GLubyte *dst = dest;
2222 for (i = 0; i < n; i++) {
2223 dst[0] = src[0];
2224 dst[1] = src[1];
2225 dst[2] = src[2];
2226 src += 4;
2227 dst += 3;
2228 }
2229 return;
2230 }
2231 }
2232 else if (dstFormat == srcFormat) {
2233 GLint comps = _mesa_components_in_format(srcFormat);
2234 assert(comps > 0);
2235 MEMCPY( dest, source, n * comps * sizeof(GLubyte) );
2236 return;
2237 }
2238 }
2239
2240
2241 /* general solution begins here */
2242 {
2243 GLfloat rgba[MAX_WIDTH][4];
2244 GLint dstComponents;
2245 GLint dstRedIndex, dstGreenIndex, dstBlueIndex, dstAlphaIndex;
2246 GLint dstLuminanceIndex, dstIntensityIndex;
2247
2248 dstComponents = _mesa_components_in_format( dstFormat );
2249 /* source & dest image formats should have been error checked by now */
2250 assert(dstComponents > 0);
2251
2252 /*
2253 * Extract image data and convert to RGBA floats
2254 */
2255 assert(n <= MAX_WIDTH);
2256 if (srcFormat == GL_COLOR_INDEX) {
2257 GLuint indexes[MAX_WIDTH];
2258 extract_uint_indexes(n, indexes, srcFormat, srcType, source,
2259 unpacking);
2260
2261 /* shift and offset indexes */
2262 _mesa_shift_and_offset_ci(ctx, n, indexes);
2263
2264 if (dstFormat == GL_COLOR_INDEX) {
2265 if (applyTransferOps) {
2266 if (ctx->Pixel.MapColorFlag) {
2267 /* Apply lookup table */
2268 _mesa_map_ci(ctx, n, indexes);
2269 }
2270 if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset) {
2271 _mesa_shift_and_offset_ci(ctx, n, indexes);
2272 }
2273 }
2274 /* convert to GLubyte and return */
2275 {
2276 GLuint i;
2277 for (i = 0; i < n; i++) {
2278 dest[i] = (GLubyte) (indexes[i] & 0xff);
2279 }
2280 }
2281 }
2282 else {
2283 /* Convert indexes to RGBA */
2284 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
2285 }
2286 }
2287 else {
2288 extract_float_rgba(n, rgba, srcFormat, srcType, source,
2289 unpacking->SwapBytes);
2290
2291 if (applyTransferOps) {
2292 /* scale and bias colors */
2293 _mesa_scale_and_bias_rgba(ctx, n, rgba);
2294 /* color map lookup */
2295 if (ctx->Pixel.MapColorFlag) {
2296 _mesa_map_rgba(ctx, n, rgba);
2297 }
2298 /* GL_COLOR_TABLE lookup */
2299 if (ctx->Pixel.ColorTableEnabled) {
2300 _mesa_lookup_rgba(&ctx->ColorTable, n, rgba);
2301 }
2302 /* XXX convolution here */
2303 /* XXX post-convolution color table look-up here */
2304 /* color matrix transform */
2305 if (ctx->ColorMatrix.type != MATRIX_IDENTITY ||
2306 ctx->Pixel.ScaleOrBiasRGBApcm) {
2307 _mesa_transform_rgba(ctx, n, rgba);
2308 }
2309 /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
2310 if (ctx->Pixel.PostColorMatrixColorTableEnabled) {
2311 _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, n, rgba);
2312 }
2313 /* XXX histogram here */
2314 /* XXX min/max here */
2315 }
2316 }
2317
2318 /* clamp to [0,1] */
2319 {
2320 GLuint i;
2321 for (i = 0; i < n; i++) {
2322 rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F);
2323 rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F);
2324 rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F);
2325 rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F);
2326 }
2327 }
2328
2329 /* Now determine which color channels we need to produce.
2330 * And determine the dest index (offset) within each color tuple.
2331 */
2332 switch (dstFormat) {
2333 case GL_ALPHA:
2334 dstAlphaIndex = 0;
2335 dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
2336 dstLuminanceIndex = dstIntensityIndex = -1;
2337 break;
2338 case GL_LUMINANCE:
2339 dstLuminanceIndex = 0;
2340 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
2341 dstIntensityIndex = -1;
2342 break;
2343 case GL_LUMINANCE_ALPHA:
2344 dstLuminanceIndex = 0;
2345 dstAlphaIndex = 1;
2346 dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
2347 dstIntensityIndex = -1;
2348 break;
2349 case GL_INTENSITY:
2350 dstIntensityIndex = 0;
2351 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
2352 dstLuminanceIndex = -1;
2353 break;
2354 case GL_RGB:
2355 dstRedIndex = 0;
2356 dstGreenIndex = 1;
2357 dstBlueIndex = 2;
2358 dstAlphaIndex = dstLuminanceIndex = dstIntensityIndex = -1;
2359 break;
2360 case GL_RGBA:
2361 dstRedIndex = 0;
2362 dstGreenIndex = 1;
2363 dstBlueIndex = 2;
2364 dstAlphaIndex = 3;
2365 dstLuminanceIndex = dstIntensityIndex = -1;
2366 break;
2367 default:
2368 gl_problem(ctx, "bad dstFormat in _mesa_unpack_ubyte_span()");
2369 return;
2370 }
2371
2372
2373 /* Now return the GLubyte data in the requested dstFormat */
2374
2375 if (dstRedIndex >= 0) {
2376 GLubyte *dst = dest;
2377 GLuint i;
2378 for (i = 0; i < n; i++) {
2379 dst[dstRedIndex] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
2380 dst += dstComponents;
2381 }
2382 }
2383
2384 if (dstGreenIndex >= 0) {
2385 GLubyte *dst = dest;
2386 GLuint i;
2387 for (i = 0; i < n; i++) {
2388 dst[dstGreenIndex] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
2389 dst += dstComponents;
2390 }
2391 }
2392
2393 if (dstBlueIndex >= 0) {
2394 GLubyte *dst = dest;
2395 GLuint i;
2396 for (i = 0; i < n; i++) {
2397 dst[dstBlueIndex] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
2398 dst += dstComponents;
2399 }
2400 }
2401
2402 if (dstAlphaIndex >= 0) {
2403 GLubyte *dst = dest;
2404 GLuint i;
2405 for (i = 0; i < n; i++) {
2406 dst[dstAlphaIndex] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
2407 dst += dstComponents;
2408 }
2409 }
2410
2411 if (dstIntensityIndex >= 0) {
2412 GLubyte *dst = dest;
2413 GLuint i;
2414 assert(dstIntensityIndex == 0);
2415 assert(dstComponents == 1);
2416 for (i = 0; i < n; i++) {
2417 /* Intensity comes from red channel */
2418 dst[i] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
2419 }
2420 }
2421
2422 if (dstLuminanceIndex >= 0) {
2423 GLubyte *dst = dest;
2424 GLuint i;
2425 assert(dstLuminanceIndex == 0);
2426 for (i = 0; i < n; i++) {
2427 /* Luminance comes from red channel */
2428 dst[0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
2429 dst += dstComponents;
2430 }
2431 }
2432 }
2433 }
2434
2435
2436
2437 /*
2438 * Unpack a row of color index data from a client buffer according to
2439 * the pixel unpacking parameters. Apply pixel transfer ops if enabled
2440 * and applyTransferOps is true.
2441 * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.
2442 *
2443 * Args: ctx - the context
2444 * n - number of pixels
2445 * dstType - destination datatype
2446 * dest - destination array
2447 * srcType - source pixel type
2448 * source - source data pointer
2449 * unpacking - pixel unpacking parameters
2450 * applyTransferOps - apply offset/bias/lookup ops?
2451 */
2452 void
2453 _mesa_unpack_index_span( const GLcontext *ctx, GLuint n,
2454 GLenum dstType, GLvoid *dest,
2455 GLenum srcType, const GLvoid *source,
2456 const struct gl_pixelstore_attrib *unpacking,
2457 GLboolean applyTransferOps )
2458 {
2459 ASSERT(srcType == GL_BITMAP ||
2460 srcType == GL_UNSIGNED_BYTE ||
2461 srcType == GL_BYTE ||
2462 srcType == GL_UNSIGNED_SHORT ||
2463 srcType == GL_SHORT ||
2464 srcType == GL_UNSIGNED_INT ||
2465 srcType == GL_INT ||
2466 srcType == GL_FLOAT);
2467
2468 ASSERT(dstType == GL_UNSIGNED_BYTE ||
2469 dstType == GL_UNSIGNED_SHORT ||
2470 dstType == GL_UNSIGNED_INT);
2471
2472 applyTransferOps &= (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset || ctx->Pixel.MapColorFlag);
2473
2474 /*
2475 * Try simple cases first
2476 */
2477 if (!applyTransferOps && srcType == GL_UNSIGNED_BYTE
2478 && dstType == GL_UNSIGNED_BYTE) {
2479 MEMCPY(dest, source, n * sizeof(GLubyte));
2480 }
2481 else if (!applyTransferOps && srcType == GL_UNSIGNED_INT
2482 && dstType == GL_UNSIGNED_INT && !unpacking->SwapBytes) {
2483 MEMCPY(dest, source, n * sizeof(GLuint));
2484 }
2485 else {
2486 /*
2487 * general solution
2488 */
2489 GLuint indexes[MAX_WIDTH];
2490 assert(n <= MAX_WIDTH);
2491
2492 extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
2493 unpacking);
2494
2495 if (applyTransferOps) {
2496 if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset) {
2497 /* shift and offset indexes */
2498 _mesa_shift_and_offset_ci(ctx, n, indexes);
2499 }
2500 if (ctx->Pixel.MapColorFlag) {
2501 /* Apply lookup table */
2502 _mesa_map_ci(ctx, n, indexes);
2503 }
2504 }
2505
2506 /* convert to dest type */
2507 switch (dstType) {
2508 case GL_UNSIGNED_BYTE:
2509 {
2510 GLubyte *dst = (GLubyte *) dest;
2511 GLuint i;
2512 for (i = 0; i < n; i++) {
2513 dst[i] = (GLubyte) (indexes[i] & 0xff);
2514 }
2515 }
2516 break;
2517 case GL_UNSIGNED_SHORT:
2518 {
2519 GLuint *dst = (GLuint *) dest;
2520 GLuint i;
2521 for (i = 0; i < n; i++) {
2522 dst[i] = (GLushort) (indexes[i] & 0xffff);
2523 }
2524 }
2525 break;
2526 case GL_UNSIGNED_INT:
2527 MEMCPY(dest, indexes, n * sizeof(GLuint));
2528 break;
2529 default:
2530 gl_problem(ctx, "bad dstType in _mesa_unpack_index_span");
2531 }
2532 }
2533 }
2534
2535
2536 /*
2537 * Unpack a row of stencil data from a client buffer according to
2538 * the pixel unpacking parameters. Apply pixel transfer ops if enabled
2539 * and applyTransferOps is true.
2540 * This is (or will be) used by glDrawPixels
2541 *
2542 * Args: ctx - the context
2543 * n - number of pixels
2544 * dstType - destination datatype
2545 * dest - destination array
2546 * srcType - source pixel type
2547 * source - source data pointer
2548 * unpacking - pixel unpacking parameters
2549 * applyTransferOps - apply offset/bias/lookup ops?
2550 */
2551 void
2552 _mesa_unpack_stencil_span( const GLcontext *ctx, GLuint n,
2553 GLenum dstType, GLvoid *dest,
2554 GLenum srcType, const GLvoid *source,
2555 const struct gl_pixelstore_attrib *unpacking,
2556 GLboolean applyTransferOps )
2557 {
2558 ASSERT(srcType == GL_BITMAP ||
2559 srcType == GL_UNSIGNED_BYTE ||
2560 srcType == GL_BYTE ||
2561 srcType == GL_UNSIGNED_SHORT ||
2562 srcType == GL_SHORT ||
2563 srcType == GL_UNSIGNED_INT ||
2564 srcType == GL_INT ||
2565 srcType == GL_FLOAT);
2566
2567 ASSERT(dstType == GL_UNSIGNED_BYTE ||
2568 dstType == GL_UNSIGNED_SHORT ||
2569 dstType == GL_UNSIGNED_INT);
2570
2571 applyTransferOps &= (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset || ctx->Pixel.MapColorFlag);
2572
2573 /*
2574 * Try simple cases first
2575 */
2576 if (!applyTransferOps && srcType == GL_UNSIGNED_BYTE
2577 && dstType == GL_UNSIGNED_BYTE) {
2578 MEMCPY(dest, source, n * sizeof(GLubyte));
2579 }
2580 else if (!applyTransferOps && srcType == GL_UNSIGNED_INT
2581 && dstType == GL_UNSIGNED_INT && !unpacking->SwapBytes) {
2582 MEMCPY(dest, source, n * sizeof(GLuint));
2583 }
2584 else {
2585 /*
2586 * general solution
2587 */
2588 GLuint indexes[MAX_WIDTH];
2589 assert(n <= MAX_WIDTH);
2590
2591 extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
2592 unpacking);
2593
2594 if (applyTransferOps) {
2595 if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset) {
2596 /* shift and offset indexes */
2597 _mesa_shift_and_offset_ci(ctx, n, indexes);
2598 }
2599
2600 if (ctx->Pixel.MapStencilFlag) {
2601 /* Apply stencil lookup table */
2602 GLuint mask = ctx->Pixel.MapStoSsize - 1;
2603 GLuint i;
2604 for (i=0;i<n;i++) {
2605 indexes[i] = ctx->Pixel.MapStoS[ indexes[i] & mask ];
2606 }
2607 }
2608 }
2609
2610 /* convert to dest type */
2611 switch (dstType) {
2612 case GL_UNSIGNED_BYTE:
2613 {
2614 GLubyte *dst = (GLubyte *) dest;
2615 GLuint i;
2616 for (i = 0; i < n; i++) {
2617 dst[i] = (GLubyte) (indexes[i] & 0xff);
2618 }
2619 }
2620 break;
2621 case GL_UNSIGNED_SHORT:
2622 {
2623 GLuint *dst = (GLuint *) dest;
2624 GLuint i;
2625 for (i = 0; i < n; i++) {
2626 dst[i] = (GLushort) (indexes[i] & 0xffff);
2627 }
2628 }
2629 break;
2630 case GL_UNSIGNED_INT:
2631 MEMCPY(dest, indexes, n * sizeof(GLuint));
2632 break;
2633 default:
2634 gl_problem(ctx, "bad dstType in _mesa_unpack_stencil_span");
2635 }
2636 }
2637 }
2638
2639
2640
2641 void
2642 _mesa_unpack_depth_span( const GLcontext *ctx, GLuint n, GLdepth *dest,
2643 GLenum srcType, const GLvoid *source,
2644 const struct gl_pixelstore_attrib *unpacking,
2645 GLboolean applyTransferOps )
2646 {
2647 GLfloat *depth = MALLOC(n * sizeof(GLfloat));
2648 if (!depth)
2649 return;
2650
2651 switch (srcType) {
2652 case GL_BYTE:
2653 {
2654 GLuint i;
2655 const GLubyte *src = (const GLubyte *) source;
2656 for (i = 0; i < n; i++) {
2657 depth[i] = BYTE_TO_FLOAT(src[i]);
2658 }
2659 }
2660 break;
2661 case GL_UNSIGNED_BYTE:
2662 {
2663 GLuint i;
2664 const GLubyte *src = (const GLubyte *) source;
2665 for (i = 0; i < n; i++) {
2666 depth[i] = UBYTE_TO_FLOAT(src[i]);
2667 }
2668 }
2669 break;
2670 case GL_SHORT:
2671 {
2672 GLuint i;
2673 const GLshort *src = (const GLshort *) source;
2674 for (i = 0; i < n; i++) {
2675 depth[i] = SHORT_TO_FLOAT(src[i]);
2676 }
2677 }
2678 break;
2679 case GL_UNSIGNED_SHORT:
2680 {
2681 GLuint i;
2682 const GLushort *src = (const GLushort *) source;
2683 for (i = 0; i < n; i++) {
2684 depth[i] = USHORT_TO_FLOAT(src[i]);
2685 }
2686 }
2687 break;
2688 case GL_INT:
2689 {
2690 GLuint i;
2691 const GLint *src = (const GLint *) source;
2692 for (i = 0; i < n; i++) {
2693 depth[i] = INT_TO_FLOAT(src[i]);
2694 }
2695 }
2696 break;
2697 case GL_UNSIGNED_INT:
2698 {
2699 GLuint i;
2700 const GLuint *src = (const GLuint *) source;
2701 for (i = 0; i < n; i++) {
2702 depth[i] = UINT_TO_FLOAT(src[i]);
2703 }
2704 }
2705 break;
2706 case GL_FLOAT:
2707 MEMCPY(depth, source, n * sizeof(GLfloat));
2708 break;
2709 default:
2710 gl_problem(NULL, "bad type in _mesa_unpack_depth_span()");
2711 return;
2712 }
2713
2714
2715 /* apply depth scale and bias */
2716 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
2717 GLuint i;
2718 for (i = 0; i < n; i++) {
2719 depth[i] = depth[i] * ctx->Pixel.DepthScale + ctx->Pixel.DepthBias;
2720 }
2721 }
2722
2723 /* clamp depth values to [0,1] and convert from floats to integers */
2724 {
2725 const GLfloat zs = ctx->Visual->DepthMaxF;
2726 GLuint i;
2727 for (i = 0; i < n; i++) {
2728 dest[i] = (GLdepth) (CLAMP(depth[i], 0.0F, 1.0F) * zs);
2729 }
2730 }
2731
2732 FREE(depth);
2733 }
2734
2735
2736
2737 /*
2738 * Unpack image data. Apply byteswapping, byte flipping (bitmap).
2739 * Return all image data in a contiguous block.
2740 */
2741 void *
2742 _mesa_unpack_image( GLsizei width, GLsizei height, GLsizei depth,
2743 GLenum format, GLenum type, const GLvoid *pixels,
2744 const struct gl_pixelstore_attrib *unpack )
2745 {
2746 GLint bytesPerRow, compsPerRow;
2747 GLboolean flipBytes, swap2, swap4;
2748
2749 if (!pixels)
2750 return NULL; /* not necessarily an error */
2751
2752 if (width <= 0 || height <= 0 || depth <= 0)
2753 return NULL; /* generate error later */
2754
2755 if (format == GL_BITMAP) {
2756 bytesPerRow = (width + 7) >> 3;
2757 flipBytes = !unpack->LsbFirst;
2758 swap2 = swap4 = GL_FALSE;
2759 compsPerRow = 0;
2760 }
2761 else {
2762 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
2763 const GLint components = _mesa_components_in_format(format);
2764 GLint bytesPerComp;
2765 if (bytesPerPixel <= 0 || components <= 0)
2766 return NULL; /* bad format or type. generate error later */
2767 bytesPerRow = bytesPerPixel * width;
2768 bytesPerComp = bytesPerPixel / components;
2769 flipBytes = GL_FALSE;
2770 swap2 = (bytesPerComp == 2) && unpack->SwapBytes;
2771 swap4 = (bytesPerComp == 4) && unpack->SwapBytes;
2772 compsPerRow = components * width;
2773 assert(compsPerRow >= width);
2774 }
2775
2776 {
2777 GLubyte *destBuffer = MALLOC(bytesPerRow * height * depth);
2778 GLubyte *dst;
2779 GLint img, row;
2780 if (!destBuffer)
2781 return NULL; /* generate GL_OUT_OF_MEMORY later */
2782
2783 dst = destBuffer;
2784 for (img = 0; img < depth; img++) {
2785 for (row = 0; row < height; row++) {
2786 const GLvoid *src = _mesa_image_address(unpack, pixels,
2787 width, height, format, type, img, row, 0);
2788 MEMCPY(dst, src, bytesPerRow);
2789 /* byte flipping/swapping */
2790 if (flipBytes) {
2791 flip_bytes((GLubyte *) dst, bytesPerRow);
2792 }
2793 else if (swap2) {
2794 _mesa_swap2((GLushort*) dst, compsPerRow);
2795 }
2796 else if (swap4) {
2797 _mesa_swap4((GLuint*) dst, compsPerRow);
2798 }
2799 dst += bytesPerRow;
2800 }
2801 }
2802 return destBuffer;
2803 }
2804 }
2805
2806
2807 /*
2808 * Unpack bitmap data. Resulting data will be in most-significant-bit-first
2809 * order with row alignment = 1 byte.
2810 */
2811 GLvoid *
2812 _mesa_unpack_bitmap( GLint width, GLint height, const GLubyte *pixels,
2813 const struct gl_pixelstore_attrib *packing )
2814 {
2815 GLint bytes, row, width_in_bytes;
2816 GLubyte *buffer, *dst;
2817
2818 if (!pixels)
2819 return NULL;
2820
2821 /* Alloc dest storage */
2822 bytes = ((width + 7) / 8 * height);
2823 buffer = (GLubyte *) MALLOC( bytes );
2824 if (!buffer)
2825 return NULL;
2826
2827
2828 width_in_bytes = CEILING( width, 8 );
2829 dst = buffer;
2830 for (row = 0; row < height; row++) {
2831 GLubyte *src = _mesa_image_address( packing, pixels, width, height,
2832 GL_COLOR_INDEX, GL_BITMAP,
2833 0, row, 0 );
2834 if (!src) {
2835 FREE(buffer);
2836 return NULL;
2837 }
2838
2839 if (packing->SkipPixels == 0) {
2840 MEMCPY( dst, src, width_in_bytes );
2841 if (packing->LsbFirst) {
2842 flip_bytes( dst, width_in_bytes );
2843 }
2844 }
2845 else {
2846 /* handling SkipPixels is a bit tricky (no pun intended!) */
2847 GLint i;
2848 if (packing->LsbFirst) {
2849 GLubyte srcMask = 1 << (packing->SkipPixels & 0x7);
2850 GLubyte dstMask = 128;
2851 GLubyte *s = src;
2852 GLubyte *d = dst;
2853 *d = 0;
2854 for (i = 0; i < width; i++) {
2855 if (*s & srcMask) {
2856 *d |= dstMask;
2857 }
2858 if (srcMask == 128) {
2859 srcMask = 1;
2860 s++;
2861 }
2862 else {
2863 srcMask = srcMask << 1;
2864 }
2865 if (dstMask == 1) {
2866 dstMask = 128;
2867 d++;
2868 *d = 0;
2869 }
2870 else {
2871 dstMask = dstMask >> 1;
2872 }
2873 }
2874 }
2875 else {
2876 GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7);
2877 GLubyte dstMask = 128;
2878 GLubyte *s = src;
2879 GLubyte *d = dst;
2880 *d = 0;
2881 for (i = 0; i < width; i++) {
2882 if (*s & srcMask) {
2883 *d |= dstMask;
2884 }
2885 if (srcMask == 1) {
2886 srcMask = 128;
2887 s++;
2888 }
2889 else {
2890 srcMask = srcMask >> 1;
2891 }
2892 if (dstMask == 1) {
2893 dstMask = 128;
2894 d++;
2895 *d = 0;
2896 }
2897 else {
2898 dstMask = dstMask >> 1;
2899 }
2900 }
2901 }
2902 }
2903 dst += width_in_bytes;
2904 }
2905
2906 return buffer;
2907 }
2908
2909
2910 /*
2911 * Pack bitmap data.
2912 */
2913 void
2914 _mesa_pack_bitmap( GLint width, GLint height, const GLubyte *source,
2915 GLubyte *dest, const struct gl_pixelstore_attrib *packing )
2916 {
2917 GLint row, width_in_bytes;
2918 const GLubyte *src;
2919
2920 if (!source)
2921 return;
2922
2923 width_in_bytes = CEILING( width, 8 );
2924 src = source;
2925 for (row = 0; row < height; row++) {
2926 GLubyte *dst = _mesa_image_address( packing, dest, width, height,
2927 GL_COLOR_INDEX, GL_BITMAP,
2928 0, row, 0 );
2929 if (!dst)
2930 return;
2931
2932 if (packing->SkipPixels == 0) {
2933 MEMCPY( dst, src, width_in_bytes );
2934 if (packing->LsbFirst) {
2935 flip_bytes( dst, width_in_bytes );
2936 }
2937 }
2938 else {
2939 /* handling SkipPixels is a bit tricky (no pun intended!) */
2940 GLint i;
2941 if (packing->LsbFirst) {
2942 GLubyte srcMask = 1 << (packing->SkipPixels & 0x7);
2943 GLubyte dstMask = 128;
2944 const GLubyte *s = src;
2945 GLubyte *d = dst;
2946 *d = 0;
2947 for (i = 0; i < width; i++) {
2948 if (*s & srcMask) {
2949 *d |= dstMask;
2950 }
2951 if (srcMask == 128) {
2952 srcMask = 1;
2953 s++;
2954 }
2955 else {
2956 srcMask = srcMask << 1;
2957 }
2958 if (dstMask == 1) {
2959 dstMask = 128;
2960 d++;
2961 *d = 0;
2962 }
2963 else {
2964 dstMask = dstMask >> 1;
2965 }
2966 }
2967 }
2968 else {
2969 GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7);
2970 GLubyte dstMask = 128;
2971 const GLubyte *s = src;
2972 GLubyte *d = dst;
2973 *d = 0;
2974 for (i = 0; i < width; i++) {
2975 if (*s & srcMask) {
2976 *d |= dstMask;
2977 }
2978 if (srcMask == 1) {
2979 srcMask = 128;
2980 s++;
2981 }
2982 else {
2983 srcMask = srcMask >> 1;
2984 }
2985 if (dstMask == 1) {
2986 dstMask = 128;
2987 d++;
2988 *d = 0;
2989 }
2990 else {
2991 dstMask = dstMask >> 1;
2992 }
2993 }
2994 }
2995 }
2996 src += width_in_bytes;
2997 }
2998 }