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