projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Remove clamp parameter from _mesa_unpack_color_span_float(). Pass the
[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 /* clamping to [0,1] */
976 if (transferOps & IMAGE_CLAMP_BIT) {
977 GLuint i;
978 for (i = 0; i < n; i++) {
979 rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F);
980 rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F);
981 rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F);
982 rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F);
983 }
984 }
985 }
986
987
988
989 /*
990 * Used to pack an array [][4] of RGBA GLchan colors as specified
991 * by the dstFormat, dstType and dstPacking. Used by glReadPixels,
992 * glGetConvolutionFilter(), etc.
993 */
994 void
995 _mesa_pack_rgba_span_float( GLcontext *ctx,
996 GLuint n, CONST GLfloat rgbaIn[][4],
997 GLenum dstFormat, GLenum dstType,
998 GLvoid *dstAddr,
999 const struct gl_pixelstore_attrib *dstPacking,
1000 GLuint transferOps )
1001 {
1002 const GLint comps = _mesa_components_in_format(dstFormat);
1003 GLfloat luminance[MAX_WIDTH];
1004 const GLfloat (*rgba)[4];
1005 GLuint i;
1006
1007 if (transferOps) {
1008 /* make copy of incoming data */
1009 DEFMARRAY(GLfloat, rgbaCopy, MAX_WIDTH, 4); /* mac 32k limitation */
1010 CHECKARRAY(rgbaCopy, return); /* mac 32k limitation */
1011
1012 _mesa_memcpy(rgbaCopy, rgbaIn, n * 4 * sizeof(GLfloat));
1013 _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgbaCopy);
1014 rgba = (const GLfloat (*)[4]) rgbaCopy;
1015
1016 if ((transferOps & IMAGE_MIN_MAX_BIT) && ctx->MinMax.Sink) {
1017 UNDEFARRAY(rgbaCopy); /* mac 32k limitation */
1018 return;
1019 }
1020 UNDEFARRAY(rgbaCopy); /* mac 32k limitation */
1021 }
1022 else {
1023 /* use incoming data, not a copy */
1024 rgba = (const GLfloat (*)[4]) rgbaIn;
1025 }
1026
1027 if (dstFormat == GL_LUMINANCE || dstFormat == GL_LUMINANCE_ALPHA) {
1028 /* compute luminance values */
1029 if (ctx->ClampFragmentColors) {
1030 for (i = 0; i < n; i++) {
1031 GLfloat sum = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
1032 luminance[i] = CLAMP(sum, 0.0F, 1.0F);
1033 }
1034 }
1035 else {
1036 for (i = 0; i < n; i++) {
1037 luminance[i] = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
1038 }
1039 }
1040 }
1041
1042 /*
1043 * Pack/store the pixels. Ugh! Lots of cases!!!
1044 */
1045 switch (dstType) {
1046 case GL_UNSIGNED_BYTE:
1047 {
1048 GLubyte *dst = (GLubyte *) dstAddr;
1049 switch (dstFormat) {
1050 case GL_RED:
1051 for (i=0;i<n;i++)
1052 dst[i] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
1053 break;
1054 case GL_GREEN:
1055 for (i=0;i<n;i++)
1056 dst[i] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
1057 break;
1058 case GL_BLUE:
1059 for (i=0;i<n;i++)
1060 dst[i] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
1061 break;
1062 case GL_ALPHA:
1063 for (i=0;i<n;i++)
1064 dst[i] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
1065 break;
1066 case GL_LUMINANCE:
1067 for (i=0;i<n;i++)
1068 dst[i] = FLOAT_TO_UBYTE(luminance[i]);
1069 break;
1070 case GL_LUMINANCE_ALPHA:
1071 for (i=0;i<n;i++) {
1072 dst[i*2+0] = FLOAT_TO_UBYTE(luminance[i]);
1073 dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
1074 }
1075 break;
1076 case GL_RGB:
1077 for (i=0;i<n;i++) {
1078 dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
1079 dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
1080 dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
1081 }
1082 break;
1083 case GL_RGBA:
1084 for (i=0;i<n;i++) {
1085 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
1086 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
1087 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
1088 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
1089 }
1090 break;
1091 case GL_BGR:
1092 for (i=0;i<n;i++) {
1093 dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
1094 dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
1095 dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
1096 }
1097 break;
1098 case GL_BGRA:
1099 for (i=0;i<n;i++) {
1100 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
1101 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
1102 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
1103 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
1104 }
1105 break;
1106 case GL_ABGR_EXT:
1107 for (i=0;i<n;i++) {
1108 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
1109 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
1110 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
1111 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
1112 }
1113 break;
1114 default:
1115 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1116 }
1117 }
1118 break;
1119 case GL_BYTE:
1120 {
1121 GLbyte *dst = (GLbyte *) dstAddr;
1122 switch (dstFormat) {
1123 case GL_RED:
1124 for (i=0;i<n;i++)
1125 dst[i] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
1126 break;
1127 case GL_GREEN:
1128 for (i=0;i<n;i++)
1129 dst[i] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
1130 break;
1131 case GL_BLUE:
1132 for (i=0;i<n;i++)
1133 dst[i] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
1134 break;
1135 case GL_ALPHA:
1136 for (i=0;i<n;i++)
1137 dst[i] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
1138 break;
1139 case GL_LUMINANCE:
1140 for (i=0;i<n;i++)
1141 dst[i] = FLOAT_TO_BYTE(luminance[i]);
1142 break;
1143 case GL_LUMINANCE_ALPHA:
1144 for (i=0;i<n;i++) {
1145 dst[i*2+0] = FLOAT_TO_BYTE(luminance[i]);
1146 dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
1147 }
1148 break;
1149 case GL_RGB:
1150 for (i=0;i<n;i++) {
1151 dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
1152 dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
1153 dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
1154 }
1155 break;
1156 case GL_RGBA:
1157 for (i=0;i<n;i++) {
1158 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
1159 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
1160 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
1161 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
1162 }
1163 break;
1164 case GL_BGR:
1165 for (i=0;i<n;i++) {
1166 dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
1167 dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
1168 dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
1169 }
1170 break;
1171 case GL_BGRA:
1172 for (i=0;i<n;i++) {
1173 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
1174 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
1175 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
1176 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
1177 }
1178 case GL_ABGR_EXT:
1179 for (i=0;i<n;i++) {
1180 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
1181 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
1182 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
1183 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
1184 }
1185 break;
1186 default:
1187 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1188 }
1189 }
1190 break;
1191 case GL_UNSIGNED_SHORT:
1192 {
1193 GLushort *dst = (GLushort *) dstAddr;
1194 switch (dstFormat) {
1195 case GL_RED:
1196 for (i=0;i<n;i++)
1197 dst[i] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
1198 break;
1199 case GL_GREEN:
1200 for (i=0;i<n;i++)
1201 dst[i] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
1202 break;
1203 case GL_BLUE:
1204 for (i=0;i<n;i++)
1205 dst[i] = FLOAT_TO_USHORT(rgba[i][BCOMP]);
1206 break;
1207 case GL_ALPHA:
1208 for (i=0;i<n;i++)
1209 dst[i] = FLOAT_TO_USHORT(rgba[i][ACOMP]);
1210 break;
1211 case GL_LUMINANCE:
1212 for (i=0;i<n;i++)
1213 dst[i] = FLOAT_TO_USHORT(luminance[i]);
1214 break;
1215 case GL_LUMINANCE_ALPHA:
1216 for (i=0;i<n;i++) {
1217 dst[i*2+0] = FLOAT_TO_USHORT(luminance[i]);
1218 dst[i*2+1] = FLOAT_TO_USHORT(rgba[i][ACOMP]);
1219 }
1220 break;
1221 case GL_RGB:
1222 for (i=0;i<n;i++) {
1223 dst[i*3+0] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
1224 dst[i*3+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
1225 dst[i*3+2] = FLOAT_TO_USHORT(rgba[i][BCOMP]);
1226 }
1227 break;
1228 case GL_RGBA:
1229 for (i=0;i<n;i++) {
1230 dst[i*4+0] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
1231 dst[i*4+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
1232 dst[i*4+2] = FLOAT_TO_USHORT(rgba[i][BCOMP]);
1233 dst[i*4+3] = FLOAT_TO_USHORT(rgba[i][ACOMP]);
1234 }
1235 break;
1236 case GL_BGR:
1237 for (i=0;i<n;i++) {
1238 dst[i*3+0] = FLOAT_TO_USHORT(rgba[i][BCOMP]);
1239 dst[i*3+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
1240 dst[i*3+2] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
1241 }
1242 break;
1243 case GL_BGRA:
1244 for (i=0;i<n;i++) {
1245 dst[i*4+0] = FLOAT_TO_USHORT(rgba[i][BCOMP]);
1246 dst[i*4+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
1247 dst[i*4+2] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
1248 dst[i*4+3] = FLOAT_TO_USHORT(rgba[i][ACOMP]);
1249 }
1250 break;
1251 case GL_ABGR_EXT:
1252 for (i=0;i<n;i++) {
1253 dst[i*4+0] = FLOAT_TO_USHORT(rgba[i][ACOMP]);
1254 dst[i*4+1] = FLOAT_TO_USHORT(rgba[i][BCOMP]);
1255 dst[i*4+2] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
1256 dst[i*4+3] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
1257 }
1258 break;
1259 default:
1260 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1261 }
1262 if (dstPacking->SwapBytes) {
1263 _mesa_swap2( (GLushort *) dst, n * comps);
1264 }
1265 }
1266 break;
1267 case GL_SHORT:
1268 {
1269 GLshort *dst = (GLshort *) dstAddr;
1270 switch (dstFormat) {
1271 case GL_RED:
1272 for (i=0;i<n;i++)
1273 dst[i] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1274 break;
1275 case GL_GREEN:
1276 for (i=0;i<n;i++)
1277 dst[i] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1278 break;
1279 case GL_BLUE:
1280 for (i=0;i<n;i++)
1281 dst[i] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1282 break;
1283 case GL_ALPHA:
1284 for (i=0;i<n;i++)
1285 dst[i] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1286 break;
1287 case GL_LUMINANCE:
1288 for (i=0;i<n;i++)
1289 dst[i] = FLOAT_TO_SHORT(luminance[i]);
1290 break;
1291 case GL_LUMINANCE_ALPHA:
1292 for (i=0;i<n;i++) {
1293 dst[i*2+0] = FLOAT_TO_SHORT(luminance[i]);
1294 dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1295 }
1296 break;
1297 case GL_RGB:
1298 for (i=0;i<n;i++) {
1299 dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1300 dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1301 dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1302 }
1303 break;
1304 case GL_RGBA:
1305 for (i=0;i<n;i++) {
1306 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1307 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1308 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1309 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1310 }
1311 break;
1312 case GL_BGR:
1313 for (i=0;i<n;i++) {
1314 dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1315 dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1316 dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1317 }
1318 break;
1319 case GL_BGRA:
1320 for (i=0;i<n;i++) {
1321 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1322 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1323 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1324 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1325 }
1326 case GL_ABGR_EXT:
1327 for (i=0;i<n;i++) {
1328 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1329 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1330 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1331 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1332 }
1333 break;
1334 default:
1335 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1336 }
1337 if (dstPacking->SwapBytes) {
1338 _mesa_swap2( (GLushort *) dst, n * comps );
1339 }
1340 }
1341 break;
1342 case GL_UNSIGNED_INT:
1343 {
1344 GLuint *dst = (GLuint *) dstAddr;
1345 switch (dstFormat) {
1346 case GL_RED:
1347 for (i=0;i<n;i++)
1348 dst[i] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1349 break;
1350 case GL_GREEN:
1351 for (i=0;i<n;i++)
1352 dst[i] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1353 break;
1354 case GL_BLUE:
1355 for (i=0;i<n;i++)
1356 dst[i] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1357 break;
1358 case GL_ALPHA:
1359 for (i=0;i<n;i++)
1360 dst[i] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1361 break;
1362 case GL_LUMINANCE:
1363 for (i=0;i<n;i++)
1364 dst[i] = FLOAT_TO_UINT(luminance[i]);
1365 break;
1366 case GL_LUMINANCE_ALPHA:
1367 for (i=0;i<n;i++) {
1368 dst[i*2+0] = FLOAT_TO_UINT(luminance[i]);
1369 dst[i*2+1] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1370 }
1371 break;
1372 case GL_RGB:
1373 for (i=0;i<n;i++) {
1374 dst[i*3+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1375 dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1376 dst[i*3+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1377 }
1378 break;
1379 case GL_RGBA:
1380 for (i=0;i<n;i++) {
1381 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1382 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1383 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1384 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1385 }
1386 break;
1387 case GL_BGR:
1388 for (i=0;i<n;i++) {
1389 dst[i*3+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1390 dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1391 dst[i*3+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1392 }
1393 break;
1394 case GL_BGRA:
1395 for (i=0;i<n;i++) {
1396 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1397 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1398 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1399 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1400 }
1401 break;
1402 case GL_ABGR_EXT:
1403 for (i=0;i<n;i++) {
1404 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1405 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1406 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1407 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1408 }
1409 break;
1410 default:
1411 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1412 }
1413 if (dstPacking->SwapBytes) {
1414 _mesa_swap4( (GLuint *) dst, n * comps );
1415 }
1416 }
1417 break;
1418 case GL_INT:
1419 {
1420 GLint *dst = (GLint *) dstAddr;
1421 switch (dstFormat) {
1422 case GL_RED:
1423 for (i=0;i<n;i++)
1424 dst[i] = FLOAT_TO_INT(rgba[i][RCOMP]);
1425 break;
1426 case GL_GREEN:
1427 for (i=0;i<n;i++)
1428 dst[i] = FLOAT_TO_INT(rgba[i][GCOMP]);
1429 break;
1430 case GL_BLUE:
1431 for (i=0;i<n;i++)
1432 dst[i] = FLOAT_TO_INT(rgba[i][BCOMP]);
1433 break;
1434 case GL_ALPHA:
1435 for (i=0;i<n;i++)
1436 dst[i] = FLOAT_TO_INT(rgba[i][ACOMP]);
1437 break;
1438 case GL_LUMINANCE:
1439 for (i=0;i<n;i++)
1440 dst[i] = FLOAT_TO_INT(luminance[i]);
1441 break;
1442 case GL_LUMINANCE_ALPHA:
1443 for (i=0;i<n;i++) {
1444 dst[i*2+0] = FLOAT_TO_INT(luminance[i]);
1445 dst[i*2+1] = FLOAT_TO_INT(rgba[i][ACOMP]);
1446 }
1447 break;
1448 case GL_RGB:
1449 for (i=0;i<n;i++) {
1450 dst[i*3+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
1451 dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1452 dst[i*3+2] = FLOAT_TO_INT(rgba[i][BCOMP]);
1453 }
1454 break;
1455 case GL_RGBA:
1456 for (i=0;i<n;i++) {
1457 dst[i*4+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
1458 dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1459 dst[i*4+2] = FLOAT_TO_INT(rgba[i][BCOMP]);
1460 dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);
1461 }
1462 break;
1463 case GL_BGR:
1464 for (i=0;i<n;i++) {
1465 dst[i*3+0] = FLOAT_TO_INT(rgba[i][BCOMP]);
1466 dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1467 dst[i*3+2] = FLOAT_TO_INT(rgba[i][RCOMP]);
1468 }
1469 break;
1470 case GL_BGRA:
1471 for (i=0;i<n;i++) {
1472 dst[i*4+0] = FLOAT_TO_INT(rgba[i][BCOMP]);
1473 dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1474 dst[i*4+2] = FLOAT_TO_INT(rgba[i][RCOMP]);
1475 dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);
1476 }
1477 break;
1478 case GL_ABGR_EXT:
1479 for (i=0;i<n;i++) {
1480 dst[i*4+0] = FLOAT_TO_INT(rgba[i][ACOMP]);
1481 dst[i*4+1] = FLOAT_TO_INT(rgba[i][BCOMP]);
1482 dst[i*4+2] = FLOAT_TO_INT(rgba[i][GCOMP]);
1483 dst[i*4+3] = FLOAT_TO_INT(rgba[i][RCOMP]);
1484 }
1485 break;
1486 default:
1487 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1488 }
1489 if (dstPacking->SwapBytes) {
1490 _mesa_swap4( (GLuint *) dst, n * comps );
1491 }
1492 }
1493 break;
1494 case GL_FLOAT:
1495 {
1496 GLfloat *dst = (GLfloat *) dstAddr;
1497 switch (dstFormat) {
1498 case GL_RED:
1499 for (i=0;i<n;i++)
1500 dst[i] = rgba[i][RCOMP];
1501 break;
1502 case GL_GREEN:
1503 for (i=0;i<n;i++)
1504 dst[i] = rgba[i][GCOMP];
1505 break;
1506 case GL_BLUE:
1507 for (i=0;i<n;i++)
1508 dst[i] = rgba[i][BCOMP];
1509 break;
1510 case GL_ALPHA:
1511 for (i=0;i<n;i++)
1512 dst[i] = rgba[i][ACOMP];
1513 break;
1514 case GL_LUMINANCE:
1515 for (i=0;i<n;i++)
1516 dst[i] = luminance[i];
1517 break;
1518 case GL_LUMINANCE_ALPHA:
1519 for (i=0;i<n;i++) {
1520 dst[i*2+0] = luminance[i];
1521 dst[i*2+1] = rgba[i][ACOMP];
1522 }
1523 break;
1524 case GL_RGB:
1525 for (i=0;i<n;i++) {
1526 dst[i*3+0] = rgba[i][RCOMP];
1527 dst[i*3+1] = rgba[i][GCOMP];
1528 dst[i*3+2] = rgba[i][BCOMP];
1529 }
1530 break;
1531 case GL_RGBA:
1532 for (i=0;i<n;i++) {
1533 dst[i*4+0] = rgba[i][RCOMP];
1534 dst[i*4+1] = rgba[i][GCOMP];
1535 dst[i*4+2] = rgba[i][BCOMP];
1536 dst[i*4+3] = rgba[i][ACOMP];
1537 }
1538 break;
1539 case GL_BGR:
1540 for (i=0;i<n;i++) {
1541 dst[i*3+0] = rgba[i][BCOMP];
1542 dst[i*3+1] = rgba[i][GCOMP];
1543 dst[i*3+2] = rgba[i][RCOMP];
1544 }
1545 break;
1546 case GL_BGRA:
1547 for (i=0;i<n;i++) {
1548 dst[i*4+0] = rgba[i][BCOMP];
1549 dst[i*4+1] = rgba[i][GCOMP];
1550 dst[i*4+2] = rgba[i][RCOMP];
1551 dst[i*4+3] = rgba[i][ACOMP];
1552 }
1553 break;
1554 case GL_ABGR_EXT:
1555 for (i=0;i<n;i++) {
1556 dst[i*4+0] = rgba[i][ACOMP];
1557 dst[i*4+1] = rgba[i][BCOMP];
1558 dst[i*4+2] = rgba[i][GCOMP];
1559 dst[i*4+3] = rgba[i][RCOMP];
1560 }
1561 break;
1562 default:
1563 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1564 }
1565 if (dstPacking->SwapBytes) {
1566 _mesa_swap4( (GLuint *) dst, n * comps );
1567 }
1568 }
1569 break;
1570 case GL_HALF_FLOAT_NV:
1571 {
1572 GLhalfNV *dst = (GLhalfNV *) dstAddr;
1573 switch (dstFormat) {
1574 case GL_RED:
1575 for (i=0;i<n;i++)
1576 dst[i] = _mesa_float_to_half(rgba[i][RCOMP]);
1577 break;
1578 case GL_GREEN:
1579 for (i=0;i<n;i++)
1580 dst[i] = _mesa_float_to_half(rgba[i][GCOMP]);
1581 break;
1582 case GL_BLUE:
1583 for (i=0;i<n;i++)
1584 dst[i] = _mesa_float_to_half(rgba[i][BCOMP]);
1585 break;
1586 case GL_ALPHA:
1587 for (i=0;i<n;i++)
1588 dst[i] = _mesa_float_to_half(rgba[i][ACOMP]);
1589 break;
1590 case GL_LUMINANCE:
1591 for (i=0;i<n;i++)
1592 dst[i] = _mesa_float_to_half(luminance[i]);
1593 break;
1594 case GL_LUMINANCE_ALPHA:
1595 for (i=0;i<n;i++) {
1596 dst[i*2+0] = _mesa_float_to_half(luminance[i]);
1597 dst[i*2+1] = _mesa_float_to_half(rgba[i][ACOMP]);
1598 }
1599 break;
1600 case GL_RGB:
1601 for (i=0;i<n;i++) {
1602 dst[i*3+0] = _mesa_float_to_half(rgba[i][RCOMP]);
1603 dst[i*3+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1604 dst[i*3+2] = _mesa_float_to_half(rgba[i][BCOMP]);
1605 }
1606 break;
1607 case GL_RGBA:
1608 for (i=0;i<n;i++) {
1609 dst[i*4+0] = _mesa_float_to_half(rgba[i][RCOMP]);
1610 dst[i*4+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1611 dst[i*4+2] = _mesa_float_to_half(rgba[i][BCOMP]);
1612 dst[i*4+3] = _mesa_float_to_half(rgba[i][ACOMP]);
1613 }
1614 break;
1615 case GL_BGR:
1616 for (i=0;i<n;i++) {
1617 dst[i*3+0] = _mesa_float_to_half(rgba[i][BCOMP]);
1618 dst[i*3+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1619 dst[i*3+2] = _mesa_float_to_half(rgba[i][RCOMP]);
1620 }
1621 break;
1622 case GL_BGRA:
1623 for (i=0;i<n;i++) {
1624 dst[i*4+0] = _mesa_float_to_half(rgba[i][BCOMP]);
1625 dst[i*4+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1626 dst[i*4+2] = _mesa_float_to_half(rgba[i][RCOMP]);
1627 dst[i*4+3] = _mesa_float_to_half(rgba[i][ACOMP]);
1628 }
1629 break;
1630 case GL_ABGR_EXT:
1631 for (i=0;i<n;i++) {
1632 dst[i*4+0] = _mesa_float_to_half(rgba[i][ACOMP]);
1633 dst[i*4+1] = _mesa_float_to_half(rgba[i][BCOMP]);
1634 dst[i*4+2] = _mesa_float_to_half(rgba[i][GCOMP]);
1635 dst[i*4+3] = _mesa_float_to_half(rgba[i][RCOMP]);
1636 }
1637 break;
1638 default:
1639 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1640 }
1641 if (dstPacking->SwapBytes) {
1642 _mesa_swap2( (GLushort *) dst, n * comps );
1643 }
1644 }
1645 break;
1646 case GL_UNSIGNED_BYTE_3_3_2:
1647 if (dstFormat == GL_RGB) {
1648 GLubyte *dst = (GLubyte *) dstAddr;
1649 for (i=0;i<n;i++) {
1650 dst[i] = (((GLint) (rgba[i][RCOMP] * 7.0F)) << 5)
1651 | (((GLint) (rgba[i][GCOMP] * 7.0F)) << 2)
1652 | (((GLint) (rgba[i][BCOMP] * 3.0F)) );
1653 }
1654 }
1655 break;
1656 case GL_UNSIGNED_BYTE_2_3_3_REV:
1657 if (dstFormat == GL_RGB) {
1658 GLubyte *dst = (GLubyte *) dstAddr;
1659 for (i=0;i<n;i++) {
1660 dst[i] = (((GLint) (rgba[i][RCOMP] * 7.0F)) )
1661 | (((GLint) (rgba[i][GCOMP] * 7.0F)) << 3)
1662 | (((GLint) (rgba[i][BCOMP] * 3.0F)) << 5);
1663 }
1664 }
1665 break;
1666 case GL_UNSIGNED_SHORT_5_6_5:
1667 if (dstFormat == GL_RGB) {
1668 GLushort *dst = (GLushort *) dstAddr;
1669 for (i=0;i<n;i++) {
1670 dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) << 11)
1671 | (((GLint) (rgba[i][GCOMP] * 63.0F)) << 5)
1672 | (((GLint) (rgba[i][BCOMP] * 31.0F)) );
1673 }
1674 }
1675 break;
1676 case GL_UNSIGNED_SHORT_5_6_5_REV:
1677 if (dstFormat == GL_RGB) {
1678 GLushort *dst = (GLushort *) dstAddr;
1679 for (i=0;i<n;i++) {
1680 dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) )
1681 | (((GLint) (rgba[i][GCOMP] * 63.0F)) << 5)
1682 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 11);
1683 }
1684 }
1685 break;
1686 case GL_UNSIGNED_SHORT_4_4_4_4:
1687 if (dstFormat == GL_RGBA) {
1688 GLushort *dst = (GLushort *) dstAddr;
1689 for (i=0;i<n;i++) {
1690 dst[i] = (((GLint) (rgba[i][RCOMP] * 15.0F)) << 12)
1691 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 8)
1692 | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 4)
1693 | (((GLint) (rgba[i][ACOMP] * 15.0F)) );
1694 }
1695 }
1696 else if (dstFormat == GL_BGRA) {
1697 GLushort *dst = (GLushort *) dstAddr;
1698 for (i=0;i<n;i++) {
1699 dst[i] = (((GLint) (rgba[i][BCOMP] * 15.0F)) << 12)
1700 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 8)
1701 | (((GLint) (rgba[i][RCOMP] * 15.0F)) << 4)
1702 | (((GLint) (rgba[i][ACOMP] * 15.0F)) );
1703 }
1704 }
1705 else if (dstFormat == GL_ABGR_EXT) {
1706 GLushort *dst = (GLushort *) dstAddr;
1707 for (i=0;i<n;i++) {
1708 dst[i] = (((GLint) (rgba[i][ACOMP] * 15.0F)) << 4)
1709 | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 8)
1710 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 12)
1711 | (((GLint) (rgba[i][RCOMP] * 15.0F)) );
1712 }
1713 }
1714 break;
1715 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1716 if (dstFormat == GL_RGBA) {
1717 GLushort *dst = (GLushort *) dstAddr;
1718 for (i=0;i<n;i++) {
1719 dst[i] = (((GLint) (rgba[i][RCOMP] * 15.0F)) )
1720 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 4)
1721 | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 8)
1722 | (((GLint) (rgba[i][ACOMP] * 15.0F)) << 12);
1723 }
1724 }
1725 else if (dstFormat == GL_BGRA) {
1726 GLushort *dst = (GLushort *) dstAddr;
1727 for (i=0;i<n;i++) {
1728 dst[i] = (((GLint) (rgba[i][BCOMP] * 15.0F)) )
1729 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 4)
1730 | (((GLint) (rgba[i][RCOMP] * 15.0F)) << 8)
1731 | (((GLint) (rgba[i][ACOMP] * 15.0F)) << 12);
1732 }
1733 }
1734 else if (dstFormat == GL_ABGR_EXT) {
1735 GLushort *dst = (GLushort *) dstAddr;
1736 for (i=0;i<n;i++) {
1737 dst[i] = (((GLint) (rgba[i][ACOMP] * 15.0F)) )
1738 | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 4)
1739 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 8)
1740 | (((GLint) (rgba[i][RCOMP] * 15.0F)) << 12);
1741 }
1742 }
1743 break;
1744 case GL_UNSIGNED_SHORT_5_5_5_1:
1745 if (dstFormat == GL_RGBA) {
1746 GLushort *dst = (GLushort *) dstAddr;
1747 for (i=0;i<n;i++) {
1748 dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) << 11)
1749 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 6)
1750 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 1)
1751 | (((GLint) (rgba[i][ACOMP] * 1.0F)) );
1752 }
1753 }
1754 else if (dstFormat == GL_BGRA) {
1755 GLushort *dst = (GLushort *) dstAddr;
1756 for (i=0;i<n;i++) {
1757 dst[i] = (((GLint) (rgba[i][BCOMP] * 31.0F)) << 11)
1758 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 6)
1759 | (((GLint) (rgba[i][RCOMP] * 31.0F)) << 1)
1760 | (((GLint) (rgba[i][ACOMP] * 1.0F)) );
1761 }
1762 }
1763 else if (dstFormat == GL_ABGR_EXT) {
1764 GLushort *dst = (GLushort *) dstAddr;
1765 for (i=0;i<n;i++) {
1766 dst[i] = (((GLint) (rgba[i][ACOMP] * 31.0F)) << 11)
1767 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 6)
1768 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 1)
1769 | (((GLint) (rgba[i][RCOMP] * 1.0F)) );
1770 }
1771 }
1772 break;
1773 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1774 if (dstFormat == GL_RGBA) {
1775 GLushort *dst = (GLushort *) dstAddr;
1776 for (i=0;i<n;i++) {
1777 dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) )
1778 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 5)
1779 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 10)
1780 | (((GLint) (rgba[i][ACOMP] * 1.0F)) << 15);
1781 }
1782 }
1783 else if (dstFormat == GL_BGRA) {
1784 GLushort *dst = (GLushort *) dstAddr;
1785 for (i=0;i<n;i++) {
1786 dst[i] = (((GLint) (rgba[i][BCOMP] * 31.0F)) )
1787 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 5)
1788 | (((GLint) (rgba[i][RCOMP] * 31.0F)) << 10)
1789 | (((GLint) (rgba[i][ACOMP] * 1.0F)) << 15);
1790 }
1791 }
1792 else if (dstFormat == GL_ABGR_EXT) {
1793 GLushort *dst = (GLushort *) dstAddr;
1794 for (i=0;i<n;i++) {
1795 dst[i] = (((GLint) (rgba[i][ACOMP] * 31.0F)) )
1796 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 5)
1797 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 10)
1798 | (((GLint) (rgba[i][RCOMP] * 1.0F)) << 15);
1799 }
1800 }
1801 break;
1802 case GL_UNSIGNED_INT_8_8_8_8:
1803 if (dstFormat == GL_RGBA) {
1804 GLuint *dst = (GLuint *) dstAddr;
1805 for (i=0;i<n;i++) {
1806 dst[i] = (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 24)
1807 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16)
1808 | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 8)
1809 | (((GLuint) (rgba[i][ACOMP] * 255.0F)) );
1810 }
1811 }
1812 else if (dstFormat == GL_BGRA) {
1813 GLuint *dst = (GLuint *) dstAddr;
1814 for (i=0;i<n;i++) {
1815 dst[i] = (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 24)
1816 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16)
1817 | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 8)
1818 | (((GLuint) (rgba[i][ACOMP] * 255.0F)) );
1819 }
1820 }
1821 else if (dstFormat == GL_ABGR_EXT) {
1822 GLuint *dst = (GLuint *) dstAddr;
1823 for (i=0;i<n;i++) {
1824 dst[i] = (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24)
1825 | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 16)
1826 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 8)
1827 | (((GLuint) (rgba[i][RCOMP] * 255.0F)) );
1828 }
1829 }
1830 break;
1831 case GL_UNSIGNED_INT_8_8_8_8_REV:
1832 if (dstFormat == GL_RGBA) {
1833 GLuint *dst = (GLuint *) dstAddr;
1834 for (i=0;i<n;i++) {
1835 dst[i] = (((GLuint) (rgba[i][RCOMP] * 255.0F)) )
1836 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 8)
1837 | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 16)
1838 | (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24);
1839 }
1840 }
1841 else if (dstFormat == GL_BGRA) {
1842 GLuint *dst = (GLuint *) dstAddr;
1843 for (i=0;i<n;i++) {
1844 dst[i] = (((GLuint) (rgba[i][BCOMP] * 255.0F)) )
1845 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 8)
1846 | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 16)
1847 | (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24);
1848 }
1849 }
1850 else if (dstFormat == GL_ABGR_EXT) {
1851 GLuint *dst = (GLuint *) dstAddr;
1852 for (i=0;i<n;i++) {
1853 dst[i] = (((GLuint) (rgba[i][ACOMP] * 255.0F)) )
1854 | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 8)
1855 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16)
1856 | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 24);
1857 }
1858 }
1859 break;
1860 case GL_UNSIGNED_INT_10_10_10_2:
1861 if (dstFormat == GL_RGBA) {
1862 GLuint *dst = (GLuint *) dstAddr;
1863 for (i=0;i<n;i++) {
1864 dst[i] = (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 22)
1865 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 12)
1866 | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 2)
1867 | (((GLuint) (rgba[i][ACOMP] * 3.0F)) );
1868 }
1869 }
1870 else if (dstFormat == GL_BGRA) {
1871 GLuint *dst = (GLuint *) dstAddr;
1872 for (i=0;i<n;i++) {
1873 dst[i] = (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 22)
1874 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 12)
1875 | (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 2)
1876 | (((GLuint) (rgba[i][ACOMP] * 3.0F)) );
1877 }
1878 }
1879 else if (dstFormat == GL_ABGR_EXT) {
1880 GLuint *dst = (GLuint *) dstAddr;
1881 for (i=0;i<n;i++) {
1882 dst[i] = (((GLuint) (rgba[i][ACOMP] * 1023.0F)) << 22)
1883 | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 12)
1884 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 2)
1885 | (((GLuint) (rgba[i][RCOMP] * 3.0F)) );
1886 }
1887 }
1888 break;
1889 case GL_UNSIGNED_INT_2_10_10_10_REV:
1890 if (dstFormat == GL_RGBA) {
1891 GLuint *dst = (GLuint *) dstAddr;
1892 for (i=0;i<n;i++) {
1893 dst[i] = (((GLuint) (rgba[i][RCOMP] * 1023.0F)) )
1894 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 10)
1895 | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 20)
1896 | (((GLuint) (rgba[i][ACOMP] * 3.0F)) << 30);
1897 }
1898 }
1899 else if (dstFormat == GL_BGRA) {
1900 GLuint *dst = (GLuint *) dstAddr;
1901 for (i=0;i<n;i++) {
1902 dst[i] = (((GLuint) (rgba[i][BCOMP] * 1023.0F)) )
1903 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 10)
1904 | (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 20)
1905 | (((GLuint) (rgba[i][ACOMP] * 3.0F)) << 30);
1906 }
1907 }
1908 else if (dstFormat == GL_ABGR_EXT) {
1909 GLuint *dst = (GLuint *) dstAddr;
1910 for (i=0;i<n;i++) {
1911 dst[i] = (((GLuint) (rgba[i][ACOMP] * 1023.0F)) )
1912 | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 10)
1913 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 20)
1914 | (((GLuint) (rgba[i][RCOMP] * 3.0F)) << 30);
1915 }
1916 }
1917 break;
1918 default:
1919 _mesa_problem(ctx, "bad type in _mesa_pack_rgba_span_float");
1920 }
1921 }
1922
1923
1924 /*
1925 * Pack the given RGBA span into client memory at 'dest' address
1926 * in the given pixel format and type.
1927 * Optionally apply the enabled pixel transfer ops.
1928 * Pack into memory using the given packing params struct.
1929 * This is used by glReadPixels and glGetTexImage?D()
1930 * \param ctx - the context
1931 * n - number of pixels in the span
1932 * rgba - the pixels
1933 * format - dest packing format
1934 * type - dest packing data type
1935 * destination - destination packing address
1936 * packing - pixel packing parameters
1937 * transferOps - bitmask of IMAGE_*_BIT operations to apply
1938 */
1939 void
1940 _mesa_pack_rgba_span_chan( GLcontext *ctx,
1941 GLuint n, CONST GLchan srcRgba[][4],
1942 GLenum dstFormat, GLenum dstType,
1943 GLvoid *dstAddr,
1944 const struct gl_pixelstore_attrib *dstPacking,
1945 GLuint transferOps)
1946 {
1947 ASSERT((ctx->NewState & _NEW_PIXEL) == 0 || transferOps == 0);
1948
1949 /* Test for optimized case first */
1950 if (transferOps == 0 && dstFormat == GL_RGBA && dstType == CHAN_TYPE) {
1951 /* common simple case */
1952 MEMCPY(dstAddr, srcRgba, n * 4 * sizeof(GLchan));
1953 }
1954 else if (transferOps == 0 && dstFormat == GL_RGB && dstType == CHAN_TYPE) {
1955 /* common simple case */
1956 GLuint i;
1957 GLchan *dest = (GLchan *) dstAddr;
1958 for (i = 0; i < n; i++) {
1959 dest[0] = srcRgba[i][RCOMP];
1960 dest[1] = srcRgba[i][GCOMP];
1961 dest[2] = srcRgba[i][BCOMP];
1962 dest += 3;
1963 }
1964 }
1965 else if (transferOps == 0 && dstFormat == GL_RGBA && dstType == GL_UNSIGNED_BYTE) {
1966 /* common simple case */
1967 GLuint i;
1968 GLubyte *dest = (GLubyte *) dstAddr;
1969 for (i = 0; i < n; i++) {
1970 dest[0] = CHAN_TO_UBYTE(srcRgba[i][RCOMP]);
1971 dest[1] = CHAN_TO_UBYTE(srcRgba[i][GCOMP]);
1972 dest[2] = CHAN_TO_UBYTE(srcRgba[i][BCOMP]);
1973 dest[3] = CHAN_TO_UBYTE(srcRgba[i][ACOMP]);
1974 dest += 4;
1975 }
1976 }
1977 else {
1978 /* general solution */
1979 GLuint i;
1980 DEFMARRAY(GLfloat, rgba, MAX_WIDTH, 4); /* mac 32k limitation */
1981 CHECKARRAY(rgba, return); /* mac 32k limitation */
1982
1983 assert(n <= MAX_WIDTH);
1984 /* convert color components to floating point */
1985 for (i = 0; i < n; i++) {
1986 rgba[i][RCOMP] = CHAN_TO_FLOAT(srcRgba[i][RCOMP]);
1987 rgba[i][GCOMP] = CHAN_TO_FLOAT(srcRgba[i][GCOMP]);
1988 rgba[i][BCOMP] = CHAN_TO_FLOAT(srcRgba[i][BCOMP]);
1989 rgba[i][ACOMP] = CHAN_TO_FLOAT(srcRgba[i][ACOMP]);
1990 }
1991 _mesa_pack_rgba_span_float(ctx, n, (const GLfloat (*)[4]) rgba,
1992 dstFormat, dstType, dstAddr,
1993 dstPacking, transferOps);
1994 UNDEFARRAY(rgba); /* mac 32k limitation */
1995 }
1996 }
1997
1998
1999 #define SWAP2BYTE(VALUE) \
2000 { \
2001 GLubyte *bytes = (GLubyte *) &(VALUE); \
2002 GLubyte tmp = bytes[0]; \
2003 bytes[0] = bytes[1]; \
2004 bytes[1] = tmp; \
2005 }
2006
2007 #define SWAP4BYTE(VALUE) \
2008 { \
2009 GLubyte *bytes = (GLubyte *) &(VALUE); \
2010 GLubyte tmp = bytes[0]; \
2011 bytes[0] = bytes[3]; \
2012 bytes[3] = tmp; \
2013 tmp = bytes[1]; \
2014 bytes[1] = bytes[2]; \
2015 bytes[2] = tmp; \
2016 }
2017
2018
2019 static void
2020 extract_uint_indexes(GLuint n, GLuint indexes[],
2021 GLenum srcFormat, GLenum srcType, const GLvoid *src,
2022 const struct gl_pixelstore_attrib *unpack )
2023 {
2024 assert(srcFormat == GL_COLOR_INDEX);
2025
2026 ASSERT(srcType == GL_BITMAP ||
2027 srcType == GL_UNSIGNED_BYTE ||
2028 srcType == GL_BYTE ||
2029 srcType == GL_UNSIGNED_SHORT ||
2030 srcType == GL_SHORT ||
2031 srcType == GL_UNSIGNED_INT ||
2032 srcType == GL_INT ||
2033 srcType == GL_HALF_FLOAT_NV ||
2034 srcType == GL_FLOAT);
2035
2036 switch (srcType) {
2037 case GL_BITMAP:
2038 {
2039 GLubyte *ubsrc = (GLubyte *) src;
2040 if (unpack->LsbFirst) {
2041 GLubyte mask = 1 << (unpack->SkipPixels & 0x7);
2042 GLuint i;
2043 for (i = 0; i < n; i++) {
2044 indexes[i] = (*ubsrc & mask) ? 1 : 0;
2045 if (mask == 128) {
2046 mask = 1;
2047 ubsrc++;
2048 }
2049 else {
2050 mask = mask << 1;
2051 }
2052 }
2053 }
2054 else {
2055 GLubyte mask = 128 >> (unpack->SkipPixels & 0x7);
2056 GLuint i;
2057 for (i = 0; i < n; i++) {
2058 indexes[i] = (*ubsrc & mask) ? 1 : 0;
2059 if (mask == 1) {
2060 mask = 128;
2061 ubsrc++;
2062 }
2063 else {
2064 mask = mask >> 1;
2065 }
2066 }
2067 }
2068 }
2069 break;
2070 case GL_UNSIGNED_BYTE:
2071 {
2072 GLuint i;
2073 const GLubyte *s = (const GLubyte *) src;
2074 for (i = 0; i < n; i++)
2075 indexes[i] = s[i];
2076 }
2077 break;
2078 case GL_BYTE:
2079 {
2080 GLuint i;
2081 const GLbyte *s = (const GLbyte *) src;
2082 for (i = 0; i < n; i++)
2083 indexes[i] = s[i];
2084 }
2085 break;
2086 case GL_UNSIGNED_SHORT:
2087 {
2088 GLuint i;
2089 const GLushort *s = (const GLushort *) src;
2090 if (unpack->SwapBytes) {
2091 for (i = 0; i < n; i++) {
2092 GLushort value = s[i];
2093 SWAP2BYTE(value);
2094 indexes[i] = value;
2095 }
2096 }
2097 else {
2098 for (i = 0; i < n; i++)
2099 indexes[i] = s[i];
2100 }
2101 }
2102 break;
2103 case GL_SHORT:
2104 {
2105 GLuint i;
2106 const GLshort *s = (const GLshort *) src;
2107 if (unpack->SwapBytes) {
2108 for (i = 0; i < n; i++) {
2109 GLshort value = s[i];
2110 SWAP2BYTE(value);
2111 indexes[i] = value;
2112 }
2113 }
2114 else {
2115 for (i = 0; i < n; i++)
2116 indexes[i] = s[i];
2117 }
2118 }
2119 break;
2120 case GL_UNSIGNED_INT:
2121 {
2122 GLuint i;
2123 const GLuint *s = (const GLuint *) src;
2124 if (unpack->SwapBytes) {
2125 for (i = 0; i < n; i++) {
2126 GLuint value = s[i];
2127 SWAP4BYTE(value);
2128 indexes[i] = value;
2129 }
2130 }
2131 else {
2132 for (i = 0; i < n; i++)
2133 indexes[i] = s[i];
2134 }
2135 }
2136 break;
2137 case GL_INT:
2138 {
2139 GLuint i;
2140 const GLint *s = (const GLint *) src;
2141 if (unpack->SwapBytes) {
2142 for (i = 0; i < n; i++) {
2143 GLint value = s[i];
2144 SWAP4BYTE(value);
2145 indexes[i] = value;
2146 }
2147 }
2148 else {
2149 for (i = 0; i < n; i++)
2150 indexes[i] = s[i];
2151 }
2152 }
2153 break;
2154 case GL_FLOAT:
2155 {
2156 GLuint i;
2157 const GLfloat *s = (const GLfloat *) src;
2158 if (unpack->SwapBytes) {
2159 for (i = 0; i < n; i++) {
2160 GLfloat value = s[i];
2161 SWAP4BYTE(value);
2162 indexes[i] = (GLuint) value;
2163 }
2164 }
2165 else {
2166 for (i = 0; i < n; i++)
2167 indexes[i] = (GLuint) s[i];
2168 }
2169 }
2170 break;
2171 case GL_HALF_FLOAT_NV:
2172 {
2173 GLuint i;
2174 const GLhalfNV *s = (const GLhalfNV *) src;
2175 if (unpack->SwapBytes) {
2176 for (i = 0; i < n; i++) {
2177 GLhalfNV value = s[i];
2178 SWAP2BYTE(value);
2179 indexes[i] = (GLuint) _mesa_half_to_float(value);
2180 }
2181 }
2182 else {
2183 for (i = 0; i < n; i++)
2184 indexes[i] = (GLuint) _mesa_half_to_float(s[i]);
2185 }
2186 }
2187 break;
2188 default:
2189 _mesa_problem(NULL, "bad srcType in extract_uint_indexes");
2190 return;
2191 }
2192 }
2193
2194
2195 /*
2196 * This function extracts floating point RGBA values from arbitrary
2197 * image data. srcFormat and srcType are the format and type parameters
2198 * passed to glDrawPixels, glTexImage[123]D, glTexSubImage[123]D, etc.
2199 *
2200 * Refering to section 3.6.4 of the OpenGL 1.2 spec, this function
2201 * implements the "Conversion to floating point", "Conversion to RGB",
2202 * and "Final Expansion to RGBA" operations.
2203 *
2204 * Args: n - number of pixels
2205 * rgba - output colors
2206 * srcFormat - format of incoming data
2207 * srcType - data type of incoming data
2208 * src - source data pointer
2209 * swapBytes - perform byteswapping of incoming data?
2210 */
2211 static void
2212 extract_float_rgba(GLuint n, GLfloat rgba[][4],
2213 GLenum srcFormat, GLenum srcType, const GLvoid *src,
2214 GLboolean swapBytes)
2215 {
2216 GLint redIndex, greenIndex, blueIndex, alphaIndex;
2217 GLint stride;
2218 GLint rComp, bComp, gComp, aComp;
2219
2220 ASSERT(srcFormat == GL_RED ||
2221 srcFormat == GL_GREEN ||
2222 srcFormat == GL_BLUE ||
2223 srcFormat == GL_ALPHA ||
2224 srcFormat == GL_LUMINANCE ||
2225 srcFormat == GL_LUMINANCE_ALPHA ||
2226 srcFormat == GL_INTENSITY ||
2227 srcFormat == GL_RGB ||
2228 srcFormat == GL_BGR ||
2229 srcFormat == GL_RGBA ||
2230 srcFormat == GL_BGRA ||
2231 srcFormat == GL_ABGR_EXT);
2232
2233 ASSERT(srcType == GL_UNSIGNED_BYTE ||
2234 srcType == GL_BYTE ||
2235 srcType == GL_UNSIGNED_SHORT ||
2236 srcType == GL_SHORT ||
2237 srcType == GL_UNSIGNED_INT ||
2238 srcType == GL_INT ||
2239 srcType == GL_HALF_FLOAT_NV ||
2240 srcType == GL_FLOAT ||
2241 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
2242 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
2243 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
2244 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
2245 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
2246 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
2247 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
2248 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
2249 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
2250 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
2251 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
2252 srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
2253
2254 rComp = gComp = bComp = aComp = -1;
2255
2256 switch (srcFormat) {
2257 case GL_RED:
2258 redIndex = 0;
2259 greenIndex = blueIndex = alphaIndex = -1;
2260 stride = 1;
2261 break;
2262 case GL_GREEN:
2263 greenIndex = 0;
2264 redIndex = blueIndex = alphaIndex = -1;
2265 stride = 1;
2266 break;
2267 case GL_BLUE:
2268 blueIndex = 0;
2269 redIndex = greenIndex = alphaIndex = -1;
2270 stride = 1;
2271 break;
2272 case GL_ALPHA:
2273 redIndex = greenIndex = blueIndex = -1;
2274 alphaIndex = 0;
2275 stride = 1;
2276 break;
2277 case GL_LUMINANCE:
2278 redIndex = greenIndex = blueIndex = 0;
2279 alphaIndex = -1;
2280 stride = 1;
2281 break;
2282 case GL_LUMINANCE_ALPHA:
2283 redIndex = greenIndex = blueIndex = 0;
2284 alphaIndex = 1;
2285 stride = 2;
2286 break;
2287 case GL_INTENSITY:
2288 redIndex = greenIndex = blueIndex = alphaIndex = 0;
2289 stride = 1;
2290 break;
2291 case GL_RGB:
2292 redIndex = 0;
2293 greenIndex = 1;
2294 blueIndex = 2;
2295 alphaIndex = -1;
2296 stride = 3;
2297 break;
2298 case GL_BGR:
2299 redIndex = 2;
2300 greenIndex = 1;
2301 blueIndex = 0;
2302 alphaIndex = -1;
2303 stride = 3;
2304 break;
2305 case GL_RGBA:
2306 redIndex = 0;
2307 greenIndex = 1;
2308 blueIndex = 2;
2309 alphaIndex = 3;
2310 rComp = 0;
2311 gComp = 1;
2312 bComp = 2;
2313 aComp = 3;
2314 stride = 4;
2315 break;
2316 case GL_BGRA:
2317 redIndex = 2;
2318 greenIndex = 1;
2319 blueIndex = 0;
2320 alphaIndex = 3;
2321 rComp = 2;
2322 gComp = 1;
2323 bComp = 0;
2324 aComp = 3;
2325 stride = 4;
2326 break;
2327 case GL_ABGR_EXT:
2328 redIndex = 3;
2329 greenIndex = 2;
2330 blueIndex = 1;
2331 alphaIndex = 0;
2332 rComp = 3;
2333 gComp = 2;
2334 bComp = 1;
2335 aComp = 0;
2336 stride = 4;
2337 break;
2338 default:
2339 _mesa_problem(NULL, "bad srcFormat in extract float data");
2340 return;
2341 }
2342
2343
2344 #define PROCESS(INDEX, CHANNEL, DEFAULT, TYPE, CONVERSION) \
2345 if ((INDEX) < 0) { \
2346 GLuint i; \
2347 for (i = 0; i < n; i++) { \
2348 rgba[i][CHANNEL] = DEFAULT; \
2349 } \
2350 } \
2351 else if (swapBytes) { \
2352 const TYPE *s = (const TYPE *) src; \
2353 GLuint i; \
2354 for (i = 0; i < n; i++) { \
2355 TYPE value = s[INDEX]; \
2356 if (sizeof(TYPE) == 2) { \
2357 SWAP2BYTE(value); \
2358 } \
2359 else if (sizeof(TYPE) == 4) { \
2360 SWAP4BYTE(value); \
2361 } \
2362 rgba[i][CHANNEL] = (GLfloat) CONVERSION(value); \
2363 s += stride; \
2364 } \
2365 } \
2366 else { \
2367 const TYPE *s = (const TYPE *) src; \
2368 GLuint i; \
2369 for (i = 0; i < n; i++) { \
2370 rgba[i][CHANNEL] = (GLfloat) CONVERSION(s[INDEX]); \
2371 s += stride; \
2372 } \
2373 }
2374
2375 switch (srcType) {
2376 case GL_UNSIGNED_BYTE:
2377 PROCESS(redIndex, RCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT);
2378 PROCESS(greenIndex, GCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT);
2379 PROCESS(blueIndex, BCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT);
2380 PROCESS(alphaIndex, ACOMP, 1.0F, GLubyte, UBYTE_TO_FLOAT);
2381 break;
2382 case GL_BYTE:
2383 PROCESS(redIndex, RCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT);
2384 PROCESS(greenIndex, GCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT);
2385 PROCESS(blueIndex, BCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT);
2386 PROCESS(alphaIndex, ACOMP, 1.0F, GLbyte, BYTE_TO_FLOAT);
2387 break;
2388 case GL_UNSIGNED_SHORT:
2389 PROCESS(redIndex, RCOMP, 0.0F, GLushort, USHORT_TO_FLOAT);
2390 PROCESS(greenIndex, GCOMP, 0.0F, GLushort, USHORT_TO_FLOAT);
2391 PROCESS(blueIndex, BCOMP, 0.0F, GLushort, USHORT_TO_FLOAT);
2392 PROCESS(alphaIndex, ACOMP, 1.0F, GLushort, USHORT_TO_FLOAT);
2393 break;
2394 case GL_SHORT:
2395 PROCESS(redIndex, RCOMP, 0.0F, GLshort, SHORT_TO_FLOAT);
2396 PROCESS(greenIndex, GCOMP, 0.0F, GLshort, SHORT_TO_FLOAT);
2397 PROCESS(blueIndex, BCOMP, 0.0F, GLshort, SHORT_TO_FLOAT);
2398 PROCESS(alphaIndex, ACOMP, 1.0F, GLshort, SHORT_TO_FLOAT);
2399 break;
2400 case GL_UNSIGNED_INT:
2401 PROCESS(redIndex, RCOMP, 0.0F, GLuint, UINT_TO_FLOAT);
2402 PROCESS(greenIndex, GCOMP, 0.0F, GLuint, UINT_TO_FLOAT);
2403 PROCESS(blueIndex, BCOMP, 0.0F, GLuint, UINT_TO_FLOAT);
2404 PROCESS(alphaIndex, ACOMP, 1.0F, GLuint, UINT_TO_FLOAT);
2405 break;
2406 case GL_INT:
2407 PROCESS(redIndex, RCOMP, 0.0F, GLint, INT_TO_FLOAT);
2408 PROCESS(greenIndex, GCOMP, 0.0F, GLint, INT_TO_FLOAT);
2409 PROCESS(blueIndex, BCOMP, 0.0F, GLint, INT_TO_FLOAT);
2410 PROCESS(alphaIndex, ACOMP, 1.0F, GLint, INT_TO_FLOAT);
2411 break;
2412 case GL_FLOAT:
2413 PROCESS(redIndex, RCOMP, 0.0F, GLfloat, (GLfloat));
2414 PROCESS(greenIndex, GCOMP, 0.0F, GLfloat, (GLfloat));
2415 PROCESS(blueIndex, BCOMP, 0.0F, GLfloat, (GLfloat));
2416 PROCESS(alphaIndex, ACOMP, 1.0F, GLfloat, (GLfloat));
2417 break;
2418 case GL_HALF_FLOAT_NV:
2419 PROCESS(redIndex, RCOMP, 0.0F, GLhalfNV, _mesa_half_to_float);
2420 PROCESS(greenIndex, GCOMP, 0.0F, GLhalfNV, _mesa_half_to_float);
2421 PROCESS(blueIndex, BCOMP, 0.0F, GLhalfNV, _mesa_half_to_float);
2422 PROCESS(alphaIndex, ACOMP, 1.0F, GLhalfNV, _mesa_half_to_float);
2423 break;
2424 case GL_UNSIGNED_BYTE_3_3_2:
2425 {
2426 const GLubyte *ubsrc = (const GLubyte *) src;
2427 GLuint i;
2428 for (i = 0; i < n; i ++) {
2429 GLubyte p = ubsrc[i];
2430 rgba[i][RCOMP] = ((p >> 5) ) * (1.0F / 7.0F);
2431 rgba[i][GCOMP] = ((p >> 2) & 0x7) * (1.0F / 7.0F);
2432 rgba[i][BCOMP] = ((p ) & 0x3) * (1.0F / 3.0F);
2433 rgba[i][ACOMP] = 1.0F;
2434 }
2435 }
2436 break;
2437 case GL_UNSIGNED_BYTE_2_3_3_REV:
2438 {
2439 const GLubyte *ubsrc = (const GLubyte *) src;
2440 GLuint i;
2441 for (i = 0; i < n; i ++) {
2442 GLubyte p = ubsrc[i];
2443 rgba[i][RCOMP] = ((p ) & 0x7) * (1.0F / 7.0F);
2444 rgba[i][GCOMP] = ((p >> 3) & 0x7) * (1.0F / 7.0F);
2445 rgba[i][BCOMP] = ((p >> 6) ) * (1.0F / 3.0F);
2446 rgba[i][ACOMP] = 1.0F;
2447 }
2448 }
2449 break;
2450 case GL_UNSIGNED_SHORT_5_6_5:
2451 if (swapBytes) {
2452 const GLushort *ussrc = (const GLushort *) src;
2453 GLuint i;
2454 for (i = 0; i < n; i ++) {
2455 GLushort p = ussrc[i];
2456 SWAP2BYTE(p);
2457 rgba[i][RCOMP] = ((p >> 11) ) * (1.0F / 31.0F);
2458 rgba[i][GCOMP] = ((p >> 5) & 0x3f) * (1.0F / 63.0F);
2459 rgba[i][BCOMP] = ((p ) & 0x1f) * (1.0F / 31.0F);
2460 rgba[i][ACOMP] = 1.0F;
2461 }
2462 }
2463 else {
2464 const GLushort *ussrc = (const GLushort *) src;
2465 GLuint i;
2466 for (i = 0; i < n; i ++) {
2467 GLushort p = ussrc[i];
2468 rgba[i][RCOMP] = ((p >> 11) ) * (1.0F / 31.0F);
2469 rgba[i][GCOMP] = ((p >> 5) & 0x3f) * (1.0F / 63.0F);
2470 rgba[i][BCOMP] = ((p ) & 0x1f) * (1.0F / 31.0F);
2471 rgba[i][ACOMP] = 1.0F;
2472 }
2473 }
2474 break;
2475 case GL_UNSIGNED_SHORT_5_6_5_REV:
2476 if (swapBytes) {
2477 const GLushort *ussrc = (const GLushort *) src;
2478 GLuint i;
2479 for (i = 0; i < n; i ++) {
2480 GLushort p = ussrc[i];
2481 SWAP2BYTE(p);
2482 rgba[i][RCOMP] = ((p ) & 0x1f) * (1.0F / 31.0F);
2483 rgba[i][GCOMP] = ((p >> 5) & 0x3f) * (1.0F / 63.0F);
2484 rgba[i][BCOMP] = ((p >> 11) ) * (1.0F / 31.0F);
2485 rgba[i][ACOMP] = 1.0F;
2486 }
2487 }
2488 else {
2489 const GLushort *ussrc = (const GLushort *) src;
2490 GLuint i;
2491 for (i = 0; i < n; i ++) {
2492 GLushort p = ussrc[i];
2493 rgba[i][RCOMP] = ((p ) & 0x1f) * (1.0F / 31.0F);
2494 rgba[i][GCOMP] = ((p >> 5) & 0x3f) * (1.0F / 63.0F);
2495 rgba[i][BCOMP] = ((p >> 11) ) * (1.0F / 31.0F);
2496 rgba[i][ACOMP] = 1.0F;
2497 }
2498 }
2499 break;
2500 case GL_UNSIGNED_SHORT_4_4_4_4:
2501 if (swapBytes) {
2502 const GLushort *ussrc = (const GLushort *) src;
2503 GLuint i;
2504 for (i = 0; i < n; i ++) {
2505 GLushort p = ussrc[i];
2506 SWAP2BYTE(p);
2507 rgba[i][rComp] = ((p >> 12) ) * (1.0F / 15.0F);
2508 rgba[i][gComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F);
2509 rgba[i][bComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F);
2510 rgba[i][aComp] = ((p ) & 0xf) * (1.0F / 15.0F);
2511 }
2512 }
2513 else {
2514 const GLushort *ussrc = (const GLushort *) src;
2515 GLuint i;
2516 for (i = 0; i < n; i ++) {
2517 GLushort p = ussrc[i];
2518 rgba[i][rComp] = ((p >> 12) ) * (1.0F / 15.0F);
2519 rgba[i][gComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F);
2520 rgba[i][bComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F);
2521 rgba[i][aComp] = ((p ) & 0xf) * (1.0F / 15.0F);
2522 }
2523 }
2524 break;
2525 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
2526 if (swapBytes) {
2527 const GLushort *ussrc = (const GLushort *) src;
2528 GLuint i;
2529 for (i = 0; i < n; i ++) {
2530 GLushort p = ussrc[i];
2531 SWAP2BYTE(p);
2532 rgba[i][rComp] = ((p ) & 0xf) * (1.0F / 15.0F);
2533 rgba[i][gComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F);
2534 rgba[i][bComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F);
2535 rgba[i][aComp] = ((p >> 12) ) * (1.0F / 15.0F);
2536 }
2537 }
2538 else {
2539 const GLushort *ussrc = (const GLushort *) src;
2540 GLuint i;
2541 for (i = 0; i < n; i ++) {
2542 GLushort p = ussrc[i];
2543 rgba[i][rComp] = ((p ) & 0xf) * (1.0F / 15.0F);
2544 rgba[i][gComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F);
2545 rgba[i][bComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F);
2546 rgba[i][aComp] = ((p >> 12) ) * (1.0F / 15.0F);
2547 }
2548 }
2549 break;
2550 case GL_UNSIGNED_SHORT_5_5_5_1:
2551 if (swapBytes) {
2552 const GLushort *ussrc = (const GLushort *) src;
2553 GLuint i;
2554 for (i = 0; i < n; i ++) {
2555 GLushort p = ussrc[i];
2556 SWAP2BYTE(p);
2557 rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F);
2558 rgba[i][gComp] = ((p >> 6) & 0x1f) * (1.0F / 31.0F);
2559 rgba[i][bComp] = ((p >> 1) & 0x1f) * (1.0F / 31.0F);
2560 rgba[i][aComp] = ((p ) & 0x1) * (1.0F / 1.0F);
2561 }
2562 }
2563 else {
2564 const GLushort *ussrc = (const GLushort *) src;
2565 GLuint i;
2566 for (i = 0; i < n; i ++) {
2567 GLushort p = ussrc[i];
2568 rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F);
2569 rgba[i][gComp] = ((p >> 6) & 0x1f) * (1.0F / 31.0F);
2570 rgba[i][bComp] = ((p >> 1) & 0x1f) * (1.0F / 31.0F);
2571 rgba[i][aComp] = ((p ) & 0x1) * (1.0F / 1.0F);
2572 }
2573 }
2574 break;
2575 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
2576 if (swapBytes) {
2577 const GLushort *ussrc = (const GLushort *) src;
2578 GLuint i;
2579 for (i = 0; i < n; i ++) {
2580 GLushort p = ussrc[i];
2581 SWAP2BYTE(p);
2582 rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F);
2583 rgba[i][gComp] = ((p >> 5) & 0x1f) * (1.0F / 31.0F);
2584 rgba[i][bComp] = ((p >> 10) & 0x1f) * (1.0F / 31.0F);
2585 rgba[i][aComp] = ((p >> 15) ) * (1.0F / 1.0F);
2586 }
2587 }
2588 else {
2589 const GLushort *ussrc = (const GLushort *) src;
2590 GLuint i;
2591 for (i = 0; i < n; i ++) {
2592 GLushort p = ussrc[i];
2593 rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F);
2594 rgba[i][gComp] = ((p >> 5) & 0x1f) * (1.0F / 31.0F);
2595 rgba[i][bComp] = ((p >> 10) & 0x1f) * (1.0F / 31.0F);
2596 rgba[i][aComp] = ((p >> 15) ) * (1.0F / 1.0F);
2597 }
2598 }
2599 break;
2600 case GL_UNSIGNED_INT_8_8_8_8:
2601 if (swapBytes) {
2602 const GLuint *uisrc = (const GLuint *) src;
2603 GLuint i;
2604 for (i = 0; i < n; i ++) {
2605 GLuint p = uisrc[i];
2606 rgba[i][rComp] = UBYTE_TO_FLOAT((p ) & 0xff);
2607 rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
2608 rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2609 rgba[i][aComp] = UBYTE_TO_FLOAT((p >> 24) );
2610 }
2611 }
2612 else {
2613 const GLuint *uisrc = (const GLuint *) src;
2614 GLuint i;
2615 for (i = 0; i < n; i ++) {
2616 GLuint p = uisrc[i];
2617 rgba[i][rComp] = UBYTE_TO_FLOAT((p >> 24) );
2618 rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2619 rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
2620 rgba[i][aComp] = UBYTE_TO_FLOAT((p ) & 0xff);
2621 }
2622 }
2623 break;
2624 case GL_UNSIGNED_INT_8_8_8_8_REV:
2625 if (swapBytes) {
2626 const GLuint *uisrc = (const GLuint *) src;
2627 GLuint i;
2628 for (i = 0; i < n; i ++) {
2629 GLuint p = uisrc[i];
2630 rgba[i][rComp] = UBYTE_TO_FLOAT((p >> 24) );
2631 rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2632 rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
2633 rgba[i][aComp] = UBYTE_TO_FLOAT((p ) & 0xff);
2634 }
2635 }
2636 else {
2637 const GLuint *uisrc = (const GLuint *) src;
2638 GLuint i;
2639 for (i = 0; i < n; i ++) {
2640 GLuint p = uisrc[i];
2641 rgba[i][rComp] = UBYTE_TO_FLOAT((p ) & 0xff);
2642 rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
2643 rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2644 rgba[i][aComp] = UBYTE_TO_FLOAT((p >> 24) );
2645 }
2646 }
2647 break;
2648 case GL_UNSIGNED_INT_10_10_10_2:
2649 if (swapBytes) {
2650 const GLuint *uisrc = (const GLuint *) src;
2651 GLuint i;
2652 for (i = 0; i < n; i ++) {
2653 GLuint p = uisrc[i];
2654 SWAP4BYTE(p);
2655 rgba[i][rComp] = ((p >> 22) ) * (1.0F / 1023.0F);
2656 rgba[i][gComp] = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F);
2657 rgba[i][bComp] = ((p >> 2) & 0x3ff) * (1.0F / 1023.0F);
2658 rgba[i][aComp] = ((p ) & 0x3 ) * (1.0F / 3.0F);
2659 }
2660 }
2661 else {
2662 const GLuint *uisrc = (const GLuint *) src;
2663 GLuint i;
2664 for (i = 0; i < n; i ++) {
2665 GLuint p = uisrc[i];
2666 rgba[i][rComp] = ((p >> 22) ) * (1.0F / 1023.0F);
2667 rgba[i][gComp] = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F);
2668 rgba[i][bComp] = ((p >> 2) & 0x3ff) * (1.0F / 1023.0F);
2669 rgba[i][aComp] = ((p ) & 0x3 ) * (1.0F / 3.0F);
2670 }
2671 }
2672 break;
2673 case GL_UNSIGNED_INT_2_10_10_10_REV:
2674 if (swapBytes) {
2675 const GLuint *uisrc = (const GLuint *) src;
2676 GLuint i;
2677 for (i = 0; i < n; i ++) {
2678 GLuint p = uisrc[i];
2679 SWAP4BYTE(p);
2680 rgba[i][rComp] = ((p ) & 0x3ff) * (1.0F / 1023.0F);
2681 rgba[i][gComp] = ((p >> 10) & 0x3ff) * (1.0F / 1023.0F);
2682 rgba[i][bComp] = ((p >> 20) & 0x3ff) * (1.0F / 1023.0F);
2683 rgba[i][aComp] = ((p >> 30) ) * (1.0F / 3.0F);
2684 }
2685 }
2686 else {
2687 const GLuint *uisrc = (const GLuint *) src;
2688 GLuint i;
2689 for (i = 0; i < n; i ++) {
2690 GLuint p = uisrc[i];
2691 rgba[i][rComp] = ((p ) & 0x3ff) * (1.0F / 1023.0F);
2692 rgba[i][gComp] = ((p >> 10) & 0x3ff) * (1.0F / 1023.0F);
2693 rgba[i][bComp] = ((p >> 20) & 0x3ff) * (1.0F / 1023.0F);
2694 rgba[i][aComp] = ((p >> 30) ) * (1.0F / 3.0F);
2695 }
2696 }
2697 break;
2698 default:
2699 _mesa_problem(NULL, "bad srcType in extract float data");
2700 break;
2701 }
2702 }
2703
2704
2705 /*
2706 * Unpack a row of color image data from a client buffer according to
2707 * the pixel unpacking parameters.
2708 * Return GLchan values in the specified dest image format.
2709 * This is used by glDrawPixels and glTexImage?D().
2710 * \param ctx - the context
2711 * n - number of pixels in the span
2712 * dstFormat - format of destination color array
2713 * dest - the destination color array
2714 * srcFormat - source image format
2715 * srcType - source image data type
2716 * source - source image pointer
2717 * srcPacking - pixel unpacking parameters
2718 * transferOps - bitmask of IMAGE_*_BIT values of operations to apply
2719 *
2720 * XXX perhaps expand this to process whole images someday.
2721 */
2722 void
2723 _mesa_unpack_color_span_chan( GLcontext *ctx,
2724 GLuint n, GLenum dstFormat, GLchan dest[],
2725 GLenum srcFormat, GLenum srcType,
2726 const GLvoid *source,
2727 const struct gl_pixelstore_attrib *srcPacking,
2728 GLuint transferOps )
2729 {
2730 ASSERT(dstFormat == GL_ALPHA ||
2731 dstFormat == GL_LUMINANCE ||
2732 dstFormat == GL_LUMINANCE_ALPHA ||
2733 dstFormat == GL_INTENSITY ||
2734 dstFormat == GL_RGB ||
2735 dstFormat == GL_RGBA ||
2736 dstFormat == GL_COLOR_INDEX);
2737
2738 ASSERT(srcFormat == GL_RED ||
2739 srcFormat == GL_GREEN ||
2740 srcFormat == GL_BLUE ||
2741 srcFormat == GL_ALPHA ||
2742 srcFormat == GL_LUMINANCE ||
2743 srcFormat == GL_LUMINANCE_ALPHA ||
2744 srcFormat == GL_INTENSITY ||
2745 srcFormat == GL_RGB ||
2746 srcFormat == GL_BGR ||
2747 srcFormat == GL_RGBA ||
2748 srcFormat == GL_BGRA ||
2749 srcFormat == GL_ABGR_EXT ||
2750 srcFormat == GL_COLOR_INDEX);
2751
2752 ASSERT(srcType == GL_BITMAP ||
2753 srcType == GL_UNSIGNED_BYTE ||
2754 srcType == GL_BYTE ||
2755 srcType == GL_UNSIGNED_SHORT ||
2756 srcType == GL_SHORT ||
2757 srcType == GL_UNSIGNED_INT ||
2758 srcType == GL_INT ||
2759 srcType == GL_HALF_FLOAT_NV ||
2760 srcType == GL_FLOAT ||
2761 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
2762 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
2763 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
2764 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
2765 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
2766 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
2767 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
2768 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
2769 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
2770 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
2771 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
2772 srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
2773
2774 /* Try simple cases first */
2775 if (transferOps == 0 ){
2776 if (srcType == CHAN_TYPE) {
2777 if (dstFormat == GL_RGBA) {
2778 if (srcFormat == GL_RGBA) {
2779 MEMCPY( dest, source, n * 4 * sizeof(GLchan) );
2780 return;
2781 }
2782 else if (srcFormat == GL_RGB) {
2783 GLuint i;
2784 const GLchan *src = (const GLchan *) source;
2785 GLchan *dst = dest;
2786 for (i = 0; i < n; i++) {
2787 dst[0] = src[0];
2788 dst[1] = src[1];
2789 dst[2] = src[2];
2790 dst[3] = CHAN_MAX;
2791 src += 3;
2792 dst += 4;
2793 }
2794 return;
2795 }
2796 }
2797 else if (dstFormat == GL_RGB) {
2798 if (srcFormat == GL_RGB) {
2799 MEMCPY( dest, source, n * 3 * sizeof(GLchan) );
2800 return;
2801 }
2802 else if (srcFormat == GL_RGBA) {
2803 GLuint i;
2804 const GLchan *src = (const GLchan *) source;
2805 GLchan *dst = dest;
2806 for (i = 0; i < n; i++) {
2807 dst[0] = src[0];
2808 dst[1] = src[1];
2809 dst[2] = src[2];
2810 src += 4;
2811 dst += 3;
2812 }
2813 return;
2814 }
2815 }
2816 else if (dstFormat == srcFormat) {
2817 GLint comps = _mesa_components_in_format(srcFormat);
2818 assert(comps > 0);
2819 MEMCPY( dest, source, n * comps * sizeof(GLchan) );
2820 return;
2821 }
2822 }
2823 /*
2824 * Common situation, loading 8bit RGBA/RGB source images
2825 * into 16/32 bit destination. (OSMesa16/32)
2826 */
2827 else if (srcType == GL_UNSIGNED_BYTE) {
2828 if (dstFormat == GL_RGBA) {
2829 if (srcFormat == GL_RGB) {
2830 GLuint i;
2831 const GLubyte *src = (const GLubyte *) source;
2832 GLchan *dst = dest;
2833 for (i = 0; i < n; i++) {
2834 dst[0] = UBYTE_TO_CHAN(src[0]);
2835 dst[1] = UBYTE_TO_CHAN(src[1]);
2836 dst[2] = UBYTE_TO_CHAN(src[2]);
2837 dst[3] = CHAN_MAX;
2838 src += 3;
2839 dst += 4;
2840 }
2841 return;
2842 }
2843 else if (srcFormat == GL_RGBA) {
2844 GLuint i;
2845 const GLubyte *src = (const GLubyte *) source;
2846 GLchan *dst = dest;
2847 for (i = 0; i < n; i++) {
2848 dst[0] = UBYTE_TO_CHAN(src[0]);
2849 dst[1] = UBYTE_TO_CHAN(src[1]);
2850 dst[2] = UBYTE_TO_CHAN(src[2]);
2851 dst[3] = UBYTE_TO_CHAN(src[3]);
2852 src += 4;
2853 dst += 4;
2854 }
2855 return;
2856 }
2857 }
2858 else if (dstFormat == GL_RGB) {
2859 if (srcFormat == GL_RGB) {
2860 GLuint i;
2861 const GLubyte *src = (const GLubyte *) source;
2862 GLchan *dst = dest;
2863 for (i = 0; i < n; i++) {
2864 dst[0] = UBYTE_TO_CHAN(src[0]);
2865 dst[1] = UBYTE_TO_CHAN(src[1]);
2866 dst[2] = UBYTE_TO_CHAN(src[2]);
2867 src += 3;
2868 dst += 3;
2869 }
2870 return;
2871 }
2872 else if (srcFormat == GL_RGBA) {
2873 GLuint i;
2874 const GLubyte *src = (const GLubyte *) source;
2875 GLchan *dst = dest;
2876 for (i = 0; i < n; i++) {
2877 dst[0] = UBYTE_TO_CHAN(src[0]);
2878 dst[1] = UBYTE_TO_CHAN(src[1]);
2879 dst[2] = UBYTE_TO_CHAN(src[2]);
2880 src += 4;
2881 dst += 3;
2882 }
2883 return;
2884 }
2885 }
2886 }
2887 }
2888
2889
2890 /* general solution begins here */
2891 {
2892 GLint dstComponents;
2893 GLint dstRedIndex, dstGreenIndex, dstBlueIndex, dstAlphaIndex;
2894 GLint dstLuminanceIndex, dstIntensityIndex;
2895 DEFMARRAY(GLfloat, rgba, MAX_WIDTH, 4); /* mac 32k limitation */
2896 CHECKARRAY(rgba, return); /* mac 32k limitation */
2897
2898 dstComponents = _mesa_components_in_format( dstFormat );
2899 /* source & dest image formats should have been error checked by now */
2900 assert(dstComponents > 0);
2901
2902 /*
2903 * Extract image data and convert to RGBA floats
2904 */
2905 assert(n <= MAX_WIDTH);
2906 if (srcFormat == GL_COLOR_INDEX) {
2907 GLuint indexes[MAX_WIDTH];
2908 extract_uint_indexes(n, indexes, srcFormat, srcType, source,
2909 srcPacking);
2910
2911 if (dstFormat == GL_COLOR_INDEX
2912 && (transferOps & IMAGE_MAP_COLOR_BIT)) {
2913 _mesa_map_ci(ctx, n, indexes);
2914 }
2915 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
2916 _mesa_shift_and_offset_ci(ctx, n, indexes);
2917 }
2918
2919 if (dstFormat == GL_COLOR_INDEX) {
2920 /* convert to GLchan and return */
2921 GLuint i;
2922 for (i = 0; i < n; i++) {
2923 dest[i] = (GLchan) (indexes[i] & 0xff);
2924 }
2925 UNDEFARRAY(rgba); /* mac 32k limitation */
2926 return;
2927 }
2928 else {
2929 /* Convert indexes to RGBA */
2930 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
2931 }
2932
2933 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
2934 * with color indexes.
2935 */
2936 transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT);
2937 }
2938 else {
2939 /* non-color index data */
2940 extract_float_rgba(n, rgba, srcFormat, srcType, source,
2941 srcPacking->SwapBytes);
2942 }
2943
2944 /* Need to clamp if returning GLubytes or GLushorts */
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 )
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 (transferOps) {
3173 _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
3174 }
3175
3176 /* Now determine which color channels we need to produce.
3177 * And determine the dest index (offset) within each color tuple.
3178 */
3179 switch (dstFormat) {
3180 case GL_ALPHA:
3181 dstAlphaIndex = 0;
3182 dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
3183 dstLuminanceIndex = dstIntensityIndex = -1;
3184 break;
3185 case GL_LUMINANCE:
3186 dstLuminanceIndex = 0;
3187 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
3188 dstIntensityIndex = -1;
3189 break;
3190 case GL_LUMINANCE_ALPHA:
3191 dstLuminanceIndex = 0;
3192 dstAlphaIndex = 1;
3193 dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
3194 dstIntensityIndex = -1;
3195 break;
3196 case GL_INTENSITY:
3197 dstIntensityIndex = 0;
3198 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
3199 dstLuminanceIndex = -1;
3200 break;
3201 case GL_RGB:
3202 dstRedIndex = 0;
3203 dstGreenIndex = 1;
3204 dstBlueIndex = 2;
3205 dstAlphaIndex = dstLuminanceIndex = dstIntensityIndex = -1;
3206 break;
3207 case GL_RGBA:
3208 dstRedIndex = 0;
3209 dstGreenIndex = 1;
3210 dstBlueIndex = 2;
3211 dstAlphaIndex = 3;
3212 dstLuminanceIndex = dstIntensityIndex = -1;
3213 break;
3214 default:
3215 _mesa_problem(ctx, "bad dstFormat in _mesa_unpack_color_span_float()");
3216 UNDEFARRAY(rgba); /* mac 32k limitation */
3217 return;
3218 }
3219
3220 /* Now pack results in the requested dstFormat */
3221 if (dstRedIndex >= 0) {
3222 GLfloat *dst = dest;
3223 GLuint i;
3224 for (i = 0; i < n; i++) {
3225 dst[dstRedIndex] = rgba[i][RCOMP];
3226 dst += dstComponents;
3227 }
3228 }
3229
3230 if (dstGreenIndex >= 0) {
3231 GLfloat *dst = dest;
3232 GLuint i;
3233 for (i = 0; i < n; i++) {
3234 dst[dstGreenIndex] = rgba[i][GCOMP];
3235 dst += dstComponents;
3236 }
3237 }
3238
3239 if (dstBlueIndex >= 0) {
3240 GLfloat *dst = dest;
3241 GLuint i;
3242 for (i = 0; i < n; i++) {
3243 dst[dstBlueIndex] = rgba[i][BCOMP];
3244 dst += dstComponents;
3245 }
3246 }
3247
3248 if (dstAlphaIndex >= 0) {
3249 GLfloat *dst = dest;
3250 GLuint i;
3251 for (i = 0; i < n; i++) {
3252 dst[dstAlphaIndex] = rgba[i][ACOMP];
3253 dst += dstComponents;
3254 }
3255 }
3256
3257 if (dstIntensityIndex >= 0) {
3258 GLfloat *dst = dest;
3259 GLuint i;
3260 assert(dstIntensityIndex == 0);
3261 assert(dstComponents == 1);
3262 for (i = 0; i < n; i++) {
3263 /* Intensity comes from red channel */
3264 dst[i] = rgba[i][RCOMP];
3265 }
3266 }
3267
3268 if (dstLuminanceIndex >= 0) {
3269 GLfloat *dst = dest;
3270 GLuint i;
3271 assert(dstLuminanceIndex == 0);
3272 for (i = 0; i < n; i++) {
3273 /* Luminance comes from red channel */
3274 dst[0] = rgba[i][RCOMP];
3275 dst += dstComponents;
3276 }
3277 }
3278 UNDEFARRAY(rgba); /* mac 32k limitation */
3279 }
3280 }
3281
3282
3283 /*
3284 * Unpack a row of color index data from a client buffer according to
3285 * the pixel unpacking parameters.
3286 * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.
3287 *
3288 * Args: ctx - the context
3289 * n - number of pixels
3290 * dstType - destination data type
3291 * dest - destination array
3292 * srcType - source pixel type
3293 * source - source data pointer
3294 * srcPacking - pixel unpacking parameters
3295 * transferOps - the pixel transfer operations to apply
3296 */
3297 void
3298 _mesa_unpack_index_span( const GLcontext *ctx, GLuint n,
3299 GLenum dstType, GLvoid *dest,
3300 GLenum srcType, const GLvoid *source,
3301 const struct gl_pixelstore_attrib *srcPacking,
3302 GLuint transferOps )
3303 {
3304 ASSERT(srcType == GL_BITMAP ||
3305 srcType == GL_UNSIGNED_BYTE ||
3306 srcType == GL_BYTE ||
3307 srcType == GL_UNSIGNED_SHORT ||
3308 srcType == GL_SHORT ||
3309 srcType == GL_UNSIGNED_INT ||
3310 srcType == GL_INT ||
3311 srcType == GL_HALF_FLOAT_NV ||
3312 srcType == GL_FLOAT);
3313
3314 ASSERT(dstType == GL_UNSIGNED_BYTE ||
3315 dstType == GL_UNSIGNED_SHORT ||
3316 dstType == GL_UNSIGNED_INT);
3317
3318
3319 transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
3320
3321 /*
3322 * Try simple cases first
3323 */
3324 if (transferOps == 0 && srcType == GL_UNSIGNED_BYTE
3325 && dstType == GL_UNSIGNED_BYTE) {
3326 MEMCPY(dest, source, n * sizeof(GLubyte));
3327 }
3328 else if (transferOps == 0 && srcType == GL_UNSIGNED_INT
3329 && dstType == GL_UNSIGNED_INT && !srcPacking->SwapBytes) {
3330 MEMCPY(dest, source, n * sizeof(GLuint));
3331 }
3332 else {
3333 /*
3334 * general solution
3335 */
3336 GLuint indexes[MAX_WIDTH];
3337 assert(n <= MAX_WIDTH);
3338
3339 extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
3340 srcPacking);
3341
3342 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
3343 /* shift and offset indexes */
3344 _mesa_shift_and_offset_ci(ctx, n, indexes);
3345 }
3346 if (transferOps & IMAGE_MAP_COLOR_BIT) {
3347 /* Apply lookup table */
3348 _mesa_map_ci(ctx, n, indexes);
3349 }
3350
3351 /* convert to dest type */
3352 switch (dstType) {
3353 case GL_UNSIGNED_BYTE:
3354 {
3355 GLubyte *dst = (GLubyte *) dest;
3356 GLuint i;
3357 for (i = 0; i < n; i++) {
3358 dst[i] = (GLubyte) (indexes[i] & 0xff);
3359 }
3360 }
3361 break;
3362 case GL_UNSIGNED_SHORT:
3363 {
3364 GLuint *dst = (GLuint *) dest;
3365 GLuint i;
3366 for (i = 0; i < n; i++) {
3367 dst[i] = (GLushort) (indexes[i] & 0xffff);
3368 }
3369 }
3370 break;
3371 case GL_UNSIGNED_INT:
3372 MEMCPY(dest, indexes, n * sizeof(GLuint));
3373 break;
3374 default:
3375 _mesa_problem(ctx, "bad dstType in _mesa_unpack_index_span");
3376 }
3377 }
3378 }
3379
3380
3381 void
3382 _mesa_pack_index_span( const GLcontext *ctx, GLuint n,
3383 GLenum dstType, GLvoid *dest, const GLuint *source,
3384 const struct gl_pixelstore_attrib *dstPacking,
3385 GLuint transferOps )
3386 {
3387 GLuint indexes[MAX_WIDTH];
3388
3389 ASSERT(n <= MAX_WIDTH);
3390
3391 transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
3392
3393 if (transferOps & (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT)) {
3394 /* make a copy of input */
3395 MEMCPY(indexes, source, n * sizeof(GLuint));
3396 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
3397 _mesa_shift_and_offset_ci( ctx, n, indexes);
3398 }
3399 if (transferOps & IMAGE_MAP_COLOR_BIT) {
3400 _mesa_map_ci(ctx, n, indexes);
3401 }
3402 source = indexes;
3403 }
3404
3405 switch (dstType) {
3406 case GL_UNSIGNED_BYTE:
3407 {
3408 GLubyte *dst = (GLubyte *) dest;
3409 GLuint i;
3410 for (i = 0; i < n; i++) {
3411 *dst++ = (GLubyte) source[i];
3412 }
3413 }
3414 break;
3415 case GL_BYTE:
3416 {
3417 GLbyte *dst = (GLbyte *) dest;
3418 GLuint i;
3419 for (i = 0; i < n; i++) {
3420 dst[i] = (GLbyte) source[i];
3421 }
3422 }
3423 break;
3424 case GL_UNSIGNED_SHORT:
3425 {
3426 GLushort *dst = (GLushort *) dest;
3427 GLuint i;
3428 for (i = 0; i < n; i++) {
3429 dst[i] = (GLushort) source[i];
3430 }
3431 if (dstPacking->SwapBytes) {
3432 _mesa_swap2( (GLushort *) dst, n );
3433 }
3434 }
3435 break;
3436 case GL_SHORT:
3437 {
3438 GLshort *dst = (GLshort *) dest;
3439 GLuint i;
3440 for (i = 0; i < n; i++) {
3441 dst[i] = (GLshort) source[i];
3442 }
3443 if (dstPacking->SwapBytes) {
3444 _mesa_swap2( (GLushort *) dst, n );
3445 }
3446 }
3447 break;
3448 case GL_UNSIGNED_INT:
3449 {
3450 GLuint *dst = (GLuint *) dest;
3451 GLuint i;
3452 for (i = 0; i < n; i++) {
3453 dst[i] = (GLuint) source[i];
3454 }
3455 if (dstPacking->SwapBytes) {
3456 _mesa_swap4( (GLuint *) dst, n );
3457 }
3458 }
3459 break;
3460 case GL_INT:
3461 {
3462 GLint *dst = (GLint *) dest;
3463 GLuint i;
3464 for (i = 0; i < n; i++) {
3465 dst[i] = (GLint) source[i];
3466 }
3467 if (dstPacking->SwapBytes) {
3468 _mesa_swap4( (GLuint *) dst, n );
3469 }
3470 }
3471 break;
3472 case GL_FLOAT:
3473 {
3474 GLfloat *dst = (GLfloat *) dest;
3475 GLuint i;
3476 for (i = 0; i < n; i++) {
3477 dst[i] = (GLfloat) source[i];
3478 }
3479 if (dstPacking->SwapBytes) {
3480 _mesa_swap4( (GLuint *) dst, n );
3481 }
3482 }
3483 break;
3484 case GL_HALF_FLOAT_NV:
3485 {
3486 GLhalfNV *dst = (GLhalfNV *) dest;
3487 GLuint i;
3488 for (i = 0; i < n; i++) {
3489 dst[i] = _mesa_float_to_half((GLfloat) source[i]);
3490 }
3491 if (dstPacking->SwapBytes) {
3492 _mesa_swap2( (GLushort *) dst, n );
3493 }
3494 }
3495 break;
3496 default:
3497 _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
3498 }
3499 }
3500
3501
3502 /*
3503 * Unpack a row of stencil data from a client buffer according to
3504 * the pixel unpacking parameters.
3505 * This is (or will be) used by glDrawPixels
3506 *
3507 * Args: ctx - the context
3508 * n - number of pixels
3509 * dstType - destination data type
3510 * dest - destination array
3511 * srcType - source pixel type
3512 * source - source data pointer
3513 * srcPacking - pixel unpacking parameters
3514 * transferOps - apply offset/bias/lookup ops?
3515 */
3516 void
3517 _mesa_unpack_stencil_span( const GLcontext *ctx, GLuint n,
3518 GLenum dstType, GLvoid *dest,
3519 GLenum srcType, const GLvoid *source,
3520 const struct gl_pixelstore_attrib *srcPacking,
3521 GLuint transferOps )
3522 {
3523 ASSERT(srcType == GL_BITMAP ||
3524 srcType == GL_UNSIGNED_BYTE ||
3525 srcType == GL_BYTE ||
3526 srcType == GL_UNSIGNED_SHORT ||
3527 srcType == GL_SHORT ||
3528 srcType == GL_UNSIGNED_INT ||
3529 srcType == GL_INT ||
3530 srcType == GL_HALF_FLOAT_NV ||
3531 srcType == GL_FLOAT);
3532
3533 ASSERT(dstType == GL_UNSIGNED_BYTE ||
3534 dstType == GL_UNSIGNED_SHORT ||
3535 dstType == GL_UNSIGNED_INT);
3536
3537 /* only shift and offset apply to stencil */
3538 transferOps &= IMAGE_SHIFT_OFFSET_BIT;
3539
3540 /*
3541 * Try simple cases first
3542 */
3543 if (transferOps == 0 &&
3544 srcType == GL_UNSIGNED_BYTE &&
3545 dstType == GL_UNSIGNED_BYTE) {
3546 MEMCPY(dest, source, n * sizeof(GLubyte));
3547 }
3548 else if (transferOps == 0 &&
3549 srcType == GL_UNSIGNED_INT &&
3550 dstType == GL_UNSIGNED_INT &&
3551 !srcPacking->SwapBytes) {
3552 MEMCPY(dest, source, n * sizeof(GLuint));
3553 }
3554 else {
3555 /*
3556 * general solution
3557 */
3558 GLuint indexes[MAX_WIDTH];
3559 assert(n <= MAX_WIDTH);
3560
3561 extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
3562 srcPacking);
3563
3564 if (transferOps) {
3565 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
3566 /* shift and offset indexes */
3567 _mesa_shift_and_offset_ci(ctx, n, indexes);
3568 }
3569
3570 if (ctx->Pixel.MapStencilFlag) {
3571 /* Apply stencil lookup table */
3572 GLuint mask = ctx->Pixel.MapStoSsize - 1;
3573 GLuint i;
3574 for (i=0;i<n;i++) {
3575 indexes[i] = ctx->Pixel.MapStoS[ indexes[i] & mask ];
3576 }
3577 }
3578 }
3579
3580 /* convert to dest type */
3581 switch (dstType) {
3582 case GL_UNSIGNED_BYTE:
3583 {
3584 GLubyte *dst = (GLubyte *) dest;
3585 GLuint i;
3586 for (i = 0; i < n; i++) {
3587 dst[i] = (GLubyte) (indexes[i] & 0xff);
3588 }
3589 }
3590 break;
3591 case GL_UNSIGNED_SHORT:
3592 {
3593 GLuint *dst = (GLuint *) dest;
3594 GLuint i;
3595 for (i = 0; i < n; i++) {
3596 dst[i] = (GLushort) (indexes[i] & 0xffff);
3597 }
3598 }
3599 break;
3600 case GL_UNSIGNED_INT:
3601 MEMCPY(dest, indexes, n * sizeof(GLuint));
3602 break;
3603 default:
3604 _mesa_problem(ctx, "bad dstType in _mesa_unpack_stencil_span");
3605 }
3606 }
3607 }
3608
3609
3610 void
3611 _mesa_pack_stencil_span( const GLcontext *ctx, GLuint n,
3612 GLenum dstType, GLvoid *dest, const GLstencil *source,
3613 const struct gl_pixelstore_attrib *dstPacking )
3614 {
3615 GLstencil stencil[MAX_WIDTH];
3616
3617 ASSERT(n <= MAX_WIDTH);
3618
3619 if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset ||
3620 ctx->Pixel.MapStencilFlag) {
3621 /* make a copy of input */
3622 MEMCPY(stencil, source, n * sizeof(GLstencil));
3623 if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset) {
3624 _mesa_shift_and_offset_stencil( ctx, n, stencil );
3625 }
3626 if (ctx->Pixel.MapStencilFlag) {
3627 _mesa_map_stencil( ctx, n, stencil );
3628 }
3629 source = stencil;
3630 }
3631
3632 switch (dstType) {
3633 case GL_UNSIGNED_BYTE:
3634 if (sizeof(GLstencil) == 8) {
3635 MEMCPY( dest, source, n );
3636 }
3637 else {
3638 GLubyte *dst = (GLubyte *) dest;
3639 GLuint i;
3640 for (i=0;i<n;i++) {
3641 dst[i] = (GLubyte) source[i];
3642 }
3643 }
3644 break;
3645 case GL_BYTE:
3646 if (sizeof(GLstencil) == 8) {
3647 MEMCPY( dest, source, n );
3648 }
3649 else {
3650 GLbyte *dst = (GLbyte *) dest;
3651 GLuint i;
3652 for (i=0;i<n;i++) {
3653 dst[i] = (GLbyte) source[i];
3654 }
3655 }
3656 break;
3657 case GL_UNSIGNED_SHORT:
3658 {
3659 GLushort *dst = (GLushort *) dest;
3660 GLuint i;
3661 for (i=0;i<n;i++) {
3662 dst[i] = (GLushort) source[i];
3663 }
3664 if (dstPacking->SwapBytes) {
3665 _mesa_swap2( (GLushort *) dst, n );
3666 }
3667 }
3668 break;
3669 case GL_SHORT:
3670 {
3671 GLshort *dst = (GLshort *) dest;
3672 GLuint i;
3673 for (i=0;i<n;i++) {
3674 dst[i] = (GLshort) source[i];
3675 }
3676 if (dstPacking->SwapBytes) {
3677 _mesa_swap2( (GLushort *) dst, n );
3678 }
3679 }
3680 break;
3681 case GL_UNSIGNED_INT:
3682 {
3683 GLuint *dst = (GLuint *) dest;
3684 GLuint i;
3685 for (i=0;i<n;i++) {
3686 dst[i] = (GLuint) source[i];
3687 }
3688 if (dstPacking->SwapBytes) {
3689 _mesa_swap4( (GLuint *) dst, n );
3690 }
3691 }
3692 break;
3693 case GL_INT:
3694 {
3695 GLint *dst = (GLint *) dest;
3696 GLuint i;
3697 for (i=0;i<n;i++) {
3698 *dst++ = (GLint) source[i];
3699 }
3700 if (dstPacking->SwapBytes) {
3701 _mesa_swap4( (GLuint *) dst, n );
3702 }
3703 }
3704 break;
3705 case GL_FLOAT:
3706 {
3707 GLfloat *dst = (GLfloat *) dest;
3708 GLuint i;
3709 for (i=0;i<n;i++) {
3710 dst[i] = (GLfloat) source[i];
3711 }
3712 if (dstPacking->SwapBytes) {
3713 _mesa_swap4( (GLuint *) dst, n );
3714 }
3715 }
3716 break;
3717 case GL_HALF_FLOAT_NV:
3718 {
3719 GLhalfNV *dst = (GLhalfNV *) dest;
3720 GLuint i;
3721 for (i=0;i<n;i++) {
3722 dst[i] = _mesa_float_to_half( (float) source[i] );
3723 }
3724 if (dstPacking->SwapBytes) {
3725 _mesa_swap2( (GLushort *) dst, n );
3726 }
3727 }
3728 break;
3729 case GL_BITMAP:
3730 if (dstPacking->LsbFirst) {
3731 GLubyte *dst = (GLubyte *) dest;
3732 GLint shift = 0;
3733 GLuint i;
3734 for (i = 0; i < n; i++) {
3735 if (shift == 0)
3736 *dst = 0;
3737 *dst |= ((source[i] != 0) << shift);
3738 shift++;
3739 if (shift == 8) {
3740 shift = 0;
3741 dst++;
3742 }
3743 }
3744 }
3745 else {
3746 GLubyte *dst = (GLubyte *) dest;
3747 GLint shift = 7;
3748 GLuint i;
3749 for (i = 0; i < n; i++) {
3750 if (shift == 7)
3751 *dst = 0;
3752 *dst |= ((source[i] != 0) << shift);
3753 shift--;
3754 if (shift < 0) {
3755 shift = 7;
3756 dst++;
3757 }
3758 }
3759 }
3760 break;
3761 default:
3762 _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
3763 }
3764 }
3765
3766
3767 void
3768 _mesa_unpack_depth_span( const GLcontext *ctx, GLuint n, GLfloat *dest,
3769 GLenum srcType, const GLvoid *source,
3770 const struct gl_pixelstore_attrib *srcPacking )
3771 {
3772 switch (srcType) {
3773 case GL_BYTE:
3774 {
3775 GLuint i;
3776 const GLubyte *src = (const GLubyte *) source;
3777 for (i = 0; i < n; i++) {
3778 dest[i] = BYTE_TO_FLOAT(src[i]);
3779 }
3780 }
3781 break;
3782 case GL_UNSIGNED_BYTE:
3783 {
3784 GLuint i;
3785 const GLubyte *src = (const GLubyte *) source;
3786 for (i = 0; i < n; i++) {
3787 dest[i] = UBYTE_TO_FLOAT(src[i]);
3788 }
3789 }
3790 break;
3791 case GL_SHORT:
3792 {
3793 GLuint i;
3794 const GLshort *src = (const GLshort *) source;
3795 for (i = 0; i < n; i++) {
3796 dest[i] = SHORT_TO_FLOAT(src[i]);
3797 }
3798 }
3799 break;
3800 case GL_UNSIGNED_SHORT:
3801 {
3802 GLuint i;
3803 const GLushort *src = (const GLushort *) source;
3804 for (i = 0; i < n; i++) {
3805 dest[i] = USHORT_TO_FLOAT(src[i]);
3806 }
3807 }
3808 break;
3809 case GL_INT:
3810 {
3811 GLuint i;
3812 const GLint *src = (const GLint *) source;
3813 for (i = 0; i < n; i++) {
3814 dest[i] = INT_TO_FLOAT(src[i]);
3815 }
3816 }
3817 break;
3818 case GL_UNSIGNED_INT:
3819 {
3820 GLuint i;
3821 const GLuint *src = (const GLuint *) source;
3822 for (i = 0; i < n; i++) {
3823 dest[i] = UINT_TO_FLOAT(src[i]);
3824 }
3825 }
3826 break;
3827 case GL_FLOAT:
3828 MEMCPY(dest, source, n * sizeof(GLfloat));
3829 break;
3830 case GL_HALF_FLOAT_NV:
3831 {
3832 GLuint i;
3833 const GLhalfNV *src = (const GLhalfNV *) source;
3834 for (i = 0; i < n; i++) {
3835 dest[i] = _mesa_half_to_float(src[i]);
3836 }
3837 }
3838 break;
3839 default:
3840 _mesa_problem(NULL, "bad type in _mesa_unpack_depth_span()");
3841 return;
3842 }
3843
3844
3845 /* apply depth scale and bias and clamp to [0,1] */
3846 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
3847 GLuint i;
3848 for (i = 0; i < n; i++) {
3849 GLfloat d = dest[i] * ctx->Pixel.DepthScale + ctx->Pixel.DepthBias;
3850 dest[i] = CLAMP(d, 0.0F, 1.0F);
3851 }
3852 }
3853 }
3854
3855
3856 /*
3857 * Pack an array of depth values. The values are floats in [0,1].
3858 */
3859 void
3860 _mesa_pack_depth_span( const GLcontext *ctx, GLuint n, GLvoid *dest,
3861 GLenum dstType, const GLfloat *depthSpan,
3862 const struct gl_pixelstore_attrib *dstPacking )
3863 {
3864 GLfloat depthCopy[MAX_WIDTH];
3865 const GLboolean bias_or_scale = ctx->Pixel.DepthBias != 0.0 ||
3866 ctx->Pixel.DepthScale != 1.0;
3867
3868 ASSERT(n <= MAX_WIDTH);
3869
3870 if (bias_or_scale) {
3871 GLuint i;
3872 for (i = 0; i < n; i++) {
3873 GLfloat d;
3874 d = depthSpan[i] * ctx->Pixel.DepthScale + ctx->Pixel.DepthBias;
3875 depthCopy[i] = CLAMP(d, 0.0F, 1.0F);
3876 }
3877 depthSpan = depthCopy;
3878 }
3879
3880 switch (dstType) {
3881 case GL_UNSIGNED_BYTE:
3882 {
3883 GLubyte *dst = (GLubyte *) dest;
3884 GLuint i;
3885 for (i = 0; i < n; i++) {
3886 dst[i] = FLOAT_TO_UBYTE( depthSpan[i] );
3887 }
3888 }
3889 break;
3890 case GL_BYTE:
3891 {
3892 GLbyte *dst = (GLbyte *) dest;
3893 GLuint i;
3894 for (i = 0; i < n; i++) {
3895 dst[i] = FLOAT_TO_BYTE( depthSpan[i] );
3896 }
3897 }
3898 break;
3899 case GL_UNSIGNED_SHORT:
3900 {
3901 GLushort *dst = (GLushort *) dest;
3902 GLuint i;
3903 for (i = 0; i < n; i++) {
3904 dst[i] = FLOAT_TO_USHORT( depthSpan[i] );
3905 }
3906 if (dstPacking->SwapBytes) {
3907 _mesa_swap2( (GLushort *) dst, n );
3908 }
3909 }
3910 break;
3911 case GL_SHORT:
3912 {
3913 GLshort *dst = (GLshort *) dest;
3914 GLuint i;
3915 for (i = 0; i < n; i++) {
3916 dst[i] = FLOAT_TO_SHORT( depthSpan[i] );
3917 }
3918 if (dstPacking->SwapBytes) {
3919 _mesa_swap2( (GLushort *) dst, n );
3920 }
3921 }
3922 break;
3923 case GL_UNSIGNED_INT:
3924 {
3925 GLuint *dst = (GLuint *) dest;
3926 GLuint i;
3927 for (i = 0; i < n; i++) {
3928 dst[i] = FLOAT_TO_UINT( depthSpan[i] );
3929 }
3930 if (dstPacking->SwapBytes) {
3931 _mesa_swap4( (GLuint *) dst, n );
3932 }
3933 }
3934 break;
3935 case GL_INT:
3936 {
3937 GLint *dst = (GLint *) dest;
3938 GLuint i;
3939 for (i = 0; i < n; i++) {
3940 dst[i] = FLOAT_TO_INT( depthSpan[i] );
3941 }
3942 if (dstPacking->SwapBytes) {
3943 _mesa_swap4( (GLuint *) dst, n );
3944 }
3945 }
3946 break;
3947 case GL_FLOAT:
3948 {
3949 GLfloat *dst = (GLfloat *) dest;
3950 GLuint i;
3951 for (i = 0; i < n; i++) {
3952 dst[i] = depthSpan[i];
3953 }
3954 if (dstPacking->SwapBytes) {
3955 _mesa_swap4( (GLuint *) dst, n );
3956 }
3957 }
3958 break;
3959 case GL_HALF_FLOAT_NV:
3960 {
3961 GLhalfNV *dst = (GLhalfNV *) dest;
3962 GLuint i;
3963 for (i = 0; i < n; i++) {
3964 dst[i] = _mesa_float_to_half(depthSpan[i]);
3965 }
3966 if (dstPacking->SwapBytes) {
3967 _mesa_swap2( (GLushort *) dst, n );
3968 }
3969 }
3970 break;
3971 default:
3972 _mesa_problem(ctx, "bad type in _mesa_pack_depth_span");
3973 }
3974 }
3975
3976
3977 /*
3978 * Unpack image data. Apply byteswapping, byte flipping (bitmap).
3979 * Return all image data in a contiguous block.
3980 */
3981 void *
3982 _mesa_unpack_image( GLsizei width, GLsizei height, GLsizei depth,
3983 GLenum format, GLenum type, const GLvoid *pixels,
3984 const struct gl_pixelstore_attrib *unpack )
3985 {
3986 GLint bytesPerRow, compsPerRow;
3987 GLboolean flipBytes, swap2, swap4;
3988
3989 if (!pixels)
3990 return NULL; /* not necessarily an error */
3991
3992 if (width <= 0 || height <= 0 || depth <= 0)
3993 return NULL; /* generate error later */
3994
3995 if (format == GL_BITMAP) {
3996 bytesPerRow = (width + 7) >> 3;
3997 flipBytes = !unpack->LsbFirst;
3998 swap2 = swap4 = GL_FALSE;
3999 compsPerRow = 0;
4000 }
4001 else {
4002 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
4003 const GLint components = _mesa_components_in_format(format);
4004 GLint bytesPerComp;
4005 if (bytesPerPixel <= 0 || components <= 0)
4006 return NULL; /* bad format or type. generate error later */
4007 bytesPerRow = bytesPerPixel * width;
4008 bytesPerComp = bytesPerPixel / components;
4009 flipBytes = GL_FALSE;
4010 swap2 = (bytesPerComp == 2) && unpack->SwapBytes;
4011 swap4 = (bytesPerComp == 4) && unpack->SwapBytes;
4012 compsPerRow = components * width;
4013 assert(compsPerRow >= width);
4014 }
4015
4016 {
4017 GLubyte *destBuffer = (GLubyte *) MALLOC(bytesPerRow * height * depth);
4018 GLubyte *dst;
4019 GLint img, row;
4020 if (!destBuffer)
4021 return NULL; /* generate GL_OUT_OF_MEMORY later */
4022
4023 dst = destBuffer;
4024 for (img = 0; img < depth; img++) {
4025 for (row = 0; row < height; row++) {
4026 const GLvoid *src = _mesa_image_address(unpack, pixels,
4027 width, height, format, type, img, row, 0);
4028 MEMCPY(dst, src, bytesPerRow);
4029 /* byte flipping/swapping */
4030 if (flipBytes) {
4031 flip_bytes((GLubyte *) dst, bytesPerRow);
4032 }
4033 else if (swap2) {
4034 _mesa_swap2((GLushort*) dst, compsPerRow);
4035 }
4036 else if (swap4) {
4037 _mesa_swap4((GLuint*) dst, compsPerRow);
4038 }
4039 dst += bytesPerRow;
4040 }
4041 }
4042 return destBuffer;
4043 }
4044 }
4045
4046 #endif