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