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