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