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