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