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