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