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