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