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