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