projects / mesa.git / blob
? search:


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