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