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