//! Writes a Jpeg file
ILboolean ilSave_JPEG(const ILstring FileName)
{
ILHANDLE JpegFile;
ILuint JpegSize;
if (ilGetBoolean(IL_FILE_MODE) == IL_FALSE) {
if (iFileExists(FileName)) {
ilSetError(IL_FILE_ALREADY_EXISTS);
return IL_FALSE;
}
}
JpegFile = iopenw(FileName);
if (JpegFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return IL_FALSE;
}
JpegSize = ilSaveF_JPEG(JpegFile);
iclosew(JpegFile);
if (JpegSize == 0)
return IL_FALSE;
return IL_TRUE;
}
//! Writes a Pnm file
ILboolean ilSavePnm(const ILstring FileName)
{
ILHANDLE PnmFile;
ILboolean bPnm = IL_FALSE;
FName = (ILstring)FileName;
if (ilGetBoolean(IL_FILE_MODE) == IL_FALSE) {
if (iFileExists(FileName)) {
ilSetError(IL_FILE_ALREADY_EXISTS);
return IL_FALSE;
}
}
PnmFile = iopenw(FileName);
if (PnmFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bPnm;
}
bPnm = ilSavePnmF(PnmFile);
iclosew(PnmFile);
return bPnm;
}
//! Reads a jpeg file
ILboolean ilLoad_JPEG(ILconst_string FileName)
{
if (!iFileExists(FileName)) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return IL_FALSE;
}
return iLoadJpegInternal(FileName, NULL, 0);
}
//! Writes a Jpeg file
ILboolean ilSave_JPEG(ILconst_string FileName)
{
if (ilGetBoolean(IL_FILE_MODE) == IL_FALSE) {
if (iFileExists(FileName)) {
ilSetError(IL_FILE_ALREADY_EXISTS);
return IL_FALSE;
}
}
return iSaveJpegInternal(FileName, NULL, 0);
}
ILboolean ilSaveJpeg(ILconst_string FileName)
{
ILHANDLE JpegFile;
ILboolean bJpeg = IL_FALSE;
if (ilGetBoolean(IL_FILE_MODE) == IL_FALSE) {
if (iFileExists(FileName)) {
ilSetError(IL_FILE_ALREADY_EXISTS);
return IL_FALSE;
}
}
JpegFile = iopenw(FileName);
if (JpegFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bJpeg;
}
bJpeg = ilSaveJpegF(JpegFile);
iclosew(JpegFile);
return bJpeg;
}
//! Writes a Hdr file
ILboolean ilSaveHdr(ILconst_string FileName)
{
ILHANDLE HdrFile;
ILboolean bHdr = IL_FALSE;
if (ilGetBoolean(IL_FILE_MODE) == IL_FALSE) {
if (iFileExists(FileName)) {
ilSetError(IL_FILE_ALREADY_EXISTS);
return IL_FALSE;
}
}
HdrFile = iopenw(FileName);
if (HdrFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bHdr;
}
bHdr = ilSaveHdrF(HdrFile);
iclosew(HdrFile);
return bHdr;
}
ILboolean ilSaveRaw(const ILstring FileName)
{
ILHANDLE RawFile;
ILboolean bRaw = IL_FALSE;
if (ilGetBoolean(IL_FILE_MODE) == IL_FALSE) {
if (iFileExists(FileName)) {
ilSetError(IL_FILE_ALREADY_EXISTS);
return IL_FALSE;
}
}
RawFile = iopenw(FileName);
if (RawFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bRaw;
}
bRaw = ilSaveRawF(RawFile);
iclosew(RawFile);
return bRaw;
}
//! Writes a Tiff file
ILboolean ilSaveTiff(const ILstring FileName)
{
ILHANDLE TiffFile;
ILboolean bTiff = IL_FALSE;
if (ilGetBoolean(IL_FILE_MODE) == IL_FALSE) {
if (iFileExists(FileName)) {
ilSetError(IL_FILE_ALREADY_EXISTS);
return IL_FALSE;
}
}
TiffFile = iopenw(FileName);
if (TiffFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bTiff;
}
//bTiff = ilSaveTiffF(TiffFile);
bTiff = iSaveTiffInternal(FileName);
iclosew(TiffFile);
return bTiff;
}
//! Generates a C-style header file for the current image.
ILboolean ilSaveCHeader(ILconst_string FileName, char *InternalName)
{
FILE *HeadFile;
ILuint i = 0, j;
ILimage *TempImage;
const char *Name;
if (iCurImage == NULL) {
ilSetError(IL_ILLEGAL_OPERATION);
return IL_FALSE;
}
Name = iGetString(IL_CHEAD_HEADER_STRING);
if (Name == NULL)
Name = InternalName;
if (FileName == NULL || Name == NULL ||
ilStrLen(FileName) < 1 || ilCharStrLen(Name) < 1) {
ilSetError(IL_INVALID_VALUE);
return IL_FALSE;
}
if (!iCheckExtension(FileName, IL_TEXT("h"))) {
ilSetError(IL_INVALID_EXTENSION);
return IL_FALSE;
}
if (ilGetBoolean(IL_FILE_MODE) == IL_FALSE) {
if (iFileExists(FileName)) {
ilSetError(IL_FILE_ALREADY_EXISTS);
return IL_FALSE;
}
}
if (iCurImage->Bpc > 1) {
TempImage = iConvertImage(iCurImage, iCurImage->Format, IL_UNSIGNED_BYTE);
if (TempImage == NULL)
return IL_FALSE;
} else {
TempImage = iCurImage;
}
#ifndef _UNICODE
HeadFile = fopen(FileName, "wb");
#else
HeadFile = _wfopen(FileName, L"rb");
#endif//_UNICODE
if (HeadFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return IL_FALSE;
}
fprintf(HeadFile, "//#include <il/il.h>\n");
fprintf(HeadFile, "// C Image Header:\n\n\n");
fprintf(HeadFile, "// IMAGE_BPP is in bytes per pixel, *not* bits\n");
fprintf(HeadFile, "#define IMAGE_BPP %d\n",iCurImage->Bpp);
fprintf(HeadFile, "#define IMAGE_WIDTH %d\n", iCurImage->Width);
fprintf(HeadFile, "#define IMAGE_HEIGHT %d\n", iCurImage->Height);
fprintf(HeadFile, "#define IMAGE_DEPTH %d\n\n\n", iCurImage->Depth);
fprintf(HeadFile, "#define IMAGE_TYPE 0x%X\n", iCurImage->Type);
fprintf(HeadFile, "#define IMAGE_FORMAT 0x%X\n\n\n", iCurImage->Format);
fprintf(HeadFile, "ILubyte %s[] = {\n", Name);
for (; i < TempImage->SizeOfData; i += MAX_LINE_WIDTH) {
fprintf(HeadFile, "\t");
for (j = 0; j < MAX_LINE_WIDTH; j++) {
if (i + j >= TempImage->SizeOfData - 1) {
fprintf(HeadFile, "%4d", TempImage->Data[i+j]);
break;
}
else
fprintf(HeadFile, "%4d,", TempImage->Data[i+j]);
}
fprintf(HeadFile, "\n");
}
if (TempImage != iCurImage)
ilCloseImage(TempImage);
fprintf(HeadFile, "};\n");
if (iCurImage->Pal.Palette && iCurImage->Pal.PalSize && iCurImage->Pal.PalType != IL_PAL_NONE) {
fprintf(HeadFile, "\n\n");
fprintf(HeadFile, "#define IMAGE_PALSIZE %u\n\n", iCurImage->Pal.PalSize);
fprintf(HeadFile, "#define IMAGE_PALTYPE 0x%X\n\n", iCurImage->Pal.PalType);
fprintf(HeadFile, "ILubyte %sPal[] = {\n", Name);
for (i = 0; i < iCurImage->Pal.PalSize; i += MAX_LINE_WIDTH) {
fprintf(HeadFile, "\t");
for (j = 0; j < MAX_LINE_WIDTH; j++) {
if (i + j >= iCurImage->Pal.PalSize - 1) {
fprintf(HeadFile, " %4d", iCurImage->Pal.Palette[i+j]);
break;
}
else
fprintf(HeadFile, " %4d,", iCurImage->Pal.Palette[i+j]);
}
fprintf(HeadFile, "\n");
}
fprintf(HeadFile, "};\n");
}
fclose(HeadFile);
return IL_TRUE;
}
ILboolean ILAPIENTRY ilSavePal(ILconst_string FileName)
{
ILstring Ext = iGetExtension(FileName);
if (iCurImage == NULL) {
ilSetError(IL_ILLEGAL_OPERATION);
return IL_FALSE;
}
#ifndef _UNICODE
if (FileName == NULL || strlen(FileName) < 1 || Ext == NULL) {
#else
if (FileName == NULL || wcslen(FileName) < 1 || Ext == NULL) {
#endif//_UNICODE
ilSetError(IL_INVALID_PARAM);
return IL_FALSE;
}
if (!iCurImage->Pal.Palette || !iCurImage->Pal.PalSize || iCurImage->Pal.PalType == IL_PAL_NONE) {
ilSetError(IL_ILLEGAL_OPERATION);
return IL_FALSE;
}
if (!iStrCmp(Ext, IL_TEXT("pal"))) {
return ilSaveJascPal(FileName);
}
ilSetError(IL_INVALID_EXTENSION);
return IL_FALSE;
}
//! Saves a Paint Shop Pro formatted palette (.pal) file.
ILboolean ilSaveJascPal(ILconst_string FileName)
{
FILE *PalFile;
ILuint i, PalBpp, NumCols = ilGetInteger(IL_PALETTE_NUM_COLS);
ILubyte *CurPal;
if (iCurImage == NULL || NumCols == 0 || NumCols > 256) {
ilSetError(IL_ILLEGAL_OPERATION);
return IL_FALSE;
}
#ifndef _UNICODE
if (FileName == NULL || strlen(FileName) < 5) {
#else
if (FileName == NULL || wcslen(FileName) < 5) {
#endif//_UNICODE
ilSetError(IL_INVALID_VALUE);
return IL_FALSE;
}
if (!iCheckExtension(FileName, IL_TEXT("pal"))) {
ilSetError(IL_INVALID_EXTENSION);
return IL_FALSE;
}
if (ilGetBoolean(IL_FILE_MODE) == IL_FALSE) {
if (iFileExists(FileName)) {
ilSetError(IL_FILE_ALREADY_EXISTS);
return IL_FALSE;
}
}
// Create a copy of the current palette and convert it to RGB24 format.
CurPal = iCurImage->Pal.Palette;
iCurImage->Pal.Palette = (ILubyte*)ialloc(iCurImage->Pal.PalSize);
if (!iCurImage->Pal.Palette) {
iCurImage->Pal.Palette = CurPal;
return IL_FALSE;
}
memcpy(iCurImage->Pal.Palette, CurPal, iCurImage->Pal.PalSize);
if (!ilConvertPal(IL_PAL_RGB24)) {
ifree(iCurImage->Pal.Palette);
iCurImage->Pal.Palette = CurPal;
return IL_FALSE;
}
#ifndef _UNICODE
PalFile = fopen(FileName, "wt");
#else
PalFile = _wfopen(FileName, L"wt");
#endif//_UNICODE
if (!PalFile) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return IL_FALSE;
}
// Header needed on all .pal files
fputs("JASC-PAL\n0100\n256\n", PalFile);
PalBpp = ilGetBppPal(iCurImage->Pal.PalType);
for (i = 0; i < iCurImage->Pal.PalSize; i += PalBpp) {
fprintf(PalFile, "%d %d %d\n",
iCurImage->Pal.Palette[i], iCurImage->Pal.Palette[i+1], iCurImage->Pal.Palette[i+2]);
}
NumCols = 256 - NumCols;
for (i = 0; i < NumCols; i++) {
fprintf(PalFile, "0 0 0\n");
}
ifree(iCurImage->Pal.Palette);
iCurImage->Pal.Palette = CurPal;
fclose(PalFile);
return IL_TRUE;
}
//! Loads a Halo formatted palette (.pal) file.
ILboolean ilLoadHaloPal(ILconst_string FileName)
{
ILHANDLE HaloFile;
HALOHEAD HaloHead;
ILushort *TempPal;
ILuint i, Size;
if (!iCheckExtension(FileName, IL_TEXT("pal"))) {
ilSetError(IL_INVALID_EXTENSION);
return IL_FALSE;
}
if (iCurImage == NULL) {
ilSetError(IL_ILLEGAL_OPERATION);
return IL_FALSE;
}
HaloFile = iopenr(FileName);
if (HaloFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return IL_FALSE;
}
if (iread(&HaloHead, sizeof(HALOHEAD), 1) != 1)
return IL_FALSE;
if (HaloHead.Id != 'A' + ('H' << 8) || HaloHead.Version != 0xe3) {
icloser(HaloFile);
ilSetError(IL_ILLEGAL_FILE_VALUE);
return IL_FALSE;
}
Size = (HaloHead.MaxIndex + 1) * 3;
TempPal = (ILushort*)ialloc(Size * sizeof(ILushort));
if (TempPal == NULL) {
icloser(HaloFile);
return IL_FALSE;
}
if (iread(TempPal, sizeof(ILushort), Size) != Size) {
icloser(HaloFile);
ifree(TempPal);
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 = Size;
iCurImage->Pal.Palette = (ILubyte*)ialloc(iCurImage->Pal.PalSize);
if (iCurImage->Pal.Palette == NULL) {
icloser(HaloFile);
return IL_FALSE;
}
for (i = 0; i < iCurImage->Pal.PalSize; i++, TempPal++) {
iCurImage->Pal.Palette[i] = (ILubyte)*TempPal;
}
TempPal -= iCurImage->Pal.PalSize;
ifree(TempPal);
icloser(HaloFile);
return IL_TRUE;
}
void sgiSwitchData(ILubyte *Data, ILuint SizeOfData)
{
ILubyte Temp;
ILuint i;
#ifdef ALTIVEC_GCC
i = 0;
union {
vector unsigned char vec;
vector unsigned int load;
}inversion_vector;
inversion_vector.load = (vector unsigned int)\
{0x01000302,0x05040706,0x09080B0A,0x0D0C0F0E};
while( i <= SizeOfData-16 ) {
vector unsigned char data = vec_ld(i,Data);
vec_perm(data,data,inversion_vector.vec);
vec_st(data,i,Data);
i+=16;
}
SizeOfData -= i;
#endif
for (i = 0; i < SizeOfData; i += 2) {
Temp = Data[i];
Data[i] = Data[i+1];
Data[i+1] = Temp;
}
return;
}
/*----------------------------------------------------------------------------*/
// Just an internal convenience function for reading SGI files
ILboolean iNewSgi(iSgiHeader *Head)
{
if (!ilTexImage(Head->XSize, Head->YSize, Head->Bpc, (ILubyte)Head->ZSize, 0, IL_UNSIGNED_BYTE, NULL)) {
return IL_FALSE;
}
iCurImage->Origin = IL_ORIGIN_LOWER_LEFT;
switch (Head->ZSize)
{
case 1:
iCurImage->Format = IL_LUMINANCE;
break;
case 2:
iCurImage->Format = IL_LUMINANCE_ALPHA;
break;
case 3:
iCurImage->Format = IL_RGB;
break;
case 4:
iCurImage->Format = IL_RGBA;
break;
default:
ilSetError(IL_ILLEGAL_FILE_VALUE);
return IL_FALSE;
}
switch (Head->Bpc)
{
case 1:
if (Head->PixMin < 0)
iCurImage->Type = IL_BYTE;
else
iCurImage->Type = IL_UNSIGNED_BYTE;
break;
case 2:
if (Head->PixMin < 0)
iCurImage->Type = IL_SHORT;
else
iCurImage->Type = IL_UNSIGNED_SHORT;
break;
default:
ilSetError(IL_ILLEGAL_FILE_VALUE);
return IL_FALSE;
}
iCurImage->Origin = IL_ORIGIN_LOWER_LEFT;
return IL_TRUE;
}
/*----------------------------------------------------------------------------*/
//! Writes a SGI file
ILboolean ilSaveSgi(ILconst_string FileName)
{
ILHANDLE SgiFile;
ILboolean bSgi = IL_FALSE;
if (ilGetBoolean(IL_FILE_MODE) == IL_FALSE) {
if (iFileExists(FileName)) {
ilSetError(IL_FILE_ALREADY_EXISTS);
return IL_FALSE;
}
}
SgiFile = iopenw(FileName);
if (SgiFile == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return bSgi;
}
bSgi = ilSaveSgiF(SgiFile);
iclosew(SgiFile);
return bSgi;
}
