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