projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Committing in .
[mesa.git] / src / mesa / main / image.c
1 /* $Id: image.c,v 1.49 2000/11/22 07:32:17 joukj Exp $ */
2
3 /*
4 * Mesa 3-D graphics library
5 * Version: 3.5
6 *
7 * Copyright (C) 1999-2000 Brian Paul All Rights Reserved.
8 *
9 * Permission is hereby granted, free of charge, to any person obtaining a
10 * copy of this software and associated documentation files (the "Software"),
11 * to deal in the Software without restriction, including without limitation
12 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
13 * and/or sell copies of the Software, and to permit persons to whom the
14 * Software is furnished to do so, subject to the following conditions:
15 *
16 * The above copyright notice and this permission notice shall be included
17 * in all copies or substantial portions of the Software.
18 *
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
20 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
22 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
23 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
24 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 */
26
27
28 #ifdef PC_HEADER
29 #include "all.h"
30 #else
31 #include "glheader.h"
32 #include "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(GLshort);
188 case GL_UNSIGNED_SHORT_5_6_5_REV:
189 return sizeof(GLshort);
190 case GL_UNSIGNED_SHORT_4_4_4_4:
191 return sizeof(GLshort);
192 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
193 return sizeof(GLshort);
194 case GL_UNSIGNED_SHORT_5_5_5_1:
195 return sizeof(GLshort);
196 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
197 return sizeof(GLshort);
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(GLshort);
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 * Unpack a 32x32 pixel polygon stipple from user memory using the
549 * current pixel unpack settings.
550 */
551 void
552 _mesa_unpack_polygon_stipple( const GLubyte *pattern, GLuint dest[32],
553 const struct gl_pixelstore_attrib *unpacking )
554 {
555 GLubyte *ptrn = (GLubyte *) _mesa_unpack_bitmap( 32, 32, pattern, unpacking );
556 if (ptrn) {
557 /* Convert pattern from GLubytes to GLuints and handle big/little
558 * endian differences
559 */
560 GLubyte *p = ptrn;
561 GLint i;
562 for (i = 0; i < 32; i++) {
563 dest[i] = (p[0] << 24)
564 | (p[1] << 16)
565 | (p[2] << 8)
566 | (p[3] );
567 p += 4;
568 }
569 FREE(ptrn);
570 }
571 }
572
573
574
575 /*
576 * Pack polygon stipple into user memory given current pixel packing
577 * settings.
578 */
579 void
580 _mesa_pack_polygon_stipple( const GLuint pattern[32], GLubyte *dest,
581 const struct gl_pixelstore_attrib *packing )
582 {
583 /* Convert pattern from GLuints to GLubytes to handle big/little
584 * endian differences.
585 */
586 GLubyte ptrn[32*4];
587 GLint i;
588 for (i = 0; i < 32; i++) {
589 ptrn[i * 4 + 0] = (GLubyte) ((pattern[i] >> 24) & 0xff);
590 ptrn[i * 4 + 1] = (GLubyte) ((pattern[i] >> 16) & 0xff);
591 ptrn[i * 4 + 2] = (GLubyte) ((pattern[i] >> 8 ) & 0xff);
592 ptrn[i * 4 + 3] = (GLubyte) ((pattern[i] ) & 0xff);
593 }
594
595 _mesa_pack_bitmap(32, 32, ptrn, dest, packing);
596 }
597
598
599 /*
600 * Unpack bitmap data. Resulting data will be in most-significant-bit-first
601 * order with row alignment = 1 byte.
602 */
603 GLvoid *
604 _mesa_unpack_bitmap( GLint width, GLint height, const GLubyte *pixels,
605 const struct gl_pixelstore_attrib *packing )
606 {
607 GLint bytes, row, width_in_bytes;
608 GLubyte *buffer, *dst;
609
610 if (!pixels)
611 return NULL;
612
613 /* Alloc dest storage */
614 bytes = ((width + 7) / 8 * height);
615 buffer = (GLubyte *) MALLOC( bytes );
616 if (!buffer)
617 return NULL;
618
619
620 width_in_bytes = CEILING( width, 8 );
621 dst = buffer;
622 for (row = 0; row < height; row++) {
623 GLubyte *src = _mesa_image_address( packing, pixels, width, height,
624 GL_COLOR_INDEX, GL_BITMAP,
625 0, row, 0 );
626 if (!src) {
627 FREE(buffer);
628 return NULL;
629 }
630
631 if (packing->SkipPixels == 0) {
632 MEMCPY( dst, src, width_in_bytes );
633 if (packing->LsbFirst) {
634 flip_bytes( dst, width_in_bytes );
635 }
636 }
637 else {
638 /* handling SkipPixels is a bit tricky (no pun intended!) */
639 GLint i;
640 if (packing->LsbFirst) {
641 GLubyte srcMask = 1 << (packing->SkipPixels & 0x7);
642 GLubyte dstMask = 128;
643 GLubyte *s = src;
644 GLubyte *d = dst;
645 *d = 0;
646 for (i = 0; i < width; i++) {
647 if (*s & srcMask) {
648 *d |= dstMask;
649 }
650 if (srcMask == 128) {
651 srcMask = 1;
652 s++;
653 }
654 else {
655 srcMask = srcMask << 1;
656 }
657 if (dstMask == 1) {
658 dstMask = 128;
659 d++;
660 *d = 0;
661 }
662 else {
663 dstMask = dstMask >> 1;
664 }
665 }
666 }
667 else {
668 GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7);
669 GLubyte dstMask = 128;
670 GLubyte *s = src;
671 GLubyte *d = dst;
672 *d = 0;
673 for (i = 0; i < width; i++) {
674 if (*s & srcMask) {
675 *d |= dstMask;
676 }
677 if (srcMask == 1) {
678 srcMask = 128;
679 s++;
680 }
681 else {
682 srcMask = srcMask >> 1;
683 }
684 if (dstMask == 1) {
685 dstMask = 128;
686 d++;
687 *d = 0;
688 }
689 else {
690 dstMask = dstMask >> 1;
691 }
692 }
693 }
694 }
695 dst += width_in_bytes;
696 }
697
698 return buffer;
699 }
700
701
702 /*
703 * Pack bitmap data.
704 */
705 void
706 _mesa_pack_bitmap( GLint width, GLint height, const GLubyte *source,
707 GLubyte *dest, const struct gl_pixelstore_attrib *packing )
708 {
709 GLint row, width_in_bytes;
710 const GLubyte *src;
711
712 if (!source)
713 return;
714
715 width_in_bytes = CEILING( width, 8 );
716 src = source;
717 for (row = 0; row < height; row++) {
718 GLubyte *dst = _mesa_image_address( packing, dest, width, height,
719 GL_COLOR_INDEX, GL_BITMAP,
720 0, row, 0 );
721 if (!dst)
722 return;
723
724 if (packing->SkipPixels == 0) {
725 MEMCPY( dst, src, width_in_bytes );
726 if (packing->LsbFirst) {
727 flip_bytes( dst, width_in_bytes );
728 }
729 }
730 else {
731 /* handling SkipPixels is a bit tricky (no pun intended!) */
732 GLint i;
733 if (packing->LsbFirst) {
734 GLubyte srcMask = 1 << (packing->SkipPixels & 0x7);
735 GLubyte dstMask = 128;
736 const GLubyte *s = src;
737 GLubyte *d = dst;
738 *d = 0;
739 for (i = 0; i < width; i++) {
740 if (*s & srcMask) {
741 *d |= dstMask;
742 }
743 if (srcMask == 128) {
744 srcMask = 1;
745 s++;
746 }
747 else {
748 srcMask = srcMask << 1;
749 }
750 if (dstMask == 1) {
751 dstMask = 128;
752 d++;
753 *d = 0;
754 }
755 else {
756 dstMask = dstMask >> 1;
757 }
758 }
759 }
760 else {
761 GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7);
762 GLubyte dstMask = 128;
763 const GLubyte *s = src;
764 GLubyte *d = dst;
765 *d = 0;
766 for (i = 0; i < width; i++) {
767 if (*s & srcMask) {
768 *d |= dstMask;
769 }
770 if (srcMask == 1) {
771 srcMask = 128;
772 s++;
773 }
774 else {
775 srcMask = srcMask >> 1;
776 }
777 if (dstMask == 1) {
778 dstMask = 128;
779 d++;
780 *d = 0;
781 }
782 else {
783 dstMask = dstMask >> 1;
784 }
785 }
786 }
787 }
788 src += width_in_bytes;
789 }
790 }
791
792
793
794 void
795 _mesa_pack_float_rgba_span( GLcontext *ctx,
796 GLuint n, CONST GLfloat rgbaIn[][4],
797 GLenum dstFormat, GLenum dstType,
798 GLvoid *dstAddr,
799 const struct gl_pixelstore_attrib *dstPacking,
800 GLuint transferOps )
801 {
802 const GLint comps = _mesa_components_in_format(dstFormat);
803 GLfloat luminance[MAX_WIDTH];
804 GLfloat (*rgba)[4];
805 GLuint i;
806
807 if (transferOps) {
808 /* make copy of incoming data */
809 GLfloat rgbaCopy[MAX_WIDTH][4];
810 for (i = 0; i < n; i++) {
811 rgbaCopy[i][0] = rgbaIn[i][0];
812 rgbaCopy[i][1] = rgbaIn[i][1];
813 rgbaCopy[i][2] = rgbaIn[i][2];
814 rgbaCopy[i][3] = rgbaIn[i][3];
815 }
816
817 rgba = (GLfloat (*)[4]) rgbaCopy;
818
819 /* scale & bias */
820 if (transferOps & IMAGE_SCALE_BIAS_BIT) {
821 _mesa_scale_and_bias_rgba( ctx, n, rgba );
822 }
823 /* color map lookup */
824 if (transferOps & IMAGE_MAP_COLOR_BIT) {
825 _mesa_map_rgba( ctx, n, rgba );
826 }
827 /* GL_COLOR_TABLE lookup */
828 if (transferOps & IMAGE_COLOR_TABLE_BIT) {
829 _mesa_lookup_rgba(&ctx->ColorTable, n, rgba);
830 }
831 /* convolution */
832 if (transferOps & IMAGE_CONVOLUTION_BIT) {
833 /* this has to be done in the calling code */
834 }
835 /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
836 if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) {
837 _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, n, rgba);
838 }
839 /* color matrix transform */
840 if (transferOps & IMAGE_COLOR_MATRIX_BIT) {
841 _mesa_transform_rgba(ctx, n, rgba);
842 }
843 /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
844 if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) {
845 _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, n, rgba);
846 }
847 /* update histogram count */
848 if (transferOps & IMAGE_HISTOGRAM_BIT) {
849 _mesa_update_histogram(ctx, n, (CONST GLfloat (*)[4]) rgba);
850 }
851 /* min/max here */
852 if (transferOps & IMAGE_MIN_MAX_BIT) {
853 _mesa_update_minmax(ctx, n, (CONST GLfloat (*)[4]) rgba);
854 if (ctx->MinMax.Sink)
855 return;
856 }
857 }
858 else {
859 /* use incoming data, not a copy */
860 rgba = (GLfloat (*)[4]) rgbaIn;
861 }
862
863 /* XXX clamp rgba to [0,1]? */
864
865
866 if (dstFormat == GL_LUMINANCE || dstFormat == GL_LUMINANCE_ALPHA) {
867 for (i = 0; i < n; i++) {
868 GLfloat sum = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
869 luminance[i] = CLAMP(sum, 0.0F, 1.0F);
870 }
871 }
872
873 /*
874 * Pack/store the pixels. Ugh! Lots of cases!!!
875 */
876 switch (dstType) {
877 case GL_UNSIGNED_BYTE:
878 {
879 GLubyte *dst = (GLubyte *) dstAddr;
880 switch (dstFormat) {
881 case GL_RED:
882 for (i=0;i<n;i++)
883 dst[i] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
884 break;
885 case GL_GREEN:
886 for (i=0;i<n;i++)
887 dst[i] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
888 break;
889 case GL_BLUE:
890 for (i=0;i<n;i++)
891 dst[i] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
892 break;
893 case GL_ALPHA:
894 for (i=0;i<n;i++)
895 dst[i] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
896 break;
897 case GL_LUMINANCE:
898 for (i=0;i<n;i++)
899 dst[i] = FLOAT_TO_UBYTE(luminance[i]);
900 break;
901 case GL_LUMINANCE_ALPHA:
902 for (i=0;i<n;i++) {
903 dst[i*2+0] = FLOAT_TO_UBYTE(luminance[i]);
904 dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
905 }
906 break;
907 case GL_RGB:
908 for (i=0;i<n;i++) {
909 dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
910 dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
911 dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
912 }
913 break;
914 case GL_RGBA:
915 for (i=0;i<n;i++) {
916 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
917 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
918 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
919 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
920 }
921 break;
922 case GL_BGR:
923 for (i=0;i<n;i++) {
924 dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
925 dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
926 dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
927 }
928 break;
929 case GL_BGRA:
930 for (i=0;i<n;i++) {
931 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
932 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
933 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
934 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
935 }
936 break;
937 case GL_ABGR_EXT:
938 for (i=0;i<n;i++) {
939 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
940 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
941 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
942 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
943 }
944 break;
945 default:
946 gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
947 }
948 }
949 break;
950 case GL_BYTE:
951 {
952 GLbyte *dst = (GLbyte *) dstAddr;
953 switch (dstFormat) {
954 case GL_RED:
955 for (i=0;i<n;i++)
956 dst[i] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
957 break;
958 case GL_GREEN:
959 for (i=0;i<n;i++)
960 dst[i] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
961 break;
962 case GL_BLUE:
963 for (i=0;i<n;i++)
964 dst[i] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
965 break;
966 case GL_ALPHA:
967 for (i=0;i<n;i++)
968 dst[i] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
969 break;
970 case GL_LUMINANCE:
971 for (i=0;i<n;i++)
972 dst[i] = FLOAT_TO_BYTE(luminance[i]);
973 break;
974 case GL_LUMINANCE_ALPHA:
975 for (i=0;i<n;i++) {
976 dst[i*2+0] = FLOAT_TO_BYTE(luminance[i]);
977 dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
978 }
979 break;
980 case GL_RGB:
981 for (i=0;i<n;i++) {
982 dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
983 dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
984 dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
985 }
986 break;
987 case GL_RGBA:
988 for (i=0;i<n;i++) {
989 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
990 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
991 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
992 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
993 }
994 break;
995 case GL_BGR:
996 for (i=0;i<n;i++) {
997 dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
998 dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
999 dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
1000 }
1001 break;
1002 case GL_BGRA:
1003 for (i=0;i<n;i++) {
1004 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
1005 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
1006 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
1007 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
1008 }
1009 case GL_ABGR_EXT:
1010 for (i=0;i<n;i++) {
1011 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
1012 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
1013 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
1014 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
1015 }
1016 break;
1017 default:
1018 gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1019 }
1020 }
1021 break;
1022 case GL_UNSIGNED_SHORT:
1023 {
1024 GLushort *dst = (GLushort *) dstAddr;
1025 switch (dstFormat) {
1026 case GL_RED:
1027 for (i=0;i<n;i++)
1028 dst[i] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
1029 break;
1030 case GL_GREEN:
1031 for (i=0;i<n;i++)
1032 dst[i] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
1033 break;
1034 case GL_BLUE:
1035 for (i=0;i<n;i++)
1036 dst[i] = FLOAT_TO_USHORT(rgba[i][BCOMP]);
1037 break;
1038 case GL_ALPHA:
1039 for (i=0;i<n;i++)
1040 dst[i] = FLOAT_TO_USHORT(rgba[i][ACOMP]);
1041 break;
1042 case GL_LUMINANCE:
1043 for (i=0;i<n;i++)
1044 dst[i] = FLOAT_TO_USHORT(luminance[i]);
1045 break;
1046 case GL_LUMINANCE_ALPHA:
1047 for (i=0;i<n;i++) {
1048 dst[i*2+0] = FLOAT_TO_USHORT(luminance[i]);
1049 dst[i*2+1] = FLOAT_TO_USHORT(rgba[i][ACOMP]);
1050 }
1051 break;
1052 case GL_RGB:
1053 for (i=0;i<n;i++) {
1054 dst[i*3+0] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
1055 dst[i*3+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
1056 dst[i*3+2] = FLOAT_TO_USHORT(rgba[i][BCOMP]);
1057 }
1058 break;
1059 case GL_RGBA:
1060 for (i=0;i<n;i++) {
1061 dst[i*4+0] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
1062 dst[i*4+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
1063 dst[i*4+2] = FLOAT_TO_USHORT(rgba[i][BCOMP]);
1064 dst[i*4+3] = FLOAT_TO_USHORT(rgba[i][ACOMP]);
1065 }
1066 break;
1067 case GL_BGR:
1068 for (i=0;i<n;i++) {
1069 dst[i*3+0] = FLOAT_TO_USHORT(rgba[i][BCOMP]);
1070 dst[i*3+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
1071 dst[i*3+2] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
1072 }
1073 break;
1074 case GL_BGRA:
1075 for (i=0;i<n;i++) {
1076 dst[i*4+0] = FLOAT_TO_USHORT(rgba[i][BCOMP]);
1077 dst[i*4+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
1078 dst[i*4+2] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
1079 dst[i*4+3] = FLOAT_TO_USHORT(rgba[i][ACOMP]);
1080 }
1081 break;
1082 case GL_ABGR_EXT:
1083 for (i=0;i<n;i++) {
1084 dst[i*4+0] = FLOAT_TO_USHORT(rgba[i][ACOMP]);
1085 dst[i*4+1] = FLOAT_TO_USHORT(rgba[i][BCOMP]);
1086 dst[i*4+2] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
1087 dst[i*4+3] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
1088 }
1089 break;
1090 default:
1091 gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1092 }
1093 if (dstPacking->SwapBytes) {
1094 _mesa_swap2( (GLushort *) dst, n * comps);
1095 }
1096 }
1097 break;
1098 case GL_SHORT:
1099 {
1100 GLshort *dst = (GLshort *) dstAddr;
1101 switch (dstFormat) {
1102 case GL_RED:
1103 for (i=0;i<n;i++)
1104 dst[i] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1105 break;
1106 case GL_GREEN:
1107 for (i=0;i<n;i++)
1108 dst[i] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1109 break;
1110 case GL_BLUE:
1111 for (i=0;i<n;i++)
1112 dst[i] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1113 break;
1114 case GL_ALPHA:
1115 for (i=0;i<n;i++)
1116 dst[i] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1117 break;
1118 case GL_LUMINANCE:
1119 for (i=0;i<n;i++)
1120 dst[i] = FLOAT_TO_SHORT(luminance[i]);
1121 break;
1122 case GL_LUMINANCE_ALPHA:
1123 for (i=0;i<n;i++) {
1124 dst[i*2+0] = FLOAT_TO_SHORT(luminance[i]);
1125 dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1126 }
1127 break;
1128 case GL_RGB:
1129 for (i=0;i<n;i++) {
1130 dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1131 dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1132 dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1133 }
1134 break;
1135 case GL_RGBA:
1136 for (i=0;i<n;i++) {
1137 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1138 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1139 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1140 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1141 }
1142 break;
1143 case GL_BGR:
1144 for (i=0;i<n;i++) {
1145 dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1146 dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1147 dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1148 }
1149 break;
1150 case GL_BGRA:
1151 for (i=0;i<n;i++) {
1152 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1153 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1154 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1155 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1156 }
1157 case GL_ABGR_EXT:
1158 for (i=0;i<n;i++) {
1159 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1160 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1161 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1162 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1163 }
1164 break;
1165 default:
1166 gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1167 }
1168 if (dstPacking->SwapBytes) {
1169 _mesa_swap2( (GLushort *) dst, n * comps );
1170 }
1171 }
1172 break;
1173 case GL_UNSIGNED_INT:
1174 {
1175 GLuint *dst = (GLuint *) dstAddr;
1176 switch (dstFormat) {
1177 case GL_RED:
1178 for (i=0;i<n;i++)
1179 dst[i] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1180 break;
1181 case GL_GREEN:
1182 for (i=0;i<n;i++)
1183 dst[i] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1184 break;
1185 case GL_BLUE:
1186 for (i=0;i<n;i++)
1187 dst[i] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1188 break;
1189 case GL_ALPHA:
1190 for (i=0;i<n;i++)
1191 dst[i] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1192 break;
1193 case GL_LUMINANCE:
1194 for (i=0;i<n;i++)
1195 dst[i] = FLOAT_TO_UINT(luminance[i]);
1196 break;
1197 case GL_LUMINANCE_ALPHA:
1198 for (i=0;i<n;i++) {
1199 dst[i*2+0] = FLOAT_TO_UINT(luminance[i]);
1200 dst[i*2+1] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1201 }
1202 break;
1203 case GL_RGB:
1204 for (i=0;i<n;i++) {
1205 dst[i*3+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1206 dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1207 dst[i*3+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1208 }
1209 break;
1210 case GL_RGBA:
1211 for (i=0;i<n;i++) {
1212 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1213 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1214 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1215 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1216 }
1217 break;
1218 case GL_BGR:
1219 for (i=0;i<n;i++) {
1220 dst[i*3+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1221 dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1222 dst[i*3+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1223 }
1224 break;
1225 case GL_BGRA:
1226 for (i=0;i<n;i++) {
1227 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1228 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1229 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1230 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1231 }
1232 break;
1233 case GL_ABGR_EXT:
1234 for (i=0;i<n;i++) {
1235 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1236 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1237 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1238 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1239 }
1240 break;
1241 default:
1242 gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1243 }
1244 if (dstPacking->SwapBytes) {
1245 _mesa_swap4( (GLuint *) dst, n * comps );
1246 }
1247 }
1248 break;
1249 case GL_INT:
1250 {
1251 GLint *dst = (GLint *) dstAddr;
1252 switch (dstFormat) {
1253 case GL_RED:
1254 for (i=0;i<n;i++)
1255 dst[i] = FLOAT_TO_INT(rgba[i][RCOMP]);
1256 break;
1257 case GL_GREEN:
1258 for (i=0;i<n;i++)
1259 dst[i] = FLOAT_TO_INT(rgba[i][GCOMP]);
1260 break;
1261 case GL_BLUE:
1262 for (i=0;i<n;i++)
1263 dst[i] = FLOAT_TO_INT(rgba[i][BCOMP]);
1264 break;
1265 case GL_ALPHA:
1266 for (i=0;i<n;i++)
1267 dst[i] = FLOAT_TO_INT(rgba[i][ACOMP]);
1268 break;
1269 case GL_LUMINANCE:
1270 for (i=0;i<n;i++)
1271 dst[i] = FLOAT_TO_INT(luminance[i]);
1272 break;
1273 case GL_LUMINANCE_ALPHA:
1274 for (i=0;i<n;i++) {
1275 dst[i*2+0] = FLOAT_TO_INT(luminance[i]);
1276 dst[i*2+1] = FLOAT_TO_INT(rgba[i][ACOMP]);
1277 }
1278 break;
1279 case GL_RGB:
1280 for (i=0;i<n;i++) {
1281 dst[i*3+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
1282 dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1283 dst[i*3+2] = FLOAT_TO_INT(rgba[i][BCOMP]);
1284 }
1285 break;
1286 case GL_RGBA:
1287 for (i=0;i<n;i++) {
1288 dst[i*4+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
1289 dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1290 dst[i*4+2] = FLOAT_TO_INT(rgba[i][BCOMP]);
1291 dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);
1292 }
1293 break;
1294 case GL_BGR:
1295 for (i=0;i<n;i++) {
1296 dst[i*3+0] = FLOAT_TO_INT(rgba[i][BCOMP]);
1297 dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1298 dst[i*3+2] = FLOAT_TO_INT(rgba[i][RCOMP]);
1299 }
1300 break;
1301 case GL_BGRA:
1302 for (i=0;i<n;i++) {
1303 dst[i*4+0] = FLOAT_TO_INT(rgba[i][BCOMP]);
1304 dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1305 dst[i*4+2] = FLOAT_TO_INT(rgba[i][RCOMP]);
1306 dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);
1307 }
1308 break;
1309 case GL_ABGR_EXT:
1310 for (i=0;i<n;i++) {
1311 dst[i*4+0] = FLOAT_TO_INT(rgba[i][ACOMP]);
1312 dst[i*4+1] = FLOAT_TO_INT(rgba[i][BCOMP]);
1313 dst[i*4+2] = FLOAT_TO_INT(rgba[i][GCOMP]);
1314 dst[i*4+3] = FLOAT_TO_INT(rgba[i][RCOMP]);
1315 }
1316 break;
1317 default:
1318 gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1319 }
1320 if (dstPacking->SwapBytes) {
1321 _mesa_swap4( (GLuint *) dst, n * comps );
1322 }
1323 }
1324 break;
1325 case GL_FLOAT:
1326 {
1327 GLfloat *dst = (GLfloat *) dstAddr;
1328 switch (dstFormat) {
1329 case GL_RED:
1330 for (i=0;i<n;i++)
1331 dst[i] = rgba[i][RCOMP];
1332 break;
1333 case GL_GREEN:
1334 for (i=0;i<n;i++)
1335 dst[i] = rgba[i][GCOMP];
1336 break;
1337 case GL_BLUE:
1338 for (i=0;i<n;i++)
1339 dst[i] = rgba[i][BCOMP];
1340 break;
1341 case GL_ALPHA:
1342 for (i=0;i<n;i++)
1343 dst[i] = rgba[i][ACOMP];
1344 break;
1345 case GL_LUMINANCE:
1346 for (i=0;i<n;i++)
1347 dst[i] = luminance[i];
1348 break;
1349 case GL_LUMINANCE_ALPHA:
1350 for (i=0;i<n;i++) {
1351 dst[i*2+0] = luminance[i];
1352 dst[i*2+1] = rgba[i][ACOMP];
1353 }
1354 break;
1355 case GL_RGB:
1356 for (i=0;i<n;i++) {
1357 dst[i*3+0] = rgba[i][RCOMP];
1358 dst[i*3+1] = rgba[i][GCOMP];
1359 dst[i*3+2] = rgba[i][BCOMP];
1360 }
1361 break;
1362 case GL_RGBA:
1363 for (i=0;i<n;i++) {
1364 dst[i*4+0] = rgba[i][RCOMP];
1365 dst[i*4+1] = rgba[i][GCOMP];
1366 dst[i*4+2] = rgba[i][BCOMP];
1367 dst[i*4+3] = rgba[i][ACOMP];
1368 }
1369 break;
1370 case GL_BGR:
1371 for (i=0;i<n;i++) {
1372 dst[i*3+0] = rgba[i][BCOMP];
1373 dst[i*3+1] = rgba[i][GCOMP];
1374 dst[i*3+2] = rgba[i][RCOMP];
1375 }
1376 break;
1377 case GL_BGRA:
1378 for (i=0;i<n;i++) {
1379 dst[i*4+0] = rgba[i][BCOMP];
1380 dst[i*4+1] = rgba[i][GCOMP];
1381 dst[i*4+2] = rgba[i][RCOMP];
1382 dst[i*4+3] = rgba[i][ACOMP];
1383 }
1384 break;
1385 case GL_ABGR_EXT:
1386 for (i=0;i<n;i++) {
1387 dst[i*4+0] = rgba[i][ACOMP];
1388 dst[i*4+1] = rgba[i][BCOMP];
1389 dst[i*4+2] = rgba[i][GCOMP];
1390 dst[i*4+3] = rgba[i][RCOMP];
1391 }
1392 break;
1393 default:
1394 gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1395 }
1396 if (dstPacking->SwapBytes) {
1397 _mesa_swap4( (GLuint *) dst, n * comps );
1398 }
1399 }
1400 break;
1401 case GL_UNSIGNED_BYTE_3_3_2:
1402 if (dstFormat == GL_RGB) {
1403 GLubyte *dst = (GLubyte *) dstAddr;
1404 for (i=0;i<n;i++) {
1405 dst[i] = (((GLint) (rgba[i][RCOMP] * 7.0F)) << 5)
1406 | (((GLint) (rgba[i][GCOMP] * 7.0F)) << 2)
1407 | (((GLint) (rgba[i][BCOMP] * 3.0F)) );
1408 }
1409 }
1410 break;
1411 case GL_UNSIGNED_BYTE_2_3_3_REV:
1412 if (dstFormat == GL_RGB) {
1413 GLubyte *dst = (GLubyte *) dstAddr;
1414 for (i=0;i<n;i++) {
1415 dst[i] = (((GLint) (rgba[i][RCOMP] * 7.0F)) )
1416 | (((GLint) (rgba[i][GCOMP] * 7.0F)) << 3)
1417 | (((GLint) (rgba[i][BCOMP] * 3.0F)) << 5);
1418 }
1419 }
1420 break;
1421 case GL_UNSIGNED_SHORT_5_6_5:
1422 if (dstFormat == GL_RGB) {
1423 GLushort *dst = (GLushort *) dstAddr;
1424 for (i=0;i<n;i++) {
1425 dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) << 11)
1426 | (((GLint) (rgba[i][GCOMP] * 63.0F)) << 5)
1427 | (((GLint) (rgba[i][BCOMP] * 31.0F)) );
1428 }
1429 }
1430 break;
1431 case GL_UNSIGNED_SHORT_5_6_5_REV:
1432 if (dstFormat == GL_RGB) {
1433 GLushort *dst = (GLushort *) dstAddr;
1434 for (i=0;i<n;i++) {
1435 dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) )
1436 | (((GLint) (rgba[i][GCOMP] * 63.0F)) << 5)
1437 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 11);
1438 }
1439 }
1440 break;
1441 case GL_UNSIGNED_SHORT_4_4_4_4:
1442 if (dstFormat == GL_RGBA) {
1443 GLushort *dst = (GLushort *) dstAddr;
1444 for (i=0;i<n;i++) {
1445 dst[i] = (((GLint) (rgba[i][RCOMP] * 15.0F)) << 12)
1446 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 8)
1447 | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 4)
1448 | (((GLint) (rgba[i][ACOMP] * 15.0F)) );
1449 }
1450 }
1451 else if (dstFormat == GL_BGRA) {
1452 GLushort *dst = (GLushort *) dstAddr;
1453 for (i=0;i<n;i++) {
1454 dst[i] = (((GLint) (rgba[i][BCOMP] * 15.0F)) << 12)
1455 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 8)
1456 | (((GLint) (rgba[i][RCOMP] * 15.0F)) << 4)
1457 | (((GLint) (rgba[i][ACOMP] * 15.0F)) );
1458 }
1459 }
1460 else if (dstFormat == GL_ABGR_EXT) {
1461 GLushort *dst = (GLushort *) dstAddr;
1462 for (i=0;i<n;i++) {
1463 dst[i] = (((GLint) (rgba[i][ACOMP] * 15.0F)) << 4)
1464 | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 8)
1465 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 12)
1466 | (((GLint) (rgba[i][RCOMP] * 15.0F)) );
1467 }
1468 }
1469 break;
1470 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1471 if (dstFormat == GL_RGBA) {
1472 GLushort *dst = (GLushort *) dstAddr;
1473 for (i=0;i<n;i++) {
1474 dst[i] = (((GLint) (rgba[i][RCOMP] * 15.0F)) )
1475 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 4)
1476 | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 8)
1477 | (((GLint) (rgba[i][ACOMP] * 15.0F)) << 12);
1478 }
1479 }
1480 else if (dstFormat == GL_BGRA) {
1481 GLushort *dst = (GLushort *) dstAddr;
1482 for (i=0;i<n;i++) {
1483 dst[i] = (((GLint) (rgba[i][BCOMP] * 15.0F)) )
1484 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 4)
1485 | (((GLint) (rgba[i][RCOMP] * 15.0F)) << 8)
1486 | (((GLint) (rgba[i][ACOMP] * 15.0F)) << 12);
1487 }
1488 }
1489 else if (dstFormat == GL_ABGR_EXT) {
1490 GLushort *dst = (GLushort *) dstAddr;
1491 for (i=0;i<n;i++) {
1492 dst[i] = (((GLint) (rgba[i][ACOMP] * 15.0F)) )
1493 | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 4)
1494 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 8)
1495 | (((GLint) (rgba[i][RCOMP] * 15.0F)) << 12);
1496 }
1497 }
1498 break;
1499 case GL_UNSIGNED_SHORT_5_5_5_1:
1500 if (dstFormat == GL_RGBA) {
1501 GLushort *dst = (GLushort *) dstAddr;
1502 for (i=0;i<n;i++) {
1503 dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) << 11)
1504 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 6)
1505 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 1)
1506 | (((GLint) (rgba[i][ACOMP] * 1.0F)) );
1507 }
1508 }
1509 else if (dstFormat == GL_BGRA) {
1510 GLushort *dst = (GLushort *) dstAddr;
1511 for (i=0;i<n;i++) {
1512 dst[i] = (((GLint) (rgba[i][BCOMP] * 31.0F)) << 11)
1513 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 6)
1514 | (((GLint) (rgba[i][RCOMP] * 31.0F)) << 1)
1515 | (((GLint) (rgba[i][ACOMP] * 1.0F)) );
1516 }
1517 }
1518 else if (dstFormat == GL_ABGR_EXT) {
1519 GLushort *dst = (GLushort *) dstAddr;
1520 for (i=0;i<n;i++) {
1521 dst[i] = (((GLint) (rgba[i][ACOMP] * 31.0F)) << 11)
1522 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 6)
1523 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 1)
1524 | (((GLint) (rgba[i][RCOMP] * 1.0F)) );
1525 }
1526 }
1527 break;
1528 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1529 if (dstFormat == GL_RGBA) {
1530 GLushort *dst = (GLushort *) dstAddr;
1531 for (i=0;i<n;i++) {
1532 dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) )
1533 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 5)
1534 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 10)
1535 | (((GLint) (rgba[i][ACOMP] * 1.0F)) << 15);
1536 }
1537 }
1538 else if (dstFormat == GL_BGRA) {
1539 GLushort *dst = (GLushort *) dstAddr;
1540 for (i=0;i<n;i++) {
1541 dst[i] = (((GLint) (rgba[i][BCOMP] * 31.0F)) )
1542 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 5)
1543 | (((GLint) (rgba[i][RCOMP] * 31.0F)) << 10)
1544 | (((GLint) (rgba[i][ACOMP] * 1.0F)) << 15);
1545 }
1546 }
1547 else if (dstFormat == GL_ABGR_EXT) {
1548 GLushort *dst = (GLushort *) dstAddr;
1549 for (i=0;i<n;i++) {
1550 dst[i] = (((GLint) (rgba[i][ACOMP] * 31.0F)) )
1551 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 5)
1552 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 10)
1553 | (((GLint) (rgba[i][RCOMP] * 1.0F)) << 15);
1554 }
1555 }
1556 break;
1557 case GL_UNSIGNED_INT_8_8_8_8:
1558 if (dstFormat == GL_RGBA) {
1559 GLuint *dst = (GLuint *) dstAddr;
1560 for (i=0;i<n;i++) {
1561 dst[i] = (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 24)
1562 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16)
1563 | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 8)
1564 | (((GLuint) (rgba[i][ACOMP] * 255.0F)) );
1565 }
1566 }
1567 else if (dstFormat == GL_BGRA) {
1568 GLuint *dst = (GLuint *) dstAddr;
1569 for (i=0;i<n;i++) {
1570 dst[i] = (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 24)
1571 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16)
1572 | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 8)
1573 | (((GLuint) (rgba[i][ACOMP] * 255.0F)) );
1574 }
1575 }
1576 else if (dstFormat == GL_ABGR_EXT) {
1577 GLuint *dst = (GLuint *) dstAddr;
1578 for (i=0;i<n;i++) {
1579 dst[i] = (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24)
1580 | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 16)
1581 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 8)
1582 | (((GLuint) (rgba[i][RCOMP] * 255.0F)) );
1583 }
1584 }
1585 break;
1586 case GL_UNSIGNED_INT_8_8_8_8_REV:
1587 if (dstFormat == GL_RGBA) {
1588 GLuint *dst = (GLuint *) dstAddr;
1589 for (i=0;i<n;i++) {
1590 dst[i] = (((GLuint) (rgba[i][RCOMP] * 255.0F)) )
1591 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 8)
1592 | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 16)
1593 | (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24);
1594 }
1595 }
1596 else if (dstFormat == GL_BGRA) {
1597 GLuint *dst = (GLuint *) dstAddr;
1598 for (i=0;i<n;i++) {
1599 dst[i] = (((GLuint) (rgba[i][BCOMP] * 255.0F)) )
1600 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 8)
1601 | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 16)
1602 | (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24);
1603 }
1604 }
1605 else if (dstFormat == GL_ABGR_EXT) {
1606 GLuint *dst = (GLuint *) dstAddr;
1607 for (i=0;i<n;i++) {
1608 dst[i] = (((GLuint) (rgba[i][ACOMP] * 255.0F)) )
1609 | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 8)
1610 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16)
1611 | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 24);
1612 }
1613 }
1614 break;
1615 case GL_UNSIGNED_INT_10_10_10_2:
1616 if (dstFormat == GL_RGBA) {
1617 GLuint *dst = (GLuint *) dstAddr;
1618 for (i=0;i<n;i++) {
1619 dst[i] = (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 22)
1620 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 12)
1621 | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 2)
1622 | (((GLuint) (rgba[i][ACOMP] * 3.0F)) );
1623 }
1624 }
1625 else if (dstFormat == GL_BGRA) {
1626 GLuint *dst = (GLuint *) dstAddr;
1627 for (i=0;i<n;i++) {
1628 dst[i] = (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 22)
1629 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 12)
1630 | (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 2)
1631 | (((GLuint) (rgba[i][ACOMP] * 3.0F)) );
1632 }
1633 }
1634 else if (dstFormat == GL_ABGR_EXT) {
1635 GLuint *dst = (GLuint *) dstAddr;
1636 for (i=0;i<n;i++) {
1637 dst[i] = (((GLuint) (rgba[i][ACOMP] * 1023.0F)) << 22)
1638 | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 12)
1639 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 2)
1640 | (((GLuint) (rgba[i][RCOMP] * 3.0F)) );
1641 }
1642 }
1643 break;
1644 case GL_UNSIGNED_INT_2_10_10_10_REV:
1645 if (dstFormat == GL_RGBA) {
1646 GLuint *dst = (GLuint *) dstAddr;
1647 for (i=0;i<n;i++) {
1648 dst[i] = (((GLuint) (rgba[i][RCOMP] * 1023.0F)) )
1649 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 10)
1650 | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 20)
1651 | (((GLuint) (rgba[i][ACOMP] * 3.0F)) << 30);
1652 }
1653 }
1654 else if (dstFormat == GL_BGRA) {
1655 GLuint *dst = (GLuint *) dstAddr;
1656 for (i=0;i<n;i++) {
1657 dst[i] = (((GLuint) (rgba[i][BCOMP] * 1023.0F)) )
1658 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 10)
1659 | (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 20)
1660 | (((GLuint) (rgba[i][ACOMP] * 3.0F)) << 30);
1661 }
1662 }
1663 else if (dstFormat == GL_ABGR_EXT) {
1664 GLuint *dst = (GLuint *) dstAddr;
1665 for (i=0;i<n;i++) {
1666 dst[i] = (((GLuint) (rgba[i][ACOMP] * 1023.0F)) )
1667 | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 10)
1668 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 20)
1669 | (((GLuint) (rgba[i][RCOMP] * 3.0F)) << 30);
1670 }
1671 }
1672 break;
1673 default:
1674 gl_problem(ctx, "bad type in _mesa_pack_float_rgba_span");
1675 }
1676 }
1677
1678
1679
1680 /*
1681 * Pack the given RGBA span into client memory at 'dest' address
1682 * in the given pixel format and type.
1683 * Optionally apply the enabled pixel transfer ops.
1684 * Pack into memory using the given packing params struct.
1685 * This is used by glReadPixels and glGetTexImage?D()
1686 * Input: ctx - the context
1687 * n - number of pixels in the span
1688 * rgba - the pixels
1689 * format - dest packing format
1690 * type - dest packing datatype
1691 * destination - destination packing address
1692 * packing - pixel packing parameters
1693 * transferOps - bitmask of IMAGE_*_BIT operations to apply
1694 */
1695 void
1696 _mesa_pack_rgba_span( GLcontext *ctx,
1697 GLuint n, CONST GLchan srcRgba[][4],
1698 GLenum dstFormat, GLenum dstType,
1699 GLvoid *dstAddr,
1700 const struct gl_pixelstore_attrib *dstPacking,
1701 GLuint transferOps)
1702 {
1703 ASSERT((ctx->NewState & _NEW_PIXEL) == 0);
1704
1705 /* Test for optimized case first */
1706 if (transferOps == 0 && dstFormat == GL_RGBA && dstType == CHAN_TYPE) {
1707 /* common simple case */
1708 MEMCPY(dstAddr, srcRgba, n * 4 * sizeof(GLchan));
1709 }
1710 else if (transferOps == 0 && dstFormat == GL_RGB && dstType == CHAN_TYPE) {
1711 /* common simple case */
1712 GLint i;
1713 GLchan *dest = (GLchan *) dstAddr;
1714 for (i = 0; i < n; i++) {
1715 dest[0] = srcRgba[i][RCOMP];
1716 dest[1] = srcRgba[i][GCOMP];
1717 dest[2] = srcRgba[i][BCOMP];
1718 dest += 3;
1719 }
1720 }
1721 else {
1722 /* general solution */
1723 GLfloat rgba[MAX_WIDTH][4];
1724 GLuint i;
1725 assert(n <= MAX_WIDTH);
1726 /* convert color components to floating point */
1727 for (i=0;i<n;i++) {
1728 rgba[i][RCOMP] = CHAN_TO_FLOAT(srcRgba[i][RCOMP]);
1729 rgba[i][GCOMP] = CHAN_TO_FLOAT(srcRgba[i][GCOMP]);
1730 rgba[i][BCOMP] = CHAN_TO_FLOAT(srcRgba[i][BCOMP]);
1731 rgba[i][ACOMP] = CHAN_TO_FLOAT(srcRgba[i][ACOMP]);
1732 }
1733 _mesa_pack_float_rgba_span(ctx, n, (const GLfloat (*)[4]) rgba,
1734 dstFormat, dstType, dstAddr,
1735 dstPacking, transferOps);
1736 }
1737 }
1738
1739
1740 #define SWAP2BYTE(VALUE) \
1741 { \
1742 GLubyte *bytes = (GLubyte *) &(VALUE); \
1743 GLubyte tmp = bytes[0]; \
1744 bytes[0] = bytes[1]; \
1745 bytes[1] = tmp; \
1746 }
1747
1748 #define SWAP4BYTE(VALUE) \
1749 { \
1750 GLubyte *bytes = (GLubyte *) &(VALUE); \
1751 GLubyte tmp = bytes[0]; \
1752 bytes[0] = bytes[3]; \
1753 bytes[3] = tmp; \
1754 tmp = bytes[1]; \
1755 bytes[1] = bytes[2]; \
1756 bytes[2] = tmp; \
1757 }
1758
1759
1760 static void
1761 extract_uint_indexes(GLuint n, GLuint indexes[],
1762 GLenum srcFormat, GLenum srcType, const GLvoid *src,
1763 const struct gl_pixelstore_attrib *unpack )
1764 {
1765 assert(srcFormat == GL_COLOR_INDEX);
1766
1767 ASSERT(srcType == GL_BITMAP ||
1768 srcType == GL_UNSIGNED_BYTE ||
1769 srcType == GL_BYTE ||
1770 srcType == GL_UNSIGNED_SHORT ||
1771 srcType == GL_SHORT ||
1772 srcType == GL_UNSIGNED_INT ||
1773 srcType == GL_INT ||
1774 srcType == GL_FLOAT);
1775
1776 switch (srcType) {
1777 case GL_BITMAP:
1778 {
1779 GLubyte *ubsrc = (GLubyte *) src;
1780 if (unpack->LsbFirst) {
1781 GLubyte mask = 1 << (unpack->SkipPixels & 0x7);
1782 GLuint i;
1783 for (i = 0; i < n; i++) {
1784 indexes[i] = (*ubsrc & mask) ? 1 : 0;
1785 if (mask == 128) {
1786 mask = 1;
1787 ubsrc++;
1788 }
1789 else {
1790 mask = mask << 1;
1791 }
1792 }
1793 }
1794 else {
1795 GLubyte mask = 128 >> (unpack->SkipPixels & 0x7);
1796 GLuint i;
1797 for (i = 0; i < n; i++) {
1798 indexes[i] = (*ubsrc & mask) ? 1 : 0;
1799 if (mask == 1) {
1800 mask = 128;
1801 ubsrc++;
1802 }
1803 else {
1804 mask = mask >> 1;
1805 }
1806 }
1807 }
1808 }
1809 break;
1810 case GL_UNSIGNED_BYTE:
1811 {
1812 GLuint i;
1813 const GLubyte *s = (const GLubyte *) src;
1814 for (i = 0; i < n; i++)
1815 indexes[i] = s[i];
1816 }
1817 break;
1818 case GL_BYTE:
1819 {
1820 GLuint i;
1821 const GLbyte *s = (const GLbyte *) src;
1822 for (i = 0; i < n; i++)
1823 indexes[i] = s[i];
1824 }
1825 break;
1826 case GL_UNSIGNED_SHORT:
1827 {
1828 GLuint i;
1829 const GLushort *s = (const GLushort *) src;
1830 if (unpack->SwapBytes) {
1831 for (i = 0; i < n; i++) {
1832 GLushort value = s[i];
1833 SWAP2BYTE(value);
1834 indexes[i] = value;
1835 }
1836 }
1837 else {
1838 for (i = 0; i < n; i++)
1839 indexes[i] = s[i];
1840 }
1841 }
1842 break;
1843 case GL_SHORT:
1844 {
1845 GLuint i;
1846 const GLshort *s = (const GLshort *) src;
1847 if (unpack->SwapBytes) {
1848 for (i = 0; i < n; i++) {
1849 GLshort value = s[i];
1850 SWAP2BYTE(value);
1851 indexes[i] = value;
1852 }
1853 }
1854 else {
1855 for (i = 0; i < n; i++)
1856 indexes[i] = s[i];
1857 }
1858 }
1859 break;
1860 case GL_UNSIGNED_INT:
1861 {
1862 GLuint i;
1863 const GLuint *s = (const GLuint *) src;
1864 if (unpack->SwapBytes) {
1865 for (i = 0; i < n; i++) {
1866 GLuint value = s[i];
1867 SWAP4BYTE(value);
1868 indexes[i] = value;
1869 }
1870 }
1871 else {
1872 for (i = 0; i < n; i++)
1873 indexes[i] = s[i];
1874 }
1875 }
1876 break;
1877 case GL_INT:
1878 {
1879 GLuint i;
1880 const GLint *s = (const GLint *) src;
1881 if (unpack->SwapBytes) {
1882 for (i = 0; i < n; i++) {
1883 GLint value = s[i];
1884 SWAP4BYTE(value);
1885 indexes[i] = value;
1886 }
1887 }
1888 else {
1889 for (i = 0; i < n; i++)
1890 indexes[i] = s[i];
1891 }
1892 }
1893 break;
1894 case GL_FLOAT:
1895 {
1896 GLuint i;
1897 const GLfloat *s = (const GLfloat *) src;
1898 if (unpack->SwapBytes) {
1899 for (i = 0; i < n; i++) {
1900 GLfloat value = s[i];
1901 SWAP4BYTE(value);
1902 indexes[i] = (GLuint) value;
1903 }
1904 }
1905 else {
1906 for (i = 0; i < n; i++)
1907 indexes[i] = (GLuint) s[i];
1908 }
1909 }
1910 break;
1911 default:
1912 gl_problem(NULL, "bad srcType in extract_uint_indexes");
1913 return;
1914 }
1915 }
1916
1917
1918
1919 /*
1920 * This function extracts floating point RGBA values from arbitrary
1921 * image data. srcFormat and srcType are the format and type parameters
1922 * passed to glDrawPixels, glTexImage[123]D, glTexSubImage[123]D, etc.
1923 *
1924 * Refering to section 3.6.4 of the OpenGL 1.2 spec, this function
1925 * implements the "Conversion to floating point", "Conversion to RGB",
1926 * and "Final Expansion to RGBA" operations.
1927 *
1928 * Args: n - number of pixels
1929 * rgba - output colors
1930 * srcFormat - format of incoming data
1931 * srcType - datatype of incoming data
1932 * src - source data pointer
1933 * swapBytes - perform byteswapping of incoming data?
1934 */
1935 static void
1936 extract_float_rgba(GLuint n, GLfloat rgba[][4],
1937 GLenum srcFormat, GLenum srcType, const GLvoid *src,
1938 GLboolean swapBytes)
1939 {
1940 GLint redIndex, greenIndex, blueIndex, alphaIndex;
1941 GLint stride;
1942 GLint rComp, bComp, gComp, aComp;
1943
1944 ASSERT(srcFormat == GL_RED ||
1945 srcFormat == GL_GREEN ||
1946 srcFormat == GL_BLUE ||
1947 srcFormat == GL_ALPHA ||
1948 srcFormat == GL_LUMINANCE ||
1949 srcFormat == GL_LUMINANCE_ALPHA ||
1950 srcFormat == GL_INTENSITY ||
1951 srcFormat == GL_RGB ||
1952 srcFormat == GL_BGR ||
1953 srcFormat == GL_RGBA ||
1954 srcFormat == GL_BGRA ||
1955 srcFormat == GL_ABGR_EXT);
1956
1957 ASSERT(srcType == GL_UNSIGNED_BYTE ||
1958 srcType == GL_BYTE ||
1959 srcType == GL_UNSIGNED_SHORT ||
1960 srcType == GL_SHORT ||
1961 srcType == GL_UNSIGNED_INT ||
1962 srcType == GL_INT ||
1963 srcType == GL_FLOAT ||
1964 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
1965 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
1966 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
1967 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
1968 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
1969 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
1970 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
1971 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
1972 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
1973 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
1974 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
1975 srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
1976
1977 rComp = gComp = bComp = aComp = -1;
1978
1979 switch (srcFormat) {
1980 case GL_RED:
1981 redIndex = 0;
1982 greenIndex = blueIndex = alphaIndex = -1;
1983 stride = 1;
1984 break;
1985 case GL_GREEN:
1986 greenIndex = 0;
1987 redIndex = blueIndex = alphaIndex = -1;
1988 stride = 1;
1989 break;
1990 case GL_BLUE:
1991 blueIndex = 0;
1992 redIndex = greenIndex = alphaIndex = -1;
1993 stride = 1;
1994 break;
1995 case GL_ALPHA:
1996 redIndex = greenIndex = blueIndex = -1;
1997 alphaIndex = 0;
1998 stride = 1;
1999 break;
2000 case GL_LUMINANCE:
2001 redIndex = greenIndex = blueIndex = 0;
2002 alphaIndex = -1;
2003 stride = 1;
2004 break;
2005 case GL_LUMINANCE_ALPHA:
2006 redIndex = greenIndex = blueIndex = 0;
2007 alphaIndex = 1;
2008 stride = 2;
2009 break;
2010 case GL_INTENSITY:
2011 redIndex = 0;
2012 greenIndex = blueIndex = alphaIndex = -1;
2013 stride = 1;
2014 break;
2015 case GL_RGB:
2016 redIndex = 0;
2017 greenIndex = 1;
2018 blueIndex = 2;
2019 alphaIndex = -1;
2020 stride = 3;
2021 break;
2022 case GL_BGR:
2023 redIndex = 2;
2024 greenIndex = 1;
2025 blueIndex = 0;
2026 alphaIndex = -1;
2027 stride = 3;
2028 break;
2029 case GL_RGBA:
2030 redIndex = 0;
2031 greenIndex = 1;
2032 blueIndex = 2;
2033 alphaIndex = 3;
2034 rComp = 0;
2035 gComp = 1;
2036 bComp = 2;
2037 aComp = 3;
2038 stride = 4;
2039 break;
2040 case GL_BGRA:
2041 redIndex = 2;
2042 greenIndex = 1;
2043 blueIndex = 0;
2044 alphaIndex = 3;
2045 rComp = 2;
2046 gComp = 1;
2047 bComp = 0;
2048 aComp = 3;
2049 stride = 4;
2050 break;
2051 case GL_ABGR_EXT:
2052 redIndex = 3;
2053 greenIndex = 2;
2054 blueIndex = 1;
2055 alphaIndex = 0;
2056 rComp = 3;
2057 gComp = 2;
2058 bComp = 1;
2059 aComp = 0;
2060 stride = 4;
2061 break;
2062 default:
2063 gl_problem(NULL, "bad srcFormat in extract float data");
2064 return;
2065 }
2066
2067
2068 #define PROCESS(INDEX, CHANNEL, DEFAULT, TYPE, CONVERSION) \
2069 if ((INDEX) < 0) { \
2070 GLuint i; \
2071 for (i = 0; i < n; i++) { \
2072 rgba[i][CHANNEL] = DEFAULT; \
2073 } \
2074 } \
2075 else if (swapBytes) { \
2076 const TYPE *s = (const TYPE *) src; \
2077 GLuint i; \
2078 for (i = 0; i < n; i++) { \
2079 TYPE value = s[INDEX]; \
2080 if (sizeof(TYPE) == 2) { \
2081 SWAP2BYTE(value); \
2082 } \
2083 else if (sizeof(TYPE) == 4) { \
2084 SWAP4BYTE(value); \
2085 } \
2086 rgba[i][CHANNEL] = (GLfloat) CONVERSION(value); \
2087 s += stride; \
2088 } \
2089 } \
2090 else { \
2091 const TYPE *s = (const TYPE *) src; \
2092 GLuint i; \
2093 for (i = 0; i < n; i++) { \
2094 rgba[i][CHANNEL] = (GLfloat) CONVERSION(s[INDEX]); \
2095 s += stride; \
2096 } \
2097 }
2098
2099 switch (srcType) {
2100 case GL_UNSIGNED_BYTE:
2101 PROCESS(redIndex, RCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT);
2102 PROCESS(greenIndex, GCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT);
2103 PROCESS(blueIndex, BCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT);
2104 PROCESS(alphaIndex, ACOMP, 1.0F, GLubyte, UBYTE_TO_FLOAT);
2105 break;
2106 case GL_BYTE:
2107 PROCESS(redIndex, RCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT);
2108 PROCESS(greenIndex, GCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT);
2109 PROCESS(blueIndex, BCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT);
2110 PROCESS(alphaIndex, ACOMP, 1.0F, GLbyte, BYTE_TO_FLOAT);
2111 break;
2112 case GL_UNSIGNED_SHORT:
2113 PROCESS(redIndex, RCOMP, 0.0F, GLushort, USHORT_TO_FLOAT);
2114 PROCESS(greenIndex, GCOMP, 0.0F, GLushort, USHORT_TO_FLOAT);
2115 PROCESS(blueIndex, BCOMP, 0.0F, GLushort, USHORT_TO_FLOAT);
2116 PROCESS(alphaIndex, ACOMP, 1.0F, GLushort, USHORT_TO_FLOAT);
2117 break;
2118 case GL_SHORT:
2119 PROCESS(redIndex, RCOMP, 0.0F, GLshort, SHORT_TO_FLOAT);
2120 PROCESS(greenIndex, GCOMP, 0.0F, GLshort, SHORT_TO_FLOAT);
2121 PROCESS(blueIndex, BCOMP, 0.0F, GLshort, SHORT_TO_FLOAT);
2122 PROCESS(alphaIndex, ACOMP, 1.0F, GLshort, SHORT_TO_FLOAT);
2123 break;
2124 case GL_UNSIGNED_INT:
2125 PROCESS(redIndex, RCOMP, 0.0F, GLuint, UINT_TO_FLOAT);
2126 PROCESS(greenIndex, GCOMP, 0.0F, GLuint, UINT_TO_FLOAT);
2127 PROCESS(blueIndex, BCOMP, 0.0F, GLuint, UINT_TO_FLOAT);
2128 PROCESS(alphaIndex, ACOMP, 1.0F, GLuint, UINT_TO_FLOAT);
2129 break;
2130 case GL_INT:
2131 PROCESS(redIndex, RCOMP, 0.0F, GLint, INT_TO_FLOAT);
2132 PROCESS(greenIndex, GCOMP, 0.0F, GLint, INT_TO_FLOAT);
2133 PROCESS(blueIndex, BCOMP, 0.0F, GLint, INT_TO_FLOAT);
2134 PROCESS(alphaIndex, ACOMP, 1.0F, GLint, INT_TO_FLOAT);
2135 break;
2136 case GL_FLOAT:
2137 PROCESS(redIndex, RCOMP, 0.0F, GLfloat, (GLfloat));
2138 PROCESS(greenIndex, GCOMP, 0.0F, GLfloat, (GLfloat));
2139 PROCESS(blueIndex, BCOMP, 0.0F, GLfloat, (GLfloat));
2140 PROCESS(alphaIndex, ACOMP, 1.0F, GLfloat, (GLfloat));
2141 break;
2142 case GL_UNSIGNED_BYTE_3_3_2:
2143 {
2144 const GLubyte *ubsrc = (const GLubyte *) src;
2145 GLuint i;
2146 for (i = 0; i < n; i ++) {
2147 GLubyte p = ubsrc[i];
2148 rgba[i][RCOMP] = ((p >> 5) ) * (1.0F / 7.0F);
2149 rgba[i][GCOMP] = ((p >> 2) & 0x7) * (1.0F / 7.0F);
2150 rgba[i][BCOMP] = ((p ) & 0x3) * (1.0F / 3.0F);
2151 rgba[i][ACOMP] = 1.0F;
2152 }
2153 }
2154 break;
2155 case GL_UNSIGNED_BYTE_2_3_3_REV:
2156 {
2157 const GLubyte *ubsrc = (const GLubyte *) src;
2158 GLuint i;
2159 for (i = 0; i < n; i ++) {
2160 GLubyte p = ubsrc[i];
2161 rgba[i][RCOMP] = ((p ) & 0x7) * (1.0F / 7.0F);
2162 rgba[i][GCOMP] = ((p >> 3) & 0x7) * (1.0F / 7.0F);
2163 rgba[i][BCOMP] = ((p >> 6) ) * (1.0F / 3.0F);
2164 rgba[i][ACOMP] = 1.0F;
2165 }
2166 }
2167 break;
2168 case GL_UNSIGNED_SHORT_5_6_5:
2169 if (swapBytes) {
2170 const GLushort *ussrc = (const GLushort *) src;
2171 GLuint i;
2172 for (i = 0; i < n; i ++) {
2173 GLushort p = ussrc[i];
2174 SWAP2BYTE(p);
2175 rgba[i][RCOMP] = ((p >> 11) ) * (1.0F / 31.0F);
2176 rgba[i][GCOMP] = ((p >> 5) & 0x3f) * (1.0F / 63.0F);
2177 rgba[i][BCOMP] = ((p ) & 0x1f) * (1.0F / 31.0F);
2178 rgba[i][ACOMP] = 1.0F;
2179 }
2180 }
2181 else {
2182 const GLushort *ussrc = (const GLushort *) src;
2183 GLuint i;
2184 for (i = 0; i < n; i ++) {
2185 GLushort p = ussrc[i];
2186 rgba[i][RCOMP] = ((p >> 11) ) * (1.0F / 31.0F);
2187 rgba[i][GCOMP] = ((p >> 5) & 0x3f) * (1.0F / 63.0F);
2188 rgba[i][BCOMP] = ((p ) & 0x1f) * (1.0F / 31.0F);
2189 rgba[i][ACOMP] = 1.0F;
2190 }
2191 }
2192 break;
2193 case GL_UNSIGNED_SHORT_5_6_5_REV:
2194 if (swapBytes) {
2195 const GLushort *ussrc = (const GLushort *) src;
2196 GLuint i;
2197 for (i = 0; i < n; i ++) {
2198 GLushort p = ussrc[i];
2199 SWAP2BYTE(p);
2200 rgba[i][RCOMP] = ((p ) & 0x1f) * (1.0F / 31.0F);
2201 rgba[i][GCOMP] = ((p >> 5) & 0x3f) * (1.0F / 63.0F);
2202 rgba[i][BCOMP] = ((p >> 11) ) * (1.0F / 31.0F);
2203 rgba[i][ACOMP] = 1.0F;
2204 }
2205 }
2206 else {
2207 const GLushort *ussrc = (const GLushort *) src;
2208 GLuint i;
2209 for (i = 0; i < n; i ++) {
2210 GLushort p = ussrc[i];
2211 rgba[i][RCOMP] = ((p ) & 0x1f) * (1.0F / 31.0F);
2212 rgba[i][GCOMP] = ((p >> 5) & 0x3f) * (1.0F / 63.0F);
2213 rgba[i][BCOMP] = ((p >> 11) ) * (1.0F / 31.0F);
2214 rgba[i][ACOMP] = 1.0F;
2215 }
2216 }
2217 break;
2218 case GL_UNSIGNED_SHORT_4_4_4_4:
2219 if (swapBytes) {
2220 const GLushort *ussrc = (const GLushort *) src;
2221 GLuint i;
2222 for (i = 0; i < n; i ++) {
2223 GLushort p = ussrc[i];
2224 SWAP2BYTE(p);
2225 rgba[i][rComp] = ((p >> 12) ) * (1.0F / 15.0F);
2226 rgba[i][gComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F);
2227 rgba[i][bComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F);
2228 rgba[i][aComp] = ((p ) & 0xf) * (1.0F / 15.0F);
2229 }
2230 }
2231 else {
2232 const GLushort *ussrc = (const GLushort *) src;
2233 GLuint i;
2234 for (i = 0; i < n; i ++) {
2235 GLushort p = ussrc[i];
2236 rgba[i][rComp] = ((p >> 12) ) * (1.0F / 15.0F);
2237 rgba[i][gComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F);
2238 rgba[i][bComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F);
2239 rgba[i][aComp] = ((p ) & 0xf) * (1.0F / 15.0F);
2240 }
2241 }
2242 break;
2243 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
2244 if (swapBytes) {
2245 const GLushort *ussrc = (const GLushort *) src;
2246 GLuint i;
2247 for (i = 0; i < n; i ++) {
2248 GLushort p = ussrc[i];
2249 SWAP2BYTE(p);
2250 rgba[i][rComp] = ((p ) & 0xf) * (1.0F / 15.0F);
2251 rgba[i][gComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F);
2252 rgba[i][bComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F);
2253 rgba[i][aComp] = ((p >> 12) ) * (1.0F / 15.0F);
2254 }
2255 }
2256 else {
2257 const GLushort *ussrc = (const GLushort *) src;
2258 GLuint i;
2259 for (i = 0; i < n; i ++) {
2260 GLushort p = ussrc[i];
2261 rgba[i][rComp] = ((p ) & 0xf) * (1.0F / 15.0F);
2262 rgba[i][gComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F);
2263 rgba[i][bComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F);
2264 rgba[i][aComp] = ((p >> 12) ) * (1.0F / 15.0F);
2265 }
2266 }
2267 break;
2268 case GL_UNSIGNED_SHORT_5_5_5_1:
2269 if (swapBytes) {
2270 const GLushort *ussrc = (const GLushort *) src;
2271 GLuint i;
2272 for (i = 0; i < n; i ++) {
2273 GLushort p = ussrc[i];
2274 SWAP2BYTE(p);
2275 rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F);
2276 rgba[i][gComp] = ((p >> 6) & 0x1f) * (1.0F / 31.0F);
2277 rgba[i][bComp] = ((p >> 1) & 0x1f) * (1.0F / 31.0F);
2278 rgba[i][aComp] = ((p ) & 0x1) * (1.0F / 1.0F);
2279 }
2280 }
2281 else {
2282 const GLushort *ussrc = (const GLushort *) src;
2283 GLuint i;
2284 for (i = 0; i < n; i ++) {
2285 GLushort p = ussrc[i];
2286 rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F);
2287 rgba[i][gComp] = ((p >> 6) & 0x1f) * (1.0F / 31.0F);
2288 rgba[i][bComp] = ((p >> 1) & 0x1f) * (1.0F / 31.0F);
2289 rgba[i][aComp] = ((p ) & 0x1) * (1.0F / 1.0F);
2290 }
2291 }
2292 break;
2293 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
2294 if (swapBytes) {
2295 const GLushort *ussrc = (const GLushort *) src;
2296 GLuint i;
2297 for (i = 0; i < n; i ++) {
2298 GLushort p = ussrc[i];
2299 SWAP2BYTE(p);
2300 rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F);
2301 rgba[i][gComp] = ((p >> 5) & 0x1f) * (1.0F / 31.0F);
2302 rgba[i][bComp] = ((p >> 10) & 0x1f) * (1.0F / 31.0F);
2303 rgba[i][aComp] = ((p >> 15) ) * (1.0F / 1.0F);
2304 }
2305 }
2306 else {
2307 const GLushort *ussrc = (const GLushort *) src;
2308 GLuint i;
2309 for (i = 0; i < n; i ++) {
2310 GLushort p = ussrc[i];
2311 rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F);
2312 rgba[i][gComp] = ((p >> 5) & 0x1f) * (1.0F / 31.0F);
2313 rgba[i][bComp] = ((p >> 10) & 0x1f) * (1.0F / 31.0F);
2314 rgba[i][aComp] = ((p >> 15) ) * (1.0F / 1.0F);
2315 }
2316 }
2317 break;
2318 case GL_UNSIGNED_INT_8_8_8_8:
2319 if (swapBytes) {
2320 const GLuint *uisrc = (const GLuint *) src;
2321 GLuint i;
2322 for (i = 0; i < n; i ++) {
2323 GLuint p = uisrc[i];
2324 rgba[i][rComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p ) & 0xff);
2325 rgba[i][gComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 8) & 0xff);
2326 rgba[i][bComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 16) & 0xff);
2327 rgba[i][aComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 24) );
2328 }
2329 }
2330 else {
2331 const GLuint *uisrc = (const GLuint *) src;
2332 GLuint i;
2333 for (i = 0; i < n; i ++) {
2334 GLuint p = uisrc[i];
2335 rgba[i][rComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 24) );
2336 rgba[i][gComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 16) & 0xff);
2337 rgba[i][bComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 8) & 0xff);
2338 rgba[i][aComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p ) & 0xff);
2339 }
2340 }
2341 break;
2342 case GL_UNSIGNED_INT_8_8_8_8_REV:
2343 if (swapBytes) {
2344 const GLuint *uisrc = (const GLuint *) src;
2345 GLuint i;
2346 for (i = 0; i < n; i ++) {
2347 GLuint p = uisrc[i];
2348 rgba[i][rComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 24) );
2349 rgba[i][gComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 16) & 0xff);
2350 rgba[i][bComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 8) & 0xff);
2351 rgba[i][aComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p ) & 0xff);
2352 }
2353 }
2354 else {
2355 const GLuint *uisrc = (const GLuint *) src;
2356 GLuint i;
2357 for (i = 0; i < n; i ++) {
2358 GLuint p = uisrc[i];
2359 rgba[i][rComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p ) & 0xff);
2360 rgba[i][gComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 8) & 0xff);
2361 rgba[i][bComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 16) & 0xff);
2362 rgba[i][aComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 24) );
2363 }
2364 }
2365 break;
2366 case GL_UNSIGNED_INT_10_10_10_2:
2367 if (swapBytes) {
2368 const GLuint *uisrc = (const GLuint *) src;
2369 GLuint i;
2370 for (i = 0; i < n; i ++) {
2371 GLuint p = uisrc[i];
2372 SWAP4BYTE(p);
2373 rgba[i][rComp] = ((p >> 22) ) * (1.0F / 1023.0F);
2374 rgba[i][gComp] = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F);
2375 rgba[i][bComp] = ((p >> 2) & 0x3ff) * (1.0F / 1023.0F);
2376 rgba[i][aComp] = ((p ) & 0x3 ) * (1.0F / 3.0F);
2377 }
2378 }
2379 else {
2380 const GLuint *uisrc = (const GLuint *) src;
2381 GLuint i;
2382 for (i = 0; i < n; i ++) {
2383 GLuint p = uisrc[i];
2384 rgba[i][rComp] = ((p >> 22) ) * (1.0F / 1023.0F);
2385 rgba[i][gComp] = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F);
2386 rgba[i][bComp] = ((p >> 2) & 0x3ff) * (1.0F / 1023.0F);
2387 rgba[i][aComp] = ((p ) & 0x3 ) * (1.0F / 3.0F);
2388 }
2389 }
2390 break;
2391 case GL_UNSIGNED_INT_2_10_10_10_REV:
2392 if (swapBytes) {
2393 const GLuint *uisrc = (const GLuint *) src;
2394 GLuint i;
2395 for (i = 0; i < n; i ++) {
2396 GLuint p = uisrc[i];
2397 SWAP4BYTE(p);
2398 rgba[i][rComp] = ((p ) & 0x3ff) * (1.0F / 1023.0F);
2399 rgba[i][gComp] = ((p >> 10) & 0x3ff) * (1.0F / 1023.0F);
2400 rgba[i][bComp] = ((p >> 20) & 0x3ff) * (1.0F / 1023.0F);
2401 rgba[i][aComp] = ((p >> 30) ) * (1.0F / 3.0F);
2402 }
2403 }
2404 else {
2405 const GLuint *uisrc = (const GLuint *) src;
2406 GLuint i;
2407 for (i = 0; i < n; i ++) {
2408 GLuint p = uisrc[i];
2409 rgba[i][rComp] = ((p ) & 0x3ff) * (1.0F / 1023.0F);
2410 rgba[i][gComp] = ((p >> 10) & 0x3ff) * (1.0F / 1023.0F);
2411 rgba[i][bComp] = ((p >> 20) & 0x3ff) * (1.0F / 1023.0F);
2412 rgba[i][aComp] = ((p >> 30) ) * (1.0F / 3.0F);
2413 }
2414 }
2415 break;
2416 default:
2417 gl_problem(NULL, "bad srcType in extract float data");
2418 break;
2419 }
2420 }
2421
2422
2423
2424 /*
2425 * Unpack a row of color image data from a client buffer according to
2426 * the pixel unpacking parameters.
2427 * Return GLubyte values in the specified dest image format.
2428 * This is (or will be) used by glDrawPixels and glTexImage?D().
2429 * Input: ctx - the context
2430 * n - number of pixels in the span
2431 * dstFormat - format of destination color array
2432 * dest - the destination color array
2433 * srcFormat - source image format
2434 * srcType - source image datatype
2435 * source - source image pointer
2436 * srcPacking - pixel unpacking parameters
2437 * transferOps - bitmask of IMAGE_*_BIT values of operations to apply
2438 *
2439 * XXX perhaps expand this to process whole images someday.
2440 */
2441 void
2442 _mesa_unpack_chan_color_span( GLcontext *ctx,
2443 GLuint n, GLenum dstFormat, GLchan dest[],
2444 GLenum srcFormat, GLenum srcType,
2445 const GLvoid *source,
2446 const struct gl_pixelstore_attrib *srcPacking,
2447 GLuint transferOps )
2448 {
2449 ASSERT(dstFormat == GL_ALPHA ||
2450 dstFormat == GL_LUMINANCE ||
2451 dstFormat == GL_LUMINANCE_ALPHA ||
2452 dstFormat == GL_INTENSITY ||
2453 dstFormat == GL_RGB ||
2454 dstFormat == GL_RGBA ||
2455 dstFormat == GL_COLOR_INDEX);
2456
2457 ASSERT(srcFormat == GL_RED ||
2458 srcFormat == GL_GREEN ||
2459 srcFormat == GL_BLUE ||
2460 srcFormat == GL_ALPHA ||
2461 srcFormat == GL_LUMINANCE ||
2462 srcFormat == GL_LUMINANCE_ALPHA ||
2463 srcFormat == GL_INTENSITY ||
2464 srcFormat == GL_RGB ||
2465 srcFormat == GL_BGR ||
2466 srcFormat == GL_RGBA ||
2467 srcFormat == GL_BGRA ||
2468 srcFormat == GL_ABGR_EXT ||
2469 srcFormat == GL_COLOR_INDEX);
2470
2471 ASSERT(srcType == GL_BITMAP ||
2472 srcType == GL_UNSIGNED_BYTE ||
2473 srcType == GL_BYTE ||
2474 srcType == GL_UNSIGNED_SHORT ||
2475 srcType == GL_SHORT ||
2476 srcType == GL_UNSIGNED_INT ||
2477 srcType == GL_INT ||
2478 srcType == GL_FLOAT ||
2479 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
2480 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
2481 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
2482 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
2483 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
2484 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
2485 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
2486 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
2487 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
2488 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
2489 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
2490 srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
2491
2492 /* this is intended for RGBA mode only */
2493 assert(ctx->Visual.RGBAflag);
2494
2495 /* Try simple cases first */
2496 if (transferOps == 0 && srcType == CHAN_TYPE) {
2497 if (dstFormat == GL_RGBA) {
2498 if (srcFormat == GL_RGBA) {
2499 MEMCPY( dest, source, n * 4 * sizeof(GLchan) );
2500 return;
2501 }
2502 else if (srcFormat == GL_RGB) {
2503 GLuint i;
2504 const GLchan *src = (const GLchan *) source;
2505 GLchan *dst = dest;
2506 for (i = 0; i < n; i++) {
2507 dst[0] = src[0];
2508 dst[1] = src[1];
2509 dst[2] = src[2];
2510 dst[3] = CHAN_MAX;
2511 src += 3;
2512 dst += 4;
2513 }
2514 return;
2515 }
2516 }
2517 else if (dstFormat == GL_RGB) {
2518 if (srcFormat == GL_RGB) {
2519 MEMCPY( dest, source, n * 3 * sizeof(GLchan) );
2520 return;
2521 }
2522 else if (srcFormat == GL_RGBA) {
2523 GLuint i;
2524 const GLchan *src = (const GLchan *) source;
2525 GLchan *dst = dest;
2526 for (i = 0; i < n; i++) {
2527 dst[0] = src[0];
2528 dst[1] = src[1];
2529 dst[2] = src[2];
2530 src += 4;
2531 dst += 3;
2532 }
2533 return;
2534 }
2535 }
2536 else if (dstFormat == srcFormat) {
2537 GLint comps = _mesa_components_in_format(srcFormat);
2538 assert(comps > 0);
2539 MEMCPY( dest, source, n * comps * sizeof(GLchan) );
2540 return;
2541 }
2542 }
2543
2544
2545 /* general solution begins here */
2546 {
2547 GLfloat rgba[MAX_WIDTH][4];
2548 GLint dstComponents;
2549 GLint dstRedIndex, dstGreenIndex, dstBlueIndex, dstAlphaIndex;
2550 GLint dstLuminanceIndex, dstIntensityIndex;
2551
2552 dstComponents = _mesa_components_in_format( dstFormat );
2553 /* source & dest image formats should have been error checked by now */
2554 assert(dstComponents > 0);
2555
2556 /*
2557 * Extract image data and convert to RGBA floats
2558 */
2559 assert(n <= MAX_WIDTH);
2560 if (srcFormat == GL_COLOR_INDEX) {
2561 GLuint indexes[MAX_WIDTH];
2562 extract_uint_indexes(n, indexes, srcFormat, srcType, source,
2563 srcPacking);
2564
2565 if (dstFormat == GL_COLOR_INDEX
2566 && (transferOps & IMAGE_MAP_COLOR_BIT)) {
2567 _mesa_map_ci(ctx, n, indexes);
2568 }
2569 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
2570 _mesa_shift_and_offset_ci(ctx, n, indexes);
2571 }
2572
2573 if (dstFormat == GL_COLOR_INDEX) {
2574 /* convert to GLchan and return */
2575 GLuint i;
2576 for (i = 0; i < n; i++) {
2577 dest[i] = (GLchan) (indexes[i] & 0xff);
2578 }
2579 return;
2580 }
2581 else {
2582 /* Convert indexes to RGBA */
2583 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
2584 }
2585 }
2586 else {
2587 extract_float_rgba(n, rgba, srcFormat, srcType, source,
2588 srcPacking->SwapBytes);
2589
2590 /* scale and bias colors */
2591 if (transferOps & IMAGE_SCALE_BIAS_BIT) {
2592 _mesa_scale_and_bias_rgba(ctx, n, rgba);
2593 }
2594 /* color map lookup */
2595 if (transferOps & IMAGE_MAP_COLOR_BIT) {
2596 _mesa_map_rgba(ctx, n, rgba);
2597 }
2598 }
2599
2600 if (transferOps) {
2601 /* GL_COLOR_TABLE lookup */
2602 if (transferOps & IMAGE_COLOR_TABLE_BIT) {
2603 _mesa_lookup_rgba(&ctx->ColorTable, n, rgba);
2604 }
2605 /* convolution */
2606 if (transferOps & IMAGE_CONVOLUTION_BIT) {
2607 /* this has to be done in the calling code */
2608 }
2609 /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
2610 if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) {
2611 _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, n, rgba);
2612 }
2613 /* color matrix transform */
2614 if (transferOps & IMAGE_COLOR_MATRIX_BIT) {
2615 _mesa_transform_rgba(ctx, n, rgba);
2616 }
2617 /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
2618 if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) {
2619 _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, n, rgba);
2620 }
2621 /* update histogram count */
2622 if (transferOps & IMAGE_HISTOGRAM_BIT) {
2623 _mesa_update_histogram(ctx, n, (CONST GLfloat (*)[4]) rgba);
2624 }
2625 /* min/max here */
2626 if (transferOps & IMAGE_MIN_MAX_BIT) {
2627 _mesa_update_minmax(ctx, n, (CONST GLfloat (*)[4]) rgba);
2628 }
2629 }
2630
2631 /* clamp to [0,1] */
2632 {
2633 GLuint i;
2634 for (i = 0; i < n; i++) {
2635 rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F);
2636 rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F);
2637 rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F);
2638 rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F);
2639 }
2640 }
2641
2642 /* Now determine which color channels we need to produce.
2643 * And determine the dest index (offset) within each color tuple.
2644 */
2645 switch (dstFormat) {
2646 case GL_ALPHA:
2647 dstAlphaIndex = 0;
2648 dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
2649 dstLuminanceIndex = dstIntensityIndex = -1;
2650 break;
2651 case GL_LUMINANCE:
2652 dstLuminanceIndex = 0;
2653 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
2654 dstIntensityIndex = -1;
2655 break;
2656 case GL_LUMINANCE_ALPHA:
2657 dstLuminanceIndex = 0;
2658 dstAlphaIndex = 1;
2659 dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
2660 dstIntensityIndex = -1;
2661 break;
2662 case GL_INTENSITY:
2663 dstIntensityIndex = 0;
2664 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
2665 dstLuminanceIndex = -1;
2666 break;
2667 case GL_RGB:
2668 dstRedIndex = 0;
2669 dstGreenIndex = 1;
2670 dstBlueIndex = 2;
2671 dstAlphaIndex = dstLuminanceIndex = dstIntensityIndex = -1;
2672 break;
2673 case GL_RGBA:
2674 dstRedIndex = 0;
2675 dstGreenIndex = 1;
2676 dstBlueIndex = 2;
2677 dstAlphaIndex = 3;
2678 dstLuminanceIndex = dstIntensityIndex = -1;
2679 break;
2680 default:
2681 gl_problem(ctx, "bad dstFormat in _mesa_unpack_chan_span()");
2682 return;
2683 }
2684
2685
2686 /* Now return the GLchan data in the requested dstFormat */
2687
2688 if (dstRedIndex >= 0) {
2689 GLchan *dst = dest;
2690 GLuint i;
2691 for (i = 0; i < n; i++) {
2692 dst[dstRedIndex] = FLOAT_TO_CHAN(rgba[i][RCOMP]);
2693 dst += dstComponents;
2694 }
2695 }
2696
2697 if (dstGreenIndex >= 0) {
2698 GLchan *dst = dest;
2699 GLuint i;
2700 for (i = 0; i < n; i++) {
2701 dst[dstGreenIndex] = FLOAT_TO_CHAN(rgba[i][GCOMP]);
2702 dst += dstComponents;
2703 }
2704 }
2705
2706 if (dstBlueIndex >= 0) {
2707 GLchan *dst = dest;
2708 GLuint i;
2709 for (i = 0; i < n; i++) {
2710 dst[dstBlueIndex] = FLOAT_TO_CHAN(rgba[i][BCOMP]);
2711 dst += dstComponents;
2712 }
2713 }
2714
2715 if (dstAlphaIndex >= 0) {
2716 GLchan *dst = dest;
2717 GLuint i;
2718 for (i = 0; i < n; i++) {
2719 dst[dstAlphaIndex] = FLOAT_TO_CHAN(rgba[i][ACOMP]);
2720 dst += dstComponents;
2721 }
2722 }
2723
2724 if (dstIntensityIndex >= 0) {
2725 GLchan *dst = dest;
2726 GLuint i;
2727 assert(dstIntensityIndex == 0);
2728 assert(dstComponents == 1);
2729 for (i = 0; i < n; i++) {
2730 /* Intensity comes from red channel */
2731 dst[i] = FLOAT_TO_CHAN(rgba[i][RCOMP]);
2732 }
2733 }
2734
2735 if (dstLuminanceIndex >= 0) {
2736 GLchan *dst = dest;
2737 GLuint i;
2738 assert(dstLuminanceIndex == 0);
2739 for (i = 0; i < n; i++) {
2740 /* Luminance comes from red channel */
2741 dst[0] = FLOAT_TO_CHAN(rgba[i][RCOMP]);
2742 dst += dstComponents;
2743 }
2744 }
2745 }
2746 }
2747
2748
2749 void
2750 _mesa_unpack_float_color_span( GLcontext *ctx,
2751 GLuint n, GLenum dstFormat, GLfloat dest[],
2752 GLenum srcFormat, GLenum srcType,
2753 const GLvoid *source,
2754 const struct gl_pixelstore_attrib *srcPacking,
2755 GLuint transferOps, GLboolean clamp )
2756 {
2757 ASSERT(dstFormat == GL_ALPHA ||
2758 dstFormat == GL_LUMINANCE ||
2759 dstFormat == GL_LUMINANCE_ALPHA ||
2760 dstFormat == GL_INTENSITY ||
2761 dstFormat == GL_RGB ||
2762 dstFormat == GL_RGBA ||
2763 dstFormat == GL_COLOR_INDEX);
2764
2765 ASSERT(srcFormat == GL_RED ||
2766 srcFormat == GL_GREEN ||
2767 srcFormat == GL_BLUE ||
2768 srcFormat == GL_ALPHA ||
2769 srcFormat == GL_LUMINANCE ||
2770 srcFormat == GL_LUMINANCE_ALPHA ||
2771 srcFormat == GL_INTENSITY ||
2772 srcFormat == GL_RGB ||
2773 srcFormat == GL_BGR ||
2774 srcFormat == GL_RGBA ||
2775 srcFormat == GL_BGRA ||
2776 srcFormat == GL_ABGR_EXT ||
2777 srcFormat == GL_COLOR_INDEX);
2778
2779 ASSERT(srcType == GL_BITMAP ||
2780 srcType == GL_UNSIGNED_BYTE ||
2781 srcType == GL_BYTE ||
2782 srcType == GL_UNSIGNED_SHORT ||
2783 srcType == GL_SHORT ||
2784 srcType == GL_UNSIGNED_INT ||
2785 srcType == GL_INT ||
2786 srcType == GL_FLOAT ||
2787 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
2788 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
2789 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
2790 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
2791 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
2792 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
2793 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
2794 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
2795 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
2796 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
2797 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
2798 srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
2799
2800 /* this is intended for RGBA mode only */
2801 assert(ctx->Visual.RGBAflag);
2802
2803 /* general solution, no special cases, yet */
2804 {
2805 GLfloat rgba[MAX_WIDTH][4];
2806 GLint dstComponents;
2807 GLint dstRedIndex, dstGreenIndex, dstBlueIndex, dstAlphaIndex;
2808 GLint dstLuminanceIndex, dstIntensityIndex;
2809
2810 dstComponents = _mesa_components_in_format( dstFormat );
2811 /* source & dest image formats should have been error checked by now */
2812 assert(dstComponents > 0);
2813
2814 /*
2815 * Extract image data and convert to RGBA floats
2816 */
2817 assert(n <= MAX_WIDTH);
2818 if (srcFormat == GL_COLOR_INDEX) {
2819 GLuint indexes[MAX_WIDTH];
2820 extract_uint_indexes(n, indexes, srcFormat, srcType, source,
2821 srcPacking);
2822
2823 if (dstFormat == GL_COLOR_INDEX
2824 && (transferOps & IMAGE_MAP_COLOR_BIT)) {
2825 _mesa_map_ci(ctx, n, indexes);
2826 }
2827 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
2828 _mesa_shift_and_offset_ci(ctx, n, indexes);
2829 }
2830
2831 if (dstFormat == GL_COLOR_INDEX) {
2832 /* convert to GLchan and return */
2833 GLuint i;
2834 for (i = 0; i < n; i++) {
2835 dest[i] = (GLchan) (indexes[i] & 0xff);
2836 }
2837 return;
2838 }
2839 else {
2840 /* Convert indexes to RGBA */
2841 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
2842 }
2843 }
2844 else {
2845 extract_float_rgba(n, rgba, srcFormat, srcType, source,
2846 srcPacking->SwapBytes);
2847
2848 /* scale and bias colors */
2849 if (transferOps & IMAGE_SCALE_BIAS_BIT) {
2850 _mesa_scale_and_bias_rgba(ctx, n, rgba);
2851 }
2852 /* color map lookup */
2853 if (transferOps & IMAGE_MAP_COLOR_BIT) {
2854 _mesa_map_rgba(ctx, n, rgba);
2855 }
2856 }
2857
2858 if (transferOps) {
2859 /* GL_COLOR_TABLE lookup */
2860 if (transferOps & IMAGE_COLOR_TABLE_BIT) {
2861 _mesa_lookup_rgba(&ctx->ColorTable, n, rgba);
2862 }
2863 /* convolution */
2864 if (transferOps & IMAGE_CONVOLUTION_BIT) {
2865 /* XXX to do */
2866 }
2867 /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
2868 if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) {
2869 _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, n, rgba);
2870 }
2871 /* color matrix transform */
2872 if (transferOps & IMAGE_COLOR_MATRIX_BIT) {
2873 _mesa_transform_rgba(ctx, n, rgba);
2874 }
2875 /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
2876 if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) {
2877 _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, n, rgba);
2878 }
2879 /* update histogram count */
2880 if (transferOps & IMAGE_HISTOGRAM_BIT) {
2881 _mesa_update_histogram(ctx, n, (CONST GLfloat (*)[4]) rgba);
2882 }
2883 /* min/max here */
2884 if (transferOps & IMAGE_MIN_MAX_BIT) {
2885 _mesa_update_minmax(ctx, n, (CONST GLfloat (*)[4]) rgba);
2886 }
2887 }
2888
2889 /* clamp to [0,1] */
2890 if (clamp) {
2891 GLuint i;
2892 for (i = 0; i < n; i++) {
2893 rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F);
2894 rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F);
2895 rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F);
2896 rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F);
2897 }
2898 }
2899
2900 /* Now determine which color channels we need to produce.
2901 * And determine the dest index (offset) within each color tuple.
2902 */
2903 switch (dstFormat) {
2904 case GL_ALPHA:
2905 dstAlphaIndex = 0;
2906 dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
2907 dstLuminanceIndex = dstIntensityIndex = -1;
2908 break;
2909 case GL_LUMINANCE:
2910 dstLuminanceIndex = 0;
2911 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
2912 dstIntensityIndex = -1;
2913 break;
2914 case GL_LUMINANCE_ALPHA:
2915 dstLuminanceIndex = 0;
2916 dstAlphaIndex = 1;
2917 dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
2918 dstIntensityIndex = -1;
2919 break;
2920 case GL_INTENSITY:
2921 dstIntensityIndex = 0;
2922 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
2923 dstLuminanceIndex = -1;
2924 break;
2925 case GL_RGB:
2926 dstRedIndex = 0;
2927 dstGreenIndex = 1;
2928 dstBlueIndex = 2;
2929 dstAlphaIndex = dstLuminanceIndex = dstIntensityIndex = -1;
2930 break;
2931 case GL_RGBA:
2932 dstRedIndex = 0;
2933 dstGreenIndex = 1;
2934 dstBlueIndex = 2;
2935 dstAlphaIndex = 3;
2936 dstLuminanceIndex = dstIntensityIndex = -1;
2937 break;
2938 default:
2939 gl_problem(ctx, "bad dstFormat in _mesa_unpack_float_color_span()");
2940 return;
2941 }
2942
2943 /* Now pack results in the requested dstFormat */
2944 if (dstRedIndex >= 0) {
2945 GLfloat *dst = dest;
2946 GLuint i;
2947 for (i = 0; i < n; i++) {
2948 dst[dstRedIndex] = rgba[i][RCOMP];
2949 dst += dstComponents;
2950 }
2951 }
2952
2953 if (dstGreenIndex >= 0) {
2954 GLfloat *dst = dest;
2955 GLuint i;
2956 for (i = 0; i < n; i++) {
2957 dst[dstGreenIndex] = rgba[i][GCOMP];
2958 dst += dstComponents;
2959 }
2960 }
2961
2962 if (dstBlueIndex >= 0) {
2963 GLfloat *dst = dest;
2964 GLuint i;
2965 for (i = 0; i < n; i++) {
2966 dst[dstBlueIndex] = rgba[i][BCOMP];
2967 dst += dstComponents;
2968 }
2969 }
2970
2971 if (dstAlphaIndex >= 0) {
2972 GLfloat *dst = dest;
2973 GLuint i;
2974 for (i = 0; i < n; i++) {
2975 dst[dstAlphaIndex] = rgba[i][ACOMP];
2976 dst += dstComponents;
2977 }
2978 }
2979
2980 if (dstIntensityIndex >= 0) {
2981 GLfloat *dst = dest;
2982 GLuint i;
2983 assert(dstIntensityIndex == 0);
2984 assert(dstComponents == 1);
2985 for (i = 0; i < n; i++) {
2986 /* Intensity comes from red channel */
2987 dst[i] = rgba[i][RCOMP];
2988 }
2989 }
2990
2991 if (dstLuminanceIndex >= 0) {
2992 GLfloat *dst = dest;
2993 GLuint i;
2994 assert(dstLuminanceIndex == 0);
2995 for (i = 0; i < n; i++) {
2996 /* Luminance comes from red channel */
2997 dst[0] = rgba[i][RCOMP];
2998 dst += dstComponents;
2999 }
3000 }
3001 }
3002 }
3003
3004
3005
3006
3007 /*
3008 * Unpack a row of color index data from a client buffer according to
3009 * the pixel unpacking parameters.
3010 * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.
3011 *
3012 * Args: ctx - the context
3013 * n - number of pixels
3014 * dstType - destination datatype
3015 * dest - destination array
3016 * srcType - source pixel type
3017 * source - source data pointer
3018 * srcPacking - pixel unpacking parameters
3019 * transferOps - the pixel transfer operations to apply
3020 */
3021 void
3022 _mesa_unpack_index_span( const GLcontext *ctx, GLuint n,
3023 GLenum dstType, GLvoid *dest,
3024 GLenum srcType, const GLvoid *source,
3025 const struct gl_pixelstore_attrib *srcPacking,
3026 GLuint transferOps )
3027 {
3028 ASSERT(srcType == GL_BITMAP ||
3029 srcType == GL_UNSIGNED_BYTE ||
3030 srcType == GL_BYTE ||
3031 srcType == GL_UNSIGNED_SHORT ||
3032 srcType == GL_SHORT ||
3033 srcType == GL_UNSIGNED_INT ||
3034 srcType == GL_INT ||
3035 srcType == GL_FLOAT);
3036
3037 ASSERT(dstType == GL_UNSIGNED_BYTE ||
3038 dstType == GL_UNSIGNED_SHORT ||
3039 dstType == GL_UNSIGNED_INT);
3040
3041
3042 transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
3043
3044 /*
3045 * Try simple cases first
3046 */
3047 if (transferOps == 0 && srcType == GL_UNSIGNED_BYTE
3048 && dstType == GL_UNSIGNED_BYTE) {
3049 MEMCPY(dest, source, n * sizeof(GLubyte));
3050 }
3051 else if (transferOps == 0 && srcType == GL_UNSIGNED_INT
3052 && dstType == GL_UNSIGNED_INT && !srcPacking->SwapBytes) {
3053 MEMCPY(dest, source, n * sizeof(GLuint));
3054 }
3055 else {
3056 /*
3057 * general solution
3058 */
3059 GLuint indexes[MAX_WIDTH];
3060 assert(n <= MAX_WIDTH);
3061
3062 extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
3063 srcPacking);
3064
3065 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
3066 /* shift and offset indexes */
3067 _mesa_shift_and_offset_ci(ctx, n, indexes);
3068 }
3069 if (transferOps & IMAGE_MAP_COLOR_BIT) {
3070 /* Apply lookup table */
3071 _mesa_map_ci(ctx, n, indexes);
3072 }
3073
3074 /* convert to dest type */
3075 switch (dstType) {
3076 case GL_UNSIGNED_BYTE:
3077 {
3078 GLubyte *dst = (GLubyte *) dest;
3079 GLuint i;
3080 for (i = 0; i < n; i++) {
3081 dst[i] = (GLubyte) (indexes[i] & 0xff);
3082 }
3083 }
3084 break;
3085 case GL_UNSIGNED_SHORT:
3086 {
3087 GLuint *dst = (GLuint *) dest;
3088 GLuint i;
3089 for (i = 0; i < n; i++) {
3090 dst[i] = (GLushort) (indexes[i] & 0xffff);
3091 }
3092 }
3093 break;
3094 case GL_UNSIGNED_INT:
3095 MEMCPY(dest, indexes, n * sizeof(GLuint));
3096 break;
3097 default:
3098 gl_problem(ctx, "bad dstType in _mesa_unpack_index_span");
3099 }
3100 }
3101 }
3102
3103
3104 /*
3105 * Unpack a row of stencil data from a client buffer according to
3106 * the pixel unpacking parameters.
3107 * This is (or will be) used by glDrawPixels
3108 *
3109 * Args: ctx - the context
3110 * n - number of pixels
3111 * dstType - destination datatype
3112 * dest - destination array
3113 * srcType - source pixel type
3114 * source - source data pointer
3115 * srcPacking - pixel unpacking parameters
3116 * transferOps - apply offset/bias/lookup ops?
3117 */
3118 void
3119 _mesa_unpack_stencil_span( const GLcontext *ctx, GLuint n,
3120 GLenum dstType, GLvoid *dest,
3121 GLenum srcType, const GLvoid *source,
3122 const struct gl_pixelstore_attrib *srcPacking,
3123 GLuint transferOps )
3124 {
3125 ASSERT(srcType == GL_BITMAP ||
3126 srcType == GL_UNSIGNED_BYTE ||
3127 srcType == GL_BYTE ||
3128 srcType == GL_UNSIGNED_SHORT ||
3129 srcType == GL_SHORT ||
3130 srcType == GL_UNSIGNED_INT ||
3131 srcType == GL_INT ||
3132 srcType == GL_FLOAT);
3133
3134 ASSERT(dstType == GL_UNSIGNED_BYTE ||
3135 dstType == GL_UNSIGNED_SHORT ||
3136 dstType == GL_UNSIGNED_INT);
3137
3138 /* only shift and offset apply to stencil */
3139 transferOps &= IMAGE_SHIFT_OFFSET_BIT;
3140
3141 /*
3142 * Try simple cases first
3143 */
3144 if (transferOps == 0 &&
3145 srcType == GL_UNSIGNED_BYTE &&
3146 dstType == GL_UNSIGNED_BYTE) {
3147 MEMCPY(dest, source, n * sizeof(GLubyte));
3148 }
3149 else if (transferOps == 0 &&
3150 srcType == GL_UNSIGNED_INT &&
3151 dstType == GL_UNSIGNED_INT &&
3152 !srcPacking->SwapBytes) {
3153 MEMCPY(dest, source, n * sizeof(GLuint));
3154 }
3155 else {
3156 /*
3157 * general solution
3158 */
3159 GLuint indexes[MAX_WIDTH];
3160 assert(n <= MAX_WIDTH);
3161
3162 extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
3163 srcPacking);
3164
3165 if (transferOps) {
3166 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
3167 /* shift and offset indexes */
3168 _mesa_shift_and_offset_ci(ctx, n, indexes);
3169 }
3170
3171 if (ctx->Pixel.MapStencilFlag) {
3172 /* Apply stencil lookup table */
3173 GLuint mask = ctx->Pixel.MapStoSsize - 1;
3174 GLuint i;
3175 for (i=0;i<n;i++) {
3176 indexes[i] = ctx->Pixel.MapStoS[ indexes[i] & mask ];
3177 }
3178 }
3179 }
3180
3181 /* convert to dest type */
3182 switch (dstType) {
3183 case GL_UNSIGNED_BYTE:
3184 {
3185 GLubyte *dst = (GLubyte *) dest;
3186 GLuint i;
3187 for (i = 0; i < n; i++) {
3188 dst[i] = (GLubyte) (indexes[i] & 0xff);
3189 }
3190 }
3191 break;
3192 case GL_UNSIGNED_SHORT:
3193 {
3194 GLuint *dst = (GLuint *) dest;
3195 GLuint i;
3196 for (i = 0; i < n; i++) {
3197 dst[i] = (GLushort) (indexes[i] & 0xffff);
3198 }
3199 }
3200 break;
3201 case GL_UNSIGNED_INT:
3202 MEMCPY(dest, indexes, n * sizeof(GLuint));
3203 break;
3204 default:
3205 gl_problem(ctx, "bad dstType in _mesa_unpack_stencil_span");
3206 }
3207 }
3208 }
3209
3210
3211
3212 void
3213 _mesa_unpack_depth_span( const GLcontext *ctx, GLuint n, GLdepth *dest,
3214 GLenum srcType, const GLvoid *source,
3215 const struct gl_pixelstore_attrib *srcPacking,
3216 GLuint transferOps )
3217 {
3218 GLfloat *depth = MALLOC(n * sizeof(GLfloat));
3219 if (!depth)
3220 return;
3221
3222 switch (srcType) {
3223 case GL_BYTE:
3224 {
3225 GLuint i;
3226 const GLubyte *src = (const GLubyte *) source;
3227 for (i = 0; i < n; i++) {
3228 depth[i] = BYTE_TO_FLOAT(src[i]);
3229 }
3230 }
3231 break;
3232 case GL_UNSIGNED_BYTE:
3233 {
3234 GLuint i;
3235 const GLubyte *src = (const GLubyte *) source;
3236 for (i = 0; i < n; i++) {
3237 depth[i] = UBYTE_TO_FLOAT(src[i]);
3238 }
3239 }
3240 break;
3241 case GL_SHORT:
3242 {
3243 GLuint i;
3244 const GLshort *src = (const GLshort *) source;
3245 for (i = 0; i < n; i++) {
3246 depth[i] = SHORT_TO_FLOAT(src[i]);
3247 }
3248 }
3249 break;
3250 case GL_UNSIGNED_SHORT:
3251 {
3252 GLuint i;
3253 const GLushort *src = (const GLushort *) source;
3254 for (i = 0; i < n; i++) {
3255 depth[i] = USHORT_TO_FLOAT(src[i]);
3256 }
3257 }
3258 break;
3259 case GL_INT:
3260 {
3261 GLuint i;
3262 const GLint *src = (const GLint *) source;
3263 for (i = 0; i < n; i++) {
3264 depth[i] = INT_TO_FLOAT(src[i]);
3265 }
3266 }
3267 break;
3268 case GL_UNSIGNED_INT:
3269 {
3270 GLuint i;
3271 const GLuint *src = (const GLuint *) source;
3272 for (i = 0; i < n; i++) {
3273 depth[i] = UINT_TO_FLOAT(src[i]);
3274 }
3275 }
3276 break;
3277 case GL_FLOAT:
3278 MEMCPY(depth, source, n * sizeof(GLfloat));
3279 break;
3280 default:
3281 gl_problem(NULL, "bad type in _mesa_unpack_depth_span()");
3282 FREE(depth);
3283 return;
3284 }
3285
3286
3287 /* apply depth scale and bias */
3288 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
3289 GLuint i;
3290 for (i = 0; i < n; i++) {
3291 depth[i] = depth[i] * ctx->Pixel.DepthScale + ctx->Pixel.DepthBias;
3292 }
3293 }
3294
3295 /* clamp depth values to [0,1] and convert from floats to integers */
3296 {
3297 const GLfloat zs = ctx->Visual.DepthMaxF;
3298 GLuint i;
3299 for (i = 0; i < n; i++) {
3300 dest[i] = (GLdepth) (CLAMP(depth[i], 0.0F, 1.0F) * zs);
3301 }
3302 }
3303
3304 FREE(depth);
3305 }
3306
3307
3308
3309 /*
3310 * Unpack image data. Apply byteswapping, byte flipping (bitmap).
3311 * Return all image data in a contiguous block.
3312 */
3313 void *
3314 _mesa_unpack_image( GLsizei width, GLsizei height, GLsizei depth,
3315 GLenum format, GLenum type, const GLvoid *pixels,
3316 const struct gl_pixelstore_attrib *unpack )
3317 {
3318 GLint bytesPerRow, compsPerRow;
3319 GLboolean flipBytes, swap2, swap4;
3320
3321 if (!pixels)
3322 return NULL; /* not necessarily an error */
3323
3324 if (width <= 0 || height <= 0 || depth <= 0)
3325 return NULL; /* generate error later */
3326
3327 if (format == GL_BITMAP) {
3328 bytesPerRow = (width + 7) >> 3;
3329 flipBytes = !unpack->LsbFirst;
3330 swap2 = swap4 = GL_FALSE;
3331 compsPerRow = 0;
3332 }
3333 else {
3334 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
3335 const GLint components = _mesa_components_in_format(format);
3336 GLint bytesPerComp;
3337 if (bytesPerPixel <= 0 || components <= 0)
3338 return NULL; /* bad format or type. generate error later */
3339 bytesPerRow = bytesPerPixel * width;
3340 bytesPerComp = bytesPerPixel / components;
3341 flipBytes = GL_FALSE;
3342 swap2 = (bytesPerComp == 2) && unpack->SwapBytes;
3343 swap4 = (bytesPerComp == 4) && unpack->SwapBytes;
3344 compsPerRow = components * width;
3345 assert(compsPerRow >= width);
3346 }
3347
3348 {
3349 GLubyte *destBuffer = MALLOC(bytesPerRow * height * depth);
3350 GLubyte *dst;
3351 GLint img, row;
3352 if (!destBuffer)
3353 return NULL; /* generate GL_OUT_OF_MEMORY later */
3354
3355 dst = destBuffer;
3356 for (img = 0; img < depth; img++) {
3357 for (row = 0; row < height; row++) {
3358 const GLvoid *src = _mesa_image_address(unpack, pixels,
3359 width, height, format, type, img, row, 0);
3360 MEMCPY(dst, src, bytesPerRow);
3361 /* byte flipping/swapping */
3362 if (flipBytes) {
3363 flip_bytes((GLubyte *) dst, bytesPerRow);
3364 }
3365 else if (swap2) {
3366 _mesa_swap2((GLushort*) dst, compsPerRow);
3367 }
3368 else if (swap4) {
3369 _mesa_swap4((GLuint*) dst, compsPerRow);
3370 }
3371 dst += bytesPerRow;
3372 }
3373 }
3374 return destBuffer;
3375 }
3376 }