projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Consolidate, move, fix code related to color index and stencil image transfer
[mesa.git] / src / mesa / main / image.c
1 /*
2 * Mesa 3-D graphics library
3 * Version: 6.5.2
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, GLbitfield 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 * Apply color index shift and offset to an array of pixels.
1064 */
1065 static void
1066 shift_and_offset_ci( const GLcontext *ctx, GLuint n, GLuint indexes[] )
1067 {
1068 GLint shift = ctx->Pixel.IndexShift;
1069 GLint offset = ctx->Pixel.IndexOffset;
1070 GLuint i;
1071 if (shift > 0) {
1072 for (i=0;i<n;i++) {
1073 indexes[i] = (indexes[i] << shift) + offset;
1074 }
1075 }
1076 else if (shift < 0) {
1077 shift = -shift;
1078 for (i=0;i<n;i++) {
1079 indexes[i] = (indexes[i] >> shift) + offset;
1080 }
1081 }
1082 else {
1083 for (i=0;i<n;i++) {
1084 indexes[i] = indexes[i] + offset;
1085 }
1086 }
1087 }
1088
1089
1090
1091 /**
1092 * Apply color index shift, offset and table lookup to an array
1093 * of color indexes;
1094 */
1095 void
1096 _mesa_apply_ci_transfer_ops(const GLcontext *ctx, GLbitfield transferOps,
1097 GLuint n, GLuint indexes[])
1098 {
1099 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
1100 shift_and_offset_ci(ctx, n, indexes);
1101 }
1102 if (transferOps & IMAGE_MAP_COLOR_BIT) {
1103 const GLuint mask = ctx->Pixel.MapItoIsize - 1;
1104 GLuint i;
1105 for (i = 0; i < n; i++) {
1106 const GLuint j = indexes[i] & mask;
1107 indexes[i] = IROUND(ctx->Pixel.MapItoI[j]);
1108 }
1109 }
1110 }
1111
1112
1113 /**
1114 * Apply stencil index shift, offset and table lookup to an array
1115 * of stencil values.
1116 */
1117 void
1118 _mesa_apply_stencil_transfer_ops(const GLcontext *ctx, GLuint n,
1119 GLstencil stencil[])
1120 {
1121 if (ctx->Pixel.IndexShift != 0 || ctx->Pixel.IndexOffset != 0) {
1122 const GLint offset = ctx->Pixel.IndexOffset;
1123 GLint shift = ctx->Pixel.IndexShift;
1124 GLuint i;
1125 if (shift > 0) {
1126 for (i = 0; i < n; i++) {
1127 stencil[i] = (stencil[i] << shift) + offset;
1128 }
1129 }
1130 else if (shift < 0) {
1131 shift = -shift;
1132 for (i = 0; i < n; i++) {
1133 stencil[i] = (stencil[i] >> shift) + offset;
1134 }
1135 }
1136 else {
1137 for (i = 0; i < n; i++) {
1138 stencil[i] = stencil[i] + offset;
1139 }
1140 }
1141 }
1142 if (ctx->Pixel.MapStencilFlag) {
1143 GLuint mask = ctx->Pixel.MapStoSsize - 1;
1144 GLuint i;
1145 for (i = 0; i < n; i++) {
1146 stencil[i] = ctx->Pixel.MapStoS[ stencil[i] & mask ];
1147 }
1148 }
1149 }
1150
1151
1152 /**
1153 * Used to pack an array [][4] of RGBA float colors as specified
1154 * by the dstFormat, dstType and dstPacking. Used by glReadPixels,
1155 * glGetConvolutionFilter(), etc.
1156 * Incoming colors will be clamped to [0,1] if needed.
1157 * Note: the rgba values will be modified by this function when any pixel
1158 * transfer ops are enabled.
1159 */
1160 void
1161 _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4],
1162 GLenum dstFormat, GLenum dstType,
1163 GLvoid *dstAddr,
1164 const struct gl_pixelstore_attrib *dstPacking,
1165 GLbitfield transferOps)
1166 {
1167 GLfloat luminance[MAX_WIDTH];
1168 const GLint comps = _mesa_components_in_format(dstFormat);
1169 GLuint i;
1170
1171 if (dstType != GL_FLOAT) {
1172 /* need to clamp to [0, 1] */
1173 transferOps |= IMAGE_CLAMP_BIT;
1174 }
1175
1176 if (transferOps) {
1177 _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
1178 if ((transferOps & IMAGE_MIN_MAX_BIT) && ctx->MinMax.Sink) {
1179 return;
1180 }
1181 }
1182
1183 if (dstFormat == GL_LUMINANCE || dstFormat == GL_LUMINANCE_ALPHA) {
1184 /* compute luminance values */
1185 if (ctx->Color.ClampReadColor == GL_TRUE || dstType != GL_FLOAT) {
1186 for (i = 0; i < n; i++) {
1187 GLfloat sum = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
1188 luminance[i] = CLAMP(sum, 0.0F, 1.0F);
1189 }
1190 }
1191 else {
1192 for (i = 0; i < n; i++) {
1193 luminance[i] = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
1194 }
1195 }
1196 }
1197
1198 /*
1199 * Pack/store the pixels. Ugh! Lots of cases!!!
1200 */
1201 switch (dstType) {
1202 case GL_UNSIGNED_BYTE:
1203 {
1204 GLubyte *dst = (GLubyte *) dstAddr;
1205 switch (dstFormat) {
1206 case GL_RED:
1207 for (i=0;i<n;i++)
1208 dst[i] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
1209 break;
1210 case GL_GREEN:
1211 for (i=0;i<n;i++)
1212 dst[i] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
1213 break;
1214 case GL_BLUE:
1215 for (i=0;i<n;i++)
1216 dst[i] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
1217 break;
1218 case GL_ALPHA:
1219 for (i=0;i<n;i++)
1220 dst[i] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
1221 break;
1222 case GL_LUMINANCE:
1223 for (i=0;i<n;i++)
1224 dst[i] = FLOAT_TO_UBYTE(luminance[i]);
1225 break;
1226 case GL_LUMINANCE_ALPHA:
1227 for (i=0;i<n;i++) {
1228 dst[i*2+0] = FLOAT_TO_UBYTE(luminance[i]);
1229 dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
1230 }
1231 break;
1232 case GL_RGB:
1233 for (i=0;i<n;i++) {
1234 dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
1235 dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
1236 dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
1237 }
1238 break;
1239 case GL_RGBA:
1240 for (i=0;i<n;i++) {
1241 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
1242 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
1243 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
1244 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
1245 }
1246 break;
1247 case GL_BGR:
1248 for (i=0;i<n;i++) {
1249 dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
1250 dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
1251 dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
1252 }
1253 break;
1254 case GL_BGRA:
1255 for (i=0;i<n;i++) {
1256 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
1257 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
1258 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
1259 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
1260 }
1261 break;
1262 case GL_ABGR_EXT:
1263 for (i=0;i<n;i++) {
1264 dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
1265 dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
1266 dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
1267 dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
1268 }
1269 break;
1270 default:
1271 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1272 }
1273 }
1274 break;
1275 case GL_BYTE:
1276 {
1277 GLbyte *dst = (GLbyte *) dstAddr;
1278 switch (dstFormat) {
1279 case GL_RED:
1280 for (i=0;i<n;i++)
1281 dst[i] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
1282 break;
1283 case GL_GREEN:
1284 for (i=0;i<n;i++)
1285 dst[i] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
1286 break;
1287 case GL_BLUE:
1288 for (i=0;i<n;i++)
1289 dst[i] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
1290 break;
1291 case GL_ALPHA:
1292 for (i=0;i<n;i++)
1293 dst[i] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
1294 break;
1295 case GL_LUMINANCE:
1296 for (i=0;i<n;i++)
1297 dst[i] = FLOAT_TO_BYTE(luminance[i]);
1298 break;
1299 case GL_LUMINANCE_ALPHA:
1300 for (i=0;i<n;i++) {
1301 dst[i*2+0] = FLOAT_TO_BYTE(luminance[i]);
1302 dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
1303 }
1304 break;
1305 case GL_RGB:
1306 for (i=0;i<n;i++) {
1307 dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
1308 dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
1309 dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
1310 }
1311 break;
1312 case GL_RGBA:
1313 for (i=0;i<n;i++) {
1314 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
1315 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
1316 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
1317 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
1318 }
1319 break;
1320 case GL_BGR:
1321 for (i=0;i<n;i++) {
1322 dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
1323 dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
1324 dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
1325 }
1326 break;
1327 case GL_BGRA:
1328 for (i=0;i<n;i++) {
1329 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
1330 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
1331 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
1332 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
1333 }
1334 case GL_ABGR_EXT:
1335 for (i=0;i<n;i++) {
1336 dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
1337 dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
1338 dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
1339 dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
1340 }
1341 break;
1342 default:
1343 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1344 }
1345 }
1346 break;
1347 case GL_UNSIGNED_SHORT:
1348 {
1349 GLushort *dst = (GLushort *) dstAddr;
1350 switch (dstFormat) {
1351 case GL_RED:
1352 for (i=0;i<n;i++)
1353 CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][RCOMP]);
1354 break;
1355 case GL_GREEN:
1356 for (i=0;i<n;i++)
1357 CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][GCOMP]);
1358 break;
1359 case GL_BLUE:
1360 for (i=0;i<n;i++)
1361 CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][BCOMP]);
1362 break;
1363 case GL_ALPHA:
1364 for (i=0;i<n;i++)
1365 CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][ACOMP]);
1366 break;
1367 case GL_LUMINANCE:
1368 for (i=0;i<n;i++)
1369 UNCLAMPED_FLOAT_TO_USHORT(dst[i], luminance[i]);
1370 break;
1371 case GL_LUMINANCE_ALPHA:
1372 for (i=0;i<n;i++) {
1373 UNCLAMPED_FLOAT_TO_USHORT(dst[i*2+0], luminance[i]);
1374 CLAMPED_FLOAT_TO_USHORT(dst[i*2+1], rgba[i][ACOMP]);
1375 }
1376 break;
1377 case GL_RGB:
1378 for (i=0;i<n;i++) {
1379 CLAMPED_FLOAT_TO_USHORT(dst[i*3+0], rgba[i][RCOMP]);
1380 CLAMPED_FLOAT_TO_USHORT(dst[i*3+1], rgba[i][GCOMP]);
1381 CLAMPED_FLOAT_TO_USHORT(dst[i*3+2], rgba[i][BCOMP]);
1382 }
1383 break;
1384 case GL_RGBA:
1385 for (i=0;i<n;i++) {
1386 CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][RCOMP]);
1387 CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][GCOMP]);
1388 CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][BCOMP]);
1389 CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][ACOMP]);
1390 }
1391 break;
1392 case GL_BGR:
1393 for (i=0;i<n;i++) {
1394 CLAMPED_FLOAT_TO_USHORT(dst[i*3+0], rgba[i][BCOMP]);
1395 CLAMPED_FLOAT_TO_USHORT(dst[i*3+1], rgba[i][GCOMP]);
1396 CLAMPED_FLOAT_TO_USHORT(dst[i*3+2], rgba[i][RCOMP]);
1397 }
1398 break;
1399 case GL_BGRA:
1400 for (i=0;i<n;i++) {
1401 CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][BCOMP]);
1402 CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][GCOMP]);
1403 CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][RCOMP]);
1404 CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][ACOMP]);
1405 }
1406 break;
1407 case GL_ABGR_EXT:
1408 for (i=0;i<n;i++) {
1409 CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][ACOMP]);
1410 CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][BCOMP]);
1411 CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][GCOMP]);
1412 CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][RCOMP]);
1413 }
1414 break;
1415 default:
1416 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1417 }
1418 if (dstPacking->SwapBytes) {
1419 _mesa_swap2( (GLushort *) dst, n * comps);
1420 }
1421 }
1422 break;
1423 case GL_SHORT:
1424 {
1425 GLshort *dst = (GLshort *) dstAddr;
1426 switch (dstFormat) {
1427 case GL_RED:
1428 for (i=0;i<n;i++)
1429 dst[i] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1430 break;
1431 case GL_GREEN:
1432 for (i=0;i<n;i++)
1433 dst[i] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1434 break;
1435 case GL_BLUE:
1436 for (i=0;i<n;i++)
1437 dst[i] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1438 break;
1439 case GL_ALPHA:
1440 for (i=0;i<n;i++)
1441 dst[i] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1442 break;
1443 case GL_LUMINANCE:
1444 for (i=0;i<n;i++)
1445 dst[i] = FLOAT_TO_SHORT(luminance[i]);
1446 break;
1447 case GL_LUMINANCE_ALPHA:
1448 for (i=0;i<n;i++) {
1449 dst[i*2+0] = FLOAT_TO_SHORT(luminance[i]);
1450 dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1451 }
1452 break;
1453 case GL_RGB:
1454 for (i=0;i<n;i++) {
1455 dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1456 dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1457 dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1458 }
1459 break;
1460 case GL_RGBA:
1461 for (i=0;i<n;i++) {
1462 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1463 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1464 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1465 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1466 }
1467 break;
1468 case GL_BGR:
1469 for (i=0;i<n;i++) {
1470 dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1471 dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1472 dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1473 }
1474 break;
1475 case GL_BGRA:
1476 for (i=0;i<n;i++) {
1477 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1478 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1479 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1480 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1481 }
1482 case GL_ABGR_EXT:
1483 for (i=0;i<n;i++) {
1484 dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1485 dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1486 dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1487 dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1488 }
1489 break;
1490 default:
1491 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1492 }
1493 if (dstPacking->SwapBytes) {
1494 _mesa_swap2( (GLushort *) dst, n * comps );
1495 }
1496 }
1497 break;
1498 case GL_UNSIGNED_INT:
1499 {
1500 GLuint *dst = (GLuint *) dstAddr;
1501 switch (dstFormat) {
1502 case GL_RED:
1503 for (i=0;i<n;i++)
1504 dst[i] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1505 break;
1506 case GL_GREEN:
1507 for (i=0;i<n;i++)
1508 dst[i] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1509 break;
1510 case GL_BLUE:
1511 for (i=0;i<n;i++)
1512 dst[i] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1513 break;
1514 case GL_ALPHA:
1515 for (i=0;i<n;i++)
1516 dst[i] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1517 break;
1518 case GL_LUMINANCE:
1519 for (i=0;i<n;i++)
1520 dst[i] = FLOAT_TO_UINT(luminance[i]);
1521 break;
1522 case GL_LUMINANCE_ALPHA:
1523 for (i=0;i<n;i++) {
1524 dst[i*2+0] = FLOAT_TO_UINT(luminance[i]);
1525 dst[i*2+1] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1526 }
1527 break;
1528 case GL_RGB:
1529 for (i=0;i<n;i++) {
1530 dst[i*3+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1531 dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1532 dst[i*3+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1533 }
1534 break;
1535 case GL_RGBA:
1536 for (i=0;i<n;i++) {
1537 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1538 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1539 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1540 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1541 }
1542 break;
1543 case GL_BGR:
1544 for (i=0;i<n;i++) {
1545 dst[i*3+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1546 dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1547 dst[i*3+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1548 }
1549 break;
1550 case GL_BGRA:
1551 for (i=0;i<n;i++) {
1552 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1553 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1554 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1555 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1556 }
1557 break;
1558 case GL_ABGR_EXT:
1559 for (i=0;i<n;i++) {
1560 dst[i*4+0] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1561 dst[i*4+1] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1562 dst[i*4+2] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1563 dst[i*4+3] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1564 }
1565 break;
1566 default:
1567 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1568 }
1569 if (dstPacking->SwapBytes) {
1570 _mesa_swap4( (GLuint *) dst, n * comps );
1571 }
1572 }
1573 break;
1574 case GL_INT:
1575 {
1576 GLint *dst = (GLint *) dstAddr;
1577 switch (dstFormat) {
1578 case GL_RED:
1579 for (i=0;i<n;i++)
1580 dst[i] = FLOAT_TO_INT(rgba[i][RCOMP]);
1581 break;
1582 case GL_GREEN:
1583 for (i=0;i<n;i++)
1584 dst[i] = FLOAT_TO_INT(rgba[i][GCOMP]);
1585 break;
1586 case GL_BLUE:
1587 for (i=0;i<n;i++)
1588 dst[i] = FLOAT_TO_INT(rgba[i][BCOMP]);
1589 break;
1590 case GL_ALPHA:
1591 for (i=0;i<n;i++)
1592 dst[i] = FLOAT_TO_INT(rgba[i][ACOMP]);
1593 break;
1594 case GL_LUMINANCE:
1595 for (i=0;i<n;i++)
1596 dst[i] = FLOAT_TO_INT(luminance[i]);
1597 break;
1598 case GL_LUMINANCE_ALPHA:
1599 for (i=0;i<n;i++) {
1600 dst[i*2+0] = FLOAT_TO_INT(luminance[i]);
1601 dst[i*2+1] = FLOAT_TO_INT(rgba[i][ACOMP]);
1602 }
1603 break;
1604 case GL_RGB:
1605 for (i=0;i<n;i++) {
1606 dst[i*3+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
1607 dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1608 dst[i*3+2] = FLOAT_TO_INT(rgba[i][BCOMP]);
1609 }
1610 break;
1611 case GL_RGBA:
1612 for (i=0;i<n;i++) {
1613 dst[i*4+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
1614 dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1615 dst[i*4+2] = FLOAT_TO_INT(rgba[i][BCOMP]);
1616 dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);
1617 }
1618 break;
1619 case GL_BGR:
1620 for (i=0;i<n;i++) {
1621 dst[i*3+0] = FLOAT_TO_INT(rgba[i][BCOMP]);
1622 dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1623 dst[i*3+2] = FLOAT_TO_INT(rgba[i][RCOMP]);
1624 }
1625 break;
1626 case GL_BGRA:
1627 for (i=0;i<n;i++) {
1628 dst[i*4+0] = FLOAT_TO_INT(rgba[i][BCOMP]);
1629 dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1630 dst[i*4+2] = FLOAT_TO_INT(rgba[i][RCOMP]);
1631 dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);
1632 }
1633 break;
1634 case GL_ABGR_EXT:
1635 for (i=0;i<n;i++) {
1636 dst[i*4+0] = FLOAT_TO_INT(rgba[i][ACOMP]);
1637 dst[i*4+1] = FLOAT_TO_INT(rgba[i][BCOMP]);
1638 dst[i*4+2] = FLOAT_TO_INT(rgba[i][GCOMP]);
1639 dst[i*4+3] = FLOAT_TO_INT(rgba[i][RCOMP]);
1640 }
1641 break;
1642 default:
1643 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1644 }
1645 if (dstPacking->SwapBytes) {
1646 _mesa_swap4( (GLuint *) dst, n * comps );
1647 }
1648 }
1649 break;
1650 case GL_FLOAT:
1651 {
1652 GLfloat *dst = (GLfloat *) dstAddr;
1653 switch (dstFormat) {
1654 case GL_RED:
1655 for (i=0;i<n;i++)
1656 dst[i] = rgba[i][RCOMP];
1657 break;
1658 case GL_GREEN:
1659 for (i=0;i<n;i++)
1660 dst[i] = rgba[i][GCOMP];
1661 break;
1662 case GL_BLUE:
1663 for (i=0;i<n;i++)
1664 dst[i] = rgba[i][BCOMP];
1665 break;
1666 case GL_ALPHA:
1667 for (i=0;i<n;i++)
1668 dst[i] = rgba[i][ACOMP];
1669 break;
1670 case GL_LUMINANCE:
1671 for (i=0;i<n;i++)
1672 dst[i] = luminance[i];
1673 break;
1674 case GL_LUMINANCE_ALPHA:
1675 for (i=0;i<n;i++) {
1676 dst[i*2+0] = luminance[i];
1677 dst[i*2+1] = rgba[i][ACOMP];
1678 }
1679 break;
1680 case GL_RGB:
1681 for (i=0;i<n;i++) {
1682 dst[i*3+0] = rgba[i][RCOMP];
1683 dst[i*3+1] = rgba[i][GCOMP];
1684 dst[i*3+2] = rgba[i][BCOMP];
1685 }
1686 break;
1687 case GL_RGBA:
1688 for (i=0;i<n;i++) {
1689 dst[i*4+0] = rgba[i][RCOMP];
1690 dst[i*4+1] = rgba[i][GCOMP];
1691 dst[i*4+2] = rgba[i][BCOMP];
1692 dst[i*4+3] = rgba[i][ACOMP];
1693 }
1694 break;
1695 case GL_BGR:
1696 for (i=0;i<n;i++) {
1697 dst[i*3+0] = rgba[i][BCOMP];
1698 dst[i*3+1] = rgba[i][GCOMP];
1699 dst[i*3+2] = rgba[i][RCOMP];
1700 }
1701 break;
1702 case GL_BGRA:
1703 for (i=0;i<n;i++) {
1704 dst[i*4+0] = rgba[i][BCOMP];
1705 dst[i*4+1] = rgba[i][GCOMP];
1706 dst[i*4+2] = rgba[i][RCOMP];
1707 dst[i*4+3] = rgba[i][ACOMP];
1708 }
1709 break;
1710 case GL_ABGR_EXT:
1711 for (i=0;i<n;i++) {
1712 dst[i*4+0] = rgba[i][ACOMP];
1713 dst[i*4+1] = rgba[i][BCOMP];
1714 dst[i*4+2] = rgba[i][GCOMP];
1715 dst[i*4+3] = rgba[i][RCOMP];
1716 }
1717 break;
1718 default:
1719 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1720 }
1721 if (dstPacking->SwapBytes) {
1722 _mesa_swap4( (GLuint *) dst, n * comps );
1723 }
1724 }
1725 break;
1726 case GL_HALF_FLOAT_ARB:
1727 {
1728 GLhalfARB *dst = (GLhalfARB *) dstAddr;
1729 switch (dstFormat) {
1730 case GL_RED:
1731 for (i=0;i<n;i++)
1732 dst[i] = _mesa_float_to_half(rgba[i][RCOMP]);
1733 break;
1734 case GL_GREEN:
1735 for (i=0;i<n;i++)
1736 dst[i] = _mesa_float_to_half(rgba[i][GCOMP]);
1737 break;
1738 case GL_BLUE:
1739 for (i=0;i<n;i++)
1740 dst[i] = _mesa_float_to_half(rgba[i][BCOMP]);
1741 break;
1742 case GL_ALPHA:
1743 for (i=0;i<n;i++)
1744 dst[i] = _mesa_float_to_half(rgba[i][ACOMP]);
1745 break;
1746 case GL_LUMINANCE:
1747 for (i=0;i<n;i++)
1748 dst[i] = _mesa_float_to_half(luminance[i]);
1749 break;
1750 case GL_LUMINANCE_ALPHA:
1751 for (i=0;i<n;i++) {
1752 dst[i*2+0] = _mesa_float_to_half(luminance[i]);
1753 dst[i*2+1] = _mesa_float_to_half(rgba[i][ACOMP]);
1754 }
1755 break;
1756 case GL_RGB:
1757 for (i=0;i<n;i++) {
1758 dst[i*3+0] = _mesa_float_to_half(rgba[i][RCOMP]);
1759 dst[i*3+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1760 dst[i*3+2] = _mesa_float_to_half(rgba[i][BCOMP]);
1761 }
1762 break;
1763 case GL_RGBA:
1764 for (i=0;i<n;i++) {
1765 dst[i*4+0] = _mesa_float_to_half(rgba[i][RCOMP]);
1766 dst[i*4+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1767 dst[i*4+2] = _mesa_float_to_half(rgba[i][BCOMP]);
1768 dst[i*4+3] = _mesa_float_to_half(rgba[i][ACOMP]);
1769 }
1770 break;
1771 case GL_BGR:
1772 for (i=0;i<n;i++) {
1773 dst[i*3+0] = _mesa_float_to_half(rgba[i][BCOMP]);
1774 dst[i*3+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1775 dst[i*3+2] = _mesa_float_to_half(rgba[i][RCOMP]);
1776 }
1777 break;
1778 case GL_BGRA:
1779 for (i=0;i<n;i++) {
1780 dst[i*4+0] = _mesa_float_to_half(rgba[i][BCOMP]);
1781 dst[i*4+1] = _mesa_float_to_half(rgba[i][GCOMP]);
1782 dst[i*4+2] = _mesa_float_to_half(rgba[i][RCOMP]);
1783 dst[i*4+3] = _mesa_float_to_half(rgba[i][ACOMP]);
1784 }
1785 break;
1786 case GL_ABGR_EXT:
1787 for (i=0;i<n;i++) {
1788 dst[i*4+0] = _mesa_float_to_half(rgba[i][ACOMP]);
1789 dst[i*4+1] = _mesa_float_to_half(rgba[i][BCOMP]);
1790 dst[i*4+2] = _mesa_float_to_half(rgba[i][GCOMP]);
1791 dst[i*4+3] = _mesa_float_to_half(rgba[i][RCOMP]);
1792 }
1793 break;
1794 default:
1795 _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1796 }
1797 if (dstPacking->SwapBytes) {
1798 _mesa_swap2( (GLushort *) dst, n * comps );
1799 }
1800 }
1801 break;
1802 case GL_UNSIGNED_BYTE_3_3_2:
1803 if (dstFormat == GL_RGB) {
1804 GLubyte *dst = (GLubyte *) dstAddr;
1805 for (i=0;i<n;i++) {
1806 dst[i] = (((GLint) (rgba[i][RCOMP] * 7.0F)) << 5)
1807 | (((GLint) (rgba[i][GCOMP] * 7.0F)) << 2)
1808 | (((GLint) (rgba[i][BCOMP] * 3.0F)) );
1809 }
1810 }
1811 break;
1812 case GL_UNSIGNED_BYTE_2_3_3_REV:
1813 if (dstFormat == GL_RGB) {
1814 GLubyte *dst = (GLubyte *) dstAddr;
1815 for (i=0;i<n;i++) {
1816 dst[i] = (((GLint) (rgba[i][RCOMP] * 7.0F)) )
1817 | (((GLint) (rgba[i][GCOMP] * 7.0F)) << 3)
1818 | (((GLint) (rgba[i][BCOMP] * 3.0F)) << 5);
1819 }
1820 }
1821 break;
1822 case GL_UNSIGNED_SHORT_5_6_5:
1823 if (dstFormat == GL_RGB) {
1824 GLushort *dst = (GLushort *) dstAddr;
1825 for (i=0;i<n;i++) {
1826 dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) << 11)
1827 | (((GLint) (rgba[i][GCOMP] * 63.0F)) << 5)
1828 | (((GLint) (rgba[i][BCOMP] * 31.0F)) );
1829 }
1830 }
1831 break;
1832 case GL_UNSIGNED_SHORT_5_6_5_REV:
1833 if (dstFormat == GL_RGB) {
1834 GLushort *dst = (GLushort *) dstAddr;
1835 for (i=0;i<n;i++) {
1836 dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) )
1837 | (((GLint) (rgba[i][GCOMP] * 63.0F)) << 5)
1838 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 11);
1839 }
1840 }
1841 break;
1842 case GL_UNSIGNED_SHORT_4_4_4_4:
1843 if (dstFormat == GL_RGBA) {
1844 GLushort *dst = (GLushort *) dstAddr;
1845 for (i=0;i<n;i++) {
1846 dst[i] = (((GLint) (rgba[i][RCOMP] * 15.0F)) << 12)
1847 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 8)
1848 | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 4)
1849 | (((GLint) (rgba[i][ACOMP] * 15.0F)) );
1850 }
1851 }
1852 else if (dstFormat == GL_BGRA) {
1853 GLushort *dst = (GLushort *) dstAddr;
1854 for (i=0;i<n;i++) {
1855 dst[i] = (((GLint) (rgba[i][BCOMP] * 15.0F)) << 12)
1856 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 8)
1857 | (((GLint) (rgba[i][RCOMP] * 15.0F)) << 4)
1858 | (((GLint) (rgba[i][ACOMP] * 15.0F)) );
1859 }
1860 }
1861 else if (dstFormat == GL_ABGR_EXT) {
1862 GLushort *dst = (GLushort *) dstAddr;
1863 for (i=0;i<n;i++) {
1864 dst[i] = (((GLint) (rgba[i][ACOMP] * 15.0F)) << 4)
1865 | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 8)
1866 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 12)
1867 | (((GLint) (rgba[i][RCOMP] * 15.0F)) );
1868 }
1869 }
1870 break;
1871 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1872 if (dstFormat == GL_RGBA) {
1873 GLushort *dst = (GLushort *) dstAddr;
1874 for (i=0;i<n;i++) {
1875 dst[i] = (((GLint) (rgba[i][RCOMP] * 15.0F)) )
1876 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 4)
1877 | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 8)
1878 | (((GLint) (rgba[i][ACOMP] * 15.0F)) << 12);
1879 }
1880 }
1881 else if (dstFormat == GL_BGRA) {
1882 GLushort *dst = (GLushort *) dstAddr;
1883 for (i=0;i<n;i++) {
1884 dst[i] = (((GLint) (rgba[i][BCOMP] * 15.0F)) )
1885 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 4)
1886 | (((GLint) (rgba[i][RCOMP] * 15.0F)) << 8)
1887 | (((GLint) (rgba[i][ACOMP] * 15.0F)) << 12);
1888 }
1889 }
1890 else if (dstFormat == GL_ABGR_EXT) {
1891 GLushort *dst = (GLushort *) dstAddr;
1892 for (i=0;i<n;i++) {
1893 dst[i] = (((GLint) (rgba[i][ACOMP] * 15.0F)) )
1894 | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 4)
1895 | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 8)
1896 | (((GLint) (rgba[i][RCOMP] * 15.0F)) << 12);
1897 }
1898 }
1899 break;
1900 case GL_UNSIGNED_SHORT_5_5_5_1:
1901 if (dstFormat == GL_RGBA) {
1902 GLushort *dst = (GLushort *) dstAddr;
1903 for (i=0;i<n;i++) {
1904 dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) << 11)
1905 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 6)
1906 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 1)
1907 | (((GLint) (rgba[i][ACOMP] * 1.0F)) );
1908 }
1909 }
1910 else if (dstFormat == GL_BGRA) {
1911 GLushort *dst = (GLushort *) dstAddr;
1912 for (i=0;i<n;i++) {
1913 dst[i] = (((GLint) (rgba[i][BCOMP] * 31.0F)) << 11)
1914 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 6)
1915 | (((GLint) (rgba[i][RCOMP] * 31.0F)) << 1)
1916 | (((GLint) (rgba[i][ACOMP] * 1.0F)) );
1917 }
1918 }
1919 else if (dstFormat == GL_ABGR_EXT) {
1920 GLushort *dst = (GLushort *) dstAddr;
1921 for (i=0;i<n;i++) {
1922 dst[i] = (((GLint) (rgba[i][ACOMP] * 31.0F)) << 11)
1923 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 6)
1924 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 1)
1925 | (((GLint) (rgba[i][RCOMP] * 1.0F)) );
1926 }
1927 }
1928 break;
1929 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1930 if (dstFormat == GL_RGBA) {
1931 GLushort *dst = (GLushort *) dstAddr;
1932 for (i=0;i<n;i++) {
1933 dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) )
1934 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 5)
1935 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 10)
1936 | (((GLint) (rgba[i][ACOMP] * 1.0F)) << 15);
1937 }
1938 }
1939 else if (dstFormat == GL_BGRA) {
1940 GLushort *dst = (GLushort *) dstAddr;
1941 for (i=0;i<n;i++) {
1942 dst[i] = (((GLint) (rgba[i][BCOMP] * 31.0F)) )
1943 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 5)
1944 | (((GLint) (rgba[i][RCOMP] * 31.0F)) << 10)
1945 | (((GLint) (rgba[i][ACOMP] * 1.0F)) << 15);
1946 }
1947 }
1948 else if (dstFormat == GL_ABGR_EXT) {
1949 GLushort *dst = (GLushort *) dstAddr;
1950 for (i=0;i<n;i++) {
1951 dst[i] = (((GLint) (rgba[i][ACOMP] * 31.0F)) )
1952 | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 5)
1953 | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 10)
1954 | (((GLint) (rgba[i][RCOMP] * 1.0F)) << 15);
1955 }
1956 }
1957 break;
1958 case GL_UNSIGNED_INT_8_8_8_8:
1959 if (dstFormat == GL_RGBA) {
1960 GLuint *dst = (GLuint *) dstAddr;
1961 for (i=0;i<n;i++) {
1962 dst[i] = (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 24)
1963 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16)
1964 | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 8)
1965 | (((GLuint) (rgba[i][ACOMP] * 255.0F)) );
1966 }
1967 }
1968 else if (dstFormat == GL_BGRA) {
1969 GLuint *dst = (GLuint *) dstAddr;
1970 for (i=0;i<n;i++) {
1971 dst[i] = (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 24)
1972 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16)
1973 | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 8)
1974 | (((GLuint) (rgba[i][ACOMP] * 255.0F)) );
1975 }
1976 }
1977 else if (dstFormat == GL_ABGR_EXT) {
1978 GLuint *dst = (GLuint *) dstAddr;
1979 for (i=0;i<n;i++) {
1980 dst[i] = (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24)
1981 | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 16)
1982 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 8)
1983 | (((GLuint) (rgba[i][RCOMP] * 255.0F)) );
1984 }
1985 }
1986 break;
1987 case GL_UNSIGNED_INT_8_8_8_8_REV:
1988 if (dstFormat == GL_RGBA) {
1989 GLuint *dst = (GLuint *) dstAddr;
1990 for (i=0;i<n;i++) {
1991 dst[i] = (((GLuint) (rgba[i][RCOMP] * 255.0F)) )
1992 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 8)
1993 | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 16)
1994 | (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24);
1995 }
1996 }
1997 else if (dstFormat == GL_BGRA) {
1998 GLuint *dst = (GLuint *) dstAddr;
1999 for (i=0;i<n;i++) {
2000 dst[i] = (((GLuint) (rgba[i][BCOMP] * 255.0F)) )
2001 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 8)
2002 | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 16)
2003 | (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24);
2004 }
2005 }
2006 else if (dstFormat == GL_ABGR_EXT) {
2007 GLuint *dst = (GLuint *) dstAddr;
2008 for (i=0;i<n;i++) {
2009 dst[i] = (((GLuint) (rgba[i][ACOMP] * 255.0F)) )
2010 | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 8)
2011 | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16)
2012 | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 24);
2013 }
2014 }
2015 break;
2016 case GL_UNSIGNED_INT_10_10_10_2:
2017 if (dstFormat == GL_RGBA) {
2018 GLuint *dst = (GLuint *) dstAddr;
2019 for (i=0;i<n;i++) {
2020 dst[i] = (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 22)
2021 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 12)
2022 | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 2)
2023 | (((GLuint) (rgba[i][ACOMP] * 3.0F)) );
2024 }
2025 }
2026 else if (dstFormat == GL_BGRA) {
2027 GLuint *dst = (GLuint *) dstAddr;
2028 for (i=0;i<n;i++) {
2029 dst[i] = (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 22)
2030 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 12)
2031 | (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 2)
2032 | (((GLuint) (rgba[i][ACOMP] * 3.0F)) );
2033 }
2034 }
2035 else if (dstFormat == GL_ABGR_EXT) {
2036 GLuint *dst = (GLuint *) dstAddr;
2037 for (i=0;i<n;i++) {
2038 dst[i] = (((GLuint) (rgba[i][ACOMP] * 1023.0F)) << 22)
2039 | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 12)
2040 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 2)
2041 | (((GLuint) (rgba[i][RCOMP] * 3.0F)) );
2042 }
2043 }
2044 break;
2045 case GL_UNSIGNED_INT_2_10_10_10_REV:
2046 if (dstFormat == GL_RGBA) {
2047 GLuint *dst = (GLuint *) dstAddr;
2048 for (i=0;i<n;i++) {
2049 dst[i] = (((GLuint) (rgba[i][RCOMP] * 1023.0F)) )
2050 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 10)
2051 | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 20)
2052 | (((GLuint) (rgba[i][ACOMP] * 3.0F)) << 30);
2053 }
2054 }
2055 else if (dstFormat == GL_BGRA) {
2056 GLuint *dst = (GLuint *) dstAddr;
2057 for (i=0;i<n;i++) {
2058 dst[i] = (((GLuint) (rgba[i][BCOMP] * 1023.0F)) )
2059 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 10)
2060 | (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 20)
2061 | (((GLuint) (rgba[i][ACOMP] * 3.0F)) << 30);
2062 }
2063 }
2064 else if (dstFormat == GL_ABGR_EXT) {
2065 GLuint *dst = (GLuint *) dstAddr;
2066 for (i=0;i<n;i++) {
2067 dst[i] = (((GLuint) (rgba[i][ACOMP] * 1023.0F)) )
2068 | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 10)
2069 | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 20)
2070 | (((GLuint) (rgba[i][RCOMP] * 3.0F)) << 30);
2071 }
2072 }
2073 break;
2074 default:
2075 _mesa_problem(ctx, "bad type in _mesa_pack_rgba_span_float");
2076 }
2077 }
2078
2079
2080 #define SWAP2BYTE(VALUE) \
2081 { \
2082 GLubyte *bytes = (GLubyte *) &(VALUE); \
2083 GLubyte tmp = bytes[0]; \
2084 bytes[0] = bytes[1]; \
2085 bytes[1] = tmp; \
2086 }
2087
2088 #define SWAP4BYTE(VALUE) \
2089 { \
2090 GLubyte *bytes = (GLubyte *) &(VALUE); \
2091 GLubyte tmp = bytes[0]; \
2092 bytes[0] = bytes[3]; \
2093 bytes[3] = tmp; \
2094 tmp = bytes[1]; \
2095 bytes[1] = bytes[2]; \
2096 bytes[2] = tmp; \
2097 }
2098
2099
2100 static void
2101 extract_uint_indexes(GLuint n, GLuint indexes[],
2102 GLenum srcFormat, GLenum srcType, const GLvoid *src,
2103 const struct gl_pixelstore_attrib *unpack )
2104 {
2105 ASSERT(srcFormat == GL_COLOR_INDEX || srcFormat == GL_STENCIL_INDEX);
2106
2107 ASSERT(srcType == GL_BITMAP ||
2108 srcType == GL_UNSIGNED_BYTE ||
2109 srcType == GL_BYTE ||
2110 srcType == GL_UNSIGNED_SHORT ||
2111 srcType == GL_SHORT ||
2112 srcType == GL_UNSIGNED_INT ||
2113 srcType == GL_INT ||
2114 srcType == GL_UNSIGNED_INT_24_8_EXT ||
2115 srcType == GL_HALF_FLOAT_ARB ||
2116 srcType == GL_FLOAT);
2117
2118 switch (srcType) {
2119 case GL_BITMAP:
2120 {
2121 GLubyte *ubsrc = (GLubyte *) src;
2122 if (unpack->LsbFirst) {
2123 GLubyte mask = 1 << (unpack->SkipPixels & 0x7);
2124 GLuint i;
2125 for (i = 0; i < n; i++) {
2126 indexes[i] = (*ubsrc & mask) ? 1 : 0;
2127 if (mask == 128) {
2128 mask = 1;
2129 ubsrc++;
2130 }
2131 else {
2132 mask = mask << 1;
2133 }
2134 }
2135 }
2136 else {
2137 GLubyte mask = 128 >> (unpack->SkipPixels & 0x7);
2138 GLuint i;
2139 for (i = 0; i < n; i++) {
2140 indexes[i] = (*ubsrc & mask) ? 1 : 0;
2141 if (mask == 1) {
2142 mask = 128;
2143 ubsrc++;
2144 }
2145 else {
2146 mask = mask >> 1;
2147 }
2148 }
2149 }
2150 }
2151 break;
2152 case GL_UNSIGNED_BYTE:
2153 {
2154 GLuint i;
2155 const GLubyte *s = (const GLubyte *) src;
2156 for (i = 0; i < n; i++)
2157 indexes[i] = s[i];
2158 }
2159 break;
2160 case GL_BYTE:
2161 {
2162 GLuint i;
2163 const GLbyte *s = (const GLbyte *) src;
2164 for (i = 0; i < n; i++)
2165 indexes[i] = s[i];
2166 }
2167 break;
2168 case GL_UNSIGNED_SHORT:
2169 {
2170 GLuint i;
2171 const GLushort *s = (const GLushort *) src;
2172 if (unpack->SwapBytes) {
2173 for (i = 0; i < n; i++) {
2174 GLushort value = s[i];
2175 SWAP2BYTE(value);
2176 indexes[i] = value;
2177 }
2178 }
2179 else {
2180 for (i = 0; i < n; i++)
2181 indexes[i] = s[i];
2182 }
2183 }
2184 break;
2185 case GL_SHORT:
2186 {
2187 GLuint i;
2188 const GLshort *s = (const GLshort *) src;
2189 if (unpack->SwapBytes) {
2190 for (i = 0; i < n; i++) {
2191 GLshort value = s[i];
2192 SWAP2BYTE(value);
2193 indexes[i] = value;
2194 }
2195 }
2196 else {
2197 for (i = 0; i < n; i++)
2198 indexes[i] = s[i];
2199 }
2200 }
2201 break;
2202 case GL_UNSIGNED_INT:
2203 {
2204 GLuint i;
2205 const GLuint *s = (const GLuint *) src;
2206 if (unpack->SwapBytes) {
2207 for (i = 0; i < n; i++) {
2208 GLuint value = s[i];
2209 SWAP4BYTE(value);
2210 indexes[i] = value;
2211 }
2212 }
2213 else {
2214 for (i = 0; i < n; i++)
2215 indexes[i] = s[i];
2216 }
2217 }
2218 break;
2219 case GL_INT:
2220 {
2221 GLuint i;
2222 const GLint *s = (const GLint *) src;
2223 if (unpack->SwapBytes) {
2224 for (i = 0; i < n; i++) {
2225 GLint value = s[i];
2226 SWAP4BYTE(value);
2227 indexes[i] = value;
2228 }
2229 }
2230 else {
2231 for (i = 0; i < n; i++)
2232 indexes[i] = s[i];
2233 }
2234 }
2235 break;
2236 case GL_FLOAT:
2237 {
2238 GLuint i;
2239 const GLfloat *s = (const GLfloat *) src;
2240 if (unpack->SwapBytes) {
2241 for (i = 0; i < n; i++) {
2242 GLfloat value = s[i];
2243 SWAP4BYTE(value);
2244 indexes[i] = (GLuint) value;
2245 }
2246 }
2247 else {
2248 for (i = 0; i < n; i++)
2249 indexes[i] = (GLuint) s[i];
2250 }
2251 }
2252 break;
2253 case GL_HALF_FLOAT_ARB:
2254 {
2255 GLuint i;
2256 const GLhalfARB *s = (const GLhalfARB *) src;
2257 if (unpack->SwapBytes) {
2258 for (i = 0; i < n; i++) {
2259 GLhalfARB value = s[i];
2260 SWAP2BYTE(value);
2261 indexes[i] = (GLuint) _mesa_half_to_float(value);
2262 }
2263 }
2264 else {
2265 for (i = 0; i < n; i++)
2266 indexes[i] = (GLuint) _mesa_half_to_float(s[i]);
2267 }
2268 }
2269 break;
2270 case GL_UNSIGNED_INT_24_8_EXT:
2271 {
2272 GLuint i;
2273 const GLuint *s = (const GLuint *) src;
2274 if (unpack->SwapBytes) {
2275 for (i = 0; i < n; i++) {
2276 GLuint value = s[i];
2277 SWAP4BYTE(value);
2278 indexes[i] = value & 0xff; /* lower 8 bits */
2279 }
2280 }
2281 else {
2282 for (i = 0; i < n; i++)
2283 indexes[i] = s[i] & 0xfff; /* lower 8 bits */
2284 }
2285 }
2286 break;
2287
2288 default:
2289 _mesa_problem(NULL, "bad srcType in extract_uint_indexes");
2290 return;
2291 }
2292 }
2293
2294
2295 /*
2296 * This function extracts floating point RGBA values from arbitrary
2297 * image data. srcFormat and srcType are the format and type parameters
2298 * passed to glDrawPixels, glTexImage[123]D, glTexSubImage[123]D, etc.
2299 *
2300 * Refering to section 3.6.4 of the OpenGL 1.2 spec, this function
2301 * implements the "Conversion to floating point", "Conversion to RGB",
2302 * and "Final Expansion to RGBA" operations.
2303 *
2304 * Args: n - number of pixels
2305 * rgba - output colors
2306 * srcFormat - format of incoming data
2307 * srcType - data type of incoming data
2308 * src - source data pointer
2309 * swapBytes - perform byteswapping of incoming data?
2310 */
2311 static void
2312 extract_float_rgba(GLuint n, GLfloat rgba[][4],
2313 GLenum srcFormat, GLenum srcType, const GLvoid *src,
2314 GLboolean swapBytes)
2315 {
2316 GLint redIndex, greenIndex, blueIndex, alphaIndex;
2317 GLint stride;
2318 GLint rComp, bComp, gComp, aComp;
2319
2320 ASSERT(srcFormat == GL_RED ||
2321 srcFormat == GL_GREEN ||
2322 srcFormat == GL_BLUE ||
2323 srcFormat == GL_ALPHA ||
2324 srcFormat == GL_LUMINANCE ||
2325 srcFormat == GL_LUMINANCE_ALPHA ||
2326 srcFormat == GL_INTENSITY ||
2327 srcFormat == GL_RGB ||
2328 srcFormat == GL_BGR ||
2329 srcFormat == GL_RGBA ||
2330 srcFormat == GL_BGRA ||
2331 srcFormat == GL_ABGR_EXT);
2332
2333 ASSERT(srcType == GL_UNSIGNED_BYTE ||
2334 srcType == GL_BYTE ||
2335 srcType == GL_UNSIGNED_SHORT ||
2336 srcType == GL_SHORT ||
2337 srcType == GL_UNSIGNED_INT ||
2338 srcType == GL_INT ||
2339 srcType == GL_HALF_FLOAT_ARB ||
2340 srcType == GL_FLOAT ||
2341 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
2342 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
2343 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
2344 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
2345 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
2346 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
2347 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
2348 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
2349 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
2350 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
2351 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
2352 srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
2353
2354 rComp = gComp = bComp = aComp = -1;
2355
2356 switch (srcFormat) {
2357 case GL_RED:
2358 redIndex = 0;
2359 greenIndex = blueIndex = alphaIndex = -1;
2360 stride = 1;
2361 break;
2362 case GL_GREEN:
2363 greenIndex = 0;
2364 redIndex = blueIndex = alphaIndex = -1;
2365 stride = 1;
2366 break;
2367 case GL_BLUE:
2368 blueIndex = 0;
2369 redIndex = greenIndex = alphaIndex = -1;
2370 stride = 1;
2371 break;
2372 case GL_ALPHA:
2373 redIndex = greenIndex = blueIndex = -1;
2374 alphaIndex = 0;
2375 stride = 1;
2376 break;
2377 case GL_LUMINANCE:
2378 redIndex = greenIndex = blueIndex = 0;
2379 alphaIndex = -1;
2380 stride = 1;
2381 break;
2382 case GL_LUMINANCE_ALPHA:
2383 redIndex = greenIndex = blueIndex = 0;
2384 alphaIndex = 1;
2385 stride = 2;
2386 break;
2387 case GL_INTENSITY:
2388 redIndex = greenIndex = blueIndex = alphaIndex = 0;
2389 stride = 1;
2390 break;
2391 case GL_RGB:
2392 redIndex = 0;
2393 greenIndex = 1;
2394 blueIndex = 2;
2395 alphaIndex = -1;
2396 rComp = 0;
2397 gComp = 1;
2398 bComp = 2;
2399 aComp = 3;
2400 stride = 3;
2401 break;
2402 case GL_BGR:
2403 redIndex = 2;
2404 greenIndex = 1;
2405 blueIndex = 0;
2406 alphaIndex = -1;
2407 rComp = 2;
2408 gComp = 1;
2409 bComp = 0;
2410 aComp = 3;
2411 stride = 3;
2412 break;
2413 case GL_RGBA:
2414 redIndex = 0;
2415 greenIndex = 1;
2416 blueIndex = 2;
2417 alphaIndex = 3;
2418 rComp = 0;
2419 gComp = 1;
2420 bComp = 2;
2421 aComp = 3;
2422 stride = 4;
2423 break;
2424 case GL_BGRA:
2425 redIndex = 2;
2426 greenIndex = 1;
2427 blueIndex = 0;
2428 alphaIndex = 3;
2429 rComp = 2;
2430 gComp = 1;
2431 bComp = 0;
2432 aComp = 3;
2433 stride = 4;
2434 break;
2435 case GL_ABGR_EXT:
2436 redIndex = 3;
2437 greenIndex = 2;
2438 blueIndex = 1;
2439 alphaIndex = 0;
2440 rComp = 3;
2441 gComp = 2;
2442 bComp = 1;
2443 aComp = 0;
2444 stride = 4;
2445 break;
2446 default:
2447 _mesa_problem(NULL, "bad srcFormat in extract float data");
2448 return;
2449 }
2450
2451
2452 #define PROCESS(INDEX, CHANNEL, DEFAULT, TYPE, CONVERSION) \
2453 if ((INDEX) < 0) { \
2454 GLuint i; \
2455 for (i = 0; i < n; i++) { \
2456 rgba[i][CHANNEL] = DEFAULT; \
2457 } \
2458 } \
2459 else if (swapBytes) { \
2460 const TYPE *s = (const TYPE *) src; \
2461 GLuint i; \
2462 for (i = 0; i < n; i++) { \
2463 TYPE value = s[INDEX]; \
2464 if (sizeof(TYPE) == 2) { \
2465 SWAP2BYTE(value); \
2466 } \
2467 else if (sizeof(TYPE) == 4) { \
2468 SWAP4BYTE(value); \
2469 } \
2470 rgba[i][CHANNEL] = (GLfloat) CONVERSION(value); \
2471 s += stride; \
2472 } \
2473 } \
2474 else { \
2475 const TYPE *s = (const TYPE *) src; \
2476 GLuint i; \
2477 for (i = 0; i < n; i++) { \
2478 rgba[i][CHANNEL] = (GLfloat) CONVERSION(s[INDEX]); \
2479 s += stride; \
2480 } \
2481 }
2482
2483 switch (srcType) {
2484 case GL_UNSIGNED_BYTE:
2485 PROCESS(redIndex, RCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT);
2486 PROCESS(greenIndex, GCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT);
2487 PROCESS(blueIndex, BCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT);
2488 PROCESS(alphaIndex, ACOMP, 1.0F, GLubyte, UBYTE_TO_FLOAT);
2489 break;
2490 case GL_BYTE:
2491 PROCESS(redIndex, RCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT);
2492 PROCESS(greenIndex, GCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT);
2493 PROCESS(blueIndex, BCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT);
2494 PROCESS(alphaIndex, ACOMP, 1.0F, GLbyte, BYTE_TO_FLOAT);
2495 break;
2496 case GL_UNSIGNED_SHORT:
2497 PROCESS(redIndex, RCOMP, 0.0F, GLushort, USHORT_TO_FLOAT);
2498 PROCESS(greenIndex, GCOMP, 0.0F, GLushort, USHORT_TO_FLOAT);
2499 PROCESS(blueIndex, BCOMP, 0.0F, GLushort, USHORT_TO_FLOAT);
2500 PROCESS(alphaIndex, ACOMP, 1.0F, GLushort, USHORT_TO_FLOAT);
2501 break;
2502 case GL_SHORT:
2503 PROCESS(redIndex, RCOMP, 0.0F, GLshort, SHORT_TO_FLOAT);
2504 PROCESS(greenIndex, GCOMP, 0.0F, GLshort, SHORT_TO_FLOAT);
2505 PROCESS(blueIndex, BCOMP, 0.0F, GLshort, SHORT_TO_FLOAT);
2506 PROCESS(alphaIndex, ACOMP, 1.0F, GLshort, SHORT_TO_FLOAT);
2507 break;
2508 case GL_UNSIGNED_INT:
2509 PROCESS(redIndex, RCOMP, 0.0F, GLuint, UINT_TO_FLOAT);
2510 PROCESS(greenIndex, GCOMP, 0.0F, GLuint, UINT_TO_FLOAT);
2511 PROCESS(blueIndex, BCOMP, 0.0F, GLuint, UINT_TO_FLOAT);
2512 PROCESS(alphaIndex, ACOMP, 1.0F, GLuint, UINT_TO_FLOAT);
2513 break;
2514 case GL_INT:
2515 PROCESS(redIndex, RCOMP, 0.0F, GLint, INT_TO_FLOAT);
2516 PROCESS(greenIndex, GCOMP, 0.0F, GLint, INT_TO_FLOAT);
2517 PROCESS(blueIndex, BCOMP, 0.0F, GLint, INT_TO_FLOAT);
2518 PROCESS(alphaIndex, ACOMP, 1.0F, GLint, INT_TO_FLOAT);
2519 break;
2520 case GL_FLOAT:
2521 PROCESS(redIndex, RCOMP, 0.0F, GLfloat, (GLfloat));
2522 PROCESS(greenIndex, GCOMP, 0.0F, GLfloat, (GLfloat));
2523 PROCESS(blueIndex, BCOMP, 0.0F, GLfloat, (GLfloat));
2524 PROCESS(alphaIndex, ACOMP, 1.0F, GLfloat, (GLfloat));
2525 break;
2526 case GL_HALF_FLOAT_ARB:
2527 PROCESS(redIndex, RCOMP, 0.0F, GLhalfARB, _mesa_half_to_float);
2528 PROCESS(greenIndex, GCOMP, 0.0F, GLhalfARB, _mesa_half_to_float);
2529 PROCESS(blueIndex, BCOMP, 0.0F, GLhalfARB, _mesa_half_to_float);
2530 PROCESS(alphaIndex, ACOMP, 1.0F, GLhalfARB, _mesa_half_to_float);
2531 break;
2532 case GL_UNSIGNED_BYTE_3_3_2:
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 >> 5) ) * (1.0F / 7.0F);
2539 rgba[i][gComp] = ((p >> 2) & 0x7) * (1.0F / 7.0F);
2540 rgba[i][bComp] = ((p ) & 0x3) * (1.0F / 3.0F);
2541 rgba[i][aComp] = 1.0F;
2542 }
2543 }
2544 break;
2545 case GL_UNSIGNED_BYTE_2_3_3_REV:
2546 {
2547 const GLubyte *ubsrc = (const GLubyte *) src;
2548 GLuint i;
2549 for (i = 0; i < n; i ++) {
2550 GLubyte p = ubsrc[i];
2551 rgba[i][rComp] = ((p ) & 0x7) * (1.0F / 7.0F);
2552 rgba[i][gComp] = ((p >> 3) & 0x7) * (1.0F / 7.0F);
2553 rgba[i][bComp] = ((p >> 6) ) * (1.0F / 3.0F);
2554 rgba[i][aComp] = 1.0F;
2555 }
2556 }
2557 break;
2558 case GL_UNSIGNED_SHORT_5_6_5:
2559 if (swapBytes) {
2560 const GLushort *ussrc = (const GLushort *) src;
2561 GLuint i;
2562 for (i = 0; i < n; i ++) {
2563 GLushort p = ussrc[i];
2564 SWAP2BYTE(p);
2565 rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F);
2566 rgba[i][gComp] = ((p >> 5) & 0x3f) * (1.0F / 63.0F);
2567 rgba[i][bComp] = ((p ) & 0x1f) * (1.0F / 31.0F);
2568 rgba[i][aComp] = 1.0F;
2569 }
2570 }
2571 else {
2572 const GLushort *ussrc = (const GLushort *) src;
2573 GLuint i;
2574 for (i = 0; i < n; i ++) {
2575 GLushort p = ussrc[i];
2576 rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F);
2577 rgba[i][gComp] = ((p >> 5) & 0x3f) * (1.0F / 63.0F);
2578 rgba[i][bComp] = ((p ) & 0x1f) * (1.0F / 31.0F);
2579 rgba[i][aComp] = 1.0F;
2580 }
2581 }
2582 break;
2583 case GL_UNSIGNED_SHORT_5_6_5_REV:
2584 if (swapBytes) {
2585 const GLushort *ussrc = (const GLushort *) src;
2586 GLuint i;
2587 for (i = 0; i < n; i ++) {
2588 GLushort p = ussrc[i];
2589 SWAP2BYTE(p);
2590 rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F);
2591 rgba[i][gComp] = ((p >> 5) & 0x3f) * (1.0F / 63.0F);
2592 rgba[i][bComp] = ((p >> 11) ) * (1.0F / 31.0F);
2593 rgba[i][aComp] = 1.0F;
2594 }
2595 }
2596 else {
2597 const GLushort *ussrc = (const GLushort *) src;
2598 GLuint i;
2599 for (i = 0; i < n; i ++) {
2600 GLushort p = ussrc[i];
2601 rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F);
2602 rgba[i][gComp] = ((p >> 5) & 0x3f) * (1.0F / 63.0F);
2603 rgba[i][bComp] = ((p >> 11) ) * (1.0F / 31.0F);
2604 rgba[i][aComp] = 1.0F;
2605 }
2606 }
2607 break;
2608 case GL_UNSIGNED_SHORT_4_4_4_4:
2609 if (swapBytes) {
2610 const GLushort *ussrc = (const GLushort *) src;
2611 GLuint i;
2612 for (i = 0; i < n; i ++) {
2613 GLushort p = ussrc[i];
2614 SWAP2BYTE(p);
2615 rgba[i][rComp] = ((p >> 12) ) * (1.0F / 15.0F);
2616 rgba[i][gComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F);
2617 rgba[i][bComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F);
2618 rgba[i][aComp] = ((p ) & 0xf) * (1.0F / 15.0F);
2619 }
2620 }
2621 else {
2622 const GLushort *ussrc = (const GLushort *) src;
2623 GLuint i;
2624 for (i = 0; i < n; i ++) {
2625 GLushort p = ussrc[i];
2626 rgba[i][rComp] = ((p >> 12) ) * (1.0F / 15.0F);
2627 rgba[i][gComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F);
2628 rgba[i][bComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F);
2629 rgba[i][aComp] = ((p ) & 0xf) * (1.0F / 15.0F);
2630 }
2631 }
2632 break;
2633 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
2634 if (swapBytes) {
2635 const GLushort *ussrc = (const GLushort *) src;
2636 GLuint i;
2637 for (i = 0; i < n; i ++) {
2638 GLushort p = ussrc[i];
2639 SWAP2BYTE(p);
2640 rgba[i][rComp] = ((p ) & 0xf) * (1.0F / 15.0F);
2641 rgba[i][gComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F);
2642 rgba[i][bComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F);
2643 rgba[i][aComp] = ((p >> 12) ) * (1.0F / 15.0F);
2644 }
2645 }
2646 else {
2647 const GLushort *ussrc = (const GLushort *) src;
2648 GLuint i;
2649 for (i = 0; i < n; i ++) {
2650 GLushort p = ussrc[i];
2651 rgba[i][rComp] = ((p ) & 0xf) * (1.0F / 15.0F);
2652 rgba[i][gComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F);
2653 rgba[i][bComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F);
2654 rgba[i][aComp] = ((p >> 12) ) * (1.0F / 15.0F);
2655 }
2656 }
2657 break;
2658 case GL_UNSIGNED_SHORT_5_5_5_1:
2659 if (swapBytes) {
2660 const GLushort *ussrc = (const GLushort *) src;
2661 GLuint i;
2662 for (i = 0; i < n; i ++) {
2663 GLushort p = ussrc[i];
2664 SWAP2BYTE(p);
2665 rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F);
2666 rgba[i][gComp] = ((p >> 6) & 0x1f) * (1.0F / 31.0F);
2667 rgba[i][bComp] = ((p >> 1) & 0x1f) * (1.0F / 31.0F);
2668 rgba[i][aComp] = ((p ) & 0x1) * (1.0F / 1.0F);
2669 }
2670 }
2671 else {
2672 const GLushort *ussrc = (const GLushort *) src;
2673 GLuint i;
2674 for (i = 0; i < n; i ++) {
2675 GLushort p = ussrc[i];
2676 rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F);
2677 rgba[i][gComp] = ((p >> 6) & 0x1f) * (1.0F / 31.0F);
2678 rgba[i][bComp] = ((p >> 1) & 0x1f) * (1.0F / 31.0F);
2679 rgba[i][aComp] = ((p ) & 0x1) * (1.0F / 1.0F);
2680 }
2681 }
2682 break;
2683 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
2684 if (swapBytes) {
2685 const GLushort *ussrc = (const GLushort *) src;
2686 GLuint i;
2687 for (i = 0; i < n; i ++) {
2688 GLushort p = ussrc[i];
2689 SWAP2BYTE(p);
2690 rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F);
2691 rgba[i][gComp] = ((p >> 5) & 0x1f) * (1.0F / 31.0F);
2692 rgba[i][bComp] = ((p >> 10) & 0x1f) * (1.0F / 31.0F);
2693 rgba[i][aComp] = ((p >> 15) ) * (1.0F / 1.0F);
2694 }
2695 }
2696 else {
2697 const GLushort *ussrc = (const GLushort *) src;
2698 GLuint i;
2699 for (i = 0; i < n; i ++) {
2700 GLushort p = ussrc[i];
2701 rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F);
2702 rgba[i][gComp] = ((p >> 5) & 0x1f) * (1.0F / 31.0F);
2703 rgba[i][bComp] = ((p >> 10) & 0x1f) * (1.0F / 31.0F);
2704 rgba[i][aComp] = ((p >> 15) ) * (1.0F / 1.0F);
2705 }
2706 }
2707 break;
2708 case GL_UNSIGNED_INT_8_8_8_8:
2709 if (swapBytes) {
2710 const GLuint *uisrc = (const GLuint *) src;
2711 GLuint i;
2712 for (i = 0; i < n; i ++) {
2713 GLuint p = uisrc[i];
2714 rgba[i][rComp] = UBYTE_TO_FLOAT((p ) & 0xff);
2715 rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
2716 rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2717 rgba[i][aComp] = UBYTE_TO_FLOAT((p >> 24) );
2718 }
2719 }
2720 else {
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 break;
2732 case GL_UNSIGNED_INT_8_8_8_8_REV:
2733 if (swapBytes) {
2734 const GLuint *uisrc = (const GLuint *) src;
2735 GLuint i;
2736 for (i = 0; i < n; i ++) {
2737 GLuint p = uisrc[i];
2738 rgba[i][rComp] = UBYTE_TO_FLOAT((p >> 24) );
2739 rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2740 rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
2741 rgba[i][aComp] = UBYTE_TO_FLOAT((p ) & 0xff);
2742 }
2743 }
2744 else {
2745 const GLuint *uisrc = (const GLuint *) src;
2746 GLuint i;
2747 for (i = 0; i < n; i ++) {
2748 GLuint p = uisrc[i];
2749 rgba[i][rComp] = UBYTE_TO_FLOAT((p ) & 0xff);
2750 rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
2751 rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2752 rgba[i][aComp] = UBYTE_TO_FLOAT((p >> 24) );
2753 }
2754 }
2755 break;
2756 case GL_UNSIGNED_INT_10_10_10_2:
2757 if (swapBytes) {
2758 const GLuint *uisrc = (const GLuint *) src;
2759 GLuint i;
2760 for (i = 0; i < n; i ++) {
2761 GLuint p = uisrc[i];
2762 SWAP4BYTE(p);
2763 rgba[i][rComp] = ((p >> 22) ) * (1.0F / 1023.0F);
2764 rgba[i][gComp] = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F);
2765 rgba[i][bComp] = ((p >> 2) & 0x3ff) * (1.0F / 1023.0F);
2766 rgba[i][aComp] = ((p ) & 0x3 ) * (1.0F / 3.0F);
2767 }
2768 }
2769 else {
2770 const GLuint *uisrc = (const GLuint *) src;
2771 GLuint i;
2772 for (i = 0; i < n; i ++) {
2773 GLuint p = uisrc[i];
2774 rgba[i][rComp] = ((p >> 22) ) * (1.0F / 1023.0F);
2775 rgba[i][gComp] = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F);
2776 rgba[i][bComp] = ((p >> 2) & 0x3ff) * (1.0F / 1023.0F);
2777 rgba[i][aComp] = ((p ) & 0x3 ) * (1.0F / 3.0F);
2778 }
2779 }
2780 break;
2781 case GL_UNSIGNED_INT_2_10_10_10_REV:
2782 if (swapBytes) {
2783 const GLuint *uisrc = (const GLuint *) src;
2784 GLuint i;
2785 for (i = 0; i < n; i ++) {
2786 GLuint p = uisrc[i];
2787 SWAP4BYTE(p);
2788 rgba[i][rComp] = ((p ) & 0x3ff) * (1.0F / 1023.0F);
2789 rgba[i][gComp] = ((p >> 10) & 0x3ff) * (1.0F / 1023.0F);
2790 rgba[i][bComp] = ((p >> 20) & 0x3ff) * (1.0F / 1023.0F);
2791 rgba[i][aComp] = ((p >> 30) ) * (1.0F / 3.0F);
2792 }
2793 }
2794 else {
2795 const GLuint *uisrc = (const GLuint *) src;
2796 GLuint i;
2797 for (i = 0; i < n; i ++) {
2798 GLuint p = uisrc[i];
2799 rgba[i][rComp] = ((p ) & 0x3ff) * (1.0F / 1023.0F);
2800 rgba[i][gComp] = ((p >> 10) & 0x3ff) * (1.0F / 1023.0F);
2801 rgba[i][bComp] = ((p >> 20) & 0x3ff) * (1.0F / 1023.0F);
2802 rgba[i][aComp] = ((p >> 30) ) * (1.0F / 3.0F);
2803 }
2804 }
2805 break;
2806 default:
2807 _mesa_problem(NULL, "bad srcType in extract float data");
2808 break;
2809 }
2810 }
2811
2812
2813 /*
2814 * Unpack a row of color image data from a client buffer according to
2815 * the pixel unpacking parameters.
2816 * Return GLchan values in the specified dest image format.
2817 * This is used by glDrawPixels and glTexImage?D().
2818 * \param ctx - the context
2819 * n - number of pixels in the span
2820 * dstFormat - format of destination color array
2821 * dest - the destination color array
2822 * srcFormat - source image format
2823 * srcType - source image data type
2824 * source - source image pointer
2825 * srcPacking - pixel unpacking parameters
2826 * transferOps - bitmask of IMAGE_*_BIT values of operations to apply
2827 *
2828 * XXX perhaps expand this to process whole images someday.
2829 */
2830 void
2831 _mesa_unpack_color_span_chan( GLcontext *ctx,
2832 GLuint n, GLenum dstFormat, GLchan dest[],
2833 GLenum srcFormat, GLenum srcType,
2834 const GLvoid *source,
2835 const struct gl_pixelstore_attrib *srcPacking,
2836 GLbitfield transferOps )
2837 {
2838 ASSERT(dstFormat == GL_ALPHA ||
2839 dstFormat == GL_LUMINANCE ||
2840 dstFormat == GL_LUMINANCE_ALPHA ||
2841 dstFormat == GL_INTENSITY ||
2842 dstFormat == GL_RGB ||
2843 dstFormat == GL_RGBA ||
2844 dstFormat == GL_COLOR_INDEX);
2845
2846 ASSERT(srcFormat == GL_RED ||
2847 srcFormat == GL_GREEN ||
2848 srcFormat == GL_BLUE ||
2849 srcFormat == GL_ALPHA ||
2850 srcFormat == GL_LUMINANCE ||
2851 srcFormat == GL_LUMINANCE_ALPHA ||
2852 srcFormat == GL_INTENSITY ||
2853 srcFormat == GL_RGB ||
2854 srcFormat == GL_BGR ||
2855 srcFormat == GL_RGBA ||
2856 srcFormat == GL_BGRA ||
2857 srcFormat == GL_ABGR_EXT ||
2858 srcFormat == GL_COLOR_INDEX);
2859
2860 ASSERT(srcType == GL_BITMAP ||
2861 srcType == GL_UNSIGNED_BYTE ||
2862 srcType == GL_BYTE ||
2863 srcType == GL_UNSIGNED_SHORT ||
2864 srcType == GL_SHORT ||
2865 srcType == GL_UNSIGNED_INT ||
2866 srcType == GL_INT ||
2867 srcType == GL_HALF_FLOAT_ARB ||
2868 srcType == GL_FLOAT ||
2869 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
2870 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
2871 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
2872 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
2873 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
2874 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
2875 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
2876 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
2877 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
2878 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
2879 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
2880 srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
2881
2882 /* Try simple cases first */
2883 if (transferOps == 0) {
2884 if (srcType == CHAN_TYPE) {
2885 if (dstFormat == GL_RGBA) {
2886 if (srcFormat == GL_RGBA) {
2887 _mesa_memcpy( dest, source, n * 4 * sizeof(GLchan) );
2888 return;
2889 }
2890 else if (srcFormat == GL_RGB) {
2891 GLuint i;
2892 const GLchan *src = (const GLchan *) source;
2893 GLchan *dst = dest;
2894 for (i = 0; i < n; i++) {
2895 dst[0] = src[0];
2896 dst[1] = src[1];
2897 dst[2] = src[2];
2898 dst[3] = CHAN_MAX;
2899 src += 3;
2900 dst += 4;
2901 }
2902 return;
2903 }
2904 }
2905 else if (dstFormat == GL_RGB) {
2906 if (srcFormat == GL_RGB) {
2907 _mesa_memcpy( dest, source, n * 3 * sizeof(GLchan) );
2908 return;
2909 }
2910 else if (srcFormat == GL_RGBA) {
2911 GLuint i;
2912 const GLchan *src = (const GLchan *) source;
2913 GLchan *dst = dest;
2914 for (i = 0; i < n; i++) {
2915 dst[0] = src[0];
2916 dst[1] = src[1];
2917 dst[2] = src[2];
2918 src += 4;
2919 dst += 3;
2920 }
2921 return;
2922 }
2923 }
2924 else if (dstFormat == srcFormat) {
2925 GLint comps = _mesa_components_in_format(srcFormat);
2926 assert(comps > 0);
2927 _mesa_memcpy( dest, source, n * comps * sizeof(GLchan) );
2928 return;
2929 }
2930 }
2931 /*
2932 * Common situation, loading 8bit RGBA/RGB source images
2933 * into 16/32 bit destination. (OSMesa16/32)
2934 */
2935 else if (srcType == GL_UNSIGNED_BYTE) {
2936 if (dstFormat == GL_RGBA) {
2937 if (srcFormat == GL_RGB) {
2938 GLuint i;
2939 const GLubyte *src = (const GLubyte *) source;
2940 GLchan *dst = dest;
2941 for (i = 0; i < n; i++) {
2942 dst[0] = UBYTE_TO_CHAN(src[0]);
2943 dst[1] = UBYTE_TO_CHAN(src[1]);
2944 dst[2] = UBYTE_TO_CHAN(src[2]);
2945 dst[3] = CHAN_MAX;
2946 src += 3;
2947 dst += 4;
2948 }
2949 return;
2950 }
2951 else if (srcFormat == GL_RGBA) {
2952 GLuint i;
2953 const GLubyte *src = (const GLubyte *) source;
2954 GLchan *dst = dest;
2955 for (i = 0; i < n; i++) {
2956 dst[0] = UBYTE_TO_CHAN(src[0]);
2957 dst[1] = UBYTE_TO_CHAN(src[1]);
2958 dst[2] = UBYTE_TO_CHAN(src[2]);
2959 dst[3] = UBYTE_TO_CHAN(src[3]);
2960 src += 4;
2961 dst += 4;
2962 }
2963 return;
2964 }
2965 }
2966 else if (dstFormat == GL_RGB) {
2967 if (srcFormat == GL_RGB) {
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 += 3;
2976 dst += 3;
2977 }
2978 return;
2979 }
2980 else if (srcFormat == GL_RGBA) {
2981 GLuint i;
2982 const GLubyte *src = (const GLubyte *) source;
2983 GLchan *dst = dest;
2984 for (i = 0; i < n; i++) {
2985 dst[0] = UBYTE_TO_CHAN(src[0]);
2986 dst[1] = UBYTE_TO_CHAN(src[1]);
2987 dst[2] = UBYTE_TO_CHAN(src[2]);
2988 src += 4;
2989 dst += 3;
2990 }
2991 return;
2992 }
2993 }
2994 }
2995 }
2996
2997
2998 /* general solution begins here */
2999 {
3000 GLint dstComponents;
3001 GLint dstRedIndex, dstGreenIndex, dstBlueIndex, dstAlphaIndex;
3002 GLint dstLuminanceIndex, dstIntensityIndex;
3003 GLfloat rgba[MAX_WIDTH][4];
3004
3005 dstComponents = _mesa_components_in_format( dstFormat );
3006 /* source & dest image formats should have been error checked by now */
3007 assert(dstComponents > 0);
3008
3009 /*
3010 * Extract image data and convert to RGBA floats
3011 */
3012 assert(n <= MAX_WIDTH);
3013 if (srcFormat == GL_COLOR_INDEX) {
3014 GLuint indexes[MAX_WIDTH];
3015 extract_uint_indexes(n, indexes, srcFormat, srcType, source,
3016 srcPacking);
3017
3018 if (dstFormat == GL_COLOR_INDEX) {
3019 GLuint i;
3020 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
3021 /* convert to GLchan and return */
3022 for (i = 0; i < n; i++) {
3023 dest[i] = (GLchan) (indexes[i] & 0xff);
3024 }
3025 return;
3026 }
3027 else {
3028 /* Convert indexes to RGBA */
3029 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
3030 shift_and_offset_ci(ctx, n, indexes);
3031 }
3032 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
3033 }
3034
3035 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
3036 * with color indexes.
3037 */
3038 transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT);
3039 }
3040 else {
3041 /* non-color index data */
3042 extract_float_rgba(n, rgba, srcFormat, srcType, source,
3043 srcPacking->SwapBytes);
3044 }
3045
3046 /* Need to clamp if returning GLubytes or GLushorts */
3047 #if CHAN_TYPE != GL_FLOAT
3048 transferOps |= IMAGE_CLAMP_BIT;
3049 #endif
3050
3051 if (transferOps) {
3052 _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
3053 }
3054
3055 /* Now determine which color channels we need to produce.
3056 * And determine the dest index (offset) within each color tuple.
3057 */
3058 switch (dstFormat) {
3059 case GL_ALPHA:
3060 dstAlphaIndex = 0;
3061 dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
3062 dstLuminanceIndex = dstIntensityIndex = -1;
3063 break;
3064 case GL_LUMINANCE:
3065 dstLuminanceIndex = 0;
3066 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
3067 dstIntensityIndex = -1;
3068 break;
3069 case GL_LUMINANCE_ALPHA:
3070 dstLuminanceIndex = 0;
3071 dstAlphaIndex = 1;
3072 dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
3073 dstIntensityIndex = -1;
3074 break;
3075 case GL_INTENSITY:
3076 dstIntensityIndex = 0;
3077 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
3078 dstLuminanceIndex = -1;
3079 break;
3080 case GL_RGB:
3081 dstRedIndex = 0;
3082 dstGreenIndex = 1;
3083 dstBlueIndex = 2;
3084 dstAlphaIndex = dstLuminanceIndex = dstIntensityIndex = -1;
3085 break;
3086 case GL_RGBA:
3087 dstRedIndex = 0;
3088 dstGreenIndex = 1;
3089 dstBlueIndex = 2;
3090 dstAlphaIndex = 3;
3091 dstLuminanceIndex = dstIntensityIndex = -1;
3092 break;
3093 default:
3094 _mesa_problem(ctx, "bad dstFormat in _mesa_unpack_chan_span()");
3095 return;
3096 }
3097
3098
3099 /* Now return the GLchan data in the requested dstFormat */
3100
3101 if (dstRedIndex >= 0) {
3102 GLchan *dst = dest;
3103 GLuint i;
3104 for (i = 0; i < n; i++) {
3105 CLAMPED_FLOAT_TO_CHAN(dst[dstRedIndex], rgba[i][RCOMP]);
3106 dst += dstComponents;
3107 }
3108 }
3109
3110 if (dstGreenIndex >= 0) {
3111 GLchan *dst = dest;
3112 GLuint i;
3113 for (i = 0; i < n; i++) {
3114 CLAMPED_FLOAT_TO_CHAN(dst[dstGreenIndex], rgba[i][GCOMP]);
3115 dst += dstComponents;
3116 }
3117 }
3118
3119 if (dstBlueIndex >= 0) {
3120 GLchan *dst = dest;
3121 GLuint i;
3122 for (i = 0; i < n; i++) {
3123 CLAMPED_FLOAT_TO_CHAN(dst[dstBlueIndex], rgba[i][BCOMP]);
3124 dst += dstComponents;
3125 }
3126 }
3127
3128 if (dstAlphaIndex >= 0) {
3129 GLchan *dst = dest;
3130 GLuint i;
3131 for (i = 0; i < n; i++) {
3132 CLAMPED_FLOAT_TO_CHAN(dst[dstAlphaIndex], rgba[i][ACOMP]);
3133 dst += dstComponents;
3134 }
3135 }
3136
3137 if (dstIntensityIndex >= 0) {
3138 GLchan *dst = dest;
3139 GLuint i;
3140 assert(dstIntensityIndex == 0);
3141 assert(dstComponents == 1);
3142 for (i = 0; i < n; i++) {
3143 /* Intensity comes from red channel */
3144 CLAMPED_FLOAT_TO_CHAN(dst[i], rgba[i][RCOMP]);
3145 }
3146 }
3147
3148 if (dstLuminanceIndex >= 0) {
3149 GLchan *dst = dest;
3150 GLuint i;
3151 assert(dstLuminanceIndex == 0);
3152 for (i = 0; i < n; i++) {
3153 /* Luminance comes from red channel */
3154 CLAMPED_FLOAT_TO_CHAN(dst[0], rgba[i][RCOMP]);
3155 dst += dstComponents;
3156 }
3157 }
3158 }
3159 }
3160
3161
3162 /**
3163 * Same as _mesa_unpack_color_span_chan(), but return GLfloat data
3164 * instead of GLchan.
3165 */
3166 void
3167 _mesa_unpack_color_span_float( GLcontext *ctx,
3168 GLuint n, GLenum dstFormat, GLfloat dest[],
3169 GLenum srcFormat, GLenum srcType,
3170 const GLvoid *source,
3171 const struct gl_pixelstore_attrib *srcPacking,
3172 GLbitfield transferOps )
3173 {
3174 ASSERT(dstFormat == GL_ALPHA ||
3175 dstFormat == GL_LUMINANCE ||
3176 dstFormat == GL_LUMINANCE_ALPHA ||
3177 dstFormat == GL_INTENSITY ||
3178 dstFormat == GL_RGB ||
3179 dstFormat == GL_RGBA ||
3180 dstFormat == GL_COLOR_INDEX);
3181
3182 ASSERT(srcFormat == GL_RED ||
3183 srcFormat == GL_GREEN ||
3184 srcFormat == GL_BLUE ||
3185 srcFormat == GL_ALPHA ||
3186 srcFormat == GL_LUMINANCE ||
3187 srcFormat == GL_LUMINANCE_ALPHA ||
3188 srcFormat == GL_INTENSITY ||
3189 srcFormat == GL_RGB ||
3190 srcFormat == GL_BGR ||
3191 srcFormat == GL_RGBA ||
3192 srcFormat == GL_BGRA ||
3193 srcFormat == GL_ABGR_EXT ||
3194 srcFormat == GL_COLOR_INDEX);
3195
3196 ASSERT(srcType == GL_BITMAP ||
3197 srcType == GL_UNSIGNED_BYTE ||
3198 srcType == GL_BYTE ||
3199 srcType == GL_UNSIGNED_SHORT ||
3200 srcType == GL_SHORT ||
3201 srcType == GL_UNSIGNED_INT ||
3202 srcType == GL_INT ||
3203 srcType == GL_HALF_FLOAT_ARB ||
3204 srcType == GL_FLOAT ||
3205 srcType == GL_UNSIGNED_BYTE_3_3_2 ||
3206 srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
3207 srcType == GL_UNSIGNED_SHORT_5_6_5 ||
3208 srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
3209 srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
3210 srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
3211 srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
3212 srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
3213 srcType == GL_UNSIGNED_INT_8_8_8_8 ||
3214 srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
3215 srcType == GL_UNSIGNED_INT_10_10_10_2 ||
3216 srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
3217
3218 /* general solution, no special cases, yet */
3219 {
3220 GLint dstComponents;
3221 GLint dstRedIndex, dstGreenIndex, dstBlueIndex, dstAlphaIndex;
3222 GLint dstLuminanceIndex, dstIntensityIndex;
3223 GLfloat rgba[MAX_WIDTH][4];
3224
3225 dstComponents = _mesa_components_in_format( dstFormat );
3226 /* source & dest image formats should have been error checked by now */
3227 assert(dstComponents > 0);
3228
3229 /*
3230 * Extract image data and convert to RGBA floats
3231 */
3232 assert(n <= MAX_WIDTH);
3233 if (srcFormat == GL_COLOR_INDEX) {
3234 GLuint indexes[MAX_WIDTH];
3235 extract_uint_indexes(n, indexes, srcFormat, srcType, source,
3236 srcPacking);
3237
3238 if (dstFormat == GL_COLOR_INDEX) {
3239 GLuint i;
3240 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
3241 /* convert to GLchan and return */
3242 for (i = 0; i < n; i++) {
3243 dest[i] = (GLchan) (indexes[i] & 0xff);
3244 }
3245 return;
3246 }
3247 else {
3248 /* Convert indexes to RGBA */
3249 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
3250 shift_and_offset_ci(ctx, n, indexes);
3251 }
3252 _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
3253 }
3254
3255 /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
3256 * with color indexes.
3257 */
3258 transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT);
3259 }
3260 else {
3261 /* non-color index data */
3262 extract_float_rgba(n, rgba, srcFormat, srcType, source,
3263 srcPacking->SwapBytes);
3264 }
3265
3266 if (transferOps) {
3267 _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
3268 }
3269
3270 /* Now determine which color channels we need to produce.
3271 * And determine the dest index (offset) within each color tuple.
3272 */
3273 switch (dstFormat) {
3274 case GL_ALPHA:
3275 dstAlphaIndex = 0;
3276 dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
3277 dstLuminanceIndex = dstIntensityIndex = -1;
3278 break;
3279 case GL_LUMINANCE:
3280 dstLuminanceIndex = 0;
3281 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
3282 dstIntensityIndex = -1;
3283 break;
3284 case GL_LUMINANCE_ALPHA:
3285 dstLuminanceIndex = 0;
3286 dstAlphaIndex = 1;
3287 dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
3288 dstIntensityIndex = -1;
3289 break;
3290 case GL_INTENSITY:
3291 dstIntensityIndex = 0;
3292 dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
3293 dstLuminanceIndex = -1;
3294 break;
3295 case GL_RGB:
3296 dstRedIndex = 0;
3297 dstGreenIndex = 1;
3298 dstBlueIndex = 2;
3299 dstAlphaIndex = dstLuminanceIndex = dstIntensityIndex = -1;
3300 break;
3301 case GL_RGBA:
3302 dstRedIndex = 0;
3303 dstGreenIndex = 1;
3304 dstBlueIndex = 2;
3305 dstAlphaIndex = 3;
3306 dstLuminanceIndex = dstIntensityIndex = -1;
3307 break;
3308 default:
3309 _mesa_problem(ctx, "bad dstFormat in _mesa_unpack_color_span_float()");
3310 return;
3311 }
3312
3313 /* Now pack results in the requested dstFormat */
3314 if (dstRedIndex >= 0) {
3315 GLfloat *dst = dest;
3316 GLuint i;
3317 for (i = 0; i < n; i++) {
3318 dst[dstRedIndex] = rgba[i][RCOMP];
3319 dst += dstComponents;
3320 }
3321 }
3322
3323 if (dstGreenIndex >= 0) {
3324 GLfloat *dst = dest;
3325 GLuint i;
3326 for (i = 0; i < n; i++) {
3327 dst[dstGreenIndex] = rgba[i][GCOMP];
3328 dst += dstComponents;
3329 }
3330 }
3331
3332 if (dstBlueIndex >= 0) {
3333 GLfloat *dst = dest;
3334 GLuint i;
3335 for (i = 0; i < n; i++) {
3336 dst[dstBlueIndex] = rgba[i][BCOMP];
3337 dst += dstComponents;
3338 }
3339 }
3340
3341 if (dstAlphaIndex >= 0) {
3342 GLfloat *dst = dest;
3343 GLuint i;
3344 for (i = 0; i < n; i++) {
3345 dst[dstAlphaIndex] = rgba[i][ACOMP];
3346 dst += dstComponents;
3347 }
3348 }
3349
3350 if (dstIntensityIndex >= 0) {
3351 GLfloat *dst = dest;
3352 GLuint i;
3353 assert(dstIntensityIndex == 0);
3354 assert(dstComponents == 1);
3355 for (i = 0; i < n; i++) {
3356 /* Intensity comes from red channel */
3357 dst[i] = rgba[i][RCOMP];
3358 }
3359 }
3360
3361 if (dstLuminanceIndex >= 0) {
3362 GLfloat *dst = dest;
3363 GLuint i;
3364 assert(dstLuminanceIndex == 0);
3365 for (i = 0; i < n; i++) {
3366 /* Luminance comes from red channel */
3367 dst[0] = rgba[i][RCOMP];
3368 dst += dstComponents;
3369 }
3370 }
3371 }
3372 }
3373
3374
3375 /*
3376 * Unpack a row of color index data from a client buffer according to
3377 * the pixel unpacking parameters.
3378 * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.
3379 *
3380 * Args: ctx - the context
3381 * n - number of pixels
3382 * dstType - destination data type
3383 * dest - destination array
3384 * srcType - source pixel type
3385 * source - source data pointer
3386 * srcPacking - pixel unpacking parameters
3387 * transferOps - the pixel transfer operations to apply
3388 */
3389 void
3390 _mesa_unpack_index_span( const GLcontext *ctx, GLuint n,
3391 GLenum dstType, GLvoid *dest,
3392 GLenum srcType, const GLvoid *source,
3393 const struct gl_pixelstore_attrib *srcPacking,
3394 GLbitfield transferOps )
3395 {
3396 ASSERT(srcType == GL_BITMAP ||
3397 srcType == GL_UNSIGNED_BYTE ||
3398 srcType == GL_BYTE ||
3399 srcType == GL_UNSIGNED_SHORT ||
3400 srcType == GL_SHORT ||
3401 srcType == GL_UNSIGNED_INT ||
3402 srcType == GL_INT ||
3403 srcType == GL_HALF_FLOAT_ARB ||
3404 srcType == GL_FLOAT);
3405
3406 ASSERT(dstType == GL_UNSIGNED_BYTE ||
3407 dstType == GL_UNSIGNED_SHORT ||
3408 dstType == GL_UNSIGNED_INT);
3409
3410
3411 transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
3412
3413 /*
3414 * Try simple cases first
3415 */
3416 if (transferOps == 0 && srcType == GL_UNSIGNED_BYTE
3417 && dstType == GL_UNSIGNED_BYTE) {
3418 _mesa_memcpy(dest, source, n * sizeof(GLubyte));
3419 }
3420 else if (transferOps == 0 && srcType == GL_UNSIGNED_INT
3421 && dstType == GL_UNSIGNED_INT && !srcPacking->SwapBytes) {
3422 _mesa_memcpy(dest, source, n * sizeof(GLuint));
3423 }
3424 else {
3425 /*
3426 * general solution
3427 */
3428 GLuint indexes[MAX_WIDTH];
3429 assert(n <= MAX_WIDTH);
3430
3431 extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
3432 srcPacking);
3433
3434 if (transferOps)
3435 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
3436
3437 /* convert to dest type */
3438 switch (dstType) {
3439 case GL_UNSIGNED_BYTE:
3440 {
3441 GLubyte *dst = (GLubyte *) dest;
3442 GLuint i;
3443 for (i = 0; i < n; i++) {
3444 dst[i] = (GLubyte) (indexes[i] & 0xff);
3445 }
3446 }
3447 break;
3448 case GL_UNSIGNED_SHORT:
3449 {
3450 GLuint *dst = (GLuint *) dest;
3451 GLuint i;
3452 for (i = 0; i < n; i++) {
3453 dst[i] = (GLushort) (indexes[i] & 0xffff);
3454 }
3455 }
3456 break;
3457 case GL_UNSIGNED_INT:
3458 _mesa_memcpy(dest, indexes, n * sizeof(GLuint));
3459 break;
3460 default:
3461 _mesa_problem(ctx, "bad dstType in _mesa_unpack_index_span");
3462 }
3463 }
3464 }
3465
3466
3467 void
3468 _mesa_pack_index_span( const GLcontext *ctx, GLuint n,
3469 GLenum dstType, GLvoid *dest, const GLuint *source,
3470 const struct gl_pixelstore_attrib *dstPacking,
3471 GLbitfield transferOps )
3472 {
3473 GLuint indexes[MAX_WIDTH];
3474
3475 ASSERT(n <= MAX_WIDTH);
3476
3477 transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
3478
3479 if (transferOps & (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT)) {
3480 /* make a copy of input */
3481 _mesa_memcpy(indexes, source, n * sizeof(GLuint));
3482 if (transferOps) {
3483 _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
3484 }
3485 source = indexes;
3486 }
3487
3488 switch (dstType) {
3489 case GL_UNSIGNED_BYTE:
3490 {
3491 GLubyte *dst = (GLubyte *) dest;
3492 GLuint i;
3493 for (i = 0; i < n; i++) {
3494 *dst++ = (GLubyte) source[i];
3495 }
3496 }
3497 break;
3498 case GL_BYTE:
3499 {
3500 GLbyte *dst = (GLbyte *) dest;
3501 GLuint i;
3502 for (i = 0; i < n; i++) {
3503 dst[i] = (GLbyte) source[i];
3504 }
3505 }
3506 break;
3507 case GL_UNSIGNED_SHORT:
3508 {
3509 GLushort *dst = (GLushort *) dest;
3510 GLuint i;
3511 for (i = 0; i < n; i++) {
3512 dst[i] = (GLushort) source[i];
3513 }
3514 if (dstPacking->SwapBytes) {
3515 _mesa_swap2( (GLushort *) dst, n );
3516 }
3517 }
3518 break;
3519 case GL_SHORT:
3520 {
3521 GLshort *dst = (GLshort *) dest;
3522 GLuint i;
3523 for (i = 0; i < n; i++) {
3524 dst[i] = (GLshort) source[i];
3525 }
3526 if (dstPacking->SwapBytes) {
3527 _mesa_swap2( (GLushort *) dst, n );
3528 }
3529 }
3530 break;
3531 case GL_UNSIGNED_INT:
3532 {
3533 GLuint *dst = (GLuint *) dest;
3534 GLuint i;
3535 for (i = 0; i < n; i++) {
3536 dst[i] = (GLuint) source[i];
3537 }
3538 if (dstPacking->SwapBytes) {
3539 _mesa_swap4( (GLuint *) dst, n );
3540 }
3541 }
3542 break;
3543 case GL_INT:
3544 {
3545 GLint *dst = (GLint *) dest;
3546 GLuint i;
3547 for (i = 0; i < n; i++) {
3548 dst[i] = (GLint) source[i];
3549 }
3550 if (dstPacking->SwapBytes) {
3551 _mesa_swap4( (GLuint *) dst, n );
3552 }
3553 }
3554 break;
3555 case GL_FLOAT:
3556 {
3557 GLfloat *dst = (GLfloat *) dest;
3558 GLuint i;
3559 for (i = 0; i < n; i++) {
3560 dst[i] = (GLfloat) source[i];
3561 }
3562 if (dstPacking->SwapBytes) {
3563 _mesa_swap4( (GLuint *) dst, n );
3564 }
3565 }
3566 break;
3567 case GL_HALF_FLOAT_ARB:
3568 {
3569 GLhalfARB *dst = (GLhalfARB *) dest;
3570 GLuint i;
3571 for (i = 0; i < n; i++) {
3572 dst[i] = _mesa_float_to_half((GLfloat) source[i]);
3573 }
3574 if (dstPacking->SwapBytes) {
3575 _mesa_swap2( (GLushort *) dst, n );
3576 }
3577 }
3578 break;
3579 default:
3580 _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
3581 }
3582 }
3583
3584
3585 /*
3586 * Unpack a row of stencil data from a client buffer according to
3587 * the pixel unpacking parameters.
3588 * This is (or will be) used by glDrawPixels
3589 *
3590 * Args: ctx - the context
3591 * n - number of pixels
3592 * dstType - destination data type
3593 * dest - destination array
3594 * srcType - source pixel type
3595 * source - source data pointer
3596 * srcPacking - pixel unpacking parameters
3597 * transferOps - apply offset/bias/lookup ops?
3598 */
3599 void
3600 _mesa_unpack_stencil_span( const GLcontext *ctx, GLuint n,
3601 GLenum dstType, GLvoid *dest,
3602 GLenum srcType, const GLvoid *source,
3603 const struct gl_pixelstore_attrib *srcPacking,
3604 GLbitfield transferOps )
3605 {
3606 ASSERT(srcType == GL_BITMAP ||
3607 srcType == GL_UNSIGNED_BYTE ||
3608 srcType == GL_BYTE ||
3609 srcType == GL_UNSIGNED_SHORT ||
3610 srcType == GL_SHORT ||
3611 srcType == GL_UNSIGNED_INT ||
3612 srcType == GL_INT ||
3613 srcType == GL_UNSIGNED_INT_24_8_EXT ||
3614 srcType == GL_HALF_FLOAT_ARB ||
3615 srcType == GL_FLOAT);
3616
3617 ASSERT(dstType == GL_UNSIGNED_BYTE ||
3618 dstType == GL_UNSIGNED_SHORT ||
3619 dstType == GL_UNSIGNED_INT);
3620
3621 /* only shift and offset apply to stencil */
3622 transferOps &= IMAGE_SHIFT_OFFSET_BIT;
3623
3624 /*
3625 * Try simple cases first
3626 */
3627 if (transferOps == 0 &&
3628 srcType == GL_UNSIGNED_BYTE &&
3629 dstType == GL_UNSIGNED_BYTE) {
3630 _mesa_memcpy(dest, source, n * sizeof(GLubyte));
3631 }
3632 else if (transferOps == 0 &&
3633 srcType == GL_UNSIGNED_INT &&
3634 dstType == GL_UNSIGNED_INT &&
3635 !srcPacking->SwapBytes) {
3636 _mesa_memcpy(dest, source, n * sizeof(GLuint));
3637 }
3638 else {
3639 /*
3640 * general solution
3641 */
3642 GLuint indexes[MAX_WIDTH];
3643 assert(n <= MAX_WIDTH);
3644
3645 extract_uint_indexes(n, indexes, GL_STENCIL_INDEX, srcType, source,
3646 srcPacking);
3647
3648 if (transferOps) {
3649 if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
3650 /* shift and offset indexes */
3651 shift_and_offset_ci(ctx, n, indexes);
3652 }
3653
3654 if (ctx->Pixel.MapStencilFlag) {
3655 /* Apply stencil lookup table */
3656 GLuint mask = ctx->Pixel.MapStoSsize - 1;
3657 GLuint i;
3658 for (i=0;i<n;i++) {
3659 indexes[i] = ctx->Pixel.MapStoS[ indexes[i] & mask ];
3660 }
3661 }
3662 }
3663
3664 /* convert to dest type */
3665 switch (dstType) {
3666 case GL_UNSIGNED_BYTE:
3667 {
3668 GLubyte *dst = (GLubyte *) dest;
3669 GLuint i;
3670 for (i = 0; i < n; i++) {
3671 dst[i] = (GLubyte) (indexes[i] & 0xff);
3672 }
3673 }
3674 break;
3675 case GL_UNSIGNED_SHORT:
3676 {
3677 GLuint *dst = (GLuint *) dest;
3678 GLuint i;
3679 for (i = 0; i < n; i++) {
3680 dst[i] = (GLushort) (indexes[i] & 0xffff);
3681 }
3682 }
3683 break;
3684 case GL_UNSIGNED_INT:
3685 _mesa_memcpy(dest, indexes, n * sizeof(GLuint));
3686 break;
3687 default:
3688 _mesa_problem(ctx, "bad dstType in _mesa_unpack_stencil_span");
3689 }
3690 }
3691 }
3692
3693
3694 void
3695 _mesa_pack_stencil_span( const GLcontext *ctx, GLuint n,
3696 GLenum dstType, GLvoid *dest, const GLstencil *source,
3697 const struct gl_pixelstore_attrib *dstPacking )
3698 {
3699 GLstencil stencil[MAX_WIDTH];
3700
3701 ASSERT(n <= MAX_WIDTH);
3702
3703 if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset ||
3704 ctx->Pixel.MapStencilFlag) {
3705 /* make a copy of input */
3706 _mesa_memcpy(stencil, source, n * sizeof(GLstencil));
3707 _mesa_apply_stencil_transfer_ops(ctx, n, stencil);
3708 source = stencil;
3709 }
3710
3711 switch (dstType) {
3712 case GL_UNSIGNED_BYTE:
3713 if (sizeof(GLstencil) == 8) {
3714 _mesa_memcpy( dest, source, n );
3715 }
3716 else {
3717 GLubyte *dst = (GLubyte *) dest;
3718 GLuint i;
3719 for (i=0;i<n;i++) {
3720 dst[i] = (GLubyte) source[i];
3721 }
3722 }
3723 break;
3724 case GL_BYTE:
3725 if (sizeof(GLstencil) == 8) {
3726 _mesa_memcpy( dest, source, n );
3727 }
3728 else {
3729 GLbyte *dst = (GLbyte *) dest;
3730 GLuint i;
3731 for (i=0;i<n;i++) {
3732 dst[i] = (GLbyte) source[i];
3733 }
3734 }
3735 break;
3736 case GL_UNSIGNED_SHORT:
3737 {
3738 GLushort *dst = (GLushort *) dest;
3739 GLuint i;
3740 for (i=0;i<n;i++) {
3741 dst[i] = (GLushort) source[i];
3742 }
3743 if (dstPacking->SwapBytes) {
3744 _mesa_swap2( (GLushort *) dst, n );
3745 }
3746 }
3747 break;
3748 case GL_SHORT:
3749 {
3750 GLshort *dst = (GLshort *) dest;
3751 GLuint i;
3752 for (i=0;i<n;i++) {
3753 dst[i] = (GLshort) source[i];
3754 }
3755 if (dstPacking->SwapBytes) {
3756 _mesa_swap2( (GLushort *) dst, n );
3757 }
3758 }
3759 break;
3760 case GL_UNSIGNED_INT:
3761 {
3762 GLuint *dst = (GLuint *) dest;
3763 GLuint i;
3764 for (i=0;i<n;i++) {
3765 dst[i] = (GLuint) source[i];
3766 }
3767 if (dstPacking->SwapBytes) {
3768 _mesa_swap4( (GLuint *) dst, n );
3769 }
3770 }
3771 break;
3772 case GL_INT:
3773 {
3774 GLint *dst = (GLint *) dest;
3775 GLuint i;
3776 for (i=0;i<n;i++) {
3777 *dst++ = (GLint) source[i];
3778 }
3779 if (dstPacking->SwapBytes) {
3780 _mesa_swap4( (GLuint *) dst, n );
3781 }
3782 }
3783 break;
3784 case GL_FLOAT:
3785 {
3786 GLfloat *dst = (GLfloat *) dest;
3787 GLuint i;
3788 for (i=0;i<n;i++) {
3789 dst[i] = (GLfloat) source[i];
3790 }
3791 if (dstPacking->SwapBytes) {
3792 _mesa_swap4( (GLuint *) dst, n );
3793 }
3794 }
3795 break;
3796 case GL_HALF_FLOAT_ARB:
3797 {
3798 GLhalfARB *dst = (GLhalfARB *) dest;
3799 GLuint i;
3800 for (i=0;i<n;i++) {
3801 dst[i] = _mesa_float_to_half( (float) source[i] );
3802 }
3803 if (dstPacking->SwapBytes) {
3804 _mesa_swap2( (GLushort *) dst, n );
3805 }
3806 }
3807 break;
3808 case GL_BITMAP:
3809 if (dstPacking->LsbFirst) {
3810 GLubyte *dst = (GLubyte *) dest;
3811 GLint shift = 0;
3812 GLuint i;
3813 for (i = 0; i < n; i++) {
3814 if (shift == 0)
3815 *dst = 0;
3816 *dst |= ((source[i] != 0) << shift);
3817 shift++;
3818 if (shift == 8) {
3819 shift = 0;
3820 dst++;
3821 }
3822 }
3823 }
3824 else {
3825 GLubyte *dst = (GLubyte *) dest;
3826 GLint shift = 7;
3827 GLuint i;
3828 for (i = 0; i < n; i++) {
3829 if (shift == 7)
3830 *dst = 0;
3831 *dst |= ((source[i] != 0) << shift);
3832 shift--;
3833 if (shift < 0) {
3834 shift = 7;
3835 dst++;
3836 }
3837 }
3838 }
3839 break;
3840 default:
3841 _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
3842 }
3843 }
3844
3845
3846 void
3847 _mesa_unpack_depth_span( const GLcontext *ctx, GLuint n,
3848 GLenum dstType, GLvoid *dest, GLfloat depthScale,
3849 GLenum srcType, const GLvoid *source,
3850 const struct gl_pixelstore_attrib *srcPacking )
3851 {
3852 GLfloat depthTemp[MAX_WIDTH], *depthValues;
3853
3854 if (dstType == GL_FLOAT) {
3855 depthValues = (GLfloat *) dest;
3856 }
3857 else {
3858 depthValues = depthTemp;
3859 }
3860
3861 /* XXX we need to obey srcPacking->SwapBytes here!!! */
3862 (void) srcPacking;
3863
3864 switch (srcType) {
3865 case GL_BYTE:
3866 {
3867 GLuint i;
3868 const GLubyte *src = (const GLubyte *) source;
3869 for (i = 0; i < n; i++) {
3870 depthValues[i] = BYTE_TO_FLOAT(src[i]);
3871 }
3872 }
3873 break;
3874 case GL_UNSIGNED_BYTE:
3875 {
3876 GLuint i;
3877 const GLubyte *src = (const GLubyte *) source;
3878 for (i = 0; i < n; i++) {
3879 depthValues[i] = UBYTE_TO_FLOAT(src[i]);
3880 }
3881 }
3882 break;
3883 case GL_SHORT:
3884 {
3885 GLuint i;
3886 const GLshort *src = (const GLshort *) source;
3887 for (i = 0; i < n; i++) {
3888 depthValues[i] = SHORT_TO_FLOAT(src[i]);
3889 }
3890 }
3891 break;
3892 case GL_UNSIGNED_SHORT:
3893 {
3894 GLuint i;
3895 const GLushort *src = (const GLushort *) source;
3896 for (i = 0; i < n; i++) {
3897 depthValues[i] = USHORT_TO_FLOAT(src[i]);
3898 }
3899 }
3900 break;
3901 case GL_INT:
3902 {
3903 GLuint i;
3904 const GLint *src = (const GLint *) source;
3905 for (i = 0; i < n; i++) {
3906 depthValues[i] = INT_TO_FLOAT(src[i]);
3907 }
3908 }
3909 break;
3910 case GL_UNSIGNED_INT:
3911 {
3912 GLuint i;
3913 const GLuint *src = (const GLuint *) source;
3914 for (i = 0; i < n; i++) {
3915 depthValues[i] = UINT_TO_FLOAT(src[i]);
3916 }
3917 }
3918 break;
3919 case GL_UNSIGNED_INT_24_8_EXT: /* GL_EXT_packed_depth_stencil */
3920 if (dstType == GL_UNSIGNED_INT &&
3921 depthScale == (GLfloat) 0xffffff &&
3922 ctx->Pixel.DepthScale == 1.0 &&
3923 ctx->Pixel.DepthBias == 0.0) {
3924 const GLuint *src = (const GLuint *) source;
3925 GLuint *zValues = (GLuint *) dest;
3926 GLuint i;
3927 for (i = 0; i < n; i++) {
3928 zValues[i] = src[i] & 0xffffff00;
3929 }
3930 return;
3931 }
3932 else {
3933 const GLuint *src = (const GLuint *) source;
3934 const GLfloat scale = 1.0f / 0xffffff;
3935 GLuint i;
3936 for (i = 0; i < n; i++) {
3937 depthValues[i] = (src[i] >> 8) * scale;
3938 }
3939 }
3940 break;
3941 case GL_FLOAT:
3942 _mesa_memcpy(depthValues, source, n * sizeof(GLfloat));
3943 break;
3944 case GL_HALF_FLOAT_ARB:
3945 {
3946 GLuint i;
3947 const GLhalfARB *src = (const GLhalfARB *) source;
3948 for (i = 0; i < n; i++) {
3949 depthValues[i] = _mesa_half_to_float(src[i]);
3950 }
3951 }
3952 break;
3953 default:
3954 _mesa_problem(NULL, "bad type in _mesa_unpack_depth_span()");
3955 return;
3956 }
3957
3958
3959 /* apply depth scale and bias and clamp to [0,1] */
3960 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
3961 _mesa_scale_and_bias_depth(ctx, n, depthValues);
3962 }
3963
3964 if (dstType == GL_UNSIGNED_INT) {
3965 GLuint *zValues = (GLuint *) dest;
3966 GLuint i;
3967 if (depthScale <= (GLfloat) 0xffffff) {
3968 /* no overflow worries */
3969 for (i = 0; i < n; i++) {
3970 zValues[i] = (GLuint) (depthValues[i] * depthScale);
3971 }
3972 }
3973 else {
3974 /* need to use double precision to prevent overflow problems */
3975 for (i = 0; i < n; i++) {
3976 GLdouble z = depthValues[i] * depthScale;
3977 if (z >= (GLdouble) 0xffffffff)
3978 zValues[i] = 0xffffffff;
3979 else
3980 zValues[i] = (GLuint) z;
3981 }
3982 }
3983 }
3984 else if (dstType == GL_UNSIGNED_SHORT) {
3985 GLushort *zValues = (GLushort *) dest;
3986 GLuint i;
3987 ASSERT(depthScale <= 65535.0);
3988 for (i = 0; i < n; i++) {
3989 zValues[i] = (GLushort) (depthValues[i] * depthScale);
3990 }
3991 }
3992 else {
3993 ASSERT(dstType == GL_FLOAT);
3994 ASSERT(depthScale == 1.0F);
3995 }
3996 }
3997
3998
3999 /*
4000 * Pack an array of depth values. The values are floats in [0,1].
4001 */
4002 void
4003 _mesa_pack_depth_span( const GLcontext *ctx, GLuint n, GLvoid *dest,
4004 GLenum dstType, const GLfloat *depthSpan,
4005 const struct gl_pixelstore_attrib *dstPacking )
4006 {
4007 GLfloat depthCopy[MAX_WIDTH];
4008
4009 ASSERT(n <= MAX_WIDTH);
4010
4011 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
4012 _mesa_memcpy(depthCopy, depthSpan, n * sizeof(GLfloat));
4013 _mesa_scale_and_bias_depth(ctx, n, depthCopy);
4014 depthSpan = depthCopy;
4015 }
4016
4017 switch (dstType) {
4018 case GL_UNSIGNED_BYTE:
4019 {
4020 GLubyte *dst = (GLubyte *) dest;
4021 GLuint i;
4022 for (i = 0; i < n; i++) {
4023 dst[i] = FLOAT_TO_UBYTE( depthSpan[i] );
4024 }
4025 }
4026 break;
4027 case GL_BYTE:
4028 {
4029 GLbyte *dst = (GLbyte *) dest;
4030 GLuint i;
4031 for (i = 0; i < n; i++) {
4032 dst[i] = FLOAT_TO_BYTE( depthSpan[i] );
4033 }
4034 }
4035 break;
4036 case GL_UNSIGNED_SHORT:
4037 {
4038 GLushort *dst = (GLushort *) dest;
4039 GLuint i;
4040 for (i = 0; i < n; i++) {
4041 CLAMPED_FLOAT_TO_USHORT(dst[i], depthSpan[i]);
4042 }
4043 if (dstPacking->SwapBytes) {
4044 _mesa_swap2( (GLushort *) dst, n );
4045 }
4046 }
4047 break;
4048 case GL_SHORT:
4049 {
4050 GLshort *dst = (GLshort *) dest;
4051 GLuint i;
4052 for (i = 0; i < n; i++) {
4053 dst[i] = FLOAT_TO_SHORT( depthSpan[i] );
4054 }
4055 if (dstPacking->SwapBytes) {
4056 _mesa_swap2( (GLushort *) dst, n );
4057 }
4058 }
4059 break;
4060 case GL_UNSIGNED_INT:
4061 {
4062 GLuint *dst = (GLuint *) dest;
4063 GLuint i;
4064 for (i = 0; i < n; i++) {
4065 dst[i] = FLOAT_TO_UINT( depthSpan[i] );
4066 }
4067 if (dstPacking->SwapBytes) {
4068 _mesa_swap4( (GLuint *) dst, n );
4069 }
4070 }
4071 break;
4072 case GL_INT:
4073 {
4074 GLint *dst = (GLint *) dest;
4075 GLuint i;
4076 for (i = 0; i < n; i++) {
4077 dst[i] = FLOAT_TO_INT( depthSpan[i] );
4078 }
4079 if (dstPacking->SwapBytes) {
4080 _mesa_swap4( (GLuint *) dst, n );
4081 }
4082 }
4083 break;
4084 case GL_FLOAT:
4085 {
4086 GLfloat *dst = (GLfloat *) dest;
4087 GLuint i;
4088 for (i = 0; i < n; i++) {
4089 dst[i] = depthSpan[i];
4090 }
4091 if (dstPacking->SwapBytes) {
4092 _mesa_swap4( (GLuint *) dst, n );
4093 }
4094 }
4095 break;
4096 case GL_HALF_FLOAT_ARB:
4097 {
4098 GLhalfARB *dst = (GLhalfARB *) dest;
4099 GLuint i;
4100 for (i = 0; i < n; i++) {
4101 dst[i] = _mesa_float_to_half(depthSpan[i]);
4102 }
4103 if (dstPacking->SwapBytes) {
4104 _mesa_swap2( (GLushort *) dst, n );
4105 }
4106 }
4107 break;
4108 default:
4109 _mesa_problem(ctx, "bad type in _mesa_pack_depth_span");
4110 }
4111 }
4112
4113
4114
4115 /**
4116 * Pack depth and stencil values as GL_DEPTH_STENCIL/GL_UNSIGNED_INT_24_8.
4117 */
4118 void
4119 _mesa_pack_depth_stencil_span(const GLcontext *ctx, GLuint n, GLuint *dest,
4120 const GLfloat *depthVals,
4121 const GLstencil *stencilVals,
4122 const struct gl_pixelstore_attrib *dstPacking)
4123 {
4124 GLfloat depthCopy[MAX_WIDTH];
4125 GLstencil stencilCopy[MAX_WIDTH];
4126 GLuint i;
4127
4128 ASSERT(n <= MAX_WIDTH);
4129
4130 if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
4131 _mesa_memcpy(depthCopy, depthVals, n * sizeof(GLfloat));
4132 _mesa_scale_and_bias_depth(ctx, n, depthCopy);
4133 depthVals = depthCopy;
4134 }
4135
4136 if (ctx->Pixel.IndexShift ||
4137 ctx->Pixel.IndexOffset ||
4138 ctx->Pixel.MapStencilFlag) {
4139 _mesa_memcpy(stencilCopy, stencilVals, n * sizeof(GLstencil));
4140 _mesa_apply_stencil_transfer_ops(ctx, n, stencilCopy);
4141 stencilVals = stencilCopy;
4142 }
4143
4144 for (i = 0; i < n; i++) {
4145 GLuint z = (GLuint) (depthVals[i] * 0xffffff);
4146 dest[i] = (z << 8) | (stencilVals[i] & 0xff);
4147 }
4148
4149 if (dstPacking->SwapBytes) {
4150 _mesa_swap4(dest, n);
4151 }
4152 }
4153
4154
4155
4156
4157 /**
4158 * Unpack image data. Apply byte swapping, byte flipping (bitmap).
4159 * Return all image data in a contiguous block. This is used when we
4160 * compile glDrawPixels, glTexImage, etc into a display list. We
4161 * need a copy of the data in a standard format.
4162 */
4163 void *
4164 _mesa_unpack_image( GLuint dimensions,
4165 GLsizei width, GLsizei height, GLsizei depth,
4166 GLenum format, GLenum type, const GLvoid *pixels,
4167 const struct gl_pixelstore_attrib *unpack )
4168 {
4169 GLint bytesPerRow, compsPerRow;
4170 GLboolean flipBytes, swap2, swap4;
4171
4172 if (!pixels)
4173 return NULL; /* not necessarily an error */
4174
4175 if (width <= 0 || height <= 0 || depth <= 0)
4176 return NULL; /* generate error later */
4177
4178 if (format == GL_BITMAP) {
4179 bytesPerRow = (width + 7) >> 3;
4180 flipBytes = !unpack->LsbFirst;
4181 swap2 = swap4 = GL_FALSE;
4182 compsPerRow = 0;
4183 }
4184 else {
4185 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
4186 const GLint components = _mesa_components_in_format(format);
4187 GLint bytesPerComp;
4188 if (bytesPerPixel <= 0 || components <= 0)
4189 return NULL; /* bad format or type. generate error later */
4190 bytesPerRow = bytesPerPixel * width;
4191 bytesPerComp = bytesPerPixel / components;
4192 flipBytes = GL_FALSE;
4193 swap2 = (bytesPerComp == 2) && unpack->SwapBytes;
4194 swap4 = (bytesPerComp == 4) && unpack->SwapBytes;
4195 compsPerRow = components * width;
4196 assert(compsPerRow >= width);
4197 }
4198
4199 {
4200 GLubyte *destBuffer
4201 = (GLubyte *) _mesa_malloc(bytesPerRow * height * depth);
4202 GLubyte *dst;
4203 GLint img, row;
4204 if (!destBuffer)
4205 return NULL; /* generate GL_OUT_OF_MEMORY later */
4206
4207 dst = destBuffer;
4208 for (img = 0; img < depth; img++) {
4209 for (row = 0; row < height; row++) {
4210 const GLvoid *src = _mesa_image_address(dimensions, unpack, pixels,
4211 width, height, format, type, img, row, 0);
4212 _mesa_memcpy(dst, src, bytesPerRow);
4213 /* byte flipping/swapping */
4214 if (flipBytes) {
4215 flip_bytes((GLubyte *) dst, bytesPerRow);
4216 }
4217 else if (swap2) {
4218 _mesa_swap2((GLushort*) dst, compsPerRow);
4219 }
4220 else if (swap4) {
4221 _mesa_swap4((GLuint*) dst, compsPerRow);
4222 }
4223 dst += bytesPerRow;
4224 }
4225 }
4226 return destBuffer;
4227 }
4228 }
4229
4230 #endif /* _HAVE_FULL_GL */
4231
4232
4233
4234 /**
4235 * Convert an array of RGBA colors from one datatype to another.
4236 * NOTE: src may equal dst. In that case, we use a temporary buffer.
4237 */
4238 void
4239 _mesa_convert_colors(GLenum srcType, const GLvoid *src,
4240 GLenum dstType, GLvoid *dst,
4241 GLuint count, const GLubyte mask[])
4242 {
4243 GLuint tempBuffer[MAX_WIDTH][4];
4244 const GLboolean useTemp = (src == dst);
4245
4246 ASSERT(srcType != dstType);
4247
4248 switch (srcType) {
4249 case GL_UNSIGNED_BYTE:
4250 if (dstType == GL_UNSIGNED_SHORT) {
4251 const GLubyte (*src1)[4] = (const GLubyte (*)[4]) src;
4252 GLushort (*dst2)[4] = (GLushort (*)[4]) (useTemp ? tempBuffer : dst);
4253 GLuint i;
4254 for (i = 0; i < count; i++) {
4255 if (!mask || mask[i]) {
4256 dst2[i][RCOMP] = UBYTE_TO_USHORT(src1[i][RCOMP]);
4257 dst2[i][GCOMP] = UBYTE_TO_USHORT(src1[i][GCOMP]);
4258 dst2[i][BCOMP] = UBYTE_TO_USHORT(src1[i][BCOMP]);
4259 dst2[i][ACOMP] = UBYTE_TO_USHORT(src1[i][ACOMP]);
4260 }
4261 }
4262 if (useTemp)
4263 _mesa_memcpy(dst, tempBuffer, count * 4 * sizeof(GLushort));
4264 }
4265 else {
4266 const GLubyte (*src1)[4] = (const GLubyte (*)[4]) src;
4267 GLfloat (*dst4)[4] = (GLfloat (*)[4]) (useTemp ? tempBuffer : dst);
4268 GLuint i;
4269 ASSERT(dstType == GL_FLOAT);
4270 for (i = 0; i < count; i++) {
4271 if (!mask || mask[i]) {
4272 dst4[i][RCOMP] = UBYTE_TO_FLOAT(src1[i][RCOMP]);
4273 dst4[i][GCOMP] = UBYTE_TO_FLOAT(src1[i][GCOMP]);
4274 dst4[i][BCOMP] = UBYTE_TO_FLOAT(src1[i][BCOMP]);
4275 dst4[i][ACOMP] = UBYTE_TO_FLOAT(src1[i][ACOMP]);
4276 }
4277 }
4278 if (useTemp)
4279 _mesa_memcpy(dst, tempBuffer, count * 4 * sizeof(GLfloat));
4280 }
4281 break;
4282 case GL_UNSIGNED_SHORT:
4283 if (dstType == GL_UNSIGNED_BYTE) {
4284 const GLushort (*src2)[4] = (const GLushort (*)[4]) src;
4285 GLubyte (*dst1)[4] = (GLubyte (*)[4]) (useTemp ? tempBuffer : dst);
4286 GLuint i;
4287 for (i = 0; i < count; i++) {
4288 if (!mask || mask[i]) {
4289 dst1[i][RCOMP] = USHORT_TO_UBYTE(src2[i][RCOMP]);
4290 dst1[i][GCOMP] = USHORT_TO_UBYTE(src2[i][GCOMP]);
4291 dst1[i][BCOMP] = USHORT_TO_UBYTE(src2[i][BCOMP]);
4292 dst1[i][ACOMP] = USHORT_TO_UBYTE(src2[i][ACOMP]);
4293 }
4294 }
4295 if (useTemp)
4296 _mesa_memcpy(dst, tempBuffer, count * 4 * sizeof(GLubyte));
4297 }
4298 else {
4299 const GLushort (*src2)[4] = (const GLushort (*)[4]) src;
4300 GLfloat (*dst4)[4] = (GLfloat (*)[4]) (useTemp ? tempBuffer : dst);
4301 GLuint i;
4302 ASSERT(dstType == GL_FLOAT);
4303 for (i = 0; i < count; i++) {
4304 if (!mask || mask[i]) {
4305 dst4[i][RCOMP] = USHORT_TO_FLOAT(src2[i][RCOMP]);
4306 dst4[i][GCOMP] = USHORT_TO_FLOAT(src2[i][GCOMP]);
4307 dst4[i][BCOMP] = USHORT_TO_FLOAT(src2[i][BCOMP]);
4308 dst4[i][ACOMP] = USHORT_TO_FLOAT(src2[i][ACOMP]);
4309 }
4310 }
4311 if (useTemp)
4312 _mesa_memcpy(dst, tempBuffer, count * 4 * sizeof(GLfloat));
4313 }
4314 break;
4315 case GL_FLOAT:
4316 if (dstType == GL_UNSIGNED_BYTE) {
4317 const GLfloat (*src4)[4] = (const GLfloat (*)[4]) src;
4318 GLubyte (*dst1)[4] = (GLubyte (*)[4]) (useTemp ? tempBuffer : dst);
4319 GLuint i;
4320 for (i = 0; i < count; i++) {
4321 if (!mask || mask[i]) {
4322 UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][RCOMP], src4[i][RCOMP]);
4323 UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][GCOMP], src4[i][GCOMP]);
4324 UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][BCOMP], src4[i][BCOMP]);
4325 UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][ACOMP], src4[i][ACOMP]);
4326 }
4327 }
4328 if (useTemp)
4329 _mesa_memcpy(dst, tempBuffer, count * 4 * sizeof(GLubyte));
4330 }
4331 else {
4332 const GLfloat (*src4)[4] = (const GLfloat (*)[4]) src;
4333 GLushort (*dst2)[4] = (GLushort (*)[4]) (useTemp ? tempBuffer : dst);
4334 GLuint i;
4335 ASSERT(dstType == GL_UNSIGNED_SHORT);
4336 for (i = 0; i < count; i++) {
4337 if (!mask || mask[i]) {
4338 UNCLAMPED_FLOAT_TO_USHORT(dst2[i][RCOMP], src4[i][RCOMP]);
4339 UNCLAMPED_FLOAT_TO_USHORT(dst2[i][GCOMP], src4[i][GCOMP]);
4340 UNCLAMPED_FLOAT_TO_USHORT(dst2[i][BCOMP], src4[i][BCOMP]);
4341 UNCLAMPED_FLOAT_TO_USHORT(dst2[i][ACOMP], src4[i][ACOMP]);
4342 }
4343 }
4344 if (useTemp)
4345 _mesa_memcpy(dst, tempBuffer, count * 4 * sizeof(GLushort));
4346 }
4347 break;
4348 default:
4349 _mesa_problem(NULL, "Invalid datatype in _mesa_convert_colors");
4350 }
4351 }
4352
4353
4354
4355
4356 /**
4357 * Perform basic clipping for glDrawPixels. The image's position and size
4358 * and the unpack SkipPixels and SkipRows are adjusted so that the image
4359 * region is entirely within the window and scissor bounds.
4360 * NOTE: this will only work when glPixelZoom is (1, 1) or (1, -1).
4361 * If Pixel.ZoomY is -1, *destY will be changed to be the first row which
4362 * we'll actually write. Beforehand, *destY-1 is the first drawing row.
4363 *
4364 * \return GL_TRUE if image is ready for drawing or
4365 * GL_FALSE if image was completely clipped away (draw nothing)
4366 */
4367 GLboolean
4368 _mesa_clip_drawpixels(const GLcontext *ctx,
4369 GLint *destX, GLint *destY,
4370 GLsizei *width, GLsizei *height,
4371 struct gl_pixelstore_attrib *unpack)
4372 {
4373 const GLframebuffer *buffer = ctx->DrawBuffer;
4374
4375 if (unpack->RowLength == 0) {
4376 unpack->RowLength = *width;
4377 }
4378
4379 ASSERT(ctx->Pixel.ZoomX == 1.0F);
4380 ASSERT(ctx->Pixel.ZoomY == 1.0F || ctx->Pixel.ZoomY == -1.0F);
4381
4382 /* left clipping */
4383 if (*destX < buffer->_Xmin) {
4384 unpack->SkipPixels += (buffer->_Xmin - *destX);
4385 *width -= (buffer->_Xmin - *destX);
4386 *destX = buffer->_Xmin;
4387 }
4388 /* right clipping */
4389 if (*destX + *width > buffer->_Xmax)
4390 *width -= (*destX + *width - buffer->_Xmax);
4391
4392 if (*width <= 0)
4393 return GL_FALSE;
4394
4395 if (ctx->Pixel.ZoomY == 1.0F) {
4396 /* bottom clipping */
4397 if (*destY < buffer->_Ymin) {
4398 unpack->SkipRows += (buffer->_Ymin - *destY);
4399 *height -= (buffer->_Ymin - *destY);
4400 *destY = buffer->_Ymin;
4401 }
4402 /* top clipping */
4403 if (*destY + *height > buffer->_Ymax)
4404 *height -= (*destY + *height - buffer->_Ymax);
4405 }
4406 else { /* upside down */
4407 /* top clipping */
4408 if (*destY > buffer->_Ymax) {
4409 unpack->SkipRows += (*destY - buffer->_Ymax);
4410 *height -= (*destY - buffer->_Ymax);
4411 *destY = buffer->_Ymax;
4412 }
4413 /* bottom clipping */
4414 if (*destY - *height < buffer->_Ymin)
4415 *height -= (buffer->_Ymin - (*destY - *height));
4416 /* adjust destY so it's the first row to write to */
4417 (*destY)--;
4418 }
4419
4420 if (*height <= 0)
4421 return GL_TRUE;
4422
4423 return GL_TRUE;
4424 }
4425
4426
4427 /**
4428 * Perform clipping for glReadPixels. The image's window position
4429 * and size, and the pack skipPixels, skipRows and rowLength are adjusted
4430 * so that the image region is entirely within the window bounds.
4431 * Note: this is different from _mesa_clip_drawpixels() in that the
4432 * scissor box is ignored, and we use the bounds of the current readbuffer
4433 * surface.
4434 *
4435 * \return GL_TRUE if image is ready for drawing or
4436 * GL_FALSE if image was completely clipped away (draw nothing)
4437 */
4438 GLboolean
4439 _mesa_clip_readpixels(const GLcontext *ctx,
4440 GLint *srcX, GLint *srcY,
4441 GLsizei *width, GLsizei *height,
4442 struct gl_pixelstore_attrib *pack)
4443 {
4444 const GLframebuffer *buffer = ctx->ReadBuffer;
4445
4446 if (pack->RowLength == 0) {
4447 pack->RowLength = *width;
4448 }
4449
4450 /* left clipping */
4451 if (*srcX < 0) {
4452 pack->SkipPixels += (0 - *srcX);
4453 *width -= (0 - *srcX);
4454 *srcX = 0;
4455 }
4456 /* right clipping */
4457 if (*srcX + *width > (GLsizei) buffer->Width)
4458 *width -= (*srcX + *width - buffer->Width);
4459
4460 if (*width <= 0)
4461 return GL_FALSE;
4462
4463 /* bottom clipping */
4464 if (*srcY < 0) {
4465 pack->SkipRows += (0 - *srcY);
4466 *height -= (0 - *srcY);
4467 *srcY = 0;
4468 }
4469 /* top clipping */
4470 if (*srcY + *height > (GLsizei) buffer->Height)
4471 *height -= (*srcY + *height - buffer->Height);
4472
4473 if (*height <= 0)
4474 return GL_TRUE;
4475
4476 return GL_TRUE;
4477 }
4478
4479
4480 /**
4481 * Clip the rectangle defined by (x, y, width, height) against the bounds
4482 * specified by [xmin, xmax) and [ymin, ymax).
4483 * \return GL_FALSE if rect is totally clipped, GL_TRUE otherwise.
4484 */
4485 GLboolean
4486 _mesa_clip_to_region(GLint xmin, GLint ymin,
4487 GLint xmax, GLint ymax,
4488 GLint *x, GLint *y,
4489 GLsizei *width, GLsizei *height )
4490 {
4491 /* left clipping */
4492 if (*x < xmin) {
4493 *width -= (xmin - *x);
4494 *x = xmin;
4495 }
4496
4497 /* right clipping */
4498 if (*x + *width > xmax)
4499 *width -= (*x + *width - xmax - 1);
4500
4501 if (*width <= 0)
4502 return GL_FALSE;
4503
4504 /* bottom (or top) clipping */
4505 if (*y < ymin) {
4506 *height -= (ymin - *y);
4507 *y = ymin;
4508 }
4509
4510 /* top (or bottom) clipping */
4511 if (*y + *height > ymax)
4512 *height -= (*y + *height - ymax - 1);
4513
4514 if (*height <= 0)
4515 return GL_FALSE;
4516
4517 return GL_TRUE;
4518 }