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