// Internal function used to get the Pix header from the current file.
ILboolean iGetPixHead(PIXHEAD *Header) {
Header->Width = GetBigUShort();
Header->Height = GetBigUShort();
Header->OffX = GetBigUShort();
Header->OffY = GetBigUShort();
Header->Bpp = GetBigUShort();
return IL_TRUE;
}
// Internal function used to get the Psd header from the current file.
ILboolean iGetPsdHead(PSDHEAD *Header)
{
iread(Header->Signature, 1, 4);
Header->Version = GetBigUShort();
iread(Header->Reserved, 1, 6);
Header->Channels = GetBigUShort();
Header->Height = GetBigUInt();
Header->Width = GetBigUInt();
Header->Depth = GetBigUShort();
Header->Mode = GetBigUShort();
return IL_TRUE;
}
static ILboolean ReadGrey(ILimage* image, PSDHEAD *Head) {
ILuint ColorMode, ResourceSize, MiscInfo;
ILushort Compressed;
ILenum Type;
ILubyte * Resources = NULL;
SIO * io = &image->io;
ILushort ChannelNum;
ColorMode = GetBigUInt(io); // Skip over the 'color mode data section'
SIOseek(io, ColorMode, IL_SEEK_CUR);
ResourceSize = GetBigUInt(io); // Read the 'image resources section'
Resources = (ILubyte*)ialloc(ResourceSize);
if (Resources == NULL) {
return IL_FALSE;
}
if (SIOread(io, Resources, 1, ResourceSize) != ResourceSize)
goto cleanup_error;
MiscInfo = GetBigUInt(io);
SIOseek(io, MiscInfo, IL_SEEK_CUR);
Compressed = GetBigUShort(io);
ChannelNum = Head->Channels;
Head->Channels = 1; // Temporary to read only one channel...some greyscale .psd files have 2.
switch (Head->Depth) {
case 8:
Type = IL_UNSIGNED_BYTE;
break;
case 16:
Type = IL_UNSIGNED_SHORT;
break;
default:
iSetError(IL_FORMAT_NOT_SUPPORTED);
return IL_FALSE;
}
if (!iTexImage(image, Head->Width, Head->Height, 1, 1, IL_LUMINANCE, Type, NULL))
goto cleanup_error;
if (!PsdGetData(image, Head, image->Data, (ILboolean)Compressed, ChannelNum))
goto cleanup_error;
if (!ParseResources(image, ResourceSize, Resources))
goto cleanup_error;
ifree(Resources);
return IL_TRUE;
cleanup_error:
ifree(Resources);
return IL_FALSE;
}
// Internal function used to get the .sgi header from the current file.
ILboolean iGetSgiHead(iSgiHeader *Header)
{
Header->MagicNum = GetBigUShort();
Header->Storage = (ILbyte)igetc();
Header->Bpc = (ILbyte)igetc();
Header->Dim = GetBigUShort();
Header->XSize = GetBigUShort();
Header->YSize = GetBigUShort();
Header->ZSize = GetBigUShort();
Header->PixMin = GetBigInt();
Header->PixMax = GetBigInt();
Header->Dummy1 = GetBigInt();
iread(Header->Name, 1, 80);
Header->ColMap = GetBigInt();
iread(Header->Dummy, 1, 404);
return IL_TRUE;
}
ILboolean ilisValidTiffFunc()
{
ILushort Header1, Header2;
Header1 = GetLittleUShort();
if (Header1 != MAGIC_HEADER1 && Header1 != MAGIC_HEADER2)
return IL_FALSE;
if (Header1 == MAGIC_HEADER1)
Header2 = GetLittleUShort();
else
Header2 = GetBigUShort();
if (Header2 != 42)
return IL_FALSE;
return IL_TRUE;
}
ILboolean ReadCMYK(PSDHEAD *Head)
{
ILuint ColorMode, ResourceSize, MiscInfo, Size, i, j;
ILushort Compressed;
ILenum Format, Type;
ILubyte *Resources = NULL, *KChannel = NULL;
ColorMode = GetBigUInt(); // Skip over the 'color mode data section'
iseek(ColorMode, IL_SEEK_CUR);
ResourceSize = GetBigUInt(); // Read the 'image resources section'
Resources = (ILubyte*)ialloc(ResourceSize);
if (Resources == NULL) {
return IL_FALSE;
}
if (iread(Resources, 1, ResourceSize) != ResourceSize)
goto cleanup_error;
MiscInfo = GetBigUInt();
iseek(MiscInfo, IL_SEEK_CUR);
Compressed = GetBigUShort();
switch (Head->Channels)
{
case 4:
Format = IL_RGB;
ChannelNum = 4;
Head->Channels = 3;
break;
case 5:
Format = IL_RGBA;
ChannelNum = 5;
Head->Channels = 4;
break;
default:
ilSetError(IL_FORMAT_NOT_SUPPORTED);
return IL_FALSE;
}
switch (Head->Depth)
{
case 8:
Type = IL_UNSIGNED_BYTE;
break;
case 16:
Type = IL_UNSIGNED_SHORT;
break;
default:
ilSetError(IL_FORMAT_NOT_SUPPORTED);
return IL_FALSE;
}
if (!ilTexImage(Head->Width, Head->Height, 1, (ILubyte)Head->Channels, Format, Type, NULL))
goto cleanup_error;
if (!PsdGetData(Head, iCurImage->Data, (ILboolean)Compressed))
goto cleanup_error;
Size = iCurImage->Bpc * iCurImage->Width * iCurImage->Height;
KChannel = (ILubyte*)ialloc(Size);
if (KChannel == NULL)
goto cleanup_error;
if (!GetSingleChannel(Head, KChannel, (ILboolean)Compressed))
goto cleanup_error;
if (Format == IL_RGB) {
for (i = 0, j = 0; i < iCurImage->SizeOfData; i += 3, j++) {
iCurImage->Data[i ] = (iCurImage->Data[i ] * KChannel[j]) >> 8;
iCurImage->Data[i+1] = (iCurImage->Data[i+1] * KChannel[j]) >> 8;
iCurImage->Data[i+2] = (iCurImage->Data[i+2] * KChannel[j]) >> 8;
}
}
else { // IL_RGBA
// The KChannel array really holds the alpha channel on this one.
for (i = 0, j = 0; i < iCurImage->SizeOfData; i += 4, j++) {
ILboolean ReadRGB(PSDHEAD *Head)
{
ILuint ColorMode, ResourceSize, MiscInfo;
ILushort Compressed;
ILenum Format, Type;
ILubyte *Resources = NULL;
ColorMode = GetBigUInt(); // Skip over the 'color mode data section'
iseek(ColorMode, IL_SEEK_CUR);
ResourceSize = GetBigUInt(); // Read the 'image resources section'
Resources = (ILubyte*)ialloc(ResourceSize);
if (Resources == NULL)
return IL_FALSE;
if (iread(Resources, 1, ResourceSize) != ResourceSize)
goto cleanup_error;
MiscInfo = GetBigUInt();
iseek(MiscInfo, IL_SEEK_CUR);
Compressed = GetBigUShort();
ChannelNum = Head->Channels;
if (Head->Channels == 3)
{
Format = IL_RGB;
}
else if (Head->Channels == 4)
{
Format = IL_RGBA;
}
else if (Head->Channels >= 5)
{
// Additional channels are accumulated as a single alpha channel, since
// if an image does not have a layer set as the "background", but also
// has a real alpha channel, there will be 5 channels (or more).
Format = IL_RGBA;
}
else
{
ilSetError(IL_FORMAT_NOT_SUPPORTED);
return IL_FALSE;
}
switch (Head->Depth)
{
case 8:
Type = IL_UNSIGNED_BYTE;
break;
case 16:
Type = IL_UNSIGNED_SHORT;
break;
default:
ilSetError(IL_FORMAT_NOT_SUPPORTED);
return IL_FALSE;
}
if (!ilTexImage(Head->Width, Head->Height, 1, (Format==IL_RGB) ? 3 : 4, Format, Type, NULL))
goto cleanup_error;
if (!PsdGetData(Head, iCurImage->Data, (ILboolean)Compressed))
goto cleanup_error;
if (!ParseResources(ResourceSize, Resources))
goto cleanup_error;
ifree(Resources);
return IL_TRUE;
cleanup_error:
ifree(Resources);
return IL_FALSE;
}
ILboolean ReadIndexed(PSDHEAD *Head)
{
ILuint ColorMode, ResourceSize, MiscInfo, i, j, NumEnt;
ILushort Compressed;
ILubyte *Palette = NULL, *Resources = NULL;
ColorMode = GetBigUInt(); // Skip over the 'color mode data section'
if (ColorMode % 3 != 0) {
ilSetError(IL_INVALID_FILE_HEADER);
return IL_FALSE;
}
Palette = (ILubyte*)ialloc(ColorMode);
if (Palette == NULL)
return IL_FALSE;
if (iread(Palette, 1, ColorMode) != ColorMode)
goto cleanup_error;
ResourceSize = GetBigUInt(); // Read the 'image resources section'
Resources = (ILubyte*)ialloc(ResourceSize);
if (Resources == NULL) {
return IL_FALSE;
}
if (iread(Resources, 1, ResourceSize) != ResourceSize)
goto cleanup_error;
MiscInfo = GetBigUInt();
if (ieof())
goto cleanup_error;
iseek(MiscInfo, IL_SEEK_CUR);
Compressed = GetBigUShort();
if (ieof())
goto cleanup_error;
if (Head->Channels != 1 || Head->Depth != 8) {
ilSetError(IL_FORMAT_NOT_SUPPORTED);
goto cleanup_error;
}
ChannelNum = Head->Channels;
if (!ilTexImage(Head->Width, Head->Height, 1, 1, IL_COLOUR_INDEX, IL_UNSIGNED_BYTE, NULL))
goto cleanup_error;
iCurImage->Pal.Palette = (ILubyte*)ialloc(ColorMode);
if (iCurImage->Pal.Palette == NULL) {
goto cleanup_error;
}
iCurImage->Pal.PalSize = ColorMode;
iCurImage->Pal.PalType = IL_PAL_RGB24;
NumEnt = iCurImage->Pal.PalSize / 3;
for (i = 0, j = 0; i < iCurImage->Pal.PalSize; i += 3, j++) {
iCurImage->Pal.Palette[i ] = Palette[j];
iCurImage->Pal.Palette[i+1] = Palette[j+NumEnt];
iCurImage->Pal.Palette[i+2] = Palette[j+NumEnt*2];
}
ifree(Palette);
Palette = NULL;
if (!PsdGetData(Head, iCurImage->Data, (ILboolean)Compressed))
goto cleanup_error;
ParseResources(ResourceSize, Resources);
ifree(Resources);
Resources = NULL;
return IL_TRUE;
cleanup_error:
ifree(Palette);
ifree(Resources);
return IL_FALSE;
}
ILboolean channelReadMixed(ILubyte *scan, ILint width, ILint noCol, ILint *off, ILint bytes)
{
ILint count;
int i, j, k;
ILubyte col[4];
for(i = 0; i < width; i += count) {
if (ieof())
return IL_FALSE;
count = igetc();
if (count == IL_EOF)
return IL_FALSE;
if (count >= 128) { // Repeated sequence
if (count == 128) { // Long run
count = GetBigUShort();
if (ieof()) {
ilSetError(IL_FILE_READ_ERROR);
return IL_FALSE;
}
}
else
count -= 127;
// We've run past...
if ((i + count) > width) {
//fprintf(stderr, "ERROR: FF_PIC_load(): Overrun scanline (Repeat) [%d + %d > %d] (NC=%d)\n", i, count, width, noCol);
ilSetError(IL_ILLEGAL_FILE_VALUE);
return IL_FALSE;
}
for (j = 0; j < noCol; j++)
if (iread(&col[j], 1, 1) != 1) {
ilSetError(IL_FILE_READ_ERROR);
return IL_FALSE;
}
for (k = 0; k < count; k++, scan += bytes) {
for (j = 0; j < noCol; j++)
scan[off[j]] = col[j];
}
} else { // Raw sequence
count++;
if ((i + count) > width) {
//fprintf(stderr, "ERROR: FF_PIC_load(): Overrun scanline (Raw) [%d + %d > %d] (NC=%d)\n", i, count, width, noCol);
ilSetError(IL_ILLEGAL_FILE_VALUE);
return IL_FALSE;
}
for (k = count; k > 0; k--, scan += bytes) {
for (j = 0; j < noCol; j++)
if (iread(&scan[off[j]], 1, 1) != 1) {
ilSetError(IL_FILE_READ_ERROR);
return IL_FALSE;
}
}
}
}
return IL_TRUE;
}
ILboolean iLoadIffInternal(void)
{
iff_chunk chunkInfo;
// -- Header info.
ILuint width, height;
ILuint flags, compress;
ILushort tiles;
ILenum format;
ILubyte bpp;
ILboolean tileImageDataFound;
// -- Initialize the top of the chunk stack.
chunkDepth = -1;
// -- File should begin with a FOR4 chunk of type CIMG
chunkInfo = iff_begin_read_chunk();
if (chunkInfo.chunkType != IFF_TAG_CIMG) {
ilSetError(IL_ILLEGAL_FILE_VALUE);
return IL_FALSE;
}
/*
* Read the image header
* OK, we have a FOR4 of type CIMG, look for the following tags
* FVER
* TBHD bitmap header, definition of size, etc.
* AUTH
* DATE
*/
while (1) {
chunkInfo = iff_begin_read_chunk();
// -- Right now, the only info we need about the image is in TBHD
// -- so search this level until we find it.
if( chunkInfo.tag == IFF_TAG_TBHD ) {
// -- Header chunk found
width = GetBigUInt();
height = GetBigUInt();
GetBigShort(); // -- Don't support
GetBigShort(); // -- Don't support
flags = GetBigUInt();
GetBigShort(); // -- Don't support
tiles = GetBigUShort();
compress = GetBigUInt();
iff_end_read_chunk();
if( compress > 1 ) {
ilSetError(IL_ILLEGAL_FILE_VALUE);
return IL_FALSE;
}
break;
} else
iff_end_read_chunk();
} /* END find TBHD while loop */
if (!(flags & RGB_FLAG)) {
ilSetError(IL_ILLEGAL_FILE_VALUE);
return IL_FALSE;
}
if (flags & ALPHA_FLAG) {
format = IL_RGBA; bpp = 4;
} else {
format = IL_RGB; bpp = 3;
}
if (!ilTexImage(width, height, 1, bpp, format, IL_UNSIGNED_BYTE, NULL))
return IL_FALSE;
iCurImage->Origin = IL_ORIGIN_UPPER_LEFT;
tileImageDataFound = IL_FALSE;
while (!tileImageDataFound) {
ILuint tileImage;
ILuint tileZ;
chunkInfo = iff_begin_read_chunk();
/*
* OK, we have a FOR4 of type TBMP, (embedded FOR4)
* look for the following tags
* RGBA color data, RLE compressed tiles of 32 bbp data
* ZBUF z-buffer data, 32 bit float values
* CLPZ depth map specific, clipping planes, 2 float values
* ESXY depth map specific, eye x-y ratios, 2 float values
* HIST
* VERS
* FOR4 <size> BLUR (twice embedded FOR4)
*/
if (chunkInfo.chunkType != IFF_TAG_TBMP) {
iff_end_read_chunk();
continue;
}
tileImageDataFound = IL_TRUE;
tileImage = 0; // Si no RGBA, tileImage = tiles...
if (flags & ZBUFFER_FLAG)
tileZ = 0;
else
tileZ = tiles;
// Read tiles
while ( (tileImage < tiles) || (tileZ < tiles)) {
char *tileData;
ILushort x1, x2, y1, y2, tile_width, tile_height;
ILuint remainingDataSize;
ILushort tile_area;
ILuint tileCompressed;
chunkInfo = iff_begin_read_chunk();
if ((chunkInfo.tag != IFF_TAG_RGBA) && (chunkInfo.tag != IFF_TAG_ZBUF)) {
ilSetError(IL_ILLEGAL_FILE_VALUE);
return IL_FALSE;
}
x1 = GetBigUShort(); y1 = GetBigUShort();
x2 = GetBigUShort(); y2 = GetBigUShort();
remainingDataSize = chunkInfo.size - 4*sizeof(ILushort);
tile_width = x2 - x1 + 1;
tile_height = y2 - y1 + 1;
tile_area = tile_width * tile_height;
if ((ILint)remainingDataSize >= (tile_width * tile_height * bpp))
tileCompressed = 0;
else
tileCompressed = 1;
if (chunkInfo.tag == IFF_TAG_RGBA) {
if (tileCompressed) {
char *data = iff_read_data(remainingDataSize);
if (data) {
tileData = iff_decompress_tile_rle(tile_width, tile_height,
bpp, data, remainingDataSize);
ifree(data);
}
} else {
tileData = iffReadUncompressedTile(tile_width, tile_height, bpp);
}
if (tileData) {
// Dump RGBA data to our data structure
ILushort i;
ILuint base;
base = bpp*(width * y1 + x1);
for (i = 0; i < tile_height; i++) {
memcpy(&iCurImage->Data[base + bpp*i*width],
&tileData[bpp*i*tile_width],
tile_width*bpp*sizeof(char));
}
ifree(tileData);
tileData = NULL;
iff_end_read_chunk();
tileImage++;
} else
return IL_FALSE;
} else if (chunkInfo.tag == IFF_TAG_ZBUF) {
tileZ++;
iff_end_read_chunk();
}
}
}
//ilConvertImage(IL_RGB, IL_UNSIGNED_BYTE); // Why was this here?
return ilFixImage();
}
ILboolean ReadIndexed(ILimage* image, PSDHEAD *Head)
{
ILuint ColorMode, ResourceSize, MiscInfo, NumEnt;
ILushort Compressed;
ILubyte *Palette = NULL, *Resources = NULL;
ILushort ChannelNum;
ColorMode = GetBigUInt(&image->io); // Skip over the 'color mode data section'
if (ColorMode % 3 != 0) {
il2SetError(IL_INVALID_FILE_HEADER);
return IL_FALSE;
}
Palette = (ILubyte*)ialloc(ColorMode);
if (Palette == NULL)
return IL_FALSE;
if (image->io.read(&image->io, Palette, 1, ColorMode) != ColorMode)
goto cleanup_error;
ResourceSize = GetBigUInt(&image->io); // Read the 'image resources section'
Resources = (ILubyte*)ialloc(ResourceSize);
if (Resources == NULL) {
return IL_FALSE;
}
if (image->io.read(&image->io, Resources, 1, ResourceSize) != ResourceSize)
goto cleanup_error;
MiscInfo = GetBigUInt(&image->io);
if (image->io.eof(&image->io))
goto cleanup_error;
image->io.seek(&image->io, MiscInfo, IL_SEEK_CUR);
Compressed = GetBigUShort(&image->io);
if (image->io.eof(&image->io))
goto cleanup_error;
if (Head->Channels != 1 || Head->Depth != 8) {
il2SetError(IL_FORMAT_NOT_SUPPORTED);
goto cleanup_error;
}
ChannelNum = Head->Channels;
if (!il2TexImage(image, Head->Width, Head->Height, 1, 1, IL_COLOUR_INDEX, IL_UNSIGNED_BYTE, NULL))
goto cleanup_error;
if (!image->Pal.use(ColorMode/3, NULL, IL_PAL_RGB24)) {
goto cleanup_error;
}
NumEnt = image->Pal.getNumCols();
for (ILuint j = 0; j < NumEnt; j++) {
image->Pal.setRGB(j, Palette[j], Palette[j+NumEnt], Palette[j+NumEnt*2]);
}
ifree(Palette);
Palette = NULL;
if (!PsdGetData(image, Head, image->Data, (ILboolean)Compressed, ChannelNum))
goto cleanup_error;
ParseResources(image, ResourceSize, Resources);
ifree(Resources);
Resources = NULL;
return IL_TRUE;
cleanup_error:
ifree(Palette);
ifree(Resources);
return IL_FALSE;
}
