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