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