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