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