projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
drawing color-index image to RGB window was broken
[mesa.git] / src / mesa / main / image.c
1 /* $Id: image.c,v 1.43 2000/10/05 16:22:22 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 (dstFormat == GL_COLOR_INDEX
2377 && (transferOps & IMAGE_MAP_COLOR_BIT)) {
2378 _mesa_map_ci(ctx, n, indexes);
2379 }
2380 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
2381 _mesa_shift_and_offset_ci(ctx, n, indexes);
2382 }
2383
2384 if (dstFormat == GL_COLOR_INDEX) {
2385 /* convert to GLubyte and return */
2386 GLuint i;
2387 for (i = 0; i < n; i++) {
2388 dest[i] = (GLubyte) (indexes[i] & 0xff);
2389 }
2390 return;
2391 }
2392 else {
2393 /* Convert indexes to RGBA */
2394 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
2395 }
2396 }
2397 else {
2398 extract_float_rgba(n, rgba, srcFormat, srcType, source,
2399 srcPacking->SwapBytes);
2400
2401 /* scale and bias colors */
2402 if (transferOps & IMAGE_SCALE_BIAS_BIT) {
2403 _mesa_scale_and_bias_rgba(ctx, n, rgba);
2404 }
2405 /* color map lookup */
2406 if (transferOps & IMAGE_MAP_COLOR_BIT) {
2407 _mesa_map_rgba(ctx, n, rgba);
2408 }
2409 }
2410
2411 if (transferOps) {
2412 /* GL_COLOR_TABLE lookup */
2413 if (transferOps & IMAGE_COLOR_TABLE_BIT) {
2414 _mesa_lookup_rgba(&ctx->ColorTable, n, rgba);
2415 }
2416 /* convolution */
2417 if (transferOps & IMAGE_CONVOLUTION_BIT) {
2418 /* this has to be done in the calling code */
2419 }
2420 /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
2421 if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) {
2422 _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, n, rgba);
2423 }
2424 /* color matrix transform */
2425 if (transferOps & IMAGE_COLOR_MATRIX_BIT) {
2426 _mesa_transform_rgba(ctx, n, rgba);
2427 }
2428 /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
2429 if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) {
2430 _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, n, rgba);
2431 }
2432 /* update histogram count */
2433 if (transferOps & IMAGE_HISTOGRAM_BIT) {
2434 _mesa_update_histogram(ctx, n, (CONST GLfloat (*)[4]) rgba);
2435 }
2436 /* min/max here */
2437 if (transferOps & IMAGE_MIN_MAX_BIT) {
2438 _mesa_update_minmax(ctx, n, (CONST GLfloat (*)[4]) rgba);
2439 }
2440 }
2441
2442 /* clamp to [0,1] */
2443 {
2444 GLuint i;
2445 for (i = 0; i < n; i++) {
2446 rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F);
2447 rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F);
2448 rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F);
2449 rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F);
2450 }
2451 }
2452
2453 /* Now determine which color channels we need to produce.
2454 * And determine the dest index (offset) within each color tuple.
2455 */
2456 switch (dstFormat) {
2457 case GL_ALPHA:
2458 dstAlphaIndex = 0;
2459 dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
2460 dstLuminanceIndex = dstIntensityIndex = -1;
2461 break;
2462 case GL_LUMINANCE:
2463 dstLuminanceIndex = 0;
2464 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
2465 dstIntensityIndex = -1;
2466 break;
2467 case GL_LUMINANCE_ALPHA:
2468 dstLuminanceIndex = 0;
2469 dstAlphaIndex = 1;
2470 dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
2471 dstIntensityIndex = -1;
2472 break;
2473 case GL_INTENSITY:
2474 dstIntensityIndex = 0;
2475 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
2476 dstLuminanceIndex = -1;
2477 break;
2478 case GL_RGB:
2479 dstRedIndex = 0;
2480 dstGreenIndex = 1;
2481 dstBlueIndex = 2;
2482 dstAlphaIndex = dstLuminanceIndex = dstIntensityIndex = -1;
2483 break;
2484 case GL_RGBA:
2485 dstRedIndex = 0;
2486 dstGreenIndex = 1;
2487 dstBlueIndex = 2;
2488 dstAlphaIndex = 3;
2489 dstLuminanceIndex = dstIntensityIndex = -1;
2490 break;
2491 default:
2492 gl_problem(ctx, "bad dstFormat in _mesa_unpack_ubyte_span()");
2493 return;
2494 }
2495
2496
2497 /* Now return the GLubyte data in the requested dstFormat */
2498
2499 if (dstRedIndex >= 0) {
2500 GLubyte *dst = dest;
2501 GLuint i;
2502 for (i = 0; i < n; i++) {
2503 dst[dstRedIndex] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
2504 dst += dstComponents;
2505 }
2506 }
2507
2508 if (dstGreenIndex >= 0) {
2509 GLubyte *dst = dest;
2510 GLuint i;
2511 for (i = 0; i < n; i++) {
2512 dst[dstGreenIndex] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
2513 dst += dstComponents;
2514 }
2515 }
2516
2517 if (dstBlueIndex >= 0) {
2518 GLubyte *dst = dest;
2519 GLuint i;
2520 for (i = 0; i < n; i++) {
2521 dst[dstBlueIndex] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
2522 dst += dstComponents;
2523 }
2524 }
2525
2526 if (dstAlphaIndex >= 0) {
2527 GLubyte *dst = dest;
2528 GLuint i;
2529 for (i = 0; i < n; i++) {
2530 dst[dstAlphaIndex] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
2531 dst += dstComponents;
2532 }
2533 }
2534
2535 if (dstIntensityIndex >= 0) {
2536 GLubyte *dst = dest;
2537 GLuint i;
2538 assert(dstIntensityIndex == 0);
2539 assert(dstComponents == 1);
2540 for (i = 0; i < n; i++) {
2541 /* Intensity comes from red channel */
2542 dst[i] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
2543 }
2544 }
2545
2546 if (dstLuminanceIndex >= 0) {
2547 GLubyte *dst = dest;
2548 GLuint i;
2549 assert(dstLuminanceIndex == 0);
2550 for (i = 0; i < n; i++) {
2551 /* Luminance comes from red channel */
2552 dst[0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
2553 dst += dstComponents;
2554 }
2555 }
2556 }
2557 }
2558
2559
2560 void
2561 _mesa_unpack_float_color_span( GLcontext *ctx,
2562 GLuint n, GLenum dstFormat, GLfloat dest[],
2563 GLenum srcFormat, GLenum srcType,
2564 const GLvoid *source,
2565 const struct gl_pixelstore_attrib *srcPacking,
2566 GLuint transferOps, GLboolean clamp )
2567 {
2568 ASSERT(dstFormat == GL_ALPHA ||
2569 dstFormat == GL_LUMINANCE ||
2570 dstFormat == GL_LUMINANCE_ALPHA ||
2571 dstFormat == GL_INTENSITY ||
2572 dstFormat == GL_RGB ||
2573 dstFormat == GL_RGBA ||
2574 dstFormat == GL_COLOR_INDEX);
2575
2576 ASSERT(srcFormat == GL_RED ||
2577 srcFormat == GL_GREEN ||
2578 srcFormat == GL_BLUE ||
2579 srcFormat == GL_ALPHA ||
2580 srcFormat == GL_LUMINANCE ||
2581 srcFormat == GL_LUMINANCE_ALPHA ||
2582 srcFormat == GL_INTENSITY ||
2583 srcFormat == GL_RGB ||
2584 srcFormat == GL_BGR ||
2585 srcFormat == GL_RGBA ||
2586 srcFormat == GL_BGRA ||
2587 srcFormat == GL_ABGR_EXT ||
2588 srcFormat == GL_COLOR_INDEX);
2589
2590 ASSERT(srcType == GL_BITMAP ||
2591 srcType == GL_UNSIGNED_BYTE ||
2592 srcType == GL_BYTE ||
2593 srcType == GL_UNSIGNED_SHORT ||
2594 srcType == GL_SHORT ||
2595 srcType == GL_UNSIGNED_INT ||
2596 srcType == GL_INT ||
2597 srcType == GL_FLOAT ||
2598 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
2599 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
2600 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
2601 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
2602 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
2603 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
2604 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
2605 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
2606 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
2607 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
2608 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
2609 srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
2610
2611 /* this is intended for RGBA mode only */
2612 assert(ctx->Visual.RGBAflag);
2613
2614 /* general solution, no special cases, yet */
2615 {
2616 GLfloat rgba[MAX_WIDTH][4];
2617 GLint dstComponents;
2618 GLint dstRedIndex, dstGreenIndex, dstBlueIndex, dstAlphaIndex;
2619 GLint dstLuminanceIndex, dstIntensityIndex;
2620
2621 dstComponents = _mesa_components_in_format( dstFormat );
2622 /* source & dest image formats should have been error checked by now */
2623 assert(dstComponents > 0);
2624
2625 /*
2626 * Extract image data and convert to RGBA floats
2627 */
2628 assert(n <= MAX_WIDTH);
2629 if (srcFormat == GL_COLOR_INDEX) {
2630 GLuint indexes[MAX_WIDTH];
2631 extract_uint_indexes(n, indexes, srcFormat, srcType, source,
2632 srcPacking);
2633
2634 if (dstFormat == GL_COLOR_INDEX
2635 && (transferOps & IMAGE_MAP_COLOR_BIT)) {
2636 _mesa_map_ci(ctx, n, indexes);
2637 }
2638 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
2639 _mesa_shift_and_offset_ci(ctx, n, indexes);
2640 }
2641
2642 if (dstFormat == GL_COLOR_INDEX) {
2643 /* convert to GLubyte and return */
2644 GLuint i;
2645 for (i = 0; i < n; i++) {
2646 dest[i] = (GLubyte) (indexes[i] & 0xff);
2647 }
2648 return;
2649 }
2650 else {
2651 /* Convert indexes to RGBA */
2652 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
2653 }
2654 }
2655 else {
2656 extract_float_rgba(n, rgba, srcFormat, srcType, source,
2657 srcPacking->SwapBytes);
2658
2659 /* scale and bias colors */
2660 if (transferOps & IMAGE_SCALE_BIAS_BIT) {
2661 _mesa_scale_and_bias_rgba(ctx, n, rgba);
2662 }
2663 /* color map lookup */
2664 if (transferOps & IMAGE_MAP_COLOR_BIT) {
2665 _mesa_map_rgba(ctx, n, rgba);
2666 }
2667 }
2668
2669 if (transferOps) {
2670 /* GL_COLOR_TABLE lookup */
2671 if (transferOps & IMAGE_COLOR_TABLE_BIT) {
2672 _mesa_lookup_rgba(&ctx->ColorTable, n, rgba);
2673 }
2674 /* convolution */
2675 if (transferOps & IMAGE_CONVOLUTION_BIT) {
2676 /* XXX to do */
2677 }
2678 /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
2679 if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) {
2680 _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, n, rgba);
2681 }
2682 /* color matrix transform */
2683 if (transferOps & IMAGE_COLOR_MATRIX_BIT) {
2684 _mesa_transform_rgba(ctx, n, rgba);
2685 }
2686 /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
2687 if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) {
2688 _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, n, rgba);
2689 }
2690 /* update histogram count */
2691 if (transferOps & IMAGE_HISTOGRAM_BIT) {
2692 _mesa_update_histogram(ctx, n, (CONST GLfloat (*)[4]) rgba);
2693 }
2694 /* min/max here */
2695 if (transferOps & IMAGE_MIN_MAX_BIT) {
2696 _mesa_update_minmax(ctx, n, (CONST GLfloat (*)[4]) rgba);
2697 }
2698 }
2699
2700 /* clamp to [0,1] */
2701 if (clamp) {
2702 GLuint i;
2703 for (i = 0; i < n; i++) {
2704 rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F);
2705 rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F);
2706 rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F);
2707 rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F);
2708 }
2709 }
2710
2711 /* Now determine which color channels we need to produce.
2712 * And determine the dest index (offset) within each color tuple.
2713 */
2714 switch (dstFormat) {
2715 case GL_ALPHA:
2716 dstAlphaIndex = 0;
2717 dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
2718 dstLuminanceIndex = dstIntensityIndex = -1;
2719 break;
2720 case GL_LUMINANCE:
2721 dstLuminanceIndex = 0;
2722 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
2723 dstIntensityIndex = -1;
2724 break;
2725 case GL_LUMINANCE_ALPHA:
2726 dstLuminanceIndex = 0;
2727 dstAlphaIndex = 1;
2728 dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
2729 dstIntensityIndex = -1;
2730 break;
2731 case GL_INTENSITY:
2732 dstIntensityIndex = 0;
2733 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
2734 dstLuminanceIndex = -1;
2735 break;
2736 case GL_RGB:
2737 dstRedIndex = 0;
2738 dstGreenIndex = 1;
2739 dstBlueIndex = 2;
2740 dstAlphaIndex = dstLuminanceIndex = dstIntensityIndex = -1;
2741 break;
2742 case GL_RGBA:
2743 dstRedIndex = 0;
2744 dstGreenIndex = 1;
2745 dstBlueIndex = 2;
2746 dstAlphaIndex = 3;
2747 dstLuminanceIndex = dstIntensityIndex = -1;
2748 break;
2749 default:
2750 gl_problem(ctx, "bad dstFormat in _mesa_unpack_float_color_span()");
2751 return;
2752 }
2753
2754 /* Now pack results in the requested dstFormat */
2755 if (dstRedIndex >= 0) {
2756 GLfloat *dst = dest;
2757 GLuint i;
2758 for (i = 0; i < n; i++) {
2759 dst[dstRedIndex] = rgba[i][RCOMP];
2760 dst += dstComponents;
2761 }
2762 }
2763
2764 if (dstGreenIndex >= 0) {
2765 GLfloat *dst = dest;
2766 GLuint i;
2767 for (i = 0; i < n; i++) {
2768 dst[dstGreenIndex] = rgba[i][GCOMP];
2769 dst += dstComponents;
2770 }
2771 }
2772
2773 if (dstBlueIndex >= 0) {
2774 GLfloat *dst = dest;
2775 GLuint i;
2776 for (i = 0; i < n; i++) {
2777 dst[dstBlueIndex] = rgba[i][BCOMP];
2778 dst += dstComponents;
2779 }
2780 }
2781
2782 if (dstAlphaIndex >= 0) {
2783 GLfloat *dst = dest;
2784 GLuint i;
2785 for (i = 0; i < n; i++) {
2786 dst[dstAlphaIndex] = rgba[i][ACOMP];
2787 dst += dstComponents;
2788 }
2789 }
2790
2791 if (dstIntensityIndex >= 0) {
2792 GLfloat *dst = dest;
2793 GLuint i;
2794 assert(dstIntensityIndex == 0);
2795 assert(dstComponents == 1);
2796 for (i = 0; i < n; i++) {
2797 /* Intensity comes from red channel */
2798 dst[i] = rgba[i][RCOMP];
2799 }
2800 }
2801
2802 if (dstLuminanceIndex >= 0) {
2803 GLfloat *dst = dest;
2804 GLuint i;
2805 assert(dstLuminanceIndex == 0);
2806 for (i = 0; i < n; i++) {
2807 /* Luminance comes from red channel */
2808 dst[0] = rgba[i][RCOMP];
2809 dst += dstComponents;
2810 }
2811 }
2812 }
2813 }
2814
2815
2816
2817
2818 /*
2819 * Unpack a row of color index data from a client buffer according to
2820 * the pixel unpacking parameters.
2821 * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.
2822 *
2823 * Args: ctx - the context
2824 * n - number of pixels
2825 * dstType - destination datatype
2826 * dest - destination array
2827 * srcType - source pixel type
2828 * source - source data pointer
2829 * srcPacking - pixel unpacking parameters
2830 * transferOps - the pixel transfer operations to apply
2831 */
2832 void
2833 _mesa_unpack_index_span( const GLcontext *ctx, GLuint n,
2834 GLenum dstType, GLvoid *dest,
2835 GLenum srcType, const GLvoid *source,
2836 const struct gl_pixelstore_attrib *srcPacking,
2837 GLuint transferOps )
2838 {
2839 ASSERT(srcType == GL_BITMAP ||
2840 srcType == GL_UNSIGNED_BYTE ||
2841 srcType == GL_BYTE ||
2842 srcType == GL_UNSIGNED_SHORT ||
2843 srcType == GL_SHORT ||
2844 srcType == GL_UNSIGNED_INT ||
2845 srcType == GL_INT ||
2846 srcType == GL_FLOAT);
2847
2848 ASSERT(dstType == GL_UNSIGNED_BYTE ||
2849 dstType == GL_UNSIGNED_SHORT ||
2850 dstType == GL_UNSIGNED_INT);
2851
2852
2853 transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
2854
2855 /*
2856 * Try simple cases first
2857 */
2858 if (transferOps == 0 && srcType == GL_UNSIGNED_BYTE
2859 && dstType == GL_UNSIGNED_BYTE) {
2860 MEMCPY(dest, source, n * sizeof(GLubyte));
2861 }
2862 else if (transferOps == 0 && srcType == GL_UNSIGNED_INT
2863 && dstType == GL_UNSIGNED_INT && !srcPacking->SwapBytes) {
2864 MEMCPY(dest, source, n * sizeof(GLuint));
2865 }
2866 else {
2867 /*
2868 * general solution
2869 */
2870 GLuint indexes[MAX_WIDTH];
2871 assert(n <= MAX_WIDTH);
2872
2873 extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
2874 srcPacking);
2875
2876 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
2877 /* shift and offset indexes */
2878 _mesa_shift_and_offset_ci(ctx, n, indexes);
2879 }
2880 if (transferOps & IMAGE_MAP_COLOR_BIT) {
2881 /* Apply lookup table */
2882 _mesa_map_ci(ctx, n, indexes);
2883 }
2884
2885 /* convert to dest type */
2886 switch (dstType) {
2887 case GL_UNSIGNED_BYTE:
2888 {
2889 GLubyte *dst = (GLubyte *) dest;
2890 GLuint i;
2891 for (i = 0; i < n; i++) {
2892 dst[i] = (GLubyte) (indexes[i] & 0xff);
2893 }
2894 }
2895 break;
2896 case GL_UNSIGNED_SHORT:
2897 {
2898 GLuint *dst = (GLuint *) dest;
2899 GLuint i;
2900 for (i = 0; i < n; i++) {
2901 dst[i] = (GLushort) (indexes[i] & 0xffff);
2902 }
2903 }
2904 break;
2905 case GL_UNSIGNED_INT:
2906 MEMCPY(dest, indexes, n * sizeof(GLuint));
2907 break;
2908 default:
2909 gl_problem(ctx, "bad dstType in _mesa_unpack_index_span");
2910 }
2911 }
2912 }
2913
2914
2915 /*
2916 * Unpack a row of stencil data from a client buffer according to
2917 * the pixel unpacking parameters.
2918 * This is (or will be) used by glDrawPixels
2919 *
2920 * Args: ctx - the context
2921 * n - number of pixels
2922 * dstType - destination datatype
2923 * dest - destination array
2924 * srcType - source pixel type
2925 * source - source data pointer
2926 * srcPacking - pixel unpacking parameters
2927 * transferOps - apply offset/bias/lookup ops?
2928 */
2929 void
2930 _mesa_unpack_stencil_span( const GLcontext *ctx, GLuint n,
2931 GLenum dstType, GLvoid *dest,
2932 GLenum srcType, const GLvoid *source,
2933 const struct gl_pixelstore_attrib *srcPacking,
2934 GLuint transferOps )
2935 {
2936 ASSERT(srcType == GL_BITMAP ||
2937 srcType == GL_UNSIGNED_BYTE ||
2938 srcType == GL_BYTE ||
2939 srcType == GL_UNSIGNED_SHORT ||
2940 srcType == GL_SHORT ||
2941 srcType == GL_UNSIGNED_INT ||
2942 srcType == GL_INT ||
2943 srcType == GL_FLOAT);
2944
2945 ASSERT(dstType == GL_UNSIGNED_BYTE ||
2946 dstType == GL_UNSIGNED_SHORT ||
2947 dstType == GL_UNSIGNED_INT);
2948
2949 /* only shift and offset apply to stencil */
2950 transferOps &= IMAGE_SHIFT_OFFSET_BIT;
2951
2952 /*
2953 * Try simple cases first
2954 */
2955 if (transferOps == 0 &&
2956 srcType == GL_UNSIGNED_BYTE &&
2957 dstType == GL_UNSIGNED_BYTE) {
2958 MEMCPY(dest, source, n * sizeof(GLubyte));
2959 }
2960 else if (transferOps == 0 &&
2961 srcType == GL_UNSIGNED_INT &&
2962 dstType == GL_UNSIGNED_INT &&
2963 !srcPacking->SwapBytes) {
2964 MEMCPY(dest, source, n * sizeof(GLuint));
2965 }
2966 else {
2967 /*
2968 * general solution
2969 */
2970 GLuint indexes[MAX_WIDTH];
2971 assert(n <= MAX_WIDTH);
2972
2973 extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
2974 srcPacking);
2975
2976 if (transferOps) {
2977 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
2978 /* shift and offset indexes */
2979 _mesa_shift_and_offset_ci(ctx, n, indexes);
2980 }
2981
2982 if (ctx->Pixel.MapStencilFlag) {
2983 /* Apply stencil lookup table */
2984 GLuint mask = ctx->Pixel.MapStoSsize - 1;
2985 GLuint i;
2986 for (i=0;i<n;i++) {
2987 indexes[i] = ctx->Pixel.MapStoS[ indexes[i] & mask ];
2988 }
2989 }
2990 }
2991
2992 /* convert to dest type */
2993 switch (dstType) {
2994 case GL_UNSIGNED_BYTE:
2995 {
2996 GLubyte *dst = (GLubyte *) dest;
2997 GLuint i;
2998 for (i = 0; i < n; i++) {
2999 dst[i] = (GLubyte) (indexes[i] & 0xff);
3000 }
3001 }
3002 break;
3003 case GL_UNSIGNED_SHORT:
3004 {
3005 GLuint *dst = (GLuint *) dest;
3006 GLuint i;
3007 for (i = 0; i < n; i++) {
3008 dst[i] = (GLushort) (indexes[i] & 0xffff);
3009 }
3010 }
3011 break;
3012 case GL_UNSIGNED_INT:
3013 MEMCPY(dest, indexes, n * sizeof(GLuint));
3014 break;
3015 default:
3016 gl_problem(ctx, "bad dstType in _mesa_unpack_stencil_span");
3017 }
3018 }
3019 }
3020
3021
3022
3023 void
3024 _mesa_unpack_depth_span( const GLcontext *ctx, GLuint n, GLdepth *dest,
3025 GLenum srcType, const GLvoid *source,
3026 const struct gl_pixelstore_attrib *srcPacking,
3027 GLuint transferOps )
3028 {
3029 GLfloat *depth = MALLOC(n * sizeof(GLfloat));
3030 if (!depth)
3031 return;
3032
3033 switch (srcType) {
3034 case GL_BYTE:
3035 {
3036 GLuint i;
3037 const GLubyte *src = (const GLubyte *) source;
3038 for (i = 0; i < n; i++) {
3039 depth[i] = BYTE_TO_FLOAT(src[i]);
3040 }
3041 }
3042 break;
3043 case GL_UNSIGNED_BYTE:
3044 {
3045 GLuint i;
3046 const GLubyte *src = (const GLubyte *) source;
3047 for (i = 0; i < n; i++) {
3048 depth[i] = UBYTE_TO_FLOAT(src[i]);
3049 }
3050 }
3051 break;
3052 case GL_SHORT:
3053 {
3054 GLuint i;
3055 const GLshort *src = (const GLshort *) source;
3056 for (i = 0; i < n; i++) {
3057 depth[i] = SHORT_TO_FLOAT(src[i]);
3058 }
3059 }
3060 break;
3061 case GL_UNSIGNED_SHORT:
3062 {
3063 GLuint i;
3064 const GLushort *src = (const GLushort *) source;
3065 for (i = 0; i < n; i++) {
3066 depth[i] = USHORT_TO_FLOAT(src[i]);
3067 }
3068 }
3069 break;
3070 case GL_INT:
3071 {
3072 GLuint i;
3073 const GLint *src = (const GLint *) source;
3074 for (i = 0; i < n; i++) {
3075 depth[i] = INT_TO_FLOAT(src[i]);
3076 }
3077 }
3078 break;
3079 case GL_UNSIGNED_INT:
3080 {
3081 GLuint i;
3082 const GLuint *src = (const GLuint *) source;
3083 for (i = 0; i < n; i++) {
3084 depth[i] = UINT_TO_FLOAT(src[i]);
3085 }
3086 }
3087 break;
3088 case GL_FLOAT:
3089 MEMCPY(depth, source, n * sizeof(GLfloat));
3090 break;
3091 default:
3092 gl_problem(NULL, "bad type in _mesa_unpack_depth_span()");
3093 FREE(depth);
3094 return;
3095 }
3096
3097
3098 /* apply depth scale and bias */
3099 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
3100 GLuint i;
3101 for (i = 0; i < n; i++) {
3102 depth[i] = depth[i] * ctx->Pixel.DepthScale + ctx->Pixel.DepthBias;
3103 }
3104 }
3105
3106 /* clamp depth values to [0,1] and convert from floats to integers */
3107 {
3108 const GLfloat zs = ctx->Visual.DepthMaxF;
3109 GLuint i;
3110 for (i = 0; i < n; i++) {
3111 dest[i] = (GLdepth) (CLAMP(depth[i], 0.0F, 1.0F) * zs);
3112 }
3113 }
3114
3115 FREE(depth);
3116 }
3117
3118
3119
3120 /*
3121 * Unpack image data. Apply byteswapping, byte flipping (bitmap).
3122 * Return all image data in a contiguous block.
3123 */
3124 void *
3125 _mesa_unpack_image( GLsizei width, GLsizei height, GLsizei depth,
3126 GLenum format, GLenum type, const GLvoid *pixels,
3127 const struct gl_pixelstore_attrib *unpack )
3128 {
3129 GLint bytesPerRow, compsPerRow;
3130 GLboolean flipBytes, swap2, swap4;
3131
3132 if (!pixels)
3133 return NULL; /* not necessarily an error */
3134
3135 if (width <= 0 || height <= 0 || depth <= 0)
3136 return NULL; /* generate error later */
3137
3138 if (format == GL_BITMAP) {
3139 bytesPerRow = (width + 7) >> 3;
3140 flipBytes = !unpack->LsbFirst;
3141 swap2 = swap4 = GL_FALSE;
3142 compsPerRow = 0;
3143 }
3144 else {
3145 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
3146 const GLint components = _mesa_components_in_format(format);
3147 GLint bytesPerComp;
3148 if (bytesPerPixel <= 0 || components <= 0)
3149 return NULL; /* bad format or type. generate error later */
3150 bytesPerRow = bytesPerPixel * width;
3151 bytesPerComp = bytesPerPixel / components;
3152 flipBytes = GL_FALSE;
3153 swap2 = (bytesPerComp == 2) && unpack->SwapBytes;
3154 swap4 = (bytesPerComp == 4) && unpack->SwapBytes;
3155 compsPerRow = components * width;
3156 assert(compsPerRow >= width);
3157 }
3158
3159 {
3160 GLubyte *destBuffer = MALLOC(bytesPerRow * height * depth);
3161 GLubyte *dst;
3162 GLint img, row;
3163 if (!destBuffer)
3164 return NULL; /* generate GL_OUT_OF_MEMORY later */
3165
3166 dst = destBuffer;
3167 for (img = 0; img < depth; img++) {
3168 for (row = 0; row < height; row++) {
3169 const GLvoid *src = _mesa_image_address(unpack, pixels,
3170 width, height, format, type, img, row, 0);
3171 MEMCPY(dst, src, bytesPerRow);
3172 /* byte flipping/swapping */
3173 if (flipBytes) {
3174 flip_bytes((GLubyte *) dst, bytesPerRow);
3175 }
3176 else if (swap2) {
3177 _mesa_swap2((GLushort*) dst, compsPerRow);
3178 }
3179 else if (swap4) {
3180 _mesa_swap4((GLuint*) dst, compsPerRow);
3181 }
3182 dst += bytesPerRow;
3183 }
3184 }
3185 return destBuffer;
3186 }
3187 }
3188
3189
3190 /*
3191 * Unpack bitmap data. Resulting data will be in most-significant-bit-first
3192 * order with row alignment = 1 byte.
3193 */
3194 GLvoid *
3195 _mesa_unpack_bitmap( GLint width, GLint height, const GLubyte *pixels,
3196 const struct gl_pixelstore_attrib *packing )
3197 {
3198 GLint bytes, row, width_in_bytes;
3199 GLubyte *buffer, *dst;
3200
3201 if (!pixels)
3202 return NULL;
3203
3204 /* Alloc dest storage */
3205 bytes = ((width + 7) / 8 * height);
3206 buffer = (GLubyte *) MALLOC( bytes );
3207 if (!buffer)
3208 return NULL;
3209
3210
3211 width_in_bytes = CEILING( width, 8 );
3212 dst = buffer;
3213 for (row = 0; row < height; row++) {
3214 GLubyte *src = _mesa_image_address( packing, pixels, width, height,
3215 GL_COLOR_INDEX, GL_BITMAP,
3216 0, row, 0 );
3217 if (!src) {
3218 FREE(buffer);
3219 return NULL;
3220 }
3221
3222 if (packing->SkipPixels == 0) {
3223 MEMCPY( dst, src, width_in_bytes );
3224 if (packing->LsbFirst) {
3225 flip_bytes( dst, width_in_bytes );
3226 }
3227 }
3228 else {
3229 /* handling SkipPixels is a bit tricky (no pun intended!) */
3230 GLint i;
3231 if (packing->LsbFirst) {
3232 GLubyte srcMask = 1 << (packing->SkipPixels & 0x7);
3233 GLubyte dstMask = 128;
3234 GLubyte *s = src;
3235 GLubyte *d = dst;
3236 *d = 0;
3237 for (i = 0; i < width; i++) {
3238 if (*s & srcMask) {
3239 *d |= dstMask;
3240 }
3241 if (srcMask == 128) {
3242 srcMask = 1;
3243 s++;
3244 }
3245 else {
3246 srcMask = srcMask << 1;
3247 }
3248 if (dstMask == 1) {
3249 dstMask = 128;
3250 d++;
3251 *d = 0;
3252 }
3253 else {
3254 dstMask = dstMask >> 1;
3255 }
3256 }
3257 }
3258 else {
3259 GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7);
3260 GLubyte dstMask = 128;
3261 GLubyte *s = src;
3262 GLubyte *d = dst;
3263 *d = 0;
3264 for (i = 0; i < width; i++) {
3265 if (*s & srcMask) {
3266 *d |= dstMask;
3267 }
3268 if (srcMask == 1) {
3269 srcMask = 128;
3270 s++;
3271 }
3272 else {
3273 srcMask = srcMask >> 1;
3274 }
3275 if (dstMask == 1) {
3276 dstMask = 128;
3277 d++;
3278 *d = 0;
3279 }
3280 else {
3281 dstMask = dstMask >> 1;
3282 }
3283 }
3284 }
3285 }
3286 dst += width_in_bytes;
3287 }
3288
3289 return buffer;
3290 }
3291
3292
3293 /*
3294 * Pack bitmap data.
3295 */
3296 void
3297 _mesa_pack_bitmap( GLint width, GLint height, const GLubyte *source,
3298 GLubyte *dest, const struct gl_pixelstore_attrib *packing )
3299 {
3300 GLint row, width_in_bytes;
3301 const GLubyte *src;
3302
3303 if (!source)
3304 return;
3305
3306 width_in_bytes = CEILING( width, 8 );
3307 src = source;
3308 for (row = 0; row < height; row++) {
3309 GLubyte *dst = _mesa_image_address( packing, dest, width, height,
3310 GL_COLOR_INDEX, GL_BITMAP,
3311 0, row, 0 );
3312 if (!dst)
3313 return;
3314
3315 if (packing->SkipPixels == 0) {
3316 MEMCPY( dst, src, width_in_bytes );
3317 if (packing->LsbFirst) {
3318 flip_bytes( dst, width_in_bytes );
3319 }
3320 }
3321 else {
3322 /* handling SkipPixels is a bit tricky (no pun intended!) */
3323 GLint i;
3324 if (packing->LsbFirst) {
3325 GLubyte srcMask = 1 << (packing->SkipPixels & 0x7);
3326 GLubyte dstMask = 128;
3327 const GLubyte *s = src;
3328 GLubyte *d = dst;
3329 *d = 0;
3330 for (i = 0; i < width; i++) {
3331 if (*s & srcMask) {
3332 *d |= dstMask;
3333 }
3334 if (srcMask == 128) {
3335 srcMask = 1;
3336 s++;
3337 }
3338 else {
3339 srcMask = srcMask << 1;
3340 }
3341 if (dstMask == 1) {
3342 dstMask = 128;
3343 d++;
3344 *d = 0;
3345 }
3346 else {
3347 dstMask = dstMask >> 1;
3348 }
3349 }
3350 }
3351 else {
3352 GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7);
3353 GLubyte dstMask = 128;
3354 const GLubyte *s = src;
3355 GLubyte *d = dst;
3356 *d = 0;
3357 for (i = 0; i < width; i++) {
3358 if (*s & srcMask) {
3359 *d |= dstMask;
3360 }
3361 if (srcMask == 1) {
3362 srcMask = 128;
3363 s++;
3364 }
3365 else {
3366 srcMask = srcMask >> 1;
3367 }
3368 if (dstMask == 1) {
3369 dstMask = 128;
3370 d++;
3371 *d = 0;
3372 }
3373 else {
3374 dstMask = dstMask >> 1;
3375 }
3376 }
3377 }
3378 }
3379 src += width_in_bytes;
3380 }
3381 }