ILuint *GetCompChanLen(ILimage* image, PSDHEAD *Head, ILushort& ChannelNum)
{
ILushort *RleTable;
ILuint *ChanLen, c, i, j;
RleTable = (ILushort*)ialloc(Head->Height * ChannelNum * sizeof(ILushort));
ChanLen = (ILuint*)ialloc(ChannelNum * sizeof(ILuint));
if (RleTable == NULL || ChanLen == NULL) {
return NULL;
}
if (image->io.read(&image->io, RleTable, sizeof(ILushort), Head->Height * ChannelNum) != Head->Height * ChannelNum) {
ifree(RleTable);
ifree(ChanLen);
return NULL;
}
#ifdef IL_LITTLE_ENDIAN
for (i = 0; i < Head->Height * ChannelNum; i++) {
iSwapUShort(&RleTable[i]);
}
#endif
imemclear(ChanLen, ChannelNum * sizeof(ILuint));
for (c = 0; c < ChannelNum; c++) {
j = c * Head->Height;
for (i = 0; i < Head->Height; i++) {
ChanLen[c] += RleTable[i + j];
}
}
ifree(RleTable);
return ChanLen;
}
ILvoid* ILAPIENTRY icalloc(ILuint Size, ILuint Num)
{
ILvoid *Ptr;
Ptr = ialloc(Size * Num);
if (Ptr == NULL)
return NULL;
imemclear(Ptr, Size * Num);
return Ptr;
}
// Makes a neat date string for the date field.
char *iMakeString()
{
static char TimeStr[255];
time_t Time;
struct tm *CurTime;
imemclear(TimeStr, 255);
time(&Time);
#ifdef _WIN32
_tzset();
#endif
CurTime = localtime(&Time);
strftime(TimeStr, 255, "%s (%z)", CurTime); // "%#c (%z)" // %s was %c
return TimeStr;
}
// Like realloc but sets new memory to 0.
ILvoid* ILAPIENTRY ilRecalloc(ILvoid *Ptr, ILuint OldSize, ILuint NewSize)
{
ILvoid *Temp = ialloc(NewSize);
ILuint CopySize = (OldSize < NewSize) ? OldSize : NewSize;
if (Temp != NULL) {
if (Ptr != NULL) {
memcpy(Temp, Ptr, CopySize);
ifree(Ptr);
}
Ptr = Temp;
if (OldSize < NewSize)
imemclear((ILubyte*)Temp + OldSize, NewSize - OldSize);
}
return Temp;
}
// Compresses an entire image using run-length encoding
ILuint ilRleCompress(ILubyte *Data, ILuint Width, ILuint Height, ILuint Depth, ILubyte Bpp,
ILubyte *Dest, ILenum CompressMode, ILuint *ScanTable) {
ILuint DestW = 0, i, j, LineLen, Bps = Width * Bpp, SizeOfPlane = Width * Height * Bpp;
if( ScanTable )
imemclear(ScanTable,Depth*Height*sizeof(ILuint));
for( j = 0; j < Depth; j++ ) {
for( i = 0; i < Height; i++ ) {
if( ScanTable )
*ScanTable++ = DestW;
ilRleCompressLine(Data + j * SizeOfPlane + i * Bps, Width, Bpp, Dest + DestW, &LineLen, CompressMode);
DestW += LineLen;
}
}
if( CompressMode == IL_BMPCOMP ) { // add end of image
*(Data+DestW) = 0x00; DestW++;
*(Data+DestW) = 0x01; DestW++;
}
return DestW;
}
ILboolean iSaveJpegInternal(ILstring FileName, ILvoid *Lump, ILuint Size)
{
JPEG_CORE_PROPERTIES Image;
ILuint Quality;
ILimage *TempImage;
ILubyte *TempData;
imemclear(&Image, sizeof(JPEG_CORE_PROPERTIES));
if (iCurImage == NULL) {
ilSetError(IL_ILLEGAL_OPERATION);
return IL_FALSE;
}
if (FileName == NULL && Lump == NULL) {
ilSetError(IL_INVALID_PARAM);
return IL_FALSE;
}
if (iGetHint(IL_COMPRESSION_HINT) == IL_USE_COMPRESSION)
Quality = 85; // Not sure how low we should dare go...
else
Quality = 99;
if (ijlInit(&Image) != IJL_OK) {
ilSetError(IL_LIB_JPEG_ERROR);
return IL_FALSE;
}
if ((iCurImage->Format != IL_RGB && iCurImage->Format != IL_RGBA && iCurImage->Format != IL_LUMINANCE)
|| iCurImage->Bpc != 1) {
if (iCurImage->Format == IL_BGRA)
Temp = iConvertImage(iCurImage, IL_RGBA, IL_UNSIGNED_BYTE);
else
Temp = iConvertImage(iCurImage, IL_RGB, IL_UNSIGNED_BYTE);
if (Temp == NULL) {
return IL_FALSE;
}
}
else {
Temp = iCurImage;
}
if (TempImage->Origin == IL_ORIGIN_LOWER_LEFT) {
TempData = iGetFlipped(TempImage);
if (TempData == NULL) {
if (TempImage != iCurImage)
ilCloseImage(TempImage);
return IL_FALSE;
}
}
else {
TempData = TempImage->Data;
}
// Setup DIB
Image.DIBWidth = TempImage->Width;
Image.DIBHeight = TempImage->Height;
Image.DIBChannels = TempImage->Bpp;
Image.DIBBytes = TempData;
Image.DIBPadBytes = 0;
// Setup JPEG
Image.JPGWidth = TempImage->Width;
Image.JPGHeight = TempImage->Height;
Image.JPGChannels = TempImage->Bpp;
switch (Temp->Bpp)
{
case 1:
Image.DIBColor = IJL_G;
Image.JPGColor = IJL_G;
Image.JPGSubsampling = IJL_NONE;
break;
case 3:
Image.DIBColor = IJL_RGB;
Image.JPGColor = IJL_YCBCR;
Image.JPGSubsampling = IJL_411;
break;
case 4:
Image.DIBColor = IJL_RGBA_FPX;
Image.JPGColor = IJL_YCBCRA_FPX;
Image.JPGSubsampling = IJL_4114;
break;
}
if (FileName != NULL) {
Image.JPGFile = FileName;
if (ijlWrite(&Image, IJL_JFILE_WRITEWHOLEIMAGE) != IJL_OK) {
if (TempImage != iCurImage)
ilCloseImage(TempImage);
ilSetError(IL_LIB_JPEG_ERROR);
return IL_FALSE;
}
}
else {
Image.JPGBytes = Lump;
Image.JPGSizeBytes = Size;
if (ijlWrite(&Image, IJL_JBUFF_WRITEWHOLEIMAGE) != IJL_OK) {
if (TempImage != iCurImage)
ilCloseImage(TempImage);
ilSetError(IL_LIB_JPEG_ERROR);
return IL_FALSE;
}
}
ijlFree(&Image);
if (TempImage->Origin == IL_ORIGIN_LOWER_LEFT)
ifree(TempData);
if (Temp != iCurImage)
ilCloseImage(Temp);
return IL_TRUE;
}
ILAPI ILboolean ILAPIENTRY ilClearImage_(ILimage *Image)
{
ILuint i, c, NumBytes;
ILubyte Colours[32]; // Maximum is sizeof(double) * 4 = 32
ILubyte *BytePtr;
ILushort *ShortPtr;
ILuint *IntPtr;
ILfloat *FloatPtr;
ILdouble *DblPtr;
NumBytes = Image->Bpp * Image->Bpc;
ilGetClear(Colours, Image->Format, Image->Type);
if (Image->Format != IL_COLOUR_INDEX) {
switch (Image->Type)
{
case IL_BYTE:
case IL_UNSIGNED_BYTE:
BytePtr = (ILubyte*)Colours;
for (c = 0; c < NumBytes; c += Image->Bpc) {
for (i = c; i < Image->SizeOfData; i += NumBytes) {
Image->Data[i] = BytePtr[c];
}
}
break;
case IL_SHORT:
case IL_UNSIGNED_SHORT:
ShortPtr = (ILushort*)Colours;
for (c = 0; c < NumBytes; c += Image->Bpc) {
for (i = c; i < Image->SizeOfData; i += NumBytes) {
*((ILushort*)(Image->Data + i)) = ShortPtr[c];
}
}
break;
case IL_INT:
case IL_UNSIGNED_INT:
IntPtr = (ILuint*)Colours;
for (c = 0; c < NumBytes; c += Image->Bpc) {
for (i = c; i < Image->SizeOfData; i += NumBytes) {
*((ILuint*)(Image->Data + i)) = IntPtr[c];
}
}
break;
case IL_FLOAT:
FloatPtr = (ILfloat*)Colours;
for (c = 0; c < NumBytes; c += Image->Bpc) {
for (i = c; i < Image->SizeOfData; i += NumBytes) {
*((ILfloat*)(Image->Data + i)) = FloatPtr[c];
}
}
break;
case IL_DOUBLE:
DblPtr = (ILdouble*)Colours;
for (c = 0; c < NumBytes; c += Image->Bpc) {
for (i = c; i < Image->SizeOfData; i += NumBytes) {
*((ILdouble*)(Image->Data + i)) = DblPtr[c];
}
}
break;
}
}
else {
imemclear(Image->Data, Image->SizeOfData);
if (Image->Pal.Palette)
ifree(Image->Pal.Palette);
Image->Pal.Palette = (ILubyte*)ialloc(4);
if (Image->Pal.Palette == NULL) {
return IL_FALSE;
}
Image->Pal.PalType = IL_PAL_RGBA32;
Image->Pal.PalSize = 4;
Image->Pal.Palette[0] = Colours[0] * UCHAR_MAX;
Image->Pal.Palette[1] = Colours[1] * UCHAR_MAX;
Image->Pal.Palette[2] = Colours[2] * UCHAR_MAX;
Image->Pal.Palette[3] = Colours[3] * UCHAR_MAX;
}
return IL_TRUE;
}
ILboolean ILAPIENTRY ilApplyPal(ILconst_string FileName)
{
ILimage Image, *CurImage = iCurImage;
ILubyte *NewData;
ILuint *PalInfo, NumColours, NumPix, MaxDist, DistEntry=0, i, j;
ILint Dist1, Dist2, Dist3;
ILboolean Same;
ILenum Origin;
// COL_CUBE *Cubes;
if( iCurImage == NULL || (iCurImage->Format != IL_BYTE || iCurImage->Format != IL_UNSIGNED_BYTE) ) {
ilSetError(IL_ILLEGAL_OPERATION);
return IL_FALSE;
}
NewData = (ILubyte*)ialloc(iCurImage->Width * iCurImage->Height * iCurImage->Depth);
if (NewData == NULL) {
return IL_FALSE;
}
iCurImage = &Image;
imemclear(&Image, sizeof(ILimage));
// IL_PAL_RGB24, because we don't want to make parts transparent that shouldn't be.
if (!ilLoadPal(FileName) || !ilConvertPal(IL_PAL_RGB24)) {
ifree(NewData);
iCurImage = CurImage;
return IL_FALSE;
}
NumColours = Image.Pal.PalSize / 3; // RGB24 is 3 bytes per entry.
PalInfo = (ILuint*)ialloc(NumColours * sizeof(ILuint));
if (PalInfo == NULL) {
ifree(NewData);
iCurImage = CurImage;
return IL_FALSE;
}
NumPix = CurImage->SizeOfData / ilGetBppFormat(CurImage->Format);
switch (CurImage->Format)
{
case IL_COLOUR_INDEX:
iCurImage = CurImage;
if (!ilConvertPal(IL_PAL_RGB24)) {
ifree(NewData);
ifree(PalInfo);
return IL_FALSE;
}
NumPix = iCurImage->Pal.PalSize / ilGetBppPal(iCurImage->Pal.PalType);
for (i = 0; i < NumPix; i++) {
for (j = 0; j < Image.Pal.PalSize; j += 3) {
// No need to perform a sqrt.
Dist1 = (ILint)iCurImage->Pal.Palette[i] - (ILint)Image.Pal.Palette[j];
Dist2 = (ILint)iCurImage->Pal.Palette[i+1] - (ILint)Image.Pal.Palette[j+1];
Dist3 = (ILint)iCurImage->Pal.Palette[i+2] - (ILint)Image.Pal.Palette[j+2];
PalInfo[j / 3] = Dist1 * Dist1 + Dist2 * Dist2 + Dist3 * Dist3;
}
MaxDist = UINT_MAX;
DistEntry = 0;
for (j = 0; j < NumColours; j++) {
if (PalInfo[j] < MaxDist) {
DistEntry = j;
MaxDist = PalInfo[j];
}
}
iCurImage->Pal.Palette[i] = DistEntry;
}
for (i = 0; i < iCurImage->SizeOfData; i++) {
NewData[i] = iCurImage->Pal.Palette[iCurImage->Data[i]];
}
break;
case IL_RGB:
case IL_RGBA:
/*Cube = (COL_CUBE*)ialloc(NumColours * sizeof(COL_CUBE));
// @TODO: Check if ialloc failed here!
for (i = 0; i < NumColours; i++)
memcpy(&Cubes[i].Val, Image.Pal.Palette[i * 3], 3);
for (j = 0; j < 3; j++) {
qsort(Cubes, NumColours, sizeof(COL_CUBE), sort_func);
Cubes[0].Min = 0;
Cubes[NumColours-1] = UCHAR_MAX;
NumColours--;
for (i = 1; i < NumColours; i++) {
Cubes[i].Min[CurSort] = Cubes[i-1].Val[CurSort] + 1;
Cubes[i-1].Max[CurSort] = Cubes[i].Val[CurSort] - 1;
}
CurSort++;
NumColours++;
}*/
for (i = 0; i < CurImage->SizeOfData; i += CurImage->Bpp) {
Same = IL_TRUE;
if (i != 0) {
for (j = 0; j < CurImage->Bpp; j++) {
if (CurImage->Data[i-CurImage->Bpp+j] != CurImage->Data[i+j]) {
Same = IL_FALSE;
break;
}
}
}
if (Same) {
NewData[i / CurImage->Bpp] = DistEntry;
continue;
}
for (j = 0; j < Image.Pal.PalSize; j += 3) {
// No need to perform a sqrt.
Dist1 = (ILint)CurImage->Data[i] - (ILint)Image.Pal.Palette[j];
Dist2 = (ILint)CurImage->Data[i+1] - (ILint)Image.Pal.Palette[j+1];
Dist3 = (ILint)CurImage->Data[i+2] - (ILint)Image.Pal.Palette[j+2];
PalInfo[j / 3] = Dist1 * Dist1 + Dist2 * Dist2 + Dist3 * Dist3;
}
MaxDist = UINT_MAX;
DistEntry = 0;
for (j = 0; j < NumColours; j++) {
if (PalInfo[j] < MaxDist) {
DistEntry = j;
MaxDist = PalInfo[j];
}
}
NewData[i / CurImage->Bpp] = DistEntry;
}
break;
case IL_BGR:
case IL_BGRA:
for (i = 0; i < CurImage->SizeOfData; i += CurImage->Bpp) {
for (j = 0; j < NumColours; j++) {
// No need to perform a sqrt.
PalInfo[j] = ((ILint)CurImage->Data[i+2] - (ILint)Image.Pal.Palette[j * 3]) *
((ILint)CurImage->Data[i+2] - (ILint)Image.Pal.Palette[j * 3]) +
((ILint)CurImage->Data[i+1] - (ILint)Image.Pal.Palette[j * 3 + 1]) *
((ILint)CurImage->Data[i+1] - (ILint)Image.Pal.Palette[j * 3 + 1]) +
((ILint)CurImage->Data[i] - (ILint)Image.Pal.Palette[j * 3 + 2]) *
((ILint)CurImage->Data[i] - (ILint)Image.Pal.Palette[j * 3 + 2]);
}
MaxDist = UINT_MAX;
DistEntry = 0;
for (j = 0; j < NumColours; j++) {
if (PalInfo[j] < MaxDist) {
DistEntry = j;
MaxDist = PalInfo[j];
}
}
NewData[i / CurImage->Bpp] = DistEntry;
}
break;
case IL_LUMINANCE:
case IL_LUMINANCE_ALPHA:
for (i = 0; i < CurImage->SizeOfData; i += CurImage->Bpp ) {
for (j = 0; j < NumColours; j++) {
// No need to perform a sqrt.
PalInfo[j] = ((ILuint)CurImage->Data[i] - (ILuint)Image.Pal.Palette[j * 3]) *
((ILuint)CurImage->Data[i] - (ILuint)Image.Pal.Palette[j * 3]) +
((ILuint)CurImage->Data[i] - (ILuint)Image.Pal.Palette[j * 3 + 1]) *
((ILuint)CurImage->Data[i] - (ILuint)Image.Pal.Palette[j * 3 + 1]) +
((ILuint)CurImage->Data[i] - (ILuint)Image.Pal.Palette[j * 3 + 2]) *
((ILuint)CurImage->Data[i] - (ILuint)Image.Pal.Palette[j * 3 + 2]);
}
MaxDist = UINT_MAX;
DistEntry = 0;
for (j = 0; j < NumColours; j++) {
if (PalInfo[j] < MaxDist) {
DistEntry = j;
MaxDist = PalInfo[j];
}
}
NewData[i] = DistEntry;
}
break;
default: // Should be no other!
ilSetError(IL_INTERNAL_ERROR);
return IL_FALSE;
}
iCurImage = CurImage;
Origin = iCurImage->Origin;
if (!ilTexImage(iCurImage->Width, iCurImage->Height, iCurImage->Depth, 1,
IL_COLOUR_INDEX, IL_UNSIGNED_BYTE, NewData)) {
ifree(Image.Pal.Palette);
ifree(PalInfo);
ifree(NewData);
return IL_FALSE;
}
iCurImage->Origin = Origin;
iCurImage->Pal.Palette = Image.Pal.Palette;
iCurImage->Pal.PalSize = Image.Pal.PalSize;
iCurImage->Pal.PalType = Image.Pal.PalType;
ifree(PalInfo);
ifree(NewData);
return IL_TRUE;
}
ILAPI ILboolean ILAPIENTRY il2ClearImage(ILimage *Image)
{
ILuint i, c, NumBytes;
ILubyte Colours[32]; // Maximum is sizeof(double) * 4 = 32
ILubyte *BytePtr;
ILushort *ShortPtr;
ILuint *IntPtr;
ILfloat *FloatPtr;
ILdouble *DblPtr;
if (Image == NULL) {
il2SetError(IL_ILLEGAL_OPERATION);
return IL_FALSE;
}
NumBytes = Image->Bpp * Image->Bpc;
il2GetClear(Colours, Image->Format, Image->Type);
if (Image->Format != IL_COLOUR_INDEX) {
switch (Image->Type)
{
case IL_BYTE:
case IL_UNSIGNED_BYTE:
BytePtr = (ILubyte*)Colours;
for (c = 0; c < NumBytes; c += Image->Bpc) {
for (i = c; i < Image->SizeOfData; i += NumBytes) {
Image->Data[i] = BytePtr[c];
}
}
break;
case IL_SHORT:
case IL_UNSIGNED_SHORT:
ShortPtr = (ILushort*)Colours;
for (c = 0; c < NumBytes; c += Image->Bpc) {
for (i = c; i < Image->SizeOfData; i += NumBytes) {
*((ILushort*)(Image->Data + i)) = ShortPtr[c / Image->Bpc];
}
}
break;
case IL_INT:
case IL_UNSIGNED_INT:
IntPtr = (ILuint*)Colours;
for (c = 0; c < NumBytes; c += Image->Bpc) {
for (i = c; i < Image->SizeOfData; i += NumBytes) {
*((ILuint*)(Image->Data + i)) = IntPtr[c / Image->Bpc];
}
}
break;
case IL_FLOAT:
FloatPtr = (ILfloat*)Colours;
for (c = 0; c < NumBytes; c += Image->Bpc) {
for (i = c; i < Image->SizeOfData; i += NumBytes) {
*((ILfloat*)(Image->Data + i)) = FloatPtr[c / Image->Bpc];
}
}
break;
case IL_DOUBLE:
DblPtr = (ILdouble*)Colours;
for (c = 0; c < NumBytes; c += Image->Bpc) {
for (i = c; i < Image->SizeOfData; i += NumBytes) {
*((ILdouble*)(Image->Data + i)) = DblPtr[c / Image->Bpc];
}
}
break;
}
}
else {
imemclear(Image->Data, Image->SizeOfData);
Image->Pal.use(1, NULL, IL_PAL_RGBA32);
Image->Pal.setRGBA(0, Colours[0] * UCHAR_MAX,
Colours[1] * UCHAR_MAX, Colours[2] * UCHAR_MAX, Colours[3] * UCHAR_MAX);
}
return IL_TRUE;
}
// Does not account for converting luminance...
SDL_Surface * ILAPIENTRY ilutConvertToSDLSurface(unsigned int flags)
{
SDL_Surface *Bitmap;
ILuint i = 0, Pad, BppPal;
ILubyte *Dest;
ilutCurImage = ilGetCurImage();
if (ilutCurImage == NULL) {
ilSetError(ILUT_ILLEGAL_OPERATION);
return NULL;
}
InitSDL();
// Should be IL_BGR(A).
if (ilutCurImage->Format == IL_RGB || ilutCurImage->Format == IL_RGBA) {
if (!isBigEndian)
iluSwapColours();
}
if (ilutCurImage->Origin == IL_ORIGIN_LOWER_LEFT)
iluFlipImage();
if (ilutCurImage->Type > IL_UNSIGNED_BYTE) {} // Can't do anything about this right now...
if (ilutCurImage->Type == IL_BYTE) {} // Can't do anything about this right now...
Bitmap = SDL_CreateRGBSurface(flags,ilutCurImage->Width,ilutCurImage->Height,ilutCurImage->Bpp * 8,
rmask,gmask,bmask,amask);
if (Bitmap == NULL) {
return IL_FALSE;
}
if (SDL_MUSTLOCK(Bitmap))
SDL_LockSurface(Bitmap);
Pad = Bitmap->pitch - ilutCurImage->Bps;
if (Pad == 0) {
memcpy(Bitmap->pixels, ilutCurImage->Data, ilutCurImage->SizeOfData);
}
else { // Must pad the lines on some images.
Dest = Bitmap->pixels;
for (i = 0; i < ilutCurImage->Height; i++) {
memcpy(Dest, ilutCurImage->Data + i * ilutCurImage->Bps, ilutCurImage->Bps);
imemclear(Dest + ilutCurImage->Bps, Pad);
Dest += Bitmap->pitch;
}
}
if (SDL_MUSTLOCK(Bitmap))
SDL_UnlockSurface(Bitmap);
if (ilutCurImage->Bpp == 1) {
BppPal = ilGetBppPal(ilutCurImage->Pal.PalType);
switch (ilutCurImage->Pal.PalType)
{
case IL_PAL_RGB24:
case IL_PAL_RGB32:
case IL_PAL_RGBA32:
for (i = 0; i < ilutCurImage->Pal.PalSize / BppPal; i++) {
(Bitmap->format)->palette->colors[i].r = ilutCurImage->Pal.Palette[i*BppPal+0];
(Bitmap->format)->palette->colors[i].g = ilutCurImage->Pal.Palette[i*BppPal+1];
(Bitmap->format)->palette->colors[i].b = ilutCurImage->Pal.Palette[i*BppPal+2];
(Bitmap->format)->palette->colors[i].unused = 255;
}
break;
case IL_PAL_BGR24:
case IL_PAL_BGR32:
case IL_PAL_BGRA32:
for (i = 0; i < ilutCurImage->Pal.PalSize / BppPal; i++) {
(Bitmap->format)->palette->colors[i].b = ilutCurImage->Pal.Palette[i*BppPal+0];
(Bitmap->format)->palette->colors[i].g = ilutCurImage->Pal.Palette[i*BppPal+1];
(Bitmap->format)->palette->colors[i].r = ilutCurImage->Pal.Palette[i*BppPal+2];
(Bitmap->format)->palette->colors[i].unused = 255;
}
break;
default:
ilSetError(IL_INTERNAL_ERROR); // Do anything else?
}
}
return Bitmap;
}
ILboolean iReadRleSgi(iSgiHeader *Head)
{
#ifdef __LITTLE_ENDIAN__
ILuint ixTable;
#endif
ILuint ChanInt = 0;
ILuint ixPlane, ixHeight,ixPixel, RleOff, RleLen;
ILuint *OffTable=NULL, *LenTable=NULL, TableSize, Cur;
ILubyte **TempData=NULL;
if (!iNewSgi(Head))
return IL_FALSE;
TableSize = Head->YSize * Head->ZSize;
OffTable = (ILuint*)ialloc(TableSize * sizeof(ILuint));
LenTable = (ILuint*)ialloc(TableSize * sizeof(ILuint));
if (OffTable == NULL || LenTable == NULL)
goto cleanup_error;
if (iread(OffTable, TableSize * sizeof(ILuint), 1) != 1)
goto cleanup_error;
if (iread(LenTable, TableSize * sizeof(ILuint), 1) != 1)
goto cleanup_error;
#ifdef __LITTLE_ENDIAN__
// Fix the offset/len table (it's big endian format)
for (ixTable = 0; ixTable < TableSize; ixTable++) {
iSwapUInt(OffTable + ixTable);
iSwapUInt(LenTable + ixTable);
}
#endif //__LITTLE_ENDIAN__
// We have to create a temporary buffer for the image, because SGI
// images are plane-separated. */
TempData = (ILubyte**)ialloc(Head->ZSize * sizeof(ILubyte*));
if (TempData == NULL)
goto cleanup_error;
imemclear(TempData, Head->ZSize * sizeof(ILubyte*)); // Just in case ialloc fails then cleanup_error.
for (ixPlane = 0; ixPlane < Head->ZSize; ixPlane++) {
TempData[ixPlane] = (ILubyte*)ialloc(Head->XSize * Head->YSize * Head->Bpc);
if (TempData[ixPlane] == NULL)
goto cleanup_error;
}
// Read the Planes into the temporary memory
for (ixPlane = 0; ixPlane < Head->ZSize; ixPlane++) {
for (ixHeight = 0, Cur = 0; ixHeight < Head->YSize;
ixHeight++, Cur += Head->XSize * Head->Bpc) {
RleOff = OffTable[ixHeight + ixPlane * Head->YSize];
RleLen = LenTable[ixHeight + ixPlane * Head->YSize];
// Seeks to the offset table position
iseek(RleOff, IL_SEEK_SET);
if (iGetScanLine((TempData[ixPlane]) + (ixHeight * Head->XSize * Head->Bpc),
Head, RleLen) != Head->XSize * Head->Bpc) {
ilSetError(IL_ILLEGAL_FILE_VALUE);
goto cleanup_error;
}
}
}
// DW: Removed on 05/25/2002.
/*// Check if an alphaplane exists and invert it
if (Head->ZSize == 4) {
for (ixPixel=0; (ILint)ixPixel<Head->XSize * Head->YSize; ixPixel++) {
TempData[3][ixPixel] = TempData[3][ixPixel] ^ 255;
}
}*/
// Assemble the image from its planes
for (ixPixel = 0; ixPixel < iCurImage->SizeOfData;
ixPixel += Head->ZSize * Head->Bpc, ChanInt += Head->Bpc) {
for (ixPlane = 0; (ILint)ixPlane < Head->ZSize * Head->Bpc; ixPlane += Head->Bpc) {
iCurImage->Data[ixPixel + ixPlane] = TempData[ixPlane][ChanInt];
if (Head->Bpc == 2)
iCurImage->Data[ixPixel + ixPlane + 1] = TempData[ixPlane][ChanInt + 1];
}
}
#ifdef __LITTLE_ENDIAN__
if (Head->Bpc == 2)
sgiSwitchData(iCurImage->Data, iCurImage->SizeOfData);
#endif
ifree(OffTable);
ifree(LenTable);
for (ixPlane = 0; ixPlane < Head->ZSize; ixPlane++) {
ifree(TempData[ixPlane]);
}
ifree(TempData);
return IL_TRUE;
cleanup_error:
ifree(OffTable);
ifree(LenTable);
if (TempData) {
for (ixPlane = 0; ixPlane < Head->ZSize; ixPlane++) {
ifree(TempData[ixPlane]);
}
ifree(TempData);
}
return IL_FALSE;
}
ILubyte *iScanFill()
{
Edge **edges = NULL, *active = NULL/*, *temp*/;
ILuint i, scan;
iRegionMask = NULL;
if ((RegionPointsi == NULL && RegionPointsf == NULL) || PointNum == 0)
return NULL;
if (RegionPointsf) {
RegionPointsi = (ILpointi*)ialloc(sizeof(ILpointi) * PointNum);
if (RegionPointsi == NULL)
goto error;
}
for (i = 0; i < PointNum; i++) {
if (RegionPointsf) {
RegionPointsi[i].x = (ILuint)(iluCurImage->Width * RegionPointsf[i].x);
RegionPointsi[i].y = (ILuint)(iluCurImage->Height * RegionPointsf[i].y);
}
if (RegionPointsi[i].x >= (ILint)iluCurImage->Width || RegionPointsi[i].y >= (ILint)iluCurImage->Height)
goto error;
}
edges = (Edge**)ialloc(sizeof(Edge*) * iluCurImage->Height);
iRegionMask = (ILubyte*)ialloc(iluCurImage->Width * iluCurImage->Height * iluCurImage->Depth);
if (edges == NULL || iRegionMask == NULL)
goto error;
imemclear(iRegionMask, iluCurImage->Width * iluCurImage->Height * iluCurImage->Depth);
for (i = 0; i < iluCurImage->Height; i++) {
edges[i] = (Edge*)ialloc(sizeof(Edge));
edges[i]->next = NULL;
}
BuildEdgeList(PointNum, RegionPointsi, edges);
active = (Edge*)ialloc(sizeof(Edge));
active->next = NULL;
for (scan = 0; scan < iluCurImage->Height; scan++) {
BuildActiveList(scan, active, edges);
if (active->next) {
FillScan(scan, active);
UpdateActiveList(scan, active);
ResortActiveList(active);
}
}
// Free edge records that have been allocated.
/*for (i = 0; i < iluCurImage->Height; i++) {
while (edges[i]) {
temp = edges[i]->next;
ifree(edges[i]);
edges[i] = temp;
}
}*/
ifree(edges);
if (RegionPointsf) {
ifree(RegionPointsi);
RegionPointsi = NULL;
}
return iRegionMask;
error:
if (RegionPointsf) {
ifree(RegionPointsi);
RegionPointsi = NULL;
}
// Free edge records that have been allocated.
ifree(edges);
ifree(iRegionMask);
return NULL;
}
