netgen/ng/Togl-1.7/image.c
Joachim Schoeberl eeac7442f3 including togl
2014-09-15 08:48:30 +00:00

250 lines
6.1 KiB
C

/*
* SGI rgb file reader borrowed from gltk library
*/
#include "togl.h" /* added by GG to include windows.h */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "image.h"
#ifndef SEEK_SET
# define SEEK_SET 0
#endif
static void
tkQuit(void)
{
exit(0);
}
/******************************************************************************/
typedef struct _rawImageRec
{
unsigned short imagic;
unsigned short type;
unsigned short dim;
unsigned short sizeX, sizeY, sizeZ;
unsigned long min, max;
unsigned long wasteBytes;
char name[80];
unsigned long colorMap;
FILE *file;
unsigned char *tmp, *tmpR, *tmpG, *tmpB, *tmpA;
unsigned long rleEnd;
GLuint *rowStart;
GLint *rowSize;
} rawImageRec;
/******************************************************************************/
static void
ConvertShort(unsigned short *array, long length)
{
unsigned long b1, b2;
unsigned char *ptr;
ptr = (unsigned char *) array;
while (length--) {
b1 = *ptr++;
b2 = *ptr++;
*array++ = (b1 << 8) | (b2);
}
}
static void
ConvertLong(GLuint *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 rawImageRec *
RawImageOpen(char *fileName)
{
union
{
int testWord;
char testByte[4];
} endianTest;
rawImageRec *raw;
GLenum swapFlag;
int x;
endianTest.testWord = 1;
if (endianTest.testByte[0] == 1) {
swapFlag = GL_TRUE;
} else {
swapFlag = GL_FALSE;
}
raw = (rawImageRec *) malloc(sizeof (rawImageRec));
if (raw == NULL) {
fprintf(stderr, "Out of memory!\n");
tkQuit();
}
if ((raw->file = fopen(fileName, "rb")) == NULL) {
perror(fileName);
tkQuit();
}
fread(raw, 1, 12, raw->file);
if (swapFlag) {
ConvertShort(&raw->imagic, 6);
}
raw->tmp = (unsigned char *) malloc(raw->sizeX * 256);
raw->tmpR = (unsigned char *) malloc(raw->sizeX * 256);
raw->tmpG = (unsigned char *) malloc(raw->sizeX * 256);
raw->tmpB = (unsigned char *) malloc(raw->sizeX * 256);
raw->tmpA = (unsigned char *) malloc(raw->sizeX * 256);
if (raw->tmp == NULL || raw->tmpR == NULL || raw->tmpG == NULL ||
raw->tmpB == NULL || raw->tmpA == NULL) {
fprintf(stderr, "Out of memory!\n");
tkQuit();
}
if ((raw->type & 0xFF00) == 0x0100) {
x = raw->sizeY * raw->sizeZ * sizeof (GLuint);
raw->rowStart = (GLuint *) malloc(x);
raw->rowSize = (GLint *) malloc(x);
if (raw->rowStart == NULL || raw->rowSize == NULL) {
fprintf(stderr, "Out of memory!\n");
tkQuit();
}
raw->rleEnd = 512 + (2 * x);
fseek(raw->file, 512, SEEK_SET);
fread(raw->rowStart, 1, x, raw->file);
fread(raw->rowSize, 1, x, raw->file);
if (swapFlag) {
ConvertLong(raw->rowStart, x / sizeof (GLuint));
ConvertLong((GLuint *) raw->rowSize, x / sizeof (GLint));
}
}
return raw;
}
static void
RawImageClose(rawImageRec * raw)
{
fclose(raw->file);
free(raw->tmp);
free(raw->tmpR);
free(raw->tmpG);
free(raw->tmpB);
free(raw->tmpA);
free(raw);
}
static void
RawImageGetRow(rawImageRec * raw, unsigned char *buf, int y, int z)
{
unsigned char *iPtr, *oPtr, pixel;
int count;
if ((raw->type & 0xFF00) == 0x0100) {
fseek(raw->file, raw->rowStart[y + z * raw->sizeY], SEEK_SET);
fread(raw->tmp, 1, (unsigned int) raw->rowSize[y + z * raw->sizeY],
raw->file);
iPtr = raw->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(raw->file, 512 + (y * raw->sizeX) + (z * raw->sizeX * raw->sizeY),
SEEK_SET);
fread(buf, 1, raw->sizeX, raw->file);
}
}
static void
RawImageGetData(rawImageRec * raw, TK_RGBImageRec * final)
{
unsigned char *ptr;
int i, j;
final->data =
(unsigned char *) malloc((raw->sizeX + 1) * (raw->sizeY + 1) * 4);
if (final->data == NULL) {
fprintf(stderr, "Out of memory!\n");
tkQuit();
}
ptr = final->data;
for (i = 0; i < (int) (raw->sizeY); i++) {
RawImageGetRow(raw, raw->tmpR, i, 0);
RawImageGetRow(raw, raw->tmpG, i, 1);
RawImageGetRow(raw, raw->tmpB, i, 2);
if (raw->sizeZ == 4) {
/* 4 components */
RawImageGetRow(raw, raw->tmpA, i, 3);
for (j = 0; j < (int) (raw->sizeX); j++) {
*ptr++ = *(raw->tmpR + j);
*ptr++ = *(raw->tmpG + j);
*ptr++ = *(raw->tmpB + j);
*ptr++ = *(raw->tmpA + j);
}
} else {
/* 3 components */
for (j = 0; j < (int) (raw->sizeX); j++) {
*ptr++ = *(raw->tmpR + j);
*ptr++ = *(raw->tmpG + j);
*ptr++ = *(raw->tmpB + j);
}
}
}
}
TK_RGBImageRec *
tkRGBImageLoad(char *fileName)
{
rawImageRec *raw;
TK_RGBImageRec *final;
raw = RawImageOpen(fileName);
final = (TK_RGBImageRec *) malloc(sizeof (TK_RGBImageRec));
if (final == NULL) {
fprintf(stderr, "Out of memory!\n");
tkQuit();
}
final->sizeX = raw->sizeX;
final->sizeY = raw->sizeY;
final->sizeZ = raw->sizeZ;
RawImageGetData(raw, final);
RawImageClose(raw);
return final;
}
/******************************************************************************/