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
  40 typedef union {
  41     unsigned char ub[4];
  42     unsigned short us[2];
  43     unsigned int ui;
  44     char b[4];
  45     short s[2];
  46     int i;
  47     float f;
  48 } Type_Widget;
  49
  50 /* Pixel storage modes */
  51 typedef struct {
  52    GLint pack_alignment;
  53    GLint pack_row_length;
  54    GLint pack_skip_rows;
  55    GLint pack_skip_pixels;
  56    GLint pack_lsb_first;
  57    GLint pack_swap_bytes;
  58    GLint pack_skip_images;
  59    GLint pack_image_height;
  60
  61    GLint unpack_alignment;
  62    GLint unpack_row_length;
  63    GLint unpack_skip_rows;
  64    GLint unpack_skip_pixels;
  65    GLint unpack_lsb_first;
  66    GLint unpack_swap_bytes;
  67    GLint unpack_skip_images;
  68    GLint unpack_image_height;
  69 } PixelStorageModes;
  70
  71 static int gluBuild1DMipmapLevelsCore(GLenum, GLint,
  72                                       GLsizei,
  73                                       GLsizei,
  74                                       GLenum, GLenum, GLint, GLint, GLint,
  75                                       const void *);
  76 static int gluBuild2DMipmapLevelsCore(GLenum, GLint,
  77                                       GLsizei, GLsizei,
  78                                       GLsizei, GLsizei,
  79                                       GLenum, GLenum, GLint, GLint, GLint,
  80                                       const void *);
  81 static int gluBuild3DMipmapLevelsCore(GLenum, GLint,
  82                                       GLsizei, GLsizei, GLsizei,
  83                                       GLsizei, GLsizei, GLsizei,
  84                                       GLenum, GLenum, GLint, GLint, GLint,
  85                                       const void *);
  86
  87 /*
  88  * internal function declarations
  89  */
  90 static GLfloat bytes_per_element(GLenum type);
  91 static GLint elements_per_group(GLenum format, GLenum type);
  92 static GLint is_index(GLenum format);
  93 static GLint image_size(GLint width, GLint height, GLenum format, GLenum type);
  94 static void fill_image(const PixelStorageModes *,
  95                        GLint width, GLint height, GLenum format,
  96                        GLenum type, GLboolean index_format,
  97                        const void *userdata, GLushort *newimage);
  98 static void empty_image(const PixelStorageModes *,
  99                         GLint width, GLint height, GLenum format,
 100                         GLenum type, GLboolean index_format,
 101                         const GLushort *oldimage, void *userdata);
 102 static void scale_internal(GLint components, GLint widthin, GLint heightin,
 103                            const GLushort *datain,
 104                            GLint widthout, GLint heightout,
 105                            GLushort *dataout);
 106
 107 static void scale_internal_ubyte(GLint components, GLint widthin,
 108                            GLint heightin, const GLubyte *datain,
 109                            GLint widthout, GLint heightout,
 110                            GLubyte *dataout, GLint element_size,
 111                            GLint ysize, GLint group_size);
 112 static void scale_internal_byte(GLint components, GLint widthin,
 113                            GLint heightin, const GLbyte *datain,
 114                            GLint widthout, GLint heightout,
 115                            GLbyte *dataout, GLint element_size,
 116                            GLint ysize, GLint group_size);
 117 static void scale_internal_ushort(GLint components, GLint widthin,
 118                            GLint heightin, const GLushort *datain,
 119                            GLint widthout, GLint heightout,
 120                            GLushort *dataout, GLint element_size,
 121                            GLint ysize, GLint group_size,
 122                            GLint myswap_bytes);
 123 static void scale_internal_short(GLint components, GLint widthin,
 124                            GLint heightin, const GLshort *datain,
 125                            GLint widthout, GLint heightout,
 126                            GLshort *dataout, GLint element_size,
 127                            GLint ysize, GLint group_size,
 128                            GLint myswap_bytes);
 129 static void scale_internal_uint(GLint components, GLint widthin,
 130                            GLint heightin, const GLuint *datain,
 131                            GLint widthout, GLint heightout,
 132                            GLuint *dataout, GLint element_size,
 133                            GLint ysize, GLint group_size,
 134                            GLint myswap_bytes);
 135 static void scale_internal_int(GLint components, GLint widthin,
 136                            GLint heightin, const GLint *datain,
 137                            GLint widthout, GLint heightout,
 138                            GLint *dataout, GLint element_size,
 139                            GLint ysize, GLint group_size,
 140                            GLint myswap_bytes);
 141 static void scale_internal_float(GLint components, GLint widthin,
 142                            GLint heightin, const GLfloat *datain,
 143                            GLint widthout, GLint heightout,
 144                            GLfloat *dataout, GLint element_size,
 145                            GLint ysize, GLint group_size,
 146                            GLint myswap_bytes);
 147
 148 static int checkMipmapArgs(GLenum, GLenum, GLenum);
 149 static GLboolean legalFormat(GLenum);
 150 static GLboolean legalType(GLenum);
 151 static GLboolean isTypePackedPixel(GLenum);
 152 static GLboolean isLegalFormatForPackedPixelType(GLenum, GLenum);
 153 static GLboolean isLegalLevels(GLint, GLint, GLint, GLint);
 154 static void closestFit(GLenum, GLint, GLint, GLint, GLenum, GLenum,
 155                        GLint *, GLint *);
 156
 157 /* all extract/shove routines must return double to handle unsigned ints */
 158 static GLdouble extractUbyte(int, const void *);
 159 static void shoveUbyte(GLdouble, int, void *);
 160 static GLdouble extractSbyte(int, const void *);
 161 static void shoveSbyte(GLdouble, int, void *);
 162 static GLdouble extractUshort(int, const void *);
 163 static void shoveUshort(GLdouble, int, void *);
 164 static GLdouble extractSshort(int, const void *);
 165 static void shoveSshort(GLdouble, int, void *);
 166 static GLdouble extractUint(int, const void *);
 167 static void shoveUint(GLdouble, int, void *);
 168 static GLdouble extractSint(int, const void *);
 169 static void shoveSint(GLdouble, int, void *);
 170 static GLdouble extractFloat(int, const void *);
 171 static void shoveFloat(GLdouble, int, void *);
 172 static void halveImageSlice(int, GLdouble (*)(int, const void *),
 173                             void (*)(GLdouble, int, void *),
 174                             GLint, GLint, GLint,
 175                             const void *, void *,
 176                             GLint, GLint, GLint, GLint, GLint);
 177 static void halveImage3D(int, GLdouble (*)(int, const void *),
 178                          void (*)(GLdouble, int, void *),
 179                          GLint, GLint, GLint,
 180                          const void *, void *,
 181                          GLint, GLint, GLint, GLint, GLint);
 182
 183 /* packedpixel type scale routines */
 184 static void extract332(int,const void *, GLfloat []);
 185 static void shove332(const GLfloat [],int ,void *);
 186 static void extract233rev(int,const void *, GLfloat []);
 187 static void shove233rev(const GLfloat [],int ,void *);
 188 static void extract565(int,const void *, GLfloat []);
 189 static void shove565(const GLfloat [],int ,void *);
 190 static void extract565rev(int,const void *, GLfloat []);
 191 static void shove565rev(const GLfloat [],int ,void *);
 192 static void extract4444(int,const void *, GLfloat []);
 193 static void shove4444(const GLfloat [],int ,void *);
 194 static void extract4444rev(int,const void *, GLfloat []);
 195 static void shove4444rev(const GLfloat [],int ,void *);
 196 static void extract5551(int,const void *, GLfloat []);
 197 static void shove5551(const GLfloat [],int ,void *);
 198 static void extract1555rev(int,const void *, GLfloat []);
 199 static void shove1555rev(const GLfloat [],int ,void *);
 200 static void extract8888(int,const void *, GLfloat []);
 201 static void shove8888(const GLfloat [],int ,void *);
 202 static void extract8888rev(int,const void *, GLfloat []);
 203 static void shove8888rev(const GLfloat [],int ,void *);
 204 static void extract1010102(int,const void *, GLfloat []);
 205 static void shove1010102(const GLfloat [],int ,void *);
 206 static void extract2101010rev(int,const void *, GLfloat []);
 207 static void shove2101010rev(const GLfloat [],int ,void *);
 208 static void scaleInternalPackedPixel(int,
 209                                      void (*)(int, const void *,GLfloat []),
 210                                      void (*)(const GLfloat [],int, void *),
 211                                      GLint,GLint, const void *,
 212                                      GLint,GLint,void *,GLint,GLint,GLint);
 213 static void halveImagePackedPixel(int,
 214                                   void (*)(int, const void *,GLfloat []),
 215                                   void (*)(const GLfloat [],int, void *),
 216                                   GLint, GLint, const void *,
 217                                   void *, GLint, GLint, GLint);
 218 static void halve1DimagePackedPixel(int,
 219                                     void (*)(int, const void *,GLfloat []),
 220                                     void (*)(const GLfloat [],int, void *),
 221                                     GLint, GLint, const void *,
 222                                     void *, GLint, GLint, GLint);
 223
 224 static void halve1Dimage_ubyte(GLint, GLuint, GLuint,const GLubyte *,
 225                                GLubyte *, GLint, GLint, GLint);
 226 static void halve1Dimage_byte(GLint, GLuint, GLuint,const GLbyte *, GLbyte *,
 227                               GLint, GLint, GLint);
 228 static void halve1Dimage_ushort(GLint, GLuint, GLuint, const GLushort *,
 229                                 GLushort *, GLint, GLint, GLint, GLint);
 230 static void halve1Dimage_short(GLint, GLuint, GLuint,const GLshort *, GLshort *,
 231                                GLint, GLint, GLint, GLint);
 232 static void halve1Dimage_uint(GLint, GLuint, GLuint, const GLuint *, GLuint *,
 233                               GLint, GLint, GLint, GLint);
 234 static void halve1Dimage_int(GLint, GLuint, GLuint, const GLint *, GLint *,
 235                              GLint, GLint, GLint, GLint);
 236 static void halve1Dimage_float(GLint, GLuint, GLuint, const GLfloat *, GLfloat *,
 237                                GLint, GLint, GLint, GLint);
 238
 239 static GLint imageSize3D(GLint, GLint, GLint, GLenum,GLenum);
 240 static void fillImage3D(const PixelStorageModes *, GLint, GLint, GLint,GLenum,
 241                         GLenum, GLboolean, const void *, GLushort *);
 242 static void emptyImage3D(const PixelStorageModes *,
 243                          GLint, GLint, GLint, GLenum,
 244                          GLenum, GLboolean,
 245                          const GLushort *, void *);
 246 static void scaleInternal3D(GLint, GLint, GLint, GLint, const GLushort *,
 247                             GLint, GLint, GLint, GLushort *);
 248
 249 static void retrieveStoreModes(PixelStorageModes *psm)
 250 {
 251     glGetIntegerv(GL_UNPACK_ALIGNMENT, &psm->unpack_alignment);
 252     glGetIntegerv(GL_UNPACK_ROW_LENGTH, &psm->unpack_row_length);
 253     glGetIntegerv(GL_UNPACK_SKIP_ROWS, &psm->unpack_skip_rows);
 254     glGetIntegerv(GL_UNPACK_SKIP_PIXELS, &psm->unpack_skip_pixels);
 255     glGetIntegerv(GL_UNPACK_LSB_FIRST, &psm->unpack_lsb_first);
 256     glGetIntegerv(GL_UNPACK_SWAP_BYTES, &psm->unpack_swap_bytes);
 257
 258     glGetIntegerv(GL_PACK_ALIGNMENT, &psm->pack_alignment);
 259     glGetIntegerv(GL_PACK_ROW_LENGTH, &psm->pack_row_length);
 260     glGetIntegerv(GL_PACK_SKIP_ROWS, &psm->pack_skip_rows);
 261     glGetIntegerv(GL_PACK_SKIP_PIXELS, &psm->pack_skip_pixels);
 262     glGetIntegerv(GL_PACK_LSB_FIRST, &psm->pack_lsb_first);
 263     glGetIntegerv(GL_PACK_SWAP_BYTES, &psm->pack_swap_bytes);
 264 }
 265
 266 static void retrieveStoreModes3D(PixelStorageModes *psm)
 267 {
 268     glGetIntegerv(GL_UNPACK_ALIGNMENT, &psm->unpack_alignment);
 269     glGetIntegerv(GL_UNPACK_ROW_LENGTH, &psm->unpack_row_length);
 270     glGetIntegerv(GL_UNPACK_SKIP_ROWS, &psm->unpack_skip_rows);
 271     glGetIntegerv(GL_UNPACK_SKIP_PIXELS, &psm->unpack_skip_pixels);
 272     glGetIntegerv(GL_UNPACK_LSB_FIRST, &psm->unpack_lsb_first);
 273     glGetIntegerv(GL_UNPACK_SWAP_BYTES, &psm->unpack_swap_bytes);
 274     glGetIntegerv(GL_UNPACK_SKIP_IMAGES, &psm->unpack_skip_images);
 275     glGetIntegerv(GL_UNPACK_IMAGE_HEIGHT, &psm->unpack_image_height);
 276
 277     glGetIntegerv(GL_PACK_ALIGNMENT, &psm->pack_alignment);
 278     glGetIntegerv(GL_PACK_ROW_LENGTH, &psm->pack_row_length);
 279     glGetIntegerv(GL_PACK_SKIP_ROWS, &psm->pack_skip_rows);
 280     glGetIntegerv(GL_PACK_SKIP_PIXELS, &psm->pack_skip_pixels);
 281     glGetIntegerv(GL_PACK_LSB_FIRST, &psm->pack_lsb_first);
 282     glGetIntegerv(GL_PACK_SWAP_BYTES, &psm->pack_swap_bytes);
 283     glGetIntegerv(GL_PACK_SKIP_IMAGES, &psm->pack_skip_images);
 284     glGetIntegerv(GL_PACK_IMAGE_HEIGHT, &psm->pack_image_height);
 285 }
 286
 287 static int computeLog(GLuint value)
 288 {
 289     int i;
 290
 291     i = 0;
 292
 293     /* Error! */
 294     if (value == 0) return -1;
 295
 296     for (;;) {
 297         if (value & 1) {
 298             /* Error ! */
 299             if (value != 1) return -1;
 300             return i;
 301         }
 302         value = value >> 1;
 303         i++;
 304     }
 305 }
 306
 307 /*
 308 ** Compute the nearest power of 2 number.  This algorithm is a little
 309 ** strange, but it works quite well.
 310 */
 311 static int nearestPower(GLuint value)
 312 {
 313     int i;
 314
 315     i = 1;
 316
 317     /* Error! */
 318     if (value == 0) return -1;
 319
 320     for (;;) {
 321         if (value == 1) {
 322             return i;
 323         } else if (value == 3) {
 324             return i*4;
 325         }
 326         value = value >> 1;
 327         i *= 2;
 328     }
 329 }
 330
 331 #define __GLU_SWAP_2_BYTES(s)\
 332 (GLushort)(((GLushort)((const GLubyte*)(s))[1])<<8 | ((const GLubyte*)(s))[0])
 333
 334 #define __GLU_SWAP_4_BYTES(s)\
 335 (GLuint)(((GLuint)((const GLubyte*)(s))[3])<<24 | \
 336         ((GLuint)((const GLubyte*)(s))[2])<<16 | \
 337         ((GLuint)((const GLubyte*)(s))[1])<<8  | ((const GLubyte*)(s))[0])
 338
 339 static void halveImage(GLint components, GLuint width, GLuint height,
 340                        const GLushort *datain, GLushort *dataout)
 341 {
 342     int i, j, k;
 343     int newwidth, newheight;
 344     int delta;
 345     GLushort *s;
 346     const GLushort *t;
 347
 348     newwidth = width / 2;
 349     newheight = height / 2;
 350     delta = width * components;
 351     s = dataout;
 352     t = datain;
 353
 354     /* Piece o' cake! */
 355     for (i = 0; i < newheight; i++) {
 356         for (j = 0; j < newwidth; j++) {
 357             for (k = 0; k < components; k++) {
 358                 s[0] = (t[0] + t[components] + t[delta] +
 359                         t[delta+components] + 2) / 4;
 360                 s++; t++;
 361             }
 362             t += components;
 363         }
 364         t += delta;
 365     }
 366 }
 367
 368 static void halveImage_ubyte(GLint components, GLuint width, GLuint height,
 369                         const GLubyte *datain, GLubyte *dataout,
 370                         GLint element_size, GLint ysize, GLint group_size)
 371 {
 372     int i, j, k;
 373     int newwidth, newheight;
 374     int padBytes;
 375     GLubyte *s;
 376     const char *t;
 377
 378     /* handle case where there is only 1 column/row */
 379     if (width == 1 || height == 1) {
 380        assert( !(width == 1 && height == 1) ); /* can't be 1x1 */
 381        halve1Dimage_ubyte(components,width,height,datain,dataout,
 382                           element_size,ysize,group_size);
 383        return;
 384     }
 385
 386     newwidth = width / 2;
 387     newheight = height / 2;
 388     padBytes = ysize - (width*group_size);
 389     s = dataout;
 390     t = (const char *)datain;
 391
 392     /* Piece o' cake! */
 393     for (i = 0; i < newheight; i++) {
 394         for (j = 0; j < newwidth; j++) {
 395             for (k = 0; k < components; k++) {
 396                 s[0] = (*(const GLubyte*)t +
 397                         *(const GLubyte*)(t+group_size) +
 398                         *(const GLubyte*)(t+ysize) +
 399                         *(const GLubyte*)(t+ysize+group_size) + 2) / 4;
 400                 s++; t += element_size;
 401             }
 402             t += group_size;
 403         }
 404         t += padBytes;
 405         t += ysize;
 406     }
 407 }
 408
 409 /* */
 410 static void halve1Dimage_ubyte(GLint components, GLuint width, GLuint height,
 411                                const GLubyte *dataIn, GLubyte *dataOut,
 412                                GLint element_size, GLint ysize,
 413                                GLint group_size)
 414 {
 415    GLint halfWidth= width / 2;
 416    GLint halfHeight= height / 2;
 417    const char *src= (const char *) dataIn;
 418    GLubyte *dest= dataOut;
 419    int jj;
 420
 421    assert(width == 1 || height == 1); /* must be 1D */
 422    assert(width != height);     /* can't be square */
 423
 424    if (height == 1) {           /* 1 row */
 425       assert(width != 1);       /* widthxheight can't be 1x1 */
 426       halfHeight= 1;
 427
 428       for (jj= 0; jj< halfWidth; jj++) {
 429          int kk;
 430          for (kk= 0; kk< components; kk++) {
 431             *dest= (*(const GLubyte*)src +
 432                  *(const GLubyte*)(src+group_size)) / 2;
 433
 434             src+= element_size;
 435             dest++;
 436          }
 437          src+= group_size;      /* skip to next 2 */
 438       }
 439       {
 440          int padBytes= ysize - (width*group_size);
 441          src+= padBytes;        /* for assertion only */
 442       }
 443    }
 444    else if (width == 1) {       /* 1 column */
 445       int padBytes= ysize - (width * group_size);
 446       assert(height != 1);      /* widthxheight can't be 1x1 */
 447       halfWidth= 1;
 448       /* one vertical column with possible pad bytes per row */
 449       /* average two at a time */
 450
 451       for (jj= 0; jj< halfHeight; jj++) {
 452          int kk;
 453          for (kk= 0; kk< components; kk++) {
 454             *dest= (*(const GLubyte*)src + *(const GLubyte*)(src+ysize)) / 2;
 455
 456             src+= element_size;
 457             dest++;
 458          }
 459          src+= padBytes; /* add pad bytes, if any, to get to end to row */
 460          src+= ysize;
 461       }
 462    }
 463
 464    assert(src == &((const char *)dataIn)[ysize*height]);
 465    assert((char *)dest == &((char *)dataOut)
 466           [components * element_size * halfWidth * halfHeight]);
 467 } /* halve1Dimage_ubyte() */
 468
 469 static void halveImage_byte(GLint components, GLuint width, GLuint height,
 470                         const GLbyte *datain, GLbyte *dataout,
 471                         GLint element_size,
 472                         GLint ysize, GLint group_size)
 473 {
 474     int i, j, k;
 475     int newwidth, newheight;
 476     int padBytes;
 477     GLbyte *s;
 478     const char *t;
 479
 480     /* handle case where there is only 1 column/row */
 481     if (width == 1 || height == 1) {
 482        assert( !(width == 1 && height == 1) ); /* can't be 1x1 */
 483        halve1Dimage_byte(components,width,height,datain,dataout,
 484                          element_size,ysize,group_size);
 485        return;
 486     }
 487
 488     newwidth = width / 2;
 489     newheight = height / 2;
 490     padBytes = ysize - (width*group_size);
 491     s = dataout;
 492     t = (const char *)datain;
 493
 494     /* Piece o' cake! */
 495     for (i = 0; i < newheight; i++) {
 496         for (j = 0; j < newwidth; j++) {
 497             for (k = 0; k < components; k++) {
 498                 s[0] = (*(const GLbyte*)t +
 499                         *(const GLbyte*)(t+group_size) +
 500                         *(const GLbyte*)(t+ysize) +
 501                         *(const GLbyte*)(t+ysize+group_size) + 2) / 4;
 502                 s++; t += element_size;
 503             }
 504             t += group_size;
 505         }
 506         t += padBytes;
 507         t += ysize;
 508     }
 509 }
 510
 511 static void halve1Dimage_byte(GLint components, GLuint width, GLuint height,
 512                               const GLbyte *dataIn, GLbyte *dataOut,
 513                               GLint element_size,GLint ysize, GLint group_size)
 514 {
 515    GLint halfWidth= width / 2;
 516    GLint halfHeight= height / 2;
 517    const char *src= (const char *) dataIn;
 518    GLbyte *dest= dataOut;
 519    int jj;
 520
 521    assert(width == 1 || height == 1); /* must be 1D */
 522    assert(width != height);     /* can't be square */
 523
 524    if (height == 1) {           /* 1 row */
 525       assert(width != 1);       /* widthxheight can't be 1x1 */
 526       halfHeight= 1;
 527
 528       for (jj= 0; jj< halfWidth; jj++) {
 529          int kk;
 530          for (kk= 0; kk< components; kk++) {
 531             *dest= (*(const GLbyte*)src + *(const GLbyte*)(src+group_size)) / 2;
 532
 533             src+= element_size;
 534             dest++;
 535          }
 536          src+= group_size;      /* skip to next 2 */
 537       }
 538       {
 539          int padBytes= ysize - (width*group_size);
 540          src+= padBytes;        /* for assertion only */
 541       }
 542    }
 543    else if (width == 1) {       /* 1 column */
 544       int padBytes= ysize - (width * group_size);
 545       assert(height != 1);      /* widthxheight can't be 1x1 */
 546       halfWidth= 1;
 547       /* one vertical column with possible pad bytes per row */
 548       /* average two at a time */
 549
 550       for (jj= 0; jj< halfHeight; jj++) {
 551          int kk;
 552          for (kk= 0; kk< components; kk++) {
 553             *dest= (*(const GLbyte*)src + *(const GLbyte*)(src+ysize)) / 2;
 554
 555             src+= element_size;
 556             dest++;
 557          }
 558          src+= padBytes; /* add pad bytes, if any, to get to end to row */
 559          src+= ysize;
 560       }
 561
 562       assert(src == &((const char *)dataIn)[ysize*height]);
 563    }
 564
 565    assert((char *)dest == &((char *)dataOut)
 566           [components * element_size * halfWidth * halfHeight]);
 567 } /* halve1Dimage_byte() */
 568
 569 static void halveImage_ushort(GLint components, GLuint width, GLuint height,
 570                         const GLushort *datain, GLushort *dataout,
 571                         GLint element_size, GLint ysize, GLint group_size,
 572                         GLint myswap_bytes)
 573 {
 574     int i, j, k;
 575     int newwidth, newheight;
 576     int padBytes;
 577     GLushort *s;
 578     const char *t;
 579
 580     /* handle case where there is only 1 column/row */
 581     if (width == 1 || height == 1) {
 582        assert( !(width == 1 && height == 1) ); /* can't be 1x1 */
 583        halve1Dimage_ushort(components,width,height,datain,dataout,
 584                            element_size,ysize,group_size, myswap_bytes);
 585        return;
 586     }
 587
 588     newwidth = width / 2;
 589     newheight = height / 2;
 590     padBytes = ysize - (width*group_size);
 591     s = dataout;
 592     t = (const char *)datain;
 593
 594     /* Piece o' cake! */
 595     if (!myswap_bytes)
 596     for (i = 0; i < newheight; i++) {
 597         for (j = 0; j < newwidth; j++) {
 598             for (k = 0; k < components; k++) {
 599                 s[0] = (*(const GLushort*)t +
 600                         *(const GLushort*)(t+group_size) +
 601                         *(const GLushort*)(t+ysize) +
 602                         *(const GLushort*)(t+ysize+group_size) + 2) / 4;
 603                 s++; t += element_size;
 604             }
 605             t += group_size;
 606         }
 607         t += padBytes;
 608         t += ysize;
 609     }
 610     else
 611     for (i = 0; i < newheight; i++) {
 612         for (j = 0; j < newwidth; j++) {
 613             for (k = 0; k < components; k++) {
 614                 s[0] = (__GLU_SWAP_2_BYTES(t) +
 615                         __GLU_SWAP_2_BYTES(t+group_size) +
 616                         __GLU_SWAP_2_BYTES(t+ysize) +
 617                         __GLU_SWAP_2_BYTES(t+ysize+group_size)+ 2)/4;
 618                 s++; t += element_size;
 619             }
 620             t += group_size;
 621         }
 622         t += padBytes;
 623         t += ysize;
 624     }
 625 }
 626
 627 static void halve1Dimage_ushort(GLint components, GLuint width, GLuint height,
 628                                 const GLushort *dataIn, GLushort *dataOut,
 629                                 GLint element_size, GLint ysize,
 630                                 GLint group_size, GLint myswap_bytes)
 631 {
 632    GLint halfWidth= width / 2;
 633    GLint halfHeight= height / 2;
 634    const char *src= (const char *) dataIn;
 635    GLushort *dest= dataOut;
 636    int jj;
 637
 638    assert(width == 1 || height == 1); /* must be 1D */
 639    assert(width != height);     /* can't be square */
 640
 641    if (height == 1) {           /* 1 row */
 642       assert(width != 1);       /* widthxheight can't be 1x1 */
 643       halfHeight= 1;
 644
 645       for (jj= 0; jj< halfWidth; jj++) {
 646          int kk;
 647          for (kk= 0; kk< components; kk++) {
 648 #define BOX2 2
 649             GLushort ushort[BOX2];
 650             if (myswap_bytes) {
 651                ushort[0]= __GLU_SWAP_2_BYTES(src);
 652                ushort[1]= __GLU_SWAP_2_BYTES(src+group_size);
 653             }
 654             else {
 655                ushort[0]= *(const GLushort*)src;
 656                ushort[1]= *(const GLushort*)(src+group_size);
 657             }
 658
 659             *dest= (ushort[0] + ushort[1]) / 2;
 660             src+= element_size;
 661             dest++;
 662          }
 663          src+= group_size;      /* skip to next 2 */
 664       }
 665       {
 666          int padBytes= ysize - (width*group_size);
 667          src+= padBytes;        /* for assertion only */
 668       }
 669    }
 670    else if (width == 1) {       /* 1 column */
 671       int padBytes= ysize - (width * group_size);
 672       assert(height != 1);      /* widthxheight can't be 1x1 */
 673       halfWidth= 1;
 674       /* one vertical column with possible pad bytes per row */
 675       /* average two at a time */
 676
 677       for (jj= 0; jj< halfHeight; jj++) {
 678          int kk;
 679          for (kk= 0; kk< components; kk++) {
 680 #define BOX2 2
 681             GLushort ushort[BOX2];
 682             if (myswap_bytes) {
 683                ushort[0]= __GLU_SWAP_2_BYTES(src);
 684                ushort[1]= __GLU_SWAP_2_BYTES(src+ysize);
 685             }
 686             else {
 687                ushort[0]= *(const GLushort*)src;
 688                ushort[1]= *(const GLushort*)(src+ysize);
 689             }
 690             *dest= (ushort[0] + ushort[1]) / 2;
 691
 692             src+= element_size;
 693             dest++;
 694          }
 695          src+= padBytes; /* add pad bytes, if any, to get to end to row */
 696          src+= ysize;
 697       }
 698
 699       assert(src == &((const char *)dataIn)[ysize*height]);
 700    }
 701
 702    assert((char *)dest == &((char *)dataOut)
 703           [components * element_size * halfWidth * halfHeight]);
 704
 705 } /* halve1Dimage_ushort() */
 706
 707
 708 static void halveImage_short(GLint components, GLuint width, GLuint height,
 709                         const GLshort *datain, GLshort *dataout,
 710                         GLint element_size, GLint ysize, GLint group_size,
 711                         GLint myswap_bytes)
 712 {
 713     int i, j, k;
 714     int newwidth, newheight;
 715     int padBytes;
 716     GLshort *s;
 717     const char *t;
 718
 719     /* handle case where there is only 1 column/row */
 720     if (width == 1 || height == 1) {
 721        assert( !(width == 1 && height == 1) ); /* can't be 1x1 */
 722        halve1Dimage_short(components,width,height,datain,dataout,
 723                           element_size,ysize,group_size, myswap_bytes);
 724        return;
 725     }
 726
 727     newwidth = width / 2;
 728     newheight = height / 2;
 729     padBytes = ysize - (width*group_size);
 730     s = dataout;
 731     t = (const char *)datain;
 732
 733     /* Piece o' cake! */
 734     if (!myswap_bytes)
 735     for (i = 0; i < newheight; i++) {
 736         for (j = 0; j < newwidth; j++) {
 737             for (k = 0; k < components; k++) {
 738                 s[0] = (*(const GLshort*)t +
 739                         *(const GLshort*)(t+group_size) +
 740                         *(const GLshort*)(t+ysize) +
 741                         *(const GLshort*)(t+ysize+group_size) + 2) / 4;
 742                 s++; t += element_size;
 743             }
 744             t += group_size;
 745         }
 746         t += padBytes;
 747         t += ysize;
 748     }
 749     else
 750     for (i = 0; i < newheight; i++) {
 751         for (j = 0; j < newwidth; j++) {
 752             for (k = 0; k < components; k++) {
 753                 GLushort b;
 754                 GLint buf;
 755                 b = __GLU_SWAP_2_BYTES(t);
 756                 buf = *(const GLshort*)&b;
 757                 b = __GLU_SWAP_2_BYTES(t+group_size);
 758                 buf += *(const GLshort*)&b;
 759                 b = __GLU_SWAP_2_BYTES(t+ysize);
 760                 buf += *(const GLshort*)&b;
 761                 b = __GLU_SWAP_2_BYTES(t+ysize+group_size);
 762                 buf += *(const GLshort*)&b;
 763                 s[0] = (GLshort)((buf+2)/4);
 764                 s++; t += element_size;
 765             }
 766             t += group_size;
 767         }
 768         t += padBytes;
 769         t += ysize;
 770     }
 771 }
 772
 773 static void halve1Dimage_short(GLint components, GLuint width, GLuint height,
 774                                 const GLshort *dataIn, GLshort *dataOut,
 775                                 GLint element_size, GLint ysize,
 776                                 GLint group_size, GLint myswap_bytes)
 777 {
 778    GLint halfWidth= width / 2;
 779    GLint halfHeight= height / 2;
 780    const char *src= (const char *) dataIn;
 781    GLshort *dest= dataOut;
 782    int jj;
 783
 784    assert(width == 1 || height == 1); /* must be 1D */
 785    assert(width != height);     /* can't be square */
 786
 787    if (height == 1) {           /* 1 row */
 788       assert(width != 1);       /* widthxheight can't be 1x1 */
 789       halfHeight= 1;
 790
 791       for (jj= 0; jj< halfWidth; jj++) {
 792          int kk;
 793          for (kk= 0; kk< components; kk++) {
 794 #define BOX2 2
 795             GLshort sshort[BOX2];
 796             if (myswap_bytes) {
 797                sshort[0]= __GLU_SWAP_2_BYTES(src);
 798                sshort[1]= __GLU_SWAP_2_BYTES(src+group_size);
 799             }
 800             else {
 801                sshort[0]= *(const GLshort*)src;
 802                sshort[1]= *(const GLshort*)(src+group_size);
 803             }
 804
 805             *dest= (sshort[0] + sshort[1]) / 2;
 806             src+= element_size;
 807             dest++;
 808          }
 809          src+= group_size;      /* skip to next 2 */
 810       }
 811       {
 812          int padBytes= ysize - (width*group_size);
 813          src+= padBytes;        /* for assertion only */
 814       }
 815    }
 816    else if (width == 1) {       /* 1 column */
 817       int padBytes= ysize - (width * group_size);
 818       assert(height != 1);      /* widthxheight can't be 1x1 */
 819       halfWidth= 1;
 820       /* one vertical column with possible pad bytes per row */
 821       /* average two at a time */
 822
 823       for (jj= 0; jj< halfHeight; jj++) {
 824          int kk;
 825          for (kk= 0; kk< components; kk++) {
 826 #define BOX2 2
 827             GLshort sshort[BOX2];
 828             if (myswap_bytes) {
 829                sshort[0]= __GLU_SWAP_2_BYTES(src);
 830                sshort[1]= __GLU_SWAP_2_BYTES(src+ysize);
 831             }
 832             else {
 833                sshort[0]= *(const GLshort*)src;
 834                sshort[1]= *(const GLshort*)(src+ysize);
 835             }
 836             *dest= (sshort[0] + sshort[1]) / 2;
 837
 838             src+= element_size;
 839             dest++;
 840          }
 841          src+= padBytes; /* add pad bytes, if any, to get to end to row */
 842          src+= ysize;
 843       }
 844
 845       assert(src == &((const char *)dataIn)[ysize*height]);
 846    }
 847
 848    assert((char *)dest == &((char *)dataOut)
 849           [components * element_size * halfWidth * halfHeight]);
 850
 851 } /* halve1Dimage_short() */
 852
 853
 854 static void halveImage_uint(GLint components, GLuint width, GLuint height,
 855                         const GLuint *datain, GLuint *dataout,
 856                         GLint element_size, GLint ysize, GLint group_size,
 857                         GLint myswap_bytes)
 858 {
 859     int i, j, k;
 860     int newwidth, newheight;
 861     int padBytes;
 862     GLuint *s;
 863     const char *t;
 864
 865     /* handle case where there is only 1 column/row */
 866     if (width == 1 || height == 1) {
 867        assert( !(width == 1 && height == 1) ); /* can't be 1x1 */
 868        halve1Dimage_uint(components,width,height,datain,dataout,
 869                          element_size,ysize,group_size, myswap_bytes);
 870        return;
 871     }
 872
 873     newwidth = width / 2;
 874     newheight = height / 2;
 875     padBytes = ysize - (width*group_size);
 876     s = dataout;
 877     t = (const char *)datain;
 878
 879     /* Piece o' cake! */
 880     if (!myswap_bytes)
 881     for (i = 0; i < newheight; i++) {
 882         for (j = 0; j < newwidth; j++) {
 883             for (k = 0; k < components; k++) {
 884                 /* need to cast to double to hold large unsigned ints */
 885                 s[0] = ((double)*(const GLuint*)t +
 886                         (double)*(const GLuint*)(t+group_size) +
 887                         (double)*(const GLuint*)(t+ysize) +
 888                         (double)*(const GLuint*)(t+ysize+group_size))/4 + 0.5;
 889                 s++; t += element_size;
 890
 891             }
 892             t += group_size;
 893         }
 894         t += padBytes;
 895         t += ysize;
 896     }
 897     else
 898     for (i = 0; i < newheight; i++) {
 899         for (j = 0; j < newwidth; j++) {
 900             for (k = 0; k < components; k++) {
 901                 /* need to cast to double to hold large unsigned ints */
 902                 GLdouble buf;
 903                 buf = (GLdouble)__GLU_SWAP_4_BYTES(t) +
 904                       (GLdouble)__GLU_SWAP_4_BYTES(t+group_size) +
 905                       (GLdouble)__GLU_SWAP_4_BYTES(t+ysize) +
 906                       (GLdouble)__GLU_SWAP_4_BYTES(t+ysize+group_size);
 907                 s[0] = (GLuint)(buf/4 + 0.5);
 908
 909                 s++; t += element_size;
 910             }
 911             t += group_size;
 912         }
 913         t += padBytes;
 914         t += ysize;
 915     }
 916 }
 917
 918 /* */
 919 static void halve1Dimage_uint(GLint components, GLuint width, GLuint height,
 920                               const GLuint *dataIn, GLuint *dataOut,
 921                               GLint element_size, GLint ysize,
 922                               GLint group_size, GLint myswap_bytes)
 923 {
 924    GLint halfWidth= width / 2;
 925    GLint halfHeight= height / 2;
 926    const char *src= (const char *) dataIn;
 927    GLuint *dest= dataOut;
 928    int jj;
 929
 930    assert(width == 1 || height == 1); /* must be 1D */
 931    assert(width != height);     /* can't be square */
 932
 933    if (height == 1) {           /* 1 row */
 934       assert(width != 1);       /* widthxheight can't be 1x1 */
 935       halfHeight= 1;
 936
 937       for (jj= 0; jj< halfWidth; jj++) {
 938          int kk;
 939          for (kk= 0; kk< components; kk++) {
 940 #define BOX2 2
 941             GLuint uint[BOX2];
 942             if (myswap_bytes) {
 943                uint[0]= __GLU_SWAP_4_BYTES(src);
 944                uint[1]= __GLU_SWAP_4_BYTES(src+group_size);
 945             }
 946             else {
 947                uint[0]= *(const GLuint*)src;
 948                uint[1]= *(const GLuint*)(src+group_size);
 949             }
 950             *dest= ((double)uint[0]+(double)uint[1])/2.0;
 951
 952             src+= element_size;
 953             dest++;
 954          }
 955          src+= group_size;      /* skip to next 2 */
 956       }
 957       {
 958          int padBytes= ysize - (width*group_size);
 959          src+= padBytes;        /* for assertion only */
 960       }
 961    }
 962    else if (width == 1) {       /* 1 column */
 963       int padBytes= ysize - (width * group_size);
 964       assert(height != 1);      /* widthxheight can't be 1x1 */
 965       halfWidth= 1;
 966       /* one vertical column with possible pad bytes per row */
 967       /* average two at a time */
 968
 969       for (jj= 0; jj< halfHeight; jj++) {
 970          int kk;
 971          for (kk= 0; kk< components; kk++) {
 972 #define BOX2 2
 973             GLuint uint[BOX2];
 974             if (myswap_bytes) {
 975                uint[0]= __GLU_SWAP_4_BYTES(src);
 976                uint[1]= __GLU_SWAP_4_BYTES(src+ysize);
 977             }
 978             else {
 979                uint[0]= *(const GLuint*)src;
 980                uint[1]= *(const GLuint*)(src+ysize);
 981             }
 982             *dest= ((double)uint[0]+(double)uint[1])/2.0;
 983
 984             src+= element_size;
 985             dest++;
 986          }
 987          src+= padBytes; /* add pad bytes, if any, to get to end to row */
 988          src+= ysize;
 989       }
 990
 991       assert(src == &((const char *)dataIn)[ysize*height]);
 992    }
 993
 994    assert((char *)dest == &((char *)dataOut)
 995           [components * element_size * halfWidth * halfHeight]);
 996
 997 } /* halve1Dimage_uint() */
 998
 999 static void halveImage_int(GLint components, GLuint width, GLuint height,
1000                         const GLint *datain, GLint *dataout, GLint element_size,
1001                         GLint ysize, GLint group_size, GLint myswap_bytes)
1002 {
1003     int i, j, k;
1004     int newwidth, newheight;
1005     int padBytes;
1006     GLint *s;
1007     const char *t;
1008
1009     /* handle case where there is only 1 column/row */
1010     if (width == 1 || height == 1) {
1011        assert( !(width == 1 && height == 1) ); /* can't be 1x1 */
1012        halve1Dimage_int(components,width,height,datain,dataout,
1013                         element_size,ysize,group_size, myswap_bytes);
1014        return;
1015     }
1016
1017     newwidth = width / 2;
1018     newheight = height / 2;
1019     padBytes = ysize - (width*group_size);
1020     s = dataout;
1021     t = (const char *)datain;
1022
1023     /* Piece o' cake! */
1024     if (!myswap_bytes)
1025     for (i = 0; i < newheight; i++) {
1026         for (j = 0; j < newwidth; j++) {
1027             for (k = 0; k < components; k++) {
1028                 s[0] = ((float)*(const GLint*)t +
1029                         (float)*(const GLint*)(t+group_size) +
1030                         (float)*(const GLint*)(t+ysize) +
1031                         (float)*(const GLint*)(t+ysize+group_size))/4 + 0.5;
1032                 s++; t += element_size;
1033             }
1034             t += group_size;
1035         }
1036         t += padBytes;
1037         t += ysize;
1038     }
1039     else
1040     for (i = 0; i < newheight; i++) {
1041         for (j = 0; j < newwidth; j++) {
1042             for (k = 0; k < components; k++) {
1043                 GLuint b;
1044                 GLfloat buf;
1045                 b = __GLU_SWAP_4_BYTES(t);
1046                 buf = *(GLint*)&b;
1047                 b = __GLU_SWAP_4_BYTES(t+group_size);
1048                 buf += *(GLint*)&b;
1049                 b = __GLU_SWAP_4_BYTES(t+ysize);
1050                 buf += *(GLint*)&b;
1051                 b = __GLU_SWAP_4_BYTES(t+ysize+group_size);
1052                 buf += *(GLint*)&b;
1053                 s[0] = (GLint)(buf/4 + 0.5);
1054
1055                 s++; t += element_size;
1056             }
1057             t += group_size;
1058         }
1059         t += padBytes;
1060         t += ysize;
1061     }
1062 }
1063
1064 /* */
1065 static void halve1Dimage_int(GLint components, GLuint width, GLuint height,
1066                              const GLint *dataIn, GLint *dataOut,
1067                              GLint element_size, GLint ysize,
1068                              GLint group_size, GLint myswap_bytes)
1069 {
1070    GLint halfWidth= width / 2;
1071    GLint halfHeight= height / 2;
1072    const char *src= (const char *) dataIn;
1073    GLint *dest= dataOut;
1074    int jj;
1075
1076    assert(width == 1 || height == 1); /* must be 1D */
1077    assert(width != height);     /* can't be square */
1078
1079    if (height == 1) {           /* 1 row */
1080       assert(width != 1);       /* widthxheight can't be 1x1 */
1081       halfHeight= 1;
1082
1083       for (jj= 0; jj< halfWidth; jj++) {
1084          int kk;
1085          for (kk= 0; kk< components; kk++) {
1086 #define BOX2 2
1087             GLuint uint[BOX2];
1088             if (myswap_bytes) {
1089                uint[0]= __GLU_SWAP_4_BYTES(src);
1090                uint[1]= __GLU_SWAP_4_BYTES(src+group_size);
1091             }
1092             else {
1093                uint[0]= *(const GLuint*)src;
1094                uint[1]= *(const GLuint*)(src+group_size);
1095             }
1096             *dest= ((float)uint[0]+(float)uint[1])/2.0;
1097
1098             src+= element_size;
1099             dest++;
1100          }
1101          src+= group_size;      /* skip to next 2 */
1102       }
1103       {
1104          int padBytes= ysize - (width*group_size);
1105          src+= padBytes;        /* for assertion only */
1106       }
1107    }
1108    else if (width == 1) {       /* 1 column */
1109       int padBytes= ysize - (width * group_size);
1110       assert(height != 1);      /* widthxheight can't be 1x1 */
1111       halfWidth= 1;
1112       /* one vertical column with possible pad bytes per row */
1113       /* average two at a time */
1114
1115       for (jj= 0; jj< halfHeight; jj++) {
1116          int kk;
1117          for (kk= 0; kk< components; kk++) {
1118 #define BOX2 2
1119             GLuint uint[BOX2];
1120             if (myswap_bytes) {
1121                uint[0]= __GLU_SWAP_4_BYTES(src);
1122                uint[1]= __GLU_SWAP_4_BYTES(src+ysize);
1123             }
1124             else {
1125                uint[0]= *(const GLuint*)src;
1126                uint[1]= *(const GLuint*)(src+ysize);
1127             }
1128             *dest= ((float)uint[0]+(float)uint[1])/2.0;
1129
1130             src+= element_size;
1131             dest++;
1132          }
1133          src+= padBytes; /* add pad bytes, if any, to get to end to row */
1134          src+= ysize;
1135       }
1136
1137       assert(src == &((const char *)dataIn)[ysize*height]);
1138    }
1139
1140    assert((char *)dest == &((char *)dataOut)
1141           [components * element_size * halfWidth * halfHeight]);
1142
1143 } /* halve1Dimage_int() */
1144
1145
1146 static void halveImage_float(GLint components, GLuint width, GLuint height,
1147                         const GLfloat *datain, GLfloat *dataout,
1148                         GLint element_size, GLint ysize, GLint group_size,
1149                         GLint myswap_bytes)
1150 {
1151     int i, j, k;
1152     int newwidth, newheight;
1153     int padBytes;
1154     GLfloat *s;
1155     const char *t;
1156
1157     /* handle case where there is only 1 column/row */
1158     if (width == 1 || height == 1) {
1159        assert( !(width == 1 && height == 1) ); /* can't be 1x1 */
1160        halve1Dimage_float(components,width,height,datain,dataout,
1161                           element_size,ysize,group_size, myswap_bytes);
1162        return;
1163     }
1164
1165     newwidth = width / 2;
1166     newheight = height / 2;
1167     padBytes = ysize - (width*group_size);
1168     s = dataout;
1169     t = (const char *)datain;
1170
1171     /* Piece o' cake! */
1172     if (!myswap_bytes)
1173     for (i = 0; i < newheight; i++) {
1174         for (j = 0; j < newwidth; j++) {
1175             for (k = 0; k < components; k++) {
1176                 s[0] = (*(const GLfloat*)t +
1177                         *(const GLfloat*)(t+group_size) +
1178                         *(const GLfloat*)(t+ysize) +
1179                         *(const GLfloat*)(t+ysize+group_size)) / 4;
1180                 s++; t += element_size;
1181             }
1182             t += group_size;
1183         }
1184         t += padBytes;
1185         t += ysize;
1186     }
1187     else
1188     for (i = 0; i < newheight; i++) {
1189         for (j = 0; j < newwidth; j++) {
1190             for (k = 0; k < components; k++) {
1191                 union { GLuint b; GLfloat f; } swapbuf;
1192                 swapbuf.b = __GLU_SWAP_4_BYTES(t);
1193                 s[0] = swapbuf.f;
1194                 swapbuf.b = __GLU_SWAP_4_BYTES(t+group_size);
1195                 s[0] += swapbuf.f;
1196                 swapbuf.b = __GLU_SWAP_4_BYTES(t+ysize);
1197                 s[0] += swapbuf.f;
1198                 swapbuf.b = __GLU_SWAP_4_BYTES(t+ysize+group_size);
1199                 s[0] += swapbuf.f;
1200                 s[0] /= 4;
1201                 s++; t += element_size;
1202             }
1203             t += group_size;
1204         }
1205         t += padBytes;
1206         t += ysize;
1207     }
1208 }
1209
1210 /* */
1211 static void halve1Dimage_float(GLint components, GLuint width, GLuint height,
1212                                const GLfloat *dataIn, GLfloat *dataOut,
1213                                GLint element_size, GLint ysize,
1214                                GLint group_size, GLint myswap_bytes)
1215 {
1216    GLint halfWidth= width / 2;
1217    GLint halfHeight= height / 2;
1218    const char *src= (const char *) dataIn;
1219    GLfloat *dest= dataOut;
1220    int jj;
1221
1222    assert(width == 1 || height == 1); /* must be 1D */
1223    assert(width != height);     /* can't be square */
1224
1225    if (height == 1) {           /* 1 row */
1226       assert(width != 1);       /* widthxheight can't be 1x1 */
1227       halfHeight= 1;
1228
1229       for (jj= 0; jj< halfWidth; jj++) {
1230          int kk;
1231          for (kk= 0; kk< components; kk++) {
1232 #define BOX2 2
1233             GLfloat sfloat[BOX2];
1234             if (myswap_bytes) {
1235                sfloat[0]= __GLU_SWAP_4_BYTES(src);
1236                sfloat[1]= __GLU_SWAP_4_BYTES(src+group_size);
1237             }
1238             else {
1239                sfloat[0]= *(const GLfloat*)src;
1240                sfloat[1]= *(const GLfloat*)(src+group_size);
1241             }
1242
1243             *dest= (sfloat[0] + sfloat[1]) / 2.0;
1244             src+= element_size;
1245             dest++;
1246          }
1247          src+= group_size;      /* skip to next 2 */
1248       }
1249       {
1250          int padBytes= ysize - (width*group_size);
1251          src+= padBytes;        /* for assertion only */
1252       }
1253    }
1254    else if (width == 1) {       /* 1 column */
1255       int padBytes= ysize - (width * group_size);
1256       assert(height != 1);      /* widthxheight can't be 1x1 */
1257       halfWidth= 1;
1258       /* one vertical column with possible pad bytes per row */
1259       /* average two at a time */
1260
1261       for (jj= 0; jj< halfHeight; jj++) {
1262          int kk;
1263          for (kk= 0; kk< components; kk++) {
1264 #define BOX2 2
1265             GLfloat sfloat[BOX2];
1266             if (myswap_bytes) {
1267                sfloat[0]= __GLU_SWAP_4_BYTES(src);
1268                sfloat[1]= __GLU_SWAP_4_BYTES(src+ysize);
1269             }
1270             else {
1271                sfloat[0]= *(const GLfloat*)src;
1272                sfloat[1]= *(const GLfloat*)(src+ysize);
1273             }
1274             *dest= (sfloat[0] + sfloat[1]) / 2.0;
1275
1276             src+= element_size;
1277             dest++;
1278          }
1279          src+= padBytes; /* add pad bytes, if any, to get to end to row */
1280          src+= ysize;           /* skip to odd row */
1281       }
1282    }
1283
1284    assert(src == &((const char *)dataIn)[ysize*height]);
1285    assert((char *)dest == &((char *)dataOut)
1286           [components * element_size * halfWidth * halfHeight]);
1287 } /* halve1Dimage_float() */
1288
1289 static void scale_internal(GLint components, GLint widthin, GLint heightin,
1290                            const GLushort *datain,
1291                            GLint widthout, GLint heightout,
1292                            GLushort *dataout)
1293 {
1294     float x, lowx, highx, convx, halfconvx;
1295     float y, lowy, highy, convy, halfconvy;
1296     float xpercent,ypercent;
1297     float percent;
1298     /* Max components in a format is 4, so... */
1299     float totals[4];
1300     float area;
1301     int i,j,k,yint,xint,xindex,yindex;
1302     int temp;
1303
1304     if (widthin == widthout*2 && heightin == heightout*2) {
1305         halveImage(components, widthin, heightin, datain, dataout);
1306         return;
1307     }
1308     convy = (float) heightin/heightout;
1309     convx = (float) widthin/widthout;
1310     halfconvx = convx/2;
1311     halfconvy = convy/2;
1312     for (i = 0; i < heightout; i++) {
1313         y = convy * (i+0.5);
1314         if (heightin > heightout) {
1315             highy = y + halfconvy;
1316             lowy = y - halfconvy;
1317         } else {
1318             highy = y + 0.5;
1319             lowy = y - 0.5;
1320         }
1321         for (j = 0; j < widthout; j++) {
1322             x = convx * (j+0.5);
1323             if (widthin > widthout) {
1324                 highx = x + halfconvx;
1325                 lowx = x - halfconvx;
1326             } else {
1327                 highx = x + 0.5;
1328                 lowx = x - 0.5;
1329             }
1330
1331             /*
1332             ** Ok, now apply box filter to box that goes from (lowx, lowy)
1333             ** to (highx, highy) on input data into this pixel on output
1334             ** data.
1335             */
1336             totals[0] = totals[1] = totals[2] = totals[3] = 0.0;
1337             area = 0.0;
1338
1339             y = lowy;
1340             yint = floor(y);
1341             while (y < highy) {
1342                 yindex = (yint + heightin) % heightin;
1343                 if (highy < yint+1) {
1344                     ypercent = highy - y;
1345                 } else {
1346                     ypercent = yint+1 - y;
1347                 }
1348
1349                 x = lowx;
1350                 xint = floor(x);
1351
1352                 while (x < highx) {
1353                     xindex = (xint + widthin) % widthin;
1354                     if (highx < xint+1) {
1355                         xpercent = highx - x;
1356                     } else {
1357                         xpercent = xint+1 - x;
1358                     }
1359
1360                     percent = xpercent * ypercent;
1361                     area += percent;
1362                     temp = (xindex + (yindex * widthin)) * components;
1363                     for (k = 0; k < components; k++) {
1364                         totals[k] += datain[temp + k] * percent;
1365                     }
1366
1367                     xint++;
1368                     x = xint;
1369                 }
1370                 yint++;
1371                 y = yint;
1372             }
1373
1374             temp = (j + (i * widthout)) * components;
1375             for (k = 0; k < components; k++) {
1376                 /* totals[] should be rounded in the case of enlarging an RGB
1377                  * ramp when the type is 332 or 4444
1378                  */
1379                 dataout[temp + k] = (totals[k]+0.5)/area;
1380             }
1381         }
1382     }
1383 }
1384
1385 static void scale_internal_ubyte(GLint components, GLint widthin,
1386                            GLint heightin, const GLubyte *datain,
1387                            GLint widthout, GLint heightout,
1388                            GLubyte *dataout, GLint element_size,
1389                            GLint ysize, GLint group_size)
1390 {
1391     float convx;
1392     float convy;
1393     float percent;
1394     /* Max components in a format is 4, so... */
1395     float totals[4];
1396     float area;
1397     int i,j,k,xindex;
1398
1399     const char *temp, *temp0;
1400     const char *temp_index;
1401     int outindex;
1402
1403     int lowx_int, highx_int, lowy_int, highy_int;
1404     float x_percent, y_percent;
1405     float lowx_float, highx_float, lowy_float, highy_float;
1406     float convy_float, convx_float;
1407     int convy_int, convx_int;
1408     int l, m;
1409     const char *left, *right;
1410
1411     if (widthin == widthout*2 && heightin == heightout*2) {
1412         halveImage_ubyte(components, widthin, heightin,
1413         (const GLubyte *)datain, (GLubyte *)dataout,
1414         element_size, ysize, group_size);
1415         return;
1416     }
1417     convy = (float) heightin/heightout;
1418     convx = (float) widthin/widthout;
1419     convy_int = floor(convy);
1420     convy_float = convy - convy_int;
1421     convx_int = floor(convx);
1422     convx_float = convx - convx_int;
1423
1424     area = convx * convy;
1425
1426     lowy_int = 0;
1427     lowy_float = 0;
1428     highy_int = convy_int;
1429     highy_float = convy_float;
1430
1431     for (i = 0; i < heightout; i++) {
1432         /* Clamp here to be sure we don't read beyond input buffer. */
1433         if (highy_int >= heightin)
1434             highy_int = heightin - 1;
1435         lowx_int = 0;
1436         lowx_float = 0;
1437         highx_int = convx_int;
1438         highx_float = convx_float;
1439
1440         for (j = 0; j < widthout; j++) {
1441
1442             /*
1443             ** Ok, now apply box filter to box that goes from (lowx, lowy)
1444             ** to (highx, highy) on input data into this pixel on output
1445             ** data.
1446             */
1447             totals[0] = totals[1] = totals[2] = totals[3] = 0.0;
1448
1449             /* calculate the value for pixels in the 1st row */
1450             xindex = lowx_int*group_size;
1451             if((highy_int>lowy_int) && (highx_int>lowx_int)) {
1452
1453                 y_percent = 1-lowy_float;
1454                 temp = (const char *)datain + xindex + lowy_int * ysize;
1455                 percent = y_percent * (1-lowx_float);
1456                 for (k = 0, temp_index = temp; k < components;
1457                      k++, temp_index += element_size) {
1458                         totals[k] += (GLubyte)(*(temp_index)) * percent;
1459                 }
1460                 left = temp;
1461                 for(l = lowx_int+1; l < highx_int; l++) {
1462                     temp += group_size;
1463                     for (k = 0, temp_index = temp; k < components;
1464                          k++, temp_index += element_size) {
1465                         totals[k] += (GLubyte)(*(temp_index)) * y_percent;
1466                     }
1467                 }
1468                 temp += group_size;
1469                 right = temp;
1470                 percent = y_percent * highx_float;
1471                 for (k = 0, temp_index = temp; k < components;
1472                      k++, temp_index += element_size) {
1473                         totals[k] += (GLubyte)(*(temp_index)) * percent;
1474                 }
1475
1476                 /* calculate the value for pixels in the last row */
1477                 y_percent = highy_float;
1478                 percent = y_percent * (1-lowx_float);
1479                 temp = (const char *)datain + xindex + highy_int * ysize;
1480                 for (k = 0, temp_index = temp; k < components;
1481                      k++, temp_index += element_size) {
1482                         totals[k] += (GLubyte)(*(temp_index)) * percent;
1483                 }
1484                 for(l = lowx_int+1; l < highx_int; l++) {
1485                     temp += group_size;
1486                     for (k = 0, temp_index = temp; k < components;
1487                          k++, temp_index += element_size) {
1488                         totals[k] += (GLubyte)(*(temp_index)) * y_percent;
1489                     }
1490                 }
1491                 temp += group_size;
1492                 percent = y_percent * highx_float;
1493                 for (k = 0, temp_index = temp; k < components;
1494                      k++, temp_index += element_size) {
1495                         totals[k] += (GLubyte)(*(temp_index)) * percent;
1496                 }
1497
1498
1499                 /* calculate the value for pixels in the 1st and last column */
1500                 for(m = lowy_int+1; m < highy_int; m++) {
1501                     left += ysize;
1502                     right += ysize;
1503                     for (k = 0; k < components;
1504                          k++, left += element_size, right += element_size) {
1505                         totals[k] += (GLubyte)(*(left))*(1-lowx_float)
1506                                 +(GLubyte)(*(right))*highx_float;
1507                     }
1508                 }
1509             } else if (highy_int > lowy_int) {
1510                 x_percent = highx_float - lowx_float;
1511                 percent = (1-lowy_float)*x_percent;
1512                 temp = (const char *)datain + xindex + lowy_int*ysize;
1513                 for (k = 0, temp_index = temp; k < components;
1514                      k++, temp_index += element_size) {
1515                         totals[k] += (GLubyte)(*(temp_index)) * percent;
1516                 }
1517                 for(m = lowy_int+1; m < highy_int; m++) {
1518                     temp += ysize;
1519                     for (k = 0, temp_index = temp; k < components;
1520                          k++, temp_index += element_size) {
1521                         totals[k] += (GLubyte)(*(temp_index)) * x_percent;
1522                     }
1523                 }
1524                 percent = x_percent * highy_float;
1525                 temp += ysize;
1526                 for (k = 0, temp_index = temp; k < components;
1527                      k++, temp_index += element_size) {
1528                         totals[k] += (GLubyte)(*(temp_index)) * percent;
1529                 }
1530             } else if (highx_int > lowx_int) {
1531                 y_percent = highy_float - lowy_float;
1532                 percent = (1-lowx_float)*y_percent;
1533                 temp = (const char *)datain + xindex + lowy_int*ysize;
1534                 for (k = 0, temp_index = temp; k < components;
1535                      k++, temp_index += element_size) {
1536                         totals[k] += (GLubyte)(*(temp_index)) * percent;
1537                 }
1538                 for (l = lowx_int+1; l < highx_int; l++) {
1539                     temp += group_size;
1540                     for (k = 0, temp_index = temp; k < components;
1541                          k++, temp_index += element_size) {
1542                         totals[k] += (GLubyte)(*(temp_index)) * y_percent;
1543                     }
1544                 }
1545                 temp += group_size;
1546                 percent = y_percent * highx_float;
1547                 for (k = 0, temp_index = temp; k < components;
1548                      k++, temp_index += element_size) {
1549                         totals[k] += (GLubyte)(*(temp_index)) * percent;
1550                 }
1551             } else {
1552                 percent = (highy_float-lowy_float)*(highx_float-lowx_float);
1553                 temp = (const char *)datain + xindex + lowy_int * ysize;
1554                 for (k = 0, temp_index = temp; k < components;
1555                      k++, temp_index += element_size) {
1556                         totals[k] += (GLubyte)(*(temp_index)) * percent;
1557                 }
1558             }
1559
1560
1561
1562             /* this is for the pixels in the body */
1563             temp0 = (const char *)datain + xindex + group_size +
1564                  (lowy_int+1)*ysize;
1565             for (m = lowy_int+1; m < highy_int; m++) {
1566                 temp = temp0;
1567                 for(l = lowx_int+1; l < highx_int; l++) {
1568                     for (k = 0, temp_index = temp; k < components;
1569                          k++, temp_index += element_size) {
1570                         totals[k] += (GLubyte)(*(temp_index));
1571                     }
1572                     temp += group_size;
1573                 }
1574                 temp0 += ysize;
1575             }
1576
1577             outindex = (j + (i * widthout)) * components;
1578             for (k = 0; k < components; k++) {
1579                 dataout[outindex + k] = totals[k]/area;
1580                 /*printf("totals[%d] = %f\n", k, totals[k]);*/
1581             }
1582             lowx_int = highx_int;
1583             lowx_float = highx_float;
1584             highx_int += convx_int;
1585             highx_float += convx_float;
1586             if(highx_float > 1) {
1587                 highx_float -= 1.0;
1588                 highx_int++;
1589             }
1590         }
1591         lowy_int = highy_int;
1592         lowy_float = highy_float;
1593         highy_int += convy_int;
1594         highy_float += convy_float;
1595         if(highy_float > 1) {
1596             highy_float -= 1.0;
1597             highy_int++;
1598         }
1599     }
1600 }
1601
1602 static void scale_internal_byte(GLint components, GLint widthin,
1603                            GLint heightin, const GLbyte *datain,
1604                            GLint widthout, GLint heightout,
1605                            GLbyte *dataout, GLint element_size,
1606                            GLint ysize, GLint group_size)
1607 {
1608     float convx;
1609     float convy;
1610     float percent;
1611     /* Max components in a format is 4, so... */
1612     float totals[4];
1613     float area;
1614     int i,j,k,xindex;
1615
1616     const char *temp, *temp0;
1617     const char *temp_index;
1618     int outindex;
1619
1620     int lowx_int, highx_int, lowy_int, highy_int;
1621     float x_percent, y_percent;
1622     float lowx_float, highx_float, lowy_float, highy_float;
1623     float convy_float, convx_float;
1624     int convy_int, convx_int;
1625     int l, m;
1626     const char *left, *right;
1627
1628     if (widthin == widthout*2 && heightin == heightout*2) {
1629         halveImage_byte(components, widthin, heightin,
1630         (const GLbyte *)datain, (GLbyte *)dataout,
1631         element_size, ysize, group_size);
1632         return;
1633     }
1634     convy = (float) heightin/heightout;
1635     convx = (float) widthin/widthout;
1636     convy_int = floor(convy);
1637     convy_float = convy - convy_int;
1638     convx_int = floor(convx);
1639     convx_float = convx - convx_int;
1640
1641     area = convx * convy;
1642
1643     lowy_int = 0;
1644     lowy_float = 0;
1645     highy_int = convy_int;
1646     highy_float = convy_float;
1647
1648     for (i = 0; i < heightout; i++) {
1649         /* Clamp here to be sure we don't read beyond input buffer. */
1650         if (highy_int >= heightin)
1651             highy_int = heightin - 1;
1652         lowx_int = 0;
1653         lowx_float = 0;
1654         highx_int = convx_int;
1655         highx_float = convx_float;
1656
1657         for (j = 0; j < widthout; j++) {
1658
1659             /*
1660             ** Ok, now apply box filter to box that goes from (lowx, lowy)
1661             ** to (highx, highy) on input data into this pixel on output
1662             ** data.
1663             */
1664             totals[0] = totals[1] = totals[2] = totals[3] = 0.0;
1665
1666             /* calculate the value for pixels in the 1st row */
1667             xindex = lowx_int*group_size;
1668             if((highy_int>lowy_int) && (highx_int>lowx_int)) {
1669
1670                 y_percent = 1-lowy_float;
1671                 temp = (const char *)datain + xindex + lowy_int * ysize;
1672                 percent = y_percent * (1-lowx_float);
1673                 for (k = 0, temp_index = temp; k < components;
1674                      k++, temp_index += element_size) {
1675                         totals[k] += (GLbyte)(*(temp_index)) * percent;
1676                 }
1677                 left = temp;
1678                 for(l = lowx_int+1; l < highx_int; l++) {
1679                     temp += group_size;
1680                     for (k = 0, temp_index = temp; k < components;
1681                      k++, temp_index += element_size) {
1682                         totals[k] += (GLbyte)(*(temp_index)) * y_percent;
1683                     }
1684                 }
1685                 temp += group_size;
1686                 right = temp;
1687                 percent = y_percent * highx_float;
1688                 for (k = 0, temp_index = temp; k < components;
1689                      k++, temp_index += element_size) {
1690                         totals[k] += (GLbyte)(*(temp_index)) * percent;
1691                 }
1692
1693                 /* calculate the value for pixels in the last row */
1694                 y_percent = highy_float;
1695                 percent = y_percent * (1-lowx_float);
1696                 temp = (const char *)datain + xindex + highy_int * ysize;
1697                 for (k = 0, temp_index = temp; k < components;
1698                      k++, temp_index += element_size) {
1699                         totals[k] += (GLbyte)(*(temp_index)) * percent;
1700                 }
1701                 for(l = lowx_int+1; l < highx_int; l++) {
1702                     temp += group_size;
1703                     for (k = 0, temp_index = temp; k < components;
1704                          k++, temp_index += element_size) {
1705                         totals[k] += (GLbyte)(*(temp_index)) * y_percent;
1706                     }
1707                 }
1708                 temp += group_size;
1709                 percent = y_percent * highx_float;
1710                 for (k = 0, temp_index = temp; k < components;
1711                      k++, temp_index += element_size) {
1712                         totals[k] += (GLbyte)(*(temp_index)) * percent;
1713                 }
1714
1715
1716                 /* calculate the value for pixels in the 1st and last column */
1717                 for(m = lowy_int+1; m < highy_int; m++) {
1718                     left += ysize;
1719                     right += ysize;
1720                     for (k = 0; k < components;
1721                          k++, left += element_size, right += element_size) {
1722                         totals[k] += (GLbyte)(*(left))*(1-lowx_float)
1723                                 +(GLbyte)(*(right))*highx_float;
1724                     }
1725                 }
1726             } else if (highy_int > lowy_int) {
1727                 x_percent = highx_float - lowx_float;
1728                 percent = (1-lowy_float)*x_percent;
1729                 temp = (const char *)datain + xindex + lowy_int*ysize;
1730                 for (k = 0, temp_index = temp; k < components;
1731                      k++, temp_index += element_size) {
1732                         totals[k] += (GLbyte)(*(temp_index)) * percent;
1733                 }
1734                 for(m = lowy_int+1; m < highy_int; m++) {
1735                     temp += ysize;
1736                     for (k = 0, temp_index = temp; k < components;
1737                          k++, temp_index += element_size) {
1738                         totals[k] += (GLbyte)(*(temp_index)) * x_percent;
1739                     }
1740                 }
1741                 percent = x_percent * highy_float;
1742                 temp += ysize;
1743                 for (k = 0, temp_index = temp; k < components;
1744                      k++, temp_index += element_size) {
1745                         totals[k] += (GLbyte)(*(temp_index)) * percent;
1746                 }
1747             } else if (highx_int > lowx_int) {
1748                 y_percent = highy_float - lowy_float;
1749                 percent = (1-lowx_float)*y_percent;
1750                 temp = (const char *)datain + xindex + lowy_int*ysize;
1751                 for (k = 0, temp_index = temp; k < components;
1752                      k++, temp_index += element_size) {
1753                         totals[k] += (GLbyte)(*(temp_index)) * percent;
1754                 }
1755                 for (l = lowx_int+1; l < highx_int; l++) {
1756                     temp += group_size;
1757                     for (k = 0, temp_index = temp; k < components;
1758                          k++, temp_index += element_size) {
1759                         totals[k] += (GLbyte)(*(temp_index)) * y_percent;
1760                     }
1761                 }
1762                 temp += group_size;
1763                 percent = y_percent * highx_float;
1764                 for (k = 0, temp_index = temp; k < components;
1765                      k++, temp_index += element_size) {
1766                         totals[k] += (GLbyte)(*(temp_index)) * percent;
1767                 }
1768             } else {
1769                 percent = (highy_float-lowy_float)*(highx_float-lowx_float);
1770                 temp = (const char *)datain + xindex + lowy_int * ysize;
1771                 for (k = 0, temp_index = temp; k < components;
1772                      k++, temp_index += element_size) {
1773                         totals[k] += (GLbyte)(*(temp_index)) * percent;
1774                 }
1775             }
1776
1777
1778
1779             /* this is for the pixels in the body */
1780             temp0 = (const char *)datain + xindex + group_size +
1781                 (lowy_int+1)*ysize;
1782             for (m = lowy_int+1; m < highy_int; m++) {
1783                 temp = temp0;
1784                 for(l = lowx_int+1; l < highx_int; l++) {
1785                     for (k = 0, temp_index = temp; k < components;
1786                      k++, temp_index += element_size) {
1787                         totals[k] += (GLbyte)(*(temp_index));
1788                     }
1789                     temp += group_size;
1790                 }
1791                 temp0 += ysize;
1792             }
1793
1794             outindex = (j + (i * widthout)) * components;
1795             for (k = 0; k < components; k++) {
1796                 dataout[outindex + k] = totals[k]/area;
1797                 /*printf("totals[%d] = %f\n", k, totals[k]);*/
1798             }
1799             lowx_int = highx_int;
1800             lowx_float = highx_float;
1801             highx_int += convx_int;
1802             highx_float += convx_float;
1803             if(highx_float > 1) {
1804                 highx_float -= 1.0;
1805                 highx_int++;
1806             }
1807         }
1808         lowy_int = highy_int;
1809         lowy_float = highy_float;
1810         highy_int += convy_int;
1811         highy_float += convy_float;
1812         if(highy_float > 1) {
1813             highy_float -= 1.0;
1814             highy_int++;
1815         }
1816     }
1817 }
1818
1819 static void scale_internal_ushort(GLint components, GLint widthin,
1820                            GLint heightin, const GLushort *datain,
1821                            GLint widthout, GLint heightout,
1822                            GLushort *dataout, GLint element_size,
1823                            GLint ysize, GLint group_size,
1824                            GLint myswap_bytes)
1825 {
1826     float convx;
1827     float convy;
1828     float percent;
1829     /* Max components in a format is 4, so... */
1830     float totals[4];
1831     float area;
1832     int i,j,k,xindex;
1833
1834     const char *temp, *temp0;
1835     const char *temp_index;
1836     int outindex;
1837
1838     int lowx_int, highx_int, lowy_int, highy_int;
1839     float x_percent, y_percent;
1840     float lowx_float, highx_float, lowy_float, highy_float;
1841     float convy_float, convx_float;
1842     int convy_int, convx_int;
1843     int l, m;
1844     const char *left, *right;
1845
1846     if (widthin == widthout*2 && heightin == heightout*2) {
1847         halveImage_ushort(components, widthin, heightin,
1848         (const GLushort *)datain, (GLushort *)dataout,
1849         element_size, ysize, group_size, myswap_bytes);
1850         return;
1851     }
1852     convy = (float) heightin/heightout;
1853     convx = (float) widthin/widthout;
1854     convy_int = floor(convy);
1855     convy_float = convy - convy_int;
1856     convx_int = floor(convx);
1857     convx_float = convx - convx_int;
1858
1859     area = convx * convy;
1860
1861     lowy_int = 0;
1862     lowy_float = 0;
1863     highy_int = convy_int;
1864     highy_float = convy_float;
1865
1866     for (i = 0; i < heightout; i++) {
1867         /* Clamp here to be sure we don't read beyond input buffer. */
1868         if (highy_int >= heightin)
1869             highy_int = heightin - 1;
1870         lowx_int = 0;
1871         lowx_float = 0;
1872         highx_int = convx_int;
1873         highx_float = convx_float;
1874
1875         for (j = 0; j < widthout; j++) {
1876             /*
1877             ** Ok, now apply box filter to box that goes from (lowx, lowy)
1878             ** to (highx, highy) on input data into this pixel on output
1879             ** data.
1880             */
1881             totals[0] = totals[1] = totals[2] = totals[3] = 0.0;
1882
1883             /* calculate the value for pixels in the 1st row */
1884             xindex = lowx_int*group_size;
1885             if((highy_int>lowy_int) && (highx_int>lowx_int)) {
1886
1887                 y_percent = 1-lowy_float;
1888                 temp = (const char *)datain + xindex + lowy_int * ysize;
1889                 percent = y_percent * (1-lowx_float);
1890                 for (k = 0, temp_index = temp; k < components;
1891                      k++, temp_index += element_size) {
1892                     if (myswap_bytes) {
1893                         totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
1894                     } else {
1895                         totals[k] += *(const GLushort*)temp_index * percent;
1896                     }
1897                 }
1898                 left = temp;
1899                 for(l = lowx_int+1; l < highx_int; l++) {
1900                     temp += group_size;
1901                     for (k = 0, temp_index = temp; k < components;
1902                          k++, temp_index += element_size) {
1903                         if (myswap_bytes) {
1904                             totals[k] +=
1905                                  __GLU_SWAP_2_BYTES(temp_index) * y_percent;
1906                         } else {
1907                             totals[k] += *(const GLushort*)temp_index * y_percent;
1908                         }
1909                     }
1910                 }
1911                 temp += group_size;
1912                 right = temp;
1913                 percent = y_percent * highx_float;
1914                 for (k = 0, temp_index = temp; k < components;
1915                      k++, temp_index += element_size) {
1916                     if (myswap_bytes) {
1917                         totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
1918                     } else {
1919                         totals[k] += *(const GLushort*)temp_index * percent;
1920                     }
1921                 }
1922
1923                 /* calculate the value for pixels in the last row */
1924                 y_percent = highy_float;
1925                 percent = y_percent * (1-lowx_float);
1926                 temp = (const char *)datain + xindex + highy_int * ysize;
1927                 for (k = 0, temp_index = temp; k < components;
1928                      k++, temp_index += element_size) {
1929                     if (myswap_bytes) {
1930                         totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
1931                     } else {
1932                         totals[k] += *(const GLushort*)temp_index * percent;
1933                     }
1934                 }
1935                 for(l = lowx_int+1; l < highx_int; l++) {
1936                     temp += group_size;
1937                     for (k = 0, temp_index = temp; k < components;
1938                          k++, temp_index += element_size) {
1939                         if (myswap_bytes) {
1940                             totals[k] +=
1941                                  __GLU_SWAP_2_BYTES(temp_index) * y_percent;
1942                         } else {
1943                             totals[k] += *(const GLushort*)temp_index * y_percent;
1944                         }
1945                     }
1946                 }
1947                 temp += group_size;
1948                 percent = y_percent * highx_float;
1949                 for (k = 0, temp_index = temp; k < components;
1950                      k++, temp_index += element_size) {
1951                     if (myswap_bytes) {
1952                         totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
1953                     } else {
1954                         totals[k] += *(const GLushort*)temp_index * percent;
1955                     }
1956                 }
1957
1958                 /* calculate the value for pixels in the 1st and last column */
1959                 for(m = lowy_int+1; m < highy_int; m++) {
1960                     left += ysize;
1961                     right += ysize;
1962                     for (k = 0; k < components;
1963                          k++, left += element_size, right += element_size) {
1964                         if (myswap_bytes) {
1965                             totals[k] +=
1966                                 __GLU_SWAP_2_BYTES(left) * (1-lowx_float) +
1967                                 __GLU_SWAP_2_BYTES(right) * highx_float;
1968                         } else {
1969                             totals[k] += *(const GLushort*)left * (1-lowx_float)
1970                                        + *(const GLushort*)right * highx_float;
1971                         }
1972                     }
1973                 }
1974             } else if (highy_int > lowy_int) {
1975                 x_percent = highx_float - lowx_float;
1976                 percent = (1-lowy_float)*x_percent;
1977                 temp = (const char *)datain + xindex + lowy_int*ysize;
1978                 for (k = 0, temp_index = temp; k < components;
1979                      k++, temp_index += element_size) {
1980                     if (myswap_bytes) {
1981                         totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
1982                     } else {
1983                         totals[k] += *(const GLushort*)temp_index * percent;
1984                     }
1985                 }
1986                 for(m = lowy_int+1; m < highy_int; m++) {
1987                     temp += ysize;
1988                     for (k = 0, temp_index = temp; k < components;
1989                          k++, temp_index += element_size) {
1990                         if (myswap_bytes) {
1991                             totals[k] +=
1992                                 __GLU_SWAP_2_BYTES(temp_index) * x_percent;
1993                         } else {
1994                             totals[k] += *(const GLushort*)temp_index * x_percent;
1995                         }
1996                     }
1997                 }
1998                 percent = x_percent * highy_float;
1999                 temp += ysize;
2000                 for (k = 0, temp_index = temp; k < components;
2001                      k++, temp_index += element_size) {
2002                     if (myswap_bytes) {
2003                         totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
2004                     } else {
2005                         totals[k] += *(const GLushort*)temp_index * percent;
2006                     }
2007                 }
2008             } else if (highx_int > lowx_int) {
2009                 y_percent = highy_float - lowy_float;
2010                 percent = (1-lowx_float)*y_percent;
2011                 temp = (const char *)datain + xindex + lowy_int*ysize;
2012                 for (k = 0, temp_index = temp; k < components;
2013                      k++, temp_index += element_size) {
2014                     if (myswap_bytes) {
2015                         totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
2016                     } else {
2017                         totals[k] += *(const GLushort*)temp_index * percent;
2018                     }
2019                 }
2020                 for (l = lowx_int+1; l < highx_int; l++) {
2021                     temp += group_size;
2022                     for (k = 0, temp_index = temp; k < components;
2023                          k++, temp_index += element_size) {
2024                         if (myswap_bytes) {
2025                             totals[k] +=
2026                                 __GLU_SWAP_2_BYTES(temp_index) * y_percent;
2027                         } else {
2028                             totals[k] += *(const GLushort*)temp_index * y_percent;
2029                         }
2030                     }
2031                 }
2032                 temp += group_size;
2033                 percent = y_percent * highx_float;
2034                 for (k = 0, temp_index = temp; k < components;
2035                      k++, temp_index += element_size) {
2036                     if (myswap_bytes) {
2037                         totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
2038                     } else {
2039                         totals[k] += *(const GLushort*)temp_index * percent;
2040                     }
2041                 }
2042             } else {
2043                 percent = (highy_float-lowy_float)*(highx_float-lowx_float);
2044                 temp = (const char *)datain + xindex + lowy_int * ysize;
2045                 for (k = 0, temp_index = temp; k < components;
2046                      k++, temp_index += element_size) {
2047                     if (myswap_bytes) {
2048                         totals[k] += __GLU_SWAP_2_BYTES(temp_index) * percent;
2049                     } else {
2050                         totals[k] += *(const GLushort*)temp_index * percent;
2051                     }
2052                 }
2053             }
2054
2055             /* this is for the pixels in the body */
2056             temp0 = (const char *)datain + xindex + group_size +
2057                  (lowy_int+1)*ysize;
2058             for (m = lowy_int+1; m < highy_int; m++) {
2059                 temp = temp0;
2060                 for(l = lowx_int+1; l < highx_int; l++) {
2061                     for (k = 0, temp_index = temp; k < components;
2062                          k++, temp_index += element_size) {
2063                         if (myswap_bytes) {
2064                             totals[k] += __GLU_SWAP_2_BYTES(temp_index);
2065                         } else {
2066                             totals[k] += *(const GLushort*)temp_index;
2067                         }
2068                     }
2069                     temp += group_size;
2070                 }
2071                 temp0 += ysize;
2072             }
2073
2074             outindex = (j + (i * widthout)) * components;
2075             for (k = 0; k < components; k++) {
2076                 dataout[outindex + k] = totals[k]/area;
2077                 /*printf("totals[%d] = %f\n", k, totals[k]);*/
2078             }
2079             lowx_int = highx_int;
2080             lowx_float = highx_float;
2081             highx_int += convx_int;
2082             highx_float += convx_float;
2083             if(highx_float > 1) {
2084                 highx_float -= 1.0;
2085                 highx_int++;
2086             }
2087         }
2088         lowy_int = highy_int;
2089         lowy_float = highy_float;
2090         highy_int += convy_int;
2091         highy_float += convy_float;
2092         if(highy_float > 1) {
2093             highy_float -= 1.0;
2094             highy_int++;
2095         }
2096     }
2097 }
2098
2099 static void scale_internal_short(GLint components, GLint widthin,
2100                            GLint heightin, const GLshort *datain,
2101                            GLint widthout, GLint heightout,
2102                            GLshort *dataout, GLint element_size,
2103                            GLint ysize, GLint group_size,
2104                            GLint myswap_bytes)
2105 {
2106     float convx;
2107     float convy;
2108     float percent;
2109     /* Max components in a format is 4, so... */
2110     float totals[4];
2111     float area;
2112     int i,j,k,xindex;
2113
2114     const char *temp, *temp0;
2115     const char *temp_index;
2116     int outindex;
2117
2118     int lowx_int, highx_int, lowy_int, highy_int;
2119     float x_percent, y_percent;
2120     float lowx_float, highx_float, lowy_float, highy_float;
2121     float convy_float, convx_float;
2122     int convy_int, convx_int;
2123     int l, m;
2124     const char *left, *right;
2125
2126     GLushort swapbuf;   /* unsigned buffer */
2127
2128     if (widthin == widthout*2 && heightin == heightout*2) {
2129         halveImage_short(components, widthin, heightin,
2130         (const GLshort *)datain, (GLshort *)dataout,
2131         element_size, ysize, group_size, myswap_bytes);
2132         return;
2133     }
2134     convy = (float) heightin/heightout;
2135     convx = (float) widthin/widthout;
2136     convy_int = floor(convy);
2137     convy_float = convy - convy_int;
2138     convx_int = floor(convx);
2139     convx_float = convx - convx_int;
2140
2141     area = convx * convy;
2142
2143     lowy_int = 0;
2144     lowy_float = 0;
2145     highy_int = convy_int;
2146     highy_float = convy_float;
2147
2148     for (i = 0; i < heightout; i++) {
2149         /* Clamp here to be sure we don't read beyond input buffer. */
2150         if (highy_int >= heightin)
2151             highy_int = heightin - 1;
2152         lowx_int = 0;
2153         lowx_float = 0;
2154         highx_int = convx_int;
2155         highx_float = convx_float;
2156
2157         for (j = 0; j < widthout; j++) {
2158             /*
2159             ** Ok, now apply box filter to box that goes from (lowx, lowy)
2160             ** to (highx, highy) on input data into this pixel on output
2161             ** data.
2162             */
2163             totals[0] = totals[1] = totals[2] = totals[3] = 0.0;
2164
2165             /* calculate the value for pixels in the 1st row */
2166             xindex = lowx_int*group_size;
2167             if((highy_int>lowy_int) && (highx_int>lowx_int)) {
2168
2169                 y_percent = 1-lowy_float;
2170                 temp = (const char *)datain + xindex + lowy_int * ysize;
2171                 percent = y_percent * (1-lowx_float);
2172                 for (k = 0, temp_index = temp; k < components;
2173                      k++, temp_index += element_size) {
2174                     if (myswap_bytes) {
2175                         swapbuf = __GLU_SWAP_2_BYTES(temp_index);
2176                         totals[k] += *(const GLshort*)&swapbuf * percent;
2177                     } else {
2178                         totals[k] += *(const GLshort*)temp_index * percent;
2179                     }
2180                 }
2181                 left = temp;
2182                 for(l = lowx_int+1; l < highx_int; l++) {
2183                     temp += group_size;
2184                     for (k = 0, temp_index = temp; k < components;
2185                          k++, temp_index += element_size) {
2186                         if (myswap_bytes) {
2187                             swapbuf = __GLU_SWAP_2_BYTES(temp_index);
2188                             totals[k] += *(const GLshort*)&swapbuf * y_percent;
2189                         } else {
2190                             totals[k] += *(const GLshort*)temp_index * y_percent;
2191                         }
2192                     }
2193                 }
2194                 temp += group_size;
2195                 right = temp;
2196                 percent = y_percent * highx_float;
2197                 for (k = 0, temp_index = temp; k < components;
2198                      k++, temp_index += element_size) {
2199                     if (myswap_bytes) {
2200                         swapbuf = __GLU_SWAP_2_BYTES(temp_index);
2201                         totals[k] += *(const GLshort*)&swapbuf * percent;
2202                     } else {
2203                         totals[k] += *(const GLshort*)temp_index * percent;
2204                     }
2205                 }
2206
2207                 /* calculate the value for pixels in the last row */
2208                 y_percent = highy_float;
2209                 percent = y_percent * (1-lowx_float);
2210                 temp = (const char *)datain + xindex + highy_int * ysize;
2211                 for (k = 0, temp_index = temp; k < components;
2212                      k++, temp_index += element_size) {
2213                     if (myswap_bytes) {
2214                         swapbuf = __GLU_SWAP_2_BYTES(temp_index);
2215                         totals[k] += *(const GLshort*)&swapbuf * percent;
2216                     } else {
2217                         totals[k] += *(const GLshort*)temp_index * percent;
2218                     }
2219                 }
2220                 for(l = lowx_int+1; l < highx_int; l++) {
2221                     temp += group_size;
2222                     for (k = 0, temp_index = temp; k < components;
2223                          k++, temp_index += element_size) {
2224                         if (myswap_bytes) {
2225                             swapbuf = __GLU_SWAP_2_BYTES(temp_index);
2226                             totals[k] += *(const GLshort*)&swapbuf * y_percent;
2227                         } else {
2228                             totals[k] += *(const GLshort*)temp_index * y_percent;
2229                         }
2230                     }
2231                 }
2232                 temp += group_size;
2233                 percent = y_percent * highx_float;
2234                 for (k = 0, temp_index = temp; k < components;
2235                      k++, temp_index += element_size) {
2236                     if (myswap_bytes) {
2237                         swapbuf = __GLU_SWAP_2_BYTES(temp_index);
2238                         totals[k] += *(const GLshort*)&swapbuf * percent;
2239                     } else {
2240                         totals[k] += *(const GLshort*)temp_index * percent;
2241                     }
2242                 }
2243
2244                 /* calculate the value for pixels in the 1st and last column */
2245                 for(m = lowy_int+1; m < highy_int; m++) {
2246                     left += ysize;
2247                     right += ysize;
2248                     for (k = 0; k < components;
2249                          k++, left += element_size, right += element_size) {
2250                         if (myswap_bytes) {
2251                             swapbuf = __GLU_SWAP_2_BYTES(left);
2252                             totals[k] += *(const GLshort*)&swapbuf * (1-lowx_float);
2253                             swapbuf = __GLU_SWAP_2_BYTES(right);
2254                             totals[k] += *(const GLshort*)&swapbuf * highx_float;
2255                         } else {
2256                             totals[k] += *(const GLshort*)left * (1-lowx_float)
2257                                        + *(const GLshort*)right * highx_float;
2258                         }
2259                     }
2260                 }
2261             } else if (highy_int > lowy_int) {
2262                 x_percent = highx_float - lowx_float;
2263                 percent = (1-lowy_float)*x_percent;
2264                 temp = (const char *)datain + xindex + lowy_int*ysize;
2265                 for (k = 0, temp_index = temp; k < components;
2266                      k++, temp_index += element_size) {
2267                     if (myswap_bytes) {
2268                         swapbuf = __GLU_SWAP_2_BYTES(temp_index);
2269                         totals[k] += *(const GLshort*)&swapbuf * percent;
2270                     } else {
2271                         totals[k] += *(const GLshort*)temp_index * percent;
2272                     }
2273                 }
2274                 for(m = lowy_int+1; m < highy_int; m++) {
2275                     temp += ysize;
2276                     for (k = 0, temp_index = temp; k < components;
2277                          k++, temp_index += element_size) {
2278                         if (myswap_bytes) {
2279                             swapbuf = __GLU_SWAP_2_BYTES(temp_index);
2280                             totals[k] += *(const GLshort*)&swapbuf * x_percent;
2281                         } else {
2282                             totals[k] += *(const GLshort*)temp_index * x_percent;
2283                         }
2284                     }
2285                 }
2286                 percent = x_percent * highy_float;
2287                 temp += ysize;
2288                 for (k = 0, temp_index = temp; k < components;
2289                      k++, temp_index += element_size) {
2290                     if (myswap_bytes) {
2291                         swapbuf = __GLU_SWAP_2_BYTES(temp_index);
2292                         totals[k] += *(const GLshort*)&swapbuf * percent;
2293                     } else {
2294                         totals[k] += *(const GLshort*)temp_index * percent;
2295                     }
2296                 }
2297             } else if (highx_int > lowx_int) {
2298                 y_percent = highy_float - lowy_float;
2299                 percent = (1-lowx_float)*y_percent;
2300
2301              temp = (const char *)datain + xindex + lowy_int*ysize;
2302                 for (k = 0, temp_index = temp; k < components;
2303                      k++, temp_index += element_size) {
2304                     if (myswap_bytes) {
2305                         swapbuf = __GLU_SWAP_2_BYTES(temp_index);
2306                         totals[k] += *(const GLshort*)&swapbuf * percent;
2307                     } else {
2308                         totals[k] += *(const GLshort*)temp_index * percent;
2309                     }
2310                 }
2311                 for (l = lowx_int+1; l < highx_int; l++) {
2312                     temp += group_size;
2313                     for (k = 0, temp_index = temp; k < components;
2314                          k++, temp_index += element_size) {
2315                         if (myswap_bytes) {
2316                             swapbuf = __GLU_SWAP_2_BYTES(temp_index);
2317                             totals[k] += *(const GLshort*)&swapbuf * y_percent;
2318                         } else {
2319                             totals[k] += *(const GLshort*)temp_index * y_percent;
2320                         }
2321                     }
2322                 }
2323                 temp += group_size;
2324                 percent = y_percent * highx_float;
2325                 for (k = 0, temp_index = temp; k < components;
2326                      k++, temp_index += element_size) {
2327                     if (myswap_bytes) {
2328                         swapbuf = __GLU_SWAP_2_BYTES(temp_index);
2329                         totals[k] += *(const GLshort*)&swapbuf * percent;
2330                     } else {
2331                         totals[k] += *(const GLshort*)temp_index * percent;
2332                     }
2333                 }
2334             } else {
2335                 percent = (highy_float-lowy_float)*(highx_float-lowx_float);
2336                 temp = (const char *)datain + xindex + lowy_int * ysize;
2337                 for (k = 0, temp_index = temp; k < components;
2338                      k++, temp_index += element_size) {
2339                     if (myswap_bytes) {
2340                         swapbuf = __GLU_SWAP_2_BYTES(temp_index);
2341                         totals[k] += *(const GLshort*)&swapbuf * percent;
2342                     } else {
2343                         totals[k] += *(const GLshort*)temp_index * percent;
2344                     }
2345                 }
2346             }
2347
2348             /* this is for the pixels in the body */
2349             temp0 = (const char *)datain + xindex + group_size +
2350                  (lowy_int+1)*ysize;
2351             for (m = lowy_int+1; m < highy_int; m++) {
2352                 temp = temp0;
2353                 for(l = lowx_int+1; l < highx_int; l++) {
2354                     for (k = 0, temp_index = temp; k < components;
2355                          k++, temp_index += element_size) {
2356                         if (myswap_bytes) {
2357                             swapbuf = __GLU_SWAP_2_BYTES(temp_index);
2358                             totals[k] += *(const GLshort*)&swapbuf;
2359                         } else {
2360                             totals[k] += *(const GLshort*)temp_index;
2361                         }
2362                     }
2363                     temp += group_size;
2364                 }
2365                 temp0 += ysize;
2366             }
2367
2368             outindex = (j + (i * widthout)) * components;
2369             for (k = 0; k < components; k++) {
2370                 dataout[outindex + k] = totals[k]/area;
2371                 /*printf("totals[%d] = %f\n", k, totals[k]);*/
2372             }
2373             lowx_int = highx_int;
2374             lowx_float = highx_float;
2375             highx_int += convx_int;
2376             highx_float += convx_float;
2377             if(highx_float > 1) {
2378                 highx_float -= 1.0;
2379                 highx_int++;
2380             }
2381         }
2382         lowy_int = highy_int;
2383         lowy_float = highy_float;
2384         highy_int += convy_int;
2385         highy_float += convy_float;
2386         if(highy_float > 1) {
2387             highy_float -= 1.0;
2388             highy_int++;
2389         }
2390     }
2391 }
2392
2393 static void scale_internal_uint(GLint components, GLint widthin,
2394                            GLint heightin, const GLuint *datain,
2395                            GLint widthout, GLint heightout,
2396                            GLuint *dataout, GLint element_size,
2397                            GLint ysize, GLint group_size,
2398                            GLint myswap_bytes)
2399 {
2400     float convx;
2401     float convy;
2402     float percent;
2403     /* Max components in a format is 4, so... */
2404     float totals[4];
2405     float area;
2406     int i,j,k,xindex;
2407
2408     const char *temp, *temp0;
2409     const char *temp_index;
2410     int outindex;
2411
2412     int lowx_int, highx_int, lowy_int, highy_int;
2413     float x_percent, y_percent;
2414     float lowx_float, highx_float, lowy_float, highy_float;
2415     float convy_float, convx_float;
2416     int convy_int, convx_int;
2417     int l, m;
2418     const char *left, *right;
2419
2420     if (widthin == widthout*2 && heightin == heightout*2) {
2421         halveImage_uint(components, widthin, heightin,
2422         (const GLuint *)datain, (GLuint *)dataout,
2423         element_size, ysize, group_size, myswap_bytes);
2424         return;
2425     }
2426     convy = (float) heightin/heightout;
2427     convx = (float) widthin/widthout;
2428     convy_int = floor(convy);
2429     convy_float = convy - convy_int;
2430     convx_int = floor(convx);
2431     convx_float = convx - convx_int;
2432
2433     area = convx * convy;
2434
2435     lowy_int = 0;
2436     lowy_float = 0;
2437     highy_int = convy_int;
2438     highy_float = convy_float;
2439
2440     for (i = 0; i < heightout; i++) {
2441         /* Clamp here to be sure we don't read beyond input buffer. */
2442         if (highy_int >= heightin)
2443             highy_int = heightin - 1;
2444         lowx_int = 0;
2445         lowx_float = 0;
2446         highx_int = convx_int;
2447         highx_float = convx_float;
2448
2449         for (j = 0; j < widthout; j++) {
2450             /*
2451             ** Ok, now apply box filter to box that goes from (lowx, lowy)
2452             ** to (highx, highy) on input data into this pixel on output
2453             ** data.
2454             */
2455             totals[0] = totals[1] = totals[2] = totals[3] = 0.0;
2456
2457             /* calculate the value for pixels in the 1st row */
2458             xindex = lowx_int*group_size;
2459             if((highy_int>lowy_int) && (highx_int>lowx_int)) {
2460
2461                 y_percent = 1-lowy_float;
2462                 temp = (const char *)datain + xindex + lowy_int * ysize;
2463                 percent = y_percent * (1-lowx_float);
2464                 for (k = 0, temp_index = temp; k < components;
2465                      k++, temp_index += element_size) {
2466                     if (myswap_bytes) {
2467                         totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;
2468                     } else {
2469                         totals[k] += *(const GLuint*)temp_index * percent;
2470                     }
2471                 }
2472                 left = temp;
2473                 for(l = lowx_int+1; l < highx_int; l++) {
2474                     temp += group_size;
2475                     for (k = 0, temp_index = temp; k < components;
2476                          k++, temp_index += element_size) {
2477                         if (myswap_bytes) {
2478                             totals[k] +=
2479                                  __GLU_SWAP_4_BYTES(temp_index) * y_percent;
2480                         } else {
2481                             totals[k] += *(const GLuint*)temp_index * y_percent;
2482                         }
2483                     }
2484                 }
2485                 temp += group_size;
2486                 right = temp;
2487                 percent = y_percent * highx_float;
2488                 for (k = 0, temp_index = temp; k < components;
2489                      k++, temp_index += element_size) {
2490                     if (myswap_bytes) {
2491                         totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;
2492                     } else {
2493                         totals[k] += *(const GLuint*)temp_index * percent;
2494                     }
2495                 }
2496
2497                 /* calculate the value for pixels in the last row */
2498                 y_percent = highy_float;
2499                 percent = y_percent * (1-lowx_float);
2500                 temp = (const char *)datain + xindex + highy_int * ysize;
2501                 for (k = 0, temp_index = temp; k < components;
2502                      k++, temp_index += element_size) {
2503                     if (myswap_bytes) {
2504                         totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;
2505                     } else {
2506                         totals[k] += *(const GLuint*)temp_index * percent;
2507                     }
2508                 }
2509                 for(l = lowx_int+1; l < highx_int; l++) {
2510                     temp += group_size;
2511                     for (k = 0, temp_index = temp; k < components;
2512                          k++, temp_index += element_size) {
2513                         if (myswap_bytes) {
2514                             totals[k] +=
2515                                  __GLU_SWAP_4_BYTES(temp_index) * y_percent;
2516                         } else {
2517                             totals[k] += *(const GLuint*)temp_index * y_percent;
2518                         }
2519                     }
2520                 }
2521                 temp += group_size;
2522                 percent = y_percent * highx_float;
2523                 for (k = 0, temp_index = temp; k < components;
2524                      k++, temp_index += element_size) {
2525                     if (myswap_bytes) {
2526                         totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;
2527                     } else {
2528                         totals[k] += *(const GLuint*)temp_index * percent;
2529                     }
2530                 }
2531
2532                 /* calculate the value for pixels in the 1st and last column */
2533                 for(m = lowy_int+1; m < highy_int; m++) {
2534                     left += ysize;
2535                     right += ysize;
2536                     for (k = 0; k < components;
2537                          k++, left += element_size, right += element_size) {
2538                         if (myswap_bytes) {
2539                             totals[k] +=
2540                                 __GLU_SWAP_4_BYTES(left) * (1-lowx_float)
2541                               + __GLU_SWAP_4_BYTES(right) * highx_float;
2542                         } else {
2543                             totals[k] += *(const GLuint*)left * (1-lowx_float)
2544                                        + *(const GLuint*)right * highx_float;
2545                         }
2546                     }
2547                 }
2548             } else if (highy_int > lowy_int) {
2549                 x_percent = highx_float - lowx_float;
2550                 percent = (1-lowy_float)*x_percent;
2551                 temp = (const char *)datain + xindex + lowy_int*ysize;
2552                 for (k = 0, temp_index = temp; k < components;
2553                      k++, temp_index += element_size) {
2554                     if (myswap_bytes) {
2555                         totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;
2556                     } else {
2557                         totals[k] += *(const GLuint*)temp_index * percent;
2558                     }
2559                 }
2560                 for(m = lowy_int+1; m < highy_int; m++) {
2561                     temp += ysize;
2562                     for (k = 0, temp_index = temp; k < components;
2563                          k++, temp_index += element_size) {
2564                         if (myswap_bytes) {
2565                             totals[k] +=
2566                                  __GLU_SWAP_4_BYTES(temp_index) * x_percent;
2567                         } else {
2568                             totals[k] += *(const GLuint*)temp_index * x_percent;
2569                         }
2570                     }
2571                 }
2572                 percent = x_percent * highy_float;
2573                 temp += ysize;
2574                 for (k = 0, temp_index = temp; k < components;
2575                      k++, temp_index += element_size) {
2576                     if (myswap_bytes) {
2577                         totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;
2578                     } else {
2579                         totals[k] += *(const GLuint*)temp_index * percent;
2580                     }
2581                 }
2582             } else if (highx_int > lowx_int) {
2583                 y_percent = highy_float - lowy_float;
2584                 percent = (1-lowx_float)*y_percent;
2585
2586              temp = (const char *)datain + xindex + lowy_int*ysize;
2587                 for (k = 0, temp_index = temp; k < components;
2588                      k++, temp_index += element_size) {
2589                     if (myswap_bytes) {
2590                         totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;
2591                     } else {
2592                         totals[k] += *(const GLuint*)temp_index * percent;
2593                     }
2594                 }
2595                 for (l = lowx_int+1; l < highx_int; l++) {
2596                     temp += group_size;
2597                     for (k = 0, temp_index = temp; k < components;
2598                          k++, temp_index += element_size) {
2599                         if (myswap_bytes) {
2600                             totals[k] +=
2601                                  __GLU_SWAP_4_BYTES(temp_index) * y_percent;
2602                         } else {
2603                             totals[k] += *(const GLuint*)temp_index * y_percent;
2604                         }
2605                     }
2606                 }
2607                 temp += group_size;
2608                 percent = y_percent * highx_float;
2609                 for (k = 0, temp_index = temp; k < components;
2610                      k++, temp_index += element_size) {
2611                     if (myswap_bytes) {
2612                         totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;
2613                     } else {
2614                         totals[k] += *(const GLuint*)temp_index * percent;
2615                     }
2616                 }
2617             } else {
2618                 percent = (highy_float-lowy_float)*(highx_float-lowx_float);
2619                 temp = (const char *)datain + xindex + lowy_int * ysize;
2620                 for (k = 0, temp_index = temp; k < components;
2621                      k++, temp_index += element_size) {
2622                     if (myswap_bytes) {
2623                         totals[k] += __GLU_SWAP_4_BYTES(temp_index) * percent;
2624                     } else {
2625                         totals[k] += *(const GLuint*)temp_index * percent;
2626                     }
2627                 }
2628             }
2629
2630             /* this is for the pixels in the body */
2631             temp0 = (const char *)datain + xindex + group_size +
2632                  (lowy_int+1)*ysize;
2633             for (m = lowy_int+1; m < highy_int; m++) {
2634                 temp = temp0;
2635                 for(l = lowx_int+1; l < highx_int; l++) {
2636                     for (k = 0, temp_index = temp; k < components;
2637                          k++, temp_index += element_size) {
2638                         if (myswap_bytes) {
2639                             totals[k] += __GLU_SWAP_4_BYTES(temp_index);
2640                         } else {
2641                             totals[k] += *(const GLuint*)temp_index;
2642                         }
2643                     }
2644                     temp += group_size;
2645                 }
2646                 temp0 += ysize;
2647             }
2648
2649             outindex = (j + (i * widthout)) * components;
2650             for (k = 0; k < components; k++) {
2651                 /* clamp at UINT_MAX */
2652                 float value= totals[k]/area;
2653                 if (value >= (float) UINT_MAX) {        /* need '=' */
2654                   dataout[outindex + k] = UINT_MAX;
2655                 }
2656                 else dataout[outindex + k] = value;
2657             }
2658             lowx_int = highx_int;
2659             lowx_float = highx_float;
2660             highx_int += convx_int;
2661             highx_float += convx_float;
2662             if(highx_float > 1) {
2663                 highx_float -= 1.0;
2664                 highx_int++;
2665             }
2666         }
2667         lowy_int = highy_int;
2668         lowy_float = highy_float;
2669         highy_int += convy_int;
2670         highy_float += convy_float;
2671         if(highy_float > 1) {
2672             highy_float -= 1.0;
2673             highy_int++;
2674         }
2675     }
2676 }
2677
2678
2679
2680 static void scale_internal_int(GLint components, GLint widthin,
2681                            GLint heightin, const GLint *datain,
2682                            GLint widthout, GLint heightout,
2683                            GLint *dataout, GLint element_size,
2684                            GLint ysize, GLint group_size,
2685                            GLint myswap_bytes)
2686 {
2687     float convx;
2688     float convy;
2689     float percent;
2690     /* Max components in a format is 4, so... */
2691     float totals[4];
2692     float area;
2693     int i,j,k,xindex;
2694
2695     const char *temp, *temp0;
2696     const char *temp_index;
2697     int outindex;
2698
2699     int lowx_int, highx_int, lowy_int, highy_int;
2700     float x_percent, y_percent;
2701     float lowx_float, highx_float, lowy_float, highy_float;
2702     float convy_float, convx_float;
2703     int convy_int, convx_int;
2704     int l, m;
2705     const char *left, *right;
2706
2707     GLuint swapbuf;     /* unsigned buffer */
2708
2709     if (widthin == widthout*2 && heightin == heightout*2) {
2710         halveImage_int(components, widthin, heightin,
2711         (const GLint *)datain, (GLint *)dataout,
2712         element_size, ysize, group_size, myswap_bytes);
2713         return;
2714     }
2715     convy = (float) heightin/heightout;
2716     convx = (float) widthin/widthout;
2717     convy_int = floor(convy);
2718     convy_float = convy - convy_int;
2719     convx_int = floor(convx);
2720     convx_float = convx - convx_int;
2721
2722     area = convx * convy;
2723
2724     lowy_int = 0;
2725     lowy_float = 0;
2726     highy_int = convy_int;
2727     highy_float = convy_float;
2728
2729     for (i = 0; i < heightout; i++) {
2730         /* Clamp here to be sure we don't read beyond input buffer. */
2731         if (highy_int >= heightin)
2732             highy_int = heightin - 1;
2733         lowx_int = 0;
2734         lowx_float = 0;
2735         highx_int = convx_int;
2736         highx_float = convx_float;
2737
2738         for (j = 0; j < widthout; j++) {
2739             /*
2740             ** Ok, now apply box filter to box that goes from (lowx, lowy)
2741             ** to (highx, highy) on input data into this pixel on output
2742             ** data.
2743             */
2744             totals[0] = totals[1] = totals[2] = totals[3] = 0.0;
2745
2746             /* calculate the value for pixels in the 1st row */
2747             xindex = lowx_int*group_size;
2748             if((highy_int>lowy_int) && (highx_int>lowx_int)) {
2749
2750                 y_percent = 1-lowy_float;
2751                 temp = (const char *)datain + xindex + lowy_int * ysize;
2752                 percent = y_percent * (1-lowx_float);
2753                 for (k = 0, temp_index = temp; k < components;
2754                      k++, temp_index += element_size) {
2755                     if (myswap_bytes) {
2756                         swapbuf = __GLU_SWAP_4_BYTES(temp_index);
2757                         totals[k] += *(const GLint*)&swapbuf * percent;
2758                     } else {
2759                         totals[k] += *(const GLint*)temp_index * percent;
2760                     }
2761                 }
2762                 left = temp;
2763                 for(l = lowx_int+1; l < highx_int; l++) {
2764                     temp += group_size;
2765                     for (k = 0, temp_index = temp; k < components;
2766                          k++, temp_index += element_size) {
2767                         if (myswap_bytes) {
2768                             swapbuf = __GLU_SWAP_4_BYTES(temp_index);
2769                             totals[k] += *(const GLint*)&swapbuf * y_percent;
2770                         } else {
2771                             totals[k] += *(const GLint*)temp_index * y_percent;
2772                         }
2773                     }
2774                 }
2775                 temp += group_size;
2776                 right = temp;
2777                 percent = y_percent * highx_float;
2778                 for (k = 0, temp_index = temp; k < components;
2779                      k++, temp_index += element_size) {
2780                     if (myswap_bytes) {
2781                         swapbuf = __GLU_SWAP_4_BYTES(temp_index);
2782                         totals[k] += *(const GLint*)&swapbuf * percent;
2783                     } else {
2784                         totals[k] += *(const GLint*)temp_index * percent;
2785                     }
2786                 }
2787
2788                 /* calculate the value for pixels in the last row */
2789                 y_percent = highy_float;
2790                 percent = y_percent * (1-lowx_float);
2791                 temp = (const char *)datain + xindex + highy_int * ysize;
2792                 for (k = 0, temp_index = temp; k < components;
2793                      k++, temp_index += element_size) {
2794                     if (myswap_bytes) {
2795                         swapbuf = __GLU_SWAP_4_BYTES(temp_index);
2796                         totals[k] += *(const GLint*)&swapbuf  * percent;
2797                     } else {
2798                         totals[k] += *(const GLint*)temp_index * percent;
2799                     }
2800                 }
2801                 for(l = lowx_int+1; l < highx_int; l++) {
2802                     temp += group_size;
2803                     for (k = 0, temp_index = temp; k < components;
2804                          k++, temp_index += element_size) {
2805                         if (myswap_bytes) {
2806                             swapbuf = __GLU_SWAP_4_BYTES(temp_index);
2807                             totals[k] += *(const GLint*)&swapbuf * y_percent;
2808                         } else {
2809                             totals[k] += *(const GLint*)temp_index * y_percent;
2810                         }
2811                     }
2812                 }
2813                 temp += group_size;
2814                 percent = y_percent * highx_float;
2815                 for (k = 0, temp_index = temp; k < components;
2816                      k++, temp_index += element_size) {
2817                     if (myswap_bytes) {
2818                         swapbuf = __GLU_SWAP_4_BYTES(temp_index);
2819                         totals[k] += *(const GLint*)&swapbuf * percent;
2820                     } else {
2821                         totals[k] += *(const GLint*)temp_index * percent;
2822                     }
2823                 }
2824
2825                 /* calculate the value for pixels in the 1st and last column */
2826                 for(m = lowy_int+1; m < highy_int; m++) {
2827                     left += ysize;
2828                     right += ysize;
2829                     for (k = 0; k < components;
2830                          k++, left += element_size, right += element_size) {
2831                         if (myswap_bytes) {
2832                             swapbuf = __GLU_SWAP_4_BYTES(left);
2833                             totals[k] += *(const GLint*)&swapbuf * (1-lowx_float);
2834                             swapbuf = __GLU_SWAP_4_BYTES(right);
2835                             totals[k] += *(const GLint*)&swapbuf * highx_float;
2836                         } else {
2837                             totals[k] += *(const GLint*)left * (1-lowx_float)
2838                                        + *(const GLint*)right * highx_float;
2839                         }
2840                     }
2841                 }
2842             } else if (highy_int > lowy_int) {
2843                 x_percent = highx_float - lowx_float;
2844                 percent = (1-lowy_float)*x_percent;
2845                 temp = (const char *)datain + xindex + lowy_int*ysize;
2846                 for (k = 0, temp_index = temp; k < components;
2847                      k++, temp_index += element_size) {
2848                     if (myswap_bytes) {
2849                         swapbuf = __GLU_SWAP_4_BYTES(temp_index);
2850                         totals[k] += *(const GLint*)&swapbuf * percent;
2851                     } else {
2852                         totals[k] += *(const GLint*)temp_index * percent;
2853                     }
2854                 }
2855                 for(m = lowy_int+1; m < highy_int; m++) {
2856                     temp += ysize;
2857                     for (k = 0, temp_index = temp; k < components;
2858                          k++, temp_index += element_size) {
2859                         if (myswap_bytes) {
2860                             swapbuf = __GLU_SWAP_4_BYTES(temp_index);
2861                             totals[k] += *(const GLint*)&swapbuf * x_percent;
2862                         } else {
2863                             totals[k] += *(const GLint*)temp_index * x_percent;
2864                         }
2865                     }
2866                 }
2867                 percent = x_percent * highy_float;
2868                 temp += ysize;
2869                 for (k = 0, temp_index = temp; k < components;
2870                      k++, temp_index += element_size) {
2871                     if (myswap_bytes) {
2872                         swapbuf = __GLU_SWAP_4_BYTES(temp_index);
2873                         totals[k] += *(const GLint*)&swapbuf * percent;
2874                     } else {
2875                         totals[k] += *(const GLint*)temp_index * percent;
2876                     }
2877                 }
2878             } else if (highx_int > lowx_int) {
2879                 y_percent = highy_float - lowy_float;
2880                 percent = (1-lowx_float)*y_percent;
2881
2882                  temp = (const char *)datain + xindex + lowy_int*ysize;
2883                 for (k = 0, temp_index = temp; k < components;
2884                      k++, temp_index += element_size) {
2885                     if (myswap_bytes) {
2886                         swapbuf = __GLU_SWAP_4_BYTES(temp_index);
2887                         totals[k] += *(const GLint*)&swapbuf * percent;
2888                     } else {
2889                         totals[k] += *(const GLint*)temp_index * percent;
2890                     }
2891                 }
2892                 for (l = lowx_int+1; l < highx_int; l++) {
2893                     temp += group_size;
2894                     for (k = 0, temp_index = temp; k < components;
2895                          k++, temp_index += element_size) {
2896                         if (myswap_bytes) {
2897                             swapbuf = __GLU_SWAP_4_BYTES(temp_index);
2898                             totals[k] += *(const GLint*)&swapbuf * y_percent;
2899                         } else {
2900                             totals[k] += *(const GLint*)temp_index * y_percent;
2901                         }
2902                     }
2903                 }
2904                 temp += group_size;
2905                 percent = y_percent * highx_float;
2906                 for (k = 0, temp_index = temp; k < components;
2907                      k++, temp_index += element_size) {
2908                     if (myswap_bytes) {
2909                         swapbuf = __GLU_SWAP_4_BYTES(temp_index);
2910                         totals[k] += *(const GLint*)&swapbuf * percent;
2911                     } else {
2912                         totals[k] += *(const GLint*)temp_index * percent;
2913                     }
2914                 }
2915             } else {
2916                 percent = (highy_float-lowy_float)*(highx_float-lowx_float);
2917                 temp = (const char *)datain + xindex + lowy_int * ysize;
2918                 for (k = 0, temp_index = temp; k < components;
2919                      k++, temp_index += element_size) {
2920                     if (myswap_bytes) {
2921                         swapbuf = __GLU_SWAP_4_BYTES(temp_index);
2922                         totals[k] += *(const GLint*)&swapbuf * percent;
2923                     } else {
2924                         totals[k] += *(const GLint*)temp_index * percent;
2925                     }
2926                 }
2927             }
2928
2929             /* this is for the pixels in the body */
2930             temp0 = (const char *)datain + xindex + group_size +
2931                  (lowy_int+1)*ysize;
2932             for (m = lowy_int+1; m < highy_int; m++) {
2933                 temp = temp0;
2934                 for(l = lowx_int+1; l < highx_int; l++) {
2935                     for (k = 0, temp_index = temp; k < components;
2936                          k++, temp_index += element_size) {
2937                         if (myswap_bytes) {
2938                             swapbuf = __GLU_SWAP_4_BYTES(temp_index);
2939                             totals[k] += *(const GLint*)&swapbuf;
2940                         } else {
2941                             totals[k] += *(const GLint*)temp_index;
2942                         }
2943                     }
2944                     temp += group_size;
2945                 }
2946                 temp0 += ysize;
2947             }
2948
2949             outindex = (j + (i * widthout)) * components;
2950             for (k = 0; k < components; k++) {
2951                 dataout[outindex + k] = totals[k]/area;
2952                 /*printf("totals[%d] = %f\n", k, totals[k]);*/
2953             }
2954             lowx_int = highx_int;
2955             lowx_float = highx_float;
2956             highx_int += convx_int;
2957             highx_float += convx_float;
2958             if(highx_float > 1) {
2959                 highx_float -= 1.0;
2960                 highx_int++;
2961             }
2962         }
2963         lowy_int = highy_int;
2964         lowy_float = highy_float;
2965         highy_int += convy_int;
2966         highy_float += convy_float;
2967         if(highy_float > 1) {
2968             highy_float -= 1.0;
2969             highy_int++;
2970         }
2971     }
2972 }
2973
2974
2975
2976 static void scale_internal_float(GLint components, GLint widthin,
2977                            GLint heightin, const GLfloat *datain,
2978                            GLint widthout, GLint heightout,
2979                            GLfloat *dataout, GLint element_size,
2980                            GLint ysize, GLint group_size,
2981                            GLint myswap_bytes)
2982 {
2983     float convx;
2984     float convy;
2985     float percent;
2986     /* Max components in a format is 4, so... */
2987     float totals[4];
2988     float area;
2989     int i,j,k,xindex;
2990
2991     const char *temp, *temp0;
2992     const char *temp_index;
2993     int outindex;
2994
2995     int lowx_int, highx_int, lowy_int, highy_int;
2996     float x_percent, y_percent;
2997     float lowx_float, highx_float, lowy_float, highy_float;
2998     float convy_float, convx_float;
2999     int convy_int, convx_int;
3000     int l, m;
3001     const char *left, *right;
3002
3003     union { GLuint b; GLfloat f; } swapbuf;
3004
3005     if (widthin == widthout*2 && heightin == heightout*2) {
3006         halveImage_float(components, widthin, heightin,
3007         (const GLfloat *)datain, (GLfloat *)dataout,
3008         element_size, ysize, group_size, myswap_bytes);
3009         return;
3010     }
3011     convy = (float) heightin/heightout;
3012     convx = (float) widthin/widthout;
3013     convy_int = floor(convy);
3014     convy_float = convy - convy_int;
3015     convx_int = floor(convx);
3016     convx_float = convx - convx_int;
3017
3018     area = convx * convy;
3019
3020     lowy_int = 0;
3021     lowy_float = 0;
3022     highy_int = convy_int;
3023     highy_float = convy_float;
3024
3025     for (i = 0; i < heightout; i++) {
3026         /* Clamp here to be sure we don't read beyond input buffer. */
3027         if (highy_int >= heightin)
3028             highy_int = heightin - 1;
3029         lowx_int = 0;
3030         lowx_float = 0;
3031         highx_int = convx_int;
3032         highx_float = convx_float;
3033
3034         for (j = 0; j < widthout; j++) {
3035             /*
3036             ** Ok, now apply box filter to box that goes from (lowx, lowy)
3037             ** to (highx, highy) on input data into this pixel on output
3038             ** data.
3039             */
3040             totals[0] = totals[1] = totals[2] = totals[3] = 0.0;
3041
3042             /* calculate the value for pixels in the 1st row */
3043             xindex = lowx_int*group_size;
3044             if((highy_int>lowy_int) && (highx_int>lowx_int)) {
3045
3046                 y_percent = 1-lowy_float;
3047                 temp = (const char *)datain + xindex + lowy_int * ysize;
3048                 percent = y_percent * (1-lowx_float);
3049                 for (k = 0, temp_index = temp; k < components;
3050                      k++, temp_index += element_size) {
3051                     if (myswap_bytes) {
3052                         swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
3053                         totals[k] += swapbuf.f * percent;
3054                     } else {
3055                         totals[k] += *(const GLfloat*)temp_index * percent;
3056                     }
3057                 }
3058                 left = temp;
3059                 for(l = lowx_int+1; l < highx_int; l++) {
3060                     temp += group_size;
3061                     for (k = 0, temp_index = temp; k < components;
3062                          k++, temp_index += element_size) {
3063                         if (myswap_bytes) {
3064                             swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
3065                             totals[k] += swapbuf.f * y_percent;
3066                         } else {
3067                             totals[k] += *(const GLfloat*)temp_index * y_percent;
3068                         }
3069                     }
3070                 }
3071                 temp += group_size;
3072                 right = temp;
3073                 percent = y_percent * highx_float;
3074                 for (k = 0, temp_index = temp; k < components;
3075                      k++, temp_index += element_size) {
3076                     if (myswap_bytes) {
3077                         swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
3078                         totals[k] += swapbuf.f * percent;
3079                     } else {
3080                         totals[k] += *(const GLfloat*)temp_index * percent;
3081                     }
3082                 }
3083
3084                 /* calculate the value for pixels in the last row */
3085                 y_percent = highy_float;
3086                 percent = y_percent * (1-lowx_float);
3087                 temp = (const char *)datain + xindex + highy_int * ysize;
3088                 for (k = 0, temp_index = temp; k < components;
3089                      k++, temp_index += element_size) {
3090                     if (myswap_bytes) {
3091                         swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
3092                         totals[k] += swapbuf.f * percent;
3093                     } else {
3094                         totals[k] += *(const GLfloat*)temp_index * percent;
3095                     }
3096                 }
3097                 for(l = lowx_int+1; l < highx_int; l++) {
3098                     temp += group_size;
3099                     for (k = 0, temp_index = temp; k < components;
3100                          k++, temp_index += element_size) {
3101                         if (myswap_bytes) {
3102                             swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
3103                             totals[k] += swapbuf.f * y_percent;
3104                         } else {
3105                             totals[k] += *(const GLfloat*)temp_index * y_percent;
3106                         }
3107                     }
3108                 }
3109                 temp += group_size;
3110                 percent = y_percent * highx_float;
3111                 for (k = 0, temp_index = temp; k < components;
3112                      k++, temp_index += element_size) {
3113                     if (myswap_bytes) {
3114                         swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
3115                         totals[k] += swapbuf.f * percent;
3116                     } else {
3117                         totals[k] += *(const GLfloat*)temp_index * percent;
3118                     }
3119                 }
3120
3121                 /* calculate the value for pixels in the 1st and last column */
3122                 for(m = lowy_int+1; m < highy_int; m++) {
3123                     left += ysize;
3124                     right += ysize;
3125                     for (k = 0; k < components;
3126                          k++, left += element_size, right += element_size) {
3127                         if (myswap_bytes) {
3128                             swapbuf.b = __GLU_SWAP_4_BYTES(left);
3129                             totals[k] += swapbuf.f * (1-lowx_float);
3130                             swapbuf.b = __GLU_SWAP_4_BYTES(right);
3131                             totals[k] += swapbuf.f * highx_float;
3132                         } else {
3133                             totals[k] += *(const GLfloat*)left * (1-lowx_float)
3134                                        + *(const GLfloat*)right * highx_float;
3135                         }
3136                     }
3137                 }
3138             } else if (highy_int > lowy_int) {
3139                 x_percent = highx_float - lowx_float;
3140                 percent = (1-lowy_float)*x_percent;
3141                 temp = (const char *)datain + xindex + lowy_int*ysize;
3142                 for (k = 0, temp_index = temp; k < components;
3143                      k++, temp_index += element_size) {
3144                     if (myswap_bytes) {
3145                         swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
3146                         totals[k] += swapbuf.f * percent;
3147                     } else {
3148                         totals[k] += *(const GLfloat*)temp_index * percent;
3149                     }
3150                 }
3151                 for(m = lowy_int+1; m < highy_int; m++) {
3152                     temp += ysize;
3153                     for (k = 0, temp_index = temp; k < components;
3154                          k++, temp_index += element_size) {
3155                         if (myswap_bytes) {
3156                             swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
3157                             totals[k] += swapbuf.f * x_percent;
3158                         } else {
3159                             totals[k] += *(const GLfloat*)temp_index * x_percent;
3160                         }
3161                     }
3162                 }
3163                 percent = x_percent * highy_float;
3164                 temp += ysize;
3165                 for (k = 0, temp_index = temp; k < components;
3166                      k++, temp_index += element_size) {
3167                     if (myswap_bytes) {
3168                         swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
3169                         totals[k] += swapbuf.f * percent;
3170                     } else {
3171                         totals[k] += *(const GLfloat*)temp_index * percent;
3172                     }
3173                 }
3174             } else if (highx_int > lowx_int) {
3175                 y_percent = highy_float - lowy_float;
3176                 percent = (1-lowx_float)*y_percent;
3177
3178              temp = (const char *)datain + xindex + lowy_int*ysize;
3179                 for (k = 0, temp_index = temp; k < components;
3180                      k++, temp_index += element_size) {
3181                     if (myswap_bytes) {
3182                         swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
3183                         totals[k] += swapbuf.f * percent;
3184                     } else {
3185                         totals[k] += *(const GLfloat*)temp_index * percent;
3186                     }
3187                 }
3188                 for (l = lowx_int+1; l < highx_int; l++) {
3189                     temp += group_size;
3190                     for (k = 0, temp_index = temp; k < components;
3191                          k++, temp_index += element_size) {
3192                         if (myswap_bytes) {
3193                             swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
3194                             totals[k] += swapbuf.f * y_percent;
3195                         } else {
3196                             totals[k] += *(const GLfloat*)temp_index * y_percent;
3197                         }
3198                     }
3199                 }
3200                 temp += group_size;
3201                 percent = y_percent * highx_float;
3202                 for (k = 0, temp_index = temp; k < components;
3203                      k++, temp_index += element_size) {
3204                     if (myswap_bytes) {
3205                         swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
3206                         totals[k] += swapbuf.f * percent;
3207                     } else {
3208                         totals[k] += *(const GLfloat*)temp_index * percent;
3209                     }
3210                 }
3211             } else {
3212                 percent = (highy_float-lowy_float)*(highx_float-lowx_float);
3213                 temp = (const char *)datain + xindex + lowy_int * ysize;
3214                 for (k = 0, temp_index = temp; k < components;
3215                      k++, temp_index += element_size) {
3216                     if (myswap_bytes) {
3217                         swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
3218                         totals[k] += swapbuf.f * percent;
3219                     } else {
3220                         totals[k] += *(const GLfloat*)temp_index * percent;
3221                     }
3222                 }
3223             }
3224
3225             /* this is for the pixels in the body */
3226             temp0 = (const char *)datain + xindex + group_size +
3227                  (lowy_int+1)*ysize;
3228             for (m = lowy_int+1; m < highy_int; m++) {
3229                 temp = temp0;
3230                 for(l = lowx_int+1; l < highx_int; l++) {
3231                     for (k = 0, temp_index = temp; k < components;
3232                          k++, temp_index += element_size) {
3233                         if (myswap_bytes) {
3234                             swapbuf.b = __GLU_SWAP_4_BYTES(temp_index);
3235                             totals[k] += swapbuf.f;
3236                         } else {
3237                             totals[k] += *(const GLfloat*)temp_index;
3238                         }
3239                     }
3240                     temp += group_size;
3241                 }
3242                 temp0 += ysize;
3243             }
3244
3245             outindex = (j + (i * widthout)) * components;
3246             for (k = 0; k < components; k++) {
3247                 dataout[outindex + k] = totals[k]/area;
3248                 /*printf("totals[%d] = %f\n", k, totals[k]);*/
3249             }
3250             lowx_int = highx_int;
3251             lowx_float = highx_float;
3252             highx_int += convx_int;
3253             highx_float += convx_float;
3254             if(highx_float > 1) {
3255                 highx_float -= 1.0;
3256                 highx_int++;
3257             }
3258         }
3259         lowy_int = highy_int;
3260         lowy_float = highy_float;
3261         highy_int += convy_int;
3262         highy_float += convy_float;
3263         if(highy_float > 1) {
3264             highy_float -= 1.0;
3265             highy_int++;
3266         }
3267     }
3268 }
3269
3270 static int checkMipmapArgs(GLenum internalFormat, GLenum format, GLenum type)
3271 {
3272     if (!legalFormat(format) || !legalType(type)) {
3273         return GLU_INVALID_ENUM;
3274     }
3275     if (format == GL_STENCIL_INDEX) {
3276         return GLU_INVALID_ENUM;
3277     }
3278
3279     if (!isLegalFormatForPackedPixelType(format, type)) {
3280         return GLU_INVALID_OPERATION;
3281     }
3282
3283     return 0;
3284 } /* checkMipmapArgs() */
3285
3286 static GLboolean legalFormat(GLenum format)
3287 {
3288     switch(format) {
3289       case GL_COLOR_INDEX:
3290       case GL_STENCIL_INDEX:
3291       case GL_DEPTH_COMPONENT:
3292       case GL_RED:
3293       case GL_GREEN:
3294       case GL_BLUE:
3295       case GL_ALPHA:
3296       case GL_RGB:
3297       case GL_RGBA:
3298       case GL_LUMINANCE:
3299       case GL_LUMINANCE_ALPHA:
3300       case GL_BGR:
3301       case GL_BGRA:
3302         return GL_TRUE;
3303       default:
3304         return GL_FALSE;
3305     }
3306 }
3307
3308
3309 static GLboolean legalType(GLenum type)
3310 {
3311     switch(type) {
3312       case GL_BITMAP:
3313       case GL_BYTE:
3314       case GL_UNSIGNED_BYTE:
3315       case GL_SHORT:
3316       case GL_UNSIGNED_SHORT:
3317       case GL_INT:
3318       case GL_UNSIGNED_INT:
3319       case GL_FLOAT:
3320       case GL_UNSIGNED_BYTE_3_3_2:
3321       case GL_UNSIGNED_BYTE_2_3_3_REV:
3322       case GL_UNSIGNED_SHORT_5_6_5:
3323       case GL_UNSIGNED_SHORT_5_6_5_REV:
3324       case GL_UNSIGNED_SHORT_4_4_4_4:
3325       case GL_UNSIGNED_SHORT_4_4_4_4_REV:
3326       case GL_UNSIGNED_SHORT_5_5_5_1:
3327       case GL_UNSIGNED_SHORT_1_5_5_5_REV:
3328       case GL_UNSIGNED_INT_8_8_8_8:
3329       case GL_UNSIGNED_INT_8_8_8_8_REV:
3330       case GL_UNSIGNED_INT_10_10_10_2:
3331       case GL_UNSIGNED_INT_2_10_10_10_REV:
3332          return GL_TRUE;
3333       default:
3334         return GL_FALSE;
3335     }
3336 }
3337
3338 /* */
3339 static GLboolean isTypePackedPixel(GLenum type)
3340 {
3341    assert(legalType(type));
3342
3343    if (type == GL_UNSIGNED_BYTE_3_3_2 ||
3344        type == GL_UNSIGNED_BYTE_2_3_3_REV ||
3345        type == GL_UNSIGNED_SHORT_5_6_5 ||
3346        type == GL_UNSIGNED_SHORT_5_6_5_REV ||
3347        type == GL_UNSIGNED_SHORT_4_4_4_4 ||
3348        type == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
3349        type == GL_UNSIGNED_SHORT_5_5_5_1 ||
3350        type == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
3351        type == GL_UNSIGNED_INT_8_8_8_8 ||
3352        type == GL_UNSIGNED_INT_8_8_8_8_REV ||
3353        type == GL_UNSIGNED_INT_10_10_10_2 ||
3354        type == GL_UNSIGNED_INT_2_10_10_10_REV) {
3355       return 1;
3356    }
3357    else return 0;
3358 } /* isTypePackedPixel() */
3359
3360 /* Determines if the packed pixel type is compatible with the format */
3361 static GLboolean isLegalFormatForPackedPixelType(GLenum format, GLenum type)
3362 {
3363    /* if not a packed pixel type then return true */
3364    if (!isTypePackedPixel(type)) {
3365       return GL_TRUE;
3366    }
3367
3368    /* 3_3_2/2_3_3_REV & 5_6_5/5_6_5_REV are only compatible with RGB */
3369    if ((type == GL_UNSIGNED_BYTE_3_3_2 || type == GL_UNSIGNED_BYTE_2_3_3_REV||
3370         type == GL_UNSIGNED_SHORT_5_6_5|| type == GL_UNSIGNED_SHORT_5_6_5_REV)
3371        && format != GL_RGB)
3372       return GL_FALSE;
3373
3374    /* 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 &
3375     * 10_10_10_2/2_10_10_10_REV are only compatible with RGBA, BGRA & ABGR_EXT.
3376     */
3377    if ((type == GL_UNSIGNED_SHORT_4_4_4_4 ||
3378         type == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
3379         type == GL_UNSIGNED_SHORT_5_5_5_1 ||
3380         type == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
3381         type == GL_UNSIGNED_INT_8_8_8_8 ||
3382         type == GL_UNSIGNED_INT_8_8_8_8_REV ||
3383         type == GL_UNSIGNED_INT_10_10_10_2 ||
3384         type == GL_UNSIGNED_INT_2_10_10_10_REV) &&
3385        (format != GL_RGBA &&
3386         format != GL_BGRA)) {
3387       return GL_FALSE;
3388    }
3389
3390    return GL_TRUE;
3391 } /* isLegalFormatForPackedPixelType() */
3392
3393 static GLboolean isLegalLevels(GLint userLevel,GLint baseLevel,GLint maxLevel,
3394                                GLint totalLevels)
3395 {
3396    if (baseLevel < 0 || baseLevel < userLevel || maxLevel < baseLevel ||
3397        totalLevels < maxLevel)
3398       return GL_FALSE;
3399    else return GL_TRUE;
3400 } /* isLegalLevels() */
3401
3402 /* Given user requested texture size, determine if it fits. If it
3403  * doesn't then halve both sides and make the determination again
3404  * until it does fit (for IR only).
3405  * Note that proxy textures are not implemented in RE* even though
3406  * they advertise the texture extension.
3407  * Note that proxy textures are implemented but not according to spec in
3408  * IMPACT*.
3409  */
3410 static void closestFit(GLenum target, GLint width, GLint height,
3411                        GLint internalFormat, GLenum format, GLenum type,
3412                        GLint *newWidth, GLint *newHeight)
3413 {
3414    /* Use proxy textures if OpenGL version is >= 1.1 */
3415    if ( (strtod((const char *)glGetString(GL_VERSION),NULL) >= 1.1)
3416         ) {
3417       GLint widthPowerOf2= nearestPower(width);
3418       GLint heightPowerOf2= nearestPower(height);
3419       GLint proxyWidth;
3420
3421       do {
3422          /* compute level 1 width & height, clamping each at 1 */
3423          GLint widthAtLevelOne= (widthPowerOf2 > 1) ?
3424                                  widthPowerOf2 >> 1 :
3425                                  widthPowerOf2;
3426          GLint heightAtLevelOne= (heightPowerOf2 > 1) ?
3427                                   heightPowerOf2 >> 1 :
3428                                   heightPowerOf2;
3429          GLenum proxyTarget;
3430          assert(widthAtLevelOne > 0); assert(heightAtLevelOne > 0);
3431
3432          /* does width x height at level 1 & all their mipmaps fit? */
3433          if (target == GL_TEXTURE_2D || target == GL_PROXY_TEXTURE_2D) {
3434             proxyTarget = GL_PROXY_TEXTURE_2D;
3435             glTexImage2D(proxyTarget, 1, /* must be non-zero */
3436                          internalFormat,
3437                          widthAtLevelOne,heightAtLevelOne,0,format,type,NULL);
3438          } else
3439 #if defined(GL_ARB_texture_cube_map)
3440          if ((target == GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB) ||
3441              (target == GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB) ||
3442              (target == GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB) ||
3443              (target == GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB) ||
3444              (target == GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB) ||
3445              (target == GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB)) {
3446              proxyTarget = GL_PROXY_TEXTURE_CUBE_MAP_ARB;
3447              glTexImage2D(proxyTarget, 1, /* must be non-zero */
3448                           internalFormat,
3449                           widthAtLevelOne,heightAtLevelOne,0,format,type,NULL);
3450          } else
3451 #endif /* GL_ARB_texture_cube_map */
3452          {
3453             assert(target == GL_TEXTURE_1D || target == GL_PROXY_TEXTURE_1D);
3454             proxyTarget = GL_PROXY_TEXTURE_1D;
3455             glTexImage1D(proxyTarget, 1, /* must be non-zero */
3456                          internalFormat,widthAtLevelOne,0,format,type,NULL);
3457          }
3458          glGetTexLevelParameteriv(proxyTarget, 1,GL_TEXTURE_WIDTH,&proxyWidth);
3459          /* does it fit??? */
3460          if (proxyWidth == 0) { /* nope, so try again with these sizes */
3461             if (widthPowerOf2 == 1 && heightPowerOf2 == 1) {
3462                /* An 1x1 texture couldn't fit for some reason, so
3463                 * break out.  This should never happen. But things
3464                 * happen.  The disadvantage with this if-statement is
3465                 * that we will never be aware of when this happens
3466                 * since it will silently branch out.
3467                 */
3468                goto noProxyTextures;
3469             }
3470             widthPowerOf2= widthAtLevelOne;
3471             heightPowerOf2= heightAtLevelOne;
3472          }
3473          /* else it does fit */
3474       } while (proxyWidth == 0);
3475       /* loop must terminate! */
3476
3477       /* return the width & height at level 0 that fits */
3478       *newWidth= widthPowerOf2;
3479       *newHeight= heightPowerOf2;
3480 /*printf("Proxy Textures\n");*/
3481    } /* if gluCheckExtension() */
3482    else {                       /* no texture extension, so do this instead */
3483       GLint maxsize;
3484
3485 noProxyTextures:
3486
3487       glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxsize);
3488       /* clamp user's texture sizes to maximum sizes, if necessary */
3489       *newWidth = nearestPower(width);
3490       if (*newWidth > maxsize) *newWidth = maxsize;
3491       *newHeight = nearestPower(height);
3492       if (*newHeight > maxsize) *newHeight = maxsize;
3493 /*printf("NO proxy textures\n");*/
3494    }
3495 } /* closestFit() */
3496
3497 GLint GLAPIENTRY
3498 gluScaleImage(GLenum format, GLsizei widthin, GLsizei heightin,
3499                     GLenum typein, const void *datain,
3500                     GLsizei widthout, GLsizei heightout, GLenum typeout,
3501                     void *dataout)
3502 {
3503     int components;
3504     GLushort *beforeImage;
3505     GLushort *afterImage;
3506     PixelStorageModes psm;
3507
3508     if (widthin == 0 || heightin == 0 || widthout == 0 || heightout == 0) {
3509         return 0;
3510     }
3511     if (widthin < 0 || heightin < 0 || widthout < 0 || heightout < 0) {
3512         return GLU_INVALID_VALUE;
3513     }
3514     if (!legalFormat(format) || !legalType(typein) || !legalType(typeout)) {
3515         return GLU_INVALID_ENUM;
3516     }
3517     if (!isLegalFormatForPackedPixelType(format, typein)) {
3518        return GLU_INVALID_OPERATION;
3519     }
3520     if (!isLegalFormatForPackedPixelType(format, typeout)) {
3521        return GLU_INVALID_OPERATION;
3522     }
3523     beforeImage =
3524         malloc(image_size(widthin, heightin, format, GL_UNSIGNED_SHORT));
3525     afterImage =
3526         malloc(image_size(widthout, heightout, format, GL_UNSIGNED_SHORT));
3527     if (beforeImage == NULL || afterImage == NULL) {
3528         free(beforeImage);
3529         free(afterImage);
3530         return GLU_OUT_OF_MEMORY;
3531     }
3532
3533     retrieveStoreModes(&psm);
3534     fill_image(&psm,widthin, heightin, format, typein, is_index(format),
3535             datain, beforeImage);
3536     components = elements_per_group(format, 0);
3537     scale_internal(components, widthin, heightin, beforeImage,
3538             widthout, heightout, afterImage);
3539     empty_image(&psm,widthout, heightout, format, typeout,
3540             is_index(format), afterImage, dataout);
3541     free((GLbyte *) beforeImage);
3542     free((GLbyte *) afterImage);
3543
3544     return 0;
3545 }
3546
3547 int gluBuild1DMipmapLevelsCore(GLenum target, GLint internalFormat,
3548                                GLsizei width,
3549                                GLsizei widthPowerOf2,
3550                                GLenum format, GLenum type,
3551                                GLint userLevel, GLint baseLevel,GLint maxLevel,
3552                                const void *data)
3553 {
3554     GLint newwidth;
3555     GLint level, levels;
3556     GLushort *newImage;
3557     GLint newImage_width;
3558     GLushort *otherImage;
3559     GLushort *imageTemp;
3560     GLint memreq;
3561     GLint cmpts;
3562     PixelStorageModes psm;
3563
3564     assert(checkMipmapArgs(internalFormat,format,type) == 0);
3565     assert(width >= 1);
3566
3567     otherImage = NULL;
3568
3569     newwidth= widthPowerOf2;
3570     levels = computeLog(newwidth);
3571
3572     levels+= userLevel;
3573
3574     retrieveStoreModes(&psm);
3575     newImage = (GLushort *)
3576         malloc(image_size(width, 1, format, GL_UNSIGNED_SHORT));
3577     newImage_width = width;
3578     if (newImage == NULL) {
3579         return GLU_OUT_OF_MEMORY;
3580     }
3581     fill_image(&psm,width, 1, format, type, is_index(format),
3582             data, newImage);
3583     cmpts = elements_per_group(format,type);
3584     glPixelStorei(GL_UNPACK_ALIGNMENT, 2);
3585     glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
3586     glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
3587     glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
3588     /*
3589     ** If swap_bytes was set, swapping occurred in fill_image.
3590     */
3591     glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE);
3592
3593     for (level = userLevel; level <= levels; level++) {
3594         if (newImage_width == newwidth) {
3595             /* Use newImage for this level */
3596             if (baseLevel <= level && level <= maxLevel) {
3597             glTexImage1D(target, level, internalFormat, newImage_width,
3598                     0, format, GL_UNSIGNED_SHORT, (void *) newImage);
3599             }
3600         } else {
3601             if (otherImage == NULL) {
3602                 memreq = image_size(newwidth, 1, format, GL_UNSIGNED_SHORT);
3603                 otherImage = (GLushort *) malloc(memreq);
3604                 if (otherImage == NULL) {
3605                     glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
3606                     glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
3607                     glPixelStorei(GL_UNPACK_SKIP_PIXELS,psm.unpack_skip_pixels);
3608                     glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
3609                     glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
3610                     free(newImage);
3611                     return GLU_OUT_OF_MEMORY;
3612                 }
3613             }
3614             scale_internal(cmpts, newImage_width, 1, newImage,
3615                     newwidth, 1, otherImage);
3616             /* Swap newImage and otherImage */
3617             imageTemp = otherImage;
3618             otherImage = newImage;
3619             newImage = imageTemp;
3620
3621             newImage_width = newwidth;
3622             if (baseLevel <= level && level <= maxLevel) {
3623             glTexImage1D(target, level, internalFormat, newImage_width,
3624                     0, format, GL_UNSIGNED_SHORT, (void *) newImage);
3625             }
3626         }
3627         if (newwidth > 1) newwidth /= 2;
3628     }
3629     glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
3630     glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
3631     glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
3632     glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
3633     glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
3634
3635     free((GLbyte *) newImage);
3636     if (otherImage) {
3637         free((GLbyte *) otherImage);
3638     }
3639     return 0;
3640 }
3641
3642 GLint GLAPIENTRY
3643 gluBuild1DMipmapLevels(GLenum target, GLint internalFormat,
3644                              GLsizei width,
3645                              GLenum format, GLenum type,
3646                              GLint userLevel, GLint baseLevel, GLint maxLevel,
3647                              const void *data)
3648 {
3649    int levels;
3650
3651    int rc= checkMipmapArgs(internalFormat,format,type);
3652    if (rc != 0) return rc;
3653
3654    if (width < 1) {
3655        return GLU_INVALID_VALUE;
3656    }
3657
3658    levels = computeLog(width);
3659
3660    levels+= userLevel;
3661    if (!isLegalLevels(userLevel,baseLevel,maxLevel,levels))
3662       return GLU_INVALID_VALUE;
3663
3664    return gluBuild1DMipmapLevelsCore(target, internalFormat,
3665                                      width,
3666                                      width,format, type,
3667                                      userLevel, baseLevel, maxLevel,
3668                                      data);
3669 } /* gluBuild1DMipmapLevels() */
3670
3671 GLint GLAPIENTRY
3672 gluBuild1DMipmaps(GLenum target, GLint internalFormat, GLsizei width,
3673                         GLenum format, GLenum type,
3674                         const void *data)
3675 {
3676    GLint widthPowerOf2;
3677    int levels;
3678    GLint dummy;
3679
3680    int rc= checkMipmapArgs(internalFormat,format,type);
3681    if (rc != 0) return rc;
3682
3683    if (width < 1) {
3684        return GLU_INVALID_VALUE;
3685    }
3686
3687    closestFit(target,width,1,internalFormat,format,type,&widthPowerOf2,&dummy);
3688    levels = computeLog(widthPowerOf2);
3689
3690    return gluBuild1DMipmapLevelsCore(target,internalFormat,
3691                                      width,
3692                                      widthPowerOf2,
3693                                      format,type,0,0,levels,data);
3694 }
3695
3696 static int bitmapBuild2DMipmaps(GLenum target, GLint internalFormat,
3697                      GLint width, GLint height, GLenum format,
3698                      GLenum type, const void *data)
3699 {
3700     GLint newwidth, newheight;
3701     GLint level, levels;
3702     GLushort *newImage;
3703     GLint newImage_width;
3704     GLint newImage_height;
3705     GLushort *otherImage;
3706     GLushort *imageTemp;
3707     GLint memreq;
3708     GLint cmpts;
3709     PixelStorageModes psm;
3710
3711     retrieveStoreModes(&psm);
3712
3713 #if 0
3714     glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxsize);
3715     newwidth = nearestPower(width);
3716     if (newwidth > maxsize) newwidth = maxsize;
3717     newheight = nearestPower(height);
3718     if (newheight > maxsize) newheight = maxsize;
3719 #else
3720     closestFit(target,width,height,internalFormat,format,type,
3721                &newwidth,&newheight);
3722 #endif
3723     levels = computeLog(newwidth);
3724     level = computeLog(newheight);
3725     if (level > levels) levels=level;
3726
3727     otherImage = NULL;
3728     newImage = (GLushort *)
3729         malloc(image_size(width, height, format, GL_UNSIGNED_SHORT));
3730     newImage_width = width;
3731     newImage_height = height;
3732     if (newImage == NULL) {
3733         return GLU_OUT_OF_MEMORY;
3734     }
3735
3736     fill_image(&psm,width, height, format, type, is_index(format),
3737           data, newImage);
3738
3739     cmpts = elements_per_group(format,type);
3740     glPixelStorei(GL_UNPACK_ALIGNMENT, 2);
3741     glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
3742     glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
3743     glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
3744     /*
3745     ** If swap_bytes was set, swapping occurred in fill_image.
3746     */
3747     glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE);
3748
3749     for (level = 0; level <= levels; level++) {
3750         if (newImage_width == newwidth && newImage_height == newheight) {            /* Use newImage for this level */
3751             glTexImage2D(target, level, internalFormat, newImage_width,
3752                     newImage_height, 0, format, GL_UNSIGNED_SHORT,
3753                     (void *) newImage);
3754         } else {
3755             if (otherImage == NULL) {
3756                 memreq =
3757                     image_size(newwidth, newheight, format, GL_UNSIGNED_SHORT);
3758                 otherImage = (GLushort *) malloc(memreq);
3759                 if (otherImage == NULL) {
3760                     glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
3761                     glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
3762                     glPixelStorei(GL_UNPACK_SKIP_PIXELS,psm.unpack_skip_pixels);
3763                     glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
3764                     glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
3765                     free(newImage);
3766                     return GLU_OUT_OF_MEMORY;
3767                 }
3768             }
3769             scale_internal(cmpts, newImage_width, newImage_height, newImage,
3770                     newwidth, newheight, otherImage);
3771             /* Swap newImage and otherImage */
3772             imageTemp = otherImage;
3773             otherImage = newImage;
3774             newImage = imageTemp;
3775
3776             newImage_width = newwidth;
3777             newImage_height = newheight;
3778             glTexImage2D(target, level, internalFormat, newImage_width,
3779                     newImage_height, 0, format, GL_UNSIGNED_SHORT,
3780                     (void *) newImage);
3781         }
3782         if (newwidth > 1) newwidth /= 2;
3783         if (newheight > 1) newheight /= 2;
3784     }
3785     glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
3786     glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
3787     glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
3788     glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
3789     glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
3790
3791     free((GLbyte *) newImage);
3792     if (otherImage) {
3793         free((GLbyte *) otherImage);
3794     }
3795     return 0;
3796 }
3797
3798 /* To make swapping images less error prone */
3799 #define __GLU_INIT_SWAP_IMAGE void *tmpImage
3800 #define __GLU_SWAP_IMAGE(a,b) tmpImage = a; a = b; b = tmpImage;
3801
3802 static int gluBuild2DMipmapLevelsCore(GLenum target, GLint internalFormat,
3803                                       GLsizei width, GLsizei height,
3804                                       GLsizei widthPowerOf2,
3805                                       GLsizei heightPowerOf2,
3806                                       GLenum format, GLenum type,
3807                                       GLint userLevel,
3808                                       GLint baseLevel,GLint maxLevel,
3809                                       const void *data)
3810 {
3811     GLint newwidth, newheight;
3812     GLint level, levels;
3813     const void *usersImage; /* passed from user. Don't touch! */
3814     void *srcImage, *dstImage; /* scratch area to build mipmapped images */
3815     __GLU_INIT_SWAP_IMAGE;
3816     GLint memreq;
3817     GLint cmpts;
3818
3819     GLint myswap_bytes, groups_per_line, element_size, group_size;
3820     GLint rowsize, padding;
3821     PixelStorageModes psm;
3822
3823     assert(checkMipmapArgs(internalFormat,format,type) == 0);
3824     assert(width >= 1 && height >= 1);
3825
3826     if(type == GL_BITMAP) {
3827         return bitmapBuild2DMipmaps(target, internalFormat, width, height,
3828                 format, type, data);
3829     }
3830
3831     srcImage = dstImage = NULL;
3832
3833     newwidth= widthPowerOf2;
3834     newheight= heightPowerOf2;
3835     levels = computeLog(newwidth);
3836     level = computeLog(newheight);
3837     if (level > levels) levels=level;
3838
3839     levels+= userLevel;
3840
3841     retrieveStoreModes(&psm);
3842     myswap_bytes = psm.unpack_swap_bytes;
3843     cmpts = elements_per_group(format,type);
3844     if (psm.unpack_row_length > 0) {
3845         groups_per_line = psm.unpack_row_length;
3846     } else {
3847         groups_per_line = width;
3848     }
3849
3850     element_size = bytes_per_element(type);
3851     group_size = element_size * cmpts;
3852     if (element_size == 1) myswap_bytes = 0;
3853
3854     rowsize = groups_per_line * group_size;
3855     padding = (rowsize % psm.unpack_alignment);
3856     if (padding) {
3857         rowsize += psm.unpack_alignment - padding;
3858     }
3859     usersImage = (const GLubyte *) data + psm.unpack_skip_rows * rowsize +
3860         psm.unpack_skip_pixels * group_size;
3861
3862     glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
3863     glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
3864     glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
3865
3866     level = userLevel;
3867
3868     /* already power-of-two square */
3869     if (width == newwidth && height == newheight) {
3870         /* Use usersImage for level userLevel */
3871         if (baseLevel <= level && level <= maxLevel) {
3872         glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
3873         glTexImage2D(target, level, internalFormat, width,
3874                 height, 0, format, type,
3875                 usersImage);
3876         }
3877         glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
3878         if(levels == 0) { /* we're done. clean up and return */
3879           glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
3880           glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
3881           glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
3882           glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
3883           glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
3884           return 0;
3885         }
3886         {
3887            int nextWidth= newwidth/2;
3888            int nextHeight= newheight/2;
3889
3890            /* clamp to 1 */
3891            if (nextWidth < 1) nextWidth= 1;
3892            if (nextHeight < 1) nextHeight= 1;
3893         memreq = image_size(nextWidth, nextHeight, format, type);
3894         }
3895
3896         switch(type) {
3897         case GL_UNSIGNED_BYTE:
3898           dstImage = (GLubyte *)malloc(memreq);
3899           break;
3900         case GL_BYTE:
3901           dstImage = (GLbyte *)malloc(memreq);
3902           break;
3903         case GL_UNSIGNED_SHORT:
3904           dstImage = (GLushort *)malloc(memreq);
3905           break;
3906         case GL_SHORT:
3907           dstImage = (GLshort *)malloc(memreq);
3908           break;
3909         case GL_UNSIGNED_INT:
3910           dstImage = (GLuint *)malloc(memreq);
3911           break;
3912         case GL_INT:
3913           dstImage = (GLint *)malloc(memreq);
3914           break;
3915         case GL_FLOAT:
3916           dstImage = (GLfloat *)malloc(memreq);
3917           break;
3918         case GL_UNSIGNED_BYTE_3_3_2:
3919         case GL_UNSIGNED_BYTE_2_3_3_REV:
3920           dstImage = (GLubyte *)malloc(memreq);
3921           break;
3922         case GL_UNSIGNED_SHORT_5_6_5:
3923         case GL_UNSIGNED_SHORT_5_6_5_REV:
3924         case GL_UNSIGNED_SHORT_4_4_4_4:
3925         case GL_UNSIGNED_SHORT_4_4_4_4_REV:
3926         case GL_UNSIGNED_SHORT_5_5_5_1:
3927         case GL_UNSIGNED_SHORT_1_5_5_5_REV:
3928           dstImage = (GLushort *)malloc(memreq);
3929           break;
3930         case GL_UNSIGNED_INT_8_8_8_8:
3931         case GL_UNSIGNED_INT_8_8_8_8_REV:
3932         case GL_UNSIGNED_INT_10_10_10_2:
3933         case GL_UNSIGNED_INT_2_10_10_10_REV:
3934           dstImage = (GLuint *)malloc(memreq);
3935           break;
3936         default:
3937           return GLU_INVALID_ENUM;
3938         }
3939         if (dstImage == NULL) {
3940           glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
3941           glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
3942           glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
3943           glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
3944           glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
3945           return GLU_OUT_OF_MEMORY;
3946         }
3947         else
3948           switch(type) {
3949           case GL_UNSIGNED_BYTE:
3950             halveImage_ubyte(cmpts, width, height,
3951                              (const GLubyte *)usersImage, (GLubyte *)dstImage,
3952                              element_size, rowsize, group_size);
3953             break;
3954           case GL_BYTE:
3955             halveImage_byte(cmpts, width, height,
3956                             (const GLbyte *)usersImage, (GLbyte *)dstImage,
3957                             element_size, rowsize, group_size);
3958             break;
3959           case GL_UNSIGNED_SHORT:
3960             halveImage_ushort(cmpts, width, height,
3961                               (const GLushort *)usersImage, (GLushort *)dstImage,
3962                               element_size, rowsize, group_size, myswap_bytes);
3963             break;
3964           case GL_SHORT:
3965             halveImage_short(cmpts, width, height,
3966                              (const GLshort *)usersImage, (GLshort *)dstImage,
3967                              element_size, rowsize, group_size, myswap_bytes);
3968             break;
3969           case GL_UNSIGNED_INT:
3970             halveImage_uint(cmpts, width, height,
3971                             (const GLuint *)usersImage, (GLuint *)dstImage,
3972                             element_size, rowsize, group_size, myswap_bytes);
3973             break;
3974           case GL_INT:
3975             halveImage_int(cmpts, width, height,
3976                            (const GLint *)usersImage, (GLint *)dstImage,
3977                            element_size, rowsize, group_size, myswap_bytes);
3978             break;
3979           case GL_FLOAT:
3980             halveImage_float(cmpts, width, height,
3981                              (const GLfloat *)usersImage, (GLfloat *)dstImage,
3982                              element_size, rowsize, group_size, myswap_bytes);
3983             break;
3984           case GL_UNSIGNED_BYTE_3_3_2:
3985             assert(format == GL_RGB);
3986             halveImagePackedPixel(3,extract332,shove332,
3987                                   width,height,usersImage,dstImage,
3988                                   element_size,rowsize,myswap_bytes);
3989             break;
3990           case GL_UNSIGNED_BYTE_2_3_3_REV:
3991             assert(format == GL_RGB);
3992             halveImagePackedPixel(3,extract233rev,shove233rev,
3993                                   width,height,usersImage,dstImage,
3994                                   element_size,rowsize,myswap_bytes);
3995             break;
3996           case GL_UNSIGNED_SHORT_5_6_5:
3997             halveImagePackedPixel(3,extract565,shove565,
3998                                   width,height,usersImage,dstImage,
3999                                   element_size,rowsize,myswap_bytes);
4000             break;
4001           case GL_UNSIGNED_SHORT_5_6_5_REV:
4002             halveImagePackedPixel(3,extract565rev,shove565rev,
4003                                   width,height,usersImage,dstImage,
4004                                   element_size,rowsize,myswap_bytes);
4005             break;
4006           case GL_UNSIGNED_SHORT_4_4_4_4:
4007             halveImagePackedPixel(4,extract4444,shove4444,
4008                                   width,height,usersImage,dstImage,
4009                                   element_size,rowsize,myswap_bytes);
4010             break;
4011           case GL_UNSIGNED_SHORT_4_4_4_4_REV:
4012             halveImagePackedPixel(4,extract4444rev,shove4444rev,
4013                                   width,height,usersImage,dstImage,
4014                                   element_size,rowsize,myswap_bytes);
4015             break;
4016           case GL_UNSIGNED_SHORT_5_5_5_1:
4017             halveImagePackedPixel(4,extract5551,shove5551,
4018                                   width,height,usersImage,dstImage,
4019                                   element_size,rowsize,myswap_bytes);
4020             break;
4021           case GL_UNSIGNED_SHORT_1_5_5_5_REV:
4022             halveImagePackedPixel(4,extract1555rev,shove1555rev,
4023                                   width,height,usersImage,dstImage,
4024                                   element_size,rowsize,myswap_bytes);
4025             break;
4026           case GL_UNSIGNED_INT_8_8_8_8:
4027             halveImagePackedPixel(4,extract8888,shove8888,
4028                                   width,height,usersImage,dstImage,
4029                                   element_size,rowsize,myswap_bytes);
4030             break;
4031           case GL_UNSIGNED_INT_8_8_8_8_REV:
4032             halveImagePackedPixel(4,extract8888rev,shove8888rev,
4033                                   width,height,usersImage,dstImage,
4034                                   element_size,rowsize,myswap_bytes);
4035             break;
4036           case GL_UNSIGNED_INT_10_10_10_2:
4037             halveImagePackedPixel(4,extract1010102,shove1010102,
4038                                   width,height,usersImage,dstImage,
4039                                   element_size,rowsize,myswap_bytes);
4040             break;
4041           case GL_UNSIGNED_INT_2_10_10_10_REV:
4042             halveImagePackedPixel(4,extract2101010rev,shove2101010rev,
4043                                   width,height,usersImage,dstImage,
4044                                   element_size,rowsize,myswap_bytes);
4045             break;
4046           default:
4047             assert(0);
4048             break;
4049           }
4050         newwidth = width/2;
4051         newheight = height/2;
4052         /* clamp to 1 */
4053         if (newwidth < 1) newwidth= 1;
4054         if (newheight < 1) newheight= 1;
4055
4056         myswap_bytes = 0;
4057         rowsize = newwidth * group_size;
4058         memreq = image_size(newwidth, newheight, format, type);
4059         /* Swap srcImage and dstImage */
4060         __GLU_SWAP_IMAGE(srcImage,dstImage);
4061         switch(type) {
4062         case GL_UNSIGNED_BYTE:
4063           dstImage = (GLubyte *)malloc(memreq);
4064           break;
4065         case GL_BYTE:
4066           dstImage = (GLbyte *)malloc(memreq);
4067           break;
4068         case GL_UNSIGNED_SHORT:
4069           dstImage = (GLushort *)malloc(memreq);
4070           break;
4071         case GL_SHORT:
4072           dstImage = (GLshort *)malloc(memreq);
4073           break;
4074         case GL_UNSIGNED_INT:
4075           dstImage = (GLuint *)malloc(memreq);
4076           break;
4077         case GL_INT:
4078           dstImage = (GLint *)malloc(memreq);
4079           break;
4080         case GL_FLOAT:
4081           dstImage = (GLfloat *)malloc(memreq);
4082           break;
4083         case GL_UNSIGNED_BYTE_3_3_2:
4084         case GL_UNSIGNED_BYTE_2_3_3_REV:
4085           dstImage = (GLubyte *)malloc(memreq);
4086           break;
4087         case GL_UNSIGNED_SHORT_5_6_5:
4088         case GL_UNSIGNED_SHORT_5_6_5_REV:
4089         case GL_UNSIGNED_SHORT_4_4_4_4:
4090         case GL_UNSIGNED_SHORT_4_4_4_4_REV:
4091         case GL_UNSIGNED_SHORT_5_5_5_1:
4092         case GL_UNSIGNED_SHORT_1_5_5_5_REV:
4093           dstImage = (GLushort *)malloc(memreq);
4094           break;
4095         case GL_UNSIGNED_INT_8_8_8_8:
4096         case GL_UNSIGNED_INT_8_8_8_8_REV:
4097         case GL_UNSIGNED_INT_10_10_10_2:
4098         case GL_UNSIGNED_INT_2_10_10_10_REV:
4099           dstImage = (GLuint *)malloc(memreq);
4100           break;
4101         default:
4102           return GLU_INVALID_ENUM;
4103         }
4104         if (dstImage == NULL) {
4105           glPixelStorei(GL_UNPACK_ALIGNMENT, psm.unpack_alignment);
4106           glPixelStorei(GL_UNPACK_SKIP_ROWS, psm.unpack_skip_rows);
4107           glPixelStorei(GL_UNPACK_SKIP_PIXELS, psm.unpack_skip_pixels);
4108           glPixelStorei(GL_UNPACK_ROW_LENGTH, psm.unpack_row_length);
4109           glPixelStorei(GL_UNPACK_SWAP_BYTES, psm.unpack_swap_bytes);
4110           free(srcImage);
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;
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;
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