void ILAPIENTRY il2RegisterPal(ILimage* image, void *Pal, ILuint Size, ILenum Type)
{
auto bpp = ilGetBppPal(Type);
auto numCols = 0;
if (bpp > 0)
auto numCols = Size / bpp;
image->Pal.use(numCols, (ILubyte*) Pal, Type);
}
//@TODO rename to ilGetImageIntegerv for 1.6.9 and make it public
//! Sets Param equal to the current value of the Mode
void ILAPIENTRY iGetIntegervImage(ILimage *Image, ILenum Mode, ILint *Param)
{
ILimage *SubImage;
if (Image == NULL) {
ilSetError(IL_ILLEGAL_OPERATION);
return;
}
if (Param == NULL) {
ilSetError(IL_INVALID_PARAM);
return;
}
*Param = 0;
switch (Mode)
{
case IL_DXTC_DATA_FORMAT:
if (Image->DxtcData == NULL || Image->DxtcSize == 0) {
*Param = IL_DXT_NO_COMP;
break;
}
*Param = Image->DxtcFormat;
break;
////
case IL_IMAGE_BITS_PER_PIXEL:
//changed 20040610 to channel count (Bpp) times Bytes per channel
*Param = (Image->Bpp << 3)*Image->Bpc;
break;
case IL_IMAGE_BYTES_PER_PIXEL:
//changed 20040610 to channel count (Bpp) times Bytes per channel
*Param = Image->Bpp*Image->Bpc;
break;
case IL_IMAGE_BPC:
*Param = Image->Bpc;
break;
case IL_IMAGE_CHANNELS:
*Param = Image->Bpp;
break;
case IL_IMAGE_CUBEFLAGS:
*Param = Image->CubeFlags;
break;
case IL_IMAGE_DEPTH:
*Param = Image->Depth;
break;
case IL_IMAGE_DURATION:
*Param = Image->Duration;
break;
case IL_IMAGE_FORMAT:
*Param = Image->Format;
break;
case IL_IMAGE_HEIGHT:
*Param = Image->Height;
break;
case IL_IMAGE_SIZE_OF_DATA:
*Param = Image->SizeOfData;
break;
case IL_IMAGE_OFFX:
*Param = Image->OffX;
break;
case IL_IMAGE_OFFY:
*Param = Image->OffY;
break;
case IL_IMAGE_ORIGIN:
*Param = Image->Origin;
break;
case IL_IMAGE_PLANESIZE:
*Param = Image->SizeOfPlane;
break;
case IL_IMAGE_TYPE:
*Param = Image->Type;
break;
case IL_IMAGE_WIDTH:
*Param = Image->Width;
break;
case IL_NUM_FACES:
for (SubImage = Image->Faces; SubImage; SubImage = SubImage->Faces)
(*Param)++;
break;
case IL_NUM_IMAGES:
for (SubImage = Image->Next; SubImage; SubImage = SubImage->Next)
(*Param)++;
break;
case IL_NUM_LAYERS:
for (SubImage = Image->Layers; SubImage; SubImage = SubImage->Layers)
(*Param)++;
break;
case IL_NUM_MIPMAPS:
for (SubImage = Image->Mipmaps; SubImage; SubImage = SubImage->Mipmaps)
(*Param)++;
break;
case IL_PALETTE_TYPE:
*Param = Image->Pal.PalType;
break;
case IL_PALETTE_BPP:
*Param = ilGetBppPal(Image->Pal.PalType);
break;
case IL_PALETTE_NUM_COLS:
if (!Image->Pal.Palette || !Image->Pal.PalSize || Image->Pal.PalType == IL_PAL_NONE)
*Param = 0;
else
*Param = Image->Pal.PalSize / ilGetBppPal(Image->Pal.PalType);
break;
case IL_PALETTE_BASE_TYPE:
switch (Image->Pal.PalType)
{
case IL_PAL_RGB24:
*Param = IL_RGB;
case IL_PAL_RGB32:
*Param = IL_RGBA; // Not sure
case IL_PAL_RGBA32:
*Param = IL_RGBA;
case IL_PAL_BGR24:
*Param = IL_BGR;
case IL_PAL_BGR32:
*Param = IL_BGRA; // Not sure
case IL_PAL_BGRA32:
*Param = IL_BGRA;
}
break;
default:
ilSetError(IL_INVALID_ENUM);
}
}
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;
}
// Converts the palette to the DestFormat format.
ILAPI ILpal* ILAPIENTRY iConvertPal(ILpal *Pal, ILenum DestFormat)
{
ILpal *NewPal = NULL;
ILuint i, j, NewPalSize;
// Checks to see if the current image is valid and has a palette
if (Pal == NULL || Pal->PalSize == 0 || Pal->Palette == NULL || Pal->PalType == IL_PAL_NONE) {
ilSetError(IL_ILLEGAL_OPERATION);
return NULL;
}
/*if (Pal->PalType == DestFormat) {
return NULL;
}*/
NewPal = (ILpal*)ialloc(sizeof(ILpal));
if (NewPal == NULL) {
return NULL;
}
NewPal->PalSize = Pal->PalSize;
NewPal->PalType = Pal->PalType;
switch (DestFormat)
{
case IL_PAL_RGB24:
case IL_PAL_BGR24:
switch (Pal->PalType)
{
case IL_PAL_RGB24:
NewPal->Palette = (ILubyte*)ialloc(Pal->PalSize);
if (NewPal->Palette == NULL)
goto alloc_error;
if (DestFormat == IL_PAL_BGR24) {
j = ilGetBppPal(Pal->PalType);
for (i = 0; i < Pal->PalSize; i += j) {
NewPal->Palette[i] = Pal->Palette[i+2];
NewPal->Palette[i+1] = Pal->Palette[i+1];
NewPal->Palette[i+2] = Pal->Palette[i];
}
}
else {
memcpy(NewPal->Palette, Pal->Palette, Pal->PalSize);
}
NewPal->PalType = DestFormat;
break;
case IL_PAL_BGR24:
NewPal->Palette = (ILubyte*)ialloc(Pal->PalSize);
if (NewPal->Palette == NULL)
goto alloc_error;
if (DestFormat == IL_PAL_RGB24) {
j = ilGetBppPal(Pal->PalType);
for (i = 0; i < Pal->PalSize; i += j) {
NewPal->Palette[i] = Pal->Palette[i+2];
NewPal->Palette[i+1] = Pal->Palette[i+1];
NewPal->Palette[i+2] = Pal->Palette[i];
}
}
else {
memcpy(NewPal->Palette, Pal->Palette, Pal->PalSize);
}
NewPal->PalType = DestFormat;
break;
case IL_PAL_BGR32:
case IL_PAL_BGRA32:
NewPalSize = (ILuint)((ILfloat)Pal->PalSize * 3.0f / 4.0f);
NewPal->Palette = (ILubyte*)ialloc(NewPalSize);
if (NewPal->Palette == NULL)
goto alloc_error;
if (DestFormat == IL_PAL_RGB24) {
for (i = 0, j = 0; i < Pal->PalSize; i += 4, j += 3) {
NewPal->Palette[j] = Pal->Palette[i+2];
NewPal->Palette[j+1] = Pal->Palette[i+1];
NewPal->Palette[j+2] = Pal->Palette[i];
}
}
else {
for (i = 0, j = 0; i < Pal->PalSize; i += 4, j += 3) {
NewPal->Palette[j] = Pal->Palette[i];
NewPal->Palette[j+1] = Pal->Palette[i+1];
NewPal->Palette[j+2] = Pal->Palette[i+2];
}
}
NewPal->PalSize = NewPalSize;
NewPal->PalType = DestFormat;
break;
case IL_PAL_RGB32:
case IL_PAL_RGBA32:
NewPalSize = (ILuint)((ILfloat)Pal->PalSize * 3.0f / 4.0f);
NewPal->Palette = (ILubyte*)ialloc(NewPalSize);
if (NewPal->Palette == NULL)
goto alloc_error;
if (DestFormat == IL_PAL_RGB24) {
for (i = 0, j = 0; i < Pal->PalSize; i += 4, j += 3) {
NewPal->Palette[j] = Pal->Palette[i];
NewPal->Palette[j+1] = Pal->Palette[i+1];
NewPal->Palette[j+2] = Pal->Palette[i+2];
}
}
else {
for (i = 0, j = 0; i < Pal->PalSize; i += 4, j += 3) {
NewPal->Palette[j] = Pal->Palette[i+2];
NewPal->Palette[j+1] = Pal->Palette[i+1];
NewPal->Palette[j+2] = Pal->Palette[i];
}
}
NewPal->PalSize = NewPalSize;
NewPal->PalType = DestFormat;
break;
default:
ilSetError(IL_INVALID_PARAM);
return NULL;
}
break;
case IL_PAL_RGB32:
case IL_PAL_RGBA32:
case IL_PAL_BGR32:
case IL_PAL_BGRA32:
switch (Pal->PalType)
{
case IL_PAL_RGB24:
case IL_PAL_BGR24:
NewPalSize = Pal->PalSize * 4 / 3;
NewPal->Palette = (ILubyte*)ialloc(NewPalSize);
if (NewPal->Palette == NULL)
goto alloc_error;
if ((Pal->PalType == IL_PAL_BGR24 && (DestFormat == IL_PAL_RGB32 || DestFormat == IL_PAL_RGBA32)) ||
(Pal->PalType == IL_PAL_RGB24 && (DestFormat == IL_PAL_BGR32 || DestFormat == IL_PAL_BGRA32))) {
for (i = 0, j = 0; i < Pal->PalSize; i += 3, j += 4) {
NewPal->Palette[j] = Pal->Palette[i+2];
NewPal->Palette[j+1] = Pal->Palette[i+1];
NewPal->Palette[j+2] = Pal->Palette[i];
NewPal->Palette[j+3] = 255;
}
}
else {
for (i = 0, j = 0; i < Pal->PalSize; i += 3, j += 4) {
NewPal->Palette[j] = Pal->Palette[i];
NewPal->Palette[j+1] = Pal->Palette[i+1];
NewPal->Palette[j+2] = Pal->Palette[i+2];
NewPal->Palette[j+3] = 255;
}
}
NewPal->PalSize = NewPalSize;
NewPal->PalType = DestFormat;
break;
case IL_PAL_RGB32:
NewPal->Palette = (ILubyte*)ialloc(Pal->PalSize);
if (NewPal->Palette == NULL)
goto alloc_error;
if (DestFormat == IL_PAL_BGR32 || DestFormat == IL_PAL_BGRA32) {
for (i = 0; i < Pal->PalSize; i += 4) {
NewPal->Palette[i] = Pal->Palette[i+2];
NewPal->Palette[i+1] = Pal->Palette[i+1];
NewPal->Palette[i+2] = Pal->Palette[i];
NewPal->Palette[i+3] = 255;
}
}
else {
for (i = 0; i < Pal->PalSize; i += 4) {
NewPal->Palette[i] = Pal->Palette[i];
NewPal->Palette[i+1] = Pal->Palette[i+1];
NewPal->Palette[i+2] = Pal->Palette[i+2];
NewPal->Palette[i+3] = 255;
}
}
NewPal->PalType = DestFormat;
break;
case IL_PAL_RGBA32:
NewPal->Palette = (ILubyte*)ialloc(Pal->PalSize);
if (NewPal->Palette == NULL)
goto alloc_error;
if (DestFormat == IL_PAL_BGR32 || DestFormat == IL_PAL_BGRA32) {
for (i = 0; i < Pal->PalSize; i += 4) {
NewPal->Palette[i] = Pal->Palette[i+2];
NewPal->Palette[i+1] = Pal->Palette[i+1];
NewPal->Palette[i+2] = Pal->Palette[i];
NewPal->Palette[i+3] = Pal->Palette[i+3];
}
}
else {
memcpy(NewPal->Palette, Pal->Palette, Pal->PalSize);
}
NewPal->PalType = DestFormat;
break;
case IL_PAL_BGR32:
NewPal->Palette = (ILubyte*)ialloc(Pal->PalSize);
if (NewPal->Palette == NULL)
goto alloc_error;
if (DestFormat == IL_PAL_RGB32 || DestFormat == IL_PAL_RGBA32) {
for (i = 0; i < Pal->PalSize; i += 4) {
NewPal->Palette[i] = Pal->Palette[i+2];
NewPal->Palette[i+1] = Pal->Palette[i+1];
NewPal->Palette[i+2] = Pal->Palette[i];
NewPal->Palette[i+3] = 255;
}
}
else {
for (i = 0; i < Pal->PalSize; i += 4) {
NewPal->Palette[i] = Pal->Palette[i];
NewPal->Palette[i+1] = Pal->Palette[i+1];
NewPal->Palette[i+2] = Pal->Palette[i+2];
NewPal->Palette[i+3] = 255;
}
}
NewPal->PalType = DestFormat;
break;
case IL_PAL_BGRA32:
NewPal->Palette = (ILubyte*)ialloc(Pal->PalSize);
if (NewPal->Palette == NULL)
goto alloc_error;
if (DestFormat == IL_PAL_RGB32 || DestFormat == IL_PAL_RGBA32) {
for (i = 0; i < Pal->PalSize; i += 4) {
NewPal->Palette[i] = Pal->Palette[i+2];
NewPal->Palette[i+1] = Pal->Palette[i+1];
NewPal->Palette[i+2] = Pal->Palette[i];
NewPal->Palette[i+3] = Pal->Palette[i+3];
}
}
else {
memcpy(NewPal->Palette, Pal->Palette, Pal->PalSize);
}
NewPal->PalType = DestFormat;
break;
default:
ilSetError(IL_INVALID_PARAM);
return NULL;
}
break;
default:
ilSetError(IL_INVALID_PARAM);
return NULL;
}
NewPal->PalType = DestFormat;
return NewPal;
alloc_error:
ifree(NewPal);
return NULL;
}
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;
}
// 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;
}
// Internal function used to save the Tiff.
ILboolean iSaveTiffInternal(char *Filename)
{
ILenum Format;
ILenum Compression;
ILuint ixLine;
TIFF *File;
char Description[512];
ILimage *TempImage;
if(iCurImage == NULL) {
ilSetError(IL_ILLEGAL_OPERATION);
return IL_FALSE;
}
if (iGetHint(IL_COMPRESSION_HINT) == IL_USE_COMPRESSION)
Compression = COMPRESSION_PACKBITS;
else
Compression = COMPRESSION_NONE;
if (iCurImage->Format == IL_COLOUR_INDEX) {
if (ilGetBppPal(iCurImage->Pal.PalType) == 4) // Preserve the alpha.
TempImage = iConvertImage(iCurImage, IL_RGBA, IL_UNSIGNED_BYTE);
else
TempImage = iConvertImage(iCurImage, IL_RGB, IL_UNSIGNED_BYTE);
if (TempImage == NULL) {
return IL_FALSE;
}
}
else {
TempImage = iCurImage;
}
File = TIFFOpen(Filename, "w");
//File = iTIFFOpen("w");
if (File == NULL) {
ilSetError(IL_COULD_NOT_OPEN_FILE);
return IL_FALSE;
}
sprintf(Description, "Tiff generated by %s", ilGetString(IL_VERSION_NUM));
TIFFSetField(File, TIFFTAG_IMAGEWIDTH, TempImage->Width);
TIFFSetField(File, TIFFTAG_IMAGELENGTH, TempImage->Height);
TIFFSetField(File, TIFFTAG_COMPRESSION, Compression);
TIFFSetField(File, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
TIFFSetField(File, TIFFTAG_BITSPERSAMPLE, TempImage->Bpc << 3);
TIFFSetField(File, TIFFTAG_SAMPLESPERPIXEL, TempImage->Bpp);
TIFFSetField(File, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
TIFFSetField(File, TIFFTAG_ROWSPERSTRIP, 1);
TIFFSetField(File, TIFFTAG_SOFTWARE, ilGetString(IL_VERSION_NUM));
/*TIFFSetField(File, TIFFTAG_DOCUMENTNAME,
iGetString(IL_TIF_DOCUMENTNAME_STRING) ?
iGetString(IL_TIF_DOCUMENTNAME_STRING) : FileName);*/
if (iGetString(IL_TIF_DOCUMENTNAME_STRING))
TIFFSetField(File, TIFFTAG_DOCUMENTNAME, iGetString(IL_TIF_DOCUMENTNAME_STRING));
if (iGetString(IL_TIF_AUTHNAME_STRING))
TIFFSetField(File, TIFFTAG_ARTIST, iGetString(IL_TIF_AUTHNAME_STRING));
if (iGetString(IL_TIF_HOSTCOMPUTER_STRING))
TIFFSetField(File, TIFFTAG_HOSTCOMPUTER,
iGetString(IL_TIF_HOSTCOMPUTER_STRING));
if (iGetString(IL_TIF_DESCRIPTION_STRING))
TIFFSetField(File, TIFFTAG_IMAGEDESCRIPTION,
iGetString(IL_TIF_DESCRIPTION_STRING));
TIFFSetField(File, TIFFTAG_DATETIME, iMakeString());
// 24/4/2003
// Orientation flag is not always supported ( Photoshop, ...), orient the image data
// and set it always to normal view
TIFFSetField(File, TIFFTAG_ORIENTATION,ORIENTATION_TOPLEFT );
if( TempImage->Origin != IL_ORIGIN_UPPER_LEFT ) {
ILubyte *Data = iGetFlipped(TempImage);
ifree( (void*)TempImage->Data );
TempImage->Data = Data;
}
/*
TIFFSetField(File, TIFFTAG_ORIENTATION,
TempImage->Origin == IL_ORIGIN_UPPER_LEFT ? ORIENTATION_TOPLEFT : ORIENTATION_BOTLEFT);
*/
Format = TempImage->Format;
if (Format == IL_BGR || Format == IL_BGRA)
ilSwapColours();
for (ixLine = 0; ixLine < TempImage->Height; ++ixLine) {
if (TIFFWriteScanline(File, TempImage->Data + ixLine * TempImage->Bps, ixLine, 0) < 0) {
TIFFClose(File);
ilSetError(IL_LIB_TIFF_ERROR);
return IL_FALSE;
}
}
if (Format == IL_BGR || Format == IL_BGRA)
ilSwapColours();
if (TempImage != iCurImage)
ilCloseImage(TempImage);
TIFFClose(File);
return IL_TRUE;
}