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