mirror of https://github.com/BOINC/boinc.git
404 lines
9.8 KiB
C++
404 lines
9.8 KiB
C++
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
|
|
using std::malloc;
|
|
using std::free;
|
|
using std::size_t;
|
|
|
|
using std::FILE;
|
|
using std::fopen;
|
|
using std::fclose;
|
|
using std::fprintf;
|
|
using std::fread;
|
|
using std::fseek;
|
|
|
|
using std::perror;
|
|
|
|
void bwtorgba(unsigned char *b,unsigned char *l,int n) {
|
|
while(n--) {
|
|
l[0] = *b;
|
|
l[1] = *b;
|
|
l[2] = *b;
|
|
l[3] = 0xff;
|
|
l += 4;
|
|
b++;
|
|
}
|
|
}
|
|
|
|
void latorgba(unsigned char *b, unsigned char *a,unsigned char *l,int n) {
|
|
while(n--) {
|
|
l[0] = *b;
|
|
l[1] = *b;
|
|
l[2] = *b;
|
|
l[3] = *a;
|
|
l += 4;
|
|
b++;
|
|
a++;
|
|
}
|
|
}
|
|
|
|
void rgbtorgba(unsigned char *r,unsigned char *g,unsigned char *b,unsigned char *l,int n) {
|
|
while(n--) {
|
|
l[0] = r[0];
|
|
l[1] = g[0];
|
|
l[2] = b[0];
|
|
l[3] = 0xff;
|
|
l += 4;
|
|
r++;
|
|
g++;
|
|
b++;
|
|
}
|
|
}
|
|
|
|
void rgbatorgba(unsigned char *r,unsigned char *g,unsigned char *b,unsigned char *a,unsigned char *l,int n) {
|
|
while(n--) {
|
|
l[0] = r[0];
|
|
l[1] = g[0];
|
|
l[2] = b[0];
|
|
l[3] = a[0];
|
|
l += 4;
|
|
r++;
|
|
g++;
|
|
b++;
|
|
a++;
|
|
}
|
|
}
|
|
|
|
typedef struct _ImageRec {
|
|
unsigned short imagic;
|
|
unsigned short type;
|
|
unsigned short dim;
|
|
unsigned short xsize, ysize, zsize;
|
|
unsigned int min, max;
|
|
unsigned int wasteBytes;
|
|
char name[80];
|
|
unsigned long colorMap;
|
|
FILE *file;
|
|
unsigned char *tmp, *tmpR, *tmpG, *tmpB;
|
|
unsigned long rleEnd;
|
|
unsigned int *rowStart;
|
|
int *rowSize;
|
|
} ImageRec;
|
|
|
|
static void ConvertShort(unsigned short *array, long length) {
|
|
unsigned b1, b2;
|
|
unsigned char *ptr;
|
|
ptr = (unsigned char *) array;
|
|
while (length--) {
|
|
b1 = *ptr++;
|
|
b2 = *ptr++;
|
|
*array++ = (b1 << 8) | (b2);
|
|
}
|
|
}
|
|
|
|
static void ConvertLong(unsigned *array, long length) {
|
|
unsigned long b1, b2, b3, b4;
|
|
unsigned char *ptr;
|
|
ptr = (unsigned char *)array;
|
|
while (length--) {
|
|
b1 = *ptr++;
|
|
b2 = *ptr++;
|
|
b3 = *ptr++;
|
|
b4 = *ptr++;
|
|
*array++ = (b1 << 24) | (b2 << 16) | (b3 << 8) | (b4);
|
|
}
|
|
}
|
|
|
|
static ImageRec *ImageOpen(const char *fileName){
|
|
union {
|
|
int testWord;
|
|
char testByte[4];
|
|
}
|
|
endianTest;
|
|
ImageRec *image;
|
|
int swapFlag;
|
|
int x;
|
|
endianTest.testWord = 1;
|
|
if (endianTest.testByte[0] == 1) {
|
|
swapFlag = 1;
|
|
}
|
|
else {
|
|
swapFlag = 0;
|
|
}
|
|
image = (ImageRec *)malloc(sizeof(ImageRec));
|
|
if (image == NULL) {
|
|
goto error;
|
|
}
|
|
if ((image->file = fopen(fileName, "rb")) == NULL) {
|
|
perror(fileName);
|
|
free(image);
|
|
return NULL;
|
|
}
|
|
fread(image, 1, 12, image->file);
|
|
if (swapFlag) {
|
|
ConvertShort(&image->imagic, 6);
|
|
}
|
|
|
|
image->tmp = (unsigned char *)malloc(image->xsize*256);
|
|
image->tmpR = (unsigned char *)malloc(image->xsize*256);
|
|
image->tmpG = (unsigned char *)malloc(image->xsize*256);
|
|
image->tmpB = (unsigned char *)malloc(image->xsize*256);
|
|
if (image->tmp == NULL || image->tmpR == NULL || image->tmpG == NULL ||image->tmpB == NULL) {
|
|
goto error;
|
|
}
|
|
|
|
if ((image->type & 0xFF00) == 0x0100) {
|
|
x = image->ysize * image->zsize * sizeof(unsigned);
|
|
image->rowStart = (unsigned *)malloc(x);
|
|
image->rowSize = (int *)malloc(x);
|
|
if (image->rowStart == NULL || image->rowSize == NULL) {
|
|
goto error;
|
|
}
|
|
image->rleEnd = 512 + (2 * x);
|
|
fseek(image->file, 512, SEEK_SET);
|
|
fread(image->rowStart, 1, x, image->file);
|
|
fread(image->rowSize, 1, x, image->file);
|
|
if (swapFlag) {
|
|
ConvertLong(image->rowStart, x/sizeof(unsigned));
|
|
ConvertLong((unsigned *)image->rowSize, x/sizeof(int));
|
|
}
|
|
}
|
|
return image;
|
|
error:
|
|
if (image) {
|
|
if (image->rowSize) free(image->rowSize);
|
|
if (image->rowStart) free(image->rowStart);
|
|
if (image->tmpB) free(image->tmpB);
|
|
if (image->tmpG) free(image->tmpG);
|
|
if (image->tmpR)free(image->tmpR);
|
|
if (image->tmp) free(image->tmp);
|
|
if (image->file) fclose(image->file);
|
|
free(image);
|
|
}
|
|
fprintf(stderr, "Out of memory!\n");
|
|
return NULL;
|
|
}
|
|
|
|
static void ImageClose(ImageRec *image) {
|
|
fclose(image->file);
|
|
free(image->tmp);
|
|
free(image->tmpR);
|
|
free(image->tmpG);
|
|
free(image->tmpB);
|
|
free(image);
|
|
}
|
|
|
|
static void ImageGetRow(ImageRec *image, unsigned char *buf, int y, int z) {
|
|
unsigned char *iPtr, *oPtr, pixel;
|
|
int count;
|
|
if ((image->type & 0xFF00) == 0x0100) {
|
|
fseek(image->file, image->rowStart[y+z*image->ysize], SEEK_SET);
|
|
fread(image->tmp, 1, (unsigned int)image->rowSize[y+z*image->ysize],image->file);
|
|
iPtr = image->tmp;
|
|
oPtr = buf;
|
|
while (1) {
|
|
pixel = *iPtr++;
|
|
count = (int)(pixel & 0x7F);
|
|
if (!count) {
|
|
return;
|
|
}
|
|
if (pixel & 0x80) {
|
|
while (count--) {
|
|
*oPtr++ = *iPtr++;
|
|
}
|
|
}
|
|
else {
|
|
pixel = *iPtr++;
|
|
while (count--) {
|
|
*oPtr++ = pixel;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
fseek(image->file, 512+(y*image->xsize)+(z*image->xsize*image->ysize),SEEK_SET);
|
|
fread(buf, 1, image->xsize, image->file);
|
|
}
|
|
}
|
|
|
|
//-------------------------TGA LOADER-------------------------
|
|
|
|
// =============
|
|
// checkSize
|
|
// Make sure its a power of 2.
|
|
// =============
|
|
int checkSize (int x){
|
|
return 1;
|
|
if (x == 2 || x == 4 ||
|
|
x == 8 || x == 16 ||
|
|
x == 32 || x == 64 ||
|
|
x == 128 || x == 256 || x == 512)
|
|
return 1;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
|
|
unsigned int texFormat;
|
|
|
|
unsigned char* getRGBA (FILE *s, size_t size){
|
|
unsigned char *rgba;
|
|
unsigned char temp;
|
|
size_t bread;
|
|
size_t i;
|
|
rgba=(unsigned char*)malloc(size * 4);
|
|
if (rgba == NULL) return 0;
|
|
bread = fread (rgba, sizeof (unsigned char), size * 4, s);
|
|
// TGA is stored in BGRA, make it RGBA
|
|
if (bread != size * 4) {
|
|
free (rgba);
|
|
return 0;
|
|
}
|
|
for (i = 0; i < size * 4; i += 4 ){
|
|
temp = rgba[i];
|
|
rgba[i] = rgba[i + 2];
|
|
rgba[i + 2] = temp;
|
|
}
|
|
return rgba;
|
|
}
|
|
|
|
|
|
// =============
|
|
// getRGB
|
|
// Reads in RGB data for a 24bit image.
|
|
// =============
|
|
unsigned char* getRGB (FILE *s, size_t size){
|
|
unsigned char *rgb;
|
|
unsigned char temp;
|
|
size_t bread;
|
|
size_t i;
|
|
rgb=(unsigned char*)malloc(size * 3);
|
|
if (rgb == NULL) return 0;
|
|
bread = fread (rgb, sizeof (unsigned char), size * 3, s);
|
|
if (bread != size * 3){
|
|
free (rgb);
|
|
return 0;
|
|
}
|
|
// TGA is stored in BGR, make it RGB
|
|
for (i = 0; i < size * 3; i += 3){
|
|
temp = rgb[i];
|
|
rgb[i] = rgb[i + 2];
|
|
rgb[i + 2] = temp;
|
|
}
|
|
return rgb;
|
|
}
|
|
|
|
|
|
// =============
|
|
// getGray
|
|
// Gets the grayscale image data. Used as an alpha channel.
|
|
// =============
|
|
unsigned char* getGray (FILE *s, size_t size){
|
|
unsigned char *grayData;
|
|
size_t bread;
|
|
grayData=(unsigned char*)malloc (size);
|
|
if (grayData == NULL) return 0;
|
|
bread = fread (grayData, sizeof (unsigned char), size, s);
|
|
if (bread != size){
|
|
free (grayData);
|
|
return 0;
|
|
}
|
|
return grayData;
|
|
}
|
|
|
|
|
|
// =============
|
|
// getData
|
|
// Gets the image data for the specified bit depth.
|
|
// =============
|
|
unsigned char* getData (FILE *s, int sz, int iBits){
|
|
switch (iBits){
|
|
case 32 : return getRGBA (s, sz); break;
|
|
case 24 : return getRGB (s, sz); break;
|
|
case 8 : return getGray (s, sz); break;
|
|
default : return NULL;
|
|
}
|
|
}
|
|
|
|
|
|
unsigned * read_tga_texture(char *name, int *width, int *height, int*) {
|
|
unsigned char type[4];
|
|
unsigned char info[7];
|
|
unsigned *base;
|
|
int imageBits, size;
|
|
FILE *s;
|
|
if (!(s = fopen (name, "r+bt"))) return NULL;
|
|
fread (&type, sizeof (char), 3, s); // read in colormap info and image type, byte 0 ignored
|
|
fseek (s, 12, SEEK_SET); // seek past the header and useless info
|
|
fread (&info, sizeof (char), 6, s);
|
|
if (type[1] != 0 || (type[2] != 2 && type[2] != 3)) return NULL;
|
|
(*width) = info[0] + info[1] * 256;
|
|
(*height) = info[2] + info[3] * 256;
|
|
imageBits = info[4];
|
|
size = (*width) * (*height);
|
|
// make sure dimension is a power of 2
|
|
if (!checkSize ((*width)) || !checkSize ((*height) )) return NULL;
|
|
// make sure we are loading a supported type
|
|
if (imageBits != 32 && imageBits != 24 && imageBits != 8) return NULL;
|
|
base = (unsigned int *)getData (s, size, imageBits);
|
|
fclose(s);
|
|
return (unsigned *) base;
|
|
}
|
|
|
|
unsigned * read_rgb_texture(const char *name, int *width, int *height, int *components) {
|
|
unsigned *base, *lptr;
|
|
unsigned char *rbuf, *gbuf, *bbuf, *abuf;
|
|
ImageRec *image;
|
|
int y;
|
|
image = ImageOpen(name);
|
|
if(!image) return NULL;
|
|
(*width)=image->xsize;
|
|
(*height)=image->ysize;
|
|
(*components)=image->zsize;
|
|
base = (unsigned *)malloc(image->xsize*image->ysize*sizeof(unsigned));
|
|
rbuf = (unsigned char *)malloc(image->xsize*sizeof(unsigned char));
|
|
gbuf = (unsigned char *)malloc(image->xsize*sizeof(unsigned char));
|
|
bbuf = (unsigned char *)malloc(image->xsize*sizeof(unsigned char));
|
|
abuf = (unsigned char *)malloc(image->xsize*sizeof(unsigned char));
|
|
if(!base || !rbuf || !gbuf || !bbuf) goto error;
|
|
lptr = base;
|
|
for(y=0; y<image->ysize; y++) {
|
|
if(image->zsize>=4) {
|
|
ImageGetRow(image,rbuf,y,0);
|
|
ImageGetRow(image,gbuf,y,1);
|
|
ImageGetRow(image,bbuf,y,2);
|
|
ImageGetRow(image,abuf,y,3);
|
|
rgbatorgba(rbuf,gbuf,bbuf,abuf,(unsigned char *)lptr,image->xsize);
|
|
lptr += image->xsize;
|
|
} else if(image->zsize==3) {
|
|
ImageGetRow(image,rbuf,y,0);
|
|
ImageGetRow(image,gbuf,y,1);
|
|
ImageGetRow(image,bbuf,y,2);
|
|
rgbtorgba(rbuf,gbuf,bbuf,(unsigned char *)lptr,image->xsize);
|
|
lptr += image->xsize;
|
|
} else if(image->zsize==2) {
|
|
ImageGetRow(image,rbuf,y,0);
|
|
ImageGetRow(image,abuf,y,1);
|
|
latorgba(rbuf,abuf,(unsigned char *)lptr,image->xsize);
|
|
lptr += image->xsize;
|
|
} else {
|
|
ImageGetRow(image,rbuf,y,0);
|
|
bwtorgba(rbuf,(unsigned char *)lptr,image->xsize);
|
|
lptr += image->xsize;
|
|
}
|
|
}
|
|
ImageClose(image);
|
|
free(rbuf);
|
|
free(gbuf);
|
|
free(bbuf);
|
|
free(abuf);
|
|
return (unsigned *) base;
|
|
error:
|
|
ImageClose(image);
|
|
if (abuf) free(abuf);
|
|
if (bbuf) free(bbuf);
|
|
if (bbuf) free(gbuf);
|
|
if (bbuf) free(rbuf);
|
|
if (base) free(base);
|
|
return NULL;
|
|
}
|
|
|
|
const char *BOINC_RCSID_97d4f29d84="$Id$";
|