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