src/glu/sgi/libutil/mipmap.c

   1 /*
   2  * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
   3  * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice including the dates of first publication and
  13  * either this permission notice or a reference to
  14  * http://oss.sgi.com/projects/FreeB/
  15  * shall be included in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  20  * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  21  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  22  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  23  * SOFTWARE.
  24  *
  25  * Except as contained in this notice, the name of Silicon Graphics, Inc.
  26  * shall not be used in advertising or otherwise to promote the sale, use or
  27  * other dealings in this Software without prior written authorization from
  28  * Silicon Graphics, Inc.
  29  */
  30
  31 #include "gluos.h"
  32 #include <assert.h>
  33 #include <GL/glu.h>
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <string.h>
  37 #include <limits.h>             /* UINT_MAX */
  38 #include <math.h>
  39 #include "gluint.h"
  40
  41 typedef union {
  42     unsigned char ub[4];
  43     unsigned short us[2];
  44     unsigned int ui;
  45     char b[4];
  46     short s[2];
  47     int i;
  48     float f;
  49 } Type_Widget;
  50
  51 /* Pixel storage modes */
  52 typedef struct {
  53    GLint pack_alignment;
  54    GLint pack_row_length;
  55    GLint pack_skip_rows;
  56    GLint pack_skip_pixels;
  57    GLint pack_lsb_first;
  58    GLint pack_swap_bytes;
  59    GLint pack_skip_images;
  60    GLint pack_image_height;
  61
  62    GLint unpack_alignment;
  63    GLint unpack_row_length;
  64    GLint unpack_skip_rows;
  65    GLint unpack_skip_pixels;
  66    GLint unpack_lsb_first;
  67    GLint unpack_swap_bytes;
  68    GLint unpack_skip_images;
  69    GLint unpack_image_height;
  70 } PixelStorageModes;
  71
  72 static int gluBuild1DMipmapLevelsCore(GLenum, GLint,
  73                                       GLsizei,
  74                                       GLsizei,
  75                                       GLenum, GLenum, GLint, GLint, GLint,
  76                                       const void *);
  77 static int gluBuild2DMipmapLevelsCore(GLenum, GLint,
  78                                       GLsizei, GLsizei,
  79                                       GLsizei, GLsizei,
  80                                       GLenum, GLenum, GLint, GLint, GLint,
  81                                       const void *);
  82 static int gluBuild3DMipmapLevelsCore(GLenum, GLint,
  83                                       GLsizei, GLsizei, GLsizei,
  84                                       GLsizei, GLsizei, GLsizei,
  85                                       GLenum, GLenum, GLint, GLint, GLint,
  86                                       const void *);
  87
  88 /*
  89  * internal function declarations
  90  */
  91 static GLfloat bytes_per_element(GLenum type);
  92 static GLint elements_per_group(GLenum format, GLenum type);
  93 static GLint is_index(GLenum format);
  94 static GLint image_size(GLint width, GLint height, GLenum format, GLenum type);
  95 static void fill_image(const PixelStorageModes *,
  96                        GLint width, GLint height, GLenum format,
  97                        GLenum type, GLboolean index_format,
  98                        const void *userdata, GLushort *newimage);
  99 static void empty_image(const PixelStorageModes *,
 100                         GLint width, GLint height, GLenum format,
 101                         GLenum type, GLboolean index_format,
 102                         const GLushort *oldimage, void *userdata);
 103 static void scale_internal(GLint components, GLint widthin, GLint heightin,
 104                            const GLushort *datain,
 105                            GLint widthout, GLint heightout,
 106                            GLushort *dataout);
 107
 108 static void scale_internal_ubyte(GLint components, GLint widthin,
 109                            GLint heightin, const GLubyte *datain,
 110                            GLint widthout, GLint heightout,
 111                            GLubyte *dataout, GLint element_size,
 112                            GLint ysize, GLint group_size);
 113 static void scale_internal_byte(GLint components, GLint widthin,
 114                            GLint heightin, const GLbyte *datain,
 115                            GLint widthout, GLint heightout,
 116                            GLbyte *dataout, GLint element_size,
 117                            GLint ysize, GLint group_size);
 118 static void scale_internal_ushort(GLint components, GLint widthin,
 119                            GLint heightin, const GLushort *datain,
 120                            GLint widthout, GLint heightout,
 121                            GLushort *dataout, GLint element_size,
 122                            GLint ysize, GLint group_size,
 123                            GLint myswap_bytes);
 124 static void scale_internal_short(GLint components, GLint widthin,
 125                            GLint heightin, const GLshort *datain,
 126                            GLint widthout, GLint heightout,
 127                            GLshort *dataout, GLint element_size,
 128                            GLint ysize, GLint group_size,
 129                            GLint myswap_bytes);
 130 static void scale_internal_uint(GLint components, GLint widthin,
 131                            GLint heightin, const GLuint *datain,
 132                            GLint widthout, GLint heightout,
 133                            GLuint *dataout, GLint element_size,
 134                            GLint ysize, GLint group_size,
 135                            GLint myswap_bytes);
 136 static void scale_internal_int(GLint components, GLint widthin,
 137                            GLint heightin, const GLint *datain,
 138                            GLint widthout, GLint heightout,
 139                            GLint *dataout, GLint element_size,
 140                            GLint ysize, GLint group_size,
 141                            GLint myswap_bytes);
 142 static void scale_internal_float(GLint components, GLint widthin,
 143                            GLint heightin, const GLfloat *datain,
 144                            GLint widthout, GLint heightout,
 145                            GLfloat *dataout, GLint element_size,
 146                            GLint ysize, GLint group_size,
 147                            GLint myswap_bytes);
 148
 149 static int checkMipmapArgs(GLenum, GLenum, GLenum);
 150 static GLboolean legalFormat(GLenum);
 151 static GLboolean legalType(GLenum);
 152 static GLboolean isTypePackedPixel(GLenum);
 153 static GLboolean isLegalFormatForPackedPixelType(GLenum, GLenum);
 154 static GLboolean isLegalLevels(GLint, GLint, GLint, GLint);
 155 static void closestFit(GLenum, GLint, GLint, GLint, GLenum, GLenum,
 156                        GLint *, GLint *);
 157
 158 /* all extract/shove routines must return double to handle unsigned ints */
 159 static GLdouble extractUbyte(int, const void *);
 160 static void shoveUbyte(GLdouble, int, void *);
 161 static GLdouble extractSbyte(int, const void *);
 162 static void shoveSbyte(GLdouble, int, void *);
 163 static GLdouble extractUshort(int, const void *);
 164 static void shoveUshort(GLdouble, int, void *);
 165 static GLdouble extractSshort(int, const void *);
 166 static void shoveSshort(GLdouble, int, void *);
 167 static GLdouble extractUint(int, const void *);
 168 static void shoveUint(GLdouble, int, void *);
 169 static GLdouble extractSint(int, const void *);
 170 static void shoveSint(GLdouble, int, void *);
 171 static GLdouble extractFloat(int, const void *);
 172 static void shoveFloat(GLdouble, int, void *);
 173 static void halveImageSlice(int, GLdouble (*)(int, const void *),
 174                             void (*)(GLdouble, int, void *),
 175                             GLint, GLint, GLint,
 176                             const void *, void *,
 177                             GLint, GLint, GLint, GLint, GLint);
 178 static void halveImage3D(int, GLdouble (*)(int, const void *),
 179                          void (*)(GLdouble, int, void *),
 180                          GLint, GLint, GLint,
 181                          const void *, void *,
 182                          GLint, GLint, GLint, GLint, GLint);
 183
 184 /* packedpixel type scale routines */
 185 static void extract332(int,const void *, GLfloat []);
 186 static void shove332(const GLfloat [],int ,void *);
 187 static void extract233rev(int,const void *, GLfloat []);
 188 static void shove233rev(const GLfloat [],int ,void *);
 189 static void extract565(int,const void *, GLfloat []);
 190 static void shove565(const GLfloat [],int ,void *);
 191 static void extract565rev(int,const void *, GLfloat []);
 192 static void shove565rev(const GLfloat [],int ,void *);
 193 static void extract4444(int,const void *, GLfloat []);
 194 static void shove4444(const GLfloat [],int ,void *);
 195 static void extract4444rev(int,const void *, GLfloat []);
 196 static void shove4444rev(const GLfloat [],int ,void *);
 197 static void extract5551(int,const void *, GLfloat []);
 198 static void shove5551(const GLfloat [],int ,void *);
 199 static void extract1555rev(int,const void *, GLfloat []);
 200 static void shove1555rev(const GLfloat [],int ,void *);
 201 static void extract8888(int,const void *, GLfloat []);
 202 static void shove8888(const GLfloat [],int ,void *);
 203 static void extract8888rev(int,const void *, GLfloat []);
 204 static void shove8888rev(const GLfloat [],int ,void *);
 205 static void extract1010102(int,const void *, GLfloat []);
 206 static void shove1010102(const GLfloat [],int ,void *);
 207 static void extract2101010rev(int,const void *, GLfloat []);
 208 static void shove2101010rev(const GLfloat [],int ,void *);
 209 static void scaleInternalPackedPixel(int,
 210                                      void (*)(int, const void *,GLfloat []),
 211                                      void (*)(const GLfloat [],int, void *),
 212                                      GLint,GLint, const void *,
 213                                      GLint,GLint,void *,GLint,GLint,GLint);
 214 static void halveImagePackedPixel(int,
 215                                   void (*)(int, const void *,GLfloat []),
 216                                   void (*)(const GLfloat [],int, void *),
 217                                   GLint, GLint, const void *,
 218                                   void *, GLint, GLint, GLint);
 219 static void halve1DimagePackedPixel(int,
 220                                     void (*)(int, const void *,GLfloat []),
 221                                     void (*)(const GLfloat [],int, void *),
 222                                     GLint, GLint, const void *,
 223                                     void *, GLint, GLint, GLint);
 224
 225 static void halve1Dimage_ubyte(GLint, GLuint, GLuint,const GLubyte *,
 226                                GLubyte *, GLint, GLint, GLint);
 227 static void halve1Dimage_byte(GLint, GLuint, GLuint,const GLbyte *, GLbyte *,
 228                               GLint, GLint, GLint);
 229 static void halve1Dimage_ushort(GLint, GLuint, GLuint, const GLushort *,
 230                                 GLushort *, GLint, GLint, GLint, GLint);
 231 static void halve1Dimage_short(GLint, GLuint, GLuint,const GLshort *, GLshort *,
 232                                GLint, GLint, GLint, GLint);
 233 static void halve1Dimage_uint(GLint, GLuint, GLuint, const GLuint *, GLuint *,
 234                               GLint, GLint, GLint, GLint);
 235 static void halve1Dimage_int(GLint, GLuint, GLuint, const GLint *, GLint *,
 236                              GLint, GLint, GLint, GLint);
 237 static void halve1Dimage_float(GLint, GLuint, GLuint, const GLfloat *, GLfloat *,
 238                                GLint, GLint, GLint, GLint);
 239
 240 static GLint imageSize3D(GLint, GLint, GLint, GLenum,GLenum);
 241 static void fillImage3D(const PixelStorageModes *, GLint, GLint, GLint,GLenum,
 242                         GLenum, GLboolean, const void *, GLushort *);
 243 static void emptyImage3D(const PixelStorageModes *,
 244                          GLint, GLint, GLint, GLenum,
 245                          GLenum, GLboolean,
 246                          const GLushort *, void *);
 247 static void scaleInternal3D(GLint, GLint, GLint, GLint, const GLushort *,
 248                             GLint, GLint, GLint, GLushort *);
 249
 250 static void retrieveStoreModes(PixelStorageModes *psm)
 251 {
 252     glGetIntegerv(GL_UNPACK_ALIGNMENT, &psm->unpack_alignment);
 253     glGetIntegerv(GL_UNPACK_ROW_LENGTH, &psm->unpack_row_length);
 254     glGetIntegerv(GL_UNPACK_SKIP_ROWS, &psm->unpack_skip_rows);
 255     glGetIntegerv(GL_UNPACK_SKIP_PIXELS, &psm->unpack_skip_pixels);
 256     glGetIntegerv(GL_UNPACK_LSB_FIRST, &psm->unpack_lsb_first);
 257     glGetIntegerv(GL_UNPACK_SWAP_BYTES, &psm->unpack_swap_bytes);
 258
 259     glGetIntegerv(GL_PACK_ALIGNMENT, &psm->pack_alignment);
 260     glGetIntegerv(GL_PACK_ROW_LENGTH, &psm->pack_row_length);
 261     glGetIntegerv(GL_PACK_SKIP_ROWS, &psm->pack_skip_rows);
 262     glGetIntegerv(GL_PACK_SKIP_PIXELS, &psm->pack_skip_pixels);
 263     glGetIntegerv(GL_PACK_LSB_FIRST, &psm->pack_lsb_first);
 264     glGetIntegerv(GL_PACK_SWAP_BYTES, &psm->pack_swap_bytes);
 265 }
 266
 267 static void retrieveStoreModes3D(PixelStorageModes *psm)
 268 {
 269     glGetIntegerv(GL_UNPACK_ALIGNMENT, &psm->unpack_alignment);
 270     glGetIntegerv(GL_UNPACK_ROW_LENGTH, &psm->unpack_row_length);
 271     glGetIntegerv(GL_UNPACK_SKIP_ROWS, &psm->unpack_skip_rows);
 272     glGetIntegerv(GL_UNPACK_SKIP_PIXELS, &psm->unpack_skip_pixels);
 273     glGetIntegerv(GL_UNPACK_LSB_FIRST, &psm->unpack_lsb_first);
 274     glGetIntegerv(GL_UNPACK_SWAP_BYTES, &psm->unpack_swap_bytes);
 275     glGetIntegerv(GL_UNPACK_SKIP_IMAGES, &psm->unpack_skip_images);
 276     glGetIntegerv(GL_UNPACK_IMAGE_HEIGHT, &psm->unpack_image_height);
 277
 278     glGetIntegerv(GL_PACK_ALIGNMENT, &psm->pack_alignment);
 279     glGetIntegerv(GL_PACK_ROW_LENGTH, &psm->pack_row_length);
 280     glGetIntegerv(GL_PACK_SKIP_ROWS, &psm->pack_skip_rows);
 281     glGetIntegerv(GL_PACK_SKIP_PIXELS, &psm->pack_skip_pixels);
 282     glGetIntegerv(GL_PACK_LSB_FIRST, &psm->pack_lsb_first);
 283     glGetIntegerv(GL_PACK_SWAP_BYTES, &psm->pack_swap_bytes);
 284     glGetIntegerv(GL_PACK_SKIP_IMAGES, &psm->pack_skip_images);
 285     glGetIntegerv(GL_PACK_IMAGE_HEIGHT, &psm->pack_image_height);
 286 }
 287
 288 static int computeLog(GLuint value)
 289 {
 290     int i;
 291
 292     i = 0;
 293
 294     /* Error! */
 295     if (value == 0) return -1;
 296
 297     for (;;) {
 298         if (value & 1) {
 299             /* Error ! */
 300             if (value != 1) return -1;
 301             return i;
 302         }
 303         value = value >> 1;
 304         i++;
 305     }
 306 }
 307
 308 /*
 309 ** Compute the nearest power of 2 number.  This algorithm is a little
 310 ** strange, but it works quite well.
 311 */
 312 static int nearestPower(GLuint value)
 313 {
 314     int i;
 315
 316     i = 1;
 317
 318     /* Error! */
 319     if (value == 0) return -1;
 320
 321     for (;;) {
 322         if (value == 1) {
 323             return i;
 324         } else if (value == 3) {
 325             return i*4;
 326         }
 327         value = value >> 1;
 328         i *= 2;
 329     }
 330 }
 331
 332 #define __GLU_SWAP_2_BYTES(s)\
 333 (GLushort)(((GLushort)((const GLubyte*)(s))[1])<<8 | ((const GLubyte*)(s))[0])
 334
 335 #define __GLU_SWAP_4_BYTES(s)\
 336 (GLuint)(((GLuint)((const GLubyte*)(s))[3])<<24 | \
 337         ((GLuint)((const GLubyte*)(s))[2])<<16 | \
 338         ((GLuint)((const GLubyte*)(s))[1])<<8  | ((const GLubyte*)(s))[0])
 339
 340 static void halveImage(GLint components, GLuint width, GLuint height,
 341                        const GLushort *datain, GLushort *dataout)
 342 {
 343     int i, j, k;
 344     int newwidth, newheight;
 345     int delta;
 346     GLushort *s;
 347     const GLushort *t;
 348
 349     newwidth = width / 2;
 350     newheight = height / 2;
 351     delta = width * components;
 352     s = dataout;
 353     t = datain;
 354
 355     /* Piece o' cake! */
 356     for (i = 0; i < newheight; i++) {
 357         for (j = 0; j < newwidth; j++) {
 358             for (k = 0; k < components; k++) {
 359                 s[0] = (t[0] + t[components] + t[delta] +
 360                         t[delta+components] + 2) / 4;
 361                 s++; t++;
 362             }
 363             t += components;
 364         }
 365         t += delta;
 366     }
 367 }
 368
 369 static void halveImage_ubyte(GLint components, GLuint width, GLuint height,
 370                         const GLubyte *datain, GLubyte *dataout,
 371                         GLint element_size, GLint ysize, GLint group_size)
 372 {
 373     int i, j, k;
 374     int newwidth, newheight;
 375     int padBytes;
 376     GLubyte *s;
 377     const char *t;
 378
 379     /* handle case where there is only 1 column/row */
 380     if (width == 1 || height == 1) {
 381        assert( !(width == 1 && height == 1) ); /* can't be 1x1 */
 382        halve1Dimage_ubyte(components,width,height,datain,dataout,
 383                           element_size,ysize,group_size);
 384        return;
 385     }
 386
 387     newwidth = width / 2;
 388     newheight = height / 2;
 389     padBytes = ysize - (width*group_size);
 390     s = dataout;
 391     t = (const char *)datain;
 392
 393     /* Piece o' cake! */
 394     for (i = 0; i < newheight; i++) {
 395         for (j = 0; j < newwidth; j++) {
 396             for (k = 0; k < components; k++) {
 397                 s[0] = (*(const GLubyte*)t +
 398                         *(const GLubyte*)(t+group_size) +
 399                         *(const GLubyte*)(t+ysize) +
 400                         *(const GLubyte*)(t+ysize+group_size) + 2) / 4;
 401                 s++; t += element_size;
 402             }
 403             t += group_size;
 404         }
 405         t += padBytes;
 406         t += ysize;
 407     }
 408 }
 409
 410 /* */
 411 static void halve1Dimage_ubyte(GLint components, GLuint width, GLuint height,
 412                                const GLubyte *dataIn, GLubyte *dataOut,
 413                                GLint element_size, GLint ysize,
 414                                GLint group_size)
 415 {
 416    GLint halfWidth= width / 2;
 417    GLint halfHeight= height / 2;
 418    const char *src= (const char *) dataIn;
 419    GLubyte *dest= dataOut;
 420    int jj;
 421
 422    assert(width == 1 || height == 1); /* must be 1D */
 423    assert(width != height);     /* can't be square */
 424
 425    if (height == 1) {           /* 1 row */
 426       assert(width != 1);       /* widthxheight can't be 1x1 */
 427       halfHeight= 1;
 428
 429       for (jj= 0; jj< halfWidth; jj++) {
 430          int kk;
 431          for (kk= 0; kk< components; kk++) {
 432             *dest= (*(const GLubyte*)src +
 433                  *(const GLubyte*)(src+group_size)) / 2;
 434
 435             src+= element_size;
 436             dest++;
 437          }
 438          src+= group_size;      /* skip to next 2 */
 439       }
 440       {
 441          int padBytes= ysize - (width*group_size);
 442          src+= padBytes;        /* for assertion only */
 443       }
 444    }
 445    else if (width == 1) {       /* 1 column */
 446       int padBytes= ysize - (width * group_size);
 447       assert(height != 1);      /* widthxheight can't be 1x1 */
 448       halfWidth= 1;
 449       /* one vertical column with possible pad bytes per row */
 450       /* average two at a time */
 451
 452       for (jj= 0; jj< halfHeight; jj++) {
 453          int kk;
 454          for (kk= 0; kk< components; kk++) {
 455             *dest= (*(const GLubyte*)src + *(const GLubyte*)(src+ysize)) / 2;
 456
 457             src+= element_size;
 458             dest++;
 459          }
 460          src+= padBytes; /* add pad bytes, if any, to get to end to row */
 461          src+= ysize;
 462       }
 463    }
 464
 465    assert(src == &((const char *)dataIn)[ysize*height]);
 466    assert((char *)dest == &((char *)dataOut)
 467           [components * element_size * halfWidth * halfHeight]);
 468 } /* halve1Dimage_ubyte() */
 469
 470 static void halveImage_byte(GLint components, GLuint width, GLuint height,
 471                         const GLbyte *datain, GLbyte *dataout,
 472                         GLint element_size,
 473                         GLint ysize, GLint group_size)
 474 {
 475     int i, j, k;
 476     int newwidth, newheight;
 477     int padBytes;
 478     GLbyte *s;
 479     const char *t;
 480
 481     /* handle case where there is only 1 column/row */
 482     if (width == 1 || height == 1) {
 483        assert( !(width == 1 && height == 1) ); /* can't be 1x1 */
 484        halve1Dimage_byte(components,width,height,datain,dataout,
 485                          element_size,ysize,group_size);
 486        return;
 487     }
 488
 489     newwidth = width / 2;
 490     newheight = height / 2;
 491     padBytes = ysize - (width*group_size);
 492     s = dataout;
 493     t = (const char *)datain;
 494
 495     /* Piece o' cake! */
 496     for (i = 0; i < newheight; i++) {
 497         for (j = 0; j < newwidth; j++) {
 498             for (k = 0; k < components; k++) {
 499                 s[0] = (*(const GLbyte*)t +
 500                         *(const GLbyte*)(t+group_size) +
 501                         *(const GLbyte*)(t+ysize) +
 502                         *(const GLbyte*)(t+ysize+group_size) + 2) / 4;
 503                 s++; t += element_size;
 504             }
 505             t += group_size;
 506         }
 507         t += padBytes;
 508         t += ysize;
 509     }
 510 }
 511
 512 static void halve1Dimage_byte(GLint components, GLuint width, GLuint height,
 513                               const GLbyte *dataIn, GLbyte *dataOut,
 514                               GLint element_size,GLint ysize, GLint group_size)
 515 {
 516    GLint halfWidth= width / 2;
 517    GLint halfHeight= height / 2;
 518    const char *src= (const char *) dataIn;
 519    GLbyte *dest= dataOut;
 520    int jj;
 521
 522    assert(width == 1 || height == 1); /* must be 1D */
 523    assert(width != height);     /* can't be square */
 524
 525    if (height == 1) {           /* 1 row */
 526       assert(width != 1);       /* widthxheight can't be 1x1 */
 527       halfHeight= 1;
 528
 529       for (jj= 0; jj< halfWidth; jj++) {
 530          int kk;
 531          for (kk= 0; kk< components; kk++) {
 532             *dest= (*(const GLbyte*)src + *(const GLbyte*)(src+group_size)) / 2;
 533
 534             src+= element_size;
 535             dest++;
 536          }
 537          src+= group_size;      /* skip to next 2 */
 538       }
 539       {
 540          int padBytes= ysize - (width*group_size);
 541          src+= padBytes;        /* for assertion only */
 542       }
 543    }
 544    else if (width == 1) {       /* 1 column */
 545       int padBytes= ysize - (width * group_size);
 546       assert(height != 1);      /* widthxheight can't be 1x1 */
 547       halfWidth= 1;
 548       /* one vertical column with possible pad bytes per row */
 549       /* average two at a time */
 550
 551       for (jj= 0; jj< halfHeight; jj++) {
 552          int kk;
 553          for (kk= 0; kk< components; kk++) {
 554             *dest= (*(const GLbyte*)src + *(const GLbyte*)(src+ysize)) / 2;
 555
 556             src+= element_size;
 557             dest++;
 558          }
 559          src+= padBytes; /* add pad bytes, if any, to get to end to row */
 560          src+= ysize;
 561       }
 562
 563       assert(src == &((const char *)dataIn)[ysize*height]);
 564    }
 565
 566    assert((char *)dest == &((char *)dataOut)
 567           [components * element_size * halfWidth * halfHeight]);
 568 } /* halve1Dimage_byte() */
 569
 570 static void halveImage_ushort(GLint components, GLuint width, GLuint height,
 571                         const GLushort *datain, GLushort *dataout,
 572                         GLint element_size, GLint ysize, GLint group_size,
 573                         GLint myswap_bytes)
 574 {
 575     int i, j, k;
 576     int newwidth, newheight;
 577     int padBytes;
 578     GLushort *s;
 579     const char *t;
 580
 581     /* handle case where there is only 1 column/row */
 582     if (width == 1 || height == 1) {
 583        assert( !(width == 1 && height == 1) ); /* can't be 1x1 */
 584        halve1Dimage_ushort(components,width,height,datain,dataout,
 585                            element_size,ysize,group_size, myswap_bytes);
 586        return;
 587     }
 588
 589     newwidth = width / 2;
 590     newheight = height / 2;
 591     padBytes = ysize - (width*group_size);
 592     s = dataout;
 593     t = (const char *)datain;
 594
 595     /* Piece o' cake! */
 596     if (!myswap_bytes)
 597     for (i = 0; i < newheight; i++) {
 598         for (j = 0; j < newwidth; j++) {
 599             for (k = 0; k < components; k++) {
 600                 s[0] = (*(const GLushort*)t +
 601                         *(const GLushort*)(t+group_size) +
 602                         *(const GLushort*)(t+ysize) +
 603                         *(const GLushort*)(t+ysize+group_size) + 2) / 4;
 604                 s++; t += element_size;
 605             }
 606             t += group_size;
 607         }
 608         t += padBytes;
 609         t += ysize;
 610     }
 611     else
 612     for (i = 0; i < newheight; i++) {
 613         for (j = 0; j < newwidth; j++) {
 614             for (k = 0; k < components; k++) {
 615                 s[0] = (__GLU_SWAP_2_BYTES(t) +
 616                         __GLU_SWAP_2_BYTES(t+group_size) +
 617                         __GLU_SWAP_2_BYTES(t+ysize) +
 618                         __GLU_SWAP_2_BYTES(t+ysize+group_size)+ 2)/4;
 619                 s++; t += element_size;
 620             }
 621             t += group_size;
 622         }
 623         t += padBytes;
 624         t += ysize;
 625     }
 626 }
 627
 628 static void halve1Dimage_ushort(GLint components, GLuint width, GLuint height,
 629                                 const GLushort *dataIn, GLushort *dataOut,
 630                                 GLint element_size, GLint ysize,
 631                                 GLint group_size, GLint myswap_bytes)
 632 {
 633    GLint halfWidth= width / 2;
 634    GLint halfHeight= height / 2;
 635    const char *src= (const char *) dataIn;
 636    GLushort *dest= dataOut;
 637    int jj;
 638
 639    assert(width == 1 || height == 1); /* must be 1D */
 640    assert(width != height);     /* can't be square */
 641
 642    if (height == 1) {           /* 1 row */
 643       assert(width != 1);       /* widthxheight can't be 1x1 */
 644       halfHeight= 1;
 645
 646       for (jj= 0; jj< halfWidth; jj++) {
 647          int kk;
 648          for (kk= 0; kk< components; kk++) {
 649 #define BOX2 2
 650             GLushort ushort[BOX2];
 651             if (myswap_bytes) {
 652                ushort[0]= __GLU_SWAP_2_BYTES(src);
 653                ushort[1]= __GLU_SWAP_2_BYTES(src+group_size);
 654             }
 655             else {
 656                ushort[0]= *(const GLushort*)src;
 657                ushort[1]= *(const GLushort*)(src+group_size);
 658             }
 659
 660             *dest= (ushort[0] + ushort[1]) / 2;
 661             src+= element_size;
 662             dest++;
 663          }
 664          src+= group_size;      /* skip to next 2 */
 665       }
 666       {
 667          int padBytes= ysize - (width*group_size);
 668          src+= padBytes;        /* for assertion only */
 669       }
 670    }
 671    else if (width == 1) {       /* 1 column */
 672       int padBytes= ysize - (width * group_size);
 673       assert(height != 1);      /* widthxheight can't be 1x1 */
 674       halfWidth= 1;
 675       /* one vertical column with possible pad bytes per row */
 676       /* average two at a time */
 677
 678       for (jj= 0; jj< halfHeight; jj++) {
 679          int kk;
 680          for (kk= 0; kk< components; kk++) {
 681 #define BOX2 2
 682             GLushort ushort[BOX2];
 683             if (myswap_bytes) {
 684                ushort[0]= __GLU_SWAP_2_BYTES(src);
 685                ushort[1]= __GLU_SWAP_2_BYTES(src+ysize);
 686             }
 687             else {
 688                ushort[0]= *(const GLushort*)src;
 689                ushort[1]= *(const GLushort*)(src+ysize);
 690             }
 691             *dest= (ushort[0] + ushort[1]) / 2;
 692
 693             src+= element_size;
 694             dest++;
 695          }
 696          src+= padBytes; /* add pad bytes, if any, to get to end to row */
 697          src+= ysize;
 698       }
 699
 700       assert(src == &((const char *)dataIn)[ysize*height]);
 701    }
 702
 703    assert((char *)dest == &((char *)dataOut)
 704           [components * element_size * halfWidth * halfHeight]);
 705
 706 } /* halve1Dimage_ushort() */
 707
 708
 709 static void halveImage_short(GLint components, GLuint width, GLuint height,
 710                         const GLshort *datain, GLshort *dataout,
 711                         GLint element_size, GLint ysize, GLint group_size,
 712                         GLint myswap_bytes)
 713 {
 714     int i, j, k;
 715     int newwidth, newheight;
 716     int padBytes;
 717     GLshort *s;
 718     const char *t;
 719
 720     /* handle case where there is only 1 column/row */
 721     if (width == 1 || height == 1) {
 722        assert( !(width == 1 && height == 1) ); /* can't be 1x1 */
 723        halve1Dimage_short(components,width,height,datain,dataout,
 724                           element_size,ysize,group_size, myswap_bytes);
 725        return;
 726     }
 727
 728     newwidth = width / 2;
 729     newheight = height / 2;
 730     padBytes = ysize - (width*group_size);
 731     s = dataout;
 732     t = (const char *)datain;
 733
 734     /* Piece o' cake! */
 735     if (!myswap_bytes)
 736     for (i = 0; i < newheight; i++) {
 737         for (j = 0; j < newwidth; j++) {
 738             for (k = 0; k < components; k++) {
 739                 s[0] = (*(const GLshort*)t +
 740                         *(const GLshort*)(t+group_size) +
 741                         *(const GLshort*)(t+ysize) +
 742                         *(const GLshort*)(t+ysize+group_size) + 2) / 4;
 743                 s++; t += element_size;
 744             }
 745             t += group_size;
 746         }
 747         t += padBytes;
 748         t += ysize;
 749     }
 750     else
 751     for (i = 0; i < newheight; i++) {
 752         for (j = 0; j < newwidth; j++) {
 753             for (k = 0; k < components; k++) {
 754                 GLushort b;
 755                 GLint buf;
 756                 b = __GLU_SWAP_2_BYTES(t);
 757                 buf = *(const GLshort*)&b;
 758                 b = __GLU_SWAP_2_BYTES(t+group_size);
 759                 buf += *(const GLshort*)&b;
 760                 b = __GLU_SWAP_2_BYTES(t+ysize);
 761                 buf += *(const GLshort*)&b;
 762                 b = __GLU_SWAP_2_BYTES(t+ysize+group_size);
 763                 buf += *(const GLshort*)&b;
 764                 s[0] = (GLshort)((buf+2)/4);
 765                 s++; t += element_size;
 766             }
 767             t += group_size;
 768         }
 769         t += padBytes;
 770         t += ysize;
 771     }
 772 }
 773
 774 static void halve1Dimage_short(GLint components, GLuint width, GLuint height,
 775                                 const GLshort *dataIn, GLshort *dataOut,
 776                                 GLint element_size, GLint ysize,
 777                                 GLint group_size, GLint myswap_bytes)
 778 {
 779    GLint halfWidth= width / 2;
 780    GLint halfHeight= height / 2;
 781    const char *src= (const char *) dataIn;
 782    GLshort *dest= dataOut;
 783    int jj;
 784
 785    assert(width == 1 || height == 1); /* must be 1D */
 786    assert(width != height);     /* can't be square */
 787
 788    if (height == 1) {           /* 1 row */
 789       assert(width != 1);       /* widthxheight can't be 1x1 */
 790       halfHeight= 1;
 791
 792       for (jj= 0; jj< halfWidth; jj++) {
 793          int kk;
 794          for (kk= 0; kk< components; kk++) {
 795 #define BOX2 2
 796             GLshort sshort[BOX2];
 797             if (myswap_bytes) {
 798                sshort[0]= __GLU_SWAP_2_BYTES(src);
 799                sshort[1]= __GLU_SWAP_2_BYTES(src+group_size);
 800             }
 801             else {
 802                sshort[0]= *(const GLshort*)src;
 803                sshort[1]= *(const GLshort*)(src+group_size);
 804             }
 805
 806             *dest= (sshort[0] + sshort[1]) / 2;
 807             src+= element_size;
 808             dest++;
 809          }
 810          src+= group_size;      /* skip to next 2 */
 811       }
 812       {
 813          int padBytes= ysize - (width*group_size);
 814          src+= padBytes;        /* for assertion only */
 815       }
 816    }
 817    else if (width == 1) {       /* 1 column */
 818       int padBytes= ysize - (width * group_size);
 819       assert(height != 1);      /* widthxheight can't be 1x1 */
 820       halfWidth= 1;
 821       /* one vertical column with possible pad bytes per row */
 822       /* average two at a time */
 823
 824       for (jj= 0; jj< halfHeight; jj++) {
 825          int kk;
 826          for (kk= 0; kk< components; kk++) {
 827 #define BOX2 2
 828             GLshort sshort[BOX2];
 829             if (myswap_bytes) {
 830                sshort[0]= __GLU_SWAP_2_BYTES(src);
 831                sshort[1]= __GLU_SWAP_2_BYTES(src+ysize);
 832             }
 833             else {
 834                sshort[0]= *(const GLshort*)src;
 835                sshort[1]= *(const GLshort*)(src+ysize);
 836             }
 837             *dest= (sshort[0] + sshort[1]) / 2;
 838
 839             src+= element_size;
 840             dest++;
 841          }
 842          src+= padBytes; /* add pad bytes, if any, to get to end to row */
 843          src+= ysize;
 844       }
 845
 846       assert(src == &((const char *)dataIn)[ysize*height]);
 847    }
 848
 849    assert((char *)dest == &((char *)dataOut)
 850           [components * element_size * halfWidth * halfHeight]);
 851
 852 } /* halve1Dimage_short() */
 853
 854
 855 static void halveImage_uint(GLint components, GLuint width, GLuint height,
 856                         const GLuint *datain, GLuint *dataout,
 857                         GLint element_size, GLint ysize, GLint group_size,
 858                         GLint myswap_bytes)
 859 {
 860     int i, j, k;
 861     int newwidth, newheight;
 862     int padBytes;
 863     GLuint *s;
 864     const char *t;
 865
 866     /* handle case where there is only 1 column/row */
 867     if (width == 1 || height == 1) {
 868        assert( !(width == 1 && height == 1) ); /* can't be 1x1 */
 869        halve1Dimage_uint(components,width,height,datain,dataout,
 870                          element_size,ysize,group_size, myswap_bytes);
 871        return;
 872     }
 873
 874     newwidth = width / 2;
 875     newheight = height / 2;
 876     padBytes = ysize - (width*group_size);
 877     s = dataout;
 878     t = (const char *)datain;
 879
 880     /* Piece o' cake! */
 881     if (!myswap_bytes)
 882     for (i = 0; i < newheight; i++) {
 883         for (j = 0; j < newwidth; j++) {
 884             for (k = 0; k < components; k++) {
 885                 /* need to cast to double to hold large unsigned ints */
 886                 s[0] = ((double)*(const GLuint*)t +
 887                         (double)*(const GLuint*)(t+group_size) +
 888                         (double)*(const GLuint*)(t+ysize) +
 889                         (double)*(const GLuint*)(t+ysize+group_size))/4 + 0.5;
 890                 s++; t += element_size;
 891
 892             }
 893             t += group_size;
 894         }
 895         t += padBytes;
 896         t += ysize;
 897     }
 898     else
 899     for (i = 0; i < newheight; i++) {
 900         for (j = 0; j < newwidth; j++) {
 901             for (k = 0; k < components; k++) {
 902                 /* need to cast to double to hold large unsigned ints */
 903                 GLdouble buf;
 904                 buf = (GLdouble)__GLU_SWAP_4_BYTES(t) +
 905                       (GLdouble)__GLU_SWAP_4_BYTES(t+group_size) +
 906                       (GLdouble)__GLU_SWAP_4_BYTES(t+ysize) +
 907                       (GLdouble)__GLU_SWAP_4_BYTES(t+ysize+group_size);
 908                 s[0] = (GLuint)(buf/4 + 0.5);
 909
 910                 s++; t += element_size;
 911             }
 912             t += group_size;
 913         }
 914         t += padBytes;
 915         t += ysize;
 916     }
 917 }
 918
 919 /* */
 920 static void halve1Dimage_uint(GLint components, GLuint width, GLuint height,
 921                               const GLuint *dataIn, GLuint *dataOut,
 922                               GLint element_size, GLint ysize,
 923                               GLint group_size, GLint myswap_bytes)
 924 {
 925    GLint halfWidth= width / 2;
 926    GLint halfHeight= height / 2;
 927    const char *src= (const char *) dataIn;
 928    GLuint *dest= dataOut;
 929    int jj;
 930
 931    assert(width == 1 || height == 1); /* must be 1D */
 932    assert(width != height);     /* can't be square */
 933
 934    if (height == 1) {           /* 1 row */
 935       assert(width != 1);       /* widthxheight can't be 1x1 */
 936       halfHeight= 1;
 937
 938       for (jj= 0; jj< halfWidth; jj++) {
 939          int kk;
 940          for (kk= 0; kk< components; kk++) {
 941 #define BOX2 2
 942             GLuint uint[BOX2];
 943             if (myswap_bytes) {
 944                uint[0]= __GLU_SWAP_4_BYTES(src);
 945                uint[1]= __GLU_SWAP_4_BYTES(src+group_size);
 946             }
 947             else {
 948                uint[0]= *(const GLuint*)src;
 949                uint[1]= *(const GLuint*)(src+group_size);
 950             }
 951             *dest= ((double)uint[0]+(double)uint[1])/2.0;
 952
 953             src+= element_size;
 954             dest++;
 955          }
 956          src+= group_size;      /* skip to next 2 */
 957       }
 958       {
 959          int padBytes= ysize - (width*group_size);
 960          src+= padBytes;        /* for assertion only */
 961       }
 962    }
 963    else if (width == 1) {       /* 1 column */
 964       int padBytes= ysize - (width * group_size);
 965       assert(height != 1);      /* widthxheight can't be 1x1 */
 966       halfWidth= 1;
 967       /* one vertical column with possible pad bytes per row */
 968       /* average two at a time */
 969
 970       for (jj= 0; jj< halfHeight; jj++) {
 971          int kk;
 972          for (kk= 0; kk< components; kk++) {
 973 #define BOX2 2
 974             GLuint uint[BOX2];
 975             if (myswap_bytes) {
 976                uint[0]= __GLU_SWAP_4_BYTES(src);
 977                uint[1]= __GLU_SWAP_4_BYTES(src+ysize);
 978             }
 979             else {
 980                uint[0]= *(const GLuint*)src;
 981                uint[1]= *(const GLuint*)(src+ysize);
 982             }
 983             *dest= ((double)uint[0]+(double)uint[1])/2.0;
 984
 985             src+= element_size;
 986             dest++;
 987          }
 988          src+= padBytes; /* add pad bytes, if any, to get to end to row */
 989          src+= ysize;
 990       }
 991
 992       assert(src == &((const char *)dataIn)[ysize*height]);
 993    }
 994
 995    assert((char *)dest == &((char *)dataOut)
 996           [components * element_size * halfWidth * halfHeight]);
 997
 998 } /* halve1Dimage_uint() */
 999
1000 static void halveImage_int(GLint components, GLuint width, GLuint height,
1001                         const GLint *datain, GLint *dataout, GLint element_size,
1002                         GLint ysize, GLint group_size, GLint myswap_bytes)
1003 {
1004     int i, j, k;
1005     int newwidth, newheight;
1006     int padBytes;
1007     GLint *s;
1008     const char *t;
1009
1010     /* handle case where there is only 1 column/row */
1011     if (width == 1 || height == 1) {
1012        assert( !(width == 1 && height == 1) ); /* can't be 1x1 */
1013        halve1Dimage_int(components,width,height,datain,dataout,
1014                         element_size,ysize,group_size, myswap_bytes);
1015        return;
1016     }
1017
1018     newwidth = width / 2;
1019     newheight = height / 2;
1020     padBytes = ysize - (width*group_size);
1021     s = dataout;
1022     t = (const char *)datain;
1023
1024     /* Piece o' cake! */
1025     if (!myswap_bytes)
1026     for (i = 0; i < newheight; i++) {
1027         for (j = 0; j < newwidth; j++) {
1028             for (k = 0; k < components; k++) {
1029                 s[0] = ((float)*(const GLint*)t +
1030                         (float)*(const GLint*)(t+group_size) +
1031                         (float)*(const GLint*)(t+ysize) +
1032                         (float)*(const GLint*)(t+ysize+group_size))/4 + 0.5;
1033                 s++; t += element_size;
1034             }
1035             t += group_size;
1036         }
1037         t += padBytes;
1038         t += ysize;
1039     }
1040     else
1041     for (i = 0; i < newheight; i++) {
1042         for (j = 0; j < newwidth; j++) {
1043             for (k = 0; k < components; k++) {
1044                 GLuint b;
1045                 GLfloat buf;
1046                 b = __GLU_SWAP_4_BYTES(t);
1047                 buf = *(GLint*)&b;
1048                 b = __GLU_SWAP_4_BYTES(t+group_size);
1049                 buf += *(GLint*)&b;
1050                 b = __GLU_SWAP_4_BYTES(t+ysize);
1051                 buf += *(GLint*)&b;
1052                 b = __GLU_SWAP_4_BYTES(t+ysize+group_size);
1053                 buf += *(GLint*)&b;
1054                 s[0] = (GLint)(buf/4 + 0.5);
1055
1056                 s++; t += element_size;
1057             }
1058             t += group_size;
1059         }
1060         t += padBytes;
1061         t += ysize;
1062     }
1063 }
1064
1065 /* */
1066 static void halve1Dimage_int(GLint components, GLuint width, GLuint height,
1067                              const GLint *dataIn, GLint *dataOut,
1068                              GLint element_size, GLint ysize,
1069                              GLint group_size, GLint myswap_bytes)
1070 {
1071    GLint halfWidth= width / 2;
1072    GLint halfHeight= height / 2;
1073    const char *src= (const char *) dataIn;
1074    GLint *dest= dataOut;
1075    int jj;
1076
1077    assert(width == 1 || height == 1); /* must be 1D */
1078    assert(width != height);     /* can't be square */
1079
1080    if (height == 1) {           /* 1 row */
1081       assert(width != 1);       /* widthxheight can't be 1x1 */
1082       halfHeight= 1;
1083
1084       for (jj= 0; jj< halfWidth; jj++) {
1085          int kk;
1086          for (kk= 0; kk< components; kk++) {
1087 #define BOX2 2
1088             GLuint uint[BOX2];
1089             if (myswap_bytes) {
1090                uint[0]= __GLU_SWAP_4_BYTES(src);
1091                uint[1]= __GLU_SWAP_4_BYTES(src+group_size);
1092             }
1093             else {
1094                uint[0]= *(const GLuint*)src;
1095                uint[1]= *(const GLuint*)(src+group_size);
1096             }
1097             *dest= ((float)uint[0]+(float)uint[1])/2.0;
1098
1099             src+= element_size;
1100             dest++;
1101          }
1102          src+= group_size;      /* skip to next 2 */
1103       }
1104       {
1105          int padBytes= ysize - (width*group_size);
1106          src+= padBytes;        /* for assertion only */
1107       }
1108    }
1109    else if (width == 1) {       /* 1 column */
1110       int padBytes= ysize - (width * group_size);
1111       assert(height != 1);      /* widthxheight can't be 1x1 */
1112       halfWidth= 1;
1113       /* one vertical column with possible pad bytes per row */
1114       /* average two at a time */
1115
1116       for (jj= 0; jj< halfHeight; jj++) {
1117          int kk;
1118          for (kk= 0; kk< components; kk++) {
1119 #define BOX2 2
1120             GLuint uint[BOX2];
1121             if (myswap_bytes) {
1122                uint[0]= __GLU_SWAP_4_BYTES(src);
1123                uint[1]= __GLU_SWAP_4_BYTES(src+ysize);
1124             }
1125             else {
1126                uint[0]= *(const GLuint*)src;
1127                uint[1]= *(const GLuint*)(src+ysize);
1128             }
1129             *dest= ((float)uint[0]+(float)uint[1])/2.0;
1130
1131             src+= element_size;
1132             dest++;
1133          }
1134          src+= padBytes; /* add pad bytes, if any, to get to end to row */
1135          src+= ysize;
1136       }
1137
1138       assert(src == &((const char *)dataIn)[ysize*height]);
1139    }
1140
1141    assert((char *)dest == &((char *)dataOut)
1142           [components * element_size * halfWidth * halfHeight]);
1143
1144 } /* halve1Dimage_int() */
1145
1146
1147 static void halveImage_float(GLint components, GLuint width, GLuint height,
1148                         const GLfloat *datain, GLfloat *dataout,
1149                         GLint element_size, GLint ysize, GLint group_size,
1150                         GLint myswap_bytes)
1151 {
1152     int i, j, k;
1153     int newwidth, newheight;
1154     int padBytes;
1155     GLfloat *s;
1156     const char *t;
1157
1158     /* handle case where there is only 1 column/row */
1159     if (width == 1 || height == 1) {
1160        assert( !(width == 1 && height == 1) ); /* can't be 1x1 */
1161        halve1Dimage_float(components,width,height,datain,dataout,
1162                           element_size,ysize,group_size, myswap_bytes);
1163        return;
1164     }
1165
1166     newwidth = width / 2;
1167     newheight = height / 2;
1168     padBytes = ysize - (width*group_size);
1169     s = dataout;
1170     t = (const char *)datain;
1171
1172     /* Piece o' cake! */
1173     if (!myswap_bytes)
1174     for (i = 0; i < newheight; i++) {
1175         for (j = 0; j < newwidth; j++) {
1176             for (k = 0; k < components; k++) {
1177                 s[0] = (*(const GLfloat*)t +
1178                         *(const GLfloat*)(t+group_size) +
1179                         *(const GLfloat*)(t+ysize) +
1180                         *(const GLfloat*)(t+ysize+group_size)) / 4;
1181                 s++; t += element_size;
1182             }
1183             t += group_size;
1184         }
1185         t += padBytes;
1186         t += ysize;
1187     }
1188     else
1189     for (i = 0; i < newheight; i++) {
1190         for (j = 0; j < newwidth; j++) {
1191             for (k = 0; k < components; k++) {
1192                 union { GLuint b; GLfloat f; } swapbuf;
1193                 swapbuf.b = __GLU_SWAP_4_BYTES(t);
1194                 s[0] = swapbuf.f;
1195                 swapbuf.b = __GLU_SWAP_4_BYTES(t+group_size);
1196                 s[0] += swapbuf.f;
1197                 swapbuf.b = __GLU_SWAP_4_BYTES(t+ysize);
1198                 s[0] += swapbuf.f;
1199                 swapbuf.b = __GLU_SWAP_4_BYTES(t+ysize+group_size);
1200                 s[0] += swapbuf.f;
1201                 s[0] /= 4;
1202                 s++; t += element_size;
1203             }
1204             t += group_size;
1205         }
1206         t += padBytes;
1207         t += ysize;
1208     }
1209 }
1210
1211 /* */
1212 static void halve1Dimage_float(GLint components, GLuint width, GLuint height,
1213                                const GLfloat *dataIn, GLfloat *dataOut,
1214                                GLint element_size, GLint ysize,
1215                                GLint group_size, GLint myswap_bytes)
1216 {
1217    GLint halfWidth= width / 2;
1218    GLint halfHeight= height / 2;
1219    const char *src= (const char *) dataIn;
1220    GLfloat *dest= dataOut;
1221    int jj;
1222
1223    assert(width == 1 || height == 1); /* must be 1D */
1224    assert(width != height);     /* can't be square */
1225
1226    if (height == 1) {           /* 1 row */
1227       assert(width != 1);       /* widthxheight can't be 1x1 */
1228       halfHeight= 1;
1229
1230       for (jj= 0; jj< halfWidth; jj++) {
1231          int kk;
1232          for (kk= 0; kk< components; kk++) {
1233 #define BOX2 2
1234             GLfloat sfloat[BOX2];
1235             if (myswap_bytes) {
1236                sfloat[0]= __GLU_SWAP_4_BYTES(src);
1237                sfloat[1]= __GLU_SWAP_4_BYTES(src+group_size);
1238             }
1239             else {
1240                sfloat[0]= *(const GLfloat*)src;
1241                sfloat[1]= *(const GLfloat*)(src+group_size);
1242             }
1243
1244             *dest= (sfloat[0] + sfloat[1]) / 2.0;
1245             src+= element_size;
1246             dest++;
1247          }
1248          src+= group_size;      /* skip to next 2 */
1249       }
1250       {
1251          int padBytes= ysize - (width*group_size);
1252          src+= padBytes;        /* for assertion only */
1253       }
1254    }
1255    else if (width == 1) {       /* 1 column */
1256       int padBytes= ysize - (width * group_size);
1257       assert(height != 1);      /* widthxheight can't be 1x1 */
1258       halfWidth= 1;
1259       /* one vertical column with possible pad bytes per row */
1260       /* average two at a time */
1261
1262       for (jj= 0; jj< halfHeight; jj++) {
1263          int kk;
1264          for (kk= 0; kk< components; kk++) {
1265 #define BOX2 2
1266             GLfloat sfloat[BOX2];
1267             if (myswap_bytes) {
1268                sfloat[0]= __GLU_SWAP_4_BYTES(src);
1269                sfloat[1]= __GLU_SWAP_4_BYTES(src+ysize);
1270             }
1271             else {
1272                sfloat[0]= *(const GLfloat*)src;
1273                sfloat[1]= *(const GLfloat*)(src+ysize);
1274             }
1275             *dest= (sfloat[0] + sfloat[1]) / 2.0;
1276
1277             src+= element_size;
1278             dest++;
1279          }
1280          src+= padBytes; /* add pad bytes, if any, to get to end to row */
1281          src+= ysize;           /* skip to odd row */
1282       }
1283    }
1284
1285    assert(src == &((const char *)dataIn)[ysize*height]);
1286    assert((char *)dest == &((char *)dataOut)
1287           [components * element_size * halfWidth * halfHeight]);
1288 } /* halve1Dimage_float() */
1289
1290 static void scale_internal(GLint components, GLint widthin, GLint heightin,
1291                            const GLushort *datain,
1292                            GLint widthout, GLint heightout,
1293                            GLushort *dataout)
1294 {
1295     float x, lowx, highx, convx, halfconvx;
1296     float y, lowy, highy, convy, halfconvy;
1297     float xpercent,ypercent;
1298     float percent;
1299     /* Max components in a format is 4, so... */
1300     float totals[4];
1301     float area;
1302     int i,j,k,yint,xint,xindex,yindex;
1303     int temp;
1304
1305     if (widthin == widthout*2 && heightin == heightout*2) {
1306         halveImage(components, widthin, heightin, datain, dataout);
1307         return;
1308     }
1309     convy = (float) heightin/heightout;
1310     convx = (float) widthin/widthout;
1311     halfconvx = convx/2;
1312     halfconvy = convy/2;
1313     for (i = 0; i < heightout; i++) {
1314         y = convy * (i+0.5);
1315         if (heightin > heightout) {
1316             highy = y + halfconvy;
1317             lowy = y - halfconvy;
1318         } else {
1319             highy = y + 0.5;
1320             lowy = y - 0.5;
1321         }
1322         for (j = 0; j < widthout; j++) {
1323             x = convx * (j+0.5);
1324             if (widthin > widthout) {
1325                 highx = x + halfconvx;
1326                 lowx = x - halfconvx;
1327             } else {
1328                 highx = x + 0.5;
1329                 lowx = x - 0.5;
1330             }
1331
1332             /*
1333             ** Ok, now apply box filter to box that goes from (lowx, lowy)
1334             ** to (highx, highy) on input data into this pixel on output
1335             ** data.
1336             */
1337             totals[0] = totals[1] = totals[2] = totals[3] = 0.0;
1338             area = 0.0;
1339
1340             y = lowy;
1341             yint = floor(y);
1342             while (y < highy) {
1343                 yindex = (yint + heightin) % heightin;
1344                 if (highy < yint+1) {
1345                     ypercent = highy - y;
1346                 } else {
1347                     ypercent = yint+1 - y;
1348                 }
1349
1350                 x = lowx;
1351                 xint = floor(x);
1352
1353                 while (x < highx) {
1354                     xindex = (xint + widthin) % widthin;
1355                     if (highx < xint+1) {
1356                         xpercent = highx - x;
1357                     } else {
1358                         xpercent = xint+1 - x;
1359                     }
1360
1361                     percent = xpercent * ypercent;
1362                     area += percent;
1363                     temp = (xindex + (yindex * widthin)) * components;
1364                     for (k = 0; k < components; k++) {
1365                         totals[k] += datain[temp + k] * percent;
1366                     }
1367
1368                     xint++;
1369                     x = xint;
1370                 }
1371                 yint++;
1372                 y = yint;
1373             }
1374
1375             temp = (j + (i * widthout)) * components;
1376             for (k = 0; k < components; k++) {
1377                 /* totals[] should be rounded in the case of enlarging an RGB
1378                  * ramp when the type is 332 or 4444
1379                  */
1380                 dataout[temp + k] = (totals[k]+0.5)/area;
1381             }
1382         }
1383     }
1384 }
1385
1386 static void scale_internal_ubyte(GLint components, GLint widthin,
1387                            GLint heightin, const GLubyte *datain,
1388                            GLint widthout, GLint heightout,
1389                            GLubyte *dataout, GLint element_size,
1390                            GLint ysize, GLint group_size)
1391 {
1392     float convx;
1393     float convy;
1394     float percent;
1395     /* Max components in a format is 4, so... */
1396     float totals[4];
1397     float area;
1398     int i,j,k,xindex;
1399
1400     const char *temp, *temp0;
1401     const char *temp_index;
1402     int outindex;
1403
1404     int lowx_int, highx_int, lowy_int, highy_int;
1405     float x_percent, y_percent;
1406     float lowx_float, highx_float, lowy_float, highy_float;
1407     float convy_float, convx_float;
1408     int convy_int, convx_int;
1409     int l, m;
1410     const char *left, *right;
1411
1412     if (widthin == widthout*2 && heightin == heightout*2) {
1413         halveImage_ubyte(components, widthin, heightin,
1414         (const GLubyte *)datain, (GLubyte *)dataout,
1415         element_size, ysize, group_size);
1416         return;
1417     }
1418     convy = (float) heightin/heightout;
1419     convx = (float) widthin/widthout;
1420     convy_int = floor(convy);
1421     convy_float = convy - convy_int;
1422     convx_int = floor(convx);
1423     convx_float = convx - convx_int;
1424
1425     area = convx * convy;
1426
1427     lowy_int = 0;
1428     lowy_float = 0;
1429     highy_int = convy_int;
1430     highy_float = convy_float;
1431
1432     for (i = 0; i < heightout; i++) {
1433         /* Clamp here to be sure we don't read beyond input buffer. */
1434         if (highy_int >= heightin)
1435             highy_int = heightin - 1;
1436         lowx_int = 0;
1437         lowx_float = 0;
1438         highx_int = convx_int;
1439         highx_float = convx_float;
1440
1441         for (j = 0; j < widthout; j++) {
1442
1443             /*
1444             ** Ok, now apply box filter to box that goes from (lowx, lowy)
1445             ** to (highx, highy) on input data into this pixel on output
1446             ** data.
1447             */
1448             totals[0] = totals[1] = totals[2] = totals[3] = 0.0;
1449
1450             /* calculate the value for pixels in the 1st row */
1451             xindex = lowx_int*group_size;
1452             if((highy_int>lowy_int) && (highx_int>lowx_int)) {
1453
1454                 y_percent = 1-lowy_float;
1455                 temp = (const char *)datain + xindex + lowy_int * ysize;
1456                 percent = y_percent * (1-lowx_float);
1457                 for (k = 0, temp_index = temp; k < components;
1458                      k++, temp_index += element_size) {
1459                         totals[k] += (GLubyte)(*(temp_index)) * percent;
1460                 }
1461                 left = temp;
1462                 for(l = lowx_int+1; l < highx_int; l++) {
1463                     temp += group_size;
1464                     for (k = 0, temp_index = temp; k < components;
1465                          k++, temp_index += element_size) {
1466                         totals[k] += (GLubyte)(*(temp_index)) * y_percent;
1467                     }
1468                 }
1469                 temp += group_size;
1470                 right = temp;
1471                 percent = y_percent * highx_float;
1472                 for (k = 0, temp_index = temp; k < components;
1473                      k++, temp_index += element_size) {
1474                         totals[k] += (GLubyte)(*(temp_index)) * percent;
1475                 }
1476
1477                 /* calculate the value for pixels in the last row */
1478                 y_percent = highy_float;
1479                 percent = y_percent * (1-lowx_float);
1480                 temp = (const char *)datain + xindex + highy_int * ysize;
1481                 for (k = 0, temp_index = temp; k < components;
1482                      k++, temp_index += element_size) {
1483                         totals[k] += (GLubyte)(*(temp_index)) * percent;
1484                 }
1485                 for(l = lowx_int+1; l < highx_int; l++) {
1486                     temp += group_size;
1487                     for (k = 0, temp_index = temp; k < components;
1488                          k++, temp_index += element_size) {
1489                         totals[k] += (GLubyte)(*(temp_index)) * y_percent;
1490                     }
1491                 }
1492                 temp += group_size;
1493                 percent = y_percent * highx_float;
1494                 for (k = 0, temp_index = temp; k < components;
1495                      k++, temp_index += element_size) {
1496                         totals[k] += (GLubyte)(*(temp_index)) * percent;
1497                 }
1498
1499
1500                 /* calculate the value for pixels in the 1st and last column */
1501                 for(m = lowy_int+1; m < highy_int; m++) {
1502                     left += ysize;
1503                     right += ysize;
1504                     for (k = 0; k < components;
1505                          k++, left += element_size, right += element_size) {
1506                         totals[k] += (GLubyte)(*(left))*(1-lowx_float)
1507                                 +(GLubyte)(*(right))*highx_float;
1508                     }
1509                 }
1510             } else if (highy_int > lowy_int) {
1511                 x_percent = highx_float - lowx_float;
1512                 percent = (1-lowy_float)*x_percent;
1513                 temp = (const char *)datain + xindex + lowy_int*ysize;
1514                 for (k = 0, temp_index = temp; k < components;
1515                      k++, temp_index += element_size) {
1516                         totals[k] += (GLubyte)(*(temp_index)) * percent;
1517                 }
1518                 for(m = lowy_int+1; m < highy_int; m++) {
1519                     temp += ysize;
1520                     for (k = 0, temp_index = temp; k < components;
1521                          k++, temp_index += element_size) {
1522                         totals[k] += (GLubyte)(*(temp_index)) * x_percent;
1523                     }
1524                 }
1525                 percent = x_percent * highy_float;
1526                 temp += ysize;
1527                 for (k = 0, temp_index = temp; k < components;
1528                      k++, temp_index += element_size) {
1529                         totals[k] += (GLubyte)(*(temp_index)) * percent;
1530                 }
1531             } else if (highx_int > lowx_int) {
1532                 y_percent = highy_float - lowy_float;
1533                 percent = (1-lowx_float)*y_percent;
1534                 temp = (const char *)datain + xindex + lowy_int*ysize;
1535                 for (k = 0, temp_index = temp; k < components;
1536                      k++, temp_index += element_size) {
1537                         totals[k] += (GLubyte)(*(temp_index)) * percent;
1538                 }
1539                 for (l = lowx_int+1; l < highx_int; l++) {
1540                     temp += group_size;
1541                     for (k = 0, temp_index = temp; k < components;
1542                          k++, temp_index += element_size) {
1543                         totals[k] += (GLubyte)(*(temp_index)) * y_percent;
1544                     }
1545                 }
1546                 temp += group_size;
1547                 percent = y_percent * highx_float;
1548                 for (k = 0, temp_index = temp; k < components;
1549                      k++, temp_index += element_size) {
1550                         totals[k] += (GLubyte)(*(temp_index)) * percent;
1551                 }
1552             } else {
1553                 percent = (highy_float-lowy_float)*(highx_float-lowx_float);
1554                 temp = (const char *)datain + xindex + lowy_int * ysize;
1555                 for (k = 0, temp_index = temp; k < components;
1556                      k++, temp_index += element_size) {
1557                         totals[k] += (GLubyte)(*(temp_index)) * percent;
1558                 }
1559             }
1560
1561
1562
1563             /* this is for the pixels in the body */
1564             temp0 = (const char *)datain + xindex + group_size +
1565                  (lowy_int+1)*ysize;
1566             for (m = lowy_int+1; m < highy_int; m++) {
1567                 temp = temp0;
1568                 for(l = lowx_int+1; l < highx_int; l++) {
1569                     for (k = 0, temp_index = temp; k < components;
1570                          k++, temp_index += element_size) {
1571                         totals[k] += (GLubyte)(*(temp_index));
1572                     }
1573                     temp += group_size;
1574                 }
1575                 temp0 += ysize;
1576             }
1577
1578             outindex = (j + (i * widthout)) * components;
1579             for (k = 0; k < components; k++) {
1580                 dataout[outindex + k] = totals[k]/area;
1581                 /*printf("totals[%d] = %f\n", k, totals[k]);*/
1582             }
1583             lowx_int = highx_int;
1584             lowx_float = highx_float;
1585             highx_int += convx_int;
1586             highx_float += convx_float;
1587             if(highx_float > 1) {
1588                 highx_float -= 1.0;
1589                 highx_int++;
1590             }
1591         }
1592         lowy_int = highy_int;
1593         lowy_float = highy_float;
1594         highy_int += convy_int;
1595         highy_float += convy_float;
1596         if(highy_float > 1) {
1597             highy_float -= 1.0;
1598             highy_int++;
1599         }
1600     }
1601 }
1602
1603 static void scale_internal_byte(GLint components, GLint widthin,
1604                            GLint heightin, const GLbyte *datain,
1605                            GLint widthout, GLint heightout,
1606                            GLbyte *dataout, GLint element_size,
1607                            GLint ysize, GLint group_size)
1608 {
1609     float convx;
1610     float convy;
1611     float percent;
1612     /* Max components in a format is 4, so... */
1613     float totals[4];
1614     float area;
1615     int i,j,k,xindex;
1616
1617     const char *temp, *temp0;
1618     const char *temp_index;
1619     int outindex;
1620
1621     int lowx_int, highx_int, lowy_int, highy_int;
1622     float x_percent, y_percent;
1623     float lowx_float, highx_float, lowy_float, highy_float;
1624     float convy_float, convx_float;
1625     int convy_int, convx_int;
1626     int l, m;
1627     const char *left, *right;
1628
1629     if (widthin == widthout*2 && heightin == heightout*2) {
1630         halveImage_byte(components, widthin, heightin,
1631         (const GLbyte *)datain, (GLbyte *)dataout,
1632         element_size, ysize, group_size);
1633         return;
1634     }
1635     convy = (float) heightin/heightout;
1636     convx = (float) widthin/widthout;
1637     convy_int = floor(convy);
1638     convy_float = convy - convy_int;
1639     convx_int = floor(convx);
1640     convx_float = convx - convx_int;
1641
1642     area = convx * convy;
1643
1644     lowy_int = 0;
1645     lowy_float = 0;
1646     highy_int = convy_int;
1647     highy_float = convy_float;
1648
1649     for (i = 0; i < heightout; i++) {
1650         /* Clamp here to be sure we don't read beyond input buffer. */
1651         if (highy_int >= heightin)
1652             highy_int = heightin - 1;
1653         lowx_int = 0;
1654         lowx_float = 0;
1655         highx_int = convx_int;
1656         highx_float = convx_float;
1657
1658         for (j = 0; j < widthout; j++) {
1659
1660             /*
1661             ** Ok, now apply box filter to box that goes from (lowx, lowy)
1662             ** to (highx, highy) on input data into this pixel on output
1663             ** data.
1664             */
1665             totals[0] = totals[1] = totals[2] = totals[3] = 0.0;
1666
1667             /* calculate the value for pixels in the 1st row */
1668             xindex = lowx_int*group_size;
1669             if((highy_int>lowy_int) && (highx_int>lowx_int)) {
1670
1671                 y_percent = 1-lowy_float;
1672                 temp = (const char *)datain + xindex + lowy_int * ysize;
1673                 percent = y_percent * (1-lowx_float);
1674                 for (k = 0, temp_index = temp; k < components;
1675                      k++, temp_index += element_size) {
1676                         totals[k] += (GLbyte)(*(temp_index)) * percent;
1677                 }
1678                 left = temp;
1679                 for(l = lowx_int+1; l < highx_int; l++) {
1680                     temp += group_size;
1681                     for (k = 0, temp_index = temp; k < components;
1682                      k++, temp_index += element_size) {
1683                         totals[k] += (GLbyte)(*(temp_index)) * y_percent;
1684                     }
1685                 }
1686                 temp += group_size;
1687                 right = temp;
1688                 percent = y_percent * highx_float;
1689                 for (k = 0, temp_index = temp; k < components;
1690                      k++, temp_index += element_size) {
1691                         totals[k] += (GLbyte)(*(temp_index)) * percent;
1692                 }
1693
1694                 /* calculate the value for pixels in the last row */
1695                 y_percent = highy_float;
1696                 percent = y_percent * (1-lowx_float);
1697                 temp = (const char *)datain + xindex + highy_int * ysize;
1698                 for (k = 0, temp_index = temp; k < components;
1699                      k++, temp_index += element_size) {
1700                         totals[k] += (GLbyte)(*(temp_index)) * percent;
1701                 }
1702                 for(l = lowx_int+1; l < highx_int; l++) {
1703                     temp += group_size;
1704                     for (k = 0, temp_index = temp; k < components;
1705                          k++, temp_index += element_size) {
1706                         totals[k] += (GLbyte)(*(temp_index)) * y_percent;
1707                     }
1708                 }
1709                 temp += group_size;
1710                 percent = y_percent * highx_float;
1711                 for (k = 0, temp_index = temp; k < components;
1712                      k++, temp_index += element_size) {
1713                         totals[k] += (GLbyte)(*(temp_index)) * percent;
1714                 }
1715
1716
1717                 /* calculate the value for pixels in the 1st and last column */
1718                 for(m = lowy_int+1; m < highy_int; m++) {
1719                     left += ysize;
1720                     right += ysize;
1721                     for (k = 0; k < components;
1722                          k++, left += element_size, right += element_size) {
1723                         totals[k] += (GLbyte)(*(left))*(1-lowx_float)
1724                                 +(GLbyte)(*(right))*highx_float;
1725                     }
1726                 }
1727             } else if (highy_int > lowy_int) {
1728                 x_percent = highx_float - lowx_float;
1729                 percent = (1-lowy_float)*x_percent;
1730                 temp = (const char *)datain + xindex + lowy_int*ysize;
1731                 for (k = 0, temp_index = temp; k < components;
1732                      k++, temp_index += element_size) {
1733                         totals[k] += (GLbyte)(*(temp_index)) * percent;
1734                 }
1735                 for(m = lowy_int+1; m < highy_int; m++) {
1736                     temp += ysize;
1737                     for (k = 0, temp_index = temp; k < components;
1738                          k++, temp_index += element_size) {
1739                         totals[k] += (GLbyte)(*(temp_index)) * x_percent;
1740                     }
1741                 }
1742                 percent = x_percent * highy_float;
1743                 temp += ysize;
1744                 for (k = 0, temp_index = temp; k < components;
1745                      k++, temp_index += element_size) {
1746                         totals[k] += (GLbyte)(*(temp_index)) * percent;
1747                 }
1748             } else if (highx_int > lowx_int) {
1749                 y_percent = highy_float - lowy_float;
1750                 percent = (1-lowx_float)*y_percent;
1751                 temp = (const char *)datain + xindex + lowy_int*ysize;
1752                 for (k = 0, temp_index = temp; k < components;
1753                      k++, temp_index += element_size) {
1754                         totals[k] += (GLbyte)(*(temp_index)) * percent;
1755                 }
1756                 for (l = lowx_int+1; l < highx_int; l++) {
1757                     temp += group_size;
1758                     for (k = 0, temp_index = temp; k < components;
1759                          k++, temp_index += element_size) {
1760                         totals[k] += (GLbyte)(*(temp_index)) * y_percent;
1761                     }
1762                 }
1763                 temp += group_size;
1764                 percent = y_percent * highx_float;
1765                 for (k = 0, temp_index = temp; k < components;
1766                      k++, temp_index += element_size) {
1767                         totals[k] += (GLbyte)(*(temp_index)) * percent;
1768                 }
1769             } else {
1770                 percent = (highy_float-lowy_float)*(highx_float-lowx_float);
1771                 temp = (const char *)datain + xindex + lowy_int * ysize;
1772                 for (k = 0, temp_index = temp; k < components;
1773                      k++, temp_index += element_size) {
1774                         totals[k] += (GLbyte)(*(temp_index)) * percent;
1775                 }
1776             }
1777
1778
1779
1780             /* this is for the pixels in the body */
1781             temp0 = (const char *)datain + xindex + group_size +
1782                 (lowy_int+1)*ysize;
1783             for (m = lowy_int+1; m < highy_int; m++) {
1784                 temp = temp0;
1785                 for(l = lowx_int+1; l < highx_int; l++) {
1786                     for (k = 0, temp_index = temp; k < components;
1787                      k++, temp_index += element_size) {
1788                         totals[k] += (GLbyte)(*(temp_index));
1789                     }
1790                     temp += group_size;
1791                 }
1792                 temp0 += ysize;
1793             }
1794
1795             outindex = (j + (i * widthout)) * components;
1796             for (k = 0; k < components; k++) {
1797                 dataout[outindex + k] = totals[k]/area;
1798                 /*printf("totals[%d] = %f\n", k, totals[k]);*/
1799             }
1800             lowx_int = highx_int;
1801             lowx_float = highx_float;
1802             highx_int += convx_int;
1803             highx_float += convx_float;
1804             if(highx_float > 1) {
1805                 highx_float -= 1.0;
1806                 highx_int++;
1807             }
1808         }
1809         lowy_int = highy_int;
1810         lowy_float = highy_float;
1811         highy_int += convy_int;
1812         highy_float += convy_float;
1813         if(highy_float > 1) {
1814             highy_float -= 1.0;
1815             highy_int++;
1816         }
1817     }
1818 }
1819
1820 static void scale_internal_ushort(GLint components, GLint widthin,
1821                            GLint heightin, const GLushort *datain,
1822                            GLint widthout, GLint heightout,
1823                            GLushort *dataout, GLint element_size,
1824                            GLint ysize, GLint group_size,
1825                            GLint myswap_bytes)
1826 {
1827     float convx;
1828     float convy;
1829     float percent;
1830     /* Max components in a format is 4, so... */
1831     float totals[4];
1832     float area;
1833     int i,j,k,xindex;
1834
1835     const char *temp, *temp0;
1836     const char *temp_index;
1837     int outindex;
1838
1839     int lowx_int, highx_int, lowy_int, highy_int;
1840     float x_percent, y_percent;
1841     float lowx_float, highx_float, lowy_float, highy_float;
1842     float convy_float, convx_float;
1843     int convy_int, convx_int;
1844     int l, m;
1845     const char *left, *right;
1846
1847     if (widthin == widthout*2 && heightin == heightout*2) {
1848         halveImage_ushort(components, widthin, heightin,
1849         (const GLushort *)datain, (GLushort *)dataout,
1850         element_size, ysize, group_size, myswap_bytes);
1851         return;
1852     }
1853     convy = (float) heightin/heightout;
1854     convx = (float) widthin/widthout;
1855     convy_int = floor(convy);
1856     convy_float = convy - convy_int;
1857     convx_int = floor(convx);
1858     convx_float = convx - convx_int;
1859
1860     area = convx * convy;
1861
1862     lowy_int = 0;
1863     lowy_float = 0;
1864     highy_int = convy_int;
1865     highy_float = convy_float;
1866
1867     for (i = 0; i < heightout; i++) {
1868         /* Clamp here to be sure we don't read beyond input buffer. */
1869         if (highy_int >= heightin)
1870             highy_int = heightin - 1;
1871         lowx_int = 0;
1872         lowx_float = 0;
1873         highx_int = convx_int;
1874         highx_float = convx_float;
1875
1876         for (j = 0; j < widthout; j++) {
1877             /*
1878             ** Ok, now apply box filter to box that goes from (lowx, lowy)
1879             ** to (highx, highy) on input data into this pixel on output
1880             ** data.
1881             */
1882             totals[0] = totals[1] = totals[2] = totals[3] = 0.0;
1883
1884             /* calculate the value for pixels in the 1st row */
1885             xindex = lowx_int*group_size;
1886             if((highy_int>lowy_int) && (highx_int>lowx_int)) {
1887
1888                 y_percent = 1-lowy_float;
1889                 temp = (const char *)datain + xindex + lowy_int * ysize;
1890                 percent = y_percent * (1-lowx_float);
1891                 for (k = 0, temp_index = temp; k < components;
1892                      k++, temp_index += element_size) {
1893                     if (myswap_bytes) {
1894                         totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
1895                     } else {
1896                         totals[k] += *(const GLushort*)temp_index * percent;
1897                     }
1898                 }
1899                 left = temp;
1900                 for(l = lowx_int+1; l < highx_int; l++) {
1901                     temp += group_size;
1902                     for (k = 0, temp_index = temp; k < components;
1903                          k++, temp_index += element_size) {
1904                         if (myswap_bytes) {
1905                             totals[k] +=
1906                                  __GLU_SWAP_2_BYTES(temp_index) * y_percent;
1907                         } else {
1908                             totals[k] += *(const GLushort*)temp_index * y_percent;
1909                         }
1910                     }
1911                 }
1912                 temp += group_size;
1913                 right = temp;
1914                 percent = y_percent * highx_float;
1915                 for (k = 0, temp_index = temp; k < components;
1916                      k++, temp_index += element_size) {
1917                     if (myswap_bytes) {
1918                         totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
1919                     } else {
1920                         totals[k] += *(const GLushort*)temp_index * percent;
1921                     }
1922                 }
1923
1924                 /* calculate the value for pixels in the last row */
1925                 y_percent = highy_float;
1926                 percent = y_percent * (1-lowx_float);
1927                 temp = (const char *)datain + xindex + highy_int * ysize;
1928                 for (k = 0, temp_index = temp; k < components;
1929                      k++, temp_index += element_size) {
1930                     if (myswap_bytes) {
1931                         totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
1932                     } else {
1933                         totals[k] += *(const GLushort*)temp_index * percent;
1934                     }
1935                 }
1936                 for(l = lowx_int+1; l < highx_int; l++) {
1937                     temp += group_size;
1938                     for (k = 0, temp_index = temp; k < components;
1939                          k++, temp_index += element_size) {
1940                         if (myswap_bytes) {
1941                             totals[k] +=
1942                                  __GLU_SWAP_2_BYTES(temp_index) * y_percent;
1943                         } else {
1944                             totals[k] += *(const GLushort*)temp_index * y_percent;
1945                         }
1946                     }
1947                 }
1948                 temp += group_size;
1949                 percent = y_percent * highx_float;
1950                 for (k = 0, temp_index = temp; k < components;
1951                      k++, temp_index += element_size) {
1952                     if (myswap_bytes) {
1953                         totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
1954                     } else {
1955                         totals[k] += *(const GLushort*)temp_index * percent;
1956                     }
1957                 }
1958
1959                 /* calculate the value for pixels in the 1st and last column */
1960                 for(m = lowy_int+1; m < highy_int; m++) {
1961                     left += ysize;
1962                     right += ysize;
1963                     for (k = 0; k < components;
1964                          k++, left += element_size, right += element_size) {
1965                         if (myswap_bytes) {
1966                             totals[k] +=
1967                                 __GLU_SWAP_2_BYTES(left) * (1-lowx_float) +
1968                                 __GLU_SWAP_2_BYTES(right) * highx_float;
1969                         } else {
1970                             totals[k] += *(const GLushort*)left * (1-lowx_float)
1971                                        + *(const GLushort*)right * highx_float;
1972                         }
1973                     }
1974                 }
1975             } else if (highy_int > lowy_int) {
1976                 x_percent = highx_float - lowx_float;
1977                 percent = (1-lowy_float)*x_percent;
1978                 temp = (const char *)datain + xindex + lowy_int*ysize;
1979                 for (k = 0, temp_index = temp; k < components;
1980                      k++, temp_index += element_size) {
1981                     if (myswap_bytes) {
1982                         totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
1983                     } else {
1984                         totals[k] += *(const GLushort*)temp_index * percent;
1985                     }
1986                 }
1987                 for(m = lowy_int+1; m < highy_int; m++) {
1988                     temp += ysize;
1989                     for (k = 0, temp_index = temp; k < components;
1990                          k++, temp_index += element_size) {
1991                         if (myswap_bytes) {
1992                             totals[k] +=
1993                                 __GLU_SWAP_2_BYTES(temp_index) * x_percent;
1994                         } else {
1995                             totals[k] += *(const GLushort*)temp_index * x_percent;
1996                         }
1997                     }
1998                 }
1999                 percent = x_percent * highy_float;
2000                 temp += ysize;
2001                 for (k = 0, temp_index = temp; k < components;
2002                      k++, temp_index += element_size) {
2003                     if (myswap_bytes) {
2004                         totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
2005                     } else {
2006                         totals[k] += *(const GLushort*)temp_index * percent;
2007                     }
2008                 }
2009             } else if (highx_int > lowx_int) {
2010                 y_percent = highy_float - lowy_float;
2011                 percent = (1-lowx_float)*y_percent;
2012                 temp = (const char *)datain + xindex + lowy_int*ysize;
2013                 for (k = 0, temp_index = temp; k < components;
2014                      k++, temp_index += element_size) {
2015                     if (myswap_bytes) {
2016                         totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
2017                     } else {
2018                         totals[k] += *(const GLushort*)temp_index * percent;
2019                     }
2020                 }
2021                 for (l = lowx_int+1; l < highx_int; l++) {
2022                     temp += group_size;
2023                     for (k = 0, temp_index = temp; k < components;
2024                          k++, temp_index += element_size) {
2025                         if (myswap_bytes) {
2026                             totals[k] +=
2027                                 __GLU_SWAP_2_BYTES(temp_index) * y_percent;
2028                         } else {
2029                             totals[k] += *(const GLushort*)temp_index * y_percent;
2030                         }
2031                     }
2032                 }
2033                 temp += group_size;
2034                 percent = y_percent * highx_float;
2035                 for (k = 0, temp_index = temp; k < components;
2036                      k++, temp_index += element_size) {
2037                     if (myswap_bytes) {
2038                         totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
2039                     } else {
2040                         totals[k] += *(const GLushort*)temp_index * percent;
2041                     }
2042                 }
2043             } else {
2044                 percent = (highy_float-lowy_float)*(highx_float-lowx_float);
2045                 temp = (const char *)datain + xindex + lowy_int * ysize;
2046                 for (k = 0, temp_index = temp; k < components;
2047                      k++, temp_index += element_size) {
2048                     if (myswap_bytes) {
2049                         totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
2050                     } else {
2051                         totals[k] += *(const GLushort*)temp_index * percent;
2052                     }
2053                 }
2054             }
2055
2056             /* this is for the pixels in the body */
2057             temp0 = (const char *)datain + xindex + group_size +
2058                  (lowy_int+1)*ysize;
2059             for (m = lowy_int+1; m < highy_int; m++) {
2060                 temp = temp0;
2061                 for(l = lowx_int+1; l < highx_int; l++) {
2062                     for (k = 0, temp_index = temp; k < components;
2063                          k++, temp_index += element_size) {
2064                         if (myswap_bytes) {
2065                             totals[k] += __GLU_SWAP_2_BYTES(temp_index);
2066                         } else {
2067                             totals[k] += *(const GLushort*)temp_index;
2068                         }
2069                     }
2070                     temp += group_size;
2071                 }
2072                 temp0 += ysize;
2073             }
2074
2075             outindex = (j + (i * widthout)) * components;
2076             for (k = 0; k < components; k++) {
2077                 dataout[outindex + k] = totals[k]/area;
2078                 /*printf("totals[%d] = %f\n", k, totals[k]);*/
2079             }
2080             lowx_int = highx_int;
2081             lowx_float = highx_float;
2082             highx_int += convx_int;
2083             highx_float += convx_float;
2084             if(highx_float > 1) {
2085                 highx_float -= 1.0;
2086                 highx_int++;
2087             }
2088         }
2089         lowy_int = highy_int;
2090         lowy_float = highy_float;
2091         highy_int += convy_int;
2092         highy_float += convy_float;
2093         if(highy_float > 1) {
2094             highy_float -= 1.0;
2095             highy_int++;
2096         }
2097     }
2098 }
2099
2100 static void scale_internal_short(GLint components, GLint widthin,
2101                            GLint heightin, const GLshort *datain,
2102                            GLint widthout, GLint heightout,
2103                            GLshort *dataout, GLint element_size,
2104                            GLint ysize, GLint group_size,
2105                            GLint myswap_bytes)
2106 {
2107     float convx;
2108     float convy;
2109     float percent;
2110     /* Max components in a format is 4, so... */
2111     float totals[4];
2112     float area;
2113     int i,j,k,xindex;
2114
2115     const char *temp, *temp0;
2116     const char *temp_index;
2117     int outindex;
2118
2119     int lowx_int, highx_int, lowy_int, highy_int;
2120     float x_percent, y_percent;
2121     float lowx_float, highx_float, lowy_float, highy_float;
2122     float convy_float, convx_float;
2123     int convy_int, convx_int;
2124     int l, m;
2125     const char *left, *right;
2126
2127     GLushort swapbuf;   /* unsigned buffer */
2128
2129     if (widthin == widthout*2 && heightin == heightout*2) {
2130         halveImage_short(components, widthin, heightin,
2131         (const GLshort *)datain, (GLshort *)dataout,
2132         element_size, ysize, group_size, myswap_bytes);
2133         return;
2134     }
2135     convy = (float) heightin/heightout;
2136     convx = (float) widthin/widthout;
2137     convy_int = floor(convy);
2138     convy_float = convy - convy_int;
2139     convx_int = floor(convx);
2140     convx_float = convx - convx_int;
2141
2142     area = convx * convy;
2143
2144     lowy_int = 0;
2145     lowy_float = 0;
2146     highy_int = convy_int;
2147     highy_float = convy_float;
2148
2149     for (i = 0; i < heightout; i++) {
2150         /* Clamp here to be sure we don't read beyond input buffer. */
2151         if (highy_int >= heightin)
2152             highy_int = heightin - 1;
2153         lowx_int = 0;
2154         lowx_float = 0;
2155         highx_int = convx_int;
2156         highx_float = convx_float;
2157
2158         for (j = 0; j < widthout; j++) {
2159             /*
2160             ** Ok, now apply box filter to box that goes from (lowx, lowy)
2161             ** to (highx, highy) on input data into this pixel on output
2162             ** data.
2163             */
2164             totals[0] = totals[1] = totals[2] = totals[3] = 0.0;
2165
2166             /* calculate the value for pixels in the 1st row */
2167             xindex = lowx_int*group_size;
2168             if((highy_int>lowy_int) && (highx_int>lowx_int)) {
2169
2170                 y_percent = 1-lowy_float;
2171                 temp = (const char *)datain + xindex + lowy_int * ysize;
2172                 percent = y_percent * (1-lowx_float);
2173                 for (k = 0, temp_index = temp; k < components;
2174                      k++, temp_index += element_size) {
2175                     if (myswap_bytes) {
2176                         swapbuf = __GLU_SWAP_2_BYTES(temp_index);
2177                         totals[k] += *(const GLshort*)&swapbuf * percent;
2178                     } else {
2179                         totals[k] += *(const GLshort*)temp_index * percent;
2180                     }
2181                 }
2182                 left = temp;
2183                 for(l = lowx_int+1; l < highx_int; l++) {
2184                     temp += group_size;
2185                     for (k = 0, temp_index = temp; k < components;
2186                          k++, temp_index += element_size) {
2187                         if (myswap_bytes) {
2188                             swapbuf = __GLU_SWAP_2_BYTES(temp_index);
2189                             totals[k] += *(const GLshort*)&swapbuf * y_percent;
2190                         } else {
2191                             totals[k] += *(const GLshort*)temp_index * y_percent;
2192                         }
2193                     }
2194                 }
2195                 temp += group_size;
2196                 right = temp;
2197                 percent = y_percent * highx_float;
2198                 for (k = 0, temp_index = temp; k < components;
2199                      k++, temp_index += element_size) {
2200                     if (myswap_bytes) {
2201                         swapbuf = __GLU_SWAP_2_BYTES(temp_index);
2202                         totals[k] += *(const GLshort*)&swapbuf * percent;
2203                     } else {
2204                         totals[k] += *(const GLshort*)temp_index * percent;
2205                     }
2206                 }
2207
2208                 /* calculate the value for pixels in the last row */
2209                 y_percent = highy_float;
2210                 percent = y_percent * (1-lowx_float);
2211                 temp = (const char *)datain + xindex + highy_int * ysize;
2212                 for (k = 0, temp_index = temp; k < components;
2213                      k++, temp_index += element_size) {
2214                     if (myswap_bytes) {
2215                         swapbuf = __GLU_SWAP_2_BYTES(temp_index);
2216                         totals[k] += *(const GLshort*)&swapbuf * percent;
2217                     } else {
2218                         totals[k] += *(const GLshort*)temp_index * percent;
2219                     }
2220                 }
2221                 for(l = lowx_int+1; l < highx_int; l++) {
2222                     temp += group_size;
2223                     for (k = 0, temp_index = temp; k < components;
2224                          k++, temp_index += element_size) {
2225                         if (myswap_bytes) {
2226                             swapbuf = __GLU_SWAP_2_BYTES(temp_index);
2227                             totals[k] += *(const GLshort*)&swapbuf * y_percent;
2228                         } else {
2229                             totals[k] += *(const GLshort*)temp_index * y_percent;
2230                         }
2231                     }
2232                 }
2233                 temp += group_size;
2234                 percent = y_percent * highx_float;
2235                 for (k = 0, temp_index = temp; k < components;
2236                      k++, temp_index += element_size) {
2237                     if (myswap_bytes) {
2238                         swapbuf = __GLU_SWAP_2_BYTES(temp_index);
2239                         totals[k] += *(const GLshort*)&swapbuf * percent;
2240                     } else {
2241                         totals[k] += *(const GLshort*)temp_index * percent;
2242                     }
2243                 }
2244
2245                 /* calculate the value for pixels in the 1st and last column */
2246                 for(m = lowy_int+1; m < highy_int; m++) {
2247                     left += ysize;
2248                     right += ysize;
2249                     for (k = 0; k < components;
2250                          k++, left += element_size, right += element_size) {
2251                         if (myswap_bytes) {
2252                             swapbuf = __GLU_SWAP_2_BYTES(left);
2253                             totals[k] += *(const GLshort*)&swapbuf * (1-lowx_float);
2254                             swapbuf = __GLU_SWAP_2_BYTES(right);
2255                             totals[k] += *(const GLshort*)&swapbuf * highx_float;
2256                         } else {
2257                             totals[k] += *(const GLshort*)left * (1-lowx_float)
2258                                        + *(const GLshort*)right * highx_float;
2259                         }
2260                     }
2261                 }
2262             } else if (highy_int > lowy_int) {
2263                 x_percent = highx_float - lowx_float;
2264                 percent = (1-lowy_float)*x_percent;
2265                 temp = (const char *)datain + xindex + lowy_int*ysize;
2266                 for (k = 0, temp_index = temp; k < components;
2267                      k++, temp_index += element_size) {
2268                     if (myswap_bytes) {
2269                         swapbuf = __GLU_SWAP_2_BYTES(temp_index);
2270                         totals[k] += *(const GLshort*)&swapbuf * percent;
2271                     } else {
2272                         totals[k] += *(const GLshort*)temp_index * percent;
2273                     }
2274                 }
2275                 for(m = lowy_int+1; m < highy_int; m++) {
2276                     temp += ysize;
2277                     for (k = 0, temp_index = temp; k < components;
2278                          k++, temp_index += element_size) {
2279                         if (myswap_bytes) {
2280                             swapbuf = __GLU_SWAP_2_BYTES(temp_index);
2281                             totals[k] += *(const GLshort*)&swapbuf * x_percent;
2282                         } else {
2283                             totals[k] += *(const GLshort*)temp_index * x_percent;
2284                         }
2285                     }
2286                 }
2287                 percent = x_percent * highy_float;
2288                 temp += ysize;
2289                 for (k = 0, temp_index = temp; k < components;
2290                      k++, temp_index += element_size) {
2291                     if (myswap_bytes) {
2292                         swapbuf = __GLU_SWAP_2_BYTES(temp_index);
2293                         totals[k] += *(const GLshort*)&swapbuf * percent;
2294                     } else {
2295                         totals[k] += *(const GLshort*)temp_index * percent;
2296                     }
2297                 }
2298             } else if (highx_int > lowx_int) {
2299                 y_percent = highy_float - lowy_float;
2300                 percent = (1-lowx_float)*y_percent;
2301
2302              temp = (const char *)datain + xindex + lowy_int*ysize;
2303                 for (k = 0, temp_index = temp; k < components;
2304                      k++, temp_index += element_size) {
2305                     if (myswap_bytes) {
2306                         swapbuf = __GLU_SWAP_2_BYTES(temp_index);
2307                         totals[k] += *(const GLshort*)&swapbuf * percent;
2308                     } else {
2309                         totals[k] += *(const GLshort*)temp_index * percent;
2310                     }
2311                 }
2312                 for (l = lowx_int+1; l < highx_int; l++) {
2313                     temp += group_size;
2314                     for (k = 0, temp_index = temp; k < components;
2315                          k++, temp_index += element_size) {
2316                         if (myswap_bytes) {
2317                             swapbuf = __GLU_SWAP_2_BYTES(temp_index);
2318                             totals[k] += *(const GLshort*)&swapbuf * y_percent;
2319                         } else {
2320                             totals[k] += *(const GLshort*)temp_index * y_percent;
2321                         }
2322                     }
2323                 }
2324                 temp += group_size;
2325                 percent = y_percent * highx_float;
2326                 for (k = 0, temp_index = temp; k < components;
2327                      k++, temp_index += element_size) {
2328                     if (myswap_bytes) {
2329                         swapbuf = __GLU_SWAP_2_BYTES(temp_index);
2330                         totals[k] += *(const GLshort*)&swapbuf * percent;
2331                     } else {
2332                         totals[k] += *(const GLshort*)temp_index * percent;
2333                     }
2334                 }
2335             } else {
2336                 percent = (highy_float-lowy_float)*(highx_float-lowx_float);
2337                 temp = (const char *)datain + xindex + lowy_int * ysize;
2338                 for (k = 0, temp_index = temp; k < components;
2339                      k++, temp_index += element_size) {
2340                     if (myswap_bytes) {
2341                         swapbuf = __GLU_SWAP_2_BYTES(temp_index);
2342                         totals[k] += *(const GLshort*)&swapbuf * percent;
2343                     } else {
2344                         totals[k] += *(const GLshort*)temp_index * percent;
2345                     }
2346                 }
2347             }
2348
2349             /* this is for the pixels in the body */
2350             temp0 = (const char *)datain + xindex + group_size +
2351                  (lowy_int+1)*ysize;
2352             for (m = lowy_int+1; m < highy_int; m++) {
2353                 temp = temp0;
2354                 for(l = lowx_int+1; l < highx_int; l++) {
2355                     for (k = 0, temp_index = temp; k < components;
2356                          k++, temp_index += element_size) {
2357                         if (myswap_bytes) {
2358                             swapbuf = __GLU_SWAP_2_BYTES(temp_index);
2359                             totals[k] += *(const GLshort*)&swapbuf;
2360                         } else {
2361                             totals[k] += *(const GLshort*)temp_index;
2362                         }
2363                     }
2364                     temp += group_size;
2365                 }
2366                 temp0 += ysize;
2367             }
2368
2369             outindex = (j + (i * widthout)) * components;
2370             for (k = 0; k < components; k++) {
2371                 dataout[outindex + k] = totals[k]/area;
2372                 /*printf("totals[%d] = %f\n", k, totals[k]);*/
2373             }
2374             lowx_int = highx_int;
2375             lowx_float = highx_float;
2376             highx_int += convx_int;
2377             highx_float += convx_float;
2378             if(highx_float > 1) {
2379                 highx_float -= 1.0;
2380                 highx_int++;
2381             }
2382         }
2383         lowy_int = highy_int;
2384         lowy_float = highy_float;
2385         highy_int += convy_int;
2386         highy_float += convy_float;
2387         if(highy_float > 1) {
2388             highy_float -= 1.0;
2389             highy_int++;
2390         }
2391     }
2392 }
2393
2394 static void scale_internal_uint(GLint components, GLint widthin,
2395                            GLint heightin, const GLuint *datain,
2396                            GLint widthout, GLint heightout,
2397                            GLuint *dataout, GLint element_size,
2398                            GLint ysize, GLint group_size,
2399                            GLint myswap_bytes)
2400 {
2401     float convx;
2402     float convy;
2403     float percent;
2404     /* Max components in a format is 4, so... */
2405     float totals[4];
2406     float area;
2407     int i,j,k,xindex;
2408
2409     const char *temp, *temp0;
2410     const char *temp_index;
2411     int outindex;
2412
2413     int lowx_int, highx_int, lowy_int, highy_int;
2414     float x_percent, y_percent;
2415     float lowx_float, highx_float, lowy_float, highy_float;
2416     float convy_float, convx_float;
2417     int convy_int, convx_int;
2418     int l, m;
2419     const char *left, *right;
2420
2421     if (widthin == widthout*2 && heightin == heightout*2) {
2422         halveImage_uint(components, widthin, heightin,
2423         (const GLuint *)datain, (GLuint *)dataout,
2424         element_size, ysize, group_size, myswap_bytes);
2425         return;
2426     }
2427     convy = (float) heightin/heightout;
2428     convx = (float) widthin/widthout;
2429     convy_int = floor(convy);
2430     convy_float = convy - convy_int;
2431     convx_int = floor(convx);
2432     convx_float = convx - convx_int;
2433
2434     area = convx * convy;
2435
2436     lowy_int = 0;
2437     lowy_float = 0;
2438     highy_int = convy_int;
2439     highy_float = convy_float;
2440
2441     for (i = 0; i < heightout; i++) {
2442         /* Clamp here to be sure we don't read beyond input buffer. */
2443         if (highy_int >= heightin)
2444             highy_int = heightin - 1;
2445         lowx_int = 0;
2446         lowx_float = 0;
2447         highx_int = convx_int;
2448         highx_float = convx_float;
2449
2450         for (j = 0; j < widthout; j++) {
2451             /*
2452             ** Ok, now apply box filter to box that goes from (lowx, lowy)
2453             ** to (highx, highy) on input data into this pixel on output
2454             ** data.
2455             */
2456             totals[0] = totals[1] = totals[2] = totals[3] = 0.0;
2457
2458             /* calculate the value for pixels in the 1st row */
2459             xindex = lowx_int*group_size;
2460             if((highy_int>lowy_int) && (highx_int>lowx_int)) {
2461
2462                 y_percent = 1-lowy_float;
2463                 temp = (const char *)datain + xindex + lowy_int * ysize;
2464                 percent = y_percent * (1-lowx_float);
2465                 for (k = 0, temp_index = temp; k < components;
2466                      k++, temp_index += element_size) {
2467                     if (myswap_bytes) {
2468                         totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;
2469                     } else {
2470                         totals[k] += *(const GLuint*)temp_index * percent;
2471                     }
2472                 }
2473                 left = temp;
2474                 for(l = lowx_int+1; l < highx_int; l++) {
2475                     temp += group_size;
2476                     for (k = 0, temp_index = temp; k < components;
2477                          k++, temp_index += element_size) {
2478                         if (myswap_bytes) {
2479                             totals[k] +=
2480                                  __GLU_SWAP_4_BYTES(temp_index) * y_percent;
2481                         } else {
2482                             totals[k] += *(const GLuint*)temp_index * y_percent;
2483                         }
2484                     }
2485                 }
2486                 temp += group_size;
2487                 right = temp;
2488                 percent = y_percent * highx_float;
2489                 for (k = 0, temp_index = temp; k < components;
2490                      k++, temp_index += element_size) {
2491                     if (myswap_bytes) {
2492                         totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;
2493                     } else {
2494                         totals[k] += *(const GLuint*)temp_index * percent;
2495                     }
2496                 }
2497
2498                 /* calculate the value for pixels in the last row */
2499                 y_percent = highy_float;
2500                 percent = y_percent * (1-lowx_float);
2501                 temp = (const char *)datain + xindex + highy_int * ysize;
2502                 for (k = 0, temp_index = temp; k < components;
2503                      k++, temp_index += element_size) {
2504                     if (myswap_bytes) {
2505                         totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;
2506                     } else {
2507                         totals[k] += *(const GLuint*)temp_index * percent;
2508                     }
2509                 }
2510                 for(l = lowx_int+1; l < highx_int; l++) {
2511                     temp += group_size;
2512                     for (k = 0, temp_index = temp; k < components;
2513                          k++, temp_index += element_size) {
2514                         if (myswap_bytes) {
2515                             totals[k] +=
2516                                  __GLU_SWAP_4_BYTES(temp_index) * y_percent;
2517                         } else {
2518                             totals[k] += *(const GLuint*)temp_index * y_percent;
2519                         }
2520                     }
2521                 }
2522                 temp += group_size;
2523                 percent = y_percent * highx_float;
2524                 for (k = 0, temp_index = temp; k < components;
2525                      k++, temp_index += element_size) {
2526                     if (myswap_bytes) {
2527                         totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;
2528                     } else {
2529                         totals[k] += *(const GLuint*)temp_index * percent;
2530                     }
2531                 }
2532
2533                 /* calculate the value for pixels in the 1st and last column */
2534                 for(m = lowy_int+1; m < highy_int; m++) {
2535                     left += ysize;
2536                     right += ysize;
2537                     for (k = 0; k < components;
2538                          k++, left += element_size, right += element_size) {
2539                         if (myswap_bytes) {
2540                             totals[k] +=
2541                                 __GLU_SWAP_4_BYTES(left) * (1-lowx_float)
2542                               + __GLU_SWAP_4_BYTES(right) * highx_float;
2543                         } else {
2544                             totals[k] += *(const GLuint*)left * (1-lowx_float)
2545                                        + *(const GLuint*)right * highx_float;
2546                         }
2547                     }
2548                 }
2549             } else if (highy_int > lowy_int) {
2550                 x_percent = highx_float - lowx_float;
2551                 percent = (1-lowy_float)*x_percent;
2552                 temp = (const char *)datain + xindex + lowy_int*ysize;
2553                 for (k = 0, temp_index = temp; k < components;
2554                      k++, temp_index += element_size) {
2555                     if (myswap_bytes) {
2556                         totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;
2557                     } else {
2558                         totals[k] += *(const GLuint*)temp_index * percent;
2559                     }
2560                 }
2561                 for(m = lowy_int+1; m < highy_int; m++) {
2562                     temp += ysize;
2563                     for (k = 0, temp_index = temp; k < components;
2564                          k++, temp_index += element_size) {
2565                         if (myswap_bytes) {
2566                             totals[k] +=
2567                                  __GLU_SWAP_4_BYTES(temp_index) * x_percent;
2568                         } else {
2569                             totals[k] += *(const GLuint*)temp_index * x_percent;
2570                         }
2571                     }
2572                 }
2573                 percent = x_percent * highy_float;
2574                 temp += ysize;
2575                 for (k = 0, temp_index = temp; k < components;
2576                      k++, temp_index += element_size) {
2577                     if (myswap_bytes) {
2578                         totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;
2579                     } else {
2580                         totals[k] += *(const GLuint*)temp_index * percent;
2581                     }
2582                 }
2583             } else if (highx_int > lowx_int) {
2584                 y_percent = highy_float - lowy_float;
2585                 percent = (1-lowx_float)*y_percent;
2586
2587              temp = (const char *)datain + xindex + lowy_int*ysize;
2588                 for (k = 0, temp_index = temp; k < components;
2589                      k++, temp_index += element_size) {
2590                     if (myswap_bytes) {
2591                         totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;
2592                     } else {
2593                         totals[k] += *(const GLuint*)temp_index * percent;
2594                     }
2595                 }
2596                 for (l = lowx_int+1; l < highx_int; l++) {
2597                     temp += group_size;
2598                     for (k = 0, temp_index = temp; k < components;
2599                          k++, temp_index += element_size) {
2600                         if (myswap_bytes) {
2601                             totals[k] +=
2602                                  __GLU_SWAP_4_BYTES(temp_index) * y_percent;
2603                         } else {
2604                             totals[k] += *(const GLuint*)temp_index * y_percent;
2605                         }
2606                     }
2607                 }
2608                 temp += group_size;
2609                 percent = y_percent * highx_float;
2610                 for (k = 0, temp_index = temp; k < components;
2611                      k++, temp_index += element_size) {
2612                     if (myswap_bytes) {
2613                         totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;
2614                     } else {
2615                         totals[k] += *(const GLuint*)temp_index * percent;
2616                     }
2617                 }
2618             } else {
2619                 percent = (highy_float-lowy_float)*(highx_float-lowx_float);
2620                 temp = (const char *)datain + xindex + lowy_int * ysize;
2621                 for (k = 0, temp_index = temp; k < components;
2622                      k++, temp_index += element_size) {
2623                     if (myswap_bytes) {
2624                         totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;
2625                     } else {
2626                         totals[k] += *(const GLuint*)temp_index * percent;
2627                     }
2628                 }
2629             }
2630
2631             /* this is for the pixels in the body */
2632             temp0 = (const char *)datain + xindex + group_size +
2633                  (lowy_int+1)*ysize;
2634             for (m = lowy_int+1; m < highy_int; m++) {
2635                 temp = temp0;
2636                 for(l = lowx_int+1; l < highx_int; l++) {
2637                     for (k = 0, temp_index = temp; k < components;
2638                          k++, temp_index += element_size) {
2639                         if (myswap_bytes) {
2640                             totals[k] += __GLU_SWAP_4_BYTES(temp_index);
2641                         } else {
2642                             totals[k] += *(const GLuint*)temp_index;
2643                         }
2644                     }
2645                     temp += group_size;
2646                 }
2647                 temp0 += ysize;
2648             }
2649
2650             outindex = (j + (i * widthout)) * components;
2651             for (k = 0; k < components; k++) {
2652                 /* clamp at UINT_MAX */
2653                 float value= totals[k]/area;
2654                 if (value >= (float) UINT_MAX) {        /* need '=' */
2655                   dataout[outindex + k] = UINT_MAX;
2656                 }
2657                 else dataout[outindex + k] = value;
2658             }
2659             lowx_int = highx_int;
2660             lowx_float = highx_float;
2661             highx_int += convx_int;
2662             highx_float += convx_float;
2663             if(highx_float > 1) {
2664                 highx_float -= 1.0;
2665                 highx_int++;
2666             }
2667         }
2668         lowy_int = highy_int;
2669         lowy_float = highy_float;
2670         highy_int += convy_int;
2671         highy_float += convy_float;
2672         if(highy_float > 1) {
2673             highy_float -= 1.0;
2674             highy_int++;
2675         }
2676     }
2677 }
2678
2679
2680
2681 static void scale_internal_int(GLint components, GLint widthin,
2682                            GLint heightin, const GLint *datain,
2683                            GLint widthout, GLint heightout,
2684                            GLint *dataout, GLint element_size,
2685                            GLint ysize, GLint group_size,
2686                            GLint myswap_bytes)
2687 {
2688     float convx;
2689     float convy;
2690     float percent;
2691     /* Max components in a format is 4, so... */
2692     float totals[4];
2693     float area;
2694     int i,j,k,xindex;
2695
2696     const char *temp, *temp0;
2697     const char *temp_index;
2698     int outindex;
2699
2700     int lowx_int, highx_int, lowy_int, highy_int;
2701     float x_percent, y_percent;
2702     float lowx_float, highx_float, lowy_float, highy_float;
2703     float convy_float, convx_float;
2704     int convy_int, convx_int;
2705     int l, m;
2706     const char *left, *right;
2707
2708     GLuint swapbuf;     /* unsigned buffer */
2709
2710     if (widthin == widthout*2 && heightin == heightout*2) {
2711         halveImage_int(components, widthin, heightin,
2712         (const GLint *)datain, (GLint *)dataout,
2713         element_size, ysize, group_size, myswap_bytes);
2714         return;
2715     }
2716     convy = (float) heightin/heightout;
2717     convx = (float) widthin/widthout;
2718     convy_int = floor(convy);
2719     convy_float = convy - convy_int;
2720     convx_int = floor(convx);
2721     convx_float = convx - convx_int;
2722
2723     area = convx * convy;
2724
2725     lowy_int = 0;
2726     lowy_float = 0;
2727     highy_int = convy_int;
2728     highy_float = convy_float;
2729
2730     for (i = 0; i < heightout; i++) {
2731         /* Clamp here to be sure we don't read beyond input buffer. */
2732         if (highy_int >= heightin)
2733             highy_int = heightin - 1;
2734         lowx_int = 0;
2735         lowx_float = 0;
2736         highx_int = convx_int;
2737         highx_float = convx_float;
2738
2739         for (j = 0; j < widthout; j++) {
2740             /*
2741             ** Ok, now apply box filter to box that goes from (lowx, lowy)
2742             ** to (highx, highy) on input data into this pixel on output
2743             ** data.
2744             */
2745             totals[0] = totals[1] = totals[2] = totals[3] = 0.0;
2746
2747             /* calculate the value for pixels in the 1st row */
2748             xindex = lowx_int*group_size;
2749             if((highy_int>lowy_int) && (highx_int>lowx_int)) {
2750
2751                 y_percent = 1-lowy_float;
2752                 temp = (const char *)datain + xindex + lowy_int * ysize;
2753                 percent = y_percent * (1-lowx_float);
2754                 for (k = 0, temp_index = temp; k < components;
2755                      k++, temp_index += element_size) {
2756                     if (myswap_bytes) {
2757                         swapbuf = __GLU_SWAP_4_BYTES(temp_index);
2758                         totals[k] += *(const GLint*)&swapbuf * percent;
2759                     } else {
2760                         totals[k] += *(const GLint*)temp_index * percent;
2761                     }
2762                 }
2763                 left = temp;
2764                 for(l = lowx_int+1; l < highx_int; l++) {
2765                     temp += group_size;
2766                     for (k = 0, temp_index = temp; k < components;
2767                          k++, temp_index += element_size) {
2768                         if (myswap_bytes) {
2769                             swapbuf = __GLU_SWAP_4_BYTES(temp_index);
2770                             totals[k] += *(const GLint*)&swapbuf * y_percent;
2771                         } else {
2772                             totals[k] += *(const GLint*)temp_index * y_percent;
2773                         }
2774                     }
2775                 }
2776                 temp += group_size;
2777                 right = temp;
2778                 percent = y_percent * highx_float;
2779                 for (k = 0, temp_index = temp; k < components;
2780                      k++, temp_index += element_size) {
2781                     if (myswap_bytes) {
2782                         swapbuf = __GLU_SWAP_4_BYTES(temp_index);
2783                         totals[k] += *(const GLint*)&swapbuf * percent;
2784                     } else {
2785                         totals[k] += *(const GLint*)temp_index * percent;
2786                     }
2787                 }
2788
2789                 /* calculate the value for pixels in the last row */
2790                 y_percent = highy_float;
2791                 percent = y_percent * (1-lowx_float);
2792                 temp = (const char *)datain + xindex + highy_int * ysize;
2793                 for (k = 0, temp_index = temp; k < components;
2794                      k++, temp_index += element_size) {
2795                     if (myswap_bytes) {
2796                         swapbuf = __GLU_SWAP_4_BYTES(temp_index);
2797                         totals[k] += *(const GLint*)&swapbuf  * percent;
2798                     } else {
2799                         totals[k] += *(const GLint*)temp_index * percent;
2800                     }
2801                 }
2802                 for(l = lowx_int+1; l < highx_int; l++) {
2803                     temp += group_size;
2804                     for (k = 0, temp_index = temp; k < components;
2805                          k++, temp_index += element_size) {
2806                         if (myswap_bytes) {
2807                             swapbuf = __GLU_SWAP_4_BYTES(temp_index);
2808                             totals[k] += *(const GLint*)&swapbuf * y_percent;
2809                         } else {
2810                             totals[k] += *(const GLint*)temp_index * y_percent;
2811                         }
2812                     }
2813                 }
2814                 temp += group_size;
2815                 percent = y_percent * highx_float;
2816                 for (k = 0, temp_index = temp; k < components;
2817                      k++, temp_index += element_size) {
2818                     if (myswap_bytes) {
2819                         swapbuf = __GLU_SWAP_4_BYTES(temp_index);
2820                         totals[k] += *(const GLint*)&swapbuf * percent;
2821                     } else {
2822                         totals[k] += *(const GLint*)temp_index * percent;
2823                     }
2824                 }
2825
2826                 /* calculate the value for pixels in the 1st and last column */
2827                 for(m = lowy_int+1; m < highy_int; m++) {
2828                     left += ysize;
2829                     right += ysize;
2830                     for (k = 0; k < components;
2831                          k++, left += element_size, right += element_size) {
2832                         if (myswap_bytes) {
2833                             swapbuf = __GLU_SWAP_4_BYTES(left);
2834                             totals[k] += *(const GLint*)&swapbuf * (1-lowx_float);
2835                             swapbuf = __GLU_SWAP_4_BYTES(right);
2836                             totals[k] += *(const GLint*)&swapbuf * highx_float;
2837                         } else {
2838                             totals[k] += *(const GLint*)left * (1-lowx_float)
2839                                        + *(const GLint*)right * highx_float;
2840                         }
2841                     }
2842                 }
2843             } else if (highy_int > lowy_int) {
2844                 x_percent = highx_float - lowx_float;
2845                 percent = (1-lowy_float)*x_percent;
2846                 temp = (const char *)datain + xindex + lowy_int*ysize;
2847                 for (k = 0, temp_index = temp; k < components;
2848                      k++, temp_index += element_size) {
2849                     if (myswap_bytes) {
2850                         swapbuf = __GLU_SWAP_4_BYTES(temp_index);
2851                         totals[k] += *(const GLint*)&swapbuf * percent;
2852                     } else {
2853                         totals[k] += *(const GLint*)temp_index * percent;
2854                     }
2855                 }
2856                 for(m = lowy_int+1; m < highy_int; m++) {
2857                     temp += ysize;
2858                     for (k = 0, temp_index = temp; k < components;
2859                          k++, temp_index += element_size) {
2860                         if (myswap_bytes) {
2861                             swapbuf = __GLU_SWAP_4_BYTES(temp_index);
2862                             totals[k] += *(const GLint*)&swapbuf * x_percent;
2863                         } else {
2864                             totals[k] += *(const GLint*)temp_index * x_percent;
2865                         }
2866                     }
2867                 }
2868                 percent = x_percent * highy_float;
2869                 temp += ysize;
2870                 for (k = 0, temp_index = temp; k < components;
2871                      k++, temp_index += element_size) {
2872                     if (myswap_bytes) {
2873                         swapbuf = __GLU_SWAP_4_BYTES(temp_index);
2874                         totals[k] += *(const GLint*)&swapbuf * percent;
2875                     } else {
2876                         totals[k] += *(const GLint*)temp_index * percent;
2877                     }
2878                 }
2879             } else if (highx_int > lowx_int) {
2880                 y_percent = highy_float - lowy_float;
2881                 percent = (1-lowx_float)*y_percent;
2882
2883                  temp = (const char *)datain + xindex + lowy_int*ysize;
2884                 for (k = 0, temp_index = temp; k < components;
2885                      k++, temp_index += element_size) {
2886                     if (myswap_bytes) {
2887                         swapbuf = __GLU_SWAP_4_BYTES(temp_index);
2888                         totals[k] += *(const GLint*)&swapbuf * percent;
2889                     } else {
2890                         totals[k] += *(const GLint*)temp_index * percent;
2891                     }
2892                 }
2893                 for (l = lowx_int+1; l < highx_int; l++) {
2894                     temp += group_size;
2895                     for (k = 0, temp_index = temp; k < components;
2896                          k++, temp_index += element_size) {
2897                         if (myswap_bytes) {
2898                             swapbuf = __GLU_SWAP_4_BYTES(temp_index);
2899                             totals[k] += *(const GLint*)&swapbuf * y_percent;
2900                         } else {
2901                             totals[k] += *(const GLint*)temp_index * y_percent;
2902                         }
2903                     }
2904                 }
2905                 temp += group_size;
2906                 percent = y_percent * highx_float;
2907                 for (k = 0, temp_index = temp; k < components;
2908                      k++, temp_index += element_size) {
2909                     if (myswap_bytes) {
2910                         swapbuf = __GLU_SWAP_4_BYTES(temp_index);
2911                         totals[k] += *(const GLint*)&swapbuf * percent;
2912                     } else {
2913                         totals[k] += *(const GLint*)temp_index * percent;
2914                     }
2915                 }
2916             } else {
2917                 percent = (highy_float-lowy_float)*(highx_float-lowx_float);
2918                 temp = (const char *)datain + xindex + lowy_int * ysize;
2919                 for (k = 0, temp_index = temp; k < components;
2920                      k++, temp_index += element_size) {
2921                     if (myswap_bytes) {
2922                         swapbuf = __GLU_SWAP_4_BYTES(temp_index);
2923                         totals[k] += *(const GLint*)&swapbuf * percent;
2924                     } else {
2925                         totals[k] += *(const GLint*)temp_index * percent;
2926                     }
2927                 }
2928             }
2929
2930             /* this is for the pixels in the body */
2931             temp0 = (const char *)datain + xindex + group_size +
2932                  (lowy_int+1)*ysize;
2933             for (m = lowy_int+1; m < highy_int; m++) {
2934                 temp = temp0;
2935                 for(l = lowx_int+1; l < highx_int; l++) {
2936                     for (k = 0, temp_index = temp; k < components;
2937                          k++, temp_index += element_size) {
2938                         if (myswap_bytes) {
2939                             swapbuf = __GLU_SWAP_4_BYTES(temp_index);
2940                             totals[k] += *(const GLint*)&swapbuf;
2941                         } else {
2942                             totals[k] += *(const GLint*)temp_index;
2943                         }
2944                     }
2945                     temp += group_size;
2946                 }
2947                 temp0 += ysize;
2948             }
2949
2950             outindex = (j + (i * widthout)) * components;
2951             for (k = 0; k < components; k++) {
2952                 dataout[outindex + k] = totals[k]/area;
2953                 /*printf("totals[%d] = %f\n", k, totals[k]);*/
2954             }
2955             lowx_int = highx_int;
2956             lowx_float = highx_float;
2957             highx_int += convx_int;
2958             highx_float += convx_float;
2959             if(highx_float > 1) {
2960                 highx_float -= 1.0;
2961                 highx_int++;
2962             }
2963         }
2964         lowy_int = highy_int;
2965         lowy_float = highy_float;
2966         highy_int += convy_int;
2967         highy_float += convy_float;
2968         if(highy_float > 1) {
2969             highy_float -= 1.0;
2970             highy_int++;
2971         }
2972     }
2973 }
2974
2975
2976
2977 static void scale_internal_float(GLint components, GLint widthin,
2978                            GLint heightin, const GLfloat *datain,
2979                            GLint widthout, GLint heightout,
2980                            GLfloat *dataout, GLint element_size,
2981                            GLint ysize, GLint group_size,
2982                            GLint myswap_bytes)
2983 {
2984     float convx;
2985     float convy;
2986     float percent;
2987     /* Max components in a format is 4, so... */
2988     float totals[4];
2989     float area;
2990     int i,j,k,xindex;
2991
2992     const char *temp, *temp0;
2993     const char *temp_index;
2994     int outindex;
2995
2996     int lowx_int, highx_int, lowy_int, highy_int;
2997     float x_percent, y_percent;
2998     float lowx_float, highx_float, lowy_float, highy_float;
2999     float convy_float, convx_float;
3000     int convy_int, convx_int;
3001     int l, m;
3002     const char *left, *right;
3003
3004     union { GLuint b; GLfloat f; } swapbuf;
3005
3006     if (widthin == widthout*2 && heightin == heightout*2) {
3007         halveImage_float(components, widthin, heightin,
3008         (const GLfloat *)datain, (GLfloat *)dataout,
3009         element_size, ysize, group_size, myswap_bytes);
3010         return;
3011     }
3012     convy = (float) heightin/heightout;
3013     convx = (float) widthin/widthout;
3014     convy_int = floor(convy);
3015     convy_float = convy - convy_int;
3016     convx_int = floor(convx);
3017     convx_float = convx - convx_int;
3018
3019     area = convx * convy;
3020
3021     lowy_int = 0;
3022     lowy_float = 0;
3023     highy_int = convy_int;
3024     highy_float = convy_float;
3025
3026     for (i = 0; i < heightout; i++) {
3027         /* Clamp here to be sure we don't read beyond input buffer. */
3028         if (highy_int >= heightin)
3029             highy_int = heightin - 1;
3030         lowx_int = 0;
3031         lowx_float = 0;
3032         highx_int = convx_int;
3033         highx_float = convx_float;
3034
3035         for (j = 0; j < widthout; j++) {
3036             /*
3037             ** Ok, now apply box filter to box that goes from (lowx, lowy)
3038             ** to (highx, highy) on input data into this pixel on output
3039             ** data.
3040             */
3041             totals[0] = totals[1] = totals[2] = totals[3] = 0.0;
3042
3043             /* calculate the value for pixels in the 1st row */
3044             xindex = lowx_int*group_size;
3045             if((highy_int>lowy_int) && (highx_int>lowx_int)) {
3046
3047                 y_percent = 1-lowy_float;
3048                 temp = (const char *)datain + xindex + lowy_int * ysize;
3049                 percent = y_percent * (1-lowx_float);
3050                 for (k = 0, temp_index = temp; k < components;
3051                      k++, temp_index += element_size) {
3052                     if (myswap_bytes) {
3053                         swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
3054                         totals[k] += swapbuf.f * percent;
3055                     } else {
3056                         totals[k] += *(const GLfloat*)temp_index * percent;
3057                     }
3058                 }
3059                 left = temp;
3060                 for(l = lowx_int+1; l < highx_int; l++) {
3061                     temp += group_size;
3062                     for (k = 0, temp_index = temp; k < components;
3063                          k++, temp_index += element_size) {
3064                         if (myswap_bytes) {
3065                             swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
3066                             totals[k] += swapbuf.f * y_percent;
3067                         } else {
3068                             totals[k] += *(const GLfloat*)temp_index * y_percent;
3069                         }
3070                     }
3071                 }
3072                 temp += group_size;
3073                 right = temp;
3074                 percent = y_percent * highx_float;
3075                 for (k = 0, temp_index = temp; k < components;
3076                      k++, temp_index += element_size) {
3077                     if (myswap_bytes) {
3078                         swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
3079                         totals[k] += swapbuf.f * percent;
3080                     } else {
3081                         totals[k] += *(const GLfloat*)temp_index * percent;
3082                     }
3083                 }
3084
3085                 /* calculate the value for pixels in the last row */
3086                 y_percent = highy_float;
3087                 percent = y_percent * (1-lowx_float);
3088                 temp = (const char *)datain + xindex + highy_int * ysize;
3089                 for (k = 0, temp_index = temp; k < components;
3090                      k++, temp_index += element_size) {
3091                     if (myswap_bytes) {
3092                         swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
3093                         totals[k] += swapbuf.f * percent;
3094                     } else {
3095                         totals[k] += *(const GLfloat*)temp_index * percent;
3096                     }
3097                 }
3098                 for(l = lowx_int+1; l < highx_int; l++) {
3099                     temp += group_size;
3100                     for (k = 0, temp_index = temp; k < components;
3101                          k++, temp_index += element_size) {
3102                         if (myswap_bytes) {
3103                             swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
3104                             totals[k] += swapbuf.f * y_percent;
3105                         } else {
3106                             totals[k] += *(const GLfloat*)temp_index * y_percent;
3107                         }
3108                     }
3109                 }
3110                 temp += group_size;
3111                 percent = y_percent * highx_float;
3112                 for (k = 0, temp_index = temp; k < components;
3113                      k++, temp_index += element_size) {
3114                     if (myswap_bytes) {
3115                         swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
3116                         totals[k] += swapbuf.f * percent;
3117                     } else {
3118                         totals[k] += *(const GLfloat*)temp_index * percent;
3119                     }
3120                 }
3121
3122                 /* calculate the value for pixels in the 1st and last column */
3123                 for(m = lowy_int+1; m < highy_int; m++) {
3124                     left += ysize;
3125                     right += ysize;
3126                     for (k = 0; k < components;
3127                          k++, left += element_size, right += element_size) {
3128                         if (myswap_bytes) {
3129                             swapbuf.b = __GLU_SWAP_4_BYTES(left);
3130                             totals[k] += swapbuf.f * (1-lowx_float);
3131                             swapbuf.b = __GLU_SWAP_4_BYTES(right);
3132                             totals[k] += swapbuf.f * highx_float;
3133                         } else {
3134                             totals[k] += *(const GLfloat*)left * (1-lowx_float)
3135                                        + *(const GLfloat*)right * highx_float;
3136                         }
3137                     }
3138                 }
3139             } else if (highy_int > lowy_int) {
3140                 x_percent = highx_float - lowx_float;
3141                 percent = (1-lowy_float)*x_percent;
3142                 temp = (const char *)datain + xindex + lowy_int*ysize;
3143                 for (k = 0, temp_index = temp; k < components;
3144                      k++, temp_index += element_size) {
3145                     if (myswap_bytes) {
3146                         swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
3147                         totals[k] += swapbuf.f * percent;
3148                     } else {
3149                         totals[k] += *(const GLfloat*)temp_index * percent;
3150                     }
3151                 }
3152                 for(m = lowy_int+1; m < highy_int; m++) {
3153                     temp += ysize;
3154                     for (k = 0, temp_index = temp; k < components;
3155                          k++, temp_index += element_size) {
3156                         if (myswap_bytes) {
3157                             swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
3158                             totals[k] += swapbuf.f * x_percent;
3159                         } else {
3160                             totals[k] += *(const GLfloat*)temp_index * x_percent;
3161                         }
3162                     }
3163                 }
3164                 percent = x_percent * highy_float;
3165                 temp += ysize;
3166                 for (k = 0, temp_index = temp; k < components;
3167                      k++, temp_index += element_size) {
3168                     if (myswap_bytes) {
3169                         swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
3170                         totals[k] += swapbuf.f * percent;
3171                     } else {
3172                         totals[k] += *(const GLfloat*)temp_index * percent;
3173                     }
3174                 }
3175             } else if (highx_int > lowx_int) {
3176                 y_percent = highy_float - lowy_float;
3177                 percent = (1-lowx_float)*y_percent;
3178
3179              temp = (const char *)datain + xindex + lowy_int*ysize;
3180                 for (k = 0, temp_index = temp; k < components;
3181                      k++, temp_index += element_size) {
3182                     if (myswap_bytes) {
3183                         swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
3184                         totals[k] += swapbuf.f * percent;
3185                     } else {
3186                         totals[k] += *(const GLfloat*)temp_index * percent;
3187                     }
3188                 }
3189                 for (l = lowx_int+1; l < highx_int; l++) {
3190                     temp += group_size;
3191                     for (k = 0, temp_index = temp; k < components;
3192                          k++, temp_index += element_size) {
3193                         if (myswap_bytes) {
3194                             swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
3195                             totals[k] += swapbuf.f * y_percent;
3196                         } else {
3197                             totals[k] += *(const GLfloat*)temp_index * y_percent;
3198                         }
3199                     }
3200                 }
3201                 temp += group_size;
3202                 percent = y_percent * highx_float;
3203                 for (k = 0, temp_index = temp; k < components;
3204                      k++, temp_index += element_size) {
3205                     if (myswap_bytes) {
3206                         swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
3207                         totals[k] += swapbuf.f * percent;
3208                     } else {
3209                         totals[k] += *(const GLfloat*)temp_index * percent;
3210                     }
3211                 }
3212             } else {
3213                 percent = (highy_float-lowy_float)*(highx_float-lowx_float);
3214                 temp = (const char *)datain + xindex + lowy_int * ysize;
3215                 for (k = 0, temp_index = temp; k < components;
3216                      k++, temp_index += element_size) {
3217                     if (myswap_bytes) {
3218                         swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
3219                         totals[k] += swapbuf.f * percent;
3220                     } else {
3221                         totals[k] += *(const GLfloat*)temp_index * percent;
3222                     }
3223                 }
3224             }
3225
3226             /* this is for the pixels in the body */
3227             temp0 = (const char *)datain + xindex + group_size +
3228                  (lowy_int+1)*ysize;
3229             for (m = lowy_int+1; m < highy_int; m++) {
3230                 temp = temp0;
3231                 for(l = lowx_int+1; l < highx_int; l++) {
3232                     for (k = 0, temp_index = temp; k < components;
3233                          k++, temp_index += element_size) {
3234                         if (myswap_bytes) {
3235                             swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
3236                             totals[k] += swapbuf.f;
3237                         } else {
3238                             totals[k] += *(const GLfloat*)temp_index;
3239                         }
3240                     }
3241                     temp += group_size;
3242                 }
3243                 temp0 += ysize;
3244             }
3245
3246             outindex = (j + (i * widthout)) * components;
3247             for (k = 0; k < components; k++) {
3248                 dataout[outindex + k] = totals[k]/area;
3249                 /*printf("totals[%d] = %f\n", k, totals[k]);*/
3250             }
3251             lowx_int = highx_int;
3252             lowx_float = highx_float;
3253             highx_int += convx_int;
3254             highx_float += convx_float;
3255             if(highx_float > 1) {
3256                 highx_float -= 1.0;
3257                 highx_int++;
3258             }
3259         }
3260         lowy_int = highy_int;
3261         lowy_float = highy_float;
3262         highy_int += convy_int;
3263         highy_float += convy_float;
3264         if(highy_float > 1) {
3265             highy_float -= 1.0;
3266             highy_int++;
3267         }
3268     }
3269 }
3270
3271 static int checkMipmapArgs(GLenum internalFormat, GLenum format, GLenum type)
3272 {
3273     if (!legalFormat(format) || !legalType(type)) {
3274         return GLU_INVALID_ENUM;
3275     }
3276     if (format == GL_STENCIL_INDEX) {
3277         return GLU_INVALID_ENUM;
3278     }
3279
3280     if (!isLegalFormatForPackedPixelType(format, type)) {
3281         return GLU_INVALID_OPERATION;
3282     }
3283
3284     return 0;
3285 } /* checkMipmapArgs() */
3286
3287 static GLboolean legalFormat(GLenum format)
3288 {
3289     switch(format) {
3290       case GL_COLOR_INDEX:
3291       case GL_STENCIL_INDEX:
3292       case GL_DEPTH_COMPONENT:
3293       case GL_RED:
3294       case GL_GREEN:
3295       case GL_BLUE:
3296       case GL_ALPHA:
3297       case GL_RGB:
3298       case GL_RGBA:
3299       case GL_LUMINANCE:
3300       case GL_LUMINANCE_ALPHA:
3301       case GL_BGR:
3302       case GL_BGRA:
3303         return GL_TRUE;
3304       default:
3305         return GL_FALSE;
3306     }
3307 }
3308
3309
3310 static GLboolean legalType(GLenum type)
3311 {
3312     switch(type) {
3313       case GL_BITMAP:
3314       case GL_BYTE:
3315       case GL_UNSIGNED_BYTE:
3316       case GL_SHORT:
3317       case GL_UNSIGNED_SHORT:
3318       case GL_INT:
3319       case GL_UNSIGNED_INT:
3320       case GL_FLOAT:
3321       case GL_UNSIGNED_BYTE_3_3_2:
3322       case GL_UNSIGNED_BYTE_2_3_3_REV:
3323       case GL_UNSIGNED_SHORT_5_6_5:
3324       case GL_UNSIGNED_SHORT_5_6_5_REV:
3325       case GL_UNSIGNED_SHORT_4_4_4_4:
3326       case GL_UNSIGNED_SHORT_4_4_4_4_REV:
3327       case GL_UNSIGNED_SHORT_5_5_5_1:
3328       case GL_UNSIGNED_SHORT_1_5_5_5_REV:
3329       case GL_UNSIGNED_INT_8_8_8_8:
3330       case GL_UNSIGNED_INT_8_8_8_8_REV:
3331       case GL_UNSIGNED_INT_10_10_10_2:
3332       case GL_UNSIGNED_INT_2_10_10_10_REV:
3333          return GL_TRUE;
3334       default:
3335         return GL_FALSE;
3336     }
3337 }
3338
3339 /* */
3340 static GLboolean isTypePackedPixel(GLenum type)
3341 {
3342    assert(legalType(type));
3343
3344    if (type == GL_UNSIGNED_BYTE_3_3_2 ||
3345        type == GL_UNSIGNED_BYTE_2_3_3_REV ||
3346        type == GL_UNSIGNED_SHORT_5_6_5 ||
3347        type == GL_UNSIGNED_SHORT_5_6_5_REV ||
3348        type == GL_UNSIGNED_SHORT_4_4_4_4 ||
3349        type == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
3350        type == GL_UNSIGNED_SHORT_5_5_5_1 ||
3351        type == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
3352        type == GL_UNSIGNED_INT_8_8_8_8 ||
3353        type == GL_UNSIGNED_INT_8_8_8_8_REV ||
3354        type == GL_UNSIGNED_INT_10_10_10_2 ||
3355        type == GL_UNSIGNED_INT_2_10_10_10_REV) {
3356       return 1;
3357    }
3358    else return 0;
3359 } /* isTypePackedPixel() */
3360
3361 /* Determines if the packed pixel type is compatible with the format */
3362 static GLboolean isLegalFormatForPackedPixelType(GLenum format, GLenum type)
3363 {
3364    /* if not a packed pixel type then return true */
3365    if (!isTypePackedPixel(type)) {
3366       return GL_TRUE;
3367    }
3368
3369    /* 3_3_2/2_3_3_REV & 5_6_5/5_6_5_REV are only compatible with RGB */
3370    if ((type == GL_UNSIGNED_BYTE_3_3_2 || type == GL_UNSIGNED_BYTE_2_3_3_REV||
3371         type == GL_UNSIGNED_SHORT_5_6_5|| type == GL_UNSIGNED_SHORT_5_6_5_REV)
3372        && format != GL_RGB)
3373       return GL_FALSE;
3374
3375    /* 4_4_4_4/4_4_4_4_REV & 5_5_5_1/1_5_5_5_REV & 8_8_8_8/8_8_8_8_REV &
3376     * 10_10_10_2/2_10_10_10_REV are only compatible with RGBA, BGRA & ABGR_EXT.
3377     */
3378    if ((type == GL_UNSIGNED_SHORT_4_4_4_4 ||
3379         type == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
3380         type == GL_UNSIGNED_SHORT_5_5_5_1 ||
3381         type == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
3382         type == GL_UNSIGNED_INT_8_8_8_8 ||
3383         type == GL_UNSIGNED_INT_8_8_8_8_REV ||
3384         type == GL_UNSIGNED_INT_10_10_10_2 ||
3385         type == GL_UNSIGNED_INT_2_10_10_10_REV) &&
3386        (format != GL_RGBA &&
3387         format != GL_BGRA)) {
3388       return GL_FALSE;
3389    }
3390
3391    return GL_TRUE;
3392 } /* isLegalFormatForPackedPixelType() */
3393
3394 static GLboolean isLegalLevels(GLint userLevel,GLint baseLevel,GLint maxLevel,
3395                                GLint totalLevels)
3396 {
3397    if (baseLevel < 0 || baseLevel < userLevel || maxLevel < baseLevel ||
3398        totalLevels < maxLevel)
3399       return GL_FALSE;
3400    else return GL_TRUE;
3401 } /* isLegalLevels() */
3402
3403 /* Given user requested texture size, determine if it fits. If it
3404  * doesn't then halve both sides and make the determination again
3405  * until it does fit (for IR only).
3406  * Note that proxy textures are not implemented in RE* even though
3407  * they advertise the texture extension.
3408  * Note that proxy textures are implemented but not according to spec in
3409  * IMPACT*.
3410  */
3411 static void closestFit(GLenum target, GLint width, GLint height,
3412                        GLint internalFormat, GLenum format, GLenum type,
3413                        GLint *newWidth, GLint *newHeight)
3414 {
3415    /* Use proxy textures if OpenGL version is >= 1.1 */
3416    if ( (strtod((const char *)glGetString(GL_VERSION),NULL) >= 1.1)
3417         ) {
3418       GLint widthPowerOf2= nearestPower(width);
3419       GLint heightPowerOf2= nearestPower(height);
3420       GLint proxyWidth;
3421
3422       do {
3423          /* compute level 1 width & height, clamping each at 1 */
3424          GLint widthAtLevelOne= (widthPowerOf2 > 1) ?
3425                                  widthPowerOf2 >> 1 :
3426                                  widthPowerOf2;
3427          GLint heightAtLevelOne= (heightPowerOf2 > 1) ?
3428                                   heightPowerOf2 >> 1 :
3429                                   heightPowerOf2;
3430          GLenum proxyTarget;
3431          assert(widthAtLevelOne > 0); assert(heightAtLevelOne > 0);
3432
3433          /* does width x height at level 1 & all their mipmaps fit? */
3434          if (target == GL_TEXTURE_2D || target == GL_PROXY_TEXTURE_2D) {
3435             proxyTarget = GL_PROXY_TEXTURE_2D;
3436             glTexImage2D(proxyTarget, 1, /* must be non-zero */
3437                          internalFormat,
3438                          widthAtLevelOne,heightAtLevelOne,0,format,type,NULL);
3439          } else
3440 #if defined(GL_ARB_texture_cube_map)
3441          if ((target == GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB) ||
3442              (target == GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB) ||
3443              (target == GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB) ||
3444              (target == GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB) ||
3445              (target == GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB) ||
3446              (target == GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB)) {
3447              proxyTarget = GL_PROXY_TEXTURE_CUBE_MAP_ARB;
3448              glTexImage2D(proxyTarget, 1, /* must be non-zero */
3449                           internalFormat,
3450                           widthAtLevelOne,heightAtLevelOne,0,format,type,NULL);
3451          } else
3452 #endif /* GL_ARB_texture_cube_map */
3453          {
3454             assert(target == GL_TEXTURE_1D || target == GL_PROXY_TEXTURE_1D);
3455             proxyTarget = GL_PROXY_TEXTURE_1D;
3456             glTexImage1D(proxyTarget, 1, /* must be non-zero */
3457                          internalFormat,widthAtLevelOne,0,format,type,NULL);
3458          }
3459          glGetTexLevelParameteriv(proxyTarget, 1,GL_TEXTURE_WIDTH,&proxyWidth);
3460          /* does it fit??? */
3461          if (proxyWidth == 0) { /* nope, so try again with these sizes */
3462             if (widthPowerOf2 == 1 && heightPowerOf2 == 1) {
3463                /* An 1x1 texture couldn't fit for some reason, so
3464                 * break out.  This should never happen. But things
3465                 * happen.  The disadvantage with this if-statement is
3466                 * that we will never be aware of when this happens
3467                 * since it will silently branch out.
3468                 */
3469                goto noProxyTextures;
3470             }
3471             widthPowerOf2= widthAtLevelOne;
3472             heightPowerOf2= heightAtLevelOne;
3473          }
3474          /* else it does fit */
3475       } while (proxyWidth == 0);
3476       /* loop must terminate! */
3477
3478       /* return the width & height at level 0 that fits */
3479       *newWidth= widthPowerOf2;
3480       *newHeight= heightPowerOf2;
3481 /*printf("Proxy Textures\n");*/
3482    } /* if gluCheckExtension() */
3483    else {                       /* no texture extension, so do this instead */
3484       GLint maxsize;
3485
3486 noProxyTextures:
3487
3488       glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxsize);
3489       /* clamp user's texture sizes to maximum sizes, if necessary */
3490       *newWidth = nearestPower(width);
3491       if (*newWidth > maxsize) *newWidth = maxsize;
3492       *newHeight = nearestPower(height);
3493       if (*newHeight > maxsize) *newHeight = maxsize;
3494 /*printf("NO proxy textures\n");*/
3495    }
3496 } /* closestFit() */
3497
3498 GLint GLAPIENTRY
3499 gluScaleImage(GLenum format, GLsizei widthin, GLsizei heightin,
3500                     GLenum typein, const void *datain,
3501                     GLsizei widthout, GLsizei heightout, GLenum typeout,
3502                     void *dataout)
3503 {
3504     int components;
3505     GLushort *beforeImage;
3506     GLushort *afterImage;
3507     PixelStorageModes psm;
3508
3509     if (widthin == 0 || heightin == 0 || widthout == 0 || heightout == 0) {
3510         return 0;
3511     }
3512     if (widthin < 0 || heightin < 0 || widthout < 0 || heightout < 0) {
3513         return GLU_INVALID_VALUE;
3514     }
3515     if (!legalFormat(format) || !legalType(typein) || !legalType(typeout)) {
3516         return GLU_INVALID_ENUM;
3517     }
3518     if (!isLegalFormatForPackedPixelType(format, typein)) {
3519        return GLU_INVALID_OPERATION;
3520     }
3521     if (!isLegalFormatForPackedPixelType(format, typeout)) {
3522        return GLU_INVALID_OPERATION;
3523     }
3524     beforeImage =
3525         malloc(image_size(widthin, heightin, format, GL_UNSIGNED_SHORT));
3526     afterImage =
3527         malloc(image_size(widthout, heightout, format, GL_UNSIGNED_SHORT));
3528     if (beforeImage == NULL || afterImage == NULL) {
3529         free(beforeImage);
3530         free(afterImage);
3531         return GLU_OUT_OF_MEMORY;
3532     }
3533
3534     retrieveStoreModes(&psm);
3535     fill_image(&psm,widthin, heightin, format, typein, is_index(format),
3536             datain, beforeImage);
3537     components = elements_per_group(format, 0);
3538     scale_internal(components, widthin, heightin, beforeImage,
3539             widthout, heightout, afterImage);
3540     empty_image(&psm,widthout, heightout, format, typeout,
3541             is_index(format), afterImage, dataout);
3542     free((GLbyte *) beforeImage);
3543     free((GLbyte *) afterImage);
3544
3545     return 0;
3546 }
3547
3548 int gluBuild1DMipmapLevelsCore(GLenum target, GLint internalFormat,
3549                                GLsizei width,
3550                                GLsizei widthPowerOf2,
3551                                GLenum format, GLenum type,
3552                                GLint userLevel, GLint baseLevel,GLint maxLevel,
3553                                const void *data)
3554 {
3555     GLint newwidth;
3556     GLint level, levels;
3557     GLushort *newImage;
3558     GLint newImage_width;
3559     GLushort *otherImage;
3560     GLushort *imageTemp;
3561     GLint memreq;
3562     GLint cmpts;
3563     PixelStorageModes psm;
3564
3565     assert(checkMipmapArgs(internalFormat,format,type) == 0);
3566     assert(width >= 1);
3567
3568     otherImage = NULL;
3569
3570     newwidth= widthPowerOf2;
3571     levels = computeLog(newwidth);
3572
3573     levels+= userLevel;
3574
3575     retrieveStoreModes(&psm);
3576     newImage = (GLushort *)
3577         malloc(image_size(width, 1, format, GL_UNSIGNED_SHORT));
3578     newImage_width = width;
3579     if (newImage == NULL) {
3580         return GLU_OUT_OF_MEMORY;
3581     }
3582     fill_image(&psm,width, 1, format, type, is_index(format),
3583             data, newImage);
3584     cmpts = elements_per_group(format,type);
3585     glPixelStorei(GL_UNPACK_ALIGNMENT, 2);
3586     glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
3587     glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
3588     glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
3589     /*
3590     ** If swap_bytes was set, swapping occurred in fill_image.
3591     */
3592     glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE);
3593
3594     for (level = userLevel; level <= levels; level++) {
3595         if (newImage_width == newwidth) {
3596             /* Use newImage for this level */
3597             if (baseLevel <= level && level <= maxLevel) {
3598             glTexImage1D(target, level, internalFormat, newImage_width,
3599                     0, format, GL_UNSIGNED_SHORT, (void *) newImage);
3600             }
3601         } else {
3602             if (otherImage == NULL) {
3603                 memreq = image_size(newwidth, 1, format, GL_UNSIGNED_SHORT);
3604                 otherImage = (GLushort *) malloc(memreq);
3605                 if (otherImage == NULL) {
3606                     glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
3607                     glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
3608                     glPixelStorei(GL_UNPACK_SKIP_PIXELS,psm.unpack_skip_pixels);
3609                     glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
3610                     glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
3611                     free(newImage);
3612                     return GLU_OUT_OF_MEMORY;
3613                 }
3614             }
3615             scale_internal(cmpts, newImage_width, 1, newImage,
3616                     newwidth, 1, otherImage);
3617             /* Swap newImage and otherImage */
3618             imageTemp = otherImage;
3619             otherImage = newImage;
3620             newImage = imageTemp;
3621
3622             newImage_width = newwidth;
3623             if (baseLevel <= level && level <= maxLevel) {
3624             glTexImage1D(target, level, internalFormat, newImage_width,
3625                     0, format, GL_UNSIGNED_SHORT, (void *) newImage);
3626             }
3627         }
3628         if (newwidth > 1) newwidth /= 2;
3629     }
3630     glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
3631     glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
3632     glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
3633     glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
3634     glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
3635
3636     free((GLbyte *) newImage);
3637     if (otherImage) {
3638         free((GLbyte *) otherImage);
3639     }
3640     return 0;
3641 }
3642
3643 GLint GLAPIENTRY
3644 gluBuild1DMipmapLevels(GLenum target, GLint internalFormat,
3645                              GLsizei width,
3646                              GLenum format, GLenum type,
3647                              GLint userLevel, GLint baseLevel, GLint maxLevel,
3648                              const void *data)
3649 {
3650    int levels;
3651
3652    int rc= checkMipmapArgs(internalFormat,format,type);
3653    if (rc != 0) return rc;
3654
3655    if (width < 1) {
3656        return GLU_INVALID_VALUE;
3657    }
3658
3659    levels = computeLog(width);
3660
3661    levels+= userLevel;
3662    if (!isLegalLevels(userLevel,baseLevel,maxLevel,levels))
3663       return GLU_INVALID_VALUE;
3664
3665    return gluBuild1DMipmapLevelsCore(target, internalFormat,
3666                                      width,
3667                                      width,format, type,
3668                                      userLevel, baseLevel, maxLevel,
3669                                      data);
3670 } /* gluBuild1DMipmapLevels() */
3671
3672 GLint GLAPIENTRY
3673 gluBuild1DMipmaps(GLenum target, GLint internalFormat, GLsizei width,
3674                         GLenum format, GLenum type,
3675                         const void *data)
3676 {
3677    GLint widthPowerOf2;
3678    int levels;
3679    GLint dummy;
3680
3681    int rc= checkMipmapArgs(internalFormat,format,type);
3682    if (rc != 0) return rc;
3683
3684    if (width < 1) {
3685        return GLU_INVALID_VALUE;
3686    }
3687
3688    closestFit(target,width,1,internalFormat,format,type,&widthPowerOf2,&dummy);
3689    levels = computeLog(widthPowerOf2);
3690
3691    return gluBuild1DMipmapLevelsCore(target,internalFormat,
3692                                      width,
3693                                      widthPowerOf2,
3694                                      format,type,0,0,levels,data);
3695 }
3696
3697 static int bitmapBuild2DMipmaps(GLenum target, GLint internalFormat,
3698                      GLint width, GLint height, GLenum format,
3699                      GLenum type, const void *data)
3700 {
3701     GLint newwidth, newheight;
3702     GLint level, levels;
3703     GLushort *newImage;
3704     GLint newImage_width;
3705     GLint newImage_height;
3706     GLushort *otherImage;
3707     GLushort *imageTemp;
3708     GLint memreq;
3709     GLint cmpts;
3710     PixelStorageModes psm;
3711
3712     retrieveStoreModes(&psm);
3713
3714 #if 0
3715     glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxsize);
3716     newwidth = nearestPower(width);
3717     if (newwidth > maxsize) newwidth = maxsize;
3718     newheight = nearestPower(height);
3719     if (newheight > maxsize) newheight = maxsize;
3720 #else
3721     closestFit(target,width,height,internalFormat,format,type,
3722                &newwidth,&newheight);
3723 #endif
3724     levels = computeLog(newwidth);
3725     level = computeLog(newheight);
3726     if (level > levels) levels=level;
3727
3728     otherImage = NULL;
3729     newImage = (GLushort *)
3730         malloc(image_size(width, height, format, GL_UNSIGNED_SHORT));
3731     newImage_width = width;
3732     newImage_height = height;
3733     if (newImage == NULL) {
3734         return GLU_OUT_OF_MEMORY;
3735     }
3736
3737     fill_image(&psm,width, height, format, type, is_index(format),
3738           data, newImage);
3739
3740     cmpts = elements_per_group(format,type);
3741     glPixelStorei(GL_UNPACK_ALIGNMENT, 2);
3742     glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
3743     glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
3744     glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
3745     /*
3746     ** If swap_bytes was set, swapping occurred in fill_image.
3747     */
3748     glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE);
3749
3750     for (level = 0; level <= levels; level++) {
3751         if (newImage_width == newwidth && newImage_height == newheight) {            /* Use newImage for this level */
3752             glTexImage2D(target, level, internalFormat, newImage_width,
3753                     newImage_height, 0, format, GL_UNSIGNED_SHORT,
3754                     (void *) newImage);
3755         } else {
3756             if (otherImage == NULL) {
3757                 memreq =
3758                     image_size(newwidth, newheight, format, GL_UNSIGNED_SHORT);
3759                 otherImage = (GLushort *) malloc(memreq);
3760                 if (otherImage == NULL) {
3761                     glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
3762                     glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
3763                     glPixelStorei(GL_UNPACK_SKIP_PIXELS,psm.unpack_skip_pixels);
3764                     glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
3765                     glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
3766                     free(newImage);
3767                     return GLU_OUT_OF_MEMORY;
3768                 }
3769             }
3770             scale_internal(cmpts, newImage_width, newImage_height, newImage,
3771                     newwidth, newheight, otherImage);
3772             /* Swap newImage and otherImage */
3773             imageTemp = otherImage;
3774             otherImage = newImage;
3775             newImage = imageTemp;
3776
3777             newImage_width = newwidth;
3778             newImage_height = newheight;
3779             glTexImage2D(target, level, internalFormat, newImage_width,
3780                     newImage_height, 0, format, GL_UNSIGNED_SHORT,
3781                     (void *) newImage);
3782         }
3783         if (newwidth > 1) newwidth /= 2;
3784         if (newheight > 1) newheight /= 2;
3785     }
3786     glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
3787     glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
3788     glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
3789     glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
3790     glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
3791
3792     free((GLbyte *) newImage);
3793     if (otherImage) {
3794         free((GLbyte *) otherImage);
3795     }
3796     return 0;
3797 }
3798
3799 /* To make swapping images less error prone */
3800 #define __GLU_INIT_SWAP_IMAGE void *tmpImage
3801 #define __GLU_SWAP_IMAGE(a,b) tmpImage = a; a = b; b = tmpImage;
3802
3803 static int gluBuild2DMipmapLevelsCore(GLenum target, GLint internalFormat,
3804                                       GLsizei width, GLsizei height,
3805                                       GLsizei widthPowerOf2,
3806                                       GLsizei heightPowerOf2,
3807                                       GLenum format, GLenum type,
3808                                       GLint userLevel,
3809                                       GLint baseLevel,GLint maxLevel,
3810                                       const void *data)
3811 {
3812     GLint newwidth, newheight;
3813     GLint level, levels;
3814     const void *usersImage; /* passed from user. Don't touch! */
3815     void *srcImage, *dstImage; /* scratch area to build mipmapped images */
3816     __GLU_INIT_SWAP_IMAGE;
3817     GLint memreq;
3818     GLint cmpts;
3819
3820     GLint myswap_bytes, groups_per_line, element_size, group_size;
3821     GLint rowsize, padding;
3822     PixelStorageModes psm;
3823
3824     assert(checkMipmapArgs(internalFormat,format,type) == 0);
3825     assert(width >= 1 && height >= 1);
3826
3827     if(type == GL_BITMAP) {
3828         return bitmapBuild2DMipmaps(target, internalFormat, width, height,
3829                 format, type, data);
3830     }
3831
3832     srcImage = dstImage = NULL;
3833
3834     newwidth= widthPowerOf2;
3835     newheight= heightPowerOf2;
3836     levels = computeLog(newwidth);
3837     level = computeLog(newheight);
3838     if (level > levels) levels=level;
3839
3840     levels+= userLevel;
3841
3842     retrieveStoreModes(&psm);
3843     myswap_bytes = psm.unpack_swap_bytes;
3844     cmpts = elements_per_group(format,type);
3845     if (psm.unpack_row_length > 0) {
3846         groups_per_line = psm.unpack_row_length;
3847     } else {
3848         groups_per_line = width;
3849     }
3850
3851     element_size = bytes_per_element(type);
3852     group_size = element_size * cmpts;
3853     if (element_size == 1) myswap_bytes = 0;
3854
3855     rowsize = groups_per_line * group_size;
3856     padding = (rowsize % psm.unpack_alignment);
3857     if (padding) {
3858         rowsize += psm.unpack_alignment - padding;
3859     }
3860     usersImage = (const GLubyte *) data + psm.unpack_skip_rows * rowsize +
3861         psm.unpack_skip_pixels * group_size;
3862
3863     glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
3864     glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
3865     glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
3866
3867     level = userLevel;
3868
3869     /* already power-of-two square */
3870     if (width == newwidth && height == newheight) {
3871         /* Use usersImage for level userLevel */
3872         if (baseLevel <= level && level <= maxLevel) {
3873         glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
3874         glTexImage2D(target, level, internalFormat, width,
3875                 height, 0, format, type,
3876                 usersImage);
3877         }
3878         glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
3879         if(levels == 0) { /* we're done. clean up and return */
3880           glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
3881           glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
3882           glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
3883           glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
3884           glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
3885           return 0;
3886         }
3887         {
3888            int nextWidth= newwidth/2;
3889            int nextHeight= newheight/2;
3890
3891            /* clamp to 1 */
3892            if (nextWidth < 1) nextWidth= 1;
3893            if (nextHeight < 1) nextHeight= 1;
3894         memreq = image_size(nextWidth, nextHeight, format, type);
3895         }
3896
3897         switch(type) {
3898         case GL_UNSIGNED_BYTE:
3899           dstImage = (GLubyte *)malloc(memreq);
3900           break;
3901         case GL_BYTE:
3902           dstImage = (GLbyte *)malloc(memreq);
3903           break;
3904         case GL_UNSIGNED_SHORT:
3905           dstImage = (GLushort *)malloc(memreq);
3906           break;
3907         case GL_SHORT:
3908           dstImage = (GLshort *)malloc(memreq);
3909           break;
3910         case GL_UNSIGNED_INT:
3911           dstImage = (GLuint *)malloc(memreq);
3912           break;
3913         case GL_INT:
3914           dstImage = (GLint *)malloc(memreq);
3915           break;
3916         case GL_FLOAT:
3917           dstImage = (GLfloat *)malloc(memreq);
3918           break;
3919         case GL_UNSIGNED_BYTE_3_3_2:
3920         case GL_UNSIGNED_BYTE_2_3_3_REV:
3921           dstImage = (GLubyte *)malloc(memreq);
3922           break;
3923         case GL_UNSIGNED_SHORT_5_6_5:
3924         case GL_UNSIGNED_SHORT_5_6_5_REV:
3925         case GL_UNSIGNED_SHORT_4_4_4_4:
3926         case GL_UNSIGNED_SHORT_4_4_4_4_REV:
3927         case GL_UNSIGNED_SHORT_5_5_5_1:
3928         case GL_UNSIGNED_SHORT_1_5_5_5_REV:
3929           dstImage = (GLushort *)malloc(memreq);
3930           break;
3931         case GL_UNSIGNED_INT_8_8_8_8:
3932         case GL_UNSIGNED_INT_8_8_8_8_REV:
3933         case GL_UNSIGNED_INT_10_10_10_2:
3934         case GL_UNSIGNED_INT_2_10_10_10_REV:
3935           dstImage = (GLuint *)malloc(memreq);
3936           break;
3937         default:
3938           return GLU_INVALID_ENUM;
3939         }
3940         if (dstImage == NULL) {
3941           glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
3942           glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
3943           glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
3944           glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
3945           glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
3946           return GLU_OUT_OF_MEMORY;
3947         }
3948         else
3949           switch(type) {
3950           case GL_UNSIGNED_BYTE:
3951             halveImage_ubyte(cmpts, width, height,
3952                              (const GLubyte *)usersImage, (GLubyte *)dstImage,
3953                              element_size, rowsize, group_size);
3954             break;
3955           case GL_BYTE:
3956             halveImage_byte(cmpts, width, height,
3957                             (const GLbyte *)usersImage, (GLbyte *)dstImage,
3958                             element_size, rowsize, group_size);
3959             break;
3960           case GL_UNSIGNED_SHORT:
3961             halveImage_ushort(cmpts, width, height,
3962                               (const GLushort *)usersImage, (GLushort *)dstImage,
3963                               element_size, rowsize, group_size, myswap_bytes);
3964             break;
3965           case GL_SHORT:
3966             halveImage_short(cmpts, width, height,
3967                              (const GLshort *)usersImage, (GLshort *)dstImage,
3968                              element_size, rowsize, group_size, myswap_bytes);
3969             break;
3970           case GL_UNSIGNED_INT:
3971             halveImage_uint(cmpts, width, height,
3972                             (const GLuint *)usersImage, (GLuint *)dstImage,
3973                             element_size, rowsize, group_size, myswap_bytes);
3974             break;
3975           case GL_INT:
3976             halveImage_int(cmpts, width, height,
3977                            (const GLint *)usersImage, (GLint *)dstImage,
3978                            element_size, rowsize, group_size, myswap_bytes);
3979             break;
3980           case GL_FLOAT:
3981             halveImage_float(cmpts, width, height,
3982                              (const GLfloat *)usersImage, (GLfloat *)dstImage,
3983                              element_size, rowsize, group_size, myswap_bytes);
3984             break;
3985           case GL_UNSIGNED_BYTE_3_3_2:
3986             assert(format == GL_RGB);
3987             halveImagePackedPixel(3,extract332,shove332,
3988                                   width,height,usersImage,dstImage,
3989                                   element_size,rowsize,myswap_bytes);
3990             break;
3991           case GL_UNSIGNED_BYTE_2_3_3_REV:
3992             assert(format == GL_RGB);
3993             halveImagePackedPixel(3,extract233rev,shove233rev,
3994                                   width,height,usersImage,dstImage,
3995                                   element_size,rowsize,myswap_bytes);
3996             break;
3997           case GL_UNSIGNED_SHORT_5_6_5:
3998             halveImagePackedPixel(3,extract565,shove565,
3999                                   width,height,usersImage,dstImage,
4000                                   element_size,rowsize,myswap_bytes);
4001             break;
4002           case GL_UNSIGNED_SHORT_5_6_5_REV:
4003             halveImagePackedPixel(3,extract565rev,shove565rev,
4004                                   width,height,usersImage,dstImage,
4005                                   element_size,rowsize,myswap_bytes);
4006             break;
4007           case GL_UNSIGNED_SHORT_4_4_4_4:
4008             halveImagePackedPixel(4,extract4444,shove4444,
4009                                   width,height,usersImage,dstImage,
4010                                   element_size,rowsize,myswap_bytes);
4011             break;
4012           case GL_UNSIGNED_SHORT_4_4_4_4_REV:
4013             halveImagePackedPixel(4,extract4444rev,shove4444rev,
4014                                   width,height,usersImage,dstImage,
4015                                   element_size,rowsize,myswap_bytes);
4016             break;
4017           case GL_UNSIGNED_SHORT_5_5_5_1:
4018             halveImagePackedPixel(4,extract5551,shove5551,
4019                                   width,height,usersImage,dstImage,
4020                                   element_size,rowsize,myswap_bytes);
4021             break;
4022           case GL_UNSIGNED_SHORT_1_5_5_5_REV:
4023             halveImagePackedPixel(4,extract1555rev,shove1555rev,
4024                                   width,height,usersImage,dstImage,
4025                                   element_size,rowsize,myswap_bytes);
4026             break;
4027           case GL_UNSIGNED_INT_8_8_8_8:
4028             halveImagePackedPixel(4,extract8888,shove8888,
4029                                   width,height,usersImage,dstImage,
4030                                   element_size,rowsize,myswap_bytes);
4031             break;
4032           case GL_UNSIGNED_INT_8_8_8_8_REV:
4033             halveImagePackedPixel(4,extract8888rev,shove8888rev,
4034                                   width,height,usersImage,dstImage,
4035                                   element_size,rowsize,myswap_bytes);
4036             break;
4037           case GL_UNSIGNED_INT_10_10_10_2:
4038             halveImagePackedPixel(4,extract1010102,shove1010102,
4039                                   width,height,usersImage,dstImage,
4040                                   element_size,rowsize,myswap_bytes);
4041             break;
4042           case GL_UNSIGNED_INT_2_10_10_10_REV:
4043             halveImagePackedPixel(4,extract2101010rev,shove2101010rev,
4044                                   width,height,usersImage,dstImage,
4045                                   element_size,rowsize,myswap_bytes);
4046             break;
4047           default:
4048             assert(0);
4049             break;
4050           }
4051         newwidth = width/2;
4052         newheight = height/2;
4053         /* clamp to 1 */
4054         if (newwidth < 1) newwidth= 1;
4055         if (newheight < 1) newheight= 1;
4056
4057         myswap_bytes = 0;
4058         rowsize = newwidth * group_size;
4059         memreq = image_size(newwidth, newheight, format, type);
4060         /* Swap srcImage and dstImage */
4061         __GLU_SWAP_IMAGE(srcImage,dstImage);
4062         switch(type) {
4063         case GL_UNSIGNED_BYTE:
4064           dstImage = (GLubyte *)malloc(memreq);
4065           break;
4066         case GL_BYTE:
4067           dstImage = (GLbyte *)malloc(memreq);
4068           break;
4069         case GL_UNSIGNED_SHORT:
4070           dstImage = (GLushort *)malloc(memreq);
4071           break;
4072         case GL_SHORT:
4073           dstImage = (GLshort *)malloc(memreq);
4074           break;
4075         case GL_UNSIGNED_INT:
4076           dstImage = (GLuint *)malloc(memreq);
4077           break;
4078         case GL_INT:
4079           dstImage = (GLint *)malloc(memreq);
4080           break;
4081         case GL_FLOAT:
4082           dstImage = (GLfloat *)malloc(memreq);
4083           break;
4084         case GL_UNSIGNED_BYTE_3_3_2:
4085         case GL_UNSIGNED_BYTE_2_3_3_REV:
4086           dstImage = (GLubyte *)malloc(memreq);
4087           break;
4088         case GL_UNSIGNED_SHORT_5_6_5:
4089         case GL_UNSIGNED_SHORT_5_6_5_REV:
4090         case GL_UNSIGNED_SHORT_4_4_4_4:
4091         case GL_UNSIGNED_SHORT_4_4_4_4_REV:
4092         case GL_UNSIGNED_SHORT_5_5_5_1:
4093         case GL_UNSIGNED_SHORT_1_5_5_5_REV:
4094           dstImage = (GLushort *)malloc(memreq);
4095           break;
4096         case GL_UNSIGNED_INT_8_8_8_8:
4097         case GL_UNSIGNED_INT_8_8_8_8_REV:
4098         case GL_UNSIGNED_INT_10_10_10_2:
4099         case GL_UNSIGNED_INT_2_10_10_10_REV:
4100           dstImage = (GLuint *)malloc(memreq);
4101           break;
4102         default:
4103           return GLU_INVALID_ENUM;
4104         }
4105         if (dstImage == NULL) {
4106           glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
4107           glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
4108           glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
4109           glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
4110           glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
4111           return GLU_OUT_OF_MEMORY;
4112         }
4113         /* level userLevel+1 is in srcImage; level userLevel already saved */
4114         level = userLevel+1;
4115     } else { /* user's image is *not* nice power-of-2 sized square */
4116         memreq = image_size(newwidth, newheight, format, type);
4117         switch(type) {
4118             case GL_UNSIGNED_BYTE:
4119                 dstImage = (GLubyte *)malloc(memreq);
4120                 break;
4121             case GL_BYTE:
4122                 dstImage = (GLbyte *)malloc(memreq);
4123                 break;
4124             case GL_UNSIGNED_SHORT:
4125                 dstImage = (GLushort *)malloc(memreq);
4126                 break;
4127             case GL_SHORT:
4128                 dstImage = (GLshort *)malloc(memreq);
4129                 break;
4130             case GL_UNSIGNED_INT:
4131                 dstImage = (GLuint *)malloc(memreq);
4132                 break;
4133             case GL_INT:
4134                 dstImage = (GLint *)malloc(memreq);
4135                 break;
4136             case GL_FLOAT:
4137                 dstImage = (GLfloat *)malloc(memreq);
4138                 break;
4139             case GL_UNSIGNED_BYTE_3_3_2:
4140             case GL_UNSIGNED_BYTE_2_3_3_REV:
4141                 dstImage = (GLubyte *)malloc(memreq);
4142                 break;
4143             case GL_UNSIGNED_SHORT_5_6_5:
4144             case GL_UNSIGNED_SHORT_5_6_5_REV:
4145             case GL_UNSIGNED_SHORT_4_4_4_4:
4146             case GL_UNSIGNED_SHORT_4_4_4_4_REV:
4147             case GL_UNSIGNED_SHORT_5_5_5_1:
4148             case GL_UNSIGNED_SHORT_1_5_5_5_REV:
4149                 dstImage = (GLushort *)malloc(memreq);
4150                 break;
4151             case GL_UNSIGNED_INT_8_8_8_8:
4152             case GL_UNSIGNED_INT_8_8_8_8_REV:
4153             case GL_UNSIGNED_INT_10_10_10_2:
4154             case GL_UNSIGNED_INT_2_10_10_10_REV:
4155                 dstImage = (GLuint *)malloc(memreq);
4156                 break;
4157             default:
4158                 return GLU_INVALID_ENUM;
4159         }
4160
4161         if (dstImage == NULL) {
4162             glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
4163             glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
4164             glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
4165             glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
4166             glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
4167             return GLU_OUT_OF_MEMORY;
4168         }
4169
4170         switch(type) {
4171         case GL_UNSIGNED_BYTE:
4172             scale_internal_ubyte(cmpts, width, height,
4173                                  (const GLubyte *)usersImage, newwidth, newheight,
4174                                  (GLubyte *)dstImage, element_size,
4175                                  rowsize, group_size);
4176             break;
4177         case GL_BYTE:
4178             scale_internal_byte(cmpts, width, height,
4179                                 (const GLbyte *)usersImage, newwidth, newheight,
4180                                 (GLbyte *)dstImage, element_size,
4181                                 rowsize, group_size);
4182             break;
4183         case GL_UNSIGNED_SHORT:
4184             scale_internal_ushort(cmpts, width, height,
4185                                   (const GLushort *)usersImage, newwidth, newheight,
4186                                   (GLushort *)dstImage, element_size,
4187                                   rowsize, group_size, myswap_bytes);
4188             break;
4189         case GL_SHORT:
4190             scale_internal_short(cmpts, width, height,
4191                                  (const GLshort *)usersImage, newwidth, newheight,
4192                                  (GLshort *)dstImage, element_size,
4193                                  rowsize, group_size, myswap_bytes);
4194             break;
4195         case GL_UNSIGNED_INT:
4196             scale_internal_uint(cmpts, width, height,
4197                                 (const GLuint *)usersImage, newwidth, newheight,
4198                                 (GLuint *)dstImage, element_size,
4199                                 rowsize, group_size, myswap_bytes);
4200             break;
4201         case GL_INT:
4202             scale_internal_int(cmpts, width, height,
4203                                (const GLint *)usersImage, newwidth, newheight,
4204                                (GLint *)dstImage, element_size,
4205                                rowsize, group_size, myswap_bytes);
4206             break;
4207         case GL_FLOAT:
4208             scale_internal_float(cmpts, width, height,
4209                                  (const GLfloat *)usersImage, newwidth, newheight,
4210                                  (GLfloat *)dstImage, element_size,
4211                                  rowsize, group_size, myswap_bytes);
4212             break;
4213         case GL_UNSIGNED_BYTE_3_3_2:
4214             scaleInternalPackedPixel(3,extract332,shove332,
4215                                      width, height,usersImage,
4216                                      newwidth,newheight,(void *)dstImage,
4217                                      element_size,rowsize,myswap_bytes);
4218             break;
4219         case GL_UNSIGNED_BYTE_2_3_3_REV:
4220             scaleInternalPackedPixel(3,extract233rev,shove233rev,
4221                                      width, height,usersImage,
4222                                      newwidth,newheight,(void *)dstImage,
4223                                      element_size,rowsize,myswap_bytes);
4224             break;
4225         case GL_UNSIGNED_SHORT_5_6_5:
4226             scaleInternalPackedPixel(3,extract565,shove565,
4227                                      width, height,usersImage,
4228                                      newwidth,newheight,(void *)dstImage,
4229                                      element_size,rowsize,myswap_bytes);
4230             break;
4231         case GL_UNSIGNED_SHORT_5_6_5_REV:
4232             scaleInternalPackedPixel(3,extract565rev,shove565rev,
4233                                      width, height,usersImage,
4234                                      newwidth,newheight,(void *)dstImage,
4235                                      element_size,rowsize,myswap_bytes);
4236             break;
4237         case GL_UNSIGNED_SHORT_4_4_4_4:
4238             scaleInternalPackedPixel(4,extract4444,shove4444,
4239                                      width, height,usersImage,
4240                                      newwidth,newheight,(void *)dstImage,
4241                                      element_size,rowsize,myswap_bytes);
4242             break;
4243         case GL_UNSIGNED_SHORT_4_4_4_4_REV:
4244             scaleInternalPackedPixel(4,extract4444rev,shove4444rev,
4245                                      width, height,usersImage,
4246                                      newwidth,newheight,(void *)dstImage,
4247                                      element_size,rowsize,myswap_bytes);
4248             break;
4249         case GL_UNSIGNED_SHORT_5_5_5_1:
4250             scaleInternalPackedPixel(4,extract5551,shove5551,
4251                                      width, height,usersImage,
4252                                      newwidth,newheight,(void *)dstImage,
4253                                      element_size,rowsize,myswap_bytes);
4254             break;
4255         case GL_UNSIGNED_SHORT_1_5_5_5_REV:
4256             scaleInternalPackedPixel(4,extract1555rev,shove1555rev,
4257                                      width, height,usersImage,
4258                                      newwidth,newheight,(void *)dstImage,
4259                                      element_size,rowsize,myswap_bytes);
4260             break;
4261         case GL_UNSIGNED_INT_8_8_8_8:
4262             scaleInternalPackedPixel(4,extract8888,shove8888,
4263                                      width, height,usersImage,
4264                                      newwidth,newheight,(void *)dstImage,
4265                                      element_size,rowsize,myswap_bytes);
4266             break;
4267         case GL_UNSIGNED_INT_8_8_8_8_REV:
4268             scaleInternalPackedPixel(4,extract8888rev,shove8888rev,
4269                                      width, height,usersImage,
4270                                      newwidth,newheight,(void *)dstImage,
4271                                      element_size,rowsize,myswap_bytes);
4272             break;
4273         case GL_UNSIGNED_INT_10_10_10_2:
4274             scaleInternalPackedPixel(4,extract1010102,shove1010102,
4275                                      width, height,usersImage,
4276                                      newwidth,newheight,(void *)dstImage,
4277                                      element_size,rowsize,myswap_bytes);
4278             break;
4279         case GL_UNSIGNED_INT_2_10_10_10_REV:
4280             scaleInternalPackedPixel(4,extract2101010rev,shove2101010rev,
4281                                      width, height,usersImage,
4282                                      newwidth,newheight,(void *)dstImage,
4283                                      element_size,rowsize,myswap_bytes);
4284             break;
4285         default:
4286             assert(0);
4287             break;
4288         }
4289         myswap_bytes = 0;
4290         rowsize = newwidth * group_size;
4291         /* Swap dstImage and srcImage */
4292         __GLU_SWAP_IMAGE(srcImage,dstImage);
4293
4294         if(levels != 0) { /* use as little memory as possible */
4295           {
4296              int nextWidth= newwidth/2;
4297              int nextHeight= newheight/2;
4298              if (nextWidth < 1) nextWidth= 1;
4299              if (nextHeight < 1) nextHeight= 1;
4300
4301           memreq = image_size(nextWidth, nextHeight, format, type);
4302           }
4303
4304           switch(type) {
4305           case GL_UNSIGNED_BYTE:
4306             dstImage = (GLubyte *)malloc(memreq);
4307             break;
4308           case GL_BYTE:
4309             dstImage = (GLbyte *)malloc(memreq);
4310             break;
4311           case GL_UNSIGNED_SHORT:
4312             dstImage = (GLushort *)malloc(memreq);
4313             break;
4314           case GL_SHORT:
4315             dstImage = (GLshort *)malloc(memreq);
4316             break;
4317           case GL_UNSIGNED_INT:
4318             dstImage = (GLuint *)malloc(memreq);
4319             break;
4320           case GL_INT:
4321             dstImage = (GLint *)malloc(memreq);
4322             break;
4323           case GL_FLOAT:
4324             dstImage = (GLfloat *)malloc(memreq);
4325             break;
4326           case GL_UNSIGNED_BYTE_3_3_2:
4327           case GL_UNSIGNED_BYTE_2_3_3_REV:
4328             dstImage = (GLubyte *)malloc(memreq);
4329             break;
4330           case GL_UNSIGNED_SHORT_5_6_5:
4331           case GL_UNSIGNED_SHORT_5_6_5_REV:
4332           case GL_UNSIGNED_SHORT_4_4_4_4:
4333           case GL_UNSIGNED_SHORT_4_4_4_4_REV:
4334           case GL_UNSIGNED_SHORT_5_5_5_1:
4335           case GL_UNSIGNED_SHORT_1_5_5_5_REV:
4336             dstImage = (GLushort *)malloc(memreq);
4337             break;
4338           case GL_UNSIGNED_INT_8_8_8_8:
4339           case GL_UNSIGNED_INT_8_8_8_8_REV:
4340           case GL_UNSIGNED_INT_10_10_10_2:
4341           case GL_UNSIGNED_INT_2_10_10_10_REV:
4342             dstImage = (GLuint *)malloc(memreq);
4343             break;
4344           default:
4345             return GLU_INVALID_ENUM;
4346           }
4347           if (dstImage == NULL) {
4348             glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
4349             glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
4350             glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
4351             glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
4352             glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
4353             free(srcImage);
4354             return GLU_OUT_OF_MEMORY;
4355           }
4356         }
4357         /* level userLevel is in srcImage; nothing saved yet */
4358         level = userLevel;
4359     }
4360
4361     glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE);
4362     if (baseLevel <= level && level <= maxLevel) {
4363     glTexImage2D(target, level, internalFormat, newwidth, newheight, 0,
4364                  format, type, (void *)srcImage);
4365     }
4366
4367     level++; /* update current level for the loop */
4368     for (; level <= levels; level++) {
4369         switch(type) {
4370             case GL_UNSIGNED_BYTE:
4371                 halveImage_ubyte(cmpts, newwidth, newheight,
4372                 (GLubyte *)srcImage, (GLubyte *)dstImage, element_size,
4373                 rowsize, group_size);
4374                 break;
4375             case GL_BYTE:
4376                 halveImage_byte(cmpts, newwidth, newheight,
4377                 (GLbyte *)srcImage, (GLbyte *)dstImage, element_size,
4378                 rowsize, group_size);
4379                 break;
4380             case GL_UNSIGNED_SHORT:
4381                 halveImage_ushort(cmpts, newwidth, newheight,
4382                 (GLushort *)srcImage, (GLushort *)dstImage, element_size,
4383                 rowsize, group_size, myswap_bytes);
4384                 break;
4385             case GL_SHORT:
4386                 halveImage_short(cmpts, newwidth, newheight,
4387                 (GLshort *)srcImage, (GLshort *)dstImage, element_size,
4388                 rowsize, group_size, myswap_bytes);
4389                 break;
4390             case GL_UNSIGNED_INT:
4391                 halveImage_uint(cmpts, newwidth, newheight,
4392                 (GLuint *)srcImage, (GLuint *)dstImage, element_size,
4393                 rowsize, group_size, myswap_bytes);
4394                 break;
4395             case GL_INT:
4396                 halveImage_int(cmpts, newwidth, newheight,
4397                 (GLint *)srcImage, (GLint *)dstImage, element_size,
4398                 rowsize, group_size, myswap_bytes);
4399                 break;
4400             case GL_FLOAT:
4401                 halveImage_float(cmpts, newwidth, newheight,
4402                 (GLfloat *)srcImage, (GLfloat *)dstImage, element_size,
4403                 rowsize, group_size, myswap_bytes);
4404                 break;
4405             case GL_UNSIGNED_BYTE_3_3_2:
4406                 halveImagePackedPixel(3,extract332,shove332,
4407                                       newwidth,newheight,
4408                                       srcImage,dstImage,element_size,rowsize,
4409                                       myswap_bytes);
4410                 break;
4411             case GL_UNSIGNED_BYTE_2_3_3_REV:
4412                 halveImagePackedPixel(3,extract233rev,shove233rev,
4413                                       newwidth,newheight,
4414                                       srcImage,dstImage,element_size,rowsize,
4415                                       myswap_bytes);
4416                 break;
4417             case GL_UNSIGNED_SHORT_5_6_5:
4418                 halveImagePackedPixel(3,extract565,shove565,
4419                                       newwidth,newheight,
4420                                       srcImage,dstImage,element_size,rowsize,
4421                                       myswap_bytes);
4422                 break;
4423             case GL_UNSIGNED_SHORT_5_6_5_REV:
4424                 halveImagePackedPixel(3,extract565rev,shove565rev,
4425                                       newwidth,newheight,
4426                                       srcImage,dstImage,element_size,rowsize,
4427                                       myswap_bytes);
4428                 break;
4429             case GL_UNSIGNED_SHORT_4_4_4_4:
4430                 halveImagePackedPixel(4,extract4444,shove4444,
4431                                       newwidth,newheight,
4432                                       srcImage,dstImage,element_size,rowsize,
4433                                       myswap_bytes);
4434                 break;
4435             case GL_UNSIGNED_SHORT_4_4_4_4_REV:
4436                 halveImagePackedPixel(4,extract4444rev,shove4444rev,
4437                                       newwidth,newheight,
4438                                       srcImage,dstImage,element_size,rowsize,
4439                                       myswap_bytes);
4440                 break;
4441             case GL_UNSIGNED_SHORT_5_5_5_1:
4442                 halveImagePackedPixel(4,extract5551,shove5551,
4443                                       newwidth,newheight,
4444                                       srcImage,dstImage,element_size,rowsize,
4445                                       myswap_bytes);
4446                 break;
4447             case GL_UNSIGNED_SHORT_1_5_5_5_REV:
4448                 halveImagePackedPixel(4,extract1555rev,shove1555rev,
4449                                       newwidth,newheight,
4450                                       srcImage,dstImage,element_size,rowsize,
4451                                       myswap_bytes);
4452                 break;
4453             case GL_UNSIGNED_INT_8_8_8_8:
4454                 halveImagePackedPixel(4,extract8888,shove8888,
4455                                       newwidth,newheight,
4456                                       srcImage,dstImage,element_size,rowsize,
4457                                       myswap_bytes);
4458                 break;
4459             case GL_UNSIGNED_INT_8_8_8_8_REV:
4460                 halveImagePackedPixel(4,extract8888rev,shove8888rev,
4461                                       newwidth,newheight,
4462                                       srcImage,dstImage,element_size,rowsize,
4463                                       myswap_bytes);
4464                 break;
4465             case GL_UNSIGNED_INT_10_10_10_2:
4466                 halveImagePackedPixel(4,extract1010102,shove1010102,
4467                                       newwidth,newheight,
4468                                       srcImage,dstImage,element_size,rowsize,
4469                                       myswap_bytes);
4470                 break;
4471             case GL_UNSIGNED_INT_2_10_10_10_REV:
4472                 halveImagePackedPixel(4,extract2101010rev,shove2101010rev,
4473                                       newwidth,newheight,
4474                                       srcImage,dstImage,element_size,rowsize,
4475                                       myswap_bytes);
4476                 break;
4477             default:
4478                 assert(0);
4479                 break;
4480         }
4481
4482         __GLU_SWAP_IMAGE(srcImage,dstImage);
4483
4484         if (newwidth > 1) { newwidth /= 2; rowsize /= 2;}
4485         if (newheight > 1) newheight /= 2;
4486       {
4487        /* compute amount to pad per row, if any */
4488        int rowPad= rowsize % psm.unpack_alignment;
4489
4490        /* should row be padded? */
4491        if (rowPad == 0) {       /* nope, row should not be padded */
4492            /* call tex image with srcImage untouched since it's not padded */
4493            if (baseLevel <= level && level <= maxLevel) {
4494            glTexImage2D(target, level, internalFormat, newwidth, newheight, 0,
4495            format, type, (void *) srcImage);
4496            }
4497        }
4498        else {                   /* yes, row should be padded */
4499           /* compute length of new row in bytes, including padding */
4500           int newRowLength= rowsize + psm.unpack_alignment - rowPad;
4501           int ii; unsigned char *dstTrav, *srcTrav; /* indices for copying */
4502
4503           /* allocate new image for mipmap of size newRowLength x newheight */
4504           void *newMipmapImage= malloc((size_t) (newRowLength*newheight));
4505           if (newMipmapImage == NULL) {
4506              /* out of memory so return */
4507              glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
4508              glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
4509              glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
4510              glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
4511              glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
4512              return GLU_OUT_OF_MEMORY;
4513           }
4514
4515           /* copy image from srcImage into newMipmapImage by rows */
4516           for (ii= 0,
4517                dstTrav= (unsigned char *) newMipmapImage,
4518                srcTrav= (unsigned char *) srcImage;
4519                ii< newheight;
4520                ii++,
4521                dstTrav+= newRowLength, /* make sure the correct distance... */
4522                srcTrav+= rowsize) {    /* ...is skipped */
4523              memcpy(dstTrav,srcTrav,rowsize);
4524              /* note that the pad bytes are not visited and will contain
4525               * garbage, which is ok.
4526               */
4527           }
4528
4529           /* ...and use this new image for mipmapping instead */
4530           if (baseLevel <= level && level <= maxLevel) {
4531           glTexImage2D(target, level, internalFormat, newwidth, newheight, 0,
4532                        format, type, newMipmapImage);
4533           }
4534           free(newMipmapImage); /* don't forget to free it! */
4535        } /* else */
4536       }
4537     } /* for level */
4538     glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
4539     glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
4540     glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
4541     glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
4542     glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
4543
4544     free(srcImage); /*if you get to here, a srcImage has always been malloc'ed*/
4545     if (dstImage) { /* if it's non-rectangular and only 1 level */
4546       free(dstImage);
4547     }
4548     return 0;
4549 } /* gluBuild2DMipmapLevelsCore() */
4550
4551 GLint GLAPIENTRY
4552 gluBuild2DMipmapLevels(GLenum target, GLint internalFormat,
4553                              GLsizei width, GLsizei height,
4554                              GLenum format, GLenum type,
4555                              GLint userLevel, GLint baseLevel, GLint maxLevel,
4556                              const void *data)
4557 {
4558    int level, levels;
4559
4560    int rc= checkMipmapArgs(internalFormat,format,type);
4561    if (rc != 0) return rc;
4562
4563    if (width < 1 || height < 1) {
4564        return GLU_INVALID_VALUE;
4565    }
4566
4567    levels = computeLog(width);
4568    level = computeLog(height);
4569    if (level > levels) levels=level;
4570
4571    levels+= userLevel;
4572    if (!isLegalLevels(userLevel,baseLevel,maxLevel,levels))
4573       return GLU_INVALID_VALUE;
4574
4575    return gluBuild2DMipmapLevelsCore(target, internalFormat,
4576                                      width, height,
4577                                      width, height,
4578                                      format, type,
4579                                      userLevel, baseLevel, maxLevel,
4580                                      data);
4581 } /* gluBuild2DMipmapLevels() */
4582
4583 GLint GLAPIENTRY
4584 gluBuild2DMipmaps(GLenum target, GLint internalFormat,
4585                         GLsizei width, GLsizei height,
4586                         GLenum format, GLenum type,
4587                         const void *data)
4588 {
4589    GLint widthPowerOf2, heightPowerOf2;
4590    int level, levels;
4591
4592    int rc= checkMipmapArgs(internalFormat,format,type);
4593    if (rc != 0) return rc;
4594
4595    if (width < 1 || height < 1) {
4596        return GLU_INVALID_VALUE;
4597    }
4598
4599    closestFit(target,width,height,internalFormat,format,type,
4600               &widthPowerOf2,&heightPowerOf2);
4601
4602    levels = computeLog(widthPowerOf2);
4603    level = computeLog(heightPowerOf2);
4604    if (level > levels) levels=level;
4605
4606    return gluBuild2DMipmapLevelsCore(target,internalFormat,
4607                                      width, height,
4608                                      widthPowerOf2,heightPowerOf2,
4609                                      format,type,
4610                                      0,0,levels,data);
4611 }  /* gluBuild2DMipmaps() */
4612
4613 #if 0
4614 /*
4615 ** This routine is for the limited case in which
4616 **      type == GL_UNSIGNED_BYTE && format != index  &&
4617 **      unpack_alignment = 1 && unpack_swap_bytes == false
4618 **
4619 ** so all of the work data can be kept as ubytes instead of shorts.
4620 */
4621 static int fastBuild2DMipmaps(const PixelStorageModes *psm,
4622                        GLenum target, GLint components, GLint width,
4623                      GLint height, GLenum format,
4624                      GLenum type, void *data)
4625 {
4626     GLint newwidth, newheight;
4627     GLint level, levels;
4628     GLubyte *newImage;
4629     GLint newImage_width;
4630     GLint newImage_height;
4631     GLubyte *otherImage;
4632     GLubyte *imageTemp;
4633     GLint memreq;
4634     GLint cmpts;
4635
4636
4637 #if 0
4638     glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxsize);
4639     newwidth = nearestPower(width);
4640     if (newwidth > maxsize) newwidth = maxsize;
4641     newheight = nearestPower(height);
4642     if (newheight > maxsize) newheight = maxsize;
4643 #else
4644     closestFit(target,width,height,components,format,type,
4645                &newwidth,&newheight);
4646 #endif
4647     levels = computeLog(newwidth);
4648     level = computeLog(newheight);
4649     if (level > levels) levels=level;
4650
4651     cmpts = elements_per_group(format,type);
4652
4653     otherImage = NULL;
4654     /**
4655     ** No need to copy the user data if its in the packed correctly.
4656     ** Make sure that later routines don't change that data.
4657     */
4658     if (psm->unpack_skip_rows == 0 && psm->unpack_skip_pixels == 0) {
4659         newImage = (GLubyte *)data;
4660         newImage_width = width;
4661         newImage_height = height;
4662     } else {
4663         GLint rowsize;
4664         GLint groups_per_line;
4665         GLint elements_per_line;
4666         const GLubyte *start;
4667         const GLubyte *iter;
4668         GLubyte *iter2;
4669         GLint i, j;
4670
4671         newImage = (GLubyte *)
4672             malloc(image_size(width, height, format, GL_UNSIGNED_BYTE));
4673         newImage_width = width;
4674         newImage_height = height;
4675         if (newImage == NULL) {
4676             return GLU_OUT_OF_MEMORY;
4677         }
4678
4679         /*
4680         ** Abbreviated version of fill_image for this restricted case.
4681         */
4682         if (psm->unpack_row_length > 0) {
4683             groups_per_line = psm->unpack_row_length;
4684         } else {
4685             groups_per_line = width;
4686         }
4687         rowsize = groups_per_line * cmpts;
4688         elements_per_line = width * cmpts;
4689         start = (const GLubyte *) data + psm->unpack_skip_rows * rowsize +
4690                 psm->unpack_skip_pixels * cmpts;
4691         iter2 = newImage;
4692
4693         for (i = 0; i < height; i++) {
4694             iter = start;
4695             for (j = 0; j < elements_per_line; j++) {
4696                 *iter2 = *iter;
4697                 iter++;
4698                 iter2++;
4699             }
4700             start += rowsize;
4701         }
4702     }
4703
4704
4705     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
4706     glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
4707     glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
4708     glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
4709     glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE);
4710
4711     for (level = 0; level <= levels; level++) {
4712         if (newImage_width == newwidth && newImage_height == newheight) {
4713             /* Use newImage for this level */
4714             glTexImage2D(target, level, components, newImage_width,
4715                     newImage_height, 0, format, GL_UNSIGNED_BYTE,
4716                     (void *) newImage);
4717         } else {
4718             if (otherImage == NULL) {
4719                 memreq =
4720                     image_size(newwidth, newheight, format, GL_UNSIGNED_BYTE);
4721                 otherImage = (GLubyte *) malloc(memreq);
4722                 if (otherImage == NULL) {
4723                     glPixelStorei(GL_UNPACK_ALIGNMENT, psm->unpack_alignment);
4724                     glPixelStorei(GL_UNPACK_SKIP_ROWS, psm->unpack_skip_rows);
4725                     glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm->unpack_skip_pixels);
4726                     glPixelStorei(GL_UNPACK_ROW_LENGTH,psm->unpack_row_length);
4727                     glPixelStorei(GL_UNPACK_SWAP_BYTES,psm->unpack_swap_bytes);
4728                     return GLU_OUT_OF_MEMORY;
4729                 }
4730             }
4731 /*
4732             scale_internal_ubyte(cmpts, newImage_width, newImage_height,
4733                     newImage, newwidth, newheight, otherImage);
4734 */
4735             /* Swap newImage and otherImage */
4736             imageTemp = otherImage;
4737             otherImage = newImage;
4738             newImage = imageTemp;
4739
4740             newImage_width = newwidth;
4741             newImage_height = newheight;
4742             glTexImage2D(target, level, components, newImage_width,
4743                     newImage_height, 0, format, GL_UNSIGNED_BYTE,
4744                     (void *) newImage);
4745         }
4746         if (newwidth > 1) newwidth /= 2;
4747         if (newheight > 1) newheight /= 2;
4748     }
4749     glPixelStorei(GL_UNPACK_ALIGNMENT, psm->unpack_alignment);
4750     glPixelStorei(GL_UNPACK_SKIP_ROWS, psm->unpack_skip_rows);
4751     glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm->unpack_skip_pixels);
4752     glPixelStorei(GL_UNPACK_ROW_LENGTH, psm->unpack_row_length);
4753     glPixelStorei(GL_UNPACK_SWAP_BYTES, psm->unpack_swap_bytes);
4754
4755     if (newImage != (const GLubyte *)data) {
4756         free((GLbyte *) newImage);
4757     }
4758     if (otherImage && otherImage != (const GLubyte *)data) {
4759         free((GLbyte *) otherImage);
4760     }
4761     return 0;
4762 }
4763 #endif
4764
4765 /*
4766  * Utility Routines
4767  */
4768 static GLint elements_per_group(GLenum format, GLenum type)
4769 {
4770     /*
4771      * Return the number of elements per group of a specified format
4772      */
4773
4774     /* If the type is packedpixels then answer is 1 (ignore format) */
4775     if (type == GL_UNSIGNED_BYTE_3_3_2 ||
4776         type == GL_UNSIGNED_BYTE_2_3_3_REV ||
4777         type == GL_UNSIGNED_SHORT_5_6_5 ||
4778         type == GL_UNSIGNED_SHORT_5_6_5_REV ||
4779         type == GL_UNSIGNED_SHORT_4_4_4_4 ||
4780         type == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
4781         type == GL_UNSIGNED_SHORT_5_5_5_1  ||
4782         type == GL_UNSIGNED_SHORT_1_5_5_5_REV  ||
4783         type == GL_UNSIGNED_INT_8_8_8_8 ||
4784         type == GL_UNSIGNED_INT_8_8_8_8_REV ||
4785         type == GL_UNSIGNED_INT_10_10_10_2 ||
4786         type == GL_UNSIGNED_INT_2_10_10_10_REV) {
4787         return 1;
4788     }
4789
4790     /* Types are not packed pixels, so get elements per group */
4791     switch(format) {
4792       case GL_RGB:
4793       case GL_BGR:
4794         return 3;
4795       case GL_LUMINANCE_ALPHA:
4796         return 2;
4797       case GL_RGBA:
4798       case GL_BGRA:
4799         return 4;
4800       default:
4801         return 1;
4802     }
4803 }
4804
4805 static GLfloat bytes_per_element(GLenum type)
4806 {
4807     /*
4808      * Return the number of bytes per element, based on the element type
4809      */
4810     switch(type) {
4811       case GL_BITMAP:
4812         return 1.0 / 8.0;
4813       case GL_UNSIGNED_SHORT:
4814         return(sizeof(GLushort));
4815       case GL_SHORT:
4816         return(sizeof(GLshort));
4817       case GL_UNSIGNED_BYTE:
4818         return(sizeof(GLubyte));
4819       case GL_BYTE:
4820         return(sizeof(GLbyte));
4821       case GL_INT:
4822         return(sizeof(GLint));
4823       case GL_UNSIGNED_INT:
4824         return(sizeof(GLuint));
4825       case GL_FLOAT:
4826         return(sizeof(GLfloat));
4827       case GL_UNSIGNED_BYTE_3_3_2:
4828       case GL_UNSIGNED_BYTE_2_3_3_REV:
4829         return(sizeof(GLubyte));
4830       case GL_UNSIGNED_SHORT_5_6_5:
4831       case GL_UNSIGNED_SHORT_5_6_5_REV:
4832       case GL_UNSIGNED_SHORT_4_4_4_4:
4833       case GL_UNSIGNED_SHORT_4_4_4_4_REV:
4834       case GL_UNSIGNED_SHORT_5_5_5_1:
4835       case GL_UNSIGNED_SHORT_1_5_5_5_REV:
4836         return(sizeof(GLushort));
4837       case GL_UNSIGNED_INT_8_8_8_8:
4838       case GL_UNSIGNED_INT_8_8_8_8_REV:
4839       case GL_UNSIGNED_INT_10_10_10_2:
4840       case GL_UNSIGNED_INT_2_10_10_10_REV:
4841         return(sizeof(GLuint));
4842       default:
4843         return 4;
4844     }
4845 }
4846
4847 static GLint is_index(GLenum format)
4848 {
4849     return format == GL_COLOR_INDEX || format == GL_STENCIL_INDEX;
4850 }
4851
4852 /*
4853 ** Compute memory required for internal packed array of data of given type
4854 ** and format.
4855 */
4856 static GLint image_size(GLint width, GLint height, GLenum format, GLenum type)
4857 {
4858     int bytes_per_row;
4859     int components;
4860
4861 assert(width > 0);
4862 assert(height > 0);
4863     components = elements_per_group(format,type);
4864     if (type == GL_BITMAP) {
4865         bytes_per_row = (width + 7) / 8;
4866     } else {
4867         bytes_per_row = bytes_per_element(type) * width;
4868     }
4869     return bytes_per_row * height * components;
4870 }
4871
4872 /*
4873 ** Extract array from user's data applying all pixel store modes.
4874 ** The internal format used is an array of unsigned shorts.
4875 */
4876 static void fill_image(const PixelStorageModes *psm,
4877                        GLint width, GLint height, GLenum format,
4878                        GLenum type, GLboolean index_format,
4879                        const void *userdata, GLushort *newimage)
4880 {
4881     GLint components;
4882     GLint element_size;
4883     GLint rowsize;
4884     GLint padding;
4885     GLint groups_per_line;
4886     GLint group_size;
4887     GLint elements_per_line;
4888     const GLubyte *start;
4889     const GLubyte *iter;
4890     GLushort *iter2;
4891     GLint i, j, k;
4892     GLint myswap_bytes;
4893
4894     myswap_bytes = psm->unpack_swap_bytes;
4895     components = elements_per_group(format,type);
4896     if (psm->unpack_row_length > 0) {
4897         groups_per_line = psm->unpack_row_length;
4898     } else {
4899         groups_per_line = width;
4900     }
4901
4902     /* All formats except GL_BITMAP fall out trivially */
4903     if (type == GL_BITMAP) {
4904         GLint bit_offset;
4905         GLint current_bit;
4906
4907         rowsize = (groups_per_line * components + 7) / 8;
4908         padding = (rowsize % psm->unpack_alignment);
4909         if (padding) {
4910             rowsize += psm->unpack_alignment - padding;
4911         }
4912         start = (const GLubyte *) userdata + psm->unpack_skip_rows * rowsize +
4913                 (psm->unpack_skip_pixels * components / 8);
4914         elements_per_line = width * components;
4915         iter2 = newimage;
4916         for (i = 0; i < height; i++) {
4917             iter = start;
4918             bit_offset = (psm->unpack_skip_pixels * components) % 8;
4919             for (j = 0; j < elements_per_line; j++) {
4920                 /* Retrieve bit */
4921                 if (psm->unpack_lsb_first) {
4922                     current_bit = iter[0] & (1 << bit_offset);
4923                 } else {
4924                     current_bit = iter[0] & (1 << (7 - bit_offset));
4925                 }
4926                 if (current_bit) {
4927                     if (index_format) {
4928                         *iter2 = 1;
4929                     } else {
4930                         *iter2 = 65535;
4931                     }
4932                 } else {
4933                     *iter2 = 0;
4934                 }
4935                 bit_offset++;
4936                 if (bit_offset == 8) {
4937                     bit_offset = 0;
4938                     iter++;
4939                 }
4940                 iter2++;
4941             }
4942             start += rowsize;
4943         }
4944     } else {
4945         element_size = bytes_per_element(type);
4946         group_size = element_size * components;
4947         if (element_size == 1) myswap_bytes = 0;
4948
4949         rowsize = groups_per_line * group_size;
4950         padding = (rowsize % psm->unpack_alignment);
4951         if (padding) {
4952             rowsize += psm->unpack_alignment - padding;
4953         }
4954         start = (const GLubyte *) userdata + psm->unpack_skip_rows * rowsize +
4955                 psm->unpack_skip_pixels * group_size;
4956         elements_per_line = width * components;
4957
4958         iter2 = newimage;
4959         for (i = 0; i < height; i++) {
4960             iter = start;
4961             for (j = 0; j < elements_per_line; j++) {
4962                 Type_Widget widget;
4963                 float extractComponents[4];
4964
4965                 switch(type) {
4966                   case GL_UNSIGNED_BYTE_3_3_2:
4967                     extract332(0,iter,extractComponents);
4968                     for (k = 0; k < 3; k++) {
4969                       *iter2++ = (GLushort)(extractComponents[k]*65535);
4970                     }
4971                     break;
4972                   case GL_UNSIGNED_BYTE_2_3_3_REV:
4973                     extract233rev(0,iter,extractComponents);
4974                     for (k = 0; k < 3; k++) {
4975                       *iter2++ = (GLushort)(extractComponents[k]*65535);
4976                     }
4977                     break;
4978                   case GL_UNSIGNED_BYTE:
4979                     if (index_format) {
4980                         *iter2++ = *iter;
4981                     } else {
4982                         *iter2++ = (*iter) * 257;
4983                     }
4984                     break;
4985                   case GL_BYTE:
4986                     if (index_format) {
4987                         *iter2++ = *((const GLbyte *) iter);
4988                     } else {
4989                         /* rough approx */
4990                         *iter2++ = (*((const GLbyte *) iter)) * 516;
4991                     }
4992                     break;
4993                   case GL_UNSIGNED_SHORT_5_6_5:
4994                     extract565(myswap_bytes,iter,extractComponents);
4995                     for (k = 0; k < 3; k++) {
4996                       *iter2++ = (GLushort)(extractComponents[k]*65535);
4997                     }
4998                     break;
4999                   case GL_UNSIGNED_SHORT_5_6_5_REV:
5000                     extract565rev(myswap_bytes,iter,extractComponents);
5001                     for (k = 0; k < 3; k++) {
5002                       *iter2++ = (GLushort)(extractComponents[k]*65535);
5003                     }
5004                     break;
5005                   case GL_UNSIGNED_SHORT_4_4_4_4:
5006                     extract4444(myswap_bytes,iter,extractComponents);
5007                     for (k = 0; k < 4; k++) {
5008                       *iter2++ = (GLushort)(extractComponents[k]*65535);
5009                     }
5010                     break;
5011                   case GL_UNSIGNED_SHORT_4_4_4_4_REV:
5012                     extract4444rev(myswap_bytes,iter,extractComponents);
5013                     for (k = 0; k < 4; k++) {
5014                       *iter2++ = (GLushort)(extractComponents[k]*65535);
5015                     }
5016                     break;
5017                   case GL_UNSIGNED_SHORT_5_5_5_1:
5018                     extract5551(myswap_bytes,iter,extractComponents);
5019                     for (k = 0; k < 4; k++) {
5020                       *iter2++ = (GLushort)(extractComponents[k]*65535);
5021                     }
5022                     break;
5023                   case GL_UNSIGNED_SHORT_1_5_5_5_REV:
5024                     extract1555rev(myswap_bytes,iter,extractComponents);
5025                     for (k = 0; k < 4; k++) {
5026                       *iter2++ = (GLushort)(extractComponents[k]*65535);
5027                     }
5028                     break;
5029                   case GL_UNSIGNED_SHORT:
5030                   case GL_SHORT:
5031                     if (myswap_bytes) {
5032                         widget.ub[0] = iter[1];
5033                         widget.ub[1] = iter[0];
5034                     } else {
5035                         widget.ub[0] = iter[0];
5036                         widget.ub[1] = iter[1];
5037                     }
5038                     if (type == GL_SHORT) {
5039                         if (index_format) {
5040                             *iter2++ = widget.s[0];
5041                         } else {
5042                             /* rough approx */
5043                             *iter2++ = widget.s[0]*2;
5044                         }
5045                     } else {
5046                         *iter2++ = widget.us[0];
5047                     }
5048                     break;
5049                   case GL_UNSIGNED_INT_8_8_8_8:
5050                     extract8888(myswap_bytes,iter,extractComponents);
5051                     for (k = 0; k < 4; k++) {
5052                       *iter2++ = (GLushort)(extractComponents[k]*65535);
5053                     }
5054                     break;
5055                   case GL_UNSIGNED_INT_8_8_8_8_REV:
5056                     extract8888rev(myswap_bytes,iter,extractComponents);
5057                     for (k = 0; k < 4; k++) {
5058                       *iter2++ = (GLushort)(extractComponents[k]*65535);
5059                     }
5060                     break;
5061                   case GL_UNSIGNED_INT_10_10_10_2:
5062                     extract1010102(myswap_bytes,iter,extractComponents);
5063                     for (k = 0; k < 4; k++) {
5064                       *iter2++ = (GLushort)(extractComponents[k]*65535);
5065                     }
5066                     break;
5067                   case GL_UNSIGNED_INT_2_10_10_10_REV:
5068                     extract2101010rev(myswap_bytes,iter,extractComponents);
5069                     for (k = 0; k < 4; k++) {
5070                       *iter2++ = (GLushort)(extractComponents[k]*65535);
5071                     }
5072                     break;
5073                   case GL_INT:
5074                   case GL_UNSIGNED_INT:
5075                   case GL_FLOAT:
5076                     if (myswap_bytes) {
5077                         widget.ub[0] = iter[3];
5078                         widget.ub[1] = iter[2];
5079                         widget.ub[2] = iter[1];
5080                         widget.ub[3] = iter[0];
5081                     } else {
5082                         widget.ub[0] = iter[0];
5083                         widget.ub[1] = iter[1];
5084                         widget.ub[2] = iter[2];
5085                         widget.ub[3] = iter[3];
5086                     }
5087                     if (type == GL_FLOAT) {
5088                         if (index_format) {
5089                             *iter2++ = widget.f;
5090                         } else {
5091                             *iter2++ = 65535 * widget.f;
5092                         }
5093                     } else if (type == GL_UNSIGNED_INT) {
5094                         if (index_format) {
5095                             *iter2++ = widget.ui;
5096                         } else {
5097                             *iter2++ = widget.ui >> 16;
5098                         }
5099                     } else {
5100                         if (index_format) {
5101                             *iter2++ = widget.i;
5102                         } else {
5103                             *iter2++ = widget.i >> 15;
5104                         }
5105                     }
5106                     break;
5107                 }
5108                 iter += element_size;
5109             } /* for j */
5110             start += rowsize;
5111 #if 1
5112             /* want 'iter' pointing at start, not within, row for assertion
5113              * purposes
5114              */
5115             iter= start;
5116 #endif
5117         } /* for i */
5118
5119        /* iterators should be one byte past end */
5120        if (!isTypePackedPixel(type)) {
5121           assert(iter2 == &newimage[width*height*components]);
5122        }
5123        else {
5124           assert(iter2 == &newimage[width*height*
5125                                     elements_per_group(format,0)]);
5126        }
5127        assert( iter == &((const GLubyte *)userdata)[rowsize*height +
5128                                         psm->unpack_skip_rows * rowsize +
5129                                         psm->unpack_skip_pixels * group_size] );
5130
5131     } /* else */
5132 } /* fill_image() */
5133
5134 /*
5135 ** Insert array into user's data applying all pixel store modes.
5136 ** The internal format is an array of unsigned shorts.
5137 ** empty_image() because it is the opposite of fill_image().
5138 */
5139 static void empty_image(const PixelStorageModes *psm,
5140                         GLint width, GLint height, GLenum format,
5141                         GLenum type, GLboolean index_format,
5142                         const GLushort *oldimage, void *userdata)
5143 {
5144     GLint components;
5145     GLint element_size;
5146     GLint rowsize;
5147     GLint padding;
5148     GLint groups_per_line;
5149     GLint group_size;
5150     GLint elements_per_line;
5151     GLubyte *start;
5152     GLubyte *iter;
5153     const GLushort *iter2;
5154     GLint i, j, k;
5155     GLint myswap_bytes;
5156
5157     myswap_bytes = psm->pack_swap_bytes;
5158     components = elements_per_group(format,type);
5159     if (psm->pack_row_length > 0) {
5160         groups_per_line = psm->pack_row_length;
5161     } else {
5162         groups_per_line = width;
5163     }
5164
5165     /* All formats except GL_BITMAP fall out trivially */
5166     if (type == GL_BITMAP) {
5167         GLint bit_offset;
5168         GLint current_bit;
5169
5170         rowsize = (groups_per_line * components + 7) / 8;
5171         padding = (rowsize % psm->pack_alignment);
5172         if (padding) {
5173             rowsize += psm->pack_alignment - padding;
5174         }
5175         start = (GLubyte *) userdata + psm->pack_skip_rows * rowsize +
5176                 (psm->pack_skip_pixels * components / 8);
5177         elements_per_line = width * components;
5178         iter2 = oldimage;
5179         for (i = 0; i < height; i++) {
5180             iter = start;
5181             bit_offset = (psm->pack_skip_pixels * components) % 8;
5182             for (j = 0; j < elements_per_line; j++) {
5183                 if (index_format) {
5184                     current_bit = iter2[0] & 1;
5185                 } else {
5186                     if (iter2[0] > 32767) {
5187                         current_bit = 1;
5188                     } else {
5189                         current_bit = 0;
5190                     }
5191                 }
5192
5193                 if (current_bit) {
5194                     if (psm->pack_lsb_first) {
5195                         *iter |= (1 << bit_offset);
5196                     } else {
5197                         *iter |= (1 << (7 - bit_offset));
5198                     }
5199                 } else {
5200                     if (psm->pack_lsb_first) {
5201                         *iter &= ~(1 << bit_offset);
5202                     } else {
5203                         *iter &= ~(1 << (7 - bit_offset));
5204                     }
5205                 }
5206
5207                 bit_offset++;
5208                 if (bit_offset == 8) {
5209                     bit_offset = 0;
5210                     iter++;
5211                 }
5212                 iter2++;
5213             }
5214             start += rowsize;
5215         }
5216     } else {
5217         float shoveComponents[4];
5218
5219         element_size = bytes_per_element(type);
5220         group_size = element_size * components;
5221         if (element_size == 1) myswap_bytes = 0;
5222
5223         rowsize = groups_per_line * group_size;
5224         padding = (rowsize % psm->pack_alignment);
5225         if (padding) {
5226             rowsize += psm->pack_alignment - padding;
5227         }
5228         start = (GLubyte *) userdata + psm->pack_skip_rows * rowsize +
5229                 psm->pack_skip_pixels * group_size;
5230         elements_per_line = width * components;
5231
5232         iter2 = oldimage;
5233         for (i = 0; i < height; i++) {
5234             iter = start;
5235             for (j = 0; j < elements_per_line; j++) {
5236                 Type_Widget widget;
5237
5238                 switch(type) {
5239                   case GL_UNSIGNED_BYTE_3_3_2:
5240                     for (k = 0; k < 3; k++) {
5241                        shoveComponents[k]= *iter2++ / 65535.0;
5242                     }
5243                     shove332(shoveComponents,0,(void *)iter);
5244                     break;
5245                   case GL_UNSIGNED_BYTE_2_3_3_REV:
5246                     for (k = 0; k < 3; k++) {
5247                        shoveComponents[k]= *iter2++ / 65535.0;
5248                     }
5249                     shove233rev(shoveComponents,0,(void *)iter);
5250                     break;
5251                   case GL_UNSIGNED_BYTE:
5252                     if (index_format) {
5253                         *iter = *iter2++;
5254                     } else {
5255                         *iter = *iter2++ >> 8;
5256                     }
5257                     break;
5258                   case GL_BYTE:
5259                     if (index_format) {
5260                         *((GLbyte *) iter) = *iter2++;
5261                     } else {
5262                         *((GLbyte *) iter) = *iter2++ >> 9;
5263                     }
5264                     break;
5265                   case GL_UNSIGNED_SHORT_5_6_5:
5266                     for (k = 0; k < 3; k++) {
5267                        shoveComponents[k]= *iter2++ / 65535.0;
5268                     }
5269                     shove565(shoveComponents,0,(void *)&widget.us[0]);
5270                     if (myswap_bytes) {
5271                        iter[0] = widget.ub[1];
5272                        iter[1] = widget.ub[0];
5273                     }
5274                     else {
5275                        *(GLushort *)iter = widget.us[0];
5276                     }
5277                     break;
5278                   case GL_UNSIGNED_SHORT_5_6_5_REV:
5279                     for (k = 0; k < 3; k++) {
5280                        shoveComponents[k]= *iter2++ / 65535.0;
5281                     }
5282                     shove565rev(shoveComponents,0,(void *)&widget.us[0]);
5283                     if (myswap_bytes) {
5284                        iter[0] = widget.ub[1];
5285                        iter[1] = widget.ub[0];
5286                     }
5287                     else {
5288                        *(GLushort *)iter = widget.us[0];
5289                     }
5290                     break;
5291                   case GL_UNSIGNED_SHORT_4_4_4_4:
5292                     for (k = 0; k < 4; k++) {
5293                        shoveComponents[k]= *iter2++ / 65535.0;
5294                     }
5295                     shove4444(shoveComponents,0,(void *)&widget.us[0]);
5296                     if (myswap_bytes) {
5297                        iter[0] = widget.ub[1];
5298                        iter[1] = widget.ub[0];
5299                     } else {
5300                        *(GLushort *)iter = widget.us[0];
5301                     }
5302                     break;
5303                   case GL_UNSIGNED_SHORT_4_4_4_4_REV:
5304                     for (k = 0; k < 4; k++) {
5305                        shoveComponents[k]= *iter2++ / 65535.0;
5306                     }
5307                     shove4444rev(shoveComponents,0,(void *)&widget.us[0]);
5308                     if (myswap_bytes) {
5309                        iter[0] = widget.ub[1];
5310                        iter[1] = widget.ub[0];
5311                     } else {
5312                        *(GLushort *)iter = widget.us[0];
5313                     }
5314                     break;
5315                   case GL_UNSIGNED_SHORT_5_5_5_1:
5316                     for (k = 0; k < 4; k++) {
5317                        shoveComponents[k]= *iter2++ / 65535.0;
5318                     }
5319                     shove5551(shoveComponents,0,(void *)&widget.us[0]);
5320                     if (myswap_bytes) {
5321                        iter[0] = widget.ub[1];
5322                        iter[1] = widget.ub[0];
5323                     } else {
5324                        *(GLushort *)iter = widget.us[0];
5325                     }
5326                     break;
5327                   case GL_UNSIGNED_SHORT_1_5_5_5_REV:
5328                     for (k = 0; k < 4; k++) {
5329                        shoveComponents[k]= *iter2++ / 65535.0;
5330                     }
5331                     shove1555rev(shoveComponents,0,(void *)&widget.us[0]);
5332                     if (myswap_bytes) {
5333                        iter[0] = widget.ub[1];
5334                        iter[1] = widget.ub[0];
5335                     } else {
5336                        *(GLushort *)iter = widget.us[0];
5337                     }
5338                     break;
5339                   case GL_UNSIGNED_SHORT:
5340                   case GL_SHORT:
5341                     if (type == GL_SHORT) {
5342                         if (index_format) {
5343                             widget.s[0] = *iter2++;
5344                         } else {
5345                             widget.s[0] = *iter2++ >> 1;
5346                         }
5347                     } else {
5348                         widget.us[0] = *iter2++;
5349                     }
5350                     if (myswap_bytes) {
5351                         iter[0] = widget.ub[1];
5352                         iter[1] = widget.ub[0];
5353                     } else {
5354                         iter[0] = widget.ub[0];
5355                         iter[1] = widget.ub[1];
5356                     }
5357                     break;
5358                   case GL_UNSIGNED_INT_8_8_8_8:
5359                     for (k = 0; k < 4; k++) {
5360                        shoveComponents[k]= *iter2++ / 65535.0;
5361                     }
5362                     shove8888(shoveComponents,0,(void *)&widget.ui);
5363                     if (myswap_bytes) {
5364                         iter[3] = widget.ub[0];
5365                         iter[2] = widget.ub[1];
5366                         iter[1] = widget.ub[2];
5367                         iter[0] = widget.ub[3];
5368                     } else {
5369                         *(GLuint *)iter= widget.ui;
5370                     }
5371
5372                     break;
5373                   case GL_UNSIGNED_INT_8_8_8_8_REV:
5374                     for (k = 0; k < 4; k++) {
5375                        shoveComponents[k]= *iter2++ / 65535.0;
5376                     }
5377                     shove8888rev(shoveComponents,0,(void *)&widget.ui);
5378                     if (myswap_bytes) {
5379                         iter[3] = widget.ub[0];
5380                         iter[2] = widget.ub[1];
5381                         iter[1] = widget.ub[2];
5382                         iter[0] = widget.ub[3];
5383                     } else {
5384                         *(GLuint *)iter= widget.ui;
5385                     }
5386                     break;
5387                   case GL_UNSIGNED_INT_10_10_10_2:
5388                     for (k = 0; k < 4; k++) {
5389                        shoveComponents[k]= *iter2++ / 65535.0;
5390                     }
5391                     shove1010102(shoveComponents,0,(void *)&widget.ui);
5392                     if (myswap_bytes) {
5393                         iter[3] = widget.ub[0];
5394                         iter[2] = widget.ub[1];
5395                         iter[1] = widget.ub[2];
5396                         iter[0] = widget.ub[3];
5397                     } else {
5398                         *(GLuint *)iter= widget.ui;
5399                     }
5400                     break;
5401                   case GL_UNSIGNED_INT_2_10_10_10_REV:
5402                     for (k = 0; k < 4; k++) {
5403                        shoveComponents[k]= *iter2++ / 65535.0;
5404                     }
5405                     shove2101010rev(shoveComponents,0,(void *)&widget.ui);
5406                     if (myswap_bytes) {
5407                         iter[3] = widget.ub[0];
5408                         iter[2] = widget.ub[1];
5409                         iter[1] = widget.ub[2];
5410                         iter[0] = widget.ub[3];
5411                     } else {
5412                         *(GLuint *)iter= widget.ui;
5413                     }
5414                     break;
5415                   case GL_INT:
5416                   case GL_UNSIGNED_INT:
5417                   case GL_FLOAT:
5418                     if (type == GL_FLOAT) {
5419                         if (index_format) {
5420                             widget.f = *iter2++;
5421                         } else {
5422                             widget.f = *iter2++ / (float) 65535.0;
5423                         }
5424                     } else if (type == GL_UNSIGNED_INT) {
5425                         if (index_format) {
5426                             widget.ui = *iter2++;
5427                         } else {
5428                             widget.ui = (unsigned int) *iter2++ * 65537;
5429                         }
5430                     } else {
5431                         if (index_format) {
5432                             widget.i = *iter2++;
5433                         } else {
5434                             widget.i = ((unsigned int) *iter2++ * 65537)/2;
5435                         }
5436                     }
5437                     if (myswap_bytes) {
5438                         iter[3] = widget.ub[0];
5439                         iter[2] = widget.ub[1];
5440                         iter[1] = widget.ub[2];
5441                         iter[0] = widget.ub[3];
5442                     } else {
5443                         iter[0] = widget.ub[0];
5444                         iter[1] = widget.ub[1];
5445                         iter[2] = widget.ub[2];
5446                         iter[3] = widget.ub[3];
5447                     }
5448                     break;
5449                 }
5450                 iter += element_size;
5451             } /* for j */
5452             start += rowsize;
5453 #if 1
5454             /* want 'iter' pointing at start, not within, row for assertion
5455              * purposes
5456              */
5457             iter= start;
5458 #endif
5459         } /* for i */
5460
5461         /* iterators should be one byte past end */
5462         if (!isTypePackedPixel(type)) {
5463            assert(iter2 == &oldimage[width*height*components]);
5464         }
5465         else {
5466            assert(iter2 == &oldimage[width*height*
5467                                      elements_per_group(format,0)]);
5468         }
5469         assert( iter == &((GLubyte *)userdata)[rowsize*height +
5470                                         psm->pack_skip_rows * rowsize +
5471                                         psm->pack_skip_pixels * group_size] );
5472
5473     } /* else */
5474 } /* empty_image() */
5475
5476 /*--------------------------------------------------------------------------
5477  * Decimation of packed pixel types
5478  *--------------------------------------------------------------------------
5479  */
5480 static void extract332(int isSwap,
5481                        const void *packedPixel, GLfloat extractComponents[])
5482 {
5483    GLubyte ubyte= *(const GLubyte *)packedPixel;
5484
5485    isSwap= isSwap;              /* turn off warnings */
5486
5487    /* 11100000 == 0xe0 */
5488    /* 00011100 == 0x1c */
5489    /* 00000011 == 0x03 */
5490
5491    extractComponents[0]=   (float)((ubyte & 0xe0)  >> 5) / 7.0;
5492    extractComponents[1]=   (float)((ubyte & 0x1c)  >> 2) / 7.0; /* 7 = 2^3-1 */
5493    extractComponents[2]=   (float)((ubyte & 0x03)      ) / 3.0; /* 3 = 2^2-1 */
5494 } /* extract332() */
5495
5496 static void shove332(const GLfloat shoveComponents[],
5497                      int index, void *packedPixel)
5498 {
5499    /* 11100000 == 0xe0 */
5500    /* 00011100 == 0x1c */
5501    /* 00000011 == 0x03 */
5502
5503    assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);
5504    assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);
5505    assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);
5506
5507    /* due to limited precision, need to round before shoving */
5508    ((GLubyte *)packedPixel)[index]  =
5509      ((GLubyte)((shoveComponents[0] * 7)+0.5)  << 5) & 0xe0;
5510    ((GLubyte *)packedPixel)[index] |=
5511      ((GLubyte)((shoveComponents[1] * 7)+0.5)  << 2) & 0x1c;
5512    ((GLubyte *)packedPixel)[index]  |=
5513      ((GLubyte)((shoveComponents[2] * 3)+0.5)      ) & 0x03;
5514 } /* shove332() */
5515
5516 static void extract233rev(int isSwap,
5517                           const void *packedPixel, GLfloat extractComponents[])
5518 {
5519    GLubyte ubyte= *(const GLubyte *)packedPixel;
5520
5521    isSwap= isSwap;              /* turn off warnings */
5522
5523    /* 0000,0111 == 0x07 */
5524    /* 0011,1000 == 0x38 */
5525    /* 1100,0000 == 0xC0 */
5526
5527    extractComponents[0]= (float)((ubyte & 0x07)     ) / 7.0;
5528    extractComponents[1]= (float)((ubyte & 0x38) >> 3) / 7.0;
5529    extractComponents[2]= (float)((ubyte & 0xC0) >> 6) / 3.0;
5530 } /* extract233rev() */
5531
5532 static void shove233rev(const GLfloat shoveComponents[],
5533                         int index, void *packedPixel)
5534 {
5535    /* 0000,0111 == 0x07 */
5536    /* 0011,1000 == 0x38 */
5537    /* 1100,0000 == 0xC0 */
5538
5539    assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);
5540    assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);
5541    assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);
5542
5543    /* due to limited precision, need to round before shoving */
5544    ((GLubyte *)packedPixel)[index] =
5545      ((GLubyte)((shoveComponents[0] * 7.0)+0.5)     ) & 0x07;
5546    ((GLubyte *)packedPixel)[index]|=
5547      ((GLubyte)((shoveComponents[1] * 7.0)+0.5) << 3) & 0x38;
5548    ((GLubyte *)packedPixel)[index]|=
5549      ((GLubyte)((shoveComponents[2] * 3.0)+0.5) << 6) & 0xC0;
5550 } /* shove233rev() */
5551
5552 static void extract565(int isSwap,
5553                        const void *packedPixel, GLfloat extractComponents[])
5554 {
5555    GLushort ushort= *(const GLushort *)packedPixel;
5556
5557    if (isSwap) {
5558      ushort= __GLU_SWAP_2_BYTES(packedPixel);
5559    }
5560    else {
5561      ushort= *(const GLushort *)packedPixel;
5562    }
5563
5564    /* 11111000,00000000 == 0xf800 */
5565    /* 00000111,11100000 == 0x07e0 */
5566    /* 00000000,00011111 == 0x001f */
5567
5568    extractComponents[0]=(float)((ushort & 0xf800) >> 11) / 31.0;/* 31 = 2^5-1*/
5569    extractComponents[1]=(float)((ushort & 0x07e0) >>  5) / 63.0;/* 63 = 2^6-1*/
5570    extractComponents[2]=(float)((ushort & 0x001f)      ) / 31.0;
5571 } /* extract565() */
5572
5573 static void shove565(const GLfloat shoveComponents[],
5574                      int index,void *packedPixel)
5575 {
5576    /* 11111000,00000000 == 0xf800 */
5577    /* 00000111,11100000 == 0x07e0 */
5578    /* 00000000,00011111 == 0x001f */
5579
5580    assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);
5581    assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);
5582    assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);
5583
5584    /* due to limited precision, need to round before shoving */
5585    ((GLushort *)packedPixel)[index] =
5586      ((GLushort)((shoveComponents[0] * 31)+0.5) << 11) & 0xf800;
5587    ((GLushort *)packedPixel)[index]|=
5588      ((GLushort)((shoveComponents[1] * 63)+0.5) <<  5) & 0x07e0;
5589    ((GLushort *)packedPixel)[index]|=
5590      ((GLushort)((shoveComponents[2] * 31)+0.5)      ) & 0x001f;
5591 } /* shove565() */
5592
5593 static void extract565rev(int isSwap,
5594                           const void *packedPixel, GLfloat extractComponents[])
5595 {
5596    GLushort ushort= *(const GLushort *)packedPixel;
5597
5598    if (isSwap) {
5599      ushort= __GLU_SWAP_2_BYTES(packedPixel);
5600    }
5601    else {
5602      ushort= *(const GLushort *)packedPixel;
5603    }
5604
5605    /* 00000000,00011111 == 0x001f */
5606    /* 00000111,11100000 == 0x07e0 */
5607    /* 11111000,00000000 == 0xf800 */
5608
5609    extractComponents[0]= (float)((ushort & 0x001F)      ) / 31.0;
5610    extractComponents[1]= (float)((ushort & 0x07E0) >>  5) / 63.0;
5611    extractComponents[2]= (float)((ushort & 0xF800) >> 11) / 31.0;
5612 } /* extract565rev() */
5613
5614 static void shove565rev(const GLfloat shoveComponents[],
5615                         int index,void *packedPixel)
5616 {
5617    /* 00000000,00011111 == 0x001f */
5618    /* 00000111,11100000 == 0x07e0 */
5619    /* 11111000,00000000 == 0xf800 */
5620
5621    assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);
5622    assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);
5623    assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);
5624
5625    /* due to limited precision, need to round before shoving */
5626    ((GLushort *)packedPixel)[index] =
5627      ((GLushort)((shoveComponents[0] * 31.0)+0.5)      ) & 0x001F;
5628    ((GLushort *)packedPixel)[index]|=
5629      ((GLushort)((shoveComponents[1] * 63.0)+0.5) <<  5) & 0x07E0;
5630    ((GLushort *)packedPixel)[index]|=
5631      ((GLushort)((shoveComponents[2] * 31.0)+0.5) << 11) & 0xF800;
5632 } /* shove565rev() */
5633
5634 static void extract4444(int isSwap,const void *packedPixel,
5635                         GLfloat extractComponents[])
5636 {
5637    GLushort ushort;
5638
5639    if (isSwap) {
5640      ushort= __GLU_SWAP_2_BYTES(packedPixel);
5641    }
5642    else {
5643      ushort= *(const GLushort *)packedPixel;
5644    }
5645
5646    /* 11110000,00000000 == 0xf000 */
5647    /* 00001111,00000000 == 0x0f00 */
5648    /* 00000000,11110000 == 0x00f0 */
5649    /* 00000000,00001111 == 0x000f */
5650
5651    extractComponents[0]= (float)((ushort & 0xf000) >> 12) / 15.0;/* 15=2^4-1 */
5652    extractComponents[1]= (float)((ushort & 0x0f00) >>  8) / 15.0;
5653    extractComponents[2]= (float)((ushort & 0x00f0) >>  4) / 15.0;
5654    extractComponents[3]= (float)((ushort & 0x000f)      ) / 15.0;
5655 } /* extract4444() */
5656
5657 static void shove4444(const GLfloat shoveComponents[],
5658                       int index,void *packedPixel)
5659 {
5660    assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);
5661    assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);
5662    assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);
5663    assert(0.0 <= shoveComponents[3] && shoveComponents[3] <= 1.0);
5664
5665    /* due to limited precision, need to round before shoving */
5666    ((GLushort *)packedPixel)[index] =
5667      ((GLushort)((shoveComponents[0] * 15)+0.5) << 12) & 0xf000;
5668    ((GLushort *)packedPixel)[index]|=
5669      ((GLushort)((shoveComponents[1] * 15)+0.5) <<  8) & 0x0f00;
5670    ((GLushort *)packedPixel)[index]|=
5671      ((GLushort)((shoveComponents[2] * 15)+0.5) <<  4) & 0x00f0;
5672    ((GLushort *)packedPixel)[index]|=
5673      ((GLushort)((shoveComponents[3] * 15)+0.5)      ) & 0x000f;
5674 } /* shove4444() */
5675
5676 static void extract4444rev(int isSwap,const void *packedPixel,
5677                            GLfloat extractComponents[])
5678 {
5679    GLushort ushort;
5680
5681    if (isSwap) {
5682      ushort= __GLU_SWAP_2_BYTES(packedPixel);
5683    }
5684    else {
5685      ushort= *(const GLushort *)packedPixel;
5686    }
5687
5688    /* 00000000,00001111 == 0x000f */
5689    /* 00000000,11110000 == 0x00f0 */
5690    /* 00001111,00000000 == 0x0f00 */
5691    /* 11110000,00000000 == 0xf000 */
5692
5693    /* 15 = 2^4-1 */
5694    extractComponents[0]= (float)((ushort & 0x000F)      ) / 15.0;
5695    extractComponents[1]= (float)((ushort & 0x00F0) >>  4) / 15.0;
5696    extractComponents[2]= (float)((ushort & 0x0F00) >>  8) / 15.0;
5697    extractComponents[3]= (float)((ushort & 0xF000) >> 12) / 15.0;
5698 } /* extract4444rev() */
5699
5700 static void shove4444rev(const GLfloat shoveComponents[],
5701                          int index,void *packedPixel)
5702 {
5703    /* 00000000,00001111 == 0x000f */
5704    /* 00000000,11110000 == 0x00f0 */
5705    /* 00001111,00000000 == 0x0f00 */
5706    /* 11110000,00000000 == 0xf000 */
5707
5708    assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);
5709    assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);
5710    assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);
5711    assert(0.0 <= shoveComponents[3] && shoveComponents[3] <= 1.0);
5712
5713    /* due to limited precision, need to round before shoving */
5714    ((GLushort *)packedPixel)[index] =
5715      ((GLushort)((shoveComponents[0] * 15)+0.5)      ) & 0x000F;
5716    ((GLushort *)packedPixel)[index]|=
5717      ((GLushort)((shoveComponents[1] * 15)+0.5) <<  4) & 0x00F0;
5718    ((GLushort *)packedPixel)[index]|=
5719      ((GLushort)((shoveComponents[2] * 15)+0.5) <<  8) & 0x0F00;
5720    ((GLushort *)packedPixel)[index]|=
5721      ((GLushort)((shoveComponents[3] * 15)+0.5) << 12) & 0xF000;
5722 } /* shove4444rev() */
5723
5724 static void extract5551(int isSwap,const void *packedPixel,
5725                         GLfloat extractComponents[])
5726 {
5727    GLushort ushort;
5728
5729    if (isSwap) {
5730      ushort= __GLU_SWAP_2_BYTES(packedPixel);
5731    }
5732    else {
5733      ushort= *(const GLushort *)packedPixel;
5734    }
5735
5736    /* 11111000,00000000 == 0xf800 */
5737    /* 00000111,11000000 == 0x07c0 */
5738    /* 00000000,00111110 == 0x003e */
5739    /* 00000000,00000001 == 0x0001 */
5740
5741    extractComponents[0]=(float)((ushort & 0xf800) >> 11) / 31.0;/* 31 = 2^5-1*/
5742    extractComponents[1]=(float)((ushort & 0x07c0) >>  6) / 31.0;
5743    extractComponents[2]=(float)((ushort & 0x003e) >>  1) / 31.0;
5744    extractComponents[3]=(float)((ushort & 0x0001)      );
5745 } /* extract5551() */
5746
5747 static void shove5551(const GLfloat shoveComponents[],
5748                       int index,void *packedPixel)
5749 {
5750    /* 11111000,00000000 == 0xf800 */
5751    /* 00000111,11000000 == 0x07c0 */
5752    /* 00000000,00111110 == 0x003e */
5753    /* 00000000,00000001 == 0x0001 */
5754
5755    assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);
5756    assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);
5757    assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);
5758    assert(0.0 <= shoveComponents[3] && shoveComponents[3] <= 1.0);
5759
5760    /* due to limited precision, need to round before shoving */
5761    ((GLushort *)packedPixel)[index]  =
5762      ((GLushort)((shoveComponents[0] * 31)+0.5) << 11) & 0xf800;
5763    ((GLushort *)packedPixel)[index]|=
5764      ((GLushort)((shoveComponents[1] * 31)+0.5) <<  6) & 0x07c0;
5765    ((GLushort *)packedPixel)[index]|=
5766      ((GLushort)((shoveComponents[2] * 31)+0.5) <<  1) & 0x003e;
5767    ((GLushort *)packedPixel)[index]|=
5768      ((GLushort)((shoveComponents[3])+0.5)           ) & 0x0001;
5769 } /* shove5551() */
5770
5771 static void extract1555rev(int isSwap,const void *packedPixel,
5772                            GLfloat extractComponents[])
5773 {
5774    GLushort ushort;
5775
5776    if (isSwap) {
5777      ushort= __GLU_SWAP_2_BYTES(packedPixel);
5778    }
5779    else {
5780      ushort= *(const GLushort *)packedPixel;
5781    }
5782
5783    /* 00000000,00011111 == 0x001F */
5784    /* 00000011,11100000 == 0x03E0 */
5785    /* 01111100,00000000 == 0x7C00 */
5786    /* 10000000,00000000 == 0x8000 */
5787
5788    /* 31 = 2^5-1 */
5789    extractComponents[0]= (float)((ushort & 0x001F)      ) / 31.0;
5790    extractComponents[1]= (float)((ushort & 0x03E0) >>  5) / 31.0;
5791    extractComponents[2]= (float)((ushort & 0x7C00) >> 10) / 31.0;
5792    extractComponents[3]= (float)((ushort & 0x8000) >> 15);
5793 } /* extract1555rev() */
5794
5795 static void shove1555rev(const GLfloat shoveComponents[],
5796                          int index,void *packedPixel)
5797 {
5798    /* 00000000,00011111 == 0x001F */
5799    /* 00000011,11100000 == 0x03E0 */
5800    /* 01111100,00000000 == 0x7C00 */
5801    /* 10000000,00000000 == 0x8000 */
5802
5803    assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);
5804    assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);
5805    assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);
5806    assert(0.0 <= shoveComponents[3] && shoveComponents[3] <= 1.0);
5807
5808    /* due to limited precision, need to round before shoving */
5809    ((GLushort *)packedPixel)[index] =
5810      ((GLushort)((shoveComponents[0] * 31)+0.5)      ) & 0x001F;
5811    ((GLushort *)packedPixel)[index]|=
5812      ((GLushort)((shoveComponents[1] * 31)+0.5) <<  5) & 0x03E0;
5813    ((GLushort *)packedPixel)[index]|=
5814      ((GLushort)((shoveComponents[2] * 31)+0.5) << 10) & 0x7C00;
5815    ((GLushort *)packedPixel)[index]|=
5816      ((GLushort)((shoveComponents[3])+0.5)      << 15) & 0x8000;
5817 } /* shove1555rev() */
5818
5819 static void extract8888(int isSwap,
5820                         const void *packedPixel, GLfloat extractComponents[])
5821 {
5822    GLuint uint;
5823
5824    if (isSwap) {
5825      uint= __GLU_SWAP_4_BYTES(packedPixel);
5826    }
5827    else {
5828      uint= *(const GLuint *)packedPixel;
5829    }
5830
5831    /* 11111111,00000000,00000000,00000000 == 0xff000000 */
5832    /* 00000000,11111111,00000000,00000000 == 0x00ff0000 */
5833    /* 00000000,00000000,11111111,00000000 == 0x0000ff00 */
5834    /* 00000000,00000000,00000000,11111111 == 0x000000ff */
5835
5836    /* 255 = 2^8-1 */
5837    extractComponents[0]= (float)((uint & 0xff000000) >> 24) / 255.0;
5838    extractComponents[1]= (float)((uint & 0x00ff0000) >> 16) / 255.0;
5839    extractComponents[2]= (float)((uint & 0x0000ff00) >>  8) / 255.0;
5840    extractComponents[3]= (float)((uint & 0x000000ff)      ) / 255.0;
5841 } /* extract8888() */
5842
5843 static void shove8888(const GLfloat shoveComponents[],
5844                       int index,void *packedPixel)
5845 {
5846    /* 11111111,00000000,00000000,00000000 == 0xff000000 */
5847    /* 00000000,11111111,00000000,00000000 == 0x00ff0000 */
5848    /* 00000000,00000000,11111111,00000000 == 0x0000ff00 */
5849    /* 00000000,00000000,00000000,11111111 == 0x000000ff */
5850
5851    assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);
5852    assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);
5853    assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);
5854    assert(0.0 <= shoveComponents[3] && shoveComponents[3] <= 1.0);
5855
5856    /* due to limited precision, need to round before shoving */
5857    ((GLuint *)packedPixel)[index] =
5858      ((GLuint)((shoveComponents[0] * 255)+0.5) << 24) & 0xff000000;
5859    ((GLuint *)packedPixel)[index]|=
5860      ((GLuint)((shoveComponents[1] * 255)+0.5) << 16) & 0x00ff0000;
5861    ((GLuint *)packedPixel)[index]|=
5862      ((GLuint)((shoveComponents[2] * 255)+0.5) <<  8) & 0x0000ff00;
5863    ((GLuint *)packedPixel)[index]|=
5864      ((GLuint)((shoveComponents[3] * 255)+0.5)      ) & 0x000000ff;
5865 } /* shove8888() */
5866
5867 static void extract8888rev(int isSwap,
5868                            const void *packedPixel,GLfloat extractComponents[])
5869 {
5870    GLuint uint;
5871
5872    if (isSwap) {
5873      uint= __GLU_SWAP_4_BYTES(packedPixel);
5874    }
5875    else {
5876      uint= *(const GLuint *)packedPixel;
5877    }
5878
5879    /* 00000000,00000000,00000000,11111111 == 0x000000ff */
5880    /* 00000000,00000000,11111111,00000000 == 0x0000ff00 */
5881    /* 00000000,11111111,00000000,00000000 == 0x00ff0000 */
5882    /* 11111111,00000000,00000000,00000000 == 0xff000000 */
5883
5884    /* 255 = 2^8-1 */
5885    extractComponents[0]= (float)((uint & 0x000000FF)      ) / 255.0;
5886    extractComponents[1]= (float)((uint & 0x0000FF00) >>  8) / 255.0;
5887    extractComponents[2]= (float)((uint & 0x00FF0000) >> 16) / 255.0;
5888    extractComponents[3]= (float)((uint & 0xFF000000) >> 24) / 255.0;
5889 } /* extract8888rev() */
5890
5891 static void shove8888rev(const GLfloat shoveComponents[],
5892                          int index,void *packedPixel)
5893 {
5894    /* 00000000,00000000,00000000,11111111 == 0x000000ff */
5895    /* 00000000,00000000,11111111,00000000 == 0x0000ff00 */
5896    /* 00000000,11111111,00000000,00000000 == 0x00ff0000 */
5897    /* 11111111,00000000,00000000,00000000 == 0xff000000 */
5898
5899    assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);
5900    assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);
5901    assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);
5902    assert(0.0 <= shoveComponents[3] && shoveComponents[3] <= 1.0);
5903
5904    /* due to limited precision, need to round before shoving */
5905    ((GLuint *)packedPixel)[index] =
5906      ((GLuint)((shoveComponents[0] * 255)+0.5)      ) & 0x000000FF;
5907    ((GLuint *)packedPixel)[index]|=
5908      ((GLuint)((shoveComponents[1] * 255)+0.5) <<  8) & 0x0000FF00;
5909    ((GLuint *)packedPixel)[index]|=
5910      ((GLuint)((shoveComponents[2] * 255)+0.5) << 16) & 0x00FF0000;
5911    ((GLuint *)packedPixel)[index]|=
5912      ((GLuint)((shoveComponents[3] * 255)+0.5) << 24) & 0xFF000000;
5913 } /* shove8888rev() */
5914
5915 static void extract1010102(int isSwap,
5916                            const void *packedPixel,GLfloat extractComponents[])
5917 {
5918    GLuint uint;
5919
5920    if (isSwap) {
5921      uint= __GLU_SWAP_4_BYTES(packedPixel);
5922    }
5923    else {
5924      uint= *(const GLuint *)packedPixel;
5925    }
5926
5927    /* 11111111,11000000,00000000,00000000 == 0xffc00000 */
5928    /* 00000000,00111111,11110000,00000000 == 0x003ff000 */
5929    /* 00000000,00000000,00001111,11111100 == 0x00000ffc */
5930    /* 00000000,00000000,00000000,00000011 == 0x00000003 */
5931
5932    /* 1023 = 2^10-1 */
5933    extractComponents[0]= (float)((uint & 0xffc00000) >> 22) / 1023.0;
5934    extractComponents[1]= (float)((uint & 0x003ff000) >> 12) / 1023.0;
5935    extractComponents[2]= (float)((uint & 0x00000ffc) >>  2) / 1023.0;
5936    extractComponents[3]= (float)((uint & 0x00000003)      ) / 3.0;
5937 } /* extract1010102() */
5938
5939 static void shove1010102(const GLfloat shoveComponents[],
5940                          int index,void *packedPixel)
5941 {
5942    /* 11111111,11000000,00000000,00000000 == 0xffc00000 */
5943    /* 00000000,00111111,11110000,00000000 == 0x003ff000 */
5944    /* 00000000,00000000,00001111,11111100 == 0x00000ffc */
5945    /* 00000000,00000000,00000000,00000011 == 0x00000003 */
5946
5947    assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);
5948    assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);
5949    assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);
5950    assert(0.0 <= shoveComponents[3] && shoveComponents[3] <= 1.0);
5951
5952    /* due to limited precision, need to round before shoving */
5953    ((GLuint *)packedPixel)[index] =
5954      ((GLuint)((shoveComponents[0] * 1023)+0.5) << 22) & 0xffc00000;
5955    ((GLuint *)packedPixel)[index]|=
5956      ((GLuint)((shoveComponents[1] * 1023)+0.5) << 12) & 0x003ff000;
5957    ((GLuint *)packedPixel)[index]|=
5958      ((GLuint)((shoveComponents[2] * 1023)+0.5) <<  2) & 0x00000ffc;
5959    ((GLuint *)packedPixel)[index]|=
5960      ((GLuint)((shoveComponents[3] * 3)+0.5)         ) & 0x00000003;
5961 } /* shove1010102() */
5962
5963 static void extract2101010rev(int isSwap,
5964                               const void *packedPixel,
5965                               GLfloat extractComponents[])
5966 {
5967    GLuint uint;
5968
5969    if (isSwap) {
5970      uint= __GLU_SWAP_4_BYTES(packedPixel);
5971    }
5972    else {
5973      uint= *(const GLuint *)packedPixel;
5974    }
5975
5976    /* 00000000,00000000,00000011,11111111 == 0x000003FF */
5977    /* 00000000,00001111,11111100,00000000 == 0x000FFC00 */
5978    /* 00111111,11110000,00000000,00000000 == 0x3FF00000 */
5979    /* 11000000,00000000,00000000,00000000 == 0xC0000000 */
5980
5981    /* 1023 = 2^10-1 */
5982    extractComponents[0]= (float)((uint & 0x000003FF)      ) / 1023.0;
5983    extractComponents[1]= (float)((uint & 0x000FFC00) >> 10) / 1023.0;
5984    extractComponents[2]= (float)((uint & 0x3FF00000) >> 20) / 1023.0;
5985    extractComponents[3]= (float)((uint & 0xC0000000) >> 30) / 3.0;
5986    /* 3 = 2^2-1 */
5987 } /* extract2101010rev() */
5988
5989 static void shove2101010rev(const GLfloat shoveComponents[],
5990                             int index,void *packedPixel)
5991 {
5992    /* 00000000,00000000,00000011,11111111 == 0x000003FF */
5993    /* 00000000,00001111,11111100,00000000 == 0x000FFC00 */
5994    /* 00111111,11110000,00000000,00000000 == 0x3FF00000 */
5995    /* 11000000,00000000,00000000,00000000 == 0xC0000000 */
5996
5997    assert(0.0 <= shoveComponents[0] && shoveComponents[0] <= 1.0);
5998    assert(0.0 <= shoveComponents[1] && shoveComponents[1] <= 1.0);
5999    assert(0.0 <= shoveComponents[2] && shoveComponents[2] <= 1.0);
6000    assert(0.0 <= shoveComponents[3] && shoveComponents[3] <= 1.0);
6001
6002    /* due to limited precision, need to round before shoving */
6003    ((GLuint *)packedPixel)[index] =
6004      ((GLuint)((shoveComponents[0] * 1023)+0.5)      ) & 0x000003FF;
6005    ((GLuint *)packedPixel)[index]|=
6006      ((GLuint)((shoveComponents[1] * 1023)+0.5) << 10) & 0x000FFC00;
6007    ((GLuint *)packedPixel)[index]|=
6008      ((GLuint)((shoveComponents[2] * 1023)+0.5) << 20) & 0x3FF00000;
6009    ((GLuint *)packedPixel)[index]|=
6010      ((GLuint)((shoveComponents[3] * 3)+0.5)    << 30) & 0xC0000000;
6011 } /* shove2101010rev() */
6012
6013 static void scaleInternalPackedPixel(int components,
6014                                      void (*extractPackedPixel)
6015                                      (int, const void *,GLfloat []),
6016                                      void (*shovePackedPixel)
6017                                      (const GLfloat [], int, void *),
6018                                      GLint widthIn,GLint heightIn,
6019                                      const void *dataIn,
6020                                      GLint widthOut,GLint heightOut,
6021                                      void *dataOut,
6022                                      GLint pixelSizeInBytes,
6023                                      GLint rowSizeInBytes,GLint isSwap)
6024 {
6025     float convx;
6026     float convy;
6027     float percent;
6028
6029     /* Max components in a format is 4, so... */
6030     float totals[4];
6031     float extractTotals[4], extractMoreTotals[4], shoveTotals[4];
6032
6033     float area;
6034     int i,j,k,xindex;
6035
6036     const char *temp, *temp0;
6037     int outindex;
6038
6039     int lowx_int, highx_int, lowy_int, highy_int;
6040     float x_percent, y_percent;
6041     float lowx_float, highx_float, lowy_float, highy_float;
6042     float convy_float, convx_float;
6043     int convy_int, convx_int;
6044     int l, m;
6045     const char *left, *right;
6046
6047     if (widthIn == widthOut*2 && heightIn == heightOut*2) {
6048         halveImagePackedPixel(components,extractPackedPixel,shovePackedPixel,
6049                               widthIn, heightIn, dataIn, dataOut,
6050                               pixelSizeInBytes,rowSizeInBytes,isSwap);
6051         return;
6052     }
6053     convy = (float) heightIn/heightOut;
6054     convx = (float) widthIn/widthOut;
6055     convy_int = floor(convy);
6056     convy_float = convy - convy_int;
6057     convx_int = floor(convx);
6058     convx_float = convx - convx_int;
6059
6060     area = convx * convy;
6061
6062     lowy_int = 0;
6063     lowy_float = 0;
6064     highy_int = convy_int;
6065     highy_float = convy_float;
6066
6067     for (i = 0; i < heightOut; i++) {
6068         lowx_int = 0;
6069         lowx_float = 0;
6070         highx_int = convx_int;
6071         highx_float = convx_float;
6072
6073         for (j = 0; j < widthOut; j++) {
6074             /*
6075             ** Ok, now apply box filter to box that goes from (lowx, lowy)
6076             ** to (highx, highy) on input data into this pixel on output
6077             ** data.
6078             */
6079             totals[0] = totals[1] = totals[2] = totals[3] = 0.0;
6080
6081             /* calculate the value for pixels in the 1st row */
6082             xindex = lowx_int*pixelSizeInBytes;
6083             if((highy_int>lowy_int) && (highx_int>lowx_int)) {
6084
6085                 y_percent = 1-lowy_float;
6086                 temp = (const char *)dataIn + xindex + lowy_int * rowSizeInBytes;
6087                 percent = y_percent * (1-lowx_float);
6088 #if 0
6089                 for (k = 0, temp_index = temp; k < components;
6090                      k++, temp_index += element_size) {
6091                     if (myswap_bytes) {
6092                         totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
6093                     } else {
6094                         totals[k] += *(const GLushort*)temp_index * percent;
6095                     }
6096                 }
6097 #else
6098                 (*extractPackedPixel)(isSwap,temp,extractTotals);
6099                 for (k = 0; k < components; k++) {
6100                    totals[k]+= extractTotals[k] * percent;
6101                 }
6102 #endif
6103                 left = temp;
6104                 for(l = lowx_int+1; l < highx_int; l++) {
6105                     temp += pixelSizeInBytes;
6106 #if 0
6107                     for (k = 0, temp_index = temp; k < components;
6108                          k++, temp_index += element_size) {
6109                         if (myswap_bytes) {
6110                             totals[k] +=
6111                                  __GLU_SWAP_2_BYTES(temp_index) * y_percent;
6112                         } else {
6113                             totals[k] += *(const GLushort*)temp_index * y_percent;
6114                         }
6115                     }
6116 #else
6117                     (*extractPackedPixel)(isSwap,temp,extractTotals);
6118                     for (k = 0; k < components; k++) {
6119                        totals[k]+= extractTotals[k] * y_percent;
6120                     }
6121 #endif
6122                 }
6123                 temp += pixelSizeInBytes;
6124                 right = temp;
6125                 percent = y_percent * highx_float;
6126 #if 0
6127                 for (k = 0, temp_index = temp; k < components;
6128                      k++, temp_index += element_size) {
6129                     if (myswap_bytes) {
6130                         totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
6131                     } else {
6132                         totals[k] += *(const GLushort*)temp_index * percent;
6133                     }
6134                 }
6135 #else
6136                 (*extractPackedPixel)(isSwap,temp,extractTotals);
6137                 for (k = 0; k < components; k++) {
6138                    totals[k]+= extractTotals[k] * percent;
6139                 }
6140 #endif
6141
6142                 /* calculate the value for pixels in the last row */
6143
6144                 y_percent = highy_float;
6145                 percent = y_percent * (1-lowx_float);
6146                 temp = (const char *)dataIn + xindex + highy_int * rowSizeInBytes;
6147 #if 0
6148                 for (k = 0, temp_index = temp; k < components;
6149                      k++, temp_index += element_size) {
6150                     if (myswap_bytes) {
6151                         totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
6152                     } else {
6153                         totals[k] += *(const GLushort*)temp_index * percent;
6154                     }
6155                 }
6156 #else
6157                 (*extractPackedPixel)(isSwap,temp,extractTotals);
6158                 for (k = 0; k < components; k++) {
6159                    totals[k]+= extractTotals[k] * percent;
6160                 }
6161 #endif
6162                 for(l = lowx_int+1; l < highx_int; l++) {
6163                     temp += pixelSizeInBytes;
6164 #if 0
6165                     for (k = 0, temp_index = temp; k < components;
6166                          k++, temp_index += element_size) {
6167                         if (myswap_bytes) {
6168                             totals[k] +=
6169                                  __GLU_SWAP_2_BYTES(temp_index) * y_percent;
6170                         } else {
6171                             totals[k] += *(const GLushort*)temp_index * y_percent;
6172                         }
6173                     }
6174 #else
6175                     (*extractPackedPixel)(isSwap,temp,extractTotals);
6176                     for (k = 0; k < components; k++) {
6177                        totals[k]+= extractTotals[k] * y_percent;
6178                     }
6179 #endif
6180
6181                 }
6182                 temp += pixelSizeInBytes;
6183                 percent = y_percent * highx_float;
6184 #if 0
6185                 for (k = 0, temp_index = temp; k < components;
6186                      k++, temp_index += element_size) {
6187                     if (myswap_bytes) {
6188                         totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
6189                     } else {
6190                         totals[k] += *(const GLushort*)temp_index * percent;
6191                     }
6192                 }
6193 #else
6194                 (*extractPackedPixel)(isSwap,temp,extractTotals);
6195                 for (k = 0; k < components; k++) {
6196                    totals[k]+= extractTotals[k] * percent;
6197                 }
6198 #endif
6199
6200                 /* calculate the value for pixels in the 1st and last column */
6201                 for(m = lowy_int+1; m < highy_int; m++) {
6202                     left += rowSizeInBytes;
6203                     right += rowSizeInBytes;
6204 #if 0
6205                     for (k = 0; k < components;
6206                          k++, left += element_size, right += element_size) {
6207                         if (myswap_bytes) {
6208                             totals[k] +=
6209                                 __GLU_SWAP_2_BYTES(left) * (1-lowx_float) +
6210                                 __GLU_SWAP_2_BYTES(right) * highx_float;
6211                         } else {
6212                             totals[k] += *(const GLushort*)left * (1-lowx_float)
6213                                        + *(const GLushort*)right * highx_float;
6214                         }
6215                     }
6216 #else
6217                     (*extractPackedPixel)(isSwap,left,extractTotals);
6218                     (*extractPackedPixel)(isSwap,right,extractMoreTotals);
6219                     for (k = 0; k < components; k++) {
6220                        totals[k]+= (extractTotals[k]*(1-lowx_float) +
6221                                    extractMoreTotals[k]*highx_float);
6222                     }
6223 #endif
6224                 }
6225             } else if (highy_int > lowy_int) {
6226                 x_percent = highx_float - lowx_float;
6227                 percent = (1-lowy_float)*x_percent;
6228                 temp = (const char *)dataIn + xindex + lowy_int*rowSizeInBytes;
6229 #if 0
6230                 for (k = 0, temp_index = temp; k < components;
6231                      k++, temp_index += element_size) {
6232                     if (myswap_bytes) {
6233                         totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
6234                     } else {
6235                         totals[k] += *(const GLushort*)temp_index * percent;
6236                     }
6237                 }
6238 #else
6239                 (*extractPackedPixel)(isSwap,temp,extractTotals);
6240                 for (k = 0; k < components; k++) {
6241                    totals[k]+= extractTotals[k] * percent;
6242                 }
6243 #endif
6244                 for(m = lowy_int+1; m < highy_int; m++) {
6245                     temp += rowSizeInBytes;
6246 #if 0
6247                     for (k = 0, temp_index = temp; k < components;
6248                          k++, temp_index += element_size) {
6249                         if (myswap_bytes) {
6250                             totals[k] +=
6251                                 __GLU_SWAP_2_BYTES(temp_index) * x_percent;
6252                         } else {
6253                             totals[k] += *(const GLushort*)temp_index * x_percent;
6254                         }
6255                     }
6256 #else
6257                     (*extractPackedPixel)(isSwap,temp,extractTotals);
6258                     for (k = 0; k < components; k++) {
6259                        totals[k]+= extractTotals[k] * x_percent;
6260                     }
6261 #endif
6262                 }
6263                 percent = x_percent * highy_float;
6264                 temp += rowSizeInBytes;
6265 #if 0
6266                 for (k = 0, temp_index = temp; k < components;
6267                      k++, temp_index += element_size) {
6268                     if (myswap_bytes) {
6269                         totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
6270                     } else {
6271                         totals[k] += *(const GLushort*)temp_index * percent;
6272                     }
6273                 }
6274 #else
6275                 (*extractPackedPixel)(isSwap,temp,extractTotals);
6276                 for (k = 0; k < components; k++) {
6277                    totals[k]+= extractTotals[k] * percent;
6278                 }
6279 #endif
6280             } else if (highx_int > lowx_int) {
6281                 y_percent = highy_float - lowy_float;
6282                 percent = (1-lowx_float)*y_percent;
6283                 temp = (const char *)dataIn + xindex + lowy_int*rowSizeInBytes;
6284 #if 0
6285                 for (k = 0, temp_index = temp; k < components;
6286                      k++, temp_index += element_size) {
6287                     if (myswap_bytes) {
6288                         totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
6289                     } else {
6290                         totals[k] += *(const GLushort*)temp_index * percent;
6291                     }
6292                 }
6293 #else
6294                 (*extractPackedPixel)(isSwap,temp,extractTotals);
6295                 for (k = 0; k < components; k++) {
6296                    totals[k]+= extractTotals[k] * percent;
6297                 }
6298 #endif
6299                 for (l = lowx_int+1; l < highx_int; l++) {
6300                     temp += pixelSizeInBytes;
6301 #if 0
6302                     for (k = 0, temp_index = temp; k < components;
6303                          k++, temp_index += element_size) {
6304                         if (myswap_bytes) {
6305                             totals[k] +=
6306                                 __GLU_SWAP_2_BYTES(temp_index) * y_percent;
6307                         } else {
6308                             totals[k] += *(const GLushort*)temp_index * y_percent;
6309                         }
6310                     }
6311 #else
6312                 (*extractPackedPixel)(isSwap,temp,extractTotals);
6313                 for (k = 0; k < components; k++) {
6314                    totals[k]+= extractTotals[k] * y_percent;
6315                 }
6316 #endif
6317                 }
6318                 temp += pixelSizeInBytes;
6319                 percent = y_percent * highx_float;
6320 #if 0
6321                 for (k = 0, temp_index = temp; k < components;
6322                      k++, temp_index += element_size) {
6323                     if (myswap_bytes) {
6324                         totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
6325                     } else {
6326                         totals[k] += *(const GLushort*)temp_index * percent;
6327                     }
6328                 }
6329 #else
6330                 (*extractPackedPixel)(isSwap,temp,extractTotals);
6331                 for (k = 0; k < components; k++) {
6332                    totals[k]+= extractTotals[k] * percent;
6333                 }
6334 #endif
6335             } else {
6336                 percent = (highy_float-lowy_float)*(highx_float-lowx_float);
6337                 temp = (const char *)dataIn + xindex + lowy_int * rowSizeInBytes;
6338 #if 0
6339                 for (k = 0, temp_index = temp; k < components;
6340                      k++, temp_index += element_size) {
6341                     if (myswap_bytes) {
6342                         totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
6343                     } else {
6344                         totals[k] += *(const GLushort*)temp_index * percent;
6345                     }
6346                 }
6347 #else
6348                 (*extractPackedPixel)(isSwap,temp,extractTotals);
6349                 for (k = 0; k < components; k++) {
6350                    totals[k]+= extractTotals[k] * percent;
6351                 }
6352 #endif
6353             }
6354
6355             /* this is for the pixels in the body */
6356             temp0 = (const char *)dataIn + xindex + pixelSizeInBytes + (lowy_int+1)*rowSizeInBytes;
6357             for (m = lowy_int+1; m < highy_int; m++) {
6358                 temp = temp0;
6359                 for(l = lowx_int+1; l < highx_int; l++) {
6360 #if 0
6361                     for (k = 0, temp_index = temp; k < components;
6362                          k++, temp_index += element_size) {
6363                         if (myswap_bytes) {
6364                             totals[k] += __GLU_SWAP_2_BYTES(temp_index);
6365                         } else {
6366                             totals[k] += *(const GLushort*)temp_index;
6367                         }
6368                     }
6369 #else
6370                     (*extractPackedPixel)(isSwap,temp,extractTotals);
6371                     for (k = 0; k < components; k++) {
6372                        totals[k]+= extractTotals[k];
6373                     }
6374 #endif
6375                     temp += pixelSizeInBytes;
6376                 }
6377                 temp0 += rowSizeInBytes;
6378             }
6379
6380             outindex = (j + (i * widthOut)); /* * (components == 1) */
6381 #if 0
6382             for (k = 0; k < components; k++) {
6383                 dataout[outindex + k] = totals[k]/area;
6384                 /*printf("totals[%d] = %f\n", k, totals[k]);*/
6385             }
6386 #else
6387             for (k = 0; k < components; k++) {
6388                 shoveTotals[k]= totals[k]/area;
6389             }
6390             (*shovePackedPixel)(shoveTotals,outindex,(void *)dataOut);
6391 #endif
6392             lowx_int = highx_int;
6393             lowx_float = highx_float;
6394             highx_int += convx_int;
6395             highx_float += convx_float;
6396             if(highx_float > 1) {
6397                 highx_float -= 1.0;
6398                 highx_int++;
6399             }
6400         }
6401         lowy_int = highy_int;
6402         lowy_float = highy_float;
6403         highy_int += convy_int;
6404         highy_float += convy_float;
6405         if(highy_float > 1) {
6406             highy_float -= 1.0;
6407             highy_int++;
6408         }
6409     }
6410
6411     assert(outindex == (widthOut*heightOut - 1));
6412 } /* scaleInternalPackedPixel() */
6413
6414 /* rowSizeInBytes is at least the width (in bytes) due to padding on
6415  *  inputs; not always equal. Output NEVER has row padding.
6416  */
6417 static void halveImagePackedPixel(int components,
6418                                   void (*extractPackedPixel)
6419                                   (int, const void *,GLfloat []),
6420                                   void (*shovePackedPixel)
6421                                   (const GLfloat [],int, void *),
6422                                   GLint width, GLint height,
6423                                   const void *dataIn, void *dataOut,
6424                                   GLint pixelSizeInBytes,
6425                                   GLint rowSizeInBytes, GLint isSwap)
6426 {
6427    /* handle case where there is only 1 column/row */
6428    if (width == 1 || height == 1) {
6429       assert(!(width == 1 && height == 1)); /* can't be 1x1 */
6430       halve1DimagePackedPixel(components,extractPackedPixel,shovePackedPixel,
6431                               width,height,dataIn,dataOut,pixelSizeInBytes,
6432                               rowSizeInBytes,isSwap);
6433       return;
6434    }
6435
6436    {
6437       int ii, jj;
6438
6439       int halfWidth= width / 2;
6440       int halfHeight= height / 2;
6441       const char *src= (const char *) dataIn;
6442       int padBytes= rowSizeInBytes - (width*pixelSizeInBytes);
6443       int outIndex= 0;
6444
6445       for (ii= 0; ii< halfHeight; ii++) {
6446          for (jj= 0; jj< halfWidth; jj++) {
6447 #define BOX4 4
6448             float totals[4];    /* 4 is maximum components */
6449             float extractTotals[BOX4][4]; /* 4 is maximum components */
6450             int cc;
6451
6452             (*extractPackedPixel)(isSwap,src,
6453                                   &extractTotals[0][0]);
6454             (*extractPackedPixel)(isSwap,(src+pixelSizeInBytes),
6455                                   &extractTotals[1][0]);
6456             (*extractPackedPixel)(isSwap,(src+rowSizeInBytes),
6457                                   &extractTotals[2][0]);
6458             (*extractPackedPixel)(isSwap,
6459                                   (src+rowSizeInBytes+pixelSizeInBytes),
6460                                   &extractTotals[3][0]);
6461             for (cc = 0; cc < components; cc++) {
6462                int kk;
6463
6464                /* grab 4 pixels to average */
6465                totals[cc]= 0.0;
6466                /* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED]+
6467                 *              extractTotals[2][RED]+extractTotals[3][RED];
6468                 * totals[RED]/= 4.0;
6469                 */
6470                for (kk = 0; kk < BOX4; kk++) {
6471                   totals[cc]+= extractTotals[kk][cc];
6472                }
6473                totals[cc]/= (float)BOX4;
6474             }
6475             (*shovePackedPixel)(totals,outIndex,dataOut);
6476
6477             outIndex++;
6478             /* skip over to next square of 4 */
6479             src+= pixelSizeInBytes + pixelSizeInBytes;
6480          }
6481          /* skip past pad bytes, if any, to get to next row */
6482          src+= padBytes;
6483
6484          /* src is at beginning of a row here, but it's the second row of
6485           * the square block of 4 pixels that we just worked on so we
6486           * need to go one more row.
6487           * i.e.,
6488           *                   OO...
6489           *           here -->OO...
6490           *       but want -->OO...
6491           *                   OO...
6492           *                   ...
6493           */
6494          src+= rowSizeInBytes;
6495       }
6496
6497       /* both pointers must reach one byte after the end */
6498       assert(src == &((const char *)dataIn)[rowSizeInBytes*height]);
6499       assert(outIndex == halfWidth * halfHeight);
6500    }
6501 } /* halveImagePackedPixel() */
6502
6503 static void halve1DimagePackedPixel(int components,
6504                                     void (*extractPackedPixel)
6505                                     (int, const void *,GLfloat []),
6506                                     void (*shovePackedPixel)
6507                                     (const GLfloat [],int, void *),
6508                                     GLint width, GLint height,
6509                                     const void *dataIn, void *dataOut,
6510                                     GLint pixelSizeInBytes,
6511                                     GLint rowSizeInBytes, GLint isSwap)
6512 {
6513    int halfWidth= width / 2;
6514    int halfHeight= height / 2;
6515    const char *src= (const char *) dataIn;
6516    int jj;
6517
6518    assert(width == 1 || height == 1); /* must be 1D */
6519    assert(width != height);     /* can't be square */
6520
6521    if (height == 1) {   /* 1 row */
6522       int outIndex= 0;
6523
6524       assert(width != 1);       /* widthxheight can't be 1x1 */
6525       halfHeight= 1;
6526
6527       /* one horizontal row with possible pad bytes */
6528
6529       for (jj= 0; jj< halfWidth; jj++) {
6530 #define BOX2 2
6531          float totals[4];       /* 4 is maximum components */
6532          float extractTotals[BOX2][4]; /* 4 is maximum components */
6533          int cc;
6534
6535          /* average two at a time, instead of four */
6536          (*extractPackedPixel)(isSwap,src,
6537                                &extractTotals[0][0]);
6538          (*extractPackedPixel)(isSwap,(src+pixelSizeInBytes),
6539                                &extractTotals[1][0]);
6540          for (cc = 0; cc < components; cc++) {
6541             int kk;
6542
6543             /* grab 2 pixels to average */
6544             totals[cc]= 0.0;
6545             /* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED];
6546              * totals[RED]/= 2.0;
6547              */
6548             for (kk = 0; kk < BOX2; kk++) {
6549                totals[cc]+= extractTotals[kk][cc];
6550             }
6551             totals[cc]/= (float)BOX2;
6552          }
6553          (*shovePackedPixel)(totals,outIndex,dataOut);
6554
6555          outIndex++;
6556          /* skip over to next group of 2 */
6557          src+= pixelSizeInBytes + pixelSizeInBytes;
6558       }
6559
6560       {
6561          int padBytes= rowSizeInBytes - (width*pixelSizeInBytes);
6562          src+= padBytes;        /* for assertion only */
6563       }
6564       assert(src == &((const char *)dataIn)[rowSizeInBytes]);
6565       assert(outIndex == halfWidth * halfHeight);
6566    }
6567    else if (width == 1) { /* 1 column */
6568       int outIndex= 0;
6569
6570       assert(height != 1);      /* widthxheight can't be 1x1 */
6571       halfWidth= 1;
6572       /* one vertical column with possible pad bytes per row */
6573       /* average two at a time */
6574
6575       for (jj= 0; jj< halfHeight; jj++) {
6576 #define BOX2 2
6577          float totals[4];       /* 4 is maximum components */
6578          float extractTotals[BOX2][4]; /* 4 is maximum components */
6579          int cc;
6580
6581          /* average two at a time, instead of four */
6582          (*extractPackedPixel)(isSwap,src,
6583                                &extractTotals[0][0]);
6584          (*extractPackedPixel)(isSwap,(src+rowSizeInBytes),
6585                                &extractTotals[1][0]);
6586          for (cc = 0; cc < components; cc++) {
6587             int kk;
6588
6589             /* grab 2 pixels to average */
6590             totals[cc]= 0.0;
6591             /* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED];
6592              * totals[RED]/= 2.0;
6593              */
6594             for (kk = 0; kk < BOX2; kk++) {
6595                totals[cc]+= extractTotals[kk][cc];
6596             }
6597             totals[cc]/= (float)BOX2;
6598          }
6599          (*shovePackedPixel)(totals,outIndex,dataOut);
6600
6601          outIndex++;
6602          src+= rowSizeInBytes + rowSizeInBytes; /* go to row after next */
6603       }
6604
6605       assert(src == &((const char *)dataIn)[rowSizeInBytes*height]);
6606       assert(outIndex == halfWidth * halfHeight);
6607    }
6608 } /* halve1DimagePackedPixel() */
6609
6610 /*===========================================================================*/
6611
6612 #ifdef RESOLVE_3D_TEXTURE_SUPPORT
6613 /*
6614  * This section ensures that GLU 1.3 will load and run on
6615  * a GL 1.1 implementation. It dynamically resolves the
6616  * call to glTexImage3D() which might not be available.
6617  * Or is it might be supported as an extension.
6618  * Contributed by Gerk Huisma <gerk@five-d.demon.nl>.
6619  */
6620
6621 typedef void (GLAPIENTRY *TexImage3Dproc)( GLenum target, GLint level,
6622                                                  GLenum internalFormat,
6623                                                  GLsizei width, GLsizei height,
6624                                                  GLsizei depth, GLint border,
6625                                                  GLenum format, GLenum type,
6626                                                  const GLvoid *pixels );
6627
6628 static TexImage3Dproc pTexImage3D = 0;
6629
6630 #if !defined(_WIN32) && !defined(__WIN32__)
6631 #  include <dlfcn.h>
6632 #  include <sys/types.h>
6633 #else
6634   WINGDIAPI PROC  WINAPI wglGetProcAddress(LPCSTR);
6635 #endif
6636
6637 static void gluTexImage3D( GLenum target, GLint level,
6638                            GLenum internalFormat,
6639                            GLsizei width, GLsizei height,
6640                            GLsizei depth, GLint border,
6641                            GLenum format, GLenum type,
6642                            const GLvoid *pixels )
6643 {
6644    if (!pTexImage3D) {
6645 #if defined(_WIN32) || defined(__WIN32__)
6646       pTexImage3D = (TexImage3Dproc) wglGetProcAddress("glTexImage3D");
6647       if (!pTexImage3D)
6648          pTexImage3D = (TexImage3Dproc) wglGetProcAddress("glTexImage3DEXT");
6649 #else
6650       void *libHandle = dlopen("libgl.so", RTLD_LAZY);
6651       pTexImage3D = TexImage3Dproc) dlsym(libHandle, "glTexImage3D" );
6652       if (!pTexImage3D)
6653          pTexImage3D = (TexImage3Dproc) dlsym(libHandle,"glTexImage3DEXT");
6654       dlclose(libHandle);
6655 #endif
6656    }
6657
6658    /* Now call glTexImage3D */
6659    if (pTexImage3D)
6660       pTexImage3D(target, level, internalFormat, width, height,
6661                   depth, border, format, type, pixels);
6662 }
6663
6664 #else
6665
6666 /* Only bind to a GL 1.2 implementation: */
6667 #define gluTexImage3D glTexImage3D
6668
6669 #endif
6670
6671 static GLint imageSize3D(GLint width, GLint height, GLint depth,
6672                          GLenum format, GLenum type)
6673 {
6674     int components= elements_per_group(format,type);
6675     int bytes_per_row=  bytes_per_element(type) * width;
6676
6677 assert(width > 0 && height > 0 && depth > 0);
6678 assert(type != GL_BITMAP);
6679
6680     return bytes_per_row * height * depth * components;
6681 } /* imageSize3D() */
6682
6683 static void fillImage3D(const PixelStorageModes *psm,
6684                         GLint width, GLint height, GLint depth, GLenum format,
6685                         GLenum type, GLboolean indexFormat,
6686                         const void *userImage, GLushort *newImage)
6687 {
6688    int myswapBytes;
6689    int components;
6690    int groupsPerLine;
6691    int elementSize;
6692    int groupSize;
6693    int rowSize;
6694    int padding;
6695    int elementsPerLine;
6696    int rowsPerImage;
6697    int imageSize;
6698    const GLubyte *start, *rowStart, *iter;
6699    GLushort *iter2;
6700    int ww, hh, dd, k;
6701
6702    myswapBytes= psm->unpack_swap_bytes;
6703    components= elements_per_group(format,type);
6704    if (psm->unpack_row_length > 0) {
6705       groupsPerLine= psm->unpack_row_length;
6706    }
6707    else {
6708       groupsPerLine= width;
6709    }
6710    elementSize= bytes_per_element(type);
6711    groupSize= elementSize * components;
6712    if (elementSize == 1) myswapBytes= 0;
6713
6714    /* 3dstuff begin */
6715    if (psm->unpack_image_height > 0) {
6716       rowsPerImage= psm->unpack_image_height;
6717    }
6718    else {
6719       rowsPerImage= height;
6720    }
6721    /* 3dstuff end */
6722
6723    rowSize= groupsPerLine * groupSize;
6724    padding= rowSize % psm->unpack_alignment;
6725    if (padding) {
6726       rowSize+= psm->unpack_alignment - padding;
6727    }
6728
6729    imageSize= rowsPerImage * rowSize; /* 3dstuff */
6730
6731    start= (const GLubyte *)userImage + psm->unpack_skip_rows * rowSize +
6732                                  psm->unpack_skip_pixels * groupSize +
6733                                  /*3dstuff*/
6734                                  psm->unpack_skip_images * imageSize;
6735    elementsPerLine = width * components;
6736
6737    iter2= newImage;
6738    for (dd= 0; dd < depth; dd++) {
6739       rowStart= start;
6740
6741       for (hh= 0; hh < height; hh++) {
6742          iter= rowStart;
6743
6744          for (ww= 0; ww < elementsPerLine; ww++) {
6745             Type_Widget widget;
6746             float extractComponents[4];
6747
6748             switch(type) {
6749             case GL_UNSIGNED_BYTE:
6750               if (indexFormat) {
6751                   *iter2++ = *iter;
6752               } else {
6753                   *iter2++ = (*iter) * 257;
6754               }
6755               break;
6756             case GL_BYTE:
6757               if (indexFormat) {
6758                   *iter2++ = *((const GLbyte *) iter);
6759               } else {
6760                   /* rough approx */
6761                   *iter2++ = (*((const GLbyte *) iter)) * 516;
6762               }
6763               break;
6764             case GL_UNSIGNED_BYTE_3_3_2:
6765               extract332(0,iter,extractComponents);
6766               for (k = 0; k < 3; k++) {
6767                 *iter2++ = (GLushort)(extractComponents[k]*65535);
6768               }
6769               break;
6770             case GL_UNSIGNED_BYTE_2_3_3_REV:
6771               extract233rev(0,iter,extractComponents);
6772               for (k = 0; k < 3; k++) {
6773                 *iter2++ = (GLushort)(extractComponents[k]*65535);
6774               }
6775               break;
6776             case GL_UNSIGNED_SHORT_5_6_5:
6777               extract565(myswapBytes,iter,extractComponents);
6778               for (k = 0; k < 3; k++) {
6779                 *iter2++ = (GLushort)(extractComponents[k]*65535);
6780               }
6781               break;
6782             case GL_UNSIGNED_SHORT_5_6_5_REV:
6783               extract565rev(myswapBytes,iter,extractComponents);
6784               for (k = 0; k < 3; k++) {
6785                 *iter2++ = (GLushort)(extractComponents[k]*65535);
6786               }
6787               break;
6788             case GL_UNSIGNED_SHORT_4_4_4_4:
6789               extract4444(myswapBytes,iter,extractComponents);
6790               for (k = 0; k < 4; k++) {
6791                 *iter2++ = (GLushort)(extractComponents[k]*65535);
6792               }
6793               break;
6794             case GL_UNSIGNED_SHORT_4_4_4_4_REV:
6795               extract4444rev(myswapBytes,iter,extractComponents);
6796               for (k = 0; k < 4; k++) {
6797                 *iter2++ = (GLushort)(extractComponents[k]*65535);
6798               }
6799               break;
6800             case GL_UNSIGNED_SHORT_5_5_5_1:
6801               extract5551(myswapBytes,iter,extractComponents);
6802               for (k = 0; k < 4; k++) {
6803                 *iter2++ = (GLushort)(extractComponents[k]*65535);
6804               }
6805               break;
6806             case GL_UNSIGNED_SHORT_1_5_5_5_REV:
6807               extract1555rev(myswapBytes,iter,extractComponents);
6808               for (k = 0; k < 4; k++) {
6809                 *iter2++ = (GLushort)(extractComponents[k]*65535);
6810               }
6811               break;
6812             case GL_UNSIGNED_SHORT:
6813             case GL_SHORT:
6814               if (myswapBytes) {
6815                   widget.ub[0] = iter[1];
6816                   widget.ub[1] = iter[0];
6817               } else {
6818                   widget.ub[0] = iter[0];
6819                   widget.ub[1] = iter[1];
6820               }
6821               if (type == GL_SHORT) {
6822                   if (indexFormat) {
6823                       *iter2++ = widget.s[0];
6824                   } else {
6825                       /* rough approx */
6826                       *iter2++ = widget.s[0]*2;
6827                   }
6828               } else {
6829                   *iter2++ = widget.us[0];
6830               }
6831               break;
6832             case GL_UNSIGNED_INT_8_8_8_8:
6833               extract8888(myswapBytes,iter,extractComponents);
6834               for (k = 0; k < 4; k++) {
6835                 *iter2++ = (GLushort)(extractComponents[k]*65535);
6836               }
6837               break;
6838             case GL_UNSIGNED_INT_8_8_8_8_REV:
6839               extract8888rev(myswapBytes,iter,extractComponents);
6840               for (k = 0; k < 4; k++) {
6841                 *iter2++ = (GLushort)(extractComponents[k]*65535);
6842               }
6843               break;
6844             case GL_UNSIGNED_INT_10_10_10_2:
6845               extract1010102(myswapBytes,iter,extractComponents);
6846               for (k = 0; k < 4; k++) {
6847                 *iter2++ = (GLushort)(extractComponents[k]*65535);
6848               }
6849               break;
6850             case GL_UNSIGNED_INT_2_10_10_10_REV:
6851               extract2101010rev(myswapBytes,iter,extractComponents);
6852               for (k = 0; k < 4; k++) {
6853                 *iter2++ = (GLushort)(extractComponents[k]*65535);
6854               }
6855               break;
6856             case GL_INT:
6857             case GL_UNSIGNED_INT:
6858             case GL_FLOAT:
6859               if (myswapBytes) {
6860                   widget.ub[0] = iter[3];
6861                   widget.ub[1] = iter[2];
6862                   widget.ub[2] = iter[1];
6863                   widget.ub[3] = iter[0];
6864               } else {
6865                   widget.ub[0] = iter[0];
6866                   widget.ub[1] = iter[1];
6867                   widget.ub[2] = iter[2];
6868                   widget.ub[3] = iter[3];
6869               }
6870               if (type == GL_FLOAT) {
6871                   if (indexFormat) {
6872                       *iter2++ = widget.f;
6873                   } else {
6874                       *iter2++ = 65535 * widget.f;
6875                   }
6876               } else if (type == GL_UNSIGNED_INT) {
6877                   if (indexFormat) {
6878                       *iter2++ = widget.ui;
6879                   } else {
6880                       *iter2++ = widget.ui >> 16;
6881                   }
6882               } else {
6883                   if (indexFormat) {
6884                       *iter2++ = widget.i;
6885                   } else {
6886                       *iter2++ = widget.i >> 15;
6887                   }
6888               }
6889               break;
6890             default:
6891               assert(0);
6892             }
6893
6894             iter+= elementSize;
6895          } /* for ww */
6896          rowStart+= rowSize;
6897
6898          iter= rowStart;        /* for assertion purposes */
6899       } /* for hh */
6900
6901       start+= imageSize;
6902    } /* for dd */
6903
6904    /* iterators should be one byte past end */
6905    if (!isTypePackedPixel(type)) {
6906       assert(iter2 == &newImage[width*height*depth*components]);
6907    }
6908    else {
6909       assert(iter2 == &newImage[width*height*depth*
6910                                 elements_per_group(format,0)]);
6911    }
6912    assert( iter == &((const GLubyte *)userImage)[rowSize*height*depth +
6913                                         psm->unpack_skip_rows * rowSize +
6914                                         psm->unpack_skip_pixels * groupSize +
6915                                         /*3dstuff*/
6916                                         psm->unpack_skip_images * imageSize] );
6917 } /* fillImage3D () */
6918
6919 static void scaleInternal3D(GLint components,
6920                             GLint widthIn, GLint heightIn, GLint depthIn,
6921                             const GLushort *dataIn,
6922                             GLint widthOut, GLint heightOut, GLint depthOut,
6923                             GLushort *dataOut)
6924 {
6925     float x, lowx, highx, convx, halfconvx;
6926     float y, lowy, highy, convy, halfconvy;
6927     float z, lowz, highz, convz, halfconvz;
6928     float xpercent,ypercent,zpercent;
6929     float percent;
6930     /* Max components in a format is 4, so... */
6931     float totals[4];
6932     float volume;
6933     int i,j,d,k,zint,yint,xint,xindex,yindex,zindex;
6934     int temp;
6935
6936     convz = (float) depthIn/depthOut;
6937     convy = (float) heightIn/heightOut;
6938     convx = (float) widthIn/widthOut;
6939     halfconvx = convx/2;
6940     halfconvy = convy/2;
6941     halfconvz = convz/2;
6942     for (d = 0; d < depthOut; d++) {
6943        z = convz * (d+0.5);
6944        if (depthIn > depthOut) {
6945            highz = z + halfconvz;
6946            lowz = z - halfconvz;
6947        } else {
6948            highz = z + 0.5;
6949            lowz = z - 0.5;
6950        }
6951        for (i = 0; i < heightOut; i++) {
6952            y = convy * (i+0.5);
6953            if (heightIn > heightOut) {
6954                highy = y + halfconvy;
6955                lowy = y - halfconvy;
6956            } else {
6957                highy = y + 0.5;
6958                lowy = y - 0.5;
6959            }
6960            for (j = 0; j < widthOut; j++) {
6961                x = convx * (j+0.5);
6962                if (widthIn > widthOut) {
6963                    highx = x + halfconvx;
6964                    lowx = x - halfconvx;
6965                } else {
6966                    highx = x + 0.5;
6967                    lowx = x - 0.5;
6968                }
6969
6970                /*
6971                ** Ok, now apply box filter to box that goes from (lowx, lowy,
6972                ** lowz) to (highx, highy, highz) on input data into this pixel
6973                ** on output data.
6974                */
6975                totals[0] = totals[1] = totals[2] = totals[3] = 0.0;
6976                volume = 0.0;
6977
6978                z = lowz;
6979                zint = floor(z);
6980                while (z < highz) {
6981                   zindex = (zint + depthIn) % depthIn;
6982                   if (highz < zint+1) {
6983                       zpercent = highz - z;
6984                   } else {
6985                       zpercent = zint+1 - z;
6986                   }
6987
6988                   y = lowy;
6989                   yint = floor(y);
6990                   while (y < highy) {
6991                       yindex = (yint + heightIn) % heightIn;
6992                       if (highy < yint+1) {
6993                           ypercent = highy - y;
6994                       } else {
6995                           ypercent = yint+1 - y;
6996                       }
6997
6998                       x = lowx;
6999                       xint = floor(x);
7000
7001                       while (x < highx) {
7002                           xindex = (xint + widthIn) % widthIn;
7003                           if (highx < xint+1) {
7004                               xpercent = highx - x;
7005                           } else {
7006                               xpercent = xint+1 - x;
7007                           }
7008
7009                           percent = xpercent * ypercent * zpercent;
7010                           volume += percent;
7011
7012                           temp = (xindex + (yindex*widthIn) +
7013                                   (zindex*widthIn*heightIn)) * components;
7014                           for (k = 0; k < components; k++) {
7015                               assert(0 <= (temp+k) &&
7016                                      (temp+k) <
7017                                      (widthIn*heightIn*depthIn*components));
7018                               totals[k] += dataIn[temp + k] * percent;
7019                           }
7020
7021                           xint++;
7022                           x = xint;
7023                       } /* while x */
7024
7025                       yint++;
7026                       y = yint;
7027                   } /* while y */
7028
7029                   zint++;
7030                   z = zint;
7031                } /* while z */
7032
7033                temp = (j + (i * widthOut) +
7034                        (d*widthOut*heightOut)) * components;
7035                for (k = 0; k < components; k++) {
7036                    /* totals[] should be rounded in the case of enlarging an
7037                     * RGB ramp when the type is 332 or 4444
7038                     */
7039                    assert(0 <= (temp+k) &&
7040                           (temp+k) < (widthOut*heightOut*depthOut*components));
7041                    dataOut[temp + k] = (totals[k]+0.5)/volume;
7042                }
7043            } /* for j */
7044        } /* for i */
7045     } /* for d */
7046 } /* scaleInternal3D() */
7047
7048 static void emptyImage3D(const PixelStorageModes *psm,
7049                          GLint width, GLint height, GLint depth,
7050                          GLenum format, GLenum type, GLboolean indexFormat,
7051                          const GLushort *oldImage, void *userImage)
7052 {
7053    int myswapBytes;
7054    int components;
7055    int groupsPerLine;
7056    int elementSize;
7057    int groupSize;
7058    int rowSize;
7059    int padding;
7060    GLubyte *start, *rowStart, *iter;
7061    int elementsPerLine;
7062    const GLushort *iter2;
7063    int ii, jj, dd, k;
7064    int rowsPerImage;
7065    int imageSize;
7066
7067    myswapBytes= psm->pack_swap_bytes;
7068    components = elements_per_group(format,type);
7069    if (psm->pack_row_length > 0) {
7070       groupsPerLine = psm->pack_row_length;
7071    }
7072    else {
7073       groupsPerLine = width;
7074    }
7075
7076    elementSize= bytes_per_element(type);
7077    groupSize= elementSize * components;
7078    if (elementSize == 1) myswapBytes= 0;
7079
7080    /* 3dstuff begin */
7081    if (psm->pack_image_height > 0) {
7082       rowsPerImage= psm->pack_image_height;
7083    }
7084    else {
7085       rowsPerImage= height;
7086    }
7087
7088    /* 3dstuff end */
7089
7090    rowSize = groupsPerLine * groupSize;
7091    padding = rowSize % psm->pack_alignment;
7092    if (padding) {
7093       rowSize+= psm->pack_alignment - padding;
7094    }
7095
7096    imageSize= rowsPerImage * rowSize; /* 3dstuff */
7097
7098    start = (GLubyte *)userImage + psm->pack_skip_rows * rowSize +
7099                                   psm->pack_skip_pixels * groupSize +
7100                                   /*3dstuff*/
7101                                   psm->pack_skip_images * imageSize;
7102    elementsPerLine= width * components;
7103
7104    iter2 = oldImage;
7105    for (dd= 0; dd < depth; dd++) {
7106       rowStart= start;
7107
7108       for (ii= 0; ii< height; ii++) {
7109          iter = rowStart;
7110
7111          for (jj = 0; jj < elementsPerLine; jj++) {
7112             Type_Widget widget;
7113             float shoveComponents[4];
7114
7115             switch(type){
7116             case GL_UNSIGNED_BYTE:
7117               if (indexFormat) {
7118                   *iter = *iter2++;
7119               } else {
7120                   *iter = *iter2++ >> 8;
7121               }
7122               break;
7123             case GL_BYTE:
7124               if (indexFormat) {
7125                   *((GLbyte *) iter) = *iter2++;
7126               } else {
7127                   *((GLbyte *) iter) = *iter2++ >> 9;
7128               }
7129               break;
7130             case GL_UNSIGNED_BYTE_3_3_2:
7131               for (k = 0; k < 3; k++) {
7132                  shoveComponents[k]= *iter2++ / 65535.0;
7133               }
7134               shove332(shoveComponents,0,(void *)iter);
7135               break;
7136             case GL_UNSIGNED_BYTE_2_3_3_REV:
7137               for (k = 0; k < 3; k++) {
7138                  shoveComponents[k]= *iter2++ / 65535.0;
7139               }
7140               shove233rev(shoveComponents,0,(void *)iter);
7141               break;
7142             case GL_UNSIGNED_SHORT_5_6_5:
7143               for (k = 0; k < 3; k++) {
7144                  shoveComponents[k]= *iter2++ / 65535.0;
7145               }
7146               shove565(shoveComponents,0,(void *)&widget.us[0]);
7147               if (myswapBytes) {
7148                  iter[0] = widget.ub[1];
7149                  iter[1] = widget.ub[0];
7150               }
7151               else {
7152                  *(GLushort *)iter = widget.us[0];
7153               }
7154               break;
7155             case GL_UNSIGNED_SHORT_5_6_5_REV:
7156               for (k = 0; k < 3; k++) {
7157                  shoveComponents[k]= *iter2++ / 65535.0;
7158               }
7159               shove565rev(shoveComponents,0,(void *)&widget.us[0]);
7160               if (myswapBytes) {
7161                  iter[0] = widget.ub[1];
7162                  iter[1] = widget.ub[0];
7163               }
7164               else {
7165                  *(GLushort *)iter = widget.us[0];
7166               }
7167               break;
7168             case GL_UNSIGNED_SHORT_4_4_4_4:
7169               for (k = 0; k < 4; k++) {
7170                  shoveComponents[k]= *iter2++ / 65535.0;
7171               }
7172               shove4444(shoveComponents,0,(void *)&widget.us[0]);
7173               if (myswapBytes) {
7174                  iter[0] = widget.ub[1];
7175                  iter[1] = widget.ub[0];
7176               } else {
7177                  *(GLushort *)iter = widget.us[0];
7178               }
7179               break;
7180             case GL_UNSIGNED_SHORT_4_4_4_4_REV:
7181               for (k = 0; k < 4; k++) {
7182                  shoveComponents[k]= *iter2++ / 65535.0;
7183               }
7184               shove4444rev(shoveComponents,0,(void *)&widget.us[0]);
7185               if (myswapBytes) {
7186                  iter[0] = widget.ub[1];
7187                  iter[1] = widget.ub[0];
7188               } else {
7189                  *(GLushort *)iter = widget.us[0];
7190               }
7191               break;
7192             case GL_UNSIGNED_SHORT_5_5_5_1:
7193               for (k = 0; k < 4; k++) {
7194                  shoveComponents[k]= *iter2++ / 65535.0;
7195               }
7196               shove5551(shoveComponents,0,(void *)&widget.us[0]);
7197               if (myswapBytes) {
7198                  iter[0] = widget.ub[1];
7199                  iter[1] = widget.ub[0];
7200               } else {
7201                  *(GLushort *)iter = widget.us[0];
7202               }
7203               break;
7204             case GL_UNSIGNED_SHORT_1_5_5_5_REV:
7205               for (k = 0; k < 4; k++) {
7206                  shoveComponents[k]= *iter2++ / 65535.0;
7207               }
7208               shove1555rev(shoveComponents,0,(void *)&widget.us[0]);
7209               if (myswapBytes) {
7210                  iter[0] = widget.ub[1];
7211                  iter[1] = widget.ub[0];
7212               } else {
7213                  *(GLushort *)iter = widget.us[0];
7214               }
7215               break;
7216             case GL_UNSIGNED_SHORT:
7217             case GL_SHORT:
7218               if (type == GL_SHORT) {
7219                   if (indexFormat) {
7220                       widget.s[0] = *iter2++;
7221                   } else {
7222                       widget.s[0] = *iter2++ >> 1;
7223                   }
7224               } else {
7225                   widget.us[0] = *iter2++;
7226               }
7227               if (myswapBytes) {
7228                   iter[0] = widget.ub[1];
7229                   iter[1] = widget.ub[0];
7230               } else {
7231                   iter[0] = widget.ub[0];
7232                   iter[1] = widget.ub[1];
7233               }
7234               break;
7235             case GL_UNSIGNED_INT_8_8_8_8:
7236                for (k = 0; k < 4; k++) {
7237                   shoveComponents[k]= *iter2++ / 65535.0;
7238                }
7239                shove8888(shoveComponents,0,(void *)&widget.ui);
7240                if (myswapBytes) {
7241                    iter[3] = widget.ub[0];
7242                    iter[2] = widget.ub[1];
7243                    iter[1] = widget.ub[2];
7244                    iter[0] = widget.ub[3];
7245                } else {
7246                    *(GLuint *)iter= widget.ui;
7247                }
7248                break;
7249             case GL_UNSIGNED_INT_8_8_8_8_REV:
7250                for (k = 0; k < 4; k++) {
7251                   shoveComponents[k]= *iter2++ / 65535.0;
7252                }
7253                shove8888rev(shoveComponents,0,(void *)&widget.ui);
7254                if (myswapBytes) {
7255                    iter[3] = widget.ub[0];
7256                    iter[2] = widget.ub[1];
7257                    iter[1] = widget.ub[2];
7258                    iter[0] = widget.ub[3];
7259                } else {
7260                    *(GLuint *)iter= widget.ui;
7261                }
7262                break;
7263             case GL_UNSIGNED_INT_10_10_10_2:
7264                for (k = 0; k < 4; k++) {
7265                   shoveComponents[k]= *iter2++ / 65535.0;
7266                }
7267                shove1010102(shoveComponents,0,(void *)&widget.ui);
7268                if (myswapBytes) {
7269                    iter[3] = widget.ub[0];
7270                    iter[2] = widget.ub[1];
7271                    iter[1] = widget.ub[2];
7272                    iter[0] = widget.ub[3];
7273                } else {
7274                    *(GLuint *)iter= widget.ui;
7275                }
7276                break;
7277             case GL_UNSIGNED_INT_2_10_10_10_REV:
7278                for (k = 0; k < 4; k++) {
7279                   shoveComponents[k]= *iter2++ / 65535.0;
7280                }
7281                shove2101010rev(shoveComponents,0,(void *)&widget.ui);
7282                if (myswapBytes) {
7283                    iter[3] = widget.ub[0];
7284                    iter[2] = widget.ub[1];
7285                    iter[1] = widget.ub[2];
7286                    iter[0] = widget.ub[3];
7287                } else {
7288                    *(GLuint *)iter= widget.ui;
7289                }
7290                break;
7291             case GL_INT:
7292             case GL_UNSIGNED_INT:
7293             case GL_FLOAT:
7294               if (type == GL_FLOAT) {
7295                   if (indexFormat) {
7296                       widget.f = *iter2++;
7297                   } else {
7298                       widget.f = *iter2++ / (float) 65535.0;
7299                   }
7300               } else if (type == GL_UNSIGNED_INT) {
7301                   if (indexFormat) {
7302                       widget.ui = *iter2++;
7303                   } else {
7304                       widget.ui = (unsigned int) *iter2++ * 65537;
7305                   }
7306               } else {
7307                   if (indexFormat) {
7308                       widget.i = *iter2++;
7309                   } else {
7310                       widget.i = ((unsigned int) *iter2++ * 65537)/2;
7311                   }
7312               }
7313               if (myswapBytes) {
7314                   iter[3] = widget.ub[0];
7315                   iter[2] = widget.ub[1];
7316                   iter[1] = widget.ub[2];
7317                   iter[0] = widget.ub[3];
7318               } else {
7319                   iter[0] = widget.ub[0];
7320                   iter[1] = widget.ub[1];
7321                   iter[2] = widget.ub[2];
7322                   iter[3] = widget.ub[3];
7323               }
7324               break;
7325             default:
7326                assert(0);
7327             }
7328
7329             iter+= elementSize;
7330          }  /* for jj */
7331
7332          rowStart+= rowSize;
7333       } /* for ii */
7334
7335       start+= imageSize;
7336    } /* for dd */
7337
7338    /* iterators should be one byte past end */
7339    if (!isTypePackedPixel(type)) {
7340       assert(iter2 == &oldImage[width*height*depth*components]);
7341    }
7342    else {
7343       assert(iter2 == &oldImage[width*height*depth*
7344                                 elements_per_group(format,0)]);
7345    }
7346    assert( iter == &((GLubyte *)userImage)[rowSize*height*depth +
7347                                         psm->unpack_skip_rows * rowSize +
7348                                         psm->unpack_skip_pixels * groupSize +
7349                                         /*3dstuff*/
7350                                         psm->unpack_skip_images * imageSize] );
7351 } /* emptyImage3D() */
7352
7353 static
7354 int gluScaleImage3D(GLenum format,
7355                     GLint widthIn, GLint heightIn, GLint depthIn,
7356                     GLenum typeIn, const void *dataIn,
7357                     GLint widthOut, GLint heightOut, GLint depthOut,
7358                     GLenum typeOut, void *dataOut)
7359 {
7360    int components;
7361    GLushort *beforeImage, *afterImage;
7362    PixelStorageModes psm;
7363
7364    if (widthIn == 0 || heightIn == 0 || depthIn == 0 ||
7365        widthOut == 0 || heightOut == 0 || depthOut == 0) {
7366       return 0;
7367    }
7368
7369    if (widthIn < 0 || heightIn < 0 || depthIn < 0 ||
7370        widthOut < 0 || heightOut < 0 || depthOut < 0) {
7371       return GLU_INVALID_VALUE;
7372    }
7373
7374    if (!legalFormat(format) || !legalType(typeIn) || !legalType(typeOut) ||
7375        typeIn == GL_BITMAP || typeOut == GL_BITMAP) {
7376       return GLU_INVALID_ENUM;
7377    }
7378    if (!isLegalFormatForPackedPixelType(format, typeIn)) {
7379       return GLU_INVALID_OPERATION;
7380    }
7381    if (!isLegalFormatForPackedPixelType(format, typeOut)) {
7382       return GLU_INVALID_OPERATION;
7383    }
7384
7385    beforeImage = malloc(imageSize3D(widthIn, heightIn, depthIn, format,
7386                                     GL_UNSIGNED_SHORT));
7387    afterImage = malloc(imageSize3D(widthOut, heightOut, depthOut, format,
7388                                    GL_UNSIGNED_SHORT));
7389    if (beforeImage == NULL || afterImage == NULL) {
7390        free(beforeImage);
7391        free(afterImage);
7392        return GLU_OUT_OF_MEMORY;
7393    }
7394    retrieveStoreModes3D(&psm);
7395
7396    fillImage3D(&psm,widthIn,heightIn,depthIn,format,typeIn, is_index(format),
7397                dataIn, beforeImage);
7398    components = elements_per_group(format,0);
7399    scaleInternal3D(components,widthIn,heightIn,depthIn,beforeImage,
7400                    widthOut,heightOut,depthOut,afterImage);
7401    emptyImage3D(&psm,widthOut,heightOut,depthOut,format,typeOut,
7402                 is_index(format),afterImage, dataOut);
7403    free((void *) beforeImage);
7404    free((void *) afterImage);
7405
7406    return 0;
7407 } /* gluScaleImage3D() */
7408
7409
7410 static void closestFit3D(GLenum target, GLint width, GLint height, GLint depth,
7411                          GLint internalFormat, GLenum format, GLenum type,
7412                          GLint *newWidth, GLint *newHeight, GLint *newDepth)
7413 {
7414    GLint widthPowerOf2= nearestPower(width);
7415    GLint heightPowerOf2= nearestPower(height);
7416    GLint depthPowerOf2= nearestPower(depth);
7417    GLint proxyWidth;
7418
7419    do {
7420       /* compute level 1 width & height & depth, clamping each at 1 */
7421       GLint widthAtLevelOne= (widthPowerOf2 > 1) ?
7422                               widthPowerOf2 >> 1 :
7423                               widthPowerOf2;
7424       GLint heightAtLevelOne= (heightPowerOf2 > 1) ?
7425                                heightPowerOf2 >> 1 :
7426                                heightPowerOf2;
7427       GLint depthAtLevelOne= (depthPowerOf2 > 1) ?
7428                               depthPowerOf2 >> 1 :
7429                               depthPowerOf2;
7430       GLenum proxyTarget = GL_PROXY_TEXTURE_3D;
7431       assert(widthAtLevelOne > 0);
7432       assert(heightAtLevelOne > 0);
7433       assert(depthAtLevelOne > 0);
7434
7435       /* does width x height x depth at level 1 & all their mipmaps fit? */
7436       assert(target == GL_TEXTURE_3D || target == GL_PROXY_TEXTURE_3D);
7437       gluTexImage3D(proxyTarget, 1, /* must be non-zero */
7438                     internalFormat,
7439                     widthAtLevelOne,heightAtLevelOne,depthAtLevelOne,
7440                     0,format,type,NULL);
7441       glGetTexLevelParameteriv(proxyTarget, 1,GL_TEXTURE_WIDTH,&proxyWidth);
7442       /* does it fit??? */
7443       if (proxyWidth == 0) { /* nope, so try again with these sizes */
7444          if (widthPowerOf2 == 1 && heightPowerOf2 == 1 &&
7445              depthPowerOf2 == 1) {
7446             *newWidth= *newHeight= *newDepth= 1; /* must fit 1x1x1 texture */
7447             return;
7448          }
7449          widthPowerOf2= widthAtLevelOne;
7450          heightPowerOf2= heightAtLevelOne;
7451          depthPowerOf2= depthAtLevelOne;
7452       }
7453       /* else it does fit */
7454    } while (proxyWidth == 0);
7455    /* loop must terminate! */
7456
7457    /* return the width & height at level 0 that fits */
7458    *newWidth= widthPowerOf2;
7459    *newHeight= heightPowerOf2;
7460    *newDepth= depthPowerOf2;
7461 /*printf("Proxy Textures\n");*/
7462 } /* closestFit3D() */
7463
7464 static void halveImagePackedPixelSlice(int components,
7465                                        void (*extractPackedPixel)
7466                                        (int, const void *,GLfloat []),
7467                                        void (*shovePackedPixel)
7468                                        (const GLfloat [],int, void *),
7469                                        GLint width, GLint height, GLint depth,
7470                                        const void *dataIn, void *dataOut,
7471                                        GLint pixelSizeInBytes,
7472                                        GLint rowSizeInBytes,
7473                                        GLint imageSizeInBytes,
7474                                        GLint isSwap)
7475 {
7476    int ii, jj;
7477    int halfWidth= width / 2;
7478    int halfHeight= height / 2;
7479    int halfDepth= depth / 2;
7480    const char *src= (const char *)dataIn;
7481    int outIndex= 0;
7482
7483    assert((width == 1 || height == 1) && depth >= 2);
7484
7485    if (width == height) {       /* a 1-pixel column viewed from top */
7486       assert(width == 1 && height == 1);
7487       assert(depth >= 2);
7488
7489       for (ii= 0; ii< halfDepth; ii++) {
7490          float totals[4];
7491          float extractTotals[BOX2][4];
7492          int cc;
7493
7494          (*extractPackedPixel)(isSwap,src,&extractTotals[0][0]);
7495          (*extractPackedPixel)(isSwap,(src+imageSizeInBytes),
7496                                &extractTotals[1][0]);
7497          for (cc = 0; cc < components; cc++) {
7498             int kk;
7499
7500             /* average 2 pixels since only a column */
7501             totals[cc]= 0.0;
7502             /* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED];
7503              * totals[RED]/= 2.0;
7504              */
7505             for (kk = 0; kk < BOX2; kk++) {
7506               totals[cc]+= extractTotals[kk][cc];
7507             }
7508             totals[cc]/= (float)BOX2;
7509          } /* for cc */
7510
7511          (*shovePackedPixel)(totals,outIndex,dataOut);
7512          outIndex++;
7513          /* skip over to next group of 2 */
7514          src+= imageSizeInBytes + imageSizeInBytes;
7515       } /* for ii */
7516    }
7517    else if (height == 1) {      /* horizontal slice viewed from top */
7518       assert(width != 1);
7519
7520       for (ii= 0; ii< halfDepth; ii++) {
7521          for (jj= 0; jj< halfWidth; jj++) {
7522              float totals[4];
7523              float extractTotals[BOX4][4];
7524              int cc;
7525
7526              (*extractPackedPixel)(isSwap,src,
7527                                    &extractTotals[0][0]);
7528              (*extractPackedPixel)(isSwap,(src+pixelSizeInBytes),
7529                                    &extractTotals[1][0]);
7530              (*extractPackedPixel)(isSwap,(src+imageSizeInBytes),
7531                                    &extractTotals[2][0]);
7532              (*extractPackedPixel)(isSwap,
7533                                    (src+imageSizeInBytes+pixelSizeInBytes),
7534                                    &extractTotals[3][0]);
7535              for (cc = 0; cc < components; cc++) {
7536                 int kk;
7537
7538                 /* grab 4 pixels to average */
7539                 totals[cc]= 0.0;
7540                 /* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED]+
7541                  *              extractTotals[2][RED]+extractTotals[3][RED];
7542                  * totals[RED]/= 4.0;
7543                  */
7544                 for (kk = 0; kk < BOX4; kk++) {
7545                    totals[cc]+= extractTotals[kk][cc];
7546                 }
7547                 totals[cc]/= (float)BOX4;
7548              }
7549              (*shovePackedPixel)(totals,outIndex,dataOut);
7550
7551              outIndex++;
7552              /* skip over to next horizontal square of 4 */
7553              src+= imageSizeInBytes + imageSizeInBytes;
7554          }
7555       }
7556
7557       /* assert() */
7558    }
7559    else if (width == 1) {       /* vertical slice viewed from top */
7560       assert(height != 1);
7561
7562       for (ii= 0; ii< halfDepth; ii++) {
7563          for (jj= 0; jj< halfHeight; jj++) {
7564             float totals[4];
7565             float extractTotals[BOX4][4];
7566             int cc;
7567
7568             (*extractPackedPixel)(isSwap,src,
7569                                   &extractTotals[0][0]);
7570             (*extractPackedPixel)(isSwap,(src+rowSizeInBytes),
7571                                   &extractTotals[1][0]);
7572             (*extractPackedPixel)(isSwap,(src+imageSizeInBytes),
7573                                   &extractTotals[2][0]);
7574             (*extractPackedPixel)(isSwap,
7575                                   (src+imageSizeInBytes+rowSizeInBytes),
7576                                   &extractTotals[3][0]);
7577             for (cc = 0; cc < components; cc++) {
7578                int kk;
7579
7580                /* grab 4 pixels to average */
7581                totals[cc]= 0.0;
7582                /* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED]+
7583                 *              extractTotals[2][RED]+extractTotals[3][RED];
7584                 * totals[RED]/= 4.0;
7585                 */
7586                for (kk = 0; kk < BOX4; kk++) {
7587                   totals[cc]+= extractTotals[kk][cc];
7588                }
7589                totals[cc]/= (float)BOX4;
7590             }
7591             (*shovePackedPixel)(totals,outIndex,dataOut);
7592
7593             outIndex++;
7594
7595             /* skip over to next vertical square of 4 */
7596             src+= imageSizeInBytes + imageSizeInBytes;
7597          }
7598       }
7599       /* assert() */
7600    }
7601
7602 } /* halveImagePackedPixelSlice() */
7603
7604 static void halveImagePackedPixel3D(int components,
7605                                     void (*extractPackedPixel)
7606                                     (int, const void *,GLfloat []),
7607                                     void (*shovePackedPixel)
7608                                     (const GLfloat [],int, void *),
7609                                     GLint width, GLint height, GLint depth,
7610                                     const void *dataIn, void *dataOut,
7611                                     GLint pixelSizeInBytes,
7612                                     GLint rowSizeInBytes,
7613                                     GLint imageSizeInBytes,
7614                                     GLint isSwap)
7615 {
7616    if (depth == 1) {
7617       assert(1 <= width && 1 <= height);
7618
7619       halveImagePackedPixel(components,extractPackedPixel,shovePackedPixel,
7620                             width,height,dataIn,dataOut,pixelSizeInBytes,
7621                             rowSizeInBytes,isSwap);
7622       return;
7623    }
7624    /* a horizontal or vertical slice viewed from top */
7625    else if (width == 1 || height == 1) {
7626       assert(1 <= depth);
7627
7628       halveImagePackedPixelSlice(components,
7629                                  extractPackedPixel,shovePackedPixel,
7630                                  width, height, depth, dataIn, dataOut,
7631                                  pixelSizeInBytes, rowSizeInBytes,
7632                                  imageSizeInBytes, isSwap);
7633       return;
7634    }
7635    {
7636       int ii, jj, dd;
7637
7638       int halfWidth= width / 2;
7639       int halfHeight= height / 2;
7640       int halfDepth= depth / 2;
7641       const char *src= (const char *) dataIn;
7642       int padBytes= rowSizeInBytes - (width*pixelSizeInBytes);
7643       int outIndex= 0;
7644
7645       for (dd= 0; dd < halfDepth; dd++) {
7646          for (ii= 0; ii< halfHeight; ii++) {
7647             for (jj= 0; jj< halfWidth; jj++) {
7648 #define BOX8 8
7649                float totals[4]; /* 4 is maximum components */
7650                float extractTotals[BOX8][4]; /* 4 is maximum components */
7651                int cc;
7652
7653                (*extractPackedPixel)(isSwap,src,
7654                                      &extractTotals[0][0]);
7655                (*extractPackedPixel)(isSwap,(src+pixelSizeInBytes),
7656                                      &extractTotals[1][0]);
7657                (*extractPackedPixel)(isSwap,(src+rowSizeInBytes),
7658                                      &extractTotals[2][0]);
7659                (*extractPackedPixel)(isSwap,
7660                                      (src+rowSizeInBytes+pixelSizeInBytes),
7661                                      &extractTotals[3][0]);
7662
7663                (*extractPackedPixel)(isSwap,(src+imageSizeInBytes),
7664                                      &extractTotals[4][0]);
7665                (*extractPackedPixel)(isSwap,(src+pixelSizeInBytes+imageSizeInBytes),
7666                                      &extractTotals[5][0]);
7667                (*extractPackedPixel)(isSwap,(src+rowSizeInBytes+imageSizeInBytes),
7668                                      &extractTotals[6][0]);
7669                (*extractPackedPixel)(isSwap,
7670                                      (src+rowSizeInBytes+pixelSizeInBytes+imageSizeInBytes),
7671                                      &extractTotals[7][0]);
7672                for (cc = 0; cc < components; cc++) {
7673                   int kk;
7674
7675                   /* grab 8 pixels to average */
7676                   totals[cc]= 0.0;
7677                   /* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED]+
7678                    *              extractTotals[2][RED]+extractTotals[3][RED]+
7679                    *              extractTotals[4][RED]+extractTotals[5][RED]+
7680                    *              extractTotals[6][RED]+extractTotals[7][RED];
7681                    * totals[RED]/= 8.0;
7682                    */
7683                   for (kk = 0; kk < BOX8; kk++) {
7684                      totals[cc]+= extractTotals[kk][cc];
7685                   }
7686                   totals[cc]/= (float)BOX8;
7687                }
7688                (*shovePackedPixel)(totals,outIndex,dataOut);
7689
7690                outIndex++;
7691                /* skip over to next square of 4 */
7692                src+= pixelSizeInBytes + pixelSizeInBytes;
7693             }
7694             /* skip past pad bytes, if any, to get to next row */
7695             src+= padBytes;
7696
7697             /* src is at beginning of a row here, but it's the second row of
7698              * the square block of 4 pixels that we just worked on so we
7699              * need to go one more row.
7700              * i.e.,
7701              *                   OO...
7702              *           here -->OO...
7703              *       but want -->OO...
7704              *                   OO...
7705              *                   ...
7706              */
7707             src+= rowSizeInBytes;
7708          }
7709
7710          src+= imageSizeInBytes;
7711       } /* for dd */
7712
7713       /* both pointers must reach one byte after the end */
7714       assert(src == &((const char *)dataIn)[rowSizeInBytes*height*depth]);
7715       assert(outIndex == halfWidth * halfHeight * halfDepth);
7716    } /* for dd */
7717
7718 } /* halveImagePackedPixel3D() */
7719
7720 static int gluBuild3DMipmapLevelsCore(GLenum target, GLint internalFormat,
7721                                       GLsizei width,
7722                                       GLsizei height,
7723                                       GLsizei depth,
7724                                       GLsizei widthPowerOf2,
7725                                       GLsizei heightPowerOf2,
7726                                       GLsizei depthPowerOf2,
7727                                       GLenum format, GLenum type,
7728                                       GLint userLevel,
7729                                       GLint baseLevel,GLint maxLevel,
7730                                       const void *data)
7731 {
7732    GLint newWidth, newHeight, newDepth;
7733    GLint level, levels;
7734    const void *usersImage;
7735    void *srcImage, *dstImage;
7736    __GLU_INIT_SWAP_IMAGE;
7737    GLint memReq;
7738    GLint cmpts;
7739
7740    GLint myswapBytes, groupsPerLine, elementSize, groupSize;
7741    GLint rowsPerImage, imageSize;
7742    GLint rowSize, padding;
7743    PixelStorageModes psm;
7744
7745    assert(checkMipmapArgs(internalFormat,format,type) == 0);
7746    assert(width >= 1 && height >= 1 && depth >= 1);
7747    assert(type != GL_BITMAP);
7748
7749    srcImage = dstImage = NULL;
7750
7751    newWidth= widthPowerOf2;
7752    newHeight= heightPowerOf2;
7753    newDepth= depthPowerOf2;
7754    levels = computeLog(newWidth);
7755    level = computeLog(newHeight);
7756    if (level > levels) levels=level;
7757    level = computeLog(newDepth);
7758    if (level > levels) levels=level;
7759
7760    levels+= userLevel;
7761
7762    retrieveStoreModes3D(&psm);
7763    myswapBytes = psm.unpack_swap_bytes;
7764    cmpts = elements_per_group(format,type);
7765    if (psm.unpack_row_length > 0) {
7766        groupsPerLine = psm.unpack_row_length;
7767    } else {
7768        groupsPerLine = width;
7769    }
7770
7771    elementSize = bytes_per_element(type);
7772    groupSize = elementSize * cmpts;
7773    if (elementSize == 1) myswapBytes = 0;
7774
7775    /* 3dstuff begin */
7776    if (psm.unpack_image_height > 0) {
7777       rowsPerImage= psm.unpack_image_height;
7778    }
7779    else {
7780       rowsPerImage= height;
7781    }
7782
7783    /* 3dstuff end */
7784    rowSize = groupsPerLine * groupSize;
7785    padding = (rowSize % psm.unpack_alignment);
7786    if (padding) {
7787        rowSize += psm.unpack_alignment - padding;
7788    }
7789
7790    imageSize= rowsPerImage * rowSize; /* 3dstuff */
7791
7792    usersImage = (const GLubyte *)data + psm.unpack_skip_rows * rowSize +
7793                                   psm.unpack_skip_pixels * groupSize +
7794                                   /* 3dstuff */
7795                                   psm.unpack_skip_images * imageSize;
7796
7797    glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
7798    glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
7799    glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
7800    glPixelStorei(GL_UNPACK_SKIP_IMAGES, 0);
7801    glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, 0);
7802
7803    level = userLevel;
7804
7805    if (width == newWidth && height == newHeight && depth == newDepth) {
7806        /* Use usersImage for level userLevel */
7807        if (baseLevel <= level && level <= maxLevel) {
7808           gluTexImage3D(target, level, internalFormat, width,
7809                        height, depth, 0, format, type,
7810                        usersImage);
7811        }
7812        if(levels == 0) { /* we're done. clean up and return */
7813          glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
7814          glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
7815          glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
7816          glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
7817          glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
7818          glPixelStorei(GL_UNPACK_SKIP_IMAGES, psm.unpack_skip_images);
7819          glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, psm.unpack_image_height);
7820          return 0;
7821        }
7822        {
7823           int nextWidth= newWidth/2;
7824           int nextHeight= newHeight/2;
7825           int nextDepth= newDepth/2;
7826
7827           /* clamp to 1 */
7828           if (nextWidth < 1) nextWidth= 1;
7829           if (nextHeight < 1) nextHeight= 1;
7830           if (nextDepth < 1) nextDepth= 1;
7831        memReq = imageSize3D(nextWidth, nextHeight, nextDepth, format, type);
7832        }
7833        switch(type) {
7834        case GL_UNSIGNED_BYTE:
7835          dstImage = (GLubyte *)malloc(memReq);
7836          break;
7837        case GL_BYTE:
7838          dstImage = (GLbyte *)malloc(memReq);
7839          break;
7840        case GL_UNSIGNED_SHORT:
7841          dstImage = (GLushort *)malloc(memReq);
7842          break;
7843        case GL_SHORT:
7844          dstImage = (GLshort *)malloc(memReq);
7845          break;
7846        case GL_UNSIGNED_INT:
7847          dstImage = (GLuint *)malloc(memReq);
7848          break;
7849        case GL_INT:
7850          dstImage = (GLint *)malloc(memReq);
7851          break;
7852        case GL_FLOAT:
7853          dstImage = (GLfloat *)malloc(memReq);
7854          break;
7855        case GL_UNSIGNED_BYTE_3_3_2:
7856        case GL_UNSIGNED_BYTE_2_3_3_REV:
7857          dstImage = (GLubyte *)malloc(memReq);
7858          break;
7859        case GL_UNSIGNED_SHORT_5_6_5:
7860        case GL_UNSIGNED_SHORT_5_6_5_REV:
7861        case GL_UNSIGNED_SHORT_4_4_4_4:
7862        case GL_UNSIGNED_SHORT_4_4_4_4_REV:
7863        case GL_UNSIGNED_SHORT_5_5_5_1:
7864        case GL_UNSIGNED_SHORT_1_5_5_5_REV:
7865          dstImage = (GLushort *)malloc(memReq);
7866          break;
7867        case GL_UNSIGNED_INT_8_8_8_8:
7868        case GL_UNSIGNED_INT_8_8_8_8_REV:
7869        case GL_UNSIGNED_INT_10_10_10_2:
7870        case GL_UNSIGNED_INT_2_10_10_10_REV:
7871          dstImage = (GLuint *)malloc(memReq);
7872          break;
7873        default:
7874          return GLU_INVALID_ENUM; /* assertion */
7875        }
7876        if (dstImage == NULL) {
7877          glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
7878          glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
7879          glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
7880          glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
7881          glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
7882          glPixelStorei(GL_UNPACK_SKIP_IMAGES, psm.unpack_skip_images);
7883          glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, psm.unpack_image_height);
7884          return GLU_OUT_OF_MEMORY;
7885        }
7886        else
7887          switch(type) {
7888          case GL_UNSIGNED_BYTE:
7889            if (depth > 1) {
7890              halveImage3D(cmpts,extractUbyte,shoveUbyte,
7891                           width,height,depth,
7892                           usersImage,dstImage,elementSize,groupSize,rowSize,
7893                           imageSize,myswapBytes);
7894            }
7895            else {
7896              halveImage_ubyte(cmpts,width,height,usersImage,dstImage,
7897                               elementSize,rowSize,groupSize);
7898            }
7899            break;
7900          case GL_BYTE:
7901            if (depth > 1) {
7902            halveImage3D(cmpts,extractSbyte,shoveSbyte,
7903                         width,height,depth,
7904                         usersImage,dstImage,elementSize,groupSize,rowSize,
7905                         imageSize,myswapBytes);
7906            }
7907            else {
7908              halveImage_byte(cmpts,width,height,usersImage,dstImage,
7909                              elementSize,rowSize,groupSize);
7910            }
7911            break;
7912          case GL_UNSIGNED_SHORT:
7913            if (depth > 1) {
7914            halveImage3D(cmpts,extractUshort,shoveUshort,
7915                         width,height,depth,
7916                         usersImage,dstImage,elementSize,groupSize,rowSize,
7917                         imageSize,myswapBytes);
7918            }
7919            else {
7920              halveImage_ushort(cmpts,width,height,usersImage,dstImage,
7921                                elementSize,rowSize,groupSize,myswapBytes);
7922            }
7923            break;
7924          case GL_SHORT:
7925            if (depth > 1) {
7926            halveImage3D(cmpts,extractSshort,shoveSshort,
7927                         width,height,depth,
7928                         usersImage,dstImage,elementSize,groupSize,rowSize,
7929                         imageSize,myswapBytes);
7930            }
7931            else {
7932              halveImage_short(cmpts,width,height,usersImage,dstImage,
7933                               elementSize,rowSize,groupSize,myswapBytes);
7934            }
7935            break;
7936          case GL_UNSIGNED_INT:
7937            if (depth > 1) {
7938            halveImage3D(cmpts,extractUint,shoveUint,
7939                         width,height,depth,
7940                         usersImage,dstImage,elementSize,groupSize,rowSize,
7941                         imageSize,myswapBytes);
7942            }
7943            else {
7944              halveImage_uint(cmpts,width,height,usersImage,dstImage,
7945                              elementSize,rowSize,groupSize,myswapBytes);
7946            }
7947            break;
7948          case GL_INT:
7949            if (depth > 1) {
7950            halveImage3D(cmpts,extractSint,shoveSint,
7951                         width,height,depth,
7952                         usersImage,dstImage,elementSize,groupSize,rowSize,
7953                         imageSize,myswapBytes);
7954            }
7955            else {
7956              halveImage_int(cmpts,width,height,usersImage,dstImage,
7957                             elementSize,rowSize,groupSize,myswapBytes);
7958            }
7959            break;
7960          case GL_FLOAT:
7961            if (depth > 1 ) {
7962            halveImage3D(cmpts,extractFloat,shoveFloat,
7963                         width,height,depth,
7964                         usersImage,dstImage,elementSize,groupSize,rowSize,
7965                         imageSize,myswapBytes);
7966            }
7967            else {
7968              halveImage_float(cmpts,width,height,usersImage,dstImage,
7969                               elementSize,rowSize,groupSize,myswapBytes);
7970            }
7971            break;
7972          case GL_UNSIGNED_BYTE_3_3_2:
7973            assert(format == GL_RGB);
7974            halveImagePackedPixel3D(3,extract332,shove332,
7975                                    width,height,depth,usersImage,dstImage,
7976                                    elementSize,rowSize,imageSize,myswapBytes);
7977            break;
7978          case GL_UNSIGNED_BYTE_2_3_3_REV:
7979            assert(format == GL_RGB);
7980            halveImagePackedPixel3D(3,extract233rev,shove233rev,
7981                                    width,height,depth,usersImage,dstImage,
7982                                    elementSize,rowSize,imageSize,myswapBytes);
7983            break;
7984          case GL_UNSIGNED_SHORT_5_6_5:
7985            halveImagePackedPixel3D(3,extract565,shove565,
7986                                    width,height,depth,usersImage,dstImage,
7987                                    elementSize,rowSize,imageSize,myswapBytes);
7988            break;
7989          case GL_UNSIGNED_SHORT_5_6_5_REV:
7990            halveImagePackedPixel3D(3,extract565rev,shove565rev,
7991                                    width,height,depth,usersImage,dstImage,
7992                                    elementSize,rowSize,imageSize,myswapBytes);
7993            break;
7994          case GL_UNSIGNED_SHORT_4_4_4_4:
7995            halveImagePackedPixel3D(4,extract4444,shove4444,
7996                                    width,height,depth,usersImage,dstImage,
7997                                    elementSize,rowSize,imageSize,myswapBytes);
7998            break;
7999          case GL_UNSIGNED_SHORT_4_4_4_4_REV:
8000            halveImagePackedPixel3D(4,extract4444rev,shove4444rev,
8001                                    width,height,depth,usersImage,dstImage,
8002                                    elementSize,rowSize,imageSize,myswapBytes);
8003            break;
8004          case GL_UNSIGNED_SHORT_5_5_5_1:
8005            halveImagePackedPixel3D(4,extract5551,shove5551,
8006                                    width,height,depth,usersImage,dstImage,
8007                                    elementSize,rowSize,imageSize,myswapBytes);
8008            break;
8009          case GL_UNSIGNED_SHORT_1_5_5_5_REV:
8010            halveImagePackedPixel3D(4,extract1555rev,shove1555rev,
8011                                    width,height,depth,usersImage,dstImage,
8012                                    elementSize,rowSize,imageSize,myswapBytes);
8013            break;
8014          case GL_UNSIGNED_INT_8_8_8_8:
8015            halveImagePackedPixel3D(4,extract8888,shove8888,
8016                                    width,height,depth,usersImage,dstImage,
8017                                    elementSize,rowSize,imageSize,myswapBytes);
8018            break;
8019          case GL_UNSIGNED_INT_8_8_8_8_REV:
8020            halveImagePackedPixel3D(4,extract8888rev,shove8888rev,
8021                                    width,height,depth,usersImage,dstImage,
8022                                    elementSize,rowSize,imageSize,myswapBytes);
8023            break;
8024          case GL_UNSIGNED_INT_10_10_10_2:
8025            halveImagePackedPixel3D(4,extract1010102,shove1010102,
8026                                    width,height,depth,usersImage,dstImage,
8027                                    elementSize,rowSize,imageSize,myswapBytes);
8028            break;
8029          case GL_UNSIGNED_INT_2_10_10_10_REV:
8030            halveImagePackedPixel3D(4,extract2101010rev,shove2101010rev,
8031                                    width,height,depth,usersImage,dstImage,
8032                                    elementSize,rowSize,imageSize,myswapBytes);
8033            break;
8034          default:
8035            assert(0);
8036            break;
8037          }
8038        newWidth = width/2;
8039        newHeight = height/2;
8040        newDepth = depth/2;
8041        /* clamp to 1 */
8042        if (newWidth < 1) newWidth= 1;
8043        if (newHeight < 1) newHeight= 1;
8044        if (newDepth < 1) newDepth= 1;
8045
8046        myswapBytes = 0;
8047        rowSize = newWidth * groupSize;
8048        imageSize= rowSize * newHeight; /* 3dstuff */
8049        memReq = imageSize3D(newWidth, newHeight, newDepth, format, type);
8050        /* Swap srcImage and dstImage */
8051        __GLU_SWAP_IMAGE(srcImage,dstImage);
8052        switch(type) {
8053        case GL_UNSIGNED_BYTE:
8054          dstImage = (GLubyte *)malloc(memReq);
8055          break;
8056        case GL_BYTE:
8057          dstImage = (GLbyte *)malloc(memReq);
8058          break;
8059        case GL_UNSIGNED_SHORT:
8060          dstImage = (GLushort *)malloc(memReq);
8061          break;
8062        case GL_SHORT:
8063          dstImage = (GLshort *)malloc(memReq);
8064          break;
8065        case GL_UNSIGNED_INT:
8066          dstImage = (GLuint *)malloc(memReq);
8067          break;
8068        case GL_INT:
8069          dstImage = (GLint *)malloc(memReq);
8070          break;
8071        case GL_FLOAT:
8072          dstImage = (GLfloat *)malloc(memReq);
8073          break;
8074        case GL_UNSIGNED_BYTE_3_3_2:
8075        case GL_UNSIGNED_BYTE_2_3_3_REV:
8076          dstImage = (GLubyte *)malloc(memReq);
8077          break;
8078        case GL_UNSIGNED_SHORT_5_6_5:
8079        case GL_UNSIGNED_SHORT_5_6_5_REV:
8080        case GL_UNSIGNED_SHORT_4_4_4_4:
8081        case GL_UNSIGNED_SHORT_4_4_4_4_REV:
8082        case GL_UNSIGNED_SHORT_5_5_5_1:
8083        case GL_UNSIGNED_SHORT_1_5_5_5_REV:
8084          dstImage = (GLushort *)malloc(memReq);
8085          break;
8086        case GL_UNSIGNED_INT_8_8_8_8:
8087        case GL_UNSIGNED_INT_8_8_8_8_REV:
8088        case GL_UNSIGNED_INT_10_10_10_2:
8089        case GL_UNSIGNED_INT_2_10_10_10_REV:
8090          dstImage = (GLuint *)malloc(memReq);
8091          break;
8092        default:
8093          return GLU_INVALID_ENUM; /* assertion */
8094        }
8095        if (dstImage == NULL) {
8096          glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
8097          glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
8098          glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
8099          glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
8100          glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
8101          glPixelStorei(GL_UNPACK_SKIP_IMAGES, psm.unpack_skip_images);
8102          glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, psm.unpack_image_height);
8103          free(srcImage);
8104          return GLU_OUT_OF_MEMORY;
8105        }
8106        /* level userLevel+1 is in srcImage; level userLevel already saved */
8107        level = userLevel+1;
8108    } else {/* user's image is *not* nice power-of-2 sized square */
8109        memReq = imageSize3D(newWidth, newHeight, newDepth, format, type);
8110        switch(type) {
8111            case GL_UNSIGNED_BYTE:
8112                dstImage = (GLubyte *)malloc(memReq);
8113                break;
8114            case GL_BYTE:
8115                dstImage = (GLbyte *)malloc(memReq);
8116                break;
8117            case GL_UNSIGNED_SHORT:
8118                dstImage = (GLushort *)malloc(memReq);
8119                break;
8120            case GL_SHORT:
8121                dstImage = (GLshort *)malloc(memReq);
8122                break;
8123            case GL_UNSIGNED_INT:
8124                dstImage = (GLuint *)malloc(memReq);
8125                break;
8126            case GL_INT:
8127                dstImage = (GLint *)malloc(memReq);
8128                break;
8129            case GL_FLOAT:
8130                dstImage = (GLfloat *)malloc(memReq);
8131                break;
8132            case GL_UNSIGNED_BYTE_3_3_2:
8133            case GL_UNSIGNED_BYTE_2_3_3_REV:
8134                dstImage = (GLubyte *)malloc(memReq);
8135                break;
8136            case GL_UNSIGNED_SHORT_5_6_5:
8137            case GL_UNSIGNED_SHORT_5_6_5_REV:
8138            case GL_UNSIGNED_SHORT_4_4_4_4:
8139            case GL_UNSIGNED_SHORT_4_4_4_4_REV:
8140            case GL_UNSIGNED_SHORT_5_5_5_1:
8141            case GL_UNSIGNED_SHORT_1_5_5_5_REV:
8142                dstImage = (GLushort *)malloc(memReq);
8143                break;
8144            case GL_UNSIGNED_INT_8_8_8_8:
8145            case GL_UNSIGNED_INT_8_8_8_8_REV:
8146            case GL_UNSIGNED_INT_10_10_10_2:
8147            case GL_UNSIGNED_INT_2_10_10_10_REV:
8148                dstImage = (GLuint *)malloc(memReq);
8149                break;
8150            default:
8151                return GLU_INVALID_ENUM; /* assertion */
8152        }
8153
8154        if (dstImage == NULL) {
8155            glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
8156            glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
8157            glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
8158            glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
8159            glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
8160            glPixelStorei(GL_UNPACK_SKIP_IMAGES, psm.unpack_skip_images);
8161            glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, psm.unpack_image_height);
8162            return GLU_OUT_OF_MEMORY;
8163        }
8164        /*printf("Build3DMipmaps(): ScaleImage3D %d %d %d->%d %d %d\n",
8165        width,height,depth,newWidth,newHeight,newDepth);*/
8166
8167        gluScaleImage3D(format, width, height, depth, type, usersImage,
8168                        newWidth, newHeight, newDepth, type, dstImage);
8169
8170        myswapBytes = 0;
8171        rowSize = newWidth * groupSize;
8172        imageSize = rowSize * newHeight; /* 3dstuff */
8173        /* Swap dstImage and srcImage */
8174        __GLU_SWAP_IMAGE(srcImage,dstImage);
8175
8176        if(levels != 0) { /* use as little memory as possible */
8177          {
8178             int nextWidth= newWidth/2;
8179             int nextHeight= newHeight/2;
8180             int nextDepth= newDepth/2;
8181             if (nextWidth < 1) nextWidth= 1;
8182             if (nextHeight < 1) nextHeight= 1;
8183             if (nextDepth < 1) nextDepth= 1;
8184
8185          memReq = imageSize3D(nextWidth, nextHeight, nextDepth, format, type);
8186          }
8187          switch(type) {
8188          case GL_UNSIGNED_BYTE:
8189            dstImage = (GLubyte *)malloc(memReq);
8190            break;
8191          case GL_BYTE:
8192            dstImage = (GLbyte *)malloc(memReq);
8193            break;
8194          case GL_UNSIGNED_SHORT:
8195            dstImage = (GLushort *)malloc(memReq);
8196            break;
8197          case GL_SHORT:
8198            dstImage = (GLshort *)malloc(memReq);
8199            break;
8200          case GL_UNSIGNED_INT:
8201            dstImage = (GLuint *)malloc(memReq);
8202            break;
8203          case GL_INT:
8204            dstImage = (GLint *)malloc(memReq);
8205            break;
8206          case GL_FLOAT:
8207            dstImage = (GLfloat *)malloc(memReq);
8208            break;
8209          case GL_UNSIGNED_BYTE_3_3_2:
8210          case GL_UNSIGNED_BYTE_2_3_3_REV:
8211            dstImage = (GLubyte *)malloc(memReq);
8212            break;
8213          case GL_UNSIGNED_SHORT_5_6_5:
8214          case GL_UNSIGNED_SHORT_5_6_5_REV:
8215          case GL_UNSIGNED_SHORT_4_4_4_4:
8216          case GL_UNSIGNED_SHORT_4_4_4_4_REV:
8217          case GL_UNSIGNED_SHORT_5_5_5_1:
8218          case GL_UNSIGNED_SHORT_1_5_5_5_REV:
8219            dstImage = (GLushort *)malloc(memReq);
8220            break;
8221          case GL_UNSIGNED_INT_8_8_8_8:
8222          case GL_UNSIGNED_INT_8_8_8_8_REV:
8223          case GL_UNSIGNED_INT_10_10_10_2:
8224          case GL_UNSIGNED_INT_2_10_10_10_REV:
8225            dstImage = (GLuint *)malloc(memReq);
8226            break;
8227          default:
8228            return GLU_INVALID_ENUM; /* assertion */
8229          }
8230          if (dstImage == NULL) {
8231            glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
8232            glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
8233            glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
8234            glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
8235            glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
8236            glPixelStorei(GL_UNPACK_SKIP_IMAGES, psm.unpack_skip_images);
8237            glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, psm.unpack_image_height);
8238            free(srcImage);
8239            return GLU_OUT_OF_MEMORY;
8240          }
8241        }
8242        /* level userLevel is in srcImage; nothing saved yet */
8243        level = userLevel;
8244    }
8245
8246    glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE);
8247    if (baseLevel <= level && level <= maxLevel) {
8248      gluTexImage3D(target, level, internalFormat, newWidth, newHeight, newDepth,
8249                   0,format, type, (void *)srcImage);
8250    }
8251    level++; /* update current level for the loop */
8252    for (; level <= levels; level++) {
8253        switch(type) {
8254            case GL_UNSIGNED_BYTE:
8255                if (newDepth > 1) {
8256                halveImage3D(cmpts,extractUbyte,shoveUbyte,
8257                             newWidth,newHeight,newDepth,
8258                             srcImage,dstImage,elementSize,groupSize,rowSize,
8259                             imageSize,myswapBytes);
8260                }
8261                else {
8262                  halveImage_ubyte(cmpts,newWidth,newHeight,srcImage,dstImage,
8263                                   elementSize,rowSize,groupSize);
8264                }
8265                break;
8266            case GL_BYTE:
8267                if (newDepth > 1) {
8268                halveImage3D(cmpts,extractSbyte,shoveSbyte,
8269                             newWidth,newHeight,newDepth,
8270                             srcImage,dstImage,elementSize,groupSize,rowSize,
8271                             imageSize,myswapBytes);
8272                }
8273                else {
8274                  halveImage_byte(cmpts,newWidth,newHeight,srcImage,dstImage,
8275                                   elementSize,rowSize,groupSize);
8276                }
8277                break;
8278            case GL_UNSIGNED_SHORT:
8279                if (newDepth > 1) {
8280                halveImage3D(cmpts,extractUshort,shoveUshort,
8281                             newWidth,newHeight,newDepth,
8282                             srcImage,dstImage,elementSize,groupSize,rowSize,
8283                             imageSize,myswapBytes);
8284                }
8285                else {
8286                  halveImage_ushort(cmpts,newWidth,newHeight,srcImage,dstImage,
8287                                    elementSize,rowSize,groupSize,myswapBytes);
8288                }
8289                break;
8290            case GL_SHORT:
8291                if (newDepth > 1) {
8292                halveImage3D(cmpts,extractSshort,shoveSshort,
8293                             newWidth,newHeight,newDepth,
8294                             srcImage,dstImage,elementSize,groupSize,rowSize,
8295                             imageSize,myswapBytes);
8296                }
8297                else {
8298                  halveImage_short(cmpts,newWidth,newHeight,srcImage,dstImage,
8299                                   elementSize,rowSize,groupSize,myswapBytes);
8300                }
8301                break;
8302            case GL_UNSIGNED_INT:
8303                if (newDepth > 1) {
8304                halveImage3D(cmpts,extractUint,shoveUint,
8305                             newWidth,newHeight,newDepth,
8306                             srcImage,dstImage,elementSize,groupSize,rowSize,
8307                             imageSize,myswapBytes);
8308                }
8309                else {
8310                  halveImage_uint(cmpts,newWidth,newHeight,srcImage,dstImage,
8311                                  elementSize,rowSize,groupSize,myswapBytes);
8312                }
8313                break;
8314            case GL_INT:
8315                if (newDepth > 1) {
8316                halveImage3D(cmpts,extractSint,shoveSint,
8317                             newWidth,newHeight,newDepth,
8318                             srcImage,dstImage,elementSize,groupSize,rowSize,
8319                             imageSize,myswapBytes);
8320                }
8321                else {
8322                  halveImage_int(cmpts,newWidth,newHeight,srcImage,dstImage,
8323                                 elementSize,rowSize,groupSize,myswapBytes);
8324                }
8325                break;
8326            case GL_FLOAT:
8327                if (newDepth > 1) {
8328                halveImage3D(cmpts,extractFloat,shoveFloat,
8329                             newWidth,newHeight,newDepth,
8330                             srcImage,dstImage,elementSize,groupSize,rowSize,
8331                             imageSize,myswapBytes);
8332                }
8333                else {
8334                  halveImage_float(cmpts,newWidth,newHeight,srcImage,dstImage,
8335                                   elementSize,rowSize,groupSize,myswapBytes);
8336                }
8337                break;
8338            case GL_UNSIGNED_BYTE_3_3_2:
8339                halveImagePackedPixel3D(3,extract332,shove332,
8340                                        newWidth,newHeight,newDepth,
8341                                        srcImage,dstImage,elementSize,rowSize,
8342                                        imageSize,myswapBytes);
8343                break;
8344            case GL_UNSIGNED_BYTE_2_3_3_REV:
8345                halveImagePackedPixel3D(3,extract233rev,shove233rev,
8346                                        newWidth,newHeight,newDepth,
8347                                        srcImage,dstImage,elementSize,rowSize,
8348                                        imageSize,myswapBytes);
8349                break;
8350            case GL_UNSIGNED_SHORT_5_6_5:
8351                halveImagePackedPixel3D(3,extract565,shove565,
8352                                        newWidth,newHeight,newDepth,
8353                                        srcImage,dstImage,elementSize,rowSize,
8354                                        imageSize,myswapBytes);
8355                break;
8356            case GL_UNSIGNED_SHORT_5_6_5_REV:
8357                halveImagePackedPixel3D(3,extract565rev,shove565rev,
8358                                        newWidth,newHeight,newDepth,
8359                                        srcImage,dstImage,elementSize,rowSize,
8360                                        imageSize,myswapBytes);
8361                break;
8362            case GL_UNSIGNED_SHORT_4_4_4_4:
8363                halveImagePackedPixel3D(4,extract4444,shove4444,
8364                                        newWidth,newHeight,newDepth,
8365                                        srcImage,dstImage,elementSize,rowSize,
8366                                        imageSize,myswapBytes);
8367                break;
8368            case GL_UNSIGNED_SHORT_4_4_4_4_REV:
8369                halveImagePackedPixel3D(4,extract4444rev,shove4444rev,
8370                                        newWidth,newHeight,newDepth,
8371                                        srcImage,dstImage,elementSize,rowSize,
8372                                        imageSize,myswapBytes);
8373                break;
8374            case GL_UNSIGNED_SHORT_5_5_5_1:
8375                halveImagePackedPixel3D(4,extract5551,shove5551,
8376                                        newWidth,newHeight,newDepth,
8377                                        srcImage,dstImage,elementSize,rowSize,
8378                                        imageSize,myswapBytes);
8379                break;
8380            case GL_UNSIGNED_SHORT_1_5_5_5_REV:
8381                halveImagePackedPixel3D(4,extract1555rev,shove1555rev,
8382                                        newWidth,newHeight,newDepth,
8383                                        srcImage,dstImage,elementSize,rowSize,
8384                                        imageSize,myswapBytes);
8385                break;
8386            case GL_UNSIGNED_INT_8_8_8_8:
8387                halveImagePackedPixel3D(4,extract8888,shove8888,
8388                                        newWidth,newHeight,newDepth,
8389                                        srcImage,dstImage,elementSize,rowSize,
8390                                        imageSize,myswapBytes);
8391                break;
8392            case GL_UNSIGNED_INT_8_8_8_8_REV:
8393                halveImagePackedPixel3D(4,extract8888rev,shove8888rev,
8394                                        newWidth,newHeight,newDepth,
8395                                        srcImage,dstImage,elementSize,rowSize,
8396                                        imageSize,myswapBytes);
8397                break;
8398            case GL_UNSIGNED_INT_10_10_10_2:
8399                halveImagePackedPixel3D(4,extract1010102,shove1010102,
8400                                        newWidth,newHeight,newDepth,
8401                                        srcImage,dstImage,elementSize,rowSize,
8402                                        imageSize,myswapBytes);
8403                break;
8404            case GL_UNSIGNED_INT_2_10_10_10_REV:
8405                halveImagePackedPixel3D(4,extract2101010rev,shove2101010rev,
8406                                        newWidth,newHeight,newDepth,
8407                                        srcImage,dstImage,elementSize,rowSize,
8408                                        imageSize,myswapBytes);
8409                break;
8410            default:
8411                assert(0);
8412                break;
8413        }
8414
8415        __GLU_SWAP_IMAGE(srcImage,dstImage);
8416
8417        if (newWidth > 1) { newWidth /= 2; rowSize /= 2;}
8418        if (newHeight > 1) { newHeight /= 2; imageSize = rowSize * newHeight; }
8419        if (newDepth > 1) newDepth /= 2;
8420        {
8421           /* call tex image with srcImage untouched since it's not padded */
8422           if (baseLevel <= level && level <= maxLevel) {
8423             gluTexImage3D(target, level, internalFormat, newWidth, newHeight,
8424                          newDepth,0, format, type, (void *) srcImage);
8425           }
8426        }
8427    } /* for level */
8428    glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
8429    glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
8430    glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
8431    glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
8432    glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
8433    glPixelStorei(GL_UNPACK_SKIP_IMAGES, psm.unpack_skip_images);
8434    glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, psm.unpack_image_height);
8435
8436    free(srcImage); /*if you get to here, a srcImage has always been malloc'ed*/
8437    if (dstImage) { /* if it's non-rectangular and only 1 level */
8438      free(dstImage);
8439    }
8440    return 0;
8441 } /* gluBuild3DMipmapLevelsCore() */
8442
8443 GLint GLAPIENTRY
8444 gluBuild3DMipmapLevels(GLenum target, GLint internalFormat,
8445                              GLsizei width, GLsizei height, GLsizei depth,
8446                              GLenum format, GLenum type,
8447                              GLint userLevel, GLint baseLevel, GLint maxLevel,
8448                              const void *data)
8449 {
8450    int level, levels;
8451
8452    int rc= checkMipmapArgs(internalFormat,format,type);
8453    if (rc != 0) return rc;
8454
8455    if (width < 1 || height < 1 || depth < 1) {
8456        return GLU_INVALID_VALUE;
8457    }
8458
8459    if(type == GL_BITMAP) {
8460       return GLU_INVALID_ENUM;
8461    }
8462
8463    levels = computeLog(width);
8464    level = computeLog(height);
8465    if (level > levels) levels=level;
8466    level = computeLog(depth);
8467    if (level > levels) levels=level;
8468
8469    levels+= userLevel;
8470    if (!isLegalLevels(userLevel,baseLevel,maxLevel,levels))
8471       return GLU_INVALID_VALUE;
8472
8473    return gluBuild3DMipmapLevelsCore(target, internalFormat,
8474                                      width, height, depth,
8475                                      width, height, depth,
8476                                      format, type,
8477                                      userLevel, baseLevel, maxLevel,
8478                                      data);
8479 } /* gluBuild3DMipmapLevels() */
8480
8481 GLint GLAPIENTRY
8482 gluBuild3DMipmaps(GLenum target, GLint internalFormat,
8483                         GLsizei width, GLsizei height, GLsizei depth,
8484                         GLenum format, GLenum type, const void *data)
8485 {
8486    GLint widthPowerOf2, heightPowerOf2, depthPowerOf2;
8487    int level, levels;
8488
8489    int rc= checkMipmapArgs(internalFormat,format,type);
8490    if (rc != 0) return rc;
8491
8492    if (width < 1 || height < 1 || depth < 1) {
8493        return GLU_INVALID_VALUE;
8494    }
8495
8496    if(type == GL_BITMAP) {
8497       return GLU_INVALID_ENUM;
8498    }
8499
8500    closestFit3D(target,width,height,depth,internalFormat,format,type,
8501                 &widthPowerOf2,&heightPowerOf2,&depthPowerOf2);
8502
8503    levels = computeLog(widthPowerOf2);
8504    level = computeLog(heightPowerOf2);
8505    if (level > levels) levels=level;
8506    level = computeLog(depthPowerOf2);
8507    if (level > levels) levels=level;
8508
8509    return gluBuild3DMipmapLevelsCore(target, internalFormat,
8510                                      width, height, depth,
8511                                      widthPowerOf2, heightPowerOf2,
8512                                      depthPowerOf2,
8513                                      format, type, 0, 0, levels,
8514                                      data);
8515 } /* gluBuild3DMipmaps() */
8516
8517 static GLdouble extractUbyte(int isSwap, const void *ubyte)
8518 {
8519    isSwap= isSwap;              /* turn off warnings */
8520
8521    assert(*((const GLubyte *)ubyte) <= 255);
8522
8523    return (GLdouble)(*((const GLubyte *)ubyte));
8524 } /* extractUbyte() */
8525
8526 static void shoveUbyte(GLdouble value, int index, void *data)
8527 {
8528    assert(0.0 <= value && value < 256.0);
8529
8530    ((GLubyte *)data)[index]= (GLubyte)value;
8531 } /* shoveUbyte() */
8532
8533 static GLdouble extractSbyte(int isSwap, const void *sbyte)
8534 {
8535    isSwap= isSwap;              /* turn off warnings */
8536
8537    assert(*((const GLbyte *)sbyte) <= 127);
8538
8539    return (GLdouble)(*((const GLbyte *)sbyte));
8540 } /* extractSbyte() */
8541
8542 static void shoveSbyte(GLdouble value, int index, void *data)
8543 {
8544    ((GLbyte *)data)[index]= (GLbyte)value;
8545 } /* shoveSbyte() */
8546
8547 static GLdouble extractUshort(int isSwap, const void *uitem)
8548 {
8549    GLushort ushort;
8550
8551    if (isSwap) {
8552      ushort= __GLU_SWAP_2_BYTES(uitem);
8553    }
8554    else {
8555      ushort= *(const GLushort *)uitem;
8556    }
8557
8558    assert(ushort <= 65535);
8559
8560    return (GLdouble)ushort;
8561 } /* extractUshort() */
8562
8563 static void shoveUshort(GLdouble value, int index, void *data)
8564 {
8565    assert(0.0 <= value && value < 65536.0);
8566
8567    ((GLushort *)data)[index]= (GLushort)value;
8568 } /* shoveUshort() */
8569
8570 static GLdouble extractSshort(int isSwap, const void *sitem)
8571 {
8572    GLshort sshort;
8573
8574    if (isSwap) {
8575      sshort= __GLU_SWAP_2_BYTES(sitem);
8576    }
8577    else {
8578      sshort= *(const GLshort *)sitem;
8579    }
8580
8581    assert(sshort <= 32767);
8582
8583    return (GLdouble)sshort;
8584 } /* extractSshort() */
8585
8586 static void shoveSshort(GLdouble value, int index, void *data)
8587 {
8588    assert(0.0 <= value && value < 32768.0);
8589
8590    ((GLshort *)data)[index]= (GLshort)value;
8591 } /* shoveSshort() */
8592
8593 static GLdouble extractUint(int isSwap, const void *uitem)
8594 {
8595    GLuint uint;
8596
8597    if (isSwap) {
8598      uint= __GLU_SWAP_4_BYTES(uitem);
8599    }
8600    else {
8601      uint= *(const GLuint *)uitem;
8602    }
8603
8604    assert(uint <= 0xffffffff);
8605
8606    return (GLdouble)uint;
8607 } /* extractUint() */
8608
8609 static void shoveUint(GLdouble value, int index, void *data)
8610 {
8611    assert(0.0 <= value && value <= (GLdouble) UINT_MAX);
8612
8613    ((GLuint *)data)[index]= (GLuint)value;
8614 } /* shoveUint() */
8615
8616 static GLdouble extractSint(int isSwap, const void *sitem)
8617 {
8618    GLint sint;
8619
8620    if (isSwap) {
8621      sint= __GLU_SWAP_4_BYTES(sitem);
8622    }
8623    else {
8624      sint= *(const GLint *)sitem;
8625    }
8626
8627    assert(sint <= 0x7fffffff);
8628
8629    return (GLdouble)sint;
8630 } /* extractSint() */
8631
8632 static void shoveSint(GLdouble value, int index, void *data)
8633 {
8634    assert(0.0 <= value && value <= (GLdouble) INT_MAX);
8635
8636    ((GLint *)data)[index]= (GLint)value;
8637 } /* shoveSint() */
8638
8639 static GLdouble extractFloat(int isSwap, const void *item)
8640 {
8641    GLfloat ffloat;
8642
8643    if (isSwap) {
8644      ffloat= __GLU_SWAP_4_BYTES(item);
8645    }
8646    else {
8647      ffloat= *(const GLfloat *)item;
8648    }
8649
8650    assert(ffloat <= 1.0);
8651
8652    return (GLdouble)ffloat;
8653 } /* extractFloat() */
8654
8655 static void shoveFloat(GLdouble value, int index, void *data)
8656 {
8657    assert(0.0 <= value && value <= 1.0);
8658
8659    ((GLfloat *)data)[index]= value;
8660 } /* shoveFloat() */
8661
8662 static void halveImageSlice(int components,
8663                             GLdouble (*extract)(int, const void *),
8664                             void (*shove)(GLdouble, int, void *),
8665                             GLint width, GLint height, GLint depth,
8666                             const void *dataIn, void *dataOut,
8667                             GLint elementSizeInBytes,
8668                             GLint groupSizeInBytes,
8669                             GLint rowSizeInBytes,
8670                             GLint imageSizeInBytes,
8671                             GLint isSwap)
8672 {
8673    int ii, jj;
8674    int halfWidth= width / 2;
8675    int halfHeight= height / 2;
8676    int halfDepth= depth / 2;
8677    const char *src= (const char *)dataIn;
8678    int rowPadBytes= rowSizeInBytes - (width * groupSizeInBytes);
8679    int imagePadBytes= imageSizeInBytes - (width*height*groupSizeInBytes);
8680    int outIndex= 0;
8681
8682    assert((width == 1 || height == 1) && depth >= 2);
8683
8684    if (width == height) {       /* a 1-pixel column viewed from top */
8685       /* printf("1-column\n");*/
8686       assert(width == 1 && height == 1);
8687       assert(depth >= 2);
8688
8689       for (ii= 0; ii< halfDepth; ii++) {
8690          int cc;
8691
8692          for (cc = 0; cc < components; cc++) {
8693             double totals[4];
8694             double extractTotals[BOX2][4];
8695             int kk;
8696
8697             extractTotals[0][cc]= (*extract)(isSwap,src);
8698             extractTotals[1][cc]= (*extract)(isSwap,(src+imageSizeInBytes));
8699
8700             /* average 2 pixels since only a column */
8701             totals[cc]= 0.0;
8702             /* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED];
8703              * totals[RED]/= 2.0;
8704              */
8705             for (kk = 0; kk < BOX2; kk++) {
8706               totals[cc]+= extractTotals[kk][cc];
8707             }
8708             totals[cc]/= (double)BOX2;
8709
8710             (*shove)(totals[cc],outIndex,dataOut);
8711             outIndex++;
8712             src+= elementSizeInBytes;
8713          } /* for cc */
8714
8715          /* skip over to next group of 2 */
8716          src+= rowSizeInBytes;
8717       } /* for ii */
8718
8719       assert(src == &((const char *)dataIn)[rowSizeInBytes*height*depth]);
8720       assert(outIndex == halfDepth * components);
8721    }
8722    else if (height == 1) {      /* horizontal slice viewed from top */
8723       /* printf("horizontal slice\n"); */
8724       assert(width != 1);
8725
8726       for (ii= 0; ii< halfDepth; ii++) {
8727          for (jj= 0; jj< halfWidth; jj++) {
8728             int cc;
8729
8730             for (cc = 0; cc < components; cc++) {
8731                int kk;
8732                double totals[4];
8733                double extractTotals[BOX4][4];
8734
8735                extractTotals[0][cc]=(*extract)(isSwap,src);
8736                extractTotals[1][cc]=(*extract)(isSwap,
8737                                                (src+groupSizeInBytes));
8738                extractTotals[2][cc]=(*extract)(isSwap,
8739                                                (src+imageSizeInBytes));
8740                extractTotals[3][cc]=(*extract)(isSwap,
8741                                                (src+imageSizeInBytes+groupSizeInBytes));
8742
8743                /* grab 4 pixels to average */
8744                totals[cc]= 0.0;
8745                /* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED]+
8746                 *              extractTotals[2][RED]+extractTotals[3][RED];
8747                 * totals[RED]/= 4.0;
8748                 */
8749                for (kk = 0; kk < BOX4; kk++) {
8750                   totals[cc]+= extractTotals[kk][cc];
8751                }
8752                totals[cc]/= (double)BOX4;
8753
8754                (*shove)(totals[cc],outIndex,dataOut);
8755                outIndex++;
8756
8757                src+= elementSizeInBytes;
8758             } /* for cc */
8759
8760             /* skip over to next horizontal square of 4 */
8761             src+= groupSizeInBytes;
8762          } /* for jj */
8763          src+= rowPadBytes;
8764
8765          src+= rowSizeInBytes;
8766       } /* for ii */
8767
8768       assert(src == &((const char *)dataIn)[rowSizeInBytes*height*depth]);
8769       assert(outIndex == halfWidth * halfDepth * components);
8770    }
8771    else if (width == 1) {       /* vertical slice viewed from top */
8772       /* printf("vertical slice\n"); */
8773       assert(height != 1);
8774
8775       for (ii= 0; ii< halfDepth; ii++) {
8776          for (jj= 0; jj< halfHeight; jj++) {
8777             int cc;
8778
8779             for (cc = 0; cc < components; cc++) {
8780                int kk;
8781                double totals[4];
8782                double extractTotals[BOX4][4];
8783
8784                extractTotals[0][cc]=(*extract)(isSwap,src);
8785                extractTotals[1][cc]=(*extract)(isSwap,
8786                                                (src+rowSizeInBytes));
8787                extractTotals[2][cc]=(*extract)(isSwap,
8788                                                (src+imageSizeInBytes));
8789                extractTotals[3][cc]=(*extract)(isSwap,
8790                                                (src+imageSizeInBytes+rowSizeInBytes));
8791
8792                /* grab 4 pixels to average */
8793                totals[cc]= 0.0;
8794                /* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED]+
8795                 *              extractTotals[2][RED]+extractTotals[3][RED];
8796                 * totals[RED]/= 4.0;
8797                 */
8798                for (kk = 0; kk < BOX4; kk++) {
8799                   totals[cc]+= extractTotals[kk][cc];
8800                }
8801                totals[cc]/= (double)BOX4;
8802
8803                (*shove)(totals[cc],outIndex,dataOut);
8804                outIndex++;
8805
8806                src+= elementSizeInBytes;
8807             } /* for cc */
8808             src+= rowPadBytes;
8809
8810             /* skip over to next vertical square of 4 */
8811             src+= rowSizeInBytes;
8812          } /* for jj */
8813          src+= imagePadBytes;
8814
8815          src+= imageSizeInBytes;
8816       } /* for ii */
8817
8818       assert(src == &((const char *)dataIn)[rowSizeInBytes*height*depth]);
8819       assert(outIndex == halfHeight * halfDepth * components);
8820    }
8821
8822 } /* halveImageSlice() */
8823
8824 static void halveImage3D(int components,
8825                          GLdouble (*extract)(int, const void *),
8826                          void (*shove)(GLdouble, int, void *),
8827                          GLint width, GLint height, GLint depth,
8828                          const void *dataIn, void *dataOut,
8829                          GLint elementSizeInBytes,
8830                          GLint groupSizeInBytes,
8831                          GLint rowSizeInBytes,
8832                          GLint imageSizeInBytes,
8833                          GLint isSwap)
8834 {
8835    assert(depth > 1);
8836
8837    /* a horizontal/vertical/one-column slice viewed from top */
8838    if (width == 1 || height == 1) {
8839       assert(1 <= depth);
8840
8841       halveImageSlice(components,extract,shove, width, height, depth,
8842                       dataIn, dataOut, elementSizeInBytes, groupSizeInBytes,
8843                       rowSizeInBytes, imageSizeInBytes, isSwap);
8844       return;
8845    }
8846    {
8847       int ii, jj, dd;
8848
8849       int halfWidth= width / 2;
8850       int halfHeight= height / 2;
8851       int halfDepth= depth / 2;
8852       const char *src= (const char *) dataIn;
8853       int rowPadBytes= rowSizeInBytes - (width*groupSizeInBytes);
8854       int imagePadBytes= imageSizeInBytes - (width*height*groupSizeInBytes);
8855       int outIndex= 0;
8856
8857       for (dd= 0; dd < halfDepth; dd++) {
8858          for (ii= 0; ii< halfHeight; ii++) {
8859             for (jj= 0; jj< halfWidth; jj++) {
8860                int cc;
8861
8862                for (cc= 0; cc < components; cc++) {
8863                   int kk;
8864 #define BOX8 8
8865                   double totals[4];     /* 4 is maximum components */
8866                   double extractTotals[BOX8][4]; /* 4 is maximum components */
8867
8868                   extractTotals[0][cc]= (*extract)(isSwap,src);
8869                   extractTotals[1][cc]= (*extract)(isSwap,
8870                                                    (src+groupSizeInBytes));
8871                   extractTotals[2][cc]= (*extract)(isSwap,
8872                                                    (src+rowSizeInBytes));
8873                   extractTotals[3][cc]= (*extract)(isSwap,
8874                                                    (src+rowSizeInBytes+groupSizeInBytes));
8875
8876                   extractTotals[4][cc]= (*extract)(isSwap,
8877                                                    (src+imageSizeInBytes));
8878
8879                   extractTotals[5][cc]= (*extract)(isSwap,
8880                                                    (src+groupSizeInBytes+imageSizeInBytes));
8881                   extractTotals[6][cc]= (*extract)(isSwap,
8882                                                    (src+rowSizeInBytes+imageSizeInBytes));
8883                   extractTotals[7][cc]= (*extract)(isSwap,
8884                                                    (src+rowSizeInBytes+groupSizeInBytes+imageSizeInBytes));
8885
8886                   totals[cc]= 0.0;
8887
8888                   /* totals[RED]= extractTotals[0][RED]+extractTotals[1][RED]+
8889                    *              extractTotals[2][RED]+extractTotals[3][RED]+
8890                    *              extractTotals[4][RED]+extractTotals[5][RED]+
8891                    *              extractTotals[6][RED]+extractTotals[7][RED];
8892                    * totals[RED]/= 8.0;
8893                    */
8894                   for (kk = 0; kk < BOX8; kk++) {
8895                      totals[cc]+= extractTotals[kk][cc];
8896                   }
8897                   totals[cc]/= (double)BOX8;
8898
8899                   (*shove)(totals[cc],outIndex,dataOut);
8900
8901                   outIndex++;
8902
8903                   src+= elementSizeInBytes; /* go to next component */
8904                } /* for cc */
8905
8906                /* skip over to next square of 4 */
8907                src+= groupSizeInBytes;
8908             } /* for jj */
8909             /* skip past pad bytes, if any, to get to next row */
8910             src+= rowPadBytes;
8911
8912             /* src is at beginning of a row here, but it's the second row of
8913              * the square block of 4 pixels that we just worked on so we
8914              * need to go one more row.
8915              * i.e.,
8916              *                   OO...
8917              *           here -->OO...
8918              *       but want -->OO...
8919              *                   OO...
8920              *                   ...
8921              */
8922             src+= rowSizeInBytes;
8923          } /* for ii */
8924
8925          /* skip past pad bytes, if any, to get to next image */
8926          src+= imagePadBytes;
8927
8928          src+= imageSizeInBytes;
8929       } /* for dd */
8930
8931       /* both pointers must reach one byte after the end */
8932       assert(src == &((const char *)dataIn)[rowSizeInBytes*height*depth]);
8933       assert(outIndex == halfWidth * halfHeight * halfDepth * components);
8934    }
8935 } /* halveImage3D() */
8936
8937
8938
8939 /*** mipmap.c ***/
8940