projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
mesa: Remove _mesa_unpack_color_span_ubyte
[mesa.git] / src / mesa / main / pack.c
1 /*
2 * Mesa 3-D graphics library
3 *
4 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved.
5 * Copyright (C) 2009-2010 VMware, Inc. All Rights Reserved.
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THEA AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 */
24
25
26 /**
27 * \file pack.c
28 * Image and pixel span packing and unpacking.
29 */
30
31
32 /*
33 * XXX: MSVC takes forever to compile this module for x86_64 unless we disable
34 * this global optimization.
35 *
36 * See also:
37 * - http://msdn.microsoft.com/en-us/library/1yk3ydd7.aspx
38 * - http://msdn.microsoft.com/en-us/library/chh3fb0k.aspx
39 */
40 #if defined(_MSC_VER) && defined(_M_X64)
41 # pragma optimize( "g", off )
42 #endif
43
44
45 #include "glheader.h"
46 #include "colormac.h"
47 #include "enums.h"
48 #include "image.h"
49 #include "imports.h"
50 #include "macros.h"
51 #include "mtypes.h"
52 #include "pack.h"
53 #include "pixeltransfer.h"
54 #include "imports.h"
55 #include "glformats.h"
56 #include "../../gallium/auxiliary/util/u_format_rgb9e5.h"
57 #include "../../gallium/auxiliary/util/u_format_r11g11b10f.h"
58 #include "format_utils.h"
59 #include "format_pack.h"
60
61
62 /**
63 * Flip the 8 bits in each byte of the given array.
64 *
65 * \param p array.
66 * \param n number of bytes.
67 *
68 * \todo try this trick to flip bytes someday:
69 * \code
70 * v = ((v & 0x55555555) << 1) | ((v >> 1) & 0x55555555);
71 * v = ((v & 0x33333333) << 2) | ((v >> 2) & 0x33333333);
72 * v = ((v & 0x0f0f0f0f) << 4) | ((v >> 4) & 0x0f0f0f0f);
73 * \endcode
74 */
75 static void
76 flip_bytes( GLubyte *p, GLuint n )
77 {
78 GLuint i, a, b;
79 for (i = 0; i < n; i++) {
80 b = (GLuint) p[i]; /* words are often faster than bytes */
81 a = ((b & 0x01) << 7) |
82 ((b & 0x02) << 5) |
83 ((b & 0x04) << 3) |
84 ((b & 0x08) << 1) |
85 ((b & 0x10) >> 1) |
86 ((b & 0x20) >> 3) |
87 ((b & 0x40) >> 5) |
88 ((b & 0x80) >> 7);
89 p[i] = (GLubyte) a;
90 }
91 }
92
93
94
95 /*
96 * Unpack a 32x32 pixel polygon stipple from user memory using the
97 * current pixel unpack settings.
98 */
99 void
100 _mesa_unpack_polygon_stipple( const GLubyte *pattern, GLuint dest[32],
101 const struct gl_pixelstore_attrib *unpacking )
102 {
103 GLubyte *ptrn = (GLubyte *) _mesa_unpack_image(2, 32, 32, 1, GL_COLOR_INDEX,
104 GL_BITMAP, pattern, unpacking);
105 if (ptrn) {
106 /* Convert pattern from GLubytes to GLuints and handle big/little
107 * endian differences
108 */
109 GLubyte *p = ptrn;
110 GLint i;
111 for (i = 0; i < 32; i++) {
112 dest[i] = (p[0] << 24)
113 | (p[1] << 16)
114 | (p[2] << 8)
115 | (p[3] );
116 p += 4;
117 }
118 free(ptrn);
119 }
120 }
121
122
123 /*
124 * Pack polygon stipple into user memory given current pixel packing
125 * settings.
126 */
127 void
128 _mesa_pack_polygon_stipple( const GLuint pattern[32], GLubyte *dest,
129 const struct gl_pixelstore_attrib *packing )
130 {
131 /* Convert pattern from GLuints to GLubytes to handle big/little
132 * endian differences.
133 */
134 GLubyte ptrn[32*4];
135 GLint i;
136 for (i = 0; i < 32; i++) {
137 ptrn[i * 4 + 0] = (GLubyte) ((pattern[i] >> 24) & 0xff);
138 ptrn[i * 4 + 1] = (GLubyte) ((pattern[i] >> 16) & 0xff);
139 ptrn[i * 4 + 2] = (GLubyte) ((pattern[i] >> 8 ) & 0xff);
140 ptrn[i * 4 + 3] = (GLubyte) ((pattern[i] ) & 0xff);
141 }
142
143 _mesa_pack_bitmap(32, 32, ptrn, dest, packing);
144 }
145
146
147 /*
148 * Pack bitmap data.
149 */
150 void
151 _mesa_pack_bitmap( GLint width, GLint height, const GLubyte *source,
152 GLubyte *dest, const struct gl_pixelstore_attrib *packing )
153 {
154 GLint row, width_in_bytes;
155 const GLubyte *src;
156
157 if (!source)
158 return;
159
160 width_in_bytes = CEILING( width, 8 );
161 src = source;
162 for (row = 0; row < height; row++) {
163 GLubyte *dst = (GLubyte *) _mesa_image_address2d(packing, dest,
164 width, height, GL_COLOR_INDEX, GL_BITMAP, row, 0);
165 if (!dst)
166 return;
167
168 if ((packing->SkipPixels & 7) == 0) {
169 memcpy( dst, src, width_in_bytes );
170 if (packing->LsbFirst) {
171 flip_bytes( dst, width_in_bytes );
172 }
173 }
174 else {
175 /* handling SkipPixels is a bit tricky (no pun intended!) */
176 GLint i;
177 if (packing->LsbFirst) {
178 GLubyte srcMask = 128;
179 GLubyte dstMask = 1 << (packing->SkipPixels & 0x7);
180 const GLubyte *s = src;
181 GLubyte *d = dst;
182 *d = 0;
183 for (i = 0; i < width; i++) {
184 if (*s & srcMask) {
185 *d |= dstMask;
186 }
187 if (srcMask == 1) {
188 srcMask = 128;
189 s++;
190 }
191 else {
192 srcMask = srcMask >> 1;
193 }
194 if (dstMask == 128) {
195 dstMask = 1;
196 d++;
197 *d = 0;
198 }
199 else {
200 dstMask = dstMask << 1;
201 }
202 }
203 }
204 else {
205 GLubyte srcMask = 128;
206 GLubyte dstMask = 128 >> (packing->SkipPixels & 0x7);
207 const GLubyte *s = src;
208 GLubyte *d = dst;
209 *d = 0;
210 for (i = 0; i < width; i++) {
211 if (*s & srcMask) {
212 *d |= dstMask;
213 }
214 if (srcMask == 1) {
215 srcMask = 128;
216 s++;
217 }
218 else {
219 srcMask = srcMask >> 1;
220 }
221 if (dstMask == 1) {
222 dstMask = 128;
223 d++;
224 *d = 0;
225 }
226 else {
227 dstMask = dstMask >> 1;
228 }
229 }
230 }
231 }
232 src += width_in_bytes;
233 }
234 }
235
236
237 /**
238 * Get indexes of color components for a basic color format, such as
239 * GL_RGBA, GL_RED, GL_LUMINANCE_ALPHA, etc. Return -1 for indexes
240 * that do not apply.
241 */
242 static void
243 get_component_indexes(GLenum format,
244 GLint *redIndex,
245 GLint *greenIndex,
246 GLint *blueIndex,
247 GLint *alphaIndex,
248 GLint *luminanceIndex,
249 GLint *intensityIndex)
250 {
251 *redIndex = -1;
252 *greenIndex = -1;
253 *blueIndex = -1;
254 *alphaIndex = -1;
255 *luminanceIndex = -1;
256 *intensityIndex = -1;
257
258 switch (format) {
259 case GL_LUMINANCE:
260 case GL_LUMINANCE_INTEGER_EXT:
261 *luminanceIndex = 0;
262 break;
263 case GL_LUMINANCE_ALPHA:
264 case GL_LUMINANCE_ALPHA_INTEGER_EXT:
265 *luminanceIndex = 0;
266 *alphaIndex = 1;
267 break;
268 case GL_INTENSITY:
269 *intensityIndex = 0;
270 break;
271 case GL_RED:
272 case GL_RED_INTEGER_EXT:
273 *redIndex = 0;
274 break;
275 case GL_GREEN:
276 case GL_GREEN_INTEGER_EXT:
277 *greenIndex = 0;
278 break;
279 case GL_BLUE:
280 case GL_BLUE_INTEGER_EXT:
281 *blueIndex = 0;
282 break;
283 case GL_ALPHA:
284 case GL_ALPHA_INTEGER_EXT:
285 *alphaIndex = 0;
286 break;
287 case GL_RG:
288 case GL_RG_INTEGER:
289 *redIndex = 0;
290 *greenIndex = 1;
291 break;
292 case GL_RGB:
293 case GL_RGB_INTEGER_EXT:
294 *redIndex = 0;
295 *greenIndex = 1;
296 *blueIndex = 2;
297 break;
298 case GL_BGR:
299 case GL_BGR_INTEGER_EXT:
300 *blueIndex = 0;
301 *greenIndex = 1;
302 *redIndex = 2;
303 break;
304 case GL_RGBA:
305 case GL_RGBA_INTEGER_EXT:
306 *redIndex = 0;
307 *greenIndex = 1;
308 *blueIndex = 2;
309 *alphaIndex = 3;
310 break;
311 case GL_BGRA:
312 case GL_BGRA_INTEGER:
313 *redIndex = 2;
314 *greenIndex = 1;
315 *blueIndex = 0;
316 *alphaIndex = 3;
317 break;
318 case GL_ABGR_EXT:
319 *redIndex = 3;
320 *greenIndex = 2;
321 *blueIndex = 1;
322 *alphaIndex = 0;
323 break;
324 default:
325 assert(0 && "bad format in get_component_indexes()");
326 }
327 }
328
329
330
331 /**
332 * For small integer types, return the min and max possible values.
333 * Used for clamping floats to unscaled integer types.
334 * \return GL_TRUE if type is handled, GL_FALSE otherwise.
335 */
336 static GLboolean
337 get_type_min_max(GLenum type, GLfloat *min, GLfloat *max)
338 {
339 switch (type) {
340 case GL_BYTE:
341 *min = -128.0;
342 *max = 127.0;
343 return GL_TRUE;
344 case GL_UNSIGNED_BYTE:
345 *min = 0.0;
346 *max = 255.0;
347 return GL_TRUE;
348 case GL_SHORT:
349 *min = -32768.0;
350 *max = 32767.0;
351 return GL_TRUE;
352 case GL_UNSIGNED_SHORT:
353 *min = 0.0;
354 *max = 65535.0;
355 return GL_TRUE;
356 default:
357 return GL_FALSE;
358 }
359 }
360
361 /* Customization of unsigned integer packing.
362 */
363 #define SRC_TYPE GLuint
364
365 #define DST_TYPE GLuint
366 #define SRC_CONVERT(x) (x)
367 #define FN_NAME pack_uint_from_uint_rgba
368 #include "pack_tmp.h"
369 #undef DST_TYPE
370 #undef SRC_CONVERT
371 #undef FN_NAME
372
373 #define DST_TYPE GLint
374 #define SRC_CONVERT(x) MIN2(x, 0x7fffffff)
375 #define FN_NAME pack_int_from_uint_rgba
376 #include "pack_tmp.h"
377 #undef DST_TYPE
378 #undef SRC_CONVERT
379 #undef FN_NAME
380
381 #define DST_TYPE GLushort
382 #define SRC_CONVERT(x) MIN2(x, 0xffff)
383 #define FN_NAME pack_ushort_from_uint_rgba
384 #include "pack_tmp.h"
385 #undef DST_TYPE
386 #undef SRC_CONVERT
387 #undef FN_NAME
388
389 #define DST_TYPE GLshort
390 #define SRC_CONVERT(x) CLAMP((int)x, -32768, 32767)
391 #define FN_NAME pack_short_from_uint_rgba
392 #include "pack_tmp.h"
393 #undef DST_TYPE
394 #undef SRC_CONVERT
395 #undef FN_NAME
396
397 #define DST_TYPE GLubyte
398 #define SRC_CONVERT(x) MIN2(x, 0xff)
399 #define FN_NAME pack_ubyte_from_uint_rgba
400 #include "pack_tmp.h"
401 #undef DST_TYPE
402 #undef SRC_CONVERT
403 #undef FN_NAME
404
405 #define DST_TYPE GLbyte
406 #define SRC_CONVERT(x) CLAMP((int)x, -128, 127)
407 #define FN_NAME pack_byte_from_uint_rgba
408 #include "pack_tmp.h"
409 #undef DST_TYPE
410 #undef SRC_CONVERT
411 #undef FN_NAME
412
413 #undef SRC_TYPE
414
415 static void
416 _pack_rgba_span_from_uints_problem(struct gl_context *ctx,
417 GLenum dstFormat, GLenum dstType)
418 {
419 _mesa_problem(ctx,
420 "Unsupported type (%s) / format (%s) "
421 "in _mesa_pack_rgba_span_from_uints",
422 _mesa_lookup_enum_by_nr(dstType),
423 _mesa_lookup_enum_by_nr(dstFormat));
424 }
425
426 void
427 _mesa_pack_rgba_span_from_uints(struct gl_context *ctx, GLuint n, GLuint rgba[][4],
428 GLenum dstFormat, GLenum dstType,
429 GLvoid *dstAddr)
430 {
431 uint32_t dstMesaFormat;
432
433 switch(dstType) {
434 case GL_UNSIGNED_INT:
435 pack_uint_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, NULL, n);
436 break;
437 case GL_INT:
438 pack_int_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, NULL, n);
439 break;
440 case GL_UNSIGNED_SHORT:
441 pack_ushort_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, NULL, n);
442 break;
443 case GL_SHORT:
444 pack_short_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, NULL, n);
445 break;
446 case GL_UNSIGNED_BYTE:
447 pack_ubyte_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, NULL, n);
448 break;
449 case GL_BYTE:
450 pack_byte_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, NULL, n);
451 break;
452 case GL_UNSIGNED_BYTE_3_3_2:
453 case GL_UNSIGNED_BYTE_2_3_3_REV:
454 case GL_UNSIGNED_SHORT_5_6_5:
455 case GL_UNSIGNED_SHORT_5_6_5_REV:
456 case GL_UNSIGNED_SHORT_4_4_4_4:
457 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
458 case GL_UNSIGNED_SHORT_5_5_5_1:
459 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
460 case GL_UNSIGNED_INT_8_8_8_8:
461 case GL_UNSIGNED_INT_8_8_8_8_REV:
462 case GL_UNSIGNED_INT_10_10_10_2:
463 case GL_UNSIGNED_INT_2_10_10_10_REV:
464 dstMesaFormat = _mesa_format_from_format_and_type(dstFormat, dstType);
465 if (!(dstMesaFormat & MESA_ARRAY_FORMAT_BIT)) {
466 _mesa_pack_uint_rgba_row(dstMesaFormat, n, (void *)rgba[0], (void *)dstAddr);
467 break;
468 } else {
469 /* Fall through */
470 }
471 default:
472 _pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
473 return;
474 }
475 }
476
477 /* Customization of signed integer packing.
478 */
479 #define SRC_TYPE GLint
480
481 #define DST_TYPE GLuint
482 #define SRC_CONVERT(x) MAX2(x, 0)
483 #define FN_NAME pack_uint_from_int_rgba
484 #include "pack_tmp.h"
485 #undef DST_TYPE
486 #undef SRC_CONVERT
487 #undef FN_NAME
488
489 #define DST_TYPE GLushort
490 #define SRC_CONVERT(x) MAX2(x, 0)
491 #define FN_NAME pack_ushort_from_int_rgba
492 #include "pack_tmp.h"
493 #undef DST_TYPE
494 #undef SRC_CONVERT
495 #undef FN_NAME
496
497 #define DST_TYPE GLshort
498 #define SRC_CONVERT(x) CLAMP(x, -0x8000, 0x7fff)
499 #define FN_NAME pack_short_from_int_rgba
500 #include "pack_tmp.h"
501 #undef DST_TYPE
502 #undef SRC_CONVERT
503 #undef FN_NAME
504
505 #define DST_TYPE GLubyte
506 #define SRC_CONVERT(x) MAX2(x, 0)
507 #define FN_NAME pack_ubyte_from_int_rgba
508 #include "pack_tmp.h"
509 #undef DST_TYPE
510 #undef SRC_CONVERT
511 #undef FN_NAME
512
513 #define DST_TYPE GLbyte
514 #define SRC_CONVERT(x) CLAMP(x, -0x80, 0x7f)
515 #define FN_NAME pack_byte_from_int_rgba
516 #include "pack_tmp.h"
517 #undef DST_TYPE
518 #undef SRC_CONVERT
519 #undef FN_NAME
520
521 #undef SRC_TYPE
522
523 static void
524 _pack_rgba_span_from_ints_problem(struct gl_context *ctx,
525 GLenum dstFormat, GLenum dstType)
526 {
527 _mesa_problem(ctx,
528 "Unsupported type (%s) / format (%s) "
529 "in _mesa_pack_rgba_span_from_ints",
530 _mesa_lookup_enum_by_nr(dstType),
531 _mesa_lookup_enum_by_nr(dstFormat));
532 }
533
534 void
535 _mesa_pack_rgba_span_from_ints(struct gl_context *ctx, GLuint n, GLint rgba[][4],
536 GLenum dstFormat, GLenum dstType,
537 GLvoid *dstAddr)
538 {
539 uint32_t dstMesaFormat;
540
541 switch(dstType) {
542 case GL_UNSIGNED_INT:
543 pack_uint_from_int_rgba(ctx, dstAddr, dstFormat, rgba, NULL, n);
544 break;
545 case GL_INT:
546 /* No conversion necessary. */
547 pack_uint_from_uint_rgba(ctx, dstAddr, dstFormat, (GLuint (*)[4]) rgba, NULL, n);
548 break;
549 case GL_UNSIGNED_SHORT:
550 pack_ushort_from_int_rgba(ctx, dstAddr, dstFormat, rgba, NULL, n);
551 break;
552 case GL_SHORT:
553 pack_short_from_int_rgba(ctx, dstAddr, dstFormat, rgba, NULL, n);
554 break;
555 case GL_UNSIGNED_BYTE:
556 pack_ubyte_from_int_rgba(ctx, dstAddr, dstFormat, rgba, NULL, n);
557 break;
558 case GL_BYTE:
559 pack_byte_from_int_rgba(ctx, dstAddr, dstFormat, rgba, NULL, n);
560 break;
561 case GL_UNSIGNED_BYTE_3_3_2:
562 case GL_UNSIGNED_BYTE_2_3_3_REV:
563 case GL_UNSIGNED_SHORT_5_6_5:
564 case GL_UNSIGNED_SHORT_5_6_5_REV:
565 case GL_UNSIGNED_SHORT_4_4_4_4:
566 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
567 case GL_UNSIGNED_SHORT_5_5_5_1:
568 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
569 case GL_UNSIGNED_INT_8_8_8_8:
570 case GL_UNSIGNED_INT_8_8_8_8_REV:
571 case GL_UNSIGNED_INT_10_10_10_2:
572 case GL_UNSIGNED_INT_2_10_10_10_REV:
573 dstMesaFormat = _mesa_format_from_format_and_type(dstFormat, dstType);
574 if (!(dstMesaFormat & MESA_ARRAY_FORMAT_BIT)) {
575 _mesa_pack_int_rgba_row(dstMesaFormat, n, (void *)rgba[0], (void *)dstAddr);
576 break;
577 } else {
578 /* Fall through */
579 }
580 default:
581 _pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
582 return;
583 }
584 }
585
586 /* Customization of float packing.
587 */
588 #define SRC_TYPE GLfloat
589
590 #define DST_TYPE GLuint
591 #define FLOAT_SRC_CONVERT(x) FLOAT_TO_UINT(x)
592 #define SRC_CONVERT(x) (GLuint) x
593 #define FN_NAME pack_uint_from_float_rgba
594 #include "pack_tmp.h"
595 #undef DST_TYPE
596 #undef SRC_CONVERT
597 #undef FLOAT_SRC_CONVERT
598 #undef FN_NAME
599
600 #define DST_TYPE GLint
601 #define FLOAT_SRC_CONVERT(x) FLOAT_TO_INT(x)
602 #define SRC_CONVERT(x) (GLint) x
603 #define FN_NAME pack_int_from_float_rgba
604 #include "pack_tmp.h"
605 #undef DST_TYPE
606 #undef SRC_CONVERT
607 #undef FLOAT_SRC_CONVERT
608 #undef FN_NAME
609
610 #define DST_TYPE GLshort
611 #define FLOAT_SRC_CONVERT(x) FLOAT_TO_SHORT_TEX(x)
612 #define SRC_CONVERT(x) (GLshort) x
613 #define FN_NAME pack_short_from_float_rgba
614 #include "pack_tmp.h"
615 #undef DST_TYPE
616 #undef SRC_CONVERT
617 #undef FLOAT_SRC_CONVERT
618 #undef FN_NAME
619
620 #define DST_TYPE GLubyte
621 #define FLOAT_SRC_CONVERT(x) FLOAT_TO_UBYTE(x)
622 #define SRC_CONVERT(x) (GLubyte) x
623 #define FN_NAME pack_ubyte_from_float_rgba
624 #include "pack_tmp.h"
625 #undef DST_TYPE
626 #undef SRC_CONVERT
627 #undef FLOAT_SRC_CONVERT
628 #undef FN_NAME
629
630 #define DST_TYPE GLbyte
631 #define FLOAT_SRC_CONVERT(x) FLOAT_TO_BYTE_TEX(x)
632 #define SRC_CONVERT(x) (GLbyte) x
633 #define FN_NAME pack_byte_from_float_rgba
634 #include "pack_tmp.h"
635 #undef DST_TYPE
636 #undef SRC_CONVERT
637 #undef FLOAT_SRC_CONVERT
638 #undef FN_NAME
639
640 #define DST_TYPE GLfloat
641 #define FLOAT_SRC_CONVERT(x) x
642 #define SRC_CONVERT(x) x
643 #define FN_NAME pack_float_from_float_rgba
644 #include "pack_tmp.h"
645 #undef DST_TYPE
646 #undef SRC_CONVERT
647 #undef FLOAT_SRC_CONVERT
648 #undef FN_NAME
649
650 #define DST_TYPE GLhalfARB
651 #define FLOAT_SRC_CONVERT(x) _mesa_float_to_half(x)
652 #define FN_NAME pack_half_float_from_float_rgba
653 #include "pack_tmp.h"
654 #undef DST_TYPE
655 #undef SRC_CONVERT
656 #undef FLOAT_SRC_CONVERT
657 #undef FN_NAME
658
659 #undef SRC_TYPE
660
661 /**
662 * Used to pack an array [][4] of RGBA float colors as specified
663 * by the dstFormat, dstType and dstPacking. Used by glReadPixels.
664 * Historically, the RGBA values were in [0,1] and rescaled to fit
665 * into GLubytes, etc. But with new integer formats, the RGBA values
666 * may have any value and we don't always rescale when converting to
667 * integers.
668 *
669 * Note: the rgba values will be modified by this function when any pixel
670 * transfer ops are enabled.
671 */
672 void
673 _mesa_pack_rgba_span_float(struct gl_context *ctx, GLuint n, GLfloat rgba[][4],
674 GLenum dstFormat, GLenum dstType,
675 GLvoid *dstAddr,
676 const struct gl_pixelstore_attrib *dstPacking,
677 GLbitfield transferOps)
678 {
679 GLfloat *luminance;
680 const GLint comps = _mesa_components_in_format(dstFormat);
681 const GLboolean intDstFormat = _mesa_is_enum_format_integer(dstFormat);
682 GLuint i;
683 uint32_t dstMesaFormat;
684
685 if (dstFormat == GL_LUMINANCE ||
686 dstFormat == GL_LUMINANCE_ALPHA ||
687 dstFormat == GL_LUMINANCE_INTEGER_EXT ||
688 dstFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT) {
689 luminance = malloc(n * sizeof(GLfloat));
690 if (!luminance) {
691 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
692 return;
693 }
694 }
695 else {
696 luminance = NULL;
697 }
698
699 /* EXT_texture_integer specifies no transfer ops on integer
700 * types in the resolved issues section. Just set them to 0
701 * for integer surfaces.
702 */
703 if (intDstFormat)
704 transferOps = 0;
705
706 if (transferOps) {
707 _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
708 }
709
710 /*
711 * Component clamping (besides clamping to [0,1] in
712 * _mesa_apply_rgba_transfer_ops()).
713 */
714 if (intDstFormat) {
715 /* clamping to dest type's min/max values */
716 GLfloat min, max;
717 if (get_type_min_max(dstType, &min, &max)) {
718 for (i = 0; i < n; i++) {
719 rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], min, max);
720 rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], min, max);
721 rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], min, max);
722 rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], min, max);
723 }
724 }
725 }
726 else if (dstFormat == GL_LUMINANCE || dstFormat == GL_LUMINANCE_ALPHA) {
727 /* compute luminance values */
728 if (transferOps & IMAGE_CLAMP_BIT) {
729 for (i = 0; i < n; i++) {
730 GLfloat sum = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
731 luminance[i] = CLAMP(sum, 0.0F, 1.0F);
732 }
733 }
734 else {
735 for (i = 0; i < n; i++) {
736 luminance[i] = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
737 }
738 }
739 }
740
741 /*
742 * Pack/store the pixels. Ugh! Lots of cases!!!
743 */
744 switch (dstType) {
745 case GL_UNSIGNED_BYTE:
746 pack_ubyte_from_float_rgba(ctx, dstAddr, dstFormat, rgba, luminance, n);
747 break;
748 case GL_BYTE:
749 pack_byte_from_float_rgba(ctx, dstAddr, dstFormat, rgba, luminance, n);
750 break;
751 case GL_UNSIGNED_SHORT:
752 {
753 GLushort *dst = (GLushort *) dstAddr;
754 switch (dstFormat) {
755 case GL_RED:
756 for (i=0;i<n;i++)
757 CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][RCOMP]);
758 break;
759 case GL_GREEN:
760 for (i=0;i<n;i++)
761 CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][GCOMP]);
762 break;
763 case GL_BLUE:
764 for (i=0;i<n;i++)
765 CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][BCOMP]);
766 break;
767 case GL_ALPHA:
768 for (i=0;i<n;i++)
769 CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][ACOMP]);
770 break;
771 case GL_LUMINANCE:
772 for (i=0;i<n;i++)
773 UNCLAMPED_FLOAT_TO_USHORT(dst[i], luminance[i]);
774 break;
775 case GL_LUMINANCE_ALPHA:
776 for (i=0;i<n;i++) {
777 UNCLAMPED_FLOAT_TO_USHORT(dst[i*2+0], luminance[i]);
778 CLAMPED_FLOAT_TO_USHORT(dst[i*2+1], rgba[i][ACOMP]);
779 }
780 break;
781 case GL_RG:
782 for (i=0;i<n;i++) {
783 CLAMPED_FLOAT_TO_USHORT(dst[i*2+0], rgba[i][RCOMP]);
784 CLAMPED_FLOAT_TO_USHORT(dst[i*2+1], rgba[i][GCOMP]);
785 }
786 break;
787 case GL_RGB:
788 for (i=0;i<n;i++) {
789 CLAMPED_FLOAT_TO_USHORT(dst[i*3+0], rgba[i][RCOMP]);
790 CLAMPED_FLOAT_TO_USHORT(dst[i*3+1], rgba[i][GCOMP]);
791 CLAMPED_FLOAT_TO_USHORT(dst[i*3+2], rgba[i][BCOMP]);
792 }
793 break;
794 case GL_RGBA:
795 for (i=0;i<n;i++) {
796 CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][RCOMP]);
797 CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][GCOMP]);
798 CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][BCOMP]);
799 CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][ACOMP]);
800 }
801 break;
802 case GL_BGR:
803 for (i=0;i<n;i++) {
804 CLAMPED_FLOAT_TO_USHORT(dst[i*3+0], rgba[i][BCOMP]);
805 CLAMPED_FLOAT_TO_USHORT(dst[i*3+1], rgba[i][GCOMP]);
806 CLAMPED_FLOAT_TO_USHORT(dst[i*3+2], rgba[i][RCOMP]);
807 }
808 break;
809 case GL_BGRA:
810 for (i=0;i<n;i++) {
811 CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][BCOMP]);
812 CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][GCOMP]);
813 CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][RCOMP]);
814 CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][ACOMP]);
815 }
816 break;
817 case GL_ABGR_EXT:
818 for (i=0;i<n;i++) {
819 CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][ACOMP]);
820 CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][BCOMP]);
821 CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][GCOMP]);
822 CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][RCOMP]);
823 }
824 break;
825 case GL_RED_INTEGER_EXT:
826 for (i=0;i<n;i++) {
827 dst[i] = (GLushort) rgba[i][RCOMP];
828 }
829 break;
830 case GL_GREEN_INTEGER_EXT:
831 for (i=0;i<n;i++) {
832 dst[i] = (GLushort) rgba[i][GCOMP];
833 }
834 break;
835 case GL_BLUE_INTEGER_EXT:
836 for (i=0;i<n;i++) {
837 dst[i] = (GLushort) rgba[i][BCOMP];
838 }
839 break;
840 case GL_ALPHA_INTEGER_EXT:
841 for (i=0;i<n;i++) {
842 dst[i] = (GLushort) rgba[i][ACOMP];
843 }
844 break;
845 case GL_RG_INTEGER:
846 for (i=0;i<n;i++) {
847 dst[i*2+0] = (GLushort) rgba[i][RCOMP];
848 dst[i*2+1] = (GLushort) rgba[i][GCOMP];
849 }
850 break;
851 case GL_RGB_INTEGER_EXT:
852 for (i=0;i<n;i++) {
853 dst[i*3+0] = (GLushort) rgba[i][RCOMP];
854 dst[i*3+1] = (GLushort) rgba[i][GCOMP];
855 dst[i*3+2] = (GLushort) rgba[i][BCOMP];
856 }
857 break;
858 case GL_RGBA_INTEGER_EXT:
859 for (i=0;i<n;i++) {
860 dst[i*4+0] = (GLushort) rgba[i][RCOMP];
861 dst[i*4+1] = (GLushort) rgba[i][GCOMP];
862 dst[i*4+2] = (GLushort) rgba[i][BCOMP];
863 dst[i*4+3] = (GLushort) rgba[i][ACOMP];
864 }
865 break;
866 case GL_BGR_INTEGER_EXT:
867 for (i=0;i<n;i++) {
868 dst[i*3+0] = (GLushort) rgba[i][BCOMP];
869 dst[i*3+1] = (GLushort) rgba[i][GCOMP];
870 dst[i*3+2] = (GLushort) rgba[i][RCOMP];
871 }
872 break;
873 case GL_BGRA_INTEGER_EXT:
874 for (i=0;i<n;i++) {
875 dst[i*4+0] = (GLushort) rgba[i][BCOMP];
876 dst[i*4+1] = (GLushort) rgba[i][GCOMP];
877 dst[i*4+2] = (GLushort) rgba[i][RCOMP];
878 dst[i*4+3] = (GLushort) rgba[i][ACOMP];
879 }
880 break;
881 case GL_LUMINANCE_INTEGER_EXT:
882 for (i=0;i<n;i++) {
883 dst[i*2+0] = (GLushort) (rgba[i][RCOMP] +
884 rgba[i][GCOMP] +
885 rgba[i][BCOMP]);
886 dst[i*2+1] = (GLushort) rgba[i][ACOMP];
887 }
888 break;
889 case GL_LUMINANCE_ALPHA_INTEGER_EXT:
890 for (i=0;i<n;i++) {
891 dst[i] = (GLushort) (rgba[i][RCOMP] +
892 rgba[i][GCOMP] +
893 rgba[i][BCOMP]);
894 }
895 break;
896 default:
897 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
898 }
899 }
900 break;
901 case GL_SHORT:
902 pack_short_from_float_rgba(ctx, dstAddr, dstFormat, rgba, luminance, n);
903 break;
904 case GL_UNSIGNED_INT:
905 pack_uint_from_float_rgba(ctx, dstAddr, dstFormat, rgba, luminance, n);
906 break;
907 case GL_INT:
908 pack_int_from_float_rgba(ctx, dstAddr, dstFormat, rgba, luminance, n);
909 break;
910 case GL_FLOAT:
911 /* No conversion necessary. */
912 pack_float_from_float_rgba(ctx, dstAddr, dstFormat, rgba, luminance, n);
913 break;
914 case GL_HALF_FLOAT_ARB:
915 pack_half_float_from_float_rgba(ctx, dstAddr, dstFormat, rgba, luminance, n);
916 break;
917 case GL_UNSIGNED_BYTE_3_3_2:
918 case GL_UNSIGNED_BYTE_2_3_3_REV:
919 case GL_UNSIGNED_SHORT_5_6_5:
920 case GL_UNSIGNED_SHORT_5_6_5_REV:
921 case GL_UNSIGNED_SHORT_4_4_4_4:
922 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
923 case GL_UNSIGNED_SHORT_5_5_5_1:
924 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
925 case GL_UNSIGNED_INT_8_8_8_8:
926 case GL_UNSIGNED_INT_8_8_8_8_REV:
927 case GL_UNSIGNED_INT_10_10_10_2:
928 case GL_UNSIGNED_INT_2_10_10_10_REV:
929 case GL_UNSIGNED_INT_5_9_9_9_REV:
930 case GL_UNSIGNED_INT_10F_11F_11F_REV:
931 dstMesaFormat = _mesa_format_from_format_and_type(dstFormat, dstType);
932 if (!(dstMesaFormat & MESA_ARRAY_FORMAT_BIT)) {
933 _mesa_pack_float_rgba_row(dstMesaFormat, n, (void *)rgba[0], (void *)dstAddr);
934 break;
935 } else {
936 /* Fall through */
937 }
938 default:
939 _mesa_problem(ctx, "bad type in _mesa_pack_rgba_span_float");
940 free(luminance);
941 return;
942 }
943
944 if (dstPacking->SwapBytes) {
945 GLint swapSize = _mesa_sizeof_packed_type(dstType);
946 if (swapSize == 2) {
947 _mesa_swap2((GLushort *) dstAddr, n * comps);
948 }
949 else if (swapSize == 4) {
950 _mesa_swap4((GLuint *) dstAddr, n * comps);
951 }
952 }
953
954 free(luminance);
955 }
956
957
958
959 #define SWAP2BYTE(VALUE) \
960 { \
961 GLubyte *bytes = (GLubyte *) &(VALUE); \
962 GLubyte tmp = bytes[0]; \
963 bytes[0] = bytes[1]; \
964 bytes[1] = tmp; \
965 }
966
967 #define SWAP4BYTE(VALUE) \
968 { \
969 GLubyte *bytes = (GLubyte *) &(VALUE); \
970 GLubyte tmp = bytes[0]; \
971 bytes[0] = bytes[3]; \
972 bytes[3] = tmp; \
973 tmp = bytes[1]; \
974 bytes[1] = bytes[2]; \
975 bytes[2] = tmp; \
976 }
977
978
979 static void
980 extract_uint_indexes(GLuint n, GLuint indexes[],
981 GLenum srcFormat, GLenum srcType, const GLvoid *src,
982 const struct gl_pixelstore_attrib *unpack )
983 {
984 ASSERT(srcFormat == GL_COLOR_INDEX || srcFormat == GL_STENCIL_INDEX);
985
986 ASSERT(srcType == GL_BITMAP ||
987 srcType == GL_UNSIGNED_BYTE ||
988 srcType == GL_BYTE ||
989 srcType == GL_UNSIGNED_SHORT ||
990 srcType == GL_SHORT ||
991 srcType == GL_UNSIGNED_INT ||
992 srcType == GL_INT ||
993 srcType == GL_UNSIGNED_INT_24_8_EXT ||
994 srcType == GL_HALF_FLOAT_ARB ||
995 srcType == GL_FLOAT ||
996 srcType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
997
998 switch (srcType) {
999 case GL_BITMAP:
1000 {
1001 GLubyte *ubsrc = (GLubyte *) src;
1002 if (unpack->LsbFirst) {
1003 GLubyte mask = 1 << (unpack->SkipPixels & 0x7);
1004 GLuint i;
1005 for (i = 0; i < n; i++) {
1006 indexes[i] = (*ubsrc & mask) ? 1 : 0;
1007 if (mask == 128) {
1008 mask = 1;
1009 ubsrc++;
1010 }
1011 else {
1012 mask = mask << 1;
1013 }
1014 }
1015 }
1016 else {
1017 GLubyte mask = 128 >> (unpack->SkipPixels & 0x7);
1018 GLuint i;
1019 for (i = 0; i < n; i++) {
1020 indexes[i] = (*ubsrc & mask) ? 1 : 0;
1021 if (mask == 1) {
1022 mask = 128;
1023 ubsrc++;
1024 }
1025 else {
1026 mask = mask >> 1;
1027 }
1028 }
1029 }
1030 }
1031 break;
1032 case GL_UNSIGNED_BYTE:
1033 {
1034 GLuint i;
1035 const GLubyte *s = (const GLubyte *) src;
1036 for (i = 0; i < n; i++)
1037 indexes[i] = s[i];
1038 }
1039 break;
1040 case GL_BYTE:
1041 {
1042 GLuint i;
1043 const GLbyte *s = (const GLbyte *) src;
1044 for (i = 0; i < n; i++)
1045 indexes[i] = s[i];
1046 }
1047 break;
1048 case GL_UNSIGNED_SHORT:
1049 {
1050 GLuint i;
1051 const GLushort *s = (const GLushort *) src;
1052 if (unpack->SwapBytes) {
1053 for (i = 0; i < n; i++) {
1054 GLushort value = s[i];
1055 SWAP2BYTE(value);
1056 indexes[i] = value;
1057 }
1058 }
1059 else {
1060 for (i = 0; i < n; i++)
1061 indexes[i] = s[i];
1062 }
1063 }
1064 break;
1065 case GL_SHORT:
1066 {
1067 GLuint i;
1068 const GLshort *s = (const GLshort *) src;
1069 if (unpack->SwapBytes) {
1070 for (i = 0; i < n; i++) {
1071 GLshort value = s[i];
1072 SWAP2BYTE(value);
1073 indexes[i] = value;
1074 }
1075 }
1076 else {
1077 for (i = 0; i < n; i++)
1078 indexes[i] = s[i];
1079 }
1080 }
1081 break;
1082 case GL_UNSIGNED_INT:
1083 {
1084 GLuint i;
1085 const GLuint *s = (const GLuint *) src;
1086 if (unpack->SwapBytes) {
1087 for (i = 0; i < n; i++) {
1088 GLuint value = s[i];
1089 SWAP4BYTE(value);
1090 indexes[i] = value;
1091 }
1092 }
1093 else {
1094 for (i = 0; i < n; i++)
1095 indexes[i] = s[i];
1096 }
1097 }
1098 break;
1099 case GL_INT:
1100 {
1101 GLuint i;
1102 const GLint *s = (const GLint *) src;
1103 if (unpack->SwapBytes) {
1104 for (i = 0; i < n; i++) {
1105 GLint value = s[i];
1106 SWAP4BYTE(value);
1107 indexes[i] = value;
1108 }
1109 }
1110 else {
1111 for (i = 0; i < n; i++)
1112 indexes[i] = s[i];
1113 }
1114 }
1115 break;
1116 case GL_FLOAT:
1117 {
1118 GLuint i;
1119 const GLfloat *s = (const GLfloat *) src;
1120 if (unpack->SwapBytes) {
1121 for (i = 0; i < n; i++) {
1122 GLfloat value = s[i];
1123 SWAP4BYTE(value);
1124 indexes[i] = (GLuint) value;
1125 }
1126 }
1127 else {
1128 for (i = 0; i < n; i++)
1129 indexes[i] = (GLuint) s[i];
1130 }
1131 }
1132 break;
1133 case GL_HALF_FLOAT_ARB:
1134 {
1135 GLuint i;
1136 const GLhalfARB *s = (const GLhalfARB *) src;
1137 if (unpack->SwapBytes) {
1138 for (i = 0; i < n; i++) {
1139 GLhalfARB value = s[i];
1140 SWAP2BYTE(value);
1141 indexes[i] = (GLuint) _mesa_half_to_float(value);
1142 }
1143 }
1144 else {
1145 for (i = 0; i < n; i++)
1146 indexes[i] = (GLuint) _mesa_half_to_float(s[i]);
1147 }
1148 }
1149 break;
1150 case GL_UNSIGNED_INT_24_8_EXT:
1151 {
1152 GLuint i;
1153 const GLuint *s = (const GLuint *) src;
1154 if (unpack->SwapBytes) {
1155 for (i = 0; i < n; i++) {
1156 GLuint value = s[i];
1157 SWAP4BYTE(value);
1158 indexes[i] = value & 0xff; /* lower 8 bits */
1159 }
1160 }
1161 else {
1162 for (i = 0; i < n; i++)
1163 indexes[i] = s[i] & 0xff; /* lower 8 bits */
1164 }
1165 }
1166 break;
1167 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
1168 {
1169 GLuint i;
1170 const GLuint *s = (const GLuint *) src;
1171 if (unpack->SwapBytes) {
1172 for (i = 0; i < n; i++) {
1173 GLuint value = s[i*2+1];
1174 SWAP4BYTE(value);
1175 indexes[i] = value & 0xff; /* lower 8 bits */
1176 }
1177 }
1178 else {
1179 for (i = 0; i < n; i++)
1180 indexes[i] = s[i*2+1] & 0xff; /* lower 8 bits */
1181 }
1182 }
1183 break;
1184
1185 default:
1186 _mesa_problem(NULL, "bad srcType in extract_uint_indexes");
1187 return;
1188 }
1189 }
1190
1191
1192 /**
1193 * Return source/dest RGBA indexes for unpacking pixels.
1194 */
1195 static void
1196 get_component_mapping(GLenum format,
1197 GLint *rSrc,
1198 GLint *gSrc,
1199 GLint *bSrc,
1200 GLint *aSrc,
1201 GLint *rDst,
1202 GLint *gDst,
1203 GLint *bDst,
1204 GLint *aDst)
1205 {
1206 switch (format) {
1207 case GL_RED:
1208 case GL_RED_INTEGER_EXT:
1209 *rSrc = 0;
1210 *gSrc = *bSrc = *aSrc = -1;
1211 break;
1212 case GL_GREEN:
1213 case GL_GREEN_INTEGER_EXT:
1214 *gSrc = 0;
1215 *rSrc = *bSrc = *aSrc = -1;
1216 break;
1217 case GL_BLUE:
1218 case GL_BLUE_INTEGER_EXT:
1219 *bSrc = 0;
1220 *rSrc = *gSrc = *aSrc = -1;
1221 break;
1222 case GL_ALPHA:
1223 case GL_ALPHA_INTEGER_EXT:
1224 *rSrc = *gSrc = *bSrc = -1;
1225 *aSrc = 0;
1226 break;
1227 case GL_LUMINANCE:
1228 case GL_LUMINANCE_INTEGER_EXT:
1229 *rSrc = *gSrc = *bSrc = 0;
1230 *aSrc = -1;
1231 break;
1232 case GL_LUMINANCE_ALPHA:
1233 case GL_LUMINANCE_ALPHA_INTEGER_EXT:
1234 *rSrc = *gSrc = *bSrc = 0;
1235 *aSrc = 1;
1236 break;
1237 case GL_INTENSITY:
1238 *rSrc = *gSrc = *bSrc = *aSrc = 0;
1239 break;
1240 case GL_RG:
1241 case GL_RG_INTEGER:
1242 *rSrc = 0;
1243 *gSrc = 1;
1244 *bSrc = -1;
1245 *aSrc = -1;
1246 *rDst = 0;
1247 *gDst = 1;
1248 *bDst = 2;
1249 *aDst = 3;
1250 break;
1251 case GL_RGB:
1252 case GL_RGB_INTEGER:
1253 *rSrc = 0;
1254 *gSrc = 1;
1255 *bSrc = 2;
1256 *aSrc = -1;
1257 *rDst = 0;
1258 *gDst = 1;
1259 *bDst = 2;
1260 *aDst = 3;
1261 break;
1262 case GL_BGR:
1263 case GL_BGR_INTEGER:
1264 *rSrc = 2;
1265 *gSrc = 1;
1266 *bSrc = 0;
1267 *aSrc = -1;
1268 *rDst = 2;
1269 *gDst = 1;
1270 *bDst = 0;
1271 *aDst = 3;
1272 break;
1273 case GL_RGBA:
1274 case GL_RGBA_INTEGER:
1275 *rSrc = 0;
1276 *gSrc = 1;
1277 *bSrc = 2;
1278 *aSrc = 3;
1279 *rDst = 0;
1280 *gDst = 1;
1281 *bDst = 2;
1282 *aDst = 3;
1283 break;
1284 case GL_BGRA:
1285 case GL_BGRA_INTEGER:
1286 *rSrc = 2;
1287 *gSrc = 1;
1288 *bSrc = 0;
1289 *aSrc = 3;
1290 *rDst = 2;
1291 *gDst = 1;
1292 *bDst = 0;
1293 *aDst = 3;
1294 break;
1295 case GL_ABGR_EXT:
1296 *rSrc = 3;
1297 *gSrc = 2;
1298 *bSrc = 1;
1299 *aSrc = 0;
1300 *rDst = 3;
1301 *gDst = 2;
1302 *bDst = 1;
1303 *aDst = 0;
1304 break;
1305 default:
1306 _mesa_problem(NULL, "bad srcFormat %s in get_component_mapping",
1307 _mesa_lookup_enum_by_nr(format));
1308 return;
1309 }
1310 }
1311
1312
1313
1314 /*
1315 * This function extracts floating point RGBA values from arbitrary
1316 * image data. srcFormat and srcType are the format and type parameters
1317 * passed to glDrawPixels, glTexImage[123]D, glTexSubImage[123]D, etc.
1318 *
1319 * Refering to section 3.6.4 of the OpenGL 1.2 spec, this function
1320 * implements the "Conversion to floating point", "Conversion to RGB",
1321 * and "Final Expansion to RGBA" operations.
1322 *
1323 * Args: n - number of pixels
1324 * rgba - output colors
1325 * srcFormat - format of incoming data
1326 * srcType - data type of incoming data
1327 * src - source data pointer
1328 * swapBytes - perform byteswapping of incoming data?
1329 */
1330 static void
1331 extract_float_rgba(GLuint n, GLfloat rgba[][4],
1332 GLenum srcFormat, GLenum srcType, const GLvoid *src,
1333 GLboolean swapBytes)
1334 {
1335 GLint rSrc, gSrc, bSrc, aSrc;
1336 GLint stride;
1337 GLint rDst, bDst, gDst, aDst;
1338 GLboolean intFormat;
1339 GLfloat rs = 1.0f, gs = 1.0f, bs = 1.0f, as = 1.0f; /* scale factors */
1340
1341 ASSERT(srcFormat == GL_RED ||
1342 srcFormat == GL_GREEN ||
1343 srcFormat == GL_BLUE ||
1344 srcFormat == GL_ALPHA ||
1345 srcFormat == GL_LUMINANCE ||
1346 srcFormat == GL_LUMINANCE_ALPHA ||
1347 srcFormat == GL_INTENSITY ||
1348 srcFormat == GL_RG ||
1349 srcFormat == GL_RGB ||
1350 srcFormat == GL_BGR ||
1351 srcFormat == GL_RGBA ||
1352 srcFormat == GL_BGRA ||
1353 srcFormat == GL_ABGR_EXT ||
1354 srcFormat == GL_RED_INTEGER_EXT ||
1355 srcFormat == GL_GREEN_INTEGER_EXT ||
1356 srcFormat == GL_BLUE_INTEGER_EXT ||
1357 srcFormat == GL_ALPHA_INTEGER_EXT ||
1358 srcFormat == GL_RG_INTEGER ||
1359 srcFormat == GL_RGB_INTEGER_EXT ||
1360 srcFormat == GL_RGBA_INTEGER_EXT ||
1361 srcFormat == GL_BGR_INTEGER_EXT ||
1362 srcFormat == GL_BGRA_INTEGER_EXT ||
1363 srcFormat == GL_LUMINANCE_INTEGER_EXT ||
1364 srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);
1365
1366 ASSERT(srcType == GL_UNSIGNED_BYTE ||
1367 srcType == GL_BYTE ||
1368 srcType == GL_UNSIGNED_SHORT ||
1369 srcType == GL_SHORT ||
1370 srcType == GL_UNSIGNED_INT ||
1371 srcType == GL_INT ||
1372 srcType == GL_HALF_FLOAT_ARB ||
1373 srcType == GL_FLOAT ||
1374 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
1375 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
1376 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
1377 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
1378 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
1379 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
1380 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
1381 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
1382 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
1383 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
1384 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
1385 srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
1386 srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
1387 srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
1388
1389 get_component_mapping(srcFormat,
1390 &rSrc, &gSrc, &bSrc, &aSrc,
1391 &rDst, &gDst, &bDst, &aDst);
1392
1393 stride = _mesa_components_in_format(srcFormat);
1394
1395 intFormat = _mesa_is_enum_format_integer(srcFormat);
1396
1397 #define PROCESS(SRC_INDEX, DST_INDEX, DEFAULT_FLT, DEFAULT_INT, TYPE, CONVERSION) \
1398 if ((SRC_INDEX) < 0) { \
1399 GLuint i; \
1400 if (intFormat) { \
1401 for (i = 0; i < n; i++) { \
1402 rgba[i][DST_INDEX] = DEFAULT_INT; \
1403 } \
1404 } \
1405 else { \
1406 for (i = 0; i < n; i++) { \
1407 rgba[i][DST_INDEX] = DEFAULT_FLT; \
1408 } \
1409 } \
1410 } \
1411 else if (swapBytes) { \
1412 const TYPE *s = (const TYPE *) src; \
1413 GLuint i; \
1414 for (i = 0; i < n; i++) { \
1415 TYPE value = s[SRC_INDEX]; \
1416 if (sizeof(TYPE) == 2) { \
1417 SWAP2BYTE(value); \
1418 } \
1419 else if (sizeof(TYPE) == 4) { \
1420 SWAP4BYTE(value); \
1421 } \
1422 if (intFormat) \
1423 rgba[i][DST_INDEX] = (GLfloat) value; \
1424 else \
1425 rgba[i][DST_INDEX] = (GLfloat) CONVERSION(value); \
1426 s += stride; \
1427 } \
1428 } \
1429 else { \
1430 const TYPE *s = (const TYPE *) src; \
1431 GLuint i; \
1432 if (intFormat) { \
1433 for (i = 0; i < n; i++) { \
1434 rgba[i][DST_INDEX] = (GLfloat) s[SRC_INDEX]; \
1435 s += stride; \
1436 } \
1437 } \
1438 else { \
1439 for (i = 0; i < n; i++) { \
1440 rgba[i][DST_INDEX] = (GLfloat) CONVERSION(s[SRC_INDEX]); \
1441 s += stride; \
1442 } \
1443 } \
1444 }
1445
1446 switch (srcType) {
1447 case GL_UNSIGNED_BYTE:
1448 PROCESS(rSrc, RCOMP, 0.0F, 0, GLubyte, UBYTE_TO_FLOAT);
1449 PROCESS(gSrc, GCOMP, 0.0F, 0, GLubyte, UBYTE_TO_FLOAT);
1450 PROCESS(bSrc, BCOMP, 0.0F, 0, GLubyte, UBYTE_TO_FLOAT);
1451 PROCESS(aSrc, ACOMP, 1.0F, 255, GLubyte, UBYTE_TO_FLOAT);
1452 break;
1453 case GL_BYTE:
1454 PROCESS(rSrc, RCOMP, 0.0F, 0, GLbyte, BYTE_TO_FLOAT_TEX);
1455 PROCESS(gSrc, GCOMP, 0.0F, 0, GLbyte, BYTE_TO_FLOAT_TEX);
1456 PROCESS(bSrc, BCOMP, 0.0F, 0, GLbyte, BYTE_TO_FLOAT_TEX);
1457 PROCESS(aSrc, ACOMP, 1.0F, 127, GLbyte, BYTE_TO_FLOAT_TEX);
1458 break;
1459 case GL_UNSIGNED_SHORT:
1460 PROCESS(rSrc, RCOMP, 0.0F, 0, GLushort, USHORT_TO_FLOAT);
1461 PROCESS(gSrc, GCOMP, 0.0F, 0, GLushort, USHORT_TO_FLOAT);
1462 PROCESS(bSrc, BCOMP, 0.0F, 0, GLushort, USHORT_TO_FLOAT);
1463 PROCESS(aSrc, ACOMP, 1.0F, 0xffff, GLushort, USHORT_TO_FLOAT);
1464 break;
1465 case GL_SHORT:
1466 PROCESS(rSrc, RCOMP, 0.0F, 0, GLshort, SHORT_TO_FLOAT_TEX);
1467 PROCESS(gSrc, GCOMP, 0.0F, 0, GLshort, SHORT_TO_FLOAT_TEX);
1468 PROCESS(bSrc, BCOMP, 0.0F, 0, GLshort, SHORT_TO_FLOAT_TEX);
1469 PROCESS(aSrc, ACOMP, 1.0F, 32767, GLshort, SHORT_TO_FLOAT_TEX);
1470 break;
1471 case GL_UNSIGNED_INT:
1472 PROCESS(rSrc, RCOMP, 0.0F, 0, GLuint, UINT_TO_FLOAT);
1473 PROCESS(gSrc, GCOMP, 0.0F, 0, GLuint, UINT_TO_FLOAT);
1474 PROCESS(bSrc, BCOMP, 0.0F, 0, GLuint, UINT_TO_FLOAT);
1475 PROCESS(aSrc, ACOMP, 1.0F, 0xffffffff, GLuint, UINT_TO_FLOAT);
1476 break;
1477 case GL_INT:
1478 PROCESS(rSrc, RCOMP, 0.0F, 0, GLint, INT_TO_FLOAT);
1479 PROCESS(gSrc, GCOMP, 0.0F, 0, GLint, INT_TO_FLOAT);
1480 PROCESS(bSrc, BCOMP, 0.0F, 0, GLint, INT_TO_FLOAT);
1481 PROCESS(aSrc, ACOMP, 1.0F, 2147483647, GLint, INT_TO_FLOAT);
1482 break;
1483 case GL_FLOAT:
1484 PROCESS(rSrc, RCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
1485 PROCESS(gSrc, GCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
1486 PROCESS(bSrc, BCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
1487 PROCESS(aSrc, ACOMP, 1.0F, 1.0F, GLfloat, (GLfloat));
1488 break;
1489 case GL_HALF_FLOAT_ARB:
1490 PROCESS(rSrc, RCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
1491 PROCESS(gSrc, GCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
1492 PROCESS(bSrc, BCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
1493 PROCESS(aSrc, ACOMP, 1.0F, 1.0F, GLhalfARB, _mesa_half_to_float);
1494 break;
1495 case GL_UNSIGNED_BYTE_3_3_2:
1496 {
1497 const GLubyte *ubsrc = (const GLubyte *) src;
1498 GLuint i;
1499 if (!intFormat) {
1500 rs = 1.0F / 7.0F;
1501 gs = 1.0F / 7.0F;
1502 bs = 1.0F / 3.0F;
1503 }
1504 for (i = 0; i < n; i ++) {
1505 GLubyte p = ubsrc[i];
1506 rgba[i][rDst] = ((p >> 5) ) * rs;
1507 rgba[i][gDst] = ((p >> 2) & 0x7) * gs;
1508 rgba[i][bDst] = ((p ) & 0x3) * bs;
1509 rgba[i][aDst] = 1.0F;
1510 }
1511 }
1512 break;
1513 case GL_UNSIGNED_BYTE_2_3_3_REV:
1514 {
1515 const GLubyte *ubsrc = (const GLubyte *) src;
1516 GLuint i;
1517 if (!intFormat) {
1518 rs = 1.0F / 7.0F;
1519 gs = 1.0F / 7.0F;
1520 bs = 1.0F / 3.0F;
1521 }
1522 for (i = 0; i < n; i ++) {
1523 GLubyte p = ubsrc[i];
1524 rgba[i][rDst] = ((p ) & 0x7) * rs;
1525 rgba[i][gDst] = ((p >> 3) & 0x7) * gs;
1526 rgba[i][bDst] = ((p >> 6) ) * bs;
1527 rgba[i][aDst] = 1.0F;
1528 }
1529 }
1530 break;
1531 case GL_UNSIGNED_SHORT_5_6_5:
1532 if (!intFormat) {
1533 rs = 1.0F / 31.0F;
1534 gs = 1.0F / 63.0F;
1535 bs = 1.0F / 31.0F;
1536 }
1537 if (swapBytes) {
1538 const GLushort *ussrc = (const GLushort *) src;
1539 GLuint i;
1540 for (i = 0; i < n; i ++) {
1541 GLushort p = ussrc[i];
1542 SWAP2BYTE(p);
1543 rgba[i][rDst] = ((p >> 11) ) * rs;
1544 rgba[i][gDst] = ((p >> 5) & 0x3f) * gs;
1545 rgba[i][bDst] = ((p ) & 0x1f) * bs;
1546 rgba[i][aDst] = 1.0F;
1547 }
1548 }
1549 else {
1550 const GLushort *ussrc = (const GLushort *) src;
1551 GLuint i;
1552 for (i = 0; i < n; i ++) {
1553 GLushort p = ussrc[i];
1554 rgba[i][rDst] = ((p >> 11) ) * rs;
1555 rgba[i][gDst] = ((p >> 5) & 0x3f) * gs;
1556 rgba[i][bDst] = ((p ) & 0x1f) * bs;
1557 rgba[i][aDst] = 1.0F;
1558 }
1559 }
1560 break;
1561 case GL_UNSIGNED_SHORT_5_6_5_REV:
1562 if (!intFormat) {
1563 rs = 1.0F / 31.0F;
1564 gs = 1.0F / 63.0F;
1565 bs = 1.0F / 31.0F;
1566 }
1567 if (swapBytes) {
1568 const GLushort *ussrc = (const GLushort *) src;
1569 GLuint i;
1570 for (i = 0; i < n; i ++) {
1571 GLushort p = ussrc[i];
1572 SWAP2BYTE(p);
1573 rgba[i][rDst] = ((p ) & 0x1f) * rs;
1574 rgba[i][gDst] = ((p >> 5) & 0x3f) * gs;
1575 rgba[i][bDst] = ((p >> 11) ) * bs;
1576 rgba[i][aDst] = 1.0F;
1577 }
1578 }
1579 else {
1580 const GLushort *ussrc = (const GLushort *) src;
1581 GLuint i;
1582 for (i = 0; i < n; i ++) {
1583 GLushort p = ussrc[i];
1584 rgba[i][rDst] = ((p ) & 0x1f) * rs;
1585 rgba[i][gDst] = ((p >> 5) & 0x3f) * gs;
1586 rgba[i][bDst] = ((p >> 11) ) * bs;
1587 rgba[i][aDst] = 1.0F;
1588 }
1589 }
1590 break;
1591 case GL_UNSIGNED_SHORT_4_4_4_4:
1592 if (!intFormat) {
1593 rs = gs = bs = as = 1.0F / 15.0F;
1594 }
1595 if (swapBytes) {
1596 const GLushort *ussrc = (const GLushort *) src;
1597 GLuint i;
1598 for (i = 0; i < n; i ++) {
1599 GLushort p = ussrc[i];
1600 SWAP2BYTE(p);
1601 rgba[i][rDst] = ((p >> 12) ) * rs;
1602 rgba[i][gDst] = ((p >> 8) & 0xf) * gs;
1603 rgba[i][bDst] = ((p >> 4) & 0xf) * bs;
1604 rgba[i][aDst] = ((p ) & 0xf) * as;
1605 }
1606 }
1607 else {
1608 const GLushort *ussrc = (const GLushort *) src;
1609 GLuint i;
1610 for (i = 0; i < n; i ++) {
1611 GLushort p = ussrc[i];
1612 rgba[i][rDst] = ((p >> 12) ) * rs;
1613 rgba[i][gDst] = ((p >> 8) & 0xf) * gs;
1614 rgba[i][bDst] = ((p >> 4) & 0xf) * bs;
1615 rgba[i][aDst] = ((p ) & 0xf) * as;
1616 }
1617 }
1618 break;
1619 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1620 if (!intFormat) {
1621 rs = gs = bs = as = 1.0F / 15.0F;
1622 }
1623 if (swapBytes) {
1624 const GLushort *ussrc = (const GLushort *) src;
1625 GLuint i;
1626 for (i = 0; i < n; i ++) {
1627 GLushort p = ussrc[i];
1628 SWAP2BYTE(p);
1629 rgba[i][rDst] = ((p ) & 0xf) * rs;
1630 rgba[i][gDst] = ((p >> 4) & 0xf) * gs;
1631 rgba[i][bDst] = ((p >> 8) & 0xf) * bs;
1632 rgba[i][aDst] = ((p >> 12) ) * as;
1633 }
1634 }
1635 else {
1636 const GLushort *ussrc = (const GLushort *) src;
1637 GLuint i;
1638 for (i = 0; i < n; i ++) {
1639 GLushort p = ussrc[i];
1640 rgba[i][rDst] = ((p ) & 0xf) * rs;
1641 rgba[i][gDst] = ((p >> 4) & 0xf) * gs;
1642 rgba[i][bDst] = ((p >> 8) & 0xf) * bs;
1643 rgba[i][aDst] = ((p >> 12) ) * as;
1644 }
1645 }
1646 break;
1647 case GL_UNSIGNED_SHORT_5_5_5_1:
1648 if (!intFormat) {
1649 rs = gs = bs = 1.0F / 31.0F;
1650 }
1651 if (swapBytes) {
1652 const GLushort *ussrc = (const GLushort *) src;
1653 GLuint i;
1654 for (i = 0; i < n; i ++) {
1655 GLushort p = ussrc[i];
1656 SWAP2BYTE(p);
1657 rgba[i][rDst] = ((p >> 11) ) * rs;
1658 rgba[i][gDst] = ((p >> 6) & 0x1f) * gs;
1659 rgba[i][bDst] = ((p >> 1) & 0x1f) * bs;
1660 rgba[i][aDst] = ((p ) & 0x1) * as;
1661 }
1662 }
1663 else {
1664 const GLushort *ussrc = (const GLushort *) src;
1665 GLuint i;
1666 for (i = 0; i < n; i ++) {
1667 GLushort p = ussrc[i];
1668 rgba[i][rDst] = ((p >> 11) ) * rs;
1669 rgba[i][gDst] = ((p >> 6) & 0x1f) * gs;
1670 rgba[i][bDst] = ((p >> 1) & 0x1f) * bs;
1671 rgba[i][aDst] = ((p ) & 0x1) * as;
1672 }
1673 }
1674 break;
1675 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1676 if (!intFormat) {
1677 rs = gs = bs = 1.0F / 31.0F;
1678 }
1679 if (swapBytes) {
1680 const GLushort *ussrc = (const GLushort *) src;
1681 GLuint i;
1682 for (i = 0; i < n; i ++) {
1683 GLushort p = ussrc[i];
1684 SWAP2BYTE(p);
1685 rgba[i][rDst] = ((p ) & 0x1f) * rs;
1686 rgba[i][gDst] = ((p >> 5) & 0x1f) * gs;
1687 rgba[i][bDst] = ((p >> 10) & 0x1f) * bs;
1688 rgba[i][aDst] = ((p >> 15) ) * as;
1689 }
1690 }
1691 else {
1692 const GLushort *ussrc = (const GLushort *) src;
1693 GLuint i;
1694 for (i = 0; i < n; i ++) {
1695 GLushort p = ussrc[i];
1696 rgba[i][rDst] = ((p ) & 0x1f) * rs;
1697 rgba[i][gDst] = ((p >> 5) & 0x1f) * gs;
1698 rgba[i][bDst] = ((p >> 10) & 0x1f) * bs;
1699 rgba[i][aDst] = ((p >> 15) ) * as;
1700 }
1701 }
1702 break;
1703 case GL_UNSIGNED_INT_8_8_8_8:
1704 if (swapBytes) {
1705 const GLuint *uisrc = (const GLuint *) src;
1706 GLuint i;
1707 if (intFormat) {
1708 for (i = 0; i < n; i ++) {
1709 GLuint p = uisrc[i];
1710 rgba[i][rDst] = (GLfloat) ((p ) & 0xff);
1711 rgba[i][gDst] = (GLfloat) ((p >> 8) & 0xff);
1712 rgba[i][bDst] = (GLfloat) ((p >> 16) & 0xff);
1713 rgba[i][aDst] = (GLfloat) ((p >> 24) );
1714 }
1715 }
1716 else {
1717 for (i = 0; i < n; i ++) {
1718 GLuint p = uisrc[i];
1719 rgba[i][rDst] = UBYTE_TO_FLOAT((p ) & 0xff);
1720 rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
1721 rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
1722 rgba[i][aDst] = UBYTE_TO_FLOAT((p >> 24) );
1723 }
1724 }
1725 }
1726 else {
1727 const GLuint *uisrc = (const GLuint *) src;
1728 GLuint i;
1729 if (intFormat) {
1730 for (i = 0; i < n; i ++) {
1731 GLuint p = uisrc[i];
1732 rgba[i][rDst] = (GLfloat) ((p >> 24) );
1733 rgba[i][gDst] = (GLfloat) ((p >> 16) & 0xff);
1734 rgba[i][bDst] = (GLfloat) ((p >> 8) & 0xff);
1735 rgba[i][aDst] = (GLfloat) ((p ) & 0xff);
1736 }
1737 }
1738 else {
1739 for (i = 0; i < n; i ++) {
1740 GLuint p = uisrc[i];
1741 rgba[i][rDst] = UBYTE_TO_FLOAT((p >> 24) );
1742 rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
1743 rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
1744 rgba[i][aDst] = UBYTE_TO_FLOAT((p ) & 0xff);
1745 }
1746 }
1747 }
1748 break;
1749 case GL_UNSIGNED_INT_8_8_8_8_REV:
1750 if (swapBytes) {
1751 const GLuint *uisrc = (const GLuint *) src;
1752 GLuint i;
1753 if (intFormat) {
1754 for (i = 0; i < n; i ++) {
1755 GLuint p = uisrc[i];
1756 rgba[i][rDst] = (GLfloat) ((p >> 24) );
1757 rgba[i][gDst] = (GLfloat) ((p >> 16) & 0xff);
1758 rgba[i][bDst] = (GLfloat) ((p >> 8) & 0xff);
1759 rgba[i][aDst] = (GLfloat) ((p ) & 0xff);
1760 }
1761 }
1762 else {
1763 for (i = 0; i < n; i ++) {
1764 GLuint p = uisrc[i];
1765 rgba[i][rDst] = UBYTE_TO_FLOAT((p >> 24) );
1766 rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
1767 rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
1768 rgba[i][aDst] = UBYTE_TO_FLOAT((p ) & 0xff);
1769 }
1770 }
1771 }
1772 else {
1773 const GLuint *uisrc = (const GLuint *) src;
1774 GLuint i;
1775 if (intFormat) {
1776 for (i = 0; i < n; i ++) {
1777 GLuint p = uisrc[i];
1778 rgba[i][rDst] = (GLfloat) ((p ) & 0xff);
1779 rgba[i][gDst] = (GLfloat) ((p >> 8) & 0xff);
1780 rgba[i][bDst] = (GLfloat) ((p >> 16) & 0xff);
1781 rgba[i][aDst] = (GLfloat) ((p >> 24) );
1782 }
1783 }
1784 else {
1785 for (i = 0; i < n; i ++) {
1786 GLuint p = uisrc[i];
1787 rgba[i][rDst] = UBYTE_TO_FLOAT((p ) & 0xff);
1788 rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
1789 rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
1790 rgba[i][aDst] = UBYTE_TO_FLOAT((p >> 24) );
1791 }
1792 }
1793 }
1794 break;
1795 case GL_UNSIGNED_INT_10_10_10_2:
1796 if (!intFormat) {
1797 rs = 1.0F / 1023.0F;
1798 gs = 1.0F / 1023.0F;
1799 bs = 1.0F / 1023.0F;
1800 as = 1.0F / 3.0F;
1801 }
1802 if (swapBytes) {
1803 const GLuint *uisrc = (const GLuint *) src;
1804 GLuint i;
1805 for (i = 0; i < n; i ++) {
1806 GLuint p = uisrc[i];
1807 SWAP4BYTE(p);
1808 rgba[i][rDst] = ((p >> 22) ) * rs;
1809 rgba[i][gDst] = ((p >> 12) & 0x3ff) * gs;
1810 rgba[i][bDst] = ((p >> 2) & 0x3ff) * bs;
1811 rgba[i][aDst] = ((p ) & 0x3 ) * as;
1812 }
1813 }
1814 else {
1815 const GLuint *uisrc = (const GLuint *) src;
1816 GLuint i;
1817 for (i = 0; i < n; i ++) {
1818 GLuint p = uisrc[i];
1819 rgba[i][rDst] = ((p >> 22) ) * rs;
1820 rgba[i][gDst] = ((p >> 12) & 0x3ff) * gs;
1821 rgba[i][bDst] = ((p >> 2) & 0x3ff) * bs;
1822 rgba[i][aDst] = ((p ) & 0x3 ) * as;
1823 }
1824 }
1825 break;
1826 case GL_UNSIGNED_INT_2_10_10_10_REV:
1827 if (!intFormat) {
1828 rs = 1.0F / 1023.0F;
1829 gs = 1.0F / 1023.0F;
1830 bs = 1.0F / 1023.0F;
1831 as = 1.0F / 3.0F;
1832 }
1833 if (swapBytes) {
1834 const GLuint *uisrc = (const GLuint *) src;
1835 GLuint i;
1836 for (i = 0; i < n; i ++) {
1837 GLuint p = uisrc[i];
1838 SWAP4BYTE(p);
1839 rgba[i][rDst] = ((p ) & 0x3ff) * rs;
1840 rgba[i][gDst] = ((p >> 10) & 0x3ff) * gs;
1841 rgba[i][bDst] = ((p >> 20) & 0x3ff) * bs;
1842 if (aSrc < 0) {
1843 rgba[i][aDst] = 1.0F;
1844 } else {
1845 rgba[i][aDst] = (p >> 30) * as;
1846 }
1847 }
1848 }
1849 else {
1850 const GLuint *uisrc = (const GLuint *) src;
1851 GLuint i;
1852 for (i = 0; i < n; i ++) {
1853 GLuint p = uisrc[i];
1854 rgba[i][rDst] = ((p ) & 0x3ff) * rs;
1855 rgba[i][gDst] = ((p >> 10) & 0x3ff) * gs;
1856 rgba[i][bDst] = ((p >> 20) & 0x3ff) * bs;
1857 if (aSrc < 0) {
1858 rgba[i][aDst] = 1.0F;
1859 } else {
1860 rgba[i][aDst] = (p >> 30) * as;
1861 }
1862 }
1863 }
1864 break;
1865 case GL_UNSIGNED_INT_5_9_9_9_REV:
1866 if (swapBytes) {
1867 const GLuint *uisrc = (const GLuint *) src;
1868 GLuint i;
1869 GLfloat f[3];
1870 for (i = 0; i < n; i ++) {
1871 GLuint p = uisrc[i];
1872 SWAP4BYTE(p);
1873 rgb9e5_to_float3(p, f);
1874 rgba[i][rDst] = f[0];
1875 rgba[i][gDst] = f[1];
1876 rgba[i][bDst] = f[2];
1877 rgba[i][aDst] = 1.0F;
1878 }
1879 }
1880 else {
1881 const GLuint *uisrc = (const GLuint *) src;
1882 GLuint i;
1883 GLfloat f[3];
1884 for (i = 0; i < n; i ++) {
1885 rgb9e5_to_float3(uisrc[i], f);
1886 rgba[i][rDst] = f[0];
1887 rgba[i][gDst] = f[1];
1888 rgba[i][bDst] = f[2];
1889 rgba[i][aDst] = 1.0F;
1890 }
1891 }
1892 break;
1893 case GL_UNSIGNED_INT_10F_11F_11F_REV:
1894 if (swapBytes) {
1895 const GLuint *uisrc = (const GLuint *) src;
1896 GLuint i;
1897 GLfloat f[3];
1898 for (i = 0; i < n; i ++) {
1899 GLuint p = uisrc[i];
1900 SWAP4BYTE(p);
1901 r11g11b10f_to_float3(p, f);
1902 rgba[i][rDst] = f[0];
1903 rgba[i][gDst] = f[1];
1904 rgba[i][bDst] = f[2];
1905 rgba[i][aDst] = 1.0F;
1906 }
1907 }
1908 else {
1909 const GLuint *uisrc = (const GLuint *) src;
1910 GLuint i;
1911 GLfloat f[3];
1912 for (i = 0; i < n; i ++) {
1913 r11g11b10f_to_float3(uisrc[i], f);
1914 rgba[i][rDst] = f[0];
1915 rgba[i][gDst] = f[1];
1916 rgba[i][bDst] = f[2];
1917 rgba[i][aDst] = 1.0F;
1918 }
1919 }
1920 break;
1921 default:
1922 _mesa_problem(NULL, "bad srcType in extract float data");
1923 break;
1924 }
1925 #undef PROCESS
1926 }
1927
1928
1929 static inline GLuint
1930 clamp_float_to_uint(GLfloat f)
1931 {
1932 return f < 0.0F ? 0 : F_TO_I(f);
1933 }
1934
1935
1936 static inline GLuint
1937 clamp_half_to_uint(GLhalfARB h)
1938 {
1939 GLfloat f = _mesa_half_to_float(h);
1940 return f < 0.0F ? 0 : F_TO_I(f);
1941 }
1942
1943
1944 /**
1945 * Same as _mesa_unpack_color_span_ubyte(), but return GLfloat data
1946 * instead of GLubyte.
1947 */
1948 void
1949 _mesa_unpack_color_span_float( struct gl_context *ctx,
1950 GLuint n, GLenum dstFormat, GLfloat dest[],
1951 GLenum srcFormat, GLenum srcType,
1952 const GLvoid *source,
1953 const struct gl_pixelstore_attrib *srcPacking,
1954 GLbitfield transferOps )
1955 {
1956 ASSERT(dstFormat == GL_ALPHA ||
1957 dstFormat == GL_LUMINANCE ||
1958 dstFormat == GL_LUMINANCE_ALPHA ||
1959 dstFormat == GL_INTENSITY ||
1960 dstFormat == GL_RED ||
1961 dstFormat == GL_RG ||
1962 dstFormat == GL_RGB ||
1963 dstFormat == GL_RGBA);
1964
1965 ASSERT(srcFormat == GL_RED ||
1966 srcFormat == GL_GREEN ||
1967 srcFormat == GL_BLUE ||
1968 srcFormat == GL_ALPHA ||
1969 srcFormat == GL_LUMINANCE ||
1970 srcFormat == GL_LUMINANCE_ALPHA ||
1971 srcFormat == GL_INTENSITY ||
1972 srcFormat == GL_RG ||
1973 srcFormat == GL_RGB ||
1974 srcFormat == GL_BGR ||
1975 srcFormat == GL_RGBA ||
1976 srcFormat == GL_BGRA ||
1977 srcFormat == GL_ABGR_EXT ||
1978 srcFormat == GL_RED_INTEGER_EXT ||
1979 srcFormat == GL_GREEN_INTEGER_EXT ||
1980 srcFormat == GL_BLUE_INTEGER_EXT ||
1981 srcFormat == GL_ALPHA_INTEGER_EXT ||
1982 srcFormat == GL_RG_INTEGER ||
1983 srcFormat == GL_RGB_INTEGER_EXT ||
1984 srcFormat == GL_RGBA_INTEGER_EXT ||
1985 srcFormat == GL_BGR_INTEGER_EXT ||
1986 srcFormat == GL_BGRA_INTEGER_EXT ||
1987 srcFormat == GL_LUMINANCE_INTEGER_EXT ||
1988 srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT ||
1989 srcFormat == GL_COLOR_INDEX);
1990
1991 ASSERT(srcType == GL_BITMAP ||
1992 srcType == GL_UNSIGNED_BYTE ||
1993 srcType == GL_BYTE ||
1994 srcType == GL_UNSIGNED_SHORT ||
1995 srcType == GL_SHORT ||
1996 srcType == GL_UNSIGNED_INT ||
1997 srcType == GL_INT ||
1998 srcType == GL_HALF_FLOAT_ARB ||
1999 srcType == GL_FLOAT ||
2000 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
2001 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
2002 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
2003 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
2004 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
2005 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
2006 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
2007 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
2008 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
2009 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
2010 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
2011 srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
2012 srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
2013 srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
2014
2015 /* general solution, no special cases, yet */
2016 {
2017 GLint dstComponents;
2018 GLint rDst, gDst, bDst, aDst, lDst, iDst;
2019 GLfloat (*rgba)[4] = malloc(4 * n * sizeof(GLfloat));
2020 GLboolean intFormat = _mesa_is_enum_format_integer(srcFormat);
2021
2022 if (!rgba) {
2023 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
2024 return;
2025 }
2026
2027 dstComponents = _mesa_components_in_format( dstFormat );
2028 /* source & dest image formats should have been error checked by now */
2029 assert(dstComponents > 0);
2030
2031 /* EXT_texture_integer specifies no transfer ops on integer
2032 * types in the resolved issues section. Just set them to 0
2033 * for integer surfaces.
2034 */
2035 if (intFormat)
2036 transferOps = 0;
2037
2038 /*
2039 * Extract image data and convert to RGBA floats
2040 */
2041 if (srcFormat == GL_COLOR_INDEX) {
2042 GLuint *indexes = malloc(n * sizeof(GLuint));
2043
2044 if (!indexes) {
2045 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
2046 free(rgba);
2047 return;
2048 }
2049
2050 extract_uint_indexes(n, indexes, srcFormat, srcType, source,
2051 srcPacking);
2052
2053 /* Convert indexes to RGBA */
2054 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
2055 _mesa_shift_and_offset_ci(ctx, n, indexes);
2056 }
2057 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
2058
2059 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
2060 * with color indexes.
2061 */
2062 transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT);
2063
2064 free(indexes);
2065 }
2066 else {
2067 /* non-color index data */
2068 extract_float_rgba(n, rgba, srcFormat, srcType, source,
2069 srcPacking->SwapBytes);
2070 }
2071
2072 if (transferOps) {
2073 _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
2074 }
2075
2076 get_component_indexes(dstFormat,
2077 &rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
2078
2079 /* Now pack results in the requested dstFormat */
2080 if (rDst >= 0) {
2081 GLfloat *dst = dest;
2082 GLuint i;
2083 for (i = 0; i < n; i++) {
2084 dst[rDst] = rgba[i][RCOMP];
2085 dst += dstComponents;
2086 }
2087 }
2088
2089 if (gDst >= 0) {
2090 GLfloat *dst = dest;
2091 GLuint i;
2092 for (i = 0; i < n; i++) {
2093 dst[gDst] = rgba[i][GCOMP];
2094 dst += dstComponents;
2095 }
2096 }
2097
2098 if (bDst >= 0) {
2099 GLfloat *dst = dest;
2100 GLuint i;
2101 for (i = 0; i < n; i++) {
2102 dst[bDst] = rgba[i][BCOMP];
2103 dst += dstComponents;
2104 }
2105 }
2106
2107 if (aDst >= 0) {
2108 GLfloat *dst = dest;
2109 GLuint i;
2110 for (i = 0; i < n; i++) {
2111 dst[aDst] = rgba[i][ACOMP];
2112 dst += dstComponents;
2113 }
2114 }
2115
2116 if (iDst >= 0) {
2117 GLfloat *dst = dest;
2118 GLuint i;
2119 assert(iDst == 0);
2120 assert(dstComponents == 1);
2121 for (i = 0; i < n; i++) {
2122 /* Intensity comes from red channel */
2123 dst[i] = rgba[i][RCOMP];
2124 }
2125 }
2126
2127 if (lDst >= 0) {
2128 GLfloat *dst = dest;
2129 GLuint i;
2130 assert(lDst == 0);
2131 for (i = 0; i < n; i++) {
2132 /* Luminance comes from red channel */
2133 dst[0] = rgba[i][RCOMP];
2134 dst += dstComponents;
2135 }
2136 }
2137
2138 free(rgba);
2139 }
2140 }
2141
2142
2143 /*
2144 * Unpack a row of color index data from a client buffer according to
2145 * the pixel unpacking parameters.
2146 * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.
2147 *
2148 * Args: ctx - the context
2149 * n - number of pixels
2150 * dstType - destination data type
2151 * dest - destination array
2152 * srcType - source pixel type
2153 * source - source data pointer
2154 * srcPacking - pixel unpacking parameters
2155 * transferOps - the pixel transfer operations to apply
2156 */
2157 void
2158 _mesa_unpack_index_span( struct gl_context *ctx, GLuint n,
2159 GLenum dstType, GLvoid *dest,
2160 GLenum srcType, const GLvoid *source,
2161 const struct gl_pixelstore_attrib *srcPacking,
2162 GLbitfield transferOps )
2163 {
2164 ASSERT(srcType == GL_BITMAP ||
2165 srcType == GL_UNSIGNED_BYTE ||
2166 srcType == GL_BYTE ||
2167 srcType == GL_UNSIGNED_SHORT ||
2168 srcType == GL_SHORT ||
2169 srcType == GL_UNSIGNED_INT ||
2170 srcType == GL_INT ||
2171 srcType == GL_HALF_FLOAT_ARB ||
2172 srcType == GL_FLOAT);
2173
2174 ASSERT(dstType == GL_UNSIGNED_BYTE ||
2175 dstType == GL_UNSIGNED_SHORT ||
2176 dstType == GL_UNSIGNED_INT);
2177
2178
2179 transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
2180
2181 /*
2182 * Try simple cases first
2183 */
2184 if (transferOps == 0 && srcType == GL_UNSIGNED_BYTE
2185 && dstType == GL_UNSIGNED_BYTE) {
2186 memcpy(dest, source, n * sizeof(GLubyte));
2187 }
2188 else if (transferOps == 0 && srcType == GL_UNSIGNED_INT
2189 && dstType == GL_UNSIGNED_INT && !srcPacking->SwapBytes) {
2190 memcpy(dest, source, n * sizeof(GLuint));
2191 }
2192 else {
2193 /*
2194 * general solution
2195 */
2196 GLuint *indexes = malloc(n * sizeof(GLuint));
2197
2198 if (!indexes) {
2199 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
2200 return;
2201 }
2202
2203 extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
2204 srcPacking);
2205
2206 if (transferOps)
2207 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
2208
2209 /* convert to dest type */
2210 switch (dstType) {
2211 case GL_UNSIGNED_BYTE:
2212 {
2213 GLubyte *dst = (GLubyte *) dest;
2214 GLuint i;
2215 for (i = 0; i < n; i++) {
2216 dst[i] = (GLubyte) (indexes[i] & 0xff);
2217 }
2218 }
2219 break;
2220 case GL_UNSIGNED_SHORT:
2221 {
2222 GLuint *dst = (GLuint *) dest;
2223 GLuint i;
2224 for (i = 0; i < n; i++) {
2225 dst[i] = (GLushort) (indexes[i] & 0xffff);
2226 }
2227 }
2228 break;
2229 case GL_UNSIGNED_INT:
2230 memcpy(dest, indexes, n * sizeof(GLuint));
2231 break;
2232 default:
2233 _mesa_problem(ctx, "bad dstType in _mesa_unpack_index_span");
2234 }
2235
2236 free(indexes);
2237 }
2238 }
2239
2240
2241 void
2242 _mesa_pack_index_span( struct gl_context *ctx, GLuint n,
2243 GLenum dstType, GLvoid *dest, const GLuint *source,
2244 const struct gl_pixelstore_attrib *dstPacking,
2245 GLbitfield transferOps )
2246 {
2247 GLuint *indexes = malloc(n * sizeof(GLuint));
2248
2249 if (!indexes) {
2250 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
2251 return;
2252 }
2253
2254 transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
2255
2256 if (transferOps & (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT)) {
2257 /* make a copy of input */
2258 memcpy(indexes, source, n * sizeof(GLuint));
2259 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
2260 source = indexes;
2261 }
2262
2263 switch (dstType) {
2264 case GL_UNSIGNED_BYTE:
2265 {
2266 GLubyte *dst = (GLubyte *) dest;
2267 GLuint i;
2268 for (i = 0; i < n; i++) {
2269 *dst++ = (GLubyte) source[i];
2270 }
2271 }
2272 break;
2273 case GL_BYTE:
2274 {
2275 GLbyte *dst = (GLbyte *) dest;
2276 GLuint i;
2277 for (i = 0; i < n; i++) {
2278 dst[i] = (GLbyte) source[i];
2279 }
2280 }
2281 break;
2282 case GL_UNSIGNED_SHORT:
2283 {
2284 GLushort *dst = (GLushort *) dest;
2285 GLuint i;
2286 for (i = 0; i < n; i++) {
2287 dst[i] = (GLushort) source[i];
2288 }
2289 if (dstPacking->SwapBytes) {
2290 _mesa_swap2( (GLushort *) dst, n );
2291 }
2292 }
2293 break;
2294 case GL_SHORT:
2295 {
2296 GLshort *dst = (GLshort *) dest;
2297 GLuint i;
2298 for (i = 0; i < n; i++) {
2299 dst[i] = (GLshort) source[i];
2300 }
2301 if (dstPacking->SwapBytes) {
2302 _mesa_swap2( (GLushort *) dst, n );
2303 }
2304 }
2305 break;
2306 case GL_UNSIGNED_INT:
2307 {
2308 GLuint *dst = (GLuint *) dest;
2309 GLuint i;
2310 for (i = 0; i < n; i++) {
2311 dst[i] = (GLuint) source[i];
2312 }
2313 if (dstPacking->SwapBytes) {
2314 _mesa_swap4( (GLuint *) dst, n );
2315 }
2316 }
2317 break;
2318 case GL_INT:
2319 {
2320 GLint *dst = (GLint *) dest;
2321 GLuint i;
2322 for (i = 0; i < n; i++) {
2323 dst[i] = (GLint) source[i];
2324 }
2325 if (dstPacking->SwapBytes) {
2326 _mesa_swap4( (GLuint *) dst, n );
2327 }
2328 }
2329 break;
2330 case GL_FLOAT:
2331 {
2332 GLfloat *dst = (GLfloat *) dest;
2333 GLuint i;
2334 for (i = 0; i < n; i++) {
2335 dst[i] = (GLfloat) source[i];
2336 }
2337 if (dstPacking->SwapBytes) {
2338 _mesa_swap4( (GLuint *) dst, n );
2339 }
2340 }
2341 break;
2342 case GL_HALF_FLOAT_ARB:
2343 {
2344 GLhalfARB *dst = (GLhalfARB *) dest;
2345 GLuint i;
2346 for (i = 0; i < n; i++) {
2347 dst[i] = _mesa_float_to_half((GLfloat) source[i]);
2348 }
2349 if (dstPacking->SwapBytes) {
2350 _mesa_swap2( (GLushort *) dst, n );
2351 }
2352 }
2353 break;
2354 default:
2355 _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
2356 }
2357
2358 free(indexes);
2359 }
2360
2361
2362 /*
2363 * Unpack a row of stencil data from a client buffer according to
2364 * the pixel unpacking parameters.
2365 * This is (or will be) used by glDrawPixels
2366 *
2367 * Args: ctx - the context
2368 * n - number of pixels
2369 * dstType - destination data type
2370 * dest - destination array
2371 * srcType - source pixel type
2372 * source - source data pointer
2373 * srcPacking - pixel unpacking parameters
2374 * transferOps - apply offset/bias/lookup ops?
2375 */
2376 void
2377 _mesa_unpack_stencil_span( struct gl_context *ctx, GLuint n,
2378 GLenum dstType, GLvoid *dest,
2379 GLenum srcType, const GLvoid *source,
2380 const struct gl_pixelstore_attrib *srcPacking,
2381 GLbitfield transferOps )
2382 {
2383 ASSERT(srcType == GL_BITMAP ||
2384 srcType == GL_UNSIGNED_BYTE ||
2385 srcType == GL_BYTE ||
2386 srcType == GL_UNSIGNED_SHORT ||
2387 srcType == GL_SHORT ||
2388 srcType == GL_UNSIGNED_INT ||
2389 srcType == GL_INT ||
2390 srcType == GL_UNSIGNED_INT_24_8_EXT ||
2391 srcType == GL_HALF_FLOAT_ARB ||
2392 srcType == GL_FLOAT ||
2393 srcType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
2394
2395 ASSERT(dstType == GL_UNSIGNED_BYTE ||
2396 dstType == GL_UNSIGNED_SHORT ||
2397 dstType == GL_UNSIGNED_INT ||
2398 dstType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
2399
2400 /* only shift and offset apply to stencil */
2401 transferOps &= IMAGE_SHIFT_OFFSET_BIT;
2402
2403 /*
2404 * Try simple cases first
2405 */
2406 if (transferOps == 0 &&
2407 !ctx->Pixel.MapStencilFlag &&
2408 srcType == GL_UNSIGNED_BYTE &&
2409 dstType == GL_UNSIGNED_BYTE) {
2410 memcpy(dest, source, n * sizeof(GLubyte));
2411 }
2412 else if (transferOps == 0 &&
2413 !ctx->Pixel.MapStencilFlag &&
2414 srcType == GL_UNSIGNED_INT &&
2415 dstType == GL_UNSIGNED_INT &&
2416 !srcPacking->SwapBytes) {
2417 memcpy(dest, source, n * sizeof(GLuint));
2418 }
2419 else {
2420 /*
2421 * general solution
2422 */
2423 GLuint *indexes = malloc(n * sizeof(GLuint));
2424
2425 if (!indexes) {
2426 _mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil unpacking");
2427 return;
2428 }
2429
2430 extract_uint_indexes(n, indexes, GL_STENCIL_INDEX, srcType, source,
2431 srcPacking);
2432
2433 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
2434 /* shift and offset indexes */
2435 _mesa_shift_and_offset_ci(ctx, n, indexes);
2436 }
2437
2438 if (ctx->Pixel.MapStencilFlag) {
2439 /* Apply stencil lookup table */
2440 const GLuint mask = ctx->PixelMaps.StoS.Size - 1;
2441 GLuint i;
2442 for (i = 0; i < n; i++) {
2443 indexes[i] = (GLuint)ctx->PixelMaps.StoS.Map[ indexes[i] & mask ];
2444 }
2445 }
2446
2447 /* convert to dest type */
2448 switch (dstType) {
2449 case GL_UNSIGNED_BYTE:
2450 {
2451 GLubyte *dst = (GLubyte *) dest;
2452 GLuint i;
2453 for (i = 0; i < n; i++) {
2454 dst[i] = (GLubyte) (indexes[i] & 0xff);
2455 }
2456 }
2457 break;
2458 case GL_UNSIGNED_SHORT:
2459 {
2460 GLuint *dst = (GLuint *) dest;
2461 GLuint i;
2462 for (i = 0; i < n; i++) {
2463 dst[i] = (GLushort) (indexes[i] & 0xffff);
2464 }
2465 }
2466 break;
2467 case GL_UNSIGNED_INT:
2468 memcpy(dest, indexes, n * sizeof(GLuint));
2469 break;
2470 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
2471 {
2472 GLuint *dst = (GLuint *) dest;
2473 GLuint i;
2474 for (i = 0; i < n; i++) {
2475 dst[i*2+1] = indexes[i] & 0xff; /* lower 8 bits */
2476 }
2477 }
2478 break;
2479 default:
2480 _mesa_problem(ctx, "bad dstType in _mesa_unpack_stencil_span");
2481 }
2482
2483 free(indexes);
2484 }
2485 }
2486
2487
2488 void
2489 _mesa_pack_stencil_span( struct gl_context *ctx, GLuint n,
2490 GLenum dstType, GLvoid *dest, const GLubyte *source,
2491 const struct gl_pixelstore_attrib *dstPacking )
2492 {
2493 GLubyte *stencil = malloc(n * sizeof(GLubyte));
2494
2495 if (!stencil) {
2496 _mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil packing");
2497 return;
2498 }
2499
2500 if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset ||
2501 ctx->Pixel.MapStencilFlag) {
2502 /* make a copy of input */
2503 memcpy(stencil, source, n * sizeof(GLubyte));
2504 _mesa_apply_stencil_transfer_ops(ctx, n, stencil);
2505 source = stencil;
2506 }
2507
2508 switch (dstType) {
2509 case GL_UNSIGNED_BYTE:
2510 memcpy(dest, source, n);
2511 break;
2512 case GL_BYTE:
2513 {
2514 GLbyte *dst = (GLbyte *) dest;
2515 GLuint i;
2516 for (i=0;i<n;i++) {
2517 dst[i] = (GLbyte) (source[i] & 0x7f);
2518 }
2519 }
2520 break;
2521 case GL_UNSIGNED_SHORT:
2522 {
2523 GLushort *dst = (GLushort *) dest;
2524 GLuint i;
2525 for (i=0;i<n;i++) {
2526 dst[i] = (GLushort) source[i];
2527 }
2528 if (dstPacking->SwapBytes) {
2529 _mesa_swap2( (GLushort *) dst, n );
2530 }
2531 }
2532 break;
2533 case GL_SHORT:
2534 {
2535 GLshort *dst = (GLshort *) dest;
2536 GLuint i;
2537 for (i=0;i<n;i++) {
2538 dst[i] = (GLshort) source[i];
2539 }
2540 if (dstPacking->SwapBytes) {
2541 _mesa_swap2( (GLushort *) dst, n );
2542 }
2543 }
2544 break;
2545 case GL_UNSIGNED_INT:
2546 {
2547 GLuint *dst = (GLuint *) dest;
2548 GLuint i;
2549 for (i=0;i<n;i++) {
2550 dst[i] = (GLuint) source[i];
2551 }
2552 if (dstPacking->SwapBytes) {
2553 _mesa_swap4( (GLuint *) dst, n );
2554 }
2555 }
2556 break;
2557 case GL_INT:
2558 {
2559 GLint *dst = (GLint *) dest;
2560 GLuint i;
2561 for (i=0;i<n;i++) {
2562 dst[i] = (GLint) source[i];
2563 }
2564 if (dstPacking->SwapBytes) {
2565 _mesa_swap4( (GLuint *) dst, n );
2566 }
2567 }
2568 break;
2569 case GL_FLOAT:
2570 {
2571 GLfloat *dst = (GLfloat *) dest;
2572 GLuint i;
2573 for (i=0;i<n;i++) {
2574 dst[i] = (GLfloat) source[i];
2575 }
2576 if (dstPacking->SwapBytes) {
2577 _mesa_swap4( (GLuint *) dst, n );
2578 }
2579 }
2580 break;
2581 case GL_HALF_FLOAT_ARB:
2582 {
2583 GLhalfARB *dst = (GLhalfARB *) dest;
2584 GLuint i;
2585 for (i=0;i<n;i++) {
2586 dst[i] = _mesa_float_to_half( (float) source[i] );
2587 }
2588 if (dstPacking->SwapBytes) {
2589 _mesa_swap2( (GLushort *) dst, n );
2590 }
2591 }
2592 break;
2593 case GL_BITMAP:
2594 if (dstPacking->LsbFirst) {
2595 GLubyte *dst = (GLubyte *) dest;
2596 GLint shift = 0;
2597 GLuint i;
2598 for (i = 0; i < n; i++) {
2599 if (shift == 0)
2600 *dst = 0;
2601 *dst |= ((source[i] != 0) << shift);
2602 shift++;
2603 if (shift == 8) {
2604 shift = 0;
2605 dst++;
2606 }
2607 }
2608 }
2609 else {
2610 GLubyte *dst = (GLubyte *) dest;
2611 GLint shift = 7;
2612 GLuint i;
2613 for (i = 0; i < n; i++) {
2614 if (shift == 7)
2615 *dst = 0;
2616 *dst |= ((source[i] != 0) << shift);
2617 shift--;
2618 if (shift < 0) {
2619 shift = 7;
2620 dst++;
2621 }
2622 }
2623 }
2624 break;
2625 default:
2626 _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
2627 }
2628
2629 free(stencil);
2630 }
2631
2632 #define DEPTH_VALUES(GLTYPE, GLTYPE2FLOAT) \
2633 do { \
2634 GLuint i; \
2635 const GLTYPE *src = (const GLTYPE *)source; \
2636 for (i = 0; i < n; i++) { \
2637 GLTYPE value = src[i]; \
2638 if (srcPacking->SwapBytes) { \
2639 if (sizeof(GLTYPE) == 2) { \
2640 SWAP2BYTE(value); \
2641 } else if (sizeof(GLTYPE) == 4) { \
2642 SWAP4BYTE(value); \
2643 } \
2644 } \
2645 depthValues[i] = GLTYPE2FLOAT(value); \
2646 } \
2647 } while (0)
2648
2649
2650 /**
2651 * Unpack a row of depth/z values from memory, returning GLushort, GLuint
2652 * or GLfloat values.
2653 * The glPixelTransfer (scale/bias) params will be applied.
2654 *
2655 * \param dstType one of GL_UNSIGNED_SHORT, GL_UNSIGNED_INT, GL_FLOAT
2656 * \param depthMax max value for returned GLushort or GLuint values
2657 * (ignored for GLfloat).
2658 */
2659 void
2660 _mesa_unpack_depth_span( struct gl_context *ctx, GLuint n,
2661 GLenum dstType, GLvoid *dest, GLuint depthMax,
2662 GLenum srcType, const GLvoid *source,
2663 const struct gl_pixelstore_attrib *srcPacking )
2664 {
2665 GLfloat *depthTemp = NULL, *depthValues;
2666 GLboolean needClamp = GL_FALSE;
2667
2668 /* Look for special cases first.
2669 * Not only are these faster, they're less prone to numeric conversion
2670 * problems. Otherwise, converting from an int type to a float then
2671 * back to an int type can introduce errors that will show up as
2672 * artifacts in things like depth peeling which uses glCopyTexImage.
2673 */
2674 if (ctx->Pixel.DepthScale == 1.0 && ctx->Pixel.DepthBias == 0.0) {
2675 if (srcType == GL_UNSIGNED_INT && dstType == GL_UNSIGNED_SHORT) {
2676 const GLuint *src = (const GLuint *) source;
2677 GLushort *dst = (GLushort *) dest;
2678 GLuint i;
2679 for (i = 0; i < n; i++) {
2680 dst[i] = src[i] >> 16;
2681 }
2682 return;
2683 }
2684 if (srcType == GL_UNSIGNED_SHORT
2685 && dstType == GL_UNSIGNED_INT
2686 && depthMax == 0xffffffff) {
2687 const GLushort *src = (const GLushort *) source;
2688 GLuint *dst = (GLuint *) dest;
2689 GLuint i;
2690 for (i = 0; i < n; i++) {
2691 dst[i] = src[i] | (src[i] << 16);
2692 }
2693 return;
2694 }
2695 if (srcType == GL_UNSIGNED_INT_24_8
2696 && dstType == GL_UNSIGNED_INT
2697 && depthMax == 0xffffff) {
2698 const GLuint *src = (const GLuint *) source;
2699 GLuint *dst = (GLuint *) dest;
2700 GLuint i;
2701 for (i = 0; i < n; i++) {
2702 dst[i] = src[i] >> 8;
2703 }
2704 return;
2705 }
2706 /* XXX may want to add additional cases here someday */
2707 }
2708
2709 /* general case path follows */
2710
2711 if (dstType == GL_FLOAT) {
2712 depthValues = (GLfloat *) dest;
2713 }
2714 else {
2715 depthTemp = malloc(n * sizeof(GLfloat));
2716 if (!depthTemp) {
2717 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
2718 return;
2719 }
2720
2721 depthValues = depthTemp;
2722 }
2723
2724 /* Convert incoming values to GLfloat. Some conversions will require
2725 * clamping, below.
2726 */
2727 switch (srcType) {
2728 case GL_BYTE:
2729 DEPTH_VALUES(GLbyte, BYTE_TO_FLOATZ);
2730 needClamp = GL_TRUE;
2731 break;
2732 case GL_UNSIGNED_BYTE:
2733 DEPTH_VALUES(GLubyte, UBYTE_TO_FLOAT);
2734 break;
2735 case GL_SHORT:
2736 DEPTH_VALUES(GLshort, SHORT_TO_FLOATZ);
2737 needClamp = GL_TRUE;
2738 break;
2739 case GL_UNSIGNED_SHORT:
2740 DEPTH_VALUES(GLushort, USHORT_TO_FLOAT);
2741 break;
2742 case GL_INT:
2743 DEPTH_VALUES(GLint, INT_TO_FLOAT);
2744 needClamp = GL_TRUE;
2745 break;
2746 case GL_UNSIGNED_INT:
2747 DEPTH_VALUES(GLuint, UINT_TO_FLOAT);
2748 break;
2749 case GL_UNSIGNED_INT_24_8_EXT: /* GL_EXT_packed_depth_stencil */
2750 if (dstType == GL_UNSIGNED_INT_24_8_EXT &&
2751 depthMax == 0xffffff &&
2752 ctx->Pixel.DepthScale == 1.0 &&
2753 ctx->Pixel.DepthBias == 0.0) {
2754 const GLuint *src = (const GLuint *) source;
2755 GLuint *zValues = (GLuint *) dest;
2756 GLuint i;
2757 for (i = 0; i < n; i++) {
2758 GLuint value = src[i];
2759 if (srcPacking->SwapBytes) {
2760 SWAP4BYTE(value);
2761 }
2762 zValues[i] = value & 0xffffff00;
2763 }
2764 free(depthTemp);
2765 return;
2766 }
2767 else {
2768 const GLuint *src = (const GLuint *) source;
2769 const GLfloat scale = 1.0f / 0xffffff;
2770 GLuint i;
2771 for (i = 0; i < n; i++) {
2772 GLuint value = src[i];
2773 if (srcPacking->SwapBytes) {
2774 SWAP4BYTE(value);
2775 }
2776 depthValues[i] = (value >> 8) * scale;
2777 }
2778 }
2779 break;
2780 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
2781 {
2782 GLuint i;
2783 const GLfloat *src = (const GLfloat *)source;
2784 for (i = 0; i < n; i++) {
2785 GLfloat value = src[i * 2];
2786 if (srcPacking->SwapBytes) {
2787 SWAP4BYTE(value);
2788 }
2789 depthValues[i] = value;
2790 }
2791 needClamp = GL_TRUE;
2792 }
2793 break;
2794 case GL_FLOAT:
2795 DEPTH_VALUES(GLfloat, 1*);
2796 needClamp = GL_TRUE;
2797 break;
2798 case GL_HALF_FLOAT_ARB:
2799 {
2800 GLuint i;
2801 const GLhalfARB *src = (const GLhalfARB *) source;
2802 for (i = 0; i < n; i++) {
2803 GLhalfARB value = src[i];
2804 if (srcPacking->SwapBytes) {
2805 SWAP2BYTE(value);
2806 }
2807 depthValues[i] = _mesa_half_to_float(value);
2808 }
2809 needClamp = GL_TRUE;
2810 }
2811 break;
2812 default:
2813 _mesa_problem(NULL, "bad type in _mesa_unpack_depth_span()");
2814 free(depthTemp);
2815 return;
2816 }
2817
2818 /* apply depth scale and bias */
2819 {
2820 const GLfloat scale = ctx->Pixel.DepthScale;
2821 const GLfloat bias = ctx->Pixel.DepthBias;
2822 if (scale != 1.0 || bias != 0.0) {
2823 GLuint i;
2824 for (i = 0; i < n; i++) {
2825 depthValues[i] = depthValues[i] * scale + bias;
2826 }
2827 needClamp = GL_TRUE;
2828 }
2829 }
2830
2831 /* clamp to [0, 1] */
2832 if (needClamp) {
2833 GLuint i;
2834 for (i = 0; i < n; i++) {
2835 depthValues[i] = (GLfloat)CLAMP(depthValues[i], 0.0, 1.0);
2836 }
2837 }
2838
2839 /*
2840 * Convert values to dstType
2841 */
2842 if (dstType == GL_UNSIGNED_INT) {
2843 GLuint *zValues = (GLuint *) dest;
2844 GLuint i;
2845 if (depthMax <= 0xffffff) {
2846 /* no overflow worries */
2847 for (i = 0; i < n; i++) {
2848 zValues[i] = (GLuint) (depthValues[i] * (GLfloat) depthMax);
2849 }
2850 }
2851 else {
2852 /* need to use double precision to prevent overflow problems */
2853 for (i = 0; i < n; i++) {
2854 GLdouble z = depthValues[i] * (GLdouble) depthMax;
2855 if (z >= (GLdouble) 0xffffffff)
2856 zValues[i] = 0xffffffff;
2857 else
2858 zValues[i] = (GLuint) z;
2859 }
2860 }
2861 }
2862 else if (dstType == GL_UNSIGNED_SHORT) {
2863 GLushort *zValues = (GLushort *) dest;
2864 GLuint i;
2865 ASSERT(depthMax <= 0xffff);
2866 for (i = 0; i < n; i++) {
2867 zValues[i] = (GLushort) (depthValues[i] * (GLfloat) depthMax);
2868 }
2869 }
2870 else if (dstType == GL_FLOAT) {
2871 /* Nothing to do. depthValues is pointing to dest. */
2872 }
2873 else if (dstType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV) {
2874 GLfloat *zValues = (GLfloat*) dest;
2875 GLuint i;
2876 for (i = 0; i < n; i++) {
2877 zValues[i*2] = depthValues[i];
2878 }
2879 }
2880 else {
2881 ASSERT(0);
2882 }
2883
2884 free(depthTemp);
2885 }
2886
2887
2888 /*
2889 * Pack an array of depth values. The values are floats in [0,1].
2890 */
2891 void
2892 _mesa_pack_depth_span( struct gl_context *ctx, GLuint n, GLvoid *dest,
2893 GLenum dstType, const GLfloat *depthSpan,
2894 const struct gl_pixelstore_attrib *dstPacking )
2895 {
2896 GLfloat *depthCopy = malloc(n * sizeof(GLfloat));
2897 if (!depthCopy) {
2898 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
2899 return;
2900 }
2901
2902 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
2903 memcpy(depthCopy, depthSpan, n * sizeof(GLfloat));
2904 _mesa_scale_and_bias_depth(ctx, n, depthCopy);
2905 depthSpan = depthCopy;
2906 }
2907
2908 switch (dstType) {
2909 case GL_UNSIGNED_BYTE:
2910 {
2911 GLubyte *dst = (GLubyte *) dest;
2912 GLuint i;
2913 for (i = 0; i < n; i++) {
2914 dst[i] = FLOAT_TO_UBYTE( depthSpan[i] );
2915 }
2916 }
2917 break;
2918 case GL_BYTE:
2919 {
2920 GLbyte *dst = (GLbyte *) dest;
2921 GLuint i;
2922 for (i = 0; i < n; i++) {
2923 dst[i] = FLOAT_TO_BYTE( depthSpan[i] );
2924 }
2925 }
2926 break;
2927 case GL_UNSIGNED_SHORT:
2928 {
2929 GLushort *dst = (GLushort *) dest;
2930 GLuint i;
2931 for (i = 0; i < n; i++) {
2932 CLAMPED_FLOAT_TO_USHORT(dst[i], depthSpan[i]);
2933 }
2934 if (dstPacking->SwapBytes) {
2935 _mesa_swap2( (GLushort *) dst, n );
2936 }
2937 }
2938 break;
2939 case GL_SHORT:
2940 {
2941 GLshort *dst = (GLshort *) dest;
2942 GLuint i;
2943 for (i = 0; i < n; i++) {
2944 dst[i] = FLOAT_TO_SHORT( depthSpan[i] );
2945 }
2946 if (dstPacking->SwapBytes) {
2947 _mesa_swap2( (GLushort *) dst, n );
2948 }
2949 }
2950 break;
2951 case GL_UNSIGNED_INT:
2952 {
2953 GLuint *dst = (GLuint *) dest;
2954 GLuint i;
2955 for (i = 0; i < n; i++) {
2956 dst[i] = FLOAT_TO_UINT( depthSpan[i] );
2957 }
2958 if (dstPacking->SwapBytes) {
2959 _mesa_swap4( (GLuint *) dst, n );
2960 }
2961 }
2962 break;
2963 case GL_INT:
2964 {
2965 GLint *dst = (GLint *) dest;
2966 GLuint i;
2967 for (i = 0; i < n; i++) {
2968 dst[i] = FLOAT_TO_INT( depthSpan[i] );
2969 }
2970 if (dstPacking->SwapBytes) {
2971 _mesa_swap4( (GLuint *) dst, n );
2972 }
2973 }
2974 break;
2975 case GL_FLOAT:
2976 {
2977 GLfloat *dst = (GLfloat *) dest;
2978 GLuint i;
2979 for (i = 0; i < n; i++) {
2980 dst[i] = depthSpan[i];
2981 }
2982 if (dstPacking->SwapBytes) {
2983 _mesa_swap4( (GLuint *) dst, n );
2984 }
2985 }
2986 break;
2987 case GL_HALF_FLOAT_ARB:
2988 {
2989 GLhalfARB *dst = (GLhalfARB *) dest;
2990 GLuint i;
2991 for (i = 0; i < n; i++) {
2992 dst[i] = _mesa_float_to_half(depthSpan[i]);
2993 }
2994 if (dstPacking->SwapBytes) {
2995 _mesa_swap2( (GLushort *) dst, n );
2996 }
2997 }
2998 break;
2999 default:
3000 _mesa_problem(ctx, "bad type in _mesa_pack_depth_span");
3001 }
3002
3003 free(depthCopy);
3004 }
3005
3006
3007
3008 /**
3009 * Pack depth and stencil values as GL_DEPTH_STENCIL (GL_UNSIGNED_INT_24_8 etc)
3010 */
3011 void
3012 _mesa_pack_depth_stencil_span(struct gl_context *ctx,GLuint n,
3013 GLenum dstType, GLuint *dest,
3014 const GLfloat *depthVals,
3015 const GLubyte *stencilVals,
3016 const struct gl_pixelstore_attrib *dstPacking)
3017 {
3018 GLfloat *depthCopy = malloc(n * sizeof(GLfloat));
3019 GLubyte *stencilCopy = malloc(n * sizeof(GLubyte));
3020 GLuint i;
3021
3022 if (!depthCopy || !stencilCopy) {
3023 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
3024 free(depthCopy);
3025 free(stencilCopy);
3026 return;
3027 }
3028
3029 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
3030 memcpy(depthCopy, depthVals, n * sizeof(GLfloat));
3031 _mesa_scale_and_bias_depth(ctx, n, depthCopy);
3032 depthVals = depthCopy;
3033 }
3034
3035 if (ctx->Pixel.IndexShift ||
3036 ctx->Pixel.IndexOffset ||
3037 ctx->Pixel.MapStencilFlag) {
3038 memcpy(stencilCopy, stencilVals, n * sizeof(GLubyte));
3039 _mesa_apply_stencil_transfer_ops(ctx, n, stencilCopy);
3040 stencilVals = stencilCopy;
3041 }
3042
3043 switch (dstType) {
3044 case GL_UNSIGNED_INT_24_8:
3045 for (i = 0; i < n; i++) {
3046 GLuint z = (GLuint) (depthVals[i] * 0xffffff);
3047 dest[i] = (z << 8) | (stencilVals[i] & 0xff);
3048 }
3049 break;
3050 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
3051 for (i = 0; i < n; i++) {
3052 ((GLfloat*)dest)[i*2] = depthVals[i];
3053 dest[i*2+1] = stencilVals[i] & 0xff;
3054 }
3055 break;
3056 }
3057
3058 if (dstPacking->SwapBytes) {
3059 _mesa_swap4(dest, n);
3060 }
3061
3062 free(depthCopy);
3063 free(stencilCopy);
3064 }
3065
3066
3067
3068
3069 /**
3070 * Unpack image data. Apply byte swapping, byte flipping (bitmap).
3071 * Return all image data in a contiguous block. This is used when we
3072 * compile glDrawPixels, glTexImage, etc into a display list. We
3073 * need a copy of the data in a standard format.
3074 */
3075 void *
3076 _mesa_unpack_image( GLuint dimensions,
3077 GLsizei width, GLsizei height, GLsizei depth,
3078 GLenum format, GLenum type, const GLvoid *pixels,
3079 const struct gl_pixelstore_attrib *unpack )
3080 {
3081 GLint bytesPerRow, compsPerRow;
3082 GLboolean flipBytes, swap2, swap4;
3083
3084 if (!pixels)
3085 return NULL; /* not necessarily an error */
3086
3087 if (width <= 0 || height <= 0 || depth <= 0)
3088 return NULL; /* generate error later */
3089
3090 if (type == GL_BITMAP) {
3091 bytesPerRow = (width + 7) >> 3;
3092 flipBytes = unpack->LsbFirst;
3093 swap2 = swap4 = GL_FALSE;
3094 compsPerRow = 0;
3095 }
3096 else {
3097 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
3098 GLint components = _mesa_components_in_format(format);
3099 GLint bytesPerComp;
3100
3101 if (_mesa_type_is_packed(type))
3102 components = 1;
3103
3104 if (bytesPerPixel <= 0 || components <= 0)
3105 return NULL; /* bad format or type. generate error later */
3106 bytesPerRow = bytesPerPixel * width;
3107 bytesPerComp = bytesPerPixel / components;
3108 flipBytes = GL_FALSE;
3109 swap2 = (bytesPerComp == 2) && unpack->SwapBytes;
3110 swap4 = (bytesPerComp == 4) && unpack->SwapBytes;
3111 compsPerRow = components * width;
3112 assert(compsPerRow >= width);
3113 }
3114
3115 {
3116 GLubyte *destBuffer
3117 = malloc(bytesPerRow * height * depth);
3118 GLubyte *dst;
3119 GLint img, row;
3120 if (!destBuffer)
3121 return NULL; /* generate GL_OUT_OF_MEMORY later */
3122
3123 dst = destBuffer;
3124 for (img = 0; img < depth; img++) {
3125 for (row = 0; row < height; row++) {
3126 const GLvoid *src = _mesa_image_address(dimensions, unpack, pixels,
3127 width, height, format, type, img, row, 0);
3128
3129 if ((type == GL_BITMAP) && (unpack->SkipPixels & 0x7)) {
3130 GLint i;
3131 flipBytes = GL_FALSE;
3132 if (unpack->LsbFirst) {
3133 GLubyte srcMask = 1 << (unpack->SkipPixels & 0x7);
3134 GLubyte dstMask = 128;
3135 const GLubyte *s = src;
3136 GLubyte *d = dst;
3137 *d = 0;
3138 for (i = 0; i < width; i++) {
3139 if (*s & srcMask) {
3140 *d |= dstMask;
3141 }
3142 if (srcMask == 128) {
3143 srcMask = 1;
3144 s++;
3145 }
3146 else {
3147 srcMask = srcMask << 1;
3148 }
3149 if (dstMask == 1) {
3150 dstMask = 128;
3151 d++;
3152 *d = 0;
3153 }
3154 else {
3155 dstMask = dstMask >> 1;
3156 }
3157 }
3158 }
3159 else {
3160 GLubyte srcMask = 128 >> (unpack->SkipPixels & 0x7);
3161 GLubyte dstMask = 128;
3162 const GLubyte *s = src;
3163 GLubyte *d = dst;
3164 *d = 0;
3165 for (i = 0; i < width; i++) {
3166 if (*s & srcMask) {
3167 *d |= dstMask;
3168 }
3169 if (srcMask == 1) {
3170 srcMask = 128;
3171 s++;
3172 }
3173 else {
3174 srcMask = srcMask >> 1;
3175 }
3176 if (dstMask == 1) {
3177 dstMask = 128;
3178 d++;
3179 *d = 0;
3180 }
3181 else {
3182 dstMask = dstMask >> 1;
3183 }
3184 }
3185 }
3186 }
3187 else {
3188 memcpy(dst, src, bytesPerRow);
3189 }
3190
3191 /* byte flipping/swapping */
3192 if (flipBytes) {
3193 flip_bytes((GLubyte *) dst, bytesPerRow);
3194 }
3195 else if (swap2) {
3196 _mesa_swap2((GLushort*) dst, compsPerRow);
3197 }
3198 else if (swap4) {
3199 _mesa_swap4((GLuint*) dst, compsPerRow);
3200 }
3201 dst += bytesPerRow;
3202 }
3203 }
3204 return destBuffer;
3205 }
3206 }
3207
3208
3209
3210 /**
3211 * If we unpack colors from a luminance surface, we'll get pixel colors
3212 * such as (l, l, l, a).
3213 * When we call _mesa_pack_rgba_span_float(format=GL_LUMINANCE), that
3214 * function will compute L=R+G+B before packing. The net effect is we'll
3215 * accidentally store luminance values = 3*l.
3216 * This function compensates for that by converting (aka rebasing) (l,l,l,a)
3217 * to be (l,0,0,a).
3218 * It's a similar story for other formats such as LUMINANCE_ALPHA, ALPHA
3219 * and INTENSITY.
3220 *
3221 * Finally, we also need to do this when the actual surface format does
3222 * not match the logical surface format. For example, suppose the user
3223 * requests a GL_LUMINANCE texture but the driver stores it as RGBA.
3224 * Again, we'll get pixel values like (l,l,l,a).
3225 */
3226 void
3227 _mesa_rebase_rgba_float(GLuint n, GLfloat rgba[][4], GLenum baseFormat)
3228 {
3229 GLuint i;
3230
3231 switch (baseFormat) {
3232 case GL_ALPHA:
3233 for (i = 0; i < n; i++) {
3234 rgba[i][RCOMP] = 0.0F;
3235 rgba[i][GCOMP] = 0.0F;
3236 rgba[i][BCOMP] = 0.0F;
3237 }
3238 break;
3239 case GL_INTENSITY:
3240 /* fall-through */
3241 case GL_LUMINANCE:
3242 for (i = 0; i < n; i++) {
3243 rgba[i][GCOMP] = 0.0F;
3244 rgba[i][BCOMP] = 0.0F;
3245 rgba[i][ACOMP] = 1.0F;
3246 }
3247 break;
3248 case GL_LUMINANCE_ALPHA:
3249 for (i = 0; i < n; i++) {
3250 rgba[i][GCOMP] = 0.0F;
3251 rgba[i][BCOMP] = 0.0F;
3252 }
3253 break;
3254 case GL_RGB:
3255 for (i = 0; i < n; i++) {
3256 rgba[i][ACOMP] = 1.0F;
3257 }
3258 break;
3259 case GL_RG:
3260 for (i = 0; i < n; i++) {
3261 rgba[i][BCOMP] = 0.0F;
3262 rgba[i][ACOMP] = 1.0F;
3263 }
3264 break;
3265 case GL_RED:
3266 for (i = 0; i < n; i++) {
3267 rgba[i][GCOMP] = 0.0F;
3268 rgba[i][BCOMP] = 0.0F;
3269 rgba[i][ACOMP] = 1.0F;
3270 }
3271 break;
3272
3273 default:
3274 /* no-op */
3275 ;
3276 }
3277 }
3278
3279
3280 /**
3281 * As above, but GLuint components.
3282 */
3283 void
3284 _mesa_rebase_rgba_uint(GLuint n, GLuint rgba[][4], GLenum baseFormat)
3285 {
3286 GLuint i;
3287
3288 switch (baseFormat) {
3289 case GL_ALPHA:
3290 for (i = 0; i < n; i++) {
3291 rgba[i][RCOMP] = 0;
3292 rgba[i][GCOMP] = 0;
3293 rgba[i][BCOMP] = 0;
3294 }
3295 break;
3296 case GL_INTENSITY:
3297 /* fall-through */
3298 case GL_LUMINANCE:
3299 for (i = 0; i < n; i++) {
3300 rgba[i][GCOMP] = 0;
3301 rgba[i][BCOMP] = 0;
3302 rgba[i][ACOMP] = 1;
3303 }
3304 break;
3305 case GL_LUMINANCE_ALPHA:
3306 for (i = 0; i < n; i++) {
3307 rgba[i][GCOMP] = 0;
3308 rgba[i][BCOMP] = 0;
3309 }
3310 break;
3311 case GL_RGB:
3312 for (i = 0; i < n; i++) {
3313 rgba[i][ACOMP] = 1;
3314 }
3315 break;
3316 case GL_RG:
3317 for (i = 0; i < n; i++) {
3318 rgba[i][BCOMP] = 0;
3319 rgba[i][ACOMP] = 1;
3320 }
3321 break;
3322 case GL_RED:
3323 for (i = 0; i < n; i++) {
3324 rgba[i][GCOMP] = 0;
3325 rgba[i][BCOMP] = 0;
3326 rgba[i][ACOMP] = 1;
3327 }
3328 default:
3329 /* no-op */
3330 ;
3331 }
3332 }
3333
3334 void
3335 _mesa_pack_luminance_from_rgba_float(GLuint n, GLfloat rgba[][4],
3336 GLvoid *dstAddr, GLenum dst_format,
3337 GLbitfield transferOps)
3338 {
3339 int i;
3340 GLfloat *dst = (GLfloat *) dstAddr;
3341
3342 switch (dst_format) {
3343 case GL_LUMINANCE:
3344 if (transferOps & IMAGE_CLAMP_BIT) {
3345 for (i = 0; i < n; i++) {
3346 GLfloat sum = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
3347 dst[i] = CLAMP(sum, 0.0F, 1.0F);
3348 }
3349 } else {
3350 for (i = 0; i < n; i++) {
3351 dst[i] = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
3352 }
3353 }
3354 return;
3355 case GL_LUMINANCE_ALPHA:
3356 if (transferOps & IMAGE_CLAMP_BIT) {
3357 for (i = 0; i < n; i++) {
3358 GLfloat sum = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
3359 dst[2*i] = CLAMP(sum, 0.0F, 1.0F);
3360 dst[2*i+1] = rgba[i][ACOMP];
3361 }
3362 } else {
3363 for (i = 0; i < n; i++) {
3364 dst[2*i] = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
3365 dst[2*i+1] = rgba[i][ACOMP];
3366 }
3367 }
3368 return;
3369 default:
3370 assert(!"Unsupported format");
3371 }
3372 }
3373
3374 static int32_t
3375 clamp_sint64_to_sint32(int64_t src)
3376 {
3377 return CLAMP(src, INT32_MIN, INT32_MAX);
3378 }
3379
3380 static int32_t
3381 clamp_sint64_to_uint32(int64_t src)
3382 {
3383 return CLAMP(src, 0, UINT32_MAX);
3384 }
3385
3386 static int32_t
3387 clamp_uint64_to_uint32(uint64_t src)
3388 {
3389 return MIN2(src, UINT32_MAX);
3390 }
3391
3392 static int32_t
3393 clamp_uint64_to_sint32(uint64_t src)
3394 {
3395 return MIN2(src, INT32_MAX);
3396 }
3397
3398 static int32_t
3399 convert_integer_luminance64(int64_t src64, int bits,
3400 bool dst_is_signed, bool src_is_signed)
3401 {
3402 int32_t src32;
3403
3404 /* Clamp Luminance value from 64-bit to 32-bit. Consider if we need
3405 * any signed<->unsigned conversion too.
3406 */
3407 if (src_is_signed && dst_is_signed)
3408 src32 = clamp_sint64_to_sint32(src64);
3409 else if (src_is_signed && !dst_is_signed)
3410 src32 = clamp_sint64_to_uint32(src64);
3411 else if (!src_is_signed && dst_is_signed)
3412 src32 = clamp_uint64_to_sint32(src64);
3413 else
3414 src32 = clamp_uint64_to_uint32(src64);
3415
3416 /* If the dst type is < 32-bit, we need an extra clamp */
3417 if (bits == 32) {
3418 return src32;
3419 } else {
3420 if (dst_is_signed)
3421 return _mesa_signed_to_signed(src32, bits);
3422 else
3423 return _mesa_unsigned_to_unsigned(src32, bits);
3424 }
3425 }
3426
3427 static int32_t
3428 convert_integer(int32_t src, int bits, bool dst_is_signed, bool src_is_signed)
3429 {
3430 if (src_is_signed && dst_is_signed)
3431 return _mesa_signed_to_signed(src, bits);
3432 else if (src_is_signed && !dst_is_signed)
3433 return _mesa_signed_to_unsigned(src, bits);
3434 else if (!src_is_signed && dst_is_signed)
3435 return _mesa_unsigned_to_signed(src, bits);
3436 else
3437 return _mesa_unsigned_to_unsigned(src, bits);
3438 }
3439
3440 void
3441 _mesa_pack_luminance_from_rgba_integer(GLuint n,
3442 GLuint rgba[][4], bool rgba_is_signed,
3443 GLvoid *dstAddr,
3444 GLenum dst_format,
3445 GLenum dst_type)
3446 {
3447 assert(dst_format == GL_LUMINANCE_INTEGER_EXT ||
3448 dst_format == GL_LUMINANCE_ALPHA_INTEGER_EXT);
3449
3450 int i;
3451 int64_t lum64;
3452 int32_t lum32, alpha;
3453 bool dst_is_signed;
3454 int dst_bits;
3455
3456 /* We first compute luminance values as a 64-bit addition of the
3457 * 32-bit R,G,B components, then we clamp the result to the dst type size.
3458 *
3459 * Notice that this operation involves casting the 32-bit R,G,B components
3460 * to 64-bit before the addition. Since rgba is defined as a GLuint array
3461 * we need to be careful when rgba packs signed data and make sure
3462 * that we cast to a 32-bit signed integer values before casting them to
3463 * 64-bit signed integers.
3464 */
3465 dst_is_signed = (dst_type == GL_BYTE || dst_type == GL_SHORT ||
3466 dst_type == GL_INT);
3467
3468 dst_bits = _mesa_sizeof_type(dst_type) * 8;
3469 assert(dst_bits > 0);
3470
3471 switch (dst_format) {
3472 case GL_LUMINANCE_INTEGER_EXT:
3473 for (i = 0; i < n; i++) {
3474 if (!rgba_is_signed) {
3475 lum64 = (uint64_t) rgba[i][RCOMP] +
3476 (uint64_t) rgba[i][GCOMP] +
3477 (uint64_t) rgba[i][BCOMP];
3478 } else {
3479 lum64 = (int64_t) ((int32_t) rgba[i][RCOMP]) +
3480 (int64_t) ((int32_t) rgba[i][GCOMP]) +
3481 (int64_t) ((int32_t) rgba[i][BCOMP]);
3482 }
3483 lum32 = convert_integer_luminance64(lum64, dst_bits,
3484 dst_is_signed, rgba_is_signed);
3485 switch (dst_type) {
3486 case GL_BYTE:
3487 case GL_UNSIGNED_BYTE: {
3488 GLbyte *dst = (GLbyte *) dstAddr;
3489 dst[i] = lum32;
3490 }
3491 break;
3492 case GL_SHORT:
3493 case GL_UNSIGNED_SHORT: {
3494 GLshort *dst = (GLshort *) dstAddr;
3495 dst[i] = lum32;
3496 }
3497 break;
3498 case GL_INT:
3499 case GL_UNSIGNED_INT: {
3500 GLint *dst = (GLint *) dstAddr;
3501 dst[i] = lum32;
3502 }
3503 break;
3504 }
3505 }
3506 return;
3507 case GL_LUMINANCE_ALPHA_INTEGER_EXT:
3508 for (i = 0; i < n; i++) {
3509 if (!rgba_is_signed) {
3510 lum64 = (uint64_t) rgba[i][RCOMP] +
3511 (uint64_t) rgba[i][GCOMP] +
3512 (uint64_t) rgba[i][BCOMP];
3513 } else {
3514 lum64 = (int64_t) ((int32_t) rgba[i][RCOMP]) +
3515 (int64_t) ((int32_t) rgba[i][GCOMP]) +
3516 (int64_t) ((int32_t) rgba[i][BCOMP]);
3517 }
3518 lum32 = convert_integer_luminance64(lum64, dst_bits,
3519 dst_is_signed, rgba_is_signed);
3520 alpha = convert_integer(rgba[i][ACOMP], dst_bits,
3521 dst_is_signed, rgba_is_signed);
3522 switch (dst_type) {
3523 case GL_BYTE:
3524 case GL_UNSIGNED_BYTE: {
3525 GLbyte *dst = (GLbyte *) dstAddr;
3526 dst[2*i] = lum32;
3527 dst[2*i+1] = alpha;
3528 }
3529 case GL_SHORT:
3530 case GL_UNSIGNED_SHORT: {
3531 GLshort *dst = (GLshort *) dstAddr;
3532 dst[i] = lum32;
3533 dst[2*i+1] = alpha;
3534 }
3535 break;
3536 case GL_INT:
3537 case GL_UNSIGNED_INT: {
3538 GLint *dst = (GLint *) dstAddr;
3539 dst[i] = lum32;
3540 dst[2*i+1] = alpha;
3541 }
3542 break;
3543 }
3544 }
3545 return;
3546 }
3547 }
3548
3549 GLfloat *
3550 _mesa_unpack_color_index_to_rgba_float(struct gl_context *ctx, GLuint dims,
3551 const void *src, GLenum srcFormat, GLenum srcType,
3552 int srcWidth, int srcHeight, int srcDepth,
3553 const struct gl_pixelstore_attrib *srcPacking,
3554 GLbitfield transferOps)
3555 {
3556 int count, img;
3557 GLuint *indexes;
3558 GLfloat *rgba, *dstPtr;
3559
3560 count = srcWidth * srcHeight;
3561 indexes = malloc(count * sizeof(GLuint));
3562 if (!indexes) {
3563 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3564 return NULL;
3565 }
3566
3567 rgba = malloc(4 * count * srcDepth * sizeof(GLfloat));
3568 if (!rgba) {
3569 free(indexes);
3570 _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
3571 return NULL;
3572 }
3573
3574 /* Convert indexes to RGBA float */
3575 dstPtr = rgba;
3576 for (img = 0; img < srcDepth; img++) {
3577 const GLubyte *srcPtr =
3578 (const GLubyte *) _mesa_image_address(dims, srcPacking, src,
3579 srcWidth, srcHeight,
3580 srcFormat, srcType,
3581 img, 0, 0);
3582
3583 extract_uint_indexes(count, indexes, srcFormat, srcType, srcPtr, srcPacking);
3584
3585 if (transferOps & IMAGE_SHIFT_OFFSET_BIT)
3586 _mesa_shift_and_offset_ci(ctx, count, indexes);
3587
3588 _mesa_map_ci_to_rgba(ctx, count, indexes, (float (*)[4])dstPtr);
3589
3590 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
3591 * with color indexes.
3592 */
3593 transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT);
3594 _mesa_apply_rgba_transfer_ops(ctx, transferOps, count, (float (*)[4])dstPtr);
3595
3596 dstPtr += srcHeight * srcWidth * 4;
3597 }
3598
3599 free(indexes);
3600
3601 return rgba;
3602 }
3603
3604 GLubyte *
3605 _mesa_unpack_color_index_to_rgba_ubyte(struct gl_context *ctx, GLuint dims,
3606 const void *src, GLenum srcFormat, GLenum srcType,
3607 int srcWidth, int srcHeight, int srcDepth,
3608 const struct gl_pixelstore_attrib *srcPacking,
3609 GLbitfield transferOps)
3610 {
3611 GLfloat *rgba;
3612 GLubyte *dst;
3613 int count, i;
3614
3615 transferOps |= IMAGE_CLAMP_BIT;
3616 rgba = _mesa_unpack_color_index_to_rgba_float(ctx, dims,
3617 src, srcFormat, srcType,
3618 srcWidth, srcHeight, srcDepth,
3619 srcPacking, transferOps);
3620
3621 count = srcWidth * srcHeight * srcDepth;
3622 dst = malloc(count * 4 * sizeof(GLubyte));
3623 for (i = 0; i < count; i++) {
3624 CLAMPED_FLOAT_TO_UBYTE(dst[i * 4 + 0], rgba[i * 4 + 0]);
3625 CLAMPED_FLOAT_TO_UBYTE(dst[i * 4 + 1], rgba[i * 4 + 1]);
3626 CLAMPED_FLOAT_TO_UBYTE(dst[i * 4 + 2], rgba[i * 4 + 2]);
3627 CLAMPED_FLOAT_TO_UBYTE(dst[i * 4 + 3], rgba[i * 4 + 3]);
3628 }
3629
3630 free(rgba);
3631
3632 return dst;
3633 }