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