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