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