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