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