mipmap.c File Reference

#include "gluos.h"
#include <assert.h>
#include <GL/glu.h>
#include <math.h>

Include dependency graph for mipmap.c:

Go to the source code of this file.

Classes
union	Type_Widget
struct	PixelStorageModes

Macros
#define	__GLU_SWAP_2_BYTES(s)   (GLushort)(((GLushort)((const GLubyte*)(s))[1])<<8 | ((const GLubyte*)(s))[0])
#define	__GLU_SWAP_4_BYTES(s)
#define	BOX2   2
#define	BOX2   2
#define	BOX2   2
#define	BOX2   2
#define	BOX2   2
#define	BOX2   2
#define	BOX2   2
#define	BOX2   2
#define	BOX2   2
#define	BOX2   2
#define	__GLU_INIT_SWAP_IMAGE   void *tmpImage
#define	__GLU_SWAP_IMAGE(a, b)   tmpImage = a; a = b; b = tmpImage;
#define	BOX4   4
#define	BOX2   2
#define	BOX2   2
#define	gluTexImage3D   glTexImage3D
#define	BOX8   8
#define	BOX8   8

Functions
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 *)
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 *)
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)
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)
static void	retrieveStoreModes3D (PixelStorageModes *psm)
static int	computeLog (GLuint value)
static int	nearestPower (GLuint value)
static void	halveImage (GLint components, GLuint width, GLuint height, const GLushort *datain, GLushort *dataout)
static void	halveImage_ubyte (GLint components, GLuint width, GLuint height, const GLubyte *datain, GLubyte *dataout, GLint element_size, GLint ysize, GLint group_size)
static void	halveImage_byte (GLint components, GLuint width, GLuint height, const GLbyte *datain, GLbyte *dataout, GLint element_size, GLint ysize, GLint group_size)
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)
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)
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)
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)
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)
GLAPI GLint GLAPIENTRY	gluScaleImage (GLenum format, GLsizei widthin, GLsizei heightin, GLenum typein, const void *datain, GLsizei widthout, GLsizei heightout, GLenum typeout, void *dataout)
GLint GLAPIENTRY	gluBuild1DMipmapLevels (GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint userLevel, GLint baseLevel, GLint maxLevel, const void *data)
GLint GLAPIENTRY	gluBuild1DMipmaps (GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void *data)
static int	bitmapBuild2DMipmaps (GLenum target, GLint internalFormat, GLint width, GLint height, GLenum format, GLenum type, const void *data)
GLint GLAPIENTRY	gluBuild2DMipmapLevels (GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint userLevel, GLint baseLevel, GLint maxLevel, const void *data)
GLint GLAPIENTRY	gluBuild2DMipmaps (GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *data)
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)
static void	closestFit3D (GLenum target, GLint width, GLint height, GLint depth, GLint internalFormat, GLenum format, GLenum type, GLint *newWidth, GLint *newHeight, GLint *newDepth)
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)
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)
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)
GLint GLAPIENTRY	gluBuild3DMipmaps (GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data)

Macro Definition Documentation

__GLU_INIT_SWAP_IMAGE

#define __GLU_INIT_SWAP_IMAGE   void *tmpImage

Definition at line 3799 of file mipmap.c.

__GLU_SWAP_2_BYTES

#define __GLU_SWAP_2_BYTES

(

s

)

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

Definition at line 331 of file mipmap.c.

__GLU_SWAP_4_BYTES

#define __GLU_SWAP_4_BYTES

(

s

)

Value:

(GLuint)(((GLuint)((const GLubyte*)(s))[3])<<24 | \
        ((GLuint)((const GLubyte*)(s))[2])<<16 | \
        ((GLuint)((const GLubyte*)(s))[1])<<8  | ((const GLubyte*)(s))[0])

Definition at line 334 of file mipmap.c.

__GLU_SWAP_IMAGE

#define __GLU_SWAP_IMAGE	(		a,
			b
	)		tmpImage = a; a = b; b = tmpImage;

Definition at line 3800 of file mipmap.c.

BOX2 [1/12]

#define BOX2   2

BOX2 [2/12]

#define BOX2   2

BOX2 [3/12]

#define BOX2   2

BOX2 [4/12]

#define BOX2   2

BOX2 [5/12]

#define BOX2   2

BOX2 [6/12]

#define BOX2   2

BOX2 [7/12]

#define BOX2   2

BOX2 [8/12]

#define BOX2   2

BOX2 [9/12]

#define BOX2   2

BOX2 [10/12]

#define BOX2   2

BOX2 [11/12]

#define BOX2   2

BOX2 [12/12]

#define BOX2   2

BOX4

#define BOX4   4

BOX8 [1/2]

#define BOX8   8

BOX8 [2/2]

#define BOX8   8

gluTexImage3D

#define gluTexImage3D   glTexImage3D

Definition at line 6669 of file mipmap.c.

Function Documentation

bitmapBuild2DMipmaps()

static int bitmapBuild2DMipmaps ( GLenum  target, GLint  internalFormat, GLint  width, GLint  height, GLenum  format, GLenum  type, const void *  data  )

static

Definition at line 3696 of file mipmap.c.

{
    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;
}

Referenced by gluBuild2DMipmapLevelsCore().

bytes_per_element()

static GLfloat bytes_per_element ( GLenum  type )

static

Definition at line 4807 of file mipmap.c.

{
    /*
     * 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;
    }
}

Referenced by empty_image(), emptyImage3D(), fill_image(), fillImage3D(), gluBuild2DMipmapLevelsCore(), gluBuild3DMipmapLevelsCore(), image_size(), and imageSize3D().

checkMipmapArgs()

static int checkMipmapArgs ( GLenum  internalFormat, GLenum  format, GLenum  type  )

static

Definition at line 3270 of file mipmap.c.

{
    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() */

Referenced by gluBuild1DMipmapLevels(), gluBuild1DMipmapLevelsCore(), gluBuild1DMipmaps(), gluBuild2DMipmapLevels(), gluBuild2DMipmapLevelsCore(), gluBuild2DMipmaps(), gluBuild3DMipmapLevels(), gluBuild3DMipmapLevelsCore(), and gluBuild3DMipmaps().

closestFit()

static void closestFit ( GLenum  target, GLint  width, GLint  height, GLint  internalFormat, GLenum  format, GLenum  type, GLint *  newWidth, GLint *  newHeight  )

static

Definition at line 3410 of file mipmap.c.

{
   /* 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() */

Referenced by bitmapBuild2DMipmaps(), gluBuild1DMipmaps(), and gluBuild2DMipmaps().

closestFit3D()

static void closestFit3D ( GLenum  target, GLint  width, GLint  height, GLint  depth, GLint  internalFormat, GLenum  format, GLenum  type, GLint *  newWidth, GLint *  newHeight, GLint *  newDepth  )

static

Definition at line 7412 of file mipmap.c.

{
   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() */

Referenced by gluBuild3DMipmaps().

computeLog()

static int computeLog ( GLuint  value )

static

Definition at line 287 of file mipmap.c.

{
    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++;
    }
}

Referenced by bitmapBuild2DMipmaps(), gluBuild1DMipmapLevels(), gluBuild1DMipmapLevelsCore(), gluBuild1DMipmaps(), gluBuild2DMipmapLevels(), gluBuild2DMipmapLevelsCore(), gluBuild2DMipmaps(), gluBuild3DMipmapLevels(), gluBuild3DMipmapLevelsCore(), and gluBuild3DMipmaps().

elements_per_group()

static GLint elements_per_group ( GLenum  format, GLenum  type  )

static

Definition at line 4770 of file mipmap.c.

{
    /*
     * 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;
    }
}

Referenced by bitmapBuild2DMipmaps(), empty_image(), emptyImage3D(), fill_image(), fillImage3D(), gluBuild1DMipmapLevelsCore(), gluBuild2DMipmapLevelsCore(), gluBuild3DMipmapLevelsCore(), gluScaleImage(), gluScaleImage3D(), image_size(), and imageSize3D().

empty_image()

static void empty_image ( const PixelStorageModes *  psm, GLint  width, GLint  height, GLenum  format, GLenum  type, GLboolean  index_format, const GLushort *  oldimage, void *  userdata  )

static

Definition at line 5141 of file mipmap.c.

{
    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() */

Referenced by gluScaleImage().

emptyImage3D()

static void emptyImage3D ( const PixelStorageModes *  psm, GLint  width, GLint  height, GLint  depth, GLenum  format, GLenum  type, GLboolean  indexFormat, const GLushort *  oldImage, void *  userImage  )

static

Definition at line 7050 of file mipmap.c.

{
   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() */

Referenced by gluScaleImage3D().

extract1010102()

static void extract1010102 ( int  isSwap, const void *  packedPixel, GLfloat  extractComponents[]  )

static

Definition at line 5917 of file mipmap.c.

{
   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() */

Referenced by fill_image(), fillImage3D(), gluBuild2DMipmapLevelsCore(), and gluBuild3DMipmapLevelsCore().

extract1555rev()

static void extract1555rev ( int  isSwap, const void *  packedPixel, GLfloat  extractComponents[]  )

static

Definition at line 5773 of file mipmap.c.

{
   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() */

Referenced by fill_image(), fillImage3D(), gluBuild2DMipmapLevelsCore(), and gluBuild3DMipmapLevelsCore().

extract2101010rev()

static void extract2101010rev ( int  isSwap, const void *  packedPixel, GLfloat  extractComponents[]  )

static

Definition at line 5965 of file mipmap.c.

{
   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() */

Referenced by fill_image(), fillImage3D(), gluBuild2DMipmapLevelsCore(), and gluBuild3DMipmapLevelsCore().

extract233rev()

static void extract233rev ( int  isSwap, const void *  packedPixel, GLfloat  extractComponents[]  )

static

Definition at line 5518 of file mipmap.c.

{
   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() */

Referenced by fill_image(), fillImage3D(), gluBuild2DMipmapLevelsCore(), and gluBuild3DMipmapLevelsCore().

extract332()

static void extract332 ( int  isSwap, const void *  packedPixel, GLfloat  extractComponents[]  )

static

Definition at line 5482 of file mipmap.c.

{
   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() */

Referenced by fill_image(), fillImage3D(), gluBuild2DMipmapLevelsCore(), and gluBuild3DMipmapLevelsCore().

extract4444()

static void extract4444 ( int  isSwap, const void *  packedPixel, GLfloat  extractComponents[]  )

static

Definition at line 5636 of file mipmap.c.

{
   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() */

Referenced by fill_image(), fillImage3D(), gluBuild2DMipmapLevelsCore(), and gluBuild3DMipmapLevelsCore().

extract4444rev()

static void extract4444rev ( int  isSwap, const void *  packedPixel, GLfloat  extractComponents[]  )

static

Definition at line 5678 of file mipmap.c.

{
   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() */

Referenced by fill_image(), fillImage3D(), gluBuild2DMipmapLevelsCore(), and gluBuild3DMipmapLevelsCore().

extract5551()

static void extract5551 ( int  isSwap, const void *  packedPixel, GLfloat  extractComponents[]  )

static

Definition at line 5726 of file mipmap.c.

{
   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() */

Referenced by fill_image(), fillImage3D(), gluBuild2DMipmapLevelsCore(), and gluBuild3DMipmapLevelsCore().

extract565()

static void extract565 ( int  isSwap, const void *  packedPixel, GLfloat  extractComponents[]  )

static

Definition at line 5554 of file mipmap.c.

{
   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() */

Referenced by fill_image(), fillImage3D(), gluBuild2DMipmapLevelsCore(), and gluBuild3DMipmapLevelsCore().

extract565rev()

static void extract565rev ( int  isSwap, const void *  packedPixel, GLfloat  extractComponents[]  )

static

Definition at line 5595 of file mipmap.c.

{
   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() */

Referenced by fill_image(), fillImage3D(), gluBuild2DMipmapLevelsCore(), and gluBuild3DMipmapLevelsCore().

extract8888()

static void extract8888 ( int  isSwap, const void *  packedPixel, GLfloat  extractComponents[]  )

static

Definition at line 5821 of file mipmap.c.

{
   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() */

Referenced by fill_image(), fillImage3D(), gluBuild2DMipmapLevelsCore(), and gluBuild3DMipmapLevelsCore().

extract8888rev()

static void extract8888rev ( int  isSwap, const void *  packedPixel, GLfloat  extractComponents[]  )

static

Definition at line 5869 of file mipmap.c.

{
   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() */

Referenced by fill_image(), fillImage3D(), gluBuild2DMipmapLevelsCore(), and gluBuild3DMipmapLevelsCore().

extractFloat()

static GLdouble extractFloat ( int  isSwap, const void *  item  )

static

Definition at line 8641 of file mipmap.c.

{
   GLfloat ffloat;
 
   if (isSwap) {
     ffloat= __GLU_SWAP_4_BYTES(item);
   }
   else {
     ffloat= *(const GLfloat *)item;
   }
 
   assert(ffloat <= 1.0);
 
   return (GLdouble)ffloat;
} /* extractFloat() */

Referenced by gluBuild3DMipmapLevelsCore().

extractSbyte()

static GLdouble extractSbyte ( int  isSwap, const void *  sbyte  )

static

Definition at line 8535 of file mipmap.c.

{
   isSwap= isSwap;      /* turn off warnings */
 
   assert(*((const GLbyte *)sbyte) <= 127);
 
   return (GLdouble)(*((const GLbyte *)sbyte));
} /* extractSbyte() */

Referenced by gluBuild3DMipmapLevelsCore().

extractSint()

static GLdouble extractSint ( int  isSwap, const void *  sitem  )

static

Definition at line 8618 of file mipmap.c.

{
   GLint sint;
 
   if (isSwap) {
     sint= __GLU_SWAP_4_BYTES(sitem);
   }
   else {
     sint= *(const GLint *)sitem;
   }
 
   assert(sint <= 0x7fffffff);
 
   return (GLdouble)sint;
} /* extractSint() */

Referenced by gluBuild3DMipmapLevelsCore().

extractSshort()

static GLdouble extractSshort ( int  isSwap, const void *  sitem  )

static

Definition at line 8572 of file mipmap.c.

{
   GLshort sshort;
 
   if (isSwap) {
     sshort= __GLU_SWAP_2_BYTES(sitem);
   }
   else {
     sshort= *(const GLshort *)sitem;
   }
 
   assert(sshort <= 32767);
 
   return (GLdouble)sshort;
} /* extractSshort() */

Referenced by gluBuild3DMipmapLevelsCore().

extractUbyte()

static GLdouble extractUbyte ( int  isSwap, const void *  ubyte  )

static

Definition at line 8519 of file mipmap.c.

{
   isSwap= isSwap;      /* turn off warnings */
 
   assert(*((const GLubyte *)ubyte) <= 255);
 
   return (GLdouble)(*((const GLubyte *)ubyte));
} /* extractUbyte() */

Referenced by gluBuild3DMipmapLevelsCore().

extractUint()

static GLdouble extractUint ( int  isSwap, const void *  uitem  )

static

Definition at line 8595 of file mipmap.c.

{
   GLuint uint;
 
   if (isSwap) {
     uint= __GLU_SWAP_4_BYTES(uitem);
   }
   else {
     uint= *(const GLuint *)uitem;
   }
 
   assert(uint <= 0xffffffff);
 
   return (GLdouble)uint;
} /* extractUint() */

Referenced by gluBuild3DMipmapLevelsCore().

extractUshort()

static GLdouble extractUshort ( int  isSwap, const void *  uitem  )

static

Definition at line 8549 of file mipmap.c.

{
   GLushort ushort;
 
   if (isSwap) {
     ushort= __GLU_SWAP_2_BYTES(uitem);
   }
   else {
     ushort= *(const GLushort *)uitem;
   }
 
   assert(ushort <= 65535);
 
   return (GLdouble)ushort;
} /* extractUshort() */

Referenced by gluBuild3DMipmapLevelsCore().

fill_image()

static void fill_image ( const PixelStorageModes *  psm, GLint  width, GLint  height, GLenum  format, GLenum  type, GLboolean  index_format, const void *  userdata, GLushort *  newimage  )

static

Definition at line 4878 of file mipmap.c.

{
    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() */

Referenced by bitmapBuild2DMipmaps(), gluBuild1DMipmapLevelsCore(), and gluScaleImage().

fillImage3D()

static void fillImage3D ( const PixelStorageModes *  psm, GLint  width, GLint  height, GLint  depth, GLenum  format, GLenum  type, GLboolean  indexFormat, const void *  userImage, GLushort *  newImage  )

static

Definition at line 6685 of file mipmap.c.

{
   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 () */

Referenced by gluScaleImage3D().

gluBuild1DMipmapLevels()

GLint GLAPIENTRY gluBuild1DMipmapLevels	(	GLenum	target,
		GLint	internalFormat,
		GLsizei	width,
		GLenum	format,
		GLenum	type,
		GLint	userLevel,
		GLint	baseLevel,
		GLint	maxLevel,
		const void *	data
	)

Definition at line 3643 of file mipmap.c.

{
   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() */

gluBuild1DMipmapLevelsCore()

int gluBuild1DMipmapLevelsCore ( GLenum  target, GLint  internalFormat, GLsizei  width, GLsizei  widthPowerOf2, GLenum  format, GLenum  type, GLint  userLevel, GLint  baseLevel, GLint  maxLevel, const void *  data  )

static

Definition at line 3547 of file mipmap.c.

{
    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;
}

Referenced by gluBuild1DMipmapLevels(), and gluBuild1DMipmaps().

gluBuild1DMipmaps()

GLint GLAPIENTRY gluBuild1DMipmaps	(	GLenum	target,
		GLint	internalFormat,
		GLsizei	width,
		GLenum	format,
		GLenum	type,
		const void *	data
	)

Definition at line 3672 of file mipmap.c.

{
   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);
}

gluBuild2DMipmapLevels()

GLint GLAPIENTRY gluBuild2DMipmapLevels	(	GLenum	target,
		GLint	internalFormat,
		GLsizei	width,
		GLsizei	height,
		GLenum	format,
		GLenum	type,
		GLint	userLevel,
		GLint	baseLevel,
		GLint	maxLevel,
		const void *	data
	)

Definition at line 4554 of file mipmap.c.

{
   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() */

gluBuild2DMipmapLevelsCore()

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  )

static

Definition at line 3802 of file mipmap.c.

{
    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);
         free(srcImage);
         free(dstImage);
         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() */

Referenced by gluBuild2DMipmapLevels(), and gluBuild2DMipmaps().

gluBuild2DMipmaps()

GLint GLAPIENTRY gluBuild2DMipmaps	(	GLenum	target,
		GLint	internalFormat,
		GLsizei	width,
		GLsizei	height,
		GLenum	format,
		GLenum	type,
		const void *	data
	)

Definition at line 4586 of file mipmap.c.

{
   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() */

gluBuild3DMipmapLevels()

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
	)

Definition at line 8446 of file mipmap.c.

{
   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() */

gluBuild3DMipmapLevelsCore()

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  )

static

Definition at line 7722 of file mipmap.c.

{
   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() */

Referenced by gluBuild3DMipmapLevels(), and gluBuild3DMipmaps().

gluBuild3DMipmaps()

GLint GLAPIENTRY gluBuild3DMipmaps	(	GLenum	target,
		GLint	internalFormat,
		GLsizei	width,
		GLsizei	height,
		GLsizei	depth,
		GLenum	format,
		GLenum	type,
		const void *	data
	)

Definition at line 8484 of file mipmap.c.

{
   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() */

gluScaleImage()

GLAPI GLint GLAPIENTRY gluScaleImage	(	GLenum	format,
		GLsizei	widthin,
		GLsizei	heightin,
		GLenum	typein,
		const void *	datain,
		GLsizei	widthout,
		GLsizei	heightout,
		GLenum	typeout,
		void *	dataout
	)

Definition at line 3498 of file mipmap.c.

{
    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;