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