image.c revision 98b607b57da6f7d2ae6e02906c1ae72cd1c3f311 
1/* $Id: image.c,v 1.10 1999/10/26 09:21:04 brianp Exp $ */
2
3/*
4 * Mesa 3-D graphics library
5 * Version:  3.1
6 *
7 * Copyright (C) 1999  Brian Paul   All Rights Reserved.
8 *
9 * Permission is hereby granted, free of charge, to any person obtaining a
10 * copy of this software and associated documentation files (the "Software"),
11 * to deal in the Software without restriction, including without limitation
12 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
13 * and/or sell copies of the Software, and to permit persons to whom the
14 * Software is furnished to do so, subject to the following conditions:
15 *
16 * The above copyright notice and this permission notice shall be included
17 * in all copies or substantial portions of the Software.
18 *
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
20 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
22 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
23 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
24 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 */
26
27
28
29#ifdef PC_HEADER
30#include "all.h"
31#else
32#ifndef XFree86Server
33#include <assert.h>
34#include <stdlib.h>
35#include <string.h>
36#else
37#include "GL/xf86glx.h"
38#endif
39#include "context.h"
40#include "image.h"
41#include "macros.h"
42#include "mmath.h"
43#include "pixel.h"
44#include "types.h"
45#ifdef XFree86Server
46#include "GL/xf86glx.h"
47#endif
48#endif
49
50
51
52/*
53 * Flip the 8 bits in each byte of the given array.
54 */
55void gl_flip_bytes( GLubyte *p, GLuint n )
56{
57   register GLuint i, a, b;
58
59   for (i=0;i<n;i++) {
60      b = (GLuint) p[i];
61      a = ((b & 0x01) << 7) |
62	  ((b & 0x02) << 5) |
63	  ((b & 0x04) << 3) |
64	  ((b & 0x08) << 1) |
65	  ((b & 0x10) >> 1) |
66	  ((b & 0x20) >> 3) |
67	  ((b & 0x40) >> 5) |
68	  ((b & 0x80) >> 7);
69      p[i] = (GLubyte) a;
70   }
71}
72
73
74/*
75 * Flip the order of the 2 bytes in each word in the given array.
76 */
77void gl_swap2( GLushort *p, GLuint n )
78{
79   register GLuint i;
80
81   for (i=0;i<n;i++) {
82      p[i] = (p[i] >> 8) | ((p[i] << 8) & 0xff00);
83   }
84}
85
86
87
88/*
89 * Flip the order of the 4 bytes in each word in the given array.
90 */
91void gl_swap4( GLuint *p, GLuint n )
92{
93   register GLuint i, a, b;
94
95   for (i=0;i<n;i++) {
96      b = p[i];
97      a =  (b >> 24)
98	| ((b >> 8) & 0xff00)
99	| ((b << 8) & 0xff0000)
100	| ((b << 24) & 0xff000000);
101      p[i] = a;
102   }
103}
104
105
106
107
108/*
109 * Return the size, in bytes, of the given GL datatype.
110 * Return 0 if GL_BITMAP.
111 * Return -1 if invalid type enum.
112 */
113GLint gl_sizeof_type( GLenum type )
114{
115   switch (type) {
116      case GL_BITMAP:
117	 return 0;
118      case GL_UNSIGNED_BYTE:
119         return sizeof(GLubyte);
120      case GL_BYTE:
121	 return sizeof(GLbyte);
122      case GL_UNSIGNED_SHORT:
123	 return sizeof(GLushort);
124      case GL_SHORT:
125	 return sizeof(GLshort);
126      case GL_UNSIGNED_INT:
127	 return sizeof(GLuint);
128      case GL_INT:
129	 return sizeof(GLint);
130      case GL_FLOAT:
131	 return sizeof(GLfloat);
132      default:
133         return -1;
134   }
135}
136
137
138/*
139 * Same as gl_sizeof_packed_type() but we also accept the
140 * packed pixel format datatypes.
141 */
142GLint gl_sizeof_packed_type( GLenum type )
143{
144   switch (type) {
145      case GL_BITMAP:
146	 return 0;
147      case GL_UNSIGNED_BYTE:
148         return sizeof(GLubyte);
149      case GL_BYTE:
150	 return sizeof(GLbyte);
151      case GL_UNSIGNED_SHORT:
152	 return sizeof(GLushort);
153      case GL_SHORT:
154	 return sizeof(GLshort);
155      case GL_UNSIGNED_INT:
156	 return sizeof(GLuint);
157      case GL_INT:
158	 return sizeof(GLint);
159      case GL_FLOAT:
160	 return sizeof(GLfloat);
161      case GL_UNSIGNED_BYTE_3_3_2:
162         return sizeof(GLubyte);
163      case GL_UNSIGNED_BYTE_2_3_3_REV:
164         return sizeof(GLubyte);
165      case GL_UNSIGNED_SHORT_5_6_5:
166         return sizeof(GLshort);
167      case GL_UNSIGNED_SHORT_5_6_5_REV:
168         return sizeof(GLshort);
169      case GL_UNSIGNED_SHORT_4_4_4_4:
170         return sizeof(GLshort);
171      case GL_UNSIGNED_SHORT_4_4_4_4_REV:
172         return sizeof(GLshort);
173      case GL_UNSIGNED_SHORT_5_5_5_1:
174         return sizeof(GLshort);
175      case GL_UNSIGNED_SHORT_1_5_5_5_REV:
176         return sizeof(GLshort);
177      case GL_UNSIGNED_INT_8_8_8_8:
178         return sizeof(GLuint);
179      case GL_UNSIGNED_INT_8_8_8_8_REV:
180         return sizeof(GLuint);
181      case GL_UNSIGNED_INT_10_10_10_2:
182         return sizeof(GLuint);
183      case GL_UNSIGNED_INT_2_10_10_10_REV:
184         return sizeof(GLuint);
185      default:
186         return -1;
187   }
188}
189
190
191
192/*
193 * Return the number of components in a GL enum pixel type.
194 * Return -1 if bad format.
195 */
196GLint gl_components_in_format( GLenum format )
197{
198   switch (format) {
199      case GL_COLOR_INDEX:
200      case GL_COLOR_INDEX1_EXT:
201      case GL_COLOR_INDEX2_EXT:
202      case GL_COLOR_INDEX4_EXT:
203      case GL_COLOR_INDEX8_EXT:
204      case GL_COLOR_INDEX12_EXT:
205      case GL_COLOR_INDEX16_EXT:
206      case GL_STENCIL_INDEX:
207      case GL_DEPTH_COMPONENT:
208      case GL_RED:
209      case GL_GREEN:
210      case GL_BLUE:
211      case GL_ALPHA:
212      case GL_LUMINANCE:
213         return 1;
214      case GL_LUMINANCE_ALPHA:
215	 return 2;
216      case GL_RGB:
217	 return 3;
218      case GL_RGBA:
219	 return 4;
220      case GL_BGR:
221	 return 3;
222      case GL_BGRA:
223	 return 4;
224      case GL_ABGR_EXT:
225         return 4;
226      default:
227         return -1;
228   }
229}
230
231
232/*
233 * Return bytes per pixel for given format and type
234 * Return -1 if bad format or type.
235 */
236GLint gl_bytes_per_pixel( GLenum format, GLenum type )
237{
238   GLint comps = gl_components_in_format( format );
239   if (comps < 0)
240      return -1;
241
242   switch (type) {
243      case GL_BITMAP:
244         return 0;  /* special case */
245      case GL_BYTE:
246      case GL_UNSIGNED_BYTE:
247         return comps * sizeof(GLubyte);
248      case GL_SHORT:
249      case GL_UNSIGNED_SHORT:
250         return comps * sizeof(GLshort);
251      case GL_INT:
252      case GL_UNSIGNED_INT:
253         return comps * sizeof(GLint);
254      case GL_FLOAT:
255         return comps * sizeof(GLfloat);
256      case GL_UNSIGNED_BYTE_3_3_2:
257      case GL_UNSIGNED_BYTE_2_3_3_REV:
258         if (format == GL_RGB || format == GL_BGR)
259            return sizeof(GLubyte);
260         else
261            return -1;  /* error */
262      case GL_UNSIGNED_SHORT_5_6_5:
263      case GL_UNSIGNED_SHORT_5_6_5_REV:
264         if (format == GL_RGB || format == GL_BGR)
265            return sizeof(GLshort);
266         else
267            return -1;  /* error */
268      case GL_UNSIGNED_SHORT_4_4_4_4:
269      case GL_UNSIGNED_SHORT_4_4_4_4_REV:
270      case GL_UNSIGNED_SHORT_5_5_5_1:
271      case GL_UNSIGNED_SHORT_1_5_5_5_REV:
272         if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT)
273            return sizeof(GLushort);
274         else
275            return -1;
276      case GL_UNSIGNED_INT_8_8_8_8:
277      case GL_UNSIGNED_INT_8_8_8_8_REV:
278      case GL_UNSIGNED_INT_10_10_10_2:
279      case GL_UNSIGNED_INT_2_10_10_10_REV:
280         if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT)
281            return sizeof(GLuint);
282         else
283            return -1;
284      default:
285         return -1;
286   }
287}
288
289
290/*
291 * Test if the given pixel format and type are legal.
292 * Return GL_TRUE for legal, GL_FALSE for illegal.
293 */
294GLboolean gl_is_legal_format_and_type( GLenum format, GLenum type )
295{
296   switch (format) {
297      case GL_COLOR_INDEX:
298      case GL_STENCIL_INDEX:
299         switch (type) {
300            case GL_BITMAP:
301            case GL_BYTE:
302            case GL_UNSIGNED_BYTE:
303            case GL_SHORT:
304            case GL_UNSIGNED_SHORT:
305            case GL_INT:
306            case GL_UNSIGNED_INT:
307            case GL_FLOAT:
308               return GL_TRUE;
309            default:
310               return GL_FALSE;
311         }
312      case GL_RED:
313      case GL_GREEN:
314      case GL_BLUE:
315      case GL_ALPHA:
316      case GL_LUMINANCE:
317      case GL_LUMINANCE_ALPHA:
318      case GL_DEPTH_COMPONENT:
319      case GL_BGR:
320         switch (type) {
321            case GL_BYTE:
322            case GL_UNSIGNED_BYTE:
323            case GL_SHORT:
324            case GL_UNSIGNED_SHORT:
325            case GL_INT:
326            case GL_UNSIGNED_INT:
327            case GL_FLOAT:
328               return GL_TRUE;
329            default:
330               return GL_FALSE;
331         }
332      case GL_RGB:
333         switch (type) {
334            case GL_BYTE:
335            case GL_UNSIGNED_BYTE:
336            case GL_SHORT:
337            case GL_UNSIGNED_SHORT:
338            case GL_INT:
339            case GL_UNSIGNED_INT:
340            case GL_FLOAT:
341            case GL_UNSIGNED_BYTE_3_3_2:
342            case GL_UNSIGNED_BYTE_2_3_3_REV:
343            case GL_UNSIGNED_SHORT_5_6_5:
344            case GL_UNSIGNED_SHORT_5_6_5_REV:
345               return GL_TRUE;
346            default:
347               return GL_FALSE;
348         }
349      case GL_RGBA:
350      case GL_BGRA:
351      case GL_ABGR_EXT:
352         switch (type) {
353            case GL_BYTE:
354            case GL_UNSIGNED_BYTE:
355            case GL_SHORT:
356            case GL_UNSIGNED_SHORT:
357            case GL_INT:
358            case GL_UNSIGNED_INT:
359            case GL_FLOAT:
360            case GL_UNSIGNED_SHORT_4_4_4_4:
361            case GL_UNSIGNED_SHORT_4_4_4_4_REV:
362            case GL_UNSIGNED_SHORT_5_5_5_1:
363            case GL_UNSIGNED_SHORT_1_5_5_5_REV:
364            case GL_UNSIGNED_INT_8_8_8_8:
365            case GL_UNSIGNED_INT_8_8_8_8_REV:
366            case GL_UNSIGNED_INT_10_10_10_2:
367            case GL_UNSIGNED_INT_2_10_10_10_REV:
368               return GL_TRUE;
369            default:
370               return GL_FALSE;
371         }
372      default:
373         ; /* fall-through */
374   }
375   return GL_FALSE;
376}
377
378
379
380/*
381 * Return the address of a pixel in an image (actually a volume).
382 * Pixel unpacking/packing parameters are observed according to 'packing'.
383 * Input:  image - start of image data
384 *         width, height - size of image
385 *         format - image format
386 *         type - pixel component type
387 *         packing - the pixelstore attributes
388 *         img - which image in the volume (0 for 1D or 2D images)
389 *         row, column - location of pixel in the image
390 * Return:  address of pixel at (image,row,column) in image or NULL if error.
391 */
392GLvoid *gl_pixel_addr_in_image( const struct gl_pixelstore_attrib *packing,
393                                const GLvoid *image, GLsizei width,
394                                GLsizei height, GLenum format, GLenum type,
395                                GLint img, GLint row, GLint column )
396{
397   GLint alignment;        /* 1, 2 or 4 */
398   GLint pixels_per_row;
399   GLint rows_per_image;
400   GLint skiprows;
401   GLint skippixels;
402   GLint skipimages;       /* for 3-D volume images */
403   GLubyte *pixel_addr;
404
405   alignment = packing->Alignment;
406   if (packing->RowLength > 0) {
407      pixels_per_row = packing->RowLength;
408   }
409   else {
410      pixels_per_row = width;
411   }
412   if (packing->ImageHeight > 0) {
413      rows_per_image = packing->ImageHeight;
414   }
415   else {
416      rows_per_image = height;
417   }
418   skiprows = packing->SkipRows;
419   skippixels = packing->SkipPixels;
420   skipimages = packing->SkipImages;
421
422   if (type==GL_BITMAP) {
423      /* BITMAP data */
424      GLint comp_per_pixel;   /* components per pixel */
425      GLint bytes_per_comp;   /* bytes per component */
426      GLint bytes_per_row;
427      GLint bytes_per_image;
428
429      /* Compute bytes per component */
430      bytes_per_comp = gl_sizeof_packed_type( type );
431      if (bytes_per_comp<0) {
432         return NULL;
433      }
434
435      /* Compute number of components per pixel */
436      comp_per_pixel = gl_components_in_format( format );
437      if (comp_per_pixel<0 && type != GL_BITMAP) {
438         return NULL;
439      }
440
441      bytes_per_row = alignment
442                    * CEILING( comp_per_pixel*pixels_per_row, 8*alignment );
443
444      bytes_per_image = bytes_per_row * rows_per_image;
445
446      pixel_addr = (GLubyte *) image
447                 + (skipimages + img) * bytes_per_image
448                 + (skiprows + row) * bytes_per_row
449                 + (skippixels + column) / 8;
450   }
451   else {
452      /* Non-BITMAP data */
453      GLint bytes_per_pixel, bytes_per_row, remainder, bytes_per_image;
454
455      bytes_per_pixel = gl_bytes_per_pixel( format, type );
456
457      /* The pixel type and format should have been error checked earlier */
458      assert(bytes_per_pixel > 0);
459
460      bytes_per_row = pixels_per_row * bytes_per_pixel;
461      remainder = bytes_per_row % alignment;
462      if (remainder > 0)
463         bytes_per_row += (alignment - remainder);
464
465      ASSERT(bytes_per_row % alignment == 0);
466
467      bytes_per_image = bytes_per_row * rows_per_image;
468
469      /* compute final pixel address */
470      pixel_addr = (GLubyte *) image
471                 + (skipimages + img) * bytes_per_image
472                 + (skiprows + row) * bytes_per_row
473                 + (skippixels + column) * bytes_per_pixel;
474   }
475
476   return (GLvoid *) pixel_addr;
477}
478
479
480
481/*
482 * Allocate a new gl_image.  All fields are initialized to zero.
483 */
484static struct gl_image *alloc_image( void )
485{
486   return CALLOC_STRUCT(gl_image);
487}
488
489
490
491/*
492 * Allocate a new gl_image with the error flag set.
493 */
494static struct gl_image *alloc_error_image( GLint width, GLint height,
495                                           GLint depth, GLenum format,
496                                           GLenum type )
497{
498   struct gl_image *image = alloc_image();
499   if (image) {
500      image->Width = width;
501      image->Height = height;
502      image->Depth = depth;
503      image->Format = format;
504      image->Type = type;
505      image->ErrorFlag = GL_TRUE;
506   }
507   return image;
508}
509
510
511
512/*
513 * Free a gl_image.
514 */
515void gl_free_image( struct gl_image *image )
516{
517   if (image->Data) {
518      FREE(image->Data);
519   }
520   FREE(image);
521}
522
523
524
525/*
526 * Do error checking on an image.  If there's an error, register it and
527 * return GL_TRUE, else return GL_FALSE.
528 */
529GLboolean gl_image_error_test( GLcontext *ctx, const struct gl_image *image,
530                               const char *msg )
531{
532   if (!image) {
533      gl_error( ctx, GL_OUT_OF_MEMORY, msg );
534      return GL_TRUE;
535   }
536   if (image->Width <= 0 || image->Height <= 0 || image->Depth <= 0) {
537      gl_error( ctx, GL_INVALID_VALUE, msg );
538      return GL_TRUE;
539   }
540   else if (!gl_is_legal_format_and_type(image->Format, image->Type)) {
541      return GL_TRUE;
542   }
543   else {
544      return GL_FALSE;
545   }
546}
547
548
549
550/*
551 * Unpack a depth-buffer image storing values as GLshort, GLuint, or GLfloats.
552 * Input:  type - datatype of src depth image
553 * Return pointer to a new gl_image structure.
554 *
555 * Notes:  if the source image type is GLushort then the gl_image will
556 * also store GLushorts.  If the src image type is GLuint then the gl_image
557 * will also store GLuints.  For all other src image types the gl_image
558 * will store GLfloats.  The integer cases can later be optimized.
559 */
560static struct gl_image *
561unpack_depth_image( GLcontext *ctx, GLenum type, GLint width, GLint height,
562                    const GLvoid *pixels,
563                    const struct gl_pixelstore_attrib *packing)
564
565{
566   struct gl_image *image;
567   GLfloat *fDst;
568   GLushort *sDst;
569   GLuint *iDst;
570   GLint i, j;
571   GLboolean errorType;
572
573   errorType = type != GL_BYTE &&
574               type != GL_UNSIGNED_BYTE &&
575               type != GL_SHORT &&
576               type != GL_UNSIGNED_SHORT &&
577               type != GL_INT &&
578               type != GL_UNSIGNED_INT &&
579               type != GL_FLOAT;
580
581   image = alloc_image();
582   if (image) {
583      image->Width = width;
584      image->Height = height;
585      image->Depth = 1;
586      image->Components = 1;
587      image->Format = GL_DEPTH_COMPONENT;
588      if (errorType) {
589         image->Type = type;
590         image->Data = NULL;
591      }
592      if (type==GL_UNSIGNED_SHORT) {
593         image->Type = GL_UNSIGNED_SHORT;
594         image->Data = MALLOC( width * height * sizeof(GLushort));
595      }
596      else if (type==GL_UNSIGNED_INT) {
597         image->Type = GL_UNSIGNED_INT;
598         image->Data = MALLOC( width * height * sizeof(GLuint));
599      }
600      else {
601         image->Type = GL_FLOAT;
602         image->Data = MALLOC( width * height * sizeof(GLfloat));
603      }
604      image->RefCount = 0;
605      if (!image->Data)
606         return image;
607   }
608   else {
609      return NULL;
610   }
611
612   if (errorType)
613      return image;
614
615   fDst = (GLfloat *) image->Data;
616   sDst = (GLushort *) image->Data;
617   iDst = (GLuint *) image->Data;
618
619   for (i=0;i<height;i++) {
620      GLvoid *src = gl_pixel_addr_in_image( packing, pixels,
621                                            width, height,
622                                            GL_DEPTH_COMPONENT, type,
623                                            0, i, 0 );
624      if (!src) {
625         return image;
626      }
627
628      switch (type) {
629         case GL_BYTE:
630            assert(image->Type == GL_FLOAT);
631            for (j=0; j<width; j++) {
632               *fDst++ = BYTE_TO_FLOAT(((GLbyte*)src)[j]);
633            }
634            break;
635         case GL_UNSIGNED_BYTE:
636            assert(image->Type == GL_FLOAT);
637            for (j=0; j<width; j++) {
638               *fDst++ = UBYTE_TO_FLOAT(((GLubyte*)src)[j]);
639            }
640            break;
641         case GL_UNSIGNED_SHORT:
642            assert(image->Type == GL_UNSIGNED_SHORT);
643            MEMCPY( sDst, src, width * sizeof(GLushort) );
644            if (packing->SwapBytes) {
645               gl_swap2( sDst, width );
646            }
647            sDst += width;
648            break;
649         case GL_SHORT:
650            assert(image->Type == GL_FLOAT);
651            if (packing->SwapBytes) {
652               for (j=0;j<width;j++) {
653                  GLshort value = ((GLshort*)src)[j];
654                  value = ((value >> 8) & 0xff) | ((value&0xff) << 8);
655                  *fDst++ = SHORT_TO_FLOAT(value);
656               }
657            }
658            else {
659               for (j=0;j<width;j++) {
660                  *fDst++ = SHORT_TO_FLOAT(((GLshort*)src)[j]);
661               }
662            }
663            break;
664         case GL_INT:
665            assert(image->Type == GL_FLOAT);
666            if (packing->SwapBytes) {
667               for (j=0;j<width;j++) {
668                  GLint value = ((GLint*)src)[j];
669                  value = ((value >> 24) & 0x000000ff) |
670                          ((value >> 8)  & 0x0000ff00) |
671                          ((value << 8)  & 0x00ff0000) |
672                          ((value << 24) & 0xff000000);
673                  *fDst++ = INT_TO_FLOAT(value);
674               }
675            }
676            else {
677               for (j=0;j<width;j++) {
678                  *fDst++ = INT_TO_FLOAT(((GLint*)src)[j]);
679               }
680            }
681            iDst += width;
682            break;
683         case GL_UNSIGNED_INT:
684            assert(image->Type == GL_UNSIGNED_INT);
685            MEMCPY( iDst, src, width * sizeof(GLuint) );
686            if (packing->SwapBytes) {
687               gl_swap4( iDst, width );
688            }
689            iDst += width;
690            break;
691         case GL_FLOAT:
692            assert(image->Type == GL_FLOAT);
693            MEMCPY( fDst, src, width * sizeof(GLfloat) );
694            if (packing->SwapBytes) {
695               gl_swap4( (GLuint*) fDst, width );
696            }
697            fDst += width;
698            break;
699         default:
700            gl_problem(ctx, "unpack_depth_image type" );
701            return image;
702      }
703   }
704
705   return image;
706}
707
708
709
710/*
711 * Unpack a stencil image.  Store as GLubytes in a gl_image structure.
712 * Return:  pointer to new gl_image structure.
713 */
714static struct gl_image *
715unpack_stencil_image( GLcontext *ctx, GLenum type, GLint width, GLint height,
716                      const GLvoid *pixels,
717                      const struct gl_pixelstore_attrib *packing )
718{
719   struct gl_image *image;
720   GLubyte *dst;
721   GLint i, j;
722   GLboolean errorType;
723
724   assert(sizeof(GLstencil) == sizeof(GLubyte));
725
726   errorType = type != GL_BYTE &&
727               type != GL_UNSIGNED_BYTE &&
728               type != GL_SHORT &&
729               type != GL_UNSIGNED_SHORT &&
730               type != GL_INT &&
731               type != GL_UNSIGNED_INT &&
732               type != GL_FLOAT &&
733               type != GL_BITMAP;
734
735   image = alloc_image();
736   if (image) {
737      image->Width = width;
738      image->Height = height;
739      image->Depth = 1;
740      image->Components = 1;
741      image->Format = GL_STENCIL_INDEX;
742      if (errorType) {
743         image->Type = type;
744         image->Data = NULL;
745      }
746      else {
747         image->Type = GL_UNSIGNED_BYTE;
748         image->Data = MALLOC( width * height * sizeof(GLubyte));
749      }
750      image->RefCount = 0;
751      if (!image->Data)
752         return image;
753   }
754   else {
755      return NULL;
756   }
757
758   if (errorType)
759      return image; /* error will be generated later */
760
761   dst = (GLubyte *) image->Data;
762
763   for (i=0;i<height;i++) {
764      GLvoid *src = gl_pixel_addr_in_image( packing, pixels,
765                                            width, height,
766                                            GL_STENCIL_INDEX, type,
767                                            0, i, 0 );
768      if (!src) {
769         return image;
770      }
771
772      switch (type) {
773         case GL_UNSIGNED_BYTE:
774         case GL_BYTE:
775            MEMCPY( dst, src, width * sizeof(GLubyte) );
776            dst += width * sizeof(GLubyte);
777            break;
778         case GL_UNSIGNED_SHORT:
779         case GL_SHORT:
780            if (packing->SwapBytes) {
781               /* grab upper byte */
782               for (j=0; j < width; j++) {
783                  *dst++ = (((GLushort*)src)[j] & 0xff00) >> 8;
784               }
785            }
786            else {
787               for (j=0; j < width; j++) {
788                  *dst++ = (((GLushort*)src)[j]) & 0xff;
789               }
790            }
791            break;
792         case GL_INT:
793            if (packing->SwapBytes) {
794               /* grab upper byte */
795               for (j=0; j < width; j++) {
796                  *dst++ = (((GLuint*)src)[j] & 0xff000000) >> 8;
797               }
798            }
799            else {
800               for (j=0; j < width; j++) {
801                  *dst++ = (((GLuint*)src)[j]) & 0xff;
802               }
803            }
804            break;
805         case GL_UNSIGNED_INT:
806            if (packing->SwapBytes) {
807               /* grab upper byte */
808               for (j=0; j < width; j++) {
809                  *dst++ = (((GLuint*)src)[j] & 0xff000000) >> 8;
810               }
811            }
812            else {
813               for (j=0; j < width; j++) {
814                  *dst++ = (((GLuint*)src)[j]) & 0xff;
815               }
816            }
817            break;
818         case GL_FLOAT:
819            if (packing->SwapBytes) {
820               for (j=0; j < width; j++) {
821                  GLfloat fvalue;
822                  GLint value = ((GLuint*)src)[j];
823                  value = ((value & 0xff000000) >> 24)
824                     | ((value & 0x00ff0000) >> 8)
825                     | ((value & 0x0000ff00) << 8)
826                     | ((value & 0x000000ff) << 24);
827                  fvalue = *((GLfloat*) &value);
828                  *dst++ = ((GLint) fvalue) & 0xff;
829               }
830            }
831            else {
832               for (j=0; j < width; j++) {
833                  GLfloat fvalue = ((GLfloat *)src)[j];
834                  *dst++ = ((GLint) fvalue) & 0xff;
835               }
836            }
837            break;
838         default:
839            gl_problem(ctx, "unpack_stencil_image type" );
840            return image;
841      }
842   }
843
844   return image;
845}
846
847
848
849/*
850 * Unpack a bitmap, return a new gl_image struct.
851 */
852static struct gl_image *
853unpack_bitmap( GLenum format, GLint width, GLint height,
854               const GLvoid *pixels,
855               const struct gl_pixelstore_attrib *packing )
856{
857   struct gl_image *image;
858   GLint bytes, i, width_in_bytes;
859   GLubyte *buffer, *dst;
860
861   assert(format == GL_COLOR_INDEX || format == GL_STENCIL_INDEX);
862
863   /* Alloc dest storage */
864   bytes = ((width+7)/8 * height);
865   if (bytes>0 && pixels!=NULL) {
866      buffer = (GLubyte *) MALLOC( bytes );
867      if (!buffer) {
868         return NULL;
869      }
870      /* Copy/unpack pixel data to buffer */
871      width_in_bytes = CEILING( width, 8 );
872      dst = buffer;
873      for (i=0; i<height; i++) {
874         GLvoid *src = gl_pixel_addr_in_image( packing, pixels,
875                                               width, height,
876                                               GL_COLOR_INDEX, GL_BITMAP,
877                                               0, i, 0 );
878         if (!src) {
879            FREE(buffer);
880            return NULL;
881         }
882         MEMCPY( dst, src, width_in_bytes );
883         dst += width_in_bytes;
884      }
885      /* Bit flipping */
886      if (packing->LsbFirst) {
887         gl_flip_bytes( buffer, bytes );
888      }
889   }
890   else {
891      /* a 'null' bitmap */
892      buffer = NULL;
893   }
894
895   image = alloc_image();
896   if (image) {
897      image->Width = width;
898      image->Height = height;
899      image->Depth = 1;
900      image->Components = 0;
901      image->Format = format;
902      image->Type = GL_BITMAP;
903      image->Data = buffer;
904      image->RefCount = 0;
905   }
906   else {
907      FREE( buffer );
908      return NULL;
909   }
910
911   return image;
912}
913
914
915
916/*
917 * Unpack a 32x32 pixel polygon stipple from user memory using the
918 * current pixel unpack settings.
919 */
920void gl_unpack_polygon_stipple( const GLcontext *ctx,
921                                const GLubyte *pattern, GLuint dest[32] )
922{
923   GLint i;
924   for (i = 0; i < 32; i++) {
925      GLubyte *src = (GLubyte *) gl_pixel_addr_in_image( &ctx->Unpack, pattern,
926                                  32, 32, GL_COLOR_INDEX, GL_BITMAP, 0, i, 0 );
927      dest[i] = (src[0] << 24)
928              | (src[1] << 16)
929              | (src[2] <<  8)
930              | (src[3]      );
931   }
932
933   /* Bit flipping within each byte */
934   if (ctx->Unpack.LsbFirst) {
935      gl_flip_bytes( (GLubyte *) dest, 32 * 4 );
936   }
937}
938
939
940
941/*
942 * Pack polygon stipple into user memory given current pixel packing
943 * settings.
944 */
945void gl_pack_polygon_stipple( const GLcontext *ctx,
946                              const GLuint pattern[32],
947                              GLubyte *dest )
948{
949   GLint i;
950   for (i = 0; i < 32; i++) {
951      GLubyte *dst = (GLubyte *) gl_pixel_addr_in_image( &ctx->Pack, dest,
952                                  32, 32, GL_COLOR_INDEX, GL_BITMAP, 0, i, 0 );
953      dst[0] = (pattern[i] >> 24) & 0xff;
954      dst[1] = (pattern[i] >> 16) & 0xff;
955      dst[2] = (pattern[i] >>  8) & 0xff;
956      dst[3] = (pattern[i]      ) & 0xff;
957
958      /* Bit flipping within each byte */
959      if (ctx->Pack.LsbFirst) {
960         gl_flip_bytes( (GLubyte *) dst, 4 );
961      }
962   }
963}
964
965
966
967/*
968 * Unpack an RGBA or CI image and store it as unsigned bytes
969 */
970static struct gl_image *
971unpack_ubyte_image( GLint width, GLint height,
972                    GLint depth, GLenum format, const GLvoid *pixels,
973                    const struct gl_pixelstore_attrib *packing )
974{
975   struct gl_image *image;
976   GLint width_in_bytes;
977   GLint components;
978   GLubyte *buffer, *dst;
979   GLint i, d;
980
981   components = gl_components_in_format( format );
982
983   width_in_bytes = width * components * sizeof(GLubyte);
984   buffer = (GLubyte *) MALLOC( height * width_in_bytes * depth );
985   if (!buffer) {
986      return NULL;
987   }
988
989   /* Copy/unpack pixel data to buffer */
990   dst = buffer;
991   for (d=0; d<depth; d++ ) {
992      for (i=0;i<height;i++) {
993         GLubyte *src = (GLubyte *) gl_pixel_addr_in_image( packing,
994                       pixels, width, height, format, GL_UNSIGNED_BYTE,
995                       d, i, 0 );
996         if (!src) {
997            FREE(buffer);
998            return NULL;
999         }
1000         MEMCPY( dst, src, width_in_bytes );
1001         dst += width_in_bytes;
1002      }
1003   }
1004
1005   if (format == GL_BGR) {
1006      /* swap order of every ubyte triplet from BGR to RGB */
1007      for (i=0; i<width*height; i++) {
1008         GLubyte b = buffer[i*3+0];
1009         GLubyte r = buffer[i*3+2];
1010         buffer[i*3+0] = r;
1011         buffer[i*3+2] = b;
1012      }
1013   }
1014   else if (format == GL_BGRA) {
1015      /* swap order of every ubyte quadruplet from BGRA to RGBA */
1016      for (i=0; i<width*height; i++) {
1017         GLubyte b = buffer[i*4+0];
1018         GLubyte r = buffer[i*4+2];
1019         buffer[i*4+0] = r;
1020         buffer[i*4+2] = b;
1021      }
1022   }
1023   else if (format == GL_ABGR_EXT) {
1024      /* swap order of every ubyte quadruplet from ABGR to RGBA */
1025      for (i=0; i<width*height; i++) {
1026         GLubyte a = buffer[i*4+0];
1027         GLubyte b = buffer[i*4+1];
1028         GLubyte g = buffer[i*4+2];
1029         GLubyte r = buffer[i*4+3];
1030         buffer[i*4+0] = r;
1031         buffer[i*4+1] = g;
1032         buffer[i*4+2] = b;
1033         buffer[i*4+3] = a;
1034      }
1035   }
1036
1037
1038   image = alloc_image();
1039   if (image) {
1040      image->Width = width;
1041      image->Height = height;
1042      image->Depth = depth;
1043      image->Components = components;
1044      if (format == GL_BGR)
1045         image->Format = GL_RGB;
1046      else if (format == GL_BGRA)
1047         image->Format = GL_RGBA;
1048      else if (format == GL_ABGR_EXT)
1049         image->Format = GL_RGBA;
1050      else
1051         image->Format = format;
1052      image->Type = GL_UNSIGNED_BYTE;
1053      image->Data = buffer;
1054      image->RefCount = 0;
1055   }
1056   else {
1057      FREE( buffer );
1058   }
1059
1060   return image;
1061}
1062
1063
1064
1065/*
1066 * Unpack a color image storing image as GLfloats
1067 */
1068static struct gl_image *
1069unpack_float_image( GLcontext *ctx, GLint width, GLint height, GLint depth,
1070                    GLenum format, GLenum type, const GLvoid *pixels,
1071                    const struct gl_pixelstore_attrib *packing )
1072{
1073   struct gl_image *image;
1074   GLfloat *dst;
1075   GLint elems_per_row;
1076   GLint components;
1077   GLint i, j, d;
1078   GLboolean normalize;
1079
1080   assert(type != GL_BITMAP);
1081
1082   components = gl_components_in_format( format );
1083   assert(components > 0);  /* should have been caught earlier */
1084
1085   if (!gl_is_legal_format_and_type( format, type )) {
1086      /* bad pixel type for format, make dummy image */
1087      image = alloc_image();
1088      if (image) {
1089         image->Width = width;
1090         image->Height = height;
1091         image->Depth = depth;
1092         image->Components = components;
1093         image->Format = format;
1094         image->Type = type;
1095         image->Data = NULL;
1096         image->RefCount = 0;
1097      }
1098      return image;
1099   }
1100
1101   elems_per_row = width * components;
1102
1103   image = alloc_image();
1104   if (image) {
1105      image->Width = width;
1106      image->Height = height;
1107      image->Depth = depth;
1108      image->Components = components;
1109      if (format == GL_BGR)
1110         image->Format = GL_RGB;
1111      else if (format == GL_BGRA)
1112         image->Format = GL_RGBA;
1113      else if (format == GL_ABGR_EXT)
1114         image->Format = GL_RGBA;
1115      else
1116         image->Format = format;
1117      image->Type = GL_FLOAT;
1118      image->Data = MALLOC( elems_per_row * height * depth * sizeof(GLfloat));
1119      image->RefCount = 0;
1120      if (!image->Data)
1121         return image;
1122   }
1123   else {
1124      return NULL;
1125   }
1126
1127   normalize = (format != GL_COLOR_INDEX) && (format != GL_STENCIL_INDEX);
1128
1129   dst = (GLfloat *) image->Data;
1130
1131   for (d=0; d<depth; d++) {
1132      for (i=0;i<height;i++) {
1133         GLvoid *src = gl_pixel_addr_in_image( packing, pixels,
1134                                               width, height,
1135                                               format, type,
1136                                               d, i, 0 );
1137         if (!src) {
1138            return image;
1139         }
1140
1141         switch (type) {
1142            case GL_UNSIGNED_BYTE:
1143               {
1144                  GLubyte *ubsrc = (GLubyte *) src;
1145                  if (normalize) {
1146                     for (j=0;j<elems_per_row;j++) {
1147                        *dst++ = UBYTE_TO_FLOAT(ubsrc[j]);
1148                     }
1149                  }
1150                  else {
1151                     for (j=0;j<elems_per_row;j++) {
1152                        *dst++ = (GLfloat) ubsrc[j];
1153                     }
1154                  }
1155               }
1156               break;
1157            case GL_BYTE:
1158               if (normalize) {
1159                  for (j=0;j<elems_per_row;j++) {
1160                     *dst++ = BYTE_TO_FLOAT(((GLbyte*)src)[j]);
1161                  }
1162               }
1163               else {
1164                  for (j=0;j<elems_per_row;j++) {
1165                     *dst++ = (GLfloat) ((GLbyte*)src)[j];
1166                  }
1167               }
1168               break;
1169            case GL_UNSIGNED_SHORT:
1170               if (packing->SwapBytes) {
1171                  for (j=0;j<elems_per_row;j++) {
1172                     GLushort value = ((GLushort*)src)[j];
1173                     value = ((value >> 8) & 0xff) | ((value&0xff) << 8);
1174                     if (normalize) {
1175                        *dst++ = USHORT_TO_FLOAT(value);
1176                     }
1177                     else {
1178                        *dst++ = (GLfloat) value;
1179                     }
1180                  }
1181               }
1182               else {
1183                  if (normalize) {
1184                     for (j=0;j<elems_per_row;j++) {
1185                        *dst++ = USHORT_TO_FLOAT(((GLushort*)src)[j]);
1186                     }
1187                  }
1188                  else {
1189                     for (j=0;j<elems_per_row;j++) {
1190                        *dst++ = (GLfloat) ((GLushort*)src)[j];
1191                     }
1192                  }
1193               }
1194               break;
1195            case GL_SHORT:
1196               if (packing->SwapBytes) {
1197                  for (j=0;j<elems_per_row;j++) {
1198                     GLshort value = ((GLshort*)src)[j];
1199                     value = ((value >> 8) & 0xff) | ((value&0xff) << 8);
1200                     if (normalize) {
1201                        *dst++ = SHORT_TO_FLOAT(value);
1202                     }
1203                     else {
1204                        *dst++ = (GLfloat) value;
1205                     }
1206                  }
1207               }
1208               else {
1209                  if (normalize) {
1210                     for (j=0;j<elems_per_row;j++) {
1211                        *dst++ = SHORT_TO_FLOAT(((GLshort*)src)[j]);
1212                     }
1213                  }
1214                  else {
1215                     for (j=0;j<elems_per_row;j++) {
1216                        *dst++ = (GLfloat) ((GLshort*)src)[j];
1217                     }
1218                  }
1219               }
1220               break;
1221            case GL_UNSIGNED_INT:
1222               if (packing->SwapBytes) {
1223                  GLuint value;
1224                  for (j=0;j<elems_per_row;j++) {
1225                     value = ((GLuint*)src)[j];
1226                     value = ((value & 0xff000000) >> 24)
1227                           | ((value & 0x00ff0000) >> 8)
1228                           | ((value & 0x0000ff00) << 8)
1229                           | ((value & 0x000000ff) << 24);
1230                     if (normalize) {
1231                        *dst++ = UINT_TO_FLOAT(value);
1232                     }
1233                     else {
1234                        *dst++ = (GLfloat) value;
1235                     }
1236                  }
1237               }
1238               else {
1239                  if (normalize) {
1240                     for (j=0;j<elems_per_row;j++) {
1241                        *dst++ = UINT_TO_FLOAT(((GLuint*)src)[j]);
1242                     }
1243                  }
1244                  else {
1245                     for (j=0;j<elems_per_row;j++) {
1246                        *dst++ = (GLfloat) ((GLuint*)src)[j];
1247                     }
1248                  }
1249               }
1250               break;
1251            case GL_INT:
1252               if (packing->SwapBytes) {
1253                  GLint value;
1254                  for (j=0;j<elems_per_row;j++) {
1255                     value = ((GLint*)src)[j];
1256                     value = ((value & 0xff000000) >> 24)
1257                           | ((value & 0x00ff0000) >> 8)
1258                           | ((value & 0x0000ff00) << 8)
1259                           | ((value & 0x000000ff) << 24);
1260                     if (normalize) {
1261                        *dst++ = INT_TO_FLOAT(value);
1262                     }
1263                     else {
1264                        *dst++ = (GLfloat) value;
1265                     }
1266                  }
1267               }
1268               else {
1269                  if (normalize) {
1270                     for (j=0;j<elems_per_row;j++) {
1271                        *dst++ = INT_TO_FLOAT(((GLint*)src)[j]);
1272                     }
1273                  }
1274                  else {
1275                     for (j=0;j<elems_per_row;j++) {
1276                        *dst++ = (GLfloat) ((GLint*)src)[j];
1277                     }
1278                  }
1279               }
1280               break;
1281            case GL_FLOAT:
1282               if (packing->SwapBytes) {
1283                  GLint value;
1284                  for (j=0;j<elems_per_row;j++) {
1285                     value = ((GLuint*)src)[j];
1286                     value = ((value & 0xff000000) >> 24)
1287                           | ((value & 0x00ff0000) >> 8)
1288                           | ((value & 0x0000ff00) << 8)
1289                           | ((value & 0x000000ff) << 24);
1290                     *dst++ = *((GLfloat*) &value);
1291                  }
1292               }
1293               else {
1294                  MEMCPY( dst, src, elems_per_row*sizeof(GLfloat) );
1295                  dst += elems_per_row;
1296               }
1297               break;
1298            case GL_UNSIGNED_BYTE_3_3_2:
1299               {
1300                  GLubyte *ubsrc = (GLubyte *) src;
1301                  for (j=0;j<width;j++) {
1302                     GLubyte p = ubsrc[j];
1303                     *dst++ = ((p >> 5)      ) * (1.0F / 7.0F); /* red */
1304                     *dst++ = ((p >> 2) & 0x7) * (1.0F / 7.0F); /* green */
1305                     *dst++ = ((p     ) & 0x3) * (1.0F / 3.0F); /* blue */
1306                  }
1307               }
1308               break;
1309            case GL_UNSIGNED_BYTE_2_3_3_REV:
1310               {
1311                  GLubyte *ubsrc = (GLubyte *) src;
1312                  for (j=0;j<width;j++) {
1313                     GLubyte p = ubsrc[j];
1314                     *dst++ = ((p     ) & 0x7) * (1.0F / 7.0F); /* red */
1315                     *dst++ = ((p >> 3) & 0x7) * (1.0F / 7.0F); /* green */
1316                     *dst++ = ((p >> 6)      ) * (1.0F / 3.0F); /* blue */
1317                  }
1318               }
1319               break;
1320            case GL_UNSIGNED_SHORT_5_6_5:
1321               {
1322                  GLushort *ussrc = (GLushort *) src;
1323                  for (j=0;j<width;j++) {
1324                     GLushort p = ussrc[j];
1325                     *dst++ = ((p >> 11)       ) * (1.0F / 31.0F); /* red */
1326                     *dst++ = ((p >>  5) & 0x3f) * (1.0F / 63.0F); /* green */
1327                     *dst++ = ((p      ) & 0x1f) * (1.0F / 31.0F); /* blue */
1328                  }
1329               }
1330               break;
1331            case GL_UNSIGNED_SHORT_5_6_5_REV:
1332               {
1333                  GLushort *ussrc = (GLushort *) src;
1334                  for (j=0;j<width;j++) {
1335                     GLushort p = ussrc[j];
1336                     *dst++ = ((p      ) & 0x1f) * (1.0F / 31.0F); /* red */
1337                     *dst++ = ((p >>  5) & 0x3f) * (1.0F / 63.0F); /* green */
1338                     *dst++ = ((p >> 11)       ) * (1.0F / 31.0F); /* blue */
1339                  }
1340               }
1341               break;
1342	    case GL_UNSIGNED_SHORT_4_4_4_4:
1343               {
1344                  GLushort *ussrc = (GLushort *) src;
1345                  for (j=0;j<width;j++) {
1346                     GLushort p = ussrc[j];
1347                     *dst++ = ((p >> 12)      ) * (1.0F / 15.0F); /* red */
1348                     *dst++ = ((p >>  8) & 0xf) * (1.0F / 15.0F); /* green */
1349                     *dst++ = ((p >>  4) & 0xf) * (1.0F / 15.0F); /* blue */
1350                     *dst++ = ((p      ) & 0xf) * (1.0F / 15.0F); /* alpha */
1351                  }
1352               }
1353               break;
1354	    case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1355               {
1356                  GLushort *ussrc = (GLushort *) src;
1357                  for (j=0;j<width;j++) {
1358                     GLushort p = ussrc[j];
1359                     *dst++ = ((p      ) & 0xf) * (1.0F / 15.0F); /* red */
1360                     *dst++ = ((p >>  4) & 0xf) * (1.0F / 15.0F); /* green */
1361                     *dst++ = ((p >>  8) & 0xf) * (1.0F / 15.0F); /* blue */
1362                     *dst++ = ((p >> 12)      ) * (1.0F / 15.0F); /* alpha */
1363                  }
1364               }
1365               break;
1366	    case GL_UNSIGNED_SHORT_5_5_5_1:
1367               {
1368                  GLushort *ussrc = (GLushort *) src;
1369                  for (j=0;j<width;j++) {
1370                     GLushort p = ussrc[j];
1371                     *dst++ = ((p >> 11)       ) * (1.0F / 31.0F); /* red */
1372                     *dst++ = ((p >>  6) & 0x1f) * (1.0F / 31.0F); /* green */
1373                     *dst++ = ((p >>  1) & 0x1f) * (1.0F / 31.0F); /* blue */
1374                     *dst++ = ((p      ) & 0x1)  * (1.0F /  1.0F); /* alpha */
1375                  }
1376               }
1377               break;
1378	    case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1379               {
1380                  GLushort *ussrc = (GLushort *) src;
1381                  for (j=0;j<width;j++) {
1382                     GLushort p = ussrc[j];
1383                     *dst++ = ((p      ) & 0x1f) * (1.0F / 31.0F); /* red */
1384                     *dst++ = ((p >>  5) & 0x1f) * (1.0F / 31.0F); /* green */
1385                     *dst++ = ((p >> 10) & 0x1f) * (1.0F / 31.0F); /* blue */
1386                     *dst++ = ((p >> 15)       ) * (1.0F /  1.0F); /* alpha */
1387                  }
1388               }
1389               break;
1390	    case GL_UNSIGNED_INT_8_8_8_8:
1391               {
1392                  GLuint *uisrc = (GLuint *) src;
1393                  for (j=0;j<width;j++) {
1394                     GLuint p = uisrc[j];
1395                     *dst++ = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 24)       );
1396                     *dst++ = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 16) & 0xff);
1397                     *dst++ = UBYTE_COLOR_TO_FLOAT_COLOR((p >>  8) & 0xff);
1398                     *dst++ = UBYTE_COLOR_TO_FLOAT_COLOR((p      ) & 0xff);
1399                  }
1400               }
1401               break;
1402	    case GL_UNSIGNED_INT_8_8_8_8_REV:
1403               {
1404                  GLuint *uisrc = (GLuint *) src;
1405                  for (j=0;j<width;j++) {
1406                     GLuint p = uisrc[j];
1407                     *dst++ = UBYTE_COLOR_TO_FLOAT_COLOR((p      ) & 0xff);
1408                     *dst++ = UBYTE_COLOR_TO_FLOAT_COLOR((p >>  8) & 0xff);
1409                     *dst++ = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 16) & 0xff);
1410                     *dst++ = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 24)       );
1411                  }
1412               }
1413               break;
1414	    case GL_UNSIGNED_INT_10_10_10_2:
1415               {
1416                  GLuint *uisrc = (GLuint *) src;
1417                  for (j=0;j<width;j++) {
1418                     GLuint p = uisrc[j];
1419                     *dst++ = ((p >> 22)        ) * (1.0F / 1023.0F); /* r */
1420                     *dst++ = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F); /* g */
1421                     *dst++ = ((p >>  2) & 0x3ff) * (1.0F / 1023.0F); /* b */
1422                     *dst++ = ((p      ) & 0x3  ) * (1.0F /    3.0F); /* a */
1423                  }
1424               }
1425               break;
1426	    case GL_UNSIGNED_INT_2_10_10_10_REV:
1427               {
1428                  GLuint *uisrc = (GLuint *) src;
1429                  for (j=0;j<width;j++) {
1430                     GLuint p = uisrc[j];
1431                     *dst++ = ((p      ) & 0x3ff) * (1.0F / 1023.0F); /* r*/
1432                     *dst++ = ((p >> 10) & 0x3ff) * (1.0F / 1023.0F); /* g */
1433                     *dst++ = ((p >> 20) & 0x3ff) * (1.0F / 1023.0F); /* b */
1434                     *dst++ = ((p >> 30)        ) * (1.0F /    3.0F); /* a */
1435                  }
1436               }
1437               break;
1438            default:
1439               gl_problem(ctx, "unpack_float_image type" );
1440               return image;
1441         }
1442      }
1443   }
1444
1445   if (format == GL_BGR) {
1446      /* swap order of every float triplet from BGR to RGBA */
1447      GLfloat *buffer = (GLfloat *) image->Data;
1448      for (i=0; i<width*height*depth; i++) {
1449         GLfloat b = buffer[i*3+0];
1450         GLfloat r = buffer[i*3+2];
1451         buffer[i*3+0] = r;
1452         buffer[i*3+2] = b;
1453      }
1454   }
1455   else if (format == GL_BGRA) {
1456      /* swap order of every float quadruplet from BGRA to RGBA */
1457      GLfloat *buffer = (GLfloat *) image->Data;
1458      for (i=0; i<width*height*depth; i++) {
1459         GLfloat b = buffer[i*4+0];
1460         GLfloat r = buffer[i*4+2];
1461         buffer[i*4+0] = r;
1462         buffer[i*4+2] = b;
1463      }
1464   }
1465   else if (format == GL_ABGR_EXT) {
1466      /* swap order of every float quadruplet from ABGR to RGBA */
1467      GLfloat *buffer = (GLfloat *) image->Data;
1468      for (i=0; i<width*height*depth; i++) {
1469         GLfloat a = buffer[i*4+0];
1470         GLfloat b = buffer[i*4+1];
1471         GLfloat g = buffer[i*4+2];
1472         GLfloat r = buffer[i*4+3];
1473         buffer[i*4+0] = r;
1474         buffer[i*4+1] = g;
1475         buffer[i*4+2] = b;
1476         buffer[i*4+3] = a;
1477      }
1478   }
1479
1480   return image;
1481}
1482
1483
1484
1485/*
1486 * Unpack a bitmap image, using current glPixelStore parameters,
1487 * making a new gl_image.
1488 */
1489struct gl_image *gl_unpack_bitmap( GLcontext *ctx,
1490                                   GLsizei width, GLsizei height,
1491                                   const GLubyte *bitmap,
1492                                   const struct gl_pixelstore_attrib *packing )
1493{
1494   return gl_unpack_image( ctx, width, height,
1495                           GL_COLOR_INDEX, GL_BITMAP, bitmap, packing );
1496}
1497
1498
1499
1500/*
1501 * Unpack a 2-D image from user's buffer.  Return pointer to new
1502 * gl_image struct.
1503 *
1504 * Input:  width, height - size in pixels
1505 *         format - format of incoming pixel data
1506 *         type - datatype of incoming pixel data
1507 *         pixels - pointer to unpacked image in user buffer
1508 */
1509struct gl_image *gl_unpack_image( GLcontext *ctx,
1510                                  GLint width, GLint height,
1511                                  GLenum format, GLenum type,
1512                                  const GLvoid *pixels,
1513                                  const struct gl_pixelstore_attrib *packing )
1514{
1515   return gl_unpack_image3D( ctx, width, height, 1,
1516                             format, type, pixels, packing );
1517}
1518
1519
1520
1521/*
1522 * Unpack a 1, 2 or 3-D image from user-supplied address, returning a
1523 * pointer to a new gl_image struct.
1524 * This function is always called by a higher-level unpack function such
1525 * as gl_unpack_texsubimage() or gl_unpack_bitmap().
1526 *
1527 * Input:  width, height, depth - size in pixels
1528 *         format - format of incoming pixel data
1529 *         type - datatype of incoming pixel data
1530 *         pixels - pointer to unpacked image.
1531 */
1532struct gl_image *gl_unpack_image3D( GLcontext *ctx,
1533                                    GLint width, GLint height, GLint depth,
1534                                    GLenum format, GLenum type,
1535                                    const GLvoid *pixels,
1536                                    const struct gl_pixelstore_attrib *packing)
1537{
1538   if (width <= 0 || height <= 0 || depth <= 0) {
1539      return alloc_error_image(width, height, depth, format, type);
1540   }
1541
1542   if (type==GL_BITMAP) {
1543      if (format != GL_COLOR_INDEX && format != GL_STENCIL_INDEX) {
1544         return alloc_error_image(width, height, depth, format, type);
1545      }
1546      else {
1547         return unpack_bitmap( format, width, height, pixels, packing );
1548      }
1549   }
1550   else if (format==GL_DEPTH_COMPONENT) {
1551      /* TODO: pack as GLdepth values (GLushort or GLuint) */
1552      return unpack_depth_image( ctx, type, width, height, pixels, packing );
1553   }
1554   else if (format==GL_STENCIL_INDEX) {
1555      /* TODO: pack as GLstencil (GLubyte or GLushort) */
1556      return unpack_stencil_image( ctx, type, width, height, pixels, packing );
1557   }
1558   else if (type==GL_UNSIGNED_BYTE) {
1559      /* upack, convert to GLubytes */
1560      return unpack_ubyte_image( width, height, depth, format, pixels, packing );
1561   }
1562   else {
1563      /* upack, convert to floats */
1564      return unpack_float_image( ctx, width, height, depth,
1565                                 format, type, pixels, packing );
1566   }
1567
1568   /* never get here */
1569   /*return NULL;*/
1570}
1571
1572
1573/*
1574 * Apply pixel-transfer operations (scale, bias, mapping) to a single row
1575 * of a gl_image.  Put resulting color components into result array.
1576 */
1577void gl_scale_bias_map_image_data( const GLcontext *ctx,
1578                                   const struct gl_image *image,
1579                                   GLint row, GLubyte result[] )
1580{
1581   GLint start, i;
1582
1583   assert(ctx);
1584   assert(image);
1585   assert(result);
1586   assert(row >= 0);
1587
1588   start = row * image->Width * image->Components;
1589
1590   for (i=0; i < image->Width; i++) {
1591      GLint pos = start+i;
1592      GLfloat red, green, blue, alpha;
1593      if (image->Type == GL_UNSIGNED_BYTE) {
1594         const GLubyte *data = (GLubyte *) image->Data;
1595         switch (image->Format) {
1596            case GL_RED:
1597               red   = data[pos] * (1.0F/255.0F);
1598               green = 0;
1599               blue  = 0;
1600               alpha = 0;
1601               break;
1602            case GL_RGB:
1603               red   = data[pos*3+0] * (1.0F/255.0F);
1604               green = data[pos*3+1] * (1.0F/255.0F);
1605               blue  = data[pos*3+2] * (1.0F/255.0F);
1606               alpha = 0;
1607               break;
1608            default:
1609               gl_problem(ctx, "bad image format in gl_scale...image_data");
1610               return;
1611         }
1612      }
1613      else if (image->Type == GL_FLOAT) {
1614         const GLubyte *data = (GLubyte *) image->Data;
1615         switch (image->Format) {
1616            case GL_RED:
1617               red   = data[pos];
1618               green = 0;
1619               blue  = 0;
1620               alpha = 0;
1621               break;
1622            case GL_RGB:
1623               red   = data[pos*3+0];
1624               green = data[pos*3+1];
1625               blue  = data[pos*3+2];
1626               alpha = 0;
1627               break;
1628            default:
1629               gl_problem(ctx, "bad image format in gl_scale...image_data");
1630               return;
1631         }
1632      }
1633      else {
1634         gl_problem(ctx, "Bad image type in gl_scale_...image_data");
1635         return;
1636      }
1637
1638      assert(red   >= 0.0 && red   <= 1.0);
1639      assert(green >= 0.0 && green <= 1.0);
1640      assert(blue  >= 0.0 && blue  <= 1.0);
1641      assert(alpha >= 0.0 && alpha <= 1.0);
1642
1643      /*
1644      if (scale or bias) {
1645
1646
1647      }
1648      if (mapping) {
1649
1650      }
1651      */
1652
1653      result[i*4+0] = (GLubyte) (red   * 255.0);
1654      result[i*4+1] = (GLubyte) (green * 255.0);
1655      result[i*4+2] = (GLubyte) (blue  * 255.0);
1656      result[i*4+3] = (GLubyte) (alpha * 255.0);
1657   }
1658}
1659
1660
1661
1662/*
1663 * Pack the given RGBA span into client memory at 'dest' address
1664 * in the given pixel format and type.
1665 * Optionally apply the enabled pixel transfer ops.
1666 * Pack into memory using the given packing params struct.
1667 * This is used by glReadPixels and glGetTexImage?D()
1668 * Input:  ctx - the context
1669 *         n - number of pixels in the span
1670 *         rgba - the pixels
1671 *         format - dest packing format
1672 *         type - dest packing datatype
1673 *         destination - destination packing address
1674 *         packing - pixel packing parameters
1675 *         applyTransferOps - apply scale/bias/lookup-table ops?
1676 */
1677void gl_pack_rgba_span( const GLcontext *ctx,
1678                        GLuint n, CONST GLubyte rgba[][4],
1679                        GLenum format, GLenum type, GLvoid *destination,
1680                        const struct gl_pixelstore_attrib *packing,
1681                        GLboolean applyTransferOps )
1682{
1683   /* Test for optimized case first */
1684   if (!ctx->Pixel.ScaleOrBiasRGBA && !ctx->Pixel.MapColorFlag &&
1685       format == GL_RGBA && type == GL_UNSIGNED_BYTE) {
1686      /* common simple case */
1687      MEMCPY( destination, rgba, n * 4 * sizeof(GLubyte) );
1688   }
1689   else if (!ctx->Pixel.ScaleOrBiasRGBA && !ctx->Pixel.MapColorFlag &&
1690       format == GL_RGB && type == GL_UNSIGNED_BYTE) {
1691      /* common simple case */
1692      GLint i;
1693      GLubyte *dest = (GLubyte *) destination;
1694      for (i = 0; i < n; i++) {
1695         dest[0] = rgba[i][RCOMP];
1696         dest[1] = rgba[i][GCOMP];
1697         dest[2] = rgba[i][BCOMP];
1698         dest += 3;
1699      }
1700   }
1701   else {
1702      GLfloat red[MAX_WIDTH], green[MAX_WIDTH], blue[MAX_WIDTH];
1703      GLfloat alpha[MAX_WIDTH], luminance[MAX_WIDTH];
1704      const GLfloat rscale = 1.0F / 255.0F;
1705      const GLfloat gscale = 1.0F / 255.0F;
1706      const GLfloat bscale = 1.0F / 255.0F;
1707      const GLfloat ascale = 1.0F / 255.0F;
1708      const GLint comps = gl_components_in_format(format);
1709      GLuint i;
1710
1711      assert(n <= MAX_WIDTH);
1712
1713      /* convert color components to floating point */
1714      for (i=0;i<n;i++) {
1715         red[i]   = rgba[i][RCOMP] * rscale;
1716         green[i] = rgba[i][GCOMP] * gscale;
1717         blue[i]  = rgba[i][BCOMP] * bscale;
1718         alpha[i] = rgba[i][ACOMP] * ascale;
1719      }
1720
1721      /*
1722       * Apply scale, bias and lookup-tables if enabled.
1723       */
1724      if (applyTransferOps) {
1725         if (ctx->Pixel.ScaleOrBiasRGBA) {
1726            gl_scale_and_bias_color( ctx, n, red, green, blue, alpha );
1727         }
1728         if (ctx->Pixel.MapColorFlag) {
1729            gl_map_color( ctx, n, red, green, blue, alpha );
1730         }
1731      }
1732
1733      if (format==GL_LUMINANCE || format==GL_LUMINANCE_ALPHA) {
1734         for (i=0;i<n;i++) {
1735            GLfloat sum = red[i] + green[i] + blue[i];
1736            luminance[i] = CLAMP( sum, 0.0F, 1.0F );
1737         }
1738      }
1739
1740      /*
1741       * Pack/store the pixels.  Ugh!  Lots of cases!!!
1742       */
1743      switch (type) {
1744         case GL_UNSIGNED_BYTE:
1745            {
1746               GLubyte *dst = (GLubyte *) destination;
1747               switch (format) {
1748                  case GL_RED:
1749                     for (i=0;i<n;i++)
1750                        dst[i] = FLOAT_TO_UBYTE(red[i]);
1751                     break;
1752                  case GL_GREEN:
1753                     for (i=0;i<n;i++)
1754                        dst[i] = FLOAT_TO_UBYTE(green[i]);
1755                     break;
1756                  case GL_BLUE:
1757                     for (i=0;i<n;i++)
1758                        dst[i] = FLOAT_TO_UBYTE(blue[i]);
1759                     break;
1760                  case GL_ALPHA:
1761                     for (i=0;i<n;i++)
1762                        dst[i] = FLOAT_TO_UBYTE(alpha[i]);
1763                     break;
1764                  case GL_LUMINANCE:
1765                     for (i=0;i<n;i++)
1766                        dst[i] = FLOAT_TO_UBYTE(luminance[i]);
1767                     break;
1768                  case GL_LUMINANCE_ALPHA:
1769                     for (i=0;i<n;i++) {
1770                        dst[i*2+0] = FLOAT_TO_UBYTE(luminance[i]);
1771                        dst[i*2+1] = FLOAT_TO_UBYTE(alpha[i]);
1772                     }
1773                     break;
1774                  case GL_RGB:
1775                     for (i=0;i<n;i++) {
1776                        dst[i*3+0] = FLOAT_TO_UBYTE(red[i]);
1777                        dst[i*3+1] = FLOAT_TO_UBYTE(green[i]);
1778                        dst[i*3+2] = FLOAT_TO_UBYTE(blue[i]);
1779                     }
1780                     break;
1781                  case GL_RGBA:
1782                     for (i=0;i<n;i++) {
1783                        dst[i*4+0] = FLOAT_TO_UBYTE(red[i]);
1784                        dst[i*4+1] = FLOAT_TO_UBYTE(green[i]);
1785                        dst[i*4+2] = FLOAT_TO_UBYTE(blue[i]);
1786                        dst[i*4+3] = FLOAT_TO_UBYTE(alpha[i]);
1787                     }
1788                     break;
1789                  case GL_BGR:
1790                     for (i=0;i<n;i++) {
1791                        dst[i*3+0] = FLOAT_TO_UBYTE(blue[i]);
1792                        dst[i*3+1] = FLOAT_TO_UBYTE(green[i]);
1793                        dst[i*3+2] = FLOAT_TO_UBYTE(red[i]);
1794                     }
1795                     break;
1796                  case GL_BGRA:
1797                     for (i=0;i<n;i++) {
1798                        dst[i*4+0] = FLOAT_TO_UBYTE(blue[i]);
1799                        dst[i*4+1] = FLOAT_TO_UBYTE(green[i]);
1800                        dst[i*4+2] = FLOAT_TO_UBYTE(red[i]);
1801                        dst[i*4+3] = FLOAT_TO_UBYTE(alpha[i]);
1802                     }
1803                     break;
1804                  case GL_ABGR_EXT:
1805                     for (i=0;i<n;i++) {
1806                        dst[i*4+0] = FLOAT_TO_UBYTE(alpha[i]);
1807                        dst[i*4+1] = FLOAT_TO_UBYTE(blue[i]);
1808                        dst[i*4+2] = FLOAT_TO_UBYTE(green[i]);
1809                        dst[i*4+3] = FLOAT_TO_UBYTE(red[i]);
1810                     }
1811                     break;
1812                  default:
1813                     gl_problem(ctx, "bad format in gl_pack_rgba_span\n");
1814               }
1815	    }
1816	    break;
1817	 case GL_BYTE:
1818            {
1819               GLbyte *dst = (GLbyte *) destination;
1820               switch (format) {
1821                  case GL_RED:
1822                     for (i=0;i<n;i++)
1823                        dst[i] = FLOAT_TO_BYTE(red[i]);
1824                     break;
1825                  case GL_GREEN:
1826                     for (i=0;i<n;i++)
1827                        dst[i] = FLOAT_TO_BYTE(green[i]);
1828                     break;
1829                  case GL_BLUE:
1830                     for (i=0;i<n;i++)
1831                        dst[i] = FLOAT_TO_BYTE(blue[i]);
1832                     break;
1833                  case GL_ALPHA:
1834                     for (i=0;i<n;i++)
1835                        dst[i] = FLOAT_TO_BYTE(alpha[i]);
1836                     break;
1837                  case GL_LUMINANCE:
1838                     for (i=0;i<n;i++)
1839                        dst[i] = FLOAT_TO_BYTE(luminance[i]);
1840                     break;
1841                  case GL_LUMINANCE_ALPHA:
1842                     for (i=0;i<n;i++) {
1843                        dst[i*2+0] = FLOAT_TO_BYTE(luminance[i]);
1844                        dst[i*2+1] = FLOAT_TO_BYTE(alpha[i]);
1845                     }
1846                     break;
1847                  case GL_RGB:
1848                     for (i=0;i<n;i++) {
1849                        dst[i*3+0] = FLOAT_TO_BYTE(red[i]);
1850                        dst[i*3+1] = FLOAT_TO_BYTE(green[i]);
1851                        dst[i*3+2] = FLOAT_TO_BYTE(blue[i]);
1852                     }
1853                     break;
1854                  case GL_RGBA:
1855                     for (i=0;i<n;i++) {
1856                        dst[i*4+0] = FLOAT_TO_BYTE(red[i]);
1857                        dst[i*4+1] = FLOAT_TO_BYTE(green[i]);
1858                        dst[i*4+2] = FLOAT_TO_BYTE(blue[i]);
1859                        dst[i*4+3] = FLOAT_TO_BYTE(alpha[i]);
1860                     }
1861                     break;
1862                  case GL_BGR:
1863                     for (i=0;i<n;i++) {
1864                        dst[i*3+0] = FLOAT_TO_BYTE(blue[i]);
1865                        dst[i*3+1] = FLOAT_TO_BYTE(green[i]);
1866                        dst[i*3+2] = FLOAT_TO_BYTE(red[i]);
1867                     }
1868                     break;
1869                  case GL_BGRA:
1870                     for (i=0;i<n;i++) {
1871                        dst[i*4+0] = FLOAT_TO_BYTE(blue[i]);
1872                        dst[i*4+1] = FLOAT_TO_BYTE(green[i]);
1873                        dst[i*4+2] = FLOAT_TO_BYTE(red[i]);
1874                        dst[i*4+3] = FLOAT_TO_BYTE(alpha[i]);
1875                     }
1876                  case GL_ABGR_EXT:
1877                     for (i=0;i<n;i++) {
1878                        dst[i*4+0] = FLOAT_TO_BYTE(alpha[i]);
1879                        dst[i*4+1] = FLOAT_TO_BYTE(blue[i]);
1880                        dst[i*4+2] = FLOAT_TO_BYTE(green[i]);
1881                        dst[i*4+3] = FLOAT_TO_BYTE(red[i]);
1882                     }
1883                     break;
1884                  default:
1885                     gl_problem(ctx, "bad format in gl_pack_rgba_span\n");
1886               }
1887            }
1888	    break;
1889	 case GL_UNSIGNED_SHORT:
1890            {
1891               GLushort *dst = (GLushort *) destination;
1892               switch (format) {
1893                  case GL_RED:
1894                     for (i=0;i<n;i++)
1895                        dst[i] = FLOAT_TO_USHORT(red[i]);
1896                     break;
1897                  case GL_GREEN:
1898                     for (i=0;i<n;i++)
1899                        dst[i] = FLOAT_TO_USHORT(green[i]);
1900                     break;
1901                  case GL_BLUE:
1902                     for (i=0;i<n;i++)
1903                        dst[i] = FLOAT_TO_USHORT(blue[i]);
1904                     break;
1905                  case GL_ALPHA:
1906                     for (i=0;i<n;i++)
1907                        dst[i] = FLOAT_TO_USHORT(alpha[i]);
1908                     break;
1909                  case GL_LUMINANCE:
1910                     for (i=0;i<n;i++)
1911                        dst[i] = FLOAT_TO_USHORT(luminance[i]);
1912                     break;
1913                  case GL_LUMINANCE_ALPHA:
1914                     for (i=0;i<n;i++) {
1915                        dst[i*2+0] = FLOAT_TO_USHORT(luminance[i]);
1916                        dst[i*2+1] = FLOAT_TO_USHORT(alpha[i]);
1917                     }
1918                     break;
1919                  case GL_RGB:
1920                     for (i=0;i<n;i++) {
1921                        dst[i*3+0] = FLOAT_TO_USHORT(red[i]);
1922                        dst[i*3+1] = FLOAT_TO_USHORT(green[i]);
1923                        dst[i*3+2] = FLOAT_TO_USHORT(blue[i]);
1924                     }
1925                     break;
1926                  case GL_RGBA:
1927                     for (i=0;i<n;i++) {
1928                        dst[i*4+0] = FLOAT_TO_USHORT(red[i]);
1929                        dst[i*4+1] = FLOAT_TO_USHORT(green[i]);
1930                        dst[i*4+2] = FLOAT_TO_USHORT(blue[i]);
1931                        dst[i*4+3] = FLOAT_TO_USHORT(alpha[i]);
1932                     }
1933                     break;
1934                  case GL_BGR:
1935                     for (i=0;i<n;i++) {
1936                        dst[i*3+0] = FLOAT_TO_USHORT(blue[i]);
1937                        dst[i*3+1] = FLOAT_TO_USHORT(green[i]);
1938                        dst[i*3+2] = FLOAT_TO_USHORT(red[i]);
1939                     }
1940                     break;
1941                  case GL_BGRA:
1942                     for (i=0;i<n;i++) {
1943                        dst[i*4+0] = FLOAT_TO_USHORT(blue[i]);
1944                        dst[i*4+1] = FLOAT_TO_USHORT(green[i]);
1945                        dst[i*4+2] = FLOAT_TO_USHORT(red[i]);
1946                        dst[i*4+3] = FLOAT_TO_USHORT(alpha[i]);
1947                     }
1948                     break;
1949                  case GL_ABGR_EXT:
1950                     for (i=0;i<n;i++) {
1951                        dst[i*4+0] = FLOAT_TO_USHORT(alpha[i]);
1952                        dst[i*4+1] = FLOAT_TO_USHORT(blue[i]);
1953                        dst[i*4+2] = FLOAT_TO_USHORT(green[i]);
1954                        dst[i*4+3] = FLOAT_TO_USHORT(red[i]);
1955                     }
1956                     break;
1957                  default:
1958                     gl_problem(ctx, "bad format in gl_pack_rgba_span\n");
1959               }
1960               if (packing->SwapBytes) {
1961                  gl_swap2( (GLushort *) dst, n * comps);
1962               }
1963            }
1964	    break;
1965	 case GL_SHORT:
1966            {
1967               GLshort *dst = (GLshort *) destination;
1968               switch (format) {
1969                  case GL_RED:
1970                     for (i=0;i<n;i++)
1971                        dst[i] = FLOAT_TO_SHORT(red[i]);
1972                     break;
1973                  case GL_GREEN:
1974                     for (i=0;i<n;i++)
1975                        dst[i] = FLOAT_TO_SHORT(green[i]);
1976                     break;
1977                  case GL_BLUE:
1978                     for (i=0;i<n;i++)
1979                        dst[i] = FLOAT_TO_SHORT(blue[i]);
1980                     break;
1981                  case GL_ALPHA:
1982                     for (i=0;i<n;i++)
1983                        dst[i] = FLOAT_TO_SHORT(alpha[i]);
1984                     break;
1985                  case GL_LUMINANCE:
1986                     for (i=0;i<n;i++)
1987                        dst[i] = FLOAT_TO_SHORT(luminance[i]);
1988                     break;
1989                  case GL_LUMINANCE_ALPHA:
1990                     for (i=0;i<n;i++) {
1991                        dst[i*2+0] = FLOAT_TO_SHORT(luminance[i]);
1992                        dst[i*2+1] = FLOAT_TO_SHORT(alpha[i]);
1993                     }
1994                     break;
1995                  case GL_RGB:
1996                     for (i=0;i<n;i++) {
1997                        dst[i*3+0] = FLOAT_TO_SHORT(red[i]);
1998                        dst[i*3+1] = FLOAT_TO_SHORT(green[i]);
1999                        dst[i*3+2] = FLOAT_TO_SHORT(blue[i]);
2000                     }
2001                     break;
2002                  case GL_RGBA:
2003                     for (i=0;i<n;i++) {
2004                        dst[i*4+0] = FLOAT_TO_SHORT(red[i]);
2005                        dst[i*4+1] = FLOAT_TO_SHORT(green[i]);
2006                        dst[i*4+2] = FLOAT_TO_SHORT(blue[i]);
2007                        dst[i*4+3] = FLOAT_TO_SHORT(alpha[i]);
2008                     }
2009                     break;
2010                  case GL_BGR:
2011                     for (i=0;i<n;i++) {
2012                        dst[i*3+0] = FLOAT_TO_SHORT(blue[i]);
2013                        dst[i*3+1] = FLOAT_TO_SHORT(green[i]);
2014                        dst[i*3+2] = FLOAT_TO_SHORT(red[i]);
2015                     }
2016                     break;
2017                  case GL_BGRA:
2018                     for (i=0;i<n;i++) {
2019                        dst[i*4+0] = FLOAT_TO_SHORT(blue[i]);
2020                        dst[i*4+1] = FLOAT_TO_SHORT(green[i]);
2021                        dst[i*4+2] = FLOAT_TO_SHORT(red[i]);
2022                        dst[i*4+3] = FLOAT_TO_SHORT(alpha[i]);
2023                     }
2024                  case GL_ABGR_EXT:
2025                     for (i=0;i<n;i++) {
2026                        dst[i*4+0] = FLOAT_TO_SHORT(alpha[i]);
2027                        dst[i*4+1] = FLOAT_TO_SHORT(blue[i]);
2028                        dst[i*4+2] = FLOAT_TO_SHORT(green[i]);
2029                        dst[i*4+3] = FLOAT_TO_SHORT(red[i]);
2030                     }
2031                     break;
2032                  default:
2033                     gl_problem(ctx, "bad format in gl_pack_rgba_span\n");
2034               }
2035               if (packing->SwapBytes) {
2036                  gl_swap2( (GLushort *) dst, n * comps );
2037               }
2038            }
2039	    break;
2040	 case GL_UNSIGNED_INT:
2041            {
2042               GLuint *dst = (GLuint *) destination;
2043               switch (format) {
2044                  case GL_RED:
2045                     for (i=0;i<n;i++)
2046                        dst[i] = FLOAT_TO_UINT(red[i]);
2047                     break;
2048                  case GL_GREEN:
2049                     for (i=0;i<n;i++)
2050                        dst[i] = FLOAT_TO_UINT(green[i]);
2051                     break;
2052                  case GL_BLUE:
2053                     for (i=0;i<n;i++)
2054                        dst[i] = FLOAT_TO_UINT(blue[i]);
2055                     break;
2056                  case GL_ALPHA:
2057                     for (i=0;i<n;i++)
2058                        dst[i] = FLOAT_TO_UINT(alpha[i]);
2059                     break;
2060                  case GL_LUMINANCE:
2061                     for (i=0;i<n;i++)
2062                        dst[i] = FLOAT_TO_UINT(luminance[i]);
2063                     break;
2064                  case GL_LUMINANCE_ALPHA:
2065                     for (i=0;i<n;i++) {
2066                        dst[i*2+0] = FLOAT_TO_UINT(luminance[i]);
2067                        dst[i*2+1] = FLOAT_TO_UINT(alpha[i]);
2068                     }
2069                     break;
2070                  case GL_RGB:
2071                     for (i=0;i<n;i++) {
2072                        dst[i*3+0] = FLOAT_TO_UINT(red[i]);
2073                        dst[i*3+1] = FLOAT_TO_UINT(green[i]);
2074                        dst[i*3+2] = FLOAT_TO_UINT(blue[i]);
2075                     }
2076                     break;
2077                  case GL_RGBA:
2078                     for (i=0;i<n;i++) {
2079                        dst[i*4+0] = FLOAT_TO_UINT(red[i]);
2080                        dst[i*4+1] = FLOAT_TO_UINT(green[i]);
2081                        dst[i*4+2] = FLOAT_TO_UINT(blue[i]);
2082                        dst[i*4+3] = FLOAT_TO_UINT(alpha[i]);
2083                     }
2084                     break;
2085                  case GL_BGR:
2086                     for (i=0;i<n;i++) {
2087                        dst[i*3+0] = FLOAT_TO_UINT(blue[i]);
2088                        dst[i*3+1] = FLOAT_TO_UINT(green[i]);
2089                        dst[i*3+2] = FLOAT_TO_UINT(red[i]);
2090                     }
2091                     break;
2092                  case GL_BGRA:
2093                     for (i=0;i<n;i++) {
2094                        dst[i*4+0] = FLOAT_TO_UINT(blue[i]);
2095                        dst[i*4+1] = FLOAT_TO_UINT(green[i]);
2096                        dst[i*4+2] = FLOAT_TO_UINT(red[i]);
2097                        dst[i*4+3] = FLOAT_TO_UINT(alpha[i]);
2098                     }
2099                     break;
2100                  case GL_ABGR_EXT:
2101                     for (i=0;i<n;i++) {
2102                        dst[i*4+0] = FLOAT_TO_UINT(alpha[i]);
2103                        dst[i*4+1] = FLOAT_TO_UINT(blue[i]);
2104                        dst[i*4+2] = FLOAT_TO_UINT(green[i]);
2105                        dst[i*4+3] = FLOAT_TO_UINT(red[i]);
2106                     }
2107                     break;
2108                  default:
2109                     gl_problem(ctx, "bad format in gl_pack_rgba_span\n");
2110               }
2111               if (packing->SwapBytes) {
2112                  gl_swap4( (GLuint *) dst, n * comps );
2113               }
2114            }
2115	    break;
2116	 case GL_INT:
2117	    {
2118               GLint *dst = (GLint *) destination;
2119               switch (format) {
2120                  case GL_RED:
2121                     for (i=0;i<n;i++)
2122                        dst[i] = FLOAT_TO_INT(red[i]);
2123                     break;
2124                  case GL_GREEN:
2125                     for (i=0;i<n;i++)
2126                        dst[i] = FLOAT_TO_INT(green[i]);
2127                     break;
2128                  case GL_BLUE:
2129                     for (i=0;i<n;i++)
2130                        dst[i] = FLOAT_TO_INT(blue[i]);
2131                     break;
2132                  case GL_ALPHA:
2133                     for (i=0;i<n;i++)
2134                        dst[i] = FLOAT_TO_INT(alpha[i]);
2135                     break;
2136                  case GL_LUMINANCE:
2137                     for (i=0;i<n;i++)
2138                        dst[i] = FLOAT_TO_INT(luminance[i]);
2139                     break;
2140                  case GL_LUMINANCE_ALPHA:
2141                     for (i=0;i<n;i++) {
2142                        dst[i*2+0] = FLOAT_TO_INT(luminance[i]);
2143                        dst[i*2+1] = FLOAT_TO_INT(alpha[i]);
2144                     }
2145                     break;
2146                  case GL_RGB:
2147                     for (i=0;i<n;i++) {
2148                        dst[i*3+0] = FLOAT_TO_INT(red[i]);
2149                        dst[i*3+1] = FLOAT_TO_INT(green[i]);
2150                        dst[i*3+2] = FLOAT_TO_INT(blue[i]);
2151                     }
2152                     break;
2153                  case GL_RGBA:
2154                     for (i=0;i<n;i++) {
2155                        dst[i*4+0] = FLOAT_TO_INT(red[i]);
2156                        dst[i*4+1] = FLOAT_TO_INT(green[i]);
2157                        dst[i*4+2] = FLOAT_TO_INT(blue[i]);
2158                        dst[i*4+3] = FLOAT_TO_INT(alpha[i]);
2159                     }
2160                     break;
2161                  case GL_BGR:
2162                     for (i=0;i<n;i++) {
2163                        dst[i*3+0] = FLOAT_TO_INT(blue[i]);
2164                        dst[i*3+1] = FLOAT_TO_INT(green[i]);
2165                        dst[i*3+2] = FLOAT_TO_INT(red[i]);
2166                     }
2167                     break;
2168                  case GL_BGRA:
2169                     for (i=0;i<n;i++) {
2170                        dst[i*4+0] = FLOAT_TO_INT(blue[i]);
2171                        dst[i*4+1] = FLOAT_TO_INT(green[i]);
2172                        dst[i*4+2] = FLOAT_TO_INT(red[i]);
2173                        dst[i*4+3] = FLOAT_TO_INT(alpha[i]);
2174                     }
2175                     break;
2176                  case GL_ABGR_EXT:
2177                     for (i=0;i<n;i++) {
2178                        dst[i*4+0] = FLOAT_TO_INT(alpha[i]);
2179                        dst[i*4+1] = FLOAT_TO_INT(blue[i]);
2180                        dst[i*4+2] = FLOAT_TO_INT(green[i]);
2181                        dst[i*4+3] = FLOAT_TO_INT(red[i]);
2182                     }
2183                     break;
2184                  default:
2185                     gl_problem(ctx, "bad format in gl_pack_rgba_span\n");
2186               }
2187	       if (packing->SwapBytes) {
2188		  gl_swap4( (GLuint *) dst, n * comps );
2189	       }
2190	    }
2191	    break;
2192	 case GL_FLOAT:
2193	    {
2194               GLfloat *dst = (GLfloat *) destination;
2195               switch (format) {
2196                  case GL_RED:
2197                     for (i=0;i<n;i++)
2198                        dst[i] = red[i];
2199                     break;
2200                  case GL_GREEN:
2201                     for (i=0;i<n;i++)
2202                        dst[i] = green[i];
2203                     break;
2204                  case GL_BLUE:
2205                     for (i=0;i<n;i++)
2206                        dst[i] = blue[i];
2207                     break;
2208                  case GL_ALPHA:
2209                     for (i=0;i<n;i++)
2210                        dst[i] = alpha[i];
2211                     break;
2212                  case GL_LUMINANCE:
2213                     for (i=0;i<n;i++)
2214                        dst[i] = luminance[i];
2215                     break;
2216                  case GL_LUMINANCE_ALPHA:
2217                     for (i=0;i<n;i++) {
2218                        dst[i*2+0] = luminance[i];
2219                        dst[i*2+1] = alpha[i];
2220                     }
2221                     break;
2222                  case GL_RGB:
2223                     for (i=0;i<n;i++) {
2224                        dst[i*3+0] = red[i];
2225                        dst[i*3+1] = green[i];
2226                        dst[i*3+2] = blue[i];
2227                     }
2228                     break;
2229                  case GL_RGBA:
2230                     for (i=0;i<n;i++) {
2231                        dst[i*4+0] = red[i];
2232                        dst[i*4+1] = green[i];
2233                        dst[i*4+2] = blue[i];
2234                        dst[i*4+3] = alpha[i];
2235                     }
2236                     break;
2237                  case GL_BGR:
2238                     for (i=0;i<n;i++) {
2239                        dst[i*3+0] = blue[i];
2240                        dst[i*3+1] = green[i];
2241                        dst[i*3+2] = red[i];
2242                     }
2243                     break;
2244                  case GL_BGRA:
2245                     for (i=0;i<n;i++) {
2246                        dst[i*4+0] = blue[i];
2247                        dst[i*4+1] = green[i];
2248                        dst[i*4+2] = red[i];
2249                        dst[i*4+3] = alpha[i];
2250                     }
2251                     break;
2252                  case GL_ABGR_EXT:
2253                     for (i=0;i<n;i++) {
2254                        dst[i*4+0] = alpha[i];
2255                        dst[i*4+1] = blue[i];
2256                        dst[i*4+2] = green[i];
2257                        dst[i*4+3] = red[i];
2258                     }
2259                     break;
2260                  default:
2261                     gl_problem(ctx, "bad format in gl_pack_rgba_span\n");
2262               }
2263	       if (packing->SwapBytes) {
2264		  gl_swap4( (GLuint *) dst, n * comps );
2265	       }
2266	    }
2267	    break;
2268         case GL_UNSIGNED_BYTE_3_3_2:
2269            if (format == GL_RGB) {
2270               GLubyte *dst = (GLubyte *) destination;
2271               for (i=0;i<n;i++) {
2272                  dst[i] = (((GLint) (red[i]   * 7.0F)) << 5)
2273                         | (((GLint) (green[i] * 7.0F)) << 2)
2274                         | (((GLint) (blue[i]  * 3.0F))     );
2275               }
2276            }
2277            break;
2278         case GL_UNSIGNED_BYTE_2_3_3_REV:
2279            if (format == GL_RGB) {
2280               GLubyte *dst = (GLubyte *) destination;
2281               for (i=0;i<n;i++) {
2282                  dst[i] = (((GLint) (red[i]   * 7.0F))     )
2283                         | (((GLint) (green[i] * 7.0F)) << 3)
2284                         | (((GLint) (blue[i]  * 3.0F)) << 5);
2285               }
2286            }
2287            break;
2288         case GL_UNSIGNED_SHORT_5_6_5:
2289            if (format == GL_RGB) {
2290               GLushort *dst = (GLushort *) destination;
2291               for (i=0;i<n;i++) {
2292                  dst[i] = (((GLint) (red[i]   * 31.0F)) << 11)
2293                         | (((GLint) (green[i] * 63.0F)) <<  5)
2294                         | (((GLint) (blue[i]  * 31.0F))      );
2295               }
2296            }
2297            break;
2298         case GL_UNSIGNED_SHORT_5_6_5_REV:
2299            if (format == GL_RGB) {
2300               GLushort *dst = (GLushort *) destination;
2301               for (i=0;i<n;i++) {
2302                  dst[i] = (((GLint) (red[i]   * 31.0F))      )
2303                         | (((GLint) (green[i] * 63.0F)) <<  5)
2304                         | (((GLint) (blue[i]  * 31.0F)) << 11);
2305               }
2306            }
2307            break;
2308         case GL_UNSIGNED_SHORT_4_4_4_4:
2309            if (format == GL_RGB) {
2310               GLushort *dst = (GLushort *) destination;
2311               for (i=0;i<n;i++) {
2312                  dst[i] = (((GLint) (red[i]   * 15.0F)) << 12)
2313                         | (((GLint) (green[i] * 15.0F)) <<  8)
2314                         | (((GLint) (blue[i]  * 15.0F)) <<  4)
2315                         | (((GLint) (alpha[i] * 15.0F))      );
2316               }
2317            }
2318            break;
2319         case GL_UNSIGNED_SHORT_4_4_4_4_REV:
2320            if (format == GL_RGB) {
2321               GLushort *dst = (GLushort *) destination;
2322               for (i=0;i<n;i++) {
2323                  dst[i] = (((GLint) (red[i]   * 15.0F))      )
2324                         | (((GLint) (green[i] * 15.0F)) <<  4)
2325                         | (((GLint) (blue[i]  * 15.0F)) <<  8)
2326                         | (((GLint) (alpha[i] * 15.0F)) << 12);
2327               }
2328            }
2329            break;
2330         case GL_UNSIGNED_SHORT_5_5_5_1:
2331            if (format == GL_RGB) {
2332               GLushort *dst = (GLushort *) destination;
2333               for (i=0;i<n;i++) {
2334                  dst[i] = (((GLint) (red[i]   * 31.0F)) << 11)
2335                         | (((GLint) (green[i] * 31.0F)) <<  6)
2336                         | (((GLint) (blue[i]  * 31.0F)) <<  1)
2337                         | (((GLint) (alpha[i] *  1.0F))      );
2338               }
2339            }
2340            break;
2341         case GL_UNSIGNED_SHORT_1_5_5_5_REV:
2342            if (format == GL_RGB) {
2343               GLushort *dst = (GLushort *) destination;
2344               for (i=0;i<n;i++) {
2345                  dst[i] = (((GLint) (red[i]   * 31.0F))      )
2346                         | (((GLint) (green[i] * 31.0F)) <<  5)
2347                         | (((GLint) (blue[i]  * 31.0F)) << 10)
2348                         | (((GLint) (alpha[i] *  1.0F)) << 15);
2349               }
2350            }
2351            break;
2352         case GL_UNSIGNED_INT_8_8_8_8:
2353            if (format == GL_RGBA) {
2354               GLuint *dst = (GLuint *) destination;
2355               for (i=0;i<n;i++) {
2356                  dst[i] = (((GLuint) (red[i]   * 255.0F)) << 24)
2357                         | (((GLuint) (green[i] * 255.0F)) << 16)
2358                         | (((GLuint) (blue[i]  * 255.0F)) <<  8)
2359                         | (((GLuint) (alpha[i] * 255.0F))      );
2360               }
2361            }
2362            else if (format == GL_BGRA) {
2363               GLuint *dst = (GLuint *) destination;
2364               for (i=0;i<n;i++) {
2365                  dst[i] = (((GLuint) (blue[i]  * 255.0F)) << 24)
2366                         | (((GLuint) (green[i] * 255.0F)) << 16)
2367                         | (((GLuint) (red[i]   * 255.0F)) <<  8)
2368                         | (((GLuint) (alpha[i] * 255.0F))      );
2369               }
2370            }
2371            else if (format == GL_ABGR_EXT) {
2372               GLuint *dst = (GLuint *) destination;
2373               for (i=0;i<n;i++) {
2374                  dst[i] = (((GLuint) (alpha[i] * 255.0F)) << 24)
2375                         | (((GLuint) (blue[i]  * 255.0F)) << 16)
2376                         | (((GLuint) (green[i] * 255.0F)) <<  8)
2377                         | (((GLuint) (red[i]   * 255.0F))      );
2378               }
2379            }
2380            break;
2381         case GL_UNSIGNED_INT_8_8_8_8_REV:
2382            if (format == GL_RGBA) {
2383               GLuint *dst = (GLuint *) destination;
2384               for (i=0;i<n;i++) {
2385                  dst[i] = (((GLuint) (red[i]   * 255.0F))      )
2386                         | (((GLuint) (green[i] * 255.0F)) <<  8)
2387                         | (((GLuint) (blue[i]  * 255.0F)) << 16)
2388                         | (((GLuint) (alpha[i] * 255.0F)) << 24);
2389               }
2390            }
2391            else if (format == GL_BGRA) {
2392               GLuint *dst = (GLuint *) destination;
2393               for (i=0;i<n;i++) {
2394                  dst[i] = (((GLuint) (blue[i]  * 255.0F))      )
2395                         | (((GLuint) (green[i] * 255.0F)) <<  8)
2396                         | (((GLuint) (red[i]   * 255.0F)) << 16)
2397                         | (((GLuint) (alpha[i] * 255.0F)) << 24);
2398               }
2399            }
2400            else if (format == GL_ABGR_EXT) {
2401               GLuint *dst = (GLuint *) destination;
2402               for (i=0;i<n;i++) {
2403                  dst[i] = (((GLuint) (alpha[i] * 255.0F))      )
2404                         | (((GLuint) (blue[i]  * 255.0F)) <<  8)
2405                         | (((GLuint) (green[i] * 255.0F)) << 16)
2406                         | (((GLuint) (red[i]   * 255.0F)) << 24);
2407               }
2408            }
2409            break;
2410         case GL_UNSIGNED_INT_10_10_10_2:
2411            if (format == GL_RGBA) {
2412               GLuint *dst = (GLuint *) destination;
2413               for (i=0;i<n;i++) {
2414                  dst[i] = (((GLuint) (red[i]   * 1023.0F)) << 22)
2415                         | (((GLuint) (green[i] * 1023.0F)) << 12)
2416                         | (((GLuint) (blue[i]  * 1023.0F)) <<  2)
2417                         | (((GLuint) (alpha[i] *    3.0F))      );
2418               }
2419            }
2420            else if (format == GL_BGRA) {
2421               GLuint *dst = (GLuint *) destination;
2422               for (i=0;i<n;i++) {
2423                  dst[i] = (((GLuint) (blue[i]  * 1023.0F)) << 22)
2424                         | (((GLuint) (green[i] * 1023.0F)) << 12)
2425                         | (((GLuint) (red[i]   * 1023.0F)) <<  2)
2426                         | (((GLuint) (alpha[i] *    3.0F))      );
2427               }
2428            }
2429            else if (format == GL_ABGR_EXT) {
2430               GLuint *dst = (GLuint *) destination;
2431               for (i=0;i<n;i++) {
2432                  dst[i] = (((GLuint) (alpha[i] * 1023.0F)) << 22)
2433                         | (((GLuint) (blue[i]  * 1023.0F)) << 12)
2434                         | (((GLuint) (green[i] * 1023.0F)) <<  2)
2435                         | (((GLuint) (red[i]   *    3.0F))      );
2436               }
2437            }
2438            break;
2439         case GL_UNSIGNED_INT_2_10_10_10_REV:
2440            if (format == GL_RGBA) {
2441               GLuint *dst = (GLuint *) destination;
2442               for (i=0;i<n;i++) {
2443                  dst[i] = (((GLuint) (red[i]   * 1023.0F))      )
2444                         | (((GLuint) (green[i] * 1023.0F)) << 10)
2445                         | (((GLuint) (blue[i]  * 1023.0F)) << 20)
2446                         | (((GLuint) (alpha[i] *    3.0F)) << 30);
2447               }
2448            }
2449            else if (format == GL_BGRA) {
2450               GLuint *dst = (GLuint *) destination;
2451               for (i=0;i<n;i++) {
2452                  dst[i] = (((GLuint) (blue[i]  * 1023.0F))      )
2453                         | (((GLuint) (green[i] * 1023.0F)) << 10)
2454                         | (((GLuint) (red[i]   * 1023.0F)) << 20)
2455                         | (((GLuint) (alpha[i] *    3.0F)) << 30);
2456               }
2457            }
2458            else if (format == GL_ABGR_EXT) {
2459               GLuint *dst = (GLuint *) destination;
2460               for (i=0;i<n;i++) {
2461                  dst[i] = (((GLuint) (alpha[i] * 1023.0F))      )
2462                         | (((GLuint) (blue[i]  * 1023.0F)) << 10)
2463                         | (((GLuint) (green[i] * 1023.0F)) << 20)
2464                         | (((GLuint) (red[i]   *    3.0F)) << 30);
2465               }
2466            }
2467            break;
2468         default:
2469            gl_problem( ctx, "bad type in gl_pack_rgba_span" );
2470      }
2471   }
2472}
2473