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; }