projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
mesa: revert f9f79c8d770e696249bd98c68b563f887562c974
[mesa.git] / src / mesa / main / image.c
1 /*
2 * Mesa 3-D graphics library
3 * Version: 6.5.3
4 *
5 * Copyright (C) 1999-2007 Brian Paul All Rights Reserved.
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 */
24
25
26 /**
27 * \file image.c
28 * Image handling.
29 */
30
31
32 #include "glheader.h"
33 #include "colormac.h"
34 #include "context.h"
35 #include "image.h"
36 #include "imports.h"
37 #include "histogram.h"
38 #include "macros.h"
39 #include "pixel.h"
40
41
42 /**
43 * NOTE:
44 * Normally, BYTE_TO_FLOAT(0) returns 0.00392 That causes problems when
45 * we later convert the float to a packed integer value (such as for
46 * GL_RGB5_A1) because we'll wind up with a non-zero value.
47 *
48 * We redefine the macros here so zero is handled correctly.
49 */
50 #undef BYTE_TO_FLOAT
51 #define BYTE_TO_FLOAT(B) ((B) == 0 ? 0.0F : ((2.0F * (B) + 1.0F) * (1.0F/255.0F)))
52
53 #undef SHORT_TO_FLOAT
54 #define SHORT_TO_FLOAT(S) ((S) == 0 ? 0.0F : ((2.0F * (S) + 1.0F) * (1.0F/65535.0F)))
55
56
57
58 /** Compute ceiling of integer quotient of A divided by B. */
59 #define CEILING( A, B ) ( (A) % (B) == 0 ? (A)/(B) : (A)/(B)+1 )
60
61
62 /**
63 * \return GL_TRUE if type is packed pixel type, GL_FALSE otherwise.
64 */
65 static GLboolean
66 _mesa_type_is_packed(GLenum type)
67 {
68 switch (type) {
69 case GL_UNSIGNED_BYTE_3_3_2:
70 case GL_UNSIGNED_BYTE_2_3_3_REV:
71 case GL_UNSIGNED_SHORT_5_6_5:
72 case GL_UNSIGNED_SHORT_5_6_5_REV:
73 case GL_UNSIGNED_SHORT_4_4_4_4:
74 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
75 case GL_UNSIGNED_SHORT_5_5_5_1:
76 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
77 case GL_UNSIGNED_INT_8_8_8_8:
78 case GL_UNSIGNED_INT_8_8_8_8_REV:
79 case GL_UNSIGNED_INT_10_10_10_2:
80 case GL_UNSIGNED_INT_2_10_10_10_REV:
81 case GL_UNSIGNED_SHORT_8_8_MESA:
82 case GL_UNSIGNED_SHORT_8_8_REV_MESA:
83 case GL_UNSIGNED_INT_24_8_EXT:
84 return GL_TRUE;
85 }
86
87 return GL_FALSE;
88 }
89
90 /**
91 * Flip the 8 bits in each byte of the given array.
92 *
93 * \param p array.
94 * \param n number of bytes.
95 *
96 * \todo try this trick to flip bytes someday:
97 * \code
98 * v = ((v & 0x55555555) << 1) | ((v >> 1) & 0x55555555);
99 * v = ((v & 0x33333333) << 2) | ((v >> 2) & 0x33333333);
100 * v = ((v & 0x0f0f0f0f) << 4) | ((v >> 4) & 0x0f0f0f0f);
101 * \endcode
102 */
103 static void
104 flip_bytes( GLubyte *p, GLuint n )
105 {
106 register GLuint i, a, b;
107
108 for (i=0;i<n;i++) {
109 b = (GLuint) p[i]; /* words are often faster than bytes */
110 a = ((b & 0x01) << 7) |
111 ((b & 0x02) << 5) |
112 ((b & 0x04) << 3) |
113 ((b & 0x08) << 1) |
114 ((b & 0x10) >> 1) |
115 ((b & 0x20) >> 3) |
116 ((b & 0x40) >> 5) |
117 ((b & 0x80) >> 7);
118 p[i] = (GLubyte) a;
119 }
120 }
121
122
123 /**
124 * Flip the order of the 2 bytes in each word in the given array.
125 *
126 * \param p array.
127 * \param n number of words.
128 */
129 void
130 _mesa_swap2( GLushort *p, GLuint n )
131 {
132 register GLuint i;
133
134 for (i=0;i<n;i++) {
135 p[i] = (p[i] >> 8) | ((p[i] << 8) & 0xff00);
136 }
137 }
138
139
140
141 /*
142 * Flip the order of the 4 bytes in each word in the given array.
143 */
144 void
145 _mesa_swap4( GLuint *p, GLuint n )
146 {
147 register GLuint i, a, b;
148
149 for (i=0;i<n;i++) {
150 b = p[i];
151 a = (b >> 24)
152 | ((b >> 8) & 0xff00)
153 | ((b << 8) & 0xff0000)
154 | ((b << 24) & 0xff000000);
155 p[i] = a;
156 }
157 }
158
159
160 /**
161 * Get the size of a GL data type.
162 *
163 * \param type GL data type.
164 *
165 * \return the size, in bytes, of the given data type, 0 if a GL_BITMAP, or -1
166 * if an invalid type enum.
167 */
168 GLint
169 _mesa_sizeof_type( GLenum type )
170 {
171 switch (type) {
172 case GL_BITMAP:
173 return 0;
174 case GL_UNSIGNED_BYTE:
175 return sizeof(GLubyte);
176 case GL_BYTE:
177 return sizeof(GLbyte);
178 case GL_UNSIGNED_SHORT:
179 return sizeof(GLushort);
180 case GL_SHORT:
181 return sizeof(GLshort);
182 case GL_UNSIGNED_INT:
183 return sizeof(GLuint);
184 case GL_INT:
185 return sizeof(GLint);
186 case GL_FLOAT:
187 return sizeof(GLfloat);
188 case GL_HALF_FLOAT_ARB:
189 return sizeof(GLhalfARB);
190 default:
191 return -1;
192 }
193 }
194
195
196 /**
197 * Same as _mesa_sizeof_type() but also accepting the packed pixel
198 * format data types.
199 */
200 GLint
201 _mesa_sizeof_packed_type( GLenum type )
202 {
203 switch (type) {
204 case GL_BITMAP:
205 return 0;
206 case GL_UNSIGNED_BYTE:
207 return sizeof(GLubyte);
208 case GL_BYTE:
209 return sizeof(GLbyte);
210 case GL_UNSIGNED_SHORT:
211 return sizeof(GLushort);
212 case GL_SHORT:
213 return sizeof(GLshort);
214 case GL_UNSIGNED_INT:
215 return sizeof(GLuint);
216 case GL_INT:
217 return sizeof(GLint);
218 case GL_HALF_FLOAT_ARB:
219 return sizeof(GLhalfARB);
220 case GL_FLOAT:
221 return sizeof(GLfloat);
222 case GL_UNSIGNED_BYTE_3_3_2:
223 return sizeof(GLubyte);
224 case GL_UNSIGNED_BYTE_2_3_3_REV:
225 return sizeof(GLubyte);
226 case GL_UNSIGNED_SHORT_5_6_5:
227 return sizeof(GLushort);
228 case GL_UNSIGNED_SHORT_5_6_5_REV:
229 return sizeof(GLushort);
230 case GL_UNSIGNED_SHORT_4_4_4_4:
231 return sizeof(GLushort);
232 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
233 return sizeof(GLushort);
234 case GL_UNSIGNED_SHORT_5_5_5_1:
235 return sizeof(GLushort);
236 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
237 return sizeof(GLushort);
238 case GL_UNSIGNED_INT_8_8_8_8:
239 return sizeof(GLuint);
240 case GL_UNSIGNED_INT_8_8_8_8_REV:
241 return sizeof(GLuint);
242 case GL_UNSIGNED_INT_10_10_10_2:
243 return sizeof(GLuint);
244 case GL_UNSIGNED_INT_2_10_10_10_REV:
245 return sizeof(GLuint);
246 case GL_UNSIGNED_SHORT_8_8_MESA:
247 case GL_UNSIGNED_SHORT_8_8_REV_MESA:
248 return sizeof(GLushort);
249 case GL_UNSIGNED_INT_24_8_EXT:
250 return sizeof(GLuint);
251 default:
252 return -1;
253 }
254 }
255
256
257 /**
258 * Get the number of components in a pixel format.
259 *
260 * \param format pixel format.
261 *
262 * \return the number of components in the given format, or -1 if a bad format.
263 */
264 GLint
265 _mesa_components_in_format( GLenum format )
266 {
267 switch (format) {
268 case GL_COLOR_INDEX:
269 case GL_COLOR_INDEX1_EXT:
270 case GL_COLOR_INDEX2_EXT:
271 case GL_COLOR_INDEX4_EXT:
272 case GL_COLOR_INDEX8_EXT:
273 case GL_COLOR_INDEX12_EXT:
274 case GL_COLOR_INDEX16_EXT:
275 case GL_STENCIL_INDEX:
276 case GL_DEPTH_COMPONENT:
277 case GL_RED:
278 case GL_GREEN:
279 case GL_BLUE:
280 case GL_ALPHA:
281 case GL_LUMINANCE:
282 case GL_INTENSITY:
283 return 1;
284 case GL_LUMINANCE_ALPHA:
285 return 2;
286 case GL_RGB:
287 return 3;
288 case GL_RGBA:
289 return 4;
290 case GL_BGR:
291 return 3;
292 case GL_BGRA:
293 return 4;
294 case GL_ABGR_EXT:
295 return 4;
296 case GL_YCBCR_MESA:
297 return 2;
298 case GL_DEPTH_STENCIL_EXT:
299 return 2;
300 default:
301 return -1;
302 }
303 }
304
305
306 /**
307 * Get the bytes per pixel of pixel format type pair.
308 *
309 * \param format pixel format.
310 * \param type pixel type.
311 *
312 * \return bytes per pixel, or -1 if a bad format or type was given.
313 */
314 GLint
315 _mesa_bytes_per_pixel( GLenum format, GLenum type )
316 {
317 GLint comps = _mesa_components_in_format( format );
318 if (comps < 0)
319 return -1;
320
321 switch (type) {
322 case GL_BITMAP:
323 return 0; /* special case */
324 case GL_BYTE:
325 case GL_UNSIGNED_BYTE:
326 return comps * sizeof(GLubyte);
327 case GL_SHORT:
328 case GL_UNSIGNED_SHORT:
329 return comps * sizeof(GLshort);
330 case GL_INT:
331 case GL_UNSIGNED_INT:
332 return comps * sizeof(GLint);
333 case GL_FLOAT:
334 return comps * sizeof(GLfloat);
335 case GL_HALF_FLOAT_ARB:
336 return comps * sizeof(GLhalfARB);
337 case GL_UNSIGNED_BYTE_3_3_2:
338 case GL_UNSIGNED_BYTE_2_3_3_REV:
339 if (format == GL_RGB || format == GL_BGR)
340 return sizeof(GLubyte);
341 else
342 return -1; /* error */
343 case GL_UNSIGNED_SHORT_5_6_5:
344 case GL_UNSIGNED_SHORT_5_6_5_REV:
345 if (format == GL_RGB || format == GL_BGR)
346 return sizeof(GLushort);
347 else
348 return -1; /* error */
349 case GL_UNSIGNED_SHORT_4_4_4_4:
350 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
351 case GL_UNSIGNED_SHORT_5_5_5_1:
352 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
353 if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT)
354 return sizeof(GLushort);
355 else
356 return -1;
357 case GL_UNSIGNED_INT_8_8_8_8:
358 case GL_UNSIGNED_INT_8_8_8_8_REV:
359 case GL_UNSIGNED_INT_10_10_10_2:
360 case GL_UNSIGNED_INT_2_10_10_10_REV:
361 if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT)
362 return sizeof(GLuint);
363 else
364 return -1;
365 case GL_UNSIGNED_SHORT_8_8_MESA:
366 case GL_UNSIGNED_SHORT_8_8_REV_MESA:
367 if (format == GL_YCBCR_MESA)
368 return sizeof(GLushort);
369 else
370 return -1;
371 case GL_UNSIGNED_INT_24_8_EXT:
372 if (format == GL_DEPTH_STENCIL_EXT)
373 return sizeof(GLuint);
374 else
375 return -1;
376 default:
377 return -1;
378 }
379 }
380
381
382 /**
383 * Test for a legal pixel format and type.
384 *
385 * \param format pixel format.
386 * \param type pixel type.
387 *
388 * \return GL_TRUE if the given pixel format and type are legal, or GL_FALSE
389 * otherwise.
390 */
391 GLboolean
392 _mesa_is_legal_format_and_type( GLcontext *ctx, GLenum format, GLenum type )
393 {
394 switch (format) {
395 case GL_COLOR_INDEX:
396 case GL_STENCIL_INDEX:
397 switch (type) {
398 case GL_BITMAP:
399 case GL_BYTE:
400 case GL_UNSIGNED_BYTE:
401 case GL_SHORT:
402 case GL_UNSIGNED_SHORT:
403 case GL_INT:
404 case GL_UNSIGNED_INT:
405 case GL_FLOAT:
406 return GL_TRUE;
407 case GL_HALF_FLOAT_ARB:
408 return ctx->Extensions.ARB_half_float_pixel;
409 default:
410 return GL_FALSE;
411 }
412 case GL_RED:
413 case GL_GREEN:
414 case GL_BLUE:
415 case GL_ALPHA:
416 #if 0 /* not legal! see table 3.6 of the 1.5 spec */
417 case GL_INTENSITY:
418 #endif
419 case GL_LUMINANCE:
420 case GL_LUMINANCE_ALPHA:
421 case GL_DEPTH_COMPONENT:
422 switch (type) {
423 case GL_BYTE:
424 case GL_UNSIGNED_BYTE:
425 case GL_SHORT:
426 case GL_UNSIGNED_SHORT:
427 case GL_INT:
428 case GL_UNSIGNED_INT:
429 case GL_FLOAT:
430 return GL_TRUE;
431 case GL_HALF_FLOAT_ARB:
432 return ctx->Extensions.ARB_half_float_pixel;
433 default:
434 return GL_FALSE;
435 }
436 case GL_RGB:
437 switch (type) {
438 case GL_BYTE:
439 case GL_UNSIGNED_BYTE:
440 case GL_SHORT:
441 case GL_UNSIGNED_SHORT:
442 case GL_INT:
443 case GL_UNSIGNED_INT:
444 case GL_FLOAT:
445 case GL_UNSIGNED_BYTE_3_3_2:
446 case GL_UNSIGNED_BYTE_2_3_3_REV:
447 case GL_UNSIGNED_SHORT_5_6_5:
448 case GL_UNSIGNED_SHORT_5_6_5_REV:
449 return GL_TRUE;
450 case GL_HALF_FLOAT_ARB:
451 return ctx->Extensions.ARB_half_float_pixel;
452 default:
453 return GL_FALSE;
454 }
455 case GL_BGR:
456 switch (type) {
457 /* NOTE: no packed types are supported with BGR. That's
458 * intentional, according to the GL spec.
459 */
460 case GL_BYTE:
461 case GL_UNSIGNED_BYTE:
462 case GL_SHORT:
463 case GL_UNSIGNED_SHORT:
464 case GL_INT:
465 case GL_UNSIGNED_INT:
466 case GL_FLOAT:
467 return GL_TRUE;
468 case GL_HALF_FLOAT_ARB:
469 return ctx->Extensions.ARB_half_float_pixel;
470 default:
471 return GL_FALSE;
472 }
473 case GL_RGBA:
474 case GL_BGRA:
475 case GL_ABGR_EXT:
476 switch (type) {
477 case GL_BYTE:
478 case GL_UNSIGNED_BYTE:
479 case GL_SHORT:
480 case GL_UNSIGNED_SHORT:
481 case GL_INT:
482 case GL_UNSIGNED_INT:
483 case GL_FLOAT:
484 case GL_UNSIGNED_SHORT_4_4_4_4:
485 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
486 case GL_UNSIGNED_SHORT_5_5_5_1:
487 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
488 case GL_UNSIGNED_INT_8_8_8_8:
489 case GL_UNSIGNED_INT_8_8_8_8_REV:
490 case GL_UNSIGNED_INT_10_10_10_2:
491 case GL_UNSIGNED_INT_2_10_10_10_REV:
492 return GL_TRUE;
493 case GL_HALF_FLOAT_ARB:
494 return ctx->Extensions.ARB_half_float_pixel;
495 default:
496 return GL_FALSE;
497 }
498 case GL_YCBCR_MESA:
499 if (type == GL_UNSIGNED_SHORT_8_8_MESA ||
500 type == GL_UNSIGNED_SHORT_8_8_REV_MESA)
501 return GL_TRUE;
502 else
503 return GL_FALSE;
504 case GL_DEPTH_STENCIL_EXT:
505 if (ctx->Extensions.EXT_packed_depth_stencil
506 && type == GL_UNSIGNED_INT_24_8_EXT)
507 return GL_TRUE;
508 else
509 return GL_FALSE;
510 default:
511 ; /* fall-through */
512 }
513 return GL_FALSE;
514 }
515
516
517 /**
518 * Return the address of a specific pixel in an image (1D, 2D or 3D).
519 *
520 * Pixel unpacking/packing parameters are observed according to \p packing.
521 *
522 * \param dimensions either 1, 2 or 3 to indicate dimensionality of image
523 * \param image starting address of image data
524 * \param width the image width
525 * \param height theimage height
526 * \param format the pixel format
527 * \param type the pixel data type
528 * \param packing the pixelstore attributes
529 * \param img which image in the volume (0 for 1D or 2D images)
530 * \param row row of pixel in the image (0 for 1D images)
531 * \param column column of pixel in the image
532 *
533 * \return address of pixel on success, or NULL on error.
534 *
535 * \sa gl_pixelstore_attrib.
536 */
537 GLvoid *
538 _mesa_image_address( GLuint dimensions,
539 const struct gl_pixelstore_attrib *packing,
540 const GLvoid *image,
541 GLsizei width, GLsizei height,
542 GLenum format, GLenum type,
543 GLint img, GLint row, GLint column )
544 {
545 GLint alignment; /* 1, 2 or 4 */
546 GLint pixels_per_row;
547 GLint rows_per_image;
548 GLint skiprows;
549 GLint skippixels;
550 GLint skipimages; /* for 3-D volume images */
551 GLubyte *pixel_addr;
552
553 ASSERT(dimensions >= 1 && dimensions <= 3);
554
555 alignment = packing->Alignment;
556 if (packing->RowLength > 0) {
557 pixels_per_row = packing->RowLength;
558 }
559 else {
560 pixels_per_row = width;
561 }
562 if (packing->ImageHeight > 0) {
563 rows_per_image = packing->ImageHeight;
564 }
565 else {
566 rows_per_image = height;
567 }
568
569 skippixels = packing->SkipPixels;
570 /* Note: SKIP_ROWS _is_ used for 1D images */
571 skiprows = packing->SkipRows;
572 /* Note: SKIP_IMAGES is only used for 3D images */
573 skipimages = (dimensions == 3) ? packing->SkipImages : 0;
574
575 if (type == GL_BITMAP) {
576 /* BITMAP data */
577 GLint comp_per_pixel; /* components per pixel */
578 GLint bytes_per_comp; /* bytes per component */
579 GLint bytes_per_row;
580 GLint bytes_per_image;
581
582 /* Compute bytes per component */
583 bytes_per_comp = _mesa_sizeof_packed_type( type );
584 if (bytes_per_comp < 0) {
585 return NULL;
586 }
587
588 /* Compute number of components per pixel */
589 comp_per_pixel = _mesa_components_in_format( format );
590 if (comp_per_pixel < 0) {
591 return NULL;
592 }
593
594 bytes_per_row = alignment
595 * CEILING( comp_per_pixel*pixels_per_row, 8*alignment );
596
597 bytes_per_image = bytes_per_row * rows_per_image;
598
599 pixel_addr = (GLubyte *) image
600 + (skipimages + img) * bytes_per_image
601 + (skiprows + row) * bytes_per_row
602 + (skippixels + column) / 8;
603 }
604 else {
605 /* Non-BITMAP data */
606 GLint bytes_per_pixel, bytes_per_row, remainder, bytes_per_image;
607 GLint topOfImage;
608
609 bytes_per_pixel = _mesa_bytes_per_pixel( format, type );
610
611 /* The pixel type and format should have been error checked earlier */
612 assert(bytes_per_pixel > 0);
613
614 bytes_per_row = pixels_per_row * bytes_per_pixel;
615 remainder = bytes_per_row % alignment;
616 if (remainder > 0)
617 bytes_per_row += (alignment - remainder);
618
619 ASSERT(bytes_per_row % alignment == 0);
620
621 bytes_per_image = bytes_per_row * rows_per_image;
622
623 if (packing->Invert) {
624 /* set pixel_addr to the last row */
625 topOfImage = bytes_per_row * (height - 1);
626 bytes_per_row = -bytes_per_row;
627 }
628 else {
629 topOfImage = 0;
630 }
631
632 /* compute final pixel address */
633 pixel_addr = (GLubyte *) image
634 + (skipimages + img) * bytes_per_image
635 + topOfImage
636 + (skiprows + row) * bytes_per_row
637 + (skippixels + column) * bytes_per_pixel;
638 }
639
640 return (GLvoid *) pixel_addr;
641 }
642
643
644 GLvoid *
645 _mesa_image_address1d( const struct gl_pixelstore_attrib *packing,
646 const GLvoid *image,
647 GLsizei width,
648 GLenum format, GLenum type,
649 GLint column )
650 {
651 return _mesa_image_address(1, packing, image, width, 1,
652 format, type, 0, 0, column);
653 }
654
655
656 GLvoid *
657 _mesa_image_address2d( const struct gl_pixelstore_attrib *packing,
658 const GLvoid *image,
659 GLsizei width, GLsizei height,
660 GLenum format, GLenum type,
661 GLint row, GLint column )
662 {
663 return _mesa_image_address(2, packing, image, width, height,
664 format, type, 0, row, column);
665 }
666
667
668 GLvoid *
669 _mesa_image_address3d( const struct gl_pixelstore_attrib *packing,
670 const GLvoid *image,
671 GLsizei width, GLsizei height,
672 GLenum format, GLenum type,
673 GLint img, GLint row, GLint column )
674 {
675 return _mesa_image_address(3, packing, image, width, height,
676 format, type, img, row, column);
677 }
678
679
680
681 /**
682 * Compute the stride (in bytes) between image rows.
683 *
684 * \param packing the pixelstore attributes
685 * \param width image width.
686 * \param format pixel format.
687 * \param type pixel data type.
688 *
689 * \return the stride in bytes for the given parameters, or -1 if error
690 */
691 GLint
692 _mesa_image_row_stride( const struct gl_pixelstore_attrib *packing,
693 GLint width, GLenum format, GLenum type )
694 {
695 GLint bytesPerRow, remainder;
696
697 ASSERT(packing);
698
699 if (type == GL_BITMAP) {
700 if (packing->RowLength == 0) {
701 bytesPerRow = (width + 7) / 8;
702 }
703 else {
704 bytesPerRow = (packing->RowLength + 7) / 8;
705 }
706 }
707 else {
708 /* Non-BITMAP data */
709 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
710 if (bytesPerPixel <= 0)
711 return -1; /* error */
712 if (packing->RowLength == 0) {
713 bytesPerRow = bytesPerPixel * width;
714 }
715 else {
716 bytesPerRow = bytesPerPixel * packing->RowLength;
717 }
718 }
719
720 remainder = bytesPerRow % packing->Alignment;
721 if (remainder > 0) {
722 bytesPerRow += (packing->Alignment - remainder);
723 }
724
725 if (packing->Invert) {
726 /* negate the bytes per row (negative row stride) */
727 bytesPerRow = -bytesPerRow;
728 }
729
730 return bytesPerRow;
731 }
732
733
734 #if _HAVE_FULL_GL
735
736 /*
737 * Compute the stride between images in a 3D texture (in bytes) for the given
738 * pixel packing parameters and image width, format and type.
739 */
740 GLint
741 _mesa_image_image_stride( const struct gl_pixelstore_attrib *packing,
742 GLint width, GLint height,
743 GLenum format, GLenum type )
744 {
745 ASSERT(packing);
746 ASSERT(type != GL_BITMAP);
747
748 {
749 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
750 GLint bytesPerRow, bytesPerImage, remainder;
751
752 if (bytesPerPixel <= 0)
753 return -1; /* error */
754 if (packing->RowLength == 0) {
755 bytesPerRow = bytesPerPixel * width;
756 }
757 else {
758 bytesPerRow = bytesPerPixel * packing->RowLength;
759 }
760 remainder = bytesPerRow % packing->Alignment;
761 if (remainder > 0)
762 bytesPerRow += (packing->Alignment - remainder);
763
764 if (packing->ImageHeight == 0)
765 bytesPerImage = bytesPerRow * height;
766 else
767 bytesPerImage = bytesPerRow * packing->ImageHeight;
768
769 return bytesPerImage;
770 }
771 }
772
773
774 /*
775 * Unpack a 32x32 pixel polygon stipple from user memory using the
776 * current pixel unpack settings.
777 */
778 void
779 _mesa_unpack_polygon_stipple( const GLubyte *pattern, GLuint dest[32],
780 const struct gl_pixelstore_attrib *unpacking )
781 {
782 GLubyte *ptrn = (GLubyte *) _mesa_unpack_bitmap(32, 32, pattern, unpacking);
783 if (ptrn) {
784 /* Convert pattern from GLubytes to GLuints and handle big/little
785 * endian differences
786 */
787 GLubyte *p = ptrn;
788 GLint i;
789 for (i = 0; i < 32; i++) {
790 dest[i] = (p[0] << 24)
791 | (p[1] << 16)
792 | (p[2] << 8)
793 | (p[3] );
794 p += 4;
795 }
796 _mesa_free(ptrn);
797 }
798 }
799
800
801 /*
802 * Pack polygon stipple into user memory given current pixel packing
803 * settings.
804 */
805 void
806 _mesa_pack_polygon_stipple( const GLuint pattern[32], GLubyte *dest,
807 const struct gl_pixelstore_attrib *packing )
808 {
809 /* Convert pattern from GLuints to GLubytes to handle big/little
810 * endian differences.
811 */
812 GLubyte ptrn[32*4];
813 GLint i;
814 for (i = 0; i < 32; i++) {
815 ptrn[i * 4 + 0] = (GLubyte) ((pattern[i] >> 24) & 0xff);
816 ptrn[i * 4 + 1] = (GLubyte) ((pattern[i] >> 16) & 0xff);
817 ptrn[i * 4 + 2] = (GLubyte) ((pattern[i] >> 8 ) & 0xff);
818 ptrn[i * 4 + 3] = (GLubyte) ((pattern[i] ) & 0xff);
819 }
820
821 _mesa_pack_bitmap(32, 32, ptrn, dest, packing);
822 }
823
824
825 /*
826 * Unpack bitmap data. Resulting data will be in most-significant-bit-first
827 * order with row alignment = 1 byte.
828 */
829 GLvoid *
830 _mesa_unpack_bitmap( GLint width, GLint height, const GLubyte *pixels,
831 const struct gl_pixelstore_attrib *packing )
832 {
833 GLint bytes, row, width_in_bytes;
834 GLubyte *buffer, *dst;
835
836 if (!pixels)
837 return NULL;
838
839 /* Alloc dest storage */
840 bytes = ((width + 7) / 8 * height);
841 buffer = (GLubyte *) _mesa_malloc( bytes );
842 if (!buffer)
843 return NULL;
844
845 width_in_bytes = CEILING( width, 8 );
846 dst = buffer;
847 for (row = 0; row < height; row++) {
848 const GLubyte *src = (const GLubyte *)
849 _mesa_image_address2d(packing, pixels, width, height,
850 GL_COLOR_INDEX, GL_BITMAP, row, 0);
851 if (!src) {
852 _mesa_free(buffer);
853 return NULL;
854 }
855
856 if (packing->SkipPixels == 0) {
857 _mesa_memcpy( dst, src, width_in_bytes );
858 if (packing->LsbFirst) {
859 flip_bytes( dst, width_in_bytes );
860 }
861 }
862 else {
863 /* handling SkipPixels is a bit tricky (no pun intended!) */
864 GLint i;
865 if (packing->LsbFirst) {
866 GLubyte srcMask = 1 << (packing->SkipPixels & 0x7);
867 GLubyte dstMask = 128;
868 const GLubyte *s = src;
869 GLubyte *d = dst;
870 *d = 0;
871 for (i = 0; i < width; i++) {
872 if (*s & srcMask) {
873 *d |= dstMask;
874 }
875 if (srcMask == 128) {
876 srcMask = 1;
877 s++;
878 }
879 else {
880 srcMask = srcMask << 1;
881 }
882 if (dstMask == 1) {
883 dstMask = 128;
884 d++;
885 *d = 0;
886 }
887 else {
888 dstMask = dstMask >> 1;
889 }
890 }
891 }
892 else {
893 GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7);
894 GLubyte dstMask = 128;
895 const GLubyte *s = src;
896 GLubyte *d = dst;
897 *d = 0;
898 for (i = 0; i < width; i++) {
899 if (*s & srcMask) {
900 *d |= dstMask;
901 }
902 if (srcMask == 1) {
903 srcMask = 128;
904 s++;
905 }
906 else {
907 srcMask = srcMask >> 1;
908 }
909 if (dstMask == 1) {
910 dstMask = 128;
911 d++;
912 *d = 0;
913 }
914 else {
915 dstMask = dstMask >> 1;
916 }
917 }
918 }
919 }
920 dst += width_in_bytes;
921 }
922
923 return buffer;
924 }
925
926
927 /*
928 * Pack bitmap data.
929 */
930 void
931 _mesa_pack_bitmap( GLint width, GLint height, const GLubyte *source,
932 GLubyte *dest, const struct gl_pixelstore_attrib *packing )
933 {
934 GLint row, width_in_bytes;
935 const GLubyte *src;
936
937 if (!source)
938 return;
939
940 width_in_bytes = CEILING( width, 8 );
941 src = source;
942 for (row = 0; row < height; row++) {
943 GLubyte *dst = (GLubyte *) _mesa_image_address2d(packing, dest,
944 width, height, GL_COLOR_INDEX, GL_BITMAP, row, 0);
945 if (!dst)
946 return;
947
948 if (packing->SkipPixels == 0) {
949 _mesa_memcpy( dst, src, width_in_bytes );
950 if (packing->LsbFirst) {
951 flip_bytes( dst, width_in_bytes );
952 }
953 }
954 else {
955 /* handling SkipPixels is a bit tricky (no pun intended!) */
956 GLint i;
957 if (packing->LsbFirst) {
958 GLubyte srcMask = 1 << (packing->SkipPixels & 0x7);
959 GLubyte dstMask = 128;
960 const GLubyte *s = src;
961 GLubyte *d = dst;
962 *d = 0;
963 for (i = 0; i < width; i++) {
964 if (*s & srcMask) {
965 *d |= dstMask;
966 }
967 if (srcMask == 128) {
968 srcMask = 1;
969 s++;
970 }
971 else {
972 srcMask = srcMask << 1;
973 }
974 if (dstMask == 1) {
975 dstMask = 128;
976 d++;
977 *d = 0;
978 }
979 else {
980 dstMask = dstMask >> 1;
981 }
982 }
983 }
984 else {
985 GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7);
986 GLubyte dstMask = 128;
987 const GLubyte *s = src;
988 GLubyte *d = dst;
989 *d = 0;
990 for (i = 0; i < width; i++) {
991 if (*s & srcMask) {
992 *d |= dstMask;
993 }
994 if (srcMask == 1) {
995 srcMask = 128;
996 s++;
997 }
998 else {
999 srcMask = srcMask >> 1;
1000 }
1001 if (dstMask == 1) {
1002 dstMask = 128;
1003 d++;
1004 *d = 0;
1005 }
1006 else {
1007 dstMask = dstMask >> 1;
1008 }
1009 }
1010 }
1011 }
1012 src += width_in_bytes;
1013 }
1014 }
1015
1016
1017 /**
1018 * Apply various pixel transfer operations to an array of RGBA pixels
1019 * as indicated by the transferOps bitmask
1020 */
1021 void
1022 _mesa_apply_rgba_transfer_ops(GLcontext *ctx, GLbitfield transferOps,
1023 GLuint n, GLfloat rgba[][4])
1024 {
1025 /* scale & bias */
1026 if (transferOps & IMAGE_SCALE_BIAS_BIT) {
1027 _mesa_scale_and_bias_rgba(n, rgba,
1028 ctx->Pixel.RedScale, ctx->Pixel.GreenScale,
1029 ctx->Pixel.BlueScale, ctx->Pixel.AlphaScale,
1030 ctx->Pixel.RedBias, ctx->Pixel.GreenBias,
1031 ctx->Pixel.BlueBias, ctx->Pixel.AlphaBias);
1032 }
1033 /* color map lookup */
1034 if (transferOps & IMAGE_MAP_COLOR_BIT) {
1035 _mesa_map_rgba( ctx, n, rgba );
1036 }
1037 /* GL_COLOR_TABLE lookup */
1038 if (transferOps & IMAGE_COLOR_TABLE_BIT) {
1039 _mesa_lookup_rgba_float(&ctx->ColorTable[COLORTABLE_PRECONVOLUTION], n, rgba);
1040 }
1041 /* convolution */
1042 if (transferOps & IMAGE_CONVOLUTION_BIT) {
1043 /* this has to be done in the calling code */
1044 _mesa_problem(ctx, "IMAGE_CONVOLUTION_BIT set in _mesa_apply_transfer_ops");
1045 }
1046 /* GL_POST_CONVOLUTION_RED/GREEN/BLUE/ALPHA_SCALE/BIAS */
1047 if (transferOps & IMAGE_POST_CONVOLUTION_SCALE_BIAS) {
1048 _mesa_scale_and_bias_rgba(n, rgba,
1049 ctx->Pixel.PostConvolutionScale[RCOMP],
1050 ctx->Pixel.PostConvolutionScale[GCOMP],
1051 ctx->Pixel.PostConvolutionScale[BCOMP],
1052 ctx->Pixel.PostConvolutionScale[ACOMP],
1053 ctx->Pixel.PostConvolutionBias[RCOMP],
1054 ctx->Pixel.PostConvolutionBias[GCOMP],
1055 ctx->Pixel.PostConvolutionBias[BCOMP],
1056 ctx->Pixel.PostConvolutionBias[ACOMP]);
1057 }
1058 /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
1059 if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) {
1060 _mesa_lookup_rgba_float(&ctx->ColorTable[COLORTABLE_POSTCONVOLUTION], n, rgba);
1061 }
1062 /* color matrix transform */
1063 if (transferOps & IMAGE_COLOR_MATRIX_BIT) {
1064 _mesa_transform_rgba(ctx, n, rgba);
1065 }
1066 /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
1067 if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) {
1068 _mesa_lookup_rgba_float(&ctx->ColorTable[COLORTABLE_POSTCOLORMATRIX], n, rgba);
1069 }
1070 /* update histogram count */
1071 if (transferOps & IMAGE_HISTOGRAM_BIT) {
1072 _mesa_update_histogram(ctx, n, (CONST GLfloat (*)[4]) rgba);
1073 }
1074 /* update min/max values */
1075 if (transferOps & IMAGE_MIN_MAX_BIT) {
1076 _mesa_update_minmax(ctx, n, (CONST GLfloat (*)[4]) rgba);
1077 }
1078 /* clamping to [0,1] */
1079 if (transferOps & IMAGE_CLAMP_BIT) {
1080 GLuint i;
1081 for (i = 0; i < n; i++) {
1082 rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F);
1083 rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F);
1084 rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F);
1085 rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F);
1086 }
1087 }
1088 }
1089
1090
1091 /*
1092 * Apply color index shift and offset to an array of pixels.
1093 */
1094 static void
1095 shift_and_offset_ci( const GLcontext *ctx, GLuint n, GLuint indexes[] )
1096 {
1097 GLint shift = ctx->Pixel.IndexShift;
1098 GLint offset = ctx->Pixel.IndexOffset;
1099 GLuint i;
1100 if (shift > 0) {
1101 for (i=0;i<n;i++) {
1102 indexes[i] = (indexes[i] << shift) + offset;
1103 }
1104 }
1105 else if (shift < 0) {
1106 shift = -shift;
1107 for (i=0;i<n;i++) {
1108 indexes[i] = (indexes[i] >> shift) + offset;
1109 }
1110 }
1111 else {
1112 for (i=0;i<n;i++) {
1113 indexes[i] = indexes[i] + offset;
1114 }
1115 }
1116 }
1117
1118
1119
1120 /**
1121 * Apply color index shift, offset and table lookup to an array
1122 * of color indexes;
1123 */
1124 void
1125 _mesa_apply_ci_transfer_ops(const GLcontext *ctx, GLbitfield transferOps,
1126 GLuint n, GLuint indexes[])
1127 {
1128 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
1129 shift_and_offset_ci(ctx, n, indexes);
1130 }
1131 if (transferOps & IMAGE_MAP_COLOR_BIT) {
1132 const GLuint mask = ctx->PixelMaps.ItoI.Size - 1;
1133 GLuint i;
1134 for (i = 0; i < n; i++) {
1135 const GLuint j = indexes[i] & mask;
1136 indexes[i] = IROUND(ctx->PixelMaps.ItoI.Map[j]);
1137 }
1138 }
1139 }
1140
1141
1142 /**
1143 * Apply stencil index shift, offset and table lookup to an array
1144 * of stencil values.
1145 */
1146 void
1147 _mesa_apply_stencil_transfer_ops(const GLcontext *ctx, GLuint n,
1148 GLstencil stencil[])
1149 {
1150 if (ctx->Pixel.IndexShift != 0 || ctx->Pixel.IndexOffset != 0) {
1151 const GLint offset = ctx->Pixel.IndexOffset;
1152 GLint shift = ctx->Pixel.IndexShift;
1153 GLuint i;
1154 if (shift > 0) {
1155 for (i = 0; i < n; i++) {
1156 stencil[i] = (stencil[i] << shift) + offset;
1157 }
1158 }
1159 else if (shift < 0) {
1160 shift = -shift;
1161 for (i = 0; i < n; i++) {
1162 stencil[i] = (stencil[i] >> shift) + offset;
1163 }
1164 }
1165 else {
1166 for (i = 0; i < n; i++) {
1167 stencil[i] = stencil[i] + offset;
1168 }
1169 }
1170 }
1171 if (ctx->Pixel.MapStencilFlag) {
1172 GLuint mask = ctx->PixelMaps.StoS.Size - 1;
1173 GLuint i;
1174 for (i = 0; i < n; i++) {
1175 stencil[i] = ctx->PixelMaps.StoS.Map[ stencil[i] & mask ];
1176 }
1177 }
1178 }
1179
1180
1181 /**
1182 * Used to pack an array [][4] of RGBA float colors as specified
1183 * by the dstFormat, dstType and dstPacking. Used by glReadPixels,
1184 * glGetConvolutionFilter(), etc.
1185 * Incoming colors will be clamped to [0,1] if needed.
1186 * Note: the rgba values will be modified by this function when any pixel
1187 * transfer ops are enabled.
1188 */
1189 void
1190 _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4],
1191 GLenum dstFormat, GLenum dstType,
1192 GLvoid *dstAddr,
1193 const struct gl_pixelstore_attrib *dstPacking,
1194 GLbitfield transferOps)
1195 {
1196 GLfloat luminance[MAX_WIDTH];
1197 const GLint comps = _mesa_components_in_format(dstFormat);
1198 GLuint i;
1199
1200 if (dstType != GL_FLOAT || ctx->Color.ClampReadColor == GL_TRUE) {
1201 /* need to clamp to [0, 1] */
1202 transferOps |= IMAGE_CLAMP_BIT;
1203 }
1204
1205 if (transferOps) {
1206 _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
1207 if ((transferOps & IMAGE_MIN_MAX_BIT) && ctx->MinMax.Sink) {
1208 return;
1209 }
1210 }
1211
1212 if (dstFormat == GL_LUMINANCE || dstFormat == GL_LUMINANCE_ALPHA) {
1213 /* compute luminance values */
1214 if (dstType != GL_FLOAT || ctx->Color.ClampReadColor == GL_TRUE) {
1215 for (i = 0; i < n; i++) {
1216 GLfloat sum = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
1217 luminance[i] = CLAMP(sum, 0.0F, 1.0F);
1218 }
1219 }
1220 else {
1221 for (i = 0; i < n; i++) {
1222 luminance[i] = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
1223 }
1224 }
1225 }
1226
1227 /*
1228 * Pack/store the pixels. Ugh! Lots of cases!!!
1229 */
1230 switch (dstType) {
1231 case GL_UNSIGNED_BYTE:
1232 {
1233 GLubyte *dst = (GLubyte *) dstAddr;
1234 switch (dstFormat) {
1235 case GL_RED:
1236 for (i=0;i<n;i++)
1237 dst[i] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
1238 break;
1239 case GL_GREEN:
1240 for (i=0;i<n;i++)
1241 dst[i] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
1242 break;
1243 case GL_BLUE:
1244 for (i=0;i<n;i++)
1245 dst[i] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
1246 break;
1247 case GL_ALPHA:
1248 for (i=0;i<n;i++)
1249 dst[i] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
1250 break;
1251 case GL_LUMINANCE:
1252 for (i=0;i<n;i++)
1253 dst[i] = FLOAT_TO_UBYTE(luminance[i]);
1254 break;
1255 case GL_LUMINANCE_ALPHA:
1256 for (i=0;i<n;i++) {
1257 dst[i*2+0] = FLOAT_TO_UBYTE(luminance[i]);
1258 dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
1259 }
1260 break;
1261 case GL_RGB:
1262 for (i=0;i<n;i++) {
1263 dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
1264 dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
1265 dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
1266 }
1267 break;
1268 case GL_RGBA:
1269 for (i=0;i<n;i++) {
1270 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
1271 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
1272 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
1273 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
1274 }
1275 break;
1276 case GL_BGR:
1277 for (i=0;i<n;i++) {
1278 dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
1279 dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
1280 dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
1281 }
1282 break;
1283 case GL_BGRA:
1284 for (i=0;i<n;i++) {
1285 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
1286 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
1287 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
1288 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
1289 }
1290 break;
1291 case GL_ABGR_EXT:
1292 for (i=0;i<n;i++) {
1293 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
1294 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
1295 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
1296 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
1297 }
1298 break;
1299 default:
1300 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1301 }
1302 }
1303 break;
1304 case GL_BYTE:
1305 {
1306 GLbyte *dst = (GLbyte *) dstAddr;
1307 switch (dstFormat) {
1308 case GL_RED:
1309 for (i=0;i<n;i++)
1310 dst[i] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
1311 break;
1312 case GL_GREEN:
1313 for (i=0;i<n;i++)
1314 dst[i] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
1315 break;
1316 case GL_BLUE:
1317 for (i=0;i<n;i++)
1318 dst[i] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
1319 break;
1320 case GL_ALPHA:
1321 for (i=0;i<n;i++)
1322 dst[i] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
1323 break;
1324 case GL_LUMINANCE:
1325 for (i=0;i<n;i++)
1326 dst[i] = FLOAT_TO_BYTE(luminance[i]);
1327 break;
1328 case GL_LUMINANCE_ALPHA:
1329 for (i=0;i<n;i++) {
1330 dst[i*2+0] = FLOAT_TO_BYTE(luminance[i]);
1331 dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
1332 }
1333 break;
1334 case GL_RGB:
1335 for (i=0;i<n;i++) {
1336 dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
1337 dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
1338 dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
1339 }
1340 break;
1341 case GL_RGBA:
1342 for (i=0;i<n;i++) {
1343 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
1344 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
1345 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
1346 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
1347 }
1348 break;
1349 case GL_BGR:
1350 for (i=0;i<n;i++) {
1351 dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
1352 dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
1353 dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
1354 }
1355 break;
1356 case GL_BGRA:
1357 for (i=0;i<n;i++) {
1358 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
1359 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
1360 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
1361 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
1362 }
1363 break;
1364 case GL_ABGR_EXT:
1365 for (i=0;i<n;i++) {
1366 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
1367 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
1368 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
1369 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
1370 }
1371 break;
1372 default:
1373 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1374 }
1375 }
1376 break;
1377 case GL_UNSIGNED_SHORT:
1378 {
1379 GLushort *dst = (GLushort *) dstAddr;
1380 switch (dstFormat) {
1381 case GL_RED:
1382 for (i=0;i<n;i++)
1383 CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][RCOMP]);
1384 break;
1385 case GL_GREEN:
1386 for (i=0;i<n;i++)
1387 CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][GCOMP]);
1388 break;
1389 case GL_BLUE:
1390 for (i=0;i<n;i++)
1391 CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][BCOMP]);
1392 break;
1393 case GL_ALPHA:
1394 for (i=0;i<n;i++)
1395 CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][ACOMP]);
1396 break;
1397 case GL_LUMINANCE:
1398 for (i=0;i<n;i++)
1399 UNCLAMPED_FLOAT_TO_USHORT(dst[i], luminance[i]);
1400 break;
1401 case GL_LUMINANCE_ALPHA:
1402 for (i=0;i<n;i++) {
1403 UNCLAMPED_FLOAT_TO_USHORT(dst[i*2+0], luminance[i]);
1404 CLAMPED_FLOAT_TO_USHORT(dst[i*2+1], rgba[i][ACOMP]);
1405 }
1406 break;
1407 case GL_RGB:
1408 for (i=0;i<n;i++) {
1409 CLAMPED_FLOAT_TO_USHORT(dst[i*3+0], rgba[i][RCOMP]);
1410 CLAMPED_FLOAT_TO_USHORT(dst[i*3+1], rgba[i][GCOMP]);
1411 CLAMPED_FLOAT_TO_USHORT(dst[i*3+2], rgba[i][BCOMP]);
1412 }
1413 break;
1414 case GL_RGBA:
1415 for (i=0;i<n;i++) {
1416 CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][RCOMP]);
1417 CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][GCOMP]);
1418 CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][BCOMP]);
1419 CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][ACOMP]);
1420 }
1421 break;
1422 case GL_BGR:
1423 for (i=0;i<n;i++) {
1424 CLAMPED_FLOAT_TO_USHORT(dst[i*3+0], rgba[i][BCOMP]);
1425 CLAMPED_FLOAT_TO_USHORT(dst[i*3+1], rgba[i][GCOMP]);
1426 CLAMPED_FLOAT_TO_USHORT(dst[i*3+2], rgba[i][RCOMP]);
1427 }
1428 break;
1429 case GL_BGRA:
1430 for (i=0;i<n;i++) {
1431 CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][BCOMP]);
1432 CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][GCOMP]);
1433 CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][RCOMP]);
1434 CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][ACOMP]);
1435 }
1436 break;
1437 case GL_ABGR_EXT:
1438 for (i=0;i<n;i++) {
1439 CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][ACOMP]);
1440 CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][BCOMP]);
1441 CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][GCOMP]);
1442 CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][RCOMP]);
1443 }
1444 break;
1445 default:
1446 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1447 }
1448 }
1449 break;
1450 case GL_SHORT:
1451 {
1452 GLshort *dst = (GLshort *) dstAddr;
1453 switch (dstFormat) {
1454 case GL_RED:
1455 for (i=0;i<n;i++)
1456 dst[i] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1457 break;
1458 case GL_GREEN:
1459 for (i=0;i<n;i++)
1460 dst[i] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1461 break;
1462 case GL_BLUE:
1463 for (i=0;i<n;i++)
1464 dst[i] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1465 break;
1466 case GL_ALPHA:
1467 for (i=0;i<n;i++)
1468 dst[i] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1469 break;
1470 case GL_LUMINANCE:
1471 for (i=0;i<n;i++)
1472 dst[i] = FLOAT_TO_SHORT(luminance[i]);
1473 break;
1474 case GL_LUMINANCE_ALPHA:
1475 for (i=0;i<n;i++) {
1476 dst[i*2+0] = FLOAT_TO_SHORT(luminance[i]);
1477 dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1478 }
1479 break;
1480 case GL_RGB:
1481 for (i=0;i<n;i++) {
1482 dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1483 dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1484 dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1485 }
1486 break;
1487 case GL_RGBA:
1488 for (i=0;i<n;i++) {
1489 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1490 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1491 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1492 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1493 }
1494 break;
1495 case GL_BGR:
1496 for (i=0;i<n;i++) {
1497 dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1498 dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1499 dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1500 }
1501 break;
1502 case GL_BGRA:
1503 for (i=0;i<n;i++) {
1504 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1505 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1506 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1507 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1508 }
1509 break;
1510 case GL_ABGR_EXT:
1511 for (i=0;i<n;i++) {
1512 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1513 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1514 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1515 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1516 }
1517 break;
1518 default:
1519 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1520 }
1521 }
1522 break;
1523 case GL_UNSIGNED_INT:
1524 {
1525 GLuint *dst = (GLuint *) dstAddr;
1526 switch (dstFormat) {
1527 case GL_RED:
1528 for (i=0;i<n;i++)
1529 dst[i] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1530 break;
1531 case GL_GREEN:
1532 for (i=0;i<n;i++)
1533 dst[i] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1534 break;
1535 case GL_BLUE:
1536 for (i=0;i<n;i++)
1537 dst[i] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1538 break;
1539 case GL_ALPHA:
1540 for (i=0;i<n;i++)
1541 dst[i] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1542 break;
1543 case GL_LUMINANCE:
1544 for (i=0;i<n;i++)
1545 dst[i] = FLOAT_TO_UINT(luminance[i]);
1546 break;
1547 case GL_LUMINANCE_ALPHA:
1548 for (i=0;i<n;i++) {
1549 dst[i*2+0] = FLOAT_TO_UINT(luminance[i]);
1550 dst[i*2+1] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1551 }
1552 break;
1553 case GL_RGB:
1554 for (i=0;i<n;i++) {
1555 dst[i*3+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1556 dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1557 dst[i*3+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1558 }
1559 break;
1560 case GL_RGBA:
1561 for (i=0;i<n;i++) {
1562 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1563 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1564 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1565 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1566 }
1567 break;
1568 case GL_BGR:
1569 for (i=0;i<n;i++) {
1570 dst[i*3+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1571 dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1572 dst[i*3+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1573 }
1574 break;
1575 case GL_BGRA:
1576 for (i=0;i<n;i++) {
1577 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1578 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1579 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1580 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1581 }
1582 break;
1583 case GL_ABGR_EXT:
1584 for (i=0;i<n;i++) {
1585 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1586 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1587 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1588 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1589 }
1590 break;
1591 default:
1592 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1593 }
1594 }
1595 break;
1596 case GL_INT:
1597 {
1598 GLint *dst = (GLint *) dstAddr;
1599 switch (dstFormat) {
1600 case GL_RED:
1601 for (i=0;i<n;i++)
1602 dst[i] = FLOAT_TO_INT(rgba[i][RCOMP]);
1603 break;
1604 case GL_GREEN:
1605 for (i=0;i<n;i++)
1606 dst[i] = FLOAT_TO_INT(rgba[i][GCOMP]);
1607 break;
1608 case GL_BLUE:
1609 for (i=0;i<n;i++)
1610 dst[i] = FLOAT_TO_INT(rgba[i][BCOMP]);
1611 break;
1612 case GL_ALPHA:
1613 for (i=0;i<n;i++)
1614 dst[i] = FLOAT_TO_INT(rgba[i][ACOMP]);
1615 break;
1616 case GL_LUMINANCE:
1617 for (i=0;i<n;i++)
1618 dst[i] = FLOAT_TO_INT(luminance[i]);
1619 break;
1620 case GL_LUMINANCE_ALPHA:
1621 for (i=0;i<n;i++) {
1622 dst[i*2+0] = FLOAT_TO_INT(luminance[i]);
1623 dst[i*2+1] = FLOAT_TO_INT(rgba[i][ACOMP]);
1624 }
1625 break;
1626 case GL_RGB:
1627 for (i=0;i<n;i++) {
1628 dst[i*3+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
1629 dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1630 dst[i*3+2] = FLOAT_TO_INT(rgba[i][BCOMP]);
1631 }
1632 break;
1633 case GL_RGBA:
1634 for (i=0;i<n;i++) {
1635 dst[i*4+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
1636 dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1637 dst[i*4+2] = FLOAT_TO_INT(rgba[i][BCOMP]);
1638 dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);
1639 }
1640 break;
1641 case GL_BGR:
1642 for (i=0;i<n;i++) {
1643 dst[i*3+0] = FLOAT_TO_INT(rgba[i][BCOMP]);
1644 dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1645 dst[i*3+2] = FLOAT_TO_INT(rgba[i][RCOMP]);
1646 }
1647 break;
1648 case GL_BGRA:
1649 for (i=0;i<n;i++) {
1650 dst[i*4+0] = FLOAT_TO_INT(rgba[i][BCOMP]);
1651 dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1652 dst[i*4+2] = FLOAT_TO_INT(rgba[i][RCOMP]);
1653 dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);
1654 }
1655 break;
1656 case GL_ABGR_EXT:
1657 for (i=0;i<n;i++) {
1658 dst[i*4+0] = FLOAT_TO_INT(rgba[i][ACOMP]);
1659 dst[i*4+1] = FLOAT_TO_INT(rgba[i][BCOMP]);
1660 dst[i*4+2] = FLOAT_TO_INT(rgba[i][GCOMP]);
1661 dst[i*4+3] = FLOAT_TO_INT(rgba[i][RCOMP]);
1662 }
1663 break;
1664 default:
1665 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1666 }
1667 }
1668 break;
1669 case GL_FLOAT:
1670 {
1671 GLfloat *dst = (GLfloat *) dstAddr;
1672 switch (dstFormat) {
1673 case GL_RED:
1674 for (i=0;i<n;i++)
1675 dst[i] = rgba[i][RCOMP];
1676 break;
1677 case GL_GREEN:
1678 for (i=0;i<n;i++)
1679 dst[i] = rgba[i][GCOMP];
1680 break;
1681 case GL_BLUE:
1682 for (i=0;i<n;i++)
1683 dst[i] = rgba[i][BCOMP];
1684 break;
1685 case GL_ALPHA:
1686 for (i=0;i<n;i++)
1687 dst[i] = rgba[i][ACOMP];
1688 break;
1689 case GL_LUMINANCE:
1690 for (i=0;i<n;i++)
1691 dst[i] = luminance[i];
1692 break;
1693 case GL_LUMINANCE_ALPHA:
1694 for (i=0;i<n;i++) {
1695 dst[i*2+0] = luminance[i];
1696 dst[i*2+1] = rgba[i][ACOMP];
1697 }
1698 break;
1699 case GL_RGB:
1700 for (i=0;i<n;i++) {
1701 dst[i*3+0] = rgba[i][RCOMP];
1702 dst[i*3+1] = rgba[i][GCOMP];
1703 dst[i*3+2] = rgba[i][BCOMP];
1704 }
1705 break;
1706 case GL_RGBA:
1707 for (i=0;i<n;i++) {
1708 dst[i*4+0] = rgba[i][RCOMP];
1709 dst[i*4+1] = rgba[i][GCOMP];
1710 dst[i*4+2] = rgba[i][BCOMP];
1711 dst[i*4+3] = rgba[i][ACOMP];
1712 }
1713 break;
1714 case GL_BGR:
1715 for (i=0;i<n;i++) {
1716 dst[i*3+0] = rgba[i][BCOMP];
1717 dst[i*3+1] = rgba[i][GCOMP];
1718 dst[i*3+2] = rgba[i][RCOMP];
1719 }
1720 break;
1721 case GL_BGRA:
1722 for (i=0;i<n;i++) {
1723 dst[i*4+0] = rgba[i][BCOMP];
1724 dst[i*4+1] = rgba[i][GCOMP];
1725 dst[i*4+2] = rgba[i][RCOMP];
1726 dst[i*4+3] = rgba[i][ACOMP];
1727 }
1728 break;
1729 case GL_ABGR_EXT:
1730 for (i=0;i<n;i++) {
1731 dst[i*4+0] = rgba[i][ACOMP];
1732 dst[i*4+1] = rgba[i][BCOMP];
1733 dst[i*4+2] = rgba[i][GCOMP];
1734 dst[i*4+3] = rgba[i][RCOMP];
1735 }
1736 break;
1737 default:
1738 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1739 }
1740 }
1741 break;
1742 case GL_HALF_FLOAT_ARB:
1743 {
1744 GLhalfARB *dst = (GLhalfARB *) dstAddr;
1745 switch (dstFormat) {
1746 case GL_RED:
1747 for (i=0;i<n;i++)
1748 dst[i] = _mesa_float_to_half(rgba[i][RCOMP]);
1749 break;
1750 case GL_GREEN:
1751 for (i=0;i<n;i++)
1752 dst[i] = _mesa_float_to_half(rgba[i][GCOMP]);
1753 break;
1754 case GL_BLUE:
1755 for (i=0;i<n;i++)
1756 dst[i] = _mesa_float_to_half(rgba[i][BCOMP]);
1757 break;
1758 case GL_ALPHA:
1759 for (i=0;i<n;i++)
1760 dst[i] = _mesa_float_to_half(rgba[i][ACOMP]);
1761 break;
1762 case GL_LUMINANCE:
1763 for (i=0;i<n;i++)
1764 dst[i] = _mesa_float_to_half(luminance[i]);
1765 break;
1766 case GL_LUMINANCE_ALPHA:
1767 for (i=0;i<n;i++) {
1768 dst[i*2+0] = _mesa_float_to_half(luminance[i]);
1769 dst[i*2+1] = _mesa_float_to_half(rgba[i][ACOMP]);
1770 }
1771 break;
1772 case GL_RGB:
1773 for (i=0;i<n;i++) {
1774 dst[i*3+0] = _mesa_float_to_half(rgba[i][RCOMP]);
1775 dst[i*3+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1776 dst[i*3+2] = _mesa_float_to_half(rgba[i][BCOMP]);
1777 }
1778 break;
1779 case GL_RGBA:
1780 for (i=0;i<n;i++) {
1781 dst[i*4+0] = _mesa_float_to_half(rgba[i][RCOMP]);
1782 dst[i*4+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1783 dst[i*4+2] = _mesa_float_to_half(rgba[i][BCOMP]);
1784 dst[i*4+3] = _mesa_float_to_half(rgba[i][ACOMP]);
1785 }
1786 break;
1787 case GL_BGR:
1788 for (i=0;i<n;i++) {
1789 dst[i*3+0] = _mesa_float_to_half(rgba[i][BCOMP]);
1790 dst[i*3+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1791 dst[i*3+2] = _mesa_float_to_half(rgba[i][RCOMP]);
1792 }
1793 break;
1794 case GL_BGRA:
1795 for (i=0;i<n;i++) {
1796 dst[i*4+0] = _mesa_float_to_half(rgba[i][BCOMP]);
1797 dst[i*4+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1798 dst[i*4+2] = _mesa_float_to_half(rgba[i][RCOMP]);
1799 dst[i*4+3] = _mesa_float_to_half(rgba[i][ACOMP]);
1800 }
1801 break;
1802 case GL_ABGR_EXT:
1803 for (i=0;i<n;i++) {
1804 dst[i*4+0] = _mesa_float_to_half(rgba[i][ACOMP]);
1805 dst[i*4+1] = _mesa_float_to_half(rgba[i][BCOMP]);
1806 dst[i*4+2] = _mesa_float_to_half(rgba[i][GCOMP]);
1807 dst[i*4+3] = _mesa_float_to_half(rgba[i][RCOMP]);
1808 }
1809 break;
1810 default:
1811 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1812 }
1813 }
1814 break;
1815 case GL_UNSIGNED_BYTE_3_3_2:
1816 if (dstFormat == GL_RGB) {
1817 GLubyte *dst = (GLubyte *) dstAddr;
1818 for (i=0;i<n;i++) {
1819 dst[i] = (((GLint) (rgba[i][RCOMP] * 7.0F)) << 5)
1820 | (((GLint) (rgba[i][GCOMP] * 7.0F)) << 2)
1821 | (((GLint) (rgba[i][BCOMP] * 3.0F)) );
1822 }
1823 }
1824 break;
1825 case GL_UNSIGNED_BYTE_2_3_3_REV:
1826 if (dstFormat == GL_RGB) {
1827 GLubyte *dst = (GLubyte *) dstAddr;
1828 for (i=0;i<n;i++) {
1829 dst[i] = (((GLint) (rgba[i][RCOMP] * 7.0F)) )
1830 | (((GLint) (rgba[i][GCOMP] * 7.0F)) << 3)
1831 | (((GLint) (rgba[i][BCOMP] * 3.0F)) << 6);
1832 }
1833 }
1834 break;
1835 case GL_UNSIGNED_SHORT_5_6_5:
1836 if (dstFormat == GL_RGB) {
1837 GLushort *dst = (GLushort *) dstAddr;
1838 for (i=0;i<n;i++) {
1839 dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) << 11)
1840 | (((GLint) (rgba[i][GCOMP] * 63.0F)) << 5)
1841 | (((GLint) (rgba[i][BCOMP] * 31.0F)) );
1842 }
1843 }
1844 break;
1845 case GL_UNSIGNED_SHORT_5_6_5_REV:
1846 if (dstFormat == GL_RGB) {
1847 GLushort *dst = (GLushort *) dstAddr;
1848 for (i=0;i<n;i++) {
1849 dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) )
1850 | (((GLint) (rgba[i][GCOMP] * 63.0F)) << 5)
1851 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 11);
1852 }
1853 }
1854 break;
1855 case GL_UNSIGNED_SHORT_4_4_4_4:
1856 if (dstFormat == GL_RGBA) {
1857 GLushort *dst = (GLushort *) dstAddr;
1858 for (i=0;i<n;i++) {
1859 dst[i] = (((GLint) (rgba[i][RCOMP] * 15.0F)) << 12)
1860 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 8)
1861 | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 4)
1862 | (((GLint) (rgba[i][ACOMP] * 15.0F)) );
1863 }
1864 }
1865 else if (dstFormat == GL_BGRA) {
1866 GLushort *dst = (GLushort *) dstAddr;
1867 for (i=0;i<n;i++) {
1868 dst[i] = (((GLint) (rgba[i][BCOMP] * 15.0F)) << 12)
1869 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 8)
1870 | (((GLint) (rgba[i][RCOMP] * 15.0F)) << 4)
1871 | (((GLint) (rgba[i][ACOMP] * 15.0F)) );
1872 }
1873 }
1874 else if (dstFormat == GL_ABGR_EXT) {
1875 GLushort *dst = (GLushort *) dstAddr;
1876 for (i=0;i<n;i++) {
1877 dst[i] = (((GLint) (rgba[i][ACOMP] * 15.0F)) << 12)
1878 | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 8)
1879 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 4)
1880 | (((GLint) (rgba[i][RCOMP] * 15.0F)) );
1881 }
1882 }
1883 break;
1884 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1885 if (dstFormat == GL_RGBA) {
1886 GLushort *dst = (GLushort *) dstAddr;
1887 for (i=0;i<n;i++) {
1888 dst[i] = (((GLint) (rgba[i][RCOMP] * 15.0F)) )
1889 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 4)
1890 | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 8)
1891 | (((GLint) (rgba[i][ACOMP] * 15.0F)) << 12);
1892 }
1893 }
1894 else if (dstFormat == GL_BGRA) {
1895 GLushort *dst = (GLushort *) dstAddr;
1896 for (i=0;i<n;i++) {
1897 dst[i] = (((GLint) (rgba[i][BCOMP] * 15.0F)) )
1898 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 4)
1899 | (((GLint) (rgba[i][RCOMP] * 15.0F)) << 8)
1900 | (((GLint) (rgba[i][ACOMP] * 15.0F)) << 12);
1901 }
1902 }
1903 else if (dstFormat == GL_ABGR_EXT) {
1904 GLushort *dst = (GLushort *) dstAddr;
1905 for (i=0;i<n;i++) {
1906 dst[i] = (((GLint) (rgba[i][ACOMP] * 15.0F)) )
1907 | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 4)
1908 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 8)
1909 | (((GLint) (rgba[i][RCOMP] * 15.0F)) << 12);
1910 }
1911 }
1912 break;
1913 case GL_UNSIGNED_SHORT_5_5_5_1:
1914 if (dstFormat == GL_RGBA) {
1915 GLushort *dst = (GLushort *) dstAddr;
1916 for (i=0;i<n;i++) {
1917 dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) << 11)
1918 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 6)
1919 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 1)
1920 | (((GLint) (rgba[i][ACOMP] * 1.0F)) );
1921 }
1922 }
1923 else if (dstFormat == GL_BGRA) {
1924 GLushort *dst = (GLushort *) dstAddr;
1925 for (i=0;i<n;i++) {
1926 dst[i] = (((GLint) (rgba[i][BCOMP] * 31.0F)) << 11)
1927 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 6)
1928 | (((GLint) (rgba[i][RCOMP] * 31.0F)) << 1)
1929 | (((GLint) (rgba[i][ACOMP] * 1.0F)) );
1930 }
1931 }
1932 else if (dstFormat == GL_ABGR_EXT) {
1933 GLushort *dst = (GLushort *) dstAddr;
1934 for (i=0;i<n;i++) {
1935 dst[i] = (((GLint) (rgba[i][ACOMP] * 31.0F)) << 11)
1936 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 6)
1937 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 1)
1938 | (((GLint) (rgba[i][RCOMP] * 1.0F)) );
1939 }
1940 }
1941 break;
1942 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1943 if (dstFormat == GL_RGBA) {
1944 GLushort *dst = (GLushort *) dstAddr;
1945 for (i=0;i<n;i++) {
1946 dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) )
1947 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 5)
1948 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 10)
1949 | (((GLint) (rgba[i][ACOMP] * 1.0F)) << 15);
1950 }
1951 }
1952 else if (dstFormat == GL_BGRA) {
1953 GLushort *dst = (GLushort *) dstAddr;
1954 for (i=0;i<n;i++) {
1955 dst[i] = (((GLint) (rgba[i][BCOMP] * 31.0F)) )
1956 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 5)
1957 | (((GLint) (rgba[i][RCOMP] * 31.0F)) << 10)
1958 | (((GLint) (rgba[i][ACOMP] * 1.0F)) << 15);
1959 }
1960 }
1961 else if (dstFormat == GL_ABGR_EXT) {
1962 GLushort *dst = (GLushort *) dstAddr;
1963 for (i=0;i<n;i++) {
1964 dst[i] = (((GLint) (rgba[i][ACOMP] * 31.0F)) )
1965 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 5)
1966 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 10)
1967 | (((GLint) (rgba[i][RCOMP] * 1.0F)) << 15);
1968 }
1969 }
1970 break;
1971 case GL_UNSIGNED_INT_8_8_8_8:
1972 if (dstFormat == GL_RGBA) {
1973 GLuint *dst = (GLuint *) dstAddr;
1974 for (i=0;i<n;i++) {
1975 dst[i] = (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 24)
1976 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16)
1977 | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 8)
1978 | (((GLuint) (rgba[i][ACOMP] * 255.0F)) );
1979 }
1980 }
1981 else if (dstFormat == GL_BGRA) {
1982 GLuint *dst = (GLuint *) dstAddr;
1983 for (i=0;i<n;i++) {
1984 dst[i] = (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 24)
1985 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16)
1986 | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 8)
1987 | (((GLuint) (rgba[i][ACOMP] * 255.0F)) );
1988 }
1989 }
1990 else if (dstFormat == GL_ABGR_EXT) {
1991 GLuint *dst = (GLuint *) dstAddr;
1992 for (i=0;i<n;i++) {
1993 dst[i] = (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24)
1994 | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 16)
1995 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 8)
1996 | (((GLuint) (rgba[i][RCOMP] * 255.0F)) );
1997 }
1998 }
1999 break;
2000 case GL_UNSIGNED_INT_8_8_8_8_REV:
2001 if (dstFormat == GL_RGBA) {
2002 GLuint *dst = (GLuint *) dstAddr;
2003 for (i=0;i<n;i++) {
2004 dst[i] = (((GLuint) (rgba[i][RCOMP] * 255.0F)) )
2005 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 8)
2006 | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 16)
2007 | (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24);
2008 }
2009 }
2010 else if (dstFormat == GL_BGRA) {
2011 GLuint *dst = (GLuint *) dstAddr;
2012 for (i=0;i<n;i++) {
2013 dst[i] = (((GLuint) (rgba[i][BCOMP] * 255.0F)) )
2014 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 8)
2015 | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 16)
2016 | (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24);
2017 }
2018 }
2019 else if (dstFormat == GL_ABGR_EXT) {
2020 GLuint *dst = (GLuint *) dstAddr;
2021 for (i=0;i<n;i++) {
2022 dst[i] = (((GLuint) (rgba[i][ACOMP] * 255.0F)) )
2023 | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 8)
2024 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16)
2025 | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 24);
2026 }
2027 }
2028 break;
2029 case GL_UNSIGNED_INT_10_10_10_2:
2030 if (dstFormat == GL_RGBA) {
2031 GLuint *dst = (GLuint *) dstAddr;
2032 for (i=0;i<n;i++) {
2033 dst[i] = (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 22)
2034 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 12)
2035 | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 2)
2036 | (((GLuint) (rgba[i][ACOMP] * 3.0F)) );
2037 }
2038 }
2039 else if (dstFormat == GL_BGRA) {
2040 GLuint *dst = (GLuint *) dstAddr;
2041 for (i=0;i<n;i++) {
2042 dst[i] = (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 22)
2043 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 12)
2044 | (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 2)
2045 | (((GLuint) (rgba[i][ACOMP] * 3.0F)) );
2046 }
2047 }
2048 else if (dstFormat == GL_ABGR_EXT) {
2049 GLuint *dst = (GLuint *) dstAddr;
2050 for (i=0;i<n;i++) {
2051 dst[i] = (((GLuint) (rgba[i][ACOMP] * 1023.0F)) << 22)
2052 | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 12)
2053 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 2)
2054 | (((GLuint) (rgba[i][RCOMP] * 3.0F)) );
2055 }
2056 }
2057 break;
2058 case GL_UNSIGNED_INT_2_10_10_10_REV:
2059 if (dstFormat == GL_RGBA) {
2060 GLuint *dst = (GLuint *) dstAddr;
2061 for (i=0;i<n;i++) {
2062 dst[i] = (((GLuint) (rgba[i][RCOMP] * 1023.0F)) )
2063 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 10)
2064 | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 20)
2065 | (((GLuint) (rgba[i][ACOMP] * 3.0F)) << 30);
2066 }
2067 }
2068 else if (dstFormat == GL_BGRA) {
2069 GLuint *dst = (GLuint *) dstAddr;
2070 for (i=0;i<n;i++) {
2071 dst[i] = (((GLuint) (rgba[i][BCOMP] * 1023.0F)) )
2072 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 10)
2073 | (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 20)
2074 | (((GLuint) (rgba[i][ACOMP] * 3.0F)) << 30);
2075 }
2076 }
2077 else if (dstFormat == GL_ABGR_EXT) {
2078 GLuint *dst = (GLuint *) dstAddr;
2079 for (i=0;i<n;i++) {
2080 dst[i] = (((GLuint) (rgba[i][ACOMP] * 1023.0F)) )
2081 | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 10)
2082 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 20)
2083 | (((GLuint) (rgba[i][RCOMP] * 3.0F)) << 30);
2084 }
2085 }
2086 break;
2087 default:
2088 _mesa_problem(ctx, "bad type in _mesa_pack_rgba_span_float");
2089 return;
2090 }
2091
2092 if (dstPacking->SwapBytes) {
2093 GLint swapSize = _mesa_sizeof_packed_type(dstType);
2094 if (swapSize == 2) {
2095 if (dstPacking->SwapBytes) {
2096 _mesa_swap2((GLushort *) dstAddr, n * comps);
2097 }
2098 }
2099 else if (swapSize == 4) {
2100 if (dstPacking->SwapBytes) {
2101 _mesa_swap4((GLuint *) dstAddr, n * comps);
2102 }
2103 }
2104 }
2105 }
2106
2107
2108 #define SWAP2BYTE(VALUE) \
2109 { \
2110 GLubyte *bytes = (GLubyte *) &(VALUE); \
2111 GLubyte tmp = bytes[0]; \
2112 bytes[0] = bytes[1]; \
2113 bytes[1] = tmp; \
2114 }
2115
2116 #define SWAP4BYTE(VALUE) \
2117 { \
2118 GLubyte *bytes = (GLubyte *) &(VALUE); \
2119 GLubyte tmp = bytes[0]; \
2120 bytes[0] = bytes[3]; \
2121 bytes[3] = tmp; \
2122 tmp = bytes[1]; \
2123 bytes[1] = bytes[2]; \
2124 bytes[2] = tmp; \
2125 }
2126
2127
2128 static void
2129 extract_uint_indexes(GLuint n, GLuint indexes[],
2130 GLenum srcFormat, GLenum srcType, const GLvoid *src,
2131 const struct gl_pixelstore_attrib *unpack )
2132 {
2133 ASSERT(srcFormat == GL_COLOR_INDEX || srcFormat == GL_STENCIL_INDEX);
2134
2135 ASSERT(srcType == GL_BITMAP ||
2136 srcType == GL_UNSIGNED_BYTE ||
2137 srcType == GL_BYTE ||
2138 srcType == GL_UNSIGNED_SHORT ||
2139 srcType == GL_SHORT ||
2140 srcType == GL_UNSIGNED_INT ||
2141 srcType == GL_INT ||
2142 srcType == GL_UNSIGNED_INT_24_8_EXT ||
2143 srcType == GL_HALF_FLOAT_ARB ||
2144 srcType == GL_FLOAT);
2145
2146 switch (srcType) {
2147 case GL_BITMAP:
2148 {
2149 GLubyte *ubsrc = (GLubyte *) src;
2150 if (unpack->LsbFirst) {
2151 GLubyte mask = 1 << (unpack->SkipPixels & 0x7);
2152 GLuint i;
2153 for (i = 0; i < n; i++) {
2154 indexes[i] = (*ubsrc & mask) ? 1 : 0;
2155 if (mask == 128) {
2156 mask = 1;
2157 ubsrc++;
2158 }
2159 else {
2160 mask = mask << 1;
2161 }
2162 }
2163 }
2164 else {
2165 GLubyte mask = 128 >> (unpack->SkipPixels & 0x7);
2166 GLuint i;
2167 for (i = 0; i < n; i++) {
2168 indexes[i] = (*ubsrc & mask) ? 1 : 0;
2169 if (mask == 1) {
2170 mask = 128;
2171 ubsrc++;
2172 }
2173 else {
2174 mask = mask >> 1;
2175 }
2176 }
2177 }
2178 }
2179 break;
2180 case GL_UNSIGNED_BYTE:
2181 {
2182 GLuint i;
2183 const GLubyte *s = (const GLubyte *) src;
2184 for (i = 0; i < n; i++)
2185 indexes[i] = s[i];
2186 }
2187 break;
2188 case GL_BYTE:
2189 {
2190 GLuint i;
2191 const GLbyte *s = (const GLbyte *) src;
2192 for (i = 0; i < n; i++)
2193 indexes[i] = s[i];
2194 }
2195 break;
2196 case GL_UNSIGNED_SHORT:
2197 {
2198 GLuint i;
2199 const GLushort *s = (const GLushort *) src;
2200 if (unpack->SwapBytes) {
2201 for (i = 0; i < n; i++) {
2202 GLushort value = s[i];
2203 SWAP2BYTE(value);
2204 indexes[i] = value;
2205 }
2206 }
2207 else {
2208 for (i = 0; i < n; i++)
2209 indexes[i] = s[i];
2210 }
2211 }
2212 break;
2213 case GL_SHORT:
2214 {
2215 GLuint i;
2216 const GLshort *s = (const GLshort *) src;
2217 if (unpack->SwapBytes) {
2218 for (i = 0; i < n; i++) {
2219 GLshort value = s[i];
2220 SWAP2BYTE(value);
2221 indexes[i] = value;
2222 }
2223 }
2224 else {
2225 for (i = 0; i < n; i++)
2226 indexes[i] = s[i];
2227 }
2228 }
2229 break;
2230 case GL_UNSIGNED_INT:
2231 {
2232 GLuint i;
2233 const GLuint *s = (const GLuint *) src;
2234 if (unpack->SwapBytes) {
2235 for (i = 0; i < n; i++) {
2236 GLuint value = s[i];
2237 SWAP4BYTE(value);
2238 indexes[i] = value;
2239 }
2240 }
2241 else {
2242 for (i = 0; i < n; i++)
2243 indexes[i] = s[i];
2244 }
2245 }
2246 break;
2247 case GL_INT:
2248 {
2249 GLuint i;
2250 const GLint *s = (const GLint *) src;
2251 if (unpack->SwapBytes) {
2252 for (i = 0; i < n; i++) {
2253 GLint value = s[i];
2254 SWAP4BYTE(value);
2255 indexes[i] = value;
2256 }
2257 }
2258 else {
2259 for (i = 0; i < n; i++)
2260 indexes[i] = s[i];
2261 }
2262 }
2263 break;
2264 case GL_FLOAT:
2265 {
2266 GLuint i;
2267 const GLfloat *s = (const GLfloat *) src;
2268 if (unpack->SwapBytes) {
2269 for (i = 0; i < n; i++) {
2270 GLfloat value = s[i];
2271 SWAP4BYTE(value);
2272 indexes[i] = (GLuint) value;
2273 }
2274 }
2275 else {
2276 for (i = 0; i < n; i++)
2277 indexes[i] = (GLuint) s[i];
2278 }
2279 }
2280 break;
2281 case GL_HALF_FLOAT_ARB:
2282 {
2283 GLuint i;
2284 const GLhalfARB *s = (const GLhalfARB *) src;
2285 if (unpack->SwapBytes) {
2286 for (i = 0; i < n; i++) {
2287 GLhalfARB value = s[i];
2288 SWAP2BYTE(value);
2289 indexes[i] = (GLuint) _mesa_half_to_float(value);
2290 }
2291 }
2292 else {
2293 for (i = 0; i < n; i++)
2294 indexes[i] = (GLuint) _mesa_half_to_float(s[i]);
2295 }
2296 }
2297 break;
2298 case GL_UNSIGNED_INT_24_8_EXT:
2299 {
2300 GLuint i;
2301 const GLuint *s = (const GLuint *) src;
2302 if (unpack->SwapBytes) {
2303 for (i = 0; i < n; i++) {
2304 GLuint value = s[i];
2305 SWAP4BYTE(value);
2306 indexes[i] = value & 0xff; /* lower 8 bits */
2307 }
2308 }
2309 else {
2310 for (i = 0; i < n; i++)
2311 indexes[i] = s[i] & 0xfff; /* lower 8 bits */
2312 }
2313 }
2314 break;
2315
2316 default:
2317 _mesa_problem(NULL, "bad srcType in extract_uint_indexes");
2318 return;
2319 }
2320 }
2321
2322
2323 /*
2324 * This function extracts floating point RGBA values from arbitrary
2325 * image data. srcFormat and srcType are the format and type parameters
2326 * passed to glDrawPixels, glTexImage[123]D, glTexSubImage[123]D, etc.
2327 *
2328 * Refering to section 3.6.4 of the OpenGL 1.2 spec, this function
2329 * implements the "Conversion to floating point", "Conversion to RGB",
2330 * and "Final Expansion to RGBA" operations.
2331 *
2332 * Args: n - number of pixels
2333 * rgba - output colors
2334 * srcFormat - format of incoming data
2335 * srcType - data type of incoming data
2336 * src - source data pointer
2337 * swapBytes - perform byteswapping of incoming data?
2338 */
2339 static void
2340 extract_float_rgba(GLuint n, GLfloat rgba[][4],
2341 GLenum srcFormat, GLenum srcType, const GLvoid *src,
2342 GLboolean swapBytes)
2343 {
2344 GLint redIndex, greenIndex, blueIndex, alphaIndex;
2345 GLint stride;
2346 GLint rComp, bComp, gComp, aComp;
2347
2348 ASSERT(srcFormat == GL_RED ||
2349 srcFormat == GL_GREEN ||
2350 srcFormat == GL_BLUE ||
2351 srcFormat == GL_ALPHA ||
2352 srcFormat == GL_LUMINANCE ||
2353 srcFormat == GL_LUMINANCE_ALPHA ||
2354 srcFormat == GL_INTENSITY ||
2355 srcFormat == GL_RGB ||
2356 srcFormat == GL_BGR ||
2357 srcFormat == GL_RGBA ||
2358 srcFormat == GL_BGRA ||
2359 srcFormat == GL_ABGR_EXT);
2360
2361 ASSERT(srcType == GL_UNSIGNED_BYTE ||
2362 srcType == GL_BYTE ||
2363 srcType == GL_UNSIGNED_SHORT ||
2364 srcType == GL_SHORT ||
2365 srcType == GL_UNSIGNED_INT ||
2366 srcType == GL_INT ||
2367 srcType == GL_HALF_FLOAT_ARB ||
2368 srcType == GL_FLOAT ||
2369 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
2370 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
2371 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
2372 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
2373 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
2374 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
2375 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
2376 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
2377 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
2378 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
2379 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
2380 srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
2381
2382 rComp = gComp = bComp = aComp = -1;
2383
2384 switch (srcFormat) {
2385 case GL_RED:
2386 redIndex = 0;
2387 greenIndex = blueIndex = alphaIndex = -1;
2388 stride = 1;
2389 break;
2390 case GL_GREEN:
2391 greenIndex = 0;
2392 redIndex = blueIndex = alphaIndex = -1;
2393 stride = 1;
2394 break;
2395 case GL_BLUE:
2396 blueIndex = 0;
2397 redIndex = greenIndex = alphaIndex = -1;
2398 stride = 1;
2399 break;
2400 case GL_ALPHA:
2401 redIndex = greenIndex = blueIndex = -1;
2402 alphaIndex = 0;
2403 stride = 1;
2404 break;
2405 case GL_LUMINANCE:
2406 redIndex = greenIndex = blueIndex = 0;
2407 alphaIndex = -1;
2408 stride = 1;
2409 break;
2410 case GL_LUMINANCE_ALPHA:
2411 redIndex = greenIndex = blueIndex = 0;
2412 alphaIndex = 1;
2413 stride = 2;
2414 break;
2415 case GL_INTENSITY:
2416 redIndex = greenIndex = blueIndex = alphaIndex = 0;
2417 stride = 1;
2418 break;
2419 case GL_RGB:
2420 redIndex = 0;
2421 greenIndex = 1;
2422 blueIndex = 2;
2423 alphaIndex = -1;
2424 rComp = 0;
2425 gComp = 1;
2426 bComp = 2;
2427 aComp = 3;
2428 stride = 3;
2429 break;
2430 case GL_BGR:
2431 redIndex = 2;
2432 greenIndex = 1;
2433 blueIndex = 0;
2434 alphaIndex = -1;
2435 rComp = 2;
2436 gComp = 1;
2437 bComp = 0;
2438 aComp = 3;
2439 stride = 3;
2440 break;
2441 case GL_RGBA:
2442 redIndex = 0;
2443 greenIndex = 1;
2444 blueIndex = 2;
2445 alphaIndex = 3;
2446 rComp = 0;
2447 gComp = 1;
2448 bComp = 2;
2449 aComp = 3;
2450 stride = 4;
2451 break;
2452 case GL_BGRA:
2453 redIndex = 2;
2454 greenIndex = 1;
2455 blueIndex = 0;
2456 alphaIndex = 3;
2457 rComp = 2;
2458 gComp = 1;
2459 bComp = 0;
2460 aComp = 3;
2461 stride = 4;
2462 break;
2463 case GL_ABGR_EXT:
2464 redIndex = 3;
2465 greenIndex = 2;
2466 blueIndex = 1;
2467 alphaIndex = 0;
2468 rComp = 3;
2469 gComp = 2;
2470 bComp = 1;
2471 aComp = 0;
2472 stride = 4;
2473 break;
2474 default:
2475 _mesa_problem(NULL, "bad srcFormat in extract float data");
2476 return;
2477 }
2478
2479
2480 #define PROCESS(INDEX, CHANNEL, DEFAULT, TYPE, CONVERSION) \
2481 if ((INDEX) < 0) { \
2482 GLuint i; \
2483 for (i = 0; i < n; i++) { \
2484 rgba[i][CHANNEL] = DEFAULT; \
2485 } \
2486 } \
2487 else if (swapBytes) { \
2488 const TYPE *s = (const TYPE *) src; \
2489 GLuint i; \
2490 for (i = 0; i < n; i++) { \
2491 TYPE value = s[INDEX]; \
2492 if (sizeof(TYPE) == 2) { \
2493 SWAP2BYTE(value); \
2494 } \
2495 else if (sizeof(TYPE) == 4) { \
2496 SWAP4BYTE(value); \
2497 } \
2498 rgba[i][CHANNEL] = (GLfloat) CONVERSION(value); \
2499 s += stride; \
2500 } \
2501 } \
2502 else { \
2503 const TYPE *s = (const TYPE *) src; \
2504 GLuint i; \
2505 for (i = 0; i < n; i++) { \
2506 rgba[i][CHANNEL] = (GLfloat) CONVERSION(s[INDEX]); \
2507 s += stride; \
2508 } \
2509 }
2510
2511 switch (srcType) {
2512 case GL_UNSIGNED_BYTE:
2513 PROCESS(redIndex, RCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT);
2514 PROCESS(greenIndex, GCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT);
2515 PROCESS(blueIndex, BCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT);
2516 PROCESS(alphaIndex, ACOMP, 1.0F, GLubyte, UBYTE_TO_FLOAT);
2517 break;
2518 case GL_BYTE:
2519 PROCESS(redIndex, RCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT);
2520 PROCESS(greenIndex, GCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT);
2521 PROCESS(blueIndex, BCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT);
2522 PROCESS(alphaIndex, ACOMP, 1.0F, GLbyte, BYTE_TO_FLOAT);
2523 break;
2524 case GL_UNSIGNED_SHORT:
2525 PROCESS(redIndex, RCOMP, 0.0F, GLushort, USHORT_TO_FLOAT);
2526 PROCESS(greenIndex, GCOMP, 0.0F, GLushort, USHORT_TO_FLOAT);
2527 PROCESS(blueIndex, BCOMP, 0.0F, GLushort, USHORT_TO_FLOAT);
2528 PROCESS(alphaIndex, ACOMP, 1.0F, GLushort, USHORT_TO_FLOAT);
2529 break;
2530 case GL_SHORT:
2531 PROCESS(redIndex, RCOMP, 0.0F, GLshort, SHORT_TO_FLOAT);
2532 PROCESS(greenIndex, GCOMP, 0.0F, GLshort, SHORT_TO_FLOAT);
2533 PROCESS(blueIndex, BCOMP, 0.0F, GLshort, SHORT_TO_FLOAT);
2534 PROCESS(alphaIndex, ACOMP, 1.0F, GLshort, SHORT_TO_FLOAT);
2535 break;
2536 case GL_UNSIGNED_INT:
2537 PROCESS(redIndex, RCOMP, 0.0F, GLuint, UINT_TO_FLOAT);
2538 PROCESS(greenIndex, GCOMP, 0.0F, GLuint, UINT_TO_FLOAT);
2539 PROCESS(blueIndex, BCOMP, 0.0F, GLuint, UINT_TO_FLOAT);
2540 PROCESS(alphaIndex, ACOMP, 1.0F, GLuint, UINT_TO_FLOAT);
2541 break;
2542 case GL_INT:
2543 PROCESS(redIndex, RCOMP, 0.0F, GLint, INT_TO_FLOAT);
2544 PROCESS(greenIndex, GCOMP, 0.0F, GLint, INT_TO_FLOAT);
2545 PROCESS(blueIndex, BCOMP, 0.0F, GLint, INT_TO_FLOAT);
2546 PROCESS(alphaIndex, ACOMP, 1.0F, GLint, INT_TO_FLOAT);
2547 break;
2548 case GL_FLOAT:
2549 PROCESS(redIndex, RCOMP, 0.0F, GLfloat, (GLfloat));
2550 PROCESS(greenIndex, GCOMP, 0.0F, GLfloat, (GLfloat));
2551 PROCESS(blueIndex, BCOMP, 0.0F, GLfloat, (GLfloat));
2552 PROCESS(alphaIndex, ACOMP, 1.0F, GLfloat, (GLfloat));
2553 break;
2554 case GL_HALF_FLOAT_ARB:
2555 PROCESS(redIndex, RCOMP, 0.0F, GLhalfARB, _mesa_half_to_float);
2556 PROCESS(greenIndex, GCOMP, 0.0F, GLhalfARB, _mesa_half_to_float);
2557 PROCESS(blueIndex, BCOMP, 0.0F, GLhalfARB, _mesa_half_to_float);
2558 PROCESS(alphaIndex, ACOMP, 1.0F, GLhalfARB, _mesa_half_to_float);
2559 break;
2560 case GL_UNSIGNED_BYTE_3_3_2:
2561 {
2562 const GLubyte *ubsrc = (const GLubyte *) src;
2563 GLuint i;
2564 for (i = 0; i < n; i ++) {
2565 GLubyte p = ubsrc[i];
2566 rgba[i][rComp] = ((p >> 5) ) * (1.0F / 7.0F);
2567 rgba[i][gComp] = ((p >> 2) & 0x7) * (1.0F / 7.0F);
2568 rgba[i][bComp] = ((p ) & 0x3) * (1.0F / 3.0F);
2569 rgba[i][aComp] = 1.0F;
2570 }
2571 }
2572 break;
2573 case GL_UNSIGNED_BYTE_2_3_3_REV:
2574 {
2575 const GLubyte *ubsrc = (const GLubyte *) src;
2576 GLuint i;
2577 for (i = 0; i < n; i ++) {
2578 GLubyte p = ubsrc[i];
2579 rgba[i][rComp] = ((p ) & 0x7) * (1.0F / 7.0F);
2580 rgba[i][gComp] = ((p >> 3) & 0x7) * (1.0F / 7.0F);
2581 rgba[i][bComp] = ((p >> 6) ) * (1.0F / 3.0F);
2582 rgba[i][aComp] = 1.0F;
2583 }
2584 }
2585 break;
2586 case GL_UNSIGNED_SHORT_5_6_5:
2587 if (swapBytes) {
2588 const GLushort *ussrc = (const GLushort *) src;
2589 GLuint i;
2590 for (i = 0; i < n; i ++) {
2591 GLushort p = ussrc[i];
2592 SWAP2BYTE(p);
2593 rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F);
2594 rgba[i][gComp] = ((p >> 5) & 0x3f) * (1.0F / 63.0F);
2595 rgba[i][bComp] = ((p ) & 0x1f) * (1.0F / 31.0F);
2596 rgba[i][aComp] = 1.0F;
2597 }
2598 }
2599 else {
2600 const GLushort *ussrc = (const GLushort *) src;
2601 GLuint i;
2602 for (i = 0; i < n; i ++) {
2603 GLushort p = ussrc[i];
2604 rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F);
2605 rgba[i][gComp] = ((p >> 5) & 0x3f) * (1.0F / 63.0F);
2606 rgba[i][bComp] = ((p ) & 0x1f) * (1.0F / 31.0F);
2607 rgba[i][aComp] = 1.0F;
2608 }
2609 }
2610 break;
2611 case GL_UNSIGNED_SHORT_5_6_5_REV:
2612 if (swapBytes) {
2613 const GLushort *ussrc = (const GLushort *) src;
2614 GLuint i;
2615 for (i = 0; i < n; i ++) {
2616 GLushort p = ussrc[i];
2617 SWAP2BYTE(p);
2618 rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F);
2619 rgba[i][gComp] = ((p >> 5) & 0x3f) * (1.0F / 63.0F);
2620 rgba[i][bComp] = ((p >> 11) ) * (1.0F / 31.0F);
2621 rgba[i][aComp] = 1.0F;
2622 }
2623 }
2624 else {
2625 const GLushort *ussrc = (const GLushort *) src;
2626 GLuint i;
2627 for (i = 0; i < n; i ++) {
2628 GLushort p = ussrc[i];
2629 rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F);
2630 rgba[i][gComp] = ((p >> 5) & 0x3f) * (1.0F / 63.0F);
2631 rgba[i][bComp] = ((p >> 11) ) * (1.0F / 31.0F);
2632 rgba[i][aComp] = 1.0F;
2633 }
2634 }
2635 break;
2636 case GL_UNSIGNED_SHORT_4_4_4_4:
2637 if (swapBytes) {
2638 const GLushort *ussrc = (const GLushort *) src;
2639 GLuint i;
2640 for (i = 0; i < n; i ++) {
2641 GLushort p = ussrc[i];
2642 SWAP2BYTE(p);
2643 rgba[i][rComp] = ((p >> 12) ) * (1.0F / 15.0F);
2644 rgba[i][gComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F);
2645 rgba[i][bComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F);
2646 rgba[i][aComp] = ((p ) & 0xf) * (1.0F / 15.0F);
2647 }
2648 }
2649 else {
2650 const GLushort *ussrc = (const GLushort *) src;
2651 GLuint i;
2652 for (i = 0; i < n; i ++) {
2653 GLushort p = ussrc[i];
2654 rgba[i][rComp] = ((p >> 12) ) * (1.0F / 15.0F);
2655 rgba[i][gComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F);
2656 rgba[i][bComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F);
2657 rgba[i][aComp] = ((p ) & 0xf) * (1.0F / 15.0F);
2658 }
2659 }
2660 break;
2661 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
2662 if (swapBytes) {
2663 const GLushort *ussrc = (const GLushort *) src;
2664 GLuint i;
2665 for (i = 0; i < n; i ++) {
2666 GLushort p = ussrc[i];
2667 SWAP2BYTE(p);
2668 rgba[i][rComp] = ((p ) & 0xf) * (1.0F / 15.0F);
2669 rgba[i][gComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F);
2670 rgba[i][bComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F);
2671 rgba[i][aComp] = ((p >> 12) ) * (1.0F / 15.0F);
2672 }
2673 }
2674 else {
2675 const GLushort *ussrc = (const GLushort *) src;
2676 GLuint i;
2677 for (i = 0; i < n; i ++) {
2678 GLushort p = ussrc[i];
2679 rgba[i][rComp] = ((p ) & 0xf) * (1.0F / 15.0F);
2680 rgba[i][gComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F);
2681 rgba[i][bComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F);
2682 rgba[i][aComp] = ((p >> 12) ) * (1.0F / 15.0F);
2683 }
2684 }
2685 break;
2686 case GL_UNSIGNED_SHORT_5_5_5_1:
2687 if (swapBytes) {
2688 const GLushort *ussrc = (const GLushort *) src;
2689 GLuint i;
2690 for (i = 0; i < n; i ++) {
2691 GLushort p = ussrc[i];
2692 SWAP2BYTE(p);
2693 rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F);
2694 rgba[i][gComp] = ((p >> 6) & 0x1f) * (1.0F / 31.0F);
2695 rgba[i][bComp] = ((p >> 1) & 0x1f) * (1.0F / 31.0F);
2696 rgba[i][aComp] = ((p ) & 0x1) * (1.0F / 1.0F);
2697 }
2698 }
2699 else {
2700 const GLushort *ussrc = (const GLushort *) src;
2701 GLuint i;
2702 for (i = 0; i < n; i ++) {
2703 GLushort p = ussrc[i];
2704 rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F);
2705 rgba[i][gComp] = ((p >> 6) & 0x1f) * (1.0F / 31.0F);
2706 rgba[i][bComp] = ((p >> 1) & 0x1f) * (1.0F / 31.0F);
2707 rgba[i][aComp] = ((p ) & 0x1) * (1.0F / 1.0F);
2708 }
2709 }
2710 break;
2711 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
2712 if (swapBytes) {
2713 const GLushort *ussrc = (const GLushort *) src;
2714 GLuint i;
2715 for (i = 0; i < n; i ++) {
2716 GLushort p = ussrc[i];
2717 SWAP2BYTE(p);
2718 rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F);
2719 rgba[i][gComp] = ((p >> 5) & 0x1f) * (1.0F / 31.0F);
2720 rgba[i][bComp] = ((p >> 10) & 0x1f) * (1.0F / 31.0F);
2721 rgba[i][aComp] = ((p >> 15) ) * (1.0F / 1.0F);
2722 }
2723 }
2724 else {
2725 const GLushort *ussrc = (const GLushort *) src;
2726 GLuint i;
2727 for (i = 0; i < n; i ++) {
2728 GLushort p = ussrc[i];
2729 rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F);
2730 rgba[i][gComp] = ((p >> 5) & 0x1f) * (1.0F / 31.0F);
2731 rgba[i][bComp] = ((p >> 10) & 0x1f) * (1.0F / 31.0F);
2732 rgba[i][aComp] = ((p >> 15) ) * (1.0F / 1.0F);
2733 }
2734 }
2735 break;
2736 case GL_UNSIGNED_INT_8_8_8_8:
2737 if (swapBytes) {
2738 const GLuint *uisrc = (const GLuint *) src;
2739 GLuint i;
2740 for (i = 0; i < n; i ++) {
2741 GLuint p = uisrc[i];
2742 rgba[i][rComp] = UBYTE_TO_FLOAT((p ) & 0xff);
2743 rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
2744 rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2745 rgba[i][aComp] = UBYTE_TO_FLOAT((p >> 24) );
2746 }
2747 }
2748 else {
2749 const GLuint *uisrc = (const GLuint *) src;
2750 GLuint i;
2751 for (i = 0; i < n; i ++) {
2752 GLuint p = uisrc[i];
2753 rgba[i][rComp] = UBYTE_TO_FLOAT((p >> 24) );
2754 rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2755 rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
2756 rgba[i][aComp] = UBYTE_TO_FLOAT((p ) & 0xff);
2757 }
2758 }
2759 break;
2760 case GL_UNSIGNED_INT_8_8_8_8_REV:
2761 if (swapBytes) {
2762 const GLuint *uisrc = (const GLuint *) src;
2763 GLuint i;
2764 for (i = 0; i < n; i ++) {
2765 GLuint p = uisrc[i];
2766 rgba[i][rComp] = UBYTE_TO_FLOAT((p >> 24) );
2767 rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2768 rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
2769 rgba[i][aComp] = UBYTE_TO_FLOAT((p ) & 0xff);
2770 }
2771 }
2772 else {
2773 const GLuint *uisrc = (const GLuint *) src;
2774 GLuint i;
2775 for (i = 0; i < n; i ++) {
2776 GLuint p = uisrc[i];
2777 rgba[i][rComp] = UBYTE_TO_FLOAT((p ) & 0xff);
2778 rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
2779 rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2780 rgba[i][aComp] = UBYTE_TO_FLOAT((p >> 24) );
2781 }
2782 }
2783 break;
2784 case GL_UNSIGNED_INT_10_10_10_2:
2785 if (swapBytes) {
2786 const GLuint *uisrc = (const GLuint *) src;
2787 GLuint i;
2788 for (i = 0; i < n; i ++) {
2789 GLuint p = uisrc[i];
2790 SWAP4BYTE(p);
2791 rgba[i][rComp] = ((p >> 22) ) * (1.0F / 1023.0F);
2792 rgba[i][gComp] = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F);
2793 rgba[i][bComp] = ((p >> 2) & 0x3ff) * (1.0F / 1023.0F);
2794 rgba[i][aComp] = ((p ) & 0x3 ) * (1.0F / 3.0F);
2795 }
2796 }
2797 else {
2798 const GLuint *uisrc = (const GLuint *) src;
2799 GLuint i;
2800 for (i = 0; i < n; i ++) {
2801 GLuint p = uisrc[i];
2802 rgba[i][rComp] = ((p >> 22) ) * (1.0F / 1023.0F);
2803 rgba[i][gComp] = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F);
2804 rgba[i][bComp] = ((p >> 2) & 0x3ff) * (1.0F / 1023.0F);
2805 rgba[i][aComp] = ((p ) & 0x3 ) * (1.0F / 3.0F);
2806 }
2807 }
2808 break;
2809 case GL_UNSIGNED_INT_2_10_10_10_REV:
2810 if (swapBytes) {
2811 const GLuint *uisrc = (const GLuint *) src;
2812 GLuint i;
2813 for (i = 0; i < n; i ++) {
2814 GLuint p = uisrc[i];
2815 SWAP4BYTE(p);
2816 rgba[i][rComp] = ((p ) & 0x3ff) * (1.0F / 1023.0F);
2817 rgba[i][gComp] = ((p >> 10) & 0x3ff) * (1.0F / 1023.0F);
2818 rgba[i][bComp] = ((p >> 20) & 0x3ff) * (1.0F / 1023.0F);
2819 rgba[i][aComp] = ((p >> 30) ) * (1.0F / 3.0F);
2820 }
2821 }
2822 else {
2823 const GLuint *uisrc = (const GLuint *) src;
2824 GLuint i;
2825 for (i = 0; i < n; i ++) {
2826 GLuint p = uisrc[i];
2827 rgba[i][rComp] = ((p ) & 0x3ff) * (1.0F / 1023.0F);
2828 rgba[i][gComp] = ((p >> 10) & 0x3ff) * (1.0F / 1023.0F);
2829 rgba[i][bComp] = ((p >> 20) & 0x3ff) * (1.0F / 1023.0F);
2830 rgba[i][aComp] = ((p >> 30) ) * (1.0F / 3.0F);
2831 }
2832 }
2833 break;
2834 default:
2835 _mesa_problem(NULL, "bad srcType in extract float data");
2836 break;
2837 }
2838 }
2839
2840
2841 /*
2842 * Unpack a row of color image data from a client buffer according to
2843 * the pixel unpacking parameters.
2844 * Return GLchan values in the specified dest image format.
2845 * This is used by glDrawPixels and glTexImage?D().
2846 * \param ctx - the context
2847 * n - number of pixels in the span
2848 * dstFormat - format of destination color array
2849 * dest - the destination color array
2850 * srcFormat - source image format
2851 * srcType - source image data type
2852 * source - source image pointer
2853 * srcPacking - pixel unpacking parameters
2854 * transferOps - bitmask of IMAGE_*_BIT values of operations to apply
2855 *
2856 * XXX perhaps expand this to process whole images someday.
2857 */
2858 void
2859 _mesa_unpack_color_span_chan( GLcontext *ctx,
2860 GLuint n, GLenum dstFormat, GLchan dest[],
2861 GLenum srcFormat, GLenum srcType,
2862 const GLvoid *source,
2863 const struct gl_pixelstore_attrib *srcPacking,
2864 GLbitfield transferOps )
2865 {
2866 ASSERT(dstFormat == GL_ALPHA ||
2867 dstFormat == GL_LUMINANCE ||
2868 dstFormat == GL_LUMINANCE_ALPHA ||
2869 dstFormat == GL_INTENSITY ||
2870 dstFormat == GL_RGB ||
2871 dstFormat == GL_RGBA ||
2872 dstFormat == GL_COLOR_INDEX);
2873
2874 ASSERT(srcFormat == GL_RED ||
2875 srcFormat == GL_GREEN ||
2876 srcFormat == GL_BLUE ||
2877 srcFormat == GL_ALPHA ||
2878 srcFormat == GL_LUMINANCE ||
2879 srcFormat == GL_LUMINANCE_ALPHA ||
2880 srcFormat == GL_INTENSITY ||
2881 srcFormat == GL_RGB ||
2882 srcFormat == GL_BGR ||
2883 srcFormat == GL_RGBA ||
2884 srcFormat == GL_BGRA ||
2885 srcFormat == GL_ABGR_EXT ||
2886 srcFormat == GL_COLOR_INDEX);
2887
2888 ASSERT(srcType == GL_BITMAP ||
2889 srcType == GL_UNSIGNED_BYTE ||
2890 srcType == GL_BYTE ||
2891 srcType == GL_UNSIGNED_SHORT ||
2892 srcType == GL_SHORT ||
2893 srcType == GL_UNSIGNED_INT ||
2894 srcType == GL_INT ||
2895 srcType == GL_HALF_FLOAT_ARB ||
2896 srcType == GL_FLOAT ||
2897 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
2898 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
2899 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
2900 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
2901 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
2902 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
2903 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
2904 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
2905 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
2906 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
2907 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
2908 srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
2909
2910 /* Try simple cases first */
2911 if (transferOps == 0) {
2912 if (srcType == CHAN_TYPE) {
2913 if (dstFormat == GL_RGBA) {
2914 if (srcFormat == GL_RGBA) {
2915 _mesa_memcpy( dest, source, n * 4 * sizeof(GLchan) );
2916 return;
2917 }
2918 else if (srcFormat == GL_RGB) {
2919 GLuint i;
2920 const GLchan *src = (const GLchan *) source;
2921 GLchan *dst = dest;
2922 for (i = 0; i < n; i++) {
2923 dst[0] = src[0];
2924 dst[1] = src[1];
2925 dst[2] = src[2];
2926 dst[3] = CHAN_MAX;
2927 src += 3;
2928 dst += 4;
2929 }
2930 return;
2931 }
2932 }
2933 else if (dstFormat == GL_RGB) {
2934 if (srcFormat == GL_RGB) {
2935 _mesa_memcpy( dest, source, n * 3 * sizeof(GLchan) );
2936 return;
2937 }
2938 else if (srcFormat == GL_RGBA) {
2939 GLuint i;
2940 const GLchan *src = (const GLchan *) source;
2941 GLchan *dst = dest;
2942 for (i = 0; i < n; i++) {
2943 dst[0] = src[0];
2944 dst[1] = src[1];
2945 dst[2] = src[2];
2946 src += 4;
2947 dst += 3;
2948 }
2949 return;
2950 }
2951 }
2952 else if (dstFormat == srcFormat) {
2953 GLint comps = _mesa_components_in_format(srcFormat);
2954 assert(comps > 0);
2955 _mesa_memcpy( dest, source, n * comps * sizeof(GLchan) );
2956 return;
2957 }
2958 }
2959 /*
2960 * Common situation, loading 8bit RGBA/RGB source images
2961 * into 16/32 bit destination. (OSMesa16/32)
2962 */
2963 else if (srcType == GL_UNSIGNED_BYTE) {
2964 if (dstFormat == GL_RGBA) {
2965 if (srcFormat == GL_RGB) {
2966 GLuint i;
2967 const GLubyte *src = (const GLubyte *) source;
2968 GLchan *dst = dest;
2969 for (i = 0; i < n; i++) {
2970 dst[0] = UBYTE_TO_CHAN(src[0]);
2971 dst[1] = UBYTE_TO_CHAN(src[1]);
2972 dst[2] = UBYTE_TO_CHAN(src[2]);
2973 dst[3] = CHAN_MAX;
2974 src += 3;
2975 dst += 4;
2976 }
2977 return;
2978 }
2979 else if (srcFormat == GL_RGBA) {
2980 GLuint i;
2981 const GLubyte *src = (const GLubyte *) source;
2982 GLchan *dst = dest;
2983 for (i = 0; i < n; i++) {
2984 dst[0] = UBYTE_TO_CHAN(src[0]);
2985 dst[1] = UBYTE_TO_CHAN(src[1]);
2986 dst[2] = UBYTE_TO_CHAN(src[2]);
2987 dst[3] = UBYTE_TO_CHAN(src[3]);
2988 src += 4;
2989 dst += 4;
2990 }
2991 return;
2992 }
2993 }
2994 else if (dstFormat == GL_RGB) {
2995 if (srcFormat == GL_RGB) {
2996 GLuint i;
2997 const GLubyte *src = (const GLubyte *) source;
2998 GLchan *dst = dest;
2999 for (i = 0; i < n; i++) {
3000 dst[0] = UBYTE_TO_CHAN(src[0]);
3001 dst[1] = UBYTE_TO_CHAN(src[1]);
3002 dst[2] = UBYTE_TO_CHAN(src[2]);
3003 src += 3;
3004 dst += 3;
3005 }
3006 return;
3007 }
3008 else if (srcFormat == GL_RGBA) {
3009 GLuint i;
3010 const GLubyte *src = (const GLubyte *) source;
3011 GLchan *dst = dest;
3012 for (i = 0; i < n; i++) {
3013 dst[0] = UBYTE_TO_CHAN(src[0]);
3014 dst[1] = UBYTE_TO_CHAN(src[1]);
3015 dst[2] = UBYTE_TO_CHAN(src[2]);
3016 src += 4;
3017 dst += 3;
3018 }
3019 return;
3020 }
3021 }
3022 }
3023 }
3024
3025
3026 /* general solution begins here */
3027 {
3028 GLint dstComponents;
3029 GLint dstRedIndex, dstGreenIndex, dstBlueIndex, dstAlphaIndex;
3030 GLint dstLuminanceIndex, dstIntensityIndex;
3031 GLfloat rgba[MAX_WIDTH][4];
3032
3033 dstComponents = _mesa_components_in_format( dstFormat );
3034 /* source & dest image formats should have been error checked by now */
3035 assert(dstComponents > 0);
3036
3037 /*
3038 * Extract image data and convert to RGBA floats
3039 */
3040 assert(n <= MAX_WIDTH);
3041 if (srcFormat == GL_COLOR_INDEX) {
3042 GLuint indexes[MAX_WIDTH];
3043 extract_uint_indexes(n, indexes, srcFormat, srcType, source,
3044 srcPacking);
3045
3046 if (dstFormat == GL_COLOR_INDEX) {
3047 GLuint i;
3048 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
3049 /* convert to GLchan and return */
3050 for (i = 0; i < n; i++) {
3051 dest[i] = (GLchan) (indexes[i] & 0xff);
3052 }
3053 return;
3054 }
3055 else {
3056 /* Convert indexes to RGBA */
3057 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
3058 shift_and_offset_ci(ctx, n, indexes);
3059 }
3060 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
3061 }
3062
3063 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
3064 * with color indexes.
3065 */
3066 transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT);
3067 }
3068 else {
3069 /* non-color index data */
3070 extract_float_rgba(n, rgba, srcFormat, srcType, source,
3071 srcPacking->SwapBytes);
3072 }
3073
3074 /* Need to clamp if returning GLubytes or GLushorts */
3075 #if CHAN_TYPE != GL_FLOAT
3076 transferOps |= IMAGE_CLAMP_BIT;
3077 #endif
3078
3079 if (transferOps) {
3080 _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
3081 }
3082
3083 /* Now determine which color channels we need to produce.
3084 * And determine the dest index (offset) within each color tuple.
3085 */
3086 switch (dstFormat) {
3087 case GL_ALPHA:
3088 dstAlphaIndex = 0;
3089 dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
3090 dstLuminanceIndex = dstIntensityIndex = -1;
3091 break;
3092 case GL_LUMINANCE:
3093 dstLuminanceIndex = 0;
3094 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
3095 dstIntensityIndex = -1;
3096 break;
3097 case GL_LUMINANCE_ALPHA:
3098 dstLuminanceIndex = 0;
3099 dstAlphaIndex = 1;
3100 dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
3101 dstIntensityIndex = -1;
3102 break;
3103 case GL_INTENSITY:
3104 dstIntensityIndex = 0;
3105 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
3106 dstLuminanceIndex = -1;
3107 break;
3108 case GL_RGB:
3109 dstRedIndex = 0;
3110 dstGreenIndex = 1;
3111 dstBlueIndex = 2;
3112 dstAlphaIndex = dstLuminanceIndex = dstIntensityIndex = -1;
3113 break;
3114 case GL_RGBA:
3115 dstRedIndex = 0;
3116 dstGreenIndex = 1;
3117 dstBlueIndex = 2;
3118 dstAlphaIndex = 3;
3119 dstLuminanceIndex = dstIntensityIndex = -1;
3120 break;
3121 default:
3122 _mesa_problem(ctx, "bad dstFormat in _mesa_unpack_chan_span()");
3123 return;
3124 }
3125
3126
3127 /* Now return the GLchan data in the requested dstFormat */
3128
3129 if (dstRedIndex >= 0) {
3130 GLchan *dst = dest;
3131 GLuint i;
3132 for (i = 0; i < n; i++) {
3133 CLAMPED_FLOAT_TO_CHAN(dst[dstRedIndex], rgba[i][RCOMP]);
3134 dst += dstComponents;
3135 }
3136 }
3137
3138 if (dstGreenIndex >= 0) {
3139 GLchan *dst = dest;
3140 GLuint i;
3141 for (i = 0; i < n; i++) {
3142 CLAMPED_FLOAT_TO_CHAN(dst[dstGreenIndex], rgba[i][GCOMP]);
3143 dst += dstComponents;
3144 }
3145 }
3146
3147 if (dstBlueIndex >= 0) {
3148 GLchan *dst = dest;
3149 GLuint i;
3150 for (i = 0; i < n; i++) {
3151 CLAMPED_FLOAT_TO_CHAN(dst[dstBlueIndex], rgba[i][BCOMP]);
3152 dst += dstComponents;
3153 }
3154 }
3155
3156 if (dstAlphaIndex >= 0) {
3157 GLchan *dst = dest;
3158 GLuint i;
3159 for (i = 0; i < n; i++) {
3160 CLAMPED_FLOAT_TO_CHAN(dst[dstAlphaIndex], rgba[i][ACOMP]);
3161 dst += dstComponents;
3162 }
3163 }
3164
3165 if (dstIntensityIndex >= 0) {
3166 GLchan *dst = dest;
3167 GLuint i;
3168 assert(dstIntensityIndex == 0);
3169 assert(dstComponents == 1);
3170 for (i = 0; i < n; i++) {
3171 /* Intensity comes from red channel */
3172 CLAMPED_FLOAT_TO_CHAN(dst[i], rgba[i][RCOMP]);
3173 }
3174 }
3175
3176 if (dstLuminanceIndex >= 0) {
3177 GLchan *dst = dest;
3178 GLuint i;
3179 assert(dstLuminanceIndex == 0);
3180 for (i = 0; i < n; i++) {
3181 /* Luminance comes from red channel */
3182 CLAMPED_FLOAT_TO_CHAN(dst[0], rgba[i][RCOMP]);
3183 dst += dstComponents;
3184 }
3185 }
3186 }
3187 }
3188
3189
3190 /**
3191 * Same as _mesa_unpack_color_span_chan(), but return GLfloat data
3192 * instead of GLchan.
3193 */
3194 void
3195 _mesa_unpack_color_span_float( GLcontext *ctx,
3196 GLuint n, GLenum dstFormat, GLfloat dest[],
3197 GLenum srcFormat, GLenum srcType,
3198 const GLvoid *source,
3199 const struct gl_pixelstore_attrib *srcPacking,
3200 GLbitfield transferOps )
3201 {
3202 ASSERT(dstFormat == GL_ALPHA ||
3203 dstFormat == GL_LUMINANCE ||
3204 dstFormat == GL_LUMINANCE_ALPHA ||
3205 dstFormat == GL_INTENSITY ||
3206 dstFormat == GL_RGB ||
3207 dstFormat == GL_RGBA ||
3208 dstFormat == GL_COLOR_INDEX);
3209
3210 ASSERT(srcFormat == GL_RED ||
3211 srcFormat == GL_GREEN ||
3212 srcFormat == GL_BLUE ||
3213 srcFormat == GL_ALPHA ||
3214 srcFormat == GL_LUMINANCE ||
3215 srcFormat == GL_LUMINANCE_ALPHA ||
3216 srcFormat == GL_INTENSITY ||
3217 srcFormat == GL_RGB ||
3218 srcFormat == GL_BGR ||
3219 srcFormat == GL_RGBA ||
3220 srcFormat == GL_BGRA ||
3221 srcFormat == GL_ABGR_EXT ||
3222 srcFormat == GL_COLOR_INDEX);
3223
3224 ASSERT(srcType == GL_BITMAP ||
3225 srcType == GL_UNSIGNED_BYTE ||
3226 srcType == GL_BYTE ||
3227 srcType == GL_UNSIGNED_SHORT ||
3228 srcType == GL_SHORT ||
3229 srcType == GL_UNSIGNED_INT ||
3230 srcType == GL_INT ||
3231 srcType == GL_HALF_FLOAT_ARB ||
3232 srcType == GL_FLOAT ||
3233 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
3234 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
3235 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
3236 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
3237 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
3238 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
3239 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
3240 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
3241 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
3242 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
3243 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
3244 srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
3245
3246 /* general solution, no special cases, yet */
3247 {
3248 GLint dstComponents;
3249 GLint dstRedIndex, dstGreenIndex, dstBlueIndex, dstAlphaIndex;
3250 GLint dstLuminanceIndex, dstIntensityIndex;
3251 GLfloat rgba[MAX_WIDTH][4];
3252
3253 dstComponents = _mesa_components_in_format( dstFormat );
3254 /* source & dest image formats should have been error checked by now */
3255 assert(dstComponents > 0);
3256
3257 /*
3258 * Extract image data and convert to RGBA floats
3259 */
3260 assert(n <= MAX_WIDTH);
3261 if (srcFormat == GL_COLOR_INDEX) {
3262 GLuint indexes[MAX_WIDTH];
3263 extract_uint_indexes(n, indexes, srcFormat, srcType, source,
3264 srcPacking);
3265
3266 if (dstFormat == GL_COLOR_INDEX) {
3267 GLuint i;
3268 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
3269 /* convert to GLchan and return */
3270 for (i = 0; i < n; i++) {
3271 dest[i] = (GLchan) (indexes[i] & 0xff);
3272 }
3273 return;
3274 }
3275 else {
3276 /* Convert indexes to RGBA */
3277 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
3278 shift_and_offset_ci(ctx, n, indexes);
3279 }
3280 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
3281 }
3282
3283 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
3284 * with color indexes.
3285 */
3286 transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT);
3287 }
3288 else {
3289 /* non-color index data */
3290 extract_float_rgba(n, rgba, srcFormat, srcType, source,
3291 srcPacking->SwapBytes);
3292 }
3293
3294 if (transferOps) {
3295 _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
3296 }
3297
3298 /* Now determine which color channels we need to produce.
3299 * And determine the dest index (offset) within each color tuple.
3300 */
3301 switch (dstFormat) {
3302 case GL_ALPHA:
3303 dstAlphaIndex = 0;
3304 dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
3305 dstLuminanceIndex = dstIntensityIndex = -1;
3306 break;
3307 case GL_LUMINANCE:
3308 dstLuminanceIndex = 0;
3309 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
3310 dstIntensityIndex = -1;
3311 break;
3312 case GL_LUMINANCE_ALPHA:
3313 dstLuminanceIndex = 0;
3314 dstAlphaIndex = 1;
3315 dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
3316 dstIntensityIndex = -1;
3317 break;
3318 case GL_INTENSITY:
3319 dstIntensityIndex = 0;
3320 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
3321 dstLuminanceIndex = -1;
3322 break;
3323 case GL_RGB:
3324 dstRedIndex = 0;
3325 dstGreenIndex = 1;
3326 dstBlueIndex = 2;
3327 dstAlphaIndex = dstLuminanceIndex = dstIntensityIndex = -1;
3328 break;
3329 case GL_RGBA:
3330 dstRedIndex = 0;
3331 dstGreenIndex = 1;
3332 dstBlueIndex = 2;
3333 dstAlphaIndex = 3;
3334 dstLuminanceIndex = dstIntensityIndex = -1;
3335 break;
3336 default:
3337 _mesa_problem(ctx, "bad dstFormat in _mesa_unpack_color_span_float()");
3338 return;
3339 }
3340
3341 /* Now pack results in the requested dstFormat */
3342 if (dstRedIndex >= 0) {
3343 GLfloat *dst = dest;
3344 GLuint i;
3345 for (i = 0; i < n; i++) {
3346 dst[dstRedIndex] = rgba[i][RCOMP];
3347 dst += dstComponents;
3348 }
3349 }
3350
3351 if (dstGreenIndex >= 0) {
3352 GLfloat *dst = dest;
3353 GLuint i;
3354 for (i = 0; i < n; i++) {
3355 dst[dstGreenIndex] = rgba[i][GCOMP];
3356 dst += dstComponents;
3357 }
3358 }
3359
3360 if (dstBlueIndex >= 0) {
3361 GLfloat *dst = dest;
3362 GLuint i;
3363 for (i = 0; i < n; i++) {
3364 dst[dstBlueIndex] = rgba[i][BCOMP];
3365 dst += dstComponents;
3366 }
3367 }
3368
3369 if (dstAlphaIndex >= 0) {
3370 GLfloat *dst = dest;
3371 GLuint i;
3372 for (i = 0; i < n; i++) {
3373 dst[dstAlphaIndex] = rgba[i][ACOMP];
3374 dst += dstComponents;
3375 }
3376 }
3377
3378 if (dstIntensityIndex >= 0) {
3379 GLfloat *dst = dest;
3380 GLuint i;
3381 assert(dstIntensityIndex == 0);
3382 assert(dstComponents == 1);
3383 for (i = 0; i < n; i++) {
3384 /* Intensity comes from red channel */
3385 dst[i] = rgba[i][RCOMP];
3386 }
3387 }
3388
3389 if (dstLuminanceIndex >= 0) {
3390 GLfloat *dst = dest;
3391 GLuint i;
3392 assert(dstLuminanceIndex == 0);
3393 for (i = 0; i < n; i++) {
3394 /* Luminance comes from red channel */
3395 dst[0] = rgba[i][RCOMP];
3396 dst += dstComponents;
3397 }
3398 }
3399 }
3400 }
3401
3402
3403 /*
3404 * Unpack a row of color index data from a client buffer according to
3405 * the pixel unpacking parameters.
3406 * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.
3407 *
3408 * Args: ctx - the context
3409 * n - number of pixels
3410 * dstType - destination data type
3411 * dest - destination array
3412 * srcType - source pixel type
3413 * source - source data pointer
3414 * srcPacking - pixel unpacking parameters
3415 * transferOps - the pixel transfer operations to apply
3416 */
3417 void
3418 _mesa_unpack_index_span( const GLcontext *ctx, GLuint n,
3419 GLenum dstType, GLvoid *dest,
3420 GLenum srcType, const GLvoid *source,
3421 const struct gl_pixelstore_attrib *srcPacking,
3422 GLbitfield transferOps )
3423 {
3424 ASSERT(srcType == GL_BITMAP ||
3425 srcType == GL_UNSIGNED_BYTE ||
3426 srcType == GL_BYTE ||
3427 srcType == GL_UNSIGNED_SHORT ||
3428 srcType == GL_SHORT ||
3429 srcType == GL_UNSIGNED_INT ||
3430 srcType == GL_INT ||
3431 srcType == GL_HALF_FLOAT_ARB ||
3432 srcType == GL_FLOAT);
3433
3434 ASSERT(dstType == GL_UNSIGNED_BYTE ||
3435 dstType == GL_UNSIGNED_SHORT ||
3436 dstType == GL_UNSIGNED_INT);
3437
3438
3439 transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
3440
3441 /*
3442 * Try simple cases first
3443 */
3444 if (transferOps == 0 && srcType == GL_UNSIGNED_BYTE
3445 && dstType == GL_UNSIGNED_BYTE) {
3446 _mesa_memcpy(dest, source, n * sizeof(GLubyte));
3447 }
3448 else if (transferOps == 0 && srcType == GL_UNSIGNED_INT
3449 && dstType == GL_UNSIGNED_INT && !srcPacking->SwapBytes) {
3450 _mesa_memcpy(dest, source, n * sizeof(GLuint));
3451 }
3452 else {
3453 /*
3454 * general solution
3455 */
3456 GLuint indexes[MAX_WIDTH];
3457 assert(n <= MAX_WIDTH);
3458
3459 extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
3460 srcPacking);
3461
3462 if (transferOps)
3463 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
3464
3465 /* convert to dest type */
3466 switch (dstType) {
3467 case GL_UNSIGNED_BYTE:
3468 {
3469 GLubyte *dst = (GLubyte *) dest;
3470 GLuint i;
3471 for (i = 0; i < n; i++) {
3472 dst[i] = (GLubyte) (indexes[i] & 0xff);
3473 }
3474 }
3475 break;
3476 case GL_UNSIGNED_SHORT:
3477 {
3478 GLuint *dst = (GLuint *) dest;
3479 GLuint i;
3480 for (i = 0; i < n; i++) {
3481 dst[i] = (GLushort) (indexes[i] & 0xffff);
3482 }
3483 }
3484 break;
3485 case GL_UNSIGNED_INT:
3486 _mesa_memcpy(dest, indexes, n * sizeof(GLuint));
3487 break;
3488 default:
3489 _mesa_problem(ctx, "bad dstType in _mesa_unpack_index_span");
3490 }
3491 }
3492 }
3493
3494
3495 void
3496 _mesa_pack_index_span( const GLcontext *ctx, GLuint n,
3497 GLenum dstType, GLvoid *dest, const GLuint *source,
3498 const struct gl_pixelstore_attrib *dstPacking,
3499 GLbitfield transferOps )
3500 {
3501 GLuint indexes[MAX_WIDTH];
3502
3503 ASSERT(n <= MAX_WIDTH);
3504
3505 transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
3506
3507 if (transferOps & (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT)) {
3508 /* make a copy of input */
3509 _mesa_memcpy(indexes, source, n * sizeof(GLuint));
3510 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
3511 source = indexes;
3512 }
3513
3514 switch (dstType) {
3515 case GL_UNSIGNED_BYTE:
3516 {
3517 GLubyte *dst = (GLubyte *) dest;
3518 GLuint i;
3519 for (i = 0; i < n; i++) {
3520 *dst++ = (GLubyte) source[i];
3521 }
3522 }
3523 break;
3524 case GL_BYTE:
3525 {
3526 GLbyte *dst = (GLbyte *) dest;
3527 GLuint i;
3528 for (i = 0; i < n; i++) {
3529 dst[i] = (GLbyte) source[i];
3530 }
3531 }
3532 break;
3533 case GL_UNSIGNED_SHORT:
3534 {
3535 GLushort *dst = (GLushort *) dest;
3536 GLuint i;
3537 for (i = 0; i < n; i++) {
3538 dst[i] = (GLushort) source[i];
3539 }
3540 if (dstPacking->SwapBytes) {
3541 _mesa_swap2( (GLushort *) dst, n );
3542 }
3543 }
3544 break;
3545 case GL_SHORT:
3546 {
3547 GLshort *dst = (GLshort *) dest;
3548 GLuint i;
3549 for (i = 0; i < n; i++) {
3550 dst[i] = (GLshort) source[i];
3551 }
3552 if (dstPacking->SwapBytes) {
3553 _mesa_swap2( (GLushort *) dst, n );
3554 }
3555 }
3556 break;
3557 case GL_UNSIGNED_INT:
3558 {
3559 GLuint *dst = (GLuint *) dest;
3560 GLuint i;
3561 for (i = 0; i < n; i++) {
3562 dst[i] = (GLuint) source[i];
3563 }
3564 if (dstPacking->SwapBytes) {
3565 _mesa_swap4( (GLuint *) dst, n );
3566 }
3567 }
3568 break;
3569 case GL_INT:
3570 {
3571 GLint *dst = (GLint *) dest;
3572 GLuint i;
3573 for (i = 0; i < n; i++) {
3574 dst[i] = (GLint) source[i];
3575 }
3576 if (dstPacking->SwapBytes) {
3577 _mesa_swap4( (GLuint *) dst, n );
3578 }
3579 }
3580 break;
3581 case GL_FLOAT:
3582 {
3583 GLfloat *dst = (GLfloat *) dest;
3584 GLuint i;
3585 for (i = 0; i < n; i++) {
3586 dst[i] = (GLfloat) source[i];
3587 }
3588 if (dstPacking->SwapBytes) {
3589 _mesa_swap4( (GLuint *) dst, n );
3590 }
3591 }
3592 break;
3593 case GL_HALF_FLOAT_ARB:
3594 {
3595 GLhalfARB *dst = (GLhalfARB *) dest;
3596 GLuint i;
3597 for (i = 0; i < n; i++) {
3598 dst[i] = _mesa_float_to_half((GLfloat) source[i]);
3599 }
3600 if (dstPacking->SwapBytes) {
3601 _mesa_swap2( (GLushort *) dst, n );
3602 }
3603 }
3604 break;
3605 default:
3606 _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
3607 }
3608 }
3609
3610
3611 /*
3612 * Unpack a row of stencil data from a client buffer according to
3613 * the pixel unpacking parameters.
3614 * This is (or will be) used by glDrawPixels
3615 *
3616 * Args: ctx - the context
3617 * n - number of pixels
3618 * dstType - destination data type
3619 * dest - destination array
3620 * srcType - source pixel type
3621 * source - source data pointer
3622 * srcPacking - pixel unpacking parameters
3623 * transferOps - apply offset/bias/lookup ops?
3624 */
3625 void
3626 _mesa_unpack_stencil_span( const GLcontext *ctx, GLuint n,
3627 GLenum dstType, GLvoid *dest,
3628 GLenum srcType, const GLvoid *source,
3629 const struct gl_pixelstore_attrib *srcPacking,
3630 GLbitfield transferOps )
3631 {
3632 ASSERT(srcType == GL_BITMAP ||
3633 srcType == GL_UNSIGNED_BYTE ||
3634 srcType == GL_BYTE ||
3635 srcType == GL_UNSIGNED_SHORT ||
3636 srcType == GL_SHORT ||
3637 srcType == GL_UNSIGNED_INT ||
3638 srcType == GL_INT ||
3639 srcType == GL_UNSIGNED_INT_24_8_EXT ||
3640 srcType == GL_HALF_FLOAT_ARB ||
3641 srcType == GL_FLOAT);
3642
3643 ASSERT(dstType == GL_UNSIGNED_BYTE ||
3644 dstType == GL_UNSIGNED_SHORT ||
3645 dstType == GL_UNSIGNED_INT);
3646
3647 /* only shift and offset apply to stencil */
3648 transferOps &= IMAGE_SHIFT_OFFSET_BIT;
3649
3650 /*
3651 * Try simple cases first
3652 */
3653 if (transferOps == 0 &&
3654 srcType == GL_UNSIGNED_BYTE &&
3655 dstType == GL_UNSIGNED_BYTE) {
3656 _mesa_memcpy(dest, source, n * sizeof(GLubyte));
3657 }
3658 else if (transferOps == 0 &&
3659 srcType == GL_UNSIGNED_INT &&
3660 dstType == GL_UNSIGNED_INT &&
3661 !srcPacking->SwapBytes) {
3662 _mesa_memcpy(dest, source, n * sizeof(GLuint));
3663 }
3664 else {
3665 /*
3666 * general solution
3667 */
3668 GLuint indexes[MAX_WIDTH];
3669 assert(n <= MAX_WIDTH);
3670
3671 extract_uint_indexes(n, indexes, GL_STENCIL_INDEX, srcType, source,
3672 srcPacking);
3673
3674 if (transferOps) {
3675 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
3676 /* shift and offset indexes */
3677 shift_and_offset_ci(ctx, n, indexes);
3678 }
3679
3680 if (ctx->Pixel.MapStencilFlag) {
3681 /* Apply stencil lookup table */
3682 GLuint mask = ctx->PixelMaps.StoS.Size - 1;
3683 GLuint i;
3684 for (i=0;i<n;i++) {
3685 indexes[i] = ctx->PixelMaps.StoS.Map[ indexes[i] & mask ];
3686 }
3687 }
3688 }
3689
3690 /* convert to dest type */
3691 switch (dstType) {
3692 case GL_UNSIGNED_BYTE:
3693 {
3694 GLubyte *dst = (GLubyte *) dest;
3695 GLuint i;
3696 for (i = 0; i < n; i++) {
3697 dst[i] = (GLubyte) (indexes[i] & 0xff);
3698 }
3699 }
3700 break;
3701 case GL_UNSIGNED_SHORT:
3702 {
3703 GLuint *dst = (GLuint *) dest;
3704 GLuint i;
3705 for (i = 0; i < n; i++) {
3706 dst[i] = (GLushort) (indexes[i] & 0xffff);
3707 }
3708 }
3709 break;
3710 case GL_UNSIGNED_INT:
3711 _mesa_memcpy(dest, indexes, n * sizeof(GLuint));
3712 break;
3713 default:
3714 _mesa_problem(ctx, "bad dstType in _mesa_unpack_stencil_span");
3715 }
3716 }
3717 }
3718
3719
3720 void
3721 _mesa_pack_stencil_span( const GLcontext *ctx, GLuint n,
3722 GLenum dstType, GLvoid *dest, const GLstencil *source,
3723 const struct gl_pixelstore_attrib *dstPacking )
3724 {
3725 GLstencil stencil[MAX_WIDTH];
3726
3727 ASSERT(n <= MAX_WIDTH);
3728
3729 if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset ||
3730 ctx->Pixel.MapStencilFlag) {
3731 /* make a copy of input */
3732 _mesa_memcpy(stencil, source, n * sizeof(GLstencil));
3733 _mesa_apply_stencil_transfer_ops(ctx, n, stencil);
3734 source = stencil;
3735 }
3736
3737 switch (dstType) {
3738 case GL_UNSIGNED_BYTE:
3739 if (sizeof(GLstencil) == 8) {
3740 _mesa_memcpy( dest, source, n );
3741 }
3742 else {
3743 GLubyte *dst = (GLubyte *) dest;
3744 GLuint i;
3745 for (i=0;i<n;i++) {
3746 dst[i] = (GLubyte) source[i];
3747 }
3748 }
3749 break;
3750 case GL_BYTE:
3751 if (sizeof(GLstencil) == 8) {
3752 _mesa_memcpy( dest, source, n );
3753 }
3754 else {
3755 GLbyte *dst = (GLbyte *) dest;
3756 GLuint i;
3757 for (i=0;i<n;i++) {
3758 dst[i] = (GLbyte) source[i];
3759 }
3760 }
3761 break;
3762 case GL_UNSIGNED_SHORT:
3763 {
3764 GLushort *dst = (GLushort *) dest;
3765 GLuint i;
3766 for (i=0;i<n;i++) {
3767 dst[i] = (GLushort) source[i];
3768 }
3769 if (dstPacking->SwapBytes) {
3770 _mesa_swap2( (GLushort *) dst, n );
3771 }
3772 }
3773 break;
3774 case GL_SHORT:
3775 {
3776 GLshort *dst = (GLshort *) dest;
3777 GLuint i;
3778 for (i=0;i<n;i++) {
3779 dst[i] = (GLshort) source[i];
3780 }
3781 if (dstPacking->SwapBytes) {
3782 _mesa_swap2( (GLushort *) dst, n );
3783 }
3784 }
3785 break;
3786 case GL_UNSIGNED_INT:
3787 {
3788 GLuint *dst = (GLuint *) dest;
3789 GLuint i;
3790 for (i=0;i<n;i++) {
3791 dst[i] = (GLuint) source[i];
3792 }
3793 if (dstPacking->SwapBytes) {
3794 _mesa_swap4( (GLuint *) dst, n );
3795 }
3796 }
3797 break;
3798 case GL_INT:
3799 {
3800 GLint *dst = (GLint *) dest;
3801 GLuint i;
3802 for (i=0;i<n;i++) {
3803 *dst++ = (GLint) source[i];
3804 }
3805 if (dstPacking->SwapBytes) {
3806 _mesa_swap4( (GLuint *) dst, n );
3807 }
3808 }
3809 break;
3810 case GL_FLOAT:
3811 {
3812 GLfloat *dst = (GLfloat *) dest;
3813 GLuint i;
3814 for (i=0;i<n;i++) {
3815 dst[i] = (GLfloat) source[i];
3816 }
3817 if (dstPacking->SwapBytes) {
3818 _mesa_swap4( (GLuint *) dst, n );
3819 }
3820 }
3821 break;
3822 case GL_HALF_FLOAT_ARB:
3823 {
3824 GLhalfARB *dst = (GLhalfARB *) dest;
3825 GLuint i;
3826 for (i=0;i<n;i++) {
3827 dst[i] = _mesa_float_to_half( (float) source[i] );
3828 }
3829 if (dstPacking->SwapBytes) {
3830 _mesa_swap2( (GLushort *) dst, n );
3831 }
3832 }
3833 break;
3834 case GL_BITMAP:
3835 if (dstPacking->LsbFirst) {
3836 GLubyte *dst = (GLubyte *) dest;
3837 GLint shift = 0;
3838 GLuint i;
3839 for (i = 0; i < n; i++) {
3840 if (shift == 0)
3841 *dst = 0;
3842 *dst |= ((source[i] != 0) << shift);
3843 shift++;
3844 if (shift == 8) {
3845 shift = 0;
3846 dst++;
3847 }
3848 }
3849 }
3850 else {
3851 GLubyte *dst = (GLubyte *) dest;
3852 GLint shift = 7;
3853 GLuint i;
3854 for (i = 0; i < n; i++) {
3855 if (shift == 7)
3856 *dst = 0;
3857 *dst |= ((source[i] != 0) << shift);
3858 shift--;
3859 if (shift < 0) {
3860 shift = 7;
3861 dst++;
3862 }
3863 }
3864 }
3865 break;
3866 default:
3867 _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
3868 }
3869 }
3870
3871 #define DEPTH_VALUES(GLTYPE, GLTYPE2FLOAT) \
3872 do { \
3873 GLuint i; \
3874 const GLTYPE *src = (const GLTYPE *)source; \
3875 for (i = 0; i < n; i++) { \
3876 GLTYPE value = src[i]; \
3877 if (srcPacking->SwapBytes) { \
3878 if (sizeof(GLTYPE) == 2) { \
3879 SWAP2BYTE(value); \
3880 } else if (sizeof(GLTYPE) == 4) { \
3881 SWAP4BYTE(value); \
3882 } \
3883 } \
3884 depthValues[i] = CLAMP(GLTYPE2FLOAT(value), 0.0F, 1.0F); \
3885 } \
3886 } while (0)
3887
3888 void
3889 _mesa_unpack_depth_span( const GLcontext *ctx, GLuint n,
3890 GLenum dstType, GLvoid *dest, GLfloat depthScale,
3891 GLenum srcType, const GLvoid *source,
3892 const struct gl_pixelstore_attrib *srcPacking )
3893 {
3894 GLfloat depthTemp[MAX_WIDTH], *depthValues;
3895
3896 if (dstType == GL_FLOAT) {
3897 depthValues = (GLfloat *) dest;
3898 }
3899 else {
3900 depthValues = depthTemp;
3901 }
3902
3903 /* XXX we need to obey srcPacking->SwapBytes here!!! */
3904 (void) srcPacking;
3905
3906 switch (srcType) {
3907 case GL_BYTE:
3908 DEPTH_VALUES(GLbyte, BYTE_TO_FLOAT);
3909 break;
3910 case GL_UNSIGNED_BYTE:
3911 DEPTH_VALUES(GLubyte, UBYTE_TO_FLOAT);
3912 break;
3913 case GL_SHORT:
3914 DEPTH_VALUES(GLshort, SHORT_TO_FLOAT);
3915 break;
3916 case GL_UNSIGNED_SHORT:
3917 DEPTH_VALUES(GLushort, USHORT_TO_FLOAT);
3918 break;
3919 case GL_INT:
3920 DEPTH_VALUES(GLint, INT_TO_FLOAT);
3921 break;
3922 case GL_UNSIGNED_INT:
3923 DEPTH_VALUES(GLuint, UINT_TO_FLOAT);
3924 break;
3925 case GL_UNSIGNED_INT_24_8_EXT: /* GL_EXT_packed_depth_stencil */
3926 if (dstType == GL_UNSIGNED_INT &&
3927 depthScale == (GLfloat) 0xffffff &&
3928 ctx->Pixel.DepthScale == 1.0 &&
3929 ctx->Pixel.DepthBias == 0.0) {
3930 const GLuint *src = (const GLuint *) source;
3931 GLuint *zValues = (GLuint *) dest;
3932 GLuint i;
3933 for (i = 0; i < n; i++) {
3934 GLuint value = src[i];
3935 if (srcPacking->SwapBytes) {
3936 SWAP4BYTE(value);
3937 }
3938 zValues[i] = value & 0xffffff00;
3939 }
3940 return;
3941 }
3942 else {
3943 const GLuint *src = (const GLuint *) source;
3944 const GLfloat scale = 1.0f / 0xffffff;
3945 GLuint i;
3946 for (i = 0; i < n; i++) {
3947 GLuint value = src[i];
3948 if (srcPacking->SwapBytes) {
3949 SWAP4BYTE(value);
3950 }
3951 depthValues[i] = (value >> 8) * scale;
3952 }
3953 }
3954 break;
3955 case GL_FLOAT:
3956 DEPTH_VALUES(GLfloat, 1*);
3957 break;
3958 case GL_HALF_FLOAT_ARB:
3959 {
3960 GLuint i;
3961 const GLhalfARB *src = (const GLhalfARB *) source;
3962 for (i = 0; i < n; i++) {
3963 GLhalfARB value = src[i];
3964 if (srcPacking->SwapBytes) {
3965 SWAP2BYTE(value);
3966 }
3967 depthValues[i] = _mesa_half_to_float(value);
3968 }
3969 }
3970 break;
3971 default:
3972 _mesa_problem(NULL, "bad type in _mesa_unpack_depth_span()");
3973 return;
3974 }
3975
3976
3977 /* apply depth scale and bias and clamp to [0,1] */
3978 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
3979 _mesa_scale_and_bias_depth(ctx, n, depthValues);
3980 }
3981
3982 if (dstType == GL_UNSIGNED_INT) {
3983 GLuint *zValues = (GLuint *) dest;
3984 GLuint i;
3985 if (depthScale <= (GLfloat) 0xffffff) {
3986 /* no overflow worries */
3987 for (i = 0; i < n; i++) {
3988 zValues[i] = (GLuint) (depthValues[i] * depthScale);
3989 }
3990 }
3991 else {
3992 /* need to use double precision to prevent overflow problems */
3993 for (i = 0; i < n; i++) {
3994 GLdouble z = depthValues[i] * depthScale;
3995 if (z >= (GLdouble) 0xffffffff)
3996 zValues[i] = 0xffffffff;
3997 else
3998 zValues[i] = (GLuint) z;
3999 }
4000 }
4001 }
4002 else if (dstType == GL_UNSIGNED_SHORT) {
4003 GLushort *zValues = (GLushort *) dest;
4004 GLuint i;
4005 ASSERT(depthScale <= 65535.0);
4006 for (i = 0; i < n; i++) {
4007 zValues[i] = (GLushort) (depthValues[i] * depthScale);
4008 }
4009 }
4010 else {
4011 ASSERT(dstType == GL_FLOAT);
4012 ASSERT(depthScale == 1.0F);
4013 }
4014 }
4015
4016
4017 /*
4018 * Pack an array of depth values. The values are floats in [0,1].
4019 */
4020 void
4021 _mesa_pack_depth_span( const GLcontext *ctx, GLuint n, GLvoid *dest,
4022 GLenum dstType, const GLfloat *depthSpan,
4023 const struct gl_pixelstore_attrib *dstPacking )
4024 {
4025 GLfloat depthCopy[MAX_WIDTH];
4026
4027 ASSERT(n <= MAX_WIDTH);
4028
4029 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
4030 _mesa_memcpy(depthCopy, depthSpan, n * sizeof(GLfloat));
4031 _mesa_scale_and_bias_depth(ctx, n, depthCopy);
4032 depthSpan = depthCopy;
4033 }
4034
4035 switch (dstType) {
4036 case GL_UNSIGNED_BYTE:
4037 {
4038 GLubyte *dst = (GLubyte *) dest;
4039 GLuint i;
4040 for (i = 0; i < n; i++) {
4041 dst[i] = FLOAT_TO_UBYTE( depthSpan[i] );
4042 }
4043 }
4044 break;
4045 case GL_BYTE:
4046 {
4047 GLbyte *dst = (GLbyte *) dest;
4048 GLuint i;
4049 for (i = 0; i < n; i++) {
4050 dst[i] = FLOAT_TO_BYTE( depthSpan[i] );
4051 }
4052 }
4053 break;
4054 case GL_UNSIGNED_SHORT:
4055 {
4056 GLushort *dst = (GLushort *) dest;
4057 GLuint i;
4058 for (i = 0; i < n; i++) {
4059 CLAMPED_FLOAT_TO_USHORT(dst[i], depthSpan[i]);
4060 }
4061 if (dstPacking->SwapBytes) {
4062 _mesa_swap2( (GLushort *) dst, n );
4063 }
4064 }
4065 break;
4066 case GL_SHORT:
4067 {
4068 GLshort *dst = (GLshort *) dest;
4069 GLuint i;
4070 for (i = 0; i < n; i++) {
4071 dst[i] = FLOAT_TO_SHORT( depthSpan[i] );
4072 }
4073 if (dstPacking->SwapBytes) {
4074 _mesa_swap2( (GLushort *) dst, n );
4075 }
4076 }
4077 break;
4078 case GL_UNSIGNED_INT:
4079 {
4080 GLuint *dst = (GLuint *) dest;
4081 GLuint i;
4082 for (i = 0; i < n; i++) {
4083 dst[i] = FLOAT_TO_UINT( depthSpan[i] );
4084 }
4085 if (dstPacking->SwapBytes) {
4086 _mesa_swap4( (GLuint *) dst, n );
4087 }
4088 }
4089 break;
4090 case GL_INT:
4091 {
4092 GLint *dst = (GLint *) dest;
4093 GLuint i;
4094 for (i = 0; i < n; i++) {
4095 dst[i] = FLOAT_TO_INT( depthSpan[i] );
4096 }
4097 if (dstPacking->SwapBytes) {
4098 _mesa_swap4( (GLuint *) dst, n );
4099 }
4100 }
4101 break;
4102 case GL_FLOAT:
4103 {
4104 GLfloat *dst = (GLfloat *) dest;
4105 GLuint i;
4106 for (i = 0; i < n; i++) {
4107 dst[i] = depthSpan[i];
4108 }
4109 if (dstPacking->SwapBytes) {
4110 _mesa_swap4( (GLuint *) dst, n );
4111 }
4112 }
4113 break;
4114 case GL_HALF_FLOAT_ARB:
4115 {
4116 GLhalfARB *dst = (GLhalfARB *) dest;
4117 GLuint i;
4118 for (i = 0; i < n; i++) {
4119 dst[i] = _mesa_float_to_half(depthSpan[i]);
4120 }
4121 if (dstPacking->SwapBytes) {
4122 _mesa_swap2( (GLushort *) dst, n );
4123 }
4124 }
4125 break;
4126 default:
4127 _mesa_problem(ctx, "bad type in _mesa_pack_depth_span");
4128 }
4129 }
4130
4131
4132
4133 /**
4134 * Pack depth and stencil values as GL_DEPTH_STENCIL/GL_UNSIGNED_INT_24_8.
4135 */
4136 void
4137 _mesa_pack_depth_stencil_span(const GLcontext *ctx, GLuint n, GLuint *dest,
4138 const GLfloat *depthVals,
4139 const GLstencil *stencilVals,
4140 const struct gl_pixelstore_attrib *dstPacking)
4141 {
4142 GLfloat depthCopy[MAX_WIDTH];
4143 GLstencil stencilCopy[MAX_WIDTH];
4144 GLuint i;
4145
4146 ASSERT(n <= MAX_WIDTH);
4147
4148 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
4149 _mesa_memcpy(depthCopy, depthVals, n * sizeof(GLfloat));
4150 _mesa_scale_and_bias_depth(ctx, n, depthCopy);
4151 depthVals = depthCopy;
4152 }
4153
4154 if (ctx->Pixel.IndexShift ||
4155 ctx->Pixel.IndexOffset ||
4156 ctx->Pixel.MapStencilFlag) {
4157 _mesa_memcpy(stencilCopy, stencilVals, n * sizeof(GLstencil));
4158 _mesa_apply_stencil_transfer_ops(ctx, n, stencilCopy);
4159 stencilVals = stencilCopy;
4160 }
4161
4162 for (i = 0; i < n; i++) {
4163 GLuint z = (GLuint) (depthVals[i] * 0xffffff);
4164 dest[i] = (z << 8) | (stencilVals[i] & 0xff);
4165 }
4166
4167 if (dstPacking->SwapBytes) {
4168 _mesa_swap4(dest, n);
4169 }
4170 }
4171
4172
4173
4174
4175 /**
4176 * Unpack image data. Apply byte swapping, byte flipping (bitmap).
4177 * Return all image data in a contiguous block. This is used when we
4178 * compile glDrawPixels, glTexImage, etc into a display list. We
4179 * need a copy of the data in a standard format.
4180 */
4181 void *
4182 _mesa_unpack_image( GLuint dimensions,
4183 GLsizei width, GLsizei height, GLsizei depth,
4184 GLenum format, GLenum type, const GLvoid *pixels,
4185 const struct gl_pixelstore_attrib *unpack )
4186 {
4187 GLint bytesPerRow, compsPerRow;
4188 GLboolean flipBytes, swap2, swap4;
4189
4190 if (!pixels)
4191 return NULL; /* not necessarily an error */
4192
4193 if (width <= 0 || height <= 0 || depth <= 0)
4194 return NULL; /* generate error later */
4195
4196 if (type == GL_BITMAP) {
4197 bytesPerRow = (width + 7) >> 3;
4198 flipBytes = unpack->LsbFirst;
4199 swap2 = swap4 = GL_FALSE;
4200 compsPerRow = 0;
4201 }
4202 else {
4203 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
4204 GLint components = _mesa_components_in_format(format);
4205 GLint bytesPerComp;
4206
4207 if (_mesa_type_is_packed(type))
4208 components = 1;
4209
4210 if (bytesPerPixel <= 0 || components <= 0)
4211 return NULL; /* bad format or type. generate error later */
4212 bytesPerRow = bytesPerPixel * width;
4213 bytesPerComp = bytesPerPixel / components;
4214 flipBytes = GL_FALSE;
4215 swap2 = (bytesPerComp == 2) && unpack->SwapBytes;
4216 swap4 = (bytesPerComp == 4) && unpack->SwapBytes;
4217 compsPerRow = components * width;
4218 assert(compsPerRow >= width);
4219 }
4220
4221 {
4222 GLubyte *destBuffer
4223 = (GLubyte *) _mesa_malloc(bytesPerRow * height * depth);
4224 GLubyte *dst;
4225 GLint img, row;
4226 if (!destBuffer)
4227 return NULL; /* generate GL_OUT_OF_MEMORY later */
4228
4229 dst = destBuffer;
4230 for (img = 0; img < depth; img++) {
4231 for (row = 0; row < height; row++) {
4232 const GLvoid *src = _mesa_image_address(dimensions, unpack, pixels,
4233 width, height, format, type, img, row, 0);
4234
4235 if ((type == GL_BITMAP) && (unpack->SkipPixels & 0x7)) {
4236 GLint i;
4237 flipBytes = GL_FALSE;
4238 if (unpack->LsbFirst) {
4239 GLubyte srcMask = 1 << (unpack->SkipPixels & 0x7);
4240 GLubyte dstMask = 128;
4241 const GLubyte *s = src;
4242 GLubyte *d = dst;
4243 *d = 0;
4244 for (i = 0; i < width; i++) {
4245 if (*s & srcMask) {
4246 *d |= dstMask;
4247 }
4248 if (srcMask == 128) {
4249 srcMask = 1;
4250 s++;
4251 } else {
4252 srcMask = srcMask << 1;
4253 }
4254 if (dstMask == 1) {
4255 dstMask = 128;
4256 d++;
4257 *d = 0;
4258 } else {
4259 dstMask = dstMask >> 1;
4260 }
4261 }
4262 } else {
4263 GLubyte srcMask = 128 >> (unpack->SkipPixels & 0x7);
4264 GLubyte dstMask = 128;
4265 const GLubyte *s = src;
4266 GLubyte *d = dst;
4267 *d = 0;
4268 for (i = 0; i < width; i++) {
4269 if (*s & srcMask) {
4270 *d |= dstMask;
4271 }
4272 if (srcMask == 1) {
4273 srcMask = 128;
4274 s++;
4275 } else {
4276 srcMask = srcMask >> 1;
4277 }
4278 if (dstMask == 1) {
4279 dstMask = 128;
4280 d++;
4281 *d = 0;
4282 } else {
4283 dstMask = dstMask >> 1;
4284 }
4285 }
4286 }
4287 } else
4288 _mesa_memcpy(dst, src, bytesPerRow);
4289 /* byte flipping/swapping */
4290 if (flipBytes) {
4291 flip_bytes((GLubyte *) dst, bytesPerRow);
4292 }
4293 else if (swap2) {
4294 _mesa_swap2((GLushort*) dst, compsPerRow);
4295 }
4296 else if (swap4) {
4297 _mesa_swap4((GLuint*) dst, compsPerRow);
4298 }
4299 dst += bytesPerRow;
4300 }
4301 }
4302 return destBuffer;
4303 }
4304 }
4305
4306 #endif /* _HAVE_FULL_GL */
4307
4308
4309
4310 /**
4311 * Convert an array of RGBA colors from one datatype to another.
4312 * NOTE: src may equal dst. In that case, we use a temporary buffer.
4313 */
4314 void
4315 _mesa_convert_colors(GLenum srcType, const GLvoid *src,
4316 GLenum dstType, GLvoid *dst,
4317 GLuint count, const GLubyte mask[])
4318 {
4319 GLuint tempBuffer[MAX_WIDTH][4];
4320 const GLboolean useTemp = (src == dst);
4321
4322 ASSERT(srcType != dstType);
4323
4324 switch (srcType) {
4325 case GL_UNSIGNED_BYTE:
4326 if (dstType == GL_UNSIGNED_SHORT) {
4327 const GLubyte (*src1)[4] = (const GLubyte (*)[4]) src;
4328 GLushort (*dst2)[4] = (GLushort (*)[4]) (useTemp ? tempBuffer : dst);
4329 GLuint i;
4330 for (i = 0; i < count; i++) {
4331 if (!mask || mask[i]) {
4332 dst2[i][RCOMP] = UBYTE_TO_USHORT(src1[i][RCOMP]);
4333 dst2[i][GCOMP] = UBYTE_TO_USHORT(src1[i][GCOMP]);
4334 dst2[i][BCOMP] = UBYTE_TO_USHORT(src1[i][BCOMP]);
4335 dst2[i][ACOMP] = UBYTE_TO_USHORT(src1[i][ACOMP]);
4336 }
4337 }
4338 if (useTemp)
4339 _mesa_memcpy(dst, tempBuffer, count * 4 * sizeof(GLushort));
4340 }
4341 else {
4342 const GLubyte (*src1)[4] = (const GLubyte (*)[4]) src;
4343 GLfloat (*dst4)[4] = (GLfloat (*)[4]) (useTemp ? tempBuffer : dst);
4344 GLuint i;
4345 ASSERT(dstType == GL_FLOAT);
4346 for (i = 0; i < count; i++) {
4347 if (!mask || mask[i]) {
4348 dst4[i][RCOMP] = UBYTE_TO_FLOAT(src1[i][RCOMP]);
4349 dst4[i][GCOMP] = UBYTE_TO_FLOAT(src1[i][GCOMP]);
4350 dst4[i][BCOMP] = UBYTE_TO_FLOAT(src1[i][BCOMP]);
4351 dst4[i][ACOMP] = UBYTE_TO_FLOAT(src1[i][ACOMP]);
4352 }
4353 }
4354 if (useTemp)
4355 _mesa_memcpy(dst, tempBuffer, count * 4 * sizeof(GLfloat));
4356 }
4357 break;
4358 case GL_UNSIGNED_SHORT:
4359 if (dstType == GL_UNSIGNED_BYTE) {
4360 const GLushort (*src2)[4] = (const GLushort (*)[4]) src;
4361 GLubyte (*dst1)[4] = (GLubyte (*)[4]) (useTemp ? tempBuffer : dst);
4362 GLuint i;
4363 for (i = 0; i < count; i++) {
4364 if (!mask || mask[i]) {
4365 dst1[i][RCOMP] = USHORT_TO_UBYTE(src2[i][RCOMP]);
4366 dst1[i][GCOMP] = USHORT_TO_UBYTE(src2[i][GCOMP]);
4367 dst1[i][BCOMP] = USHORT_TO_UBYTE(src2[i][BCOMP]);
4368 dst1[i][ACOMP] = USHORT_TO_UBYTE(src2[i][ACOMP]);
4369 }
4370 }
4371 if (useTemp)
4372 _mesa_memcpy(dst, tempBuffer, count * 4 * sizeof(GLubyte));
4373 }
4374 else {
4375 const GLushort (*src2)[4] = (const GLushort (*)[4]) src;
4376 GLfloat (*dst4)[4] = (GLfloat (*)[4]) (useTemp ? tempBuffer : dst);
4377 GLuint i;
4378 ASSERT(dstType == GL_FLOAT);
4379 for (i = 0; i < count; i++) {
4380 if (!mask || mask[i]) {
4381 dst4[i][RCOMP] = USHORT_TO_FLOAT(src2[i][RCOMP]);
4382 dst4[i][GCOMP] = USHORT_TO_FLOAT(src2[i][GCOMP]);
4383 dst4[i][BCOMP] = USHORT_TO_FLOAT(src2[i][BCOMP]);
4384 dst4[i][ACOMP] = USHORT_TO_FLOAT(src2[i][ACOMP]);
4385 }
4386 }
4387 if (useTemp)
4388 _mesa_memcpy(dst, tempBuffer, count * 4 * sizeof(GLfloat));
4389 }
4390 break;
4391 case GL_FLOAT:
4392 if (dstType == GL_UNSIGNED_BYTE) {
4393 const GLfloat (*src4)[4] = (const GLfloat (*)[4]) src;
4394 GLubyte (*dst1)[4] = (GLubyte (*)[4]) (useTemp ? tempBuffer : dst);
4395 GLuint i;
4396 for (i = 0; i < count; i++) {
4397 if (!mask || mask[i]) {
4398 UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][RCOMP], src4[i][RCOMP]);
4399 UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][GCOMP], src4[i][GCOMP]);
4400 UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][BCOMP], src4[i][BCOMP]);
4401 UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][ACOMP], src4[i][ACOMP]);
4402 }
4403 }
4404 if (useTemp)
4405 _mesa_memcpy(dst, tempBuffer, count * 4 * sizeof(GLubyte));
4406 }
4407 else {
4408 const GLfloat (*src4)[4] = (const GLfloat (*)[4]) src;
4409 GLushort (*dst2)[4] = (GLushort (*)[4]) (useTemp ? tempBuffer : dst);
4410 GLuint i;
4411 ASSERT(dstType == GL_UNSIGNED_SHORT);
4412 for (i = 0; i < count; i++) {
4413 if (!mask || mask[i]) {
4414 UNCLAMPED_FLOAT_TO_USHORT(dst2[i][RCOMP], src4[i][RCOMP]);
4415 UNCLAMPED_FLOAT_TO_USHORT(dst2[i][GCOMP], src4[i][GCOMP]);
4416 UNCLAMPED_FLOAT_TO_USHORT(dst2[i][BCOMP], src4[i][BCOMP]);
4417 UNCLAMPED_FLOAT_TO_USHORT(dst2[i][ACOMP], src4[i][ACOMP]);
4418 }
4419 }
4420 if (useTemp)
4421 _mesa_memcpy(dst, tempBuffer, count * 4 * sizeof(GLushort));
4422 }
4423 break;
4424 default:
4425 _mesa_problem(NULL, "Invalid datatype in _mesa_convert_colors");
4426 }
4427 }
4428
4429
4430
4431
4432 /**
4433 * Perform basic clipping for glDrawPixels. The image's position and size
4434 * and the unpack SkipPixels and SkipRows are adjusted so that the image
4435 * region is entirely within the window and scissor bounds.
4436 * NOTE: this will only work when glPixelZoom is (1, 1) or (1, -1).
4437 * If Pixel.ZoomY is -1, *destY will be changed to be the first row which
4438 * we'll actually write. Beforehand, *destY-1 is the first drawing row.
4439 *
4440 * \return GL_TRUE if image is ready for drawing or
4441 * GL_FALSE if image was completely clipped away (draw nothing)
4442 */
4443 GLboolean
4444 _mesa_clip_drawpixels(const GLcontext *ctx,
4445 GLint *destX, GLint *destY,
4446 GLsizei *width, GLsizei *height,
4447 struct gl_pixelstore_attrib *unpack)
4448 {
4449 const GLframebuffer *buffer = ctx->DrawBuffer;
4450
4451 if (unpack->RowLength == 0) {
4452 unpack->RowLength = *width;
4453 }
4454
4455 ASSERT(ctx->Pixel.ZoomX == 1.0F);
4456 ASSERT(ctx->Pixel.ZoomY == 1.0F || ctx->Pixel.ZoomY == -1.0F);
4457
4458 /* left clipping */
4459 if (*destX < buffer->_Xmin) {
4460 unpack->SkipPixels += (buffer->_Xmin - *destX);
4461 *width -= (buffer->_Xmin - *destX);
4462 *destX = buffer->_Xmin;
4463 }
4464 /* right clipping */
4465 if (*destX + *width > buffer->_Xmax)
4466 *width -= (*destX + *width - buffer->_Xmax);
4467
4468 if (*width <= 0)
4469 return GL_FALSE;
4470
4471 if (ctx->Pixel.ZoomY == 1.0F) {
4472 /* bottom clipping */
4473 if (*destY < buffer->_Ymin) {
4474 unpack->SkipRows += (buffer->_Ymin - *destY);
4475 *height -= (buffer->_Ymin - *destY);
4476 *destY = buffer->_Ymin;
4477 }
4478 /* top clipping */
4479 if (*destY + *height > buffer->_Ymax)
4480 *height -= (*destY + *height - buffer->_Ymax);
4481 }
4482 else { /* upside down */
4483 /* top clipping */
4484 if (*destY > buffer->_Ymax) {
4485 unpack->SkipRows += (*destY - buffer->_Ymax);
4486 *height -= (*destY - buffer->_Ymax);
4487 *destY = buffer->_Ymax;
4488 }
4489 /* bottom clipping */
4490 if (*destY - *height < buffer->_Ymin)
4491 *height -= (buffer->_Ymin - (*destY - *height));
4492 /* adjust destY so it's the first row to write to */
4493 (*destY)--;
4494 }
4495
4496 if (*height <= 0)
4497 return GL_TRUE;
4498
4499 return GL_TRUE;
4500 }
4501
4502
4503 /**
4504 * Perform clipping for glReadPixels. The image's window position
4505 * and size, and the pack skipPixels, skipRows and rowLength are adjusted
4506 * so that the image region is entirely within the window bounds.
4507 * Note: this is different from _mesa_clip_drawpixels() in that the
4508 * scissor box is ignored, and we use the bounds of the current readbuffer
4509 * surface.
4510 *
4511 * \return GL_TRUE if image is ready for drawing or
4512 * GL_FALSE if image was completely clipped away (draw nothing)
4513 */
4514 GLboolean
4515 _mesa_clip_readpixels(const GLcontext *ctx,
4516 GLint *srcX, GLint *srcY,
4517 GLsizei *width, GLsizei *height,
4518 struct gl_pixelstore_attrib *pack)
4519 {
4520 const GLframebuffer *buffer = ctx->ReadBuffer;
4521
4522 if (pack->RowLength == 0) {
4523 pack->RowLength = *width;
4524 }
4525
4526 /* left clipping */
4527 if (*srcX < 0) {
4528 pack->SkipPixels += (0 - *srcX);
4529 *width -= (0 - *srcX);
4530 *srcX = 0;
4531 }
4532 /* right clipping */
4533 if (*srcX + *width > (GLsizei) buffer->Width)
4534 *width -= (*srcX + *width - buffer->Width);
4535
4536 if (*width <= 0)
4537 return GL_FALSE;
4538
4539 /* bottom clipping */
4540 if (*srcY < 0) {
4541 pack->SkipRows += (0 - *srcY);
4542 *height -= (0 - *srcY);
4543 *srcY = 0;
4544 }
4545 /* top clipping */
4546 if (*srcY + *height > (GLsizei) buffer->Height)
4547 *height -= (*srcY + *height - buffer->Height);
4548
4549 if (*height <= 0)
4550 return GL_TRUE;
4551
4552 return GL_TRUE;
4553 }
4554
4555
4556 /**
4557 * Clip the rectangle defined by (x, y, width, height) against the bounds
4558 * specified by [xmin, xmax) and [ymin, ymax).
4559 * \return GL_FALSE if rect is totally clipped, GL_TRUE otherwise.
4560 */
4561 GLboolean
4562 _mesa_clip_to_region(GLint xmin, GLint ymin,
4563 GLint xmax, GLint ymax,
4564 GLint *x, GLint *y,
4565 GLsizei *width, GLsizei *height )
4566 {
4567 /* left clipping */
4568 if (*x < xmin) {
4569 *width -= (xmin - *x);
4570 *x = xmin;
4571 }
4572
4573 /* right clipping */
4574 if (*x + *width > xmax)
4575 *width -= (*x + *width - xmax - 1);
4576
4577 if (*width <= 0)
4578 return GL_FALSE;
4579
4580 /* bottom (or top) clipping */
4581 if (*y < ymin) {
4582 *height -= (ymin - *y);
4583 *y = ymin;
4584 }
4585
4586 /* top (or bottom) clipping */
4587 if (*y + *height > ymax)
4588 *height -= (*y + *height - ymax - 1);
4589
4590 if (*height <= 0)
4591 return GL_FALSE;
4592
4593 return GL_TRUE;
4594 }