//! Checks if the file specified in FileName is a valid .jpg file.
ILboolean ilIsValid_JPEG(ILconst_string FileName)
{
ILHANDLE JpegFile;
ILboolean bJpeg = IL_FALSE;
if (!iCheckExtension(FileName, IL_TEXT("jpg")) &&
!iCheckExtension(FileName, IL_TEXT("jpe")) &&
!iCheckExtension(FileName, IL_TEXT("jpeg")) &&
!iCheckExtension(FileName, IL_TEXT("jif")) &&
!iCheckExtension(FileName, IL_TEXT("jfif")))
{
ilSetError(IL_INVALID_EXTENSION);
return bJpeg;
}
JpegFile = iopenr(FileName);
if (JpegFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bJpeg;
}
bJpeg = ilIsValidF_JPEG(JpegFile);
icloser(JpegFile);
return bJpeg;
}
ILboolean ilLoadJpeg(ILconst_string FileName)
{
ILHANDLE JpegFile;
ILboolean bJpeg = IL_FALSE;
JpegFile = iopenr(FileName);
if (JpegFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bJpeg;
}
bJpeg = ilLoadJpegF(JpegFile);
icloser(JpegFile);
return bJpeg;
}
//! Reads an IFF file
ILboolean ilLoadIff(const ILstring FileName)
{
ILHANDLE iffFile;
ILboolean ret = IL_FALSE;
iffFile = iopenr(FileName);
if (iffFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return ret;
}
ret = ilLoadIffF(iffFile);
icloser(iffFile);
return ret;
}
//! Loads an .plt palette file.
ILboolean ilLoadPltPal(ILconst_string FileName)
{
ILHANDLE PltFile;
if (!iCheckExtension(FileName, IL_TEXT("plt"))) {
ilSetError(IL_INVALID_EXTENSION);
return IL_FALSE;
}
if (iCurImage == NULL) {
ilSetError(IL_ILLEGAL_OPERATION);
return IL_FALSE;
}
PltFile = iopenr(FileName);
if (PltFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return IL_FALSE;
}
if (iCurImage->Pal.Palette && iCurImage->Pal.PalSize > 0 && iCurImage->Pal.PalType != IL_PAL_NONE) {
ifree(iCurImage->Pal.Palette);
iCurImage->Pal.Palette = NULL;
}
iCurImage->Pal.PalSize = GetLittleUInt();
if (iCurImage->Pal.PalSize == 0) {
ilSetError(IL_INVALID_FILE_HEADER);
return IL_FALSE;
}
iCurImage->Pal.PalType = IL_PAL_RGB24;
iCurImage->Pal.Palette = (ILubyte*)ialloc(iCurImage->Pal.PalSize);
if (!iCurImage->Pal.Palette) {
icloser(PltFile);
return IL_FALSE;
}
if (iread(iCurImage->Pal.Palette, iCurImage->Pal.PalSize, 1) != 1) {
ifree(iCurImage->Pal.Palette);
iCurImage->Pal.Palette = NULL;
icloser(PltFile);
return IL_FALSE;
}
icloser(PltFile);
return IL_TRUE;
}
//! Reads a .Lif file
ILboolean ilLoadLif(ILconst_string FileName)
{
ILHANDLE LifFile;
ILboolean bLif = IL_FALSE;
LifFile = iopenr(FileName);
if (LifFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bLif;
}
bLif = ilLoadLifF(LifFile);
icloser(LifFile);
return bLif;
}
//! Reads a .ktx file
ILboolean ilLoadKtx(ILconst_string FileName)
{
ILHANDLE KtxFile;
ILboolean bKtx = IL_FALSE;
KtxFile = iopenr(FileName);
if (KtxFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bKtx;
}
bKtx = ilLoadKtxF(KtxFile);
icloser(KtxFile);
return bKtx;
}
//! Reads a Tiff file
ILboolean ilLoad_TIFF(ILconst_string FileName)
{
ILHANDLE TiffFile;
ILboolean bTiff = IL_FALSE;
TiffFile = iopenr(FileName);
if (TiffFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
}
else {
bTiff = ilLoadF_TIFF(TiffFile);
icloser(TiffFile);
}
return bTiff;
}
//! Reads a .hdr file
ILboolean ilLoadHdr(ILconst_string FileName)
{
ILHANDLE HdrFile;
ILboolean bHdr = IL_FALSE;
HdrFile = iopenr(FileName);
if (HdrFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bHdr;
}
bHdr = ilLoadHdrF(HdrFile);
icloser(HdrFile);
return bHdr;
}
//! Reads an icon file.
ILboolean ilLoadIcns(ILconst_string FileName)
{
ILHANDLE IcnsFile;
ILboolean bIcns = IL_FALSE;
IcnsFile = iopenr(FileName);
if (IcnsFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bIcns;
}
bIcns = ilLoadIcnsF(IcnsFile);
icloser(IcnsFile);
return bIcns;
}
//! Reads a BLP file
ILboolean ilLoadBlp(ILconst_string FileName)
{
ILHANDLE BlpFile;
ILboolean bBlp = IL_FALSE;
BlpFile = iopenr(FileName);
if (BlpFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bBlp;
}
bBlp = ilLoadBlpF(BlpFile);
icloser(BlpFile);
return bBlp;
}
//! Reads a WDP file
ILboolean ilLoadWdp(ILconst_string FileName)
{
ILHANDLE WdpFile;
ILboolean bWdp = IL_FALSE;
WdpFile = iopenr(FileName);
if (WdpFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bWdp;
}
bWdp = ilLoadWdpF(WdpFile);
icloser(WdpFile);
return bWdp;
}
//! Reads a ROT file
ILboolean ilLoad_ROT(ILconst_string FileName)
{
ILHANDLE RotFile;
ILboolean bRot = IL_FALSE;
RotFile = iopenr(FileName);
if (RotFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bRot;
}
bRot = ilLoadF_ROT(RotFile);
icloser(RotFile);
return bRot;
}
/*! Reads a SGI file */
ILboolean ilLoadSgi(ILconst_string FileName)
{
ILHANDLE SgiFile;
ILboolean bSgi = IL_FALSE;
SgiFile = iopenr(FileName);
if (SgiFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bSgi;
}
bSgi = ilLoadSgiF(SgiFile);
icloser(SgiFile);
return bSgi;
}
//! Reads a .cut file
ILboolean ilLoadCut(ILconst_string FileName)
{
ILHANDLE CutFile;
ILboolean bCut = IL_FALSE;
CutFile = iopenr(FileName);
if (CutFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bCut;
}
bCut = ilLoadCutF(CutFile);
icloser(CutFile);
return bCut;
}
//! Reads a Jpeg2000 file.
ILboolean ilLoadJp2(ILconst_string FileName)
{
ILHANDLE Jp2File;
ILboolean bRet;
Jp2File = iopenr(FileName);
if (Jp2File == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return IL_FALSE;
}
bRet = ilLoadJp2F(Jp2File);
icloser(Jp2File);
return bRet;
}
// Reads a file
ILboolean ilLoadIlbm(ILconst_string FileName)
{
ILHANDLE IlbmFile;
ILboolean bIlbm = IL_FALSE;
IlbmFile = iopenr(FileName);
if (IlbmFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bIlbm;
}
bIlbm = ilLoadIlbmF(IlbmFile);
icloser(IlbmFile);
return bIlbm;
}
//! Reads a Pix file
ILboolean ilLoadPix(ILconst_string FileName)
{
ILHANDLE PixFile;
ILboolean bPix = IL_FALSE;
PixFile = iopenr(FileName);
if (PixFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bPix;
}
bPix = ilLoadPixF(PixFile);
icloser(PixFile);
return bPix;
}
//! Reads a Gif file
ILboolean ilLoadGif(const ILstring FileName)
{
ILHANDLE GifFile;
ILboolean bGif = IL_FALSE;
GifFile = iopenr(FileName);
if (GifFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bGif;
}
bGif = ilLoadGifF(GifFile);
icloser(GifFile);
return bGif;
}
//! Reads a .pcd file
ILboolean ilLoad_PCD(ILconst_string FileName)
{
ILHANDLE PcdFile;
ILboolean bPcd = IL_FALSE;
PcdFile = iopenr(FileName);
if (PcdFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bPcd;
}
bPcd = ilLoadF_PCD(PcdFile);
icloser(PcdFile);
return bPcd;
}
// Reads a file
ILboolean ilLoadMng(ILconst_string FileName)
{
ILHANDLE MngFile;
ILboolean bMng = IL_FALSE;
MngFile = iopenr(FileName);
if (MngFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bMng;
}
bMng = ilLoadMngF(MngFile);
icloser(MngFile);
return bMng;
}
//! Reads a DICOM file
ILboolean ilLoadDicom(ILconst_string FileName)
{
ILHANDLE DicomFile;
ILboolean bDicom = IL_FALSE;
DicomFile = iopenr(FileName);
if (DicomFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bDicom;
}
bDicom = ilLoadDicomF(DicomFile);
icloser(DicomFile);
return bDicom;
}
ILboolean ilLoadDcx(const ILstring FileName)
{
ILHANDLE DcxFile;
ILboolean bDcx = IL_FALSE;
DcxFile = iopenr(FileName);
if (DcxFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bDcx;
}
bDcx = ilLoadDcxF(DcxFile);
icloser(DcxFile);
return bDcx;
}
//! Reads a PSP file
ILboolean ilLoadPsp(ILconst_string FileName)
{
ILHANDLE PSPFile;
ILboolean bPsp = IL_FALSE;
PSPFile = iopenr(FileName);
if (PSPFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bPsp;
}
bPsp = ilLoadPspF(PSPFile);
icloser(PSPFile);
return bPsp;
}
// Reads a file
ILboolean ilLoadPnm(const ILstring FileName)
{
ILHANDLE PnmFile;
ILboolean bPnm = IL_FALSE;
PnmFile = iopenr(FileName);
if (PnmFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bPnm;
}
bPnm = ilLoadPnmF(PnmFile);
icloser(PnmFile);
return bPnm;
}
// Reads an .xpm file
ILboolean ilLoadXpm(ILconst_string FileName)
{
ILHANDLE XpmFile;
ILboolean bXpm = IL_FALSE;
XpmFile = iopenr(FileName);
if (XpmFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bXpm;
}
iSetInputFile(XpmFile);
bXpm = ilLoadXpmF(XpmFile);
icloser(XpmFile);
return bXpm;
}
ILboolean ilIsValidJpg(const ILstring FileName)
{
ILHANDLE JpegFile;
ILboolean bJpeg = IL_FALSE;
if (!iCheckExtension(FileName, "jpg") &&
!iCheckExtension(FileName, "jpe") &&
!iCheckExtension(FileName, "jpeg")) {
ilSetError(IL_INVALID_EXTENSION);
return bJpeg;
}
JpegFile = iopenr(FileName);
if (JpegFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bJpeg;
}
bJpeg = ilIsValidJpgF(JpegFile);
icloser(JpegFile);
return bJpeg;
}
// Reads a Sun file
ILboolean ilLoad_SUN(ILconst_string FileName)
{
ILHANDLE SunFile;
ILboolean bSun = IL_FALSE;
SunFile = iopenr(FileName);
if (SunFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bSun;
}
iSetInputFile(SunFile);
bSun = ilLoadF_SUN(SunFile);
icloser(SunFile);
return bSun;
}
//! Loads an .act palette file.
ILboolean ilLoadActPal(ILconst_string FileName)
{
ILHANDLE ActFile;
if (!iCheckExtension(FileName, IL_TEXT("act"))) {
ilSetError(IL_INVALID_EXTENSION);
return IL_FALSE;
}
if (iCurImage == NULL) {
ilSetError(IL_ILLEGAL_OPERATION);
return IL_FALSE;
}
ActFile = iopenr(FileName);
if (ActFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return IL_FALSE;
}
if (iCurImage->Pal.Palette && iCurImage->Pal.PalSize > 0 && iCurImage->Pal.PalType != IL_PAL_NONE) {
ifree(iCurImage->Pal.Palette);
iCurImage->Pal.Palette = NULL;
}
iCurImage->Pal.PalType = IL_PAL_RGB24;
iCurImage->Pal.PalSize = 768;
iCurImage->Pal.Palette = (ILubyte*)ialloc(768);
if (!iCurImage->Pal.Palette) {
icloser(ActFile);
return IL_FALSE;
}
if (iread(iCurImage->Pal.Palette, 1, 768) != 768) {
icloser(ActFile);
return IL_FALSE;
}
icloser(ActFile);
return IL_TRUE;
}
//! Save the current image to FileName as raw data
ILboolean ILAPIENTRY ilSaveData(ILconst_string FileName)
{
ILHANDLE DataFile;
if (iCurImage == NULL) {
ilSetError(IL_ILLEGAL_OPERATION);
return IL_FALSE;
}
DataFile = iopenr(FileName);
if (DataFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return IL_FALSE;
}
iwrite(iCurImage->Data, 1, iCurImage->SizeOfData);
icloser(DataFile);
return IL_TRUE;
}
//! Checks if the file specified in FileName is a valid .pcx file.
ILboolean ilIsValidPcx(const ILstring FileName)
{
ILHANDLE PcxFile;
ILboolean bPcx = IL_FALSE;
if (!iCheckExtension(FileName, IL_TEXT("pcx"))) {
ilSetError(IL_INVALID_EXTENSION);
return bPcx;
}
PcxFile = iopenr(FileName);
if (PcxFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bPcx;
}
bPcx = ilIsValidPcxF(PcxFile);
icloser(PcxFile);
return bPcx;
}
