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