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