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