projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge branch 'mesa_7_5_branch'
[mesa.git] / src / mesa / main / image.c
1 /*
2 * Mesa 3-D graphics library
3 * Version: 7.5
4 *
5 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved.
6 * Copyright (C) 2009 VMware, Inc. All Rights Reserved.
7 *
8 * Permission is hereby granted, free of charge, to any person obtaining a
9 * copy of this software and associated documentation files (the "Software"),
10 * to deal in the Software without restriction, including without limitation
11 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
12 * and/or sell copies of the Software, and to permit persons to whom the
13 * Software is furnished to do so, subject to the following conditions:
14 *
15 * The above copyright notice and this permission notice shall be included
16 * in all copies or substantial portions of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
22 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
23 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 */
25
26
27 /**
28 * \file image.c
29 * Image handling.
30 */
31
32
33 #include "glheader.h"
34 #include "colormac.h"
35 #include "context.h"
36 #include "image.h"
37 #include "imports.h"
38 #include "macros.h"
39 #include "pixel.h"
40
41
42 /**
43 * NOTE:
44 * Normally, BYTE_TO_FLOAT(0) returns 0.00392 That causes problems when
45 * we later convert the float to a packed integer value (such as for
46 * GL_RGB5_A1) because we'll wind up with a non-zero value.
47 *
48 * We redefine the macros here so zero is handled correctly.
49 */
50 #undef BYTE_TO_FLOAT
51 #define BYTE_TO_FLOAT(B) ((B) == 0 ? 0.0F : ((2.0F * (B) + 1.0F) * (1.0F/255.0F)))
52
53 #undef SHORT_TO_FLOAT
54 #define SHORT_TO_FLOAT(S) ((S) == 0 ? 0.0F : ((2.0F * (S) + 1.0F) * (1.0F/65535.0F)))
55
56
57
58 /** Compute ceiling of integer quotient of A divided by B. */
59 #define CEILING( A, B ) ( (A) % (B) == 0 ? (A)/(B) : (A)/(B)+1 )
60
61
62 /**
63 * \return GL_TRUE if type is packed pixel type, GL_FALSE otherwise.
64 */
65 GLboolean
66 _mesa_type_is_packed(GLenum type)
67 {
68 switch (type) {
69 case GL_UNSIGNED_BYTE_3_3_2:
70 case GL_UNSIGNED_BYTE_2_3_3_REV:
71 case GL_UNSIGNED_SHORT_5_6_5:
72 case GL_UNSIGNED_SHORT_5_6_5_REV:
73 case GL_UNSIGNED_SHORT_4_4_4_4:
74 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
75 case GL_UNSIGNED_SHORT_5_5_5_1:
76 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
77 case GL_UNSIGNED_INT_8_8_8_8:
78 case GL_UNSIGNED_INT_8_8_8_8_REV:
79 case GL_UNSIGNED_INT_10_10_10_2:
80 case GL_UNSIGNED_INT_2_10_10_10_REV:
81 case GL_UNSIGNED_SHORT_8_8_MESA:
82 case GL_UNSIGNED_SHORT_8_8_REV_MESA:
83 case GL_UNSIGNED_INT_24_8_EXT:
84 return GL_TRUE;
85 }
86
87 return GL_FALSE;
88 }
89
90 /**
91 * Flip the 8 bits in each byte of the given array.
92 *
93 * \param p array.
94 * \param n number of bytes.
95 *
96 * \todo try this trick to flip bytes someday:
97 * \code
98 * v = ((v & 0x55555555) << 1) | ((v >> 1) & 0x55555555);
99 * v = ((v & 0x33333333) << 2) | ((v >> 2) & 0x33333333);
100 * v = ((v & 0x0f0f0f0f) << 4) | ((v >> 4) & 0x0f0f0f0f);
101 * \endcode
102 */
103 static void
104 flip_bytes( GLubyte *p, GLuint n )
105 {
106 GLuint i, a, b;
107 for (i = 0; i < n; i++) {
108 b = (GLuint) p[i]; /* words are often faster than bytes */
109 a = ((b & 0x01) << 7) |
110 ((b & 0x02) << 5) |
111 ((b & 0x04) << 3) |
112 ((b & 0x08) << 1) |
113 ((b & 0x10) >> 1) |
114 ((b & 0x20) >> 3) |
115 ((b & 0x40) >> 5) |
116 ((b & 0x80) >> 7);
117 p[i] = (GLubyte) a;
118 }
119 }
120
121
122 /**
123 * Flip the order of the 2 bytes in each word in the given array.
124 *
125 * \param p array.
126 * \param n number of words.
127 */
128 void
129 _mesa_swap2( GLushort *p, GLuint n )
130 {
131 GLuint i;
132 for (i = 0; i < n; i++) {
133 p[i] = (p[i] >> 8) | ((p[i] << 8) & 0xff00);
134 }
135 }
136
137
138
139 /*
140 * Flip the order of the 4 bytes in each word in the given array.
141 */
142 void
143 _mesa_swap4( GLuint *p, GLuint n )
144 {
145 GLuint i, a, b;
146 for (i = 0; i < n; i++) {
147 b = p[i];
148 a = (b >> 24)
149 | ((b >> 8) & 0xff00)
150 | ((b << 8) & 0xff0000)
151 | ((b << 24) & 0xff000000);
152 p[i] = a;
153 }
154 }
155
156
157 /**
158 * Get the size of a GL data type.
159 *
160 * \param type GL data type.
161 *
162 * \return the size, in bytes, of the given data type, 0 if a GL_BITMAP, or -1
163 * if an invalid type enum.
164 */
165 GLint
166 _mesa_sizeof_type( GLenum type )
167 {
168 switch (type) {
169 case GL_BITMAP:
170 return 0;
171 case GL_UNSIGNED_BYTE:
172 return sizeof(GLubyte);
173 case GL_BYTE:
174 return sizeof(GLbyte);
175 case GL_UNSIGNED_SHORT:
176 return sizeof(GLushort);
177 case GL_SHORT:
178 return sizeof(GLshort);
179 case GL_UNSIGNED_INT:
180 return sizeof(GLuint);
181 case GL_INT:
182 return sizeof(GLint);
183 case GL_FLOAT:
184 return sizeof(GLfloat);
185 case GL_DOUBLE:
186 return sizeof(GLdouble);
187 case GL_HALF_FLOAT_ARB:
188 return sizeof(GLhalfARB);
189 default:
190 return -1;
191 }
192 }
193
194
195 /**
196 * Same as _mesa_sizeof_type() but also accepting the packed pixel
197 * format data types.
198 */
199 GLint
200 _mesa_sizeof_packed_type( GLenum type )
201 {
202 switch (type) {
203 case GL_BITMAP:
204 return 0;
205 case GL_UNSIGNED_BYTE:
206 return sizeof(GLubyte);
207 case GL_BYTE:
208 return sizeof(GLbyte);
209 case GL_UNSIGNED_SHORT:
210 return sizeof(GLushort);
211 case GL_SHORT:
212 return sizeof(GLshort);
213 case GL_UNSIGNED_INT:
214 return sizeof(GLuint);
215 case GL_INT:
216 return sizeof(GLint);
217 case GL_HALF_FLOAT_ARB:
218 return sizeof(GLhalfARB);
219 case GL_FLOAT:
220 return sizeof(GLfloat);
221 case GL_UNSIGNED_BYTE_3_3_2:
222 return sizeof(GLubyte);
223 case GL_UNSIGNED_BYTE_2_3_3_REV:
224 return sizeof(GLubyte);
225 case GL_UNSIGNED_SHORT_5_6_5:
226 return sizeof(GLushort);
227 case GL_UNSIGNED_SHORT_5_6_5_REV:
228 return sizeof(GLushort);
229 case GL_UNSIGNED_SHORT_4_4_4_4:
230 return sizeof(GLushort);
231 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
232 return sizeof(GLushort);
233 case GL_UNSIGNED_SHORT_5_5_5_1:
234 return sizeof(GLushort);
235 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
236 return sizeof(GLushort);
237 case GL_UNSIGNED_INT_8_8_8_8:
238 return sizeof(GLuint);
239 case GL_UNSIGNED_INT_8_8_8_8_REV:
240 return sizeof(GLuint);
241 case GL_UNSIGNED_INT_10_10_10_2:
242 return sizeof(GLuint);
243 case GL_UNSIGNED_INT_2_10_10_10_REV:
244 return sizeof(GLuint);
245 case GL_UNSIGNED_SHORT_8_8_MESA:
246 case GL_UNSIGNED_SHORT_8_8_REV_MESA:
247 return sizeof(GLushort);
248 case GL_UNSIGNED_INT_24_8_EXT:
249 return sizeof(GLuint);
250 default:
251 return -1;
252 }
253 }
254
255
256 /**
257 * Get the number of components in a pixel format.
258 *
259 * \param format pixel format.
260 *
261 * \return the number of components in the given format, or -1 if a bad format.
262 */
263 GLint
264 _mesa_components_in_format( GLenum format )
265 {
266 switch (format) {
267 case GL_COLOR_INDEX:
268 case GL_COLOR_INDEX1_EXT:
269 case GL_COLOR_INDEX2_EXT:
270 case GL_COLOR_INDEX4_EXT:
271 case GL_COLOR_INDEX8_EXT:
272 case GL_COLOR_INDEX12_EXT:
273 case GL_COLOR_INDEX16_EXT:
274 case GL_STENCIL_INDEX:
275 case GL_DEPTH_COMPONENT:
276 case GL_RED:
277 case GL_GREEN:
278 case GL_BLUE:
279 case GL_ALPHA:
280 case GL_LUMINANCE:
281 case GL_INTENSITY:
282 return 1;
283 case GL_LUMINANCE_ALPHA:
284 return 2;
285 case GL_RGB:
286 return 3;
287 case GL_RGBA:
288 return 4;
289 case GL_BGR:
290 return 3;
291 case GL_BGRA:
292 return 4;
293 case GL_ABGR_EXT:
294 return 4;
295 case GL_YCBCR_MESA:
296 return 2;
297 case GL_DEPTH_STENCIL_EXT:
298 return 2;
299 case GL_DUDV_ATI:
300 case GL_DU8DV8_ATI:
301 return 2;
302 default:
303 return -1;
304 }
305 }
306
307
308 /**
309 * Get the bytes per pixel of pixel format type pair.
310 *
311 * \param format pixel format.
312 * \param type pixel type.
313 *
314 * \return bytes per pixel, or -1 if a bad format or type was given.
315 */
316 GLint
317 _mesa_bytes_per_pixel( GLenum format, GLenum type )
318 {
319 GLint comps = _mesa_components_in_format( format );
320 if (comps < 0)
321 return -1;
322
323 switch (type) {
324 case GL_BITMAP:
325 return 0; /* special case */
326 case GL_BYTE:
327 case GL_UNSIGNED_BYTE:
328 return comps * sizeof(GLubyte);
329 case GL_SHORT:
330 case GL_UNSIGNED_SHORT:
331 return comps * sizeof(GLshort);
332 case GL_INT:
333 case GL_UNSIGNED_INT:
334 return comps * sizeof(GLint);
335 case GL_FLOAT:
336 return comps * sizeof(GLfloat);
337 case GL_HALF_FLOAT_ARB:
338 return comps * sizeof(GLhalfARB);
339 case GL_UNSIGNED_BYTE_3_3_2:
340 case GL_UNSIGNED_BYTE_2_3_3_REV:
341 if (format == GL_RGB || format == GL_BGR)
342 return sizeof(GLubyte);
343 else
344 return -1; /* error */
345 case GL_UNSIGNED_SHORT_5_6_5:
346 case GL_UNSIGNED_SHORT_5_6_5_REV:
347 if (format == GL_RGB || format == GL_BGR)
348 return sizeof(GLushort);
349 else
350 return -1; /* error */
351 case GL_UNSIGNED_SHORT_4_4_4_4:
352 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
353 case GL_UNSIGNED_SHORT_5_5_5_1:
354 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
355 if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT)
356 return sizeof(GLushort);
357 else
358 return -1;
359 case GL_UNSIGNED_INT_8_8_8_8:
360 case GL_UNSIGNED_INT_8_8_8_8_REV:
361 case GL_UNSIGNED_INT_10_10_10_2:
362 case GL_UNSIGNED_INT_2_10_10_10_REV:
363 if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT)
364 return sizeof(GLuint);
365 else
366 return -1;
367 case GL_UNSIGNED_SHORT_8_8_MESA:
368 case GL_UNSIGNED_SHORT_8_8_REV_MESA:
369 if (format == GL_YCBCR_MESA)
370 return sizeof(GLushort);
371 else
372 return -1;
373 case GL_UNSIGNED_INT_24_8_EXT:
374 if (format == GL_DEPTH_STENCIL_EXT)
375 return sizeof(GLuint);
376 else
377 return -1;
378 default:
379 return -1;
380 }
381 }
382
383
384 /**
385 * Test for a legal pixel format and type.
386 *
387 * \param format pixel format.
388 * \param type pixel type.
389 *
390 * \return GL_TRUE if the given pixel format and type are legal, or GL_FALSE
391 * otherwise.
392 */
393 GLboolean
394 _mesa_is_legal_format_and_type( GLcontext *ctx, GLenum format, GLenum type )
395 {
396 switch (format) {
397 case GL_COLOR_INDEX:
398 case GL_STENCIL_INDEX:
399 switch (type) {
400 case GL_BITMAP:
401 case GL_BYTE:
402 case GL_UNSIGNED_BYTE:
403 case GL_SHORT:
404 case GL_UNSIGNED_SHORT:
405 case GL_INT:
406 case GL_UNSIGNED_INT:
407 case GL_FLOAT:
408 return GL_TRUE;
409 case GL_HALF_FLOAT_ARB:
410 return ctx->Extensions.ARB_half_float_pixel;
411 default:
412 return GL_FALSE;
413 }
414 case GL_RED:
415 case GL_GREEN:
416 case GL_BLUE:
417 case GL_ALPHA:
418 #if 0 /* not legal! see table 3.6 of the 1.5 spec */
419 case GL_INTENSITY:
420 #endif
421 case GL_LUMINANCE:
422 case GL_LUMINANCE_ALPHA:
423 case GL_DEPTH_COMPONENT:
424 switch (type) {
425 case GL_BYTE:
426 case GL_UNSIGNED_BYTE:
427 case GL_SHORT:
428 case GL_UNSIGNED_SHORT:
429 case GL_INT:
430 case GL_UNSIGNED_INT:
431 case GL_FLOAT:
432 return GL_TRUE;
433 case GL_HALF_FLOAT_ARB:
434 return ctx->Extensions.ARB_half_float_pixel;
435 default:
436 return GL_FALSE;
437 }
438 case GL_RGB:
439 switch (type) {
440 case GL_BYTE:
441 case GL_UNSIGNED_BYTE:
442 case GL_SHORT:
443 case GL_UNSIGNED_SHORT:
444 case GL_INT:
445 case GL_UNSIGNED_INT:
446 case GL_FLOAT:
447 case GL_UNSIGNED_BYTE_3_3_2:
448 case GL_UNSIGNED_BYTE_2_3_3_REV:
449 case GL_UNSIGNED_SHORT_5_6_5:
450 case GL_UNSIGNED_SHORT_5_6_5_REV:
451 return GL_TRUE;
452 case GL_HALF_FLOAT_ARB:
453 return ctx->Extensions.ARB_half_float_pixel;
454 default:
455 return GL_FALSE;
456 }
457 case GL_BGR:
458 switch (type) {
459 /* NOTE: no packed types are supported with BGR. That's
460 * intentional, according to the GL spec.
461 */
462 case GL_BYTE:
463 case GL_UNSIGNED_BYTE:
464 case GL_SHORT:
465 case GL_UNSIGNED_SHORT:
466 case GL_INT:
467 case GL_UNSIGNED_INT:
468 case GL_FLOAT:
469 return GL_TRUE;
470 case GL_HALF_FLOAT_ARB:
471 return ctx->Extensions.ARB_half_float_pixel;
472 default:
473 return GL_FALSE;
474 }
475 case GL_RGBA:
476 case GL_BGRA:
477 case GL_ABGR_EXT:
478 switch (type) {
479 case GL_BYTE:
480 case GL_UNSIGNED_BYTE:
481 case GL_SHORT:
482 case GL_UNSIGNED_SHORT:
483 case GL_INT:
484 case GL_UNSIGNED_INT:
485 case GL_FLOAT:
486 case GL_UNSIGNED_SHORT_4_4_4_4:
487 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
488 case GL_UNSIGNED_SHORT_5_5_5_1:
489 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
490 case GL_UNSIGNED_INT_8_8_8_8:
491 case GL_UNSIGNED_INT_8_8_8_8_REV:
492 case GL_UNSIGNED_INT_10_10_10_2:
493 case GL_UNSIGNED_INT_2_10_10_10_REV:
494 return GL_TRUE;
495 case GL_HALF_FLOAT_ARB:
496 return ctx->Extensions.ARB_half_float_pixel;
497 default:
498 return GL_FALSE;
499 }
500 case GL_YCBCR_MESA:
501 if (type == GL_UNSIGNED_SHORT_8_8_MESA ||
502 type == GL_UNSIGNED_SHORT_8_8_REV_MESA)
503 return GL_TRUE;
504 else
505 return GL_FALSE;
506 case GL_DEPTH_STENCIL_EXT:
507 if (ctx->Extensions.EXT_packed_depth_stencil
508 && type == GL_UNSIGNED_INT_24_8_EXT)
509 return GL_TRUE;
510 else
511 return GL_FALSE;
512 case GL_DUDV_ATI:
513 case GL_DU8DV8_ATI:
514 switch (type) {
515 case GL_BYTE:
516 case GL_UNSIGNED_BYTE:
517 case GL_SHORT:
518 case GL_UNSIGNED_SHORT:
519 case GL_INT:
520 case GL_UNSIGNED_INT:
521 case GL_FLOAT:
522 return GL_TRUE;
523 default:
524 return GL_FALSE;
525 }
526 default:
527 ; /* fall-through */
528 }
529 return GL_FALSE;
530 }
531
532
533 /**
534 * Test if the given image format is a color/RGBA format (i.e., not color
535 * index, depth, stencil, etc).
536 * \param format the image format value (may by an internal texture format)
537 * \return GL_TRUE if its a color/RGBA format, GL_FALSE otherwise.
538 */
539 GLboolean
540 _mesa_is_color_format(GLenum format)
541 {
542 switch (format) {
543 case GL_RED:
544 case GL_GREEN:
545 case GL_BLUE:
546 case GL_ALPHA:
547 case GL_ALPHA4:
548 case GL_ALPHA8:
549 case GL_ALPHA12:
550 case GL_ALPHA16:
551 case 1:
552 case GL_LUMINANCE:
553 case GL_LUMINANCE4:
554 case GL_LUMINANCE8:
555 case GL_LUMINANCE12:
556 case GL_LUMINANCE16:
557 case 2:
558 case GL_LUMINANCE_ALPHA:
559 case GL_LUMINANCE4_ALPHA4:
560 case GL_LUMINANCE6_ALPHA2:
561 case GL_LUMINANCE8_ALPHA8:
562 case GL_LUMINANCE12_ALPHA4:
563 case GL_LUMINANCE12_ALPHA12:
564 case GL_LUMINANCE16_ALPHA16:
565 case GL_INTENSITY:
566 case GL_INTENSITY4:
567 case GL_INTENSITY8:
568 case GL_INTENSITY12:
569 case GL_INTENSITY16:
570 case 3:
571 case GL_RGB:
572 case GL_BGR:
573 case GL_R3_G3_B2:
574 case GL_RGB4:
575 case GL_RGB5:
576 case GL_RGB8:
577 case GL_RGB10:
578 case GL_RGB12:
579 case GL_RGB16:
580 case 4:
581 case GL_ABGR_EXT:
582 case GL_RGBA:
583 case GL_BGRA:
584 case GL_RGBA2:
585 case GL_RGBA4:
586 case GL_RGB5_A1:
587 case GL_RGBA8:
588 case GL_RGB10_A2:
589 case GL_RGBA12:
590 case GL_RGBA16:
591 /* float texture formats */
592 case GL_ALPHA16F_ARB:
593 case GL_ALPHA32F_ARB:
594 case GL_LUMINANCE16F_ARB:
595 case GL_LUMINANCE32F_ARB:
596 case GL_LUMINANCE_ALPHA16F_ARB:
597 case GL_LUMINANCE_ALPHA32F_ARB:
598 case GL_INTENSITY16F_ARB:
599 case GL_INTENSITY32F_ARB:
600 case GL_RGB16F_ARB:
601 case GL_RGB32F_ARB:
602 case GL_RGBA16F_ARB:
603 case GL_RGBA32F_ARB:
604 /* compressed formats */
605 case GL_COMPRESSED_ALPHA:
606 case GL_COMPRESSED_LUMINANCE:
607 case GL_COMPRESSED_LUMINANCE_ALPHA:
608 case GL_COMPRESSED_INTENSITY:
609 case GL_COMPRESSED_RGB:
610 case GL_COMPRESSED_RGBA:
611 case GL_RGB_S3TC:
612 case GL_RGB4_S3TC:
613 case GL_RGBA_S3TC:
614 case GL_RGBA4_S3TC:
615 case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
616 case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
617 case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
618 case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
619 case GL_COMPRESSED_RGB_FXT1_3DFX:
620 case GL_COMPRESSED_RGBA_FXT1_3DFX:
621 #if FEATURE_EXT_texture_sRGB
622 case GL_SRGB_EXT:
623 case GL_SRGB8_EXT:
624 case GL_SRGB_ALPHA_EXT:
625 case GL_SRGB8_ALPHA8_EXT:
626 case GL_SLUMINANCE_ALPHA_EXT:
627 case GL_SLUMINANCE8_ALPHA8_EXT:
628 case GL_SLUMINANCE_EXT:
629 case GL_SLUMINANCE8_EXT:
630 case GL_COMPRESSED_SRGB_EXT:
631 case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
632 case GL_COMPRESSED_SRGB_ALPHA_EXT:
633 case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
634 case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
635 case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
636 case GL_COMPRESSED_SLUMINANCE_EXT:
637 case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT:
638 #endif /* FEATURE_EXT_texture_sRGB */
639 return GL_TRUE;
640 /* signed texture formats */
641 case GL_RGBA_SNORM:
642 case GL_RGBA8_SNORM:
643 return GL_TRUE;
644 case GL_YCBCR_MESA: /* not considered to be RGB */
645 /* fall-through */
646 default:
647 return GL_FALSE;
648 }
649 }
650
651
652 /**
653 * Test if the given image format is a color index format.
654 */
655 GLboolean
656 _mesa_is_index_format(GLenum format)
657 {
658 switch (format) {
659 case GL_COLOR_INDEX:
660 case GL_COLOR_INDEX1_EXT:
661 case GL_COLOR_INDEX2_EXT:
662 case GL_COLOR_INDEX4_EXT:
663 case GL_COLOR_INDEX8_EXT:
664 case GL_COLOR_INDEX12_EXT:
665 case GL_COLOR_INDEX16_EXT:
666 return GL_TRUE;
667 default:
668 return GL_FALSE;
669 }
670 }
671
672
673 /**
674 * Test if the given image format is a depth component format.
675 */
676 GLboolean
677 _mesa_is_depth_format(GLenum format)
678 {
679 switch (format) {
680 case GL_DEPTH_COMPONENT:
681 case GL_DEPTH_COMPONENT16:
682 case GL_DEPTH_COMPONENT24:
683 case GL_DEPTH_COMPONENT32:
684 return GL_TRUE;
685 default:
686 return GL_FALSE;
687 }
688 }
689
690
691 /**
692 * Test if the given image format is a YCbCr format.
693 */
694 GLboolean
695 _mesa_is_ycbcr_format(GLenum format)
696 {
697 switch (format) {
698 case GL_YCBCR_MESA:
699 return GL_TRUE;
700 default:
701 return GL_FALSE;
702 }
703 }
704
705
706 /**
707 * Test if the given image format is a depth+stencil format.
708 */
709 GLboolean
710 _mesa_is_depthstencil_format(GLenum format)
711 {
712 switch (format) {
713 case GL_DEPTH24_STENCIL8_EXT:
714 case GL_DEPTH_STENCIL_EXT:
715 return GL_TRUE;
716 default:
717 return GL_FALSE;
718 }
719 }
720
721 /**
722 * Test if the given image format is a dudv format.
723 */
724 GLboolean
725 _mesa_is_dudv_format(GLenum format)
726 {
727 switch (format) {
728 case GL_DUDV_ATI:
729 case GL_DU8DV8_ATI:
730 return GL_TRUE;
731 default:
732 return GL_FALSE;
733 }
734 }
735
736
737 /**
738 * Return the address of a specific pixel in an image (1D, 2D or 3D).
739 *
740 * Pixel unpacking/packing parameters are observed according to \p packing.
741 *
742 * \param dimensions either 1, 2 or 3 to indicate dimensionality of image
743 * \param image starting address of image data
744 * \param width the image width
745 * \param height theimage height
746 * \param format the pixel format
747 * \param type the pixel data type
748 * \param packing the pixelstore attributes
749 * \param img which image in the volume (0 for 1D or 2D images)
750 * \param row row of pixel in the image (0 for 1D images)
751 * \param column column of pixel in the image
752 *
753 * \return address of pixel on success, or NULL on error.
754 *
755 * \sa gl_pixelstore_attrib.
756 */
757 GLvoid *
758 _mesa_image_address( GLuint dimensions,
759 const struct gl_pixelstore_attrib *packing,
760 const GLvoid *image,
761 GLsizei width, GLsizei height,
762 GLenum format, GLenum type,
763 GLint img, GLint row, GLint column )
764 {
765 GLint alignment; /* 1, 2 or 4 */
766 GLint pixels_per_row;
767 GLint rows_per_image;
768 GLint skiprows;
769 GLint skippixels;
770 GLint skipimages; /* for 3-D volume images */
771 GLubyte *pixel_addr;
772
773 ASSERT(dimensions >= 1 && dimensions <= 3);
774
775 alignment = packing->Alignment;
776 if (packing->RowLength > 0) {
777 pixels_per_row = packing->RowLength;
778 }
779 else {
780 pixels_per_row = width;
781 }
782 if (packing->ImageHeight > 0) {
783 rows_per_image = packing->ImageHeight;
784 }
785 else {
786 rows_per_image = height;
787 }
788
789 skippixels = packing->SkipPixels;
790 /* Note: SKIP_ROWS _is_ used for 1D images */
791 skiprows = packing->SkipRows;
792 /* Note: SKIP_IMAGES is only used for 3D images */
793 skipimages = (dimensions == 3) ? packing->SkipImages : 0;
794
795 if (type == GL_BITMAP) {
796 /* BITMAP data */
797 GLint comp_per_pixel; /* components per pixel */
798 GLint bytes_per_comp; /* bytes per component */
799 GLint bytes_per_row;
800 GLint bytes_per_image;
801
802 /* Compute bytes per component */
803 bytes_per_comp = _mesa_sizeof_packed_type( type );
804 if (bytes_per_comp < 0) {
805 return NULL;
806 }
807
808 /* Compute number of components per pixel */
809 comp_per_pixel = _mesa_components_in_format( format );
810 if (comp_per_pixel < 0) {
811 return NULL;
812 }
813
814 bytes_per_row = alignment
815 * CEILING( comp_per_pixel*pixels_per_row, 8*alignment );
816
817 bytes_per_image = bytes_per_row * rows_per_image;
818
819 pixel_addr = (GLubyte *) image
820 + (skipimages + img) * bytes_per_image
821 + (skiprows + row) * bytes_per_row
822 + (skippixels + column) / 8;
823 }
824 else {
825 /* Non-BITMAP data */
826 GLint bytes_per_pixel, bytes_per_row, remainder, bytes_per_image;
827 GLint topOfImage;
828
829 bytes_per_pixel = _mesa_bytes_per_pixel( format, type );
830
831 /* The pixel type and format should have been error checked earlier */
832 assert(bytes_per_pixel > 0);
833
834 bytes_per_row = pixels_per_row * bytes_per_pixel;
835 remainder = bytes_per_row % alignment;
836 if (remainder > 0)
837 bytes_per_row += (alignment - remainder);
838
839 ASSERT(bytes_per_row % alignment == 0);
840
841 bytes_per_image = bytes_per_row * rows_per_image;
842
843 if (packing->Invert) {
844 /* set pixel_addr to the last row */
845 topOfImage = bytes_per_row * (height - 1);
846 bytes_per_row = -bytes_per_row;
847 }
848 else {
849 topOfImage = 0;
850 }
851
852 /* compute final pixel address */
853 pixel_addr = (GLubyte *) image
854 + (skipimages + img) * bytes_per_image
855 + topOfImage
856 + (skiprows + row) * bytes_per_row
857 + (skippixels + column) * bytes_per_pixel;
858 }
859
860 return (GLvoid *) pixel_addr;
861 }
862
863
864 GLvoid *
865 _mesa_image_address1d( const struct gl_pixelstore_attrib *packing,
866 const GLvoid *image,
867 GLsizei width,
868 GLenum format, GLenum type,
869 GLint column )
870 {
871 return _mesa_image_address(1, packing, image, width, 1,
872 format, type, 0, 0, column);
873 }
874
875
876 GLvoid *
877 _mesa_image_address2d( const struct gl_pixelstore_attrib *packing,
878 const GLvoid *image,
879 GLsizei width, GLsizei height,
880 GLenum format, GLenum type,
881 GLint row, GLint column )
882 {
883 return _mesa_image_address(2, packing, image, width, height,
884 format, type, 0, row, column);
885 }
886
887
888 GLvoid *
889 _mesa_image_address3d( const struct gl_pixelstore_attrib *packing,
890 const GLvoid *image,
891 GLsizei width, GLsizei height,
892 GLenum format, GLenum type,
893 GLint img, GLint row, GLint column )
894 {
895 return _mesa_image_address(3, packing, image, width, height,
896 format, type, img, row, column);
897 }
898
899
900
901 /**
902 * Compute the stride (in bytes) between image rows.
903 *
904 * \param packing the pixelstore attributes
905 * \param width image width.
906 * \param format pixel format.
907 * \param type pixel data type.
908 *
909 * \return the stride in bytes for the given parameters, or -1 if error
910 */
911 GLint
912 _mesa_image_row_stride( const struct gl_pixelstore_attrib *packing,
913 GLint width, GLenum format, GLenum type )
914 {
915 GLint bytesPerRow, remainder;
916
917 ASSERT(packing);
918
919 if (type == GL_BITMAP) {
920 if (packing->RowLength == 0) {
921 bytesPerRow = (width + 7) / 8;
922 }
923 else {
924 bytesPerRow = (packing->RowLength + 7) / 8;
925 }
926 }
927 else {
928 /* Non-BITMAP data */
929 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
930 if (bytesPerPixel <= 0)
931 return -1; /* error */
932 if (packing->RowLength == 0) {
933 bytesPerRow = bytesPerPixel * width;
934 }
935 else {
936 bytesPerRow = bytesPerPixel * packing->RowLength;
937 }
938 }
939
940 remainder = bytesPerRow % packing->Alignment;
941 if (remainder > 0) {
942 bytesPerRow += (packing->Alignment - remainder);
943 }
944
945 if (packing->Invert) {
946 /* negate the bytes per row (negative row stride) */
947 bytesPerRow = -bytesPerRow;
948 }
949
950 return bytesPerRow;
951 }
952
953
954 #if _HAVE_FULL_GL
955
956 /*
957 * Compute the stride between images in a 3D texture (in bytes) for the given
958 * pixel packing parameters and image width, format and type.
959 */
960 GLint
961 _mesa_image_image_stride( const struct gl_pixelstore_attrib *packing,
962 GLint width, GLint height,
963 GLenum format, GLenum type )
964 {
965 GLint bytesPerRow, bytesPerImage, remainder;
966
967 ASSERT(packing);
968
969 if (type == GL_BITMAP) {
970 if (packing->RowLength == 0) {
971 bytesPerRow = (width + 7) / 8;
972 }
973 else {
974 bytesPerRow = (packing->RowLength + 7) / 8;
975 }
976 }
977 else {
978 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
979
980 if (bytesPerPixel <= 0)
981 return -1; /* error */
982 if (packing->RowLength == 0) {
983 bytesPerRow = bytesPerPixel * width;
984 }
985 else {
986 bytesPerRow = bytesPerPixel * packing->RowLength;
987 }
988 }
989
990 remainder = bytesPerRow % packing->Alignment;
991 if (remainder > 0)
992 bytesPerRow += (packing->Alignment - remainder);
993
994 if (packing->ImageHeight == 0)
995 bytesPerImage = bytesPerRow * height;
996 else
997 bytesPerImage = bytesPerRow * packing->ImageHeight;
998
999 return bytesPerImage;
1000 }
1001
1002
1003 /*
1004 * Unpack a 32x32 pixel polygon stipple from user memory using the
1005 * current pixel unpack settings.
1006 */
1007 void
1008 _mesa_unpack_polygon_stipple( const GLubyte *pattern, GLuint dest[32],
1009 const struct gl_pixelstore_attrib *unpacking )
1010 {
1011 GLubyte *ptrn = (GLubyte *) _mesa_unpack_bitmap(32, 32, pattern, unpacking);
1012 if (ptrn) {
1013 /* Convert pattern from GLubytes to GLuints and handle big/little
1014 * endian differences
1015 */
1016 GLubyte *p = ptrn;
1017 GLint i;
1018 for (i = 0; i < 32; i++) {
1019 dest[i] = (p[0] << 24)
1020 | (p[1] << 16)
1021 | (p[2] << 8)
1022 | (p[3] );
1023 p += 4;
1024 }
1025 _mesa_free(ptrn);
1026 }
1027 }
1028
1029
1030 /*
1031 * Pack polygon stipple into user memory given current pixel packing
1032 * settings.
1033 */
1034 void
1035 _mesa_pack_polygon_stipple( const GLuint pattern[32], GLubyte *dest,
1036 const struct gl_pixelstore_attrib *packing )
1037 {
1038 /* Convert pattern from GLuints to GLubytes to handle big/little
1039 * endian differences.
1040 */
1041 GLubyte ptrn[32*4];
1042 GLint i;
1043 for (i = 0; i < 32; i++) {
1044 ptrn[i * 4 + 0] = (GLubyte) ((pattern[i] >> 24) & 0xff);
1045 ptrn[i * 4 + 1] = (GLubyte) ((pattern[i] >> 16) & 0xff);
1046 ptrn[i * 4 + 2] = (GLubyte) ((pattern[i] >> 8 ) & 0xff);
1047 ptrn[i * 4 + 3] = (GLubyte) ((pattern[i] ) & 0xff);
1048 }
1049
1050 _mesa_pack_bitmap(32, 32, ptrn, dest, packing);
1051 }
1052
1053
1054 /*
1055 * Unpack bitmap data. Resulting data will be in most-significant-bit-first
1056 * order with row alignment = 1 byte.
1057 */
1058 GLvoid *
1059 _mesa_unpack_bitmap( GLint width, GLint height, const GLubyte *pixels,
1060 const struct gl_pixelstore_attrib *packing )
1061 {
1062 GLint bytes, row, width_in_bytes;
1063 GLubyte *buffer, *dst;
1064
1065 if (!pixels)
1066 return NULL;
1067
1068 /* Alloc dest storage */
1069 bytes = ((width + 7) / 8 * height);
1070 buffer = (GLubyte *) _mesa_malloc( bytes );
1071 if (!buffer)
1072 return NULL;
1073
1074 width_in_bytes = CEILING( width, 8 );
1075 dst = buffer;
1076 for (row = 0; row < height; row++) {
1077 const GLubyte *src = (const GLubyte *)
1078 _mesa_image_address2d(packing, pixels, width, height,
1079 GL_COLOR_INDEX, GL_BITMAP, row, 0);
1080 if (!src) {
1081 _mesa_free(buffer);
1082 return NULL;
1083 }
1084
1085 if ((packing->SkipPixels & 7) == 0) {
1086 _mesa_memcpy( dst, src, width_in_bytes );
1087 if (packing->LsbFirst) {
1088 flip_bytes( dst, width_in_bytes );
1089 }
1090 }
1091 else {
1092 /* handling SkipPixels is a bit tricky (no pun intended!) */
1093 GLint i;
1094 if (packing->LsbFirst) {
1095 GLubyte srcMask = 1 << (packing->SkipPixels & 0x7);
1096 GLubyte dstMask = 128;
1097 const GLubyte *s = src;
1098 GLubyte *d = dst;
1099 *d = 0;
1100 for (i = 0; i < width; i++) {
1101 if (*s & srcMask) {
1102 *d |= dstMask;
1103 }
1104 if (srcMask == 128) {
1105 srcMask = 1;
1106 s++;
1107 }
1108 else {
1109 srcMask = srcMask << 1;
1110 }
1111 if (dstMask == 1) {
1112 dstMask = 128;
1113 d++;
1114 *d = 0;
1115 }
1116 else {
1117 dstMask = dstMask >> 1;
1118 }
1119 }
1120 }
1121 else {
1122 GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7);
1123 GLubyte dstMask = 128;
1124 const GLubyte *s = src;
1125 GLubyte *d = dst;
1126 *d = 0;
1127 for (i = 0; i < width; i++) {
1128 if (*s & srcMask) {
1129 *d |= dstMask;
1130 }
1131 if (srcMask == 1) {
1132 srcMask = 128;
1133 s++;
1134 }
1135 else {
1136 srcMask = srcMask >> 1;
1137 }
1138 if (dstMask == 1) {
1139 dstMask = 128;
1140 d++;
1141 *d = 0;
1142 }
1143 else {
1144 dstMask = dstMask >> 1;
1145 }
1146 }
1147 }
1148 }
1149 dst += width_in_bytes;
1150 }
1151
1152 return buffer;
1153 }
1154
1155
1156 /*
1157 * Pack bitmap data.
1158 */
1159 void
1160 _mesa_pack_bitmap( GLint width, GLint height, const GLubyte *source,
1161 GLubyte *dest, const struct gl_pixelstore_attrib *packing )
1162 {
1163 GLint row, width_in_bytes;
1164 const GLubyte *src;
1165
1166 if (!source)
1167 return;
1168
1169 width_in_bytes = CEILING( width, 8 );
1170 src = source;
1171 for (row = 0; row < height; row++) {
1172 GLubyte *dst = (GLubyte *) _mesa_image_address2d(packing, dest,
1173 width, height, GL_COLOR_INDEX, GL_BITMAP, row, 0);
1174 if (!dst)
1175 return;
1176
1177 if ((packing->SkipPixels & 7) == 0) {
1178 _mesa_memcpy( dst, src, width_in_bytes );
1179 if (packing->LsbFirst) {
1180 flip_bytes( dst, width_in_bytes );
1181 }
1182 }
1183 else {
1184 /* handling SkipPixels is a bit tricky (no pun intended!) */
1185 GLint i;
1186 if (packing->LsbFirst) {
1187 GLubyte srcMask = 128;
1188 GLubyte dstMask = 1 << (packing->SkipPixels & 0x7);
1189 const GLubyte *s = src;
1190 GLubyte *d = dst;
1191 *d = 0;
1192 for (i = 0; i < width; i++) {
1193 if (*s & srcMask) {
1194 *d |= dstMask;
1195 }
1196 if (srcMask == 1) {
1197 srcMask = 128;
1198 s++;
1199 }
1200 else {
1201 srcMask = srcMask >> 1;
1202 }
1203 if (dstMask == 128) {
1204 dstMask = 1;
1205 d++;
1206 *d = 0;
1207 }
1208 else {
1209 dstMask = dstMask << 1;
1210 }
1211 }
1212 }
1213 else {
1214 GLubyte srcMask = 128;
1215 GLubyte dstMask = 128 >> (packing->SkipPixels & 0x7);
1216 const GLubyte *s = src;
1217 GLubyte *d = dst;
1218 *d = 0;
1219 for (i = 0; i < width; i++) {
1220 if (*s & srcMask) {
1221 *d |= dstMask;
1222 }
1223 if (srcMask == 1) {
1224 srcMask = 128;
1225 s++;
1226 }
1227 else {
1228 srcMask = srcMask >> 1;
1229 }
1230 if (dstMask == 1) {
1231 dstMask = 128;
1232 d++;
1233 *d = 0;
1234 }
1235 else {
1236 dstMask = dstMask >> 1;
1237 }
1238 }
1239 }
1240 }
1241 src += width_in_bytes;
1242 }
1243 }
1244
1245
1246 /**********************************************************************/
1247 /***** Pixel processing functions ******/
1248 /**********************************************************************/
1249
1250 /*
1251 * Apply scale and bias factors to an array of RGBA pixels.
1252 */
1253 void
1254 _mesa_scale_and_bias_rgba(GLuint n, GLfloat rgba[][4],
1255 GLfloat rScale, GLfloat gScale,
1256 GLfloat bScale, GLfloat aScale,
1257 GLfloat rBias, GLfloat gBias,
1258 GLfloat bBias, GLfloat aBias)
1259 {
1260 if (rScale != 1.0 || rBias != 0.0) {
1261 GLuint i;
1262 for (i = 0; i < n; i++) {
1263 rgba[i][RCOMP] = rgba[i][RCOMP] * rScale + rBias;
1264 }
1265 }
1266 if (gScale != 1.0 || gBias != 0.0) {
1267 GLuint i;
1268 for (i = 0; i < n; i++) {
1269 rgba[i][GCOMP] = rgba[i][GCOMP] * gScale + gBias;
1270 }
1271 }
1272 if (bScale != 1.0 || bBias != 0.0) {
1273 GLuint i;
1274 for (i = 0; i < n; i++) {
1275 rgba[i][BCOMP] = rgba[i][BCOMP] * bScale + bBias;
1276 }
1277 }
1278 if (aScale != 1.0 || aBias != 0.0) {
1279 GLuint i;
1280 for (i = 0; i < n; i++) {
1281 rgba[i][ACOMP] = rgba[i][ACOMP] * aScale + aBias;
1282 }
1283 }
1284 }
1285
1286
1287 /*
1288 * Apply pixel mapping to an array of floating point RGBA pixels.
1289 */
1290 void
1291 _mesa_map_rgba( const GLcontext *ctx, GLuint n, GLfloat rgba[][4] )
1292 {
1293 const GLfloat rscale = (GLfloat) (ctx->PixelMaps.RtoR.Size - 1);
1294 const GLfloat gscale = (GLfloat) (ctx->PixelMaps.GtoG.Size - 1);
1295 const GLfloat bscale = (GLfloat) (ctx->PixelMaps.BtoB.Size - 1);
1296 const GLfloat ascale = (GLfloat) (ctx->PixelMaps.AtoA.Size - 1);
1297 const GLfloat *rMap = ctx->PixelMaps.RtoR.Map;
1298 const GLfloat *gMap = ctx->PixelMaps.GtoG.Map;
1299 const GLfloat *bMap = ctx->PixelMaps.BtoB.Map;
1300 const GLfloat *aMap = ctx->PixelMaps.AtoA.Map;
1301 GLuint i;
1302 for (i=0;i<n;i++) {
1303 GLfloat r = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F);
1304 GLfloat g = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F);
1305 GLfloat b = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F);
1306 GLfloat a = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F);
1307 rgba[i][RCOMP] = rMap[IROUND(r * rscale)];
1308 rgba[i][GCOMP] = gMap[IROUND(g * gscale)];
1309 rgba[i][BCOMP] = bMap[IROUND(b * bscale)];
1310 rgba[i][ACOMP] = aMap[IROUND(a * ascale)];
1311 }
1312 }
1313
1314
1315 /*
1316 * Apply the color matrix and post color matrix scaling and biasing.
1317 */
1318 void
1319 _mesa_transform_rgba(const GLcontext *ctx, GLuint n, GLfloat rgba[][4])
1320 {
1321 const GLfloat rs = ctx->Pixel.PostColorMatrixScale[0];
1322 const GLfloat rb = ctx->Pixel.PostColorMatrixBias[0];
1323 const GLfloat gs = ctx->Pixel.PostColorMatrixScale[1];
1324 const GLfloat gb = ctx->Pixel.PostColorMatrixBias[1];
1325 const GLfloat bs = ctx->Pixel.PostColorMatrixScale[2];
1326 const GLfloat bb = ctx->Pixel.PostColorMatrixBias[2];
1327 const GLfloat as = ctx->Pixel.PostColorMatrixScale[3];
1328 const GLfloat ab = ctx->Pixel.PostColorMatrixBias[3];
1329 const GLfloat *m = ctx->ColorMatrixStack.Top->m;
1330 GLuint i;
1331 for (i = 0; i < n; i++) {
1332 const GLfloat r = rgba[i][RCOMP];
1333 const GLfloat g = rgba[i][GCOMP];
1334 const GLfloat b = rgba[i][BCOMP];
1335 const GLfloat a = rgba[i][ACOMP];
1336 rgba[i][RCOMP] = (m[0] * r + m[4] * g + m[ 8] * b + m[12] * a) * rs + rb;
1337 rgba[i][GCOMP] = (m[1] * r + m[5] * g + m[ 9] * b + m[13] * a) * gs + gb;
1338 rgba[i][BCOMP] = (m[2] * r + m[6] * g + m[10] * b + m[14] * a) * bs + bb;
1339 rgba[i][ACOMP] = (m[3] * r + m[7] * g + m[11] * b + m[15] * a) * as + ab;
1340 }
1341 }
1342
1343
1344 /**
1345 * Apply a color table lookup to an array of floating point RGBA colors.
1346 */
1347 void
1348 _mesa_lookup_rgba_float(const struct gl_color_table *table,
1349 GLuint n, GLfloat rgba[][4])
1350 {
1351 const GLint max = table->Size - 1;
1352 const GLfloat scale = (GLfloat) max;
1353 const GLfloat *lut = table->TableF;
1354 GLuint i;
1355
1356 if (!table->TableF || table->Size == 0)
1357 return;
1358
1359 switch (table->_BaseFormat) {
1360 case GL_INTENSITY:
1361 /* replace RGBA with I */
1362 for (i = 0; i < n; i++) {
1363 GLint j = IROUND(rgba[i][RCOMP] * scale);
1364 GLfloat c = lut[CLAMP(j, 0, max)];
1365 rgba[i][RCOMP] =
1366 rgba[i][GCOMP] =
1367 rgba[i][BCOMP] =
1368 rgba[i][ACOMP] = c;
1369 }
1370 break;
1371 case GL_LUMINANCE:
1372 /* replace RGB with L */
1373 for (i = 0; i < n; i++) {
1374 GLint j = IROUND(rgba[i][RCOMP] * scale);
1375 GLfloat c = lut[CLAMP(j, 0, max)];
1376 rgba[i][RCOMP] =
1377 rgba[i][GCOMP] =
1378 rgba[i][BCOMP] = c;
1379 }
1380 break;
1381 case GL_ALPHA:
1382 /* replace A with A */
1383 for (i = 0; i < n; i++) {
1384 GLint j = IROUND(rgba[i][ACOMP] * scale);
1385 rgba[i][ACOMP] = lut[CLAMP(j, 0, max)];
1386 }
1387 break;
1388 case GL_LUMINANCE_ALPHA:
1389 /* replace RGBA with LLLA */
1390 for (i = 0; i < n; i++) {
1391 GLint jL = IROUND(rgba[i][RCOMP] * scale);
1392 GLint jA = IROUND(rgba[i][ACOMP] * scale);
1393 GLfloat luminance, alpha;
1394 jL = CLAMP(jL, 0, max);
1395 jA = CLAMP(jA, 0, max);
1396 luminance = lut[jL * 2 + 0];
1397 alpha = lut[jA * 2 + 1];
1398 rgba[i][RCOMP] =
1399 rgba[i][GCOMP] =
1400 rgba[i][BCOMP] = luminance;
1401 rgba[i][ACOMP] = alpha;;
1402 }
1403 break;
1404 case GL_RGB:
1405 /* replace RGB with RGB */
1406 for (i = 0; i < n; i++) {
1407 GLint jR = IROUND(rgba[i][RCOMP] * scale);
1408 GLint jG = IROUND(rgba[i][GCOMP] * scale);
1409 GLint jB = IROUND(rgba[i][BCOMP] * scale);
1410 jR = CLAMP(jR, 0, max);
1411 jG = CLAMP(jG, 0, max);
1412 jB = CLAMP(jB, 0, max);
1413 rgba[i][RCOMP] = lut[jR * 3 + 0];
1414 rgba[i][GCOMP] = lut[jG * 3 + 1];
1415 rgba[i][BCOMP] = lut[jB * 3 + 2];
1416 }
1417 break;
1418 case GL_RGBA:
1419 /* replace RGBA with RGBA */
1420 for (i = 0; i < n; i++) {
1421 GLint jR = IROUND(rgba[i][RCOMP] * scale);
1422 GLint jG = IROUND(rgba[i][GCOMP] * scale);
1423 GLint jB = IROUND(rgba[i][BCOMP] * scale);
1424 GLint jA = IROUND(rgba[i][ACOMP] * scale);
1425 jR = CLAMP(jR, 0, max);
1426 jG = CLAMP(jG, 0, max);
1427 jB = CLAMP(jB, 0, max);
1428 jA = CLAMP(jA, 0, max);
1429 rgba[i][RCOMP] = lut[jR * 4 + 0];
1430 rgba[i][GCOMP] = lut[jG * 4 + 1];
1431 rgba[i][BCOMP] = lut[jB * 4 + 2];
1432 rgba[i][ACOMP] = lut[jA * 4 + 3];
1433 }
1434 break;
1435 default:
1436 _mesa_problem(NULL, "Bad format in _mesa_lookup_rgba_float");
1437 return;
1438 }
1439 }
1440
1441
1442
1443 /**
1444 * Apply a color table lookup to an array of ubyte/RGBA colors.
1445 */
1446 void
1447 _mesa_lookup_rgba_ubyte(const struct gl_color_table *table,
1448 GLuint n, GLubyte rgba[][4])
1449 {
1450 const GLubyte *lut = table->TableUB;
1451 const GLfloat scale = (GLfloat) (table->Size - 1) / (GLfloat)255.0;
1452 GLuint i;
1453
1454 if (!table->TableUB || table->Size == 0)
1455 return;
1456
1457 switch (table->_BaseFormat) {
1458 case GL_INTENSITY:
1459 /* replace RGBA with I */
1460 if (table->Size == 256) {
1461 for (i = 0; i < n; i++) {
1462 const GLubyte c = lut[rgba[i][RCOMP]];
1463 rgba[i][RCOMP] =
1464 rgba[i][GCOMP] =
1465 rgba[i][BCOMP] =
1466 rgba[i][ACOMP] = c;
1467 }
1468 }
1469 else {
1470 for (i = 0; i < n; i++) {
1471 GLint j = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1472 rgba[i][RCOMP] =
1473 rgba[i][GCOMP] =
1474 rgba[i][BCOMP] =
1475 rgba[i][ACOMP] = lut[j];
1476 }
1477 }
1478 break;
1479 case GL_LUMINANCE:
1480 /* replace RGB with L */
1481 if (table->Size == 256) {
1482 for (i = 0; i < n; i++) {
1483 const GLubyte c = lut[rgba[i][RCOMP]];
1484 rgba[i][RCOMP] =
1485 rgba[i][GCOMP] =
1486 rgba[i][BCOMP] = c;
1487 }
1488 }
1489 else {
1490 for (i = 0; i < n; i++) {
1491 GLint j = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1492 rgba[i][RCOMP] =
1493 rgba[i][GCOMP] =
1494 rgba[i][BCOMP] = lut[j];
1495 }
1496 }
1497 break;
1498 case GL_ALPHA:
1499 /* replace A with A */
1500 if (table->Size == 256) {
1501 for (i = 0; i < n; i++) {
1502 rgba[i][ACOMP] = lut[rgba[i][ACOMP]];
1503 }
1504 }
1505 else {
1506 for (i = 0; i < n; i++) {
1507 GLint j = IROUND((GLfloat) rgba[i][ACOMP] * scale);
1508 rgba[i][ACOMP] = lut[j];
1509 }
1510 }
1511 break;
1512 case GL_LUMINANCE_ALPHA:
1513 /* replace RGBA with LLLA */
1514 if (table->Size == 256) {
1515 for (i = 0; i < n; i++) {
1516 GLubyte l = lut[rgba[i][RCOMP] * 2 + 0];
1517 GLubyte a = lut[rgba[i][ACOMP] * 2 + 1];;
1518 rgba[i][RCOMP] =
1519 rgba[i][GCOMP] =
1520 rgba[i][BCOMP] = l;
1521 rgba[i][ACOMP] = a;
1522 }
1523 }
1524 else {
1525 for (i = 0; i < n; i++) {
1526 GLint jL = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1527 GLint jA = IROUND((GLfloat) rgba[i][ACOMP] * scale);
1528 GLubyte luminance = lut[jL * 2 + 0];
1529 GLubyte alpha = lut[jA * 2 + 1];
1530 rgba[i][RCOMP] =
1531 rgba[i][GCOMP] =
1532 rgba[i][BCOMP] = luminance;
1533 rgba[i][ACOMP] = alpha;
1534 }
1535 }
1536 break;
1537 case GL_RGB:
1538 if (table->Size == 256) {
1539 for (i = 0; i < n; i++) {
1540 rgba[i][RCOMP] = lut[rgba[i][RCOMP] * 3 + 0];
1541 rgba[i][GCOMP] = lut[rgba[i][GCOMP] * 3 + 1];
1542 rgba[i][BCOMP] = lut[rgba[i][BCOMP] * 3 + 2];
1543 }
1544 }
1545 else {
1546 for (i = 0; i < n; i++) {
1547 GLint jR = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1548 GLint jG = IROUND((GLfloat) rgba[i][GCOMP] * scale);
1549 GLint jB = IROUND((GLfloat) rgba[i][BCOMP] * scale);
1550 rgba[i][RCOMP] = lut[jR * 3 + 0];
1551 rgba[i][GCOMP] = lut[jG * 3 + 1];
1552 rgba[i][BCOMP] = lut[jB * 3 + 2];
1553 }
1554 }
1555 break;
1556 case GL_RGBA:
1557 if (table->Size == 256) {
1558 for (i = 0; i < n; i++) {
1559 rgba[i][RCOMP] = lut[rgba[i][RCOMP] * 4 + 0];
1560 rgba[i][GCOMP] = lut[rgba[i][GCOMP] * 4 + 1];
1561 rgba[i][BCOMP] = lut[rgba[i][BCOMP] * 4 + 2];
1562 rgba[i][ACOMP] = lut[rgba[i][ACOMP] * 4 + 3];
1563 }
1564 }
1565 else {
1566 for (i = 0; i < n; i++) {
1567 GLint jR = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1568 GLint jG = IROUND((GLfloat) rgba[i][GCOMP] * scale);
1569 GLint jB = IROUND((GLfloat) rgba[i][BCOMP] * scale);
1570 GLint jA = IROUND((GLfloat) rgba[i][ACOMP] * scale);
1571 CLAMPED_FLOAT_TO_CHAN(rgba[i][RCOMP], lut[jR * 4 + 0]);
1572 CLAMPED_FLOAT_TO_CHAN(rgba[i][GCOMP], lut[jG * 4 + 1]);
1573 CLAMPED_FLOAT_TO_CHAN(rgba[i][BCOMP], lut[jB * 4 + 2]);
1574 CLAMPED_FLOAT_TO_CHAN(rgba[i][ACOMP], lut[jA * 4 + 3]);
1575 }
1576 }
1577 break;
1578 default:
1579 _mesa_problem(NULL, "Bad format in _mesa_lookup_rgba_chan");
1580 return;
1581 }
1582 }
1583
1584
1585
1586 /*
1587 * Map color indexes to float rgba values.
1588 */
1589 void
1590 _mesa_map_ci_to_rgba( const GLcontext *ctx, GLuint n,
1591 const GLuint index[], GLfloat rgba[][4] )
1592 {
1593 GLuint rmask = ctx->PixelMaps.ItoR.Size - 1;
1594 GLuint gmask = ctx->PixelMaps.ItoG.Size - 1;
1595 GLuint bmask = ctx->PixelMaps.ItoB.Size - 1;
1596 GLuint amask = ctx->PixelMaps.ItoA.Size - 1;
1597 const GLfloat *rMap = ctx->PixelMaps.ItoR.Map;
1598 const GLfloat *gMap = ctx->PixelMaps.ItoG.Map;
1599 const GLfloat *bMap = ctx->PixelMaps.ItoB.Map;
1600 const GLfloat *aMap = ctx->PixelMaps.ItoA.Map;
1601 GLuint i;
1602 for (i=0;i<n;i++) {
1603 rgba[i][RCOMP] = rMap[index[i] & rmask];
1604 rgba[i][GCOMP] = gMap[index[i] & gmask];
1605 rgba[i][BCOMP] = bMap[index[i] & bmask];
1606 rgba[i][ACOMP] = aMap[index[i] & amask];
1607 }
1608 }
1609
1610
1611 /**
1612 * Map ubyte color indexes to ubyte/RGBA values.
1613 */
1614 void
1615 _mesa_map_ci8_to_rgba8(const GLcontext *ctx, GLuint n, const GLubyte index[],
1616 GLubyte rgba[][4])
1617 {
1618 GLuint rmask = ctx->PixelMaps.ItoR.Size - 1;
1619 GLuint gmask = ctx->PixelMaps.ItoG.Size - 1;
1620 GLuint bmask = ctx->PixelMaps.ItoB.Size - 1;
1621 GLuint amask = ctx->PixelMaps.ItoA.Size - 1;
1622 const GLubyte *rMap = ctx->PixelMaps.ItoR.Map8;
1623 const GLubyte *gMap = ctx->PixelMaps.ItoG.Map8;
1624 const GLubyte *bMap = ctx->PixelMaps.ItoB.Map8;
1625 const GLubyte *aMap = ctx->PixelMaps.ItoA.Map8;
1626 GLuint i;
1627 for (i=0;i<n;i++) {
1628 rgba[i][RCOMP] = rMap[index[i] & rmask];
1629 rgba[i][GCOMP] = gMap[index[i] & gmask];
1630 rgba[i][BCOMP] = bMap[index[i] & bmask];
1631 rgba[i][ACOMP] = aMap[index[i] & amask];
1632 }
1633 }
1634
1635
1636 void
1637 _mesa_scale_and_bias_depth(const GLcontext *ctx, GLuint n,
1638 GLfloat depthValues[])
1639 {
1640 const GLfloat scale = ctx->Pixel.DepthScale;
1641 const GLfloat bias = ctx->Pixel.DepthBias;
1642 GLuint i;
1643 for (i = 0; i < n; i++) {
1644 GLfloat d = depthValues[i] * scale + bias;
1645 depthValues[i] = CLAMP(d, 0.0F, 1.0F);
1646 }
1647 }
1648
1649
1650 void
1651 _mesa_scale_and_bias_depth_uint(const GLcontext *ctx, GLuint n,
1652 GLuint depthValues[])
1653 {
1654 const GLdouble max = (double) 0xffffffff;
1655 const GLdouble scale = ctx->Pixel.DepthScale;
1656 const GLdouble bias = ctx->Pixel.DepthBias * max;
1657 GLuint i;
1658 for (i = 0; i < n; i++) {
1659 GLdouble d = (GLdouble) depthValues[i] * scale + bias;
1660 d = CLAMP(d, 0.0, max);
1661 depthValues[i] = (GLuint) d;
1662 }
1663 }
1664
1665
1666
1667 /*
1668 * Update the min/max values from an array of fragment colors.
1669 */
1670 static void
1671 update_minmax(GLcontext *ctx, GLuint n, const GLfloat rgba[][4])
1672 {
1673 GLuint i;
1674 for (i = 0; i < n; i++) {
1675 /* update mins */
1676 if (rgba[i][RCOMP] < ctx->MinMax.Min[RCOMP])
1677 ctx->MinMax.Min[RCOMP] = rgba[i][RCOMP];
1678 if (rgba[i][GCOMP] < ctx->MinMax.Min[GCOMP])
1679 ctx->MinMax.Min[GCOMP] = rgba[i][GCOMP];
1680 if (rgba[i][BCOMP] < ctx->MinMax.Min[BCOMP])
1681 ctx->MinMax.Min[BCOMP] = rgba[i][BCOMP];
1682 if (rgba[i][ACOMP] < ctx->MinMax.Min[ACOMP])
1683 ctx->MinMax.Min[ACOMP] = rgba[i][ACOMP];
1684
1685 /* update maxs */
1686 if (rgba[i][RCOMP] > ctx->MinMax.Max[RCOMP])
1687 ctx->MinMax.Max[RCOMP] = rgba[i][RCOMP];
1688 if (rgba[i][GCOMP] > ctx->MinMax.Max[GCOMP])
1689 ctx->MinMax.Max[GCOMP] = rgba[i][GCOMP];
1690 if (rgba[i][BCOMP] > ctx->MinMax.Max[BCOMP])
1691 ctx->MinMax.Max[BCOMP] = rgba[i][BCOMP];
1692 if (rgba[i][ACOMP] > ctx->MinMax.Max[ACOMP])
1693 ctx->MinMax.Max[ACOMP] = rgba[i][ACOMP];
1694 }
1695 }
1696
1697
1698 /*
1699 * Update the histogram values from an array of fragment colors.
1700 */
1701 static void
1702 update_histogram(GLcontext *ctx, GLuint n, const GLfloat rgba[][4])
1703 {
1704 const GLint max = ctx->Histogram.Width - 1;
1705 GLfloat w = (GLfloat) max;
1706 GLuint i;
1707
1708 if (ctx->Histogram.Width == 0)
1709 return;
1710
1711 for (i = 0; i < n; i++) {
1712 GLint ri = IROUND(rgba[i][RCOMP] * w);
1713 GLint gi = IROUND(rgba[i][GCOMP] * w);
1714 GLint bi = IROUND(rgba[i][BCOMP] * w);
1715 GLint ai = IROUND(rgba[i][ACOMP] * w);
1716 ri = CLAMP(ri, 0, max);
1717 gi = CLAMP(gi, 0, max);
1718 bi = CLAMP(bi, 0, max);
1719 ai = CLAMP(ai, 0, max);
1720 ctx->Histogram.Count[ri][RCOMP]++;
1721 ctx->Histogram.Count[gi][GCOMP]++;
1722 ctx->Histogram.Count[bi][BCOMP]++;
1723 ctx->Histogram.Count[ai][ACOMP]++;
1724 }
1725 }
1726
1727
1728 /**
1729 * Apply various pixel transfer operations to an array of RGBA pixels
1730 * as indicated by the transferOps bitmask
1731 */
1732 void
1733 _mesa_apply_rgba_transfer_ops(GLcontext *ctx, GLbitfield transferOps,
1734 GLuint n, GLfloat rgba[][4])
1735 {
1736 /* scale & bias */
1737 if (transferOps & IMAGE_SCALE_BIAS_BIT) {
1738 _mesa_scale_and_bias_rgba(n, rgba,
1739 ctx->Pixel.RedScale, ctx->Pixel.GreenScale,
1740 ctx->Pixel.BlueScale, ctx->Pixel.AlphaScale,
1741 ctx->Pixel.RedBias, ctx->Pixel.GreenBias,
1742 ctx->Pixel.BlueBias, ctx->Pixel.AlphaBias);
1743 }
1744 /* color map lookup */
1745 if (transferOps & IMAGE_MAP_COLOR_BIT) {
1746 _mesa_map_rgba( ctx, n, rgba );
1747 }
1748 /* GL_COLOR_TABLE lookup */
1749 if (transferOps & IMAGE_COLOR_TABLE_BIT) {
1750 _mesa_lookup_rgba_float(&ctx->ColorTable[COLORTABLE_PRECONVOLUTION], n, rgba);
1751 }
1752 /* convolution */
1753 if (transferOps & IMAGE_CONVOLUTION_BIT) {
1754 /* this has to be done in the calling code */
1755 _mesa_problem(ctx, "IMAGE_CONVOLUTION_BIT set in _mesa_apply_transfer_ops");
1756 }
1757 /* GL_POST_CONVOLUTION_RED/GREEN/BLUE/ALPHA_SCALE/BIAS */
1758 if (transferOps & IMAGE_POST_CONVOLUTION_SCALE_BIAS) {
1759 _mesa_scale_and_bias_rgba(n, rgba,
1760 ctx->Pixel.PostConvolutionScale[RCOMP],
1761 ctx->Pixel.PostConvolutionScale[GCOMP],
1762 ctx->Pixel.PostConvolutionScale[BCOMP],
1763 ctx->Pixel.PostConvolutionScale[ACOMP],
1764 ctx->Pixel.PostConvolutionBias[RCOMP],
1765 ctx->Pixel.PostConvolutionBias[GCOMP],
1766 ctx->Pixel.PostConvolutionBias[BCOMP],
1767 ctx->Pixel.PostConvolutionBias[ACOMP]);
1768 }
1769 /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
1770 if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) {
1771 _mesa_lookup_rgba_float(&ctx->ColorTable[COLORTABLE_POSTCONVOLUTION], n, rgba);
1772 }
1773 /* color matrix transform */
1774 if (transferOps & IMAGE_COLOR_MATRIX_BIT) {
1775 _mesa_transform_rgba(ctx, n, rgba);
1776 }
1777 /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
1778 if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) {
1779 _mesa_lookup_rgba_float(&ctx->ColorTable[COLORTABLE_POSTCOLORMATRIX], n, rgba);
1780 }
1781 /* update histogram count */
1782 if (transferOps & IMAGE_HISTOGRAM_BIT) {
1783 update_histogram(ctx, n, (CONST GLfloat (*)[4]) rgba);
1784 }
1785 /* update min/max values */
1786 if (transferOps & IMAGE_MIN_MAX_BIT) {
1787 update_minmax(ctx, n, (CONST GLfloat (*)[4]) rgba);
1788 }
1789 /* clamping to [0,1] */
1790 if (transferOps & IMAGE_CLAMP_BIT) {
1791 GLuint i;
1792 for (i = 0; i < n; i++) {
1793 rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F);
1794 rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F);
1795 rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F);
1796 rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F);
1797 }
1798 }
1799 }
1800
1801
1802 /*
1803 * Apply color index shift and offset to an array of pixels.
1804 */
1805 static void
1806 shift_and_offset_ci( const GLcontext *ctx, GLuint n, GLuint indexes[] )
1807 {
1808 GLint shift = ctx->Pixel.IndexShift;
1809 GLint offset = ctx->Pixel.IndexOffset;
1810 GLuint i;
1811 if (shift > 0) {
1812 for (i=0;i<n;i++) {
1813 indexes[i] = (indexes[i] << shift) + offset;
1814 }
1815 }
1816 else if (shift < 0) {
1817 shift = -shift;
1818 for (i=0;i<n;i++) {
1819 indexes[i] = (indexes[i] >> shift) + offset;
1820 }
1821 }
1822 else {
1823 for (i=0;i<n;i++) {
1824 indexes[i] = indexes[i] + offset;
1825 }
1826 }
1827 }
1828
1829
1830
1831 /**
1832 * Apply color index shift, offset and table lookup to an array
1833 * of color indexes;
1834 */
1835 void
1836 _mesa_apply_ci_transfer_ops(const GLcontext *ctx, GLbitfield transferOps,
1837 GLuint n, GLuint indexes[])
1838 {
1839 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
1840 shift_and_offset_ci(ctx, n, indexes);
1841 }
1842 if (transferOps & IMAGE_MAP_COLOR_BIT) {
1843 const GLuint mask = ctx->PixelMaps.ItoI.Size - 1;
1844 GLuint i;
1845 for (i = 0; i < n; i++) {
1846 const GLuint j = indexes[i] & mask;
1847 indexes[i] = IROUND(ctx->PixelMaps.ItoI.Map[j]);
1848 }
1849 }
1850 }
1851
1852
1853 /**
1854 * Apply stencil index shift, offset and table lookup to an array
1855 * of stencil values.
1856 */
1857 void
1858 _mesa_apply_stencil_transfer_ops(const GLcontext *ctx, GLuint n,
1859 GLstencil stencil[])
1860 {
1861 if (ctx->Pixel.IndexShift != 0 || ctx->Pixel.IndexOffset != 0) {
1862 const GLint offset = ctx->Pixel.IndexOffset;
1863 GLint shift = ctx->Pixel.IndexShift;
1864 GLuint i;
1865 if (shift > 0) {
1866 for (i = 0; i < n; i++) {
1867 stencil[i] = (stencil[i] << shift) + offset;
1868 }
1869 }
1870 else if (shift < 0) {
1871 shift = -shift;
1872 for (i = 0; i < n; i++) {
1873 stencil[i] = (stencil[i] >> shift) + offset;
1874 }
1875 }
1876 else {
1877 for (i = 0; i < n; i++) {
1878 stencil[i] = stencil[i] + offset;
1879 }
1880 }
1881 }
1882 if (ctx->Pixel.MapStencilFlag) {
1883 GLuint mask = ctx->PixelMaps.StoS.Size - 1;
1884 GLuint i;
1885 for (i = 0; i < n; i++) {
1886 stencil[i] = (GLstencil)ctx->PixelMaps.StoS.Map[ stencil[i] & mask ];
1887 }
1888 }
1889 }
1890
1891
1892 /**
1893 * Used to pack an array [][4] of RGBA float colors as specified
1894 * by the dstFormat, dstType and dstPacking. Used by glReadPixels,
1895 * glGetConvolutionFilter(), etc.
1896 * Note: the rgba values will be modified by this function when any pixel
1897 * transfer ops are enabled.
1898 */
1899 void
1900 _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4],
1901 GLenum dstFormat, GLenum dstType,
1902 GLvoid *dstAddr,
1903 const struct gl_pixelstore_attrib *dstPacking,
1904 GLbitfield transferOps)
1905 {
1906 GLfloat luminance[MAX_WIDTH];
1907 const GLint comps = _mesa_components_in_format(dstFormat);
1908 GLuint i;
1909
1910 /* XXX
1911 * This test should probably go away. Have the caller set/clear the
1912 * IMAGE_CLAMP_BIT as needed.
1913 */
1914 if (dstType != GL_FLOAT || ctx->Color.ClampReadColor == GL_TRUE) {
1915 /* need to clamp to [0, 1] */
1916 transferOps |= IMAGE_CLAMP_BIT;
1917 }
1918
1919 if (transferOps) {
1920 _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
1921 if ((transferOps & IMAGE_MIN_MAX_BIT) && ctx->MinMax.Sink) {
1922 return;
1923 }
1924 }
1925
1926 if (dstFormat == GL_LUMINANCE || dstFormat == GL_LUMINANCE_ALPHA) {
1927 /* compute luminance values */
1928 if (transferOps & IMAGE_CLAMP_BIT) {
1929 for (i = 0; i < n; i++) {
1930 GLfloat sum = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
1931 luminance[i] = CLAMP(sum, 0.0F, 1.0F);
1932 }
1933 }
1934 else {
1935 for (i = 0; i < n; i++) {
1936 luminance[i] = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
1937 }
1938 }
1939 }
1940
1941 /*
1942 * Pack/store the pixels. Ugh! Lots of cases!!!
1943 */
1944 switch (dstType) {
1945 case GL_UNSIGNED_BYTE:
1946 {
1947 GLubyte *dst = (GLubyte *) dstAddr;
1948 switch (dstFormat) {
1949 case GL_RED:
1950 for (i=0;i<n;i++)
1951 dst[i] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
1952 break;
1953 case GL_GREEN:
1954 for (i=0;i<n;i++)
1955 dst[i] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
1956 break;
1957 case GL_BLUE:
1958 for (i=0;i<n;i++)
1959 dst[i] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
1960 break;
1961 case GL_ALPHA:
1962 for (i=0;i<n;i++)
1963 dst[i] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
1964 break;
1965 case GL_LUMINANCE:
1966 for (i=0;i<n;i++)
1967 dst[i] = FLOAT_TO_UBYTE(luminance[i]);
1968 break;
1969 case GL_LUMINANCE_ALPHA:
1970 for (i=0;i<n;i++) {
1971 dst[i*2+0] = FLOAT_TO_UBYTE(luminance[i]);
1972 dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
1973 }
1974 break;
1975 case GL_RGB:
1976 for (i=0;i<n;i++) {
1977 dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
1978 dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
1979 dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
1980 }
1981 break;
1982 case GL_RGBA:
1983 for (i=0;i<n;i++) {
1984 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
1985 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
1986 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
1987 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
1988 }
1989 break;
1990 case GL_BGR:
1991 for (i=0;i<n;i++) {
1992 dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
1993 dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
1994 dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
1995 }
1996 break;
1997 case GL_BGRA:
1998 for (i=0;i<n;i++) {
1999 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
2000 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
2001 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
2002 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
2003 }
2004 break;
2005 case GL_ABGR_EXT:
2006 for (i=0;i<n;i++) {
2007 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
2008 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
2009 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
2010 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
2011 }
2012 break;
2013 case GL_DUDV_ATI:
2014 case GL_DU8DV8_ATI:
2015 for (i=0;i<n;i++) {
2016 dst[i*2+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
2017 dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
2018 }
2019 break;
2020 default:
2021 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
2022 }
2023 }
2024 break;
2025 case GL_BYTE:
2026 {
2027 GLbyte *dst = (GLbyte *) dstAddr;
2028 switch (dstFormat) {
2029 case GL_RED:
2030 for (i=0;i<n;i++)
2031 dst[i] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
2032 break;
2033 case GL_GREEN:
2034 for (i=0;i<n;i++)
2035 dst[i] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
2036 break;
2037 case GL_BLUE:
2038 for (i=0;i<n;i++)
2039 dst[i] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
2040 break;
2041 case GL_ALPHA:
2042 for (i=0;i<n;i++)
2043 dst[i] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
2044 break;
2045 case GL_LUMINANCE:
2046 for (i=0;i<n;i++)
2047 dst[i] = FLOAT_TO_BYTE(luminance[i]);
2048 break;
2049 case GL_LUMINANCE_ALPHA:
2050 for (i=0;i<n;i++) {
2051 dst[i*2+0] = FLOAT_TO_BYTE(luminance[i]);
2052 dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
2053 }
2054 break;
2055 case GL_RGB:
2056 for (i=0;i<n;i++) {
2057 dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
2058 dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
2059 dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
2060 }
2061 break;
2062 case GL_RGBA:
2063 for (i=0;i<n;i++) {
2064 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
2065 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
2066 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
2067 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
2068 }
2069 break;
2070 case GL_BGR:
2071 for (i=0;i<n;i++) {
2072 dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
2073 dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
2074 dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
2075 }
2076 break;
2077 case GL_BGRA:
2078 for (i=0;i<n;i++) {
2079 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
2080 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
2081 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
2082 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
2083 }
2084 break;
2085 case GL_ABGR_EXT:
2086 for (i=0;i<n;i++) {
2087 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
2088 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
2089 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
2090 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
2091 }
2092 break;
2093 case GL_DUDV_ATI:
2094 case GL_DU8DV8_ATI:
2095 for (i=0;i<n;i++) {
2096 dst[i*2+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
2097 dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
2098 }
2099 break;
2100 default:
2101 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
2102 }
2103 }
2104 break;
2105 case GL_UNSIGNED_SHORT:
2106 {
2107 GLushort *dst = (GLushort *) dstAddr;
2108 switch (dstFormat) {
2109 case GL_RED:
2110 for (i=0;i<n;i++)
2111 CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][RCOMP]);
2112 break;
2113 case GL_GREEN:
2114 for (i=0;i<n;i++)
2115 CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][GCOMP]);
2116 break;
2117 case GL_BLUE:
2118 for (i=0;i<n;i++)
2119 CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][BCOMP]);
2120 break;
2121 case GL_ALPHA:
2122 for (i=0;i<n;i++)
2123 CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][ACOMP]);
2124 break;
2125 case GL_LUMINANCE:
2126 for (i=0;i<n;i++)
2127 UNCLAMPED_FLOAT_TO_USHORT(dst[i], luminance[i]);
2128 break;
2129 case GL_LUMINANCE_ALPHA:
2130 for (i=0;i<n;i++) {
2131 UNCLAMPED_FLOAT_TO_USHORT(dst[i*2+0], luminance[i]);
2132 CLAMPED_FLOAT_TO_USHORT(dst[i*2+1], rgba[i][ACOMP]);
2133 }
2134 break;
2135 case GL_RGB:
2136 for (i=0;i<n;i++) {
2137 CLAMPED_FLOAT_TO_USHORT(dst[i*3+0], rgba[i][RCOMP]);
2138 CLAMPED_FLOAT_TO_USHORT(dst[i*3+1], rgba[i][GCOMP]);
2139 CLAMPED_FLOAT_TO_USHORT(dst[i*3+2], rgba[i][BCOMP]);
2140 }
2141 break;
2142 case GL_RGBA:
2143 for (i=0;i<n;i++) {
2144 CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][RCOMP]);
2145 CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][GCOMP]);
2146 CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][BCOMP]);
2147 CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][ACOMP]);
2148 }
2149 break;
2150 case GL_BGR:
2151 for (i=0;i<n;i++) {
2152 CLAMPED_FLOAT_TO_USHORT(dst[i*3+0], rgba[i][BCOMP]);
2153 CLAMPED_FLOAT_TO_USHORT(dst[i*3+1], rgba[i][GCOMP]);
2154 CLAMPED_FLOAT_TO_USHORT(dst[i*3+2], rgba[i][RCOMP]);
2155 }
2156 break;
2157 case GL_BGRA:
2158 for (i=0;i<n;i++) {
2159 CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][BCOMP]);
2160 CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][GCOMP]);
2161 CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][RCOMP]);
2162 CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][ACOMP]);
2163 }
2164 break;
2165 case GL_ABGR_EXT:
2166 for (i=0;i<n;i++) {
2167 CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][ACOMP]);
2168 CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][BCOMP]);
2169 CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][GCOMP]);
2170 CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][RCOMP]);
2171 }
2172 break;
2173 case GL_DUDV_ATI:
2174 case GL_DU8DV8_ATI:
2175 for (i=0;i<n;i++) {
2176 dst[i*2+0] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
2177 dst[i*2+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
2178 }
2179 break;
2180 default:
2181 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
2182 }
2183 }
2184 break;
2185 case GL_SHORT:
2186 {
2187 GLshort *dst = (GLshort *) dstAddr;
2188 switch (dstFormat) {
2189 case GL_RED:
2190 for (i=0;i<n;i++)
2191 dst[i] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
2192 break;
2193 case GL_GREEN:
2194 for (i=0;i<n;i++)
2195 dst[i] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
2196 break;
2197 case GL_BLUE:
2198 for (i=0;i<n;i++)
2199 dst[i] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
2200 break;
2201 case GL_ALPHA:
2202 for (i=0;i<n;i++)
2203 dst[i] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
2204 break;
2205 case GL_LUMINANCE:
2206 for (i=0;i<n;i++)
2207 dst[i] = FLOAT_TO_SHORT(luminance[i]);
2208 break;
2209 case GL_LUMINANCE_ALPHA:
2210 for (i=0;i<n;i++) {
2211 dst[i*2+0] = FLOAT_TO_SHORT(luminance[i]);
2212 dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
2213 }
2214 break;
2215 case GL_RGB:
2216 for (i=0;i<n;i++) {
2217 dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
2218 dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
2219 dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
2220 }
2221 break;
2222 case GL_RGBA:
2223 for (i=0;i<n;i++) {
2224 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
2225 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
2226 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
2227 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
2228 }
2229 break;
2230 case GL_BGR:
2231 for (i=0;i<n;i++) {
2232 dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
2233 dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
2234 dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
2235 }
2236 break;
2237 case GL_BGRA:
2238 for (i=0;i<n;i++) {
2239 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
2240 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
2241 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
2242 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
2243 }
2244 break;
2245 case GL_ABGR_EXT:
2246 for (i=0;i<n;i++) {
2247 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
2248 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
2249 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
2250 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
2251 }
2252 break;
2253 case GL_DUDV_ATI:
2254 case GL_DU8DV8_ATI:
2255 for (i=0;i<n;i++) {
2256 dst[i*2+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
2257 dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
2258 }
2259 break;
2260 default:
2261 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
2262 }
2263 }
2264 break;
2265 case GL_UNSIGNED_INT:
2266 {
2267 GLuint *dst = (GLuint *) dstAddr;
2268 switch (dstFormat) {
2269 case GL_RED:
2270 for (i=0;i<n;i++)
2271 dst[i] = FLOAT_TO_UINT(rgba[i][RCOMP]);
2272 break;
2273 case GL_GREEN:
2274 for (i=0;i<n;i++)
2275 dst[i] = FLOAT_TO_UINT(rgba[i][GCOMP]);
2276 break;
2277 case GL_BLUE:
2278 for (i=0;i<n;i++)
2279 dst[i] = FLOAT_TO_UINT(rgba[i][BCOMP]);
2280 break;
2281 case GL_ALPHA:
2282 for (i=0;i<n;i++)
2283 dst[i] = FLOAT_TO_UINT(rgba[i][ACOMP]);
2284 break;
2285 case GL_LUMINANCE:
2286 for (i=0;i<n;i++)
2287 dst[i] = FLOAT_TO_UINT(luminance[i]);
2288 break;
2289 case GL_LUMINANCE_ALPHA:
2290 for (i=0;i<n;i++) {
2291 dst[i*2+0] = FLOAT_TO_UINT(luminance[i]);
2292 dst[i*2+1] = FLOAT_TO_UINT(rgba[i][ACOMP]);
2293 }
2294 break;
2295 case GL_RGB:
2296 for (i=0;i<n;i++) {
2297 dst[i*3+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
2298 dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
2299 dst[i*3+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);
2300 }
2301 break;
2302 case GL_RGBA:
2303 for (i=0;i<n;i++) {
2304 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
2305 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
2306 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);
2307 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);
2308 }
2309 break;
2310 case GL_BGR:
2311 for (i=0;i<n;i++) {
2312 dst[i*3+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);
2313 dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
2314 dst[i*3+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);
2315 }
2316 break;
2317 case GL_BGRA:
2318 for (i=0;i<n;i++) {
2319 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);
2320 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
2321 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);
2322 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);
2323 }
2324 break;
2325 case GL_ABGR_EXT:
2326 for (i=0;i<n;i++) {
2327 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][ACOMP]);
2328 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][BCOMP]);
2329 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][GCOMP]);
2330 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][RCOMP]);
2331 }
2332 break;
2333 case GL_DUDV_ATI:
2334 case GL_DU8DV8_ATI:
2335 for (i=0;i<n;i++) {
2336 dst[i*2+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
2337 dst[i*2+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
2338 }
2339 break;
2340 default:
2341 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
2342 }
2343 }
2344 break;
2345 case GL_INT:
2346 {
2347 GLint *dst = (GLint *) dstAddr;
2348 switch (dstFormat) {
2349 case GL_RED:
2350 for (i=0;i<n;i++)
2351 dst[i] = FLOAT_TO_INT(rgba[i][RCOMP]);
2352 break;
2353 case GL_GREEN:
2354 for (i=0;i<n;i++)
2355 dst[i] = FLOAT_TO_INT(rgba[i][GCOMP]);
2356 break;
2357 case GL_BLUE:
2358 for (i=0;i<n;i++)
2359 dst[i] = FLOAT_TO_INT(rgba[i][BCOMP]);
2360 break;
2361 case GL_ALPHA:
2362 for (i=0;i<n;i++)
2363 dst[i] = FLOAT_TO_INT(rgba[i][ACOMP]);
2364 break;
2365 case GL_LUMINANCE:
2366 for (i=0;i<n;i++)
2367 dst[i] = FLOAT_TO_INT(luminance[i]);
2368 break;
2369 case GL_LUMINANCE_ALPHA:
2370 for (i=0;i<n;i++) {
2371 dst[i*2+0] = FLOAT_TO_INT(luminance[i]);
2372 dst[i*2+1] = FLOAT_TO_INT(rgba[i][ACOMP]);
2373 }
2374 break;
2375 case GL_RGB:
2376 for (i=0;i<n;i++) {
2377 dst[i*3+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
2378 dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
2379 dst[i*3+2] = FLOAT_TO_INT(rgba[i][BCOMP]);
2380 }
2381 break;
2382 case GL_RGBA:
2383 for (i=0;i<n;i++) {
2384 dst[i*4+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
2385 dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
2386 dst[i*4+2] = FLOAT_TO_INT(rgba[i][BCOMP]);
2387 dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);
2388 }
2389 break;
2390 case GL_BGR:
2391 for (i=0;i<n;i++) {
2392 dst[i*3+0] = FLOAT_TO_INT(rgba[i][BCOMP]);
2393 dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
2394 dst[i*3+2] = FLOAT_TO_INT(rgba[i][RCOMP]);
2395 }
2396 break;
2397 case GL_BGRA:
2398 for (i=0;i<n;i++) {
2399 dst[i*4+0] = FLOAT_TO_INT(rgba[i][BCOMP]);
2400 dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
2401 dst[i*4+2] = FLOAT_TO_INT(rgba[i][RCOMP]);
2402 dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);
2403 }
2404 break;
2405 case GL_ABGR_EXT:
2406 for (i=0;i<n;i++) {
2407 dst[i*4+0] = FLOAT_TO_INT(rgba[i][ACOMP]);
2408 dst[i*4+1] = FLOAT_TO_INT(rgba[i][BCOMP]);
2409 dst[i*4+2] = FLOAT_TO_INT(rgba[i][GCOMP]);
2410 dst[i*4+3] = FLOAT_TO_INT(rgba[i][RCOMP]);
2411 }
2412 break;
2413 case GL_DUDV_ATI:
2414 case GL_DU8DV8_ATI:
2415 for (i=0;i<n;i++) {
2416 dst[i*2+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
2417 dst[i*2+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
2418 }
2419 break;
2420 default:
2421 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
2422 }
2423 }
2424 break;
2425 case GL_FLOAT:
2426 {
2427 GLfloat *dst = (GLfloat *) dstAddr;
2428 switch (dstFormat) {
2429 case GL_RED:
2430 for (i=0;i<n;i++)
2431 dst[i] = rgba[i][RCOMP];
2432 break;
2433 case GL_GREEN:
2434 for (i=0;i<n;i++)
2435 dst[i] = rgba[i][GCOMP];
2436 break;
2437 case GL_BLUE:
2438 for (i=0;i<n;i++)
2439 dst[i] = rgba[i][BCOMP];
2440 break;
2441 case GL_ALPHA:
2442 for (i=0;i<n;i++)
2443 dst[i] = rgba[i][ACOMP];
2444 break;
2445 case GL_LUMINANCE:
2446 for (i=0;i<n;i++)
2447 dst[i] = luminance[i];
2448 break;
2449 case GL_LUMINANCE_ALPHA:
2450 for (i=0;i<n;i++) {
2451 dst[i*2+0] = luminance[i];
2452 dst[i*2+1] = rgba[i][ACOMP];
2453 }
2454 break;
2455 case GL_RGB:
2456 for (i=0;i<n;i++) {
2457 dst[i*3+0] = rgba[i][RCOMP];
2458 dst[i*3+1] = rgba[i][GCOMP];
2459 dst[i*3+2] = rgba[i][BCOMP];
2460 }
2461 break;
2462 case GL_RGBA:
2463 for (i=0;i<n;i++) {
2464 dst[i*4+0] = rgba[i][RCOMP];
2465 dst[i*4+1] = rgba[i][GCOMP];
2466 dst[i*4+2] = rgba[i][BCOMP];
2467 dst[i*4+3] = rgba[i][ACOMP];
2468 }
2469 break;
2470 case GL_BGR:
2471 for (i=0;i<n;i++) {
2472 dst[i*3+0] = rgba[i][BCOMP];
2473 dst[i*3+1] = rgba[i][GCOMP];
2474 dst[i*3+2] = rgba[i][RCOMP];
2475 }
2476 break;
2477 case GL_BGRA:
2478 for (i=0;i<n;i++) {
2479 dst[i*4+0] = rgba[i][BCOMP];
2480 dst[i*4+1] = rgba[i][GCOMP];
2481 dst[i*4+2] = rgba[i][RCOMP];
2482 dst[i*4+3] = rgba[i][ACOMP];
2483 }
2484 break;
2485 case GL_ABGR_EXT:
2486 for (i=0;i<n;i++) {
2487 dst[i*4+0] = rgba[i][ACOMP];
2488 dst[i*4+1] = rgba[i][BCOMP];
2489 dst[i*4+2] = rgba[i][GCOMP];
2490 dst[i*4+3] = rgba[i][RCOMP];
2491 }
2492 break;
2493 case GL_DUDV_ATI:
2494 case GL_DU8DV8_ATI:
2495 for (i=0;i<n;i++) {
2496 dst[i*2+0] = rgba[i][RCOMP];
2497 dst[i*2+1] = rgba[i][GCOMP];
2498 }
2499 break;
2500 default:
2501 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
2502 }
2503 }
2504 break;
2505 case GL_HALF_FLOAT_ARB:
2506 {
2507 GLhalfARB *dst = (GLhalfARB *) dstAddr;
2508 switch (dstFormat) {
2509 case GL_RED:
2510 for (i=0;i<n;i++)
2511 dst[i] = _mesa_float_to_half(rgba[i][RCOMP]);
2512 break;
2513 case GL_GREEN:
2514 for (i=0;i<n;i++)
2515 dst[i] = _mesa_float_to_half(rgba[i][GCOMP]);
2516 break;
2517 case GL_BLUE:
2518 for (i=0;i<n;i++)
2519 dst[i] = _mesa_float_to_half(rgba[i][BCOMP]);
2520 break;
2521 case GL_ALPHA:
2522 for (i=0;i<n;i++)
2523 dst[i] = _mesa_float_to_half(rgba[i][ACOMP]);
2524 break;
2525 case GL_LUMINANCE:
2526 for (i=0;i<n;i++)
2527 dst[i] = _mesa_float_to_half(luminance[i]);
2528 break;
2529 case GL_LUMINANCE_ALPHA:
2530 for (i=0;i<n;i++) {
2531 dst[i*2+0] = _mesa_float_to_half(luminance[i]);
2532 dst[i*2+1] = _mesa_float_to_half(rgba[i][ACOMP]);
2533 }
2534 break;
2535 case GL_RGB:
2536 for (i=0;i<n;i++) {
2537 dst[i*3+0] = _mesa_float_to_half(rgba[i][RCOMP]);
2538 dst[i*3+1] = _mesa_float_to_half(rgba[i][GCOMP]);
2539 dst[i*3+2] = _mesa_float_to_half(rgba[i][BCOMP]);
2540 }
2541 break;
2542 case GL_RGBA:
2543 for (i=0;i<n;i++) {
2544 dst[i*4+0] = _mesa_float_to_half(rgba[i][RCOMP]);
2545 dst[i*4+1] = _mesa_float_to_half(rgba[i][GCOMP]);
2546 dst[i*4+2] = _mesa_float_to_half(rgba[i][BCOMP]);
2547 dst[i*4+3] = _mesa_float_to_half(rgba[i][ACOMP]);
2548 }
2549 break;
2550 case GL_BGR:
2551 for (i=0;i<n;i++) {
2552 dst[i*3+0] = _mesa_float_to_half(rgba[i][BCOMP]);
2553 dst[i*3+1] = _mesa_float_to_half(rgba[i][GCOMP]);
2554 dst[i*3+2] = _mesa_float_to_half(rgba[i][RCOMP]);
2555 }
2556 break;
2557 case GL_BGRA:
2558 for (i=0;i<n;i++) {
2559 dst[i*4+0] = _mesa_float_to_half(rgba[i][BCOMP]);
2560 dst[i*4+1] = _mesa_float_to_half(rgba[i][GCOMP]);
2561 dst[i*4+2] = _mesa_float_to_half(rgba[i][RCOMP]);
2562 dst[i*4+3] = _mesa_float_to_half(rgba[i][ACOMP]);
2563 }
2564 break;
2565 case GL_ABGR_EXT:
2566 for (i=0;i<n;i++) {
2567 dst[i*4+0] = _mesa_float_to_half(rgba[i][ACOMP]);
2568 dst[i*4+1] = _mesa_float_to_half(rgba[i][BCOMP]);
2569 dst[i*4+2] = _mesa_float_to_half(rgba[i][GCOMP]);
2570 dst[i*4+3] = _mesa_float_to_half(rgba[i][RCOMP]);
2571 }
2572 break;
2573 case GL_DUDV_ATI:
2574 case GL_DU8DV8_ATI:
2575 for (i=0;i<n;i++) {
2576 dst[i*2+0] = _mesa_float_to_half(rgba[i][RCOMP]);
2577 dst[i*2+1] = _mesa_float_to_half(rgba[i][GCOMP]);
2578 }
2579 break;
2580 default:
2581 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
2582 }
2583 }
2584 break;
2585 case GL_UNSIGNED_BYTE_3_3_2:
2586 if (dstFormat == GL_RGB) {
2587 GLubyte *dst = (GLubyte *) dstAddr;
2588 for (i=0;i<n;i++) {
2589 dst[i] = (IROUND(rgba[i][RCOMP] * 7.0F) << 5)
2590 | (IROUND(rgba[i][GCOMP] * 7.0F) << 2)
2591 | (IROUND(rgba[i][BCOMP] * 3.0F) );
2592 }
2593 }
2594 break;
2595 case GL_UNSIGNED_BYTE_2_3_3_REV:
2596 if (dstFormat == GL_RGB) {
2597 GLubyte *dst = (GLubyte *) dstAddr;
2598 for (i=0;i<n;i++) {
2599 dst[i] = (IROUND(rgba[i][RCOMP] * 7.0F) )
2600 | (IROUND(rgba[i][GCOMP] * 7.0F) << 3)
2601 | (IROUND(rgba[i][BCOMP] * 3.0F) << 6);
2602 }
2603 }
2604 break;
2605 case GL_UNSIGNED_SHORT_5_6_5:
2606 if (dstFormat == GL_RGB) {
2607 GLushort *dst = (GLushort *) dstAddr;
2608 for (i=0;i<n;i++) {
2609 dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F) << 11)
2610 | (IROUND(rgba[i][GCOMP] * 63.0F) << 5)
2611 | (IROUND(rgba[i][BCOMP] * 31.0F) );
2612 }
2613 }
2614 break;
2615 case GL_UNSIGNED_SHORT_5_6_5_REV:
2616 if (dstFormat == GL_RGB) {
2617 GLushort *dst = (GLushort *) dstAddr;
2618 for (i=0;i<n;i++) {
2619 dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F) )
2620 | (IROUND(rgba[i][GCOMP] * 63.0F) << 5)
2621 | (IROUND(rgba[i][BCOMP] * 31.0F) << 11);
2622 }
2623 }
2624 break;
2625 case GL_UNSIGNED_SHORT_4_4_4_4:
2626 if (dstFormat == GL_RGBA) {
2627 GLushort *dst = (GLushort *) dstAddr;
2628 for (i=0;i<n;i++) {
2629 dst[i] = (IROUND(rgba[i][RCOMP] * 15.0F) << 12)
2630 | (IROUND(rgba[i][GCOMP] * 15.0F) << 8)
2631 | (IROUND(rgba[i][BCOMP] * 15.0F) << 4)
2632 | (IROUND(rgba[i][ACOMP] * 15.0F) );
2633 }
2634 }
2635 else if (dstFormat == GL_BGRA) {
2636 GLushort *dst = (GLushort *) dstAddr;
2637 for (i=0;i<n;i++) {
2638 dst[i] = (IROUND(rgba[i][BCOMP] * 15.0F) << 12)
2639 | (IROUND(rgba[i][GCOMP] * 15.0F) << 8)
2640 | (IROUND(rgba[i][RCOMP] * 15.0F) << 4)
2641 | (IROUND(rgba[i][ACOMP] * 15.0F) );
2642 }
2643 }
2644 else if (dstFormat == GL_ABGR_EXT) {
2645 GLushort *dst = (GLushort *) dstAddr;
2646 for (i=0;i<n;i++) {
2647 dst[i] = (IROUND(rgba[i][ACOMP] * 15.0F) << 12)
2648 | (IROUND(rgba[i][BCOMP] * 15.0F) << 8)
2649 | (IROUND(rgba[i][GCOMP] * 15.0F) << 4)
2650 | (IROUND(rgba[i][RCOMP] * 15.0F) );
2651 }
2652 }
2653 break;
2654 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
2655 if (dstFormat == GL_RGBA) {
2656 GLushort *dst = (GLushort *) dstAddr;
2657 for (i=0;i<n;i++) {
2658 dst[i] = (IROUND(rgba[i][RCOMP] * 15.0F) )
2659 | (IROUND(rgba[i][GCOMP] * 15.0F) << 4)
2660 | (IROUND(rgba[i][BCOMP] * 15.0F) << 8)
2661 | (IROUND(rgba[i][ACOMP] * 15.0F) << 12);
2662 }
2663 }
2664 else if (dstFormat == GL_BGRA) {
2665 GLushort *dst = (GLushort *) dstAddr;
2666 for (i=0;i<n;i++) {
2667 dst[i] = (IROUND(rgba[i][BCOMP] * 15.0F) )
2668 | (IROUND(rgba[i][GCOMP] * 15.0F) << 4)
2669 | (IROUND(rgba[i][RCOMP] * 15.0F) << 8)
2670 | (IROUND(rgba[i][ACOMP] * 15.0F) << 12);
2671 }
2672 }
2673 else if (dstFormat == GL_ABGR_EXT) {
2674 GLushort *dst = (GLushort *) dstAddr;
2675 for (i=0;i<n;i++) {
2676 dst[i] = (IROUND(rgba[i][ACOMP] * 15.0F) )
2677 | (IROUND(rgba[i][BCOMP] * 15.0F) << 4)
2678 | (IROUND(rgba[i][GCOMP] * 15.0F) << 8)
2679 | (IROUND(rgba[i][RCOMP] * 15.0F) << 12);
2680 }
2681 }
2682 break;
2683 case GL_UNSIGNED_SHORT_5_5_5_1:
2684 if (dstFormat == GL_RGBA) {
2685 GLushort *dst = (GLushort *) dstAddr;
2686 for (i=0;i<n;i++) {
2687 dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F) << 11)
2688 | (IROUND(rgba[i][GCOMP] * 31.0F) << 6)
2689 | (IROUND(rgba[i][BCOMP] * 31.0F) << 1)
2690 | (IROUND(rgba[i][ACOMP] * 1.0F) );
2691 }
2692 }
2693 else if (dstFormat == GL_BGRA) {
2694 GLushort *dst = (GLushort *) dstAddr;
2695 for (i=0;i<n;i++) {
2696 dst[i] = (IROUND(rgba[i][BCOMP] * 31.0F) << 11)
2697 | (IROUND(rgba[i][GCOMP] * 31.0F) << 6)
2698 | (IROUND(rgba[i][RCOMP] * 31.0F) << 1)
2699 | (IROUND(rgba[i][ACOMP] * 1.0F) );
2700 }
2701 }
2702 else if (dstFormat == GL_ABGR_EXT) {
2703 GLushort *dst = (GLushort *) dstAddr;
2704 for (i=0;i<n;i++) {
2705 dst[i] = (IROUND(rgba[i][ACOMP] * 31.0F) << 11)
2706 | (IROUND(rgba[i][BCOMP] * 31.0F) << 6)
2707 | (IROUND(rgba[i][GCOMP] * 31.0F) << 1)
2708 | (IROUND(rgba[i][RCOMP] * 1.0F) );
2709 }
2710 }
2711 break;
2712 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
2713 if (dstFormat == GL_RGBA) {
2714 GLushort *dst = (GLushort *) dstAddr;
2715 for (i=0;i<n;i++) {
2716 dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F) )
2717 | (IROUND(rgba[i][GCOMP] * 31.0F) << 5)
2718 | (IROUND(rgba[i][BCOMP] * 31.0F) << 10)
2719 | (IROUND(rgba[i][ACOMP] * 1.0F) << 15);
2720 }
2721 }
2722 else if (dstFormat == GL_BGRA) {
2723 GLushort *dst = (GLushort *) dstAddr;
2724 for (i=0;i<n;i++) {
2725 dst[i] = (IROUND(rgba[i][BCOMP] * 31.0F) )
2726 | (IROUND(rgba[i][GCOMP] * 31.0F) << 5)
2727 | (IROUND(rgba[i][RCOMP] * 31.0F) << 10)
2728 | (IROUND(rgba[i][ACOMP] * 1.0F) << 15);
2729 }
2730 }
2731 else if (dstFormat == GL_ABGR_EXT) {
2732 GLushort *dst = (GLushort *) dstAddr;
2733 for (i=0;i<n;i++) {
2734 dst[i] = (IROUND(rgba[i][ACOMP] * 31.0F) )
2735 | (IROUND(rgba[i][BCOMP] * 31.0F) << 5)
2736 | (IROUND(rgba[i][GCOMP] * 31.0F) << 10)
2737 | (IROUND(rgba[i][RCOMP] * 1.0F) << 15);
2738 }
2739 }
2740 break;
2741 case GL_UNSIGNED_INT_8_8_8_8:
2742 if (dstFormat == GL_RGBA) {
2743 GLuint *dst = (GLuint *) dstAddr;
2744 for (i=0;i<n;i++) {
2745 dst[i] = (IROUND(rgba[i][RCOMP] * 255.F) << 24)
2746 | (IROUND(rgba[i][GCOMP] * 255.F) << 16)
2747 | (IROUND(rgba[i][BCOMP] * 255.F) << 8)
2748 | (IROUND(rgba[i][ACOMP] * 255.F) );
2749 }
2750 }
2751 else if (dstFormat == GL_BGRA) {
2752 GLuint *dst = (GLuint *) dstAddr;
2753 for (i=0;i<n;i++) {
2754 dst[i] = (IROUND(rgba[i][BCOMP] * 255.F) << 24)
2755 | (IROUND(rgba[i][GCOMP] * 255.F) << 16)
2756 | (IROUND(rgba[i][RCOMP] * 255.F) << 8)
2757 | (IROUND(rgba[i][ACOMP] * 255.F) );
2758 }
2759 }
2760 else if (dstFormat == GL_ABGR_EXT) {
2761 GLuint *dst = (GLuint *) dstAddr;
2762 for (i=0;i<n;i++) {
2763 dst[i] = (IROUND(rgba[i][ACOMP] * 255.F) << 24)
2764 | (IROUND(rgba[i][BCOMP] * 255.F) << 16)
2765 | (IROUND(rgba[i][GCOMP] * 255.F) << 8)
2766 | (IROUND(rgba[i][RCOMP] * 255.F) );
2767 }
2768 }
2769 break;
2770 case GL_UNSIGNED_INT_8_8_8_8_REV:
2771 if (dstFormat == GL_RGBA) {
2772 GLuint *dst = (GLuint *) dstAddr;
2773 for (i=0;i<n;i++) {
2774 dst[i] = (IROUND(rgba[i][RCOMP] * 255.0F) )
2775 | (IROUND(rgba[i][GCOMP] * 255.0F) << 8)
2776 | (IROUND(rgba[i][BCOMP] * 255.0F) << 16)
2777 | (IROUND(rgba[i][ACOMP] * 255.0F) << 24);
2778 }
2779 }
2780 else if (dstFormat == GL_BGRA) {
2781 GLuint *dst = (GLuint *) dstAddr;
2782 for (i=0;i<n;i++) {
2783 dst[i] = (IROUND(rgba[i][BCOMP] * 255.0F) )
2784 | (IROUND(rgba[i][GCOMP] * 255.0F) << 8)
2785 | (IROUND(rgba[i][RCOMP] * 255.0F) << 16)
2786 | (IROUND(rgba[i][ACOMP] * 255.0F) << 24);
2787 }
2788 }
2789 else if (dstFormat == GL_ABGR_EXT) {
2790 GLuint *dst = (GLuint *) dstAddr;
2791 for (i=0;i<n;i++) {
2792 dst[i] = (IROUND(rgba[i][ACOMP] * 255.0F) )
2793 | (IROUND(rgba[i][BCOMP] * 255.0F) << 8)
2794 | (IROUND(rgba[i][GCOMP] * 255.0F) << 16)
2795 | (IROUND(rgba[i][RCOMP] * 255.0F) << 24);
2796 }
2797 }
2798 break;
2799 case GL_UNSIGNED_INT_10_10_10_2:
2800 if (dstFormat == GL_RGBA) {
2801 GLuint *dst = (GLuint *) dstAddr;
2802 for (i=0;i<n;i++) {
2803 dst[i] = (IROUND(rgba[i][RCOMP] * 1023.0F) << 22)
2804 | (IROUND(rgba[i][GCOMP] * 1023.0F) << 12)
2805 | (IROUND(rgba[i][BCOMP] * 1023.0F) << 2)
2806 | (IROUND(rgba[i][ACOMP] * 3.0F) );
2807 }
2808 }
2809 else if (dstFormat == GL_BGRA) {
2810 GLuint *dst = (GLuint *) dstAddr;
2811 for (i=0;i<n;i++) {
2812 dst[i] = (IROUND(rgba[i][BCOMP] * 1023.0F) << 22)
2813 | (IROUND(rgba[i][GCOMP] * 1023.0F) << 12)
2814 | (IROUND(rgba[i][RCOMP] * 1023.0F) << 2)
2815 | (IROUND(rgba[i][ACOMP] * 3.0F) );
2816 }
2817 }
2818 else if (dstFormat == GL_ABGR_EXT) {
2819 GLuint *dst = (GLuint *) dstAddr;
2820 for (i=0;i<n;i++) {
2821 dst[i] = (IROUND(rgba[i][ACOMP] * 1023.0F) << 22)
2822 | (IROUND(rgba[i][BCOMP] * 1023.0F) << 12)
2823 | (IROUND(rgba[i][GCOMP] * 1023.0F) << 2)
2824 | (IROUND(rgba[i][RCOMP] * 3.0F) );
2825 }
2826 }
2827 break;
2828 case GL_UNSIGNED_INT_2_10_10_10_REV:
2829 if (dstFormat == GL_RGBA) {
2830 GLuint *dst = (GLuint *) dstAddr;
2831 for (i=0;i<n;i++) {
2832 dst[i] = (IROUND(rgba[i][RCOMP] * 1023.0F) )
2833 | (IROUND(rgba[i][GCOMP] * 1023.0F) << 10)
2834 | (IROUND(rgba[i][BCOMP] * 1023.0F) << 20)
2835 | (IROUND(rgba[i][ACOMP] * 3.0F) << 30);
2836 }
2837 }
2838 else if (dstFormat == GL_BGRA) {
2839 GLuint *dst = (GLuint *) dstAddr;
2840 for (i=0;i<n;i++) {
2841 dst[i] = (IROUND(rgba[i][BCOMP] * 1023.0F) )
2842 | (IROUND(rgba[i][GCOMP] * 1023.0F) << 10)
2843 | (IROUND(rgba[i][RCOMP] * 1023.0F) << 20)
2844 | (IROUND(rgba[i][ACOMP] * 3.0F) << 30);
2845 }
2846 }
2847 else if (dstFormat == GL_ABGR_EXT) {
2848 GLuint *dst = (GLuint *) dstAddr;
2849 for (i=0;i<n;i++) {
2850 dst[i] = (IROUND(rgba[i][ACOMP] * 1023.0F) )
2851 | (IROUND(rgba[i][BCOMP] * 1023.0F) << 10)
2852 | (IROUND(rgba[i][GCOMP] * 1023.0F) << 20)
2853 | (IROUND(rgba[i][RCOMP] * 3.0F) << 30);
2854 }
2855 }
2856 break;
2857 default:
2858 _mesa_problem(ctx, "bad type in _mesa_pack_rgba_span_float");
2859 return;
2860 }
2861
2862 if (dstPacking->SwapBytes) {
2863 GLint swapSize = _mesa_sizeof_packed_type(dstType);
2864 if (swapSize == 2) {
2865 if (dstPacking->SwapBytes) {
2866 _mesa_swap2((GLushort *) dstAddr, n * comps);
2867 }
2868 }
2869 else if (swapSize == 4) {
2870 if (dstPacking->SwapBytes) {
2871 _mesa_swap4((GLuint *) dstAddr, n * comps);
2872 }
2873 }
2874 }
2875 }
2876
2877
2878 #define SWAP2BYTE(VALUE) \
2879 { \
2880 GLubyte *bytes = (GLubyte *) &(VALUE); \
2881 GLubyte tmp = bytes[0]; \
2882 bytes[0] = bytes[1]; \
2883 bytes[1] = tmp; \
2884 }
2885
2886 #define SWAP4BYTE(VALUE) \
2887 { \
2888 GLubyte *bytes = (GLubyte *) &(VALUE); \
2889 GLubyte tmp = bytes[0]; \
2890 bytes[0] = bytes[3]; \
2891 bytes[3] = tmp; \
2892 tmp = bytes[1]; \
2893 bytes[1] = bytes[2]; \
2894 bytes[2] = tmp; \
2895 }
2896
2897
2898 static void
2899 extract_uint_indexes(GLuint n, GLuint indexes[],
2900 GLenum srcFormat, GLenum srcType, const GLvoid *src,
2901 const struct gl_pixelstore_attrib *unpack )
2902 {
2903 ASSERT(srcFormat == GL_COLOR_INDEX || srcFormat == GL_STENCIL_INDEX);
2904
2905 ASSERT(srcType == GL_BITMAP ||
2906 srcType == GL_UNSIGNED_BYTE ||
2907 srcType == GL_BYTE ||
2908 srcType == GL_UNSIGNED_SHORT ||
2909 srcType == GL_SHORT ||
2910 srcType == GL_UNSIGNED_INT ||
2911 srcType == GL_INT ||
2912 srcType == GL_UNSIGNED_INT_24_8_EXT ||
2913 srcType == GL_HALF_FLOAT_ARB ||
2914 srcType == GL_FLOAT);
2915
2916 switch (srcType) {
2917 case GL_BITMAP:
2918 {
2919 GLubyte *ubsrc = (GLubyte *) src;
2920 if (unpack->LsbFirst) {
2921 GLubyte mask = 1 << (unpack->SkipPixels & 0x7);
2922 GLuint i;
2923 for (i = 0; i < n; i++) {
2924 indexes[i] = (*ubsrc & mask) ? 1 : 0;
2925 if (mask == 128) {
2926 mask = 1;
2927 ubsrc++;
2928 }
2929 else {
2930 mask = mask << 1;
2931 }
2932 }
2933 }
2934 else {
2935 GLubyte mask = 128 >> (unpack->SkipPixels & 0x7);
2936 GLuint i;
2937 for (i = 0; i < n; i++) {
2938 indexes[i] = (*ubsrc & mask) ? 1 : 0;
2939 if (mask == 1) {
2940 mask = 128;
2941 ubsrc++;
2942 }
2943 else {
2944 mask = mask >> 1;
2945 }
2946 }
2947 }
2948 }
2949 break;
2950 case GL_UNSIGNED_BYTE:
2951 {
2952 GLuint i;
2953 const GLubyte *s = (const GLubyte *) src;
2954 for (i = 0; i < n; i++)
2955 indexes[i] = s[i];
2956 }
2957 break;
2958 case GL_BYTE:
2959 {
2960 GLuint i;
2961 const GLbyte *s = (const GLbyte *) src;
2962 for (i = 0; i < n; i++)
2963 indexes[i] = s[i];
2964 }
2965 break;
2966 case GL_UNSIGNED_SHORT:
2967 {
2968 GLuint i;
2969 const GLushort *s = (const GLushort *) src;
2970 if (unpack->SwapBytes) {
2971 for (i = 0; i < n; i++) {
2972 GLushort value = s[i];
2973 SWAP2BYTE(value);
2974 indexes[i] = value;
2975 }
2976 }
2977 else {
2978 for (i = 0; i < n; i++)
2979 indexes[i] = s[i];
2980 }
2981 }
2982 break;
2983 case GL_SHORT:
2984 {
2985 GLuint i;
2986 const GLshort *s = (const GLshort *) src;
2987 if (unpack->SwapBytes) {
2988 for (i = 0; i < n; i++) {
2989 GLshort value = s[i];
2990 SWAP2BYTE(value);
2991 indexes[i] = value;
2992 }
2993 }
2994 else {
2995 for (i = 0; i < n; i++)
2996 indexes[i] = s[i];
2997 }
2998 }
2999 break;
3000 case GL_UNSIGNED_INT:
3001 {
3002 GLuint i;
3003 const GLuint *s = (const GLuint *) src;
3004 if (unpack->SwapBytes) {
3005 for (i = 0; i < n; i++) {
3006 GLuint value = s[i];
3007 SWAP4BYTE(value);
3008 indexes[i] = value;
3009 }
3010 }
3011 else {
3012 for (i = 0; i < n; i++)
3013 indexes[i] = s[i];
3014 }
3015 }
3016 break;
3017 case GL_INT:
3018 {
3019 GLuint i;
3020 const GLint *s = (const GLint *) src;
3021 if (unpack->SwapBytes) {
3022 for (i = 0; i < n; i++) {
3023 GLint value = s[i];
3024 SWAP4BYTE(value);
3025 indexes[i] = value;
3026 }
3027 }
3028 else {
3029 for (i = 0; i < n; i++)
3030 indexes[i] = s[i];
3031 }
3032 }
3033 break;
3034 case GL_FLOAT:
3035 {
3036 GLuint i;
3037 const GLfloat *s = (const GLfloat *) src;
3038 if (unpack->SwapBytes) {
3039 for (i = 0; i < n; i++) {
3040 GLfloat value = s[i];
3041 SWAP4BYTE(value);
3042 indexes[i] = (GLuint) value;
3043 }
3044 }
3045 else {
3046 for (i = 0; i < n; i++)
3047 indexes[i] = (GLuint) s[i];
3048 }
3049 }
3050 break;
3051 case GL_HALF_FLOAT_ARB:
3052 {
3053 GLuint i;
3054 const GLhalfARB *s = (const GLhalfARB *) src;
3055 if (unpack->SwapBytes) {
3056 for (i = 0; i < n; i++) {
3057 GLhalfARB value = s[i];
3058 SWAP2BYTE(value);
3059 indexes[i] = (GLuint) _mesa_half_to_float(value);
3060 }
3061 }
3062 else {
3063 for (i = 0; i < n; i++)
3064 indexes[i] = (GLuint) _mesa_half_to_float(s[i]);
3065 }
3066 }
3067 break;
3068 case GL_UNSIGNED_INT_24_8_EXT:
3069 {
3070 GLuint i;
3071 const GLuint *s = (const GLuint *) src;
3072 if (unpack->SwapBytes) {
3073 for (i = 0; i < n; i++) {
3074 GLuint value = s[i];
3075 SWAP4BYTE(value);
3076 indexes[i] = value & 0xff; /* lower 8 bits */
3077 }
3078 }
3079 else {
3080 for (i = 0; i < n; i++)
3081 indexes[i] = s[i] & 0xff; /* lower 8 bits */
3082 }
3083 }
3084 break;
3085
3086 default:
3087 _mesa_problem(NULL, "bad srcType in extract_uint_indexes");
3088 return;
3089 }
3090 }
3091
3092
3093 /*
3094 * This function extracts floating point RGBA values from arbitrary
3095 * image data. srcFormat and srcType are the format and type parameters
3096 * passed to glDrawPixels, glTexImage[123]D, glTexSubImage[123]D, etc.
3097 *
3098 * Refering to section 3.6.4 of the OpenGL 1.2 spec, this function
3099 * implements the "Conversion to floating point", "Conversion to RGB",
3100 * and "Final Expansion to RGBA" operations.
3101 *
3102 * Args: n - number of pixels
3103 * rgba - output colors
3104 * srcFormat - format of incoming data
3105 * srcType - data type of incoming data
3106 * src - source data pointer
3107 * swapBytes - perform byteswapping of incoming data?
3108 */
3109 static void
3110 extract_float_rgba(GLuint n, GLfloat rgba[][4],
3111 GLenum srcFormat, GLenum srcType, const GLvoid *src,
3112 GLboolean swapBytes)
3113 {
3114 GLint redIndex, greenIndex, blueIndex, alphaIndex;
3115 GLint stride;
3116 GLint rComp, bComp, gComp, aComp;
3117
3118 ASSERT(srcFormat == GL_RED ||
3119 srcFormat == GL_GREEN ||
3120 srcFormat == GL_BLUE ||
3121 srcFormat == GL_ALPHA ||
3122 srcFormat == GL_LUMINANCE ||
3123 srcFormat == GL_LUMINANCE_ALPHA ||
3124 srcFormat == GL_INTENSITY ||
3125 srcFormat == GL_RGB ||
3126 srcFormat == GL_BGR ||
3127 srcFormat == GL_RGBA ||
3128 srcFormat == GL_BGRA ||
3129 srcFormat == GL_ABGR_EXT ||
3130 srcFormat == GL_DUDV_ATI);
3131
3132 ASSERT(srcType == GL_UNSIGNED_BYTE ||
3133 srcType == GL_BYTE ||
3134 srcType == GL_UNSIGNED_SHORT ||
3135 srcType == GL_SHORT ||
3136 srcType == GL_UNSIGNED_INT ||
3137 srcType == GL_INT ||
3138 srcType == GL_HALF_FLOAT_ARB ||
3139 srcType == GL_FLOAT ||
3140 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
3141 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
3142 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
3143 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
3144 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
3145 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
3146 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
3147 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
3148 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
3149 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
3150 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
3151 srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
3152
3153 rComp = gComp = bComp = aComp = -1;
3154
3155 switch (srcFormat) {
3156 case GL_RED:
3157 redIndex = 0;
3158 greenIndex = blueIndex = alphaIndex = -1;
3159 stride = 1;
3160 break;
3161 case GL_GREEN:
3162 greenIndex = 0;
3163 redIndex = blueIndex = alphaIndex = -1;
3164 stride = 1;
3165 break;
3166 case GL_BLUE:
3167 blueIndex = 0;
3168 redIndex = greenIndex = alphaIndex = -1;
3169 stride = 1;
3170 break;
3171 case GL_ALPHA:
3172 redIndex = greenIndex = blueIndex = -1;
3173 alphaIndex = 0;
3174 stride = 1;
3175 break;
3176 case GL_LUMINANCE:
3177 redIndex = greenIndex = blueIndex = 0;
3178 alphaIndex = -1;
3179 stride = 1;
3180 break;
3181 case GL_LUMINANCE_ALPHA:
3182 redIndex = greenIndex = blueIndex = 0;
3183 alphaIndex = 1;
3184 stride = 2;
3185 break;
3186 case GL_INTENSITY:
3187 redIndex = greenIndex = blueIndex = alphaIndex = 0;
3188 stride = 1;
3189 break;
3190 case GL_RGB:
3191 redIndex = 0;
3192 greenIndex = 1;
3193 blueIndex = 2;
3194 alphaIndex = -1;
3195 rComp = 0;
3196 gComp = 1;
3197 bComp = 2;
3198 aComp = 3;
3199 stride = 3;
3200 break;
3201 case GL_BGR:
3202 redIndex = 2;
3203 greenIndex = 1;
3204 blueIndex = 0;
3205 alphaIndex = -1;
3206 rComp = 2;
3207 gComp = 1;
3208 bComp = 0;
3209 aComp = 3;
3210 stride = 3;
3211 break;
3212 case GL_RGBA:
3213 redIndex = 0;
3214 greenIndex = 1;
3215 blueIndex = 2;
3216 alphaIndex = 3;
3217 rComp = 0;
3218 gComp = 1;
3219 bComp = 2;
3220 aComp = 3;
3221 stride = 4;
3222 break;
3223 case GL_BGRA:
3224 redIndex = 2;
3225 greenIndex = 1;
3226 blueIndex = 0;
3227 alphaIndex = 3;
3228 rComp = 2;
3229 gComp = 1;
3230 bComp = 0;
3231 aComp = 3;
3232 stride = 4;
3233 break;
3234 case GL_ABGR_EXT:
3235 redIndex = 3;
3236 greenIndex = 2;
3237 blueIndex = 1;
3238 alphaIndex = 0;
3239 rComp = 3;
3240 gComp = 2;
3241 bComp = 1;
3242 aComp = 0;
3243 stride = 4;
3244 break;
3245 case GL_DUDV_ATI:
3246 redIndex = 0;
3247 greenIndex = 1;
3248 blueIndex = -1;
3249 alphaIndex = -1;
3250 stride = 2;
3251 break;
3252 default:
3253 _mesa_problem(NULL, "bad srcFormat in extract float data");
3254 return;
3255 }
3256
3257
3258 #define PROCESS(INDEX, CHANNEL, DEFAULT, TYPE, CONVERSION) \
3259 if ((INDEX) < 0) { \
3260 GLuint i; \
3261 for (i = 0; i < n; i++) { \
3262 rgba[i][CHANNEL] = DEFAULT; \
3263 } \
3264 } \
3265 else if (swapBytes) { \
3266 const TYPE *s = (const TYPE *) src; \
3267 GLuint i; \
3268 for (i = 0; i < n; i++) { \
3269 TYPE value = s[INDEX]; \
3270 if (sizeof(TYPE) == 2) { \
3271 SWAP2BYTE(value); \
3272 } \
3273 else if (sizeof(TYPE) == 4) { \
3274 SWAP4BYTE(value); \
3275 } \
3276 rgba[i][CHANNEL] = (GLfloat) CONVERSION(value); \
3277 s += stride; \
3278 } \
3279 } \
3280 else { \
3281 const TYPE *s = (const TYPE *) src; \
3282 GLuint i; \
3283 for (i = 0; i < n; i++) { \
3284 rgba[i][CHANNEL] = (GLfloat) CONVERSION(s[INDEX]); \
3285 s += stride; \
3286 } \
3287 }
3288
3289 switch (srcType) {
3290 case GL_UNSIGNED_BYTE:
3291 PROCESS(redIndex, RCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT);
3292 PROCESS(greenIndex, GCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT);
3293 PROCESS(blueIndex, BCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT);
3294 PROCESS(alphaIndex, ACOMP, 1.0F, GLubyte, UBYTE_TO_FLOAT);
3295 break;
3296 case GL_BYTE:
3297 PROCESS(redIndex, RCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT);
3298 PROCESS(greenIndex, GCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT);
3299 PROCESS(blueIndex, BCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT);
3300 PROCESS(alphaIndex, ACOMP, 1.0F, GLbyte, BYTE_TO_FLOAT);
3301 break;
3302 case GL_UNSIGNED_SHORT:
3303 PROCESS(redIndex, RCOMP, 0.0F, GLushort, USHORT_TO_FLOAT);
3304 PROCESS(greenIndex, GCOMP, 0.0F, GLushort, USHORT_TO_FLOAT);
3305 PROCESS(blueIndex, BCOMP, 0.0F, GLushort, USHORT_TO_FLOAT);
3306 PROCESS(alphaIndex, ACOMP, 1.0F, GLushort, USHORT_TO_FLOAT);
3307 break;
3308 case GL_SHORT:
3309 PROCESS(redIndex, RCOMP, 0.0F, GLshort, SHORT_TO_FLOAT);
3310 PROCESS(greenIndex, GCOMP, 0.0F, GLshort, SHORT_TO_FLOAT);
3311 PROCESS(blueIndex, BCOMP, 0.0F, GLshort, SHORT_TO_FLOAT);
3312 PROCESS(alphaIndex, ACOMP, 1.0F, GLshort, SHORT_TO_FLOAT);
3313 break;
3314 case GL_UNSIGNED_INT:
3315 PROCESS(redIndex, RCOMP, 0.0F, GLuint, UINT_TO_FLOAT);
3316 PROCESS(greenIndex, GCOMP, 0.0F, GLuint, UINT_TO_FLOAT);
3317 PROCESS(blueIndex, BCOMP, 0.0F, GLuint, UINT_TO_FLOAT);
3318 PROCESS(alphaIndex, ACOMP, 1.0F, GLuint, UINT_TO_FLOAT);
3319 break;
3320 case GL_INT:
3321 PROCESS(redIndex, RCOMP, 0.0F, GLint, INT_TO_FLOAT);
3322 PROCESS(greenIndex, GCOMP, 0.0F, GLint, INT_TO_FLOAT);
3323 PROCESS(blueIndex, BCOMP, 0.0F, GLint, INT_TO_FLOAT);
3324 PROCESS(alphaIndex, ACOMP, 1.0F, GLint, INT_TO_FLOAT);
3325 break;
3326 case GL_FLOAT:
3327 PROCESS(redIndex, RCOMP, 0.0F, GLfloat, (GLfloat));
3328 PROCESS(greenIndex, GCOMP, 0.0F, GLfloat, (GLfloat));
3329 PROCESS(blueIndex, BCOMP, 0.0F, GLfloat, (GLfloat));
3330 PROCESS(alphaIndex, ACOMP, 1.0F, GLfloat, (GLfloat));
3331 break;
3332 case GL_HALF_FLOAT_ARB:
3333 PROCESS(redIndex, RCOMP, 0.0F, GLhalfARB, _mesa_half_to_float);
3334 PROCESS(greenIndex, GCOMP, 0.0F, GLhalfARB, _mesa_half_to_float);
3335 PROCESS(blueIndex, BCOMP, 0.0F, GLhalfARB, _mesa_half_to_float);
3336 PROCESS(alphaIndex, ACOMP, 1.0F, GLhalfARB, _mesa_half_to_float);
3337 break;
3338 case GL_UNSIGNED_BYTE_3_3_2:
3339 {
3340 const GLubyte *ubsrc = (const GLubyte *) src;
3341 GLuint i;
3342 for (i = 0; i < n; i ++) {
3343 GLubyte p = ubsrc[i];
3344 rgba[i][rComp] = ((p >> 5) ) * (1.0F / 7.0F);
3345 rgba[i][gComp] = ((p >> 2) & 0x7) * (1.0F / 7.0F);
3346 rgba[i][bComp] = ((p ) & 0x3) * (1.0F / 3.0F);
3347 rgba[i][aComp] = 1.0F;
3348 }
3349 }
3350 break;
3351 case GL_UNSIGNED_BYTE_2_3_3_REV:
3352 {
3353 const GLubyte *ubsrc = (const GLubyte *) src;
3354 GLuint i;
3355 for (i = 0; i < n; i ++) {
3356 GLubyte p = ubsrc[i];
3357 rgba[i][rComp] = ((p ) & 0x7) * (1.0F / 7.0F);
3358 rgba[i][gComp] = ((p >> 3) & 0x7) * (1.0F / 7.0F);
3359 rgba[i][bComp] = ((p >> 6) ) * (1.0F / 3.0F);
3360 rgba[i][aComp] = 1.0F;
3361 }
3362 }
3363 break;
3364 case GL_UNSIGNED_SHORT_5_6_5:
3365 if (swapBytes) {
3366 const GLushort *ussrc = (const GLushort *) src;
3367 GLuint i;
3368 for (i = 0; i < n; i ++) {
3369 GLushort p = ussrc[i];
3370 SWAP2BYTE(p);
3371 rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F);
3372 rgba[i][gComp] = ((p >> 5) & 0x3f) * (1.0F / 63.0F);
3373 rgba[i][bComp] = ((p ) & 0x1f) * (1.0F / 31.0F);
3374 rgba[i][aComp] = 1.0F;
3375 }
3376 }
3377 else {
3378 const GLushort *ussrc = (const GLushort *) src;
3379 GLuint i;
3380 for (i = 0; i < n; i ++) {
3381 GLushort p = ussrc[i];
3382 rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F);
3383 rgba[i][gComp] = ((p >> 5) & 0x3f) * (1.0F / 63.0F);
3384 rgba[i][bComp] = ((p ) & 0x1f) * (1.0F / 31.0F);
3385 rgba[i][aComp] = 1.0F;
3386 }
3387 }
3388 break;
3389 case GL_UNSIGNED_SHORT_5_6_5_REV:
3390 if (swapBytes) {
3391 const GLushort *ussrc = (const GLushort *) src;
3392 GLuint i;
3393 for (i = 0; i < n; i ++) {
3394 GLushort p = ussrc[i];
3395 SWAP2BYTE(p);
3396 rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F);
3397 rgba[i][gComp] = ((p >> 5) & 0x3f) * (1.0F / 63.0F);
3398 rgba[i][bComp] = ((p >> 11) ) * (1.0F / 31.0F);
3399 rgba[i][aComp] = 1.0F;
3400 }
3401 }
3402 else {
3403 const GLushort *ussrc = (const GLushort *) src;
3404 GLuint i;
3405 for (i = 0; i < n; i ++) {
3406 GLushort p = ussrc[i];
3407 rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F);
3408 rgba[i][gComp] = ((p >> 5) & 0x3f) * (1.0F / 63.0F);
3409 rgba[i][bComp] = ((p >> 11) ) * (1.0F / 31.0F);
3410 rgba[i][aComp] = 1.0F;
3411 }
3412 }
3413 break;
3414 case GL_UNSIGNED_SHORT_4_4_4_4:
3415 if (swapBytes) {
3416 const GLushort *ussrc = (const GLushort *) src;
3417 GLuint i;
3418 for (i = 0; i < n; i ++) {
3419 GLushort p = ussrc[i];
3420 SWAP2BYTE(p);
3421 rgba[i][rComp] = ((p >> 12) ) * (1.0F / 15.0F);
3422 rgba[i][gComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F);
3423 rgba[i][bComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F);
3424 rgba[i][aComp] = ((p ) & 0xf) * (1.0F / 15.0F);
3425 }
3426 }
3427 else {
3428 const GLushort *ussrc = (const GLushort *) src;
3429 GLuint i;
3430 for (i = 0; i < n; i ++) {
3431 GLushort p = ussrc[i];
3432 rgba[i][rComp] = ((p >> 12) ) * (1.0F / 15.0F);
3433 rgba[i][gComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F);
3434 rgba[i][bComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F);
3435 rgba[i][aComp] = ((p ) & 0xf) * (1.0F / 15.0F);
3436 }
3437 }
3438 break;
3439 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
3440 if (swapBytes) {
3441 const GLushort *ussrc = (const GLushort *) src;
3442 GLuint i;
3443 for (i = 0; i < n; i ++) {
3444 GLushort p = ussrc[i];
3445 SWAP2BYTE(p);
3446 rgba[i][rComp] = ((p ) & 0xf) * (1.0F / 15.0F);
3447 rgba[i][gComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F);
3448 rgba[i][bComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F);
3449 rgba[i][aComp] = ((p >> 12) ) * (1.0F / 15.0F);
3450 }
3451 }
3452 else {
3453 const GLushort *ussrc = (const GLushort *) src;
3454 GLuint i;
3455 for (i = 0; i < n; i ++) {
3456 GLushort p = ussrc[i];
3457 rgba[i][rComp] = ((p ) & 0xf) * (1.0F / 15.0F);
3458 rgba[i][gComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F);
3459 rgba[i][bComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F);
3460 rgba[i][aComp] = ((p >> 12) ) * (1.0F / 15.0F);
3461 }
3462 }
3463 break;
3464 case GL_UNSIGNED_SHORT_5_5_5_1:
3465 if (swapBytes) {
3466 const GLushort *ussrc = (const GLushort *) src;
3467 GLuint i;
3468 for (i = 0; i < n; i ++) {
3469 GLushort p = ussrc[i];
3470 SWAP2BYTE(p);
3471 rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F);
3472 rgba[i][gComp] = ((p >> 6) & 0x1f) * (1.0F / 31.0F);
3473 rgba[i][bComp] = ((p >> 1) & 0x1f) * (1.0F / 31.0F);
3474 rgba[i][aComp] = ((p ) & 0x1) * (1.0F / 1.0F);
3475 }
3476 }
3477 else {
3478 const GLushort *ussrc = (const GLushort *) src;
3479 GLuint i;
3480 for (i = 0; i < n; i ++) {
3481 GLushort p = ussrc[i];
3482 rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F);
3483 rgba[i][gComp] = ((p >> 6) & 0x1f) * (1.0F / 31.0F);
3484 rgba[i][bComp] = ((p >> 1) & 0x1f) * (1.0F / 31.0F);
3485 rgba[i][aComp] = ((p ) & 0x1) * (1.0F / 1.0F);
3486 }
3487 }
3488 break;
3489 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
3490 if (swapBytes) {
3491 const GLushort *ussrc = (const GLushort *) src;
3492 GLuint i;
3493 for (i = 0; i < n; i ++) {
3494 GLushort p = ussrc[i];
3495 SWAP2BYTE(p);
3496 rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F);
3497 rgba[i][gComp] = ((p >> 5) & 0x1f) * (1.0F / 31.0F);
3498 rgba[i][bComp] = ((p >> 10) & 0x1f) * (1.0F / 31.0F);
3499 rgba[i][aComp] = ((p >> 15) ) * (1.0F / 1.0F);
3500 }
3501 }
3502 else {
3503 const GLushort *ussrc = (const GLushort *) src;
3504 GLuint i;
3505 for (i = 0; i < n; i ++) {
3506 GLushort p = ussrc[i];
3507 rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F);
3508 rgba[i][gComp] = ((p >> 5) & 0x1f) * (1.0F / 31.0F);
3509 rgba[i][bComp] = ((p >> 10) & 0x1f) * (1.0F / 31.0F);
3510 rgba[i][aComp] = ((p >> 15) ) * (1.0F / 1.0F);
3511 }
3512 }
3513 break;
3514 case GL_UNSIGNED_INT_8_8_8_8:
3515 if (swapBytes) {
3516 const GLuint *uisrc = (const GLuint *) src;
3517 GLuint i;
3518 for (i = 0; i < n; i ++) {
3519 GLuint p = uisrc[i];
3520 rgba[i][rComp] = UBYTE_TO_FLOAT((p ) & 0xff);
3521 rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
3522 rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
3523 rgba[i][aComp] = UBYTE_TO_FLOAT((p >> 24) );
3524 }
3525 }
3526 else {
3527 const GLuint *uisrc = (const GLuint *) src;
3528 GLuint i;
3529 for (i = 0; i < n; i ++) {
3530 GLuint p = uisrc[i];
3531 rgba[i][rComp] = UBYTE_TO_FLOAT((p >> 24) );
3532 rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
3533 rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
3534 rgba[i][aComp] = UBYTE_TO_FLOAT((p ) & 0xff);
3535 }
3536 }
3537 break;
3538 case GL_UNSIGNED_INT_8_8_8_8_REV:
3539 if (swapBytes) {
3540 const GLuint *uisrc = (const GLuint *) src;
3541 GLuint i;
3542 for (i = 0; i < n; i ++) {
3543 GLuint p = uisrc[i];
3544 rgba[i][rComp] = UBYTE_TO_FLOAT((p >> 24) );
3545 rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
3546 rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
3547 rgba[i][aComp] = UBYTE_TO_FLOAT((p ) & 0xff);
3548 }
3549 }
3550 else {
3551 const GLuint *uisrc = (const GLuint *) src;
3552 GLuint i;
3553 for (i = 0; i < n; i ++) {
3554 GLuint p = uisrc[i];
3555 rgba[i][rComp] = UBYTE_TO_FLOAT((p ) & 0xff);
3556 rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
3557 rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
3558 rgba[i][aComp] = UBYTE_TO_FLOAT((p >> 24) );
3559 }
3560 }
3561 break;
3562 case GL_UNSIGNED_INT_10_10_10_2:
3563 if (swapBytes) {
3564 const GLuint *uisrc = (const GLuint *) src;
3565 GLuint i;
3566 for (i = 0; i < n; i ++) {
3567 GLuint p = uisrc[i];
3568 SWAP4BYTE(p);
3569 rgba[i][rComp] = ((p >> 22) ) * (1.0F / 1023.0F);
3570 rgba[i][gComp] = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F);
3571 rgba[i][bComp] = ((p >> 2) & 0x3ff) * (1.0F / 1023.0F);
3572 rgba[i][aComp] = ((p ) & 0x3 ) * (1.0F / 3.0F);
3573 }
3574 }
3575 else {
3576 const GLuint *uisrc = (const GLuint *) src;
3577 GLuint i;
3578 for (i = 0; i < n; i ++) {
3579 GLuint p = uisrc[i];
3580 rgba[i][rComp] = ((p >> 22) ) * (1.0F / 1023.0F);
3581 rgba[i][gComp] = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F);
3582 rgba[i][bComp] = ((p >> 2) & 0x3ff) * (1.0F / 1023.0F);
3583 rgba[i][aComp] = ((p ) & 0x3 ) * (1.0F / 3.0F);
3584 }
3585 }
3586 break;
3587 case GL_UNSIGNED_INT_2_10_10_10_REV:
3588 if (swapBytes) {
3589 const GLuint *uisrc = (const GLuint *) src;
3590 GLuint i;
3591 for (i = 0; i < n; i ++) {
3592 GLuint p = uisrc[i];
3593 SWAP4BYTE(p);
3594 rgba[i][rComp] = ((p ) & 0x3ff) * (1.0F / 1023.0F);
3595 rgba[i][gComp] = ((p >> 10) & 0x3ff) * (1.0F / 1023.0F);
3596 rgba[i][bComp] = ((p >> 20) & 0x3ff) * (1.0F / 1023.0F);
3597 rgba[i][aComp] = ((p >> 30) ) * (1.0F / 3.0F);
3598 }
3599 }
3600 else {
3601 const GLuint *uisrc = (const GLuint *) src;
3602 GLuint i;
3603 for (i = 0; i < n; i ++) {
3604 GLuint p = uisrc[i];
3605 rgba[i][rComp] = ((p ) & 0x3ff) * (1.0F / 1023.0F);
3606 rgba[i][gComp] = ((p >> 10) & 0x3ff) * (1.0F / 1023.0F);
3607 rgba[i][bComp] = ((p >> 20) & 0x3ff) * (1.0F / 1023.0F);
3608 rgba[i][aComp] = ((p >> 30) ) * (1.0F / 3.0F);
3609 }
3610 }
3611 break;
3612 default:
3613 _mesa_problem(NULL, "bad srcType in extract float data");
3614 break;
3615 }
3616 }
3617
3618
3619 /*
3620 * Unpack a row of color image data from a client buffer according to
3621 * the pixel unpacking parameters.
3622 * Return GLchan values in the specified dest image format.
3623 * This is used by glDrawPixels and glTexImage?D().
3624 * \param ctx - the context
3625 * n - number of pixels in the span
3626 * dstFormat - format of destination color array
3627 * dest - the destination color array
3628 * srcFormat - source image format
3629 * srcType - source image data type
3630 * source - source image pointer
3631 * srcPacking - pixel unpacking parameters
3632 * transferOps - bitmask of IMAGE_*_BIT values of operations to apply
3633 *
3634 * XXX perhaps expand this to process whole images someday.
3635 */
3636 void
3637 _mesa_unpack_color_span_chan( GLcontext *ctx,
3638 GLuint n, GLenum dstFormat, GLchan dest[],
3639 GLenum srcFormat, GLenum srcType,
3640 const GLvoid *source,
3641 const struct gl_pixelstore_attrib *srcPacking,
3642 GLbitfield transferOps )
3643 {
3644 ASSERT(dstFormat == GL_ALPHA ||
3645 dstFormat == GL_LUMINANCE ||
3646 dstFormat == GL_LUMINANCE_ALPHA ||
3647 dstFormat == GL_INTENSITY ||
3648 dstFormat == GL_RGB ||
3649 dstFormat == GL_RGBA ||
3650 dstFormat == GL_COLOR_INDEX);
3651
3652 ASSERT(srcFormat == GL_RED ||
3653 srcFormat == GL_GREEN ||
3654 srcFormat == GL_BLUE ||
3655 srcFormat == GL_ALPHA ||
3656 srcFormat == GL_LUMINANCE ||
3657 srcFormat == GL_LUMINANCE_ALPHA ||
3658 srcFormat == GL_INTENSITY ||
3659 srcFormat == GL_RGB ||
3660 srcFormat == GL_BGR ||
3661 srcFormat == GL_RGBA ||
3662 srcFormat == GL_BGRA ||
3663 srcFormat == GL_ABGR_EXT ||
3664 srcFormat == GL_COLOR_INDEX);
3665
3666 ASSERT(srcType == GL_BITMAP ||
3667 srcType == GL_UNSIGNED_BYTE ||
3668 srcType == GL_BYTE ||
3669 srcType == GL_UNSIGNED_SHORT ||
3670 srcType == GL_SHORT ||
3671 srcType == GL_UNSIGNED_INT ||
3672 srcType == GL_INT ||
3673 srcType == GL_HALF_FLOAT_ARB ||
3674 srcType == GL_FLOAT ||
3675 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
3676 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
3677 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
3678 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
3679 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
3680 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
3681 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
3682 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
3683 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
3684 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
3685 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
3686 srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
3687
3688 /* Try simple cases first */
3689 if (transferOps == 0) {
3690 if (srcType == CHAN_TYPE) {
3691 if (dstFormat == GL_RGBA) {
3692 if (srcFormat == GL_RGBA) {
3693 _mesa_memcpy( dest, source, n * 4 * sizeof(GLchan) );
3694 return;
3695 }
3696 else if (srcFormat == GL_RGB) {
3697 GLuint i;
3698 const GLchan *src = (const GLchan *) source;
3699 GLchan *dst = dest;
3700 for (i = 0; i < n; i++) {
3701 dst[0] = src[0];
3702 dst[1] = src[1];
3703 dst[2] = src[2];
3704 dst[3] = CHAN_MAX;
3705 src += 3;
3706 dst += 4;
3707 }
3708 return;
3709 }
3710 }
3711 else if (dstFormat == GL_RGB) {
3712 if (srcFormat == GL_RGB) {
3713 _mesa_memcpy( dest, source, n * 3 * sizeof(GLchan) );
3714 return;
3715 }
3716 else if (srcFormat == GL_RGBA) {
3717 GLuint i;
3718 const GLchan *src = (const GLchan *) source;
3719 GLchan *dst = dest;
3720 for (i = 0; i < n; i++) {
3721 dst[0] = src[0];
3722 dst[1] = src[1];
3723 dst[2] = src[2];
3724 src += 4;
3725 dst += 3;
3726 }
3727 return;
3728 }
3729 }
3730 else if (dstFormat == srcFormat) {
3731 GLint comps = _mesa_components_in_format(srcFormat);
3732 assert(comps > 0);
3733 _mesa_memcpy( dest, source, n * comps * sizeof(GLchan) );
3734 return;
3735 }
3736 }
3737 /*
3738 * Common situation, loading 8bit RGBA/RGB source images
3739 * into 16/32 bit destination. (OSMesa16/32)
3740 */
3741 else if (srcType == GL_UNSIGNED_BYTE) {
3742 if (dstFormat == GL_RGBA) {
3743 if (srcFormat == GL_RGB) {
3744 GLuint i;
3745 const GLubyte *src = (const GLubyte *) source;
3746 GLchan *dst = dest;
3747 for (i = 0; i < n; i++) {
3748 dst[0] = UBYTE_TO_CHAN(src[0]);
3749 dst[1] = UBYTE_TO_CHAN(src[1]);
3750 dst[2] = UBYTE_TO_CHAN(src[2]);
3751 dst[3] = CHAN_MAX;
3752 src += 3;
3753 dst += 4;
3754 }
3755 return;
3756 }
3757 else if (srcFormat == GL_RGBA) {
3758 GLuint i;
3759 const GLubyte *src = (const GLubyte *) source;
3760 GLchan *dst = dest;
3761 for (i = 0; i < n; i++) {
3762 dst[0] = UBYTE_TO_CHAN(src[0]);
3763 dst[1] = UBYTE_TO_CHAN(src[1]);
3764 dst[2] = UBYTE_TO_CHAN(src[2]);
3765 dst[3] = UBYTE_TO_CHAN(src[3]);
3766 src += 4;
3767 dst += 4;
3768 }
3769 return;
3770 }
3771 }
3772 else if (dstFormat == GL_RGB) {
3773 if (srcFormat == GL_RGB) {
3774 GLuint i;
3775 const GLubyte *src = (const GLubyte *) source;
3776 GLchan *dst = dest;
3777 for (i = 0; i < n; i++) {
3778 dst[0] = UBYTE_TO_CHAN(src[0]);
3779 dst[1] = UBYTE_TO_CHAN(src[1]);
3780 dst[2] = UBYTE_TO_CHAN(src[2]);
3781 src += 3;
3782 dst += 3;
3783 }
3784 return;
3785 }
3786 else if (srcFormat == GL_RGBA) {
3787 GLuint i;
3788 const GLubyte *src = (const GLubyte *) source;
3789 GLchan *dst = dest;
3790 for (i = 0; i < n; i++) {
3791 dst[0] = UBYTE_TO_CHAN(src[0]);
3792 dst[1] = UBYTE_TO_CHAN(src[1]);
3793 dst[2] = UBYTE_TO_CHAN(src[2]);
3794 src += 4;
3795 dst += 3;
3796 }
3797 return;
3798 }
3799 }
3800 }
3801 }
3802
3803
3804 /* general solution begins here */
3805 {
3806 GLint dstComponents;
3807 GLint dstRedIndex, dstGreenIndex, dstBlueIndex, dstAlphaIndex;
3808 GLint dstLuminanceIndex, dstIntensityIndex;
3809 GLfloat rgba[MAX_WIDTH][4];
3810
3811 dstComponents = _mesa_components_in_format( dstFormat );
3812 /* source & dest image formats should have been error checked by now */
3813 assert(dstComponents > 0);
3814
3815 /*
3816 * Extract image data and convert to RGBA floats
3817 */
3818 assert(n <= MAX_WIDTH);
3819 if (srcFormat == GL_COLOR_INDEX) {
3820 GLuint indexes[MAX_WIDTH];
3821 extract_uint_indexes(n, indexes, srcFormat, srcType, source,
3822 srcPacking);
3823
3824 if (dstFormat == GL_COLOR_INDEX) {
3825 GLuint i;
3826 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
3827 /* convert to GLchan and return */
3828 for (i = 0; i < n; i++) {
3829 dest[i] = (GLchan) (indexes[i] & 0xff);
3830 }
3831 return;
3832 }
3833 else {
3834 /* Convert indexes to RGBA */
3835 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
3836 shift_and_offset_ci(ctx, n, indexes);
3837 }
3838 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
3839 }
3840
3841 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
3842 * with color indexes.
3843 */
3844 transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT);
3845 }
3846 else {
3847 /* non-color index data */
3848 extract_float_rgba(n, rgba, srcFormat, srcType, source,
3849 srcPacking->SwapBytes);
3850 }
3851
3852 /* Need to clamp if returning GLubytes or GLushorts */
3853 #if CHAN_TYPE != GL_FLOAT
3854 transferOps |= IMAGE_CLAMP_BIT;
3855 #endif
3856
3857 if (transferOps) {
3858 _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
3859 }
3860
3861 /* Now determine which color channels we need to produce.
3862 * And determine the dest index (offset) within each color tuple.
3863 */
3864 switch (dstFormat) {
3865 case GL_ALPHA:
3866 dstAlphaIndex = 0;
3867 dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
3868 dstLuminanceIndex = dstIntensityIndex = -1;
3869 break;
3870 case GL_LUMINANCE:
3871 dstLuminanceIndex = 0;
3872 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
3873 dstIntensityIndex = -1;
3874 break;
3875 case GL_LUMINANCE_ALPHA:
3876 dstLuminanceIndex = 0;
3877 dstAlphaIndex = 1;
3878 dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
3879 dstIntensityIndex = -1;
3880 break;
3881 case GL_INTENSITY:
3882 dstIntensityIndex = 0;
3883 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
3884 dstLuminanceIndex = -1;
3885 break;
3886 case GL_RGB:
3887 dstRedIndex = 0;
3888 dstGreenIndex = 1;
3889 dstBlueIndex = 2;
3890 dstAlphaIndex = dstLuminanceIndex = dstIntensityIndex = -1;
3891 break;
3892 case GL_RGBA:
3893 dstRedIndex = 0;
3894 dstGreenIndex = 1;
3895 dstBlueIndex = 2;
3896 dstAlphaIndex = 3;
3897 dstLuminanceIndex = dstIntensityIndex = -1;
3898 break;
3899 default:
3900 _mesa_problem(ctx, "bad dstFormat in _mesa_unpack_chan_span()");
3901 return;
3902 }
3903
3904
3905 /* Now return the GLchan data in the requested dstFormat */
3906
3907 if (dstRedIndex >= 0) {
3908 GLchan *dst = dest;
3909 GLuint i;
3910 for (i = 0; i < n; i++) {
3911 CLAMPED_FLOAT_TO_CHAN(dst[dstRedIndex], rgba[i][RCOMP]);
3912 dst += dstComponents;
3913 }
3914 }
3915
3916 if (dstGreenIndex >= 0) {
3917 GLchan *dst = dest;
3918 GLuint i;
3919 for (i = 0; i < n; i++) {
3920 CLAMPED_FLOAT_TO_CHAN(dst[dstGreenIndex], rgba[i][GCOMP]);
3921 dst += dstComponents;
3922 }
3923 }
3924
3925 if (dstBlueIndex >= 0) {
3926 GLchan *dst = dest;
3927 GLuint i;
3928 for (i = 0; i < n; i++) {
3929 CLAMPED_FLOAT_TO_CHAN(dst[dstBlueIndex], rgba[i][BCOMP]);
3930 dst += dstComponents;
3931 }
3932 }
3933
3934 if (dstAlphaIndex >= 0) {
3935 GLchan *dst = dest;
3936 GLuint i;
3937 for (i = 0; i < n; i++) {
3938 CLAMPED_FLOAT_TO_CHAN(dst[dstAlphaIndex], rgba[i][ACOMP]);
3939 dst += dstComponents;
3940 }
3941 }
3942
3943 if (dstIntensityIndex >= 0) {
3944 GLchan *dst = dest;
3945 GLuint i;
3946 assert(dstIntensityIndex == 0);
3947 assert(dstComponents == 1);
3948 for (i = 0; i < n; i++) {
3949 /* Intensity comes from red channel */
3950 CLAMPED_FLOAT_TO_CHAN(dst[i], rgba[i][RCOMP]);
3951 }
3952 }
3953
3954 if (dstLuminanceIndex >= 0) {
3955 GLchan *dst = dest;
3956 GLuint i;
3957 assert(dstLuminanceIndex == 0);
3958 for (i = 0; i < n; i++) {
3959 /* Luminance comes from red channel */
3960 CLAMPED_FLOAT_TO_CHAN(dst[0], rgba[i][RCOMP]);
3961 dst += dstComponents;
3962 }
3963 }
3964 }
3965 }
3966
3967
3968 /**
3969 * Same as _mesa_unpack_color_span_chan(), but return GLfloat data
3970 * instead of GLchan.
3971 */
3972 void
3973 _mesa_unpack_color_span_float( GLcontext *ctx,
3974 GLuint n, GLenum dstFormat, GLfloat dest[],
3975 GLenum srcFormat, GLenum srcType,
3976 const GLvoid *source,
3977 const struct gl_pixelstore_attrib *srcPacking,
3978 GLbitfield transferOps )
3979 {
3980 ASSERT(dstFormat == GL_ALPHA ||
3981 dstFormat == GL_LUMINANCE ||
3982 dstFormat == GL_LUMINANCE_ALPHA ||
3983 dstFormat == GL_INTENSITY ||
3984 dstFormat == GL_RGB ||
3985 dstFormat == GL_RGBA ||
3986 dstFormat == GL_COLOR_INDEX);
3987
3988 ASSERT(srcFormat == GL_RED ||
3989 srcFormat == GL_GREEN ||
3990 srcFormat == GL_BLUE ||
3991 srcFormat == GL_ALPHA ||
3992 srcFormat == GL_LUMINANCE ||
3993 srcFormat == GL_LUMINANCE_ALPHA ||
3994 srcFormat == GL_INTENSITY ||
3995 srcFormat == GL_RGB ||
3996 srcFormat == GL_BGR ||
3997 srcFormat == GL_RGBA ||
3998 srcFormat == GL_BGRA ||
3999 srcFormat == GL_ABGR_EXT ||
4000 srcFormat == GL_COLOR_INDEX);
4001
4002 ASSERT(srcType == GL_BITMAP ||
4003 srcType == GL_UNSIGNED_BYTE ||
4004 srcType == GL_BYTE ||
4005 srcType == GL_UNSIGNED_SHORT ||
4006 srcType == GL_SHORT ||
4007 srcType == GL_UNSIGNED_INT ||
4008 srcType == GL_INT ||
4009 srcType == GL_HALF_FLOAT_ARB ||
4010 srcType == GL_FLOAT ||
4011 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
4012 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
4013 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
4014 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
4015 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
4016 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
4017 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
4018 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
4019 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
4020 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
4021 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
4022 srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
4023
4024 /* general solution, no special cases, yet */
4025 {
4026 GLint dstComponents;
4027 GLint dstRedIndex, dstGreenIndex, dstBlueIndex, dstAlphaIndex;
4028 GLint dstLuminanceIndex, dstIntensityIndex;
4029 GLfloat rgba[MAX_WIDTH][4];
4030
4031 dstComponents = _mesa_components_in_format( dstFormat );
4032 /* source & dest image formats should have been error checked by now */
4033 assert(dstComponents > 0);
4034
4035 /*
4036 * Extract image data and convert to RGBA floats
4037 */
4038 assert(n <= MAX_WIDTH);
4039 if (srcFormat == GL_COLOR_INDEX) {
4040 GLuint indexes[MAX_WIDTH];
4041 extract_uint_indexes(n, indexes, srcFormat, srcType, source,
4042 srcPacking);
4043
4044 if (dstFormat == GL_COLOR_INDEX) {
4045 GLuint i;
4046 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
4047 /* convert to GLchan and return */
4048 for (i = 0; i < n; i++) {
4049 dest[i] = (GLchan) (indexes[i] & 0xff);
4050 }
4051 return;
4052 }
4053 else {
4054 /* Convert indexes to RGBA */
4055 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
4056 shift_and_offset_ci(ctx, n, indexes);
4057 }
4058 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
4059 }
4060
4061 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
4062 * with color indexes.
4063 */
4064 transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT);
4065 }
4066 else {
4067 /* non-color index data */
4068 extract_float_rgba(n, rgba, srcFormat, srcType, source,
4069 srcPacking->SwapBytes);
4070 }
4071
4072 if (transferOps) {
4073 _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
4074 }
4075
4076 /* Now determine which color channels we need to produce.
4077 * And determine the dest index (offset) within each color tuple.
4078 */
4079 switch (dstFormat) {
4080 case GL_ALPHA:
4081 dstAlphaIndex = 0;
4082 dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
4083 dstLuminanceIndex = dstIntensityIndex = -1;
4084 break;
4085 case GL_LUMINANCE:
4086 dstLuminanceIndex = 0;
4087 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
4088 dstIntensityIndex = -1;
4089 break;
4090 case GL_LUMINANCE_ALPHA:
4091 dstLuminanceIndex = 0;
4092 dstAlphaIndex = 1;
4093 dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
4094 dstIntensityIndex = -1;
4095 break;
4096 case GL_INTENSITY:
4097 dstIntensityIndex = 0;
4098 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
4099 dstLuminanceIndex = -1;
4100 break;
4101 case GL_RGB:
4102 dstRedIndex = 0;
4103 dstGreenIndex = 1;
4104 dstBlueIndex = 2;
4105 dstAlphaIndex = dstLuminanceIndex = dstIntensityIndex = -1;
4106 break;
4107 case GL_RGBA:
4108 dstRedIndex = 0;
4109 dstGreenIndex = 1;
4110 dstBlueIndex = 2;
4111 dstAlphaIndex = 3;
4112 dstLuminanceIndex = dstIntensityIndex = -1;
4113 break;
4114 default:
4115 _mesa_problem(ctx, "bad dstFormat in _mesa_unpack_color_span_float()");
4116 return;
4117 }
4118
4119 /* Now pack results in the requested dstFormat */
4120 if (dstRedIndex >= 0) {
4121 GLfloat *dst = dest;
4122 GLuint i;
4123 for (i = 0; i < n; i++) {
4124 dst[dstRedIndex] = rgba[i][RCOMP];
4125 dst += dstComponents;
4126 }
4127 }
4128
4129 if (dstGreenIndex >= 0) {
4130 GLfloat *dst = dest;
4131 GLuint i;
4132 for (i = 0; i < n; i++) {
4133 dst[dstGreenIndex] = rgba[i][GCOMP];
4134 dst += dstComponents;
4135 }
4136 }
4137
4138 if (dstBlueIndex >= 0) {
4139 GLfloat *dst = dest;
4140 GLuint i;
4141 for (i = 0; i < n; i++) {
4142 dst[dstBlueIndex] = rgba[i][BCOMP];
4143 dst += dstComponents;
4144 }
4145 }
4146
4147 if (dstAlphaIndex >= 0) {
4148 GLfloat *dst = dest;
4149 GLuint i;
4150 for (i = 0; i < n; i++) {
4151 dst[dstAlphaIndex] = rgba[i][ACOMP];
4152 dst += dstComponents;
4153 }
4154 }
4155
4156 if (dstIntensityIndex >= 0) {
4157 GLfloat *dst = dest;
4158 GLuint i;
4159 assert(dstIntensityIndex == 0);
4160 assert(dstComponents == 1);
4161 for (i = 0; i < n; i++) {
4162 /* Intensity comes from red channel */
4163 dst[i] = rgba[i][RCOMP];
4164 }
4165 }
4166
4167 if (dstLuminanceIndex >= 0) {
4168 GLfloat *dst = dest;
4169 GLuint i;
4170 assert(dstLuminanceIndex == 0);
4171 for (i = 0; i < n; i++) {
4172 /* Luminance comes from red channel */
4173 dst[0] = rgba[i][RCOMP];
4174 dst += dstComponents;
4175 }
4176 }
4177 }
4178 }
4179
4180 /**
4181 * Similar to _mesa_unpack_color_span_float(), but for dudv data instead of rgba,
4182 * directly return GLbyte data, no transfer ops apply.
4183 */
4184 void
4185 _mesa_unpack_dudv_span_byte( GLcontext *ctx,
4186 GLuint n, GLenum dstFormat, GLbyte dest[],
4187 GLenum srcFormat, GLenum srcType,
4188 const GLvoid *source,
4189 const struct gl_pixelstore_attrib *srcPacking,
4190 GLbitfield transferOps )
4191 {
4192 ASSERT(dstFormat == GL_DUDV_ATI);
4193 ASSERT(srcFormat == GL_DUDV_ATI);
4194
4195 ASSERT(srcType == GL_UNSIGNED_BYTE ||
4196 srcType == GL_BYTE ||
4197 srcType == GL_UNSIGNED_SHORT ||
4198 srcType == GL_SHORT ||
4199 srcType == GL_UNSIGNED_INT ||
4200 srcType == GL_INT ||
4201 srcType == GL_HALF_FLOAT_ARB ||
4202 srcType == GL_FLOAT);
4203
4204 /* general solution */
4205 {
4206 GLint dstComponents;
4207 GLfloat rgba[MAX_WIDTH][4];
4208 GLbyte *dst = dest;
4209 GLuint i;
4210
4211 dstComponents = _mesa_components_in_format( dstFormat );
4212 /* source & dest image formats should have been error checked by now */
4213 assert(dstComponents > 0);
4214
4215 /*
4216 * Extract image data and convert to RGBA floats
4217 */
4218 assert(n <= MAX_WIDTH);
4219 extract_float_rgba(n, rgba, srcFormat, srcType, source,
4220 srcPacking->SwapBytes);
4221
4222
4223 /* Now determine which color channels we need to produce.
4224 * And determine the dest index (offset) within each color tuple.
4225 */
4226
4227 /* Now pack results in the requested dstFormat */
4228 for (i = 0; i < n; i++) {
4229 /* not sure - need clamp[-1,1] here? */
4230 dst[0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
4231 dst[1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
4232 dst += dstComponents;
4233 }
4234 }
4235 }
4236
4237 /*
4238 * Unpack a row of color index data from a client buffer according to
4239 * the pixel unpacking parameters.
4240 * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.
4241 *
4242 * Args: ctx - the context
4243 * n - number of pixels
4244 * dstType - destination data type
4245 * dest - destination array
4246 * srcType - source pixel type
4247 * source - source data pointer
4248 * srcPacking - pixel unpacking parameters
4249 * transferOps - the pixel transfer operations to apply
4250 */
4251 void
4252 _mesa_unpack_index_span( const GLcontext *ctx, GLuint n,
4253 GLenum dstType, GLvoid *dest,
4254 GLenum srcType, const GLvoid *source,
4255 const struct gl_pixelstore_attrib *srcPacking,
4256 GLbitfield transferOps )
4257 {
4258 ASSERT(srcType == GL_BITMAP ||
4259 srcType == GL_UNSIGNED_BYTE ||
4260 srcType == GL_BYTE ||
4261 srcType == GL_UNSIGNED_SHORT ||
4262 srcType == GL_SHORT ||
4263 srcType == GL_UNSIGNED_INT ||
4264 srcType == GL_INT ||
4265 srcType == GL_HALF_FLOAT_ARB ||
4266 srcType == GL_FLOAT);
4267
4268 ASSERT(dstType == GL_UNSIGNED_BYTE ||
4269 dstType == GL_UNSIGNED_SHORT ||
4270 dstType == GL_UNSIGNED_INT);
4271
4272
4273 transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
4274
4275 /*
4276 * Try simple cases first
4277 */
4278 if (transferOps == 0 && srcType == GL_UNSIGNED_BYTE
4279 && dstType == GL_UNSIGNED_BYTE) {
4280 _mesa_memcpy(dest, source, n * sizeof(GLubyte));
4281 }
4282 else if (transferOps == 0 && srcType == GL_UNSIGNED_INT
4283 && dstType == GL_UNSIGNED_INT && !srcPacking->SwapBytes) {
4284 _mesa_memcpy(dest, source, n * sizeof(GLuint));
4285 }
4286 else {
4287 /*
4288 * general solution
4289 */
4290 GLuint indexes[MAX_WIDTH];
4291 assert(n <= MAX_WIDTH);
4292
4293 extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
4294 srcPacking);
4295
4296 if (transferOps)
4297 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
4298
4299 /* convert to dest type */
4300 switch (dstType) {
4301 case GL_UNSIGNED_BYTE:
4302 {
4303 GLubyte *dst = (GLubyte *) dest;
4304 GLuint i;
4305 for (i = 0; i < n; i++) {
4306 dst[i] = (GLubyte) (indexes[i] & 0xff);
4307 }
4308 }
4309 break;
4310 case GL_UNSIGNED_SHORT:
4311 {
4312 GLuint *dst = (GLuint *) dest;
4313 GLuint i;
4314 for (i = 0; i < n; i++) {
4315 dst[i] = (GLushort) (indexes[i] & 0xffff);
4316 }
4317 }
4318 break;
4319 case GL_UNSIGNED_INT:
4320 _mesa_memcpy(dest, indexes, n * sizeof(GLuint));
4321 break;
4322 default:
4323 _mesa_problem(ctx, "bad dstType in _mesa_unpack_index_span");
4324 }
4325 }
4326 }
4327
4328
4329 void
4330 _mesa_pack_index_span( const GLcontext *ctx, GLuint n,
4331 GLenum dstType, GLvoid *dest, const GLuint *source,
4332 const struct gl_pixelstore_attrib *dstPacking,
4333 GLbitfield transferOps )
4334 {
4335 GLuint indexes[MAX_WIDTH];
4336
4337 ASSERT(n <= MAX_WIDTH);
4338
4339 transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
4340
4341 if (transferOps & (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT)) {
4342 /* make a copy of input */
4343 _mesa_memcpy(indexes, source, n * sizeof(GLuint));
4344 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
4345 source = indexes;
4346 }
4347
4348 switch (dstType) {
4349 case GL_UNSIGNED_BYTE:
4350 {
4351 GLubyte *dst = (GLubyte *) dest;
4352 GLuint i;
4353 for (i = 0; i < n; i++) {
4354 *dst++ = (GLubyte) source[i];
4355 }
4356 }
4357 break;
4358 case GL_BYTE:
4359 {
4360 GLbyte *dst = (GLbyte *) dest;
4361 GLuint i;
4362 for (i = 0; i < n; i++) {
4363 dst[i] = (GLbyte) source[i];
4364 }
4365 }
4366 break;
4367 case GL_UNSIGNED_SHORT:
4368 {
4369 GLushort *dst = (GLushort *) dest;
4370 GLuint i;
4371 for (i = 0; i < n; i++) {
4372 dst[i] = (GLushort) source[i];
4373 }
4374 if (dstPacking->SwapBytes) {
4375 _mesa_swap2( (GLushort *) dst, n );
4376 }
4377 }
4378 break;
4379 case GL_SHORT:
4380 {
4381 GLshort *dst = (GLshort *) dest;
4382 GLuint i;
4383 for (i = 0; i < n; i++) {
4384 dst[i] = (GLshort) source[i];
4385 }
4386 if (dstPacking->SwapBytes) {
4387 _mesa_swap2( (GLushort *) dst, n );
4388 }
4389 }
4390 break;
4391 case GL_UNSIGNED_INT:
4392 {
4393 GLuint *dst = (GLuint *) dest;
4394 GLuint i;
4395 for (i = 0; i < n; i++) {
4396 dst[i] = (GLuint) source[i];
4397 }
4398 if (dstPacking->SwapBytes) {
4399 _mesa_swap4( (GLuint *) dst, n );
4400 }
4401 }
4402 break;
4403 case GL_INT:
4404 {
4405 GLint *dst = (GLint *) dest;
4406 GLuint i;
4407 for (i = 0; i < n; i++) {
4408 dst[i] = (GLint) source[i];
4409 }
4410 if (dstPacking->SwapBytes) {
4411 _mesa_swap4( (GLuint *) dst, n );
4412 }
4413 }
4414 break;
4415 case GL_FLOAT:
4416 {
4417 GLfloat *dst = (GLfloat *) dest;
4418 GLuint i;
4419 for (i = 0; i < n; i++) {
4420 dst[i] = (GLfloat) source[i];
4421 }
4422 if (dstPacking->SwapBytes) {
4423 _mesa_swap4( (GLuint *) dst, n );
4424 }
4425 }
4426 break;
4427 case GL_HALF_FLOAT_ARB:
4428 {
4429 GLhalfARB *dst = (GLhalfARB *) dest;
4430 GLuint i;
4431 for (i = 0; i < n; i++) {
4432 dst[i] = _mesa_float_to_half((GLfloat) source[i]);
4433 }
4434 if (dstPacking->SwapBytes) {
4435 _mesa_swap2( (GLushort *) dst, n );
4436 }
4437 }
4438 break;
4439 default:
4440 _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
4441 }
4442 }
4443
4444
4445 /*
4446 * Unpack a row of stencil data from a client buffer according to
4447 * the pixel unpacking parameters.
4448 * This is (or will be) used by glDrawPixels
4449 *
4450 * Args: ctx - the context
4451 * n - number of pixels
4452 * dstType - destination data type
4453 * dest - destination array
4454 * srcType - source pixel type
4455 * source - source data pointer
4456 * srcPacking - pixel unpacking parameters
4457 * transferOps - apply offset/bias/lookup ops?
4458 */
4459 void
4460 _mesa_unpack_stencil_span( const GLcontext *ctx, GLuint n,
4461 GLenum dstType, GLvoid *dest,
4462 GLenum srcType, const GLvoid *source,
4463 const struct gl_pixelstore_attrib *srcPacking,
4464 GLbitfield transferOps )
4465 {
4466 ASSERT(srcType == GL_BITMAP ||
4467 srcType == GL_UNSIGNED_BYTE ||
4468 srcType == GL_BYTE ||
4469 srcType == GL_UNSIGNED_SHORT ||
4470 srcType == GL_SHORT ||
4471 srcType == GL_UNSIGNED_INT ||
4472 srcType == GL_INT ||
4473 srcType == GL_UNSIGNED_INT_24_8_EXT ||
4474 srcType == GL_HALF_FLOAT_ARB ||
4475 srcType == GL_FLOAT);
4476
4477 ASSERT(dstType == GL_UNSIGNED_BYTE ||
4478 dstType == GL_UNSIGNED_SHORT ||
4479 dstType == GL_UNSIGNED_INT);
4480
4481 /* only shift and offset apply to stencil */
4482 transferOps &= IMAGE_SHIFT_OFFSET_BIT;
4483
4484 /*
4485 * Try simple cases first
4486 */
4487 if (transferOps == 0 &&
4488 !ctx->Pixel.MapStencilFlag &&
4489 srcType == GL_UNSIGNED_BYTE &&
4490 dstType == GL_UNSIGNED_BYTE) {
4491 _mesa_memcpy(dest, source, n * sizeof(GLubyte));
4492 }
4493 else if (transferOps == 0 &&
4494 !ctx->Pixel.MapStencilFlag &&
4495 srcType == GL_UNSIGNED_INT &&
4496 dstType == GL_UNSIGNED_INT &&
4497 !srcPacking->SwapBytes) {
4498 _mesa_memcpy(dest, source, n * sizeof(GLuint));
4499 }
4500 else {
4501 /*
4502 * general solution
4503 */
4504 GLuint indexes[MAX_WIDTH];
4505 assert(n <= MAX_WIDTH);
4506
4507 extract_uint_indexes(n, indexes, GL_STENCIL_INDEX, srcType, source,
4508 srcPacking);
4509
4510 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
4511 /* shift and offset indexes */
4512 shift_and_offset_ci(ctx, n, indexes);
4513 }
4514
4515 if (ctx->Pixel.MapStencilFlag) {
4516 /* Apply stencil lookup table */
4517 const GLuint mask = ctx->PixelMaps.StoS.Size - 1;
4518 GLuint i;
4519 for (i = 0; i < n; i++) {
4520 indexes[i] = (GLuint)ctx->PixelMaps.StoS.Map[ indexes[i] & mask ];
4521 }
4522 }
4523
4524 /* convert to dest type */
4525 switch (dstType) {
4526 case GL_UNSIGNED_BYTE:
4527 {
4528 GLubyte *dst = (GLubyte *) dest;
4529 GLuint i;
4530 for (i = 0; i < n; i++) {
4531 dst[i] = (GLubyte) (indexes[i] & 0xff);
4532 }
4533 }
4534 break;
4535 case GL_UNSIGNED_SHORT:
4536 {
4537 GLuint *dst = (GLuint *) dest;
4538 GLuint i;
4539 for (i = 0; i < n; i++) {
4540 dst[i] = (GLushort) (indexes[i] & 0xffff);
4541 }
4542 }
4543 break;
4544 case GL_UNSIGNED_INT:
4545 _mesa_memcpy(dest, indexes, n * sizeof(GLuint));
4546 break;
4547 default:
4548 _mesa_problem(ctx, "bad dstType in _mesa_unpack_stencil_span");
4549 }
4550 }
4551 }
4552
4553
4554 void
4555 _mesa_pack_stencil_span( const GLcontext *ctx, GLuint n,
4556 GLenum dstType, GLvoid *dest, const GLstencil *source,
4557 const struct gl_pixelstore_attrib *dstPacking )
4558 {
4559 GLstencil stencil[MAX_WIDTH];
4560
4561 ASSERT(n <= MAX_WIDTH);
4562
4563 if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset ||
4564 ctx->Pixel.MapStencilFlag) {
4565 /* make a copy of input */
4566 _mesa_memcpy(stencil, source, n * sizeof(GLstencil));
4567 _mesa_apply_stencil_transfer_ops(ctx, n, stencil);
4568 source = stencil;
4569 }
4570
4571 switch (dstType) {
4572 case GL_UNSIGNED_BYTE:
4573 if (sizeof(GLstencil) == 1) {
4574 _mesa_memcpy( dest, source, n );
4575 }
4576 else {
4577 GLubyte *dst = (GLubyte *) dest;
4578 GLuint i;
4579 for (i=0;i<n;i++) {
4580 dst[i] = (GLubyte) source[i];
4581 }
4582 }
4583 break;
4584 case GL_BYTE:
4585 {
4586 GLbyte *dst = (GLbyte *) dest;
4587 GLuint i;
4588 for (i=0;i<n;i++) {
4589 dst[i] = (GLbyte) (source[i] & 0x7f);
4590 }
4591 }
4592 break;
4593 case GL_UNSIGNED_SHORT:
4594 {
4595 GLushort *dst = (GLushort *) dest;
4596 GLuint i;
4597 for (i=0;i<n;i++) {
4598 dst[i] = (GLushort) source[i];
4599 }
4600 if (dstPacking->SwapBytes) {
4601 _mesa_swap2( (GLushort *) dst, n );
4602 }
4603 }
4604 break;
4605 case GL_SHORT:
4606 {
4607 GLshort *dst = (GLshort *) dest;
4608 GLuint i;
4609 for (i=0;i<n;i++) {
4610 dst[i] = (GLshort) source[i];
4611 }
4612 if (dstPacking->SwapBytes) {
4613 _mesa_swap2( (GLushort *) dst, n );
4614 }
4615 }
4616 break;
4617 case GL_UNSIGNED_INT:
4618 {
4619 GLuint *dst = (GLuint *) dest;
4620 GLuint i;
4621 for (i=0;i<n;i++) {
4622 dst[i] = (GLuint) source[i];
4623 }
4624 if (dstPacking->SwapBytes) {
4625 _mesa_swap4( (GLuint *) dst, n );
4626 }
4627 }
4628 break;
4629 case GL_INT:
4630 {
4631 GLint *dst = (GLint *) dest;
4632 GLuint i;
4633 for (i=0;i<n;i++) {
4634 dst[i] = (GLint) source[i];
4635 }
4636 if (dstPacking->SwapBytes) {
4637 _mesa_swap4( (GLuint *) dst, n );
4638 }
4639 }
4640 break;
4641 case GL_FLOAT:
4642 {
4643 GLfloat *dst = (GLfloat *) dest;
4644 GLuint i;
4645 for (i=0;i<n;i++) {
4646 dst[i] = (GLfloat) source[i];
4647 }
4648 if (dstPacking->SwapBytes) {
4649 _mesa_swap4( (GLuint *) dst, n );
4650 }
4651 }
4652 break;
4653 case GL_HALF_FLOAT_ARB:
4654 {
4655 GLhalfARB *dst = (GLhalfARB *) dest;
4656 GLuint i;
4657 for (i=0;i<n;i++) {
4658 dst[i] = _mesa_float_to_half( (float) source[i] );
4659 }
4660 if (dstPacking->SwapBytes) {
4661 _mesa_swap2( (GLushort *) dst, n );
4662 }
4663 }
4664 break;
4665 case GL_BITMAP:
4666 if (dstPacking->LsbFirst) {
4667 GLubyte *dst = (GLubyte *) dest;
4668 GLint shift = 0;
4669 GLuint i;
4670 for (i = 0; i < n; i++) {
4671 if (shift == 0)
4672 *dst = 0;
4673 *dst |= ((source[i] != 0) << shift);
4674 shift++;
4675 if (shift == 8) {
4676 shift = 0;
4677 dst++;
4678 }
4679 }
4680 }
4681 else {
4682 GLubyte *dst = (GLubyte *) dest;
4683 GLint shift = 7;
4684 GLuint i;
4685 for (i = 0; i < n; i++) {
4686 if (shift == 7)
4687 *dst = 0;
4688 *dst |= ((source[i] != 0) << shift);
4689 shift--;
4690 if (shift < 0) {
4691 shift = 7;
4692 dst++;
4693 }
4694 }
4695 }
4696 break;
4697 default:
4698 _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
4699 }
4700 }
4701
4702 #define DEPTH_VALUES(GLTYPE, GLTYPE2FLOAT) \
4703 do { \
4704 GLuint i; \
4705 const GLTYPE *src = (const GLTYPE *)source; \
4706 for (i = 0; i < n; i++) { \
4707 GLTYPE value = src[i]; \
4708 if (srcPacking->SwapBytes) { \
4709 if (sizeof(GLTYPE) == 2) { \
4710 SWAP2BYTE(value); \
4711 } else if (sizeof(GLTYPE) == 4) { \
4712 SWAP4BYTE(value); \
4713 } \
4714 } \
4715 depthValues[i] = GLTYPE2FLOAT(value); \
4716 } \
4717 } while (0)
4718
4719
4720 /**
4721 * Unpack a row of depth/z values from memory, returning GLushort, GLuint
4722 * or GLfloat values.
4723 * The glPixelTransfer (scale/bias) params will be applied.
4724 *
4725 * \param dstType one of GL_UNSIGNED_SHORT, GL_UNSIGNED_INT, GL_FLOAT
4726 * \param depthMax max value for returned GLushort or GLuint values
4727 * (ignored for GLfloat).
4728 */
4729 void
4730 _mesa_unpack_depth_span( const GLcontext *ctx, GLuint n,
4731 GLenum dstType, GLvoid *dest, GLuint depthMax,
4732 GLenum srcType, const GLvoid *source,
4733 const struct gl_pixelstore_attrib *srcPacking )
4734 {
4735 GLfloat depthTemp[MAX_WIDTH], *depthValues;
4736 GLboolean needClamp = GL_FALSE;
4737
4738 /* Look for special cases first.
4739 * Not only are these faster, they're less prone to numeric conversion
4740 * problems. Otherwise, converting from an int type to a float then
4741 * back to an int type can introduce errors that will show up as
4742 * artifacts in things like depth peeling which uses glCopyTexImage.
4743 */
4744 if (ctx->Pixel.DepthScale == 1.0 && ctx->Pixel.DepthBias == 0.0) {
4745 if (srcType == GL_UNSIGNED_INT && dstType == GL_UNSIGNED_SHORT) {
4746 const GLuint *src = (const GLuint *) source;
4747 GLushort *dst = (GLushort *) dest;
4748 GLuint i;
4749 for (i = 0; i < n; i++) {
4750 dst[i] = src[i] >> 16;
4751 }
4752 return;
4753 }
4754 if (srcType == GL_UNSIGNED_SHORT
4755 && dstType == GL_UNSIGNED_INT
4756 && depthMax == 0xffffffff) {
4757 const GLushort *src = (const GLushort *) source;
4758 GLuint *dst = (GLuint *) dest;
4759 GLuint i;
4760 for (i = 0; i < n; i++) {
4761 dst[i] = src[i] | (src[i] << 16);
4762 }
4763 return;
4764 }
4765 if (srcType == GL_UNSIGNED_INT_24_8
4766 && dstType == GL_UNSIGNED_INT
4767 && depthMax == 0xffffff) {
4768 const GLuint *src = (const GLuint *) source;
4769 GLuint *dst = (GLuint *) dest;
4770 GLuint i;
4771 for (i = 0; i < n; i++) {
4772 dst[i] = src[i] >> 8;
4773 }
4774 return;
4775 }
4776 /* XXX may want to add additional cases here someday */
4777 }
4778
4779 /* general case path follows */
4780
4781 if (dstType == GL_FLOAT) {
4782 depthValues = (GLfloat *) dest;
4783 }
4784 else {
4785 depthValues = depthTemp;
4786 }
4787
4788 /* Convert incoming values to GLfloat. Some conversions will require
4789 * clamping, below.
4790 */
4791 switch (srcType) {
4792 case GL_BYTE:
4793 DEPTH_VALUES(GLbyte, BYTE_TO_FLOAT);
4794 needClamp = GL_TRUE;
4795 break;
4796 case GL_UNSIGNED_BYTE:
4797 DEPTH_VALUES(GLubyte, UBYTE_TO_FLOAT);
4798 break;
4799 case GL_SHORT:
4800 DEPTH_VALUES(GLshort, SHORT_TO_FLOAT);
4801 needClamp = GL_TRUE;
4802 break;
4803 case GL_UNSIGNED_SHORT:
4804 DEPTH_VALUES(GLushort, USHORT_TO_FLOAT);
4805 break;
4806 case GL_INT:
4807 DEPTH_VALUES(GLint, INT_TO_FLOAT);
4808 needClamp = GL_TRUE;
4809 break;
4810 case GL_UNSIGNED_INT:
4811 DEPTH_VALUES(GLuint, UINT_TO_FLOAT);
4812 break;
4813 case GL_UNSIGNED_INT_24_8_EXT: /* GL_EXT_packed_depth_stencil */
4814 if (dstType == GL_UNSIGNED_INT_24_8_EXT &&
4815 depthMax == 0xffffff &&
4816 ctx->Pixel.DepthScale == 1.0 &&
4817 ctx->Pixel.DepthBias == 0.0) {
4818 const GLuint *src = (const GLuint *) source;
4819 GLuint *zValues = (GLuint *) dest;
4820 GLuint i;
4821 for (i = 0; i < n; i++) {
4822 GLuint value = src[i];
4823 if (srcPacking->SwapBytes) {
4824 SWAP4BYTE(value);
4825 }
4826 zValues[i] = value & 0xffffff00;
4827 }
4828 return;
4829 }
4830 else {
4831 const GLuint *src = (const GLuint *) source;
4832 const GLfloat scale = 1.0f / 0xffffff;
4833 GLuint i;
4834 for (i = 0; i < n; i++) {
4835 GLuint value = src[i];
4836 if (srcPacking->SwapBytes) {
4837 SWAP4BYTE(value);
4838 }
4839 depthValues[i] = (value >> 8) * scale;
4840 }
4841 }
4842 break;
4843 case GL_FLOAT:
4844 DEPTH_VALUES(GLfloat, 1*);
4845 needClamp = GL_TRUE;
4846 break;
4847 case GL_HALF_FLOAT_ARB:
4848 {
4849 GLuint i;
4850 const GLhalfARB *src = (const GLhalfARB *) source;
4851 for (i = 0; i < n; i++) {
4852 GLhalfARB value = src[i];
4853 if (srcPacking->SwapBytes) {
4854 SWAP2BYTE(value);
4855 }
4856 depthValues[i] = _mesa_half_to_float(value);
4857 }
4858 needClamp = GL_TRUE;
4859 }
4860 break;
4861 default:
4862 _mesa_problem(NULL, "bad type in _mesa_unpack_depth_span()");
4863 return;
4864 }
4865
4866 /* apply depth scale and bias */
4867 {
4868 const GLfloat scale = ctx->Pixel.DepthScale;
4869 const GLfloat bias = ctx->Pixel.DepthBias;
4870 if (scale != 1.0 || bias != 0.0) {
4871 GLuint i;
4872 for (i = 0; i < n; i++) {
4873 depthValues[i] = depthValues[i] * scale + bias;
4874 }
4875 needClamp = GL_TRUE;
4876 }
4877 }
4878
4879 /* clamp to [0, 1] */
4880 if (needClamp) {
4881 GLuint i;
4882 for (i = 0; i < n; i++) {
4883 depthValues[i] = (GLfloat)CLAMP(depthValues[i], 0.0, 1.0);
4884 }
4885 }
4886
4887 /*
4888 * Convert values to dstType
4889 */
4890 if (dstType == GL_UNSIGNED_INT) {
4891 GLuint *zValues = (GLuint *) dest;
4892 GLuint i;
4893 if (depthMax <= 0xffffff) {
4894 /* no overflow worries */
4895 for (i = 0; i < n; i++) {
4896 zValues[i] = (GLuint) (depthValues[i] * (GLfloat) depthMax);
4897 }
4898 }
4899 else {
4900 /* need to use double precision to prevent overflow problems */
4901 for (i = 0; i < n; i++) {
4902 GLdouble z = depthValues[i] * (GLfloat) depthMax;
4903 if (z >= (GLdouble) 0xffffffff)
4904 zValues[i] = 0xffffffff;
4905 else
4906 zValues[i] = (GLuint) z;
4907 }
4908 }
4909 }
4910 else if (dstType == GL_UNSIGNED_SHORT) {
4911 GLushort *zValues = (GLushort *) dest;
4912 GLuint i;
4913 ASSERT(depthMax <= 0xffff);
4914 for (i = 0; i < n; i++) {
4915 zValues[i] = (GLushort) (depthValues[i] * (GLfloat) depthMax);
4916 }
4917 }
4918 else {
4919 ASSERT(dstType == GL_FLOAT);
4920 /*ASSERT(depthMax == 1.0F);*/
4921 }
4922 }
4923
4924
4925 /*
4926 * Pack an array of depth values. The values are floats in [0,1].
4927 */
4928 void
4929 _mesa_pack_depth_span( const GLcontext *ctx, GLuint n, GLvoid *dest,
4930 GLenum dstType, const GLfloat *depthSpan,
4931 const struct gl_pixelstore_attrib *dstPacking )
4932 {
4933 GLfloat depthCopy[MAX_WIDTH];
4934
4935 ASSERT(n <= MAX_WIDTH);
4936
4937 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
4938 _mesa_memcpy(depthCopy, depthSpan, n * sizeof(GLfloat));
4939 _mesa_scale_and_bias_depth(ctx, n, depthCopy);
4940 depthSpan = depthCopy;
4941 }
4942
4943 switch (dstType) {
4944 case GL_UNSIGNED_BYTE:
4945 {
4946 GLubyte *dst = (GLubyte *) dest;
4947 GLuint i;
4948 for (i = 0; i < n; i++) {
4949 dst[i] = FLOAT_TO_UBYTE( depthSpan[i] );
4950 }
4951 }
4952 break;
4953 case GL_BYTE:
4954 {
4955 GLbyte *dst = (GLbyte *) dest;
4956 GLuint i;
4957 for (i = 0; i < n; i++) {
4958 dst[i] = FLOAT_TO_BYTE( depthSpan[i] );
4959 }
4960 }
4961 break;
4962 case GL_UNSIGNED_SHORT:
4963 {
4964 GLushort *dst = (GLushort *) dest;
4965 GLuint i;
4966 for (i = 0; i < n; i++) {
4967 CLAMPED_FLOAT_TO_USHORT(dst[i], depthSpan[i]);
4968 }
4969 if (dstPacking->SwapBytes) {
4970 _mesa_swap2( (GLushort *) dst, n );
4971 }
4972 }
4973 break;
4974 case GL_SHORT:
4975 {
4976 GLshort *dst = (GLshort *) dest;
4977 GLuint i;
4978 for (i = 0; i < n; i++) {
4979 dst[i] = FLOAT_TO_SHORT( depthSpan[i] );
4980 }
4981 if (dstPacking->SwapBytes) {
4982 _mesa_swap2( (GLushort *) dst, n );
4983 }
4984 }
4985 break;
4986 case GL_UNSIGNED_INT:
4987 {
4988 GLuint *dst = (GLuint *) dest;
4989 GLuint i;
4990 for (i = 0; i < n; i++) {
4991 dst[i] = FLOAT_TO_UINT( depthSpan[i] );
4992 }
4993 if (dstPacking->SwapBytes) {
4994 _mesa_swap4( (GLuint *) dst, n );
4995 }
4996 }
4997 break;
4998 case GL_INT:
4999 {
5000 GLint *dst = (GLint *) dest;
5001 GLuint i;
5002 for (i = 0; i < n; i++) {
5003 dst[i] = FLOAT_TO_INT( depthSpan[i] );
5004 }
5005 if (dstPacking->SwapBytes) {
5006 _mesa_swap4( (GLuint *) dst, n );
5007 }
5008 }
5009 break;
5010 case GL_FLOAT:
5011 {
5012 GLfloat *dst = (GLfloat *) dest;
5013 GLuint i;
5014 for (i = 0; i < n; i++) {
5015 dst[i] = depthSpan[i];
5016 }
5017 if (dstPacking->SwapBytes) {
5018 _mesa_swap4( (GLuint *) dst, n );
5019 }
5020 }
5021 break;
5022 case GL_HALF_FLOAT_ARB:
5023 {
5024 GLhalfARB *dst = (GLhalfARB *) dest;
5025 GLuint i;
5026 for (i = 0; i < n; i++) {
5027 dst[i] = _mesa_float_to_half(depthSpan[i]);
5028 }
5029 if (dstPacking->SwapBytes) {
5030 _mesa_swap2( (GLushort *) dst, n );
5031 }
5032 }
5033 break;
5034 default:
5035 _mesa_problem(ctx, "bad type in _mesa_pack_depth_span");
5036 }
5037 }
5038
5039
5040
5041 /**
5042 * Pack depth and stencil values as GL_DEPTH_STENCIL/GL_UNSIGNED_INT_24_8.
5043 */
5044 void
5045 _mesa_pack_depth_stencil_span(const GLcontext *ctx, GLuint n, GLuint *dest,
5046 const GLfloat *depthVals,
5047 const GLstencil *stencilVals,
5048 const struct gl_pixelstore_attrib *dstPacking)
5049 {
5050 GLfloat depthCopy[MAX_WIDTH];
5051 GLstencil stencilCopy[MAX_WIDTH];
5052 GLuint i;
5053
5054 ASSERT(n <= MAX_WIDTH);
5055
5056 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
5057 _mesa_memcpy(depthCopy, depthVals, n * sizeof(GLfloat));
5058 _mesa_scale_and_bias_depth(ctx, n, depthCopy);
5059 depthVals = depthCopy;
5060 }
5061
5062 if (ctx->Pixel.IndexShift ||
5063 ctx->Pixel.IndexOffset ||
5064 ctx->Pixel.MapStencilFlag) {
5065 _mesa_memcpy(stencilCopy, stencilVals, n * sizeof(GLstencil));
5066 _mesa_apply_stencil_transfer_ops(ctx, n, stencilCopy);
5067 stencilVals = stencilCopy;
5068 }
5069
5070 for (i = 0; i < n; i++) {
5071 GLuint z = (GLuint) (depthVals[i] * 0xffffff);
5072 dest[i] = (z << 8) | (stencilVals[i] & 0xff);
5073 }
5074
5075 if (dstPacking->SwapBytes) {
5076 _mesa_swap4(dest, n);
5077 }
5078 }
5079
5080
5081
5082
5083 /**
5084 * Unpack image data. Apply byte swapping, byte flipping (bitmap).
5085 * Return all image data in a contiguous block. This is used when we
5086 * compile glDrawPixels, glTexImage, etc into a display list. We
5087 * need a copy of the data in a standard format.
5088 */
5089 void *
5090 _mesa_unpack_image( GLuint dimensions,
5091 GLsizei width, GLsizei height, GLsizei depth,
5092 GLenum format, GLenum type, const GLvoid *pixels,
5093 const struct gl_pixelstore_attrib *unpack )
5094 {
5095 GLint bytesPerRow, compsPerRow;
5096 GLboolean flipBytes, swap2, swap4;
5097
5098 if (!pixels)
5099 return NULL; /* not necessarily an error */
5100
5101 if (width <= 0 || height <= 0 || depth <= 0)
5102 return NULL; /* generate error later */
5103
5104 if (type == GL_BITMAP) {
5105 bytesPerRow = (width + 7) >> 3;
5106 flipBytes = unpack->LsbFirst;
5107 swap2 = swap4 = GL_FALSE;
5108 compsPerRow = 0;
5109 }
5110 else {
5111 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
5112 GLint components = _mesa_components_in_format(format);
5113 GLint bytesPerComp;
5114
5115 if (_mesa_type_is_packed(type))
5116 components = 1;
5117
5118 if (bytesPerPixel <= 0 || components <= 0)
5119 return NULL; /* bad format or type. generate error later */
5120 bytesPerRow = bytesPerPixel * width;
5121 bytesPerComp = bytesPerPixel / components;
5122 flipBytes = GL_FALSE;
5123 swap2 = (bytesPerComp == 2) && unpack->SwapBytes;
5124 swap4 = (bytesPerComp == 4) && unpack->SwapBytes;
5125 compsPerRow = components * width;
5126 assert(compsPerRow >= width);
5127 }
5128
5129 {
5130 GLubyte *destBuffer
5131 = (GLubyte *) _mesa_malloc(bytesPerRow * height * depth);
5132 GLubyte *dst;
5133 GLint img, row;
5134 if (!destBuffer)
5135 return NULL; /* generate GL_OUT_OF_MEMORY later */
5136
5137 dst = destBuffer;
5138 for (img = 0; img < depth; img++) {
5139 for (row = 0; row < height; row++) {
5140 const GLvoid *src = _mesa_image_address(dimensions, unpack, pixels,
5141 width, height, format, type, img, row, 0);
5142
5143 if ((type == GL_BITMAP) && (unpack->SkipPixels & 0x7)) {
5144 GLint i;
5145 flipBytes = GL_FALSE;
5146 if (unpack->LsbFirst) {
5147 GLubyte srcMask = 1 << (unpack->SkipPixels & 0x7);
5148 GLubyte dstMask = 128;
5149 const GLubyte *s = src;
5150 GLubyte *d = dst;
5151 *d = 0;
5152 for (i = 0; i < width; i++) {
5153 if (*s & srcMask) {
5154 *d |= dstMask;
5155 }
5156 if (srcMask == 128) {
5157 srcMask = 1;
5158 s++;
5159 }
5160 else {
5161 srcMask = srcMask << 1;
5162 }
5163 if (dstMask == 1) {
5164 dstMask = 128;
5165 d++;
5166 *d = 0;
5167 }
5168 else {
5169 dstMask = dstMask >> 1;
5170 }
5171 }
5172 }
5173 else {
5174 GLubyte srcMask = 128 >> (unpack->SkipPixels & 0x7);
5175 GLubyte dstMask = 128;
5176 const GLubyte *s = src;
5177 GLubyte *d = dst;
5178 *d = 0;
5179 for (i = 0; i < width; i++) {
5180 if (*s & srcMask) {
5181 *d |= dstMask;
5182 }
5183 if (srcMask == 1) {
5184 srcMask = 128;
5185 s++;
5186 }
5187 else {
5188 srcMask = srcMask >> 1;
5189 }
5190 if (dstMask == 1) {
5191 dstMask = 128;
5192 d++;
5193 *d = 0;
5194 }
5195 else {
5196 dstMask = dstMask >> 1;
5197 }
5198 }
5199 }
5200 }
5201 else {
5202 _mesa_memcpy(dst, src, bytesPerRow);
5203 }
5204
5205 /* byte flipping/swapping */
5206 if (flipBytes) {
5207 flip_bytes((GLubyte *) dst, bytesPerRow);
5208 }
5209 else if (swap2) {
5210 _mesa_swap2((GLushort*) dst, compsPerRow);
5211 }
5212 else if (swap4) {
5213 _mesa_swap4((GLuint*) dst, compsPerRow);
5214 }
5215 dst += bytesPerRow;
5216 }
5217 }
5218 return destBuffer;
5219 }
5220 }
5221
5222 #endif /* _HAVE_FULL_GL */
5223
5224
5225
5226 /**
5227 * Convert an array of RGBA colors from one datatype to another.
5228 * NOTE: src may equal dst. In that case, we use a temporary buffer.
5229 */
5230 void
5231 _mesa_convert_colors(GLenum srcType, const GLvoid *src,
5232 GLenum dstType, GLvoid *dst,
5233 GLuint count, const GLubyte mask[])
5234 {
5235 GLuint tempBuffer[MAX_WIDTH][4];
5236 const GLboolean useTemp = (src == dst);
5237
5238 ASSERT(srcType != dstType);
5239
5240 switch (srcType) {
5241 case GL_UNSIGNED_BYTE:
5242 if (dstType == GL_UNSIGNED_SHORT) {
5243 const GLubyte (*src1)[4] = (const GLubyte (*)[4]) src;
5244 GLushort (*dst2)[4] = (GLushort (*)[4]) (useTemp ? tempBuffer : dst);
5245 GLuint i;
5246 for (i = 0; i < count; i++) {
5247 if (!mask || mask[i]) {
5248 dst2[i][RCOMP] = UBYTE_TO_USHORT(src1[i][RCOMP]);
5249 dst2[i][GCOMP] = UBYTE_TO_USHORT(src1[i][GCOMP]);
5250 dst2[i][BCOMP] = UBYTE_TO_USHORT(src1[i][BCOMP]);
5251 dst2[i][ACOMP] = UBYTE_TO_USHORT(src1[i][ACOMP]);
5252 }
5253 }
5254 if (useTemp)
5255 _mesa_memcpy(dst, tempBuffer, count * 4 * sizeof(GLushort));
5256 }
5257 else {
5258 const GLubyte (*src1)[4] = (const GLubyte (*)[4]) src;
5259 GLfloat (*dst4)[4] = (GLfloat (*)[4]) (useTemp ? tempBuffer : dst);
5260 GLuint i;
5261 ASSERT(dstType == GL_FLOAT);
5262 for (i = 0; i < count; i++) {
5263 if (!mask || mask[i]) {
5264 dst4[i][RCOMP] = UBYTE_TO_FLOAT(src1[i][RCOMP]);
5265 dst4[i][GCOMP] = UBYTE_TO_FLOAT(src1[i][GCOMP]);
5266 dst4[i][BCOMP] = UBYTE_TO_FLOAT(src1[i][BCOMP]);
5267 dst4[i][ACOMP] = UBYTE_TO_FLOAT(src1[i][ACOMP]);
5268 }
5269 }
5270 if (useTemp)
5271 _mesa_memcpy(dst, tempBuffer, count * 4 * sizeof(GLfloat));
5272 }
5273 break;
5274 case GL_UNSIGNED_SHORT:
5275 if (dstType == GL_UNSIGNED_BYTE) {
5276 const GLushort (*src2)[4] = (const GLushort (*)[4]) src;
5277 GLubyte (*dst1)[4] = (GLubyte (*)[4]) (useTemp ? tempBuffer : dst);
5278 GLuint i;
5279 for (i = 0; i < count; i++) {
5280 if (!mask || mask[i]) {
5281 dst1[i][RCOMP] = USHORT_TO_UBYTE(src2[i][RCOMP]);
5282 dst1[i][GCOMP] = USHORT_TO_UBYTE(src2[i][GCOMP]);
5283 dst1[i][BCOMP] = USHORT_TO_UBYTE(src2[i][BCOMP]);
5284 dst1[i][ACOMP] = USHORT_TO_UBYTE(src2[i][ACOMP]);
5285 }
5286 }
5287 if (useTemp)
5288 _mesa_memcpy(dst, tempBuffer, count * 4 * sizeof(GLubyte));
5289 }
5290 else {
5291 const GLushort (*src2)[4] = (const GLushort (*)[4]) src;
5292 GLfloat (*dst4)[4] = (GLfloat (*)[4]) (useTemp ? tempBuffer : dst);
5293 GLuint i;
5294 ASSERT(dstType == GL_FLOAT);
5295 for (i = 0; i < count; i++) {
5296 if (!mask || mask[i]) {
5297 dst4[i][RCOMP] = USHORT_TO_FLOAT(src2[i][RCOMP]);
5298 dst4[i][GCOMP] = USHORT_TO_FLOAT(src2[i][GCOMP]);
5299 dst4[i][BCOMP] = USHORT_TO_FLOAT(src2[i][BCOMP]);
5300 dst4[i][ACOMP] = USHORT_TO_FLOAT(src2[i][ACOMP]);
5301 }
5302 }
5303 if (useTemp)
5304 _mesa_memcpy(dst, tempBuffer, count * 4 * sizeof(GLfloat));
5305 }
5306 break;
5307 case GL_FLOAT:
5308 if (dstType == GL_UNSIGNED_BYTE) {
5309 const GLfloat (*src4)[4] = (const GLfloat (*)[4]) src;
5310 GLubyte (*dst1)[4] = (GLubyte (*)[4]) (useTemp ? tempBuffer : dst);
5311 GLuint i;
5312 for (i = 0; i < count; i++) {
5313 if (!mask || mask[i]) {
5314 UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][RCOMP], src4[i][RCOMP]);
5315 UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][GCOMP], src4[i][GCOMP]);
5316 UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][BCOMP], src4[i][BCOMP]);
5317 UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][ACOMP], src4[i][ACOMP]);
5318 }
5319 }
5320 if (useTemp)
5321 _mesa_memcpy(dst, tempBuffer, count * 4 * sizeof(GLubyte));
5322 }
5323 else {
5324 const GLfloat (*src4)[4] = (const GLfloat (*)[4]) src;
5325 GLushort (*dst2)[4] = (GLushort (*)[4]) (useTemp ? tempBuffer : dst);
5326 GLuint i;
5327 ASSERT(dstType == GL_UNSIGNED_SHORT);
5328 for (i = 0; i < count; i++) {
5329 if (!mask || mask[i]) {
5330 UNCLAMPED_FLOAT_TO_USHORT(dst2[i][RCOMP], src4[i][RCOMP]);
5331 UNCLAMPED_FLOAT_TO_USHORT(dst2[i][GCOMP], src4[i][GCOMP]);
5332 UNCLAMPED_FLOAT_TO_USHORT(dst2[i][BCOMP], src4[i][BCOMP]);
5333 UNCLAMPED_FLOAT_TO_USHORT(dst2[i][ACOMP], src4[i][ACOMP]);
5334 }
5335 }
5336 if (useTemp)
5337 _mesa_memcpy(dst, tempBuffer, count * 4 * sizeof(GLushort));
5338 }
5339 break;
5340 default:
5341 _mesa_problem(NULL, "Invalid datatype in _mesa_convert_colors");
5342 }
5343 }
5344
5345
5346
5347
5348 /**
5349 * Perform basic clipping for glDrawPixels. The image's position and size
5350 * and the unpack SkipPixels and SkipRows are adjusted so that the image
5351 * region is entirely within the window and scissor bounds.
5352 * NOTE: this will only work when glPixelZoom is (1, 1) or (1, -1).
5353 * If Pixel.ZoomY is -1, *destY will be changed to be the first row which
5354 * we'll actually write. Beforehand, *destY-1 is the first drawing row.
5355 *
5356 * \return GL_TRUE if image is ready for drawing or
5357 * GL_FALSE if image was completely clipped away (draw nothing)
5358 */
5359 GLboolean
5360 _mesa_clip_drawpixels(const GLcontext *ctx,
5361 GLint *destX, GLint *destY,
5362 GLsizei *width, GLsizei *height,
5363 struct gl_pixelstore_attrib *unpack)
5364 {
5365 const GLframebuffer *buffer = ctx->DrawBuffer;
5366
5367 if (unpack->RowLength == 0) {
5368 unpack->RowLength = *width;
5369 }
5370
5371 ASSERT(ctx->Pixel.ZoomX == 1.0F);
5372 ASSERT(ctx->Pixel.ZoomY == 1.0F || ctx->Pixel.ZoomY == -1.0F);
5373
5374 /* left clipping */
5375 if (*destX < buffer->_Xmin) {
5376 unpack->SkipPixels += (buffer->_Xmin - *destX);
5377 *width -= (buffer->_Xmin - *destX);
5378 *destX = buffer->_Xmin;
5379 }
5380 /* right clipping */
5381 if (*destX + *width > buffer->_Xmax)
5382 *width -= (*destX + *width - buffer->_Xmax);
5383
5384 if (*width <= 0)
5385 return GL_FALSE;
5386
5387 if (ctx->Pixel.ZoomY == 1.0F) {
5388 /* bottom clipping */
5389 if (*destY < buffer->_Ymin) {
5390 unpack->SkipRows += (buffer->_Ymin - *destY);
5391 *height -= (buffer->_Ymin - *destY);
5392 *destY = buffer->_Ymin;
5393 }
5394 /* top clipping */
5395 if (*destY + *height > buffer->_Ymax)
5396 *height -= (*destY + *height - buffer->_Ymax);
5397 }
5398 else { /* upside down */
5399 /* top clipping */
5400 if (*destY > buffer->_Ymax) {
5401 unpack->SkipRows += (*destY - buffer->_Ymax);
5402 *height -= (*destY - buffer->_Ymax);
5403 *destY = buffer->_Ymax;
5404 }
5405 /* bottom clipping */
5406 if (*destY - *height < buffer->_Ymin)
5407 *height -= (buffer->_Ymin - (*destY - *height));
5408 /* adjust destY so it's the first row to write to */
5409 (*destY)--;
5410 }
5411
5412 if (*height <= 0)
5413 return GL_TRUE;
5414
5415 return GL_TRUE;
5416 }
5417
5418
5419 /**
5420 * Perform clipping for glReadPixels. The image's window position
5421 * and size, and the pack skipPixels, skipRows and rowLength are adjusted
5422 * so that the image region is entirely within the window bounds.
5423 * Note: this is different from _mesa_clip_drawpixels() in that the
5424 * scissor box is ignored, and we use the bounds of the current readbuffer
5425 * surface.
5426 *
5427 * \return GL_TRUE if image is ready for drawing or
5428 * GL_FALSE if image was completely clipped away (draw nothing)
5429 */
5430 GLboolean
5431 _mesa_clip_readpixels(const GLcontext *ctx,
5432 GLint *srcX, GLint *srcY,
5433 GLsizei *width, GLsizei *height,
5434 struct gl_pixelstore_attrib *pack)
5435 {
5436 const GLframebuffer *buffer = ctx->ReadBuffer;
5437
5438 if (pack->RowLength == 0) {
5439 pack->RowLength = *width;
5440 }
5441
5442 /* left clipping */
5443 if (*srcX < 0) {
5444 pack->SkipPixels += (0 - *srcX);
5445 *width -= (0 - *srcX);
5446 *srcX = 0;
5447 }
5448 /* right clipping */
5449 if (*srcX + *width > (GLsizei) buffer->Width)
5450 *width -= (*srcX + *width - buffer->Width);
5451
5452 if (*width <= 0)
5453 return GL_FALSE;
5454
5455 /* bottom clipping */
5456 if (*srcY < 0) {
5457 pack->SkipRows += (0 - *srcY);
5458 *height -= (0 - *srcY);
5459 *srcY = 0;
5460 }
5461 /* top clipping */
5462 if (*srcY + *height > (GLsizei) buffer->Height)
5463 *height -= (*srcY + *height - buffer->Height);
5464
5465 if (*height <= 0)
5466 return GL_TRUE;
5467
5468 return GL_TRUE;
5469 }
5470
5471
5472 /**
5473 * Do clipping for a glCopyTexSubImage call.
5474 * The framebuffer source region might extend outside the framebuffer
5475 * bounds. Clip the source region against the framebuffer bounds and
5476 * adjust the texture/dest position and size accordingly.
5477 *
5478 * \return GL_FALSE if region is totally clipped, GL_TRUE otherwise.
5479 */
5480 GLboolean
5481 _mesa_clip_copytexsubimage(const GLcontext *ctx,
5482 GLint *destX, GLint *destY,
5483 GLint *srcX, GLint *srcY,
5484 GLsizei *width, GLsizei *height)
5485 {
5486 const struct gl_framebuffer *fb = ctx->ReadBuffer;
5487 const GLint srcX0 = *srcX, srcY0 = *srcY;
5488
5489 if (_mesa_clip_to_region(0, 0, fb->Width, fb->Height,
5490 srcX, srcY, width, height)) {
5491 *destX = *destX + *srcX - srcX0;
5492 *destY = *destY + *srcY - srcY0;
5493
5494 return GL_TRUE;
5495 }
5496 else {
5497 return GL_FALSE;
5498 }
5499 }
5500
5501
5502
5503 /**
5504 * Clip the rectangle defined by (x, y, width, height) against the bounds
5505 * specified by [xmin, xmax) and [ymin, ymax).
5506 * \return GL_FALSE if rect is totally clipped, GL_TRUE otherwise.
5507 */
5508 GLboolean
5509 _mesa_clip_to_region(GLint xmin, GLint ymin,
5510 GLint xmax, GLint ymax,
5511 GLint *x, GLint *y,
5512 GLsizei *width, GLsizei *height )
5513 {
5514 /* left clipping */
5515 if (*x < xmin) {
5516 *width -= (xmin - *x);
5517 *x = xmin;
5518 }
5519
5520 /* right clipping */
5521 if (*x + *width > xmax)
5522 *width -= (*x + *width - xmax);
5523
5524 if (*width <= 0)
5525 return GL_FALSE;
5526
5527 /* bottom (or top) clipping */
5528 if (*y < ymin) {
5529 *height -= (ymin - *y);
5530 *y = ymin;
5531 }
5532
5533 /* top (or bottom) clipping */
5534 if (*y + *height > ymax)
5535 *height -= (*y + *height - ymax);
5536
5537 if (*height <= 0)
5538 return GL_FALSE;
5539
5540 return GL_TRUE;
5541 }
5542
5543
5544 /**
5545 * Clip dst coords against Xmax (or Ymax).
5546 */
5547 static INLINE void
5548 clip_right_or_top(GLint *srcX0, GLint *srcX1,
5549 GLint *dstX0, GLint *dstX1,
5550 GLint maxValue)
5551 {
5552 GLfloat t, bias;
5553
5554 if (*dstX1 > maxValue) {
5555 /* X1 outside right edge */
5556 ASSERT(*dstX0 < maxValue); /* X0 should be inside right edge */
5557 t = (GLfloat) (maxValue - *dstX0) / (GLfloat) (*dstX1 - *dstX0);
5558 /* chop off [t, 1] part */
5559 ASSERT(t >= 0.0 && t <= 1.0);
5560 *dstX1 = maxValue;
5561 bias = (*srcX0 < *srcX1) ? 0.5 : -0.5;
5562 *srcX1 = *srcX0 + (GLint) (t * (*srcX1 - *srcX0) + bias);
5563 }
5564 else if (*dstX0 > maxValue) {
5565 /* X0 outside right edge */
5566 ASSERT(*dstX1 < maxValue); /* X1 should be inside right edge */
5567 t = (GLfloat) (maxValue - *dstX1) / (GLfloat) (*dstX0 - *dstX1);
5568 /* chop off [t, 1] part */
5569 ASSERT(t >= 0.0 && t <= 1.0);
5570 *dstX0 = maxValue;
5571 bias = (*srcX0 < *srcX1) ? -0.5 : 0.5;
5572 *srcX0 = *srcX1 + (GLint) (t * (*srcX0 - *srcX1) + bias);
5573 }
5574 }
5575
5576
5577 /**
5578 * Clip dst coords against Xmin (or Ymin).
5579 */
5580 static INLINE void
5581 clip_left_or_bottom(GLint *srcX0, GLint *srcX1,
5582 GLint *dstX0, GLint *dstX1,
5583 GLint minValue)
5584 {
5585 GLfloat t, bias;
5586
5587 if (*dstX0 < minValue) {
5588 /* X0 outside left edge */
5589 ASSERT(*dstX1 > minValue); /* X1 should be inside left edge */
5590 t = (GLfloat) (minValue - *dstX0) / (GLfloat) (*dstX1 - *dstX0);
5591 /* chop off [0, t] part */
5592 ASSERT(t >= 0.0 && t <= 1.0);
5593 *dstX0 = minValue;
5594 bias = (*srcX0 < *srcX1) ? 0.5 : -0.5; /* flipped??? */
5595 *srcX0 = *srcX0 + (GLint) (t * (*srcX1 - *srcX0) + bias);
5596 }
5597 else if (*dstX1 < minValue) {
5598 /* X1 outside left edge */
5599 ASSERT(*dstX0 > minValue); /* X0 should be inside left edge */
5600 t = (GLfloat) (minValue - *dstX1) / (GLfloat) (*dstX0 - *dstX1);
5601 /* chop off [0, t] part */
5602 ASSERT(t >= 0.0 && t <= 1.0);
5603 *dstX1 = minValue;
5604 bias = (*srcX0 < *srcX1) ? 0.5 : -0.5;
5605 *srcX1 = *srcX1 + (GLint) (t * (*srcX0 - *srcX1) + bias);
5606 }
5607 }
5608
5609
5610 /**
5611 * Do clipping of blit src/dest rectangles.
5612 * The dest rect is clipped against both the buffer bounds and scissor bounds.
5613 * The src rect is just clipped against the buffer bounds.
5614 *
5615 * When either the src or dest rect is clipped, the other is also clipped
5616 * proportionately!
5617 *
5618 * Note that X0 need not be less than X1 (same for Y) for either the source
5619 * and dest rects. That makes the clipping a little trickier.
5620 *
5621 * \return GL_TRUE if anything is left to draw, GL_FALSE if totally clipped
5622 */
5623 GLboolean
5624 _mesa_clip_blit(GLcontext *ctx,
5625 GLint *srcX0, GLint *srcY0, GLint *srcX1, GLint *srcY1,
5626 GLint *dstX0, GLint *dstY0, GLint *dstX1, GLint *dstY1)
5627 {
5628 const GLint srcXmin = 0;
5629 const GLint srcXmax = ctx->ReadBuffer->Width;
5630 const GLint srcYmin = 0;
5631 const GLint srcYmax = ctx->ReadBuffer->Height;
5632
5633 /* these include scissor bounds */
5634 const GLint dstXmin = ctx->DrawBuffer->_Xmin;
5635 const GLint dstXmax = ctx->DrawBuffer->_Xmax;
5636 const GLint dstYmin = ctx->DrawBuffer->_Ymin;
5637 const GLint dstYmax = ctx->DrawBuffer->_Ymax;
5638
5639 /*
5640 printf("PreClipX: src: %d .. %d dst: %d .. %d\n",
5641 *srcX0, *srcX1, *dstX0, *dstX1);
5642 printf("PreClipY: src: %d .. %d dst: %d .. %d\n",
5643 *srcY0, *srcY1, *dstY0, *dstY1);
5644 */
5645
5646 /* trivial rejection tests */
5647 if (*dstX0 == *dstX1)
5648 return GL_FALSE; /* no width */
5649 if (*dstX0 <= dstXmin && *dstX1 <= dstXmin)
5650 return GL_FALSE; /* totally out (left) of bounds */
5651 if (*dstX0 >= dstXmax && *dstX1 >= dstXmax)
5652 return GL_FALSE; /* totally out (right) of bounds */
5653
5654 if (*dstY0 == *dstY1)
5655 return GL_FALSE;
5656 if (*dstY0 <= dstYmin && *dstY1 <= dstYmin)
5657 return GL_FALSE;
5658 if (*dstY0 >= dstYmax && *dstY1 >= dstYmax)
5659 return GL_FALSE;
5660
5661 if (*srcX0 == *srcX1)
5662 return GL_FALSE;
5663 if (*srcX0 <= srcXmin && *srcX1 <= srcXmin)
5664 return GL_FALSE;
5665 if (*srcX0 >= srcXmax && *srcX1 >= srcXmax)
5666 return GL_FALSE;
5667
5668 if (*srcY0 == *srcY1)
5669 return GL_FALSE;
5670 if (*srcY0 <= srcYmin && *srcY1 <= srcYmin)
5671 return GL_FALSE;
5672 if (*srcY0 >= srcYmax && *srcY1 >= srcYmax)
5673 return GL_FALSE;
5674
5675 /*
5676 * dest clip
5677 */
5678 clip_right_or_top(srcX0, srcX1, dstX0, dstX1, dstXmax);
5679 clip_right_or_top(srcY0, srcY1, dstY0, dstY1, dstYmax);
5680 clip_left_or_bottom(srcX0, srcX1, dstX0, dstX1, dstXmin);
5681 clip_left_or_bottom(srcY0, srcY1, dstY0, dstY1, dstYmin);
5682
5683 /*
5684 * src clip (just swap src/dst values from above)
5685 */
5686 clip_right_or_top(dstX0, dstX1, srcX0, srcX1, srcXmax);
5687 clip_right_or_top(dstY0, dstY1, srcY0, srcY1, srcYmax);
5688 clip_left_or_bottom(dstX0, dstX1, srcX0, srcX1, srcXmin);
5689 clip_left_or_bottom(dstY0, dstY1, srcY0, srcY1, srcYmin);
5690
5691 /*
5692 printf("PostClipX: src: %d .. %d dst: %d .. %d\n",
5693 *srcX0, *srcX1, *dstX0, *dstX1);
5694 printf("PostClipY: src: %d .. %d dst: %d .. %d\n",
5695 *srcY0, *srcY1, *dstY0, *dstY1);
5696 */
5697
5698 ASSERT(*dstX0 >= dstXmin);
5699 ASSERT(*dstX0 <= dstXmax);
5700 ASSERT(*dstX1 >= dstXmin);
5701 ASSERT(*dstX1 <= dstXmax);
5702
5703 ASSERT(*dstY0 >= dstYmin);
5704 ASSERT(*dstY0 <= dstYmax);
5705 ASSERT(*dstY1 >= dstYmin);
5706 ASSERT(*dstY1 <= dstYmax);
5707
5708 ASSERT(*srcX0 >= srcXmin);
5709 ASSERT(*srcX0 <= srcXmax);
5710 ASSERT(*srcX1 >= srcXmin);
5711 ASSERT(*srcX1 <= srcXmax);
5712
5713 ASSERT(*srcY0 >= srcYmin);
5714 ASSERT(*srcY0 <= srcYmax);
5715 ASSERT(*srcY1 >= srcYmin);
5716 ASSERT(*srcY1 <= srcYmax);
5717
5718 return GL_TRUE;
5719 }