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