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