svn merge ^/branches/released .

3 files changed, 9154 insertions, 9012 deletions

diff --git a/mesalib/src/glu/sgi/SConscript b/mesalib/src/glu/sgi/SConscript
new file mode 100644
index 000000000..a0c6c6584
--- /dev/null
+++ b/mesalib/src/glu/sgi/SConscript
@@ -0,0 +1,138 @@
+Import('*')
+
+env = env.Clone()
+
+env.Prepend(CPPPATH = [
+    'include',
+    'internals',
+    'libnurbs/internals',
+    'libnurbs/interface',
+    'libnurbs/nurbtess',
+])
+
+env.Prepend(CPPDEFINES = [
+    'NDEBUG',
+    'LIBRARYBUILD',
+    'RESOLVE_3D_TEXTURE_SUPPORT',
+])
+
+sources = [
+    'libutil/error.c',
+    'libutil/glue.c',
+    'libutil/mipmap.c',
+    'libutil/project.c',
+    'libutil/quad.c',
+    'libutil/registry.c',
+    'libtess/dict.c',
+    'libtess/geom.c',
+    'libtess/memalloc.c',
+    'libtess/mesh.c',
+    'libtess/normal.c',
+    'libtess/priorityq.c',
+    'libtess/render.c',
+    'libtess/sweep.c',
+    'libtess/tess.c',
+    'libtess/tessmono.c',
+    'libnurbs/interface/bezierEval.cc',
+    'libnurbs/interface/bezierPatch.cc',
+    'libnurbs/interface/bezierPatchMesh.cc',
+    'libnurbs/interface/glcurveval.cc',
+    'libnurbs/interface/glinterface.cc',
+    'libnurbs/interface/glrenderer.cc',
+    'libnurbs/interface/glsurfeval.cc',
+    'libnurbs/interface/incurveeval.cc',
+    'libnurbs/interface/insurfeval.cc',
+    'libnurbs/internals/arc.cc',
+    'libnurbs/internals/arcsorter.cc',
+    'libnurbs/internals/arctess.cc',
+    'libnurbs/internals/backend.cc',
+    'libnurbs/internals/basiccrveval.cc',
+    'libnurbs/internals/basicsurfeval.cc',
+    'libnurbs/internals/bin.cc',
+    'libnurbs/internals/bufpool.cc',
+    'libnurbs/internals/cachingeval.cc',
+    'libnurbs/internals/ccw.cc',
+    'libnurbs/internals/coveandtiler.cc',
+    'libnurbs/internals/curve.cc',
+    'libnurbs/internals/curvelist.cc',
+    'libnurbs/internals/curvesub.cc',
+    'libnurbs/internals/dataTransform.cc',
+    'libnurbs/internals/displaylist.cc',
+    'libnurbs/internals/flist.cc',
+    'libnurbs/internals/flistsorter.cc',
+    'libnurbs/internals/hull.cc',
+    'libnurbs/internals/intersect.cc',
+    'libnurbs/internals/knotvector.cc',
+    'libnurbs/internals/mapdesc.cc',
+    'libnurbs/internals/mapdescv.cc',
+    'libnurbs/internals/maplist.cc',
+    'libnurbs/internals/mesher.cc',
+    'libnurbs/internals/monoTriangulationBackend.cc',
+    'libnurbs/internals/monotonizer.cc',
+    'libnurbs/internals/mycode.cc',
+    'libnurbs/internals/nurbsinterfac.cc',
+    'libnurbs/internals/nurbstess.cc',
+    'libnurbs/internals/patch.cc',
+    'libnurbs/internals/patchlist.cc',
+    'libnurbs/internals/quilt.cc',
+    'libnurbs/internals/reader.cc',
+    'libnurbs/internals/renderhints.cc',
+    'libnurbs/internals/slicer.cc',
+    'libnurbs/internals/sorter.cc',
+    'libnurbs/internals/splitarcs.cc',
+    'libnurbs/internals/subdivider.cc',
+    'libnurbs/internals/tobezier.cc',
+    'libnurbs/internals/trimline.cc',
+    'libnurbs/internals/trimregion.cc',
+    'libnurbs/internals/trimvertpool.cc',
+    'libnurbs/internals/uarray.cc',
+    'libnurbs/internals/varray.cc',
+    'libnurbs/nurbtess/directedLine.cc',
+    'libnurbs/nurbtess/gridWrap.cc',
+    'libnurbs/nurbtess/monoChain.cc',
+    'libnurbs/nurbtess/monoPolyPart.cc',
+    'libnurbs/nurbtess/monoTriangulation.cc',
+    'libnurbs/nurbtess/partitionX.cc',
+    'libnurbs/nurbtess/partitionY.cc',
+    'libnurbs/nurbtess/polyDBG.cc',
+    'libnurbs/nurbtess/polyUtil.cc',
+    'libnurbs/nurbtess/primitiveStream.cc',
+    'libnurbs/nurbtess/quicksort.cc',
+    'libnurbs/nurbtess/rectBlock.cc',
+    'libnurbs/nurbtess/sampleComp.cc',
+    'libnurbs/nurbtess/sampleCompBot.cc',
+    'libnurbs/nurbtess/sampleCompRight.cc',
+    'libnurbs/nurbtess/sampleCompTop.cc',
+    'libnurbs/nurbtess/sampleMonoPoly.cc',
+    'libnurbs/nurbtess/sampledLine.cc',
+    'libnurbs/nurbtess/searchTree.cc',
+]
+
+if env['platform'] == 'windows':
+    # -D_OPENGL32_ -Iinclude -DBUILD_GL32
+    env.PrependUnique(LIBS = [
+        'gdi32', 
+        'user32', 
+        'opengl32', 
+    ])
+    target = 'glu32'
+    sources += ['glu.def']
+else:
+    env.PrependUnique(LIBS = [
+        'GL',
+    ])
+    target = 'glu'
+
+glu = env.SharedLibrary(
+    target = target,
+    source = sources
+)
+
+env.Alias('glu', env.InstallSharedLibrary(glu, version=(1, 3, 0)))
+
+if env['platform'] == 'windows':
+    glu = env.FindIxes(glu, 'LIBPREFIX', 'LIBSUFFIX')
+else:
+    glu = env.FindIxes(glu, 'SHLIBPREFIX', 'SHLIBSUFFIX')
+
+Export('glu')
diff --git a/mesalib/src/glu/sgi/include/gluos.h b/mesalib/src/glu/sgi/include/gluos.h
index 8eaa7a153..e22e6721e 100644
--- a/mesalib/src/glu/sgi/include/gluos.h
+++ b/mesalib/src/glu/sgi/include/gluos.h
@@ -1,72 +1,76 @@
-/*
-** gluos.h - operating system dependencies for GLU
-**
-*/
-#ifdef __VMS
-#ifdef __cplusplus
-#pragma message disable nocordel
-#pragma message disable codeunreachable
-#pragma message disable codcauunr
-#endif
-#endif
-
-#ifdef __WATCOMC__
-/* Disable *lots* of warnings to get a clean build. I can't be bothered fixing the
- * code at the moment, as it is pretty ugly.
- */
-#pragma warning 7   10
-#pragma warning 13  10
-#pragma warning 14  10
-#pragma warning 367 10
-#pragma warning 379 10
-#pragma warning 726 10
-#pragma warning 836 10
-#endif
-
-#ifdef BUILD_FOR_SNAP
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <malloc.h>
-
-#elif defined(_WIN32)
-
-#include <stdlib.h>	    /* For _MAX_PATH definition */
-#include <stdio.h>
-#include <malloc.h>
-
-#define WIN32_LEAN_AND_MEAN
-#define NOGDI
-#define NOIME
-#define NOMINMAX
-
-#define _WIN32_WINNT 0x0400
-#ifndef STRICT
-  #define STRICT 1
-#endif
-
-#include <windows.h>
-
-/* Disable warnings */
-#pragma warning(disable : 4101)
-#pragma warning(disable : 4244)
-#pragma warning(disable : 4761)
-
-#if defined(_MSC_VER) && _MSC_VER >= 1200 && _MSC_VER < 1300
-#pragma comment(linker, "/OPT:NOWIN98")
-#endif
-
-#elif defined(__OS2__)
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <malloc.h>
-#define WINGDIAPI
-
-#else
-
-/* Disable Microsoft-specific keywords */
-#define GLAPIENTRY
-#define WINGDIAPI
-
-#endif
+/*

+** gluos.h - operating system dependencies for GLU

+**

+*/

+#ifdef __VMS

+#ifdef __cplusplus

+#pragma message disable nocordel

+#pragma message disable codeunreachable

+#pragma message disable codcauunr

+#endif

+#endif

+

+#ifdef __WATCOMC__

+/* Disable *lots* of warnings to get a clean build. I can't be bothered fixing the

+ * code at the moment, as it is pretty ugly.

+ */

+#pragma warning 7   10

+#pragma warning 13  10

+#pragma warning 14  10

+#pragma warning 367 10

+#pragma warning 379 10

+#pragma warning 726 10

+#pragma warning 836 10

+#endif

+

+#ifdef BUILD_FOR_SNAP

+

+#include <stdlib.h>

+#include <stdio.h>

+#include <malloc.h>

+

+#elif defined(_WIN32)

+

+#include <stdlib.h>	    /* For _MAX_PATH definition */

+#include <stdio.h>

+#include <malloc.h>

+

+#define WIN32_LEAN_AND_MEAN

+#define NOGDI

+#define NOIME

+#define NOMINMAX

+

+#ifndef _WIN32_WINNT

+  #define _WIN32_WINNT 0x0400

+#endif

+#ifndef STRICT

+  #define STRICT 1

+#endif

+

+#include <windows.h>

+

+/* Disable warnings */

+#if defined(_MSC_VER)

+#pragma warning(disable : 4101)

+#pragma warning(disable : 4244)

+#pragma warning(disable : 4761)

+#endif

+

+#if defined(_MSC_VER) && _MSC_VER >= 1200 && _MSC_VER < 1300

+#pragma comment(linker, "/OPT:NOWIN98")

+#endif

+

+#elif defined(__OS2__)

+

+#include <stdlib.h>

+#include <stdio.h>

+#include <malloc.h>

+#define WINGDIAPI

+

+#else

+

+/* Disable Microsoft-specific keywords */

+#define GLAPIENTRY

+#define WINGDIAPI

+

+#endif

diff --git a/mesalib/src/glu/sgi/libutil/mipmap.c b/mesalib/src/glu/sgi/libutil/mipmap.c
index 026ab849c..a156a963d 100644
--- a/mesalib/src/glu/sgi/libutil/mipmap.c
+++ b/mesalib/src/glu/sgi/libutil/mipmap.c
@@ -1,8940 +1,8940 @@
-/*
- * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
- * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice including the dates of first publication and
- * either this permission notice or a reference to
- * http://oss.sgi.com/projects/FreeB/
- * shall be included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
- * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- *
- * Except as contained in this notice, the name of Silicon Graphics, Inc.
- * shall not be used in advertising or otherwise to promote the sale, use or
- * other dealings in this Software without prior written authorization from
- * Silicon Graphics, Inc.
- */
-
-#include "gluos.h"
-#include <assert.h>
-#include <GL/glu.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <limits.h>		/* UINT_MAX */
-#include <math.h>
-
-typedef union {
-    unsigned char ub[4];
-    unsigned short us[2];
-    unsigned int ui;
-    char b[4];
-    short s[2];
-    int i;
-    float f;
-} Type_Widget;
-
-/* Pixel storage modes */
-typedef struct {
-   GLint pack_alignment;
-   GLint pack_row_length;
-   GLint pack_skip_rows;
-   GLint pack_skip_pixels;
-   GLint pack_lsb_first;
-   GLint pack_swap_bytes;
-   GLint pack_skip_images;
-   GLint pack_image_height;
-
-   GLint unpack_alignment;
-   GLint unpack_row_length;
-   GLint unpack_skip_rows;
-   GLint unpack_skip_pixels;
-   GLint unpack_lsb_first;
-   GLint unpack_swap_bytes;
-   GLint unpack_skip_images;
-   GLint unpack_image_height;
-} PixelStorageModes;
-
-static int gluBuild1DMipmapLevelsCore(GLenum, GLint,
-				      GLsizei,
-				      GLsizei,
-				      GLenum, GLenum, GLint, GLint, GLint,
-				      const void *);
-static int gluBuild2DMipmapLevelsCore(GLenum, GLint,
-				      GLsizei, GLsizei,
-				      GLsizei, GLsizei,
-				      GLenum, GLenum, GLint, GLint, GLint,
-				      const void *);
-static int gluBuild3DMipmapLevelsCore(GLenum, GLint,
-				      GLsizei, GLsizei, GLsizei,
-				      GLsizei, GLsizei, GLsizei,
-				      GLenum, GLenum, GLint, GLint, GLint,
-				      const void *);
-
-/*
- * internal function declarations
- */
-static GLfloat bytes_per_element(GLenum type);
-static GLint elements_per_group(GLenum format, GLenum type);
-static GLint is_index(GLenum format);
-static GLint image_size(GLint width, GLint height, GLenum format, GLenum type);
-static void fill_image(const PixelStorageModes *,
-		       GLint width, GLint height, GLenum format,
-		       GLenum type, GLboolean index_format,
-		       const void *userdata, GLushort *newimage);
-static void empty_image(const PixelStorageModes *,
-			GLint width, GLint height, GLenum format,
-			GLenum type, GLboolean index_format,
-			const GLushort *oldimage, void *userdata);
-static void scale_internal(GLint components, GLint widthin, GLint heightin,
-			   const GLushort *datain,
-			   GLint widthout, GLint heightout,
-			   GLushort *dataout);
-
-static void scale_internal_ubyte(GLint components, GLint widthin,
-			   GLint heightin, const GLubyte *datain,
-			   GLint widthout, GLint heightout,
-			   GLubyte *dataout, GLint element_size,
-			   GLint ysize, GLint group_size);
-static void scale_internal_byte(GLint components, GLint widthin,
-			   GLint heightin, const GLbyte *datain,
-			   GLint widthout, GLint heightout,
-			   GLbyte *dataout, GLint element_size,
-			   GLint ysize, GLint group_size);
-static void scale_internal_ushort(GLint components, GLint widthin,
-			   GLint heightin, const GLushort *datain,
-			   GLint widthout, GLint heightout,
-			   GLushort *dataout, GLint element_size,
-			   GLint ysize, GLint group_size,
-			   GLint myswap_bytes);
-static void scale_internal_short(GLint components, GLint widthin,
-			   GLint heightin, const GLshort *datain,
-			   GLint widthout, GLint heightout,
-			   GLshort *dataout, GLint element_size,
-			   GLint ysize, GLint group_size,
-			   GLint myswap_bytes);
-static void scale_internal_uint(GLint components, GLint widthin,
-			   GLint heightin, const GLuint *datain,
-			   GLint widthout, GLint heightout,
-			   GLuint *dataout, GLint element_size,
-			   GLint ysize, GLint group_size,
-			   GLint myswap_bytes);
-static void scale_internal_int(GLint components, GLint widthin,
-			   GLint heightin, const GLint *datain,
-			   GLint widthout, GLint heightout,
-			   GLint *dataout, GLint element_size,
-			   GLint ysize, GLint group_size,
-			   GLint myswap_bytes);
-static void scale_internal_float(GLint components, GLint widthin,
-			   GLint heightin, const GLfloat *datain,
-			   GLint widthout, GLint heightout,
-			   GLfloat *dataout, GLint element_size,
-			   GLint ysize, GLint group_size,
-			   GLint myswap_bytes);
-
-static int checkMipmapArgs(GLenum, GLenum, GLenum);
-static GLboolean legalFormat(GLenum);
-static GLboolean legalType(GLenum);
-static GLboolean isTypePackedPixel(GLenum);
-static GLboolean isLegalFormatForPackedPixelType(GLenum, GLenum);
-static GLboolean isLegalLevels(GLint, GLint, GLint, GLint);
-static void closestFit(GLenum, GLint, GLint, GLint, GLenum, GLenum,
-		       GLint *, GLint *);
-
-/* all extract/shove routines must return double to handle unsigned ints */
-static GLdouble extractUbyte(int, const void *);
-static void shoveUbyte(GLdouble, int, void *);
-static GLdouble extractSbyte(int, const void *);
-static void shoveSbyte(GLdouble, int, void *);
-static GLdouble extractUshort(int, const void *);
-static void shoveUshort(GLdouble, int, void *);
-static GLdouble extractSshort(int, const void *);
-static void shoveSshort(GLdouble, int, void *);
-static GLdouble extractUint(int, const void *);
-static void shoveUint(GLdouble, int, void *);
-static GLdouble extractSint(int, const void *);
-static void shoveSint(GLdouble, int, void *);
-static GLdouble extractFloat(int, const void *);
-static void shoveFloat(GLdouble, int, void *);
-static void halveImageSlice(int, GLdouble (*)(int, const void *),
-			    void (*)(GLdouble, int, void *),
-			    GLint, GLint, GLint,
-			    const void *, void *,
-			    GLint, GLint, GLint, GLint, GLint);
-static void halveImage3D(int, GLdouble (*)(int, const void *),
-			 void (*)(GLdouble, int, void *),
-			 GLint, GLint, GLint,
-			 const void *, void *,
-			 GLint, GLint, GLint, GLint, GLint);
-
-/* packedpixel type scale routines */
-static void extract332(int,const void *, GLfloat []);
-static void shove332(const GLfloat [],int ,void *);
-static void extract233rev(int,const void *, GLfloat []);
-static void shove233rev(const GLfloat [],int ,void *);
-static void extract565(int,const void *, GLfloat []);
-static void shove565(const GLfloat [],int ,void *);
-static void extract565rev(int,const void *, GLfloat []);
-static void shove565rev(const GLfloat [],int ,void *);
-static void extract4444(int,const void *, GLfloat []);
-static void shove4444(const GLfloat [],int ,void *);
-static void extract4444rev(int,const void *, GLfloat []);
-static void shove4444rev(const GLfloat [],int ,void *);
-static void extract5551(int,const void *, GLfloat []);
-static void shove5551(const GLfloat [],int ,void *);
-static void extract1555rev(int,const void *, GLfloat []);
-static void shove1555rev(const GLfloat [],int ,void *);
-static void extract8888(int,const void *, GLfloat []);
-static void shove8888(const GLfloat [],int ,void *);
-static void extract8888rev(int,const void *, GLfloat []);
-static void shove8888rev(const GLfloat [],int ,void *);
-static void extract1010102(int,const void *, GLfloat []);
-static void shove1010102(const GLfloat [],int ,void *);
-static void extract2101010rev(int,const void *, GLfloat []);
-static void shove2101010rev(const GLfloat [],int ,void *);
-static void scaleInternalPackedPixel(int,
-				     void (*)(int, const void *,GLfloat []),
-				     void (*)(const GLfloat [],int, void *),
-				     GLint,GLint, const void *,
-				     GLint,GLint,void *,GLint,GLint,GLint);
-static void halveImagePackedPixel(int,
-				  void (*)(int, const void *,GLfloat []),
-				  void (*)(const GLfloat [],int, void *),
-				  GLint, GLint, const void *,
-				  void *, GLint, GLint, GLint);
-static void halve1DimagePackedPixel(int,
-				    void (*)(int, const void *,GLfloat []),
-				    void (*)(const GLfloat [],int, void *),
-				    GLint, GLint, const void *,
-				    void *, GLint, GLint, GLint);
-
-static void halve1Dimage_ubyte(GLint, GLuint, GLuint,const GLubyte *,
-			       GLubyte *, GLint, GLint, GLint);
-static void halve1Dimage_byte(GLint, GLuint, GLuint,const GLbyte *, GLbyte *,
-			      GLint, GLint, GLint);
-static void halve1Dimage_ushort(GLint, GLuint, GLuint, const GLushort *,
-				GLushort *, GLint, GLint, GLint, GLint);
-static void halve1Dimage_short(GLint, GLuint, GLuint,const GLshort *, GLshort *,
-			       GLint, GLint, GLint, GLint);
-static void halve1Dimage_uint(GLint, GLuint, GLuint, const GLuint *, GLuint *,
-			      GLint, GLint, GLint, GLint);
-static void halve1Dimage_int(GLint, GLuint, GLuint, const GLint *, GLint *,
-			     GLint, GLint, GLint, GLint);
-static void halve1Dimage_float(GLint, GLuint, GLuint, const GLfloat *, GLfloat *,
-			       GLint, GLint, GLint, GLint);
-
-static GLint imageSize3D(GLint, GLint, GLint, GLenum,GLenum);
-static void fillImage3D(const PixelStorageModes *, GLint, GLint, GLint,GLenum,
-			GLenum, GLboolean, const void *, GLushort *);
-static void emptyImage3D(const PixelStorageModes *,
-			 GLint, GLint, GLint, GLenum,
-			 GLenum, GLboolean,
-			 const GLushort *, void *);
-static void scaleInternal3D(GLint, GLint, GLint, GLint, const GLushort *,
-			    GLint, GLint, GLint, GLushort *);
-
-static void retrieveStoreModes(PixelStorageModes *psm)
-{
-    glGetIntegerv(GL_UNPACK_ALIGNMENT, &psm->unpack_alignment);
-    glGetIntegerv(GL_UNPACK_ROW_LENGTH, &psm->unpack_row_length);
-    glGetIntegerv(GL_UNPACK_SKIP_ROWS, &psm->unpack_skip_rows);
-    glGetIntegerv(GL_UNPACK_SKIP_PIXELS, &psm->unpack_skip_pixels);
-    glGetIntegerv(GL_UNPACK_LSB_FIRST, &psm->unpack_lsb_first);
-    glGetIntegerv(GL_UNPACK_SWAP_BYTES, &psm->unpack_swap_bytes);
-
-    glGetIntegerv(GL_PACK_ALIGNMENT, &psm->pack_alignment);
-    glGetIntegerv(GL_PACK_ROW_LENGTH, &psm->pack_row_length);
-    glGetIntegerv(GL_PACK_SKIP_ROWS, &psm->pack_skip_rows);
-    glGetIntegerv(GL_PACK_SKIP_PIXELS, &psm->pack_skip_pixels);
-    glGetIntegerv(GL_PACK_LSB_FIRST, &psm->pack_lsb_first);
-    glGetIntegerv(GL_PACK_SWAP_BYTES, &psm->pack_swap_bytes);
-}
-
-static void retrieveStoreModes3D(PixelStorageModes *psm)
-{
-    glGetIntegerv(GL_UNPACK_ALIGNMENT, &psm->unpack_alignment);
-    glGetIntegerv(GL_UNPACK_ROW_LENGTH, &psm->unpack_row_length);
-    glGetIntegerv(GL_UNPACK_SKIP_ROWS, &psm->unpack_skip_rows);
-    glGetIntegerv(GL_UNPACK_SKIP_PIXELS, &psm->unpack_skip_pixels);
-    glGetIntegerv(GL_UNPACK_LSB_FIRST, &psm->unpack_lsb_first);
-    glGetIntegerv(GL_UNPACK_SWAP_BYTES, &psm->unpack_swap_bytes);
-    glGetIntegerv(GL_UNPACK_SKIP_IMAGES, &psm->unpack_skip_images);
-    glGetIntegerv(GL_UNPACK_IMAGE_HEIGHT, &psm->unpack_image_height);
-
-    glGetIntegerv(GL_PACK_ALIGNMENT, &psm->pack_alignment);
-    glGetIntegerv(GL_PACK_ROW_LENGTH, &psm->pack_row_length);
-    glGetIntegerv(GL_PACK_SKIP_ROWS, &psm->pack_skip_rows);
-    glGetIntegerv(GL_PACK_SKIP_PIXELS, &psm->pack_skip_pixels);
-    glGetIntegerv(GL_PACK_LSB_FIRST, &psm->pack_lsb_first);
-    glGetIntegerv(GL_PACK_SWAP_BYTES, &psm->pack_swap_bytes);
-    glGetIntegerv(GL_PACK_SKIP_IMAGES, &psm->pack_skip_images);
-    glGetIntegerv(GL_PACK_IMAGE_HEIGHT, &psm->pack_image_height);
-}
-
-static int computeLog(GLuint value)
-{
-    int i;
-
-    i = 0;
-
-    /* Error! */
-    if (value == 0) return -1;
-
-    for (;;) {
-	if (value & 1) {
-	    /* Error ! */
-	    if (value != 1) return -1;
-	    return i;
-	}
-	value = value >> 1;
-	i++;
-    }
-}
-
-/*
-** Compute the nearest power of 2 number.  This algorithm is a little
-** strange, but it works quite well.
-*/
-static int nearestPower(GLuint value)
-{
-    int i;
-
-    i = 1;
-
-    /* Error! */
-    if (value == 0) return -1;
-
-    for (;;) {
-	if (value == 1) {
-	    return i;
-	} else if (value == 3) {
-	    return i*4;
-	}
-	value = value >> 1;
-	i *= 2;
-    }
-}
-
-#define __GLU_SWAP_2_BYTES(s)\
-(GLushort)(((GLushort)((const GLubyte*)(s))[1])<<8 | ((const GLubyte*)(s))[0])
-
-#define __GLU_SWAP_4_BYTES(s)\
-(GLuint)(((GLuint)((const GLubyte*)(s))[3])<<24 | \
-        ((GLuint)((const GLubyte*)(s))[2])<<16 | \
-        ((GLuint)((const GLubyte*)(s))[1])<<8  | ((const GLubyte*)(s))[0])
-
-static void halveImage(GLint components, GLuint width, GLuint height,
-		       const GLushort *datain, GLushort *dataout)
-{
-    int i, j, k;
-    int newwidth, newheight;
-    int delta;
-    GLushort *s;
-    const GLushort *t;
-
-    newwidth = width / 2;
-    newheight = height / 2;
-    delta = width * components;
-    s = dataout;
-    t = datain;
-
-    /* Piece o' cake! */
-    for (i = 0; i < newheight; i++) {
-	for (j = 0; j < newwidth; j++) {
-	    for (k = 0; k < components; k++) {
-		s[0] = (t[0] + t[components] + t[delta] +
-			t[delta+components] + 2) / 4;
-		s++; t++;
-	    }
-	    t += components;
-	}
-	t += delta;
-    }
-}
-
-static void halveImage_ubyte(GLint components, GLuint width, GLuint height,
-			const GLubyte *datain, GLubyte *dataout,
-			GLint element_size, GLint ysize, GLint group_size)
-{
-    int i, j, k;
-    int newwidth, newheight;
-    int padBytes;
-    GLubyte *s;
-    const char *t;
-
-    /* handle case where there is only 1 column/row */
-    if (width == 1 || height == 1) {
-       assert( !(width == 1 && height == 1) ); /* can't be 1x1 */
-       halve1Dimage_ubyte(components,width,height,datain,dataout,
-			  element_size,ysize,group_size);
-       return;
-    }
-
-    newwidth = width / 2;
-    newheight = height / 2;
-    padBytes = ysize - (width*group_size);
-    s = dataout;
-    t = (const char *)datain;
-
-    /* Piece o' cake! */
-    for (i = 0; i < newheight; i++) {
-	for (j = 0; j < newwidth; j++) {
-	    for (k = 0; k < components; k++) {
-		s[0] = (*(const GLubyte*)t +
-			*(const GLubyte*)(t+group_size) +
-			*(const GLubyte*)(t+ysize) +
-			*(const GLubyte*)(t+ysize+group_size) + 2) / 4;
-		s++; t += element_size;
-	    }
-	    t += group_size;
-	}
-	t += padBytes;
-	t += ysize;
-    }
-}
-
-/* */
-static void halve1Dimage_ubyte(GLint components, GLuint width, GLuint height,
-			       const GLubyte *dataIn, GLubyte *dataOut,
-			       GLint element_size, GLint ysize,
-			       GLint group_size)
-{
-   GLint halfWidth= width / 2;
-   GLint halfHeight= height / 2;
-   const char *src= (const char *) dataIn;
-   GLubyte *dest= dataOut;
-   int jj;
-
-   assert(width == 1 || height == 1); /* must be 1D */
-   assert(width != height);	/* can't be square */
-
-   if (height == 1) {		/* 1 row */
-      assert(width != 1);	/* widthxheight can't be 1x1 */
-      halfHeight= 1;
-
-      for (jj= 0; jj< halfWidth; jj++) {
-	 int kk;
-	 for (kk= 0; kk< components; kk++) {
-	    *dest= (*(const GLubyte*)src +
-		 *(const GLubyte*)(src+group_size)) / 2;
-
-	    src+= element_size;
-	    dest++;
-	 }
-	 src+= group_size;	/* skip to next 2 */
-      }
-      {
-	 int padBytes= ysize - (width*group_size);
-	 src+= padBytes;	/* for assertion only */
-      }
-   }
-   else if (width == 1) {	/* 1 column */
-      int padBytes= ysize - (width * group_size);
-      assert(height != 1);	/* widthxheight can't be 1x1 */
-      halfWidth= 1;
-      /* one vertical column with possible pad bytes per row */
-      /* average two at a time */
-
-      for (jj= 0; jj< halfHeight; jj++) {
-	 int kk;
-	 for (kk= 0; kk< components; kk++) {
-	    *dest= (*(const GLubyte*)src + *(const GLubyte*)(src+ysize)) / 2;
-
-	    src+= element_size;
-	    dest++;
-	 }
-	 src+= padBytes; /* add pad bytes, if any, to get to end to row */
-	 src+= ysize;
-      }
-   }
-
-   assert(src == &((const char *)dataIn)[ysize*height]);
-   assert((char *)dest == &((char *)dataOut)
-	  [components * element_size * halfWidth * halfHeight]);
-} /* halve1Dimage_ubyte() */
-
-static void halveImage_byte(GLint components, GLuint width, GLuint height,
-			const GLbyte *datain, GLbyte *dataout,
-			GLint element_size,
-			GLint ysize, GLint group_size)
-{
-    int i, j, k;
-    int newwidth, newheight;
-    int padBytes;
-    GLbyte *s;
-    const char *t;
-
-    /* handle case where there is only 1 column/row */
-    if (width == 1 || height == 1) {
-       assert( !(width == 1 && height == 1) ); /* can't be 1x1 */
-       halve1Dimage_byte(components,width,height,datain,dataout,
-			 element_size,ysize,group_size);
-       return;
-    }
-
-    newwidth = width / 2;
-    newheight = height / 2;
-    padBytes = ysize - (width*group_size);
-    s = dataout;
-    t = (const char *)datain;
-
-    /* Piece o' cake! */
-    for (i = 0; i < newheight; i++) {
-	for (j = 0; j < newwidth; j++) {
-	    for (k = 0; k < components; k++) {
-		s[0] = (*(const GLbyte*)t +
-			*(const GLbyte*)(t+group_size) +
-			*(const GLbyte*)(t+ysize) +
-			*(const GLbyte*)(t+ysize+group_size) + 2) / 4;
-		s++; t += element_size;
-	    }
-	    t += group_size;
-	}
-	t += padBytes;
-	t += ysize;
-    }
-}
-
-static void halve1Dimage_byte(GLint components, GLuint width, GLuint height,
-			      const GLbyte *dataIn, GLbyte *dataOut,
-			      GLint element_size,GLint ysize, GLint group_size)
-{
-   GLint halfWidth= width / 2;
-   GLint halfHeight= height / 2;
-   const char *src= (const char *) dataIn;
-   GLbyte *dest= dataOut;
-   int jj;
-
-   assert(width == 1 || height == 1); /* must be 1D */
-   assert(width != height);	/* can't be square */
-
-   if (height == 1) {		/* 1 row */
-      assert(width != 1);	/* widthxheight can't be 1x1 */
-      halfHeight= 1;
-
-      for (jj= 0; jj< halfWidth; jj++) {
-	 int kk;
-	 for (kk= 0; kk< components; kk++) {
-	    *dest= (*(const GLbyte*)src + *(const GLbyte*)(src+group_size)) / 2;
-
-	    src+= element_size;
-	    dest++;
-	 }
-	 src+= group_size;	/* skip to next 2 */
-      }
-      {
-	 int padBytes= ysize - (width*group_size);
-	 src+= padBytes;	/* for assertion only */
-      }
-   }
-   else if (width == 1) {	/* 1 column */
-      int padBytes= ysize - (width * group_size);
-      assert(height != 1);	/* widthxheight can't be 1x1 */
-      halfWidth= 1;
-      /* one vertical column with possible pad bytes per row */
-      /* average two at a time */
-
-      for (jj= 0; jj< halfHeight; jj++) {
-	 int kk;
-	 for (kk= 0; kk< components; kk++) {
-	    *dest= (*(const GLbyte*)src + *(const GLbyte*)(src+ysize)) / 2;
-
-	    src+= element_size;
-	    dest++;
-	 }
-	 src+= padBytes; /* add pad bytes, if any, to get to end to row */
-	 src+= ysize;
-      }
-
-      assert(src == &((const char *)dataIn)[ysize*height]);
-   }
-
-   assert((char *)dest == &((char *)dataOut)
-	  [components * element_size * halfWidth * halfHeight]);
-} /* halve1Dimage_byte() */
-
-static void halveImage_ushort(GLint components, GLuint width, GLuint height,
-			const GLushort *datain, GLushort *dataout,
-			GLint element_size, GLint ysize, GLint group_size,
-			GLint myswap_bytes)
-{
-    int i, j, k;
-    int newwidth, newheight;
-    int padBytes;
-    GLushort *s;
-    const char *t;
-
-    /* handle case where there is only 1 column/row */
-    if (width == 1 || height == 1) {
-       assert( !(width == 1 && height == 1) ); /* can't be 1x1 */
-       halve1Dimage_ushort(components,width,height,datain,dataout,
-			   element_size,ysize,group_size, myswap_bytes);
-       return;
-    }
-
-    newwidth = width / 2;
-    newheight = height / 2;
-    padBytes = ysize - (width*group_size);
-    s = dataout;
-    t = (const char *)datain;
-
-    /* Piece o' cake! */
-    if (!myswap_bytes)
-    for (i = 0; i < newheight; i++) {
-	for (j = 0; j < newwidth; j++) {
-	    for (k = 0; k < components; k++) {
-		s[0] = (*(const GLushort*)t +
-			*(const GLushort*)(t+group_size) +
-			*(const GLushort*)(t+ysize) +
-			*(const GLushort*)(t+ysize+group_size) + 2) / 4;
-		s++; t += element_size;
-	    }
-	    t += group_size;
-	}
-	t += padBytes;
-	t += ysize;
-    }
-    else
-    for (i = 0; i < newheight; i++) {
-	for (j = 0; j < newwidth; j++) {
-	    for (k = 0; k < components; k++) {
-		s[0] = (__GLU_SWAP_2_BYTES(t) +
-			__GLU_SWAP_2_BYTES(t+group_size) +
-			__GLU_SWAP_2_BYTES(t+ysize) +
-			__GLU_SWAP_2_BYTES(t+ysize+group_size)+ 2)/4;
-		s++; t += element_size;
-	    }
-	    t += group_size;
-	}
-	t += padBytes;
-	t += ysize;
-    }
-}
-
-static void halve1Dimage_ushort(GLint components, GLuint width, GLuint height,
-				const GLushort *dataIn, GLushort *dataOut,
-				GLint element_size, GLint ysize,
-				GLint group_size, GLint myswap_bytes)
-{
-   GLint halfWidth= width / 2;
-   GLint halfHeight= height / 2;
-   const char *src= (const char *) dataIn;
-   GLushort *dest= dataOut;
-   int jj;
-
-   assert(width == 1 || height == 1); /* must be 1D */
-   assert(width != height);	/* can't be square */
-
-   if (height == 1) {		/* 1 row */
-      assert(width != 1);	/* widthxheight can't be 1x1 */
-      halfHeight= 1;
-
-      for (jj= 0; jj< halfWidth; jj++) {
-	 int kk;
-	 for (kk= 0; kk< components; kk++) {
-#define BOX2 2
-	    GLushort ushort[BOX2];
-	    if (myswap_bytes) {
-	       ushort[0]= __GLU_SWAP_2_BYTES(src);
-	       ushort[1]= __GLU_SWAP_2_BYTES(src+group_size);
-	    }
-	    else {
-	       ushort[0]= *(const GLushort*)src;
-	       ushort[1]= *(const GLushort*)(src+group_size);
-	    }
-
-	    *dest= (ushort[0] + ushort[1]) / 2;
-	    src+= element_size;
-	    dest++;
-	 }
-	 src+= group_size;	/* skip to next 2 */
-      }
-      {
-	 int padBytes= ysize - (width*group_size);
-	 src+= padBytes;	/* for assertion only */
-      }
-   }
-   else if (width == 1) {	/* 1 column */
-      int padBytes= ysize - (width * group_size);
-      assert(height != 1);	/* widthxheight can't be 1x1 */
-      halfWidth= 1;
-      /* one vertical column with possible pad bytes per row */
-      /* average two at a time */
-
-      for (jj= 0; jj< halfHeight; jj++) {
-	 int kk;
-	 for (kk= 0; kk< components; kk++) {
-#define BOX2 2
-	    GLushort ushort[BOX2];
-	    if (myswap_bytes) {
-	       ushort[0]= __GLU_SWAP_2_BYTES(src);
-	       ushort[1]= __GLU_SWAP_2_BYTES(src+ysize);
-	    }
-	    else {
-	       ushort[0]= *(const GLushort*)src;
-	       ushort[1]= *(const GLushort*)(src+ysize);
-	    }
-	    *dest= (ushort[0] + ushort[1]) / 2;
-
-	    src+= element_size;
-	    dest++;
-	 }
-	 src+= padBytes; /* add pad bytes, if any, to get to end to row */
-	 src+= ysize;
-      }
-
-      assert(src == &((const char *)dataIn)[ysize*height]);
-   }
-
-   assert((char *)dest == &((char *)dataOut)
-	  [components * element_size * halfWidth * halfHeight]);
-
-} /* halve1Dimage_ushort() */
-
-
-static void halveImage_short(GLint components, GLuint width, GLuint height,
-			const GLshort *datain, GLshort *dataout,
-			GLint element_size, GLint ysize, GLint group_size,
-			GLint myswap_bytes)
-{
-    int i, j, k;
-    int newwidth, newheight;
-    int padBytes;
-    GLshort *s;
-    const char *t;
-
-    /* handle case where there is only 1 column/row */
-    if (width == 1 || height == 1) {
-       assert( !(width == 1 && height == 1) ); /* can't be 1x1 */
-       halve1Dimage_short(components,width,height,datain,dataout,
-			  element_size,ysize,group_size, myswap_bytes);
-       return;
-    }
-
-    newwidth = width / 2;
-    newheight = height / 2;
-    padBytes = ysize - (width*group_size);
-    s = dataout;
-    t = (const char *)datain;
-
-    /* Piece o' cake! */
-    if (!myswap_bytes)
-    for (i = 0; i < newheight; i++) {
-	for (j = 0; j < newwidth; j++) {
-	    for (k = 0; k < components; k++) {
-		s[0] = (*(const GLshort*)t +
-			*(const GLshort*)(t+group_size) +
-			*(const GLshort*)(t+ysize) +
-			*(const GLshort*)(t+ysize+group_size) + 2) / 4;
-		s++; t += element_size;
-	    }
-	    t += group_size;
-	}
-	t += padBytes;
-	t += ysize;
-    }
-    else
-    for (i = 0; i < newheight; i++) {
-	for (j = 0; j < newwidth; j++) {
-	    for (k = 0; k < components; k++) {
-		GLushort b;
-		GLint buf;
-		b = __GLU_SWAP_2_BYTES(t);
-		buf = *(const GLshort*)&b;
-		b = __GLU_SWAP_2_BYTES(t+group_size);
-		buf += *(const GLshort*)&b;
-		b = __GLU_SWAP_2_BYTES(t+ysize);
-		buf += *(const GLshort*)&b;
-		b = __GLU_SWAP_2_BYTES(t+ysize+group_size);
-		buf += *(const GLshort*)&b;
-		s[0] = (GLshort)((buf+2)/4);
-		s++; t += element_size;
-	    }
-	    t += group_size;
-	}
-	t += padBytes;
-	t += ysize;
-    }
-}
-
-static void halve1Dimage_short(GLint components, GLuint width, GLuint height,
-				const GLshort *dataIn, GLshort *dataOut,
-				GLint element_size, GLint ysize,
-				GLint group_size, GLint myswap_bytes)
-{
-   GLint halfWidth= width / 2;
-   GLint halfHeight= height / 2;
-   const char *src= (const char *) dataIn;
-   GLshort *dest= dataOut;
-   int jj;
-
-   assert(width == 1 || height == 1); /* must be 1D */
-   assert(width != height);	/* can't be square */
-
-   if (height == 1) {		/* 1 row */
-      assert(width != 1);	/* widthxheight can't be 1x1 */
-      halfHeight= 1;
-
-      for (jj= 0; jj< halfWidth; jj++) {
-	 int kk;
-	 for (kk= 0; kk< components; kk++) {
-#define BOX2 2
-	    GLshort sshort[BOX2];
-	    if (myswap_bytes) {
-	       sshort[0]= __GLU_SWAP_2_BYTES(src);
-	       sshort[1]= __GLU_SWAP_2_BYTES(src+group_size);
-	    }
-	    else {
-	       sshort[0]= *(const GLshort*)src;
-	       sshort[1]= *(const GLshort*)(src+group_size);
-	    }
-
-	    *dest= (sshort[0] + sshort[1]) / 2;
-	    src+= element_size;
-	    dest++;
-	 }
-	 src+= group_size;	/* skip to next 2 */
-      }
-      {
-	 int padBytes= ysize - (width*group_size);
-	 src+= padBytes;	/* for assertion only */
-      }
-   }
-   else if (width == 1) {	/* 1 column */
-      int padBytes= ysize - (width * group_size);
-      assert(height != 1);	/* widthxheight can't be 1x1 */
-      halfWidth= 1;
-      /* one vertical column with possible pad bytes per row */
-      /* average two at a time */
-
-      for (jj= 0; jj< halfHeight; jj++) {
-	 int kk;
-	 for (kk= 0; kk< components; kk++) {
-#define BOX2 2
-	    GLshort sshort[BOX2];
-	    if (myswap_bytes) {
-	       sshort[0]= __GLU_SWAP_2_BYTES(src);
-	       sshort[1]= __GLU_SWAP_2_BYTES(src+ysize);
-	    }
-	    else {
-	       sshort[0]= *(const GLshort*)src;
-	       sshort[1]= *(const GLshort*)(src+ysize);
-	    }
-	    *dest= (sshort[0] + sshort[1]) / 2;
-
-	    src+= element_size;
-	    dest++;
-	 }
-	 src+= padBytes; /* add pad bytes, if any, to get to end to row */
-	 src+= ysize;
-      }
-
-      assert(src == &((const char *)dataIn)[ysize*height]);
-   }
-
-   assert((char *)dest == &((char *)dataOut)
-	  [components * element_size * halfWidth * halfHeight]);
-
-} /* halve1Dimage_short() */
-
-
-static void halveImage_uint(GLint components, GLuint width, GLuint height,
-			const GLuint *datain, GLuint *dataout,
-			GLint element_size, GLint ysize, GLint group_size,
-			GLint myswap_bytes)
-{
-    int i, j, k;
-    int newwidth, newheight;
-    int padBytes;
-    GLuint *s;
-    const char *t;
-
-    /* handle case where there is only 1 column/row */
-    if (width == 1 || height == 1) {
-       assert( !(width == 1 && height == 1) ); /* can't be 1x1 */
-       halve1Dimage_uint(components,width,height,datain,dataout,
-			 element_size,ysize,group_size, myswap_bytes);
-       return;
-    }
-
-    newwidth = width / 2;
-    newheight = height / 2;
-    padBytes = ysize - (width*group_size);
-    s = dataout;
-    t = (const char *)datain;
-
-    /* Piece o' cake! */
-    if (!myswap_bytes)
-    for (i = 0; i < newheight; i++) {
-	for (j = 0; j < newwidth; j++) {
-	    for (k = 0; k < components; k++) {
-		/* need to cast to double to hold large unsigned ints */
-		s[0] = ((double)*(const GLuint*)t +
-			(double)*(const GLuint*)(t+group_size) +
-			(double)*(const GLuint*)(t+ysize) +
-			(double)*(const GLuint*)(t+ysize+group_size))/4 + 0.5;
-		s++; t += element_size;
-
-	    }
-	    t += group_size;
-	}
-	t += padBytes;
-	t += ysize;
-    }
-    else
-    for (i = 0; i < newheight; i++) {
-	for (j = 0; j < newwidth; j++) {
-	    for (k = 0; k < components; k++) {
-		/* need to cast to double to hold large unsigned ints */
-		GLdouble buf;
-		buf = (GLdouble)__GLU_SWAP_4_BYTES(t) +
-		      (GLdouble)__GLU_SWAP_4_BYTES(t+group_size) +
-		      (GLdouble)__GLU_SWAP_4_BYTES(t+ysize) +
-		      (GLdouble)__GLU_SWAP_4_BYTES(t+ysize+group_size);
-		s[0] = (GLuint)(buf/4 + 0.5);
-
-		s++; t += element_size;
-	    }
-	    t += group_size;
-	}
-	t += padBytes;
-	t += ysize;
-    }
-}
-
-/* */
-static void halve1Dimage_uint(GLint components, GLuint width, GLuint height,
-			      const GLuint *dataIn, GLuint *dataOut,
-			      GLint element_size, GLint ysize,
-			      GLint group_size, GLint myswap_bytes)
-{
-   GLint halfWidth= width / 2;
-   GLint halfHeight= height / 2;
-   const char *src= (const char *) dataIn;
-   GLuint *dest= dataOut;
-   int jj;
-
-   assert(width == 1 || height == 1); /* must be 1D */
-   assert(width != height);	/* can't be square */
-
-   if (height == 1) {		/* 1 row */
-      assert(width != 1);	/* widthxheight can't be 1x1 */
-      halfHeight= 1;
-
-      for (jj= 0; jj< halfWidth; jj++) {
-	 int kk;
-	 for (kk= 0; kk< components; kk++) {
-#define BOX2 2
-	    GLuint uint[BOX2];
-	    if (myswap_bytes) {
-	       uint[0]= __GLU_SWAP_4_BYTES(src);
-	       uint[1]= __GLU_SWAP_4_BYTES(src+group_size);
-	    }
-	    else {
-	       uint[0]= *(const GLuint*)src;
-	       uint[1]= *(const GLuint*)(src+group_size);
-	    }
-	    *dest= ((double)uint[0]+(double)uint[1])/2.0;
-
-	    src+= element_size;
-	    dest++;
-	 }
-	 src+= group_size;	/* skip to next 2 */
-      }
-      {
-	 int padBytes= ysize - (width*group_size);
-	 src+= padBytes;	/* for assertion only */
-      }
-   }
-   else if (width == 1) {	/* 1 column */
-      int padBytes= ysize - (width * group_size);
-      assert(height != 1);	/* widthxheight can't be 1x1 */
-      halfWidth= 1;
-      /* one vertical column with possible pad bytes per row */
-      /* average two at a time */
-
-      for (jj= 0; jj< halfHeight; jj++) {
-	 int kk;
-	 for (kk= 0; kk< components; kk++) {
-#define BOX2 2
-	    GLuint uint[BOX2];
-	    if (myswap_bytes) {
-	       uint[0]= __GLU_SWAP_4_BYTES(src);
-	       uint[1]= __GLU_SWAP_4_BYTES(src+ysize);
-	    }
-	    else {
-	       uint[0]= *(const GLuint*)src;
-	       uint[1]= *(const GLuint*)(src+ysize);
-	    }
-	    *dest= ((double)uint[0]+(double)uint[1])/2.0;
-
-	    src+= element_size;
-	    dest++;
-	 }
-	 src+= padBytes; /* add pad bytes, if any, to get to end to row */
-	 src+= ysize;
-      }
-
-      assert(src == &((const char *)dataIn)[ysize*height]);
-   }
-
-   assert((char *)dest == &((char *)dataOut)
-	  [components * element_size * halfWidth * halfHeight]);
-
-} /* halve1Dimage_uint() */
-
-static void halveImage_int(GLint components, GLuint width, GLuint height,
-			const GLint *datain, GLint *dataout, GLint element_size,
-			GLint ysize, GLint group_size, GLint myswap_bytes)
-{
-    int i, j, k;
-    int newwidth, newheight;
-    int padBytes;
-    GLint *s;
-    const char *t;
-
-    /* handle case where there is only 1 column/row */
-    if (width == 1 || height == 1) {
-       assert( !(width == 1 && height == 1) ); /* can't be 1x1 */
-       halve1Dimage_int(components,width,height,datain,dataout,
-			element_size,ysize,group_size, myswap_bytes);
-       return;
-    }
-
-    newwidth = width / 2;
-    newheight = height / 2;
-    padBytes = ysize - (width*group_size);
-    s = dataout;
-    t = (const char *)datain;
-
-    /* Piece o' cake! */
-    if (!myswap_bytes)
-    for (i = 0; i < newheight; i++) {
-	for (j = 0; j < newwidth; j++) {
-	    for (k = 0; k < components; k++) {
-		s[0] = ((float)*(const GLint*)t +
-			(float)*(const GLint*)(t+group_size) +
-			(float)*(const GLint*)(t+ysize) +
-			(float)*(const GLint*)(t+ysize+group_size))/4 + 0.5;
-		s++; t += element_size;
-	    }
-	    t += group_size;
-	}
-	t += padBytes;
-	t += ysize;
-    }
-    else
-    for (i = 0; i < newheight; i++) {
-	for (j = 0; j < newwidth; j++) {
-	    for (k = 0; k < components; k++) {
-		GLuint b;
-		GLfloat buf;
-		b = __GLU_SWAP_4_BYTES(t);
-		buf = *(GLint*)&b;
-		b = __GLU_SWAP_4_BYTES(t+group_size);
-		buf += *(GLint*)&b;
-		b = __GLU_SWAP_4_BYTES(t+ysize);
-		buf += *(GLint*)&b;
-		b = __GLU_SWAP_4_BYTES(t+ysize+group_size);
-		buf += *(GLint*)&b;
-		s[0] = (GLint)(buf/4 + 0.5);
-
-		s++; t += element_size;
-	    }
-	    t += group_size;
-	}
-	t += padBytes;
-	t += ysize;
-    }
-}
-
-/* */
-static void halve1Dimage_int(GLint components, GLuint width, GLuint height,
-			     const GLint *dataIn, GLint *dataOut,
-			     GLint element_size, GLint ysize,
-			     GLint group_size, GLint myswap_bytes)
-{
-   GLint halfWidth= width / 2;
-   GLint halfHeight= height / 2;
-   const char *src= (const char *) dataIn;
-   GLint *dest= dataOut;
-   int jj;
-
-   assert(width == 1 || height == 1); /* must be 1D */
-   assert(width != height);	/* can't be square */
-
-   if (height == 1) {		/* 1 row */
-      assert(width != 1);	/* widthxheight can't be 1x1 */
-      halfHeight= 1;
-
-      for (jj= 0; jj< halfWidth; jj++) {
-	 int kk;
-	 for (kk= 0; kk< components; kk++) {
-#define BOX2 2
-	    GLuint uint[BOX2];
-	    if (myswap_bytes) {
-	       uint[0]= __GLU_SWAP_4_BYTES(src);
-	       uint[1]= __GLU_SWAP_4_BYTES(src+group_size);
-	    }
-	    else {
-	       uint[0]= *(const GLuint*)src;
-	       uint[1]= *(const GLuint*)(src+group_size);
-	    }
-	    *dest= ((float)uint[0]+(float)uint[1])/2.0;
-
-	    src+= element_size;
-	    dest++;
-	 }
-	 src+= group_size;	/* skip to next 2 */
-      }
-      {
-	 int padBytes= ysize - (width*group_size);
-	 src+= padBytes;	/* for assertion only */
-      }
-   }
-   else if (width == 1) {	/* 1 column */
-      int padBytes= ysize - (width * group_size);
-      assert(height != 1);	/* widthxheight can't be 1x1 */
-      halfWidth= 1;
-      /* one vertical column with possible pad bytes per row */
-      /* average two at a time */
-
-      for (jj= 0; jj< halfHeight; jj++) {
-	 int kk;
-	 for (kk= 0; kk< components; kk++) {
-#define BOX2 2
-	    GLuint uint[BOX2];
-	    if (myswap_bytes) {
-	       uint[0]= __GLU_SWAP_4_BYTES(src);
-	       uint[1]= __GLU_SWAP_4_BYTES(src+ysize);
-	    }
-	    else {
-	       uint[0]= *(const GLuint*)src;
-	       uint[1]= *(const GLuint*)(src+ysize);
-	    }
-	    *dest= ((float)uint[0]+(float)uint[1])/2.0;
-
-	    src+= element_size;
-	    dest++;
-	 }
-	 src+= padBytes; /* add pad bytes, if any, to get to end to row */
-	 src+= ysize;
-      }
-
-      assert(src == &((const char *)dataIn)[ysize*height]);
-   }
-
-   assert((char *)dest == &((char *)dataOut)
-	  [components * element_size * halfWidth * halfHeight]);
-
-} /* halve1Dimage_int() */
-
-
-static void halveImage_float(GLint components, GLuint width, GLuint height,
-			const GLfloat *datain, GLfloat *dataout,
-			GLint element_size, GLint ysize, GLint group_size,
-			GLint myswap_bytes)
-{
-    int i, j, k;
-    int newwidth, newheight;
-    int padBytes;
-    GLfloat *s;
-    const char *t;
-
-    /* handle case where there is only 1 column/row */
-    if (width == 1 || height == 1) {
-       assert( !(width == 1 && height == 1) ); /* can't be 1x1 */
-       halve1Dimage_float(components,width,height,datain,dataout,
-			  element_size,ysize,group_size, myswap_bytes);
-       return;
-    }
-
-    newwidth = width / 2;
-    newheight = height / 2;
-    padBytes = ysize - (width*group_size);
-    s = dataout;
-    t = (const char *)datain;
-
-    /* Piece o' cake! */
-    if (!myswap_bytes)
-    for (i = 0; i < newheight; i++) {
-	for (j = 0; j < newwidth; j++) {
-	    for (k = 0; k < components; k++) {
-		s[0] = (*(const GLfloat*)t +
-			*(const GLfloat*)(t+group_size) +
-			*(const GLfloat*)(t+ysize) +
-			*(const GLfloat*)(t+ysize+group_size)) / 4;
-		s++; t += element_size;
-	    }
-	    t += group_size;
-	}
-	t += padBytes;
-	t += ysize;
-    }
-    else
-    for (i = 0; i < newheight; i++) {
-	for (j = 0; j < newwidth; j++) {
-	    for (k = 0; k < components; k++) {
-		union { GLuint b; GLfloat f; } swapbuf;
-		swapbuf.b = __GLU_SWAP_4_BYTES(t);
-		s[0] = swapbuf.f;
-		swapbuf.b = __GLU_SWAP_4_BYTES(t+group_size);
-		s[0] += swapbuf.f;
-		swapbuf.b = __GLU_SWAP_4_BYTES(t+ysize);
-		s[0] += swapbuf.f;
-		swapbuf.b = __GLU_SWAP_4_BYTES(t+ysize+group_size);
-		s[0] += swapbuf.f;
-		s[0] /= 4;
-		s++; t += element_size;
-	    }
-	    t += group_size;
-	}
-	t += padBytes;
-	t += ysize;
-    }
-}
-
-/* */
-static void halve1Dimage_float(GLint components, GLuint width, GLuint height,
-			       const GLfloat *dataIn, GLfloat *dataOut,
-			       GLint element_size, GLint ysize,
-			       GLint group_size, GLint myswap_bytes)
-{
-   GLint halfWidth= width / 2;
-   GLint halfHeight= height / 2;
-   const char *src= (const char *) dataIn;
-   GLfloat *dest= dataOut;
-   int jj;
-
-   assert(width == 1 || height == 1); /* must be 1D */
-   assert(width != height);	/* can't be square */
-
-   if (height == 1) {		/* 1 row */
-      assert(width != 1);	/* widthxheight can't be 1x1 */
-      halfHeight= 1;
-
-      for (jj= 0; jj< halfWidth; jj++) {
-	 int kk;
-	 for (kk= 0; kk< components; kk++) {
-#define BOX2 2
-	    GLfloat sfloat[BOX2];
-	    if (myswap_bytes) {
-	       sfloat[0]= __GLU_SWAP_4_BYTES(src);
-	       sfloat[1]= __GLU_SWAP_4_BYTES(src+group_size);
-	    }
-	    else {
-	       sfloat[0]= *(const GLfloat*)src;
-	       sfloat[1]= *(const GLfloat*)(src+group_size);
-	    }
-
-	    *dest= (sfloat[0] + sfloat[1]) / 2.0;
-	    src+= element_size;
-	    dest++;
-	 }
-	 src+= group_size;	/* skip to next 2 */
-      }
-      {
-	 int padBytes= ysize - (width*group_size);
-	 src+= padBytes;	/* for assertion only */
-      }
-   }
-   else if (width == 1) {	/* 1 column */
-      int padBytes= ysize - (width * group_size);
-      assert(height != 1);	/* widthxheight can't be 1x1 */
-      halfWidth= 1;
-      /* one vertical column with possible pad bytes per row */
-      /* average two at a time */
-
-      for (jj= 0; jj< halfHeight; jj++) {
-	 int kk;
-	 for (kk= 0; kk< components; kk++) {
-#define BOX2 2
-	    GLfloat sfloat[BOX2];
-	    if (myswap_bytes) {
-	       sfloat[0]= __GLU_SWAP_4_BYTES(src);
-	       sfloat[1]= __GLU_SWAP_4_BYTES(src+ysize);
-	    }
-	    else {
-	       sfloat[0]= *(const GLfloat*)src;
-	       sfloat[1]= *(const GLfloat*)(src+ysize);
-	    }
-	    *dest= (sfloat[0] + sfloat[1]) / 2.0;
-
-	    src+= element_size;
-	    dest++;
-	 }
-	 src+= padBytes; /* add pad bytes, if any, to get to end to row */
-	 src+= ysize;		/* skip to odd row */
-      }
-   }
-
-   assert(src == &((const char *)dataIn)[ysize*height]);
-   assert((char *)dest == &((char *)dataOut)
-	  [components * element_size * halfWidth * halfHeight]);
-} /* halve1Dimage_float() */
-
-static void scale_internal(GLint components, GLint widthin, GLint heightin,
-			   const GLushort *datain,
-			   GLint widthout, GLint heightout,
-			   GLushort *dataout)
-{
-    float x, lowx, highx, convx, halfconvx;
-    float y, lowy, highy, convy, halfconvy;
-    float xpercent,ypercent;
-    float percent;
-    /* Max components in a format is 4, so... */
-    float totals[4];
-    float area;
-    int i,j,k,yint,xint,xindex,yindex;
-    int temp;
-
-    if (widthin == widthout*2 && heightin == heightout*2) {
-	halveImage(components, widthin, heightin, datain, dataout);
-	return;
-    }
-    convy = (float) heightin/heightout;
-    convx = (float) widthin/widthout;
-    halfconvx = convx/2;
-    halfconvy = convy/2;
-    for (i = 0; i < heightout; i++) {
-	y = convy * (i+0.5);
-	if (heightin > heightout) {
-	    highy = y + halfconvy;
-	    lowy = y - halfconvy;
-	} else {
-	    highy = y + 0.5;
-	    lowy = y - 0.5;
-	}
-	for (j = 0; j < widthout; j++) {
-	    x = convx * (j+0.5);
-	    if (widthin > widthout) {
-		highx = x + halfconvx;
-		lowx = x - halfconvx;
-	    } else {
-		highx = x + 0.5;
-		lowx = x - 0.5;
-	    }
-
-	    /*
-	    ** Ok, now apply box filter to box that goes from (lowx, lowy)
-	    ** to (highx, highy) on input data into this pixel on output
-	    ** data.
-	    */
-	    totals[0] = totals[1] = totals[2] = totals[3] = 0.0;
-	    area = 0.0;
-
-	    y = lowy;
-	    yint = floor(y);
-	    while (y < highy) {
-		yindex = (yint + heightin) % heightin;
-		if (highy < yint+1) {
-		    ypercent = highy - y;
-		} else {
-		    ypercent = yint+1 - y;
-		}
-
-		x = lowx;
-		xint = floor(x);
-
-		while (x < highx) {
-		    xindex = (xint + widthin) % widthin;
-		    if (highx < xint+1) {
-			xpercent = highx - x;
-		    } else {
-			xpercent = xint+1 - x;
-		    }
-
-		    percent = xpercent * ypercent;
-		    area += percent;
-		    temp = (xindex + (yindex * widthin)) * components;
-		    for (k = 0; k < components; k++) {
-			totals[k] += datain[temp + k] * percent;
-		    }
-
-		    xint++;
-		    x = xint;
-		}
-		yint++;
-		y = yint;
-	    }
-
-	    temp = (j + (i * widthout)) * components;
-	    for (k = 0; k < components; k++) {
-		/* totals[] should be rounded in the case of enlarging an RGB
-		 * ramp when the type is 332 or 4444
-		 */
-		dataout[temp + k] = (totals[k]+0.5)/area;
-	    }
-	}
-    }
-}
-
-static void scale_internal_ubyte(GLint components, GLint widthin,
-			   GLint heightin, const GLubyte *datain,
-			   GLint widthout, GLint heightout,
-			   GLubyte *dataout, GLint element_size,
-			   GLint ysize, GLint group_size)
-{
-    float convx;
-    float convy;
-    float percent;
-    /* Max components in a format is 4, so... */
-    float totals[4];
-    float area;
-    int i,j,k,xindex;
-
-    const char *temp, *temp0;
-    const char *temp_index;
-    int outindex;
-
-    int lowx_int, highx_int, lowy_int, highy_int;
-    float x_percent, y_percent;
-    float lowx_float, highx_float, lowy_float, highy_float;
-    float convy_float, convx_float;
-    int convy_int, convx_int;
-    int l, m;
-    const char *left, *right;
-
-    if (widthin == widthout*2 && heightin == heightout*2) {
-	halveImage_ubyte(components, widthin, heightin,
-	(const GLubyte *)datain, (GLubyte *)dataout,
-	element_size, ysize, group_size);
-	return;
-    }
-    convy = (float) heightin/heightout;
-    convx = (float) widthin/widthout;
-    convy_int = floor(convy);
-    convy_float = convy - convy_int;
-    convx_int = floor(convx);
-    convx_float = convx - convx_int;
-
-    area = convx * convy;
-
-    lowy_int = 0;
-    lowy_float = 0;
-    highy_int = convy_int;
-    highy_float = convy_float;
-
-    for (i = 0; i < heightout; i++) {
-        /* Clamp here to be sure we don't read beyond input buffer. */
-        if (highy_int >= heightin)
-            highy_int = heightin - 1;
-	lowx_int = 0;
-	lowx_float = 0;
-	highx_int = convx_int;
-	highx_float = convx_float;
-
-	for (j = 0; j < widthout; j++) {
-
-	    /*
-	    ** Ok, now apply box filter to box that goes from (lowx, lowy)
-	    ** to (highx, highy) on input data into this pixel on output
-	    ** data.
-	    */
-	    totals[0] = totals[1] = totals[2] = totals[3] = 0.0;
-
-	    /* calculate the value for pixels in the 1st row */
-	    xindex = lowx_int*group_size;
-	    if((highy_int>lowy_int) && (highx_int>lowx_int)) {
-
-		y_percent = 1-lowy_float;
-		temp = (const char *)datain + xindex + lowy_int * ysize;
-		percent = y_percent * (1-lowx_float);
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-			totals[k] += (GLubyte)(*(temp_index)) * percent;
-		}
-		left = temp;
-		for(l = lowx_int+1; l < highx_int; l++) {
-		    temp += group_size;
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			totals[k] += (GLubyte)(*(temp_index)) * y_percent;
-		    }
-		}
-		temp += group_size;
-		right = temp;
-		percent = y_percent * highx_float;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-			totals[k] += (GLubyte)(*(temp_index)) * percent;
-		}
-
-		/* calculate the value for pixels in the last row */
-		y_percent = highy_float;
-		percent = y_percent * (1-lowx_float);
-		temp = (const char *)datain + xindex + highy_int * ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-			totals[k] += (GLubyte)(*(temp_index)) * percent;
-		}
-		for(l = lowx_int+1; l < highx_int; l++) {
-		    temp += group_size;
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			totals[k] += (GLubyte)(*(temp_index)) * y_percent;
-		    }
-		}
-		temp += group_size;
-		percent = y_percent * highx_float;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-			totals[k] += (GLubyte)(*(temp_index)) * percent;
-		}
-
-
-		/* calculate the value for pixels in the 1st and last column */
-		for(m = lowy_int+1; m < highy_int; m++) {
-		    left += ysize;
-		    right += ysize;
-		    for (k = 0; k < components;
-			 k++, left += element_size, right += element_size) {
-			totals[k] += (GLubyte)(*(left))*(1-lowx_float)
-				+(GLubyte)(*(right))*highx_float;
-		    }
-		}
-	    } else if (highy_int > lowy_int) {
-		x_percent = highx_float - lowx_float;
-		percent = (1-lowy_float)*x_percent;
-		temp = (const char *)datain + xindex + lowy_int*ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-			totals[k] += (GLubyte)(*(temp_index)) * percent;
-		}
-		for(m = lowy_int+1; m < highy_int; m++) {
-		    temp += ysize;
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			totals[k] += (GLubyte)(*(temp_index)) * x_percent;
-		    }
-		}
-		percent = x_percent * highy_float;
-		temp += ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-			totals[k] += (GLubyte)(*(temp_index)) * percent;
-		}
-	    } else if (highx_int > lowx_int) {
-		y_percent = highy_float - lowy_float;
-		percent = (1-lowx_float)*y_percent;
-		temp = (const char *)datain + xindex + lowy_int*ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-			totals[k] += (GLubyte)(*(temp_index)) * percent;
-		}
-		for (l = lowx_int+1; l < highx_int; l++) {
-		    temp += group_size;
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			totals[k] += (GLubyte)(*(temp_index)) * y_percent;
-		    }
-		}
-		temp += group_size;
-		percent = y_percent * highx_float;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-			totals[k] += (GLubyte)(*(temp_index)) * percent;
-		}
-	    } else {
-		percent = (highy_float-lowy_float)*(highx_float-lowx_float);
-		temp = (const char *)datain + xindex + lowy_int * ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-			totals[k] += (GLubyte)(*(temp_index)) * percent;
-		}
-	    }
-
-
-
-	    /* this is for the pixels in the body */
-	    temp0 = (const char *)datain + xindex + group_size +
-		 (lowy_int+1)*ysize;
-	    for (m = lowy_int+1; m < highy_int; m++) {
-		temp = temp0;
-		for(l = lowx_int+1; l < highx_int; l++) {
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			totals[k] += (GLubyte)(*(temp_index));
-		    }
-		    temp += group_size;
-		}
-		temp0 += ysize;
-	    }
-
-	    outindex = (j + (i * widthout)) * components;
-	    for (k = 0; k < components; k++) {
-		dataout[outindex + k] = totals[k]/area;
-		/*printf("totals[%d] = %f\n", k, totals[k]);*/
-	    }
-	    lowx_int = highx_int;
-	    lowx_float = highx_float;
-	    highx_int += convx_int;
-	    highx_float += convx_float;
-	    if(highx_float > 1) {
-		highx_float -= 1.0;
-		highx_int++;
-	    }
-	}
-	lowy_int = highy_int;
-	lowy_float = highy_float;
-	highy_int += convy_int;
-	highy_float += convy_float;
-	if(highy_float > 1) {
-	    highy_float -= 1.0;
-	    highy_int++;
-	}
-    }
-}
-
-static void scale_internal_byte(GLint components, GLint widthin,
-			   GLint heightin, const GLbyte *datain,
-			   GLint widthout, GLint heightout,
-			   GLbyte *dataout, GLint element_size,
-			   GLint ysize, GLint group_size)
-{
-    float convx;
-    float convy;
-    float percent;
-    /* Max components in a format is 4, so... */
-    float totals[4];
-    float area;
-    int i,j,k,xindex;
-
-    const char *temp, *temp0;
-    const char *temp_index;
-    int outindex;
-
-    int lowx_int, highx_int, lowy_int, highy_int;
-    float x_percent, y_percent;
-    float lowx_float, highx_float, lowy_float, highy_float;
-    float convy_float, convx_float;
-    int convy_int, convx_int;
-    int l, m;
-    const char *left, *right;
-
-    if (widthin == widthout*2 && heightin == heightout*2) {
-	halveImage_byte(components, widthin, heightin,
-	(const GLbyte *)datain, (GLbyte *)dataout,
-	element_size, ysize, group_size);
-	return;
-    }
-    convy = (float) heightin/heightout;
-    convx = (float) widthin/widthout;
-    convy_int = floor(convy);
-    convy_float = convy - convy_int;
-    convx_int = floor(convx);
-    convx_float = convx - convx_int;
-
-    area = convx * convy;
-
-    lowy_int = 0;
-    lowy_float = 0;
-    highy_int = convy_int;
-    highy_float = convy_float;
-
-    for (i = 0; i < heightout; i++) {
-        /* Clamp here to be sure we don't read beyond input buffer. */
-        if (highy_int >= heightin)
-            highy_int = heightin - 1;
-	lowx_int = 0;
-	lowx_float = 0;
-	highx_int = convx_int;
-	highx_float = convx_float;
-
-	for (j = 0; j < widthout; j++) {
-
-	    /*
-	    ** Ok, now apply box filter to box that goes from (lowx, lowy)
-	    ** to (highx, highy) on input data into this pixel on output
-	    ** data.
-	    */
-	    totals[0] = totals[1] = totals[2] = totals[3] = 0.0;
-
-	    /* calculate the value for pixels in the 1st row */
-	    xindex = lowx_int*group_size;
-	    if((highy_int>lowy_int) && (highx_int>lowx_int)) {
-
-		y_percent = 1-lowy_float;
-		temp = (const char *)datain + xindex + lowy_int * ysize;
-		percent = y_percent * (1-lowx_float);
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-			totals[k] += (GLbyte)(*(temp_index)) * percent;
-		}
-		left = temp;
-		for(l = lowx_int+1; l < highx_int; l++) {
-		    temp += group_size;
-		    for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-			totals[k] += (GLbyte)(*(temp_index)) * y_percent;
-		    }
-		}
-		temp += group_size;
-		right = temp;
-		percent = y_percent * highx_float;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-			totals[k] += (GLbyte)(*(temp_index)) * percent;
-		}
-
-		/* calculate the value for pixels in the last row */	        
-		y_percent = highy_float;
-		percent = y_percent * (1-lowx_float);
-		temp = (const char *)datain + xindex + highy_int * ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-			totals[k] += (GLbyte)(*(temp_index)) * percent;
-		}
-		for(l = lowx_int+1; l < highx_int; l++) {
-		    temp += group_size;
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			totals[k] += (GLbyte)(*(temp_index)) * y_percent;
-		    }
-		}
-		temp += group_size;
-		percent = y_percent * highx_float;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-			totals[k] += (GLbyte)(*(temp_index)) * percent;
-		}
-
-
-		/* calculate the value for pixels in the 1st and last column */
-		for(m = lowy_int+1; m < highy_int; m++) {
-		    left += ysize;
-		    right += ysize;
-		    for (k = 0; k < components;
-			 k++, left += element_size, right += element_size) {
-			totals[k] += (GLbyte)(*(left))*(1-lowx_float)
-				+(GLbyte)(*(right))*highx_float;
-		    }
-		}
-	    } else if (highy_int > lowy_int) {
-		x_percent = highx_float - lowx_float;
-		percent = (1-lowy_float)*x_percent;
-		temp = (const char *)datain + xindex + lowy_int*ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-			totals[k] += (GLbyte)(*(temp_index)) * percent;
-		}
-		for(m = lowy_int+1; m < highy_int; m++) {
-		    temp += ysize;
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			totals[k] += (GLbyte)(*(temp_index)) * x_percent;
-		    }
-		}
-		percent = x_percent * highy_float;
-		temp += ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-			totals[k] += (GLbyte)(*(temp_index)) * percent;
-		}
-	    } else if (highx_int > lowx_int) {
-		y_percent = highy_float - lowy_float;
-		percent = (1-lowx_float)*y_percent;
-		temp = (const char *)datain + xindex + lowy_int*ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-			totals[k] += (GLbyte)(*(temp_index)) * percent;
-		}
-		for (l = lowx_int+1; l < highx_int; l++) {
-		    temp += group_size;
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			totals[k] += (GLbyte)(*(temp_index)) * y_percent;
-		    }
-		}
-		temp += group_size;
-		percent = y_percent * highx_float;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-			totals[k] += (GLbyte)(*(temp_index)) * percent;
-		}
-	    } else {
-		percent = (highy_float-lowy_float)*(highx_float-lowx_float);
-		temp = (const char *)datain + xindex + lowy_int * ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-			totals[k] += (GLbyte)(*(temp_index)) * percent;
-		}
-	    }
-
-
-
-	    /* this is for the pixels in the body */
-	    temp0 = (const char *)datain + xindex + group_size +
-		(lowy_int+1)*ysize;
-	    for (m = lowy_int+1; m < highy_int; m++) {
-		temp = temp0;
-		for(l = lowx_int+1; l < highx_int; l++) {
-		    for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-			totals[k] += (GLbyte)(*(temp_index));
-		    }
-		    temp += group_size;
-		}
-		temp0 += ysize;
-	    }
-
-	    outindex = (j + (i * widthout)) * components;
-	    for (k = 0; k < components; k++) {
-		dataout[outindex + k] = totals[k]/area;
-		/*printf("totals[%d] = %f\n", k, totals[k]);*/
-	    }
-	    lowx_int = highx_int;
-	    lowx_float = highx_float;
-	    highx_int += convx_int;
-	    highx_float += convx_float;
-	    if(highx_float > 1) {
-		highx_float -= 1.0;
-		highx_int++;
-	    }
-	}
-	lowy_int = highy_int;
-	lowy_float = highy_float;
-	highy_int += convy_int;
-	highy_float += convy_float;
-	if(highy_float > 1) {
-	    highy_float -= 1.0;
-	    highy_int++;
-	}
-    }
-}
-
-static void scale_internal_ushort(GLint components, GLint widthin,
-			   GLint heightin, const GLushort *datain,
-			   GLint widthout, GLint heightout,
-			   GLushort *dataout, GLint element_size,
-			   GLint ysize, GLint group_size,
-			   GLint myswap_bytes)
-{
-    float convx;
-    float convy;
-    float percent;
-    /* Max components in a format is 4, so... */
-    float totals[4];
-    float area;
-    int i,j,k,xindex;
-
-    const char *temp, *temp0;
-    const char *temp_index;
-    int outindex;
-
-    int lowx_int, highx_int, lowy_int, highy_int;
-    float x_percent, y_percent;
-    float lowx_float, highx_float, lowy_float, highy_float;
-    float convy_float, convx_float;
-    int convy_int, convx_int;
-    int l, m;
-    const char *left, *right;
-
-    if (widthin == widthout*2 && heightin == heightout*2) {
-	halveImage_ushort(components, widthin, heightin,
-	(const GLushort *)datain, (GLushort *)dataout,
-	element_size, ysize, group_size, myswap_bytes);
-	return;
-    }
-    convy = (float) heightin/heightout;
-    convx = (float) widthin/widthout;
-    convy_int = floor(convy);
-    convy_float = convy - convy_int;
-    convx_int = floor(convx);
-    convx_float = convx - convx_int;
-
-    area = convx * convy;
-
-    lowy_int = 0;
-    lowy_float = 0;
-    highy_int = convy_int;
-    highy_float = convy_float;
-
-    for (i = 0; i < heightout; i++) {
-        /* Clamp here to be sure we don't read beyond input buffer. */
-        if (highy_int >= heightin)
-            highy_int = heightin - 1;
-	lowx_int = 0;
-	lowx_float = 0;
-	highx_int = convx_int;
-	highx_float = convx_float;
-
-	for (j = 0; j < widthout; j++) {
-	    /*
-	    ** Ok, now apply box filter to box that goes from (lowx, lowy)
-	    ** to (highx, highy) on input data into this pixel on output
-	    ** data.
-	    */
-	    totals[0] = totals[1] = totals[2] = totals[3] = 0.0;
-
-	    /* calculate the value for pixels in the 1st row */
-	    xindex = lowx_int*group_size;
-	    if((highy_int>lowy_int) && (highx_int>lowx_int)) {
-
-		y_percent = 1-lowy_float;
-		temp = (const char *)datain + xindex + lowy_int * ysize;
-		percent = y_percent * (1-lowx_float);
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
-		    } else {
-			totals[k] += *(const GLushort*)temp_index * percent;
-		    }
-		}
-		left = temp;
-		for(l = lowx_int+1; l < highx_int; l++) {
-		    temp += group_size;
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			if (myswap_bytes) {
-			    totals[k] +=
-				 __GLU_SWAP_2_BYTES(temp_index) * y_percent;
-			} else {
-			    totals[k] += *(const GLushort*)temp_index * y_percent;
-			}
-		    }
-		}
-		temp += group_size;
-		right = temp;
-		percent = y_percent * highx_float;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
-		    } else {
-			totals[k] += *(const GLushort*)temp_index * percent;
-		    }
-		}
-
-		/* calculate the value for pixels in the last row */	        
-		y_percent = highy_float;
-		percent = y_percent * (1-lowx_float);
-		temp = (const char *)datain + xindex + highy_int * ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
-		    } else {
-			totals[k] += *(const GLushort*)temp_index * percent;
-		    }
-		}
-		for(l = lowx_int+1; l < highx_int; l++) {
-		    temp += group_size;
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			if (myswap_bytes) {
-			    totals[k] +=
-				 __GLU_SWAP_2_BYTES(temp_index) * y_percent;
-			} else {
-			    totals[k] += *(const GLushort*)temp_index * y_percent;
-			}
-		    }
-		}
-		temp += group_size;
-		percent = y_percent * highx_float;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
-		    } else {
-			totals[k] += *(const GLushort*)temp_index * percent;
-		    }
-		}
-
-		/* calculate the value for pixels in the 1st and last column */
-		for(m = lowy_int+1; m < highy_int; m++) {
-		    left += ysize;
-		    right += ysize;
-		    for (k = 0; k < components;
-			 k++, left += element_size, right += element_size) {
-			if (myswap_bytes) {
-			    totals[k] +=
-				__GLU_SWAP_2_BYTES(left) * (1-lowx_float) +
-				__GLU_SWAP_2_BYTES(right) * highx_float;
-			} else {
-			    totals[k] += *(const GLushort*)left * (1-lowx_float)
-				       + *(const GLushort*)right * highx_float;
-			}
-		    }
-		}
-	    } else if (highy_int > lowy_int) {
-		x_percent = highx_float - lowx_float;
-		percent = (1-lowy_float)*x_percent;
-		temp = (const char *)datain + xindex + lowy_int*ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
-		    } else {
-			totals[k] += *(const GLushort*)temp_index * percent;
-		    }
-		}
-		for(m = lowy_int+1; m < highy_int; m++) {
-		    temp += ysize;
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			if (myswap_bytes) {
-			    totals[k] +=
-				__GLU_SWAP_2_BYTES(temp_index) * x_percent;
-			} else {
-			    totals[k] += *(const GLushort*)temp_index * x_percent;
-			}
-		    }
-		}
-		percent = x_percent * highy_float;
-		temp += ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
-		    } else {
-			totals[k] += *(const GLushort*)temp_index * percent;
-		    }
-		}
-	    } else if (highx_int > lowx_int) {
-		y_percent = highy_float - lowy_float;
-		percent = (1-lowx_float)*y_percent;
-		temp = (const char *)datain + xindex + lowy_int*ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
-		    } else {
-			totals[k] += *(const GLushort*)temp_index * percent;
-		    }
-		}
-		for (l = lowx_int+1; l < highx_int; l++) {
-		    temp += group_size;
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			if (myswap_bytes) {
-			    totals[k] +=
-				__GLU_SWAP_2_BYTES(temp_index) * y_percent;
-			} else {
-			    totals[k] += *(const GLushort*)temp_index * y_percent;
-			}
-		    }
-		}
-		temp += group_size;
-		percent = y_percent * highx_float;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
-		    } else {
-			totals[k] += *(const GLushort*)temp_index * percent;
-		    }
-		}
-	    } else {
-		percent = (highy_float-lowy_float)*(highx_float-lowx_float);
-		temp = (const char *)datain + xindex + lowy_int * ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
-		    } else {
-			totals[k] += *(const GLushort*)temp_index * percent;
-		    }
-		}
-	    }
-
-	    /* this is for the pixels in the body */
-	    temp0 = (const char *)datain + xindex + group_size +
-		 (lowy_int+1)*ysize;
-	    for (m = lowy_int+1; m < highy_int; m++) {
-		temp = temp0;
-		for(l = lowx_int+1; l < highx_int; l++) {
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			if (myswap_bytes) {
-			    totals[k] += __GLU_SWAP_2_BYTES(temp_index);
-			} else {
-			    totals[k] += *(const GLushort*)temp_index;
-			}
-		    }
-		    temp += group_size;
-		}
-		temp0 += ysize;
-	    }
-
-	    outindex = (j + (i * widthout)) * components;
-	    for (k = 0; k < components; k++) {
-		dataout[outindex + k] = totals[k]/area;
-		/*printf("totals[%d] = %f\n", k, totals[k]);*/
-	    }
-	    lowx_int = highx_int;
-	    lowx_float = highx_float;
-	    highx_int += convx_int;
-	    highx_float += convx_float;
-	    if(highx_float > 1) {
-		highx_float -= 1.0;
-		highx_int++;
-	    }
-	}
-	lowy_int = highy_int;
-	lowy_float = highy_float;
-	highy_int += convy_int;
-	highy_float += convy_float;
-	if(highy_float > 1) {
-	    highy_float -= 1.0;
-	    highy_int++;
-	}
-    }
-}
-
-static void scale_internal_short(GLint components, GLint widthin,
-			   GLint heightin, const GLshort *datain,
-			   GLint widthout, GLint heightout,
-			   GLshort *dataout, GLint element_size,
-			   GLint ysize, GLint group_size,
-			   GLint myswap_bytes)
-{
-    float convx;
-    float convy;
-    float percent;
-    /* Max components in a format is 4, so... */
-    float totals[4];
-    float area;
-    int i,j,k,xindex;
-
-    const char *temp, *temp0;
-    const char *temp_index;
-    int outindex;
-
-    int lowx_int, highx_int, lowy_int, highy_int;
-    float x_percent, y_percent;
-    float lowx_float, highx_float, lowy_float, highy_float;
-    float convy_float, convx_float;
-    int convy_int, convx_int;
-    int l, m;
-    const char *left, *right;
-
-    GLushort swapbuf;	/* unsigned buffer */
-
-    if (widthin == widthout*2 && heightin == heightout*2) {
-	halveImage_short(components, widthin, heightin,
-	(const GLshort *)datain, (GLshort *)dataout,
-	element_size, ysize, group_size, myswap_bytes);
-	return;
-    }
-    convy = (float) heightin/heightout;
-    convx = (float) widthin/widthout;
-    convy_int = floor(convy);
-    convy_float = convy - convy_int;
-    convx_int = floor(convx);
-    convx_float = convx - convx_int;
-
-    area = convx * convy;
-
-    lowy_int = 0;
-    lowy_float = 0;
-    highy_int = convy_int;
-    highy_float = convy_float;
-
-    for (i = 0; i < heightout; i++) {
-        /* Clamp here to be sure we don't read beyond input buffer. */
-        if (highy_int >= heightin)
-            highy_int = heightin - 1;
-	lowx_int = 0;
-	lowx_float = 0;
-	highx_int = convx_int;
-	highx_float = convx_float;
-
-	for (j = 0; j < widthout; j++) {
-	    /*
-	    ** Ok, now apply box filter to box that goes from (lowx, lowy)
-	    ** to (highx, highy) on input data into this pixel on output
-	    ** data.
-	    */
-	    totals[0] = totals[1] = totals[2] = totals[3] = 0.0;
-
-	    /* calculate the value for pixels in the 1st row */
-	    xindex = lowx_int*group_size;
-	    if((highy_int>lowy_int) && (highx_int>lowx_int)) {
-
-		y_percent = 1-lowy_float;
-		temp = (const char *)datain + xindex + lowy_int * ysize;
-		percent = y_percent * (1-lowx_float);
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			swapbuf = __GLU_SWAP_2_BYTES(temp_index);
-			totals[k] += *(const GLshort*)&swapbuf * percent;
-		    } else {
-			totals[k] += *(const GLshort*)temp_index * percent;
-		    }
-		}
-		left = temp;
-		for(l = lowx_int+1; l < highx_int; l++) {
-		    temp += group_size;
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			if (myswap_bytes) {
-			    swapbuf = __GLU_SWAP_2_BYTES(temp_index);
-			    totals[k] += *(const GLshort*)&swapbuf * y_percent;
-			} else {
-			    totals[k] += *(const GLshort*)temp_index * y_percent;
-			}
-		    }
-		}
-		temp += group_size;
-		right = temp;
-		percent = y_percent * highx_float;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			swapbuf = __GLU_SWAP_2_BYTES(temp_index);
-			totals[k] += *(const GLshort*)&swapbuf * percent;
-		    } else {
-			totals[k] += *(const GLshort*)temp_index * percent;
-		    }
-		}
-
-		/* calculate the value for pixels in the last row */
-		y_percent = highy_float;
-		percent = y_percent * (1-lowx_float);
-		temp = (const char *)datain + xindex + highy_int * ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			swapbuf = __GLU_SWAP_2_BYTES(temp_index);
-			totals[k] += *(const GLshort*)&swapbuf * percent;
-		    } else {
-			totals[k] += *(const GLshort*)temp_index * percent;
-		    }
-		}
-		for(l = lowx_int+1; l < highx_int; l++) {
-		    temp += group_size;
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			if (myswap_bytes) {
-			    swapbuf = __GLU_SWAP_2_BYTES(temp_index);
-			    totals[k] += *(const GLshort*)&swapbuf * y_percent;
-			} else {
-			    totals[k] += *(const GLshort*)temp_index * y_percent;
-			}
-		    }
-		}
-		temp += group_size;
-		percent = y_percent * highx_float;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			swapbuf = __GLU_SWAP_2_BYTES(temp_index);
-			totals[k] += *(const GLshort*)&swapbuf * percent;
-		    } else {
-			totals[k] += *(const GLshort*)temp_index * percent;
-		    }
-		}
-
-		/* calculate the value for pixels in the 1st and last column */
-		for(m = lowy_int+1; m < highy_int; m++) {
-		    left += ysize;
-		    right += ysize;
-		    for (k = 0; k < components;
-			 k++, left += element_size, right += element_size) {
-			if (myswap_bytes) {
-			    swapbuf = __GLU_SWAP_2_BYTES(left);
-			    totals[k] += *(const GLshort*)&swapbuf * (1-lowx_float);
-			    swapbuf = __GLU_SWAP_2_BYTES(right);
-			    totals[k] += *(const GLshort*)&swapbuf * highx_float;
-			} else {
-			    totals[k] += *(const GLshort*)left * (1-lowx_float)
-				       + *(const GLshort*)right * highx_float;
-			}
-		    }
-		}
-	    } else if (highy_int > lowy_int) {
-		x_percent = highx_float - lowx_float;
-		percent = (1-lowy_float)*x_percent;
-		temp = (const char *)datain + xindex + lowy_int*ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			swapbuf = __GLU_SWAP_2_BYTES(temp_index);
-			totals[k] += *(const GLshort*)&swapbuf * percent;
-		    } else {
-			totals[k] += *(const GLshort*)temp_index * percent;
-		    }
-		}
-		for(m = lowy_int+1; m < highy_int; m++) {
-		    temp += ysize;
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			if (myswap_bytes) {
-			    swapbuf = __GLU_SWAP_2_BYTES(temp_index);
-			    totals[k] += *(const GLshort*)&swapbuf * x_percent;
-			} else {
-			    totals[k] += *(const GLshort*)temp_index * x_percent;
-			}
-		    }
-		}
-		percent = x_percent * highy_float;
-		temp += ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			swapbuf = __GLU_SWAP_2_BYTES(temp_index);
-			totals[k] += *(const GLshort*)&swapbuf * percent;
-		    } else {
-			totals[k] += *(const GLshort*)temp_index * percent;
-		    }
-		}
-	    } else if (highx_int > lowx_int) {
-		y_percent = highy_float - lowy_float;
-		percent = (1-lowx_float)*y_percent;
-
-	     temp = (const char *)datain + xindex + lowy_int*ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			swapbuf = __GLU_SWAP_2_BYTES(temp_index);
-			totals[k] += *(const GLshort*)&swapbuf * percent;
-		    } else {
-			totals[k] += *(const GLshort*)temp_index * percent;
-		    }
-		}
-		for (l = lowx_int+1; l < highx_int; l++) {
-		    temp += group_size;
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			if (myswap_bytes) {
-			    swapbuf = __GLU_SWAP_2_BYTES(temp_index);
-			    totals[k] += *(const GLshort*)&swapbuf * y_percent;
-			} else {
-			    totals[k] += *(const GLshort*)temp_index * y_percent;
-			}
-		    }
-		}
-		temp += group_size;
-		percent = y_percent * highx_float;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			swapbuf = __GLU_SWAP_2_BYTES(temp_index);
-			totals[k] += *(const GLshort*)&swapbuf * percent;
-		    } else {
-			totals[k] += *(const GLshort*)temp_index * percent;
-		    }
-		}
-	    } else {
-		percent = (highy_float-lowy_float)*(highx_float-lowx_float);
-		temp = (const char *)datain + xindex + lowy_int * ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			swapbuf = __GLU_SWAP_2_BYTES(temp_index);
-			totals[k] += *(const GLshort*)&swapbuf * percent;
-		    } else {
-			totals[k] += *(const GLshort*)temp_index * percent;
-		    }
-		}
-	    }
-
-	    /* this is for the pixels in the body */
-	    temp0 = (const char *)datain + xindex + group_size +
-		 (lowy_int+1)*ysize;
-	    for (m = lowy_int+1; m < highy_int; m++) {
-		temp = temp0;
-		for(l = lowx_int+1; l < highx_int; l++) {
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			if (myswap_bytes) {
-			    swapbuf = __GLU_SWAP_2_BYTES(temp_index);
-			    totals[k] += *(const GLshort*)&swapbuf;
-			} else {
-			    totals[k] += *(const GLshort*)temp_index;
-			}
-		    }
-		    temp += group_size;
-		}
-		temp0 += ysize;
-	    }
-
-	    outindex = (j + (i * widthout)) * components;
-	    for (k = 0; k < components; k++) {
-		dataout[outindex + k] = totals[k]/area;
-		/*printf("totals[%d] = %f\n", k, totals[k]);*/
-	    }
-	    lowx_int = highx_int;
-	    lowx_float = highx_float;
-	    highx_int += convx_int;
-	    highx_float += convx_float;
-	    if(highx_float > 1) {
-		highx_float -= 1.0;
-		highx_int++;
-	    }
-	}
-	lowy_int = highy_int;
-	lowy_float = highy_float;
-	highy_int += convy_int;
-	highy_float += convy_float;
-	if(highy_float > 1) {
-	    highy_float -= 1.0;
-	    highy_int++;
-	}
-    }
-}
-
-static void scale_internal_uint(GLint components, GLint widthin,
-			   GLint heightin, const GLuint *datain,
-			   GLint widthout, GLint heightout,
-			   GLuint *dataout, GLint element_size,
-			   GLint ysize, GLint group_size,
-			   GLint myswap_bytes)
-{
-    float convx;
-    float convy;
-    float percent;
-    /* Max components in a format is 4, so... */
-    float totals[4];
-    float area;
-    int i,j,k,xindex;
-
-    const char *temp, *temp0;
-    const char *temp_index;
-    int outindex;
-
-    int lowx_int, highx_int, lowy_int, highy_int;
-    float x_percent, y_percent;
-    float lowx_float, highx_float, lowy_float, highy_float;
-    float convy_float, convx_float;
-    int convy_int, convx_int;
-    int l, m;
-    const char *left, *right;
-
-    if (widthin == widthout*2 && heightin == heightout*2) {
-	halveImage_uint(components, widthin, heightin,
-	(const GLuint *)datain, (GLuint *)dataout,
-	element_size, ysize, group_size, myswap_bytes);
-	return;
-    }
-    convy = (float) heightin/heightout;
-    convx = (float) widthin/widthout;
-    convy_int = floor(convy);
-    convy_float = convy - convy_int;
-    convx_int = floor(convx);
-    convx_float = convx - convx_int;
-
-    area = convx * convy;
-
-    lowy_int = 0;
-    lowy_float = 0;
-    highy_int = convy_int;
-    highy_float = convy_float;
-
-    for (i = 0; i < heightout; i++) {
-        /* Clamp here to be sure we don't read beyond input buffer. */
-        if (highy_int >= heightin)
-            highy_int = heightin - 1;
-	lowx_int = 0;
-	lowx_float = 0;
-	highx_int = convx_int;
-	highx_float = convx_float;
-
-	for (j = 0; j < widthout; j++) {
-	    /*
-	    ** Ok, now apply box filter to box that goes from (lowx, lowy)
-	    ** to (highx, highy) on input data into this pixel on output
-	    ** data.
-	    */
-	    totals[0] = totals[1] = totals[2] = totals[3] = 0.0;
-
-	    /* calculate the value for pixels in the 1st row */
-	    xindex = lowx_int*group_size;
-	    if((highy_int>lowy_int) && (highx_int>lowx_int)) {
-
-		y_percent = 1-lowy_float;
-		temp = (const char *)datain + xindex + lowy_int * ysize;
-		percent = y_percent * (1-lowx_float);
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;
-		    } else {
-			totals[k] += *(const GLuint*)temp_index * percent;
-		    }
-		}
-		left = temp;
-		for(l = lowx_int+1; l < highx_int; l++) {
-		    temp += group_size;
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			if (myswap_bytes) {
-			    totals[k] +=
-				 __GLU_SWAP_4_BYTES(temp_index) * y_percent;
-			} else {
-			    totals[k] += *(const GLuint*)temp_index * y_percent;
-			}
-		    }
-		}
-		temp += group_size;
-		right = temp;
-		percent = y_percent * highx_float;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;
-		    } else {
-			totals[k] += *(const GLuint*)temp_index * percent;
-		    }
-		}
-
-		/* calculate the value for pixels in the last row */
-		y_percent = highy_float;
-		percent = y_percent * (1-lowx_float);
-		temp = (const char *)datain + xindex + highy_int * ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;
-		    } else {
-			totals[k] += *(const GLuint*)temp_index * percent;
-		    }
-		}
-		for(l = lowx_int+1; l < highx_int; l++) {
-		    temp += group_size;
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			if (myswap_bytes) {
-			    totals[k] +=
-				 __GLU_SWAP_4_BYTES(temp_index) * y_percent;
-			} else {
-			    totals[k] += *(const GLuint*)temp_index * y_percent;
-			}
-		    }
-		}
-		temp += group_size;
-		percent = y_percent * highx_float;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;
-		    } else {
-			totals[k] += *(const GLuint*)temp_index * percent;
-		    }
-		}
-
-		/* calculate the value for pixels in the 1st and last column */
-		for(m = lowy_int+1; m < highy_int; m++) {
-		    left += ysize;
-		    right += ysize;
-		    for (k = 0; k < components;
-			 k++, left += element_size, right += element_size) {
-			if (myswap_bytes) {
-			    totals[k] +=
-				__GLU_SWAP_4_BYTES(left) * (1-lowx_float)
-			      + __GLU_SWAP_4_BYTES(right) * highx_float;
-			} else {
-			    totals[k] += *(const GLuint*)left * (1-lowx_float)
-				       + *(const GLuint*)right * highx_float;
-			}
-		    }
-		}
-	    } else if (highy_int > lowy_int) {
-		x_percent = highx_float - lowx_float;
-		percent = (1-lowy_float)*x_percent;
-		temp = (const char *)datain + xindex + lowy_int*ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;
-		    } else {
-			totals[k] += *(const GLuint*)temp_index * percent;
-		    }
-		}
-		for(m = lowy_int+1; m < highy_int; m++) {
-		    temp += ysize;
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			if (myswap_bytes) {
-			    totals[k] +=
-				 __GLU_SWAP_4_BYTES(temp_index) * x_percent;
-			} else {
-			    totals[k] += *(const GLuint*)temp_index * x_percent;
-			}
-		    }
-		}
-		percent = x_percent * highy_float;
-		temp += ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;
-		    } else {
-			totals[k] += *(const GLuint*)temp_index * percent;
-		    }
-		}
-	    } else if (highx_int > lowx_int) {
-		y_percent = highy_float - lowy_float;
-		percent = (1-lowx_float)*y_percent;
-
-	     temp = (const char *)datain + xindex + lowy_int*ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;
-		    } else {
-			totals[k] += *(const GLuint*)temp_index * percent;
-		    }
-		}
-		for (l = lowx_int+1; l < highx_int; l++) {
-		    temp += group_size;
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			if (myswap_bytes) {
-			    totals[k] +=
-				 __GLU_SWAP_4_BYTES(temp_index) * y_percent;
-			} else {
-			    totals[k] += *(const GLuint*)temp_index * y_percent;
-			}
-		    }
-		}
-		temp += group_size;
-		percent = y_percent * highx_float;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;
-		    } else {
-			totals[k] += *(const GLuint*)temp_index * percent;
-		    }
-		}
-	    } else {
-		percent = (highy_float-lowy_float)*(highx_float-lowx_float);
-		temp = (const char *)datain + xindex + lowy_int * ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;
-		    } else {
-			totals[k] += *(const GLuint*)temp_index * percent;
-		    }
-		}
-	    }
-
-	    /* this is for the pixels in the body */
-	    temp0 = (const char *)datain + xindex + group_size +
-		 (lowy_int+1)*ysize;
-	    for (m = lowy_int+1; m < highy_int; m++) {
-		temp = temp0;
-		for(l = lowx_int+1; l < highx_int; l++) {
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			if (myswap_bytes) {
-			    totals[k] += __GLU_SWAP_4_BYTES(temp_index);
-			} else {
-			    totals[k] += *(const GLuint*)temp_index;
-			}
-		    }
-		    temp += group_size;
-		}
-		temp0 += ysize;
-	    }
-
-	    outindex = (j + (i * widthout)) * components;
-	    for (k = 0; k < components; k++) {
-		/* clamp at UINT_MAX */
-		float value= totals[k]/area;
-		if (value >= (float) UINT_MAX) {	/* need '=' */
-		  dataout[outindex + k] = UINT_MAX;
-		}
-		else dataout[outindex + k] = value;
-	    }
-	    lowx_int = highx_int;
-	    lowx_float = highx_float;
-	    highx_int += convx_int;
-	    highx_float += convx_float;
-	    if(highx_float > 1) {
-		highx_float -= 1.0;
-		highx_int++;
-	    }
-	}
-	lowy_int = highy_int;
-	lowy_float = highy_float;
-	highy_int += convy_int;
-	highy_float += convy_float;
-	if(highy_float > 1) {
-	    highy_float -= 1.0;
-	    highy_int++;
-	}
-    }
-}
-
-
-
-static void scale_internal_int(GLint components, GLint widthin,
-			   GLint heightin, const GLint *datain,
-			   GLint widthout, GLint heightout,
-			   GLint *dataout, GLint element_size,
-			   GLint ysize, GLint group_size,
-			   GLint myswap_bytes)
-{
-    float convx;
-    float convy;
-    float percent;
-    /* Max components in a format is 4, so... */
-    float totals[4];
-    float area;
-    int i,j,k,xindex;
-
-    const char *temp, *temp0;
-    const char *temp_index;
-    int outindex;
-
-    int lowx_int, highx_int, lowy_int, highy_int;
-    float x_percent, y_percent;
-    float lowx_float, highx_float, lowy_float, highy_float;
-    float convy_float, convx_float;
-    int convy_int, convx_int;
-    int l, m;
-    const char *left, *right;
-
-    GLuint swapbuf;	/* unsigned buffer */
-
-    if (widthin == widthout*2 && heightin == heightout*2) {
-	halveImage_int(components, widthin, heightin,
-	(const GLint *)datain, (GLint *)dataout,
-	element_size, ysize, group_size, myswap_bytes);
-	return;
-    }
-    convy = (float) heightin/heightout;
-    convx = (float) widthin/widthout;
-    convy_int = floor(convy);
-    convy_float = convy - convy_int;
-    convx_int = floor(convx);
-    convx_float = convx - convx_int;
-
-    area = convx * convy;
-
-    lowy_int = 0;
-    lowy_float = 0;
-    highy_int = convy_int;
-    highy_float = convy_float;
-
-    for (i = 0; i < heightout; i++) {
-        /* Clamp here to be sure we don't read beyond input buffer. */
-        if (highy_int >= heightin)
-            highy_int = heightin - 1;
-	lowx_int = 0;
-	lowx_float = 0;
-	highx_int = convx_int;
-	highx_float = convx_float;
-
-	for (j = 0; j < widthout; j++) {
-	    /*
-	    ** Ok, now apply box filter to box that goes from (lowx, lowy)
-	    ** to (highx, highy) on input data into this pixel on output
-	    ** data.
-	    */
-	    totals[0] = totals[1] = totals[2] = totals[3] = 0.0;
-
-	    /* calculate the value for pixels in the 1st row */
-	    xindex = lowx_int*group_size;
-	    if((highy_int>lowy_int) && (highx_int>lowx_int)) {
-
-		y_percent = 1-lowy_float;
-		temp = (const char *)datain + xindex + lowy_int * ysize;
-		percent = y_percent * (1-lowx_float);
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			swapbuf = __GLU_SWAP_4_BYTES(temp_index);
-			totals[k] += *(const GLint*)&swapbuf * percent;
-		    } else {
-			totals[k] += *(const GLint*)temp_index * percent;
-		    }
-		}
-		left = temp;
-		for(l = lowx_int+1; l < highx_int; l++) {
-		    temp += group_size;
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			if (myswap_bytes) {
-			    swapbuf = __GLU_SWAP_4_BYTES(temp_index);
-			    totals[k] += *(const GLint*)&swapbuf * y_percent;
-			} else {
-			    totals[k] += *(const GLint*)temp_index * y_percent;
-			}
-		    }
-		}
-		temp += group_size;
-		right = temp;
-		percent = y_percent * highx_float;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			swapbuf = __GLU_SWAP_4_BYTES(temp_index);
-			totals[k] += *(const GLint*)&swapbuf * percent;
-		    } else {
-			totals[k] += *(const GLint*)temp_index * percent;
-		    }
-		}
-
-		/* calculate the value for pixels in the last row */
-		y_percent = highy_float;
-		percent = y_percent * (1-lowx_float);
-		temp = (const char *)datain + xindex + highy_int * ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			swapbuf = __GLU_SWAP_4_BYTES(temp_index);
-			totals[k] += *(const GLint*)&swapbuf  * percent;
-		    } else {
-			totals[k] += *(const GLint*)temp_index * percent;
-		    }
-		}
-		for(l = lowx_int+1; l < highx_int; l++) {
-		    temp += group_size;
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			if (myswap_bytes) {
-			    swapbuf = __GLU_SWAP_4_BYTES(temp_index);
-			    totals[k] += *(const GLint*)&swapbuf * y_percent;
-			} else {
-			    totals[k] += *(const GLint*)temp_index * y_percent;
-			}
-		    }
-		}
-		temp += group_size;
-		percent = y_percent * highx_float;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			swapbuf = __GLU_SWAP_4_BYTES(temp_index);
-			totals[k] += *(const GLint*)&swapbuf * percent;
-		    } else {
-			totals[k] += *(const GLint*)temp_index * percent;
-		    }
-		}
-
-		/* calculate the value for pixels in the 1st and last column */
-		for(m = lowy_int+1; m < highy_int; m++) {
-		    left += ysize;
-		    right += ysize;
-		    for (k = 0; k < components;
-			 k++, left += element_size, right += element_size) {
-			if (myswap_bytes) {
-			    swapbuf = __GLU_SWAP_4_BYTES(left);
-			    totals[k] += *(const GLint*)&swapbuf * (1-lowx_float);
-			    swapbuf = __GLU_SWAP_4_BYTES(right);
-			    totals[k] += *(const GLint*)&swapbuf * highx_float;
-			} else {
-			    totals[k] += *(const GLint*)left * (1-lowx_float)
-				       + *(const GLint*)right * highx_float;
-			}
-		    }
-		}
-	    } else if (highy_int > lowy_int) {
-		x_percent = highx_float - lowx_float;
-		percent = (1-lowy_float)*x_percent;
-		temp = (const char *)datain + xindex + lowy_int*ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			swapbuf = __GLU_SWAP_4_BYTES(temp_index);
-			totals[k] += *(const GLint*)&swapbuf * percent;
-		    } else {
-			totals[k] += *(const GLint*)temp_index * percent;
-		    }
-		}
-		for(m = lowy_int+1; m < highy_int; m++) {
-		    temp += ysize;
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			if (myswap_bytes) {
-			    swapbuf = __GLU_SWAP_4_BYTES(temp_index);
-			    totals[k] += *(const GLint*)&swapbuf * x_percent;
-			} else {
-			    totals[k] += *(const GLint*)temp_index * x_percent;
-			}
-		    }
-		}
-		percent = x_percent * highy_float;
-		temp += ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			swapbuf = __GLU_SWAP_4_BYTES(temp_index);
-			totals[k] += *(const GLint*)&swapbuf * percent;
-		    } else {
-			totals[k] += *(const GLint*)temp_index * percent;
-		    }
-		}
-	    } else if (highx_int > lowx_int) {
-		y_percent = highy_float - lowy_float;
-		percent = (1-lowx_float)*y_percent;
-
-		 temp = (const char *)datain + xindex + lowy_int*ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			swapbuf = __GLU_SWAP_4_BYTES(temp_index);
-			totals[k] += *(const GLint*)&swapbuf * percent;
-		    } else {
-			totals[k] += *(const GLint*)temp_index * percent;
-		    }
-		}
-		for (l = lowx_int+1; l < highx_int; l++) {
-		    temp += group_size;
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			if (myswap_bytes) {
-			    swapbuf = __GLU_SWAP_4_BYTES(temp_index);
-			    totals[k] += *(const GLint*)&swapbuf * y_percent;
-			} else {
-			    totals[k] += *(const GLint*)temp_index * y_percent;
-			}
-		    }
-		}
-		temp += group_size;
-		percent = y_percent * highx_float;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			swapbuf = __GLU_SWAP_4_BYTES(temp_index);
-			totals[k] += *(const GLint*)&swapbuf * percent;
-		    } else {
-			totals[k] += *(const GLint*)temp_index * percent;
-		    }
-		}
-	    } else {
-		percent = (highy_float-lowy_float)*(highx_float-lowx_float);
-		temp = (const char *)datain + xindex + lowy_int * ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			swapbuf = __GLU_SWAP_4_BYTES(temp_index);
-			totals[k] += *(const GLint*)&swapbuf * percent;
-		    } else {
-			totals[k] += *(const GLint*)temp_index * percent;
-		    }
-		}
-	    }
-
-	    /* this is for the pixels in the body */
-	    temp0 = (const char *)datain + xindex + group_size +
-		 (lowy_int+1)*ysize;
-	    for (m = lowy_int+1; m < highy_int; m++) {
-		temp = temp0;
-		for(l = lowx_int+1; l < highx_int; l++) {
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			if (myswap_bytes) {
-			    swapbuf = __GLU_SWAP_4_BYTES(temp_index);
-			    totals[k] += *(const GLint*)&swapbuf;
-			} else {
-			    totals[k] += *(const GLint*)temp_index;
-			}
-		    }
-		    temp += group_size;
-		}
-		temp0 += ysize;
-	    }
-
-	    outindex = (j + (i * widthout)) * components;
-	    for (k = 0; k < components; k++) {
-		dataout[outindex + k] = totals[k]/area;
-		/*printf("totals[%d] = %f\n", k, totals[k]);*/
-	    }
-	    lowx_int = highx_int;
-	    lowx_float = highx_float;
-	    highx_int += convx_int;
-	    highx_float += convx_float;
-	    if(highx_float > 1) {
-		highx_float -= 1.0;
-		highx_int++;
-	    }
-	}
-	lowy_int = highy_int;
-	lowy_float = highy_float;
-	highy_int += convy_int;
-	highy_float += convy_float;
-	if(highy_float > 1) {
-	    highy_float -= 1.0;
-	    highy_int++;
-	}
-    }
-}
-
-
-
-static void scale_internal_float(GLint components, GLint widthin,
-			   GLint heightin, const GLfloat *datain,
-			   GLint widthout, GLint heightout,
-			   GLfloat *dataout, GLint element_size,
-			   GLint ysize, GLint group_size,
-			   GLint myswap_bytes)
-{
-    float convx;
-    float convy;
-    float percent;
-    /* Max components in a format is 4, so... */
-    float totals[4];
-    float area;
-    int i,j,k,xindex;
-
-    const char *temp, *temp0;
-    const char *temp_index;
-    int outindex;
-
-    int lowx_int, highx_int, lowy_int, highy_int;
-    float x_percent, y_percent;
-    float lowx_float, highx_float, lowy_float, highy_float;
-    float convy_float, convx_float;
-    int convy_int, convx_int;
-    int l, m;
-    const char *left, *right;
-
-    union { GLuint b; GLfloat f; } swapbuf;
-
-    if (widthin == widthout*2 && heightin == heightout*2) {
-	halveImage_float(components, widthin, heightin,
-	(const GLfloat *)datain, (GLfloat *)dataout,
-	element_size, ysize, group_size, myswap_bytes);
-	return;
-    }
-    convy = (float) heightin/heightout;
-    convx = (float) widthin/widthout;
-    convy_int = floor(convy);
-    convy_float = convy - convy_int;
-    convx_int = floor(convx);
-    convx_float = convx - convx_int;
-
-    area = convx * convy;
-
-    lowy_int = 0;
-    lowy_float = 0;
-    highy_int = convy_int;
-    highy_float = convy_float;
-
-    for (i = 0; i < heightout; i++) {
-        /* Clamp here to be sure we don't read beyond input buffer. */
-        if (highy_int >= heightin)
-            highy_int = heightin - 1;
-	lowx_int = 0;
-	lowx_float = 0;
-	highx_int = convx_int;
-	highx_float = convx_float;
-
-	for (j = 0; j < widthout; j++) {
-	    /*
-	    ** Ok, now apply box filter to box that goes from (lowx, lowy)
-	    ** to (highx, highy) on input data into this pixel on output
-	    ** data.
-	    */
-	    totals[0] = totals[1] = totals[2] = totals[3] = 0.0;
-
-	    /* calculate the value for pixels in the 1st row */
-	    xindex = lowx_int*group_size;
-	    if((highy_int>lowy_int) && (highx_int>lowx_int)) {
-
-		y_percent = 1-lowy_float;
-		temp = (const char *)datain + xindex + lowy_int * ysize;
-		percent = y_percent * (1-lowx_float);
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
-			totals[k] += swapbuf.f * percent;
-		    } else {
-			totals[k] += *(const GLfloat*)temp_index * percent;
-		    }
-		}
-		left = temp;
-		for(l = lowx_int+1; l < highx_int; l++) {
-		    temp += group_size;
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			if (myswap_bytes) {
-			    swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
-			    totals[k] += swapbuf.f * y_percent;
-			} else {
-			    totals[k] += *(const GLfloat*)temp_index * y_percent;
-			}
-		    }
-		}
-		temp += group_size;
-		right = temp;
-		percent = y_percent * highx_float;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
-			totals[k] += swapbuf.f * percent;
-		    } else {
-			totals[k] += *(const GLfloat*)temp_index * percent;
-		    }
-		}
-
-		/* calculate the value for pixels in the last row */
-		y_percent = highy_float;
-		percent = y_percent * (1-lowx_float);
-		temp = (const char *)datain + xindex + highy_int * ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
-			totals[k] += swapbuf.f * percent;
-		    } else {
-			totals[k] += *(const GLfloat*)temp_index * percent;
-		    }
-		}
-		for(l = lowx_int+1; l < highx_int; l++) {
-		    temp += group_size;
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			if (myswap_bytes) {
-			    swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
-			    totals[k] += swapbuf.f * y_percent;
-			} else {
-			    totals[k] += *(const GLfloat*)temp_index * y_percent;
-			}
-		    }
-		}
-		temp += group_size;
-		percent = y_percent * highx_float;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
-			totals[k] += swapbuf.f * percent;
-		    } else {
-			totals[k] += *(const GLfloat*)temp_index * percent;
-		    }
-		}
-
-		/* calculate the value for pixels in the 1st and last column */
-		for(m = lowy_int+1; m < highy_int; m++) {
-		    left += ysize;
-		    right += ysize;
-		    for (k = 0; k < components;
-			 k++, left += element_size, right += element_size) {
-			if (myswap_bytes) {
-			    swapbuf.b = __GLU_SWAP_4_BYTES(left);
-			    totals[k] += swapbuf.f * (1-lowx_float);
-			    swapbuf.b = __GLU_SWAP_4_BYTES(right);
-			    totals[k] += swapbuf.f * highx_float;
-			} else {
-			    totals[k] += *(const GLfloat*)left * (1-lowx_float)
-				       + *(const GLfloat*)right * highx_float;
-			}
-		    }
-		}
-	    } else if (highy_int > lowy_int) {
-		x_percent = highx_float - lowx_float;
-		percent = (1-lowy_float)*x_percent;
-		temp = (const char *)datain + xindex + lowy_int*ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
-			totals[k] += swapbuf.f * percent;
-		    } else {
-			totals[k] += *(const GLfloat*)temp_index * percent;
-		    }
-		}
-		for(m = lowy_int+1; m < highy_int; m++) {
-		    temp += ysize;
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			if (myswap_bytes) {
-			    swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
-			    totals[k] += swapbuf.f * x_percent;
-			} else {
-			    totals[k] += *(const GLfloat*)temp_index * x_percent;
-			}
-		    }
-		}
-		percent = x_percent * highy_float;
-		temp += ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
-			totals[k] += swapbuf.f * percent;
-		    } else {
-			totals[k] += *(const GLfloat*)temp_index * percent;
-		    }
-		}
-	    } else if (highx_int > lowx_int) {
-		y_percent = highy_float - lowy_float;
-		percent = (1-lowx_float)*y_percent;
-
-	     temp = (const char *)datain + xindex + lowy_int*ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
-			totals[k] += swapbuf.f * percent;
-		    } else {
-			totals[k] += *(const GLfloat*)temp_index * percent;
-		    }
-		}
-		for (l = lowx_int+1; l < highx_int; l++) {
-		    temp += group_size;
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			if (myswap_bytes) {
-			    swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
-			    totals[k] += swapbuf.f * y_percent;
-			} else {
-			    totals[k] += *(const GLfloat*)temp_index * y_percent;
-			}
-		    }
-		}
-		temp += group_size;
-		percent = y_percent * highx_float;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
-			totals[k] += swapbuf.f * percent;
-		    } else {
-			totals[k] += *(const GLfloat*)temp_index * percent;
-		    }
-		}
-	    } else {
-		percent = (highy_float-lowy_float)*(highx_float-lowx_float);
-		temp = (const char *)datain + xindex + lowy_int * ysize;
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
-			totals[k] += swapbuf.f * percent;
-		    } else {
-			totals[k] += *(const GLfloat*)temp_index * percent;
-		    }
-		}
-	    }
-
-	    /* this is for the pixels in the body */
-	    temp0 = (const char *)datain + xindex + group_size +
-		 (lowy_int+1)*ysize;
-	    for (m = lowy_int+1; m < highy_int; m++) {
-		temp = temp0;
-		for(l = lowx_int+1; l < highx_int; l++) {
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			if (myswap_bytes) {
-			    swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
-			    totals[k] += swapbuf.f;
-			} else {
-			    totals[k] += *(const GLfloat*)temp_index;
-			}
-		    }
-		    temp += group_size;
-		}
-		temp0 += ysize;
-	    }
-
-	    outindex = (j + (i * widthout)) * components;
-	    for (k = 0; k < components; k++) {
-		dataout[outindex + k] = totals[k]/area;
-		/*printf("totals[%d] = %f\n", k, totals[k]);*/
-	    }
-	    lowx_int = highx_int;
-	    lowx_float = highx_float;
-	    highx_int += convx_int;
-	    highx_float += convx_float;
-	    if(highx_float > 1) {
-		highx_float -= 1.0;
-		highx_int++;
-	    }
-	}
-	lowy_int = highy_int;
-	lowy_float = highy_float;
-	highy_int += convy_int;
-	highy_float += convy_float;
-	if(highy_float > 1) {
-	    highy_float -= 1.0;
-	    highy_int++;
-	}
-    }
-}
-
-static int checkMipmapArgs(GLenum internalFormat, GLenum format, GLenum type)
-{
-    if (!legalFormat(format) || !legalType(type)) {
-	return GLU_INVALID_ENUM;
-    }
-    if (format == GL_STENCIL_INDEX) {
-	return GLU_INVALID_ENUM;
-    }
-
-    if (!isLegalFormatForPackedPixelType(format, type)) {
-	return GLU_INVALID_OPERATION;
-    }
-
-    return 0;
-} /* checkMipmapArgs() */
-
-static GLboolean legalFormat(GLenum format)
-{
-    switch(format) {
-      case GL_COLOR_INDEX:
-      case GL_STENCIL_INDEX:
-      case GL_DEPTH_COMPONENT:
-      case GL_RED:
-      case GL_GREEN:
-      case GL_BLUE:
-      case GL_ALPHA:
-      case GL_RGB:
-      case GL_RGBA:
-      case GL_LUMINANCE:
-      case GL_LUMINANCE_ALPHA:
-      case GL_BGR:
-      case GL_BGRA:
-	return GL_TRUE;
-      default:
-	return GL_FALSE;
-    }
-}
-
-
-static GLboolean legalType(GLenum type)
-{
-    switch(type) {
-      case GL_BITMAP:
-      case GL_BYTE:
-      case GL_UNSIGNED_BYTE:
-      case GL_SHORT:
-      case GL_UNSIGNED_SHORT:
-      case GL_INT:
-      case GL_UNSIGNED_INT:
-      case GL_FLOAT:
-      case GL_UNSIGNED_BYTE_3_3_2:
-      case GL_UNSIGNED_BYTE_2_3_3_REV:  
-      case GL_UNSIGNED_SHORT_5_6_5:
-      case GL_UNSIGNED_SHORT_5_6_5_REV:
-      case GL_UNSIGNED_SHORT_4_4_4_4:
-      case GL_UNSIGNED_SHORT_4_4_4_4_REV:
-      case GL_UNSIGNED_SHORT_5_5_5_1:
-      case GL_UNSIGNED_SHORT_1_5_5_5_REV:
-      case GL_UNSIGNED_INT_8_8_8_8:
-      case GL_UNSIGNED_INT_8_8_8_8_REV:
-      case GL_UNSIGNED_INT_10_10_10_2:
-      case GL_UNSIGNED_INT_2_10_10_10_REV:
-	 return GL_TRUE;
-      default:
-	return GL_FALSE;
-    }
-}
-
-/* */
-static GLboolean isTypePackedPixel(GLenum type)
-{
-   assert(legalType(type));
-
-   if (type == GL_UNSIGNED_BYTE_3_3_2 ||
-       type == GL_UNSIGNED_BYTE_2_3_3_REV ||
-       type == GL_UNSIGNED_SHORT_5_6_5 ||
-       type == GL_UNSIGNED_SHORT_5_6_5_REV ||
-       type == GL_UNSIGNED_SHORT_4_4_4_4 ||
-       type == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
-       type == GL_UNSIGNED_SHORT_5_5_5_1 ||
-       type == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
-       type == GL_UNSIGNED_INT_8_8_8_8 ||
-       type == GL_UNSIGNED_INT_8_8_8_8_REV ||
-       type == GL_UNSIGNED_INT_10_10_10_2 ||
-       type == GL_UNSIGNED_INT_2_10_10_10_REV) {
-      return 1;
-   }
-   else return 0;
-} /* isTypePackedPixel() */
-
-/* Determines if the packed pixel type is compatible with the format */
-static GLboolean isLegalFormatForPackedPixelType(GLenum format, GLenum type)
-{
-   /* if not a packed pixel type then return true */
-   if (!isTypePackedPixel(type)) {
-      return GL_TRUE;
-   }
-
-   /* 3_3_2/2_3_3_REV & 5_6_5/5_6_5_REV are only compatible with RGB */
-   if ((type == GL_UNSIGNED_BYTE_3_3_2 || type == GL_UNSIGNED_BYTE_2_3_3_REV||
-	type == GL_UNSIGNED_SHORT_5_6_5|| type == GL_UNSIGNED_SHORT_5_6_5_REV)
-       && format != GL_RGB)
-      return GL_FALSE;
-
-   /* 4_4_4_4/4_4_4_4_REV & 5_5_5_1/1_5_5_5_REV & 8_8_8_8/8_8_8_8_REV &
-    * 10_10_10_2/2_10_10_10_REV are only compatible with RGBA, BGRA & ABGR_EXT.
-    */
-   if ((type == GL_UNSIGNED_SHORT_4_4_4_4 ||
-	type == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
-	type == GL_UNSIGNED_SHORT_5_5_5_1 ||
-	type == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
-	type == GL_UNSIGNED_INT_8_8_8_8 ||
-	type == GL_UNSIGNED_INT_8_8_8_8_REV ||
-	type == GL_UNSIGNED_INT_10_10_10_2 ||
-	type == GL_UNSIGNED_INT_2_10_10_10_REV) &&
-       (format != GL_RGBA &&
-	format != GL_BGRA)) {
-      return GL_FALSE;
-   }
-
-   return GL_TRUE;
-} /* isLegalFormatForPackedPixelType() */
-
-static GLboolean isLegalLevels(GLint userLevel,GLint baseLevel,GLint maxLevel,
-			       GLint totalLevels)
-{
-   if (baseLevel < 0 || baseLevel < userLevel || maxLevel < baseLevel ||
-       totalLevels < maxLevel)
-      return GL_FALSE;
-   else return GL_TRUE;
-} /* isLegalLevels() */
-
-/* Given user requested texture size, determine if it fits. If it
- * doesn't then halve both sides and make the determination again
- * until it does fit (for IR only).
- * Note that proxy textures are not implemented in RE* even though
- * they advertise the texture extension.
- * Note that proxy textures are implemented but not according to spec in
- * IMPACT*.
- */
-static void closestFit(GLenum target, GLint width, GLint height,
-		       GLint internalFormat, GLenum format, GLenum type,
-		       GLint *newWidth, GLint *newHeight)
-{
-   /* Use proxy textures if OpenGL version is >= 1.1 */
-   if ( (strtod((const char *)glGetString(GL_VERSION),NULL) >= 1.1)
-	) {
-      GLint widthPowerOf2= nearestPower(width);
-      GLint heightPowerOf2= nearestPower(height);       
-      GLint proxyWidth;
-
-      do {
-	 /* compute level 1 width & height, clamping each at 1 */
-	 GLint widthAtLevelOne= (widthPowerOf2 > 1) ?
-				 widthPowerOf2 >> 1 :
-				 widthPowerOf2;
-	 GLint heightAtLevelOne= (heightPowerOf2 > 1) ?
-				  heightPowerOf2 >> 1 :
-				  heightPowerOf2;
-	 GLenum proxyTarget;
-	 assert(widthAtLevelOne > 0); assert(heightAtLevelOne > 0);
-
-	 /* does width x height at level 1 & all their mipmaps fit? */
-	 if (target == GL_TEXTURE_2D || target == GL_PROXY_TEXTURE_2D) {
-	    proxyTarget = GL_PROXY_TEXTURE_2D;
-	    glTexImage2D(proxyTarget, 1, /* must be non-zero */
-			 internalFormat,
-			 widthAtLevelOne,heightAtLevelOne,0,format,type,NULL);
-	 } else
-#if defined(GL_ARB_texture_cube_map)
-	 if ((target == GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB) ||
-	     (target == GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB) ||
-	     (target == GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB) ||
-	     (target == GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB) ||
-	     (target == GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB) ||
-	     (target == GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB)) {
-	     proxyTarget = GL_PROXY_TEXTURE_CUBE_MAP_ARB;
-	     glTexImage2D(proxyTarget, 1, /* must be non-zero */
-			  internalFormat,
-			  widthAtLevelOne,heightAtLevelOne,0,format,type,NULL);
-	 } else
-#endif /* GL_ARB_texture_cube_map */
-	 {
-	    assert(target == GL_TEXTURE_1D || target == GL_PROXY_TEXTURE_1D);
-	    proxyTarget = GL_PROXY_TEXTURE_1D;
-	    glTexImage1D(proxyTarget, 1, /* must be non-zero */
-			 internalFormat,widthAtLevelOne,0,format,type,NULL);
-	 }
-	 glGetTexLevelParameteriv(proxyTarget, 1,GL_TEXTURE_WIDTH,&proxyWidth);
-	 /* does it fit??? */
-	 if (proxyWidth == 0) { /* nope, so try again with these sizes */
-	    if (widthPowerOf2 == 1 && heightPowerOf2 == 1) {
-	       /* An 1x1 texture couldn't fit for some reason, so
-		* break out.  This should never happen. But things
-		* happen.  The disadvantage with this if-statement is
-		* that we will never be aware of when this happens
-		* since it will silently branch out.
-		*/
-	       goto noProxyTextures;
-	    }
-	    widthPowerOf2= widthAtLevelOne;
-	    heightPowerOf2= heightAtLevelOne;
-	 }
-	 /* else it does fit */
-      } while (proxyWidth == 0);
-      /* loop must terminate! */
-
-      /* return the width & height at level 0 that fits */
-      *newWidth= widthPowerOf2;
-      *newHeight= heightPowerOf2;
-/*printf("Proxy Textures\n");*/
-   } /* if gluCheckExtension() */
-   else {			/* no texture extension, so do this instead */
-      GLint maxsize;
-
-noProxyTextures:
-
-      glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxsize);
-      /* clamp user's texture sizes to maximum sizes, if necessary */
-      *newWidth = nearestPower(width);
-      if (*newWidth > maxsize) *newWidth = maxsize;
-      *newHeight = nearestPower(height);
-      if (*newHeight > maxsize) *newHeight = maxsize;
-/*printf("NO proxy textures\n");*/
-   }
-} /* closestFit() */
-
-GLint GLAPIENTRY
-gluScaleImage(GLenum format, GLsizei widthin, GLsizei heightin,
-		    GLenum typein, const void *datain,
-		    GLsizei widthout, GLsizei heightout, GLenum typeout,
-		    void *dataout)
-{
-    int components;
-    GLushort *beforeImage;
-    GLushort *afterImage;
-    PixelStorageModes psm;
-
-    if (widthin == 0 || heightin == 0 || widthout == 0 || heightout == 0) {
-	return 0;
-    }
-    if (widthin < 0 || heightin < 0 || widthout < 0 || heightout < 0) {
-	return GLU_INVALID_VALUE;
-    }
-    if (!legalFormat(format) || !legalType(typein) || !legalType(typeout)) {
-	return GLU_INVALID_ENUM;
-    }
-    if (!isLegalFormatForPackedPixelType(format, typein)) {
-       return GLU_INVALID_OPERATION;
-    }
-    if (!isLegalFormatForPackedPixelType(format, typeout)) {
-       return GLU_INVALID_OPERATION;
-    }
-    beforeImage =
-	malloc(image_size(widthin, heightin, format, GL_UNSIGNED_SHORT));
-    afterImage =
-	malloc(image_size(widthout, heightout, format, GL_UNSIGNED_SHORT));
-    if (beforeImage == NULL || afterImage == NULL) {
-	free(beforeImage);
-	free(afterImage);
-	return GLU_OUT_OF_MEMORY;
-    }
-
-    retrieveStoreModes(&psm);
-    fill_image(&psm,widthin, heightin, format, typein, is_index(format),
-	    datain, beforeImage);
-    components = elements_per_group(format, 0);
-    scale_internal(components, widthin, heightin, beforeImage,
-	    widthout, heightout, afterImage);
-    empty_image(&psm,widthout, heightout, format, typeout,
-	    is_index(format), afterImage, dataout);
-    free((GLbyte *) beforeImage);
-    free((GLbyte *) afterImage);
-
-    return 0;
-}
-
-int gluBuild1DMipmapLevelsCore(GLenum target, GLint internalFormat,
-			       GLsizei width,
-			       GLsizei widthPowerOf2,
-			       GLenum format, GLenum type,
-			       GLint userLevel, GLint baseLevel,GLint maxLevel,
-			       const void *data)
-{
-    GLint newwidth;
-    GLint level, levels;
-    GLushort *newImage;
-    GLint newImage_width;
-    GLushort *otherImage;
-    GLushort *imageTemp;
-    GLint memreq;
-    GLint cmpts;
-    PixelStorageModes psm;
-
-    assert(checkMipmapArgs(internalFormat,format,type) == 0);
-    assert(width >= 1);
-
-    otherImage = NULL;
-
-    newwidth= widthPowerOf2;
-    levels = computeLog(newwidth);
-
-    levels+= userLevel;
-
-    retrieveStoreModes(&psm);
-    newImage = (GLushort *)
-	malloc(image_size(width, 1, format, GL_UNSIGNED_SHORT));
-    newImage_width = width;
-    if (newImage == NULL) {
-	return GLU_OUT_OF_MEMORY;
-    }
-    fill_image(&psm,width, 1, format, type, is_index(format),
-	    data, newImage);
-    cmpts = elements_per_group(format,type);
-    glPixelStorei(GL_UNPACK_ALIGNMENT, 2);
-    glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
-    glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
-    /*
-    ** If swap_bytes was set, swapping occurred in fill_image.
-    */
-    glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE);
-
-    for (level = userLevel; level <= levels; level++) {
-	if (newImage_width == newwidth) {
-	    /* Use newImage for this level */
-	    if (baseLevel <= level && level <= maxLevel) {
-	    glTexImage1D(target, level, internalFormat, newImage_width,
-		    0, format, GL_UNSIGNED_SHORT, (void *) newImage);
-	    }
-	} else {
-	    if (otherImage == NULL) {
-		memreq = image_size(newwidth, 1, format, GL_UNSIGNED_SHORT);
-		otherImage = (GLushort *) malloc(memreq);
-		if (otherImage == NULL) {
-		    glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
-		    glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
-		    glPixelStorei(GL_UNPACK_SKIP_PIXELS,psm.unpack_skip_pixels);
-		    glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
-		    glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
-		    free(newImage);
-		    return GLU_OUT_OF_MEMORY;
-		}
-	    }
-	    scale_internal(cmpts, newImage_width, 1, newImage,
-		    newwidth, 1, otherImage);
-	    /* Swap newImage and otherImage */
-	    imageTemp = otherImage;
-	    otherImage = newImage;
-	    newImage = imageTemp;
-
-	    newImage_width = newwidth;
-	    if (baseLevel <= level && level <= maxLevel) {
-	    glTexImage1D(target, level, internalFormat, newImage_width,
-		    0, format, GL_UNSIGNED_SHORT, (void *) newImage);
-	    }
-	}
-	if (newwidth > 1) newwidth /= 2;
-    }
-    glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
-    glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
-    glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
-    glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
-
-    free((GLbyte *) newImage);
-    if (otherImage) {
-	free((GLbyte *) otherImage);
-    }
-    return 0;
-}
-
-GLint GLAPIENTRY
-gluBuild1DMipmapLevels(GLenum target, GLint internalFormat,
-			     GLsizei width,
-			     GLenum format, GLenum type,
-			     GLint userLevel, GLint baseLevel, GLint maxLevel,
-			     const void *data)
-{
-   int levels;
-
-   int rc= checkMipmapArgs(internalFormat,format,type);
-   if (rc != 0) return rc;
-
-   if (width < 1) {
-       return GLU_INVALID_VALUE;
-   }
-
-   levels = computeLog(width);
-
-   levels+= userLevel;
-   if (!isLegalLevels(userLevel,baseLevel,maxLevel,levels))
-      return GLU_INVALID_VALUE;
-
-   return gluBuild1DMipmapLevelsCore(target, internalFormat,
-				     width,
-				     width,format, type,
-				     userLevel, baseLevel, maxLevel,
-				     data);
-} /* gluBuild1DMipmapLevels() */
-
-GLint GLAPIENTRY
-gluBuild1DMipmaps(GLenum target, GLint internalFormat, GLsizei width,
-			GLenum format, GLenum type,
-			const void *data)
-{
-   GLint widthPowerOf2;
-   int levels;
-   GLint dummy;
-
-   int rc= checkMipmapArgs(internalFormat,format,type);
-   if (rc != 0) return rc;
-
-   if (width < 1) {
-       return GLU_INVALID_VALUE;
-   }
-
-   closestFit(target,width,1,internalFormat,format,type,&widthPowerOf2,&dummy);
-   levels = computeLog(widthPowerOf2);
-
-   return gluBuild1DMipmapLevelsCore(target,internalFormat,
-				     width,
-				     widthPowerOf2,
-				     format,type,0,0,levels,data);
-}
-
-static int bitmapBuild2DMipmaps(GLenum target, GLint internalFormat,
-		     GLint width, GLint height, GLenum format,
-		     GLenum type, const void *data)
-{
-    GLint newwidth, newheight;
-    GLint level, levels;
-    GLushort *newImage;
-    GLint newImage_width;
-    GLint newImage_height;
-    GLushort *otherImage;
-    GLushort *imageTemp;
-    GLint memreq;
-    GLint cmpts;
-    PixelStorageModes psm;
-
-    retrieveStoreModes(&psm);
-
-#if 0
-    glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxsize);
-    newwidth = nearestPower(width);
-    if (newwidth > maxsize) newwidth = maxsize;
-    newheight = nearestPower(height);
-    if (newheight > maxsize) newheight = maxsize;
-#else
-    closestFit(target,width,height,internalFormat,format,type,
-	       &newwidth,&newheight);
-#endif
-    levels = computeLog(newwidth);
-    level = computeLog(newheight);
-    if (level > levels) levels=level;
-
-    otherImage = NULL;
-    newImage = (GLushort *)
-	malloc(image_size(width, height, format, GL_UNSIGNED_SHORT));
-    newImage_width = width;
-    newImage_height = height;
-    if (newImage == NULL) {
-	return GLU_OUT_OF_MEMORY;
-    }
-
-    fill_image(&psm,width, height, format, type, is_index(format),
-	  data, newImage);
-
-    cmpts = elements_per_group(format,type);
-    glPixelStorei(GL_UNPACK_ALIGNMENT, 2);
-    glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
-    glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
-    /*
-    ** If swap_bytes was set, swapping occurred in fill_image.
-    */
-    glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE);
-
-    for (level = 0; level <= levels; level++) {
-	if (newImage_width == newwidth && newImage_height == newheight) {	     /* Use newImage for this level */
-	    glTexImage2D(target, level, internalFormat, newImage_width,
-		    newImage_height, 0, format, GL_UNSIGNED_SHORT,
-		    (void *) newImage);
-	} else {
-	    if (otherImage == NULL) {
-		memreq =
-		    image_size(newwidth, newheight, format, GL_UNSIGNED_SHORT);
-		otherImage = (GLushort *) malloc(memreq);
-		if (otherImage == NULL) {
-		    glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
-		    glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
-		    glPixelStorei(GL_UNPACK_SKIP_PIXELS,psm.unpack_skip_pixels);
-		    glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
-		    glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
-		    free(newImage);
-		    return GLU_OUT_OF_MEMORY;
-		}
-	    }
-	    scale_internal(cmpts, newImage_width, newImage_height, newImage,
-		    newwidth, newheight, otherImage);
-	    /* Swap newImage and otherImage */
-	    imageTemp = otherImage;
-	    otherImage = newImage;
-	    newImage = imageTemp;
-
-	    newImage_width = newwidth;
-	    newImage_height = newheight;
-	    glTexImage2D(target, level, internalFormat, newImage_width,
-		    newImage_height, 0, format, GL_UNSIGNED_SHORT,
-		    (void *) newImage);
-	}
-	if (newwidth > 1) newwidth /= 2;
-	if (newheight > 1) newheight /= 2;
-    }
-    glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
-    glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
-    glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
-    glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
-
-    free((GLbyte *) newImage);
-    if (otherImage) {
-	free((GLbyte *) otherImage);
-    }
-    return 0;
-}
-
-/* To make swapping images less error prone */
-#define __GLU_INIT_SWAP_IMAGE void *tmpImage
-#define __GLU_SWAP_IMAGE(a,b) tmpImage = a; a = b; b = tmpImage;
-
-static int gluBuild2DMipmapLevelsCore(GLenum target, GLint internalFormat,
-				      GLsizei width, GLsizei height,
-				      GLsizei widthPowerOf2,
-				      GLsizei heightPowerOf2,
-				      GLenum format, GLenum type,
-				      GLint userLevel,
-				      GLint baseLevel,GLint maxLevel,
-				      const void *data)
-{
-    GLint newwidth, newheight;
-    GLint level, levels;
-    const void *usersImage; /* passed from user. Don't touch! */
-    void *srcImage, *dstImage; /* scratch area to build mipmapped images */
-    __GLU_INIT_SWAP_IMAGE;
-    GLint memreq;
-    GLint cmpts;
-
-    GLint myswap_bytes, groups_per_line, element_size, group_size;
-    GLint rowsize, padding;
-    PixelStorageModes psm;
-
-    assert(checkMipmapArgs(internalFormat,format,type) == 0);
-    assert(width >= 1 && height >= 1);
-
-    if(type == GL_BITMAP) {
-	return bitmapBuild2DMipmaps(target, internalFormat, width, height,
-		format, type, data);
-    }
-
-    srcImage = dstImage = NULL;
-
-    newwidth= widthPowerOf2;
-    newheight= heightPowerOf2;
-    levels = computeLog(newwidth);
-    level = computeLog(newheight);
-    if (level > levels) levels=level;
-
-    levels+= userLevel;
-
-    retrieveStoreModes(&psm);
-    myswap_bytes = psm.unpack_swap_bytes;
-    cmpts = elements_per_group(format,type);
-    if (psm.unpack_row_length > 0) {
-	groups_per_line = psm.unpack_row_length;
-    } else {
-	groups_per_line = width;
-    }
-
-    element_size = bytes_per_element(type);
-    group_size = element_size * cmpts;
-    if (element_size == 1) myswap_bytes = 0;
-
-    rowsize = groups_per_line * group_size;
-    padding = (rowsize % psm.unpack_alignment);
-    if (padding) {
-	rowsize += psm.unpack_alignment - padding;
-    }
-    usersImage = (const GLubyte *) data + psm.unpack_skip_rows * rowsize +
-	psm.unpack_skip_pixels * group_size;
-
-    glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
-    glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
-
-    level = userLevel;
-
-    /* already power-of-two square */
-    if (width == newwidth && height == newheight) {
-	/* Use usersImage for level userLevel */
-	if (baseLevel <= level && level <= maxLevel) {
-        glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
-	glTexImage2D(target, level, internalFormat, width,
-		height, 0, format, type,
-		usersImage);
-	}
-        glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
-	if(levels == 0) { /* we're done. clean up and return */
-	  glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
-	  glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
-	  glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
-	  glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
-	  glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
-	  return 0;
-	}
-	{
-	   int nextWidth= newwidth/2;
-	   int nextHeight= newheight/2;
-
-	   /* clamp to 1 */
-	   if (nextWidth < 1) nextWidth= 1;
-	   if (nextHeight < 1) nextHeight= 1;
-	memreq = image_size(nextWidth, nextHeight, format, type);
-	}
-
-	switch(type) {
-	case GL_UNSIGNED_BYTE:
-	  dstImage = (GLubyte *)malloc(memreq);
-	  break;
-	case GL_BYTE:
-	  dstImage = (GLbyte *)malloc(memreq);
-	  break;
-	case GL_UNSIGNED_SHORT:
-	  dstImage = (GLushort *)malloc(memreq);
-	  break;
-	case GL_SHORT:
-	  dstImage = (GLshort *)malloc(memreq);
-	  break;
-	case GL_UNSIGNED_INT:
-	  dstImage = (GLuint *)malloc(memreq);
-	  break;
-	case GL_INT:
-	  dstImage = (GLint *)malloc(memreq);
-	  break;
-	case GL_FLOAT:
-	  dstImage = (GLfloat *)malloc(memreq);
-	  break;
-	case GL_UNSIGNED_BYTE_3_3_2:
-	case GL_UNSIGNED_BYTE_2_3_3_REV:
-	  dstImage = (GLubyte *)malloc(memreq);
-	  break;
-	case GL_UNSIGNED_SHORT_5_6_5:
-	case GL_UNSIGNED_SHORT_5_6_5_REV:
-	case GL_UNSIGNED_SHORT_4_4_4_4:
-	case GL_UNSIGNED_SHORT_4_4_4_4_REV:
-	case GL_UNSIGNED_SHORT_5_5_5_1:
-	case GL_UNSIGNED_SHORT_1_5_5_5_REV:
-	  dstImage = (GLushort *)malloc(memreq);
-	  break;
-	case GL_UNSIGNED_INT_8_8_8_8:
-	case GL_UNSIGNED_INT_8_8_8_8_REV:
-	case GL_UNSIGNED_INT_10_10_10_2:
-	case GL_UNSIGNED_INT_2_10_10_10_REV:
-	  dstImage = (GLuint *)malloc(memreq);  
-	  break;
-	default:
-	  return GLU_INVALID_ENUM;
-	}
-	if (dstImage == NULL) {
-	  glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
-	  glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
-	  glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
-	  glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
-	  glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
-	  return GLU_OUT_OF_MEMORY;
-	}
-	else
-	  switch(type) {
-	  case GL_UNSIGNED_BYTE:
-	    halveImage_ubyte(cmpts, width, height,
-			     (const GLubyte *)usersImage, (GLubyte *)dstImage,
-			     element_size, rowsize, group_size);
-	    break;
-	  case GL_BYTE:
-	    halveImage_byte(cmpts, width, height,
-			    (const GLbyte *)usersImage, (GLbyte *)dstImage,
-			    element_size, rowsize, group_size);
-	    break;
-	  case GL_UNSIGNED_SHORT:
-	    halveImage_ushort(cmpts, width, height,
-			      (const GLushort *)usersImage, (GLushort *)dstImage,
-			      element_size, rowsize, group_size, myswap_bytes);
-	    break;
-	  case GL_SHORT:
-	    halveImage_short(cmpts, width, height,
-			     (const GLshort *)usersImage, (GLshort *)dstImage,
-			     element_size, rowsize, group_size, myswap_bytes);
-	    break;
-	  case GL_UNSIGNED_INT:
-	    halveImage_uint(cmpts, width, height,
-			    (const GLuint *)usersImage, (GLuint *)dstImage,
-			    element_size, rowsize, group_size, myswap_bytes);
-	    break;
-	  case GL_INT:
-	    halveImage_int(cmpts, width, height,
-			   (const GLint *)usersImage, (GLint *)dstImage,
-			   element_size, rowsize, group_size, myswap_bytes);
-	    break;
-	  case GL_FLOAT:
-	    halveImage_float(cmpts, width, height,
-			     (const GLfloat *)usersImage, (GLfloat *)dstImage,
-			     element_size, rowsize, group_size, myswap_bytes);
-	    break;
-	  case GL_UNSIGNED_BYTE_3_3_2:
-	    assert(format == GL_RGB);
-	    halveImagePackedPixel(3,extract332,shove332,
-				  width,height,usersImage,dstImage,
-				  element_size,rowsize,myswap_bytes);
-	    break;
-	  case GL_UNSIGNED_BYTE_2_3_3_REV:
-	    assert(format == GL_RGB);
-	    halveImagePackedPixel(3,extract233rev,shove233rev,
-				  width,height,usersImage,dstImage,
-				  element_size,rowsize,myswap_bytes);
-	    break;
-	  case GL_UNSIGNED_SHORT_5_6_5:
-	    halveImagePackedPixel(3,extract565,shove565,
-				  width,height,usersImage,dstImage,
-				  element_size,rowsize,myswap_bytes);
-	    break;
-	  case GL_UNSIGNED_SHORT_5_6_5_REV:
-	    halveImagePackedPixel(3,extract565rev,shove565rev,
-				  width,height,usersImage,dstImage,
-				  element_size,rowsize,myswap_bytes);
-	    break;
-	  case GL_UNSIGNED_SHORT_4_4_4_4:
-	    halveImagePackedPixel(4,extract4444,shove4444,
-				  width,height,usersImage,dstImage,
-				  element_size,rowsize,myswap_bytes);
-	    break;
-	  case GL_UNSIGNED_SHORT_4_4_4_4_REV:
-	    halveImagePackedPixel(4,extract4444rev,shove4444rev,
-				  width,height,usersImage,dstImage,
-				  element_size,rowsize,myswap_bytes);
-	    break;
-	  case GL_UNSIGNED_SHORT_5_5_5_1:
-	    halveImagePackedPixel(4,extract5551,shove5551,
-				  width,height,usersImage,dstImage,
-				  element_size,rowsize,myswap_bytes);
-	    break;
-	  case GL_UNSIGNED_SHORT_1_5_5_5_REV:
-	    halveImagePackedPixel(4,extract1555rev,shove1555rev,
-				  width,height,usersImage,dstImage,
-				  element_size,rowsize,myswap_bytes);
-	    break;
-	  case GL_UNSIGNED_INT_8_8_8_8:
-	    halveImagePackedPixel(4,extract8888,shove8888,
-				  width,height,usersImage,dstImage,
-				  element_size,rowsize,myswap_bytes);
-	    break;
-	  case GL_UNSIGNED_INT_8_8_8_8_REV:
-	    halveImagePackedPixel(4,extract8888rev,shove8888rev,
-				  width,height,usersImage,dstImage,
-				  element_size,rowsize,myswap_bytes);
-	    break;
-	  case GL_UNSIGNED_INT_10_10_10_2:
-	    halveImagePackedPixel(4,extract1010102,shove1010102,
-				  width,height,usersImage,dstImage,
-				  element_size,rowsize,myswap_bytes);
-	    break;
-	  case GL_UNSIGNED_INT_2_10_10_10_REV:
-	    halveImagePackedPixel(4,extract2101010rev,shove2101010rev,
-				  width,height,usersImage,dstImage,
-				  element_size,rowsize,myswap_bytes);
-	    break;
-	  default:
-	    assert(0);
-	    break;
-	  }
-	newwidth = width/2;
-	newheight = height/2;
-	/* clamp to 1 */
-	if (newwidth < 1) newwidth= 1;
-	if (newheight < 1) newheight= 1;
-
-	myswap_bytes = 0;
-	rowsize = newwidth * group_size;
-	memreq = image_size(newwidth, newheight, format, type);
-	/* Swap srcImage and dstImage */
-	__GLU_SWAP_IMAGE(srcImage,dstImage);
-	switch(type) {
-	case GL_UNSIGNED_BYTE:
-	  dstImage = (GLubyte *)malloc(memreq);
-	  break;
-	case GL_BYTE:
-	  dstImage = (GLbyte *)malloc(memreq);
-	  break;
-	case GL_UNSIGNED_SHORT:
-	  dstImage = (GLushort *)malloc(memreq);
-	  break;
-	case GL_SHORT:
-	  dstImage = (GLshort *)malloc(memreq);
-	  break;
-	case GL_UNSIGNED_INT:
-	  dstImage = (GLuint *)malloc(memreq);
-	  break;
-	case GL_INT:
-	  dstImage = (GLint *)malloc(memreq);
-	  break;
-	case GL_FLOAT:
-	  dstImage = (GLfloat *)malloc(memreq);
-	  break;
-	case GL_UNSIGNED_BYTE_3_3_2:
-	case GL_UNSIGNED_BYTE_2_3_3_REV:
-	  dstImage = (GLubyte *)malloc(memreq);
-	  break;
-	case GL_UNSIGNED_SHORT_5_6_5:
-	case GL_UNSIGNED_SHORT_5_6_5_REV:
-	case GL_UNSIGNED_SHORT_4_4_4_4:
-	case GL_UNSIGNED_SHORT_4_4_4_4_REV:
-	case GL_UNSIGNED_SHORT_5_5_5_1:
-	case GL_UNSIGNED_SHORT_1_5_5_5_REV:
-	  dstImage = (GLushort *)malloc(memreq);
-	  break;
-	case GL_UNSIGNED_INT_8_8_8_8:
-	case GL_UNSIGNED_INT_8_8_8_8_REV:
-	case GL_UNSIGNED_INT_10_10_10_2:
-	case GL_UNSIGNED_INT_2_10_10_10_REV:
-	  dstImage = (GLuint *)malloc(memreq);
-	  break;
-	default:
-	  return GLU_INVALID_ENUM;
-	}
-	if (dstImage == NULL) {
-	  glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
-	  glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
-	  glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
-	  glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
-	  glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
-	  free(srcImage);
-	  return GLU_OUT_OF_MEMORY;
-	}
-	/* level userLevel+1 is in srcImage; level userLevel already saved */
-	level = userLevel+1;
-    } else { /* user's image is *not* nice power-of-2 sized square */
-	memreq = image_size(newwidth, newheight, format, type);
-	switch(type) {
-	    case GL_UNSIGNED_BYTE:
-		dstImage = (GLubyte *)malloc(memreq);
-		break;
-	    case GL_BYTE:
-		dstImage = (GLbyte *)malloc(memreq);
-		break;
-	    case GL_UNSIGNED_SHORT:
-		dstImage = (GLushort *)malloc(memreq);
-		break;
-	    case GL_SHORT:
-		dstImage = (GLshort *)malloc(memreq);
-		break;
-	    case GL_UNSIGNED_INT:
-		dstImage = (GLuint *)malloc(memreq);
-		break;
-	    case GL_INT:
-		dstImage = (GLint *)malloc(memreq);
-		break;
-	    case GL_FLOAT:
-		dstImage = (GLfloat *)malloc(memreq);
-		break;
-	    case GL_UNSIGNED_BYTE_3_3_2:
-	    case GL_UNSIGNED_BYTE_2_3_3_REV:
-		dstImage = (GLubyte *)malloc(memreq);
-		break;
-	    case GL_UNSIGNED_SHORT_5_6_5:
-	    case GL_UNSIGNED_SHORT_5_6_5_REV:
-	    case GL_UNSIGNED_SHORT_4_4_4_4:
-	    case GL_UNSIGNED_SHORT_4_4_4_4_REV:
-	    case GL_UNSIGNED_SHORT_5_5_5_1:
-	    case GL_UNSIGNED_SHORT_1_5_5_5_REV:
-		dstImage = (GLushort *)malloc(memreq);
-		break;
-	    case GL_UNSIGNED_INT_8_8_8_8:
-	    case GL_UNSIGNED_INT_8_8_8_8_REV:
-	    case GL_UNSIGNED_INT_10_10_10_2:
-	    case GL_UNSIGNED_INT_2_10_10_10_REV:
-		dstImage = (GLuint *)malloc(memreq);
-		break;
-	    default:
-		return GLU_INVALID_ENUM;
-	}
-
-	if (dstImage == NULL) {
-	    glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
-	    glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
-	    glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
-	    glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
-	    glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
-	    return GLU_OUT_OF_MEMORY;
-	}
-
-	switch(type) {
-	case GL_UNSIGNED_BYTE:
-	    scale_internal_ubyte(cmpts, width, height,
-				 (const GLubyte *)usersImage, newwidth, newheight,
-				 (GLubyte *)dstImage, element_size,
-				 rowsize, group_size);
-	    break;
-	case GL_BYTE:
-	    scale_internal_byte(cmpts, width, height,
-				(const GLbyte *)usersImage, newwidth, newheight,
-				(GLbyte *)dstImage, element_size,
-				rowsize, group_size);
-	    break;
-	case GL_UNSIGNED_SHORT:
-	    scale_internal_ushort(cmpts, width, height,
-				  (const GLushort *)usersImage, newwidth, newheight,
-				  (GLushort *)dstImage, element_size,
-				  rowsize, group_size, myswap_bytes);
-	    break;
-	case GL_SHORT:
-	    scale_internal_short(cmpts, width, height,
-				 (const GLshort *)usersImage, newwidth, newheight,
-				 (GLshort *)dstImage, element_size,
-				 rowsize, group_size, myswap_bytes);
-	    break;
-	case GL_UNSIGNED_INT:
-	    scale_internal_uint(cmpts, width, height,
-				(const GLuint *)usersImage, newwidth, newheight,
-				(GLuint *)dstImage, element_size,
-				rowsize, group_size, myswap_bytes);
-	    break;
-	case GL_INT:
-	    scale_internal_int(cmpts, width, height,
-			       (const GLint *)usersImage, newwidth, newheight,
-			       (GLint *)dstImage, element_size,
-			       rowsize, group_size, myswap_bytes);
-	    break;
-	case GL_FLOAT:
-	    scale_internal_float(cmpts, width, height,
-				 (const GLfloat *)usersImage, newwidth, newheight,
-				 (GLfloat *)dstImage, element_size,
-				 rowsize, group_size, myswap_bytes);
-	    break;
-	case GL_UNSIGNED_BYTE_3_3_2:
-	    scaleInternalPackedPixel(3,extract332,shove332,
-				     width, height,usersImage,
-				     newwidth,newheight,(void *)dstImage,
-				     element_size,rowsize,myswap_bytes);
-	    break;
-	case GL_UNSIGNED_BYTE_2_3_3_REV:
-	    scaleInternalPackedPixel(3,extract233rev,shove233rev,
-				     width, height,usersImage,
-				     newwidth,newheight,(void *)dstImage,
-				     element_size,rowsize,myswap_bytes);
-	    break;
-	case GL_UNSIGNED_SHORT_5_6_5:
-	    scaleInternalPackedPixel(3,extract565,shove565,
-				     width, height,usersImage,
-				     newwidth,newheight,(void *)dstImage,
-				     element_size,rowsize,myswap_bytes);
-	    break;
-	case GL_UNSIGNED_SHORT_5_6_5_REV:
-	    scaleInternalPackedPixel(3,extract565rev,shove565rev,
-				     width, height,usersImage,
-				     newwidth,newheight,(void *)dstImage,
-				     element_size,rowsize,myswap_bytes);
-	    break;
-	case GL_UNSIGNED_SHORT_4_4_4_4:
-	    scaleInternalPackedPixel(4,extract4444,shove4444,
-				     width, height,usersImage,
-				     newwidth,newheight,(void *)dstImage,
-				     element_size,rowsize,myswap_bytes);
-	    break;
-	case GL_UNSIGNED_SHORT_4_4_4_4_REV:
-	    scaleInternalPackedPixel(4,extract4444rev,shove4444rev,
-				     width, height,usersImage,
-				     newwidth,newheight,(void *)dstImage,
-				     element_size,rowsize,myswap_bytes);
-	    break;
-	case GL_UNSIGNED_SHORT_5_5_5_1:
-	    scaleInternalPackedPixel(4,extract5551,shove5551,
-				     width, height,usersImage,
-				     newwidth,newheight,(void *)dstImage,
-				     element_size,rowsize,myswap_bytes);
-	    break;
-	case GL_UNSIGNED_SHORT_1_5_5_5_REV:
-	    scaleInternalPackedPixel(4,extract1555rev,shove1555rev,
-				     width, height,usersImage,
-				     newwidth,newheight,(void *)dstImage,
-				     element_size,rowsize,myswap_bytes);
-	    break;
-	case GL_UNSIGNED_INT_8_8_8_8:
-	    scaleInternalPackedPixel(4,extract8888,shove8888,
-				     width, height,usersImage,
-				     newwidth,newheight,(void *)dstImage,
-				     element_size,rowsize,myswap_bytes);
-	    break;
-	case GL_UNSIGNED_INT_8_8_8_8_REV:
-	    scaleInternalPackedPixel(4,extract8888rev,shove8888rev,
-				     width, height,usersImage,
-				     newwidth,newheight,(void *)dstImage,
-				     element_size,rowsize,myswap_bytes);
-	    break;
-	case GL_UNSIGNED_INT_10_10_10_2:
-	    scaleInternalPackedPixel(4,extract1010102,shove1010102,
-				     width, height,usersImage,
-				     newwidth,newheight,(void *)dstImage,
-				     element_size,rowsize,myswap_bytes);
-	    break;
-	case GL_UNSIGNED_INT_2_10_10_10_REV:
-	    scaleInternalPackedPixel(4,extract2101010rev,shove2101010rev,
-				     width, height,usersImage,
-				     newwidth,newheight,(void *)dstImage,
-				     element_size,rowsize,myswap_bytes);
-	    break;
-	default:
-	    assert(0);
-	    break;
-	}
-	myswap_bytes = 0;
-	rowsize = newwidth * group_size;
-	/* Swap dstImage and srcImage */
-	__GLU_SWAP_IMAGE(srcImage,dstImage);
-
-	if(levels != 0) { /* use as little memory as possible */
-	  {
-	     int nextWidth= newwidth/2;
-	     int nextHeight= newheight/2;
-	     if (nextWidth < 1) nextWidth= 1;
-	     if (nextHeight < 1) nextHeight= 1; 
-
-	  memreq = image_size(nextWidth, nextHeight, format, type);
-	  }
-
-	  switch(type) {
-	  case GL_UNSIGNED_BYTE:
-	    dstImage = (GLubyte *)malloc(memreq);
-	    break;
-	  case GL_BYTE:
-	    dstImage = (GLbyte *)malloc(memreq);
-	    break;
-	  case GL_UNSIGNED_SHORT:
-	    dstImage = (GLushort *)malloc(memreq);
-	    break;
-	  case GL_SHORT:
-	    dstImage = (GLshort *)malloc(memreq);
-	    break;
-	  case GL_UNSIGNED_INT:
-	    dstImage = (GLuint *)malloc(memreq);
-	    break;
-	  case GL_INT:
-	    dstImage = (GLint *)malloc(memreq);
-	    break;
-	  case GL_FLOAT:
-	    dstImage = (GLfloat *)malloc(memreq);
-	    break;
-	  case GL_UNSIGNED_BYTE_3_3_2:
-	  case GL_UNSIGNED_BYTE_2_3_3_REV:
-	    dstImage = (GLubyte *)malloc(memreq);
-	    break;
-	  case GL_UNSIGNED_SHORT_5_6_5:
-	  case GL_UNSIGNED_SHORT_5_6_5_REV:
-	  case GL_UNSIGNED_SHORT_4_4_4_4:
-	  case GL_UNSIGNED_SHORT_4_4_4_4_REV:
-	  case GL_UNSIGNED_SHORT_5_5_5_1:
-	  case GL_UNSIGNED_SHORT_1_5_5_5_REV:
-	    dstImage = (GLushort *)malloc(memreq);
-	    break;
-	  case GL_UNSIGNED_INT_8_8_8_8:
-	  case GL_UNSIGNED_INT_8_8_8_8_REV:
-	  case GL_UNSIGNED_INT_10_10_10_2:
-	  case GL_UNSIGNED_INT_2_10_10_10_REV:
-	    dstImage = (GLuint *)malloc(memreq);
-	    break;
-	  default:
-	    return GLU_INVALID_ENUM;
-	  }
-	  if (dstImage == NULL) {
-	    glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
-	    glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
-	    glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
-	    glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
-	    glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
-	    free(srcImage);
-	    return GLU_OUT_OF_MEMORY;
-	  }
-	}
-	/* level userLevel is in srcImage; nothing saved yet */
-	level = userLevel;
-    }
-
-    glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE);
-    if (baseLevel <= level && level <= maxLevel) {
-    glTexImage2D(target, level, internalFormat, newwidth, newheight, 0,
-		 format, type, (void *)srcImage);
-    }
-
-    level++; /* update current level for the loop */
-    for (; level <= levels; level++) {
-	switch(type) {
-	    case GL_UNSIGNED_BYTE:
-		halveImage_ubyte(cmpts, newwidth, newheight,
-		(GLubyte *)srcImage, (GLubyte *)dstImage, element_size,
-		rowsize, group_size);
-		break;
-	    case GL_BYTE:
-		halveImage_byte(cmpts, newwidth, newheight,
-		(GLbyte *)srcImage, (GLbyte *)dstImage, element_size,
-		rowsize, group_size);
-		break;
-	    case GL_UNSIGNED_SHORT:
-		halveImage_ushort(cmpts, newwidth, newheight,
-		(GLushort *)srcImage, (GLushort *)dstImage, element_size,
-		rowsize, group_size, myswap_bytes);
-		break;
-	    case GL_SHORT:
-		halveImage_short(cmpts, newwidth, newheight,
-		(GLshort *)srcImage, (GLshort *)dstImage, element_size,
-		rowsize, group_size, myswap_bytes);
-		break;
-	    case GL_UNSIGNED_INT:
-		halveImage_uint(cmpts, newwidth, newheight,
-		(GLuint *)srcImage, (GLuint *)dstImage, element_size,
-		rowsize, group_size, myswap_bytes);
-		break;
-	    case GL_INT:
-		halveImage_int(cmpts, newwidth, newheight,
-		(GLint *)srcImage, (GLint *)dstImage, element_size,
-		rowsize, group_size, myswap_bytes);
-		break;
-	    case GL_FLOAT:
-		halveImage_float(cmpts, newwidth, newheight,
-		(GLfloat *)srcImage, (GLfloat *)dstImage, element_size,
-		rowsize, group_size, myswap_bytes);
-		break;
-	    case GL_UNSIGNED_BYTE_3_3_2:
-		halveImagePackedPixel(3,extract332,shove332,
-				      newwidth,newheight,
-				      srcImage,dstImage,element_size,rowsize,
-				      myswap_bytes);
-		break;
-	    case GL_UNSIGNED_BYTE_2_3_3_REV:
-		halveImagePackedPixel(3,extract233rev,shove233rev,
-				      newwidth,newheight,
-				      srcImage,dstImage,element_size,rowsize,
-				      myswap_bytes);
-		break;
-	    case GL_UNSIGNED_SHORT_5_6_5:
-		halveImagePackedPixel(3,extract565,shove565,
-				      newwidth,newheight,
-				      srcImage,dstImage,element_size,rowsize,
-				      myswap_bytes);
-		break;
-	    case GL_UNSIGNED_SHORT_5_6_5_REV:
-		halveImagePackedPixel(3,extract565rev,shove565rev,
-				      newwidth,newheight,
-				      srcImage,dstImage,element_size,rowsize,
-				      myswap_bytes);
-		break;
-	    case GL_UNSIGNED_SHORT_4_4_4_4:
-		halveImagePackedPixel(4,extract4444,shove4444,
-				      newwidth,newheight,
-				      srcImage,dstImage,element_size,rowsize,
-				      myswap_bytes);
-		break;
-	    case GL_UNSIGNED_SHORT_4_4_4_4_REV:
-		halveImagePackedPixel(4,extract4444rev,shove4444rev,
-				      newwidth,newheight,
-				      srcImage,dstImage,element_size,rowsize,
-				      myswap_bytes);
-		break;
-	    case GL_UNSIGNED_SHORT_5_5_5_1:	        
-		halveImagePackedPixel(4,extract5551,shove5551,
-				      newwidth,newheight,
-				      srcImage,dstImage,element_size,rowsize,
-				      myswap_bytes);
-		break;
-	    case GL_UNSIGNED_SHORT_1_5_5_5_REV: 	        
-		halveImagePackedPixel(4,extract1555rev,shove1555rev,
-				      newwidth,newheight,
-				      srcImage,dstImage,element_size,rowsize,
-				      myswap_bytes);
-		break;
-	    case GL_UNSIGNED_INT_8_8_8_8:
-		halveImagePackedPixel(4,extract8888,shove8888,
-				      newwidth,newheight,
-				      srcImage,dstImage,element_size,rowsize,
-				      myswap_bytes);
-		break;
-	    case GL_UNSIGNED_INT_8_8_8_8_REV:
-		halveImagePackedPixel(4,extract8888rev,shove8888rev,
-				      newwidth,newheight,
-				      srcImage,dstImage,element_size,rowsize,
-				      myswap_bytes);
-		break;
-	    case GL_UNSIGNED_INT_10_10_10_2:
-		halveImagePackedPixel(4,extract1010102,shove1010102,
-				      newwidth,newheight,
-				      srcImage,dstImage,element_size,rowsize,
-				      myswap_bytes);
-		break;
-	    case GL_UNSIGNED_INT_2_10_10_10_REV:
-		halveImagePackedPixel(4,extract2101010rev,shove2101010rev,
-				      newwidth,newheight,
-				      srcImage,dstImage,element_size,rowsize,
-				      myswap_bytes);
-		break;
-	    default:
-		assert(0);
-		break;
-	}
-
-	__GLU_SWAP_IMAGE(srcImage,dstImage);
-
-	if (newwidth > 1) { newwidth /= 2; rowsize /= 2;}
-	if (newheight > 1) newheight /= 2;
-      {
-       /* compute amount to pad per row, if any */
-       int rowPad= rowsize % psm.unpack_alignment;
-
-       /* should row be padded? */
-       if (rowPad == 0) {	/* nope, row should not be padded */
-	   /* call tex image with srcImage untouched since it's not padded */
-	   if (baseLevel <= level && level <= maxLevel) {
-	   glTexImage2D(target, level, internalFormat, newwidth, newheight, 0,
-	   format, type, (void *) srcImage);
-	   }
-       }
-       else {			/* yes, row should be padded */
-	  /* compute length of new row in bytes, including padding */
-	  int newRowLength= rowsize + psm.unpack_alignment - rowPad;
-	  int ii; unsigned char *dstTrav, *srcTrav; /* indices for copying */
-
-	  /* allocate new image for mipmap of size newRowLength x newheight */
-	  void *newMipmapImage= malloc((size_t) (newRowLength*newheight));
-	  if (newMipmapImage == NULL) {
-	     /* out of memory so return */
-	     glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
-	     glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
-	     glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
-	     glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
-	     glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
-	     return GLU_OUT_OF_MEMORY;
-	  }
-
-	  /* copy image from srcImage into newMipmapImage by rows */
-	  for (ii= 0,
-	       dstTrav= (unsigned char *) newMipmapImage,
-	       srcTrav= (unsigned char *) srcImage;
-	       ii< newheight;
-	       ii++,
-	       dstTrav+= newRowLength, /* make sure the correct distance... */
-	       srcTrav+= rowsize) {    /* ...is skipped */
-	     memcpy(dstTrav,srcTrav,rowsize);
-	     /* note that the pad bytes are not visited and will contain
-	      * garbage, which is ok.
-	      */
-	  }
-
-	  /* ...and use this new image for mipmapping instead */
-	  if (baseLevel <= level && level <= maxLevel) {
-	  glTexImage2D(target, level, internalFormat, newwidth, newheight, 0,
-		       format, type, newMipmapImage);
-	  }
-	  free(newMipmapImage); /* don't forget to free it! */
-       } /* else */
-      }
-    } /* for level */
-    glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
-    glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
-    glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
-    glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
-
-    free(srcImage); /*if you get to here, a srcImage has always been malloc'ed*/
-    if (dstImage) { /* if it's non-rectangular and only 1 level */
-      free(dstImage);
-    }
-    return 0;
-} /* gluBuild2DMipmapLevelsCore() */
-
-GLint GLAPIENTRY
-gluBuild2DMipmapLevels(GLenum target, GLint internalFormat,
-			     GLsizei width, GLsizei height,
-			     GLenum format, GLenum type,
-			     GLint userLevel, GLint baseLevel, GLint maxLevel,
-			     const void *data)
-{
-   int level, levels;
-
-   int rc= checkMipmapArgs(internalFormat,format,type);
-   if (rc != 0) return rc;
-
-   if (width < 1 || height < 1) {
-       return GLU_INVALID_VALUE;
-   }
-
-   levels = computeLog(width);
-   level = computeLog(height);
-   if (level > levels) levels=level;
-
-   levels+= userLevel;
-   if (!isLegalLevels(userLevel,baseLevel,maxLevel,levels))
-      return GLU_INVALID_VALUE;
-
-   return gluBuild2DMipmapLevelsCore(target, internalFormat,
-				     width, height,
-				     width, height,
-				     format, type,
-				     userLevel, baseLevel, maxLevel,
-				     data);
-} /* gluBuild2DMipmapLevels() */
-
-GLint GLAPIENTRY
-gluBuild2DMipmaps(GLenum target, GLint internalFormat,
-			GLsizei width, GLsizei height,
-			GLenum format, GLenum type,
-			const void *data)
-{
-   GLint widthPowerOf2, heightPowerOf2;
-   int level, levels;
-
-   int rc= checkMipmapArgs(internalFormat,format,type);
-   if (rc != 0) return rc;
-
-   if (width < 1 || height < 1) {
-       return GLU_INVALID_VALUE;
-   }
-
-   closestFit(target,width,height,internalFormat,format,type,
-	      &widthPowerOf2,&heightPowerOf2);
-
-   levels = computeLog(widthPowerOf2);
-   level = computeLog(heightPowerOf2);
-   if (level > levels) levels=level;
-
-   return gluBuild2DMipmapLevelsCore(target,internalFormat,
-				     width, height,
-				     widthPowerOf2,heightPowerOf2,
-				     format,type,
-				     0,0,levels,data);
-}  /* gluBuild2DMipmaps() */
-
-#if 0
-/*
-** This routine is for the limited case in which
-**	type == GL_UNSIGNED_BYTE && format != index  &&
-**	unpack_alignment = 1 && unpack_swap_bytes == false
-**
-** so all of the work data can be kept as ubytes instead of shorts.
-*/
-static int fastBuild2DMipmaps(const PixelStorageModes *psm,
-		       GLenum target, GLint components, GLint width,
-		     GLint height, GLenum format,
-		     GLenum type, void *data)
-{
-    GLint newwidth, newheight;
-    GLint level, levels;
-    GLubyte *newImage;
-    GLint newImage_width;
-    GLint newImage_height;
-    GLubyte *otherImage;
-    GLubyte *imageTemp;
-    GLint memreq;
-    GLint cmpts;
-
-
-#if 0
-    glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxsize);
-    newwidth = nearestPower(width);
-    if (newwidth > maxsize) newwidth = maxsize;
-    newheight = nearestPower(height);
-    if (newheight > maxsize) newheight = maxsize;
-#else
-    closestFit(target,width,height,components,format,type,
-	       &newwidth,&newheight);
-#endif
-    levels = computeLog(newwidth);
-    level = computeLog(newheight);
-    if (level > levels) levels=level;
-
-    cmpts = elements_per_group(format,type);
-
-    otherImage = NULL;
-    /**
-    ** No need to copy the user data if its in the packed correctly.
-    ** Make sure that later routines don't change that data.
-    */
-    if (psm->unpack_skip_rows == 0 && psm->unpack_skip_pixels == 0) {
-	newImage = (GLubyte *)data;
-	newImage_width = width;
-	newImage_height = height;
-    } else {
-	GLint rowsize;
-	GLint groups_per_line;
-	GLint elements_per_line;
-	const GLubyte *start;
-	const GLubyte *iter;
-	GLubyte *iter2;
-	GLint i, j;
-
-	newImage = (GLubyte *)
-	    malloc(image_size(width, height, format, GL_UNSIGNED_BYTE));
-	newImage_width = width;
-	newImage_height = height;
-	if (newImage == NULL) {
-	    return GLU_OUT_OF_MEMORY;
-	}
-
-	/*
-	** Abbreviated version of fill_image for this restricted case.
-	*/
-	if (psm->unpack_row_length > 0) {
-	    groups_per_line = psm->unpack_row_length;
-	} else {
-	    groups_per_line = width;
-	}
-	rowsize = groups_per_line * cmpts;
-	elements_per_line = width * cmpts;
-	start = (const GLubyte *) data + psm->unpack_skip_rows * rowsize +
-		psm->unpack_skip_pixels * cmpts;
-	iter2 = newImage;
-
-	for (i = 0; i < height; i++) {
-	    iter = start;
-	    for (j = 0; j < elements_per_line; j++) {
-		*iter2 = *iter;
-		iter++;
-		iter2++;
-	    }
-	    start += rowsize;
-	}
-    }
-
-
-    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-    glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
-    glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
-    glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE);
-
-    for (level = 0; level <= levels; level++) {
-	if (newImage_width == newwidth && newImage_height == newheight) {
-	    /* Use newImage for this level */
-	    glTexImage2D(target, level, components, newImage_width,
-		    newImage_height, 0, format, GL_UNSIGNED_BYTE,
-		    (void *) newImage);
-	} else {
-	    if (otherImage == NULL) {
-		memreq =
-		    image_size(newwidth, newheight, format, GL_UNSIGNED_BYTE);
-		otherImage = (GLubyte *) malloc(memreq);
-		if (otherImage == NULL) {
-		    glPixelStorei(GL_UNPACK_ALIGNMENT, psm->unpack_alignment);
-		    glPixelStorei(GL_UNPACK_SKIP_ROWS, psm->unpack_skip_rows);
-		    glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm->unpack_skip_pixels);
-		    glPixelStorei(GL_UNPACK_ROW_LENGTH,psm->unpack_row_length);
-		    glPixelStorei(GL_UNPACK_SWAP_BYTES,psm->unpack_swap_bytes);
-		    return GLU_OUT_OF_MEMORY;
-		}
-	    }
-/*
-	    scale_internal_ubyte(cmpts, newImage_width, newImage_height,
-		    newImage, newwidth, newheight, otherImage);
-*/
-	    /* Swap newImage and otherImage */
-	    imageTemp = otherImage;
-	    otherImage = newImage;
-	    newImage = imageTemp;
-
-	    newImage_width = newwidth;
-	    newImage_height = newheight;
-	    glTexImage2D(target, level, components, newImage_width,
-		    newImage_height, 0, format, GL_UNSIGNED_BYTE,
-		    (void *) newImage);
-	}
-	if (newwidth > 1) newwidth /= 2;
-	if (newheight > 1) newheight /= 2;
-    }
-    glPixelStorei(GL_UNPACK_ALIGNMENT, psm->unpack_alignment);
-    glPixelStorei(GL_UNPACK_SKIP_ROWS, psm->unpack_skip_rows);
-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm->unpack_skip_pixels);
-    glPixelStorei(GL_UNPACK_ROW_LENGTH, psm->unpack_row_length);
-    glPixelStorei(GL_UNPACK_SWAP_BYTES, psm->unpack_swap_bytes);
-
-    if (newImage != (const GLubyte *)data) {
-	free((GLbyte *) newImage);
-    }
-    if (otherImage && otherImage != (const GLubyte *)data) {
-	free((GLbyte *) otherImage);
-    }
-    return 0;
-}
-#endif
-
-/*
- * Utility Routines
- */
-static GLint elements_per_group(GLenum format, GLenum type)
-{
-    /*
-     * Return the number of elements per group of a specified format
-     */
-
-    /* If the type is packedpixels then answer is 1 (ignore format) */
-    if (type == GL_UNSIGNED_BYTE_3_3_2 ||
-	type == GL_UNSIGNED_BYTE_2_3_3_REV ||
-	type == GL_UNSIGNED_SHORT_5_6_5 ||
-	type == GL_UNSIGNED_SHORT_5_6_5_REV ||
-	type == GL_UNSIGNED_SHORT_4_4_4_4 ||
-	type == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
-	type == GL_UNSIGNED_SHORT_5_5_5_1  ||
-	type == GL_UNSIGNED_SHORT_1_5_5_5_REV  ||
-	type == GL_UNSIGNED_INT_8_8_8_8 ||
-	type == GL_UNSIGNED_INT_8_8_8_8_REV ||
-	type == GL_UNSIGNED_INT_10_10_10_2 ||
-	type == GL_UNSIGNED_INT_2_10_10_10_REV) {
-	return 1;
-    }
-
-    /* Types are not packed pixels, so get elements per group */
-    switch(format) {
-      case GL_RGB:
-      case GL_BGR:
-	return 3;
-      case GL_LUMINANCE_ALPHA:
-	return 2;
-      case GL_RGBA:
-      case GL_BGRA:
-	return 4;
-      default:
-	return 1;
-    }
-}
-
-static GLfloat bytes_per_element(GLenum type)
-{
-    /*
-     * Return the number of bytes per element, based on the element type
-     */
-    switch(type) {
-      case GL_BITMAP:
-	return 1.0 / 8.0;
-      case GL_UNSIGNED_SHORT:
-	return(sizeof(GLushort));
-      case GL_SHORT:
-	return(sizeof(GLshort));
-      case GL_UNSIGNED_BYTE:
-	return(sizeof(GLubyte));
-      case GL_BYTE:
-	return(sizeof(GLbyte));
-      case GL_INT:
-	return(sizeof(GLint));
-      case GL_UNSIGNED_INT:
-	return(sizeof(GLuint));
-      case GL_FLOAT:
-	return(sizeof(GLfloat));
-      case GL_UNSIGNED_BYTE_3_3_2:
-      case GL_UNSIGNED_BYTE_2_3_3_REV:  
-	return(sizeof(GLubyte));
-      case GL_UNSIGNED_SHORT_5_6_5:
-      case GL_UNSIGNED_SHORT_5_6_5_REV:
-      case GL_UNSIGNED_SHORT_4_4_4_4:
-      case GL_UNSIGNED_SHORT_4_4_4_4_REV:
-      case GL_UNSIGNED_SHORT_5_5_5_1:
-      case GL_UNSIGNED_SHORT_1_5_5_5_REV:
-	return(sizeof(GLushort));
-      case GL_UNSIGNED_INT_8_8_8_8:
-      case GL_UNSIGNED_INT_8_8_8_8_REV:
-      case GL_UNSIGNED_INT_10_10_10_2:
-      case GL_UNSIGNED_INT_2_10_10_10_REV:
-	return(sizeof(GLuint));
-      default:
-	return 4;
-    }
-}
-
-static GLint is_index(GLenum format)
-{
-    return format == GL_COLOR_INDEX || format == GL_STENCIL_INDEX;
-}
-
-/*
-** Compute memory required for internal packed array of data of given type
-** and format.
-*/
-static GLint image_size(GLint width, GLint height, GLenum format, GLenum type)
-{
-    int bytes_per_row;
-    int components;
-
-assert(width > 0);
-assert(height > 0);
-    components = elements_per_group(format,type);
-    if (type == GL_BITMAP) {
-	bytes_per_row = (width + 7) / 8;
-    } else {
-	bytes_per_row = bytes_per_element(type) * width;
-    }
-    return bytes_per_row * height * components;
-}
-
-/*
-** Extract array from user's data applying all pixel store modes.
-** The internal format used is an array of unsigned shorts.
-*/
-static void fill_image(const PixelStorageModes *psm,
-		       GLint width, GLint height, GLenum format,
-		       GLenum type, GLboolean index_format,
-		       const void *userdata, GLushort *newimage)
-{
-    GLint components;
-    GLint element_size;
-    GLint rowsize;
-    GLint padding;
-    GLint groups_per_line;
-    GLint group_size;
-    GLint elements_per_line;
-    const GLubyte *start;
-    const GLubyte *iter;
-    GLushort *iter2;
-    GLint i, j, k;
-    GLint myswap_bytes;
-
-    myswap_bytes = psm->unpack_swap_bytes;
-    components = elements_per_group(format,type);
-    if (psm->unpack_row_length > 0) {
-	groups_per_line = psm->unpack_row_length;
-    } else {
-	groups_per_line = width;
-    }
-
-    /* All formats except GL_BITMAP fall out trivially */
-    if (type == GL_BITMAP) {
-	GLint bit_offset;
-	GLint current_bit;
-
-	rowsize = (groups_per_line * components + 7) / 8;
-	padding = (rowsize % psm->unpack_alignment);
-	if (padding) {
-	    rowsize += psm->unpack_alignment - padding;
-	}
-	start = (const GLubyte *) userdata + psm->unpack_skip_rows * rowsize +
-		(psm->unpack_skip_pixels * components / 8);
-	elements_per_line = width * components;
-	iter2 = newimage;
-	for (i = 0; i < height; i++) {
-	    iter = start;
-	    bit_offset = (psm->unpack_skip_pixels * components) % 8;
-	    for (j = 0; j < elements_per_line; j++) {
-		/* Retrieve bit */
-		if (psm->unpack_lsb_first) {
-		    current_bit = iter[0] & (1 << bit_offset);
-		} else {
-		    current_bit = iter[0] & (1 << (7 - bit_offset));
-		}
-		if (current_bit) {
-		    if (index_format) {
-			*iter2 = 1;
-		    } else {
-			*iter2 = 65535;
-		    }
-		} else {
-		    *iter2 = 0;
-		}
-		bit_offset++;
-		if (bit_offset == 8) {
-		    bit_offset = 0;
-		    iter++;
-		}
-		iter2++;
-	    }
-	    start += rowsize;
-	}
-    } else {
-	element_size = bytes_per_element(type);
-	group_size = element_size * components;
-	if (element_size == 1) myswap_bytes = 0;
-
-	rowsize = groups_per_line * group_size;
-	padding = (rowsize % psm->unpack_alignment);
-	if (padding) {
-	    rowsize += psm->unpack_alignment - padding;
-	}
-	start = (const GLubyte *) userdata + psm->unpack_skip_rows * rowsize +
-		psm->unpack_skip_pixels * group_size;
-	elements_per_line = width * components;
-
-	iter2 = newimage;
-	for (i = 0; i < height; i++) {
-	    iter = start;
-	    for (j = 0; j < elements_per_line; j++) {
-		Type_Widget widget;
-		float extractComponents[4];
-
-		switch(type) {
-		  case GL_UNSIGNED_BYTE_3_3_2:
-		    extract332(0,iter,extractComponents);
-		    for (k = 0; k < 3; k++) {
-		      *iter2++ = (GLushort)(extractComponents[k]*65535);
-		    }
-		    break;
-		  case GL_UNSIGNED_BYTE_2_3_3_REV:
-		    extract233rev(0,iter,extractComponents);
-		    for (k = 0; k < 3; k++) {
-		      *iter2++ = (GLushort)(extractComponents[k]*65535);
-		    }
-		    break;
-		  case GL_UNSIGNED_BYTE:
-		    if (index_format) {
-			*iter2++ = *iter;
-		    } else {
-			*iter2++ = (*iter) * 257;
-		    }
-		    break;
-		  case GL_BYTE:
-		    if (index_format) {
-			*iter2++ = *((const GLbyte *) iter);
-		    } else {
-			/* rough approx */
-			*iter2++ = (*((const GLbyte *) iter)) * 516;
-		    }
-		    break;
-		  case GL_UNSIGNED_SHORT_5_6_5: 		        
-		    extract565(myswap_bytes,iter,extractComponents);
-		    for (k = 0; k < 3; k++) {
-		      *iter2++ = (GLushort)(extractComponents[k]*65535);
-		    }
-		    break;
-		  case GL_UNSIGNED_SHORT_5_6_5_REV:		        
-		    extract565rev(myswap_bytes,iter,extractComponents);
-		    for (k = 0; k < 3; k++) {
-		      *iter2++ = (GLushort)(extractComponents[k]*65535);
-		    }
-		    break;
-		  case GL_UNSIGNED_SHORT_4_4_4_4:	        
-		    extract4444(myswap_bytes,iter,extractComponents);
-		    for (k = 0; k < 4; k++) {
-		      *iter2++ = (GLushort)(extractComponents[k]*65535);
-		    }
-		    break;
-		  case GL_UNSIGNED_SHORT_4_4_4_4_REV:	        
-		    extract4444rev(myswap_bytes,iter,extractComponents);
-		    for (k = 0; k < 4; k++) {
-		      *iter2++ = (GLushort)(extractComponents[k]*65535);
-		    }
-		    break;
-		  case GL_UNSIGNED_SHORT_5_5_5_1:	        
-		    extract5551(myswap_bytes,iter,extractComponents);
-		    for (k = 0; k < 4; k++) {
-		      *iter2++ = (GLushort)(extractComponents[k]*65535);
-		    }
-		    break;
-		  case GL_UNSIGNED_SHORT_1_5_5_5_REV:
-		    extract1555rev(myswap_bytes,iter,extractComponents);
-		    for (k = 0; k < 4; k++) {
-		      *iter2++ = (GLushort)(extractComponents[k]*65535);
-		    }
-		    break;
-		  case GL_UNSIGNED_SHORT:
-		  case GL_SHORT:
-		    if (myswap_bytes) {
-			widget.ub[0] = iter[1];
-			widget.ub[1] = iter[0];
-		    } else {
-			widget.ub[0] = iter[0];
-			widget.ub[1] = iter[1];
-		    }
-		    if (type == GL_SHORT) {
-			if (index_format) {
-			    *iter2++ = widget.s[0];
-			} else {
-			    /* rough approx */
-			    *iter2++ = widget.s[0]*2;
-			}
-		    } else {
-			*iter2++ = widget.us[0];
-		    }
-		    break;
-		  case GL_UNSIGNED_INT_8_8_8_8:         
-		    extract8888(myswap_bytes,iter,extractComponents);
-		    for (k = 0; k < 4; k++) {
-		      *iter2++ = (GLushort)(extractComponents[k]*65535);
-		    }
-		    break;
-		  case GL_UNSIGNED_INT_8_8_8_8_REV:	        
-		    extract8888rev(myswap_bytes,iter,extractComponents);
-		    for (k = 0; k < 4; k++) {
-		      *iter2++ = (GLushort)(extractComponents[k]*65535);
-		    }
-		    break;
-		  case GL_UNSIGNED_INT_10_10_10_2:	        
-		    extract1010102(myswap_bytes,iter,extractComponents);
-		    for (k = 0; k < 4; k++) {
-		      *iter2++ = (GLushort)(extractComponents[k]*65535);
-		    }
-		    break;
-		  case GL_UNSIGNED_INT_2_10_10_10_REV:
-		    extract2101010rev(myswap_bytes,iter,extractComponents);
-		    for (k = 0; k < 4; k++) {
-		      *iter2++ = (GLushort)(extractComponents[k]*65535);
-		    }
-		    break;
-		  case GL_INT:
-		  case GL_UNSIGNED_INT:
-		  case GL_FLOAT:
-		    if (myswap_bytes) {
-			widget.ub[0] = iter[3];
-			widget.ub[1] = iter[2];
-			widget.ub[2] = iter[1];
-			widget.ub[3] = iter[0];
-		    } else {
-			widget.ub[0] = iter[0];
-			widget.ub[1] = iter[1];
-			widget.ub[2] = iter[2];
-			widget.ub[3] = iter[3];
-		    }
-		    if (type == GL_FLOAT) {
-			if (index_format) {
-			    *iter2++ = widget.f;
-			} else {
-			    *iter2++ = 65535 * widget.f;
-			}
-		    } else if (type == GL_UNSIGNED_INT) {
-			if (index_format) {
-			    *iter2++ = widget.ui;
-			} else {
-			    *iter2++ = widget.ui >> 16;
-			}
-		    } else {
-			if (index_format) {
-			    *iter2++ = widget.i;
-			} else {
-			    *iter2++ = widget.i >> 15;
-			}
-		    }
-		    break;
-		}
-		iter += element_size;
-	    } /* for j */
-	    start += rowsize;
-#if 1
-	    /* want 'iter' pointing at start, not within, row for assertion
-	     * purposes
-	     */
-	    iter= start;        
-#endif
-	} /* for i */
-
-       /* iterators should be one byte past end */
-       if (!isTypePackedPixel(type)) {
-	  assert(iter2 == &newimage[width*height*components]);
-       }
-       else {
-	  assert(iter2 == &newimage[width*height*
-				    elements_per_group(format,0)]);
-       }
-       assert( iter == &((const GLubyte *)userdata)[rowsize*height +
-					psm->unpack_skip_rows * rowsize +
-					psm->unpack_skip_pixels * group_size] );
-
-    } /* else */
-} /* fill_image() */
-
-/*
-** Insert array into user's data applying all pixel store modes.
-** The internal format is an array of unsigned shorts.
-** empty_image() because it is the opposite of fill_image().
-*/
-static void empty_image(const PixelStorageModes *psm,
-			GLint width, GLint height, GLenum format,
-			GLenum type, GLboolean index_format,
-			const GLushort *oldimage, void *userdata)
-{
-    GLint components;
-    GLint element_size;
-    GLint rowsize;
-    GLint padding;
-    GLint groups_per_line;
-    GLint group_size;
-    GLint elements_per_line;
-    GLubyte *start;
-    GLubyte *iter;
-    const GLushort *iter2;
-    GLint i, j, k;
-    GLint myswap_bytes;
-
-    myswap_bytes = psm->pack_swap_bytes;
-    components = elements_per_group(format,type);
-    if (psm->pack_row_length > 0) {
-	groups_per_line = psm->pack_row_length;
-    } else {
-	groups_per_line = width;
-    }
-
-    /* All formats except GL_BITMAP fall out trivially */
-    if (type == GL_BITMAP) {
-	GLint bit_offset;
-	GLint current_bit;
-
-	rowsize = (groups_per_line * components + 7) / 8;
-	padding = (rowsize % psm->pack_alignment);
-	if (padding) {
-	    rowsize += psm->pack_alignment - padding;
-	}
-	start = (GLubyte *) userdata + psm->pack_skip_rows * rowsize +
-		(psm->pack_skip_pixels * components / 8);
-	elements_per_line = width * components;
-	iter2 = oldimage;
-	for (i = 0; i < height; i++) {
-	    iter = start;
-	    bit_offset = (psm->pack_skip_pixels * components) % 8;
-	    for (j = 0; j < elements_per_line; j++) {
-		if (index_format) {
-		    current_bit = iter2[0] & 1;
-		} else {
-		    if (iter2[0] > 32767) {
-			current_bit = 1;
-		    } else {
-			current_bit = 0;
-		    }
-		}
-
-		if (current_bit) {
-		    if (psm->pack_lsb_first) {
-			*iter |= (1 << bit_offset);
-		    } else {
-			*iter |= (1 << (7 - bit_offset));
-		    }
-		} else {
-		    if (psm->pack_lsb_first) {
-			*iter &= ~(1 << bit_offset);
-		    } else {
-			*iter &= ~(1 << (7 - bit_offset));
-		    }
-		}
-
-		bit_offset++;
-		if (bit_offset == 8) {
-		    bit_offset = 0;
-		    iter++;
-		}
-		iter2++;
-	    }
-	    start += rowsize;
-	}
-    } else {
-	float shoveComponents[4];
-
-	element_size = bytes_per_element(type);
-	group_size = element_size * components;
-	if (element_size == 1) myswap_bytes = 0;
-
-	rowsize = groups_per_line * group_size;
-	padding = (rowsize % psm->pack_alignment);
-	if (padding) {
-	    rowsize += psm->pack_alignment - padding;
-	}
-	start = (GLubyte *) userdata + psm->pack_skip_rows * rowsize +
-		psm->pack_skip_pixels * group_size;
-	elements_per_line = width * components;
-
-	iter2 = oldimage;
-	for (i = 0; i < height; i++) {
-	    iter = start;
-	    for (j = 0; j < elements_per_line; j++) {
-		Type_Widget widget;
-
-		switch(type) {
-		  case GL_UNSIGNED_BYTE_3_3_2:
-		    for (k = 0; k < 3; k++) {
-		       shoveComponents[k]= *iter2++ / 65535.0;
-		    }
-		    shove332(shoveComponents,0,(void *)iter);
-		    break;
-		  case GL_UNSIGNED_BYTE_2_3_3_REV:
-		    for (k = 0; k < 3; k++) {
-		       shoveComponents[k]= *iter2++ / 65535.0;
-		    }
-		    shove233rev(shoveComponents,0,(void *)iter);
-		    break;
-		  case GL_UNSIGNED_BYTE:
-		    if (index_format) {
-			*iter = *iter2++;
-		    } else {
-			*iter = *iter2++ >> 8;
-		    }
-		    break;
-		  case GL_BYTE:
-		    if (index_format) {
-			*((GLbyte *) iter) = *iter2++;
-		    } else {
-			*((GLbyte *) iter) = *iter2++ >> 9;
-		    }
-		    break;
-		  case GL_UNSIGNED_SHORT_5_6_5:         
-		    for (k = 0; k < 3; k++) {
-		       shoveComponents[k]= *iter2++ / 65535.0;
-		    }
-		    shove565(shoveComponents,0,(void *)&widget.us[0]);
-		    if (myswap_bytes) {
-		       iter[0] = widget.ub[1];
-		       iter[1] = widget.ub[0];
-		    }
-		    else {
-		       *(GLushort *)iter = widget.us[0];
-		    }
-		    break;
-		  case GL_UNSIGNED_SHORT_5_6_5_REV:	        
-		    for (k = 0; k < 3; k++) {
-		       shoveComponents[k]= *iter2++ / 65535.0;
-		    }
-		    shove565rev(shoveComponents,0,(void *)&widget.us[0]);
-		    if (myswap_bytes) {
-		       iter[0] = widget.ub[1];
-		       iter[1] = widget.ub[0];
-		    }
-		    else {
-		       *(GLushort *)iter = widget.us[0];
-		    }
-		    break;
-		  case GL_UNSIGNED_SHORT_4_4_4_4:
-		    for (k = 0; k < 4; k++) {
-		       shoveComponents[k]= *iter2++ / 65535.0;
-		    }
-		    shove4444(shoveComponents,0,(void *)&widget.us[0]);
-		    if (myswap_bytes) {
-		       iter[0] = widget.ub[1];
-		       iter[1] = widget.ub[0];
-		    } else {
-		       *(GLushort *)iter = widget.us[0];
-		    }
-		    break;
-		  case GL_UNSIGNED_SHORT_4_4_4_4_REV:
-		    for (k = 0; k < 4; k++) {
-		       shoveComponents[k]= *iter2++ / 65535.0;
-		    }
-		    shove4444rev(shoveComponents,0,(void *)&widget.us[0]);
-		    if (myswap_bytes) {
-		       iter[0] = widget.ub[1];
-		       iter[1] = widget.ub[0];
-		    } else {
-		       *(GLushort *)iter = widget.us[0];
-		    }
-		    break;
-		  case GL_UNSIGNED_SHORT_5_5_5_1:
-		    for (k = 0; k < 4; k++) {
-		       shoveComponents[k]= *iter2++ / 65535.0;
-		    }
-		    shove5551(shoveComponents,0,(void *)&widget.us[0]);
-		    if (myswap_bytes) {
-		       iter[0] = widget.ub[1];
-		       iter[1] = widget.ub[0];
-		    } else {
-		       *(GLushort *)iter = widget.us[0];
-		    }
-		    break;
-		  case GL_UNSIGNED_SHORT_1_5_5_5_REV:
-		    for (k = 0; k < 4; k++) {
-		       shoveComponents[k]= *iter2++ / 65535.0;
-		    }
-		    shove1555rev(shoveComponents,0,(void *)&widget.us[0]);
-		    if (myswap_bytes) {
-		       iter[0] = widget.ub[1];
-		       iter[1] = widget.ub[0];
-		    } else {
-		       *(GLushort *)iter = widget.us[0];
-		    }
-		    break;
-		  case GL_UNSIGNED_SHORT:
-		  case GL_SHORT:
-		    if (type == GL_SHORT) {
-			if (index_format) {
-			    widget.s[0] = *iter2++;
-			} else {
-			    widget.s[0] = *iter2++ >> 1;
-			}
-		    } else {
-			widget.us[0] = *iter2++;
-		    }
-		    if (myswap_bytes) {
-			iter[0] = widget.ub[1];
-			iter[1] = widget.ub[0];
-		    } else {
-			iter[0] = widget.ub[0];
-			iter[1] = widget.ub[1];
-		    }
-		    break;
-		  case GL_UNSIGNED_INT_8_8_8_8:
-		    for (k = 0; k < 4; k++) {
-		       shoveComponents[k]= *iter2++ / 65535.0;
-		    }
-		    shove8888(shoveComponents,0,(void *)&widget.ui);
-		    if (myswap_bytes) {
-			iter[3] = widget.ub[0];
-			iter[2] = widget.ub[1];
-			iter[1] = widget.ub[2];
-			iter[0] = widget.ub[3];
-		    } else {
-			*(GLuint *)iter= widget.ui;
-		    }
-
-		    break;
-		  case GL_UNSIGNED_INT_8_8_8_8_REV:
-		    for (k = 0; k < 4; k++) {
-		       shoveComponents[k]= *iter2++ / 65535.0;
-		    }
-		    shove8888rev(shoveComponents,0,(void *)&widget.ui);
-		    if (myswap_bytes) {
-			iter[3] = widget.ub[0];
-			iter[2] = widget.ub[1];
-			iter[1] = widget.ub[2];
-			iter[0] = widget.ub[3];
-		    } else {
-			*(GLuint *)iter= widget.ui;
-		    }
-		    break;
-		  case GL_UNSIGNED_INT_10_10_10_2:
-		    for (k = 0; k < 4; k++) {
-		       shoveComponents[k]= *iter2++ / 65535.0;
-		    }
-		    shove1010102(shoveComponents,0,(void *)&widget.ui);
-		    if (myswap_bytes) {
-			iter[3] = widget.ub[0];
-			iter[2] = widget.ub[1];
-			iter[1] = widget.ub[2];
-			iter[0] = widget.ub[3];
-		    } else {
-			*(GLuint *)iter= widget.ui;
-		    }
-		    break;
-		  case GL_UNSIGNED_INT_2_10_10_10_REV:
-		    for (k = 0; k < 4; k++) {
-		       shoveComponents[k]= *iter2++ / 65535.0;
-		    }
-		    shove2101010rev(shoveComponents,0,(void *)&widget.ui);
-		    if (myswap_bytes) {
-			iter[3] = widget.ub[0];
-			iter[2] = widget.ub[1];
-			iter[1] = widget.ub[2];
-			iter[0] = widget.ub[3];
-		    } else {
-			*(GLuint *)iter= widget.ui;
-		    }
-		    break;
-		  case GL_INT:
-		  case GL_UNSIGNED_INT:
-		  case GL_FLOAT:
-		    if (type == GL_FLOAT) {
-			if (index_format) {
-			    widget.f = *iter2++;
-			} else {
-			    widget.f = *iter2++ / (float) 65535.0;
-			}
-		    } else if (type == GL_UNSIGNED_INT) {
-			if (index_format) {
-			    widget.ui = *iter2++;
-			} else {
-			    widget.ui = (unsigned int) *iter2++ * 65537;
-			}
-		    } else {
-			if (index_format) {
-			    widget.i = *iter2++;
-			} else {
-			    widget.i = ((unsigned int) *iter2++ * 65537)/2;
-			}
-		    }
-		    if (myswap_bytes) {
-			iter[3] = widget.ub[0];
-			iter[2] = widget.ub[1];
-			iter[1] = widget.ub[2];
-			iter[0] = widget.ub[3];
-		    } else {
-			iter[0] = widget.ub[0];
-			iter[1] = widget.ub[1];
-			iter[2] = widget.ub[2];
-			iter[3] = widget.ub[3];
-		    }
-		    break;
-		}
-		iter += element_size;
-	    } /* for j */
-	    start += rowsize;
-#if 1
-	    /* want 'iter' pointing at start, not within, row for assertion
-	     * purposes
-	     */
-	    iter= start;        
-#endif
-	} /* for i */
-
-	/* iterators should be one byte past end */
-	if (!isTypePackedPixel(type)) {
-	   assert(iter2 == &oldimage[width*height*components]);
-	}
-	else {
-	   assert(iter2 == &oldimage[width*height*
-				     elements_per_group(format,0)]);
-	}
-	assert( iter == &((GLubyte *)userdata)[rowsize*height +
-					psm->pack_skip_rows * rowsize +
-					psm->pack_skip_pixels * group_size] );
-
-    } /* else */
-} /* empty_image() */
-
-/*--------------------------------------------------------------------------
- * Decimation of packed pixel types
- *--------------------------------------------------------------------------
- */
-static void extract332(int isSwap,
-		       const void *packedPixel, GLfloat extractComponents[])
-{
-   GLubyte ubyte= *(const GLubyte *)packedPixel;
-
-   isSwap= isSwap;		/* turn off warnings */
-
-   /* 11100000 == 0xe0 */
-   /* 00011100 == 0x1c */
-   /* 00000011 == 0x03 */
-
-   extractComponents[0]=   (float)((ubyte & 0xe0)  >> 5) / 7.0;
-   extractComponents[1]=   (float)((ubyte & 0x1c)  >> 2) / 7.0; /* 7 = 2^3-1 */
-   extractComponents[2]=   (float)((ubyte & 0x03)      ) / 3.0; /* 3 = 2^2-1 */
-} /* extract332() */
-
-static void shove332(const GLfloat shoveComponents[],
-		     int index, void *packedPixel)      
-{
-   /* 11100000 == 0xe0 */
-   /* 00011100 == 0x1c */
-   /* 00000011 == 0x03 */
-
-   assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);
-   assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);
-   assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);
-
-   /* due to limited precision, need to round before shoving */
-   ((GLubyte *)packedPixel)[index]  =
-     ((GLubyte)((shoveComponents[0] * 7)+0.5)  << 5) & 0xe0;
-   ((GLubyte *)packedPixel)[index] |=
-     ((GLubyte)((shoveComponents[1] * 7)+0.5)  << 2) & 0x1c;
-   ((GLubyte *)packedPixel)[index]  |=
-     ((GLubyte)((shoveComponents[2] * 3)+0.5)	   ) & 0x03;
-} /* shove332() */
-
-static void extract233rev(int isSwap,
-			  const void *packedPixel, GLfloat extractComponents[])
-{
-   GLubyte ubyte= *(const GLubyte *)packedPixel;
-
-   isSwap= isSwap;		/* turn off warnings */
-
-   /* 0000,0111 == 0x07 */
-   /* 0011,1000 == 0x38 */
-   /* 1100,0000 == 0xC0 */
-
-   extractComponents[0]= (float)((ubyte & 0x07)     ) / 7.0;
-   extractComponents[1]= (float)((ubyte & 0x38) >> 3) / 7.0;
-   extractComponents[2]= (float)((ubyte & 0xC0) >> 6) / 3.0;
-} /* extract233rev() */
-
-static void shove233rev(const GLfloat shoveComponents[],
-			int index, void *packedPixel)   
-{
-   /* 0000,0111 == 0x07 */
-   /* 0011,1000 == 0x38 */
-   /* 1100,0000 == 0xC0 */
-
-   assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);
-   assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);
-   assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);
-
-   /* due to limited precision, need to round before shoving */
-   ((GLubyte *)packedPixel)[index] =
-     ((GLubyte)((shoveComponents[0] * 7.0)+0.5)     ) & 0x07;
-   ((GLubyte *)packedPixel)[index]|=
-     ((GLubyte)((shoveComponents[1] * 7.0)+0.5) << 3) & 0x38;
-   ((GLubyte *)packedPixel)[index]|=
-     ((GLubyte)((shoveComponents[2] * 3.0)+0.5) << 6) & 0xC0;
-} /* shove233rev() */
-
-static void extract565(int isSwap,
-		       const void *packedPixel, GLfloat extractComponents[])
-{
-   GLushort ushort;
-
-   if (isSwap) {
-     ushort= __GLU_SWAP_2_BYTES(packedPixel);
-   }
-   else {
-     ushort= *(const GLushort *)packedPixel;
-   }
-
-   /* 11111000,00000000 == 0xf800 */
-   /* 00000111,11100000 == 0x07e0 */
-   /* 00000000,00011111 == 0x001f */
-
-   extractComponents[0]=(float)((ushort & 0xf800) >> 11) / 31.0;/* 31 = 2^5-1*/
-   extractComponents[1]=(float)((ushort & 0x07e0) >>  5) / 63.0;/* 63 = 2^6-1*/
-   extractComponents[2]=(float)((ushort & 0x001f)      ) / 31.0;
-} /* extract565() */
-
-static void shove565(const GLfloat shoveComponents[],
-		     int index,void *packedPixel)
-{
-   /* 11111000,00000000 == 0xf800 */
-   /* 00000111,11100000 == 0x07e0 */
-   /* 00000000,00011111 == 0x001f */
-
-   assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);
-   assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);
-   assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);
-
-   /* due to limited precision, need to round before shoving */
-   ((GLushort *)packedPixel)[index] =
-     ((GLushort)((shoveComponents[0] * 31)+0.5) << 11) & 0xf800;
-   ((GLushort *)packedPixel)[index]|=
-     ((GLushort)((shoveComponents[1] * 63)+0.5) <<  5) & 0x07e0;
-   ((GLushort *)packedPixel)[index]|=
-     ((GLushort)((shoveComponents[2] * 31)+0.5)      ) & 0x001f;
-} /* shove565() */
-
-static void extract565rev(int isSwap,
-			  const void *packedPixel, GLfloat extractComponents[])
-{
-   GLushort ushort;
-
-   if (isSwap) {
-     ushort= __GLU_SWAP_2_BYTES(packedPixel);
-   }
-   else {
-     ushort= *(const GLushort *)packedPixel;
-   }
-
-   /* 00000000,00011111 == 0x001f */
-   /* 00000111,11100000 == 0x07e0 */
-   /* 11111000,00000000 == 0xf800 */
-
-   extractComponents[0]= (float)((ushort & 0x001F)	) / 31.0;
-   extractComponents[1]= (float)((ushort & 0x07E0) >>  5) / 63.0;
-   extractComponents[2]= (float)((ushort & 0xF800) >> 11) / 31.0;
-} /* extract565rev() */
-
-static void shove565rev(const GLfloat shoveComponents[],
-			int index,void *packedPixel)
-{
-   /* 00000000,00011111 == 0x001f */
-   /* 00000111,11100000 == 0x07e0 */
-   /* 11111000,00000000 == 0xf800 */
-
-   assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);
-   assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);
-   assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);
-
-   /* due to limited precision, need to round before shoving */
-   ((GLushort *)packedPixel)[index] =
-     ((GLushort)((shoveComponents[0] * 31.0)+0.5)      ) & 0x001F;
-   ((GLushort *)packedPixel)[index]|=
-     ((GLushort)((shoveComponents[1] * 63.0)+0.5) <<  5) & 0x07E0;
-   ((GLushort *)packedPixel)[index]|=
-     ((GLushort)((shoveComponents[2] * 31.0)+0.5) << 11) & 0xF800;
-} /* shove565rev() */
-
-static void extract4444(int isSwap,const void *packedPixel,
-			GLfloat extractComponents[])
-{
-   GLushort ushort;
-
-   if (isSwap) {
-     ushort= __GLU_SWAP_2_BYTES(packedPixel);
-   }
-   else {
-     ushort= *(const GLushort *)packedPixel;
-   }
-
-   /* 11110000,00000000 == 0xf000 */
-   /* 00001111,00000000 == 0x0f00 */
-   /* 00000000,11110000 == 0x00f0 */
-   /* 00000000,00001111 == 0x000f */
-
-   extractComponents[0]= (float)((ushort & 0xf000) >> 12) / 15.0;/* 15=2^4-1 */
-   extractComponents[1]= (float)((ushort & 0x0f00) >>  8) / 15.0;
-   extractComponents[2]= (float)((ushort & 0x00f0) >>  4) / 15.0;
-   extractComponents[3]= (float)((ushort & 0x000f)	) / 15.0;
-} /* extract4444() */
-
-static void shove4444(const GLfloat shoveComponents[],
-		      int index,void *packedPixel)
-{
-   assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);
-   assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);
-   assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);
-   assert(0.0 <= shoveComponents[3] && shoveComponents[3] <= 1.0);
-
-   /* due to limited precision, need to round before shoving */
-   ((GLushort *)packedPixel)[index] =
-     ((GLushort)((shoveComponents[0] * 15)+0.5) << 12) & 0xf000;
-   ((GLushort *)packedPixel)[index]|=
-     ((GLushort)((shoveComponents[1] * 15)+0.5) <<  8) & 0x0f00;
-   ((GLushort *)packedPixel)[index]|=
-     ((GLushort)((shoveComponents[2] * 15)+0.5) <<  4) & 0x00f0;
-   ((GLushort *)packedPixel)[index]|=
-     ((GLushort)((shoveComponents[3] * 15)+0.5)      ) & 0x000f;
-} /* shove4444() */
-
-static void extract4444rev(int isSwap,const void *packedPixel,
-			   GLfloat extractComponents[])
-{
-   GLushort ushort;
-
-   if (isSwap) {
-     ushort= __GLU_SWAP_2_BYTES(packedPixel);
-   }
-   else {
-     ushort= *(const GLushort *)packedPixel;
-   }
-
-   /* 00000000,00001111 == 0x000f */
-   /* 00000000,11110000 == 0x00f0 */
-   /* 00001111,00000000 == 0x0f00 */
-   /* 11110000,00000000 == 0xf000 */
-
-   /* 15 = 2^4-1 */
-   extractComponents[0]= (float)((ushort & 0x000F)	) / 15.0;
-   extractComponents[1]= (float)((ushort & 0x00F0) >>  4) / 15.0;
-   extractComponents[2]= (float)((ushort & 0x0F00) >>  8) / 15.0;
-   extractComponents[3]= (float)((ushort & 0xF000) >> 12) / 15.0;
-} /* extract4444rev() */
-
-static void shove4444rev(const GLfloat shoveComponents[],
-			 int index,void *packedPixel)
-{
-   /* 00000000,00001111 == 0x000f */
-   /* 00000000,11110000 == 0x00f0 */
-   /* 00001111,00000000 == 0x0f00 */
-   /* 11110000,00000000 == 0xf000 */
-
-   assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);
-   assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);
-   assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);
-   assert(0.0 <= shoveComponents[3] && shoveComponents[3] <= 1.0);
-
-   /* due to limited precision, need to round before shoving */
-   ((GLushort *)packedPixel)[index] =
-     ((GLushort)((shoveComponents[0] * 15)+0.5)      ) & 0x000F;
-   ((GLushort *)packedPixel)[index]|=
-     ((GLushort)((shoveComponents[1] * 15)+0.5) <<  4) & 0x00F0;
-   ((GLushort *)packedPixel)[index]|=
-     ((GLushort)((shoveComponents[2] * 15)+0.5) <<  8) & 0x0F00;
-   ((GLushort *)packedPixel)[index]|=
-     ((GLushort)((shoveComponents[3] * 15)+0.5) << 12) & 0xF000;
-} /* shove4444rev() */
-
-static void extract5551(int isSwap,const void *packedPixel,
-			GLfloat extractComponents[])
-{
-   GLushort ushort;
-
-   if (isSwap) {
-     ushort= __GLU_SWAP_2_BYTES(packedPixel);
-   }
-   else {
-     ushort= *(const GLushort *)packedPixel;
-   }
-
-   /* 11111000,00000000 == 0xf800 */
-   /* 00000111,11000000 == 0x07c0 */
-   /* 00000000,00111110 == 0x003e */
-   /* 00000000,00000001 == 0x0001 */
-
-   extractComponents[0]=(float)((ushort & 0xf800) >> 11) / 31.0;/* 31 = 2^5-1*/
-   extractComponents[1]=(float)((ushort & 0x07c0) >>  6) / 31.0;
-   extractComponents[2]=(float)((ushort & 0x003e) >>  1) / 31.0;
-   extractComponents[3]=(float)((ushort & 0x0001)      );
-} /* extract5551() */
-
-static void shove5551(const GLfloat shoveComponents[],
-		      int index,void *packedPixel)
-{
-   /* 11111000,00000000 == 0xf800 */
-   /* 00000111,11000000 == 0x07c0 */
-   /* 00000000,00111110 == 0x003e */
-   /* 00000000,00000001 == 0x0001 */
-
-   assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);
-   assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);
-   assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);
-   assert(0.0 <= shoveComponents[3] && shoveComponents[3] <= 1.0);
-
-   /* due to limited precision, need to round before shoving */
-   ((GLushort *)packedPixel)[index]  =
-     ((GLushort)((shoveComponents[0] * 31)+0.5) << 11) & 0xf800;
-   ((GLushort *)packedPixel)[index]|=
-     ((GLushort)((shoveComponents[1] * 31)+0.5) <<  6) & 0x07c0;
-   ((GLushort *)packedPixel)[index]|=
-     ((GLushort)((shoveComponents[2] * 31)+0.5) <<  1) & 0x003e;
-   ((GLushort *)packedPixel)[index]|=
-     ((GLushort)((shoveComponents[3])+0.5)	     ) & 0x0001;
-} /* shove5551() */
-
-static void extract1555rev(int isSwap,const void *packedPixel,
-			   GLfloat extractComponents[])
-{
-   GLushort ushort;
-
-   if (isSwap) {
-     ushort= __GLU_SWAP_2_BYTES(packedPixel);
-   }
-   else {
-     ushort= *(const GLushort *)packedPixel;
-   }
-
-   /* 00000000,00011111 == 0x001F */
-   /* 00000011,11100000 == 0x03E0 */
-   /* 01111100,00000000 == 0x7C00 */
-   /* 10000000,00000000 == 0x8000 */
-
-   /* 31 = 2^5-1 */
-   extractComponents[0]= (float)((ushort & 0x001F)	) / 31.0;
-   extractComponents[1]= (float)((ushort & 0x03E0) >>  5) / 31.0;
-   extractComponents[2]= (float)((ushort & 0x7C00) >> 10) / 31.0;
-   extractComponents[3]= (float)((ushort & 0x8000) >> 15);
-} /* extract1555rev() */
-
-static void shove1555rev(const GLfloat shoveComponents[],
-			 int index,void *packedPixel)
-{
-   /* 00000000,00011111 == 0x001F */
-   /* 00000011,11100000 == 0x03E0 */
-   /* 01111100,00000000 == 0x7C00 */
-   /* 10000000,00000000 == 0x8000 */
-
-   assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);
-   assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);
-   assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);
-   assert(0.0 <= shoveComponents[3] && shoveComponents[3] <= 1.0);
-
-   /* due to limited precision, need to round before shoving */
-   ((GLushort *)packedPixel)[index] =
-     ((GLushort)((shoveComponents[0] * 31)+0.5)      ) & 0x001F;
-   ((GLushort *)packedPixel)[index]|=
-     ((GLushort)((shoveComponents[1] * 31)+0.5) <<  5) & 0x03E0;
-   ((GLushort *)packedPixel)[index]|=
-     ((GLushort)((shoveComponents[2] * 31)+0.5) << 10) & 0x7C00;
-   ((GLushort *)packedPixel)[index]|=
-     ((GLushort)((shoveComponents[3])+0.5)	<< 15) & 0x8000;
-} /* shove1555rev() */
-
-static void extract8888(int isSwap,
-			const void *packedPixel, GLfloat extractComponents[])
-{
-   GLuint uint;
-
-   if (isSwap) {
-     uint= __GLU_SWAP_4_BYTES(packedPixel);
-   }
-   else {
-     uint= *(const GLuint *)packedPixel;
-   }
-
-   /* 11111111,00000000,00000000,00000000 == 0xff000000 */
-   /* 00000000,11111111,00000000,00000000 == 0x00ff0000 */
-   /* 00000000,00000000,11111111,00000000 == 0x0000ff00 */
-   /* 00000000,00000000,00000000,11111111 == 0x000000ff */
-
-   /* 255 = 2^8-1 */
-   extractComponents[0]= (float)((uint & 0xff000000) >> 24) / 255.0;
-   extractComponents[1]= (float)((uint & 0x00ff0000) >> 16) / 255.0;
-   extractComponents[2]= (float)((uint & 0x0000ff00) >>  8) / 255.0;
-   extractComponents[3]= (float)((uint & 0x000000ff)	  ) / 255.0;
-} /* extract8888() */
-
-static void shove8888(const GLfloat shoveComponents[],
-		      int index,void *packedPixel)
-{
-   /* 11111111,00000000,00000000,00000000 == 0xff000000 */
-   /* 00000000,11111111,00000000,00000000 == 0x00ff0000 */
-   /* 00000000,00000000,11111111,00000000 == 0x0000ff00 */
-   /* 00000000,00000000,00000000,11111111 == 0x000000ff */
-
-   assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);
-   assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);
-   assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);
-   assert(0.0 <= shoveComponents[3] && shoveComponents[3] <= 1.0);
-
-   /* due to limited precision, need to round before shoving */
-   ((GLuint *)packedPixel)[index] =
-     ((GLuint)((shoveComponents[0] * 255)+0.5) << 24) & 0xff000000;
-   ((GLuint *)packedPixel)[index]|=
-     ((GLuint)((shoveComponents[1] * 255)+0.5) << 16) & 0x00ff0000;
-   ((GLuint *)packedPixel)[index]|=
-     ((GLuint)((shoveComponents[2] * 255)+0.5) <<  8) & 0x0000ff00;
-   ((GLuint *)packedPixel)[index]|=
-     ((GLuint)((shoveComponents[3] * 255)+0.5)	    ) & 0x000000ff;
-} /* shove8888() */
-
-static void extract8888rev(int isSwap,
-			   const void *packedPixel,GLfloat extractComponents[])
-{
-   GLuint uint;
-
-   if (isSwap) {
-     uint= __GLU_SWAP_4_BYTES(packedPixel);
-   }
-   else {
-     uint= *(const GLuint *)packedPixel;
-   }
-
-   /* 00000000,00000000,00000000,11111111 == 0x000000ff */
-   /* 00000000,00000000,11111111,00000000 == 0x0000ff00 */
-   /* 00000000,11111111,00000000,00000000 == 0x00ff0000 */
-   /* 11111111,00000000,00000000,00000000 == 0xff000000 */
-
-   /* 255 = 2^8-1 */
-   extractComponents[0]= (float)((uint & 0x000000FF)	  ) / 255.0;
-   extractComponents[1]= (float)((uint & 0x0000FF00) >>  8) / 255.0;
-   extractComponents[2]= (float)((uint & 0x00FF0000) >> 16) / 255.0;
-   extractComponents[3]= (float)((uint & 0xFF000000) >> 24) / 255.0;
-} /* extract8888rev() */
-
-static void shove8888rev(const GLfloat shoveComponents[],
-			 int index,void *packedPixel)
-{
-   /* 00000000,00000000,00000000,11111111 == 0x000000ff */
-   /* 00000000,00000000,11111111,00000000 == 0x0000ff00 */
-   /* 00000000,11111111,00000000,00000000 == 0x00ff0000 */
-   /* 11111111,00000000,00000000,00000000 == 0xff000000 */
-
-   assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);
-   assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);
-   assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);
-   assert(0.0 <= shoveComponents[3] && shoveComponents[3] <= 1.0);
-
-   /* due to limited precision, need to round before shoving */
-   ((GLuint *)packedPixel)[index] =
-     ((GLuint)((shoveComponents[0] * 255)+0.5)	    ) & 0x000000FF;
-   ((GLuint *)packedPixel)[index]|=
-     ((GLuint)((shoveComponents[1] * 255)+0.5) <<  8) & 0x0000FF00;
-   ((GLuint *)packedPixel)[index]|=
-     ((GLuint)((shoveComponents[2] * 255)+0.5) << 16) & 0x00FF0000;
-   ((GLuint *)packedPixel)[index]|=
-     ((GLuint)((shoveComponents[3] * 255)+0.5) << 24) & 0xFF000000;
-} /* shove8888rev() */
-
-static void extract1010102(int isSwap,
-			   const void *packedPixel,GLfloat extractComponents[])
-{
-   GLuint uint;
-
-   if (isSwap) {
-     uint= __GLU_SWAP_4_BYTES(packedPixel);
-   }
-   else {
-     uint= *(const GLuint *)packedPixel;
-   }
-
-   /* 11111111,11000000,00000000,00000000 == 0xffc00000 */
-   /* 00000000,00111111,11110000,00000000 == 0x003ff000 */
-   /* 00000000,00000000,00001111,11111100 == 0x00000ffc */
-   /* 00000000,00000000,00000000,00000011 == 0x00000003 */
-
-   /* 1023 = 2^10-1 */
-   extractComponents[0]= (float)((uint & 0xffc00000) >> 22) / 1023.0;
-   extractComponents[1]= (float)((uint & 0x003ff000) >> 12) / 1023.0;
-   extractComponents[2]= (float)((uint & 0x00000ffc) >>  2) / 1023.0;
-   extractComponents[3]= (float)((uint & 0x00000003)	  ) / 3.0;
-} /* extract1010102() */
-
-static void shove1010102(const GLfloat shoveComponents[],
-			 int index,void *packedPixel)
-{
-   /* 11111111,11000000,00000000,00000000 == 0xffc00000 */
-   /* 00000000,00111111,11110000,00000000 == 0x003ff000 */
-   /* 00000000,00000000,00001111,11111100 == 0x00000ffc */
-   /* 00000000,00000000,00000000,00000011 == 0x00000003 */
-
-   assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);
-   assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);
-   assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);
-   assert(0.0 <= shoveComponents[3] && shoveComponents[3] <= 1.0);
-
-   /* due to limited precision, need to round before shoving */
-   ((GLuint *)packedPixel)[index] =
-     ((GLuint)((shoveComponents[0] * 1023)+0.5) << 22) & 0xffc00000;
-   ((GLuint *)packedPixel)[index]|=
-     ((GLuint)((shoveComponents[1] * 1023)+0.5) << 12) & 0x003ff000;
-   ((GLuint *)packedPixel)[index]|=
-     ((GLuint)((shoveComponents[2] * 1023)+0.5) <<  2) & 0x00000ffc;
-   ((GLuint *)packedPixel)[index]|=
-     ((GLuint)((shoveComponents[3] * 3)+0.5)	     ) & 0x00000003;
-} /* shove1010102() */
-
-static void extract2101010rev(int isSwap,
-			      const void *packedPixel,
-			      GLfloat extractComponents[])
-{
-   GLuint uint;
-
-   if (isSwap) {
-     uint= __GLU_SWAP_4_BYTES(packedPixel);
-   }
-   else {
-     uint= *(const GLuint *)packedPixel;
-   }
-
-   /* 00000000,00000000,00000011,11111111 == 0x000003FF */
-   /* 00000000,00001111,11111100,00000000 == 0x000FFC00 */
-   /* 00111111,11110000,00000000,00000000 == 0x3FF00000 */
-   /* 11000000,00000000,00000000,00000000 == 0xC0000000 */
-
-   /* 1023 = 2^10-1 */
-   extractComponents[0]= (float)((uint & 0x000003FF)	  ) / 1023.0;
-   extractComponents[1]= (float)((uint & 0x000FFC00) >> 10) / 1023.0;
-   extractComponents[2]= (float)((uint & 0x3FF00000) >> 20) / 1023.0;
-   extractComponents[3]= (float)((uint & 0xC0000000) >> 30) / 3.0;
-   /* 3 = 2^2-1 */
-} /* extract2101010rev() */
-
-static void shove2101010rev(const GLfloat shoveComponents[],
-			    int index,void *packedPixel)
-{
-   /* 00000000,00000000,00000011,11111111 == 0x000003FF */
-   /* 00000000,00001111,11111100,00000000 == 0x000FFC00 */
-   /* 00111111,11110000,00000000,00000000 == 0x3FF00000 */
-   /* 11000000,00000000,00000000,00000000 == 0xC0000000 */
-
-   assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);
-   assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);
-   assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);
-   assert(0.0 <= shoveComponents[3] && shoveComponents[3] <= 1.0);
-
-   /* due to limited precision, need to round before shoving */
-   ((GLuint *)packedPixel)[index] =
-     ((GLuint)((shoveComponents[0] * 1023)+0.5)      ) & 0x000003FF;
-   ((GLuint *)packedPixel)[index]|=
-     ((GLuint)((shoveComponents[1] * 1023)+0.5) << 10) & 0x000FFC00;
-   ((GLuint *)packedPixel)[index]|=
-     ((GLuint)((shoveComponents[2] * 1023)+0.5) << 20) & 0x3FF00000;
-   ((GLuint *)packedPixel)[index]|=
-     ((GLuint)((shoveComponents[3] * 3)+0.5)	<< 30) & 0xC0000000;
-} /* shove2101010rev() */
-
-static void scaleInternalPackedPixel(int components,
-				     void (*extractPackedPixel)
-				     (int, const void *,GLfloat []),
-				     void (*shovePackedPixel)
-				     (const GLfloat [], int, void *),
-				     GLint widthIn,GLint heightIn,
-				     const void *dataIn,
-				     GLint widthOut,GLint heightOut,
-				     void *dataOut,
-				     GLint pixelSizeInBytes,
-				     GLint rowSizeInBytes,GLint isSwap)
-{
-    float convx;
-    float convy;
-    float percent;
-
-    /* Max components in a format is 4, so... */
-    float totals[4];
-    float extractTotals[4], extractMoreTotals[4], shoveTotals[4];
-
-    float area;
-    int i,j,k,xindex;
-
-    const char *temp, *temp0;
-    int outindex;
-
-    int lowx_int, highx_int, lowy_int, highy_int;
-    float x_percent, y_percent;
-    float lowx_float, highx_float, lowy_float, highy_float;
-    float convy_float, convx_float;
-    int convy_int, convx_int;
-    int l, m;
-    const char *left, *right;
-
-    if (widthIn == widthOut*2 && heightIn == heightOut*2) {
-	halveImagePackedPixel(components,extractPackedPixel,shovePackedPixel,
-			      widthIn, heightIn, dataIn, dataOut,
-			      pixelSizeInBytes,rowSizeInBytes,isSwap);
-	return;
-    }
-    convy = (float) heightIn/heightOut;
-    convx = (float) widthIn/widthOut;
-    convy_int = floor(convy);
-    convy_float = convy - convy_int;
-    convx_int = floor(convx);
-    convx_float = convx - convx_int;
-
-    area = convx * convy;
-
-    lowy_int = 0;
-    lowy_float = 0;
-    highy_int = convy_int;
-    highy_float = convy_float;
-
-    for (i = 0; i < heightOut; i++) {
-	lowx_int = 0;
-	lowx_float = 0;
-	highx_int = convx_int;
-	highx_float = convx_float;
-
-	for (j = 0; j < widthOut; j++) {
-	    /*
-	    ** Ok, now apply box filter to box that goes from (lowx, lowy)
-	    ** to (highx, highy) on input data into this pixel on output
-	    ** data.
-	    */
-	    totals[0] = totals[1] = totals[2] = totals[3] = 0.0;
-
-	    /* calculate the value for pixels in the 1st row */
-	    xindex = lowx_int*pixelSizeInBytes;
-	    if((highy_int>lowy_int) && (highx_int>lowx_int)) {
-
-		y_percent = 1-lowy_float;
-		temp = (const char *)dataIn + xindex + lowy_int * rowSizeInBytes;
-		percent = y_percent * (1-lowx_float);
-#if 0
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
-		    } else {
-			totals[k] += *(const GLushort*)temp_index * percent;
-		    }
-		}
-#else
-		(*extractPackedPixel)(isSwap,temp,extractTotals);
-		for (k = 0; k < components; k++) {
-		   totals[k]+= extractTotals[k] * percent;
-		}
-#endif
-		left = temp;
-		for(l = lowx_int+1; l < highx_int; l++) {
-		    temp += pixelSizeInBytes;
-#if 0
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			if (myswap_bytes) {
-			    totals[k] +=
-				 __GLU_SWAP_2_BYTES(temp_index) * y_percent;
-			} else {
-			    totals[k] += *(const GLushort*)temp_index * y_percent;
-			}
-		    }
-#else
-		    (*extractPackedPixel)(isSwap,temp,extractTotals);
-		    for (k = 0; k < components; k++) {
-		       totals[k]+= extractTotals[k] * y_percent;
-		    }
-#endif
-		}
-		temp += pixelSizeInBytes;
-		right = temp;
-		percent = y_percent * highx_float;
-#if 0
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
-		    } else {
-			totals[k] += *(const GLushort*)temp_index * percent;
-		    }
-		}
-#else
-		(*extractPackedPixel)(isSwap,temp,extractTotals);
-		for (k = 0; k < components; k++) {
-		   totals[k]+= extractTotals[k] * percent;
-		}
-#endif
-
-		/* calculate the value for pixels in the last row */
-	        
-		y_percent = highy_float;
-		percent = y_percent * (1-lowx_float);
-		temp = (const char *)dataIn + xindex + highy_int * rowSizeInBytes;
-#if 0
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
-		    } else {
-			totals[k] += *(const GLushort*)temp_index * percent;
-		    }
-		}
-#else
-		(*extractPackedPixel)(isSwap,temp,extractTotals);
-		for (k = 0; k < components; k++) {
-		   totals[k]+= extractTotals[k] * percent;
-		}
-#endif
-		for(l = lowx_int+1; l < highx_int; l++) {
-		    temp += pixelSizeInBytes;
-#if 0
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			if (myswap_bytes) {
-			    totals[k] +=
-				 __GLU_SWAP_2_BYTES(temp_index) * y_percent;
-			} else {
-			    totals[k] += *(const GLushort*)temp_index * y_percent;
-			}
-		    }
-#else
-		    (*extractPackedPixel)(isSwap,temp,extractTotals);
-		    for (k = 0; k < components; k++) {
-		       totals[k]+= extractTotals[k] * y_percent;
-		    }
-#endif
-
-		}
-		temp += pixelSizeInBytes;
-		percent = y_percent * highx_float;
-#if 0
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
-		    } else {
-			totals[k] += *(const GLushort*)temp_index * percent;
-		    }
-		}
-#else
-		(*extractPackedPixel)(isSwap,temp,extractTotals);
-		for (k = 0; k < components; k++) {
-		   totals[k]+= extractTotals[k] * percent;
-		}
-#endif
-
-		/* calculate the value for pixels in the 1st and last column */
-		for(m = lowy_int+1; m < highy_int; m++) {
-		    left += rowSizeInBytes;
-		    right += rowSizeInBytes;
-#if 0
-		    for (k = 0; k < components;
-			 k++, left += element_size, right += element_size) {
-			if (myswap_bytes) {
-			    totals[k] +=
-				__GLU_SWAP_2_BYTES(left) * (1-lowx_float) +
-				__GLU_SWAP_2_BYTES(right) * highx_float;
-			} else {
-			    totals[k] += *(const GLushort*)left * (1-lowx_float)
-				       + *(const GLushort*)right * highx_float;
-			}
-		    }
-#else
-		    (*extractPackedPixel)(isSwap,left,extractTotals);
-		    (*extractPackedPixel)(isSwap,right,extractMoreTotals);
-		    for (k = 0; k < components; k++) {
-		       totals[k]+= (extractTotals[k]*(1-lowx_float) +
-				   extractMoreTotals[k]*highx_float);
-		    }
-#endif
-		}
-	    } else if (highy_int > lowy_int) {
-		x_percent = highx_float - lowx_float;
-		percent = (1-lowy_float)*x_percent;
-		temp = (const char *)dataIn + xindex + lowy_int*rowSizeInBytes;
-#if 0
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
-		    } else {
-			totals[k] += *(const GLushort*)temp_index * percent;
-		    }
-		}
-#else
-		(*extractPackedPixel)(isSwap,temp,extractTotals);
-		for (k = 0; k < components; k++) {
-		   totals[k]+= extractTotals[k] * percent;
-		}
-#endif
-		for(m = lowy_int+1; m < highy_int; m++) {
-		    temp += rowSizeInBytes;
-#if 0
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			if (myswap_bytes) {
-			    totals[k] +=
-				__GLU_SWAP_2_BYTES(temp_index) * x_percent;
-			} else {
-			    totals[k] += *(const GLushort*)temp_index * x_percent;
-			}
-		    }
-#else
-		    (*extractPackedPixel)(isSwap,temp,extractTotals);
-		    for (k = 0; k < components; k++) {
-		       totals[k]+= extractTotals[k] * x_percent;
-		    }
-#endif
-		}
-		percent = x_percent * highy_float;
-		temp += rowSizeInBytes;
-#if 0
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
-		    } else {
-			totals[k] += *(const GLushort*)temp_index * percent;
-		    }
-		}
-#else
-		(*extractPackedPixel)(isSwap,temp,extractTotals);
-		for (k = 0; k < components; k++) {
-		   totals[k]+= extractTotals[k] * percent;
-		}
-#endif
-	    } else if (highx_int > lowx_int) {
-		y_percent = highy_float - lowy_float;
-		percent = (1-lowx_float)*y_percent;
-		temp = (const char *)dataIn + xindex + lowy_int*rowSizeInBytes;
-#if 0
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
-		    } else {
-			totals[k] += *(const GLushort*)temp_index * percent;
-		    }
-		}
-#else
-		(*extractPackedPixel)(isSwap,temp,extractTotals);
-		for (k = 0; k < components; k++) {
-		   totals[k]+= extractTotals[k] * percent;
-		}
-#endif
-		for (l = lowx_int+1; l < highx_int; l++) {
-		    temp += pixelSizeInBytes;
-#if 0
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			if (myswap_bytes) {
-			    totals[k] +=
-				__GLU_SWAP_2_BYTES(temp_index) * y_percent;
-			} else {
-			    totals[k] += *(const GLushort*)temp_index * y_percent;
-			}
-		    }
-#else
-		(*extractPackedPixel)(isSwap,temp,extractTotals);
-		for (k = 0; k < components; k++) {
-		   totals[k]+= extractTotals[k] * y_percent;
-		}
-#endif
-		}
-		temp += pixelSizeInBytes;
-		percent = y_percent * highx_float;
-#if 0
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
-		    } else {
-			totals[k] += *(const GLushort*)temp_index * percent;
-		    }
-		}
-#else
-		(*extractPackedPixel)(isSwap,temp,extractTotals);
-		for (k = 0; k < components; k++) {
-		   totals[k]+= extractTotals[k] * percent;
-		}
-#endif
-	    } else {
-		percent = (highy_float-lowy_float)*(highx_float-lowx_float);
-		temp = (const char *)dataIn + xindex + lowy_int * rowSizeInBytes;
-#if 0
-		for (k = 0, temp_index = temp; k < components;
-		     k++, temp_index += element_size) {
-		    if (myswap_bytes) {
-			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
-		    } else {
-			totals[k] += *(const GLushort*)temp_index * percent;
-		    }
-		}
-#else
-		(*extractPackedPixel)(isSwap,temp,extractTotals);
-		for (k = 0; k < components; k++) {
-		   totals[k]+= extractTotals[k] * percent;
-		}
-#endif
-	    }
-
-	    /* this is for the pixels in the body */
-	    temp0 = (const char *)dataIn + xindex + pixelSizeInBytes + (lowy_int+1)*rowSizeInBytes;
-	    for (m = lowy_int+1; m < highy_int; m++) {
-		temp = temp0;
-		for(l = lowx_int+1; l < highx_int; l++) {
-#if 0
-		    for (k = 0, temp_index = temp; k < components;
-			 k++, temp_index += element_size) {
-			if (myswap_bytes) {
-			    totals[k] += __GLU_SWAP_2_BYTES(temp_index);
-			} else {
-			    totals[k] += *(const GLushort*)temp_index;
-			}
-		    }
-#else
-		    (*extractPackedPixel)(isSwap,temp,extractTotals);
-		    for (k = 0; k < components; k++) {
-		       totals[k]+= extractTotals[k];
-		    }
-#endif
-		    temp += pixelSizeInBytes;
-		}
-		temp0 += rowSizeInBytes;
-	    }
-
-	    outindex = (j + (i * widthOut)); /* * (components == 1) */
-#if 0
-	    for (k = 0; k < components; k++) {
-		dataout[outindex + k] = totals[k]/area;
-		/*printf("totals[%d] = %f\n", k, totals[k]);*/
-	    }
-#else
-	    for (k = 0; k < components; k++) {
-		shoveTotals[k]= totals[k]/area;
-	    }
-	    (*shovePackedPixel)(shoveTotals,outindex,(void *)dataOut);
-#endif
-	    lowx_int = highx_int;
-	    lowx_float = highx_float;
-	    highx_int += convx_int;
-	    highx_float += convx_float;
-	    if(highx_float > 1) {
-		highx_float -= 1.0;
-		highx_int++;
-	    }
-	}
-	lowy_int = highy_int;
-	lowy_float = highy_float;
-	highy_int += convy_int;
-	highy_float += convy_float;
-	if(highy_float > 1) {
-	    highy_float -= 1.0;
-	    highy_int++;
-	}
-    }
-
-    assert(outindex == (widthOut*heightOut - 1));
-} /* scaleInternalPackedPixel() */
-
-/* rowSizeInBytes is at least the width (in bytes) due to padding on
- *  inputs; not always equal. Output NEVER has row padding.
- */
-static void halveImagePackedPixel(int components,
-				  void (*extractPackedPixel)
-				  (int, const void *,GLfloat []),
-				  void (*shovePackedPixel)
-				  (const GLfloat [],int, void *),
-				  GLint width, GLint height,
-				  const void *dataIn, void *dataOut,
-				  GLint pixelSizeInBytes,
-				  GLint rowSizeInBytes, GLint isSwap)
-{
-   /* handle case where there is only 1 column/row */
-   if (width == 1 || height == 1) {
-      assert(!(width == 1 && height == 1)); /* can't be 1x1 */
-      halve1DimagePackedPixel(components,extractPackedPixel,shovePackedPixel,
-			      width,height,dataIn,dataOut,pixelSizeInBytes,
-			      rowSizeInBytes,isSwap);
-      return;
-   }
-
-   {
-      int ii, jj;
-
-      int halfWidth= width / 2;
-      int halfHeight= height / 2;
-      const char *src= (const char *) dataIn;
-      int padBytes= rowSizeInBytes - (width*pixelSizeInBytes);
-      int outIndex= 0;
-
-      for (ii= 0; ii< halfHeight; ii++) {
-	 for (jj= 0; jj< halfWidth; jj++) {
-#define BOX4 4
-	    float totals[4];	/* 4 is maximum components */
-	    float extractTotals[BOX4][4]; /* 4 is maximum components */
-	    int cc;
-
-	    (*extractPackedPixel)(isSwap,src,
-				  &extractTotals[0][0]);
-	    (*extractPackedPixel)(isSwap,(src+pixelSizeInBytes),
-				  &extractTotals[1][0]);
-	    (*extractPackedPixel)(isSwap,(src+rowSizeInBytes),
-				  &extractTotals[2][0]);
-	    (*extractPackedPixel)(isSwap,
-				  (src+rowSizeInBytes+pixelSizeInBytes),
-				  &extractTotals[3][0]);
-	    for (cc = 0; cc < components; cc++) {
-	       int kk;
-
-	       /* grab 4 pixels to average */
-	       totals[cc]= 0.0;
-	       /* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED]+
-		*	       extractTotals[2][RED]+extractTotals[3][RED];
-		* totals[RED]/= 4.0;
-		*/
-	       for (kk = 0; kk < BOX4; kk++) {
-		  totals[cc]+= extractTotals[kk][cc];
-	       }
-	       totals[cc]/= (float)BOX4;
-	    }
-	    (*shovePackedPixel)(totals,outIndex,dataOut);
-
-	    outIndex++;
-	    /* skip over to next square of 4 */
-	    src+= pixelSizeInBytes + pixelSizeInBytes;
-	 }
-	 /* skip past pad bytes, if any, to get to next row */
-	 src+= padBytes;
-
-	 /* src is at beginning of a row here, but it's the second row of
-	  * the square block of 4 pixels that we just worked on so we
-	  * need to go one more row.
-	  * i.e.,
-	  *		      OO...
-	  *	      here -->OO...
-	  *	  but want -->OO...
-	  *		      OO...
-	  *		      ...
-	  */
-	 src+= rowSizeInBytes;
-      }
-
-      /* both pointers must reach one byte after the end */
-      assert(src == &((const char *)dataIn)[rowSizeInBytes*height]);
-      assert(outIndex == halfWidth * halfHeight);
-   }
-} /* halveImagePackedPixel() */
-
-static void halve1DimagePackedPixel(int components,
-				    void (*extractPackedPixel)
-				    (int, const void *,GLfloat []),
-				    void (*shovePackedPixel)
-				    (const GLfloat [],int, void *),
-				    GLint width, GLint height,
-				    const void *dataIn, void *dataOut,
-				    GLint pixelSizeInBytes,
-				    GLint rowSizeInBytes, GLint isSwap)
-{
-   int halfWidth= width / 2;
-   int halfHeight= height / 2;
-   const char *src= (const char *) dataIn;
-   int jj;
-
-   assert(width == 1 || height == 1); /* must be 1D */
-   assert(width != height);	/* can't be square */
-
-   if (height == 1) {	/* 1 row */
-      int outIndex= 0;
-
-      assert(width != 1);	/* widthxheight can't be 1x1 */
-      halfHeight= 1;
-
-      /* one horizontal row with possible pad bytes */
-
-      for (jj= 0; jj< halfWidth; jj++) {
-#define BOX2 2
-	 float totals[4];	/* 4 is maximum components */
-	 float extractTotals[BOX2][4]; /* 4 is maximum components */
-	 int cc;
-
-	 /* average two at a time, instead of four */
-	 (*extractPackedPixel)(isSwap,src,
-			       &extractTotals[0][0]);
-	 (*extractPackedPixel)(isSwap,(src+pixelSizeInBytes),
-			       &extractTotals[1][0]);		        
-	 for (cc = 0; cc < components; cc++) {
-	    int kk;
-
-	    /* grab 2 pixels to average */
-	    totals[cc]= 0.0;
-	    /* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED];
-	     * totals[RED]/= 2.0;
-	     */
-	    for (kk = 0; kk < BOX2; kk++) {
-	       totals[cc]+= extractTotals[kk][cc];
-	    }
-	    totals[cc]/= (float)BOX2;
-	 }
-	 (*shovePackedPixel)(totals,outIndex,dataOut);
-
-	 outIndex++;
-	 /* skip over to next group of 2 */
-	 src+= pixelSizeInBytes + pixelSizeInBytes;
-      }
-
-      {
-	 int padBytes= rowSizeInBytes - (width*pixelSizeInBytes);
-	 src+= padBytes;	/* for assertion only */
-      }
-      assert(src == &((const char *)dataIn)[rowSizeInBytes]);
-      assert(outIndex == halfWidth * halfHeight);
-   }
-   else if (width == 1) { /* 1 column */
-      int outIndex= 0;
-
-      assert(height != 1);	/* widthxheight can't be 1x1 */
-      halfWidth= 1;
-      /* one vertical column with possible pad bytes per row */
-      /* average two at a time */
-
-      for (jj= 0; jj< halfHeight; jj++) {
-#define BOX2 2
-	 float totals[4];	/* 4 is maximum components */
-	 float extractTotals[BOX2][4]; /* 4 is maximum components */
-	 int cc;
-
-	 /* average two at a time, instead of four */
-	 (*extractPackedPixel)(isSwap,src,
-			       &extractTotals[0][0]);
-	 (*extractPackedPixel)(isSwap,(src+rowSizeInBytes),
-			       &extractTotals[1][0]);		        
-	 for (cc = 0; cc < components; cc++) {
-	    int kk;
-
-	    /* grab 2 pixels to average */
-	    totals[cc]= 0.0;
-	    /* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED];
-	     * totals[RED]/= 2.0;
-	     */
-	    for (kk = 0; kk < BOX2; kk++) {
-	       totals[cc]+= extractTotals[kk][cc];
-	    }
-	    totals[cc]/= (float)BOX2;
-	 }
-	 (*shovePackedPixel)(totals,outIndex,dataOut);
-
-	 outIndex++;
-	 src+= rowSizeInBytes + rowSizeInBytes; /* go to row after next */
-      }
-
-      assert(src == &((const char *)dataIn)[rowSizeInBytes*height]);
-      assert(outIndex == halfWidth * halfHeight);
-   }
-} /* halve1DimagePackedPixel() */
-
-/*===========================================================================*/
-
-#ifdef RESOLVE_3D_TEXTURE_SUPPORT
-/*
- * This section ensures that GLU 1.3 will load and run on
- * a GL 1.1 implementation. It dynamically resolves the
- * call to glTexImage3D() which might not be available.
- * Or is it might be supported as an extension.
- * Contributed by Gerk Huisma <gerk@five-d.demon.nl>.
- */
-
-typedef void (GLAPIENTRY *TexImage3Dproc)( GLenum target, GLint level,
-						 GLenum internalFormat,
-						 GLsizei width, GLsizei height,
-						 GLsizei depth, GLint border,
-						 GLenum format, GLenum type,
-						 const GLvoid *pixels );
-
-static TexImage3Dproc pTexImage3D = 0;
-
-#if !defined(_WIN32) && !defined(__WIN32__)
-#  include <dlfcn.h>
-#  include <sys/types.h>
-#else
-  WINGDIAPI PROC  WINAPI wglGetProcAddress(LPCSTR);
-#endif
-
-static void gluTexImage3D( GLenum target, GLint level,
-			   GLenum internalFormat,
-			   GLsizei width, GLsizei height,
-			   GLsizei depth, GLint border,
-			   GLenum format, GLenum type,
-			   const GLvoid *pixels )
-{
-   if (!pTexImage3D) {
-#if defined(_WIN32) || defined(__WIN32__)
-      pTexImage3D = (TexImage3Dproc) wglGetProcAddress("glTexImage3D");
-      if (!pTexImage3D)
-	 pTexImage3D = (TexImage3Dproc) wglGetProcAddress("glTexImage3DEXT");
-#else
-      void *libHandle = dlopen("libgl.so", RTLD_LAZY);
-      pTexImage3D = TexImage3Dproc) dlsym(libHandle, "glTexImage3D" );
-      if (!pTexImage3D)
-	 pTexImage3D = (TexImage3Dproc) dlsym(libHandle,"glTexImage3DEXT");
-      dlclose(libHandle);
-#endif
-   }
-
-   /* Now call glTexImage3D */
-   if (pTexImage3D)
-      pTexImage3D(target, level, internalFormat, width, height,
-		  depth, border, format, type, pixels);
-}
-
-#else
-
-/* Only bind to a GL 1.2 implementation: */
-#define gluTexImage3D glTexImage3D
-
-#endif
-
-static GLint imageSize3D(GLint width, GLint height, GLint depth,
-			 GLenum format, GLenum type)
-{
-    int components= elements_per_group(format,type);
-    int bytes_per_row=	bytes_per_element(type) * width;
-
-assert(width > 0 && height > 0 && depth > 0);
-assert(type != GL_BITMAP);
-
-    return bytes_per_row * height * depth * components;
-} /* imageSize3D() */
-
-static void fillImage3D(const PixelStorageModes *psm,
-			GLint width, GLint height, GLint depth, GLenum format,
-			GLenum type, GLboolean indexFormat,
-			const void *userImage, GLushort *newImage)
-{
-   int myswapBytes;
-   int components;
-   int groupsPerLine;
-   int elementSize;
-   int groupSize;
-   int rowSize;
-   int padding;
-   int elementsPerLine;
-   int rowsPerImage;
-   int imageSize;
-   const GLubyte *start, *rowStart, *iter;
-   GLushort *iter2;
-   int ww, hh, dd, k;
-
-   myswapBytes= psm->unpack_swap_bytes;
-   components= elements_per_group(format,type);
-   if (psm->unpack_row_length > 0) {
-      groupsPerLine= psm->unpack_row_length;
-   }
-   else {
-      groupsPerLine= width;
-   }
-   elementSize= bytes_per_element(type);
-   groupSize= elementSize * components;
-   if (elementSize == 1) myswapBytes= 0;
-
-   /* 3dstuff begin */
-   if (psm->unpack_image_height > 0) {
-      rowsPerImage= psm->unpack_image_height;
-   }
-   else {
-      rowsPerImage= height;
-   }
-   /* 3dstuff end */
-
-   rowSize= groupsPerLine * groupSize;
-   padding= rowSize % psm->unpack_alignment;
-   if (padding) {
-      rowSize+= psm->unpack_alignment - padding;
-   }
-
-   imageSize= rowsPerImage * rowSize; /* 3dstuff */
-
-   start= (const GLubyte *)userImage + psm->unpack_skip_rows * rowSize +
-				 psm->unpack_skip_pixels * groupSize +
-				 /*3dstuff*/
-				 psm->unpack_skip_images * imageSize;
-   elementsPerLine = width * components;
-
-   iter2= newImage;
-   for (dd= 0; dd < depth; dd++) {
-      rowStart= start;
-
-      for (hh= 0; hh < height; hh++) {
-	 iter= rowStart;
-
-	 for (ww= 0; ww < elementsPerLine; ww++) {
-	    Type_Widget widget;
-	    float extractComponents[4];
-
-	    switch(type) {
-	    case GL_UNSIGNED_BYTE:
-	      if (indexFormat) {
-		  *iter2++ = *iter;
-	      } else {
-		  *iter2++ = (*iter) * 257;
-	      }
-	      break;
-	    case GL_BYTE:
-	      if (indexFormat) {
-		  *iter2++ = *((const GLbyte *) iter);
-	      } else {
-		  /* rough approx */
-		  *iter2++ = (*((const GLbyte *) iter)) * 516;
-	      }
-	      break;
-	    case GL_UNSIGNED_BYTE_3_3_2:
-	      extract332(0,iter,extractComponents);
-	      for (k = 0; k < 3; k++) {
-		*iter2++ = (GLushort)(extractComponents[k]*65535);
-	      }
-	      break;
-	    case GL_UNSIGNED_BYTE_2_3_3_REV:
-	      extract233rev(0,iter,extractComponents);
-	      for (k = 0; k < 3; k++) {
-		*iter2++ = (GLushort)(extractComponents[k]*65535);
-	      }
-	      break;
-	    case GL_UNSIGNED_SHORT_5_6_5:			        
-	      extract565(myswapBytes,iter,extractComponents);
-	      for (k = 0; k < 3; k++) {
-		*iter2++ = (GLushort)(extractComponents[k]*65535);
-	      }
-	      break;
-	    case GL_UNSIGNED_SHORT_5_6_5_REV:			        
-	      extract565rev(myswapBytes,iter,extractComponents);
-	      for (k = 0; k < 3; k++) {
-		*iter2++ = (GLushort)(extractComponents[k]*65535);
-	      }
-	      break;
-	    case GL_UNSIGNED_SHORT_4_4_4_4:	        
-	      extract4444(myswapBytes,iter,extractComponents);
-	      for (k = 0; k < 4; k++) {
-		*iter2++ = (GLushort)(extractComponents[k]*65535);
-	      }
-	      break;
-	    case GL_UNSIGNED_SHORT_4_4_4_4_REV:         
-	      extract4444rev(myswapBytes,iter,extractComponents);
-	      for (k = 0; k < 4; k++) {
-		*iter2++ = (GLushort)(extractComponents[k]*65535);
-	      }
-	      break;
-	    case GL_UNSIGNED_SHORT_5_5_5_1:	        
-	      extract5551(myswapBytes,iter,extractComponents);
-	      for (k = 0; k < 4; k++) {
-		*iter2++ = (GLushort)(extractComponents[k]*65535);
-	      }
-	      break;
-	    case GL_UNSIGNED_SHORT_1_5_5_5_REV:
-	      extract1555rev(myswapBytes,iter,extractComponents);
-	      for (k = 0; k < 4; k++) {
-		*iter2++ = (GLushort)(extractComponents[k]*65535);
-	      }
-	      break;
-	    case GL_UNSIGNED_SHORT:
-	    case GL_SHORT:
-	      if (myswapBytes) {
-		  widget.ub[0] = iter[1];
-		  widget.ub[1] = iter[0];
-	      } else {
-		  widget.ub[0] = iter[0];
-		  widget.ub[1] = iter[1];
-	      }
-	      if (type == GL_SHORT) {
-		  if (indexFormat) {
-		      *iter2++ = widget.s[0];
-		  } else {
-		      /* rough approx */
-		      *iter2++ = widget.s[0]*2;
-		  }
-	      } else {
-		  *iter2++ = widget.us[0];
-	      }
-	      break;
-	    case GL_UNSIGNED_INT_8_8_8_8:	        
-	      extract8888(myswapBytes,iter,extractComponents);
-	      for (k = 0; k < 4; k++) {
-		*iter2++ = (GLushort)(extractComponents[k]*65535);
-	      }
-	      break;
-	    case GL_UNSIGNED_INT_8_8_8_8_REV:	        
-	      extract8888rev(myswapBytes,iter,extractComponents);
-	      for (k = 0; k < 4; k++) {
-		*iter2++ = (GLushort)(extractComponents[k]*65535);
-	      }
-	      break;
-	    case GL_UNSIGNED_INT_10_10_10_2:	        
-	      extract1010102(myswapBytes,iter,extractComponents);
-	      for (k = 0; k < 4; k++) {
-		*iter2++ = (GLushort)(extractComponents[k]*65535);
-	      }
-	      break;
-	    case GL_UNSIGNED_INT_2_10_10_10_REV:
-	      extract2101010rev(myswapBytes,iter,extractComponents);
-	      for (k = 0; k < 4; k++) {
-		*iter2++ = (GLushort)(extractComponents[k]*65535);
-	      }
-	      break;
-	    case GL_INT:
-	    case GL_UNSIGNED_INT:
-	    case GL_FLOAT:
-	      if (myswapBytes) {
-		  widget.ub[0] = iter[3];
-		  widget.ub[1] = iter[2];
-		  widget.ub[2] = iter[1];
-		  widget.ub[3] = iter[0];
-	      } else {
-		  widget.ub[0] = iter[0];
-		  widget.ub[1] = iter[1];
-		  widget.ub[2] = iter[2];
-		  widget.ub[3] = iter[3];
-	      }
-	      if (type == GL_FLOAT) {
-		  if (indexFormat) {
-		      *iter2++ = widget.f;
-		  } else {
-		      *iter2++ = 65535 * widget.f;
-		  }
-	      } else if (type == GL_UNSIGNED_INT) {
-		  if (indexFormat) {
-		      *iter2++ = widget.ui;
-		  } else {
-		      *iter2++ = widget.ui >> 16;
-		  }
-	      } else {
-		  if (indexFormat) {
-		      *iter2++ = widget.i;
-		  } else {
-		      *iter2++ = widget.i >> 15;
-		  }
-	      }
-	      break;
-	    default:
-	      assert(0);
-	    }
-
-	    iter+= elementSize;
-	 } /* for ww */
-	 rowStart+= rowSize;
-
-	 iter= rowStart;	/* for assertion purposes */
-      } /* for hh */
-
-      start+= imageSize;
-   } /* for dd */
-
-   /* iterators should be one byte past end */
-   if (!isTypePackedPixel(type)) {
-      assert(iter2 == &newImage[width*height*depth*components]);
-   }
-   else {
-      assert(iter2 == &newImage[width*height*depth*
-				elements_per_group(format,0)]);
-   }
-   assert( iter == &((const GLubyte *)userImage)[rowSize*height*depth +
-					psm->unpack_skip_rows * rowSize +
-					psm->unpack_skip_pixels * groupSize +
-					/*3dstuff*/
-					psm->unpack_skip_images * imageSize] );
-} /* fillImage3D () */
-
-static void scaleInternal3D(GLint components,
-			    GLint widthIn, GLint heightIn, GLint depthIn,
-			    const GLushort *dataIn,
-			    GLint widthOut, GLint heightOut, GLint depthOut,
-			    GLushort *dataOut)
-{
-    float x, lowx, highx, convx, halfconvx;
-    float y, lowy, highy, convy, halfconvy;
-    float z, lowz, highz, convz, halfconvz;
-    float xpercent,ypercent,zpercent;
-    float percent;
-    /* Max components in a format is 4, so... */
-    float totals[4];
-    float volume;
-    int i,j,d,k,zint,yint,xint,xindex,yindex,zindex;
-    int temp;
-
-    convz = (float) depthIn/depthOut;
-    convy = (float) heightIn/heightOut;
-    convx = (float) widthIn/widthOut;
-    halfconvx = convx/2;
-    halfconvy = convy/2;
-    halfconvz = convz/2;
-    for (d = 0; d < depthOut; d++) {
-       z = convz * (d+0.5);
-       if (depthIn > depthOut) {
-	   highz = z + halfconvz;
-	   lowz = z - halfconvz;
-       } else {
-	   highz = z + 0.5;
-	   lowz = z - 0.5;
-       }
-       for (i = 0; i < heightOut; i++) {
-	   y = convy * (i+0.5);
-	   if (heightIn > heightOut) {
-	       highy = y + halfconvy;
-	       lowy = y - halfconvy;
-	   } else {
-	       highy = y + 0.5;
-	       lowy = y - 0.5;
-	   }
-	   for (j = 0; j < widthOut; j++) {
-	       x = convx * (j+0.5);
-	       if (widthIn > widthOut) {
-		   highx = x + halfconvx;
-		   lowx = x - halfconvx;
-	       } else {
-		   highx = x + 0.5;
-		   lowx = x - 0.5;
-	       }
-
-	       /*
-	       ** Ok, now apply box filter to box that goes from (lowx, lowy,
-	       ** lowz) to (highx, highy, highz) on input data into this pixel
-	       ** on output data.
-	       */
-	       totals[0] = totals[1] = totals[2] = totals[3] = 0.0;
-	       volume = 0.0;
-
-	       z = lowz;
-	       zint = floor(z);
-	       while (z < highz) {
-		  zindex = (zint + depthIn) % depthIn;
-		  if (highz < zint+1) {
-		      zpercent = highz - z;
-		  } else {
-		      zpercent = zint+1 - z;
-		  }
-
-		  y = lowy;
-		  yint = floor(y);
-		  while (y < highy) {
-		      yindex = (yint + heightIn) % heightIn;
-		      if (highy < yint+1) {
-			  ypercent = highy - y;
-		      } else {
-			  ypercent = yint+1 - y;
-		      }
-
-		      x = lowx;
-		      xint = floor(x);
-
-		      while (x < highx) {
-			  xindex = (xint + widthIn) % widthIn;
-			  if (highx < xint+1) {
-			      xpercent = highx - x;
-			  } else {
-			      xpercent = xint+1 - x;
-			  }
-
-			  percent = xpercent * ypercent * zpercent;
-			  volume += percent;
-
-			  temp = (xindex + (yindex*widthIn) +
-				  (zindex*widthIn*heightIn)) * components;
-			  for (k = 0; k < components; k++) {
-			      assert(0 <= (temp+k) &&
-				     (temp+k) <
-				     (widthIn*heightIn*depthIn*components));
-			      totals[k] += dataIn[temp + k] * percent;
-			  }
-
-			  xint++;
-			  x = xint;
-		      } /* while x */
-
-		      yint++;
-		      y = yint;
-		  } /* while y */
-
-		  zint++;
-		  z = zint;
-	       } /* while z */
-
-	       temp = (j + (i * widthOut) +
-		       (d*widthOut*heightOut)) * components;
-	       for (k = 0; k < components; k++) {
-		   /* totals[] should be rounded in the case of enlarging an
-		    * RGB ramp when the type is 332 or 4444
-		    */
-		   assert(0 <= (temp+k) &&
-			  (temp+k) < (widthOut*heightOut*depthOut*components));
-		   dataOut[temp + k] = (totals[k]+0.5)/volume;
-	       }
-	   } /* for j */
-       } /* for i */
-    } /* for d */
-} /* scaleInternal3D() */
-
-static void emptyImage3D(const PixelStorageModes *psm,
-			 GLint width, GLint height, GLint depth,
-			 GLenum format, GLenum type, GLboolean indexFormat,
-			 const GLushort *oldImage, void *userImage)
-{
-   int myswapBytes;
-   int components;
-   int groupsPerLine;
-   int elementSize;
-   int groupSize;
-   int rowSize;
-   int padding;
-   GLubyte *start, *rowStart, *iter;
-   int elementsPerLine;
-   const GLushort *iter2;
-   int ii, jj, dd, k;
-   int rowsPerImage;
-   int imageSize;
-
-   myswapBytes= psm->pack_swap_bytes;
-   components = elements_per_group(format,type);
-   if (psm->pack_row_length > 0) {
-      groupsPerLine = psm->pack_row_length;
-   }
-   else {
-      groupsPerLine = width;
-   }
-
-   elementSize= bytes_per_element(type);
-   groupSize= elementSize * components;
-   if (elementSize == 1) myswapBytes= 0;
-
-   /* 3dstuff begin */
-   if (psm->pack_image_height > 0) {
-      rowsPerImage= psm->pack_image_height;
-   }
-   else {
-      rowsPerImage= height;
-   }
-
-   /* 3dstuff end */
-
-   rowSize = groupsPerLine * groupSize;
-   padding = rowSize % psm->pack_alignment;
-   if (padding) {
-      rowSize+= psm->pack_alignment - padding;
-   }
-
-   imageSize= rowsPerImage * rowSize; /* 3dstuff */
-
-   start = (GLubyte *)userImage + psm->pack_skip_rows * rowSize +
-				  psm->pack_skip_pixels * groupSize +
-				  /*3dstuff*/
-				  psm->pack_skip_images * imageSize;
-   elementsPerLine= width * components;
-
-   iter2 = oldImage;
-   for (dd= 0; dd < depth; dd++) {
-      rowStart= start;
-
-      for (ii= 0; ii< height; ii++) {
-	 iter = rowStart;
-
-	 for (jj = 0; jj < elementsPerLine; jj++) {
-	    Type_Widget widget;
-	    float shoveComponents[4];
-
-	    switch(type){
-	    case GL_UNSIGNED_BYTE:
-	      if (indexFormat) {
-		  *iter = *iter2++;
-	      } else {
-		  *iter = *iter2++ >> 8;
-	      }
-	      break;
-	    case GL_BYTE:
-	      if (indexFormat) {
-		  *((GLbyte *) iter) = *iter2++;
-	      } else {
-		  *((GLbyte *) iter) = *iter2++ >> 9;
-	      }
-	      break;
-	    case GL_UNSIGNED_BYTE_3_3_2:
-	      for (k = 0; k < 3; k++) {
-		 shoveComponents[k]= *iter2++ / 65535.0;
-	      }
-	      shove332(shoveComponents,0,(void *)iter);
-	      break;
-	    case GL_UNSIGNED_BYTE_2_3_3_REV:
-	      for (k = 0; k < 3; k++) {
-		 shoveComponents[k]= *iter2++ / 65535.0;
-	      }
-	      shove233rev(shoveComponents,0,(void *)iter);
-	      break;
-	    case GL_UNSIGNED_SHORT_5_6_5:	        
-	      for (k = 0; k < 3; k++) {
-		 shoveComponents[k]= *iter2++ / 65535.0;
-	      }
-	      shove565(shoveComponents,0,(void *)&widget.us[0]);
-	      if (myswapBytes) {
-		 iter[0] = widget.ub[1];
-		 iter[1] = widget.ub[0];
-	      }
-	      else {
-		 *(GLushort *)iter = widget.us[0];
-	      }
-	      break;
-	    case GL_UNSIGNED_SHORT_5_6_5_REV:	        
-	      for (k = 0; k < 3; k++) {
-		 shoveComponents[k]= *iter2++ / 65535.0;
-	      }
-	      shove565rev(shoveComponents,0,(void *)&widget.us[0]);
-	      if (myswapBytes) {
-		 iter[0] = widget.ub[1];
-		 iter[1] = widget.ub[0];
-	      }
-	      else {
-		 *(GLushort *)iter = widget.us[0];
-	      }
-	      break;
-	    case GL_UNSIGNED_SHORT_4_4_4_4:
-	      for (k = 0; k < 4; k++) {
-		 shoveComponents[k]= *iter2++ / 65535.0;
-	      }
-	      shove4444(shoveComponents,0,(void *)&widget.us[0]);
-	      if (myswapBytes) {
-		 iter[0] = widget.ub[1];
-		 iter[1] = widget.ub[0];
-	      } else {
-		 *(GLushort *)iter = widget.us[0];
-	      }
-	      break;
-	    case GL_UNSIGNED_SHORT_4_4_4_4_REV:
-	      for (k = 0; k < 4; k++) {
-		 shoveComponents[k]= *iter2++ / 65535.0;
-	      }
-	      shove4444rev(shoveComponents,0,(void *)&widget.us[0]);
-	      if (myswapBytes) {
-		 iter[0] = widget.ub[1];
-		 iter[1] = widget.ub[0];
-	      } else {
-		 *(GLushort *)iter = widget.us[0];
-	      }
-	      break;
-	    case GL_UNSIGNED_SHORT_5_5_5_1:
-	      for (k = 0; k < 4; k++) {
-		 shoveComponents[k]= *iter2++ / 65535.0;
-	      }
-	      shove5551(shoveComponents,0,(void *)&widget.us[0]);
-	      if (myswapBytes) {
-		 iter[0] = widget.ub[1];
-		 iter[1] = widget.ub[0];
-	      } else {
-		 *(GLushort *)iter = widget.us[0];
-	      }
-	      break;
-	    case GL_UNSIGNED_SHORT_1_5_5_5_REV:
-	      for (k = 0; k < 4; k++) {
-		 shoveComponents[k]= *iter2++ / 65535.0;
-	      }
-	      shove1555rev(shoveComponents,0,(void *)&widget.us[0]);
-	      if (myswapBytes) {
-		 iter[0] = widget.ub[1];
-		 iter[1] = widget.ub[0];
-	      } else {
-		 *(GLushort *)iter = widget.us[0];
-	      }
-	      break;
-	    case GL_UNSIGNED_SHORT:
-	    case GL_SHORT:
-	      if (type == GL_SHORT) {
-		  if (indexFormat) {
-		      widget.s[0] = *iter2++;
-		  } else {
-		      widget.s[0] = *iter2++ >> 1;
-		  }
-	      } else {
-		  widget.us[0] = *iter2++;
-	      }
-	      if (myswapBytes) {
-		  iter[0] = widget.ub[1];
-		  iter[1] = widget.ub[0];
-	      } else {
-		  iter[0] = widget.ub[0];
-		  iter[1] = widget.ub[1];
-	      }
-	      break;
-	    case GL_UNSIGNED_INT_8_8_8_8:
-	       for (k = 0; k < 4; k++) {
-		  shoveComponents[k]= *iter2++ / 65535.0;
-	       }
-	       shove8888(shoveComponents,0,(void *)&widget.ui);
-	       if (myswapBytes) {
-		   iter[3] = widget.ub[0];
-		   iter[2] = widget.ub[1];
-		   iter[1] = widget.ub[2];
-		   iter[0] = widget.ub[3];
-	       } else {
-		   *(GLuint *)iter= widget.ui;
-	       }
-	       break;
-	    case GL_UNSIGNED_INT_8_8_8_8_REV:
-	       for (k = 0; k < 4; k++) {
-		  shoveComponents[k]= *iter2++ / 65535.0;
-	       }
-	       shove8888rev(shoveComponents,0,(void *)&widget.ui);
-	       if (myswapBytes) {
-		   iter[3] = widget.ub[0];
-		   iter[2] = widget.ub[1];
-		   iter[1] = widget.ub[2];
-		   iter[0] = widget.ub[3];
-	       } else {
-		   *(GLuint *)iter= widget.ui;
-	       }
-	       break;
-	    case GL_UNSIGNED_INT_10_10_10_2:
-	       for (k = 0; k < 4; k++) {
-		  shoveComponents[k]= *iter2++ / 65535.0;
-	       }
-	       shove1010102(shoveComponents,0,(void *)&widget.ui);
-	       if (myswapBytes) {
-		   iter[3] = widget.ub[0];
-		   iter[2] = widget.ub[1];
-		   iter[1] = widget.ub[2];
-		   iter[0] = widget.ub[3];
-	       } else {
-		   *(GLuint *)iter= widget.ui;
-	       }
-	       break;
-	    case GL_UNSIGNED_INT_2_10_10_10_REV:
-	       for (k = 0; k < 4; k++) {
-		  shoveComponents[k]= *iter2++ / 65535.0;
-	       }
-	       shove2101010rev(shoveComponents,0,(void *)&widget.ui);
-	       if (myswapBytes) {
-		   iter[3] = widget.ub[0];
-		   iter[2] = widget.ub[1];
-		   iter[1] = widget.ub[2];
-		   iter[0] = widget.ub[3];
-	       } else {
-		   *(GLuint *)iter= widget.ui;
-	       }
-	       break;
-	    case GL_INT:
-	    case GL_UNSIGNED_INT:
-	    case GL_FLOAT:
-	      if (type == GL_FLOAT) {
-		  if (indexFormat) {
-		      widget.f = *iter2++;
-		  } else {
-		      widget.f = *iter2++ / (float) 65535.0;
-		  }
-	      } else if (type == GL_UNSIGNED_INT) {
-		  if (indexFormat) {
-		      widget.ui = *iter2++;
-		  } else {
-		      widget.ui = (unsigned int) *iter2++ * 65537;
-		  }
-	      } else {
-		  if (indexFormat) {
-		      widget.i = *iter2++;
-		  } else {
-		      widget.i = ((unsigned int) *iter2++ * 65537)/2;
-		  }
-	      }
-	      if (myswapBytes) {
-		  iter[3] = widget.ub[0];
-		  iter[2] = widget.ub[1];
-		  iter[1] = widget.ub[2];
-		  iter[0] = widget.ub[3];
-	      } else {
-		  iter[0] = widget.ub[0];
-		  iter[1] = widget.ub[1];
-		  iter[2] = widget.ub[2];
-		  iter[3] = widget.ub[3];
-	      }
-	      break;
-	    default:
-	       assert(0);
-	    }
-
-	    iter+= elementSize;
-	 }  /* for jj */
-
-	 rowStart+= rowSize;
-      } /* for ii */
-
-      start+= imageSize;
-   } /* for dd */
-
-   /* iterators should be one byte past end */
-   if (!isTypePackedPixel(type)) {
-      assert(iter2 == &oldImage[width*height*depth*components]);
-   }
-   else {
-      assert(iter2 == &oldImage[width*height*depth*
-				elements_per_group(format,0)]);
-   }
-   assert( iter == &((GLubyte *)userImage)[rowSize*height*depth +
-					psm->unpack_skip_rows * rowSize +
-					psm->unpack_skip_pixels * groupSize +
-					/*3dstuff*/
-					psm->unpack_skip_images * imageSize] );
-} /* emptyImage3D() */
-
-static
-int gluScaleImage3D(GLenum format,
-		    GLint widthIn, GLint heightIn, GLint depthIn,
-		    GLenum typeIn, const void *dataIn,
-		    GLint widthOut, GLint heightOut, GLint depthOut,
-		    GLenum typeOut, void *dataOut)
-{
-   int components;
-   GLushort *beforeImage, *afterImage;
-   PixelStorageModes psm;
-
-   if (widthIn == 0 || heightIn == 0 || depthIn == 0 ||
-       widthOut == 0 || heightOut == 0 || depthOut == 0) {
-      return 0;
-   }
-
-   if (widthIn < 0 || heightIn < 0 || depthIn < 0 ||
-       widthOut < 0 || heightOut < 0 || depthOut < 0) {
-      return GLU_INVALID_VALUE;
-   }
-
-   if (!legalFormat(format) || !legalType(typeIn) || !legalType(typeOut) ||
-       typeIn == GL_BITMAP || typeOut == GL_BITMAP) {
-      return GLU_INVALID_ENUM;
-   }
-   if (!isLegalFormatForPackedPixelType(format, typeIn)) {
-      return GLU_INVALID_OPERATION;
-   }
-   if (!isLegalFormatForPackedPixelType(format, typeOut)) {
-      return GLU_INVALID_OPERATION;
-   }
-
-   beforeImage = malloc(imageSize3D(widthIn, heightIn, depthIn, format,
-				    GL_UNSIGNED_SHORT));
-   afterImage = malloc(imageSize3D(widthOut, heightOut, depthOut, format,
-				   GL_UNSIGNED_SHORT));
-   if (beforeImage == NULL || afterImage == NULL) {
-       free(beforeImage);
-       free(afterImage);
-       return GLU_OUT_OF_MEMORY;
-   }
-   retrieveStoreModes3D(&psm);
-
-   fillImage3D(&psm,widthIn,heightIn,depthIn,format,typeIn, is_index(format),
-	       dataIn, beforeImage);
-   components = elements_per_group(format,0);
-   scaleInternal3D(components,widthIn,heightIn,depthIn,beforeImage,
-		   widthOut,heightOut,depthOut,afterImage);
-   emptyImage3D(&psm,widthOut,heightOut,depthOut,format,typeOut,
-		is_index(format),afterImage, dataOut);
-   free((void *) beforeImage);
-   free((void *) afterImage);
-
-   return 0;
-} /* gluScaleImage3D() */
-
-
-static void closestFit3D(GLenum target, GLint width, GLint height, GLint depth,
-			 GLint internalFormat, GLenum format, GLenum type,
-			 GLint *newWidth, GLint *newHeight, GLint *newDepth)
-{
-   GLint widthPowerOf2= nearestPower(width);
-   GLint heightPowerOf2= nearestPower(height);	        
-   GLint depthPowerOf2= nearestPower(depth);
-   GLint proxyWidth;
-
-   do {
-      /* compute level 1 width & height & depth, clamping each at 1 */
-      GLint widthAtLevelOne= (widthPowerOf2 > 1) ?
-			      widthPowerOf2 >> 1 :
-			      widthPowerOf2;
-      GLint heightAtLevelOne= (heightPowerOf2 > 1) ?
-			       heightPowerOf2 >> 1 :
-			       heightPowerOf2;
-      GLint depthAtLevelOne= (depthPowerOf2 > 1) ?
-			      depthPowerOf2 >> 1 :
-			      depthPowerOf2;
-      GLenum proxyTarget = GL_PROXY_TEXTURE_3D;
-      assert(widthAtLevelOne > 0);
-      assert(heightAtLevelOne > 0);
-      assert(depthAtLevelOne > 0);
-
-      /* does width x height x depth at level 1 & all their mipmaps fit? */
-      assert(target == GL_TEXTURE_3D || target == GL_PROXY_TEXTURE_3D);
-      gluTexImage3D(proxyTarget, 1, /* must be non-zero */
-                    internalFormat,
-                    widthAtLevelOne,heightAtLevelOne,depthAtLevelOne,
-                    0,format,type,NULL);
-      glGetTexLevelParameteriv(proxyTarget, 1,GL_TEXTURE_WIDTH,&proxyWidth);
-      /* does it fit??? */
-      if (proxyWidth == 0) { /* nope, so try again with these sizes */
-	 if (widthPowerOf2 == 1 && heightPowerOf2 == 1 &&
-	     depthPowerOf2 == 1) {
-	    *newWidth= *newHeight= *newDepth= 1; /* must fit 1x1x1 texture */
-	    return;
-	 }
-	 widthPowerOf2= widthAtLevelOne;
-	 heightPowerOf2= heightAtLevelOne;
-	 depthPowerOf2= depthAtLevelOne;
-      }
-      /* else it does fit */
-   } while (proxyWidth == 0);
-   /* loop must terminate! */
-
-   /* return the width & height at level 0 that fits */
-   *newWidth= widthPowerOf2;
-   *newHeight= heightPowerOf2;
-   *newDepth= depthPowerOf2;
-/*printf("Proxy Textures\n");*/
-} /* closestFit3D() */
-
-static void halveImagePackedPixelSlice(int components,
-				       void (*extractPackedPixel)
-				       (int, const void *,GLfloat []),
-				       void (*shovePackedPixel)
-				       (const GLfloat [],int, void *),
-				       GLint width, GLint height, GLint depth,
-				       const void *dataIn, void *dataOut,
-				       GLint pixelSizeInBytes,
-				       GLint rowSizeInBytes,
-				       GLint imageSizeInBytes,
-				       GLint isSwap)
-{
-   int ii, jj;
-   int halfWidth= width / 2;
-   int halfHeight= height / 2;
-   int halfDepth= depth / 2;
-   const char *src= (const char *)dataIn;
-   int outIndex= 0;
-
-   assert((width == 1 || height == 1) && depth >= 2);
-
-   if (width == height) {	/* a 1-pixel column viewed from top */
-      assert(width == 1 && height == 1);
-      assert(depth >= 2);
-
-      for (ii= 0; ii< halfDepth; ii++) {
-	 float totals[4];
-	 float extractTotals[BOX2][4];
-	 int cc;
-
-	 (*extractPackedPixel)(isSwap,src,&extractTotals[0][0]);
-	 (*extractPackedPixel)(isSwap,(src+imageSizeInBytes),
-			       &extractTotals[1][0]);
-	 for (cc = 0; cc < components; cc++) {
-	    int kk;
-
-	    /* average 2 pixels since only a column */
-	    totals[cc]= 0.0;
-	    /* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED];
-	     * totals[RED]/= 2.0;
-	     */
-	    for (kk = 0; kk < BOX2; kk++) {
-	      totals[cc]+= extractTotals[kk][cc];
-	    }
-	    totals[cc]/= (float)BOX2;
-	 } /* for cc */
-        
-	 (*shovePackedPixel)(totals,outIndex,dataOut);
-	 outIndex++;
-	 /* skip over to next group of 2 */
-	 src+= imageSizeInBytes + imageSizeInBytes;
-      } /* for ii */
-   }
-   else if (height == 1) {	/* horizontal slice viewed from top */
-      assert(width != 1);
-
-      for (ii= 0; ii< halfDepth; ii++) {
-	 for (jj= 0; jj< halfWidth; jj++) {
-	     float totals[4];
-	     float extractTotals[BOX4][4];
-	     int cc;
-
-	     (*extractPackedPixel)(isSwap,src,
-				   &extractTotals[0][0]);
-	     (*extractPackedPixel)(isSwap,(src+pixelSizeInBytes),
-				   &extractTotals[1][0]);
-	     (*extractPackedPixel)(isSwap,(src+imageSizeInBytes),
-				   &extractTotals[2][0]);
-	     (*extractPackedPixel)(isSwap,
-				   (src+imageSizeInBytes+pixelSizeInBytes),
-				   &extractTotals[3][0]);
-	     for (cc = 0; cc < components; cc++) {
-		int kk;
-
-		/* grab 4 pixels to average */
-		totals[cc]= 0.0;
-		/* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED]+
-		 *		extractTotals[2][RED]+extractTotals[3][RED];
-		 * totals[RED]/= 4.0;
-		 */
-		for (kk = 0; kk < BOX4; kk++) {
-		   totals[cc]+= extractTotals[kk][cc];
-		}
-		totals[cc]/= (float)BOX4;
-	     }
-	     (*shovePackedPixel)(totals,outIndex,dataOut);
-
-	     outIndex++;
-	     /* skip over to next horizontal square of 4 */
-	     src+= imageSizeInBytes + imageSizeInBytes;
-	 }
-      }
-
-      /* assert() */
-   }
-   else if (width == 1) {	/* vertical slice viewed from top */
-      assert(height != 1);
-
-      for (ii= 0; ii< halfDepth; ii++) {
-	 for (jj= 0; jj< halfHeight; jj++) {
-	    float totals[4];
-	    float extractTotals[BOX4][4];
-	    int cc;
-
-	    (*extractPackedPixel)(isSwap,src,
-				  &extractTotals[0][0]);
-	    (*extractPackedPixel)(isSwap,(src+rowSizeInBytes),
-				  &extractTotals[1][0]);
-	    (*extractPackedPixel)(isSwap,(src+imageSizeInBytes),
-				  &extractTotals[2][0]);
-	    (*extractPackedPixel)(isSwap,
-				  (src+imageSizeInBytes+rowSizeInBytes),
-				  &extractTotals[3][0]);
-	    for (cc = 0; cc < components; cc++) {
-	       int kk;
-
-	       /* grab 4 pixels to average */
-	       totals[cc]= 0.0;
-	       /* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED]+
-		*	       extractTotals[2][RED]+extractTotals[3][RED];
-		* totals[RED]/= 4.0;
-		*/
-	       for (kk = 0; kk < BOX4; kk++) {
-		  totals[cc]+= extractTotals[kk][cc];
-	       }
-	       totals[cc]/= (float)BOX4;
-	    }
-	    (*shovePackedPixel)(totals,outIndex,dataOut);
-
-	    outIndex++;
-
-	    /* skip over to next vertical square of 4 */
-	    src+= imageSizeInBytes + imageSizeInBytes;
-	 }
-      }
-      /* assert() */
-   }
-
-} /* halveImagePackedPixelSlice() */
-
-static void halveImagePackedPixel3D(int components,
-				    void (*extractPackedPixel)
-				    (int, const void *,GLfloat []),
-				    void (*shovePackedPixel)
-				    (const GLfloat [],int, void *),
-				    GLint width, GLint height, GLint depth,
-				    const void *dataIn, void *dataOut,
-				    GLint pixelSizeInBytes,
-				    GLint rowSizeInBytes,
-				    GLint imageSizeInBytes,
-				    GLint isSwap)
-{
-   if (depth == 1) {
-      assert(1 <= width && 1 <= height);
-
-      halveImagePackedPixel(components,extractPackedPixel,shovePackedPixel,
-			    width,height,dataIn,dataOut,pixelSizeInBytes,
-			    rowSizeInBytes,isSwap);
-      return;
-   }
-   /* a horizontal or vertical slice viewed from top */
-   else if (width == 1 || height == 1) {
-      assert(1 <= depth);
-
-      halveImagePackedPixelSlice(components,
-				 extractPackedPixel,shovePackedPixel,
-				 width, height, depth, dataIn, dataOut,
-				 pixelSizeInBytes, rowSizeInBytes,
-				 imageSizeInBytes, isSwap);
-      return;
-   }
-   {
-      int ii, jj, dd;
-
-      int halfWidth= width / 2;
-      int halfHeight= height / 2;
-      int halfDepth= depth / 2;
-      const char *src= (const char *) dataIn;
-      int padBytes= rowSizeInBytes - (width*pixelSizeInBytes);
-      int outIndex= 0;
-
-      for (dd= 0; dd < halfDepth; dd++) {
-	 for (ii= 0; ii< halfHeight; ii++) {
-	    for (jj= 0; jj< halfWidth; jj++) {
-#define BOX8 8
-	       float totals[4]; /* 4 is maximum components */
-	       float extractTotals[BOX8][4]; /* 4 is maximum components */
-	       int cc;
-
-	       (*extractPackedPixel)(isSwap,src,
-				     &extractTotals[0][0]);
-	       (*extractPackedPixel)(isSwap,(src+pixelSizeInBytes),
-				     &extractTotals[1][0]);
-	       (*extractPackedPixel)(isSwap,(src+rowSizeInBytes),
-				     &extractTotals[2][0]);
-	       (*extractPackedPixel)(isSwap,
-				     (src+rowSizeInBytes+pixelSizeInBytes),
-				     &extractTotals[3][0]);
-
-	       (*extractPackedPixel)(isSwap,(src+imageSizeInBytes),
-				     &extractTotals[4][0]);
-	       (*extractPackedPixel)(isSwap,(src+pixelSizeInBytes+imageSizeInBytes),
-				     &extractTotals[5][0]);
-	       (*extractPackedPixel)(isSwap,(src+rowSizeInBytes+imageSizeInBytes),
-				     &extractTotals[6][0]);
-	       (*extractPackedPixel)(isSwap,
-				     (src+rowSizeInBytes+pixelSizeInBytes+imageSizeInBytes),
-				     &extractTotals[7][0]);
-	       for (cc = 0; cc < components; cc++) {
-		  int kk;
-
-		  /* grab 8 pixels to average */
-		  totals[cc]= 0.0;
-		  /* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED]+
-		   *		  extractTotals[2][RED]+extractTotals[3][RED]+
-		   *		  extractTotals[4][RED]+extractTotals[5][RED]+
-		   *		  extractTotals[6][RED]+extractTotals[7][RED];
-		   * totals[RED]/= 8.0;
-		   */
-		  for (kk = 0; kk < BOX8; kk++) {
-		     totals[cc]+= extractTotals[kk][cc];
-		  }
-		  totals[cc]/= (float)BOX8;
-	       }
-	       (*shovePackedPixel)(totals,outIndex,dataOut);
-
-	       outIndex++;
-	       /* skip over to next square of 4 */
-	       src+= pixelSizeInBytes + pixelSizeInBytes;
-	    }
-	    /* skip past pad bytes, if any, to get to next row */
-	    src+= padBytes;
-
-	    /* src is at beginning of a row here, but it's the second row of
-	     * the square block of 4 pixels that we just worked on so we
-	     * need to go one more row.
-	     * i.e.,
-	     *			 OO...
-	     *		 here -->OO...
-	     *	     but want -->OO...
-	     *			 OO...
-	     *			 ...
-	     */
-	    src+= rowSizeInBytes;
-	 }
-
-	 src+= imageSizeInBytes;
-      } /* for dd */
-
-      /* both pointers must reach one byte after the end */
-      assert(src == &((const char *)dataIn)[rowSizeInBytes*height*depth]);
-      assert(outIndex == halfWidth * halfHeight * halfDepth);
-   } /* for dd */
-
-} /* halveImagePackedPixel3D() */
-
-static int gluBuild3DMipmapLevelsCore(GLenum target, GLint internalFormat,
-				      GLsizei width,
-				      GLsizei height,
-				      GLsizei depth,
-				      GLsizei widthPowerOf2,
-				      GLsizei heightPowerOf2,
-				      GLsizei depthPowerOf2,
-				      GLenum format, GLenum type,
-				      GLint userLevel,
-				      GLint baseLevel,GLint maxLevel,
-				      const void *data)
-{
-   GLint newWidth, newHeight, newDepth;
-   GLint level, levels;
-   const void *usersImage;
-   void *srcImage, *dstImage;
-   __GLU_INIT_SWAP_IMAGE;
-   GLint memReq;
-   GLint cmpts;
-
-   GLint myswapBytes, groupsPerLine, elementSize, groupSize;
-   GLint rowsPerImage, imageSize;
-   GLint rowSize, padding;
-   PixelStorageModes psm;
-
-   assert(checkMipmapArgs(internalFormat,format,type) == 0);
-   assert(width >= 1 && height >= 1 && depth >= 1);
-   assert(type != GL_BITMAP);
-
-   srcImage = dstImage = NULL;
-
-   newWidth= widthPowerOf2;
-   newHeight= heightPowerOf2;
-   newDepth= depthPowerOf2;
-   levels = computeLog(newWidth);
-   level = computeLog(newHeight);
-   if (level > levels) levels=level;
-   level = computeLog(newDepth);
-   if (level > levels) levels=level;
-
-   levels+= userLevel;
-
-   retrieveStoreModes3D(&psm);
-   myswapBytes = psm.unpack_swap_bytes;
-   cmpts = elements_per_group(format,type);
-   if (psm.unpack_row_length > 0) {
-       groupsPerLine = psm.unpack_row_length;
-   } else {
-       groupsPerLine = width;
-   }
-
-   elementSize = bytes_per_element(type);
-   groupSize = elementSize * cmpts;
-   if (elementSize == 1) myswapBytes = 0;
-
-   /* 3dstuff begin */
-   if (psm.unpack_image_height > 0) {
-      rowsPerImage= psm.unpack_image_height;
-   }
-   else {
-      rowsPerImage= height;
-   }
-
-   /* 3dstuff end */
-   rowSize = groupsPerLine * groupSize;
-   padding = (rowSize % psm.unpack_alignment);
-   if (padding) {
-       rowSize += psm.unpack_alignment - padding;
-   }
-
-   imageSize= rowsPerImage * rowSize; /* 3dstuff */
-
-   usersImage = (const GLubyte *)data + psm.unpack_skip_rows * rowSize +
-				  psm.unpack_skip_pixels * groupSize +
-				  /* 3dstuff */
-				  psm.unpack_skip_images * imageSize;
-
-   glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
-   glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
-   glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
-   glPixelStorei(GL_UNPACK_SKIP_IMAGES, 0);
-   glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, 0);
-
-   level = userLevel;
-
-   if (width == newWidth && height == newHeight && depth == newDepth) {
-       /* Use usersImage for level userLevel */
-       if (baseLevel <= level && level <= maxLevel) {
-	  gluTexImage3D(target, level, internalFormat, width,
-		       height, depth, 0, format, type,
-		       usersImage);
-       }
-       if(levels == 0) { /* we're done. clean up and return */
-	 glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
-	 glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
-	 glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
-	 glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
-	 glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
-	 glPixelStorei(GL_UNPACK_SKIP_IMAGES, psm.unpack_skip_images);
-	 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, psm.unpack_image_height);
-	 return 0;
-       }
-       {
-	  int nextWidth= newWidth/2;
-	  int nextHeight= newHeight/2;
-	  int nextDepth= newDepth/2;
-
-	  /* clamp to 1 */
-	  if (nextWidth < 1) nextWidth= 1;
-	  if (nextHeight < 1) nextHeight= 1;
-	  if (nextDepth < 1) nextDepth= 1;      
-       memReq = imageSize3D(nextWidth, nextHeight, nextDepth, format, type);
-       }
-       switch(type) {
-       case GL_UNSIGNED_BYTE:
-	 dstImage = (GLubyte *)malloc(memReq);
-	 break;
-       case GL_BYTE:
-	 dstImage = (GLbyte *)malloc(memReq);
-	 break;
-       case GL_UNSIGNED_SHORT:
-	 dstImage = (GLushort *)malloc(memReq);
-	 break;
-       case GL_SHORT:
-	 dstImage = (GLshort *)malloc(memReq);
-	 break;
-       case GL_UNSIGNED_INT:
-	 dstImage = (GLuint *)malloc(memReq);
-	 break;
-       case GL_INT:
-	 dstImage = (GLint *)malloc(memReq);
-	 break;
-       case GL_FLOAT:
-	 dstImage = (GLfloat *)malloc(memReq);
-	 break;
-       case GL_UNSIGNED_BYTE_3_3_2:
-       case GL_UNSIGNED_BYTE_2_3_3_REV:
-	 dstImage = (GLubyte *)malloc(memReq);
-	 break;
-       case GL_UNSIGNED_SHORT_5_6_5:
-       case GL_UNSIGNED_SHORT_5_6_5_REV:
-       case GL_UNSIGNED_SHORT_4_4_4_4:
-       case GL_UNSIGNED_SHORT_4_4_4_4_REV:
-       case GL_UNSIGNED_SHORT_5_5_5_1:
-       case GL_UNSIGNED_SHORT_1_5_5_5_REV:
-	 dstImage = (GLushort *)malloc(memReq);
-	 break;
-       case GL_UNSIGNED_INT_8_8_8_8:
-       case GL_UNSIGNED_INT_8_8_8_8_REV:
-       case GL_UNSIGNED_INT_10_10_10_2:
-       case GL_UNSIGNED_INT_2_10_10_10_REV:
-	 dstImage = (GLuint *)malloc(memReq);   
-	 break;
-       default:
-	 return GLU_INVALID_ENUM; /* assertion */
-       }
-       if (dstImage == NULL) {
-	 glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
-	 glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
-	 glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
-	 glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
-	 glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
-	 glPixelStorei(GL_UNPACK_SKIP_IMAGES, psm.unpack_skip_images);
-	 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, psm.unpack_image_height);
-	 return GLU_OUT_OF_MEMORY;
-       }
-       else
-	 switch(type) {
-	 case GL_UNSIGNED_BYTE:
-	   if (depth > 1) {
-	     halveImage3D(cmpts,extractUbyte,shoveUbyte,
-			  width,height,depth,
-			  usersImage,dstImage,elementSize,groupSize,rowSize,
-			  imageSize,myswapBytes);
-	   }
-	   else {
-	     halveImage_ubyte(cmpts,width,height,usersImage,dstImage,
-			      elementSize,rowSize,groupSize);
-	   }
-	   break;
-	 case GL_BYTE:
-	   if (depth > 1) {
-	   halveImage3D(cmpts,extractSbyte,shoveSbyte,
-			width,height,depth,
-			usersImage,dstImage,elementSize,groupSize,rowSize,
-			imageSize,myswapBytes);
-	   }
-	   else {
-	     halveImage_byte(cmpts,width,height,usersImage,dstImage,
-			     elementSize,rowSize,groupSize);
-	   }
-	   break;
-	 case GL_UNSIGNED_SHORT:
-	   if (depth > 1) {
-	   halveImage3D(cmpts,extractUshort,shoveUshort,
-			width,height,depth,
-			usersImage,dstImage,elementSize,groupSize,rowSize,
-			imageSize,myswapBytes);
-	   }
-	   else {
-	     halveImage_ushort(cmpts,width,height,usersImage,dstImage,
-			       elementSize,rowSize,groupSize,myswapBytes);
-	   }
-	   break;
-	 case GL_SHORT:
-	   if (depth > 1) {
-	   halveImage3D(cmpts,extractSshort,shoveSshort,
-			width,height,depth,
-			usersImage,dstImage,elementSize,groupSize,rowSize,
-			imageSize,myswapBytes);
-	   }
-	   else {
-	     halveImage_short(cmpts,width,height,usersImage,dstImage,
-			      elementSize,rowSize,groupSize,myswapBytes);
-	   }
-	   break;
-	 case GL_UNSIGNED_INT:
-	   if (depth > 1) {
-	   halveImage3D(cmpts,extractUint,shoveUint,
-			width,height,depth,
-			usersImage,dstImage,elementSize,groupSize,rowSize,
-			imageSize,myswapBytes);
-	   }
-	   else {
-	     halveImage_uint(cmpts,width,height,usersImage,dstImage,
-			     elementSize,rowSize,groupSize,myswapBytes);
-	   }
-	   break;
-	 case GL_INT:
-	   if (depth > 1) {
-	   halveImage3D(cmpts,extractSint,shoveSint,
-			width,height,depth,
-			usersImage,dstImage,elementSize,groupSize,rowSize,
-			imageSize,myswapBytes);
-	   }
-	   else {
-	     halveImage_int(cmpts,width,height,usersImage,dstImage,
-			    elementSize,rowSize,groupSize,myswapBytes);
-	   }
-	   break;
-	 case GL_FLOAT:
-	   if (depth > 1 ) {
-	   halveImage3D(cmpts,extractFloat,shoveFloat,
-			width,height,depth,
-			usersImage,dstImage,elementSize,groupSize,rowSize,
-			imageSize,myswapBytes);
-	   }
-	   else {
-	     halveImage_float(cmpts,width,height,usersImage,dstImage,
-			      elementSize,rowSize,groupSize,myswapBytes);
-	   }
-	   break;
-	 case GL_UNSIGNED_BYTE_3_3_2:
-	   assert(format == GL_RGB);
-	   halveImagePackedPixel3D(3,extract332,shove332,
-				   width,height,depth,usersImage,dstImage,
-				   elementSize,rowSize,imageSize,myswapBytes);
-	   break;
-	 case GL_UNSIGNED_BYTE_2_3_3_REV:
-	   assert(format == GL_RGB);
-	   halveImagePackedPixel3D(3,extract233rev,shove233rev,
-				   width,height,depth,usersImage,dstImage,
-				   elementSize,rowSize,imageSize,myswapBytes);
-	   break;
-	 case GL_UNSIGNED_SHORT_5_6_5:
-	   halveImagePackedPixel3D(3,extract565,shove565,
-				   width,height,depth,usersImage,dstImage,
-				   elementSize,rowSize,imageSize,myswapBytes);
-	   break;
-	 case GL_UNSIGNED_SHORT_5_6_5_REV:
-	   halveImagePackedPixel3D(3,extract565rev,shove565rev,
-				   width,height,depth,usersImage,dstImage,
-				   elementSize,rowSize,imageSize,myswapBytes);
-	   break;
-	 case GL_UNSIGNED_SHORT_4_4_4_4:
-	   halveImagePackedPixel3D(4,extract4444,shove4444,
-				   width,height,depth,usersImage,dstImage,
-				   elementSize,rowSize,imageSize,myswapBytes);
-	   break;
-	 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
-	   halveImagePackedPixel3D(4,extract4444rev,shove4444rev,
-				   width,height,depth,usersImage,dstImage,
-				   elementSize,rowSize,imageSize,myswapBytes);
-	   break;
-	 case GL_UNSIGNED_SHORT_5_5_5_1:
-	   halveImagePackedPixel3D(4,extract5551,shove5551,
-				   width,height,depth,usersImage,dstImage,
-				   elementSize,rowSize,imageSize,myswapBytes);
-	   break;
-	 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
-	   halveImagePackedPixel3D(4,extract1555rev,shove1555rev,
-				   width,height,depth,usersImage,dstImage,
-				   elementSize,rowSize,imageSize,myswapBytes);
-	   break;
-	 case GL_UNSIGNED_INT_8_8_8_8:
-	   halveImagePackedPixel3D(4,extract8888,shove8888,
-				   width,height,depth,usersImage,dstImage,
-				   elementSize,rowSize,imageSize,myswapBytes);
-	   break;
-	 case GL_UNSIGNED_INT_8_8_8_8_REV:
-	   halveImagePackedPixel3D(4,extract8888rev,shove8888rev,
-				   width,height,depth,usersImage,dstImage,
-				   elementSize,rowSize,imageSize,myswapBytes);
-	   break;
-	 case GL_UNSIGNED_INT_10_10_10_2:
-	   halveImagePackedPixel3D(4,extract1010102,shove1010102,
-				   width,height,depth,usersImage,dstImage,
-				   elementSize,rowSize,imageSize,myswapBytes);
-	   break;
-	 case GL_UNSIGNED_INT_2_10_10_10_REV:
-	   halveImagePackedPixel3D(4,extract2101010rev,shove2101010rev,
-				   width,height,depth,usersImage,dstImage,
-				   elementSize,rowSize,imageSize,myswapBytes);
-	   break;
-	 default:
-	   assert(0);
-	   break;
-	 }
-       newWidth = width/2;
-       newHeight = height/2;
-       newDepth = depth/2;
-       /* clamp to 1 */
-       if (newWidth < 1) newWidth= 1;
-       if (newHeight < 1) newHeight= 1;
-       if (newDepth < 1) newDepth= 1;
-
-       myswapBytes = 0;
-       rowSize = newWidth * groupSize;
-       imageSize= rowSize * newHeight; /* 3dstuff */
-       memReq = imageSize3D(newWidth, newHeight, newDepth, format, type);
-       /* Swap srcImage and dstImage */
-       __GLU_SWAP_IMAGE(srcImage,dstImage);
-       switch(type) {
-       case GL_UNSIGNED_BYTE:
-	 dstImage = (GLubyte *)malloc(memReq);
-	 break;
-       case GL_BYTE:
-	 dstImage = (GLbyte *)malloc(memReq);
-	 break;
-       case GL_UNSIGNED_SHORT:
-	 dstImage = (GLushort *)malloc(memReq);
-	 break;
-       case GL_SHORT:
-	 dstImage = (GLshort *)malloc(memReq);
-	 break;
-       case GL_UNSIGNED_INT:
-	 dstImage = (GLuint *)malloc(memReq);
-	 break;
-       case GL_INT:
-	 dstImage = (GLint *)malloc(memReq);
-	 break;
-       case GL_FLOAT:
-	 dstImage = (GLfloat *)malloc(memReq);
-	 break;
-       case GL_UNSIGNED_BYTE_3_3_2:
-       case GL_UNSIGNED_BYTE_2_3_3_REV:
-	 dstImage = (GLubyte *)malloc(memReq);
-	 break;
-       case GL_UNSIGNED_SHORT_5_6_5:
-       case GL_UNSIGNED_SHORT_5_6_5_REV:
-       case GL_UNSIGNED_SHORT_4_4_4_4:
-       case GL_UNSIGNED_SHORT_4_4_4_4_REV:
-       case GL_UNSIGNED_SHORT_5_5_5_1:
-       case GL_UNSIGNED_SHORT_1_5_5_5_REV:
-	 dstImage = (GLushort *)malloc(memReq);
-	 break;
-       case GL_UNSIGNED_INT_8_8_8_8:
-       case GL_UNSIGNED_INT_8_8_8_8_REV:
-       case GL_UNSIGNED_INT_10_10_10_2:
-       case GL_UNSIGNED_INT_2_10_10_10_REV:
-	 dstImage = (GLuint *)malloc(memReq);
-	 break;
-       default:
-	 return GLU_INVALID_ENUM; /* assertion */
-       }
-       if (dstImage == NULL) {
-	 glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
-	 glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
-	 glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
-	 glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
-	 glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
-	 glPixelStorei(GL_UNPACK_SKIP_IMAGES, psm.unpack_skip_images);
-	 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, psm.unpack_image_height);
-	 free(srcImage);
-	 return GLU_OUT_OF_MEMORY;
-       }
-       /* level userLevel+1 is in srcImage; level userLevel already saved */
-       level = userLevel+1;
-   } else {/* user's image is *not* nice power-of-2 sized square */
-       memReq = imageSize3D(newWidth, newHeight, newDepth, format, type);
-       switch(type) {
-	   case GL_UNSIGNED_BYTE:
-	       dstImage = (GLubyte *)malloc(memReq);
-	       break;
-	   case GL_BYTE:
-	       dstImage = (GLbyte *)malloc(memReq);
-	       break;
-	   case GL_UNSIGNED_SHORT:
-	       dstImage = (GLushort *)malloc(memReq);
-	       break;
-	   case GL_SHORT:
-	       dstImage = (GLshort *)malloc(memReq);
-	       break;
-	   case GL_UNSIGNED_INT:
-	       dstImage = (GLuint *)malloc(memReq);
-	       break;
-	   case GL_INT:
-	       dstImage = (GLint *)malloc(memReq);
-	       break;
-	   case GL_FLOAT:
-	       dstImage = (GLfloat *)malloc(memReq);
-	       break;
-	   case GL_UNSIGNED_BYTE_3_3_2:
-	   case GL_UNSIGNED_BYTE_2_3_3_REV:
-	       dstImage = (GLubyte *)malloc(memReq);
-	       break;
-	   case GL_UNSIGNED_SHORT_5_6_5:
-	   case GL_UNSIGNED_SHORT_5_6_5_REV:
-	   case GL_UNSIGNED_SHORT_4_4_4_4:
-	   case GL_UNSIGNED_SHORT_4_4_4_4_REV:
-	   case GL_UNSIGNED_SHORT_5_5_5_1:
-	   case GL_UNSIGNED_SHORT_1_5_5_5_REV:
-	       dstImage = (GLushort *)malloc(memReq);
-	       break;
-	   case GL_UNSIGNED_INT_8_8_8_8:
-	   case GL_UNSIGNED_INT_8_8_8_8_REV:
-	   case GL_UNSIGNED_INT_10_10_10_2:
-	   case GL_UNSIGNED_INT_2_10_10_10_REV:
-	       dstImage = (GLuint *)malloc(memReq);
-	       break;
-	   default:
-	       return GLU_INVALID_ENUM; /* assertion */
-       }
-
-       if (dstImage == NULL) {
-	   glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
-	   glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
-	   glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
-	   glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
-	   glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
-	   glPixelStorei(GL_UNPACK_SKIP_IMAGES, psm.unpack_skip_images);
-	   glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, psm.unpack_image_height);
-	   return GLU_OUT_OF_MEMORY;
-       }
-       /*printf("Build3DMipmaps(): ScaleImage3D %d %d %d->%d %d %d\n",
-       width,height,depth,newWidth,newHeight,newDepth);*/
-
-       gluScaleImage3D(format, width, height, depth, type, usersImage,
-		       newWidth, newHeight, newDepth, type, dstImage);
-
-       myswapBytes = 0;
-       rowSize = newWidth * groupSize;
-       imageSize = rowSize * newHeight; /* 3dstuff */
-       /* Swap dstImage and srcImage */
-       __GLU_SWAP_IMAGE(srcImage,dstImage);
-
-       if(levels != 0) { /* use as little memory as possible */
-	 {
-	    int nextWidth= newWidth/2;
-	    int nextHeight= newHeight/2;
-	    int nextDepth= newDepth/2;
-	    if (nextWidth < 1) nextWidth= 1;
-	    if (nextHeight < 1) nextHeight= 1;  
-	    if (nextDepth < 1) nextDepth= 1;    
-
-	 memReq = imageSize3D(nextWidth, nextHeight, nextDepth, format, type);
-	 }
-	 switch(type) {
-	 case GL_UNSIGNED_BYTE:
-	   dstImage = (GLubyte *)malloc(memReq);
-	   break;
-	 case GL_BYTE:
-	   dstImage = (GLbyte *)malloc(memReq);
-	   break;
-	 case GL_UNSIGNED_SHORT:
-	   dstImage = (GLushort *)malloc(memReq);
-	   break;
-	 case GL_SHORT:
-	   dstImage = (GLshort *)malloc(memReq);
-	   break;
-	 case GL_UNSIGNED_INT:
-	   dstImage = (GLuint *)malloc(memReq);
-	   break;
-	 case GL_INT:
-	   dstImage = (GLint *)malloc(memReq);
-	   break;
-	 case GL_FLOAT:
-	   dstImage = (GLfloat *)malloc(memReq);
-	   break;
-	 case GL_UNSIGNED_BYTE_3_3_2:
-	 case GL_UNSIGNED_BYTE_2_3_3_REV:
-	   dstImage = (GLubyte *)malloc(memReq);
-	   break;
-	 case GL_UNSIGNED_SHORT_5_6_5:
-	 case GL_UNSIGNED_SHORT_5_6_5_REV:
-	 case GL_UNSIGNED_SHORT_4_4_4_4:
-	 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
-	 case GL_UNSIGNED_SHORT_5_5_5_1:
-	 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
-	   dstImage = (GLushort *)malloc(memReq);
-	   break;
-	 case GL_UNSIGNED_INT_8_8_8_8:
-	 case GL_UNSIGNED_INT_8_8_8_8_REV:
-	 case GL_UNSIGNED_INT_10_10_10_2:
-	 case GL_UNSIGNED_INT_2_10_10_10_REV:
-	   dstImage = (GLuint *)malloc(memReq);
-	   break;
-	 default:
-	   return GLU_INVALID_ENUM; /* assertion */
-	 }
-	 if (dstImage == NULL) {
-	   glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
-	   glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
-	   glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
-	   glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
-	   glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
-	   glPixelStorei(GL_UNPACK_SKIP_IMAGES, psm.unpack_skip_images);
-	   glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, psm.unpack_image_height);
-	   free(srcImage);
-	   return GLU_OUT_OF_MEMORY;
-	 }
-       }
-       /* level userLevel is in srcImage; nothing saved yet */
-       level = userLevel;       
-   }
-
-   glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE);
-   if (baseLevel <= level && level <= maxLevel) {
-     gluTexImage3D(target, level, internalFormat, newWidth, newHeight, newDepth,
-		  0,format, type, (void *)srcImage);
-   }
-   level++; /* update current level for the loop */
-   for (; level <= levels; level++) {
-       switch(type) {
-	   case GL_UNSIGNED_BYTE:
-	       if (newDepth > 1) {
-	       halveImage3D(cmpts,extractUbyte,shoveUbyte,
-			    newWidth,newHeight,newDepth,
-			    srcImage,dstImage,elementSize,groupSize,rowSize,
-			    imageSize,myswapBytes);
-	       }
-	       else {
-		 halveImage_ubyte(cmpts,newWidth,newHeight,srcImage,dstImage,
-				  elementSize,rowSize,groupSize);
-	       }
-	       break;
-	   case GL_BYTE:
-	       if (newDepth > 1) {
-	       halveImage3D(cmpts,extractSbyte,shoveSbyte,
-			    newWidth,newHeight,newDepth,
-			    srcImage,dstImage,elementSize,groupSize,rowSize,
-			    imageSize,myswapBytes);
-	       }
-	       else {
-		 halveImage_byte(cmpts,newWidth,newHeight,srcImage,dstImage,
-				  elementSize,rowSize,groupSize);
-	       }
-	       break;
-	   case GL_UNSIGNED_SHORT:
-	       if (newDepth > 1) {
-	       halveImage3D(cmpts,extractUshort,shoveUshort,
-			    newWidth,newHeight,newDepth,
-			    srcImage,dstImage,elementSize,groupSize,rowSize,
-			    imageSize,myswapBytes);
-	       }
-	       else {
-		 halveImage_ushort(cmpts,newWidth,newHeight,srcImage,dstImage,
-				   elementSize,rowSize,groupSize,myswapBytes);
-	       }
-	       break;
-	   case GL_SHORT:
-	       if (newDepth > 1) {
-	       halveImage3D(cmpts,extractSshort,shoveSshort,
-			    newWidth,newHeight,newDepth,
-			    srcImage,dstImage,elementSize,groupSize,rowSize,
-			    imageSize,myswapBytes);
-	       }
-	       else {
-		 halveImage_short(cmpts,newWidth,newHeight,srcImage,dstImage,
-				  elementSize,rowSize,groupSize,myswapBytes);
-	       }
-	       break;
-	   case GL_UNSIGNED_INT:
-	       if (newDepth > 1) {
-	       halveImage3D(cmpts,extractUint,shoveUint,
-			    newWidth,newHeight,newDepth,
-			    srcImage,dstImage,elementSize,groupSize,rowSize,
-			    imageSize,myswapBytes);
-	       }
-	       else {
-		 halveImage_uint(cmpts,newWidth,newHeight,srcImage,dstImage,
-				 elementSize,rowSize,groupSize,myswapBytes);
-	       }
-	       break;
-	   case GL_INT:
-	       if (newDepth > 1) {
-	       halveImage3D(cmpts,extractSint,shoveSint,
-			    newWidth,newHeight,newDepth,
-			    srcImage,dstImage,elementSize,groupSize,rowSize,
-			    imageSize,myswapBytes);
-	       }
-	       else {
-		 halveImage_int(cmpts,newWidth,newHeight,srcImage,dstImage,
-				elementSize,rowSize,groupSize,myswapBytes);
-	       }
-	       break;
-	   case GL_FLOAT:
-	       if (newDepth > 1) {
-	       halveImage3D(cmpts,extractFloat,shoveFloat,
-			    newWidth,newHeight,newDepth,
-			    srcImage,dstImage,elementSize,groupSize,rowSize,
-			    imageSize,myswapBytes);
-	       }
-	       else {
-		 halveImage_float(cmpts,newWidth,newHeight,srcImage,dstImage,
-				  elementSize,rowSize,groupSize,myswapBytes);
-	       }
-	       break;
-	   case GL_UNSIGNED_BYTE_3_3_2:
-	       halveImagePackedPixel3D(3,extract332,shove332,
-				       newWidth,newHeight,newDepth,
-				       srcImage,dstImage,elementSize,rowSize,
-				       imageSize,myswapBytes);
-	       break;
-	   case GL_UNSIGNED_BYTE_2_3_3_REV:
-	       halveImagePackedPixel3D(3,extract233rev,shove233rev,
-				       newWidth,newHeight,newDepth,
-				       srcImage,dstImage,elementSize,rowSize,
-				       imageSize,myswapBytes);
-	       break;
-	   case GL_UNSIGNED_SHORT_5_6_5:
-	       halveImagePackedPixel3D(3,extract565,shove565,
-				       newWidth,newHeight,newDepth,
-				       srcImage,dstImage,elementSize,rowSize,
-				       imageSize,myswapBytes);
-	       break;
-	   case GL_UNSIGNED_SHORT_5_6_5_REV:
-	       halveImagePackedPixel3D(3,extract565rev,shove565rev,
-				       newWidth,newHeight,newDepth,
-				       srcImage,dstImage,elementSize,rowSize,
-				       imageSize,myswapBytes);
-	       break;
-	   case GL_UNSIGNED_SHORT_4_4_4_4:
-	       halveImagePackedPixel3D(4,extract4444,shove4444,
-				       newWidth,newHeight,newDepth,
-				       srcImage,dstImage,elementSize,rowSize,
-				       imageSize,myswapBytes);
-	       break;
-	   case GL_UNSIGNED_SHORT_4_4_4_4_REV:
-	       halveImagePackedPixel3D(4,extract4444rev,shove4444rev,
-				       newWidth,newHeight,newDepth,
-				       srcImage,dstImage,elementSize,rowSize,
-				       imageSize,myswapBytes);
-	       break;
-	   case GL_UNSIGNED_SHORT_5_5_5_1:	        
-	       halveImagePackedPixel3D(4,extract5551,shove5551,
-				       newWidth,newHeight,newDepth,
-				       srcImage,dstImage,elementSize,rowSize,
-				       imageSize,myswapBytes);
-	       break;
-	   case GL_UNSIGNED_SHORT_1_5_5_5_REV:	        
-	       halveImagePackedPixel3D(4,extract1555rev,shove1555rev,
-				       newWidth,newHeight,newDepth,
-				       srcImage,dstImage,elementSize,rowSize,
-				       imageSize,myswapBytes);
-	       break;
-	   case GL_UNSIGNED_INT_8_8_8_8:
-	       halveImagePackedPixel3D(4,extract8888,shove8888,
-				       newWidth,newHeight,newDepth,
-				       srcImage,dstImage,elementSize,rowSize,
-				       imageSize,myswapBytes);
-	       break;
-	   case GL_UNSIGNED_INT_8_8_8_8_REV:
-	       halveImagePackedPixel3D(4,extract8888rev,shove8888rev,
-				       newWidth,newHeight,newDepth,
-				       srcImage,dstImage,elementSize,rowSize,
-				       imageSize,myswapBytes);
-	       break;
-	   case GL_UNSIGNED_INT_10_10_10_2:
-	       halveImagePackedPixel3D(4,extract1010102,shove1010102,
-				       newWidth,newHeight,newDepth,
-				       srcImage,dstImage,elementSize,rowSize,
-				       imageSize,myswapBytes);
-	       break;
-	   case GL_UNSIGNED_INT_2_10_10_10_REV:
-	       halveImagePackedPixel3D(4,extract2101010rev,shove2101010rev,
-				       newWidth,newHeight,newDepth,
-				       srcImage,dstImage,elementSize,rowSize,
-				       imageSize,myswapBytes);
-	       break;
-	   default:
-	       assert(0);
-	       break;
-       }
-
-       __GLU_SWAP_IMAGE(srcImage,dstImage);
-
-       if (newWidth > 1) { newWidth /= 2; rowSize /= 2;}
-       if (newHeight > 1) { newHeight /= 2; imageSize = rowSize * newHeight; }
-       if (newDepth > 1) newDepth /= 2;
-       {
-	  /* call tex image with srcImage untouched since it's not padded */
-	  if (baseLevel <= level && level <= maxLevel) {
-	    gluTexImage3D(target, level, internalFormat, newWidth, newHeight,
-			 newDepth,0, format, type, (void *) srcImage);
-	  }
-       }
-   } /* for level */
-   glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
-   glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
-   glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
-   glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
-   glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
-   glPixelStorei(GL_UNPACK_SKIP_IMAGES, psm.unpack_skip_images);
-   glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, psm.unpack_image_height);
-
-   free(srcImage); /*if you get to here, a srcImage has always been malloc'ed*/
-   if (dstImage) { /* if it's non-rectangular and only 1 level */
-     free(dstImage);
-   }
-   return 0;
-} /* gluBuild3DMipmapLevelsCore() */
-
-GLint GLAPIENTRY
-gluBuild3DMipmapLevels(GLenum target, GLint internalFormat,
-			     GLsizei width, GLsizei height, GLsizei depth,
-			     GLenum format, GLenum type,
-			     GLint userLevel, GLint baseLevel, GLint maxLevel,
-			     const void *data)
-{
-   int level, levels;
-
-   int rc= checkMipmapArgs(internalFormat,format,type);
-   if (rc != 0) return rc;
-
-   if (width < 1 || height < 1 || depth < 1) {
-       return GLU_INVALID_VALUE;
-   }
-
-   if(type == GL_BITMAP) {
-      return GLU_INVALID_ENUM;
-   }
-
-   levels = computeLog(width);
-   level = computeLog(height);
-   if (level > levels) levels=level;
-   level = computeLog(depth);
-   if (level > levels) levels=level;
-
-   levels+= userLevel;
-   if (!isLegalLevels(userLevel,baseLevel,maxLevel,levels))
-      return GLU_INVALID_VALUE;
-
-   return gluBuild3DMipmapLevelsCore(target, internalFormat,
-				     width, height, depth,
-				     width, height, depth,
-				     format, type,
-				     userLevel, baseLevel, maxLevel,
-				     data);
-} /* gluBuild3DMipmapLevels() */
-
-GLint GLAPIENTRY
-gluBuild3DMipmaps(GLenum target, GLint internalFormat,
-			GLsizei width, GLsizei height, GLsizei depth,
-			GLenum format, GLenum type, const void *data)
-{
-   GLint widthPowerOf2, heightPowerOf2, depthPowerOf2;
-   int level, levels;
-
-   int rc= checkMipmapArgs(internalFormat,format,type);
-   if (rc != 0) return rc;
-
-   if (width < 1 || height < 1 || depth < 1) {
-       return GLU_INVALID_VALUE;
-   }
-
-   if(type == GL_BITMAP) {
-      return GLU_INVALID_ENUM;
-   }
-
-   closestFit3D(target,width,height,depth,internalFormat,format,type,
-		&widthPowerOf2,&heightPowerOf2,&depthPowerOf2);
-
-   levels = computeLog(widthPowerOf2);
-   level = computeLog(heightPowerOf2);
-   if (level > levels) levels=level;
-   level = computeLog(depthPowerOf2);
-   if (level > levels) levels=level;
-
-   return gluBuild3DMipmapLevelsCore(target, internalFormat,
-				     width, height, depth,
-				     widthPowerOf2, heightPowerOf2,
-				     depthPowerOf2,
-				     format, type, 0, 0, levels,
-				     data);
-} /* gluBuild3DMipmaps() */
-
-static GLdouble extractUbyte(int isSwap, const void *ubyte)
-{
-   isSwap= isSwap;		/* turn off warnings */
-
-   assert(*((const GLubyte *)ubyte) <= 255);
-
-   return (GLdouble)(*((const GLubyte *)ubyte));
-} /* extractUbyte() */
-
-static void shoveUbyte(GLdouble value, int index, void *data)
-{
-   assert(0.0 <= value && value < 256.0);
-
-   ((GLubyte *)data)[index]= (GLubyte)value;
-} /* shoveUbyte() */
-
-static GLdouble extractSbyte(int isSwap, const void *sbyte)
-{
-   isSwap= isSwap;		/* turn off warnings */
-
-   assert(*((const GLbyte *)sbyte) <= 127);
-
-   return (GLdouble)(*((const GLbyte *)sbyte));
-} /* extractSbyte() */
-
-static void shoveSbyte(GLdouble value, int index, void *data)
-{
-   ((GLbyte *)data)[index]= (GLbyte)value;
-} /* shoveSbyte() */
-
-static GLdouble extractUshort(int isSwap, const void *uitem)
-{
-   GLushort ushort;
-
-   if (isSwap) {
-     ushort= __GLU_SWAP_2_BYTES(uitem);
-   }
-   else {
-     ushort= *(const GLushort *)uitem;
-   }
-
-   assert(ushort <= 65535);
-
-   return (GLdouble)ushort;
-} /* extractUshort() */
-
-static void shoveUshort(GLdouble value, int index, void *data)
-{
-   assert(0.0 <= value && value < 65536.0);
-
-   ((GLushort *)data)[index]= (GLushort)value;
-} /* shoveUshort() */
-
-static GLdouble extractSshort(int isSwap, const void *sitem)
-{
-   GLshort sshort;
-
-   if (isSwap) {
-     sshort= __GLU_SWAP_2_BYTES(sitem);
-   }
-   else {
-     sshort= *(const GLshort *)sitem;
-   }
-
-   assert(sshort <= 32767);
-
-   return (GLdouble)sshort;
-} /* extractSshort() */
-
-static void shoveSshort(GLdouble value, int index, void *data)
-{
-   assert(0.0 <= value && value < 32768.0);
-
-   ((GLshort *)data)[index]= (GLshort)value;
-} /* shoveSshort() */
-
-static GLdouble extractUint(int isSwap, const void *uitem)
-{
-   GLuint uint;
-
-   if (isSwap) {
-     uint= __GLU_SWAP_4_BYTES(uitem);
-   }
-   else {
-     uint= *(const GLuint *)uitem;
-   }
-
-   assert(uint <= 0xffffffff);
-
-   return (GLdouble)uint;
-} /* extractUint() */
-
-static void shoveUint(GLdouble value, int index, void *data)
-{
-   assert(0.0 <= value && value <= (GLdouble) UINT_MAX);
-
-   ((GLuint *)data)[index]= (GLuint)value;
-} /* shoveUint() */
-
-static GLdouble extractSint(int isSwap, const void *sitem)
-{
-   GLint sint;
-
-   if (isSwap) {
-     sint= __GLU_SWAP_4_BYTES(sitem);
-   }
-   else {
-     sint= *(const GLint *)sitem;
-   }
-
-   assert(sint <= 0x7fffffff);
-
-   return (GLdouble)sint;
-} /* extractSint() */
-
-static void shoveSint(GLdouble value, int index, void *data)
-{
-   assert(0.0 <= value && value <= (GLdouble) INT_MAX);
-
-   ((GLint *)data)[index]= (GLint)value;
-} /* shoveSint() */
-
-static GLdouble extractFloat(int isSwap, const void *item)
-{
-   GLfloat ffloat;
-
-   if (isSwap) {
-     ffloat= __GLU_SWAP_4_BYTES(item);
-   }
-   else {
-     ffloat= *(const GLfloat *)item;
-   }
-
-   assert(ffloat <= 1.0);
-
-   return (GLdouble)ffloat;
-} /* extractFloat() */
-
-static void shoveFloat(GLdouble value, int index, void *data)
-{
-   assert(0.0 <= value && value <= 1.0);
-
-   ((GLfloat *)data)[index]= value;
-} /* shoveFloat() */
-
-static void halveImageSlice(int components,
-			    GLdouble (*extract)(int, const void *),
-			    void (*shove)(GLdouble, int, void *),
-			    GLint width, GLint height, GLint depth,
-			    const void *dataIn, void *dataOut,
-			    GLint elementSizeInBytes,
-			    GLint groupSizeInBytes,
-			    GLint rowSizeInBytes,
-			    GLint imageSizeInBytes,
-			    GLint isSwap)
-{
-   int ii, jj;
-   int halfWidth= width / 2;
-   int halfHeight= height / 2;
-   int halfDepth= depth / 2;
-   const char *src= (const char *)dataIn;
-   int rowPadBytes= rowSizeInBytes - (width * groupSizeInBytes);
-   int imagePadBytes= imageSizeInBytes - (width*height*groupSizeInBytes);
-   int outIndex= 0;
-
-   assert((width == 1 || height == 1) && depth >= 2);
-
-   if (width == height) {	/* a 1-pixel column viewed from top */
-      /* printf("1-column\n");*/
-      assert(width == 1 && height == 1);
-      assert(depth >= 2);
-
-      for (ii= 0; ii< halfDepth; ii++) {
-	 int cc;
-
-	 for (cc = 0; cc < components; cc++) {
-	    double totals[4];
-	    double extractTotals[BOX2][4];
-	    int kk;
-
-	    extractTotals[0][cc]= (*extract)(isSwap,src);
-	    extractTotals[1][cc]= (*extract)(isSwap,(src+imageSizeInBytes));
-
-	    /* average 2 pixels since only a column */
-	    totals[cc]= 0.0;
-	    /* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED];
-	     * totals[RED]/= 2.0;
-	     */
-	    for (kk = 0; kk < BOX2; kk++) {
-	      totals[cc]+= extractTotals[kk][cc];
-	    }
-	    totals[cc]/= (double)BOX2;
-
-	    (*shove)(totals[cc],outIndex,dataOut);
-	    outIndex++;
-	    src+= elementSizeInBytes;
-	 } /* for cc */
-
-	 /* skip over to next group of 2 */
-	 src+= rowSizeInBytes;
-      } /* for ii */
-
-      assert(src == &((const char *)dataIn)[rowSizeInBytes*height*depth]);
-      assert(outIndex == halfDepth * components);
-   }
-   else if (height == 1) {	/* horizontal slice viewed from top */
-      /* printf("horizontal slice\n"); */
-      assert(width != 1);
-
-      for (ii= 0; ii< halfDepth; ii++) {
-	 for (jj= 0; jj< halfWidth; jj++) {
-	    int cc;
-
-	    for (cc = 0; cc < components; cc++) {
-	       int kk;
-	       double totals[4];
-	       double extractTotals[BOX4][4];
-
-	       extractTotals[0][cc]=(*extract)(isSwap,src);
-	       extractTotals[1][cc]=(*extract)(isSwap,
-					       (src+groupSizeInBytes));
-	       extractTotals[2][cc]=(*extract)(isSwap,
-					       (src+imageSizeInBytes));
-	       extractTotals[3][cc]=(*extract)(isSwap,
-					       (src+imageSizeInBytes+groupSizeInBytes));
-
-	       /* grab 4 pixels to average */
-	       totals[cc]= 0.0;
-	       /* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED]+
-		*	       extractTotals[2][RED]+extractTotals[3][RED];
-		* totals[RED]/= 4.0;
-		*/
-	       for (kk = 0; kk < BOX4; kk++) {
-		  totals[cc]+= extractTotals[kk][cc];
-	       }
-	       totals[cc]/= (double)BOX4;
-
-	       (*shove)(totals[cc],outIndex,dataOut);
-	       outIndex++;
-
-	       src+= elementSizeInBytes;
-	    } /* for cc */
-
-	    /* skip over to next horizontal square of 4 */
-	    src+= groupSizeInBytes;
-	 } /* for jj */
-	 src+= rowPadBytes;
-
-	 src+= rowSizeInBytes;
-      } /* for ii */
-
-      assert(src == &((const char *)dataIn)[rowSizeInBytes*height*depth]);
-      assert(outIndex == halfWidth * halfDepth * components);
-   }
-   else if (width == 1) {	/* vertical slice viewed from top */
-      /* printf("vertical slice\n"); */
-      assert(height != 1);
-
-      for (ii= 0; ii< halfDepth; ii++) {
-	 for (jj= 0; jj< halfHeight; jj++) {
-	    int cc;
-
-	    for (cc = 0; cc < components; cc++) {
-	       int kk;
-	       double totals[4];
-	       double extractTotals[BOX4][4];
-
-	       extractTotals[0][cc]=(*extract)(isSwap,src);
-	       extractTotals[1][cc]=(*extract)(isSwap,
-					       (src+rowSizeInBytes));
-	       extractTotals[2][cc]=(*extract)(isSwap,
-					       (src+imageSizeInBytes));
-	       extractTotals[3][cc]=(*extract)(isSwap,
-					       (src+imageSizeInBytes+rowSizeInBytes));
-
-	       /* grab 4 pixels to average */
-	       totals[cc]= 0.0;
-	       /* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED]+
-		*	       extractTotals[2][RED]+extractTotals[3][RED];
-		* totals[RED]/= 4.0;
-		*/
-	       for (kk = 0; kk < BOX4; kk++) {
-		  totals[cc]+= extractTotals[kk][cc];
-	       }
-	       totals[cc]/= (double)BOX4;
-
-	       (*shove)(totals[cc],outIndex,dataOut);
-	       outIndex++;
-
-	       src+= elementSizeInBytes;
-	    } /* for cc */
-	    src+= rowPadBytes;
-
-	    /* skip over to next vertical square of 4 */
-	    src+= rowSizeInBytes;
-	 } /* for jj */
-         src+= imagePadBytes;
-
-	 src+= imageSizeInBytes;
-      } /* for ii */
-
-      assert(src == &((const char *)dataIn)[rowSizeInBytes*height*depth]);
-      assert(outIndex == halfHeight * halfDepth * components);
-   }
-
-} /* halveImageSlice() */
-
-static void halveImage3D(int components,
-			 GLdouble (*extract)(int, const void *),
-			 void (*shove)(GLdouble, int, void *),
-			 GLint width, GLint height, GLint depth,
-			 const void *dataIn, void *dataOut,
-			 GLint elementSizeInBytes,
-			 GLint groupSizeInBytes,
-			 GLint rowSizeInBytes,
-			 GLint imageSizeInBytes,
-			 GLint isSwap)
-{
-   assert(depth > 1);
-
-   /* a horizontal/vertical/one-column slice viewed from top */
-   if (width == 1 || height == 1) {
-      assert(1 <= depth);
-
-      halveImageSlice(components,extract,shove, width, height, depth,
-		      dataIn, dataOut, elementSizeInBytes, groupSizeInBytes,
-		      rowSizeInBytes, imageSizeInBytes, isSwap);
-      return;
-   }
-   {
-      int ii, jj, dd;
-
-      int halfWidth= width / 2;
-      int halfHeight= height / 2;
-      int halfDepth= depth / 2;
-      const char *src= (const char *) dataIn;
-      int rowPadBytes= rowSizeInBytes - (width*groupSizeInBytes);
-      int imagePadBytes= imageSizeInBytes - (width*height*groupSizeInBytes);
-      int outIndex= 0;
-
-      for (dd= 0; dd < halfDepth; dd++) {
-	 for (ii= 0; ii< halfHeight; ii++) {
-	    for (jj= 0; jj< halfWidth; jj++) {
-	       int cc;
-
-	       for (cc= 0; cc < components; cc++) {
-		  int kk;
-#define BOX8 8
-		  double totals[4];	/* 4 is maximum components */
-		  double extractTotals[BOX8][4]; /* 4 is maximum components */
-
-		  extractTotals[0][cc]= (*extract)(isSwap,src);
-		  extractTotals[1][cc]= (*extract)(isSwap,
-						   (src+groupSizeInBytes));
-		  extractTotals[2][cc]= (*extract)(isSwap,
-						   (src+rowSizeInBytes));
-		  extractTotals[3][cc]= (*extract)(isSwap,
-						   (src+rowSizeInBytes+groupSizeInBytes));
-
-		  extractTotals[4][cc]= (*extract)(isSwap,
-						   (src+imageSizeInBytes));
-
-		  extractTotals[5][cc]= (*extract)(isSwap,
-						   (src+groupSizeInBytes+imageSizeInBytes));
-		  extractTotals[6][cc]= (*extract)(isSwap,
-						   (src+rowSizeInBytes+imageSizeInBytes));
-		  extractTotals[7][cc]= (*extract)(isSwap,
-						   (src+rowSizeInBytes+groupSizeInBytes+imageSizeInBytes));
-
-		  totals[cc]= 0.0;
-
-		  /* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED]+
-		   *		  extractTotals[2][RED]+extractTotals[3][RED]+
-		   *		  extractTotals[4][RED]+extractTotals[5][RED]+
-		   *		  extractTotals[6][RED]+extractTotals[7][RED];
-		   * totals[RED]/= 8.0;
-		   */
-		  for (kk = 0; kk < BOX8; kk++) {
-		     totals[cc]+= extractTotals[kk][cc];
-		  }
-		  totals[cc]/= (double)BOX8;
-
-		  (*shove)(totals[cc],outIndex,dataOut);
-
-		  outIndex++;
-
-		  src+= elementSizeInBytes; /* go to next component */
-	       } /* for cc */
-
-	       /* skip over to next square of 4 */
-	       src+= groupSizeInBytes;
-	    } /* for jj */
-	    /* skip past pad bytes, if any, to get to next row */
-	    src+= rowPadBytes;
-
-	    /* src is at beginning of a row here, but it's the second row of
-	     * the square block of 4 pixels that we just worked on so we
-	     * need to go one more row.
-	     * i.e.,
-	     *			 OO...
-	     *		 here -->OO...
-	     *	     but want -->OO...
-	     *			 OO...
-	     *			 ...
-	     */
-	    src+= rowSizeInBytes;
-	 } /* for ii */
-
-	 /* skip past pad bytes, if any, to get to next image */
-	 src+= imagePadBytes;
-
-	 src+= imageSizeInBytes;
-      } /* for dd */
-
-      /* both pointers must reach one byte after the end */
-      assert(src == &((const char *)dataIn)[rowSizeInBytes*height*depth]);
-      assert(outIndex == halfWidth * halfHeight * halfDepth * components);
-   }
-} /* halveImage3D() */
-
-
-
-/*** mipmap.c ***/
-
+/*

+ * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)

+ * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice including the dates of first publication and

+ * either this permission notice or a reference to

+ * http://oss.sgi.com/projects/FreeB/

+ * shall be included in all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

+ * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF

+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * Except as contained in this notice, the name of Silicon Graphics, Inc.

+ * shall not be used in advertising or otherwise to promote the sale, use or

+ * other dealings in this Software without prior written authorization from

+ * Silicon Graphics, Inc.

+ */

+

+#include "gluos.h"

+#include <assert.h>

+#include <GL/glu.h>

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+#include <limits.h>		/* UINT_MAX */

+#include <math.h>

+

+typedef union {

+    unsigned char ub[4];

+    unsigned short us[2];

+    unsigned int ui;

+    char b[4];

+    short s[2];

+    int i;

+    float f;

+} Type_Widget;

+

+/* Pixel storage modes */

+typedef struct {

+   GLint pack_alignment;

+   GLint pack_row_length;

+   GLint pack_skip_rows;

+   GLint pack_skip_pixels;

+   GLint pack_lsb_first;

+   GLint pack_swap_bytes;

+   GLint pack_skip_images;

+   GLint pack_image_height;

+

+   GLint unpack_alignment;

+   GLint unpack_row_length;

+   GLint unpack_skip_rows;

+   GLint unpack_skip_pixels;

+   GLint unpack_lsb_first;

+   GLint unpack_swap_bytes;

+   GLint unpack_skip_images;

+   GLint unpack_image_height;

+} PixelStorageModes;

+

+static int gluBuild1DMipmapLevelsCore(GLenum, GLint,

+				      GLsizei,

+				      GLsizei,

+				      GLenum, GLenum, GLint, GLint, GLint,

+				      const void *);

+static int gluBuild2DMipmapLevelsCore(GLenum, GLint,

+				      GLsizei, GLsizei,

+				      GLsizei, GLsizei,

+				      GLenum, GLenum, GLint, GLint, GLint,

+				      const void *);

+static int gluBuild3DMipmapLevelsCore(GLenum, GLint,

+				      GLsizei, GLsizei, GLsizei,

+				      GLsizei, GLsizei, GLsizei,

+				      GLenum, GLenum, GLint, GLint, GLint,

+				      const void *);

+

+/*

+ * internal function declarations

+ */

+static GLfloat bytes_per_element(GLenum type);

+static GLint elements_per_group(GLenum format, GLenum type);

+static GLint is_index(GLenum format);

+static GLint image_size(GLint width, GLint height, GLenum format, GLenum type);

+static void fill_image(const PixelStorageModes *,

+		       GLint width, GLint height, GLenum format,

+		       GLenum type, GLboolean index_format,

+		       const void *userdata, GLushort *newimage);

+static void empty_image(const PixelStorageModes *,

+			GLint width, GLint height, GLenum format,

+			GLenum type, GLboolean index_format,

+			const GLushort *oldimage, void *userdata);

+static void scale_internal(GLint components, GLint widthin, GLint heightin,

+			   const GLushort *datain,

+			   GLint widthout, GLint heightout,

+			   GLushort *dataout);

+

+static void scale_internal_ubyte(GLint components, GLint widthin,

+			   GLint heightin, const GLubyte *datain,

+			   GLint widthout, GLint heightout,

+			   GLubyte *dataout, GLint element_size,

+			   GLint ysize, GLint group_size);

+static void scale_internal_byte(GLint components, GLint widthin,

+			   GLint heightin, const GLbyte *datain,

+			   GLint widthout, GLint heightout,

+			   GLbyte *dataout, GLint element_size,

+			   GLint ysize, GLint group_size);

+static void scale_internal_ushort(GLint components, GLint widthin,

+			   GLint heightin, const GLushort *datain,

+			   GLint widthout, GLint heightout,

+			   GLushort *dataout, GLint element_size,

+			   GLint ysize, GLint group_size,

+			   GLint myswap_bytes);

+static void scale_internal_short(GLint components, GLint widthin,

+			   GLint heightin, const GLshort *datain,

+			   GLint widthout, GLint heightout,

+			   GLshort *dataout, GLint element_size,

+			   GLint ysize, GLint group_size,

+			   GLint myswap_bytes);

+static void scale_internal_uint(GLint components, GLint widthin,

+			   GLint heightin, const GLuint *datain,

+			   GLint widthout, GLint heightout,

+			   GLuint *dataout, GLint element_size,

+			   GLint ysize, GLint group_size,

+			   GLint myswap_bytes);

+static void scale_internal_int(GLint components, GLint widthin,

+			   GLint heightin, const GLint *datain,

+			   GLint widthout, GLint heightout,

+			   GLint *dataout, GLint element_size,

+			   GLint ysize, GLint group_size,

+			   GLint myswap_bytes);

+static void scale_internal_float(GLint components, GLint widthin,

+			   GLint heightin, const GLfloat *datain,

+			   GLint widthout, GLint heightout,

+			   GLfloat *dataout, GLint element_size,

+			   GLint ysize, GLint group_size,

+			   GLint myswap_bytes);

+

+static int checkMipmapArgs(GLenum, GLenum, GLenum);

+static GLboolean legalFormat(GLenum);

+static GLboolean legalType(GLenum);

+static GLboolean isTypePackedPixel(GLenum);

+static GLboolean isLegalFormatForPackedPixelType(GLenum, GLenum);

+static GLboolean isLegalLevels(GLint, GLint, GLint, GLint);

+static void closestFit(GLenum, GLint, GLint, GLint, GLenum, GLenum,

+		       GLint *, GLint *);

+

+/* all extract/shove routines must return double to handle unsigned ints */

+static GLdouble extractUbyte(int, const void *);

+static void shoveUbyte(GLdouble, int, void *);

+static GLdouble extractSbyte(int, const void *);

+static void shoveSbyte(GLdouble, int, void *);

+static GLdouble extractUshort(int, const void *);

+static void shoveUshort(GLdouble, int, void *);

+static GLdouble extractSshort(int, const void *);

+static void shoveSshort(GLdouble, int, void *);

+static GLdouble extractUint(int, const void *);

+static void shoveUint(GLdouble, int, void *);

+static GLdouble extractSint(int, const void *);

+static void shoveSint(GLdouble, int, void *);

+static GLdouble extractFloat(int, const void *);

+static void shoveFloat(GLdouble, int, void *);

+static void halveImageSlice(int, GLdouble (*)(int, const void *),

+			    void (*)(GLdouble, int, void *),

+			    GLint, GLint, GLint,

+			    const void *, void *,

+			    GLint, GLint, GLint, GLint, GLint);

+static void halveImage3D(int, GLdouble (*)(int, const void *),

+			 void (*)(GLdouble, int, void *),

+			 GLint, GLint, GLint,

+			 const void *, void *,

+			 GLint, GLint, GLint, GLint, GLint);

+

+/* packedpixel type scale routines */

+static void extract332(int,const void *, GLfloat []);

+static void shove332(const GLfloat [],int ,void *);

+static void extract233rev(int,const void *, GLfloat []);

+static void shove233rev(const GLfloat [],int ,void *);

+static void extract565(int,const void *, GLfloat []);

+static void shove565(const GLfloat [],int ,void *);

+static void extract565rev(int,const void *, GLfloat []);

+static void shove565rev(const GLfloat [],int ,void *);

+static void extract4444(int,const void *, GLfloat []);

+static void shove4444(const GLfloat [],int ,void *);

+static void extract4444rev(int,const void *, GLfloat []);

+static void shove4444rev(const GLfloat [],int ,void *);

+static void extract5551(int,const void *, GLfloat []);

+static void shove5551(const GLfloat [],int ,void *);

+static void extract1555rev(int,const void *, GLfloat []);

+static void shove1555rev(const GLfloat [],int ,void *);

+static void extract8888(int,const void *, GLfloat []);

+static void shove8888(const GLfloat [],int ,void *);

+static void extract8888rev(int,const void *, GLfloat []);

+static void shove8888rev(const GLfloat [],int ,void *);

+static void extract1010102(int,const void *, GLfloat []);

+static void shove1010102(const GLfloat [],int ,void *);

+static void extract2101010rev(int,const void *, GLfloat []);

+static void shove2101010rev(const GLfloat [],int ,void *);

+static void scaleInternalPackedPixel(int,

+				     void (*)(int, const void *,GLfloat []),

+				     void (*)(const GLfloat [],int, void *),

+				     GLint,GLint, const void *,

+				     GLint,GLint,void *,GLint,GLint,GLint);

+static void halveImagePackedPixel(int,

+				  void (*)(int, const void *,GLfloat []),

+				  void (*)(const GLfloat [],int, void *),

+				  GLint, GLint, const void *,

+				  void *, GLint, GLint, GLint);

+static void halve1DimagePackedPixel(int,

+				    void (*)(int, const void *,GLfloat []),

+				    void (*)(const GLfloat [],int, void *),

+				    GLint, GLint, const void *,

+				    void *, GLint, GLint, GLint);

+

+static void halve1Dimage_ubyte(GLint, GLuint, GLuint,const GLubyte *,

+			       GLubyte *, GLint, GLint, GLint);

+static void halve1Dimage_byte(GLint, GLuint, GLuint,const GLbyte *, GLbyte *,

+			      GLint, GLint, GLint);

+static void halve1Dimage_ushort(GLint, GLuint, GLuint, const GLushort *,

+				GLushort *, GLint, GLint, GLint, GLint);

+static void halve1Dimage_short(GLint, GLuint, GLuint,const GLshort *, GLshort *,

+			       GLint, GLint, GLint, GLint);

+static void halve1Dimage_uint(GLint, GLuint, GLuint, const GLuint *, GLuint *,

+			      GLint, GLint, GLint, GLint);

+static void halve1Dimage_int(GLint, GLuint, GLuint, const GLint *, GLint *,

+			     GLint, GLint, GLint, GLint);

+static void halve1Dimage_float(GLint, GLuint, GLuint, const GLfloat *, GLfloat *,

+			       GLint, GLint, GLint, GLint);

+

+static GLint imageSize3D(GLint, GLint, GLint, GLenum,GLenum);

+static void fillImage3D(const PixelStorageModes *, GLint, GLint, GLint,GLenum,

+			GLenum, GLboolean, const void *, GLushort *);

+static void emptyImage3D(const PixelStorageModes *,

+			 GLint, GLint, GLint, GLenum,

+			 GLenum, GLboolean,

+			 const GLushort *, void *);

+static void scaleInternal3D(GLint, GLint, GLint, GLint, const GLushort *,

+			    GLint, GLint, GLint, GLushort *);

+

+static void retrieveStoreModes(PixelStorageModes *psm)

+{

+    glGetIntegerv(GL_UNPACK_ALIGNMENT, &psm->unpack_alignment);

+    glGetIntegerv(GL_UNPACK_ROW_LENGTH, &psm->unpack_row_length);

+    glGetIntegerv(GL_UNPACK_SKIP_ROWS, &psm->unpack_skip_rows);

+    glGetIntegerv(GL_UNPACK_SKIP_PIXELS, &psm->unpack_skip_pixels);

+    glGetIntegerv(GL_UNPACK_LSB_FIRST, &psm->unpack_lsb_first);

+    glGetIntegerv(GL_UNPACK_SWAP_BYTES, &psm->unpack_swap_bytes);

+

+    glGetIntegerv(GL_PACK_ALIGNMENT, &psm->pack_alignment);

+    glGetIntegerv(GL_PACK_ROW_LENGTH, &psm->pack_row_length);

+    glGetIntegerv(GL_PACK_SKIP_ROWS, &psm->pack_skip_rows);

+    glGetIntegerv(GL_PACK_SKIP_PIXELS, &psm->pack_skip_pixels);

+    glGetIntegerv(GL_PACK_LSB_FIRST, &psm->pack_lsb_first);

+    glGetIntegerv(GL_PACK_SWAP_BYTES, &psm->pack_swap_bytes);

+}

+

+static void retrieveStoreModes3D(PixelStorageModes *psm)

+{

+    glGetIntegerv(GL_UNPACK_ALIGNMENT, &psm->unpack_alignment);

+    glGetIntegerv(GL_UNPACK_ROW_LENGTH, &psm->unpack_row_length);

+    glGetIntegerv(GL_UNPACK_SKIP_ROWS, &psm->unpack_skip_rows);

+    glGetIntegerv(GL_UNPACK_SKIP_PIXELS, &psm->unpack_skip_pixels);

+    glGetIntegerv(GL_UNPACK_LSB_FIRST, &psm->unpack_lsb_first);

+    glGetIntegerv(GL_UNPACK_SWAP_BYTES, &psm->unpack_swap_bytes);

+    glGetIntegerv(GL_UNPACK_SKIP_IMAGES, &psm->unpack_skip_images);

+    glGetIntegerv(GL_UNPACK_IMAGE_HEIGHT, &psm->unpack_image_height);

+

+    glGetIntegerv(GL_PACK_ALIGNMENT, &psm->pack_alignment);

+    glGetIntegerv(GL_PACK_ROW_LENGTH, &psm->pack_row_length);

+    glGetIntegerv(GL_PACK_SKIP_ROWS, &psm->pack_skip_rows);

+    glGetIntegerv(GL_PACK_SKIP_PIXELS, &psm->pack_skip_pixels);

+    glGetIntegerv(GL_PACK_LSB_FIRST, &psm->pack_lsb_first);

+    glGetIntegerv(GL_PACK_SWAP_BYTES, &psm->pack_swap_bytes);

+    glGetIntegerv(GL_PACK_SKIP_IMAGES, &psm->pack_skip_images);

+    glGetIntegerv(GL_PACK_IMAGE_HEIGHT, &psm->pack_image_height);

+}

+

+static int computeLog(GLuint value)

+{

+    int i;

+

+    i = 0;

+

+    /* Error! */

+    if (value == 0) return -1;

+

+    for (;;) {

+	if (value & 1) {

+	    /* Error ! */

+	    if (value != 1) return -1;

+	    return i;

+	}

+	value = value >> 1;

+	i++;

+    }

+}

+

+/*

+** Compute the nearest power of 2 number.  This algorithm is a little

+** strange, but it works quite well.

+*/

+static int nearestPower(GLuint value)

+{

+    int i;

+

+    i = 1;

+

+    /* Error! */

+    if (value == 0) return -1;

+

+    for (;;) {

+	if (value == 1) {

+	    return i;

+	} else if (value == 3) {

+	    return i*4;

+	}

+	value = value >> 1;

+	i *= 2;

+    }

+}

+

+#define __GLU_SWAP_2_BYTES(s)\

+(GLushort)(((GLushort)((const GLubyte*)(s))[1])<<8 | ((const GLubyte*)(s))[0])

+

+#define __GLU_SWAP_4_BYTES(s)\

+(GLuint)(((GLuint)((const GLubyte*)(s))[3])<<24 | \

+        ((GLuint)((const GLubyte*)(s))[2])<<16 | \

+        ((GLuint)((const GLubyte*)(s))[1])<<8  | ((const GLubyte*)(s))[0])

+

+static void halveImage(GLint components, GLuint width, GLuint height,

+		       const GLushort *datain, GLushort *dataout)

+{

+    int i, j, k;

+    int newwidth, newheight;

+    int delta;

+    GLushort *s;

+    const GLushort *t;

+

+    newwidth = width / 2;

+    newheight = height / 2;

+    delta = width * components;

+    s = dataout;

+    t = datain;

+

+    /* Piece o' cake! */

+    for (i = 0; i < newheight; i++) {

+	for (j = 0; j < newwidth; j++) {

+	    for (k = 0; k < components; k++) {

+		s[0] = (t[0] + t[components] + t[delta] +

+			t[delta+components] + 2) / 4;

+		s++; t++;

+	    }

+	    t += components;

+	}

+	t += delta;

+    }

+}

+

+static void halveImage_ubyte(GLint components, GLuint width, GLuint height,

+			const GLubyte *datain, GLubyte *dataout,

+			GLint element_size, GLint ysize, GLint group_size)

+{

+    int i, j, k;

+    int newwidth, newheight;

+    int padBytes;

+    GLubyte *s;

+    const char *t;

+

+    /* handle case where there is only 1 column/row */

+    if (width == 1 || height == 1) {

+       assert( !(width == 1 && height == 1) ); /* can't be 1x1 */

+       halve1Dimage_ubyte(components,width,height,datain,dataout,

+			  element_size,ysize,group_size);

+       return;

+    }

+

+    newwidth = width / 2;

+    newheight = height / 2;

+    padBytes = ysize - (width*group_size);

+    s = dataout;

+    t = (const char *)datain;

+

+    /* Piece o' cake! */

+    for (i = 0; i < newheight; i++) {

+	for (j = 0; j < newwidth; j++) {

+	    for (k = 0; k < components; k++) {

+		s[0] = (*(const GLubyte*)t +

+			*(const GLubyte*)(t+group_size) +

+			*(const GLubyte*)(t+ysize) +

+			*(const GLubyte*)(t+ysize+group_size) + 2) / 4;

+		s++; t += element_size;

+	    }

+	    t += group_size;

+	}

+	t += padBytes;

+	t += ysize;

+    }

+}

+

+/* */

+static void halve1Dimage_ubyte(GLint components, GLuint width, GLuint height,

+			       const GLubyte *dataIn, GLubyte *dataOut,

+			       GLint element_size, GLint ysize,

+			       GLint group_size)

+{

+   GLint halfWidth= width / 2;

+   GLint halfHeight= height / 2;

+   const char *src= (const char *) dataIn;

+   GLubyte *dest= dataOut;

+   int jj;

+

+   assert(width == 1 || height == 1); /* must be 1D */

+   assert(width != height);	/* can't be square */

+

+   if (height == 1) {		/* 1 row */

+      assert(width != 1);	/* widthxheight can't be 1x1 */

+      halfHeight= 1;

+

+      for (jj= 0; jj< halfWidth; jj++) {

+	 int kk;

+	 for (kk= 0; kk< components; kk++) {

+	    *dest= (*(const GLubyte*)src +

+		 *(const GLubyte*)(src+group_size)) / 2;

+

+	    src+= element_size;

+	    dest++;

+	 }

+	 src+= group_size;	/* skip to next 2 */

+      }

+      {

+	 int padBytes= ysize - (width*group_size);

+	 src+= padBytes;	/* for assertion only */

+      }

+   }

+   else if (width == 1) {	/* 1 column */

+      int padBytes= ysize - (width * group_size);

+      assert(height != 1);	/* widthxheight can't be 1x1 */

+      halfWidth= 1;

+      /* one vertical column with possible pad bytes per row */

+      /* average two at a time */

+

+      for (jj= 0; jj< halfHeight; jj++) {

+	 int kk;

+	 for (kk= 0; kk< components; kk++) {

+	    *dest= (*(const GLubyte*)src + *(const GLubyte*)(src+ysize)) / 2;

+

+	    src+= element_size;

+	    dest++;

+	 }

+	 src+= padBytes; /* add pad bytes, if any, to get to end to row */

+	 src+= ysize;

+      }

+   }

+

+   assert(src == &((const char *)dataIn)[ysize*height]);

+   assert((char *)dest == &((char *)dataOut)

+	  [components * element_size * halfWidth * halfHeight]);

+} /* halve1Dimage_ubyte() */

+

+static void halveImage_byte(GLint components, GLuint width, GLuint height,

+			const GLbyte *datain, GLbyte *dataout,

+			GLint element_size,

+			GLint ysize, GLint group_size)

+{

+    int i, j, k;

+    int newwidth, newheight;

+    int padBytes;

+    GLbyte *s;

+    const char *t;

+

+    /* handle case where there is only 1 column/row */

+    if (width == 1 || height == 1) {

+       assert( !(width == 1 && height == 1) ); /* can't be 1x1 */

+       halve1Dimage_byte(components,width,height,datain,dataout,

+			 element_size,ysize,group_size);

+       return;

+    }

+

+    newwidth = width / 2;

+    newheight = height / 2;

+    padBytes = ysize - (width*group_size);

+    s = dataout;

+    t = (const char *)datain;

+

+    /* Piece o' cake! */

+    for (i = 0; i < newheight; i++) {

+	for (j = 0; j < newwidth; j++) {

+	    for (k = 0; k < components; k++) {

+		s[0] = (*(const GLbyte*)t +

+			*(const GLbyte*)(t+group_size) +

+			*(const GLbyte*)(t+ysize) +

+			*(const GLbyte*)(t+ysize+group_size) + 2) / 4;

+		s++; t += element_size;

+	    }

+	    t += group_size;

+	}

+	t += padBytes;

+	t += ysize;

+    }

+}

+

+static void halve1Dimage_byte(GLint components, GLuint width, GLuint height,

+			      const GLbyte *dataIn, GLbyte *dataOut,

+			      GLint element_size,GLint ysize, GLint group_size)

+{

+   GLint halfWidth= width / 2;

+   GLint halfHeight= height / 2;

+   const char *src= (const char *) dataIn;

+   GLbyte *dest= dataOut;

+   int jj;

+

+   assert(width == 1 || height == 1); /* must be 1D */

+   assert(width != height);	/* can't be square */

+

+   if (height == 1) {		/* 1 row */

+      assert(width != 1);	/* widthxheight can't be 1x1 */

+      halfHeight= 1;

+

+      for (jj= 0; jj< halfWidth; jj++) {

+	 int kk;

+	 for (kk= 0; kk< components; kk++) {

+	    *dest= (*(const GLbyte*)src + *(const GLbyte*)(src+group_size)) / 2;

+

+	    src+= element_size;

+	    dest++;

+	 }

+	 src+= group_size;	/* skip to next 2 */

+      }

+      {

+	 int padBytes= ysize - (width*group_size);

+	 src+= padBytes;	/* for assertion only */

+      }

+   }

+   else if (width == 1) {	/* 1 column */

+      int padBytes= ysize - (width * group_size);

+      assert(height != 1);	/* widthxheight can't be 1x1 */

+      halfWidth= 1;

+      /* one vertical column with possible pad bytes per row */

+      /* average two at a time */

+

+      for (jj= 0; jj< halfHeight; jj++) {

+	 int kk;

+	 for (kk= 0; kk< components; kk++) {

+	    *dest= (*(const GLbyte*)src + *(const GLbyte*)(src+ysize)) / 2;

+

+	    src+= element_size;

+	    dest++;

+	 }

+	 src+= padBytes; /* add pad bytes, if any, to get to end to row */

+	 src+= ysize;

+      }

+

+      assert(src == &((const char *)dataIn)[ysize*height]);

+   }

+

+   assert((char *)dest == &((char *)dataOut)

+	  [components * element_size * halfWidth * halfHeight]);

+} /* halve1Dimage_byte() */

+

+static void halveImage_ushort(GLint components, GLuint width, GLuint height,

+			const GLushort *datain, GLushort *dataout,

+			GLint element_size, GLint ysize, GLint group_size,

+			GLint myswap_bytes)

+{

+    int i, j, k;

+    int newwidth, newheight;

+    int padBytes;

+    GLushort *s;

+    const char *t;

+

+    /* handle case where there is only 1 column/row */

+    if (width == 1 || height == 1) {

+       assert( !(width == 1 && height == 1) ); /* can't be 1x1 */

+       halve1Dimage_ushort(components,width,height,datain,dataout,

+			   element_size,ysize,group_size, myswap_bytes);

+       return;

+    }

+

+    newwidth = width / 2;

+    newheight = height / 2;

+    padBytes = ysize - (width*group_size);

+    s = dataout;

+    t = (const char *)datain;

+

+    /* Piece o' cake! */

+    if (!myswap_bytes)

+    for (i = 0; i < newheight; i++) {

+	for (j = 0; j < newwidth; j++) {

+	    for (k = 0; k < components; k++) {

+		s[0] = (*(const GLushort*)t +

+			*(const GLushort*)(t+group_size) +

+			*(const GLushort*)(t+ysize) +

+			*(const GLushort*)(t+ysize+group_size) + 2) / 4;

+		s++; t += element_size;

+	    }

+	    t += group_size;

+	}

+	t += padBytes;

+	t += ysize;

+    }

+    else

+    for (i = 0; i < newheight; i++) {

+	for (j = 0; j < newwidth; j++) {

+	    for (k = 0; k < components; k++) {

+		s[0] = (__GLU_SWAP_2_BYTES(t) +

+			__GLU_SWAP_2_BYTES(t+group_size) +

+			__GLU_SWAP_2_BYTES(t+ysize) +

+			__GLU_SWAP_2_BYTES(t+ysize+group_size)+ 2)/4;

+		s++; t += element_size;

+	    }

+	    t += group_size;

+	}

+	t += padBytes;

+	t += ysize;

+    }

+}

+

+static void halve1Dimage_ushort(GLint components, GLuint width, GLuint height,

+				const GLushort *dataIn, GLushort *dataOut,

+				GLint element_size, GLint ysize,

+				GLint group_size, GLint myswap_bytes)

+{

+   GLint halfWidth= width / 2;

+   GLint halfHeight= height / 2;

+   const char *src= (const char *) dataIn;

+   GLushort *dest= dataOut;

+   int jj;

+

+   assert(width == 1 || height == 1); /* must be 1D */

+   assert(width != height);	/* can't be square */

+

+   if (height == 1) {		/* 1 row */

+      assert(width != 1);	/* widthxheight can't be 1x1 */

+      halfHeight= 1;

+

+      for (jj= 0; jj< halfWidth; jj++) {

+	 int kk;

+	 for (kk= 0; kk< components; kk++) {

+#define BOX2 2

+	    GLushort ushort[BOX2];

+	    if (myswap_bytes) {

+	       ushort[0]= __GLU_SWAP_2_BYTES(src);

+	       ushort[1]= __GLU_SWAP_2_BYTES(src+group_size);

+	    }

+	    else {

+	       ushort[0]= *(const GLushort*)src;

+	       ushort[1]= *(const GLushort*)(src+group_size);

+	    }

+

+	    *dest= (ushort[0] + ushort[1]) / 2;

+	    src+= element_size;

+	    dest++;

+	 }

+	 src+= group_size;	/* skip to next 2 */

+      }

+      {

+	 int padBytes= ysize - (width*group_size);

+	 src+= padBytes;	/* for assertion only */

+      }

+   }

+   else if (width == 1) {	/* 1 column */

+      int padBytes= ysize - (width * group_size);

+      assert(height != 1);	/* widthxheight can't be 1x1 */

+      halfWidth= 1;

+      /* one vertical column with possible pad bytes per row */

+      /* average two at a time */

+

+      for (jj= 0; jj< halfHeight; jj++) {

+	 int kk;

+	 for (kk= 0; kk< components; kk++) {

+#define BOX2 2

+	    GLushort ushort[BOX2];

+	    if (myswap_bytes) {

+	       ushort[0]= __GLU_SWAP_2_BYTES(src);

+	       ushort[1]= __GLU_SWAP_2_BYTES(src+ysize);

+	    }

+	    else {

+	       ushort[0]= *(const GLushort*)src;

+	       ushort[1]= *(const GLushort*)(src+ysize);

+	    }

+	    *dest= (ushort[0] + ushort[1]) / 2;

+

+	    src+= element_size;

+	    dest++;

+	 }

+	 src+= padBytes; /* add pad bytes, if any, to get to end to row */

+	 src+= ysize;

+      }

+

+      assert(src == &((const char *)dataIn)[ysize*height]);

+   }

+

+   assert((char *)dest == &((char *)dataOut)

+	  [components * element_size * halfWidth * halfHeight]);

+

+} /* halve1Dimage_ushort() */

+

+

+static void halveImage_short(GLint components, GLuint width, GLuint height,

+			const GLshort *datain, GLshort *dataout,

+			GLint element_size, GLint ysize, GLint group_size,

+			GLint myswap_bytes)

+{

+    int i, j, k;

+    int newwidth, newheight;

+    int padBytes;

+    GLshort *s;

+    const char *t;

+

+    /* handle case where there is only 1 column/row */

+    if (width == 1 || height == 1) {

+       assert( !(width == 1 && height == 1) ); /* can't be 1x1 */

+       halve1Dimage_short(components,width,height,datain,dataout,

+			  element_size,ysize,group_size, myswap_bytes);

+       return;

+    }

+

+    newwidth = width / 2;

+    newheight = height / 2;

+    padBytes = ysize - (width*group_size);

+    s = dataout;

+    t = (const char *)datain;

+

+    /* Piece o' cake! */

+    if (!myswap_bytes)

+    for (i = 0; i < newheight; i++) {

+	for (j = 0; j < newwidth; j++) {

+	    for (k = 0; k < components; k++) {

+		s[0] = (*(const GLshort*)t +

+			*(const GLshort*)(t+group_size) +

+			*(const GLshort*)(t+ysize) +

+			*(const GLshort*)(t+ysize+group_size) + 2) / 4;

+		s++; t += element_size;

+	    }

+	    t += group_size;

+	}

+	t += padBytes;

+	t += ysize;

+    }

+    else

+    for (i = 0; i < newheight; i++) {

+	for (j = 0; j < newwidth; j++) {

+	    for (k = 0; k < components; k++) {

+		GLushort b;

+		GLint buf;

+		b = __GLU_SWAP_2_BYTES(t);

+		buf = *(const GLshort*)&b;

+		b = __GLU_SWAP_2_BYTES(t+group_size);

+		buf += *(const GLshort*)&b;

+		b = __GLU_SWAP_2_BYTES(t+ysize);

+		buf += *(const GLshort*)&b;

+		b = __GLU_SWAP_2_BYTES(t+ysize+group_size);

+		buf += *(const GLshort*)&b;

+		s[0] = (GLshort)((buf+2)/4);

+		s++; t += element_size;

+	    }

+	    t += group_size;

+	}

+	t += padBytes;

+	t += ysize;

+    }

+}

+

+static void halve1Dimage_short(GLint components, GLuint width, GLuint height,

+				const GLshort *dataIn, GLshort *dataOut,

+				GLint element_size, GLint ysize,

+				GLint group_size, GLint myswap_bytes)

+{

+   GLint halfWidth= width / 2;

+   GLint halfHeight= height / 2;

+   const char *src= (const char *) dataIn;

+   GLshort *dest= dataOut;

+   int jj;

+

+   assert(width == 1 || height == 1); /* must be 1D */

+   assert(width != height);	/* can't be square */

+

+   if (height == 1) {		/* 1 row */

+      assert(width != 1);	/* widthxheight can't be 1x1 */

+      halfHeight= 1;

+

+      for (jj= 0; jj< halfWidth; jj++) {

+	 int kk;

+	 for (kk= 0; kk< components; kk++) {

+#define BOX2 2

+	    GLshort sshort[BOX2];

+	    if (myswap_bytes) {

+	       sshort[0]= __GLU_SWAP_2_BYTES(src);

+	       sshort[1]= __GLU_SWAP_2_BYTES(src+group_size);

+	    }

+	    else {

+	       sshort[0]= *(const GLshort*)src;

+	       sshort[1]= *(const GLshort*)(src+group_size);

+	    }

+

+	    *dest= (sshort[0] + sshort[1]) / 2;

+	    src+= element_size;

+	    dest++;

+	 }

+	 src+= group_size;	/* skip to next 2 */

+      }

+      {

+	 int padBytes= ysize - (width*group_size);

+	 src+= padBytes;	/* for assertion only */

+      }

+   }

+   else if (width == 1) {	/* 1 column */

+      int padBytes= ysize - (width * group_size);

+      assert(height != 1);	/* widthxheight can't be 1x1 */

+      halfWidth= 1;

+      /* one vertical column with possible pad bytes per row */

+      /* average two at a time */

+

+      for (jj= 0; jj< halfHeight; jj++) {

+	 int kk;

+	 for (kk= 0; kk< components; kk++) {

+#define BOX2 2

+	    GLshort sshort[BOX2];

+	    if (myswap_bytes) {

+	       sshort[0]= __GLU_SWAP_2_BYTES(src);

+	       sshort[1]= __GLU_SWAP_2_BYTES(src+ysize);

+	    }

+	    else {

+	       sshort[0]= *(const GLshort*)src;

+	       sshort[1]= *(const GLshort*)(src+ysize);

+	    }

+	    *dest= (sshort[0] + sshort[1]) / 2;

+

+	    src+= element_size;

+	    dest++;

+	 }

+	 src+= padBytes; /* add pad bytes, if any, to get to end to row */

+	 src+= ysize;

+      }

+

+      assert(src == &((const char *)dataIn)[ysize*height]);

+   }

+

+   assert((char *)dest == &((char *)dataOut)

+	  [components * element_size * halfWidth * halfHeight]);

+

+} /* halve1Dimage_short() */

+

+

+static void halveImage_uint(GLint components, GLuint width, GLuint height,

+			const GLuint *datain, GLuint *dataout,

+			GLint element_size, GLint ysize, GLint group_size,

+			GLint myswap_bytes)

+{

+    int i, j, k;

+    int newwidth, newheight;

+    int padBytes;

+    GLuint *s;

+    const char *t;

+

+    /* handle case where there is only 1 column/row */

+    if (width == 1 || height == 1) {

+       assert( !(width == 1 && height == 1) ); /* can't be 1x1 */

+       halve1Dimage_uint(components,width,height,datain,dataout,

+			 element_size,ysize,group_size, myswap_bytes);

+       return;

+    }

+

+    newwidth = width / 2;

+    newheight = height / 2;

+    padBytes = ysize - (width*group_size);

+    s = dataout;

+    t = (const char *)datain;

+

+    /* Piece o' cake! */

+    if (!myswap_bytes)

+    for (i = 0; i < newheight; i++) {

+	for (j = 0; j < newwidth; j++) {

+	    for (k = 0; k < components; k++) {

+		/* need to cast to double to hold large unsigned ints */

+		s[0] = ((double)*(const GLuint*)t +

+			(double)*(const GLuint*)(t+group_size) +

+			(double)*(const GLuint*)(t+ysize) +

+			(double)*(const GLuint*)(t+ysize+group_size))/4 + 0.5;

+		s++; t += element_size;

+

+	    }

+	    t += group_size;

+	}

+	t += padBytes;

+	t += ysize;

+    }

+    else

+    for (i = 0; i < newheight; i++) {

+	for (j = 0; j < newwidth; j++) {

+	    for (k = 0; k < components; k++) {

+		/* need to cast to double to hold large unsigned ints */

+		GLdouble buf;

+		buf = (GLdouble)__GLU_SWAP_4_BYTES(t) +

+		      (GLdouble)__GLU_SWAP_4_BYTES(t+group_size) +

+		      (GLdouble)__GLU_SWAP_4_BYTES(t+ysize) +

+		      (GLdouble)__GLU_SWAP_4_BYTES(t+ysize+group_size);

+		s[0] = (GLuint)(buf/4 + 0.5);

+

+		s++; t += element_size;

+	    }

+	    t += group_size;

+	}

+	t += padBytes;

+	t += ysize;

+    }

+}

+

+/* */

+static void halve1Dimage_uint(GLint components, GLuint width, GLuint height,

+			      const GLuint *dataIn, GLuint *dataOut,

+			      GLint element_size, GLint ysize,

+			      GLint group_size, GLint myswap_bytes)

+{

+   GLint halfWidth= width / 2;

+   GLint halfHeight= height / 2;

+   const char *src= (const char *) dataIn;

+   GLuint *dest= dataOut;

+   int jj;

+

+   assert(width == 1 || height == 1); /* must be 1D */

+   assert(width != height);	/* can't be square */

+

+   if (height == 1) {		/* 1 row */

+      assert(width != 1);	/* widthxheight can't be 1x1 */

+      halfHeight= 1;

+

+      for (jj= 0; jj< halfWidth; jj++) {

+	 int kk;

+	 for (kk= 0; kk< components; kk++) {

+#define BOX2 2

+	    GLuint uint[BOX2];

+	    if (myswap_bytes) {

+	       uint[0]= __GLU_SWAP_4_BYTES(src);

+	       uint[1]= __GLU_SWAP_4_BYTES(src+group_size);

+	    }

+	    else {

+	       uint[0]= *(const GLuint*)src;

+	       uint[1]= *(const GLuint*)(src+group_size);

+	    }

+	    *dest= ((double)uint[0]+(double)uint[1])/2.0;

+

+	    src+= element_size;

+	    dest++;

+	 }

+	 src+= group_size;	/* skip to next 2 */

+      }

+      {

+	 int padBytes= ysize - (width*group_size);

+	 src+= padBytes;	/* for assertion only */

+      }

+   }

+   else if (width == 1) {	/* 1 column */

+      int padBytes= ysize - (width * group_size);

+      assert(height != 1);	/* widthxheight can't be 1x1 */

+      halfWidth= 1;

+      /* one vertical column with possible pad bytes per row */

+      /* average two at a time */

+

+      for (jj= 0; jj< halfHeight; jj++) {

+	 int kk;

+	 for (kk= 0; kk< components; kk++) {

+#define BOX2 2

+	    GLuint uint[BOX2];

+	    if (myswap_bytes) {

+	       uint[0]= __GLU_SWAP_4_BYTES(src);

+	       uint[1]= __GLU_SWAP_4_BYTES(src+ysize);

+	    }

+	    else {

+	       uint[0]= *(const GLuint*)src;

+	       uint[1]= *(const GLuint*)(src+ysize);

+	    }

+	    *dest= ((double)uint[0]+(double)uint[1])/2.0;

+

+	    src+= element_size;

+	    dest++;

+	 }

+	 src+= padBytes; /* add pad bytes, if any, to get to end to row */

+	 src+= ysize;

+      }

+

+      assert(src == &((const char *)dataIn)[ysize*height]);

+   }

+

+   assert((char *)dest == &((char *)dataOut)

+	  [components * element_size * halfWidth * halfHeight]);

+

+} /* halve1Dimage_uint() */

+

+static void halveImage_int(GLint components, GLuint width, GLuint height,

+			const GLint *datain, GLint *dataout, GLint element_size,

+			GLint ysize, GLint group_size, GLint myswap_bytes)

+{

+    int i, j, k;

+    int newwidth, newheight;

+    int padBytes;

+    GLint *s;

+    const char *t;

+

+    /* handle case where there is only 1 column/row */

+    if (width == 1 || height == 1) {

+       assert( !(width == 1 && height == 1) ); /* can't be 1x1 */

+       halve1Dimage_int(components,width,height,datain,dataout,

+			element_size,ysize,group_size, myswap_bytes);

+       return;

+    }

+

+    newwidth = width / 2;

+    newheight = height / 2;

+    padBytes = ysize - (width*group_size);

+    s = dataout;

+    t = (const char *)datain;

+

+    /* Piece o' cake! */

+    if (!myswap_bytes)

+    for (i = 0; i < newheight; i++) {

+	for (j = 0; j < newwidth; j++) {

+	    for (k = 0; k < components; k++) {

+		s[0] = ((float)*(const GLint*)t +

+			(float)*(const GLint*)(t+group_size) +

+			(float)*(const GLint*)(t+ysize) +

+			(float)*(const GLint*)(t+ysize+group_size))/4 + 0.5;

+		s++; t += element_size;

+	    }

+	    t += group_size;

+	}

+	t += padBytes;

+	t += ysize;

+    }

+    else

+    for (i = 0; i < newheight; i++) {

+	for (j = 0; j < newwidth; j++) {

+	    for (k = 0; k < components; k++) {

+		GLuint b;

+		GLfloat buf;

+		b = __GLU_SWAP_4_BYTES(t);

+		buf = *(GLint*)&b;

+		b = __GLU_SWAP_4_BYTES(t+group_size);

+		buf += *(GLint*)&b;

+		b = __GLU_SWAP_4_BYTES(t+ysize);

+		buf += *(GLint*)&b;

+		b = __GLU_SWAP_4_BYTES(t+ysize+group_size);

+		buf += *(GLint*)&b;

+		s[0] = (GLint)(buf/4 + 0.5);

+

+		s++; t += element_size;

+	    }

+	    t += group_size;

+	}

+	t += padBytes;

+	t += ysize;

+    }

+}

+

+/* */

+static void halve1Dimage_int(GLint components, GLuint width, GLuint height,

+			     const GLint *dataIn, GLint *dataOut,

+			     GLint element_size, GLint ysize,

+			     GLint group_size, GLint myswap_bytes)

+{

+   GLint halfWidth= width / 2;

+   GLint halfHeight= height / 2;

+   const char *src= (const char *) dataIn;

+   GLint *dest= dataOut;

+   int jj;

+

+   assert(width == 1 || height == 1); /* must be 1D */

+   assert(width != height);	/* can't be square */

+

+   if (height == 1) {		/* 1 row */

+      assert(width != 1);	/* widthxheight can't be 1x1 */

+      halfHeight= 1;

+

+      for (jj= 0; jj< halfWidth; jj++) {

+	 int kk;

+	 for (kk= 0; kk< components; kk++) {

+#define BOX2 2

+	    GLuint uint[BOX2];

+	    if (myswap_bytes) {

+	       uint[0]= __GLU_SWAP_4_BYTES(src);

+	       uint[1]= __GLU_SWAP_4_BYTES(src+group_size);

+	    }

+	    else {

+	       uint[0]= *(const GLuint*)src;

+	       uint[1]= *(const GLuint*)(src+group_size);

+	    }

+	    *dest= ((float)uint[0]+(float)uint[1])/2.0;

+

+	    src+= element_size;

+	    dest++;

+	 }

+	 src+= group_size;	/* skip to next 2 */

+      }

+      {

+	 int padBytes= ysize - (width*group_size);

+	 src+= padBytes;	/* for assertion only */

+      }

+   }

+   else if (width == 1) {	/* 1 column */

+      int padBytes= ysize - (width * group_size);

+      assert(height != 1);	/* widthxheight can't be 1x1 */

+      halfWidth= 1;

+      /* one vertical column with possible pad bytes per row */

+      /* average two at a time */

+

+      for (jj= 0; jj< halfHeight; jj++) {

+	 int kk;

+	 for (kk= 0; kk< components; kk++) {

+#define BOX2 2

+	    GLuint uint[BOX2];

+	    if (myswap_bytes) {

+	       uint[0]= __GLU_SWAP_4_BYTES(src);

+	       uint[1]= __GLU_SWAP_4_BYTES(src+ysize);

+	    }

+	    else {

+	       uint[0]= *(const GLuint*)src;

+	       uint[1]= *(const GLuint*)(src+ysize);

+	    }

+	    *dest= ((float)uint[0]+(float)uint[1])/2.0;

+

+	    src+= element_size;

+	    dest++;

+	 }

+	 src+= padBytes; /* add pad bytes, if any, to get to end to row */

+	 src+= ysize;

+      }

+

+      assert(src == &((const char *)dataIn)[ysize*height]);

+   }

+

+   assert((char *)dest == &((char *)dataOut)

+	  [components * element_size * halfWidth * halfHeight]);

+

+} /* halve1Dimage_int() */

+

+

+static void halveImage_float(GLint components, GLuint width, GLuint height,

+			const GLfloat *datain, GLfloat *dataout,

+			GLint element_size, GLint ysize, GLint group_size,

+			GLint myswap_bytes)

+{

+    int i, j, k;

+    int newwidth, newheight;

+    int padBytes;

+    GLfloat *s;

+    const char *t;

+

+    /* handle case where there is only 1 column/row */

+    if (width == 1 || height == 1) {

+       assert( !(width == 1 && height == 1) ); /* can't be 1x1 */

+       halve1Dimage_float(components,width,height,datain,dataout,

+			  element_size,ysize,group_size, myswap_bytes);

+       return;

+    }

+

+    newwidth = width / 2;

+    newheight = height / 2;

+    padBytes = ysize - (width*group_size);

+    s = dataout;

+    t = (const char *)datain;

+

+    /* Piece o' cake! */

+    if (!myswap_bytes)

+    for (i = 0; i < newheight; i++) {

+	for (j = 0; j < newwidth; j++) {

+	    for (k = 0; k < components; k++) {

+		s[0] = (*(const GLfloat*)t +

+			*(const GLfloat*)(t+group_size) +

+			*(const GLfloat*)(t+ysize) +

+			*(const GLfloat*)(t+ysize+group_size)) / 4;

+		s++; t += element_size;

+	    }

+	    t += group_size;

+	}

+	t += padBytes;

+	t += ysize;

+    }

+    else

+    for (i = 0; i < newheight; i++) {

+	for (j = 0; j < newwidth; j++) {

+	    for (k = 0; k < components; k++) {

+		union { GLuint b; GLfloat f; } swapbuf;

+		swapbuf.b = __GLU_SWAP_4_BYTES(t);

+		s[0] = swapbuf.f;

+		swapbuf.b = __GLU_SWAP_4_BYTES(t+group_size);

+		s[0] += swapbuf.f;

+		swapbuf.b = __GLU_SWAP_4_BYTES(t+ysize);

+		s[0] += swapbuf.f;

+		swapbuf.b = __GLU_SWAP_4_BYTES(t+ysize+group_size);

+		s[0] += swapbuf.f;

+		s[0] /= 4;

+		s++; t += element_size;

+	    }

+	    t += group_size;

+	}

+	t += padBytes;

+	t += ysize;

+    }

+}

+

+/* */

+static void halve1Dimage_float(GLint components, GLuint width, GLuint height,

+			       const GLfloat *dataIn, GLfloat *dataOut,

+			       GLint element_size, GLint ysize,

+			       GLint group_size, GLint myswap_bytes)

+{

+   GLint halfWidth= width / 2;

+   GLint halfHeight= height / 2;

+   const char *src= (const char *) dataIn;

+   GLfloat *dest= dataOut;

+   int jj;

+

+   assert(width == 1 || height == 1); /* must be 1D */

+   assert(width != height);	/* can't be square */

+

+   if (height == 1) {		/* 1 row */

+      assert(width != 1);	/* widthxheight can't be 1x1 */

+      halfHeight= 1;

+

+      for (jj= 0; jj< halfWidth; jj++) {

+	 int kk;

+	 for (kk= 0; kk< components; kk++) {

+#define BOX2 2

+	    GLfloat sfloat[BOX2];

+	    if (myswap_bytes) {

+	       sfloat[0]= __GLU_SWAP_4_BYTES(src);

+	       sfloat[1]= __GLU_SWAP_4_BYTES(src+group_size);

+	    }

+	    else {

+	       sfloat[0]= *(const GLfloat*)src;

+	       sfloat[1]= *(const GLfloat*)(src+group_size);

+	    }

+

+	    *dest= (sfloat[0] + sfloat[1]) / 2.0;

+	    src+= element_size;

+	    dest++;

+	 }

+	 src+= group_size;	/* skip to next 2 */

+      }

+      {

+	 int padBytes= ysize - (width*group_size);

+	 src+= padBytes;	/* for assertion only */

+      }

+   }

+   else if (width == 1) {	/* 1 column */

+      int padBytes= ysize - (width * group_size);

+      assert(height != 1);	/* widthxheight can't be 1x1 */

+      halfWidth= 1;

+      /* one vertical column with possible pad bytes per row */

+      /* average two at a time */

+

+      for (jj= 0; jj< halfHeight; jj++) {

+	 int kk;

+	 for (kk= 0; kk< components; kk++) {

+#define BOX2 2

+	    GLfloat sfloat[BOX2];

+	    if (myswap_bytes) {

+	       sfloat[0]= __GLU_SWAP_4_BYTES(src);

+	       sfloat[1]= __GLU_SWAP_4_BYTES(src+ysize);

+	    }

+	    else {

+	       sfloat[0]= *(const GLfloat*)src;

+	       sfloat[1]= *(const GLfloat*)(src+ysize);

+	    }

+	    *dest= (sfloat[0] + sfloat[1]) / 2.0;

+

+	    src+= element_size;

+	    dest++;

+	 }

+	 src+= padBytes; /* add pad bytes, if any, to get to end to row */

+	 src+= ysize;		/* skip to odd row */

+      }

+   }

+

+   assert(src == &((const char *)dataIn)[ysize*height]);

+   assert((char *)dest == &((char *)dataOut)

+	  [components * element_size * halfWidth * halfHeight]);

+} /* halve1Dimage_float() */

+

+static void scale_internal(GLint components, GLint widthin, GLint heightin,

+			   const GLushort *datain,

+			   GLint widthout, GLint heightout,

+			   GLushort *dataout)

+{

+    float x, lowx, highx, convx, halfconvx;

+    float y, lowy, highy, convy, halfconvy;

+    float xpercent,ypercent;

+    float percent;

+    /* Max components in a format is 4, so... */

+    float totals[4];

+    float area;

+    int i,j,k,yint,xint,xindex,yindex;

+    int temp;

+

+    if (widthin == widthout*2 && heightin == heightout*2) {

+	halveImage(components, widthin, heightin, datain, dataout);

+	return;

+    }

+    convy = (float) heightin/heightout;

+    convx = (float) widthin/widthout;

+    halfconvx = convx/2;

+    halfconvy = convy/2;

+    for (i = 0; i < heightout; i++) {

+	y = convy * (i+0.5);

+	if (heightin > heightout) {

+	    highy = y + halfconvy;

+	    lowy = y - halfconvy;

+	} else {

+	    highy = y + 0.5;

+	    lowy = y - 0.5;

+	}

+	for (j = 0; j < widthout; j++) {

+	    x = convx * (j+0.5);

+	    if (widthin > widthout) {

+		highx = x + halfconvx;

+		lowx = x - halfconvx;

+	    } else {

+		highx = x + 0.5;

+		lowx = x - 0.5;

+	    }

+

+	    /*

+	    ** Ok, now apply box filter to box that goes from (lowx, lowy)

+	    ** to (highx, highy) on input data into this pixel on output

+	    ** data.

+	    */

+	    totals[0] = totals[1] = totals[2] = totals[3] = 0.0;

+	    area = 0.0;

+

+	    y = lowy;

+	    yint = floor(y);

+	    while (y < highy) {

+		yindex = (yint + heightin) % heightin;

+		if (highy < yint+1) {

+		    ypercent = highy - y;

+		} else {

+		    ypercent = yint+1 - y;

+		}

+

+		x = lowx;

+		xint = floor(x);

+

+		while (x < highx) {

+		    xindex = (xint + widthin) % widthin;

+		    if (highx < xint+1) {

+			xpercent = highx - x;

+		    } else {

+			xpercent = xint+1 - x;

+		    }

+

+		    percent = xpercent * ypercent;

+		    area += percent;

+		    temp = (xindex + (yindex * widthin)) * components;

+		    for (k = 0; k < components; k++) {

+			totals[k] += datain[temp + k] * percent;

+		    }

+

+		    xint++;

+		    x = xint;

+		}

+		yint++;

+		y = yint;

+	    }

+

+	    temp = (j + (i * widthout)) * components;

+	    for (k = 0; k < components; k++) {

+		/* totals[] should be rounded in the case of enlarging an RGB

+		 * ramp when the type is 332 or 4444

+		 */

+		dataout[temp + k] = (totals[k]+0.5)/area;

+	    }

+	}

+    }

+}

+

+static void scale_internal_ubyte(GLint components, GLint widthin,

+			   GLint heightin, const GLubyte *datain,

+			   GLint widthout, GLint heightout,

+			   GLubyte *dataout, GLint element_size,

+			   GLint ysize, GLint group_size)

+{

+    float convx;

+    float convy;

+    float percent;

+    /* Max components in a format is 4, so... */

+    float totals[4];

+    float area;

+    int i,j,k,xindex;

+

+    const char *temp, *temp0;

+    const char *temp_index;

+    int outindex;

+

+    int lowx_int, highx_int, lowy_int, highy_int;

+    float x_percent, y_percent;

+    float lowx_float, highx_float, lowy_float, highy_float;

+    float convy_float, convx_float;

+    int convy_int, convx_int;

+    int l, m;

+    const char *left, *right;

+

+    if (widthin == widthout*2 && heightin == heightout*2) {

+	halveImage_ubyte(components, widthin, heightin,

+	(const GLubyte *)datain, (GLubyte *)dataout,

+	element_size, ysize, group_size);

+	return;

+    }

+    convy = (float) heightin/heightout;

+    convx = (float) widthin/widthout;

+    convy_int = floor(convy);

+    convy_float = convy - convy_int;

+    convx_int = floor(convx);

+    convx_float = convx - convx_int;

+

+    area = convx * convy;

+

+    lowy_int = 0;

+    lowy_float = 0;

+    highy_int = convy_int;

+    highy_float = convy_float;

+

+    for (i = 0; i < heightout; i++) {

+        /* Clamp here to be sure we don't read beyond input buffer. */

+        if (highy_int >= heightin)

+            highy_int = heightin - 1;

+	lowx_int = 0;

+	lowx_float = 0;

+	highx_int = convx_int;

+	highx_float = convx_float;

+

+	for (j = 0; j < widthout; j++) {

+

+	    /*

+	    ** Ok, now apply box filter to box that goes from (lowx, lowy)

+	    ** to (highx, highy) on input data into this pixel on output

+	    ** data.

+	    */

+	    totals[0] = totals[1] = totals[2] = totals[3] = 0.0;

+

+	    /* calculate the value for pixels in the 1st row */

+	    xindex = lowx_int*group_size;

+	    if((highy_int>lowy_int) && (highx_int>lowx_int)) {

+

+		y_percent = 1-lowy_float;

+		temp = (const char *)datain + xindex + lowy_int * ysize;

+		percent = y_percent * (1-lowx_float);

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+			totals[k] += (GLubyte)(*(temp_index)) * percent;

+		}

+		left = temp;

+		for(l = lowx_int+1; l < highx_int; l++) {

+		    temp += group_size;

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			totals[k] += (GLubyte)(*(temp_index)) * y_percent;

+		    }

+		}

+		temp += group_size;

+		right = temp;

+		percent = y_percent * highx_float;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+			totals[k] += (GLubyte)(*(temp_index)) * percent;

+		}

+

+		/* calculate the value for pixels in the last row */

+		y_percent = highy_float;

+		percent = y_percent * (1-lowx_float);

+		temp = (const char *)datain + xindex + highy_int * ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+			totals[k] += (GLubyte)(*(temp_index)) * percent;

+		}

+		for(l = lowx_int+1; l < highx_int; l++) {

+		    temp += group_size;

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			totals[k] += (GLubyte)(*(temp_index)) * y_percent;

+		    }

+		}

+		temp += group_size;

+		percent = y_percent * highx_float;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+			totals[k] += (GLubyte)(*(temp_index)) * percent;

+		}

+

+

+		/* calculate the value for pixels in the 1st and last column */

+		for(m = lowy_int+1; m < highy_int; m++) {

+		    left += ysize;

+		    right += ysize;

+		    for (k = 0; k < components;

+			 k++, left += element_size, right += element_size) {

+			totals[k] += (GLubyte)(*(left))*(1-lowx_float)

+				+(GLubyte)(*(right))*highx_float;

+		    }

+		}

+	    } else if (highy_int > lowy_int) {

+		x_percent = highx_float - lowx_float;

+		percent = (1-lowy_float)*x_percent;

+		temp = (const char *)datain + xindex + lowy_int*ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+			totals[k] += (GLubyte)(*(temp_index)) * percent;

+		}

+		for(m = lowy_int+1; m < highy_int; m++) {

+		    temp += ysize;

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			totals[k] += (GLubyte)(*(temp_index)) * x_percent;

+		    }

+		}

+		percent = x_percent * highy_float;

+		temp += ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+			totals[k] += (GLubyte)(*(temp_index)) * percent;

+		}

+	    } else if (highx_int > lowx_int) {

+		y_percent = highy_float - lowy_float;

+		percent = (1-lowx_float)*y_percent;

+		temp = (const char *)datain + xindex + lowy_int*ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+			totals[k] += (GLubyte)(*(temp_index)) * percent;

+		}

+		for (l = lowx_int+1; l < highx_int; l++) {

+		    temp += group_size;

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			totals[k] += (GLubyte)(*(temp_index)) * y_percent;

+		    }

+		}

+		temp += group_size;

+		percent = y_percent * highx_float;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+			totals[k] += (GLubyte)(*(temp_index)) * percent;

+		}

+	    } else {

+		percent = (highy_float-lowy_float)*(highx_float-lowx_float);

+		temp = (const char *)datain + xindex + lowy_int * ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+			totals[k] += (GLubyte)(*(temp_index)) * percent;

+		}

+	    }

+

+

+

+	    /* this is for the pixels in the body */

+	    temp0 = (const char *)datain + xindex + group_size +

+		 (lowy_int+1)*ysize;

+	    for (m = lowy_int+1; m < highy_int; m++) {

+		temp = temp0;

+		for(l = lowx_int+1; l < highx_int; l++) {

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			totals[k] += (GLubyte)(*(temp_index));

+		    }

+		    temp += group_size;

+		}

+		temp0 += ysize;

+	    }

+

+	    outindex = (j + (i * widthout)) * components;

+	    for (k = 0; k < components; k++) {

+		dataout[outindex + k] = totals[k]/area;

+		/*printf("totals[%d] = %f\n", k, totals[k]);*/

+	    }

+	    lowx_int = highx_int;

+	    lowx_float = highx_float;

+	    highx_int += convx_int;

+	    highx_float += convx_float;

+	    if(highx_float > 1) {

+		highx_float -= 1.0;

+		highx_int++;

+	    }

+	}

+	lowy_int = highy_int;

+	lowy_float = highy_float;

+	highy_int += convy_int;

+	highy_float += convy_float;

+	if(highy_float > 1) {

+	    highy_float -= 1.0;

+	    highy_int++;

+	}

+    }

+}

+

+static void scale_internal_byte(GLint components, GLint widthin,

+			   GLint heightin, const GLbyte *datain,

+			   GLint widthout, GLint heightout,

+			   GLbyte *dataout, GLint element_size,

+			   GLint ysize, GLint group_size)

+{

+    float convx;

+    float convy;

+    float percent;

+    /* Max components in a format is 4, so... */

+    float totals[4];

+    float area;

+    int i,j,k,xindex;

+

+    const char *temp, *temp0;

+    const char *temp_index;

+    int outindex;

+

+    int lowx_int, highx_int, lowy_int, highy_int;

+    float x_percent, y_percent;

+    float lowx_float, highx_float, lowy_float, highy_float;

+    float convy_float, convx_float;

+    int convy_int, convx_int;

+    int l, m;

+    const char *left, *right;

+

+    if (widthin == widthout*2 && heightin == heightout*2) {

+	halveImage_byte(components, widthin, heightin,

+	(const GLbyte *)datain, (GLbyte *)dataout,

+	element_size, ysize, group_size);

+	return;

+    }

+    convy = (float) heightin/heightout;

+    convx = (float) widthin/widthout;

+    convy_int = floor(convy);

+    convy_float = convy - convy_int;

+    convx_int = floor(convx);

+    convx_float = convx - convx_int;

+

+    area = convx * convy;

+

+    lowy_int = 0;

+    lowy_float = 0;

+    highy_int = convy_int;

+    highy_float = convy_float;

+

+    for (i = 0; i < heightout; i++) {

+        /* Clamp here to be sure we don't read beyond input buffer. */

+        if (highy_int >= heightin)

+            highy_int = heightin - 1;

+	lowx_int = 0;

+	lowx_float = 0;

+	highx_int = convx_int;

+	highx_float = convx_float;

+

+	for (j = 0; j < widthout; j++) {

+

+	    /*

+	    ** Ok, now apply box filter to box that goes from (lowx, lowy)

+	    ** to (highx, highy) on input data into this pixel on output

+	    ** data.

+	    */

+	    totals[0] = totals[1] = totals[2] = totals[3] = 0.0;

+

+	    /* calculate the value for pixels in the 1st row */

+	    xindex = lowx_int*group_size;

+	    if((highy_int>lowy_int) && (highx_int>lowx_int)) {

+

+		y_percent = 1-lowy_float;

+		temp = (const char *)datain + xindex + lowy_int * ysize;

+		percent = y_percent * (1-lowx_float);

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+			totals[k] += (GLbyte)(*(temp_index)) * percent;

+		}

+		left = temp;

+		for(l = lowx_int+1; l < highx_int; l++) {

+		    temp += group_size;

+		    for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+			totals[k] += (GLbyte)(*(temp_index)) * y_percent;

+		    }

+		}

+		temp += group_size;

+		right = temp;

+		percent = y_percent * highx_float;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+			totals[k] += (GLbyte)(*(temp_index)) * percent;

+		}

+

+		/* calculate the value for pixels in the last row */	        

+		y_percent = highy_float;

+		percent = y_percent * (1-lowx_float);

+		temp = (const char *)datain + xindex + highy_int * ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+			totals[k] += (GLbyte)(*(temp_index)) * percent;

+		}

+		for(l = lowx_int+1; l < highx_int; l++) {

+		    temp += group_size;

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			totals[k] += (GLbyte)(*(temp_index)) * y_percent;

+		    }

+		}

+		temp += group_size;

+		percent = y_percent * highx_float;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+			totals[k] += (GLbyte)(*(temp_index)) * percent;

+		}

+

+

+		/* calculate the value for pixels in the 1st and last column */

+		for(m = lowy_int+1; m < highy_int; m++) {

+		    left += ysize;

+		    right += ysize;

+		    for (k = 0; k < components;

+			 k++, left += element_size, right += element_size) {

+			totals[k] += (GLbyte)(*(left))*(1-lowx_float)

+				+(GLbyte)(*(right))*highx_float;

+		    }

+		}

+	    } else if (highy_int > lowy_int) {

+		x_percent = highx_float - lowx_float;

+		percent = (1-lowy_float)*x_percent;

+		temp = (const char *)datain + xindex + lowy_int*ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+			totals[k] += (GLbyte)(*(temp_index)) * percent;

+		}

+		for(m = lowy_int+1; m < highy_int; m++) {

+		    temp += ysize;

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			totals[k] += (GLbyte)(*(temp_index)) * x_percent;

+		    }

+		}

+		percent = x_percent * highy_float;

+		temp += ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+			totals[k] += (GLbyte)(*(temp_index)) * percent;

+		}

+	    } else if (highx_int > lowx_int) {

+		y_percent = highy_float - lowy_float;

+		percent = (1-lowx_float)*y_percent;

+		temp = (const char *)datain + xindex + lowy_int*ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+			totals[k] += (GLbyte)(*(temp_index)) * percent;

+		}

+		for (l = lowx_int+1; l < highx_int; l++) {

+		    temp += group_size;

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			totals[k] += (GLbyte)(*(temp_index)) * y_percent;

+		    }

+		}

+		temp += group_size;

+		percent = y_percent * highx_float;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+			totals[k] += (GLbyte)(*(temp_index)) * percent;

+		}

+	    } else {

+		percent = (highy_float-lowy_float)*(highx_float-lowx_float);

+		temp = (const char *)datain + xindex + lowy_int * ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+			totals[k] += (GLbyte)(*(temp_index)) * percent;

+		}

+	    }

+

+

+

+	    /* this is for the pixels in the body */

+	    temp0 = (const char *)datain + xindex + group_size +

+		(lowy_int+1)*ysize;

+	    for (m = lowy_int+1; m < highy_int; m++) {

+		temp = temp0;

+		for(l = lowx_int+1; l < highx_int; l++) {

+		    for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+			totals[k] += (GLbyte)(*(temp_index));

+		    }

+		    temp += group_size;

+		}

+		temp0 += ysize;

+	    }

+

+	    outindex = (j + (i * widthout)) * components;

+	    for (k = 0; k < components; k++) {

+		dataout[outindex + k] = totals[k]/area;

+		/*printf("totals[%d] = %f\n", k, totals[k]);*/

+	    }

+	    lowx_int = highx_int;

+	    lowx_float = highx_float;

+	    highx_int += convx_int;

+	    highx_float += convx_float;

+	    if(highx_float > 1) {

+		highx_float -= 1.0;

+		highx_int++;

+	    }

+	}

+	lowy_int = highy_int;

+	lowy_float = highy_float;

+	highy_int += convy_int;

+	highy_float += convy_float;

+	if(highy_float > 1) {

+	    highy_float -= 1.0;

+	    highy_int++;

+	}

+    }

+}

+

+static void scale_internal_ushort(GLint components, GLint widthin,

+			   GLint heightin, const GLushort *datain,

+			   GLint widthout, GLint heightout,

+			   GLushort *dataout, GLint element_size,

+			   GLint ysize, GLint group_size,

+			   GLint myswap_bytes)

+{

+    float convx;

+    float convy;

+    float percent;

+    /* Max components in a format is 4, so... */

+    float totals[4];

+    float area;

+    int i,j,k,xindex;

+

+    const char *temp, *temp0;

+    const char *temp_index;

+    int outindex;

+

+    int lowx_int, highx_int, lowy_int, highy_int;

+    float x_percent, y_percent;

+    float lowx_float, highx_float, lowy_float, highy_float;

+    float convy_float, convx_float;

+    int convy_int, convx_int;

+    int l, m;

+    const char *left, *right;

+

+    if (widthin == widthout*2 && heightin == heightout*2) {

+	halveImage_ushort(components, widthin, heightin,

+	(const GLushort *)datain, (GLushort *)dataout,

+	element_size, ysize, group_size, myswap_bytes);

+	return;

+    }

+    convy = (float) heightin/heightout;

+    convx = (float) widthin/widthout;

+    convy_int = floor(convy);

+    convy_float = convy - convy_int;

+    convx_int = floor(convx);

+    convx_float = convx - convx_int;

+

+    area = convx * convy;

+

+    lowy_int = 0;

+    lowy_float = 0;

+    highy_int = convy_int;

+    highy_float = convy_float;

+

+    for (i = 0; i < heightout; i++) {

+        /* Clamp here to be sure we don't read beyond input buffer. */

+        if (highy_int >= heightin)

+            highy_int = heightin - 1;

+	lowx_int = 0;

+	lowx_float = 0;

+	highx_int = convx_int;

+	highx_float = convx_float;

+

+	for (j = 0; j < widthout; j++) {

+	    /*

+	    ** Ok, now apply box filter to box that goes from (lowx, lowy)

+	    ** to (highx, highy) on input data into this pixel on output

+	    ** data.

+	    */

+	    totals[0] = totals[1] = totals[2] = totals[3] = 0.0;

+

+	    /* calculate the value for pixels in the 1st row */

+	    xindex = lowx_int*group_size;

+	    if((highy_int>lowy_int) && (highx_int>lowx_int)) {

+

+		y_percent = 1-lowy_float;

+		temp = (const char *)datain + xindex + lowy_int * ysize;

+		percent = y_percent * (1-lowx_float);

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;

+		    } else {

+			totals[k] += *(const GLushort*)temp_index * percent;

+		    }

+		}

+		left = temp;

+		for(l = lowx_int+1; l < highx_int; l++) {

+		    temp += group_size;

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			if (myswap_bytes) {

+			    totals[k] +=

+				 __GLU_SWAP_2_BYTES(temp_index) * y_percent;

+			} else {

+			    totals[k] += *(const GLushort*)temp_index * y_percent;

+			}

+		    }

+		}

+		temp += group_size;

+		right = temp;

+		percent = y_percent * highx_float;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;

+		    } else {

+			totals[k] += *(const GLushort*)temp_index * percent;

+		    }

+		}

+

+		/* calculate the value for pixels in the last row */	        

+		y_percent = highy_float;

+		percent = y_percent * (1-lowx_float);

+		temp = (const char *)datain + xindex + highy_int * ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;

+		    } else {

+			totals[k] += *(const GLushort*)temp_index * percent;

+		    }

+		}

+		for(l = lowx_int+1; l < highx_int; l++) {

+		    temp += group_size;

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			if (myswap_bytes) {

+			    totals[k] +=

+				 __GLU_SWAP_2_BYTES(temp_index) * y_percent;

+			} else {

+			    totals[k] += *(const GLushort*)temp_index * y_percent;

+			}

+		    }

+		}

+		temp += group_size;

+		percent = y_percent * highx_float;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;

+		    } else {

+			totals[k] += *(const GLushort*)temp_index * percent;

+		    }

+		}

+

+		/* calculate the value for pixels in the 1st and last column */

+		for(m = lowy_int+1; m < highy_int; m++) {

+		    left += ysize;

+		    right += ysize;

+		    for (k = 0; k < components;

+			 k++, left += element_size, right += element_size) {

+			if (myswap_bytes) {

+			    totals[k] +=

+				__GLU_SWAP_2_BYTES(left) * (1-lowx_float) +

+				__GLU_SWAP_2_BYTES(right) * highx_float;

+			} else {

+			    totals[k] += *(const GLushort*)left * (1-lowx_float)

+				       + *(const GLushort*)right * highx_float;

+			}

+		    }

+		}

+	    } else if (highy_int > lowy_int) {

+		x_percent = highx_float - lowx_float;

+		percent = (1-lowy_float)*x_percent;

+		temp = (const char *)datain + xindex + lowy_int*ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;

+		    } else {

+			totals[k] += *(const GLushort*)temp_index * percent;

+		    }

+		}

+		for(m = lowy_int+1; m < highy_int; m++) {

+		    temp += ysize;

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			if (myswap_bytes) {

+			    totals[k] +=

+				__GLU_SWAP_2_BYTES(temp_index) * x_percent;

+			} else {

+			    totals[k] += *(const GLushort*)temp_index * x_percent;

+			}

+		    }

+		}

+		percent = x_percent * highy_float;

+		temp += ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;

+		    } else {

+			totals[k] += *(const GLushort*)temp_index * percent;

+		    }

+		}

+	    } else if (highx_int > lowx_int) {

+		y_percent = highy_float - lowy_float;

+		percent = (1-lowx_float)*y_percent;

+		temp = (const char *)datain + xindex + lowy_int*ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;

+		    } else {

+			totals[k] += *(const GLushort*)temp_index * percent;

+		    }

+		}

+		for (l = lowx_int+1; l < highx_int; l++) {

+		    temp += group_size;

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			if (myswap_bytes) {

+			    totals[k] +=

+				__GLU_SWAP_2_BYTES(temp_index) * y_percent;

+			} else {

+			    totals[k] += *(const GLushort*)temp_index * y_percent;

+			}

+		    }

+		}

+		temp += group_size;

+		percent = y_percent * highx_float;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;

+		    } else {

+			totals[k] += *(const GLushort*)temp_index * percent;

+		    }

+		}

+	    } else {

+		percent = (highy_float-lowy_float)*(highx_float-lowx_float);

+		temp = (const char *)datain + xindex + lowy_int * ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;

+		    } else {

+			totals[k] += *(const GLushort*)temp_index * percent;

+		    }

+		}

+	    }

+

+	    /* this is for the pixels in the body */

+	    temp0 = (const char *)datain + xindex + group_size +

+		 (lowy_int+1)*ysize;

+	    for (m = lowy_int+1; m < highy_int; m++) {

+		temp = temp0;

+		for(l = lowx_int+1; l < highx_int; l++) {

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			if (myswap_bytes) {

+			    totals[k] += __GLU_SWAP_2_BYTES(temp_index);

+			} else {

+			    totals[k] += *(const GLushort*)temp_index;

+			}

+		    }

+		    temp += group_size;

+		}

+		temp0 += ysize;

+	    }

+

+	    outindex = (j + (i * widthout)) * components;

+	    for (k = 0; k < components; k++) {

+		dataout[outindex + k] = totals[k]/area;

+		/*printf("totals[%d] = %f\n", k, totals[k]);*/

+	    }

+	    lowx_int = highx_int;

+	    lowx_float = highx_float;

+	    highx_int += convx_int;

+	    highx_float += convx_float;

+	    if(highx_float > 1) {

+		highx_float -= 1.0;

+		highx_int++;

+	    }

+	}

+	lowy_int = highy_int;

+	lowy_float = highy_float;

+	highy_int += convy_int;

+	highy_float += convy_float;

+	if(highy_float > 1) {

+	    highy_float -= 1.0;

+	    highy_int++;

+	}

+    }

+}

+

+static void scale_internal_short(GLint components, GLint widthin,

+			   GLint heightin, const GLshort *datain,

+			   GLint widthout, GLint heightout,

+			   GLshort *dataout, GLint element_size,

+			   GLint ysize, GLint group_size,

+			   GLint myswap_bytes)

+{

+    float convx;

+    float convy;

+    float percent;

+    /* Max components in a format is 4, so... */

+    float totals[4];

+    float area;

+    int i,j,k,xindex;

+

+    const char *temp, *temp0;

+    const char *temp_index;

+    int outindex;

+

+    int lowx_int, highx_int, lowy_int, highy_int;

+    float x_percent, y_percent;

+    float lowx_float, highx_float, lowy_float, highy_float;

+    float convy_float, convx_float;

+    int convy_int, convx_int;

+    int l, m;

+    const char *left, *right;

+

+    GLushort swapbuf;	/* unsigned buffer */

+

+    if (widthin == widthout*2 && heightin == heightout*2) {

+	halveImage_short(components, widthin, heightin,

+	(const GLshort *)datain, (GLshort *)dataout,

+	element_size, ysize, group_size, myswap_bytes);

+	return;

+    }

+    convy = (float) heightin/heightout;

+    convx = (float) widthin/widthout;

+    convy_int = floor(convy);

+    convy_float = convy - convy_int;

+    convx_int = floor(convx);

+    convx_float = convx - convx_int;

+

+    area = convx * convy;

+

+    lowy_int = 0;

+    lowy_float = 0;

+    highy_int = convy_int;

+    highy_float = convy_float;

+

+    for (i = 0; i < heightout; i++) {

+        /* Clamp here to be sure we don't read beyond input buffer. */

+        if (highy_int >= heightin)

+            highy_int = heightin - 1;

+	lowx_int = 0;

+	lowx_float = 0;

+	highx_int = convx_int;

+	highx_float = convx_float;

+

+	for (j = 0; j < widthout; j++) {

+	    /*

+	    ** Ok, now apply box filter to box that goes from (lowx, lowy)

+	    ** to (highx, highy) on input data into this pixel on output

+	    ** data.

+	    */

+	    totals[0] = totals[1] = totals[2] = totals[3] = 0.0;

+

+	    /* calculate the value for pixels in the 1st row */

+	    xindex = lowx_int*group_size;

+	    if((highy_int>lowy_int) && (highx_int>lowx_int)) {

+

+		y_percent = 1-lowy_float;

+		temp = (const char *)datain + xindex + lowy_int * ysize;

+		percent = y_percent * (1-lowx_float);

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			swapbuf = __GLU_SWAP_2_BYTES(temp_index);

+			totals[k] += *(const GLshort*)&swapbuf * percent;

+		    } else {

+			totals[k] += *(const GLshort*)temp_index * percent;

+		    }

+		}

+		left = temp;

+		for(l = lowx_int+1; l < highx_int; l++) {

+		    temp += group_size;

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			if (myswap_bytes) {

+			    swapbuf = __GLU_SWAP_2_BYTES(temp_index);

+			    totals[k] += *(const GLshort*)&swapbuf * y_percent;

+			} else {

+			    totals[k] += *(const GLshort*)temp_index * y_percent;

+			}

+		    }

+		}

+		temp += group_size;

+		right = temp;

+		percent = y_percent * highx_float;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			swapbuf = __GLU_SWAP_2_BYTES(temp_index);

+			totals[k] += *(const GLshort*)&swapbuf * percent;

+		    } else {

+			totals[k] += *(const GLshort*)temp_index * percent;

+		    }

+		}

+

+		/* calculate the value for pixels in the last row */

+		y_percent = highy_float;

+		percent = y_percent * (1-lowx_float);

+		temp = (const char *)datain + xindex + highy_int * ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			swapbuf = __GLU_SWAP_2_BYTES(temp_index);

+			totals[k] += *(const GLshort*)&swapbuf * percent;

+		    } else {

+			totals[k] += *(const GLshort*)temp_index * percent;

+		    }

+		}

+		for(l = lowx_int+1; l < highx_int; l++) {

+		    temp += group_size;

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			if (myswap_bytes) {

+			    swapbuf = __GLU_SWAP_2_BYTES(temp_index);

+			    totals[k] += *(const GLshort*)&swapbuf * y_percent;

+			} else {

+			    totals[k] += *(const GLshort*)temp_index * y_percent;

+			}

+		    }

+		}

+		temp += group_size;

+		percent = y_percent * highx_float;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			swapbuf = __GLU_SWAP_2_BYTES(temp_index);

+			totals[k] += *(const GLshort*)&swapbuf * percent;

+		    } else {

+			totals[k] += *(const GLshort*)temp_index * percent;

+		    }

+		}

+

+		/* calculate the value for pixels in the 1st and last column */

+		for(m = lowy_int+1; m < highy_int; m++) {

+		    left += ysize;

+		    right += ysize;

+		    for (k = 0; k < components;

+			 k++, left += element_size, right += element_size) {

+			if (myswap_bytes) {

+			    swapbuf = __GLU_SWAP_2_BYTES(left);

+			    totals[k] += *(const GLshort*)&swapbuf * (1-lowx_float);

+			    swapbuf = __GLU_SWAP_2_BYTES(right);

+			    totals[k] += *(const GLshort*)&swapbuf * highx_float;

+			} else {

+			    totals[k] += *(const GLshort*)left * (1-lowx_float)

+				       + *(const GLshort*)right * highx_float;

+			}

+		    }

+		}

+	    } else if (highy_int > lowy_int) {

+		x_percent = highx_float - lowx_float;

+		percent = (1-lowy_float)*x_percent;

+		temp = (const char *)datain + xindex + lowy_int*ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			swapbuf = __GLU_SWAP_2_BYTES(temp_index);

+			totals[k] += *(const GLshort*)&swapbuf * percent;

+		    } else {

+			totals[k] += *(const GLshort*)temp_index * percent;

+		    }

+		}

+		for(m = lowy_int+1; m < highy_int; m++) {

+		    temp += ysize;

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			if (myswap_bytes) {

+			    swapbuf = __GLU_SWAP_2_BYTES(temp_index);

+			    totals[k] += *(const GLshort*)&swapbuf * x_percent;

+			} else {

+			    totals[k] += *(const GLshort*)temp_index * x_percent;

+			}

+		    }

+		}

+		percent = x_percent * highy_float;

+		temp += ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			swapbuf = __GLU_SWAP_2_BYTES(temp_index);

+			totals[k] += *(const GLshort*)&swapbuf * percent;

+		    } else {

+			totals[k] += *(const GLshort*)temp_index * percent;

+		    }

+		}

+	    } else if (highx_int > lowx_int) {

+		y_percent = highy_float - lowy_float;

+		percent = (1-lowx_float)*y_percent;

+

+	     temp = (const char *)datain + xindex + lowy_int*ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			swapbuf = __GLU_SWAP_2_BYTES(temp_index);

+			totals[k] += *(const GLshort*)&swapbuf * percent;

+		    } else {

+			totals[k] += *(const GLshort*)temp_index * percent;

+		    }

+		}

+		for (l = lowx_int+1; l < highx_int; l++) {

+		    temp += group_size;

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			if (myswap_bytes) {

+			    swapbuf = __GLU_SWAP_2_BYTES(temp_index);

+			    totals[k] += *(const GLshort*)&swapbuf * y_percent;

+			} else {

+			    totals[k] += *(const GLshort*)temp_index * y_percent;

+			}

+		    }

+		}

+		temp += group_size;

+		percent = y_percent * highx_float;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			swapbuf = __GLU_SWAP_2_BYTES(temp_index);

+			totals[k] += *(const GLshort*)&swapbuf * percent;

+		    } else {

+			totals[k] += *(const GLshort*)temp_index * percent;

+		    }

+		}

+	    } else {

+		percent = (highy_float-lowy_float)*(highx_float-lowx_float);

+		temp = (const char *)datain + xindex + lowy_int * ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			swapbuf = __GLU_SWAP_2_BYTES(temp_index);

+			totals[k] += *(const GLshort*)&swapbuf * percent;

+		    } else {

+			totals[k] += *(const GLshort*)temp_index * percent;

+		    }

+		}

+	    }

+

+	    /* this is for the pixels in the body */

+	    temp0 = (const char *)datain + xindex + group_size +

+		 (lowy_int+1)*ysize;

+	    for (m = lowy_int+1; m < highy_int; m++) {

+		temp = temp0;

+		for(l = lowx_int+1; l < highx_int; l++) {

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			if (myswap_bytes) {

+			    swapbuf = __GLU_SWAP_2_BYTES(temp_index);

+			    totals[k] += *(const GLshort*)&swapbuf;

+			} else {

+			    totals[k] += *(const GLshort*)temp_index;

+			}

+		    }

+		    temp += group_size;

+		}

+		temp0 += ysize;

+	    }

+

+	    outindex = (j + (i * widthout)) * components;

+	    for (k = 0; k < components; k++) {

+		dataout[outindex + k] = totals[k]/area;

+		/*printf("totals[%d] = %f\n", k, totals[k]);*/

+	    }

+	    lowx_int = highx_int;

+	    lowx_float = highx_float;

+	    highx_int += convx_int;

+	    highx_float += convx_float;

+	    if(highx_float > 1) {

+		highx_float -= 1.0;

+		highx_int++;

+	    }

+	}

+	lowy_int = highy_int;

+	lowy_float = highy_float;

+	highy_int += convy_int;

+	highy_float += convy_float;

+	if(highy_float > 1) {

+	    highy_float -= 1.0;

+	    highy_int++;

+	}

+    }

+}

+

+static void scale_internal_uint(GLint components, GLint widthin,

+			   GLint heightin, const GLuint *datain,

+			   GLint widthout, GLint heightout,

+			   GLuint *dataout, GLint element_size,

+			   GLint ysize, GLint group_size,

+			   GLint myswap_bytes)

+{

+    float convx;

+    float convy;

+    float percent;

+    /* Max components in a format is 4, so... */

+    float totals[4];

+    float area;

+    int i,j,k,xindex;

+

+    const char *temp, *temp0;

+    const char *temp_index;

+    int outindex;

+

+    int lowx_int, highx_int, lowy_int, highy_int;

+    float x_percent, y_percent;

+    float lowx_float, highx_float, lowy_float, highy_float;

+    float convy_float, convx_float;

+    int convy_int, convx_int;

+    int l, m;

+    const char *left, *right;

+

+    if (widthin == widthout*2 && heightin == heightout*2) {

+	halveImage_uint(components, widthin, heightin,

+	(const GLuint *)datain, (GLuint *)dataout,

+	element_size, ysize, group_size, myswap_bytes);

+	return;

+    }

+    convy = (float) heightin/heightout;

+    convx = (float) widthin/widthout;

+    convy_int = floor(convy);

+    convy_float = convy - convy_int;

+    convx_int = floor(convx);

+    convx_float = convx - convx_int;

+

+    area = convx * convy;

+

+    lowy_int = 0;

+    lowy_float = 0;

+    highy_int = convy_int;

+    highy_float = convy_float;

+

+    for (i = 0; i < heightout; i++) {

+        /* Clamp here to be sure we don't read beyond input buffer. */

+        if (highy_int >= heightin)

+            highy_int = heightin - 1;

+	lowx_int = 0;

+	lowx_float = 0;

+	highx_int = convx_int;

+	highx_float = convx_float;

+

+	for (j = 0; j < widthout; j++) {

+	    /*

+	    ** Ok, now apply box filter to box that goes from (lowx, lowy)

+	    ** to (highx, highy) on input data into this pixel on output

+	    ** data.

+	    */

+	    totals[0] = totals[1] = totals[2] = totals[3] = 0.0;

+

+	    /* calculate the value for pixels in the 1st row */

+	    xindex = lowx_int*group_size;

+	    if((highy_int>lowy_int) && (highx_int>lowx_int)) {

+

+		y_percent = 1-lowy_float;

+		temp = (const char *)datain + xindex + lowy_int * ysize;

+		percent = y_percent * (1-lowx_float);

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;

+		    } else {

+			totals[k] += *(const GLuint*)temp_index * percent;

+		    }

+		}

+		left = temp;

+		for(l = lowx_int+1; l < highx_int; l++) {

+		    temp += group_size;

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			if (myswap_bytes) {

+			    totals[k] +=

+				 __GLU_SWAP_4_BYTES(temp_index) * y_percent;

+			} else {

+			    totals[k] += *(const GLuint*)temp_index * y_percent;

+			}

+		    }

+		}

+		temp += group_size;

+		right = temp;

+		percent = y_percent * highx_float;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;

+		    } else {

+			totals[k] += *(const GLuint*)temp_index * percent;

+		    }

+		}

+

+		/* calculate the value for pixels in the last row */

+		y_percent = highy_float;

+		percent = y_percent * (1-lowx_float);

+		temp = (const char *)datain + xindex + highy_int * ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;

+		    } else {

+			totals[k] += *(const GLuint*)temp_index * percent;

+		    }

+		}

+		for(l = lowx_int+1; l < highx_int; l++) {

+		    temp += group_size;

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			if (myswap_bytes) {

+			    totals[k] +=

+				 __GLU_SWAP_4_BYTES(temp_index) * y_percent;

+			} else {

+			    totals[k] += *(const GLuint*)temp_index * y_percent;

+			}

+		    }

+		}

+		temp += group_size;

+		percent = y_percent * highx_float;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;

+		    } else {

+			totals[k] += *(const GLuint*)temp_index * percent;

+		    }

+		}

+

+		/* calculate the value for pixels in the 1st and last column */

+		for(m = lowy_int+1; m < highy_int; m++) {

+		    left += ysize;

+		    right += ysize;

+		    for (k = 0; k < components;

+			 k++, left += element_size, right += element_size) {

+			if (myswap_bytes) {

+			    totals[k] +=

+				__GLU_SWAP_4_BYTES(left) * (1-lowx_float)

+			      + __GLU_SWAP_4_BYTES(right) * highx_float;

+			} else {

+			    totals[k] += *(const GLuint*)left * (1-lowx_float)

+				       + *(const GLuint*)right * highx_float;

+			}

+		    }

+		}

+	    } else if (highy_int > lowy_int) {

+		x_percent = highx_float - lowx_float;

+		percent = (1-lowy_float)*x_percent;

+		temp = (const char *)datain + xindex + lowy_int*ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;

+		    } else {

+			totals[k] += *(const GLuint*)temp_index * percent;

+		    }

+		}

+		for(m = lowy_int+1; m < highy_int; m++) {

+		    temp += ysize;

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			if (myswap_bytes) {

+			    totals[k] +=

+				 __GLU_SWAP_4_BYTES(temp_index) * x_percent;

+			} else {

+			    totals[k] += *(const GLuint*)temp_index * x_percent;

+			}

+		    }

+		}

+		percent = x_percent * highy_float;

+		temp += ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;

+		    } else {

+			totals[k] += *(const GLuint*)temp_index * percent;

+		    }

+		}

+	    } else if (highx_int > lowx_int) {

+		y_percent = highy_float - lowy_float;

+		percent = (1-lowx_float)*y_percent;

+

+	     temp = (const char *)datain + xindex + lowy_int*ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;

+		    } else {

+			totals[k] += *(const GLuint*)temp_index * percent;

+		    }

+		}

+		for (l = lowx_int+1; l < highx_int; l++) {

+		    temp += group_size;

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			if (myswap_bytes) {

+			    totals[k] +=

+				 __GLU_SWAP_4_BYTES(temp_index) * y_percent;

+			} else {

+			    totals[k] += *(const GLuint*)temp_index * y_percent;

+			}

+		    }

+		}

+		temp += group_size;

+		percent = y_percent * highx_float;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;

+		    } else {

+			totals[k] += *(const GLuint*)temp_index * percent;

+		    }

+		}

+	    } else {

+		percent = (highy_float-lowy_float)*(highx_float-lowx_float);

+		temp = (const char *)datain + xindex + lowy_int * ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;

+		    } else {

+			totals[k] += *(const GLuint*)temp_index * percent;

+		    }

+		}

+	    }

+

+	    /* this is for the pixels in the body */

+	    temp0 = (const char *)datain + xindex + group_size +

+		 (lowy_int+1)*ysize;

+	    for (m = lowy_int+1; m < highy_int; m++) {

+		temp = temp0;

+		for(l = lowx_int+1; l < highx_int; l++) {

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			if (myswap_bytes) {

+			    totals[k] += __GLU_SWAP_4_BYTES(temp_index);

+			} else {

+			    totals[k] += *(const GLuint*)temp_index;

+			}

+		    }

+		    temp += group_size;

+		}

+		temp0 += ysize;

+	    }

+

+	    outindex = (j + (i * widthout)) * components;

+	    for (k = 0; k < components; k++) {

+		/* clamp at UINT_MAX */

+		float value= totals[k]/area;

+		if (value >= (float) UINT_MAX) {	/* need '=' */

+		  dataout[outindex + k] = UINT_MAX;

+		}

+		else dataout[outindex + k] = value;

+	    }

+	    lowx_int = highx_int;

+	    lowx_float = highx_float;

+	    highx_int += convx_int;

+	    highx_float += convx_float;

+	    if(highx_float > 1) {

+		highx_float -= 1.0;

+		highx_int++;

+	    }

+	}

+	lowy_int = highy_int;

+	lowy_float = highy_float;

+	highy_int += convy_int;

+	highy_float += convy_float;

+	if(highy_float > 1) {

+	    highy_float -= 1.0;

+	    highy_int++;

+	}

+    }

+}

+

+

+

+static void scale_internal_int(GLint components, GLint widthin,

+			   GLint heightin, const GLint *datain,

+			   GLint widthout, GLint heightout,

+			   GLint *dataout, GLint element_size,

+			   GLint ysize, GLint group_size,

+			   GLint myswap_bytes)

+{

+    float convx;

+    float convy;

+    float percent;

+    /* Max components in a format is 4, so... */

+    float totals[4];

+    float area;

+    int i,j,k,xindex;

+

+    const char *temp, *temp0;

+    const char *temp_index;

+    int outindex;

+

+    int lowx_int, highx_int, lowy_int, highy_int;

+    float x_percent, y_percent;

+    float lowx_float, highx_float, lowy_float, highy_float;

+    float convy_float, convx_float;

+    int convy_int, convx_int;

+    int l, m;

+    const char *left, *right;

+

+    GLuint swapbuf;	/* unsigned buffer */

+

+    if (widthin == widthout*2 && heightin == heightout*2) {

+	halveImage_int(components, widthin, heightin,

+	(const GLint *)datain, (GLint *)dataout,

+	element_size, ysize, group_size, myswap_bytes);

+	return;

+    }

+    convy = (float) heightin/heightout;

+    convx = (float) widthin/widthout;

+    convy_int = floor(convy);

+    convy_float = convy - convy_int;

+    convx_int = floor(convx);

+    convx_float = convx - convx_int;

+

+    area = convx * convy;

+

+    lowy_int = 0;

+    lowy_float = 0;

+    highy_int = convy_int;

+    highy_float = convy_float;

+

+    for (i = 0; i < heightout; i++) {

+        /* Clamp here to be sure we don't read beyond input buffer. */

+        if (highy_int >= heightin)

+            highy_int = heightin - 1;

+	lowx_int = 0;

+	lowx_float = 0;

+	highx_int = convx_int;

+	highx_float = convx_float;

+

+	for (j = 0; j < widthout; j++) {

+	    /*

+	    ** Ok, now apply box filter to box that goes from (lowx, lowy)

+	    ** to (highx, highy) on input data into this pixel on output

+	    ** data.

+	    */

+	    totals[0] = totals[1] = totals[2] = totals[3] = 0.0;

+

+	    /* calculate the value for pixels in the 1st row */

+	    xindex = lowx_int*group_size;

+	    if((highy_int>lowy_int) && (highx_int>lowx_int)) {

+

+		y_percent = 1-lowy_float;

+		temp = (const char *)datain + xindex + lowy_int * ysize;

+		percent = y_percent * (1-lowx_float);

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			swapbuf = __GLU_SWAP_4_BYTES(temp_index);

+			totals[k] += *(const GLint*)&swapbuf * percent;

+		    } else {

+			totals[k] += *(const GLint*)temp_index * percent;

+		    }

+		}

+		left = temp;

+		for(l = lowx_int+1; l < highx_int; l++) {

+		    temp += group_size;

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			if (myswap_bytes) {

+			    swapbuf = __GLU_SWAP_4_BYTES(temp_index);

+			    totals[k] += *(const GLint*)&swapbuf * y_percent;

+			} else {

+			    totals[k] += *(const GLint*)temp_index * y_percent;

+			}

+		    }

+		}

+		temp += group_size;

+		right = temp;

+		percent = y_percent * highx_float;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			swapbuf = __GLU_SWAP_4_BYTES(temp_index);

+			totals[k] += *(const GLint*)&swapbuf * percent;

+		    } else {

+			totals[k] += *(const GLint*)temp_index * percent;

+		    }

+		}

+

+		/* calculate the value for pixels in the last row */

+		y_percent = highy_float;

+		percent = y_percent * (1-lowx_float);

+		temp = (const char *)datain + xindex + highy_int * ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			swapbuf = __GLU_SWAP_4_BYTES(temp_index);

+			totals[k] += *(const GLint*)&swapbuf  * percent;

+		    } else {

+			totals[k] += *(const GLint*)temp_index * percent;

+		    }

+		}

+		for(l = lowx_int+1; l < highx_int; l++) {

+		    temp += group_size;

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			if (myswap_bytes) {

+			    swapbuf = __GLU_SWAP_4_BYTES(temp_index);

+			    totals[k] += *(const GLint*)&swapbuf * y_percent;

+			} else {

+			    totals[k] += *(const GLint*)temp_index * y_percent;

+			}

+		    }

+		}

+		temp += group_size;

+		percent = y_percent * highx_float;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			swapbuf = __GLU_SWAP_4_BYTES(temp_index);

+			totals[k] += *(const GLint*)&swapbuf * percent;

+		    } else {

+			totals[k] += *(const GLint*)temp_index * percent;

+		    }

+		}

+

+		/* calculate the value for pixels in the 1st and last column */

+		for(m = lowy_int+1; m < highy_int; m++) {

+		    left += ysize;

+		    right += ysize;

+		    for (k = 0; k < components;

+			 k++, left += element_size, right += element_size) {

+			if (myswap_bytes) {

+			    swapbuf = __GLU_SWAP_4_BYTES(left);

+			    totals[k] += *(const GLint*)&swapbuf * (1-lowx_float);

+			    swapbuf = __GLU_SWAP_4_BYTES(right);

+			    totals[k] += *(const GLint*)&swapbuf * highx_float;

+			} else {

+			    totals[k] += *(const GLint*)left * (1-lowx_float)

+				       + *(const GLint*)right * highx_float;

+			}

+		    }

+		}

+	    } else if (highy_int > lowy_int) {

+		x_percent = highx_float - lowx_float;

+		percent = (1-lowy_float)*x_percent;

+		temp = (const char *)datain + xindex + lowy_int*ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			swapbuf = __GLU_SWAP_4_BYTES(temp_index);

+			totals[k] += *(const GLint*)&swapbuf * percent;

+		    } else {

+			totals[k] += *(const GLint*)temp_index * percent;

+		    }

+		}

+		for(m = lowy_int+1; m < highy_int; m++) {

+		    temp += ysize;

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			if (myswap_bytes) {

+			    swapbuf = __GLU_SWAP_4_BYTES(temp_index);

+			    totals[k] += *(const GLint*)&swapbuf * x_percent;

+			} else {

+			    totals[k] += *(const GLint*)temp_index * x_percent;

+			}

+		    }

+		}

+		percent = x_percent * highy_float;

+		temp += ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			swapbuf = __GLU_SWAP_4_BYTES(temp_index);

+			totals[k] += *(const GLint*)&swapbuf * percent;

+		    } else {

+			totals[k] += *(const GLint*)temp_index * percent;

+		    }

+		}

+	    } else if (highx_int > lowx_int) {

+		y_percent = highy_float - lowy_float;

+		percent = (1-lowx_float)*y_percent;

+

+		 temp = (const char *)datain + xindex + lowy_int*ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			swapbuf = __GLU_SWAP_4_BYTES(temp_index);

+			totals[k] += *(const GLint*)&swapbuf * percent;

+		    } else {

+			totals[k] += *(const GLint*)temp_index * percent;

+		    }

+		}

+		for (l = lowx_int+1; l < highx_int; l++) {

+		    temp += group_size;

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			if (myswap_bytes) {

+			    swapbuf = __GLU_SWAP_4_BYTES(temp_index);

+			    totals[k] += *(const GLint*)&swapbuf * y_percent;

+			} else {

+			    totals[k] += *(const GLint*)temp_index * y_percent;

+			}

+		    }

+		}

+		temp += group_size;

+		percent = y_percent * highx_float;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			swapbuf = __GLU_SWAP_4_BYTES(temp_index);

+			totals[k] += *(const GLint*)&swapbuf * percent;

+		    } else {

+			totals[k] += *(const GLint*)temp_index * percent;

+		    }

+		}

+	    } else {

+		percent = (highy_float-lowy_float)*(highx_float-lowx_float);

+		temp = (const char *)datain + xindex + lowy_int * ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			swapbuf = __GLU_SWAP_4_BYTES(temp_index);

+			totals[k] += *(const GLint*)&swapbuf * percent;

+		    } else {

+			totals[k] += *(const GLint*)temp_index * percent;

+		    }

+		}

+	    }

+

+	    /* this is for the pixels in the body */

+	    temp0 = (const char *)datain + xindex + group_size +

+		 (lowy_int+1)*ysize;

+	    for (m = lowy_int+1; m < highy_int; m++) {

+		temp = temp0;

+		for(l = lowx_int+1; l < highx_int; l++) {

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			if (myswap_bytes) {

+			    swapbuf = __GLU_SWAP_4_BYTES(temp_index);

+			    totals[k] += *(const GLint*)&swapbuf;

+			} else {

+			    totals[k] += *(const GLint*)temp_index;

+			}

+		    }

+		    temp += group_size;

+		}

+		temp0 += ysize;

+	    }

+

+	    outindex = (j + (i * widthout)) * components;

+	    for (k = 0; k < components; k++) {

+		dataout[outindex + k] = totals[k]/area;

+		/*printf("totals[%d] = %f\n", k, totals[k]);*/

+	    }

+	    lowx_int = highx_int;

+	    lowx_float = highx_float;

+	    highx_int += convx_int;

+	    highx_float += convx_float;

+	    if(highx_float > 1) {

+		highx_float -= 1.0;

+		highx_int++;

+	    }

+	}

+	lowy_int = highy_int;

+	lowy_float = highy_float;

+	highy_int += convy_int;

+	highy_float += convy_float;

+	if(highy_float > 1) {

+	    highy_float -= 1.0;

+	    highy_int++;

+	}

+    }

+}

+

+

+

+static void scale_internal_float(GLint components, GLint widthin,

+			   GLint heightin, const GLfloat *datain,

+			   GLint widthout, GLint heightout,

+			   GLfloat *dataout, GLint element_size,

+			   GLint ysize, GLint group_size,

+			   GLint myswap_bytes)

+{

+    float convx;

+    float convy;

+    float percent;

+    /* Max components in a format is 4, so... */

+    float totals[4];

+    float area;

+    int i,j,k,xindex;

+

+    const char *temp, *temp0;

+    const char *temp_index;

+    int outindex;

+

+    int lowx_int, highx_int, lowy_int, highy_int;

+    float x_percent, y_percent;

+    float lowx_float, highx_float, lowy_float, highy_float;

+    float convy_float, convx_float;

+    int convy_int, convx_int;

+    int l, m;

+    const char *left, *right;

+

+    union { GLuint b; GLfloat f; } swapbuf;

+

+    if (widthin == widthout*2 && heightin == heightout*2) {

+	halveImage_float(components, widthin, heightin,

+	(const GLfloat *)datain, (GLfloat *)dataout,

+	element_size, ysize, group_size, myswap_bytes);

+	return;

+    }

+    convy = (float) heightin/heightout;

+    convx = (float) widthin/widthout;

+    convy_int = floor(convy);

+    convy_float = convy - convy_int;

+    convx_int = floor(convx);

+    convx_float = convx - convx_int;

+

+    area = convx * convy;

+

+    lowy_int = 0;

+    lowy_float = 0;

+    highy_int = convy_int;

+    highy_float = convy_float;

+

+    for (i = 0; i < heightout; i++) {

+        /* Clamp here to be sure we don't read beyond input buffer. */

+        if (highy_int >= heightin)

+            highy_int = heightin - 1;

+	lowx_int = 0;

+	lowx_float = 0;

+	highx_int = convx_int;

+	highx_float = convx_float;

+

+	for (j = 0; j < widthout; j++) {

+	    /*

+	    ** Ok, now apply box filter to box that goes from (lowx, lowy)

+	    ** to (highx, highy) on input data into this pixel on output

+	    ** data.

+	    */

+	    totals[0] = totals[1] = totals[2] = totals[3] = 0.0;

+

+	    /* calculate the value for pixels in the 1st row */

+	    xindex = lowx_int*group_size;

+	    if((highy_int>lowy_int) && (highx_int>lowx_int)) {

+

+		y_percent = 1-lowy_float;

+		temp = (const char *)datain + xindex + lowy_int * ysize;

+		percent = y_percent * (1-lowx_float);

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);

+			totals[k] += swapbuf.f * percent;

+		    } else {

+			totals[k] += *(const GLfloat*)temp_index * percent;

+		    }

+		}

+		left = temp;

+		for(l = lowx_int+1; l < highx_int; l++) {

+		    temp += group_size;

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			if (myswap_bytes) {

+			    swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);

+			    totals[k] += swapbuf.f * y_percent;

+			} else {

+			    totals[k] += *(const GLfloat*)temp_index * y_percent;

+			}

+		    }

+		}

+		temp += group_size;

+		right = temp;

+		percent = y_percent * highx_float;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);

+			totals[k] += swapbuf.f * percent;

+		    } else {

+			totals[k] += *(const GLfloat*)temp_index * percent;

+		    }

+		}

+

+		/* calculate the value for pixels in the last row */

+		y_percent = highy_float;

+		percent = y_percent * (1-lowx_float);

+		temp = (const char *)datain + xindex + highy_int * ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);

+			totals[k] += swapbuf.f * percent;

+		    } else {

+			totals[k] += *(const GLfloat*)temp_index * percent;

+		    }

+		}

+		for(l = lowx_int+1; l < highx_int; l++) {

+		    temp += group_size;

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			if (myswap_bytes) {

+			    swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);

+			    totals[k] += swapbuf.f * y_percent;

+			} else {

+			    totals[k] += *(const GLfloat*)temp_index * y_percent;

+			}

+		    }

+		}

+		temp += group_size;

+		percent = y_percent * highx_float;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);

+			totals[k] += swapbuf.f * percent;

+		    } else {

+			totals[k] += *(const GLfloat*)temp_index * percent;

+		    }

+		}

+

+		/* calculate the value for pixels in the 1st and last column */

+		for(m = lowy_int+1; m < highy_int; m++) {

+		    left += ysize;

+		    right += ysize;

+		    for (k = 0; k < components;

+			 k++, left += element_size, right += element_size) {

+			if (myswap_bytes) {

+			    swapbuf.b = __GLU_SWAP_4_BYTES(left);

+			    totals[k] += swapbuf.f * (1-lowx_float);

+			    swapbuf.b = __GLU_SWAP_4_BYTES(right);

+			    totals[k] += swapbuf.f * highx_float;

+			} else {

+			    totals[k] += *(const GLfloat*)left * (1-lowx_float)

+				       + *(const GLfloat*)right * highx_float;

+			}

+		    }

+		}

+	    } else if (highy_int > lowy_int) {

+		x_percent = highx_float - lowx_float;

+		percent = (1-lowy_float)*x_percent;

+		temp = (const char *)datain + xindex + lowy_int*ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);

+			totals[k] += swapbuf.f * percent;

+		    } else {

+			totals[k] += *(const GLfloat*)temp_index * percent;

+		    }

+		}

+		for(m = lowy_int+1; m < highy_int; m++) {

+		    temp += ysize;

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			if (myswap_bytes) {

+			    swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);

+			    totals[k] += swapbuf.f * x_percent;

+			} else {

+			    totals[k] += *(const GLfloat*)temp_index * x_percent;

+			}

+		    }

+		}

+		percent = x_percent * highy_float;

+		temp += ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);

+			totals[k] += swapbuf.f * percent;

+		    } else {

+			totals[k] += *(const GLfloat*)temp_index * percent;

+		    }

+		}

+	    } else if (highx_int > lowx_int) {

+		y_percent = highy_float - lowy_float;

+		percent = (1-lowx_float)*y_percent;

+

+	     temp = (const char *)datain + xindex + lowy_int*ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);

+			totals[k] += swapbuf.f * percent;

+		    } else {

+			totals[k] += *(const GLfloat*)temp_index * percent;

+		    }

+		}

+		for (l = lowx_int+1; l < highx_int; l++) {

+		    temp += group_size;

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			if (myswap_bytes) {

+			    swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);

+			    totals[k] += swapbuf.f * y_percent;

+			} else {

+			    totals[k] += *(const GLfloat*)temp_index * y_percent;

+			}

+		    }

+		}

+		temp += group_size;

+		percent = y_percent * highx_float;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);

+			totals[k] += swapbuf.f * percent;

+		    } else {

+			totals[k] += *(const GLfloat*)temp_index * percent;

+		    }

+		}

+	    } else {

+		percent = (highy_float-lowy_float)*(highx_float-lowx_float);

+		temp = (const char *)datain + xindex + lowy_int * ysize;

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);

+			totals[k] += swapbuf.f * percent;

+		    } else {

+			totals[k] += *(const GLfloat*)temp_index * percent;

+		    }

+		}

+	    }

+

+	    /* this is for the pixels in the body */

+	    temp0 = (const char *)datain + xindex + group_size +

+		 (lowy_int+1)*ysize;

+	    for (m = lowy_int+1; m < highy_int; m++) {

+		temp = temp0;

+		for(l = lowx_int+1; l < highx_int; l++) {

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			if (myswap_bytes) {

+			    swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);

+			    totals[k] += swapbuf.f;

+			} else {

+			    totals[k] += *(const GLfloat*)temp_index;

+			}

+		    }

+		    temp += group_size;

+		}

+		temp0 += ysize;

+	    }

+

+	    outindex = (j + (i * widthout)) * components;

+	    for (k = 0; k < components; k++) {

+		dataout[outindex + k] = totals[k]/area;

+		/*printf("totals[%d] = %f\n", k, totals[k]);*/

+	    }

+	    lowx_int = highx_int;

+	    lowx_float = highx_float;

+	    highx_int += convx_int;

+	    highx_float += convx_float;

+	    if(highx_float > 1) {

+		highx_float -= 1.0;

+		highx_int++;

+	    }

+	}

+	lowy_int = highy_int;

+	lowy_float = highy_float;

+	highy_int += convy_int;

+	highy_float += convy_float;

+	if(highy_float > 1) {

+	    highy_float -= 1.0;

+	    highy_int++;

+	}

+    }

+}

+

+static int checkMipmapArgs(GLenum internalFormat, GLenum format, GLenum type)

+{

+    if (!legalFormat(format) || !legalType(type)) {

+	return GLU_INVALID_ENUM;

+    }

+    if (format == GL_STENCIL_INDEX) {

+	return GLU_INVALID_ENUM;

+    }

+

+    if (!isLegalFormatForPackedPixelType(format, type)) {

+	return GLU_INVALID_OPERATION;

+    }

+

+    return 0;

+} /* checkMipmapArgs() */

+

+static GLboolean legalFormat(GLenum format)

+{

+    switch(format) {

+      case GL_COLOR_INDEX:

+      case GL_STENCIL_INDEX:

+      case GL_DEPTH_COMPONENT:

+      case GL_RED:

+      case GL_GREEN:

+      case GL_BLUE:

+      case GL_ALPHA:

+      case GL_RGB:

+      case GL_RGBA:

+      case GL_LUMINANCE:

+      case GL_LUMINANCE_ALPHA:

+      case GL_BGR:

+      case GL_BGRA:

+	return GL_TRUE;

+      default:

+	return GL_FALSE;

+    }

+}

+

+

+static GLboolean legalType(GLenum type)

+{

+    switch(type) {

+      case GL_BITMAP:

+      case GL_BYTE:

+      case GL_UNSIGNED_BYTE:

+      case GL_SHORT:

+      case GL_UNSIGNED_SHORT:

+      case GL_INT:

+      case GL_UNSIGNED_INT:

+      case GL_FLOAT:

+      case GL_UNSIGNED_BYTE_3_3_2:

+      case GL_UNSIGNED_BYTE_2_3_3_REV:  

+      case GL_UNSIGNED_SHORT_5_6_5:

+      case GL_UNSIGNED_SHORT_5_6_5_REV:

+      case GL_UNSIGNED_SHORT_4_4_4_4:

+      case GL_UNSIGNED_SHORT_4_4_4_4_REV:

+      case GL_UNSIGNED_SHORT_5_5_5_1:

+      case GL_UNSIGNED_SHORT_1_5_5_5_REV:

+      case GL_UNSIGNED_INT_8_8_8_8:

+      case GL_UNSIGNED_INT_8_8_8_8_REV:

+      case GL_UNSIGNED_INT_10_10_10_2:

+      case GL_UNSIGNED_INT_2_10_10_10_REV:

+	 return GL_TRUE;

+      default:

+	return GL_FALSE;

+    }

+}

+

+/* */

+static GLboolean isTypePackedPixel(GLenum type)

+{

+   assert(legalType(type));

+

+   if (type == GL_UNSIGNED_BYTE_3_3_2 ||

+       type == GL_UNSIGNED_BYTE_2_3_3_REV ||

+       type == GL_UNSIGNED_SHORT_5_6_5 ||

+       type == GL_UNSIGNED_SHORT_5_6_5_REV ||

+       type == GL_UNSIGNED_SHORT_4_4_4_4 ||

+       type == GL_UNSIGNED_SHORT_4_4_4_4_REV ||

+       type == GL_UNSIGNED_SHORT_5_5_5_1 ||

+       type == GL_UNSIGNED_SHORT_1_5_5_5_REV ||

+       type == GL_UNSIGNED_INT_8_8_8_8 ||

+       type == GL_UNSIGNED_INT_8_8_8_8_REV ||

+       type == GL_UNSIGNED_INT_10_10_10_2 ||

+       type == GL_UNSIGNED_INT_2_10_10_10_REV) {

+      return 1;

+   }

+   else return 0;

+} /* isTypePackedPixel() */

+

+/* Determines if the packed pixel type is compatible with the format */

+static GLboolean isLegalFormatForPackedPixelType(GLenum format, GLenum type)

+{

+   /* if not a packed pixel type then return true */

+   if (!isTypePackedPixel(type)) {

+      return GL_TRUE;

+   }

+

+   /* 3_3_2/2_3_3_REV & 5_6_5/5_6_5_REV are only compatible with RGB */

+   if ((type == GL_UNSIGNED_BYTE_3_3_2 || type == GL_UNSIGNED_BYTE_2_3_3_REV||

+	type == GL_UNSIGNED_SHORT_5_6_5|| type == GL_UNSIGNED_SHORT_5_6_5_REV)

+       && format != GL_RGB)

+      return GL_FALSE;

+

+   /* 4_4_4_4/4_4_4_4_REV & 5_5_5_1/1_5_5_5_REV & 8_8_8_8/8_8_8_8_REV &

+    * 10_10_10_2/2_10_10_10_REV are only compatible with RGBA, BGRA & ABGR_EXT.

+    */

+   if ((type == GL_UNSIGNED_SHORT_4_4_4_4 ||

+	type == GL_UNSIGNED_SHORT_4_4_4_4_REV ||

+	type == GL_UNSIGNED_SHORT_5_5_5_1 ||

+	type == GL_UNSIGNED_SHORT_1_5_5_5_REV ||

+	type == GL_UNSIGNED_INT_8_8_8_8 ||

+	type == GL_UNSIGNED_INT_8_8_8_8_REV ||

+	type == GL_UNSIGNED_INT_10_10_10_2 ||

+	type == GL_UNSIGNED_INT_2_10_10_10_REV) &&

+       (format != GL_RGBA &&

+	format != GL_BGRA)) {

+      return GL_FALSE;

+   }

+

+   return GL_TRUE;

+} /* isLegalFormatForPackedPixelType() */

+

+static GLboolean isLegalLevels(GLint userLevel,GLint baseLevel,GLint maxLevel,

+			       GLint totalLevels)

+{

+   if (baseLevel < 0 || baseLevel < userLevel || maxLevel < baseLevel ||

+       totalLevels < maxLevel)

+      return GL_FALSE;

+   else return GL_TRUE;

+} /* isLegalLevels() */

+

+/* Given user requested texture size, determine if it fits. If it

+ * doesn't then halve both sides and make the determination again

+ * until it does fit (for IR only).

+ * Note that proxy textures are not implemented in RE* even though

+ * they advertise the texture extension.

+ * Note that proxy textures are implemented but not according to spec in

+ * IMPACT*.

+ */

+static void closestFit(GLenum target, GLint width, GLint height,

+		       GLint internalFormat, GLenum format, GLenum type,

+		       GLint *newWidth, GLint *newHeight)

+{

+   /* Use proxy textures if OpenGL version is >= 1.1 */

+   if ( (strtod((const char *)glGetString(GL_VERSION),NULL) >= 1.1)

+	) {

+      GLint widthPowerOf2= nearestPower(width);

+      GLint heightPowerOf2= nearestPower(height);       

+      GLint proxyWidth;

+

+      do {

+	 /* compute level 1 width & height, clamping each at 1 */

+	 GLint widthAtLevelOne= (widthPowerOf2 > 1) ?

+				 widthPowerOf2 >> 1 :

+				 widthPowerOf2;

+	 GLint heightAtLevelOne= (heightPowerOf2 > 1) ?

+				  heightPowerOf2 >> 1 :

+				  heightPowerOf2;

+	 GLenum proxyTarget;

+	 assert(widthAtLevelOne > 0); assert(heightAtLevelOne > 0);

+

+	 /* does width x height at level 1 & all their mipmaps fit? */

+	 if (target == GL_TEXTURE_2D || target == GL_PROXY_TEXTURE_2D) {

+	    proxyTarget = GL_PROXY_TEXTURE_2D;

+	    glTexImage2D(proxyTarget, 1, /* must be non-zero */

+			 internalFormat,

+			 widthAtLevelOne,heightAtLevelOne,0,format,type,NULL);

+	 } else

+#if defined(GL_ARB_texture_cube_map)

+	 if ((target == GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB) ||

+	     (target == GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB) ||

+	     (target == GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB) ||

+	     (target == GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB) ||

+	     (target == GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB) ||

+	     (target == GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB)) {

+	     proxyTarget = GL_PROXY_TEXTURE_CUBE_MAP_ARB;

+	     glTexImage2D(proxyTarget, 1, /* must be non-zero */

+			  internalFormat,

+			  widthAtLevelOne,heightAtLevelOne,0,format,type,NULL);

+	 } else

+#endif /* GL_ARB_texture_cube_map */

+	 {

+	    assert(target == GL_TEXTURE_1D || target == GL_PROXY_TEXTURE_1D);

+	    proxyTarget = GL_PROXY_TEXTURE_1D;

+	    glTexImage1D(proxyTarget, 1, /* must be non-zero */

+			 internalFormat,widthAtLevelOne,0,format,type,NULL);

+	 }

+	 glGetTexLevelParameteriv(proxyTarget, 1,GL_TEXTURE_WIDTH,&proxyWidth);

+	 /* does it fit??? */

+	 if (proxyWidth == 0) { /* nope, so try again with these sizes */

+	    if (widthPowerOf2 == 1 && heightPowerOf2 == 1) {

+	       /* An 1x1 texture couldn't fit for some reason, so

+		* break out.  This should never happen. But things

+		* happen.  The disadvantage with this if-statement is

+		* that we will never be aware of when this happens

+		* since it will silently branch out.

+		*/

+	       goto noProxyTextures;

+	    }

+	    widthPowerOf2= widthAtLevelOne;

+	    heightPowerOf2= heightAtLevelOne;

+	 }

+	 /* else it does fit */

+      } while (proxyWidth == 0);

+      /* loop must terminate! */

+

+      /* return the width & height at level 0 that fits */

+      *newWidth= widthPowerOf2;

+      *newHeight= heightPowerOf2;

+/*printf("Proxy Textures\n");*/

+   } /* if gluCheckExtension() */

+   else {			/* no texture extension, so do this instead */

+      GLint maxsize;

+

+noProxyTextures:

+

+      glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxsize);

+      /* clamp user's texture sizes to maximum sizes, if necessary */

+      *newWidth = nearestPower(width);

+      if (*newWidth > maxsize) *newWidth = maxsize;

+      *newHeight = nearestPower(height);

+      if (*newHeight > maxsize) *newHeight = maxsize;

+/*printf("NO proxy textures\n");*/

+   }

+} /* closestFit() */

+

+GLint GLAPIENTRY

+gluScaleImage(GLenum format, GLsizei widthin, GLsizei heightin,

+		    GLenum typein, const void *datain,

+		    GLsizei widthout, GLsizei heightout, GLenum typeout,

+		    void *dataout)

+{

+    int components;

+    GLushort *beforeImage;

+    GLushort *afterImage;

+    PixelStorageModes psm;

+

+    if (widthin == 0 || heightin == 0 || widthout == 0 || heightout == 0) {

+	return 0;

+    }

+    if (widthin < 0 || heightin < 0 || widthout < 0 || heightout < 0) {

+	return GLU_INVALID_VALUE;

+    }

+    if (!legalFormat(format) || !legalType(typein) || !legalType(typeout)) {

+	return GLU_INVALID_ENUM;

+    }

+    if (!isLegalFormatForPackedPixelType(format, typein)) {

+       return GLU_INVALID_OPERATION;

+    }

+    if (!isLegalFormatForPackedPixelType(format, typeout)) {

+       return GLU_INVALID_OPERATION;

+    }

+    beforeImage =

+	malloc(image_size(widthin, heightin, format, GL_UNSIGNED_SHORT));

+    afterImage =

+	malloc(image_size(widthout, heightout, format, GL_UNSIGNED_SHORT));

+    if (beforeImage == NULL || afterImage == NULL) {

+	free(beforeImage);

+	free(afterImage);

+	return GLU_OUT_OF_MEMORY;

+    }

+

+    retrieveStoreModes(&psm);

+    fill_image(&psm,widthin, heightin, format, typein, is_index(format),

+	    datain, beforeImage);

+    components = elements_per_group(format, 0);

+    scale_internal(components, widthin, heightin, beforeImage,

+	    widthout, heightout, afterImage);

+    empty_image(&psm,widthout, heightout, format, typeout,

+	    is_index(format), afterImage, dataout);

+    free((GLbyte *) beforeImage);

+    free((GLbyte *) afterImage);

+

+    return 0;

+}

+

+int gluBuild1DMipmapLevelsCore(GLenum target, GLint internalFormat,

+			       GLsizei width,

+			       GLsizei widthPowerOf2,

+			       GLenum format, GLenum type,

+			       GLint userLevel, GLint baseLevel,GLint maxLevel,

+			       const void *data)

+{

+    GLint newwidth;

+    GLint level, levels;

+    GLushort *newImage;

+    GLint newImage_width;

+    GLushort *otherImage;

+    GLushort *imageTemp;

+    GLint memreq;

+    GLint cmpts;

+    PixelStorageModes psm;

+

+    assert(checkMipmapArgs(internalFormat,format,type) == 0);

+    assert(width >= 1);

+

+    otherImage = NULL;

+

+    newwidth= widthPowerOf2;

+    levels = computeLog(newwidth);

+

+    levels+= userLevel;

+

+    retrieveStoreModes(&psm);

+    newImage = (GLushort *)

+	malloc(image_size(width, 1, format, GL_UNSIGNED_SHORT));

+    newImage_width = width;

+    if (newImage == NULL) {

+	return GLU_OUT_OF_MEMORY;

+    }

+    fill_image(&psm,width, 1, format, type, is_index(format),

+	    data, newImage);

+    cmpts = elements_per_group(format,type);

+    glPixelStorei(GL_UNPACK_ALIGNMENT, 2);

+    glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);

+    glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);

+    glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);

+    /*

+    ** If swap_bytes was set, swapping occurred in fill_image.

+    */

+    glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE);

+

+    for (level = userLevel; level <= levels; level++) {

+	if (newImage_width == newwidth) {

+	    /* Use newImage for this level */

+	    if (baseLevel <= level && level <= maxLevel) {

+	    glTexImage1D(target, level, internalFormat, newImage_width,

+		    0, format, GL_UNSIGNED_SHORT, (void *) newImage);

+	    }

+	} else {

+	    if (otherImage == NULL) {

+		memreq = image_size(newwidth, 1, format, GL_UNSIGNED_SHORT);

+		otherImage = (GLushort *) malloc(memreq);

+		if (otherImage == NULL) {

+		    glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);

+		    glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);

+		    glPixelStorei(GL_UNPACK_SKIP_PIXELS,psm.unpack_skip_pixels);

+		    glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);

+		    glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);

+		    free(newImage);

+		    return GLU_OUT_OF_MEMORY;

+		}

+	    }

+	    scale_internal(cmpts, newImage_width, 1, newImage,

+		    newwidth, 1, otherImage);

+	    /* Swap newImage and otherImage */

+	    imageTemp = otherImage;

+	    otherImage = newImage;

+	    newImage = imageTemp;

+

+	    newImage_width = newwidth;

+	    if (baseLevel <= level && level <= maxLevel) {

+	    glTexImage1D(target, level, internalFormat, newImage_width,

+		    0, format, GL_UNSIGNED_SHORT, (void *) newImage);

+	    }

+	}

+	if (newwidth > 1) newwidth /= 2;

+    }

+    glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);

+    glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);

+    glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);

+    glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);

+    glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);

+

+    free((GLbyte *) newImage);

+    if (otherImage) {

+	free((GLbyte *) otherImage);

+    }

+    return 0;

+}

+

+GLint GLAPIENTRY

+gluBuild1DMipmapLevels(GLenum target, GLint internalFormat,

+			     GLsizei width,

+			     GLenum format, GLenum type,

+			     GLint userLevel, GLint baseLevel, GLint maxLevel,

+			     const void *data)

+{

+   int levels;

+

+   int rc= checkMipmapArgs(internalFormat,format,type);

+   if (rc != 0) return rc;

+

+   if (width < 1) {

+       return GLU_INVALID_VALUE;

+   }

+

+   levels = computeLog(width);

+

+   levels+= userLevel;

+   if (!isLegalLevels(userLevel,baseLevel,maxLevel,levels))

+      return GLU_INVALID_VALUE;

+

+   return gluBuild1DMipmapLevelsCore(target, internalFormat,

+				     width,

+				     width,format, type,

+				     userLevel, baseLevel, maxLevel,

+				     data);

+} /* gluBuild1DMipmapLevels() */

+

+GLint GLAPIENTRY

+gluBuild1DMipmaps(GLenum target, GLint internalFormat, GLsizei width,

+			GLenum format, GLenum type,

+			const void *data)

+{

+   GLint widthPowerOf2;

+   int levels;

+   GLint dummy;

+

+   int rc= checkMipmapArgs(internalFormat,format,type);

+   if (rc != 0) return rc;

+

+   if (width < 1) {

+       return GLU_INVALID_VALUE;

+   }

+

+   closestFit(target,width,1,internalFormat,format,type,&widthPowerOf2,&dummy);

+   levels = computeLog(widthPowerOf2);

+

+   return gluBuild1DMipmapLevelsCore(target,internalFormat,

+				     width,

+				     widthPowerOf2,

+				     format,type,0,0,levels,data);

+}

+

+static int bitmapBuild2DMipmaps(GLenum target, GLint internalFormat,

+		     GLint width, GLint height, GLenum format,

+		     GLenum type, const void *data)

+{

+    GLint newwidth, newheight;

+    GLint level, levels;

+    GLushort *newImage;

+    GLint newImage_width;

+    GLint newImage_height;

+    GLushort *otherImage;

+    GLushort *imageTemp;

+    GLint memreq;

+    GLint cmpts;

+    PixelStorageModes psm;

+

+    retrieveStoreModes(&psm);

+

+#if 0

+    glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxsize);

+    newwidth = nearestPower(width);

+    if (newwidth > maxsize) newwidth = maxsize;

+    newheight = nearestPower(height);

+    if (newheight > maxsize) newheight = maxsize;

+#else

+    closestFit(target,width,height,internalFormat,format,type,

+	       &newwidth,&newheight);

+#endif

+    levels = computeLog(newwidth);

+    level = computeLog(newheight);

+    if (level > levels) levels=level;

+

+    otherImage = NULL;

+    newImage = (GLushort *)

+	malloc(image_size(width, height, format, GL_UNSIGNED_SHORT));

+    newImage_width = width;

+    newImage_height = height;

+    if (newImage == NULL) {

+	return GLU_OUT_OF_MEMORY;

+    }

+

+    fill_image(&psm,width, height, format, type, is_index(format),

+	  data, newImage);

+

+    cmpts = elements_per_group(format,type);

+    glPixelStorei(GL_UNPACK_ALIGNMENT, 2);

+    glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);

+    glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);

+    glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);

+    /*

+    ** If swap_bytes was set, swapping occurred in fill_image.

+    */

+    glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE);

+

+    for (level = 0; level <= levels; level++) {

+	if (newImage_width == newwidth && newImage_height == newheight) {	     /* Use newImage for this level */

+	    glTexImage2D(target, level, internalFormat, newImage_width,

+		    newImage_height, 0, format, GL_UNSIGNED_SHORT,

+		    (void *) newImage);

+	} else {

+	    if (otherImage == NULL) {

+		memreq =

+		    image_size(newwidth, newheight, format, GL_UNSIGNED_SHORT);

+		otherImage = (GLushort *) malloc(memreq);

+		if (otherImage == NULL) {

+		    glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);

+		    glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);

+		    glPixelStorei(GL_UNPACK_SKIP_PIXELS,psm.unpack_skip_pixels);

+		    glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);

+		    glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);

+		    free(newImage);

+		    return GLU_OUT_OF_MEMORY;

+		}

+	    }

+	    scale_internal(cmpts, newImage_width, newImage_height, newImage,

+		    newwidth, newheight, otherImage);

+	    /* Swap newImage and otherImage */

+	    imageTemp = otherImage;

+	    otherImage = newImage;

+	    newImage = imageTemp;

+

+	    newImage_width = newwidth;

+	    newImage_height = newheight;

+	    glTexImage2D(target, level, internalFormat, newImage_width,

+		    newImage_height, 0, format, GL_UNSIGNED_SHORT,

+		    (void *) newImage);

+	}

+	if (newwidth > 1) newwidth /= 2;

+	if (newheight > 1) newheight /= 2;

+    }

+    glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);

+    glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);

+    glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);

+    glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);

+    glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);

+

+    free((GLbyte *) newImage);

+    if (otherImage) {

+	free((GLbyte *) otherImage);

+    }

+    return 0;

+}

+

+/* To make swapping images less error prone */

+#define __GLU_INIT_SWAP_IMAGE void *tmpImage

+#define __GLU_SWAP_IMAGE(a,b) tmpImage = a; a = b; b = tmpImage;

+

+static int gluBuild2DMipmapLevelsCore(GLenum target, GLint internalFormat,

+				      GLsizei width, GLsizei height,

+				      GLsizei widthPowerOf2,

+				      GLsizei heightPowerOf2,

+				      GLenum format, GLenum type,

+				      GLint userLevel,

+				      GLint baseLevel,GLint maxLevel,

+				      const void *data)

+{

+    GLint newwidth, newheight;

+    GLint level, levels;

+    const void *usersImage; /* passed from user. Don't touch! */

+    void *srcImage, *dstImage; /* scratch area to build mipmapped images */

+    __GLU_INIT_SWAP_IMAGE;

+    GLint memreq;

+    GLint cmpts;

+

+    GLint myswap_bytes, groups_per_line, element_size, group_size;

+    GLint rowsize, padding;

+    PixelStorageModes psm;

+

+    assert(checkMipmapArgs(internalFormat,format,type) == 0);

+    assert(width >= 1 && height >= 1);

+

+    if(type == GL_BITMAP) {

+	return bitmapBuild2DMipmaps(target, internalFormat, width, height,

+		format, type, data);

+    }

+

+    srcImage = dstImage = NULL;

+

+    newwidth= widthPowerOf2;

+    newheight= heightPowerOf2;

+    levels = computeLog(newwidth);

+    level = computeLog(newheight);

+    if (level > levels) levels=level;

+

+    levels+= userLevel;

+

+    retrieveStoreModes(&psm);

+    myswap_bytes = psm.unpack_swap_bytes;

+    cmpts = elements_per_group(format,type);

+    if (psm.unpack_row_length > 0) {

+	groups_per_line = psm.unpack_row_length;

+    } else {

+	groups_per_line = width;

+    }

+

+    element_size = bytes_per_element(type);

+    group_size = element_size * cmpts;

+    if (element_size == 1) myswap_bytes = 0;

+

+    rowsize = groups_per_line * group_size;

+    padding = (rowsize % psm.unpack_alignment);

+    if (padding) {

+	rowsize += psm.unpack_alignment - padding;

+    }

+    usersImage = (const GLubyte *) data + psm.unpack_skip_rows * rowsize +

+	psm.unpack_skip_pixels * group_size;

+

+    glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);

+    glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);

+    glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);

+

+    level = userLevel;

+

+    /* already power-of-two square */

+    if (width == newwidth && height == newheight) {

+	/* Use usersImage for level userLevel */

+	if (baseLevel <= level && level <= maxLevel) {

+        glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);

+	glTexImage2D(target, level, internalFormat, width,

+		height, 0, format, type,

+		usersImage);

+	}

+        glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);

+	if(levels == 0) { /* we're done. clean up and return */

+	  glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);

+	  glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);

+	  glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);

+	  glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);

+	  glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);

+	  return 0;

+	}

+	{

+	   int nextWidth= newwidth/2;

+	   int nextHeight= newheight/2;

+

+	   /* clamp to 1 */

+	   if (nextWidth < 1) nextWidth= 1;

+	   if (nextHeight < 1) nextHeight= 1;

+	memreq = image_size(nextWidth, nextHeight, format, type);

+	}

+

+	switch(type) {

+	case GL_UNSIGNED_BYTE:

+	  dstImage = (GLubyte *)malloc(memreq);

+	  break;

+	case GL_BYTE:

+	  dstImage = (GLbyte *)malloc(memreq);

+	  break;

+	case GL_UNSIGNED_SHORT:

+	  dstImage = (GLushort *)malloc(memreq);

+	  break;

+	case GL_SHORT:

+	  dstImage = (GLshort *)malloc(memreq);

+	  break;

+	case GL_UNSIGNED_INT:

+	  dstImage = (GLuint *)malloc(memreq);

+	  break;

+	case GL_INT:

+	  dstImage = (GLint *)malloc(memreq);

+	  break;

+	case GL_FLOAT:

+	  dstImage = (GLfloat *)malloc(memreq);

+	  break;

+	case GL_UNSIGNED_BYTE_3_3_2:

+	case GL_UNSIGNED_BYTE_2_3_3_REV:

+	  dstImage = (GLubyte *)malloc(memreq);

+	  break;

+	case GL_UNSIGNED_SHORT_5_6_5:

+	case GL_UNSIGNED_SHORT_5_6_5_REV:

+	case GL_UNSIGNED_SHORT_4_4_4_4:

+	case GL_UNSIGNED_SHORT_4_4_4_4_REV:

+	case GL_UNSIGNED_SHORT_5_5_5_1:

+	case GL_UNSIGNED_SHORT_1_5_5_5_REV:

+	  dstImage = (GLushort *)malloc(memreq);

+	  break;

+	case GL_UNSIGNED_INT_8_8_8_8:

+	case GL_UNSIGNED_INT_8_8_8_8_REV:

+	case GL_UNSIGNED_INT_10_10_10_2:

+	case GL_UNSIGNED_INT_2_10_10_10_REV:

+	  dstImage = (GLuint *)malloc(memreq);  

+	  break;

+	default:

+	  return GLU_INVALID_ENUM;

+	}

+	if (dstImage == NULL) {

+	  glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);

+	  glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);

+	  glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);

+	  glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);

+	  glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);

+	  return GLU_OUT_OF_MEMORY;

+	}

+	else

+	  switch(type) {

+	  case GL_UNSIGNED_BYTE:

+	    halveImage_ubyte(cmpts, width, height,

+			     (const GLubyte *)usersImage, (GLubyte *)dstImage,

+			     element_size, rowsize, group_size);

+	    break;

+	  case GL_BYTE:

+	    halveImage_byte(cmpts, width, height,

+			    (const GLbyte *)usersImage, (GLbyte *)dstImage,

+			    element_size, rowsize, group_size);

+	    break;

+	  case GL_UNSIGNED_SHORT:

+	    halveImage_ushort(cmpts, width, height,

+			      (const GLushort *)usersImage, (GLushort *)dstImage,

+			      element_size, rowsize, group_size, myswap_bytes);

+	    break;

+	  case GL_SHORT:

+	    halveImage_short(cmpts, width, height,

+			     (const GLshort *)usersImage, (GLshort *)dstImage,

+			     element_size, rowsize, group_size, myswap_bytes);

+	    break;

+	  case GL_UNSIGNED_INT:

+	    halveImage_uint(cmpts, width, height,

+			    (const GLuint *)usersImage, (GLuint *)dstImage,

+			    element_size, rowsize, group_size, myswap_bytes);

+	    break;

+	  case GL_INT:

+	    halveImage_int(cmpts, width, height,

+			   (const GLint *)usersImage, (GLint *)dstImage,

+			   element_size, rowsize, group_size, myswap_bytes);

+	    break;

+	  case GL_FLOAT:

+	    halveImage_float(cmpts, width, height,

+			     (const GLfloat *)usersImage, (GLfloat *)dstImage,

+			     element_size, rowsize, group_size, myswap_bytes);

+	    break;

+	  case GL_UNSIGNED_BYTE_3_3_2:

+	    assert(format == GL_RGB);

+	    halveImagePackedPixel(3,extract332,shove332,

+				  width,height,usersImage,dstImage,

+				  element_size,rowsize,myswap_bytes);

+	    break;

+	  case GL_UNSIGNED_BYTE_2_3_3_REV:

+	    assert(format == GL_RGB);

+	    halveImagePackedPixel(3,extract233rev,shove233rev,

+				  width,height,usersImage,dstImage,

+				  element_size,rowsize,myswap_bytes);

+	    break;

+	  case GL_UNSIGNED_SHORT_5_6_5:

+	    halveImagePackedPixel(3,extract565,shove565,

+				  width,height,usersImage,dstImage,

+				  element_size,rowsize,myswap_bytes);

+	    break;

+	  case GL_UNSIGNED_SHORT_5_6_5_REV:

+	    halveImagePackedPixel(3,extract565rev,shove565rev,

+				  width,height,usersImage,dstImage,

+				  element_size,rowsize,myswap_bytes);

+	    break;

+	  case GL_UNSIGNED_SHORT_4_4_4_4:

+	    halveImagePackedPixel(4,extract4444,shove4444,

+				  width,height,usersImage,dstImage,

+				  element_size,rowsize,myswap_bytes);

+	    break;

+	  case GL_UNSIGNED_SHORT_4_4_4_4_REV:

+	    halveImagePackedPixel(4,extract4444rev,shove4444rev,

+				  width,height,usersImage,dstImage,

+				  element_size,rowsize,myswap_bytes);

+	    break;

+	  case GL_UNSIGNED_SHORT_5_5_5_1:

+	    halveImagePackedPixel(4,extract5551,shove5551,

+				  width,height,usersImage,dstImage,

+				  element_size,rowsize,myswap_bytes);

+	    break;

+	  case GL_UNSIGNED_SHORT_1_5_5_5_REV:

+	    halveImagePackedPixel(4,extract1555rev,shove1555rev,

+				  width,height,usersImage,dstImage,

+				  element_size,rowsize,myswap_bytes);

+	    break;

+	  case GL_UNSIGNED_INT_8_8_8_8:

+	    halveImagePackedPixel(4,extract8888,shove8888,

+				  width,height,usersImage,dstImage,

+				  element_size,rowsize,myswap_bytes);

+	    break;

+	  case GL_UNSIGNED_INT_8_8_8_8_REV:

+	    halveImagePackedPixel(4,extract8888rev,shove8888rev,

+				  width,height,usersImage,dstImage,

+				  element_size,rowsize,myswap_bytes);

+	    break;

+	  case GL_UNSIGNED_INT_10_10_10_2:

+	    halveImagePackedPixel(4,extract1010102,shove1010102,

+				  width,height,usersImage,dstImage,

+				  element_size,rowsize,myswap_bytes);

+	    break;

+	  case GL_UNSIGNED_INT_2_10_10_10_REV:

+	    halveImagePackedPixel(4,extract2101010rev,shove2101010rev,

+				  width,height,usersImage,dstImage,

+				  element_size,rowsize,myswap_bytes);

+	    break;

+	  default:

+	    assert(0);

+	    break;

+	  }

+	newwidth = width/2;

+	newheight = height/2;

+	/* clamp to 1 */

+	if (newwidth < 1) newwidth= 1;

+	if (newheight < 1) newheight= 1;

+

+	myswap_bytes = 0;

+	rowsize = newwidth * group_size;

+	memreq = image_size(newwidth, newheight, format, type);

+	/* Swap srcImage and dstImage */

+	__GLU_SWAP_IMAGE(srcImage,dstImage);

+	switch(type) {

+	case GL_UNSIGNED_BYTE:

+	  dstImage = (GLubyte *)malloc(memreq);

+	  break;

+	case GL_BYTE:

+	  dstImage = (GLbyte *)malloc(memreq);

+	  break;

+	case GL_UNSIGNED_SHORT:

+	  dstImage = (GLushort *)malloc(memreq);

+	  break;

+	case GL_SHORT:

+	  dstImage = (GLshort *)malloc(memreq);

+	  break;

+	case GL_UNSIGNED_INT:

+	  dstImage = (GLuint *)malloc(memreq);

+	  break;

+	case GL_INT:

+	  dstImage = (GLint *)malloc(memreq);

+	  break;

+	case GL_FLOAT:

+	  dstImage = (GLfloat *)malloc(memreq);

+	  break;

+	case GL_UNSIGNED_BYTE_3_3_2:

+	case GL_UNSIGNED_BYTE_2_3_3_REV:

+	  dstImage = (GLubyte *)malloc(memreq);

+	  break;

+	case GL_UNSIGNED_SHORT_5_6_5:

+	case GL_UNSIGNED_SHORT_5_6_5_REV:

+	case GL_UNSIGNED_SHORT_4_4_4_4:

+	case GL_UNSIGNED_SHORT_4_4_4_4_REV:

+	case GL_UNSIGNED_SHORT_5_5_5_1:

+	case GL_UNSIGNED_SHORT_1_5_5_5_REV:

+	  dstImage = (GLushort *)malloc(memreq);

+	  break;

+	case GL_UNSIGNED_INT_8_8_8_8:

+	case GL_UNSIGNED_INT_8_8_8_8_REV:

+	case GL_UNSIGNED_INT_10_10_10_2:

+	case GL_UNSIGNED_INT_2_10_10_10_REV:

+	  dstImage = (GLuint *)malloc(memreq);

+	  break;

+	default:

+	  return GLU_INVALID_ENUM;

+	}

+	if (dstImage == NULL) {

+	  glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);

+	  glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);

+	  glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);

+	  glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);

+	  glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);

+	  free(srcImage);

+	  return GLU_OUT_OF_MEMORY;

+	}

+	/* level userLevel+1 is in srcImage; level userLevel already saved */

+	level = userLevel+1;

+    } else { /* user's image is *not* nice power-of-2 sized square */

+	memreq = image_size(newwidth, newheight, format, type);

+	switch(type) {

+	    case GL_UNSIGNED_BYTE:

+		dstImage = (GLubyte *)malloc(memreq);

+		break;

+	    case GL_BYTE:

+		dstImage = (GLbyte *)malloc(memreq);

+		break;

+	    case GL_UNSIGNED_SHORT:

+		dstImage = (GLushort *)malloc(memreq);

+		break;

+	    case GL_SHORT:

+		dstImage = (GLshort *)malloc(memreq);

+		break;

+	    case GL_UNSIGNED_INT:

+		dstImage = (GLuint *)malloc(memreq);

+		break;

+	    case GL_INT:

+		dstImage = (GLint *)malloc(memreq);

+		break;

+	    case GL_FLOAT:

+		dstImage = (GLfloat *)malloc(memreq);

+		break;

+	    case GL_UNSIGNED_BYTE_3_3_2:

+	    case GL_UNSIGNED_BYTE_2_3_3_REV:

+		dstImage = (GLubyte *)malloc(memreq);

+		break;

+	    case GL_UNSIGNED_SHORT_5_6_5:

+	    case GL_UNSIGNED_SHORT_5_6_5_REV:

+	    case GL_UNSIGNED_SHORT_4_4_4_4:

+	    case GL_UNSIGNED_SHORT_4_4_4_4_REV:

+	    case GL_UNSIGNED_SHORT_5_5_5_1:

+	    case GL_UNSIGNED_SHORT_1_5_5_5_REV:

+		dstImage = (GLushort *)malloc(memreq);

+		break;

+	    case GL_UNSIGNED_INT_8_8_8_8:

+	    case GL_UNSIGNED_INT_8_8_8_8_REV:

+	    case GL_UNSIGNED_INT_10_10_10_2:

+	    case GL_UNSIGNED_INT_2_10_10_10_REV:

+		dstImage = (GLuint *)malloc(memreq);

+		break;

+	    default:

+		return GLU_INVALID_ENUM;

+	}

+

+	if (dstImage == NULL) {

+	    glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);

+	    glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);

+	    glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);

+	    glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);

+	    glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);

+	    return GLU_OUT_OF_MEMORY;

+	}

+

+	switch(type) {

+	case GL_UNSIGNED_BYTE:

+	    scale_internal_ubyte(cmpts, width, height,

+				 (const GLubyte *)usersImage, newwidth, newheight,

+				 (GLubyte *)dstImage, element_size,

+				 rowsize, group_size);

+	    break;

+	case GL_BYTE:

+	    scale_internal_byte(cmpts, width, height,

+				(const GLbyte *)usersImage, newwidth, newheight,

+				(GLbyte *)dstImage, element_size,

+				rowsize, group_size);

+	    break;

+	case GL_UNSIGNED_SHORT:

+	    scale_internal_ushort(cmpts, width, height,

+				  (const GLushort *)usersImage, newwidth, newheight,

+				  (GLushort *)dstImage, element_size,

+				  rowsize, group_size, myswap_bytes);

+	    break;

+	case GL_SHORT:

+	    scale_internal_short(cmpts, width, height,

+				 (const GLshort *)usersImage, newwidth, newheight,

+				 (GLshort *)dstImage, element_size,

+				 rowsize, group_size, myswap_bytes);

+	    break;

+	case GL_UNSIGNED_INT:

+	    scale_internal_uint(cmpts, width, height,

+				(const GLuint *)usersImage, newwidth, newheight,

+				(GLuint *)dstImage, element_size,

+				rowsize, group_size, myswap_bytes);

+	    break;

+	case GL_INT:

+	    scale_internal_int(cmpts, width, height,

+			       (const GLint *)usersImage, newwidth, newheight,

+			       (GLint *)dstImage, element_size,

+			       rowsize, group_size, myswap_bytes);

+	    break;

+	case GL_FLOAT:

+	    scale_internal_float(cmpts, width, height,

+				 (const GLfloat *)usersImage, newwidth, newheight,

+				 (GLfloat *)dstImage, element_size,

+				 rowsize, group_size, myswap_bytes);

+	    break;

+	case GL_UNSIGNED_BYTE_3_3_2:

+	    scaleInternalPackedPixel(3,extract332,shove332,

+				     width, height,usersImage,

+				     newwidth,newheight,(void *)dstImage,

+				     element_size,rowsize,myswap_bytes);

+	    break;

+	case GL_UNSIGNED_BYTE_2_3_3_REV:

+	    scaleInternalPackedPixel(3,extract233rev,shove233rev,

+				     width, height,usersImage,

+				     newwidth,newheight,(void *)dstImage,

+				     element_size,rowsize,myswap_bytes);

+	    break;

+	case GL_UNSIGNED_SHORT_5_6_5:

+	    scaleInternalPackedPixel(3,extract565,shove565,

+				     width, height,usersImage,

+				     newwidth,newheight,(void *)dstImage,

+				     element_size,rowsize,myswap_bytes);

+	    break;

+	case GL_UNSIGNED_SHORT_5_6_5_REV:

+	    scaleInternalPackedPixel(3,extract565rev,shove565rev,

+				     width, height,usersImage,

+				     newwidth,newheight,(void *)dstImage,

+				     element_size,rowsize,myswap_bytes);

+	    break;

+	case GL_UNSIGNED_SHORT_4_4_4_4:

+	    scaleInternalPackedPixel(4,extract4444,shove4444,

+				     width, height,usersImage,

+				     newwidth,newheight,(void *)dstImage,

+				     element_size,rowsize,myswap_bytes);

+	    break;

+	case GL_UNSIGNED_SHORT_4_4_4_4_REV:

+	    scaleInternalPackedPixel(4,extract4444rev,shove4444rev,

+				     width, height,usersImage,

+				     newwidth,newheight,(void *)dstImage,

+				     element_size,rowsize,myswap_bytes);

+	    break;

+	case GL_UNSIGNED_SHORT_5_5_5_1:

+	    scaleInternalPackedPixel(4,extract5551,shove5551,

+				     width, height,usersImage,

+				     newwidth,newheight,(void *)dstImage,

+				     element_size,rowsize,myswap_bytes);

+	    break;

+	case GL_UNSIGNED_SHORT_1_5_5_5_REV:

+	    scaleInternalPackedPixel(4,extract1555rev,shove1555rev,

+				     width, height,usersImage,

+				     newwidth,newheight,(void *)dstImage,

+				     element_size,rowsize,myswap_bytes);

+	    break;

+	case GL_UNSIGNED_INT_8_8_8_8:

+	    scaleInternalPackedPixel(4,extract8888,shove8888,

+				     width, height,usersImage,

+				     newwidth,newheight,(void *)dstImage,

+				     element_size,rowsize,myswap_bytes);

+	    break;

+	case GL_UNSIGNED_INT_8_8_8_8_REV:

+	    scaleInternalPackedPixel(4,extract8888rev,shove8888rev,

+				     width, height,usersImage,

+				     newwidth,newheight,(void *)dstImage,

+				     element_size,rowsize,myswap_bytes);

+	    break;

+	case GL_UNSIGNED_INT_10_10_10_2:

+	    scaleInternalPackedPixel(4,extract1010102,shove1010102,

+				     width, height,usersImage,

+				     newwidth,newheight,(void *)dstImage,

+				     element_size,rowsize,myswap_bytes);

+	    break;

+	case GL_UNSIGNED_INT_2_10_10_10_REV:

+	    scaleInternalPackedPixel(4,extract2101010rev,shove2101010rev,

+				     width, height,usersImage,

+				     newwidth,newheight,(void *)dstImage,

+				     element_size,rowsize,myswap_bytes);

+	    break;

+	default:

+	    assert(0);

+	    break;

+	}

+	myswap_bytes = 0;

+	rowsize = newwidth * group_size;

+	/* Swap dstImage and srcImage */

+	__GLU_SWAP_IMAGE(srcImage,dstImage);

+

+	if(levels != 0) { /* use as little memory as possible */

+	  {

+	     int nextWidth= newwidth/2;

+	     int nextHeight= newheight/2;

+	     if (nextWidth < 1) nextWidth= 1;

+	     if (nextHeight < 1) nextHeight= 1; 

+

+	  memreq = image_size(nextWidth, nextHeight, format, type);

+	  }

+

+	  switch(type) {

+	  case GL_UNSIGNED_BYTE:

+	    dstImage = (GLubyte *)malloc(memreq);

+	    break;

+	  case GL_BYTE:

+	    dstImage = (GLbyte *)malloc(memreq);

+	    break;

+	  case GL_UNSIGNED_SHORT:

+	    dstImage = (GLushort *)malloc(memreq);

+	    break;

+	  case GL_SHORT:

+	    dstImage = (GLshort *)malloc(memreq);

+	    break;

+	  case GL_UNSIGNED_INT:

+	    dstImage = (GLuint *)malloc(memreq);

+	    break;

+	  case GL_INT:

+	    dstImage = (GLint *)malloc(memreq);

+	    break;

+	  case GL_FLOAT:

+	    dstImage = (GLfloat *)malloc(memreq);

+	    break;

+	  case GL_UNSIGNED_BYTE_3_3_2:

+	  case GL_UNSIGNED_BYTE_2_3_3_REV:

+	    dstImage = (GLubyte *)malloc(memreq);

+	    break;

+	  case GL_UNSIGNED_SHORT_5_6_5:

+	  case GL_UNSIGNED_SHORT_5_6_5_REV:

+	  case GL_UNSIGNED_SHORT_4_4_4_4:

+	  case GL_UNSIGNED_SHORT_4_4_4_4_REV:

+	  case GL_UNSIGNED_SHORT_5_5_5_1:

+	  case GL_UNSIGNED_SHORT_1_5_5_5_REV:

+	    dstImage = (GLushort *)malloc(memreq);

+	    break;

+	  case GL_UNSIGNED_INT_8_8_8_8:

+	  case GL_UNSIGNED_INT_8_8_8_8_REV:

+	  case GL_UNSIGNED_INT_10_10_10_2:

+	  case GL_UNSIGNED_INT_2_10_10_10_REV:

+	    dstImage = (GLuint *)malloc(memreq);

+	    break;

+	  default:

+	    return GLU_INVALID_ENUM;

+	  }

+	  if (dstImage == NULL) {

+	    glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);

+	    glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);

+	    glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);

+	    glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);

+	    glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);

+	    free(srcImage);

+	    return GLU_OUT_OF_MEMORY;

+	  }

+	}

+	/* level userLevel is in srcImage; nothing saved yet */

+	level = userLevel;

+    }

+

+    glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE);

+    if (baseLevel <= level && level <= maxLevel) {

+    glTexImage2D(target, level, internalFormat, newwidth, newheight, 0,

+		 format, type, (void *)srcImage);

+    }

+

+    level++; /* update current level for the loop */

+    for (; level <= levels; level++) {

+	switch(type) {

+	    case GL_UNSIGNED_BYTE:

+		halveImage_ubyte(cmpts, newwidth, newheight,

+		(GLubyte *)srcImage, (GLubyte *)dstImage, element_size,

+		rowsize, group_size);

+		break;

+	    case GL_BYTE:

+		halveImage_byte(cmpts, newwidth, newheight,

+		(GLbyte *)srcImage, (GLbyte *)dstImage, element_size,

+		rowsize, group_size);

+		break;

+	    case GL_UNSIGNED_SHORT:

+		halveImage_ushort(cmpts, newwidth, newheight,

+		(GLushort *)srcImage, (GLushort *)dstImage, element_size,

+		rowsize, group_size, myswap_bytes);

+		break;

+	    case GL_SHORT:

+		halveImage_short(cmpts, newwidth, newheight,

+		(GLshort *)srcImage, (GLshort *)dstImage, element_size,

+		rowsize, group_size, myswap_bytes);

+		break;

+	    case GL_UNSIGNED_INT:

+		halveImage_uint(cmpts, newwidth, newheight,

+		(GLuint *)srcImage, (GLuint *)dstImage, element_size,

+		rowsize, group_size, myswap_bytes);

+		break;

+	    case GL_INT:

+		halveImage_int(cmpts, newwidth, newheight,

+		(GLint *)srcImage, (GLint *)dstImage, element_size,

+		rowsize, group_size, myswap_bytes);

+		break;

+	    case GL_FLOAT:

+		halveImage_float(cmpts, newwidth, newheight,

+		(GLfloat *)srcImage, (GLfloat *)dstImage, element_size,

+		rowsize, group_size, myswap_bytes);

+		break;

+	    case GL_UNSIGNED_BYTE_3_3_2:

+		halveImagePackedPixel(3,extract332,shove332,

+				      newwidth,newheight,

+				      srcImage,dstImage,element_size,rowsize,

+				      myswap_bytes);

+		break;

+	    case GL_UNSIGNED_BYTE_2_3_3_REV:

+		halveImagePackedPixel(3,extract233rev,shove233rev,

+				      newwidth,newheight,

+				      srcImage,dstImage,element_size,rowsize,

+				      myswap_bytes);

+		break;

+	    case GL_UNSIGNED_SHORT_5_6_5:

+		halveImagePackedPixel(3,extract565,shove565,

+				      newwidth,newheight,

+				      srcImage,dstImage,element_size,rowsize,

+				      myswap_bytes);

+		break;

+	    case GL_UNSIGNED_SHORT_5_6_5_REV:

+		halveImagePackedPixel(3,extract565rev,shove565rev,

+				      newwidth,newheight,

+				      srcImage,dstImage,element_size,rowsize,

+				      myswap_bytes);

+		break;

+	    case GL_UNSIGNED_SHORT_4_4_4_4:

+		halveImagePackedPixel(4,extract4444,shove4444,

+				      newwidth,newheight,

+				      srcImage,dstImage,element_size,rowsize,

+				      myswap_bytes);

+		break;

+	    case GL_UNSIGNED_SHORT_4_4_4_4_REV:

+		halveImagePackedPixel(4,extract4444rev,shove4444rev,

+				      newwidth,newheight,

+				      srcImage,dstImage,element_size,rowsize,

+				      myswap_bytes);

+		break;

+	    case GL_UNSIGNED_SHORT_5_5_5_1:	        

+		halveImagePackedPixel(4,extract5551,shove5551,

+				      newwidth,newheight,

+				      srcImage,dstImage,element_size,rowsize,

+				      myswap_bytes);

+		break;

+	    case GL_UNSIGNED_SHORT_1_5_5_5_REV: 	        

+		halveImagePackedPixel(4,extract1555rev,shove1555rev,

+				      newwidth,newheight,

+				      srcImage,dstImage,element_size,rowsize,

+				      myswap_bytes);

+		break;

+	    case GL_UNSIGNED_INT_8_8_8_8:

+		halveImagePackedPixel(4,extract8888,shove8888,

+				      newwidth,newheight,

+				      srcImage,dstImage,element_size,rowsize,

+				      myswap_bytes);

+		break;

+	    case GL_UNSIGNED_INT_8_8_8_8_REV:

+		halveImagePackedPixel(4,extract8888rev,shove8888rev,

+				      newwidth,newheight,

+				      srcImage,dstImage,element_size,rowsize,

+				      myswap_bytes);

+		break;

+	    case GL_UNSIGNED_INT_10_10_10_2:

+		halveImagePackedPixel(4,extract1010102,shove1010102,

+				      newwidth,newheight,

+				      srcImage,dstImage,element_size,rowsize,

+				      myswap_bytes);

+		break;

+	    case GL_UNSIGNED_INT_2_10_10_10_REV:

+		halveImagePackedPixel(4,extract2101010rev,shove2101010rev,

+				      newwidth,newheight,

+				      srcImage,dstImage,element_size,rowsize,

+				      myswap_bytes);

+		break;

+	    default:

+		assert(0);

+		break;

+	}

+

+	__GLU_SWAP_IMAGE(srcImage,dstImage);

+

+	if (newwidth > 1) { newwidth /= 2; rowsize /= 2;}

+	if (newheight > 1) newheight /= 2;

+      {

+       /* compute amount to pad per row, if any */

+       int rowPad= rowsize % psm.unpack_alignment;

+

+       /* should row be padded? */

+       if (rowPad == 0) {	/* nope, row should not be padded */

+	   /* call tex image with srcImage untouched since it's not padded */

+	   if (baseLevel <= level && level <= maxLevel) {

+	   glTexImage2D(target, level, internalFormat, newwidth, newheight, 0,

+	   format, type, (void *) srcImage);

+	   }

+       }

+       else {			/* yes, row should be padded */

+	  /* compute length of new row in bytes, including padding */

+	  int newRowLength= rowsize + psm.unpack_alignment - rowPad;

+	  int ii; unsigned char *dstTrav, *srcTrav; /* indices for copying */

+

+	  /* allocate new image for mipmap of size newRowLength x newheight */

+	  void *newMipmapImage= malloc((size_t) (newRowLength*newheight));

+	  if (newMipmapImage == NULL) {

+	     /* out of memory so return */

+	     glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);

+	     glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);

+	     glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);

+	     glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);

+	     glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);

+	     return GLU_OUT_OF_MEMORY;

+	  }

+

+	  /* copy image from srcImage into newMipmapImage by rows */

+	  for (ii= 0,

+	       dstTrav= (unsigned char *) newMipmapImage,

+	       srcTrav= (unsigned char *) srcImage;

+	       ii< newheight;

+	       ii++,

+	       dstTrav+= newRowLength, /* make sure the correct distance... */

+	       srcTrav+= rowsize) {    /* ...is skipped */

+	     memcpy(dstTrav,srcTrav,rowsize);

+	     /* note that the pad bytes are not visited and will contain

+	      * garbage, which is ok.

+	      */

+	  }

+

+	  /* ...and use this new image for mipmapping instead */

+	  if (baseLevel <= level && level <= maxLevel) {

+	  glTexImage2D(target, level, internalFormat, newwidth, newheight, 0,

+		       format, type, newMipmapImage);

+	  }

+	  free(newMipmapImage); /* don't forget to free it! */

+       } /* else */

+      }

+    } /* for level */

+    glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);

+    glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);

+    glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);

+    glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);

+    glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);

+

+    free(srcImage); /*if you get to here, a srcImage has always been malloc'ed*/

+    if (dstImage) { /* if it's non-rectangular and only 1 level */

+      free(dstImage);

+    }

+    return 0;

+} /* gluBuild2DMipmapLevelsCore() */

+

+GLint GLAPIENTRY

+gluBuild2DMipmapLevels(GLenum target, GLint internalFormat,

+			     GLsizei width, GLsizei height,

+			     GLenum format, GLenum type,

+			     GLint userLevel, GLint baseLevel, GLint maxLevel,

+			     const void *data)

+{

+   int level, levels;

+

+   int rc= checkMipmapArgs(internalFormat,format,type);

+   if (rc != 0) return rc;

+

+   if (width < 1 || height < 1) {

+       return GLU_INVALID_VALUE;

+   }

+

+   levels = computeLog(width);

+   level = computeLog(height);

+   if (level > levels) levels=level;

+

+   levels+= userLevel;

+   if (!isLegalLevels(userLevel,baseLevel,maxLevel,levels))

+      return GLU_INVALID_VALUE;

+

+   return gluBuild2DMipmapLevelsCore(target, internalFormat,

+				     width, height,

+				     width, height,

+				     format, type,

+				     userLevel, baseLevel, maxLevel,

+				     data);

+} /* gluBuild2DMipmapLevels() */

+

+GLint GLAPIENTRY

+gluBuild2DMipmaps(GLenum target, GLint internalFormat,

+			GLsizei width, GLsizei height,

+			GLenum format, GLenum type,

+			const void *data)

+{

+   GLint widthPowerOf2, heightPowerOf2;

+   int level, levels;

+

+   int rc= checkMipmapArgs(internalFormat,format,type);

+   if (rc != 0) return rc;

+

+   if (width < 1 || height < 1) {

+       return GLU_INVALID_VALUE;

+   }

+

+   closestFit(target,width,height,internalFormat,format,type,

+	      &widthPowerOf2,&heightPowerOf2);

+

+   levels = computeLog(widthPowerOf2);

+   level = computeLog(heightPowerOf2);

+   if (level > levels) levels=level;

+

+   return gluBuild2DMipmapLevelsCore(target,internalFormat,

+				     width, height,

+				     widthPowerOf2,heightPowerOf2,

+				     format,type,

+				     0,0,levels,data);

+}  /* gluBuild2DMipmaps() */

+

+#if 0

+/*

+** This routine is for the limited case in which

+**	type == GL_UNSIGNED_BYTE && format != index  &&

+**	unpack_alignment = 1 && unpack_swap_bytes == false

+**

+** so all of the work data can be kept as ubytes instead of shorts.

+*/

+static int fastBuild2DMipmaps(const PixelStorageModes *psm,

+		       GLenum target, GLint components, GLint width,

+		     GLint height, GLenum format,

+		     GLenum type, void *data)

+{

+    GLint newwidth, newheight;

+    GLint level, levels;

+    GLubyte *newImage;

+    GLint newImage_width;

+    GLint newImage_height;

+    GLubyte *otherImage;

+    GLubyte *imageTemp;

+    GLint memreq;

+    GLint cmpts;

+

+

+#if 0

+    glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxsize);

+    newwidth = nearestPower(width);

+    if (newwidth > maxsize) newwidth = maxsize;

+    newheight = nearestPower(height);

+    if (newheight > maxsize) newheight = maxsize;

+#else

+    closestFit(target,width,height,components,format,type,

+	       &newwidth,&newheight);

+#endif

+    levels = computeLog(newwidth);

+    level = computeLog(newheight);

+    if (level > levels) levels=level;

+

+    cmpts = elements_per_group(format,type);

+

+    otherImage = NULL;

+    /**

+    ** No need to copy the user data if its in the packed correctly.

+    ** Make sure that later routines don't change that data.

+    */

+    if (psm->unpack_skip_rows == 0 && psm->unpack_skip_pixels == 0) {

+	newImage = (GLubyte *)data;

+	newImage_width = width;

+	newImage_height = height;

+    } else {

+	GLint rowsize;

+	GLint groups_per_line;

+	GLint elements_per_line;

+	const GLubyte *start;

+	const GLubyte *iter;

+	GLubyte *iter2;

+	GLint i, j;

+

+	newImage = (GLubyte *)

+	    malloc(image_size(width, height, format, GL_UNSIGNED_BYTE));

+	newImage_width = width;

+	newImage_height = height;

+	if (newImage == NULL) {

+	    return GLU_OUT_OF_MEMORY;

+	}

+

+	/*

+	** Abbreviated version of fill_image for this restricted case.

+	*/

+	if (psm->unpack_row_length > 0) {

+	    groups_per_line = psm->unpack_row_length;

+	} else {

+	    groups_per_line = width;

+	}

+	rowsize = groups_per_line * cmpts;

+	elements_per_line = width * cmpts;

+	start = (const GLubyte *) data + psm->unpack_skip_rows * rowsize +

+		psm->unpack_skip_pixels * cmpts;

+	iter2 = newImage;

+

+	for (i = 0; i < height; i++) {

+	    iter = start;

+	    for (j = 0; j < elements_per_line; j++) {

+		*iter2 = *iter;

+		iter++;

+		iter2++;

+	    }

+	    start += rowsize;

+	}

+    }

+

+

+    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

+    glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);

+    glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);

+    glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);

+    glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE);

+

+    for (level = 0; level <= levels; level++) {

+	if (newImage_width == newwidth && newImage_height == newheight) {

+	    /* Use newImage for this level */

+	    glTexImage2D(target, level, components, newImage_width,

+		    newImage_height, 0, format, GL_UNSIGNED_BYTE,

+		    (void *) newImage);

+	} else {

+	    if (otherImage == NULL) {

+		memreq =

+		    image_size(newwidth, newheight, format, GL_UNSIGNED_BYTE);

+		otherImage = (GLubyte *) malloc(memreq);

+		if (otherImage == NULL) {

+		    glPixelStorei(GL_UNPACK_ALIGNMENT, psm->unpack_alignment);

+		    glPixelStorei(GL_UNPACK_SKIP_ROWS, psm->unpack_skip_rows);

+		    glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm->unpack_skip_pixels);

+		    glPixelStorei(GL_UNPACK_ROW_LENGTH,psm->unpack_row_length);

+		    glPixelStorei(GL_UNPACK_SWAP_BYTES,psm->unpack_swap_bytes);

+		    return GLU_OUT_OF_MEMORY;

+		}

+	    }

+/*

+	    scale_internal_ubyte(cmpts, newImage_width, newImage_height,

+		    newImage, newwidth, newheight, otherImage);

+*/

+	    /* Swap newImage and otherImage */

+	    imageTemp = otherImage;

+	    otherImage = newImage;

+	    newImage = imageTemp;

+

+	    newImage_width = newwidth;

+	    newImage_height = newheight;

+	    glTexImage2D(target, level, components, newImage_width,

+		    newImage_height, 0, format, GL_UNSIGNED_BYTE,

+		    (void *) newImage);

+	}

+	if (newwidth > 1) newwidth /= 2;

+	if (newheight > 1) newheight /= 2;

+    }

+    glPixelStorei(GL_UNPACK_ALIGNMENT, psm->unpack_alignment);

+    glPixelStorei(GL_UNPACK_SKIP_ROWS, psm->unpack_skip_rows);

+    glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm->unpack_skip_pixels);

+    glPixelStorei(GL_UNPACK_ROW_LENGTH, psm->unpack_row_length);

+    glPixelStorei(GL_UNPACK_SWAP_BYTES, psm->unpack_swap_bytes);

+

+    if (newImage != (const GLubyte *)data) {

+	free((GLbyte *) newImage);

+    }

+    if (otherImage && otherImage != (const GLubyte *)data) {

+	free((GLbyte *) otherImage);

+    }

+    return 0;

+}

+#endif

+

+/*

+ * Utility Routines

+ */

+static GLint elements_per_group(GLenum format, GLenum type)

+{

+    /*

+     * Return the number of elements per group of a specified format

+     */

+

+    /* If the type is packedpixels then answer is 1 (ignore format) */

+    if (type == GL_UNSIGNED_BYTE_3_3_2 ||

+	type == GL_UNSIGNED_BYTE_2_3_3_REV ||

+	type == GL_UNSIGNED_SHORT_5_6_5 ||

+	type == GL_UNSIGNED_SHORT_5_6_5_REV ||

+	type == GL_UNSIGNED_SHORT_4_4_4_4 ||

+	type == GL_UNSIGNED_SHORT_4_4_4_4_REV ||

+	type == GL_UNSIGNED_SHORT_5_5_5_1  ||

+	type == GL_UNSIGNED_SHORT_1_5_5_5_REV  ||

+	type == GL_UNSIGNED_INT_8_8_8_8 ||

+	type == GL_UNSIGNED_INT_8_8_8_8_REV ||

+	type == GL_UNSIGNED_INT_10_10_10_2 ||

+	type == GL_UNSIGNED_INT_2_10_10_10_REV) {

+	return 1;

+    }

+

+    /* Types are not packed pixels, so get elements per group */

+    switch(format) {

+      case GL_RGB:

+      case GL_BGR:

+	return 3;

+      case GL_LUMINANCE_ALPHA:

+	return 2;

+      case GL_RGBA:

+      case GL_BGRA:

+	return 4;

+      default:

+	return 1;

+    }

+}

+

+static GLfloat bytes_per_element(GLenum type)

+{

+    /*

+     * Return the number of bytes per element, based on the element type

+     */

+    switch(type) {

+      case GL_BITMAP:

+	return 1.0 / 8.0;

+      case GL_UNSIGNED_SHORT:

+	return(sizeof(GLushort));

+      case GL_SHORT:

+	return(sizeof(GLshort));

+      case GL_UNSIGNED_BYTE:

+	return(sizeof(GLubyte));

+      case GL_BYTE:

+	return(sizeof(GLbyte));

+      case GL_INT:

+	return(sizeof(GLint));

+      case GL_UNSIGNED_INT:

+	return(sizeof(GLuint));

+      case GL_FLOAT:

+	return(sizeof(GLfloat));

+      case GL_UNSIGNED_BYTE_3_3_2:

+      case GL_UNSIGNED_BYTE_2_3_3_REV:  

+	return(sizeof(GLubyte));

+      case GL_UNSIGNED_SHORT_5_6_5:

+      case GL_UNSIGNED_SHORT_5_6_5_REV:

+      case GL_UNSIGNED_SHORT_4_4_4_4:

+      case GL_UNSIGNED_SHORT_4_4_4_4_REV:

+      case GL_UNSIGNED_SHORT_5_5_5_1:

+      case GL_UNSIGNED_SHORT_1_5_5_5_REV:

+	return(sizeof(GLushort));

+      case GL_UNSIGNED_INT_8_8_8_8:

+      case GL_UNSIGNED_INT_8_8_8_8_REV:

+      case GL_UNSIGNED_INT_10_10_10_2:

+      case GL_UNSIGNED_INT_2_10_10_10_REV:

+	return(sizeof(GLuint));

+      default:

+	return 4;

+    }

+}

+

+static GLint is_index(GLenum format)

+{

+    return format == GL_COLOR_INDEX || format == GL_STENCIL_INDEX;

+}

+

+/*

+** Compute memory required for internal packed array of data of given type

+** and format.

+*/

+static GLint image_size(GLint width, GLint height, GLenum format, GLenum type)

+{

+    int bytes_per_row;

+    int components;

+

+assert(width > 0);

+assert(height > 0);

+    components = elements_per_group(format,type);

+    if (type == GL_BITMAP) {

+	bytes_per_row = (width + 7) / 8;

+    } else {

+	bytes_per_row = bytes_per_element(type) * width;

+    }

+    return bytes_per_row * height * components;

+}

+

+/*

+** Extract array from user's data applying all pixel store modes.

+** The internal format used is an array of unsigned shorts.

+*/

+static void fill_image(const PixelStorageModes *psm,

+		       GLint width, GLint height, GLenum format,

+		       GLenum type, GLboolean index_format,

+		       const void *userdata, GLushort *newimage)

+{

+    GLint components;

+    GLint element_size;

+    GLint rowsize;

+    GLint padding;

+    GLint groups_per_line;

+    GLint group_size;

+    GLint elements_per_line;

+    const GLubyte *start;

+    const GLubyte *iter;

+    GLushort *iter2;

+    GLint i, j, k;

+    GLint myswap_bytes;

+

+    myswap_bytes = psm->unpack_swap_bytes;

+    components = elements_per_group(format,type);

+    if (psm->unpack_row_length > 0) {

+	groups_per_line = psm->unpack_row_length;

+    } else {

+	groups_per_line = width;

+    }

+

+    /* All formats except GL_BITMAP fall out trivially */

+    if (type == GL_BITMAP) {

+	GLint bit_offset;

+	GLint current_bit;

+

+	rowsize = (groups_per_line * components + 7) / 8;

+	padding = (rowsize % psm->unpack_alignment);

+	if (padding) {

+	    rowsize += psm->unpack_alignment - padding;

+	}

+	start = (const GLubyte *) userdata + psm->unpack_skip_rows * rowsize +

+		(psm->unpack_skip_pixels * components / 8);

+	elements_per_line = width * components;

+	iter2 = newimage;

+	for (i = 0; i < height; i++) {

+	    iter = start;

+	    bit_offset = (psm->unpack_skip_pixels * components) % 8;

+	    for (j = 0; j < elements_per_line; j++) {

+		/* Retrieve bit */

+		if (psm->unpack_lsb_first) {

+		    current_bit = iter[0] & (1 << bit_offset);

+		} else {

+		    current_bit = iter[0] & (1 << (7 - bit_offset));

+		}

+		if (current_bit) {

+		    if (index_format) {

+			*iter2 = 1;

+		    } else {

+			*iter2 = 65535;

+		    }

+		} else {

+		    *iter2 = 0;

+		}

+		bit_offset++;

+		if (bit_offset == 8) {

+		    bit_offset = 0;

+		    iter++;

+		}

+		iter2++;

+	    }

+	    start += rowsize;

+	}

+    } else {

+	element_size = bytes_per_element(type);

+	group_size = element_size * components;

+	if (element_size == 1) myswap_bytes = 0;

+

+	rowsize = groups_per_line * group_size;

+	padding = (rowsize % psm->unpack_alignment);

+	if (padding) {

+	    rowsize += psm->unpack_alignment - padding;

+	}

+	start = (const GLubyte *) userdata + psm->unpack_skip_rows * rowsize +

+		psm->unpack_skip_pixels * group_size;

+	elements_per_line = width * components;

+

+	iter2 = newimage;

+	for (i = 0; i < height; i++) {

+	    iter = start;

+	    for (j = 0; j < elements_per_line; j++) {

+		Type_Widget widget;

+		float extractComponents[4];

+

+		switch(type) {

+		  case GL_UNSIGNED_BYTE_3_3_2:

+		    extract332(0,iter,extractComponents);

+		    for (k = 0; k < 3; k++) {

+		      *iter2++ = (GLushort)(extractComponents[k]*65535);

+		    }

+		    break;

+		  case GL_UNSIGNED_BYTE_2_3_3_REV:

+		    extract233rev(0,iter,extractComponents);

+		    for (k = 0; k < 3; k++) {

+		      *iter2++ = (GLushort)(extractComponents[k]*65535);

+		    }

+		    break;

+		  case GL_UNSIGNED_BYTE:

+		    if (index_format) {

+			*iter2++ = *iter;

+		    } else {

+			*iter2++ = (*iter) * 257;

+		    }

+		    break;

+		  case GL_BYTE:

+		    if (index_format) {

+			*iter2++ = *((const GLbyte *) iter);

+		    } else {

+			/* rough approx */

+			*iter2++ = (*((const GLbyte *) iter)) * 516;

+		    }

+		    break;

+		  case GL_UNSIGNED_SHORT_5_6_5: 		        

+		    extract565(myswap_bytes,iter,extractComponents);

+		    for (k = 0; k < 3; k++) {

+		      *iter2++ = (GLushort)(extractComponents[k]*65535);

+		    }

+		    break;

+		  case GL_UNSIGNED_SHORT_5_6_5_REV:		        

+		    extract565rev(myswap_bytes,iter,extractComponents);

+		    for (k = 0; k < 3; k++) {

+		      *iter2++ = (GLushort)(extractComponents[k]*65535);

+		    }

+		    break;

+		  case GL_UNSIGNED_SHORT_4_4_4_4:	        

+		    extract4444(myswap_bytes,iter,extractComponents);

+		    for (k = 0; k < 4; k++) {

+		      *iter2++ = (GLushort)(extractComponents[k]*65535);

+		    }

+		    break;

+		  case GL_UNSIGNED_SHORT_4_4_4_4_REV:	        

+		    extract4444rev(myswap_bytes,iter,extractComponents);

+		    for (k = 0; k < 4; k++) {

+		      *iter2++ = (GLushort)(extractComponents[k]*65535);

+		    }

+		    break;

+		  case GL_UNSIGNED_SHORT_5_5_5_1:	        

+		    extract5551(myswap_bytes,iter,extractComponents);

+		    for (k = 0; k < 4; k++) {

+		      *iter2++ = (GLushort)(extractComponents[k]*65535);

+		    }

+		    break;

+		  case GL_UNSIGNED_SHORT_1_5_5_5_REV:

+		    extract1555rev(myswap_bytes,iter,extractComponents);

+		    for (k = 0; k < 4; k++) {

+		      *iter2++ = (GLushort)(extractComponents[k]*65535);

+		    }

+		    break;

+		  case GL_UNSIGNED_SHORT:

+		  case GL_SHORT:

+		    if (myswap_bytes) {

+			widget.ub[0] = iter[1];

+			widget.ub[1] = iter[0];

+		    } else {

+			widget.ub[0] = iter[0];

+			widget.ub[1] = iter[1];

+		    }

+		    if (type == GL_SHORT) {

+			if (index_format) {

+			    *iter2++ = widget.s[0];

+			} else {

+			    /* rough approx */

+			    *iter2++ = widget.s[0]*2;

+			}

+		    } else {

+			*iter2++ = widget.us[0];

+		    }

+		    break;

+		  case GL_UNSIGNED_INT_8_8_8_8:         

+		    extract8888(myswap_bytes,iter,extractComponents);

+		    for (k = 0; k < 4; k++) {

+		      *iter2++ = (GLushort)(extractComponents[k]*65535);

+		    }

+		    break;

+		  case GL_UNSIGNED_INT_8_8_8_8_REV:	        

+		    extract8888rev(myswap_bytes,iter,extractComponents);

+		    for (k = 0; k < 4; k++) {

+		      *iter2++ = (GLushort)(extractComponents[k]*65535);

+		    }

+		    break;

+		  case GL_UNSIGNED_INT_10_10_10_2:	        

+		    extract1010102(myswap_bytes,iter,extractComponents);

+		    for (k = 0; k < 4; k++) {

+		      *iter2++ = (GLushort)(extractComponents[k]*65535);

+		    }

+		    break;

+		  case GL_UNSIGNED_INT_2_10_10_10_REV:

+		    extract2101010rev(myswap_bytes,iter,extractComponents);

+		    for (k = 0; k < 4; k++) {

+		      *iter2++ = (GLushort)(extractComponents[k]*65535);

+		    }

+		    break;

+		  case GL_INT:

+		  case GL_UNSIGNED_INT:

+		  case GL_FLOAT:

+		    if (myswap_bytes) {

+			widget.ub[0] = iter[3];

+			widget.ub[1] = iter[2];

+			widget.ub[2] = iter[1];

+			widget.ub[3] = iter[0];

+		    } else {

+			widget.ub[0] = iter[0];

+			widget.ub[1] = iter[1];

+			widget.ub[2] = iter[2];

+			widget.ub[3] = iter[3];

+		    }

+		    if (type == GL_FLOAT) {

+			if (index_format) {

+			    *iter2++ = widget.f;

+			} else {

+			    *iter2++ = 65535 * widget.f;

+			}

+		    } else if (type == GL_UNSIGNED_INT) {

+			if (index_format) {

+			    *iter2++ = widget.ui;

+			} else {

+			    *iter2++ = widget.ui >> 16;

+			}

+		    } else {

+			if (index_format) {

+			    *iter2++ = widget.i;

+			} else {

+			    *iter2++ = widget.i >> 15;

+			}

+		    }

+		    break;

+		}

+		iter += element_size;

+	    } /* for j */

+	    start += rowsize;

+#if 1

+	    /* want 'iter' pointing at start, not within, row for assertion

+	     * purposes

+	     */

+	    iter= start;        

+#endif

+	} /* for i */

+

+       /* iterators should be one byte past end */

+       if (!isTypePackedPixel(type)) {

+	  assert(iter2 == &newimage[width*height*components]);

+       }

+       else {

+	  assert(iter2 == &newimage[width*height*

+				    elements_per_group(format,0)]);

+       }

+       assert( iter == &((const GLubyte *)userdata)[rowsize*height +

+					psm->unpack_skip_rows * rowsize +

+					psm->unpack_skip_pixels * group_size] );

+

+    } /* else */

+} /* fill_image() */

+

+/*

+** Insert array into user's data applying all pixel store modes.

+** The internal format is an array of unsigned shorts.

+** empty_image() because it is the opposite of fill_image().

+*/

+static void empty_image(const PixelStorageModes *psm,

+			GLint width, GLint height, GLenum format,

+			GLenum type, GLboolean index_format,

+			const GLushort *oldimage, void *userdata)

+{

+    GLint components;

+    GLint element_size;

+    GLint rowsize;

+    GLint padding;

+    GLint groups_per_line;

+    GLint group_size;

+    GLint elements_per_line;

+    GLubyte *start;

+    GLubyte *iter;

+    const GLushort *iter2;

+    GLint i, j, k;

+    GLint myswap_bytes;

+

+    myswap_bytes = psm->pack_swap_bytes;

+    components = elements_per_group(format,type);

+    if (psm->pack_row_length > 0) {

+	groups_per_line = psm->pack_row_length;

+    } else {

+	groups_per_line = width;

+    }

+

+    /* All formats except GL_BITMAP fall out trivially */

+    if (type == GL_BITMAP) {

+	GLint bit_offset;

+	GLint current_bit;

+

+	rowsize = (groups_per_line * components + 7) / 8;

+	padding = (rowsize % psm->pack_alignment);

+	if (padding) {

+	    rowsize += psm->pack_alignment - padding;

+	}

+	start = (GLubyte *) userdata + psm->pack_skip_rows * rowsize +

+		(psm->pack_skip_pixels * components / 8);

+	elements_per_line = width * components;

+	iter2 = oldimage;

+	for (i = 0; i < height; i++) {

+	    iter = start;

+	    bit_offset = (psm->pack_skip_pixels * components) % 8;

+	    for (j = 0; j < elements_per_line; j++) {

+		if (index_format) {

+		    current_bit = iter2[0] & 1;

+		} else {

+		    if (iter2[0] > 32767) {

+			current_bit = 1;

+		    } else {

+			current_bit = 0;

+		    }

+		}

+

+		if (current_bit) {

+		    if (psm->pack_lsb_first) {

+			*iter |= (1 << bit_offset);

+		    } else {

+			*iter |= (1 << (7 - bit_offset));

+		    }

+		} else {

+		    if (psm->pack_lsb_first) {

+			*iter &= ~(1 << bit_offset);

+		    } else {

+			*iter &= ~(1 << (7 - bit_offset));

+		    }

+		}

+

+		bit_offset++;

+		if (bit_offset == 8) {

+		    bit_offset = 0;

+		    iter++;

+		}

+		iter2++;

+	    }

+	    start += rowsize;

+	}

+    } else {

+	float shoveComponents[4];

+

+	element_size = bytes_per_element(type);

+	group_size = element_size * components;

+	if (element_size == 1) myswap_bytes = 0;

+

+	rowsize = groups_per_line * group_size;

+	padding = (rowsize % psm->pack_alignment);

+	if (padding) {

+	    rowsize += psm->pack_alignment - padding;

+	}

+	start = (GLubyte *) userdata + psm->pack_skip_rows * rowsize +

+		psm->pack_skip_pixels * group_size;

+	elements_per_line = width * components;

+

+	iter2 = oldimage;

+	for (i = 0; i < height; i++) {

+	    iter = start;

+	    for (j = 0; j < elements_per_line; j++) {

+		Type_Widget widget;

+

+		switch(type) {

+		  case GL_UNSIGNED_BYTE_3_3_2:

+		    for (k = 0; k < 3; k++) {

+		       shoveComponents[k]= *iter2++ / 65535.0;

+		    }

+		    shove332(shoveComponents,0,(void *)iter);

+		    break;

+		  case GL_UNSIGNED_BYTE_2_3_3_REV:

+		    for (k = 0; k < 3; k++) {

+		       shoveComponents[k]= *iter2++ / 65535.0;

+		    }

+		    shove233rev(shoveComponents,0,(void *)iter);

+		    break;

+		  case GL_UNSIGNED_BYTE:

+		    if (index_format) {

+			*iter = *iter2++;

+		    } else {

+			*iter = *iter2++ >> 8;

+		    }

+		    break;

+		  case GL_BYTE:

+		    if (index_format) {

+			*((GLbyte *) iter) = *iter2++;

+		    } else {

+			*((GLbyte *) iter) = *iter2++ >> 9;

+		    }

+		    break;

+		  case GL_UNSIGNED_SHORT_5_6_5:         

+		    for (k = 0; k < 3; k++) {

+		       shoveComponents[k]= *iter2++ / 65535.0;

+		    }

+		    shove565(shoveComponents,0,(void *)&widget.us[0]);

+		    if (myswap_bytes) {

+		       iter[0] = widget.ub[1];

+		       iter[1] = widget.ub[0];

+		    }

+		    else {

+		       *(GLushort *)iter = widget.us[0];

+		    }

+		    break;

+		  case GL_UNSIGNED_SHORT_5_6_5_REV:	        

+		    for (k = 0; k < 3; k++) {

+		       shoveComponents[k]= *iter2++ / 65535.0;

+		    }

+		    shove565rev(shoveComponents,0,(void *)&widget.us[0]);

+		    if (myswap_bytes) {

+		       iter[0] = widget.ub[1];

+		       iter[1] = widget.ub[0];

+		    }

+		    else {

+		       *(GLushort *)iter = widget.us[0];

+		    }

+		    break;

+		  case GL_UNSIGNED_SHORT_4_4_4_4:

+		    for (k = 0; k < 4; k++) {

+		       shoveComponents[k]= *iter2++ / 65535.0;

+		    }

+		    shove4444(shoveComponents,0,(void *)&widget.us[0]);

+		    if (myswap_bytes) {

+		       iter[0] = widget.ub[1];

+		       iter[1] = widget.ub[0];

+		    } else {

+		       *(GLushort *)iter = widget.us[0];

+		    }

+		    break;

+		  case GL_UNSIGNED_SHORT_4_4_4_4_REV:

+		    for (k = 0; k < 4; k++) {

+		       shoveComponents[k]= *iter2++ / 65535.0;

+		    }

+		    shove4444rev(shoveComponents,0,(void *)&widget.us[0]);

+		    if (myswap_bytes) {

+		       iter[0] = widget.ub[1];

+		       iter[1] = widget.ub[0];

+		    } else {

+		       *(GLushort *)iter = widget.us[0];

+		    }

+		    break;

+		  case GL_UNSIGNED_SHORT_5_5_5_1:

+		    for (k = 0; k < 4; k++) {

+		       shoveComponents[k]= *iter2++ / 65535.0;

+		    }

+		    shove5551(shoveComponents,0,(void *)&widget.us[0]);

+		    if (myswap_bytes) {

+		       iter[0] = widget.ub[1];

+		       iter[1] = widget.ub[0];

+		    } else {

+		       *(GLushort *)iter = widget.us[0];

+		    }

+		    break;

+		  case GL_UNSIGNED_SHORT_1_5_5_5_REV:

+		    for (k = 0; k < 4; k++) {

+		       shoveComponents[k]= *iter2++ / 65535.0;

+		    }

+		    shove1555rev(shoveComponents,0,(void *)&widget.us[0]);

+		    if (myswap_bytes) {

+		       iter[0] = widget.ub[1];

+		       iter[1] = widget.ub[0];

+		    } else {

+		       *(GLushort *)iter = widget.us[0];

+		    }

+		    break;

+		  case GL_UNSIGNED_SHORT:

+		  case GL_SHORT:

+		    if (type == GL_SHORT) {

+			if (index_format) {

+			    widget.s[0] = *iter2++;

+			} else {

+			    widget.s[0] = *iter2++ >> 1;

+			}

+		    } else {

+			widget.us[0] = *iter2++;

+		    }

+		    if (myswap_bytes) {

+			iter[0] = widget.ub[1];

+			iter[1] = widget.ub[0];

+		    } else {

+			iter[0] = widget.ub[0];

+			iter[1] = widget.ub[1];

+		    }

+		    break;

+		  case GL_UNSIGNED_INT_8_8_8_8:

+		    for (k = 0; k < 4; k++) {

+		       shoveComponents[k]= *iter2++ / 65535.0;

+		    }

+		    shove8888(shoveComponents,0,(void *)&widget.ui);

+		    if (myswap_bytes) {

+			iter[3] = widget.ub[0];

+			iter[2] = widget.ub[1];

+			iter[1] = widget.ub[2];

+			iter[0] = widget.ub[3];

+		    } else {

+			*(GLuint *)iter= widget.ui;

+		    }

+

+		    break;

+		  case GL_UNSIGNED_INT_8_8_8_8_REV:

+		    for (k = 0; k < 4; k++) {

+		       shoveComponents[k]= *iter2++ / 65535.0;

+		    }

+		    shove8888rev(shoveComponents,0,(void *)&widget.ui);

+		    if (myswap_bytes) {

+			iter[3] = widget.ub[0];

+			iter[2] = widget.ub[1];

+			iter[1] = widget.ub[2];

+			iter[0] = widget.ub[3];

+		    } else {

+			*(GLuint *)iter= widget.ui;

+		    }

+		    break;

+		  case GL_UNSIGNED_INT_10_10_10_2:

+		    for (k = 0; k < 4; k++) {

+		       shoveComponents[k]= *iter2++ / 65535.0;

+		    }

+		    shove1010102(shoveComponents,0,(void *)&widget.ui);

+		    if (myswap_bytes) {

+			iter[3] = widget.ub[0];

+			iter[2] = widget.ub[1];

+			iter[1] = widget.ub[2];

+			iter[0] = widget.ub[3];

+		    } else {

+			*(GLuint *)iter= widget.ui;

+		    }

+		    break;

+		  case GL_UNSIGNED_INT_2_10_10_10_REV:

+		    for (k = 0; k < 4; k++) {

+		       shoveComponents[k]= *iter2++ / 65535.0;

+		    }

+		    shove2101010rev(shoveComponents,0,(void *)&widget.ui);

+		    if (myswap_bytes) {

+			iter[3] = widget.ub[0];

+			iter[2] = widget.ub[1];

+			iter[1] = widget.ub[2];

+			iter[0] = widget.ub[3];

+		    } else {

+			*(GLuint *)iter= widget.ui;

+		    }

+		    break;

+		  case GL_INT:

+		  case GL_UNSIGNED_INT:

+		  case GL_FLOAT:

+		    if (type == GL_FLOAT) {

+			if (index_format) {

+			    widget.f = *iter2++;

+			} else {

+			    widget.f = *iter2++ / (float) 65535.0;

+			}

+		    } else if (type == GL_UNSIGNED_INT) {

+			if (index_format) {

+			    widget.ui = *iter2++;

+			} else {

+			    widget.ui = (unsigned int) *iter2++ * 65537;

+			}

+		    } else {

+			if (index_format) {

+			    widget.i = *iter2++;

+			} else {

+			    widget.i = ((unsigned int) *iter2++ * 65537)/2;

+			}

+		    }

+		    if (myswap_bytes) {

+			iter[3] = widget.ub[0];

+			iter[2] = widget.ub[1];

+			iter[1] = widget.ub[2];

+			iter[0] = widget.ub[3];

+		    } else {

+			iter[0] = widget.ub[0];

+			iter[1] = widget.ub[1];

+			iter[2] = widget.ub[2];

+			iter[3] = widget.ub[3];

+		    }

+		    break;

+		}

+		iter += element_size;

+	    } /* for j */

+	    start += rowsize;

+#if 1

+	    /* want 'iter' pointing at start, not within, row for assertion

+	     * purposes

+	     */

+	    iter= start;        

+#endif

+	} /* for i */

+

+	/* iterators should be one byte past end */

+	if (!isTypePackedPixel(type)) {

+	   assert(iter2 == &oldimage[width*height*components]);

+	}

+	else {

+	   assert(iter2 == &oldimage[width*height*

+				     elements_per_group(format,0)]);

+	}

+	assert( iter == &((GLubyte *)userdata)[rowsize*height +

+					psm->pack_skip_rows * rowsize +

+					psm->pack_skip_pixels * group_size] );

+

+    } /* else */

+} /* empty_image() */

+

+/*--------------------------------------------------------------------------

+ * Decimation of packed pixel types

+ *--------------------------------------------------------------------------

+ */

+static void extract332(int isSwap,

+		       const void *packedPixel, GLfloat extractComponents[])

+{

+   GLubyte ubyte= *(const GLubyte *)packedPixel;

+

+   isSwap= isSwap;		/* turn off warnings */

+

+   /* 11100000 == 0xe0 */

+   /* 00011100 == 0x1c */

+   /* 00000011 == 0x03 */

+

+   extractComponents[0]=   (float)((ubyte & 0xe0)  >> 5) / 7.0;

+   extractComponents[1]=   (float)((ubyte & 0x1c)  >> 2) / 7.0; /* 7 = 2^3-1 */

+   extractComponents[2]=   (float)((ubyte & 0x03)      ) / 3.0; /* 3 = 2^2-1 */

+} /* extract332() */

+

+static void shove332(const GLfloat shoveComponents[],

+		     int index, void *packedPixel)      

+{

+   /* 11100000 == 0xe0 */

+   /* 00011100 == 0x1c */

+   /* 00000011 == 0x03 */

+

+   assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);

+   assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);

+   assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);

+

+   /* due to limited precision, need to round before shoving */

+   ((GLubyte *)packedPixel)[index]  =

+     ((GLubyte)((shoveComponents[0] * 7)+0.5)  << 5) & 0xe0;

+   ((GLubyte *)packedPixel)[index] |=

+     ((GLubyte)((shoveComponents[1] * 7)+0.5)  << 2) & 0x1c;

+   ((GLubyte *)packedPixel)[index]  |=

+     ((GLubyte)((shoveComponents[2] * 3)+0.5)	   ) & 0x03;

+} /* shove332() */

+

+static void extract233rev(int isSwap,

+			  const void *packedPixel, GLfloat extractComponents[])

+{

+   GLubyte ubyte= *(const GLubyte *)packedPixel;

+

+   isSwap= isSwap;		/* turn off warnings */

+

+   /* 0000,0111 == 0x07 */

+   /* 0011,1000 == 0x38 */

+   /* 1100,0000 == 0xC0 */

+

+   extractComponents[0]= (float)((ubyte & 0x07)     ) / 7.0;

+   extractComponents[1]= (float)((ubyte & 0x38) >> 3) / 7.0;

+   extractComponents[2]= (float)((ubyte & 0xC0) >> 6) / 3.0;

+} /* extract233rev() */

+

+static void shove233rev(const GLfloat shoveComponents[],

+			int index, void *packedPixel)   

+{

+   /* 0000,0111 == 0x07 */

+   /* 0011,1000 == 0x38 */

+   /* 1100,0000 == 0xC0 */

+

+   assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);

+   assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);

+   assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);

+

+   /* due to limited precision, need to round before shoving */

+   ((GLubyte *)packedPixel)[index] =

+     ((GLubyte)((shoveComponents[0] * 7.0)+0.5)     ) & 0x07;

+   ((GLubyte *)packedPixel)[index]|=

+     ((GLubyte)((shoveComponents[1] * 7.0)+0.5) << 3) & 0x38;

+   ((GLubyte *)packedPixel)[index]|=

+     ((GLubyte)((shoveComponents[2] * 3.0)+0.5) << 6) & 0xC0;

+} /* shove233rev() */

+

+static void extract565(int isSwap,

+		       const void *packedPixel, GLfloat extractComponents[])

+{

+   GLushort ushort;

+

+   if (isSwap) {

+     ushort= __GLU_SWAP_2_BYTES(packedPixel);

+   }

+   else {

+     ushort= *(const GLushort *)packedPixel;

+   }

+

+   /* 11111000,00000000 == 0xf800 */

+   /* 00000111,11100000 == 0x07e0 */

+   /* 00000000,00011111 == 0x001f */

+

+   extractComponents[0]=(float)((ushort & 0xf800) >> 11) / 31.0;/* 31 = 2^5-1*/

+   extractComponents[1]=(float)((ushort & 0x07e0) >>  5) / 63.0;/* 63 = 2^6-1*/

+   extractComponents[2]=(float)((ushort & 0x001f)      ) / 31.0;

+} /* extract565() */

+

+static void shove565(const GLfloat shoveComponents[],

+		     int index,void *packedPixel)

+{

+   /* 11111000,00000000 == 0xf800 */

+   /* 00000111,11100000 == 0x07e0 */

+   /* 00000000,00011111 == 0x001f */

+

+   assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);

+   assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);

+   assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);

+

+   /* due to limited precision, need to round before shoving */

+   ((GLushort *)packedPixel)[index] =

+     ((GLushort)((shoveComponents[0] * 31)+0.5) << 11) & 0xf800;

+   ((GLushort *)packedPixel)[index]|=

+     ((GLushort)((shoveComponents[1] * 63)+0.5) <<  5) & 0x07e0;

+   ((GLushort *)packedPixel)[index]|=

+     ((GLushort)((shoveComponents[2] * 31)+0.5)      ) & 0x001f;

+} /* shove565() */

+

+static void extract565rev(int isSwap,

+			  const void *packedPixel, GLfloat extractComponents[])

+{

+   GLushort ushort;

+

+   if (isSwap) {

+     ushort= __GLU_SWAP_2_BYTES(packedPixel);

+   }

+   else {

+     ushort= *(const GLushort *)packedPixel;

+   }

+

+   /* 00000000,00011111 == 0x001f */

+   /* 00000111,11100000 == 0x07e0 */

+   /* 11111000,00000000 == 0xf800 */

+

+   extractComponents[0]= (float)((ushort & 0x001F)	) / 31.0;

+   extractComponents[1]= (float)((ushort & 0x07E0) >>  5) / 63.0;

+   extractComponents[2]= (float)((ushort & 0xF800) >> 11) / 31.0;

+} /* extract565rev() */

+

+static void shove565rev(const GLfloat shoveComponents[],

+			int index,void *packedPixel)

+{

+   /* 00000000,00011111 == 0x001f */

+   /* 00000111,11100000 == 0x07e0 */

+   /* 11111000,00000000 == 0xf800 */

+

+   assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);

+   assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);

+   assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);

+

+   /* due to limited precision, need to round before shoving */

+   ((GLushort *)packedPixel)[index] =

+     ((GLushort)((shoveComponents[0] * 31.0)+0.5)      ) & 0x001F;

+   ((GLushort *)packedPixel)[index]|=

+     ((GLushort)((shoveComponents[1] * 63.0)+0.5) <<  5) & 0x07E0;

+   ((GLushort *)packedPixel)[index]|=

+     ((GLushort)((shoveComponents[2] * 31.0)+0.5) << 11) & 0xF800;

+} /* shove565rev() */

+

+static void extract4444(int isSwap,const void *packedPixel,

+			GLfloat extractComponents[])

+{

+   GLushort ushort;

+

+   if (isSwap) {

+     ushort= __GLU_SWAP_2_BYTES(packedPixel);

+   }

+   else {

+     ushort= *(const GLushort *)packedPixel;

+   }

+

+   /* 11110000,00000000 == 0xf000 */

+   /* 00001111,00000000 == 0x0f00 */

+   /* 00000000,11110000 == 0x00f0 */

+   /* 00000000,00001111 == 0x000f */

+

+   extractComponents[0]= (float)((ushort & 0xf000) >> 12) / 15.0;/* 15=2^4-1 */

+   extractComponents[1]= (float)((ushort & 0x0f00) >>  8) / 15.0;

+   extractComponents[2]= (float)((ushort & 0x00f0) >>  4) / 15.0;

+   extractComponents[3]= (float)((ushort & 0x000f)	) / 15.0;

+} /* extract4444() */

+

+static void shove4444(const GLfloat shoveComponents[],

+		      int index,void *packedPixel)

+{

+   assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);

+   assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);

+   assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);

+   assert(0.0 <= shoveComponents[3] && shoveComponents[3] <= 1.0);

+

+   /* due to limited precision, need to round before shoving */

+   ((GLushort *)packedPixel)[index] =

+     ((GLushort)((shoveComponents[0] * 15)+0.5) << 12) & 0xf000;

+   ((GLushort *)packedPixel)[index]|=

+     ((GLushort)((shoveComponents[1] * 15)+0.5) <<  8) & 0x0f00;

+   ((GLushort *)packedPixel)[index]|=

+     ((GLushort)((shoveComponents[2] * 15)+0.5) <<  4) & 0x00f0;

+   ((GLushort *)packedPixel)[index]|=

+     ((GLushort)((shoveComponents[3] * 15)+0.5)      ) & 0x000f;

+} /* shove4444() */

+

+static void extract4444rev(int isSwap,const void *packedPixel,

+			   GLfloat extractComponents[])

+{

+   GLushort ushort;

+

+   if (isSwap) {

+     ushort= __GLU_SWAP_2_BYTES(packedPixel);

+   }

+   else {

+     ushort= *(const GLushort *)packedPixel;

+   }

+

+   /* 00000000,00001111 == 0x000f */

+   /* 00000000,11110000 == 0x00f0 */

+   /* 00001111,00000000 == 0x0f00 */

+   /* 11110000,00000000 == 0xf000 */

+

+   /* 15 = 2^4-1 */

+   extractComponents[0]= (float)((ushort & 0x000F)	) / 15.0;

+   extractComponents[1]= (float)((ushort & 0x00F0) >>  4) / 15.0;

+   extractComponents[2]= (float)((ushort & 0x0F00) >>  8) / 15.0;

+   extractComponents[3]= (float)((ushort & 0xF000) >> 12) / 15.0;

+} /* extract4444rev() */

+

+static void shove4444rev(const GLfloat shoveComponents[],

+			 int index,void *packedPixel)

+{

+   /* 00000000,00001111 == 0x000f */

+   /* 00000000,11110000 == 0x00f0 */

+   /* 00001111,00000000 == 0x0f00 */

+   /* 11110000,00000000 == 0xf000 */

+

+   assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);

+   assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);

+   assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);

+   assert(0.0 <= shoveComponents[3] && shoveComponents[3] <= 1.0);

+

+   /* due to limited precision, need to round before shoving */

+   ((GLushort *)packedPixel)[index] =

+     ((GLushort)((shoveComponents[0] * 15)+0.5)      ) & 0x000F;

+   ((GLushort *)packedPixel)[index]|=

+     ((GLushort)((shoveComponents[1] * 15)+0.5) <<  4) & 0x00F0;

+   ((GLushort *)packedPixel)[index]|=

+     ((GLushort)((shoveComponents[2] * 15)+0.5) <<  8) & 0x0F00;

+   ((GLushort *)packedPixel)[index]|=

+     ((GLushort)((shoveComponents[3] * 15)+0.5) << 12) & 0xF000;

+} /* shove4444rev() */

+

+static void extract5551(int isSwap,const void *packedPixel,

+			GLfloat extractComponents[])

+{

+   GLushort ushort;

+

+   if (isSwap) {

+     ushort= __GLU_SWAP_2_BYTES(packedPixel);

+   }

+   else {

+     ushort= *(const GLushort *)packedPixel;

+   }

+

+   /* 11111000,00000000 == 0xf800 */

+   /* 00000111,11000000 == 0x07c0 */

+   /* 00000000,00111110 == 0x003e */

+   /* 00000000,00000001 == 0x0001 */

+

+   extractComponents[0]=(float)((ushort & 0xf800) >> 11) / 31.0;/* 31 = 2^5-1*/

+   extractComponents[1]=(float)((ushort & 0x07c0) >>  6) / 31.0;

+   extractComponents[2]=(float)((ushort & 0x003e) >>  1) / 31.0;

+   extractComponents[3]=(float)((ushort & 0x0001)      );

+} /* extract5551() */

+

+static void shove5551(const GLfloat shoveComponents[],

+		      int index,void *packedPixel)

+{

+   /* 11111000,00000000 == 0xf800 */

+   /* 00000111,11000000 == 0x07c0 */

+   /* 00000000,00111110 == 0x003e */

+   /* 00000000,00000001 == 0x0001 */

+

+   assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);

+   assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);

+   assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);

+   assert(0.0 <= shoveComponents[3] && shoveComponents[3] <= 1.0);

+

+   /* due to limited precision, need to round before shoving */

+   ((GLushort *)packedPixel)[index]  =

+     ((GLushort)((shoveComponents[0] * 31)+0.5) << 11) & 0xf800;

+   ((GLushort *)packedPixel)[index]|=

+     ((GLushort)((shoveComponents[1] * 31)+0.5) <<  6) & 0x07c0;

+   ((GLushort *)packedPixel)[index]|=

+     ((GLushort)((shoveComponents[2] * 31)+0.5) <<  1) & 0x003e;

+   ((GLushort *)packedPixel)[index]|=

+     ((GLushort)((shoveComponents[3])+0.5)	     ) & 0x0001;

+} /* shove5551() */

+

+static void extract1555rev(int isSwap,const void *packedPixel,

+			   GLfloat extractComponents[])

+{

+   GLushort ushort;

+

+   if (isSwap) {

+     ushort= __GLU_SWAP_2_BYTES(packedPixel);

+   }

+   else {

+     ushort= *(const GLushort *)packedPixel;

+   }

+

+   /* 00000000,00011111 == 0x001F */

+   /* 00000011,11100000 == 0x03E0 */

+   /* 01111100,00000000 == 0x7C00 */

+   /* 10000000,00000000 == 0x8000 */

+

+   /* 31 = 2^5-1 */

+   extractComponents[0]= (float)((ushort & 0x001F)	) / 31.0;

+   extractComponents[1]= (float)((ushort & 0x03E0) >>  5) / 31.0;

+   extractComponents[2]= (float)((ushort & 0x7C00) >> 10) / 31.0;

+   extractComponents[3]= (float)((ushort & 0x8000) >> 15);

+} /* extract1555rev() */

+

+static void shove1555rev(const GLfloat shoveComponents[],

+			 int index,void *packedPixel)

+{

+   /* 00000000,00011111 == 0x001F */

+   /* 00000011,11100000 == 0x03E0 */

+   /* 01111100,00000000 == 0x7C00 */

+   /* 10000000,00000000 == 0x8000 */

+

+   assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);

+   assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);

+   assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);

+   assert(0.0 <= shoveComponents[3] && shoveComponents[3] <= 1.0);

+

+   /* due to limited precision, need to round before shoving */

+   ((GLushort *)packedPixel)[index] =

+     ((GLushort)((shoveComponents[0] * 31)+0.5)      ) & 0x001F;

+   ((GLushort *)packedPixel)[index]|=

+     ((GLushort)((shoveComponents[1] * 31)+0.5) <<  5) & 0x03E0;

+   ((GLushort *)packedPixel)[index]|=

+     ((GLushort)((shoveComponents[2] * 31)+0.5) << 10) & 0x7C00;

+   ((GLushort *)packedPixel)[index]|=

+     ((GLushort)((shoveComponents[3])+0.5)	<< 15) & 0x8000;

+} /* shove1555rev() */

+

+static void extract8888(int isSwap,

+			const void *packedPixel, GLfloat extractComponents[])

+{

+   GLuint uint;

+

+   if (isSwap) {

+     uint= __GLU_SWAP_4_BYTES(packedPixel);

+   }

+   else {

+     uint= *(const GLuint *)packedPixel;

+   }

+

+   /* 11111111,00000000,00000000,00000000 == 0xff000000 */

+   /* 00000000,11111111,00000000,00000000 == 0x00ff0000 */

+   /* 00000000,00000000,11111111,00000000 == 0x0000ff00 */

+   /* 00000000,00000000,00000000,11111111 == 0x000000ff */

+

+   /* 255 = 2^8-1 */

+   extractComponents[0]= (float)((uint & 0xff000000) >> 24) / 255.0;

+   extractComponents[1]= (float)((uint & 0x00ff0000) >> 16) / 255.0;

+   extractComponents[2]= (float)((uint & 0x0000ff00) >>  8) / 255.0;

+   extractComponents[3]= (float)((uint & 0x000000ff)	  ) / 255.0;

+} /* extract8888() */

+

+static void shove8888(const GLfloat shoveComponents[],

+		      int index,void *packedPixel)

+{

+   /* 11111111,00000000,00000000,00000000 == 0xff000000 */

+   /* 00000000,11111111,00000000,00000000 == 0x00ff0000 */

+   /* 00000000,00000000,11111111,00000000 == 0x0000ff00 */

+   /* 00000000,00000000,00000000,11111111 == 0x000000ff */

+

+   assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);

+   assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);

+   assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);

+   assert(0.0 <= shoveComponents[3] && shoveComponents[3] <= 1.0);

+

+   /* due to limited precision, need to round before shoving */

+   ((GLuint *)packedPixel)[index] =

+     ((GLuint)((shoveComponents[0] * 255)+0.5) << 24) & 0xff000000;

+   ((GLuint *)packedPixel)[index]|=

+     ((GLuint)((shoveComponents[1] * 255)+0.5) << 16) & 0x00ff0000;

+   ((GLuint *)packedPixel)[index]|=

+     ((GLuint)((shoveComponents[2] * 255)+0.5) <<  8) & 0x0000ff00;

+   ((GLuint *)packedPixel)[index]|=

+     ((GLuint)((shoveComponents[3] * 255)+0.5)	    ) & 0x000000ff;

+} /* shove8888() */

+

+static void extract8888rev(int isSwap,

+			   const void *packedPixel,GLfloat extractComponents[])

+{

+   GLuint uint;

+

+   if (isSwap) {

+     uint= __GLU_SWAP_4_BYTES(packedPixel);

+   }

+   else {

+     uint= *(const GLuint *)packedPixel;

+   }

+

+   /* 00000000,00000000,00000000,11111111 == 0x000000ff */

+   /* 00000000,00000000,11111111,00000000 == 0x0000ff00 */

+   /* 00000000,11111111,00000000,00000000 == 0x00ff0000 */

+   /* 11111111,00000000,00000000,00000000 == 0xff000000 */

+

+   /* 255 = 2^8-1 */

+   extractComponents[0]= (float)((uint & 0x000000FF)	  ) / 255.0;

+   extractComponents[1]= (float)((uint & 0x0000FF00) >>  8) / 255.0;

+   extractComponents[2]= (float)((uint & 0x00FF0000) >> 16) / 255.0;

+   extractComponents[3]= (float)((uint & 0xFF000000) >> 24) / 255.0;

+} /* extract8888rev() */

+

+static void shove8888rev(const GLfloat shoveComponents[],

+			 int index,void *packedPixel)

+{

+   /* 00000000,00000000,00000000,11111111 == 0x000000ff */

+   /* 00000000,00000000,11111111,00000000 == 0x0000ff00 */

+   /* 00000000,11111111,00000000,00000000 == 0x00ff0000 */

+   /* 11111111,00000000,00000000,00000000 == 0xff000000 */

+

+   assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);

+   assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);

+   assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);

+   assert(0.0 <= shoveComponents[3] && shoveComponents[3] <= 1.0);

+

+   /* due to limited precision, need to round before shoving */

+   ((GLuint *)packedPixel)[index] =

+     ((GLuint)((shoveComponents[0] * 255)+0.5)	    ) & 0x000000FF;

+   ((GLuint *)packedPixel)[index]|=

+     ((GLuint)((shoveComponents[1] * 255)+0.5) <<  8) & 0x0000FF00;

+   ((GLuint *)packedPixel)[index]|=

+     ((GLuint)((shoveComponents[2] * 255)+0.5) << 16) & 0x00FF0000;

+   ((GLuint *)packedPixel)[index]|=

+     ((GLuint)((shoveComponents[3] * 255)+0.5) << 24) & 0xFF000000;

+} /* shove8888rev() */

+

+static void extract1010102(int isSwap,

+			   const void *packedPixel,GLfloat extractComponents[])

+{

+   GLuint uint;

+

+   if (isSwap) {

+     uint= __GLU_SWAP_4_BYTES(packedPixel);

+   }

+   else {

+     uint= *(const GLuint *)packedPixel;

+   }

+

+   /* 11111111,11000000,00000000,00000000 == 0xffc00000 */

+   /* 00000000,00111111,11110000,00000000 == 0x003ff000 */

+   /* 00000000,00000000,00001111,11111100 == 0x00000ffc */

+   /* 00000000,00000000,00000000,00000011 == 0x00000003 */

+

+   /* 1023 = 2^10-1 */

+   extractComponents[0]= (float)((uint & 0xffc00000) >> 22) / 1023.0;

+   extractComponents[1]= (float)((uint & 0x003ff000) >> 12) / 1023.0;

+   extractComponents[2]= (float)((uint & 0x00000ffc) >>  2) / 1023.0;

+   extractComponents[3]= (float)((uint & 0x00000003)	  ) / 3.0;

+} /* extract1010102() */

+

+static void shove1010102(const GLfloat shoveComponents[],

+			 int index,void *packedPixel)

+{

+   /* 11111111,11000000,00000000,00000000 == 0xffc00000 */

+   /* 00000000,00111111,11110000,00000000 == 0x003ff000 */

+   /* 00000000,00000000,00001111,11111100 == 0x00000ffc */

+   /* 00000000,00000000,00000000,00000011 == 0x00000003 */

+

+   assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);

+   assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);

+   assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);

+   assert(0.0 <= shoveComponents[3] && shoveComponents[3] <= 1.0);

+

+   /* due to limited precision, need to round before shoving */

+   ((GLuint *)packedPixel)[index] =

+     ((GLuint)((shoveComponents[0] * 1023)+0.5) << 22) & 0xffc00000;

+   ((GLuint *)packedPixel)[index]|=

+     ((GLuint)((shoveComponents[1] * 1023)+0.5) << 12) & 0x003ff000;

+   ((GLuint *)packedPixel)[index]|=

+     ((GLuint)((shoveComponents[2] * 1023)+0.5) <<  2) & 0x00000ffc;

+   ((GLuint *)packedPixel)[index]|=

+     ((GLuint)((shoveComponents[3] * 3)+0.5)	     ) & 0x00000003;

+} /* shove1010102() */

+

+static void extract2101010rev(int isSwap,

+			      const void *packedPixel,

+			      GLfloat extractComponents[])

+{

+   GLuint uint;

+

+   if (isSwap) {

+     uint= __GLU_SWAP_4_BYTES(packedPixel);

+   }

+   else {

+     uint= *(const GLuint *)packedPixel;

+   }

+

+   /* 00000000,00000000,00000011,11111111 == 0x000003FF */

+   /* 00000000,00001111,11111100,00000000 == 0x000FFC00 */

+   /* 00111111,11110000,00000000,00000000 == 0x3FF00000 */

+   /* 11000000,00000000,00000000,00000000 == 0xC0000000 */

+

+   /* 1023 = 2^10-1 */

+   extractComponents[0]= (float)((uint & 0x000003FF)	  ) / 1023.0;

+   extractComponents[1]= (float)((uint & 0x000FFC00) >> 10) / 1023.0;

+   extractComponents[2]= (float)((uint & 0x3FF00000) >> 20) / 1023.0;

+   extractComponents[3]= (float)((uint & 0xC0000000) >> 30) / 3.0;

+   /* 3 = 2^2-1 */

+} /* extract2101010rev() */

+

+static void shove2101010rev(const GLfloat shoveComponents[],

+			    int index,void *packedPixel)

+{

+   /* 00000000,00000000,00000011,11111111 == 0x000003FF */

+   /* 00000000,00001111,11111100,00000000 == 0x000FFC00 */

+   /* 00111111,11110000,00000000,00000000 == 0x3FF00000 */

+   /* 11000000,00000000,00000000,00000000 == 0xC0000000 */

+

+   assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);

+   assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);

+   assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);

+   assert(0.0 <= shoveComponents[3] && shoveComponents[3] <= 1.0);

+

+   /* due to limited precision, need to round before shoving */

+   ((GLuint *)packedPixel)[index] =

+     ((GLuint)((shoveComponents[0] * 1023)+0.5)      ) & 0x000003FF;

+   ((GLuint *)packedPixel)[index]|=

+     ((GLuint)((shoveComponents[1] * 1023)+0.5) << 10) & 0x000FFC00;

+   ((GLuint *)packedPixel)[index]|=

+     ((GLuint)((shoveComponents[2] * 1023)+0.5) << 20) & 0x3FF00000;

+   ((GLuint *)packedPixel)[index]|=

+     ((GLuint)((shoveComponents[3] * 3)+0.5)	<< 30) & 0xC0000000;

+} /* shove2101010rev() */

+

+static void scaleInternalPackedPixel(int components,

+				     void (*extractPackedPixel)

+				     (int, const void *,GLfloat []),

+				     void (*shovePackedPixel)

+				     (const GLfloat [], int, void *),

+				     GLint widthIn,GLint heightIn,

+				     const void *dataIn,

+				     GLint widthOut,GLint heightOut,

+				     void *dataOut,

+				     GLint pixelSizeInBytes,

+				     GLint rowSizeInBytes,GLint isSwap)

+{

+    float convx;

+    float convy;

+    float percent;

+

+    /* Max components in a format is 4, so... */

+    float totals[4];

+    float extractTotals[4], extractMoreTotals[4], shoveTotals[4];

+

+    float area;

+    int i,j,k,xindex;

+

+    const char *temp, *temp0;

+    int outindex;

+

+    int lowx_int, highx_int, lowy_int, highy_int;

+    float x_percent, y_percent;

+    float lowx_float, highx_float, lowy_float, highy_float;

+    float convy_float, convx_float;

+    int convy_int, convx_int;

+    int l, m;

+    const char *left, *right;

+

+    if (widthIn == widthOut*2 && heightIn == heightOut*2) {

+	halveImagePackedPixel(components,extractPackedPixel,shovePackedPixel,

+			      widthIn, heightIn, dataIn, dataOut,

+			      pixelSizeInBytes,rowSizeInBytes,isSwap);

+	return;

+    }

+    convy = (float) heightIn/heightOut;

+    convx = (float) widthIn/widthOut;

+    convy_int = floor(convy);

+    convy_float = convy - convy_int;

+    convx_int = floor(convx);

+    convx_float = convx - convx_int;

+

+    area = convx * convy;

+

+    lowy_int = 0;

+    lowy_float = 0;

+    highy_int = convy_int;

+    highy_float = convy_float;

+

+    for (i = 0; i < heightOut; i++) {

+	lowx_int = 0;

+	lowx_float = 0;

+	highx_int = convx_int;

+	highx_float = convx_float;

+

+	for (j = 0; j < widthOut; j++) {

+	    /*

+	    ** Ok, now apply box filter to box that goes from (lowx, lowy)

+	    ** to (highx, highy) on input data into this pixel on output

+	    ** data.

+	    */

+	    totals[0] = totals[1] = totals[2] = totals[3] = 0.0;

+

+	    /* calculate the value for pixels in the 1st row */

+	    xindex = lowx_int*pixelSizeInBytes;

+	    if((highy_int>lowy_int) && (highx_int>lowx_int)) {

+

+		y_percent = 1-lowy_float;

+		temp = (const char *)dataIn + xindex + lowy_int * rowSizeInBytes;

+		percent = y_percent * (1-lowx_float);

+#if 0

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;

+		    } else {

+			totals[k] += *(const GLushort*)temp_index * percent;

+		    }

+		}

+#else

+		(*extractPackedPixel)(isSwap,temp,extractTotals);

+		for (k = 0; k < components; k++) {

+		   totals[k]+= extractTotals[k] * percent;

+		}

+#endif

+		left = temp;

+		for(l = lowx_int+1; l < highx_int; l++) {

+		    temp += pixelSizeInBytes;

+#if 0

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			if (myswap_bytes) {

+			    totals[k] +=

+				 __GLU_SWAP_2_BYTES(temp_index) * y_percent;

+			} else {

+			    totals[k] += *(const GLushort*)temp_index * y_percent;

+			}

+		    }

+#else

+		    (*extractPackedPixel)(isSwap,temp,extractTotals);

+		    for (k = 0; k < components; k++) {

+		       totals[k]+= extractTotals[k] * y_percent;

+		    }

+#endif

+		}

+		temp += pixelSizeInBytes;

+		right = temp;

+		percent = y_percent * highx_float;

+#if 0

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;

+		    } else {

+			totals[k] += *(const GLushort*)temp_index * percent;

+		    }

+		}

+#else

+		(*extractPackedPixel)(isSwap,temp,extractTotals);

+		for (k = 0; k < components; k++) {

+		   totals[k]+= extractTotals[k] * percent;

+		}

+#endif

+

+		/* calculate the value for pixels in the last row */

+	        

+		y_percent = highy_float;

+		percent = y_percent * (1-lowx_float);

+		temp = (const char *)dataIn + xindex + highy_int * rowSizeInBytes;

+#if 0

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;

+		    } else {

+			totals[k] += *(const GLushort*)temp_index * percent;

+		    }

+		}

+#else

+		(*extractPackedPixel)(isSwap,temp,extractTotals);

+		for (k = 0; k < components; k++) {

+		   totals[k]+= extractTotals[k] * percent;

+		}

+#endif

+		for(l = lowx_int+1; l < highx_int; l++) {

+		    temp += pixelSizeInBytes;

+#if 0

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			if (myswap_bytes) {

+			    totals[k] +=

+				 __GLU_SWAP_2_BYTES(temp_index) * y_percent;

+			} else {

+			    totals[k] += *(const GLushort*)temp_index * y_percent;

+			}

+		    }

+#else

+		    (*extractPackedPixel)(isSwap,temp,extractTotals);

+		    for (k = 0; k < components; k++) {

+		       totals[k]+= extractTotals[k] * y_percent;

+		    }

+#endif

+

+		}

+		temp += pixelSizeInBytes;

+		percent = y_percent * highx_float;

+#if 0

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;

+		    } else {

+			totals[k] += *(const GLushort*)temp_index * percent;

+		    }

+		}

+#else

+		(*extractPackedPixel)(isSwap,temp,extractTotals);

+		for (k = 0; k < components; k++) {

+		   totals[k]+= extractTotals[k] * percent;

+		}

+#endif

+

+		/* calculate the value for pixels in the 1st and last column */

+		for(m = lowy_int+1; m < highy_int; m++) {

+		    left += rowSizeInBytes;

+		    right += rowSizeInBytes;

+#if 0

+		    for (k = 0; k < components;

+			 k++, left += element_size, right += element_size) {

+			if (myswap_bytes) {

+			    totals[k] +=

+				__GLU_SWAP_2_BYTES(left) * (1-lowx_float) +

+				__GLU_SWAP_2_BYTES(right) * highx_float;

+			} else {

+			    totals[k] += *(const GLushort*)left * (1-lowx_float)

+				       + *(const GLushort*)right * highx_float;

+			}

+		    }

+#else

+		    (*extractPackedPixel)(isSwap,left,extractTotals);

+		    (*extractPackedPixel)(isSwap,right,extractMoreTotals);

+		    for (k = 0; k < components; k++) {

+		       totals[k]+= (extractTotals[k]*(1-lowx_float) +

+				   extractMoreTotals[k]*highx_float);

+		    }

+#endif

+		}

+	    } else if (highy_int > lowy_int) {

+		x_percent = highx_float - lowx_float;

+		percent = (1-lowy_float)*x_percent;

+		temp = (const char *)dataIn + xindex + lowy_int*rowSizeInBytes;

+#if 0

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;

+		    } else {

+			totals[k] += *(const GLushort*)temp_index * percent;

+		    }

+		}

+#else

+		(*extractPackedPixel)(isSwap,temp,extractTotals);

+		for (k = 0; k < components; k++) {

+		   totals[k]+= extractTotals[k] * percent;

+		}

+#endif

+		for(m = lowy_int+1; m < highy_int; m++) {

+		    temp += rowSizeInBytes;

+#if 0

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			if (myswap_bytes) {

+			    totals[k] +=

+				__GLU_SWAP_2_BYTES(temp_index) * x_percent;

+			} else {

+			    totals[k] += *(const GLushort*)temp_index * x_percent;

+			}

+		    }

+#else

+		    (*extractPackedPixel)(isSwap,temp,extractTotals);

+		    for (k = 0; k < components; k++) {

+		       totals[k]+= extractTotals[k] * x_percent;

+		    }

+#endif

+		}

+		percent = x_percent * highy_float;

+		temp += rowSizeInBytes;

+#if 0

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;

+		    } else {

+			totals[k] += *(const GLushort*)temp_index * percent;

+		    }

+		}

+#else

+		(*extractPackedPixel)(isSwap,temp,extractTotals);

+		for (k = 0; k < components; k++) {

+		   totals[k]+= extractTotals[k] * percent;

+		}

+#endif

+	    } else if (highx_int > lowx_int) {

+		y_percent = highy_float - lowy_float;

+		percent = (1-lowx_float)*y_percent;

+		temp = (const char *)dataIn + xindex + lowy_int*rowSizeInBytes;

+#if 0

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;

+		    } else {

+			totals[k] += *(const GLushort*)temp_index * percent;

+		    }

+		}

+#else

+		(*extractPackedPixel)(isSwap,temp,extractTotals);

+		for (k = 0; k < components; k++) {

+		   totals[k]+= extractTotals[k] * percent;

+		}

+#endif

+		for (l = lowx_int+1; l < highx_int; l++) {

+		    temp += pixelSizeInBytes;

+#if 0

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			if (myswap_bytes) {

+			    totals[k] +=

+				__GLU_SWAP_2_BYTES(temp_index) * y_percent;

+			} else {

+			    totals[k] += *(const GLushort*)temp_index * y_percent;

+			}

+		    }

+#else

+		(*extractPackedPixel)(isSwap,temp,extractTotals);

+		for (k = 0; k < components; k++) {

+		   totals[k]+= extractTotals[k] * y_percent;

+		}

+#endif

+		}

+		temp += pixelSizeInBytes;

+		percent = y_percent * highx_float;

+#if 0

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;

+		    } else {

+			totals[k] += *(const GLushort*)temp_index * percent;

+		    }

+		}

+#else

+		(*extractPackedPixel)(isSwap,temp,extractTotals);

+		for (k = 0; k < components; k++) {

+		   totals[k]+= extractTotals[k] * percent;

+		}

+#endif

+	    } else {

+		percent = (highy_float-lowy_float)*(highx_float-lowx_float);

+		temp = (const char *)dataIn + xindex + lowy_int * rowSizeInBytes;

+#if 0

+		for (k = 0, temp_index = temp; k < components;

+		     k++, temp_index += element_size) {

+		    if (myswap_bytes) {

+			totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;

+		    } else {

+			totals[k] += *(const GLushort*)temp_index * percent;

+		    }

+		}

+#else

+		(*extractPackedPixel)(isSwap,temp,extractTotals);

+		for (k = 0; k < components; k++) {

+		   totals[k]+= extractTotals[k] * percent;

+		}

+#endif

+	    }

+

+	    /* this is for the pixels in the body */

+	    temp0 = (const char *)dataIn + xindex + pixelSizeInBytes + (lowy_int+1)*rowSizeInBytes;

+	    for (m = lowy_int+1; m < highy_int; m++) {

+		temp = temp0;

+		for(l = lowx_int+1; l < highx_int; l++) {

+#if 0

+		    for (k = 0, temp_index = temp; k < components;

+			 k++, temp_index += element_size) {

+			if (myswap_bytes) {

+			    totals[k] += __GLU_SWAP_2_BYTES(temp_index);

+			} else {

+			    totals[k] += *(const GLushort*)temp_index;

+			}

+		    }

+#else

+		    (*extractPackedPixel)(isSwap,temp,extractTotals);

+		    for (k = 0; k < components; k++) {

+		       totals[k]+= extractTotals[k];

+		    }

+#endif

+		    temp += pixelSizeInBytes;

+		}

+		temp0 += rowSizeInBytes;

+	    }

+

+	    outindex = (j + (i * widthOut)); /* * (components == 1) */

+#if 0

+	    for (k = 0; k < components; k++) {

+		dataout[outindex + k] = totals[k]/area;

+		/*printf("totals[%d] = %f\n", k, totals[k]);*/

+	    }

+#else

+	    for (k = 0; k < components; k++) {

+		shoveTotals[k]= totals[k]/area;

+	    }

+	    (*shovePackedPixel)(shoveTotals,outindex,(void *)dataOut);

+#endif

+	    lowx_int = highx_int;

+	    lowx_float = highx_float;

+	    highx_int += convx_int;

+	    highx_float += convx_float;

+	    if(highx_float > 1) {

+		highx_float -= 1.0;

+		highx_int++;

+	    }

+	}

+	lowy_int = highy_int;

+	lowy_float = highy_float;

+	highy_int += convy_int;

+	highy_float += convy_float;

+	if(highy_float > 1) {

+	    highy_float -= 1.0;

+	    highy_int++;

+	}

+    }

+

+    assert(outindex == (widthOut*heightOut - 1));

+} /* scaleInternalPackedPixel() */

+

+/* rowSizeInBytes is at least the width (in bytes) due to padding on

+ *  inputs; not always equal. Output NEVER has row padding.

+ */

+static void halveImagePackedPixel(int components,

+				  void (*extractPackedPixel)

+				  (int, const void *,GLfloat []),

+				  void (*shovePackedPixel)

+				  (const GLfloat [],int, void *),

+				  GLint width, GLint height,

+				  const void *dataIn, void *dataOut,

+				  GLint pixelSizeInBytes,

+				  GLint rowSizeInBytes, GLint isSwap)

+{

+   /* handle case where there is only 1 column/row */

+   if (width == 1 || height == 1) {

+      assert(!(width == 1 && height == 1)); /* can't be 1x1 */

+      halve1DimagePackedPixel(components,extractPackedPixel,shovePackedPixel,

+			      width,height,dataIn,dataOut,pixelSizeInBytes,

+			      rowSizeInBytes,isSwap);

+      return;

+   }

+

+   {

+      int ii, jj;

+

+      int halfWidth= width / 2;

+      int halfHeight= height / 2;

+      const char *src= (const char *) dataIn;

+      int padBytes= rowSizeInBytes - (width*pixelSizeInBytes);

+      int outIndex= 0;

+

+      for (ii= 0; ii< halfHeight; ii++) {

+	 for (jj= 0; jj< halfWidth; jj++) {

+#define BOX4 4

+	    float totals[4];	/* 4 is maximum components */

+	    float extractTotals[BOX4][4]; /* 4 is maximum components */

+	    int cc;

+

+	    (*extractPackedPixel)(isSwap,src,

+				  &extractTotals[0][0]);

+	    (*extractPackedPixel)(isSwap,(src+pixelSizeInBytes),

+				  &extractTotals[1][0]);

+	    (*extractPackedPixel)(isSwap,(src+rowSizeInBytes),

+				  &extractTotals[2][0]);

+	    (*extractPackedPixel)(isSwap,

+				  (src+rowSizeInBytes+pixelSizeInBytes),

+				  &extractTotals[3][0]);

+	    for (cc = 0; cc < components; cc++) {

+	       int kk;

+

+	       /* grab 4 pixels to average */

+	       totals[cc]= 0.0;

+	       /* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED]+

+		*	       extractTotals[2][RED]+extractTotals[3][RED];

+		* totals[RED]/= 4.0;

+		*/

+	       for (kk = 0; kk < BOX4; kk++) {

+		  totals[cc]+= extractTotals[kk][cc];

+	       }

+	       totals[cc]/= (float)BOX4;

+	    }

+	    (*shovePackedPixel)(totals,outIndex,dataOut);

+

+	    outIndex++;

+	    /* skip over to next square of 4 */

+	    src+= pixelSizeInBytes + pixelSizeInBytes;

+	 }

+	 /* skip past pad bytes, if any, to get to next row */

+	 src+= padBytes;

+

+	 /* src is at beginning of a row here, but it's the second row of

+	  * the square block of 4 pixels that we just worked on so we

+	  * need to go one more row.

+	  * i.e.,

+	  *		      OO...

+	  *	      here -->OO...

+	  *	  but want -->OO...

+	  *		      OO...

+	  *		      ...

+	  */

+	 src+= rowSizeInBytes;

+      }

+

+      /* both pointers must reach one byte after the end */

+      assert(src == &((const char *)dataIn)[rowSizeInBytes*height]);

+      assert(outIndex == halfWidth * halfHeight);

+   }

+} /* halveImagePackedPixel() */

+

+static void halve1DimagePackedPixel(int components,

+				    void (*extractPackedPixel)

+				    (int, const void *,GLfloat []),

+				    void (*shovePackedPixel)

+				    (const GLfloat [],int, void *),

+				    GLint width, GLint height,

+				    const void *dataIn, void *dataOut,

+				    GLint pixelSizeInBytes,

+				    GLint rowSizeInBytes, GLint isSwap)

+{

+   int halfWidth= width / 2;

+   int halfHeight= height / 2;

+   const char *src= (const char *) dataIn;

+   int jj;

+

+   assert(width == 1 || height == 1); /* must be 1D */

+   assert(width != height);	/* can't be square */

+

+   if (height == 1) {	/* 1 row */

+      int outIndex= 0;

+

+      assert(width != 1);	/* widthxheight can't be 1x1 */

+      halfHeight= 1;

+

+      /* one horizontal row with possible pad bytes */

+

+      for (jj= 0; jj< halfWidth; jj++) {

+#define BOX2 2

+	 float totals[4];	/* 4 is maximum components */

+	 float extractTotals[BOX2][4]; /* 4 is maximum components */

+	 int cc;

+

+	 /* average two at a time, instead of four */

+	 (*extractPackedPixel)(isSwap,src,

+			       &extractTotals[0][0]);

+	 (*extractPackedPixel)(isSwap,(src+pixelSizeInBytes),

+			       &extractTotals[1][0]);		        

+	 for (cc = 0; cc < components; cc++) {

+	    int kk;

+

+	    /* grab 2 pixels to average */

+	    totals[cc]= 0.0;

+	    /* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED];

+	     * totals[RED]/= 2.0;

+	     */

+	    for (kk = 0; kk < BOX2; kk++) {

+	       totals[cc]+= extractTotals[kk][cc];

+	    }

+	    totals[cc]/= (float)BOX2;

+	 }

+	 (*shovePackedPixel)(totals,outIndex,dataOut);

+

+	 outIndex++;

+	 /* skip over to next group of 2 */

+	 src+= pixelSizeInBytes + pixelSizeInBytes;

+      }

+

+      {

+	 int padBytes= rowSizeInBytes - (width*pixelSizeInBytes);

+	 src+= padBytes;	/* for assertion only */

+      }

+      assert(src == &((const char *)dataIn)[rowSizeInBytes]);

+      assert(outIndex == halfWidth * halfHeight);

+   }

+   else if (width == 1) { /* 1 column */

+      int outIndex= 0;

+

+      assert(height != 1);	/* widthxheight can't be 1x1 */

+      halfWidth= 1;

+      /* one vertical column with possible pad bytes per row */

+      /* average two at a time */

+

+      for (jj= 0; jj< halfHeight; jj++) {

+#define BOX2 2

+	 float totals[4];	/* 4 is maximum components */

+	 float extractTotals[BOX2][4]; /* 4 is maximum components */

+	 int cc;

+

+	 /* average two at a time, instead of four */

+	 (*extractPackedPixel)(isSwap,src,

+			       &extractTotals[0][0]);

+	 (*extractPackedPixel)(isSwap,(src+rowSizeInBytes),

+			       &extractTotals[1][0]);		        

+	 for (cc = 0; cc < components; cc++) {

+	    int kk;

+

+	    /* grab 2 pixels to average */

+	    totals[cc]= 0.0;

+	    /* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED];

+	     * totals[RED]/= 2.0;

+	     */

+	    for (kk = 0; kk < BOX2; kk++) {

+	       totals[cc]+= extractTotals[kk][cc];

+	    }

+	    totals[cc]/= (float)BOX2;

+	 }

+	 (*shovePackedPixel)(totals,outIndex,dataOut);

+

+	 outIndex++;

+	 src+= rowSizeInBytes + rowSizeInBytes; /* go to row after next */

+      }

+

+      assert(src == &((const char *)dataIn)[rowSizeInBytes*height]);

+      assert(outIndex == halfWidth * halfHeight);

+   }

+} /* halve1DimagePackedPixel() */

+

+/*===========================================================================*/

+

+#ifdef RESOLVE_3D_TEXTURE_SUPPORT

+/*

+ * This section ensures that GLU 1.3 will load and run on

+ * a GL 1.1 implementation. It dynamically resolves the

+ * call to glTexImage3D() which might not be available.

+ * Or is it might be supported as an extension.

+ * Contributed by Gerk Huisma <gerk@five-d.demon.nl>.

+ */

+

+typedef void (GLAPIENTRY *TexImage3Dproc)( GLenum target, GLint level,

+						 GLenum internalFormat,

+						 GLsizei width, GLsizei height,

+						 GLsizei depth, GLint border,

+						 GLenum format, GLenum type,

+						 const GLvoid *pixels );

+

+static TexImage3Dproc pTexImage3D = 0;

+

+#if !defined(_WIN32) && !defined(__WIN32__)

+#  include <dlfcn.h>

+#  include <sys/types.h>

+#else

+#  include <windows.h>

+#endif

+

+static void gluTexImage3D( GLenum target, GLint level,

+			   GLenum internalFormat,

+			   GLsizei width, GLsizei height,

+			   GLsizei depth, GLint border,

+			   GLenum format, GLenum type,

+			   const GLvoid *pixels )

+{

+   if (!pTexImage3D) {

+#if defined(_WIN32) || defined(__WIN32__)

+      pTexImage3D = (TexImage3Dproc) wglGetProcAddress("glTexImage3D");

+      if (!pTexImage3D)

+	 pTexImage3D = (TexImage3Dproc) wglGetProcAddress("glTexImage3DEXT");

+#else

+      void *libHandle = dlopen("libgl.so", RTLD_LAZY);

+      pTexImage3D = (TexImage3Dproc) dlsym(libHandle, "glTexImage3D" );

+      if (!pTexImage3D)

+	 pTexImage3D = (TexImage3Dproc) dlsym(libHandle,"glTexImage3DEXT");

+      dlclose(libHandle);

+#endif

+   }

+

+   /* Now call glTexImage3D */

+   if (pTexImage3D)

+      pTexImage3D(target, level, internalFormat, width, height,

+		  depth, border, format, type, pixels);

+}

+

+#else

+

+/* Only bind to a GL 1.2 implementation: */

+#define gluTexImage3D glTexImage3D

+

+#endif

+

+static GLint imageSize3D(GLint width, GLint height, GLint depth,

+			 GLenum format, GLenum type)

+{

+    int components= elements_per_group(format,type);

+    int bytes_per_row=	bytes_per_element(type) * width;

+

+assert(width > 0 && height > 0 && depth > 0);

+assert(type != GL_BITMAP);

+

+    return bytes_per_row * height * depth * components;

+} /* imageSize3D() */

+

+static void fillImage3D(const PixelStorageModes *psm,

+			GLint width, GLint height, GLint depth, GLenum format,

+			GLenum type, GLboolean indexFormat,

+			const void *userImage, GLushort *newImage)

+{

+   int myswapBytes;

+   int components;

+   int groupsPerLine;

+   int elementSize;

+   int groupSize;

+   int rowSize;

+   int padding;

+   int elementsPerLine;

+   int rowsPerImage;

+   int imageSize;

+   const GLubyte *start, *rowStart, *iter;

+   GLushort *iter2;

+   int ww, hh, dd, k;

+

+   myswapBytes= psm->unpack_swap_bytes;

+   components= elements_per_group(format,type);

+   if (psm->unpack_row_length > 0) {

+      groupsPerLine= psm->unpack_row_length;

+   }

+   else {

+      groupsPerLine= width;

+   }

+   elementSize= bytes_per_element(type);

+   groupSize= elementSize * components;

+   if (elementSize == 1) myswapBytes= 0;

+

+   /* 3dstuff begin */

+   if (psm->unpack_image_height > 0) {

+      rowsPerImage= psm->unpack_image_height;

+   }

+   else {

+      rowsPerImage= height;

+   }

+   /* 3dstuff end */

+

+   rowSize= groupsPerLine * groupSize;

+   padding= rowSize % psm->unpack_alignment;

+   if (padding) {

+      rowSize+= psm->unpack_alignment - padding;

+   }

+

+   imageSize= rowsPerImage * rowSize; /* 3dstuff */

+

+   start= (const GLubyte *)userImage + psm->unpack_skip_rows * rowSize +

+				 psm->unpack_skip_pixels * groupSize +

+				 /*3dstuff*/

+				 psm->unpack_skip_images * imageSize;

+   elementsPerLine = width * components;

+

+   iter2= newImage;

+   for (dd= 0; dd < depth; dd++) {

+      rowStart= start;

+

+      for (hh= 0; hh < height; hh++) {

+	 iter= rowStart;

+

+	 for (ww= 0; ww < elementsPerLine; ww++) {

+	    Type_Widget widget;

+	    float extractComponents[4];

+

+	    switch(type) {

+	    case GL_UNSIGNED_BYTE:

+	      if (indexFormat) {

+		  *iter2++ = *iter;

+	      } else {

+		  *iter2++ = (*iter) * 257;

+	      }

+	      break;

+	    case GL_BYTE:

+	      if (indexFormat) {

+		  *iter2++ = *((const GLbyte *) iter);

+	      } else {

+		  /* rough approx */

+		  *iter2++ = (*((const GLbyte *) iter)) * 516;

+	      }

+	      break;

+	    case GL_UNSIGNED_BYTE_3_3_2:

+	      extract332(0,iter,extractComponents);

+	      for (k = 0; k < 3; k++) {

+		*iter2++ = (GLushort)(extractComponents[k]*65535);

+	      }

+	      break;

+	    case GL_UNSIGNED_BYTE_2_3_3_REV:

+	      extract233rev(0,iter,extractComponents);

+	      for (k = 0; k < 3; k++) {

+		*iter2++ = (GLushort)(extractComponents[k]*65535);

+	      }

+	      break;

+	    case GL_UNSIGNED_SHORT_5_6_5:			        

+	      extract565(myswapBytes,iter,extractComponents);

+	      for (k = 0; k < 3; k++) {

+		*iter2++ = (GLushort)(extractComponents[k]*65535);

+	      }

+	      break;

+	    case GL_UNSIGNED_SHORT_5_6_5_REV:			        

+	      extract565rev(myswapBytes,iter,extractComponents);

+	      for (k = 0; k < 3; k++) {

+		*iter2++ = (GLushort)(extractComponents[k]*65535);

+	      }

+	      break;

+	    case GL_UNSIGNED_SHORT_4_4_4_4:	        

+	      extract4444(myswapBytes,iter,extractComponents);

+	      for (k = 0; k < 4; k++) {

+		*iter2++ = (GLushort)(extractComponents[k]*65535);

+	      }

+	      break;

+	    case GL_UNSIGNED_SHORT_4_4_4_4_REV:         

+	      extract4444rev(myswapBytes,iter,extractComponents);

+	      for (k = 0; k < 4; k++) {

+		*iter2++ = (GLushort)(extractComponents[k]*65535);

+	      }

+	      break;

+	    case GL_UNSIGNED_SHORT_5_5_5_1:	        

+	      extract5551(myswapBytes,iter,extractComponents);

+	      for (k = 0; k < 4; k++) {

+		*iter2++ = (GLushort)(extractComponents[k]*65535);

+	      }

+	      break;

+	    case GL_UNSIGNED_SHORT_1_5_5_5_REV:

+	      extract1555rev(myswapBytes,iter,extractComponents);

+	      for (k = 0; k < 4; k++) {

+		*iter2++ = (GLushort)(extractComponents[k]*65535);

+	      }

+	      break;

+	    case GL_UNSIGNED_SHORT:

+	    case GL_SHORT:

+	      if (myswapBytes) {

+		  widget.ub[0] = iter[1];

+		  widget.ub[1] = iter[0];

+	      } else {

+		  widget.ub[0] = iter[0];

+		  widget.ub[1] = iter[1];

+	      }

+	      if (type == GL_SHORT) {

+		  if (indexFormat) {

+		      *iter2++ = widget.s[0];

+		  } else {

+		      /* rough approx */

+		      *iter2++ = widget.s[0]*2;

+		  }

+	      } else {

+		  *iter2++ = widget.us[0];

+	      }

+	      break;

+	    case GL_UNSIGNED_INT_8_8_8_8:	        

+	      extract8888(myswapBytes,iter,extractComponents);

+	      for (k = 0; k < 4; k++) {

+		*iter2++ = (GLushort)(extractComponents[k]*65535);

+	      }

+	      break;

+	    case GL_UNSIGNED_INT_8_8_8_8_REV:	        

+	      extract8888rev(myswapBytes,iter,extractComponents);

+	      for (k = 0; k < 4; k++) {

+		*iter2++ = (GLushort)(extractComponents[k]*65535);

+	      }

+	      break;

+	    case GL_UNSIGNED_INT_10_10_10_2:	        

+	      extract1010102(myswapBytes,iter,extractComponents);

+	      for (k = 0; k < 4; k++) {

+		*iter2++ = (GLushort)(extractComponents[k]*65535);

+	      }

+	      break;

+	    case GL_UNSIGNED_INT_2_10_10_10_REV:

+	      extract2101010rev(myswapBytes,iter,extractComponents);

+	      for (k = 0; k < 4; k++) {

+		*iter2++ = (GLushort)(extractComponents[k]*65535);

+	      }

+	      break;

+	    case GL_INT:

+	    case GL_UNSIGNED_INT:

+	    case GL_FLOAT:

+	      if (myswapBytes) {

+		  widget.ub[0] = iter[3];

+		  widget.ub[1] = iter[2];

+		  widget.ub[2] = iter[1];

+		  widget.ub[3] = iter[0];

+	      } else {

+		  widget.ub[0] = iter[0];

+		  widget.ub[1] = iter[1];

+		  widget.ub[2] = iter[2];

+		  widget.ub[3] = iter[3];

+	      }

+	      if (type == GL_FLOAT) {

+		  if (indexFormat) {

+		      *iter2++ = widget.f;

+		  } else {

+		      *iter2++ = 65535 * widget.f;

+		  }

+	      } else if (type == GL_UNSIGNED_INT) {

+		  if (indexFormat) {

+		      *iter2++ = widget.ui;

+		  } else {

+		      *iter2++ = widget.ui >> 16;

+		  }

+	      } else {

+		  if (indexFormat) {

+		      *iter2++ = widget.i;

+		  } else {

+		      *iter2++ = widget.i >> 15;

+		  }

+	      }

+	      break;

+	    default:

+	      assert(0);

+	    }

+

+	    iter+= elementSize;

+	 } /* for ww */

+	 rowStart+= rowSize;

+

+	 iter= rowStart;	/* for assertion purposes */

+      } /* for hh */

+

+      start+= imageSize;

+   } /* for dd */

+

+   /* iterators should be one byte past end */

+   if (!isTypePackedPixel(type)) {

+      assert(iter2 == &newImage[width*height*depth*components]);

+   }

+   else {

+      assert(iter2 == &newImage[width*height*depth*

+				elements_per_group(format,0)]);

+   }

+   assert( iter == &((const GLubyte *)userImage)[rowSize*height*depth +

+					psm->unpack_skip_rows * rowSize +

+					psm->unpack_skip_pixels * groupSize +

+					/*3dstuff*/

+					psm->unpack_skip_images * imageSize] );

+} /* fillImage3D () */

+

+static void scaleInternal3D(GLint components,

+			    GLint widthIn, GLint heightIn, GLint depthIn,

+			    const GLushort *dataIn,

+			    GLint widthOut, GLint heightOut, GLint depthOut,

+			    GLushort *dataOut)

+{

+    float x, lowx, highx, convx, halfconvx;

+    float y, lowy, highy, convy, halfconvy;

+    float z, lowz, highz, convz, halfconvz;

+    float xpercent,ypercent,zpercent;

+    float percent;

+    /* Max components in a format is 4, so... */

+    float totals[4];

+    float volume;

+    int i,j,d,k,zint,yint,xint,xindex,yindex,zindex;

+    int temp;

+

+    convz = (float) depthIn/depthOut;

+    convy = (float) heightIn/heightOut;

+    convx = (float) widthIn/widthOut;

+    halfconvx = convx/2;

+    halfconvy = convy/2;

+    halfconvz = convz/2;

+    for (d = 0; d < depthOut; d++) {

+       z = convz * (d+0.5);

+       if (depthIn > depthOut) {

+	   highz = z + halfconvz;

+	   lowz = z - halfconvz;

+       } else {

+	   highz = z + 0.5;

+	   lowz = z - 0.5;

+       }

+       for (i = 0; i < heightOut; i++) {

+	   y = convy * (i+0.5);

+	   if (heightIn > heightOut) {

+	       highy = y + halfconvy;

+	       lowy = y - halfconvy;

+	   } else {

+	       highy = y + 0.5;

+	       lowy = y - 0.5;

+	   }

+	   for (j = 0; j < widthOut; j++) {

+	       x = convx * (j+0.5);

+	       if (widthIn > widthOut) {

+		   highx = x + halfconvx;

+		   lowx = x - halfconvx;

+	       } else {

+		   highx = x + 0.5;

+		   lowx = x - 0.5;

+	       }

+

+	       /*

+	       ** Ok, now apply box filter to box that goes from (lowx, lowy,

+	       ** lowz) to (highx, highy, highz) on input data into this pixel

+	       ** on output data.

+	       */

+	       totals[0] = totals[1] = totals[2] = totals[3] = 0.0;

+	       volume = 0.0;

+

+	       z = lowz;

+	       zint = floor(z);

+	       while (z < highz) {

+		  zindex = (zint + depthIn) % depthIn;

+		  if (highz < zint+1) {

+		      zpercent = highz - z;

+		  } else {

+		      zpercent = zint+1 - z;

+		  }

+

+		  y = lowy;

+		  yint = floor(y);

+		  while (y < highy) {

+		      yindex = (yint + heightIn) % heightIn;

+		      if (highy < yint+1) {

+			  ypercent = highy - y;

+		      } else {

+			  ypercent = yint+1 - y;

+		      }

+

+		      x = lowx;

+		      xint = floor(x);

+

+		      while (x < highx) {

+			  xindex = (xint + widthIn) % widthIn;

+			  if (highx < xint+1) {

+			      xpercent = highx - x;

+			  } else {

+			      xpercent = xint+1 - x;

+			  }

+

+			  percent = xpercent * ypercent * zpercent;

+			  volume += percent;

+

+			  temp = (xindex + (yindex*widthIn) +

+				  (zindex*widthIn*heightIn)) * components;

+			  for (k = 0; k < components; k++) {

+			      assert(0 <= (temp+k) &&

+				     (temp+k) <

+				     (widthIn*heightIn*depthIn*components));

+			      totals[k] += dataIn[temp + k] * percent;

+			  }

+

+			  xint++;

+			  x = xint;

+		      } /* while x */

+

+		      yint++;

+		      y = yint;

+		  } /* while y */

+

+		  zint++;

+		  z = zint;

+	       } /* while z */

+

+	       temp = (j + (i * widthOut) +

+		       (d*widthOut*heightOut)) * components;

+	       for (k = 0; k < components; k++) {

+		   /* totals[] should be rounded in the case of enlarging an

+		    * RGB ramp when the type is 332 or 4444

+		    */

+		   assert(0 <= (temp+k) &&

+			  (temp+k) < (widthOut*heightOut*depthOut*components));

+		   dataOut[temp + k] = (totals[k]+0.5)/volume;

+	       }

+	   } /* for j */

+       } /* for i */

+    } /* for d */

+} /* scaleInternal3D() */

+

+static void emptyImage3D(const PixelStorageModes *psm,

+			 GLint width, GLint height, GLint depth,

+			 GLenum format, GLenum type, GLboolean indexFormat,

+			 const GLushort *oldImage, void *userImage)

+{

+   int myswapBytes;

+   int components;

+   int groupsPerLine;

+   int elementSize;

+   int groupSize;

+   int rowSize;

+   int padding;

+   GLubyte *start, *rowStart, *iter;

+   int elementsPerLine;

+   const GLushort *iter2;

+   int ii, jj, dd, k;

+   int rowsPerImage;

+   int imageSize;

+

+   myswapBytes= psm->pack_swap_bytes;

+   components = elements_per_group(format,type);

+   if (psm->pack_row_length > 0) {

+      groupsPerLine = psm->pack_row_length;

+   }

+   else {

+      groupsPerLine = width;

+   }

+

+   elementSize= bytes_per_element(type);

+   groupSize= elementSize * components;

+   if (elementSize == 1) myswapBytes= 0;

+

+   /* 3dstuff begin */

+   if (psm->pack_image_height > 0) {

+      rowsPerImage= psm->pack_image_height;

+   }

+   else {

+      rowsPerImage= height;

+   }

+

+   /* 3dstuff end */

+

+   rowSize = groupsPerLine * groupSize;

+   padding = rowSize % psm->pack_alignment;

+   if (padding) {

+      rowSize+= psm->pack_alignment - padding;

+   }

+

+   imageSize= rowsPerImage * rowSize; /* 3dstuff */

+

+   start = (GLubyte *)userImage + psm->pack_skip_rows * rowSize +

+				  psm->pack_skip_pixels * groupSize +

+				  /*3dstuff*/

+				  psm->pack_skip_images * imageSize;

+   elementsPerLine= width * components;

+

+   iter2 = oldImage;

+   for (dd= 0; dd < depth; dd++) {

+      rowStart= start;

+

+      for (ii= 0; ii< height; ii++) {

+	 iter = rowStart;

+

+	 for (jj = 0; jj < elementsPerLine; jj++) {

+	    Type_Widget widget;

+	    float shoveComponents[4];

+

+	    switch(type){

+	    case GL_UNSIGNED_BYTE:

+	      if (indexFormat) {

+		  *iter = *iter2++;

+	      } else {

+		  *iter = *iter2++ >> 8;

+	      }

+	      break;

+	    case GL_BYTE:

+	      if (indexFormat) {

+		  *((GLbyte *) iter) = *iter2++;

+	      } else {

+		  *((GLbyte *) iter) = *iter2++ >> 9;

+	      }

+	      break;

+	    case GL_UNSIGNED_BYTE_3_3_2:

+	      for (k = 0; k < 3; k++) {

+		 shoveComponents[k]= *iter2++ / 65535.0;

+	      }

+	      shove332(shoveComponents,0,(void *)iter);

+	      break;

+	    case GL_UNSIGNED_BYTE_2_3_3_REV:

+	      for (k = 0; k < 3; k++) {

+		 shoveComponents[k]= *iter2++ / 65535.0;

+	      }

+	      shove233rev(shoveComponents,0,(void *)iter);

+	      break;

+	    case GL_UNSIGNED_SHORT_5_6_5:	        

+	      for (k = 0; k < 3; k++) {

+		 shoveComponents[k]= *iter2++ / 65535.0;

+	      }

+	      shove565(shoveComponents,0,(void *)&widget.us[0]);

+	      if (myswapBytes) {

+		 iter[0] = widget.ub[1];

+		 iter[1] = widget.ub[0];

+	      }

+	      else {

+		 *(GLushort *)iter = widget.us[0];

+	      }

+	      break;

+	    case GL_UNSIGNED_SHORT_5_6_5_REV:	        

+	      for (k = 0; k < 3; k++) {

+		 shoveComponents[k]= *iter2++ / 65535.0;

+	      }

+	      shove565rev(shoveComponents,0,(void *)&widget.us[0]);

+	      if (myswapBytes) {

+		 iter[0] = widget.ub[1];

+		 iter[1] = widget.ub[0];

+	      }

+	      else {

+		 *(GLushort *)iter = widget.us[0];

+	      }

+	      break;

+	    case GL_UNSIGNED_SHORT_4_4_4_4:

+	      for (k = 0; k < 4; k++) {

+		 shoveComponents[k]= *iter2++ / 65535.0;

+	      }

+	      shove4444(shoveComponents,0,(void *)&widget.us[0]);

+	      if (myswapBytes) {

+		 iter[0] = widget.ub[1];

+		 iter[1] = widget.ub[0];

+	      } else {

+		 *(GLushort *)iter = widget.us[0];

+	      }

+	      break;

+	    case GL_UNSIGNED_SHORT_4_4_4_4_REV:

+	      for (k = 0; k < 4; k++) {

+		 shoveComponents[k]= *iter2++ / 65535.0;

+	      }

+	      shove4444rev(shoveComponents,0,(void *)&widget.us[0]);

+	      if (myswapBytes) {

+		 iter[0] = widget.ub[1];

+		 iter[1] = widget.ub[0];

+	      } else {

+		 *(GLushort *)iter = widget.us[0];

+	      }

+	      break;

+	    case GL_UNSIGNED_SHORT_5_5_5_1:

+	      for (k = 0; k < 4; k++) {

+		 shoveComponents[k]= *iter2++ / 65535.0;

+	      }

+	      shove5551(shoveComponents,0,(void *)&widget.us[0]);

+	      if (myswapBytes) {

+		 iter[0] = widget.ub[1];

+		 iter[1] = widget.ub[0];

+	      } else {

+		 *(GLushort *)iter = widget.us[0];

+	      }

+	      break;

+	    case GL_UNSIGNED_SHORT_1_5_5_5_REV:

+	      for (k = 0; k < 4; k++) {

+		 shoveComponents[k]= *iter2++ / 65535.0;

+	      }

+	      shove1555rev(shoveComponents,0,(void *)&widget.us[0]);

+	      if (myswapBytes) {

+		 iter[0] = widget.ub[1];

+		 iter[1] = widget.ub[0];

+	      } else {

+		 *(GLushort *)iter = widget.us[0];

+	      }

+	      break;

+	    case GL_UNSIGNED_SHORT:

+	    case GL_SHORT:

+	      if (type == GL_SHORT) {

+		  if (indexFormat) {

+		      widget.s[0] = *iter2++;

+		  } else {

+		      widget.s[0] = *iter2++ >> 1;

+		  }

+	      } else {

+		  widget.us[0] = *iter2++;

+	      }

+	      if (myswapBytes) {

+		  iter[0] = widget.ub[1];

+		  iter[1] = widget.ub[0];

+	      } else {

+		  iter[0] = widget.ub[0];

+		  iter[1] = widget.ub[1];

+	      }

+	      break;

+	    case GL_UNSIGNED_INT_8_8_8_8:

+	       for (k = 0; k < 4; k++) {

+		  shoveComponents[k]= *iter2++ / 65535.0;

+	       }

+	       shove8888(shoveComponents,0,(void *)&widget.ui);

+	       if (myswapBytes) {

+		   iter[3] = widget.ub[0];

+		   iter[2] = widget.ub[1];

+		   iter[1] = widget.ub[2];

+		   iter[0] = widget.ub[3];

+	       } else {

+		   *(GLuint *)iter= widget.ui;

+	       }

+	       break;

+	    case GL_UNSIGNED_INT_8_8_8_8_REV:

+	       for (k = 0; k < 4; k++) {

+		  shoveComponents[k]= *iter2++ / 65535.0;

+	       }

+	       shove8888rev(shoveComponents,0,(void *)&widget.ui);

+	       if (myswapBytes) {

+		   iter[3] = widget.ub[0];

+		   iter[2] = widget.ub[1];

+		   iter[1] = widget.ub[2];

+		   iter[0] = widget.ub[3];

+	       } else {

+		   *(GLuint *)iter= widget.ui;

+	       }

+	       break;

+	    case GL_UNSIGNED_INT_10_10_10_2:

+	       for (k = 0; k < 4; k++) {

+		  shoveComponents[k]= *iter2++ / 65535.0;

+	       }

+	       shove1010102(shoveComponents,0,(void *)&widget.ui);

+	       if (myswapBytes) {

+		   iter[3] = widget.ub[0];

+		   iter[2] = widget.ub[1];

+		   iter[1] = widget.ub[2];

+		   iter[0] = widget.ub[3];

+	       } else {

+		   *(GLuint *)iter= widget.ui;

+	       }

+	       break;

+	    case GL_UNSIGNED_INT_2_10_10_10_REV:

+	       for (k = 0; k < 4; k++) {

+		  shoveComponents[k]= *iter2++ / 65535.0;

+	       }

+	       shove2101010rev(shoveComponents,0,(void *)&widget.ui);

+	       if (myswapBytes) {

+		   iter[3] = widget.ub[0];

+		   iter[2] = widget.ub[1];

+		   iter[1] = widget.ub[2];

+		   iter[0] = widget.ub[3];

+	       } else {

+		   *(GLuint *)iter= widget.ui;

+	       }

+	       break;

+	    case GL_INT:

+	    case GL_UNSIGNED_INT:

+	    case GL_FLOAT:

+	      if (type == GL_FLOAT) {

+		  if (indexFormat) {

+		      widget.f = *iter2++;

+		  } else {

+		      widget.f = *iter2++ / (float) 65535.0;

+		  }

+	      } else if (type == GL_UNSIGNED_INT) {

+		  if (indexFormat) {

+		      widget.ui = *iter2++;

+		  } else {

+		      widget.ui = (unsigned int) *iter2++ * 65537;

+		  }

+	      } else {

+		  if (indexFormat) {

+		      widget.i = *iter2++;

+		  } else {

+		      widget.i = ((unsigned int) *iter2++ * 65537)/2;

+		  }

+	      }

+	      if (myswapBytes) {

+		  iter[3] = widget.ub[0];

+		  iter[2] = widget.ub[1];

+		  iter[1] = widget.ub[2];

+		  iter[0] = widget.ub[3];

+	      } else {

+		  iter[0] = widget.ub[0];

+		  iter[1] = widget.ub[1];

+		  iter[2] = widget.ub[2];

+		  iter[3] = widget.ub[3];

+	      }

+	      break;

+	    default:

+	       assert(0);

+	    }

+

+	    iter+= elementSize;

+	 }  /* for jj */

+

+	 rowStart+= rowSize;

+      } /* for ii */

+

+      start+= imageSize;

+   } /* for dd */

+

+   /* iterators should be one byte past end */

+   if (!isTypePackedPixel(type)) {

+      assert(iter2 == &oldImage[width*height*depth*components]);

+   }

+   else {

+      assert(iter2 == &oldImage[width*height*depth*

+				elements_per_group(format,0)]);

+   }

+   assert( iter == &((GLubyte *)userImage)[rowSize*height*depth +

+					psm->unpack_skip_rows * rowSize +

+					psm->unpack_skip_pixels * groupSize +

+					/*3dstuff*/

+					psm->unpack_skip_images * imageSize] );

+} /* emptyImage3D() */

+

+static

+int gluScaleImage3D(GLenum format,

+		    GLint widthIn, GLint heightIn, GLint depthIn,

+		    GLenum typeIn, const void *dataIn,

+		    GLint widthOut, GLint heightOut, GLint depthOut,

+		    GLenum typeOut, void *dataOut)

+{

+   int components;

+   GLushort *beforeImage, *afterImage;

+   PixelStorageModes psm;

+

+   if (widthIn == 0 || heightIn == 0 || depthIn == 0 ||

+       widthOut == 0 || heightOut == 0 || depthOut == 0) {

+      return 0;

+   }

+

+   if (widthIn < 0 || heightIn < 0 || depthIn < 0 ||

+       widthOut < 0 || heightOut < 0 || depthOut < 0) {

+      return GLU_INVALID_VALUE;

+   }

+

+   if (!legalFormat(format) || !legalType(typeIn) || !legalType(typeOut) ||

+       typeIn == GL_BITMAP || typeOut == GL_BITMAP) {

+      return GLU_INVALID_ENUM;

+   }

+   if (!isLegalFormatForPackedPixelType(format, typeIn)) {

+      return GLU_INVALID_OPERATION;

+   }

+   if (!isLegalFormatForPackedPixelType(format, typeOut)) {

+      return GLU_INVALID_OPERATION;

+   }

+

+   beforeImage = malloc(imageSize3D(widthIn, heightIn, depthIn, format,

+				    GL_UNSIGNED_SHORT));

+   afterImage = malloc(imageSize3D(widthOut, heightOut, depthOut, format,

+				   GL_UNSIGNED_SHORT));

+   if (beforeImage == NULL || afterImage == NULL) {

+       free(beforeImage);

+       free(afterImage);

+       return GLU_OUT_OF_MEMORY;

+   }

+   retrieveStoreModes3D(&psm);

+

+   fillImage3D(&psm,widthIn,heightIn,depthIn,format,typeIn, is_index(format),

+	       dataIn, beforeImage);

+   components = elements_per_group(format,0);

+   scaleInternal3D(components,widthIn,heightIn,depthIn,beforeImage,

+		   widthOut,heightOut,depthOut,afterImage);

+   emptyImage3D(&psm,widthOut,heightOut,depthOut,format,typeOut,

+		is_index(format),afterImage, dataOut);

+   free((void *) beforeImage);

+   free((void *) afterImage);

+

+   return 0;

+} /* gluScaleImage3D() */

+

+

+static void closestFit3D(GLenum target, GLint width, GLint height, GLint depth,

+			 GLint internalFormat, GLenum format, GLenum type,

+			 GLint *newWidth, GLint *newHeight, GLint *newDepth)

+{

+   GLint widthPowerOf2= nearestPower(width);

+   GLint heightPowerOf2= nearestPower(height);	        

+   GLint depthPowerOf2= nearestPower(depth);

+   GLint proxyWidth;

+

+   do {

+      /* compute level 1 width & height & depth, clamping each at 1 */

+      GLint widthAtLevelOne= (widthPowerOf2 > 1) ?

+			      widthPowerOf2 >> 1 :

+			      widthPowerOf2;

+      GLint heightAtLevelOne= (heightPowerOf2 > 1) ?

+			       heightPowerOf2 >> 1 :

+			       heightPowerOf2;

+      GLint depthAtLevelOne= (depthPowerOf2 > 1) ?

+			      depthPowerOf2 >> 1 :

+			      depthPowerOf2;

+      GLenum proxyTarget = GL_PROXY_TEXTURE_3D;

+      assert(widthAtLevelOne > 0);

+      assert(heightAtLevelOne > 0);

+      assert(depthAtLevelOne > 0);

+

+      /* does width x height x depth at level 1 & all their mipmaps fit? */

+      assert(target == GL_TEXTURE_3D || target == GL_PROXY_TEXTURE_3D);

+      gluTexImage3D(proxyTarget, 1, /* must be non-zero */

+                    internalFormat,

+                    widthAtLevelOne,heightAtLevelOne,depthAtLevelOne,

+                    0,format,type,NULL);

+      glGetTexLevelParameteriv(proxyTarget, 1,GL_TEXTURE_WIDTH,&proxyWidth);

+      /* does it fit??? */

+      if (proxyWidth == 0) { /* nope, so try again with these sizes */

+	 if (widthPowerOf2 == 1 && heightPowerOf2 == 1 &&

+	     depthPowerOf2 == 1) {

+	    *newWidth= *newHeight= *newDepth= 1; /* must fit 1x1x1 texture */

+	    return;

+	 }

+	 widthPowerOf2= widthAtLevelOne;

+	 heightPowerOf2= heightAtLevelOne;

+	 depthPowerOf2= depthAtLevelOne;

+      }

+      /* else it does fit */

+   } while (proxyWidth == 0);

+   /* loop must terminate! */

+

+   /* return the width & height at level 0 that fits */

+   *newWidth= widthPowerOf2;

+   *newHeight= heightPowerOf2;

+   *newDepth= depthPowerOf2;

+/*printf("Proxy Textures\n");*/

+} /* closestFit3D() */

+

+static void halveImagePackedPixelSlice(int components,

+				       void (*extractPackedPixel)

+				       (int, const void *,GLfloat []),

+				       void (*shovePackedPixel)

+				       (const GLfloat [],int, void *),

+				       GLint width, GLint height, GLint depth,

+				       const void *dataIn, void *dataOut,

+				       GLint pixelSizeInBytes,

+				       GLint rowSizeInBytes,

+				       GLint imageSizeInBytes,

+				       GLint isSwap)

+{

+   int ii, jj;

+   int halfWidth= width / 2;

+   int halfHeight= height / 2;

+   int halfDepth= depth / 2;

+   const char *src= (const char *)dataIn;

+   int outIndex= 0;

+

+   assert((width == 1 || height == 1) && depth >= 2);

+

+   if (width == height) {	/* a 1-pixel column viewed from top */

+      assert(width == 1 && height == 1);

+      assert(depth >= 2);

+

+      for (ii= 0; ii< halfDepth; ii++) {

+	 float totals[4];

+	 float extractTotals[BOX2][4];

+	 int cc;

+

+	 (*extractPackedPixel)(isSwap,src,&extractTotals[0][0]);

+	 (*extractPackedPixel)(isSwap,(src+imageSizeInBytes),

+			       &extractTotals[1][0]);

+	 for (cc = 0; cc < components; cc++) {

+	    int kk;

+

+	    /* average 2 pixels since only a column */

+	    totals[cc]= 0.0;

+	    /* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED];

+	     * totals[RED]/= 2.0;

+	     */

+	    for (kk = 0; kk < BOX2; kk++) {

+	      totals[cc]+= extractTotals[kk][cc];

+	    }

+	    totals[cc]/= (float)BOX2;

+	 } /* for cc */

+        

+	 (*shovePackedPixel)(totals,outIndex,dataOut);

+	 outIndex++;

+	 /* skip over to next group of 2 */

+	 src+= imageSizeInBytes + imageSizeInBytes;

+      } /* for ii */

+   }

+   else if (height == 1) {	/* horizontal slice viewed from top */

+      assert(width != 1);

+

+      for (ii= 0; ii< halfDepth; ii++) {

+	 for (jj= 0; jj< halfWidth; jj++) {

+	     float totals[4];

+	     float extractTotals[BOX4][4];

+	     int cc;

+

+	     (*extractPackedPixel)(isSwap,src,

+				   &extractTotals[0][0]);

+	     (*extractPackedPixel)(isSwap,(src+pixelSizeInBytes),

+				   &extractTotals[1][0]);

+	     (*extractPackedPixel)(isSwap,(src+imageSizeInBytes),

+				   &extractTotals[2][0]);

+	     (*extractPackedPixel)(isSwap,

+				   (src+imageSizeInBytes+pixelSizeInBytes),

+				   &extractTotals[3][0]);

+	     for (cc = 0; cc < components; cc++) {

+		int kk;

+

+		/* grab 4 pixels to average */

+		totals[cc]= 0.0;

+		/* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED]+

+		 *		extractTotals[2][RED]+extractTotals[3][RED];

+		 * totals[RED]/= 4.0;

+		 */

+		for (kk = 0; kk < BOX4; kk++) {

+		   totals[cc]+= extractTotals[kk][cc];

+		}

+		totals[cc]/= (float)BOX4;

+	     }

+	     (*shovePackedPixel)(totals,outIndex,dataOut);

+

+	     outIndex++;

+	     /* skip over to next horizontal square of 4 */

+	     src+= imageSizeInBytes + imageSizeInBytes;

+	 }

+      }

+

+      /* assert() */

+   }

+   else if (width == 1) {	/* vertical slice viewed from top */

+      assert(height != 1);

+

+      for (ii= 0; ii< halfDepth; ii++) {

+	 for (jj= 0; jj< halfHeight; jj++) {

+	    float totals[4];

+	    float extractTotals[BOX4][4];

+	    int cc;

+

+	    (*extractPackedPixel)(isSwap,src,

+				  &extractTotals[0][0]);

+	    (*extractPackedPixel)(isSwap,(src+rowSizeInBytes),

+				  &extractTotals[1][0]);

+	    (*extractPackedPixel)(isSwap,(src+imageSizeInBytes),

+				  &extractTotals[2][0]);

+	    (*extractPackedPixel)(isSwap,

+				  (src+imageSizeInBytes+rowSizeInBytes),

+				  &extractTotals[3][0]);

+	    for (cc = 0; cc < components; cc++) {

+	       int kk;

+

+	       /* grab 4 pixels to average */

+	       totals[cc]= 0.0;

+	       /* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED]+

+		*	       extractTotals[2][RED]+extractTotals[3][RED];

+		* totals[RED]/= 4.0;

+		*/

+	       for (kk = 0; kk < BOX4; kk++) {

+		  totals[cc]+= extractTotals[kk][cc];

+	       }

+	       totals[cc]/= (float)BOX4;

+	    }

+	    (*shovePackedPixel)(totals,outIndex,dataOut);

+

+	    outIndex++;

+

+	    /* skip over to next vertical square of 4 */

+	    src+= imageSizeInBytes + imageSizeInBytes;

+	 }

+      }

+      /* assert() */

+   }

+

+} /* halveImagePackedPixelSlice() */

+

+static void halveImagePackedPixel3D(int components,

+				    void (*extractPackedPixel)

+				    (int, const void *,GLfloat []),

+				    void (*shovePackedPixel)

+				    (const GLfloat [],int, void *),

+				    GLint width, GLint height, GLint depth,

+				    const void *dataIn, void *dataOut,

+				    GLint pixelSizeInBytes,

+				    GLint rowSizeInBytes,

+				    GLint imageSizeInBytes,

+				    GLint isSwap)

+{

+   if (depth == 1) {

+      assert(1 <= width && 1 <= height);

+

+      halveImagePackedPixel(components,extractPackedPixel,shovePackedPixel,

+			    width,height,dataIn,dataOut,pixelSizeInBytes,

+			    rowSizeInBytes,isSwap);

+      return;

+   }

+   /* a horizontal or vertical slice viewed from top */

+   else if (width == 1 || height == 1) {

+      assert(1 <= depth);

+

+      halveImagePackedPixelSlice(components,

+				 extractPackedPixel,shovePackedPixel,

+				 width, height, depth, dataIn, dataOut,

+				 pixelSizeInBytes, rowSizeInBytes,

+				 imageSizeInBytes, isSwap);

+      return;

+   }

+   {

+      int ii, jj, dd;

+

+      int halfWidth= width / 2;

+      int halfHeight= height / 2;

+      int halfDepth= depth / 2;

+      const char *src= (const char *) dataIn;

+      int padBytes= rowSizeInBytes - (width*pixelSizeInBytes);

+      int outIndex= 0;

+

+      for (dd= 0; dd < halfDepth; dd++) {

+	 for (ii= 0; ii< halfHeight; ii++) {

+	    for (jj= 0; jj< halfWidth; jj++) {

+#define BOX8 8

+	       float totals[4]; /* 4 is maximum components */

+	       float extractTotals[BOX8][4]; /* 4 is maximum components */

+	       int cc;

+

+	       (*extractPackedPixel)(isSwap,src,

+				     &extractTotals[0][0]);

+	       (*extractPackedPixel)(isSwap,(src+pixelSizeInBytes),

+				     &extractTotals[1][0]);

+	       (*extractPackedPixel)(isSwap,(src+rowSizeInBytes),

+				     &extractTotals[2][0]);

+	       (*extractPackedPixel)(isSwap,

+				     (src+rowSizeInBytes+pixelSizeInBytes),

+				     &extractTotals[3][0]);

+

+	       (*extractPackedPixel)(isSwap,(src+imageSizeInBytes),

+				     &extractTotals[4][0]);

+	       (*extractPackedPixel)(isSwap,(src+pixelSizeInBytes+imageSizeInBytes),

+				     &extractTotals[5][0]);

+	       (*extractPackedPixel)(isSwap,(src+rowSizeInBytes+imageSizeInBytes),

+				     &extractTotals[6][0]);

+	       (*extractPackedPixel)(isSwap,

+				     (src+rowSizeInBytes+pixelSizeInBytes+imageSizeInBytes),

+				     &extractTotals[7][0]);

+	       for (cc = 0; cc < components; cc++) {

+		  int kk;

+

+		  /* grab 8 pixels to average */

+		  totals[cc]= 0.0;

+		  /* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED]+

+		   *		  extractTotals[2][RED]+extractTotals[3][RED]+

+		   *		  extractTotals[4][RED]+extractTotals[5][RED]+

+		   *		  extractTotals[6][RED]+extractTotals[7][RED];

+		   * totals[RED]/= 8.0;

+		   */

+		  for (kk = 0; kk < BOX8; kk++) {

+		     totals[cc]+= extractTotals[kk][cc];

+		  }

+		  totals[cc]/= (float)BOX8;

+	       }

+	       (*shovePackedPixel)(totals,outIndex,dataOut);

+

+	       outIndex++;

+	       /* skip over to next square of 4 */

+	       src+= pixelSizeInBytes + pixelSizeInBytes;

+	    }

+	    /* skip past pad bytes, if any, to get to next row */

+	    src+= padBytes;

+

+	    /* src is at beginning of a row here, but it's the second row of

+	     * the square block of 4 pixels that we just worked on so we

+	     * need to go one more row.

+	     * i.e.,

+	     *			 OO...

+	     *		 here -->OO...

+	     *	     but want -->OO...

+	     *			 OO...

+	     *			 ...

+	     */

+	    src+= rowSizeInBytes;

+	 }

+

+	 src+= imageSizeInBytes;

+      } /* for dd */

+

+      /* both pointers must reach one byte after the end */

+      assert(src == &((const char *)dataIn)[rowSizeInBytes*height*depth]);

+      assert(outIndex == halfWidth * halfHeight * halfDepth);

+   } /* for dd */

+

+} /* halveImagePackedPixel3D() */

+

+static int gluBuild3DMipmapLevelsCore(GLenum target, GLint internalFormat,

+				      GLsizei width,

+				      GLsizei height,

+				      GLsizei depth,

+				      GLsizei widthPowerOf2,

+				      GLsizei heightPowerOf2,

+				      GLsizei depthPowerOf2,

+				      GLenum format, GLenum type,

+				      GLint userLevel,

+				      GLint baseLevel,GLint maxLevel,

+				      const void *data)

+{

+   GLint newWidth, newHeight, newDepth;

+   GLint level, levels;

+   const void *usersImage;

+   void *srcImage, *dstImage;

+   __GLU_INIT_SWAP_IMAGE;

+   GLint memReq;

+   GLint cmpts;

+

+   GLint myswapBytes, groupsPerLine, elementSize, groupSize;

+   GLint rowsPerImage, imageSize;

+   GLint rowSize, padding;

+   PixelStorageModes psm;

+

+   assert(checkMipmapArgs(internalFormat,format,type) == 0);

+   assert(width >= 1 && height >= 1 && depth >= 1);

+   assert(type != GL_BITMAP);

+

+   srcImage = dstImage = NULL;

+

+   newWidth= widthPowerOf2;

+   newHeight= heightPowerOf2;

+   newDepth= depthPowerOf2;

+   levels = computeLog(newWidth);

+   level = computeLog(newHeight);

+   if (level > levels) levels=level;

+   level = computeLog(newDepth);

+   if (level > levels) levels=level;

+

+   levels+= userLevel;

+

+   retrieveStoreModes3D(&psm);

+   myswapBytes = psm.unpack_swap_bytes;

+   cmpts = elements_per_group(format,type);

+   if (psm.unpack_row_length > 0) {

+       groupsPerLine = psm.unpack_row_length;

+   } else {

+       groupsPerLine = width;

+   }

+

+   elementSize = bytes_per_element(type);

+   groupSize = elementSize * cmpts;

+   if (elementSize == 1) myswapBytes = 0;

+

+   /* 3dstuff begin */

+   if (psm.unpack_image_height > 0) {

+      rowsPerImage= psm.unpack_image_height;

+   }

+   else {

+      rowsPerImage= height;

+   }

+

+   /* 3dstuff end */

+   rowSize = groupsPerLine * groupSize;

+   padding = (rowSize % psm.unpack_alignment);

+   if (padding) {

+       rowSize += psm.unpack_alignment - padding;

+   }

+

+   imageSize= rowsPerImage * rowSize; /* 3dstuff */

+

+   usersImage = (const GLubyte *)data + psm.unpack_skip_rows * rowSize +

+				  psm.unpack_skip_pixels * groupSize +

+				  /* 3dstuff */

+				  psm.unpack_skip_images * imageSize;

+

+   glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);

+   glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);

+   glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);

+   glPixelStorei(GL_UNPACK_SKIP_IMAGES, 0);

+   glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, 0);

+

+   level = userLevel;

+

+   if (width == newWidth && height == newHeight && depth == newDepth) {

+       /* Use usersImage for level userLevel */

+       if (baseLevel <= level && level <= maxLevel) {

+	  gluTexImage3D(target, level, internalFormat, width,

+		       height, depth, 0, format, type,

+		       usersImage);

+       }

+       if(levels == 0) { /* we're done. clean up and return */

+	 glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);

+	 glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);

+	 glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);

+	 glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);

+	 glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);

+	 glPixelStorei(GL_UNPACK_SKIP_IMAGES, psm.unpack_skip_images);

+	 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, psm.unpack_image_height);

+	 return 0;

+       }

+       {

+	  int nextWidth= newWidth/2;

+	  int nextHeight= newHeight/2;

+	  int nextDepth= newDepth/2;

+

+	  /* clamp to 1 */

+	  if (nextWidth < 1) nextWidth= 1;

+	  if (nextHeight < 1) nextHeight= 1;

+	  if (nextDepth < 1) nextDepth= 1;      

+       memReq = imageSize3D(nextWidth, nextHeight, nextDepth, format, type);

+       }

+       switch(type) {

+       case GL_UNSIGNED_BYTE:

+	 dstImage = (GLubyte *)malloc(memReq);

+	 break;

+       case GL_BYTE:

+	 dstImage = (GLbyte *)malloc(memReq);

+	 break;

+       case GL_UNSIGNED_SHORT:

+	 dstImage = (GLushort *)malloc(memReq);

+	 break;

+       case GL_SHORT:

+	 dstImage = (GLshort *)malloc(memReq);

+	 break;

+       case GL_UNSIGNED_INT:

+	 dstImage = (GLuint *)malloc(memReq);

+	 break;

+       case GL_INT:

+	 dstImage = (GLint *)malloc(memReq);

+	 break;

+       case GL_FLOAT:

+	 dstImage = (GLfloat *)malloc(memReq);

+	 break;

+       case GL_UNSIGNED_BYTE_3_3_2:

+       case GL_UNSIGNED_BYTE_2_3_3_REV:

+	 dstImage = (GLubyte *)malloc(memReq);

+	 break;

+       case GL_UNSIGNED_SHORT_5_6_5:

+       case GL_UNSIGNED_SHORT_5_6_5_REV:

+       case GL_UNSIGNED_SHORT_4_4_4_4:

+       case GL_UNSIGNED_SHORT_4_4_4_4_REV:

+       case GL_UNSIGNED_SHORT_5_5_5_1:

+       case GL_UNSIGNED_SHORT_1_5_5_5_REV:

+	 dstImage = (GLushort *)malloc(memReq);

+	 break;

+       case GL_UNSIGNED_INT_8_8_8_8:

+       case GL_UNSIGNED_INT_8_8_8_8_REV:

+       case GL_UNSIGNED_INT_10_10_10_2:

+       case GL_UNSIGNED_INT_2_10_10_10_REV:

+	 dstImage = (GLuint *)malloc(memReq);   

+	 break;

+       default:

+	 return GLU_INVALID_ENUM; /* assertion */

+       }

+       if (dstImage == NULL) {

+	 glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);

+	 glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);

+	 glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);

+	 glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);

+	 glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);

+	 glPixelStorei(GL_UNPACK_SKIP_IMAGES, psm.unpack_skip_images);

+	 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, psm.unpack_image_height);

+	 return GLU_OUT_OF_MEMORY;

+       }

+       else

+	 switch(type) {

+	 case GL_UNSIGNED_BYTE:

+	   if (depth > 1) {

+	     halveImage3D(cmpts,extractUbyte,shoveUbyte,

+			  width,height,depth,

+			  usersImage,dstImage,elementSize,groupSize,rowSize,

+			  imageSize,myswapBytes);

+	   }

+	   else {

+	     halveImage_ubyte(cmpts,width,height,usersImage,dstImage,

+			      elementSize,rowSize,groupSize);

+	   }

+	   break;

+	 case GL_BYTE:

+	   if (depth > 1) {

+	   halveImage3D(cmpts,extractSbyte,shoveSbyte,

+			width,height,depth,

+			usersImage,dstImage,elementSize,groupSize,rowSize,

+			imageSize,myswapBytes);

+	   }

+	   else {

+	     halveImage_byte(cmpts,width,height,usersImage,dstImage,

+			     elementSize,rowSize,groupSize);

+	   }

+	   break;

+	 case GL_UNSIGNED_SHORT:

+	   if (depth > 1) {

+	   halveImage3D(cmpts,extractUshort,shoveUshort,

+			width,height,depth,

+			usersImage,dstImage,elementSize,groupSize,rowSize,

+			imageSize,myswapBytes);

+	   }

+	   else {

+	     halveImage_ushort(cmpts,width,height,usersImage,dstImage,

+			       elementSize,rowSize,groupSize,myswapBytes);

+	   }

+	   break;

+	 case GL_SHORT:

+	   if (depth > 1) {

+	   halveImage3D(cmpts,extractSshort,shoveSshort,

+			width,height,depth,

+			usersImage,dstImage,elementSize,groupSize,rowSize,

+			imageSize,myswapBytes);

+	   }

+	   else {

+	     halveImage_short(cmpts,width,height,usersImage,dstImage,

+			      elementSize,rowSize,groupSize,myswapBytes);

+	   }

+	   break;

+	 case GL_UNSIGNED_INT:

+	   if (depth > 1) {

+	   halveImage3D(cmpts,extractUint,shoveUint,

+			width,height,depth,

+			usersImage,dstImage,elementSize,groupSize,rowSize,

+			imageSize,myswapBytes);

+	   }

+	   else {

+	     halveImage_uint(cmpts,width,height,usersImage,dstImage,

+			     elementSize,rowSize,groupSize,myswapBytes);

+	   }

+	   break;

+	 case GL_INT:

+	   if (depth > 1) {

+	   halveImage3D(cmpts,extractSint,shoveSint,

+			width,height,depth,

+			usersImage,dstImage,elementSize,groupSize,rowSize,

+			imageSize,myswapBytes);

+	   }

+	   else {

+	     halveImage_int(cmpts,width,height,usersImage,dstImage,

+			    elementSize,rowSize,groupSize,myswapBytes);

+	   }

+	   break;

+	 case GL_FLOAT:

+	   if (depth > 1 ) {

+	   halveImage3D(cmpts,extractFloat,shoveFloat,

+			width,height,depth,

+			usersImage,dstImage,elementSize,groupSize,rowSize,

+			imageSize,myswapBytes);

+	   }

+	   else {

+	     halveImage_float(cmpts,width,height,usersImage,dstImage,

+			      elementSize,rowSize,groupSize,myswapBytes);

+	   }

+	   break;

+	 case GL_UNSIGNED_BYTE_3_3_2:

+	   assert(format == GL_RGB);

+	   halveImagePackedPixel3D(3,extract332,shove332,

+				   width,height,depth,usersImage,dstImage,

+				   elementSize,rowSize,imageSize,myswapBytes);

+	   break;

+	 case GL_UNSIGNED_BYTE_2_3_3_REV:

+	   assert(format == GL_RGB);

+	   halveImagePackedPixel3D(3,extract233rev,shove233rev,

+				   width,height,depth,usersImage,dstImage,

+				   elementSize,rowSize,imageSize,myswapBytes);

+	   break;

+	 case GL_UNSIGNED_SHORT_5_6_5:

+	   halveImagePackedPixel3D(3,extract565,shove565,

+				   width,height,depth,usersImage,dstImage,

+				   elementSize,rowSize,imageSize,myswapBytes);

+	   break;

+	 case GL_UNSIGNED_SHORT_5_6_5_REV:

+	   halveImagePackedPixel3D(3,extract565rev,shove565rev,

+				   width,height,depth,usersImage,dstImage,

+				   elementSize,rowSize,imageSize,myswapBytes);

+	   break;

+	 case GL_UNSIGNED_SHORT_4_4_4_4:

+	   halveImagePackedPixel3D(4,extract4444,shove4444,

+				   width,height,depth,usersImage,dstImage,

+				   elementSize,rowSize,imageSize,myswapBytes);

+	   break;

+	 case GL_UNSIGNED_SHORT_4_4_4_4_REV:

+	   halveImagePackedPixel3D(4,extract4444rev,shove4444rev,

+				   width,height,depth,usersImage,dstImage,

+				   elementSize,rowSize,imageSize,myswapBytes);

+	   break;

+	 case GL_UNSIGNED_SHORT_5_5_5_1:

+	   halveImagePackedPixel3D(4,extract5551,shove5551,

+				   width,height,depth,usersImage,dstImage,

+				   elementSize,rowSize,imageSize,myswapBytes);

+	   break;

+	 case GL_UNSIGNED_SHORT_1_5_5_5_REV:

+	   halveImagePackedPixel3D(4,extract1555rev,shove1555rev,

+				   width,height,depth,usersImage,dstImage,

+				   elementSize,rowSize,imageSize,myswapBytes);

+	   break;

+	 case GL_UNSIGNED_INT_8_8_8_8:

+	   halveImagePackedPixel3D(4,extract8888,shove8888,

+				   width,height,depth,usersImage,dstImage,

+				   elementSize,rowSize,imageSize,myswapBytes);

+	   break;

+	 case GL_UNSIGNED_INT_8_8_8_8_REV:

+	   halveImagePackedPixel3D(4,extract8888rev,shove8888rev,

+				   width,height,depth,usersImage,dstImage,

+				   elementSize,rowSize,imageSize,myswapBytes);

+	   break;

+	 case GL_UNSIGNED_INT_10_10_10_2:

+	   halveImagePackedPixel3D(4,extract1010102,shove1010102,

+				   width,height,depth,usersImage,dstImage,

+				   elementSize,rowSize,imageSize,myswapBytes);

+	   break;

+	 case GL_UNSIGNED_INT_2_10_10_10_REV:

+	   halveImagePackedPixel3D(4,extract2101010rev,shove2101010rev,

+				   width,height,depth,usersImage,dstImage,

+				   elementSize,rowSize,imageSize,myswapBytes);

+	   break;

+	 default:

+	   assert(0);

+	   break;

+	 }

+       newWidth = width/2;

+       newHeight = height/2;

+       newDepth = depth/2;

+       /* clamp to 1 */

+       if (newWidth < 1) newWidth= 1;

+       if (newHeight < 1) newHeight= 1;

+       if (newDepth < 1) newDepth= 1;

+

+       myswapBytes = 0;

+       rowSize = newWidth * groupSize;

+       imageSize= rowSize * newHeight; /* 3dstuff */

+       memReq = imageSize3D(newWidth, newHeight, newDepth, format, type);

+       /* Swap srcImage and dstImage */

+       __GLU_SWAP_IMAGE(srcImage,dstImage);

+       switch(type) {

+       case GL_UNSIGNED_BYTE:

+	 dstImage = (GLubyte *)malloc(memReq);

+	 break;

+       case GL_BYTE:

+	 dstImage = (GLbyte *)malloc(memReq);

+	 break;

+       case GL_UNSIGNED_SHORT:

+	 dstImage = (GLushort *)malloc(memReq);

+	 break;

+       case GL_SHORT:

+	 dstImage = (GLshort *)malloc(memReq);

+	 break;

+       case GL_UNSIGNED_INT:

+	 dstImage = (GLuint *)malloc(memReq);

+	 break;

+       case GL_INT:

+	 dstImage = (GLint *)malloc(memReq);

+	 break;

+       case GL_FLOAT:

+	 dstImage = (GLfloat *)malloc(memReq);

+	 break;

+       case GL_UNSIGNED_BYTE_3_3_2:

+       case GL_UNSIGNED_BYTE_2_3_3_REV:

+	 dstImage = (GLubyte *)malloc(memReq);

+	 break;

+       case GL_UNSIGNED_SHORT_5_6_5:

+       case GL_UNSIGNED_SHORT_5_6_5_REV:

+       case GL_UNSIGNED_SHORT_4_4_4_4:

+       case GL_UNSIGNED_SHORT_4_4_4_4_REV:

+       case GL_UNSIGNED_SHORT_5_5_5_1:

+       case GL_UNSIGNED_SHORT_1_5_5_5_REV:

+	 dstImage = (GLushort *)malloc(memReq);

+	 break;

+       case GL_UNSIGNED_INT_8_8_8_8:

+       case GL_UNSIGNED_INT_8_8_8_8_REV:

+       case GL_UNSIGNED_INT_10_10_10_2:

+       case GL_UNSIGNED_INT_2_10_10_10_REV:

+	 dstImage = (GLuint *)malloc(memReq);

+	 break;

+       default:

+	 return GLU_INVALID_ENUM; /* assertion */

+       }

+       if (dstImage == NULL) {

+	 glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);

+	 glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);

+	 glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);

+	 glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);

+	 glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);

+	 glPixelStorei(GL_UNPACK_SKIP_IMAGES, psm.unpack_skip_images);

+	 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, psm.unpack_image_height);

+	 free(srcImage);

+	 return GLU_OUT_OF_MEMORY;

+       }

+       /* level userLevel+1 is in srcImage; level userLevel already saved */

+       level = userLevel+1;

+   } else {/* user's image is *not* nice power-of-2 sized square */

+       memReq = imageSize3D(newWidth, newHeight, newDepth, format, type);

+       switch(type) {

+	   case GL_UNSIGNED_BYTE:

+	       dstImage = (GLubyte *)malloc(memReq);

+	       break;

+	   case GL_BYTE:

+	       dstImage = (GLbyte *)malloc(memReq);

+	       break;

+	   case GL_UNSIGNED_SHORT:

+	       dstImage = (GLushort *)malloc(memReq);

+	       break;

+	   case GL_SHORT:

+	       dstImage = (GLshort *)malloc(memReq);

+	       break;

+	   case GL_UNSIGNED_INT:

+	       dstImage = (GLuint *)malloc(memReq);

+	       break;

+	   case GL_INT:

+	       dstImage = (GLint *)malloc(memReq);

+	       break;

+	   case GL_FLOAT:

+	       dstImage = (GLfloat *)malloc(memReq);

+	       break;

+	   case GL_UNSIGNED_BYTE_3_3_2:

+	   case GL_UNSIGNED_BYTE_2_3_3_REV:

+	       dstImage = (GLubyte *)malloc(memReq);

+	       break;

+	   case GL_UNSIGNED_SHORT_5_6_5:

+	   case GL_UNSIGNED_SHORT_5_6_5_REV:

+	   case GL_UNSIGNED_SHORT_4_4_4_4:

+	   case GL_UNSIGNED_SHORT_4_4_4_4_REV:

+	   case GL_UNSIGNED_SHORT_5_5_5_1:

+	   case GL_UNSIGNED_SHORT_1_5_5_5_REV:

+	       dstImage = (GLushort *)malloc(memReq);

+	       break;

+	   case GL_UNSIGNED_INT_8_8_8_8:

+	   case GL_UNSIGNED_INT_8_8_8_8_REV:

+	   case GL_UNSIGNED_INT_10_10_10_2:

+	   case GL_UNSIGNED_INT_2_10_10_10_REV:

+	       dstImage = (GLuint *)malloc(memReq);

+	       break;

+	   default:

+	       return GLU_INVALID_ENUM; /* assertion */

+       }

+

+       if (dstImage == NULL) {

+	   glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);

+	   glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);

+	   glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);

+	   glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);

+	   glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);

+	   glPixelStorei(GL_UNPACK_SKIP_IMAGES, psm.unpack_skip_images);

+	   glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, psm.unpack_image_height);

+	   return GLU_OUT_OF_MEMORY;

+       }

+       /*printf("Build3DMipmaps(): ScaleImage3D %d %d %d->%d %d %d\n",

+       width,height,depth,newWidth,newHeight,newDepth);*/

+

+       gluScaleImage3D(format, width, height, depth, type, usersImage,

+		       newWidth, newHeight, newDepth, type, dstImage);

+

+       myswapBytes = 0;

+       rowSize = newWidth * groupSize;

+       imageSize = rowSize * newHeight; /* 3dstuff */

+       /* Swap dstImage and srcImage */

+       __GLU_SWAP_IMAGE(srcImage,dstImage);

+

+       if(levels != 0) { /* use as little memory as possible */

+	 {

+	    int nextWidth= newWidth/2;

+	    int nextHeight= newHeight/2;

+	    int nextDepth= newDepth/2;

+	    if (nextWidth < 1) nextWidth= 1;

+	    if (nextHeight < 1) nextHeight= 1;  

+	    if (nextDepth < 1) nextDepth= 1;    

+

+	 memReq = imageSize3D(nextWidth, nextHeight, nextDepth, format, type);

+	 }

+	 switch(type) {

+	 case GL_UNSIGNED_BYTE:

+	   dstImage = (GLubyte *)malloc(memReq);

+	   break;

+	 case GL_BYTE:

+	   dstImage = (GLbyte *)malloc(memReq);

+	   break;

+	 case GL_UNSIGNED_SHORT:

+	   dstImage = (GLushort *)malloc(memReq);

+	   break;

+	 case GL_SHORT:

+	   dstImage = (GLshort *)malloc(memReq);

+	   break;

+	 case GL_UNSIGNED_INT:

+	   dstImage = (GLuint *)malloc(memReq);

+	   break;

+	 case GL_INT:

+	   dstImage = (GLint *)malloc(memReq);

+	   break;

+	 case GL_FLOAT:

+	   dstImage = (GLfloat *)malloc(memReq);

+	   break;

+	 case GL_UNSIGNED_BYTE_3_3_2:

+	 case GL_UNSIGNED_BYTE_2_3_3_REV:

+	   dstImage = (GLubyte *)malloc(memReq);

+	   break;

+	 case GL_UNSIGNED_SHORT_5_6_5:

+	 case GL_UNSIGNED_SHORT_5_6_5_REV:

+	 case GL_UNSIGNED_SHORT_4_4_4_4:

+	 case GL_UNSIGNED_SHORT_4_4_4_4_REV:

+	 case GL_UNSIGNED_SHORT_5_5_5_1:

+	 case GL_UNSIGNED_SHORT_1_5_5_5_REV:

+	   dstImage = (GLushort *)malloc(memReq);

+	   break;

+	 case GL_UNSIGNED_INT_8_8_8_8:

+	 case GL_UNSIGNED_INT_8_8_8_8_REV:

+	 case GL_UNSIGNED_INT_10_10_10_2:

+	 case GL_UNSIGNED_INT_2_10_10_10_REV:

+	   dstImage = (GLuint *)malloc(memReq);

+	   break;

+	 default:

+	   return GLU_INVALID_ENUM; /* assertion */

+	 }

+	 if (dstImage == NULL) {

+	   glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);

+	   glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);

+	   glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);

+	   glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);

+	   glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);

+	   glPixelStorei(GL_UNPACK_SKIP_IMAGES, psm.unpack_skip_images);

+	   glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, psm.unpack_image_height);

+	   free(srcImage);

+	   return GLU_OUT_OF_MEMORY;

+	 }

+       }

+       /* level userLevel is in srcImage; nothing saved yet */

+       level = userLevel;       

+   }

+

+   glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE);

+   if (baseLevel <= level && level <= maxLevel) {

+     gluTexImage3D(target, level, internalFormat, newWidth, newHeight, newDepth,

+		  0,format, type, (void *)srcImage);

+   }

+   level++; /* update current level for the loop */

+   for (; level <= levels; level++) {

+       switch(type) {

+	   case GL_UNSIGNED_BYTE:

+	       if (newDepth > 1) {

+	       halveImage3D(cmpts,extractUbyte,shoveUbyte,

+			    newWidth,newHeight,newDepth,

+			    srcImage,dstImage,elementSize,groupSize,rowSize,

+			    imageSize,myswapBytes);

+	       }

+	       else {

+		 halveImage_ubyte(cmpts,newWidth,newHeight,srcImage,dstImage,

+				  elementSize,rowSize,groupSize);

+	       }

+	       break;

+	   case GL_BYTE:

+	       if (newDepth > 1) {

+	       halveImage3D(cmpts,extractSbyte,shoveSbyte,

+			    newWidth,newHeight,newDepth,

+			    srcImage,dstImage,elementSize,groupSize,rowSize,

+			    imageSize,myswapBytes);

+	       }

+	       else {

+		 halveImage_byte(cmpts,newWidth,newHeight,srcImage,dstImage,

+				  elementSize,rowSize,groupSize);

+	       }

+	       break;

+	   case GL_UNSIGNED_SHORT:

+	       if (newDepth > 1) {

+	       halveImage3D(cmpts,extractUshort,shoveUshort,

+			    newWidth,newHeight,newDepth,

+			    srcImage,dstImage,elementSize,groupSize,rowSize,

+			    imageSize,myswapBytes);

+	       }

+	       else {

+		 halveImage_ushort(cmpts,newWidth,newHeight,srcImage,dstImage,

+				   elementSize,rowSize,groupSize,myswapBytes);

+	       }

+	       break;

+	   case GL_SHORT:

+	       if (newDepth > 1) {

+	       halveImage3D(cmpts,extractSshort,shoveSshort,

+			    newWidth,newHeight,newDepth,

+			    srcImage,dstImage,elementSize,groupSize,rowSize,

+			    imageSize,myswapBytes);

+	       }

+	       else {

+		 halveImage_short(cmpts,newWidth,newHeight,srcImage,dstImage,

+				  elementSize,rowSize,groupSize,myswapBytes);

+	       }

+	       break;

+	   case GL_UNSIGNED_INT:

+	       if (newDepth > 1) {

+	       halveImage3D(cmpts,extractUint,shoveUint,

+			    newWidth,newHeight,newDepth,

+			    srcImage,dstImage,elementSize,groupSize,rowSize,

+			    imageSize,myswapBytes);

+	       }

+	       else {

+		 halveImage_uint(cmpts,newWidth,newHeight,srcImage,dstImage,

+				 elementSize,rowSize,groupSize,myswapBytes);

+	       }

+	       break;

+	   case GL_INT:

+	       if (newDepth > 1) {

+	       halveImage3D(cmpts,extractSint,shoveSint,

+			    newWidth,newHeight,newDepth,

+			    srcImage,dstImage,elementSize,groupSize,rowSize,

+			    imageSize,myswapBytes);

+	       }

+	       else {

+		 halveImage_int(cmpts,newWidth,newHeight,srcImage,dstImage,

+				elementSize,rowSize,groupSize,myswapBytes);

+	       }

+	       break;

+	   case GL_FLOAT:

+	       if (newDepth > 1) {

+	       halveImage3D(cmpts,extractFloat,shoveFloat,

+			    newWidth,newHeight,newDepth,

+			    srcImage,dstImage,elementSize,groupSize,rowSize,

+			    imageSize,myswapBytes);

+	       }

+	       else {

+		 halveImage_float(cmpts,newWidth,newHeight,srcImage,dstImage,

+				  elementSize,rowSize,groupSize,myswapBytes);

+	       }

+	       break;

+	   case GL_UNSIGNED_BYTE_3_3_2:

+	       halveImagePackedPixel3D(3,extract332,shove332,

+				       newWidth,newHeight,newDepth,

+				       srcImage,dstImage,elementSize,rowSize,

+				       imageSize,myswapBytes);

+	       break;

+	   case GL_UNSIGNED_BYTE_2_3_3_REV:

+	       halveImagePackedPixel3D(3,extract233rev,shove233rev,

+				       newWidth,newHeight,newDepth,

+				       srcImage,dstImage,elementSize,rowSize,

+				       imageSize,myswapBytes);

+	       break;

+	   case GL_UNSIGNED_SHORT_5_6_5:

+	       halveImagePackedPixel3D(3,extract565,shove565,

+				       newWidth,newHeight,newDepth,

+				       srcImage,dstImage,elementSize,rowSize,

+				       imageSize,myswapBytes);

+	       break;

+	   case GL_UNSIGNED_SHORT_5_6_5_REV:

+	       halveImagePackedPixel3D(3,extract565rev,shove565rev,

+				       newWidth,newHeight,newDepth,

+				       srcImage,dstImage,elementSize,rowSize,

+				       imageSize,myswapBytes);

+	       break;

+	   case GL_UNSIGNED_SHORT_4_4_4_4:

+	       halveImagePackedPixel3D(4,extract4444,shove4444,

+				       newWidth,newHeight,newDepth,

+				       srcImage,dstImage,elementSize,rowSize,

+				       imageSize,myswapBytes);

+	       break;

+	   case GL_UNSIGNED_SHORT_4_4_4_4_REV:

+	       halveImagePackedPixel3D(4,extract4444rev,shove4444rev,

+				       newWidth,newHeight,newDepth,

+				       srcImage,dstImage,elementSize,rowSize,

+				       imageSize,myswapBytes);

+	       break;

+	   case GL_UNSIGNED_SHORT_5_5_5_1:	        

+	       halveImagePackedPixel3D(4,extract5551,shove5551,

+				       newWidth,newHeight,newDepth,

+				       srcImage,dstImage,elementSize,rowSize,

+				       imageSize,myswapBytes);

+	       break;

+	   case GL_UNSIGNED_SHORT_1_5_5_5_REV:	        

+	       halveImagePackedPixel3D(4,extract1555rev,shove1555rev,

+				       newWidth,newHeight,newDepth,

+				       srcImage,dstImage,elementSize,rowSize,

+				       imageSize,myswapBytes);

+	       break;

+	   case GL_UNSIGNED_INT_8_8_8_8:

+	       halveImagePackedPixel3D(4,extract8888,shove8888,

+				       newWidth,newHeight,newDepth,

+				       srcImage,dstImage,elementSize,rowSize,

+				       imageSize,myswapBytes);

+	       break;

+	   case GL_UNSIGNED_INT_8_8_8_8_REV:

+	       halveImagePackedPixel3D(4,extract8888rev,shove8888rev,

+				       newWidth,newHeight,newDepth,

+				       srcImage,dstImage,elementSize,rowSize,

+				       imageSize,myswapBytes);

+	       break;

+	   case GL_UNSIGNED_INT_10_10_10_2:

+	       halveImagePackedPixel3D(4,extract1010102,shove1010102,

+				       newWidth,newHeight,newDepth,

+				       srcImage,dstImage,elementSize,rowSize,

+				       imageSize,myswapBytes);

+	       break;

+	   case GL_UNSIGNED_INT_2_10_10_10_REV:

+	       halveImagePackedPixel3D(4,extract2101010rev,shove2101010rev,

+				       newWidth,newHeight,newDepth,

+				       srcImage,dstImage,elementSize,rowSize,

+				       imageSize,myswapBytes);

+	       break;

+	   default:

+	       assert(0);

+	       break;

+       }

+

+       __GLU_SWAP_IMAGE(srcImage,dstImage);

+

+       if (newWidth > 1) { newWidth /= 2; rowSize /= 2;}

+       if (newHeight > 1) { newHeight /= 2; imageSize = rowSize * newHeight; }

+       if (newDepth > 1) newDepth /= 2;

+       {

+	  /* call tex image with srcImage untouched since it's not padded */

+	  if (baseLevel <= level && level <= maxLevel) {

+	    gluTexImage3D(target, level, internalFormat, newWidth, newHeight,

+			 newDepth,0, format, type, (void *) srcImage);

+	  }

+       }

+   } /* for level */

+   glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);

+   glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);

+   glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);

+   glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);

+   glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);

+   glPixelStorei(GL_UNPACK_SKIP_IMAGES, psm.unpack_skip_images);

+   glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, psm.unpack_image_height);

+

+   free(srcImage); /*if you get to here, a srcImage has always been malloc'ed*/

+   if (dstImage) { /* if it's non-rectangular and only 1 level */

+     free(dstImage);

+   }

+   return 0;

+} /* gluBuild3DMipmapLevelsCore() */

+

+GLint GLAPIENTRY

+gluBuild3DMipmapLevels(GLenum target, GLint internalFormat,

+			     GLsizei width, GLsizei height, GLsizei depth,

+			     GLenum format, GLenum type,

+			     GLint userLevel, GLint baseLevel, GLint maxLevel,

+			     const void *data)

+{

+   int level, levels;

+

+   int rc= checkMipmapArgs(internalFormat,format,type);

+   if (rc != 0) return rc;

+

+   if (width < 1 || height < 1 || depth < 1) {

+       return GLU_INVALID_VALUE;

+   }

+

+   if(type == GL_BITMAP) {

+      return GLU_INVALID_ENUM;

+   }

+

+   levels = computeLog(width);

+   level = computeLog(height);

+   if (level > levels) levels=level;

+   level = computeLog(depth);

+   if (level > levels) levels=level;

+

+   levels+= userLevel;

+   if (!isLegalLevels(userLevel,baseLevel,maxLevel,levels))

+      return GLU_INVALID_VALUE;

+

+   return gluBuild3DMipmapLevelsCore(target, internalFormat,

+				     width, height, depth,

+				     width, height, depth,

+				     format, type,

+				     userLevel, baseLevel, maxLevel,

+				     data);

+} /* gluBuild3DMipmapLevels() */

+

+GLint GLAPIENTRY

+gluBuild3DMipmaps(GLenum target, GLint internalFormat,

+			GLsizei width, GLsizei height, GLsizei depth,

+			GLenum format, GLenum type, const void *data)

+{

+   GLint widthPowerOf2, heightPowerOf2, depthPowerOf2;

+   int level, levels;

+

+   int rc= checkMipmapArgs(internalFormat,format,type);

+   if (rc != 0) return rc;

+

+   if (width < 1 || height < 1 || depth < 1) {

+       return GLU_INVALID_VALUE;

+   }

+

+   if(type == GL_BITMAP) {

+      return GLU_INVALID_ENUM;

+   }

+

+   closestFit3D(target,width,height,depth,internalFormat,format,type,

+		&widthPowerOf2,&heightPowerOf2,&depthPowerOf2);

+

+   levels = computeLog(widthPowerOf2);

+   level = computeLog(heightPowerOf2);

+   if (level > levels) levels=level;

+   level = computeLog(depthPowerOf2);

+   if (level > levels) levels=level;

+

+   return gluBuild3DMipmapLevelsCore(target, internalFormat,

+				     width, height, depth,

+				     widthPowerOf2, heightPowerOf2,

+				     depthPowerOf2,

+				     format, type, 0, 0, levels,

+				     data);

+} /* gluBuild3DMipmaps() */

+

+static GLdouble extractUbyte(int isSwap, const void *ubyte)

+{

+   isSwap= isSwap;		/* turn off warnings */

+

+   assert(*((const GLubyte *)ubyte) <= 255);

+

+   return (GLdouble)(*((const GLubyte *)ubyte));

+} /* extractUbyte() */

+

+static void shoveUbyte(GLdouble value, int index, void *data)

+{

+   assert(0.0 <= value && value < 256.0);

+

+   ((GLubyte *)data)[index]= (GLubyte)value;

+} /* shoveUbyte() */

+

+static GLdouble extractSbyte(int isSwap, const void *sbyte)

+{

+   isSwap= isSwap;		/* turn off warnings */

+

+   assert(*((const GLbyte *)sbyte) <= 127);

+

+   return (GLdouble)(*((const GLbyte *)sbyte));

+} /* extractSbyte() */

+

+static void shoveSbyte(GLdouble value, int index, void *data)

+{

+   ((GLbyte *)data)[index]= (GLbyte)value;

+} /* shoveSbyte() */

+

+static GLdouble extractUshort(int isSwap, const void *uitem)

+{

+   GLushort ushort;

+

+   if (isSwap) {

+     ushort= __GLU_SWAP_2_BYTES(uitem);

+   }

+   else {

+     ushort= *(const GLushort *)uitem;

+   }

+

+   assert(ushort <= 65535);

+

+   return (GLdouble)ushort;

+} /* extractUshort() */

+

+static void shoveUshort(GLdouble value, int index, void *data)

+{

+   assert(0.0 <= value && value < 65536.0);

+

+   ((GLushort *)data)[index]= (GLushort)value;

+} /* shoveUshort() */

+

+static GLdouble extractSshort(int isSwap, const void *sitem)

+{

+   GLshort sshort;

+

+   if (isSwap) {

+     sshort= __GLU_SWAP_2_BYTES(sitem);

+   }

+   else {

+     sshort= *(const GLshort *)sitem;

+   }

+

+   assert(sshort <= 32767);

+

+   return (GLdouble)sshort;

+} /* extractSshort() */

+

+static void shoveSshort(GLdouble value, int index, void *data)

+{

+   assert(0.0 <= value && value < 32768.0);

+

+   ((GLshort *)data)[index]= (GLshort)value;

+} /* shoveSshort() */

+

+static GLdouble extractUint(int isSwap, const void *uitem)

+{

+   GLuint uint;

+

+   if (isSwap) {

+     uint= __GLU_SWAP_4_BYTES(uitem);

+   }

+   else {

+     uint= *(const GLuint *)uitem;

+   }

+

+   assert(uint <= 0xffffffff);

+

+   return (GLdouble)uint;

+} /* extractUint() */

+

+static void shoveUint(GLdouble value, int index, void *data)

+{

+   assert(0.0 <= value && value <= (GLdouble) UINT_MAX);

+

+   ((GLuint *)data)[index]= (GLuint)value;

+} /* shoveUint() */

+

+static GLdouble extractSint(int isSwap, const void *sitem)

+{

+   GLint sint;

+

+   if (isSwap) {

+     sint= __GLU_SWAP_4_BYTES(sitem);

+   }

+   else {

+     sint= *(const GLint *)sitem;

+   }

+

+   assert(sint <= 0x7fffffff);

+

+   return (GLdouble)sint;

+} /* extractSint() */

+

+static void shoveSint(GLdouble value, int index, void *data)

+{

+   assert(0.0 <= value && value <= (GLdouble) INT_MAX);

+

+   ((GLint *)data)[index]= (GLint)value;

+} /* shoveSint() */

+

+static GLdouble extractFloat(int isSwap, const void *item)

+{

+   GLfloat ffloat;

+

+   if (isSwap) {

+     ffloat= __GLU_SWAP_4_BYTES(item);

+   }

+   else {

+     ffloat= *(const GLfloat *)item;

+   }

+

+   assert(ffloat <= 1.0);

+

+   return (GLdouble)ffloat;

+} /* extractFloat() */

+

+static void shoveFloat(GLdouble value, int index, void *data)

+{

+   assert(0.0 <= value && value <= 1.0);

+

+   ((GLfloat *)data)[index]= value;

+} /* shoveFloat() */

+

+static void halveImageSlice(int components,

+			    GLdouble (*extract)(int, const void *),

+			    void (*shove)(GLdouble, int, void *),

+			    GLint width, GLint height, GLint depth,

+			    const void *dataIn, void *dataOut,

+			    GLint elementSizeInBytes,

+			    GLint groupSizeInBytes,

+			    GLint rowSizeInBytes,

+			    GLint imageSizeInBytes,

+			    GLint isSwap)

+{

+   int ii, jj;

+   int halfWidth= width / 2;

+   int halfHeight= height / 2;

+   int halfDepth= depth / 2;

+   const char *src= (const char *)dataIn;

+   int rowPadBytes= rowSizeInBytes - (width * groupSizeInBytes);

+   int imagePadBytes= imageSizeInBytes - (width*height*groupSizeInBytes);

+   int outIndex= 0;

+

+   assert((width == 1 || height == 1) && depth >= 2);

+

+   if (width == height) {	/* a 1-pixel column viewed from top */

+      /* printf("1-column\n");*/

+      assert(width == 1 && height == 1);

+      assert(depth >= 2);

+

+      for (ii= 0; ii< halfDepth; ii++) {

+	 int cc;

+

+	 for (cc = 0; cc < components; cc++) {

+	    double totals[4];

+	    double extractTotals[BOX2][4];

+	    int kk;

+

+	    extractTotals[0][cc]= (*extract)(isSwap,src);

+	    extractTotals[1][cc]= (*extract)(isSwap,(src+imageSizeInBytes));

+

+	    /* average 2 pixels since only a column */

+	    totals[cc]= 0.0;

+	    /* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED];

+	     * totals[RED]/= 2.0;

+	     */

+	    for (kk = 0; kk < BOX2; kk++) {

+	      totals[cc]+= extractTotals[kk][cc];

+	    }

+	    totals[cc]/= (double)BOX2;

+

+	    (*shove)(totals[cc],outIndex,dataOut);

+	    outIndex++;

+	    src+= elementSizeInBytes;

+	 } /* for cc */

+

+	 /* skip over to next group of 2 */

+	 src+= rowSizeInBytes;

+      } /* for ii */

+

+      assert(src == &((const char *)dataIn)[rowSizeInBytes*height*depth]);

+      assert(outIndex == halfDepth * components);

+   }

+   else if (height == 1) {	/* horizontal slice viewed from top */

+      /* printf("horizontal slice\n"); */

+      assert(width != 1);

+

+      for (ii= 0; ii< halfDepth; ii++) {

+	 for (jj= 0; jj< halfWidth; jj++) {

+	    int cc;

+

+	    for (cc = 0; cc < components; cc++) {

+	       int kk;

+	       double totals[4];

+	       double extractTotals[BOX4][4];

+

+	       extractTotals[0][cc]=(*extract)(isSwap,src);

+	       extractTotals[1][cc]=(*extract)(isSwap,

+					       (src+groupSizeInBytes));

+	       extractTotals[2][cc]=(*extract)(isSwap,

+					       (src+imageSizeInBytes));

+	       extractTotals[3][cc]=(*extract)(isSwap,

+					       (src+imageSizeInBytes+groupSizeInBytes));

+

+	       /* grab 4 pixels to average */

+	       totals[cc]= 0.0;

+	       /* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED]+

+		*	       extractTotals[2][RED]+extractTotals[3][RED];

+		* totals[RED]/= 4.0;

+		*/

+	       for (kk = 0; kk < BOX4; kk++) {

+		  totals[cc]+= extractTotals[kk][cc];

+	       }

+	       totals[cc]/= (double)BOX4;

+

+	       (*shove)(totals[cc],outIndex,dataOut);

+	       outIndex++;

+

+	       src+= elementSizeInBytes;

+	    } /* for cc */

+

+	    /* skip over to next horizontal square of 4 */

+	    src+= groupSizeInBytes;

+	 } /* for jj */

+	 src+= rowPadBytes;

+

+	 src+= rowSizeInBytes;

+      } /* for ii */

+

+      assert(src == &((const char *)dataIn)[rowSizeInBytes*height*depth]);

+      assert(outIndex == halfWidth * halfDepth * components);

+   }

+   else if (width == 1) {	/* vertical slice viewed from top */

+      /* printf("vertical slice\n"); */

+      assert(height != 1);

+

+      for (ii= 0; ii< halfDepth; ii++) {

+	 for (jj= 0; jj< halfHeight; jj++) {

+	    int cc;

+

+	    for (cc = 0; cc < components; cc++) {

+	       int kk;

+	       double totals[4];

+	       double extractTotals[BOX4][4];

+

+	       extractTotals[0][cc]=(*extract)(isSwap,src);

+	       extractTotals[1][cc]=(*extract)(isSwap,

+					       (src+rowSizeInBytes));

+	       extractTotals[2][cc]=(*extract)(isSwap,

+					       (src+imageSizeInBytes));

+	       extractTotals[3][cc]=(*extract)(isSwap,

+					       (src+imageSizeInBytes+rowSizeInBytes));

+

+	       /* grab 4 pixels to average */

+	       totals[cc]= 0.0;

+	       /* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED]+

+		*	       extractTotals[2][RED]+extractTotals[3][RED];

+		* totals[RED]/= 4.0;

+		*/

+	       for (kk = 0; kk < BOX4; kk++) {

+		  totals[cc]+= extractTotals[kk][cc];

+	       }

+	       totals[cc]/= (double)BOX4;

+

+	       (*shove)(totals[cc],outIndex,dataOut);

+	       outIndex++;

+

+	       src+= elementSizeInBytes;

+	    } /* for cc */

+	    src+= rowPadBytes;

+

+	    /* skip over to next vertical square of 4 */

+	    src+= rowSizeInBytes;

+	 } /* for jj */

+         src+= imagePadBytes;

+

+	 src+= imageSizeInBytes;

+      } /* for ii */

+

+      assert(src == &((const char *)dataIn)[rowSizeInBytes*height*depth]);

+      assert(outIndex == halfHeight * halfDepth * components);

+   }

+

+} /* halveImageSlice() */

+

+static void halveImage3D(int components,

+			 GLdouble (*extract)(int, const void *),

+			 void (*shove)(GLdouble, int, void *),

+			 GLint width, GLint height, GLint depth,

+			 const void *dataIn, void *dataOut,

+			 GLint elementSizeInBytes,

+			 GLint groupSizeInBytes,

+			 GLint rowSizeInBytes,

+			 GLint imageSizeInBytes,

+			 GLint isSwap)

+{

+   assert(depth > 1);

+

+   /* a horizontal/vertical/one-column slice viewed from top */

+   if (width == 1 || height == 1) {

+      assert(1 <= depth);

+

+      halveImageSlice(components,extract,shove, width, height, depth,

+		      dataIn, dataOut, elementSizeInBytes, groupSizeInBytes,

+		      rowSizeInBytes, imageSizeInBytes, isSwap);

+      return;

+   }

+   {

+      int ii, jj, dd;

+

+      int halfWidth= width / 2;

+      int halfHeight= height / 2;

+      int halfDepth= depth / 2;

+      const char *src= (const char *) dataIn;

+      int rowPadBytes= rowSizeInBytes - (width*groupSizeInBytes);

+      int imagePadBytes= imageSizeInBytes - (width*height*groupSizeInBytes);

+      int outIndex= 0;

+

+      for (dd= 0; dd < halfDepth; dd++) {

+	 for (ii= 0; ii< halfHeight; ii++) {

+	    for (jj= 0; jj< halfWidth; jj++) {

+	       int cc;

+

+	       for (cc= 0; cc < components; cc++) {

+		  int kk;

+#define BOX8 8

+		  double totals[4];	/* 4 is maximum components */

+		  double extractTotals[BOX8][4]; /* 4 is maximum components */

+

+		  extractTotals[0][cc]= (*extract)(isSwap,src);

+		  extractTotals[1][cc]= (*extract)(isSwap,

+						   (src+groupSizeInBytes));

+		  extractTotals[2][cc]= (*extract)(isSwap,

+						   (src+rowSizeInBytes));

+		  extractTotals[3][cc]= (*extract)(isSwap,

+						   (src+rowSizeInBytes+groupSizeInBytes));

+

+		  extractTotals[4][cc]= (*extract)(isSwap,

+						   (src+imageSizeInBytes));

+

+		  extractTotals[5][cc]= (*extract)(isSwap,

+						   (src+groupSizeInBytes+imageSizeInBytes));

+		  extractTotals[6][cc]= (*extract)(isSwap,

+						   (src+rowSizeInBytes+imageSizeInBytes));

+		  extractTotals[7][cc]= (*extract)(isSwap,

+						   (src+rowSizeInBytes+groupSizeInBytes+imageSizeInBytes));

+

+		  totals[cc]= 0.0;

+

+		  /* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED]+

+		   *		  extractTotals[2][RED]+extractTotals[3][RED]+

+		   *		  extractTotals[4][RED]+extractTotals[5][RED]+

+		   *		  extractTotals[6][RED]+extractTotals[7][RED];

+		   * totals[RED]/= 8.0;

+		   */

+		  for (kk = 0; kk < BOX8; kk++) {

+		     totals[cc]+= extractTotals[kk][cc];

+		  }

+		  totals[cc]/= (double)BOX8;

+

+		  (*shove)(totals[cc],outIndex,dataOut);

+

+		  outIndex++;

+

+		  src+= elementSizeInBytes; /* go to next component */

+	       } /* for cc */

+

+	       /* skip over to next square of 4 */

+	       src+= groupSizeInBytes;

+	    } /* for jj */

+	    /* skip past pad bytes, if any, to get to next row */

+	    src+= rowPadBytes;

+

+	    /* src is at beginning of a row here, but it's the second row of

+	     * the square block of 4 pixels that we just worked on so we

+	     * need to go one more row.

+	     * i.e.,

+	     *			 OO...

+	     *		 here -->OO...

+	     *	     but want -->OO...

+	     *			 OO...

+	     *			 ...

+	     */

+	    src+= rowSizeInBytes;

+	 } /* for ii */

+

+	 /* skip past pad bytes, if any, to get to next image */

+	 src+= imagePadBytes;

+

+	 src+= imageSizeInBytes;

+      } /* for dd */

+

+      /* both pointers must reach one byte after the end */

+      assert(src == &((const char *)dataIn)[rowSizeInBytes*height*depth]);

+      assert(outIndex == halfWidth * halfHeight * halfDepth * components);

+   }

+} /* halveImage3D() */

+

+

+

+/*** mipmap.c ***/

+