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