#include "image-sgi.h"
static int getlong(FILE *);
static int getshort(FILE *);
static int putlong(long, FILE *);
static int putshort(unsigned short, FILE *);
static int read_rle8(FILE *, unsigned short *, int);
static int read_rle16(FILE *, unsigned short *, int);
static int write_rle8(FILE *, unsigned short *, int);
static int write_rle16(FILE *, unsigned short *, int);
int
sgiClose(sgi_t *sgip)
{
int i;
long *offset;
if (sgip == NULL)
return (-1);
if (sgip->mode == SGI_WRITE && sgip->comp != SGI_COMP_NONE)
{
fseek(sgip->file, 512, SEEK_SET);
for (i = sgip->ysize * sgip->zsize, offset = sgip->table[0];
i > 0;
i --, offset ++)
if (putlong(offset[0], sgip->file) < 0)
return (-1);
for (i = sgip->ysize * sgip->zsize, offset = sgip->length[0];
i > 0;
i --, offset ++)
if (putlong(offset[0], sgip->file) < 0)
return (-1);
}
if (sgip->table != NULL)
{
free(sgip->table[0]);
free(sgip->table);
}
if (sgip->length != NULL)
{
free(sgip->length[0]);
free(sgip->length);
}
if (sgip->comp == SGI_COMP_ARLE)
free(sgip->arle_row);
i = fclose(sgip->file);
free(sgip);
return (i);
}
int
sgiGetRow(sgi_t *sgip,
unsigned short *row,
int y,
int z)
{
int x;
long offset;
if (sgip == NULL ||
row == NULL ||
y < 0 || y >= sgip->ysize ||
z < 0 || z >= sgip->zsize)
return (-1);
switch (sgip->comp)
{
case SGI_COMP_NONE :
offset = 512 + (y + z * sgip->ysize) * sgip->xsize * sgip->bpp;
if (offset != ftell(sgip->file))
fseek(sgip->file, offset, SEEK_SET);
if (sgip->bpp == 1)
{
for (x = sgip->xsize; x > 0; x --, row ++)
*row = getc(sgip->file);
}
else
{
for (x = sgip->xsize; x > 0; x --, row ++)
*row = getshort(sgip->file);
}
break;
case SGI_COMP_RLE :
offset = sgip->table[z][y];
if (offset != ftell(sgip->file))
fseek(sgip->file, offset, SEEK_SET);
if (sgip->bpp == 1)
return (read_rle8(sgip->file, row, sgip->xsize));
else
return (read_rle16(sgip->file, row, sgip->xsize));
}
return (0);
}
sgi_t *
sgiOpen(char *filename,
int mode,
int comp,
int bpp,
int xsize,
int ysize,
int zsize)
{
sgi_t *sgip;
FILE *file;
if (mode == SGI_READ)
file = fopen(filename, "rb");
else
file = fopen(filename, "wb+");
if (file == NULL)
return (NULL);
if ((sgip = sgiOpenFile(file, mode, comp, bpp, xsize, ysize, zsize)) == NULL)
fclose(file);
return (sgip);
}
sgi_t *
sgiOpenFile(FILE *file,
int mode,
int comp,
int bpp,
int xsize,
int ysize,
int zsize)
{
int i, j;
char name[80];
short magic;
sgi_t *sgip;
if ((sgip = calloc(sizeof(sgi_t), 1)) == NULL)
return (NULL);
sgip->file = file;
switch (mode)
{
case SGI_READ :
sgip->mode = SGI_READ;
magic = getshort(sgip->file);
if (magic != SGI_MAGIC)
{
free(sgip);
return (NULL);
}
sgip->comp = getc(sgip->file);
sgip->bpp = getc(sgip->file);
getshort(sgip->file);
sgip->xsize = getshort(sgip->file);
sgip->ysize = getshort(sgip->file);
sgip->zsize = getshort(sgip->file);
getlong(sgip->file);
getlong(sgip->file);
if (sgip->comp)
{
fseek(sgip->file, 512, SEEK_SET);
sgip->table = calloc(sgip->zsize, sizeof(long *));
sgip->table[0] = calloc(sgip->ysize * sgip->zsize, sizeof(long));
for (i = 1; i < sgip->zsize; i ++)
sgip->table[i] = sgip->table[0] + i * sgip->ysize;
for (i = 0; i < sgip->zsize; i ++)
for (j = 0; j < sgip->ysize; j ++)
sgip->table[i][j] = getlong(sgip->file);
}
break;
case SGI_WRITE :
if (xsize < 1 ||
ysize < 1 ||
zsize < 1 ||
bpp < 1 || bpp > 2 ||
comp < SGI_COMP_NONE || comp > SGI_COMP_ARLE)
{
free(sgip);
return (NULL);
}
sgip->mode = SGI_WRITE;
putshort(SGI_MAGIC, sgip->file);
putc((sgip->comp = comp) != 0, sgip->file);
putc(sgip->bpp = bpp, sgip->file);
putshort(3, sgip->file);
putshort(sgip->xsize = xsize, sgip->file);
putshort(sgip->ysize = ysize, sgip->file);
putshort(sgip->zsize = zsize, sgip->file);
if (bpp == 1)
{
putlong(0, sgip->file);
putlong(255, sgip->file);
}
else
{
putlong(-32768, sgip->file);
putlong(32767, sgip->file);
}
putlong(0, sgip->file);
memset(name, 0, sizeof(name));
fwrite(name, sizeof(name), 1, sgip->file);
for (i = 0; i < 102; i ++)
putlong(0, sgip->file);
switch (comp)
{
case SGI_COMP_NONE :
if (bpp == 1)
{
for (i = xsize * ysize * zsize; i > 0; i --)
putc(0, sgip->file);
}
else
{
for (i = xsize * ysize * zsize; i > 0; i --)
putshort(0, sgip->file);
}
break;
case SGI_COMP_ARLE :
sgip->arle_row = calloc(xsize, sizeof(unsigned short));
sgip->arle_offset = 0;
case SGI_COMP_RLE :
for (i = 2 * ysize * zsize; i > 0; i --)
putlong(0, sgip->file);
sgip->firstrow = ftell(sgip->file);
sgip->nextrow = ftell(sgip->file);
sgip->table = calloc(sgip->zsize, sizeof(long *));
sgip->table[0] = calloc(sgip->ysize * sgip->zsize, sizeof(long));
for (i = 1; i < sgip->zsize; i ++)
sgip->table[i] = sgip->table[0] + i * sgip->ysize;
sgip->length = calloc(sgip->zsize, sizeof(long *));
sgip->length[0] = calloc(sgip->ysize * sgip->zsize, sizeof(long));
for (i = 1; i < sgip->zsize; i ++)
sgip->length[i] = sgip->length[0] + i * sgip->ysize;
break;
}
break;
default :
free(sgip);
return (NULL);
}
return (sgip);
}
int
sgiPutRow(sgi_t *sgip,
unsigned short *row,
int y,
int z)
{
int x;
long offset;
if (sgip == NULL ||
row == NULL ||
y < 0 || y >= sgip->ysize ||
z < 0 || z >= sgip->zsize)
return (-1);
switch (sgip->comp)
{
case SGI_COMP_NONE :
offset = 512 + (y + z * sgip->ysize) * sgip->xsize * sgip->bpp;
if (offset != ftell(sgip->file))
fseek(sgip->file, offset, SEEK_SET);
if (sgip->bpp == 1)
{
for (x = sgip->xsize; x > 0; x --, row ++)
putc(*row, sgip->file);
}
else
{
for (x = sgip->xsize; x > 0; x --, row ++)
putshort(*row, sgip->file);
}
break;
case SGI_COMP_ARLE :
if (sgip->table[z][y] != 0)
return (-1);
if (sgip->arle_offset > 0)
{
for (x = 0; x < sgip->xsize; x ++)
if (row[x] != sgip->arle_row[x])
break;
if (x == sgip->xsize)
{
sgip->table[z][y] = sgip->arle_offset;
sgip->length[z][y] = sgip->arle_length;
return (0);
}
}
fseek(sgip->file, sgip->firstrow, SEEK_SET);
if (sgip->bpp == 1)
{
for (;;)
{
sgip->arle_offset = ftell(sgip->file);
if ((sgip->arle_length = read_rle8(sgip->file, sgip->arle_row, sgip->xsize)) < 0)
{
x = 0;
break;
}
if (memcmp(row, sgip->arle_row, sgip->xsize * sizeof(unsigned short)) == 0)
{
x = sgip->xsize;
break;
}
}
}
else
{
for (;;)
{
sgip->arle_offset = ftell(sgip->file);
if ((sgip->arle_length = read_rle16(sgip->file, sgip->arle_row, sgip->xsize)) < 0)
{
x = 0;
break;
}
if (memcmp(row, sgip->arle_row, sgip->xsize * sizeof(unsigned short)) == 0)
{
x = sgip->xsize;
break;
}
}
}
if (x == sgip->xsize)
{
sgip->table[z][y] = sgip->arle_offset;
sgip->length[z][y] = sgip->arle_length;
return (0);
}
else
fseek(sgip->file, 0, SEEK_END);
case SGI_COMP_RLE :
if (sgip->table[z][y] != 0)
return (-1);
offset = sgip->table[z][y] = sgip->nextrow;
if (offset != ftell(sgip->file))
fseek(sgip->file, offset, SEEK_SET);
if (sgip->bpp == 1)
x = write_rle8(sgip->file, row, sgip->xsize);
else
x = write_rle16(sgip->file, row, sgip->xsize);
if (sgip->comp == SGI_COMP_ARLE)
{
sgip->arle_offset = offset;
sgip->arle_length = x;
memcpy(sgip->arle_row, row, sgip->xsize * sizeof(unsigned short));
}
sgip->nextrow = ftell(sgip->file);
sgip->length[z][y] = x;
return (x);
}
return (0);
}
static int
getlong(FILE *fp)
{
unsigned char b[4];
fread(b, 4, 1, fp);
return ((b[0] << 24) | (b[1] << 16) | (b[2] << 8) | b[3]);
}
static int
getshort(FILE *fp)
{
unsigned char b[2];
fread(b, 2, 1, fp);
return ((b[0] << 8) | b[1]);
}
static int
putlong(long n,
FILE *fp)
{
if (putc(n >> 24, fp) == EOF)
return (EOF);
if (putc(n >> 16, fp) == EOF)
return (EOF);
if (putc(n >> 8, fp) == EOF)
return (EOF);
if (putc(n, fp) == EOF)
return (EOF);
else
return (0);
}
static int
putshort(unsigned short n,
FILE *fp)
{
if (putc(n >> 8, fp) == EOF)
return (EOF);
if (putc(n, fp) == EOF)
return (EOF);
else
return (0);
}
static int
read_rle8(FILE *fp,
unsigned short *row,
int xsize)
{
int i,
ch,
count,
length;
length = 0;
while (xsize > 0)
{
if ((ch = getc(fp)) == EOF)
return (-1);
length ++;
count = ch & 127;
if (count == 0)
break;
if (ch & 128)
{
for (i = 0; i < count; i ++, row ++, xsize --, length ++)
*row = getc(fp);
}
else
{
ch = getc(fp);
length ++;
for (i = 0; i < count; i ++, row ++, xsize --)
*row = ch;
}
}
return (xsize > 0 ? -1 : length);
}
static int
read_rle16(FILE *fp,
unsigned short *row,
int xsize)
{
int i,
ch,
count,
length;
length = 0;
while (xsize > 0)
{
if ((ch = getshort(fp)) == EOF)
return (-1);
length ++;
count = ch & 127;
if (count == 0)
break;
if (ch & 128)
{
for (i = 0; i < count; i ++, row ++, xsize --, length ++)
*row = getshort(fp);
}
else
{
ch = getshort(fp);
length ++;
for (i = 0; i < count; i ++, row ++, xsize --)
*row = ch;
}
}
return (xsize > 0 ? -1 : length * 2);
}
static int
write_rle8(FILE *fp,
unsigned short *row,
int xsize)
{
int length,
count,
i,
x;
unsigned short *start,
repeat;
for (x = xsize, length = 0; x > 0;)
{
start = row;
row += 2;
x -= 2;
while (x > 0 && (row[-2] != row[-1] || row[-1] != row[0]))
{
row ++;
x --;
}
row -= 2;
x += 2;
count = row - start;
while (count > 0)
{
i = count > 126 ? 126 : count;
count -= i;
if (putc(128 | i, fp) == EOF)
return (-1);
length ++;
while (i > 0)
{
if (putc(*start, fp) == EOF)
return (-1);
start ++;
i --;
length ++;
}
}
if (x <= 0)
break;
start = row;
repeat = row[0];
row ++;
x --;
while (x > 0 && *row == repeat)
{
row ++;
x --;
}
count = row - start;
while (count > 0)
{
i = count > 126 ? 126 : count;
count -= i;
if (putc(i, fp) == EOF)
return (-1);
length ++;
if (putc(repeat, fp) == EOF)
return (-1);
length ++;
}
}
length ++;
if (putc(0, fp) == EOF)
return (-1);
else
return (length);
}
static int
write_rle16(FILE *fp,
unsigned short *row,
int xsize)
{
int length,
count,
i,
x;
unsigned short *start,
repeat;
for (x = xsize, length = 0; x > 0;)
{
start = row;
row += 2;
x -= 2;
while (x > 0 && (row[-2] != row[-1] || row[-1] != row[0]))
{
row ++;
x --;
}
row -= 2;
x += 2;
count = row - start;
while (count > 0)
{
i = count > 126 ? 126 : count;
count -= i;
if (putshort(128 | i, fp) == EOF)
return (-1);
length ++;
while (i > 0)
{
if (putshort(*start, fp) == EOF)
return (-1);
start ++;
i --;
length ++;
}
}
if (x <= 0)
break;
start = row;
repeat = row[0];
row ++;
x --;
while (x > 0 && *row == repeat)
{
row ++;
x --;
}
count = row - start;
while (count > 0)
{
i = count > 126 ? 126 : count;
count -= i;
if (putshort(i, fp) == EOF)
return (-1);
length ++;
if (putshort(repeat, fp) == EOF)
return (-1);
length ++;
}
}
length ++;
if (putshort(0, fp) == EOF)
return (-1);
else
return (2 * length);
}