// Should we add type to the parameter list?
// Copies a 1d block of pixels to the buffer pointed to by Data.
ILboolean ilCopyPixels1D(ILimage* image, ILuint XOff, ILuint Width, void *Data)
{
ILuint x, c, NewBps, NewOff, PixBpp;
ILubyte *Temp = (ILubyte*)Data, *TempData = image->Data;
if (ilIsEnabled(IL_ORIGIN_SET)) {
if ((ILenum)ilGetInteger(IL_ORIGIN_MODE) != image->Origin) {
TempData = iGetFlipped(image);
if (TempData == NULL)
return IL_FALSE;
}
}
PixBpp = image->Bpp * image->Bpc;
if (image->Width < XOff + Width) {
NewBps = (image->Width - XOff) * PixBpp;
}
else {
NewBps = Width * PixBpp;
}
NewOff = XOff * PixBpp;
for (x = 0; x < NewBps; x += PixBpp) {
for (c = 0; c < PixBpp; c++) {
Temp[x + c] = TempData[(x + NewOff) + c];
}
}
if (TempData != image->Data)
ifree(TempData);
return IL_TRUE;
}
ILboolean ilSetPixels2D(ILimage* image, ILint XOff, ILint YOff, ILuint Width, ILuint Height, void *Data)
{
ILuint c, SkipX = 0, SkipY = 0, NewBps, PixBpp;
ILint x, y, NewWidth, NewHeight;
ILubyte *Temp = (ILubyte*)Data, *TempData = image->Data;
if (ilIsEnabled(IL_ORIGIN_SET)) {
if ((ILenum)ilGetInteger(IL_ORIGIN_MODE) != image->Origin) {
TempData = iGetFlipped(image);
if (TempData == NULL)
return IL_FALSE;
}
}
PixBpp = image->Bpp * image->Bpc;
if (XOff < 0) {
SkipX = abs(XOff);
XOff = 0;
}
if (YOff < 0) {
SkipY = abs(YOff);
YOff = 0;
}
if (image->Width < XOff + Width)
NewWidth = image->Width - XOff;
else
NewWidth = Width;
NewBps = Width * PixBpp;
if (image->Height < YOff + Height)
NewHeight = image->Height - YOff;
else
NewHeight = Height;
NewWidth -= SkipX;
NewHeight -= SkipY;
for (y = 0; y < NewHeight; y++) {
for (x = 0; x < NewWidth; x++) {
for (c = 0; c < PixBpp; c++) {
TempData[(y + YOff) * image->Bps + (x + XOff) * PixBpp + c] =
Temp[(y + SkipY) * NewBps + (x + SkipX) * PixBpp + c];
}
}
}
if (TempData != image->Data) {
ifree(image->Data);
image->Data = TempData;
}
return IL_TRUE;
}
// Copies a 3d block of pixels to the buffer pointed to by Data.
ILboolean ilCopyPixels3D(ILimage* image, ILuint XOff, ILuint YOff, ILuint ZOff, ILuint Width, ILuint Height, ILuint Depth, void *Data)
{
ILuint x, y, z, c, NewBps, DataBps, NewSizePlane, NewH, NewD, NewXOff, PixBpp;
ILubyte *Temp = (ILubyte*)Data, *TempData = image->Data;
if (ilIsEnabled(IL_ORIGIN_SET)) {
if ((ILenum)ilGetInteger(IL_ORIGIN_MODE) != image->Origin) {
TempData = iGetFlipped(image);
if (TempData == NULL)
return IL_FALSE;
}
}
PixBpp = image->Bpp * image->Bpc;
if (image->Width < XOff + Width)
NewBps = (image->Width - XOff) * PixBpp;
else
NewBps = Width * PixBpp;
if (image->Height < YOff + Height)
NewH = image->Height - YOff;
else
NewH = Height;
if (image->Depth < ZOff + Depth)
NewD = image->Depth - ZOff;
else
NewD = Depth;
DataBps = Width * PixBpp;
NewSizePlane = NewBps * NewH;
NewXOff = XOff * PixBpp;
for (z = 0; z < NewD; z++) {
for (y = 0; y < NewH; y++) {
for (x = 0; x < NewBps; x += PixBpp) {
for (c = 0; c < PixBpp; c++) {
Temp[z * NewSizePlane + y * DataBps + x + c] =
TempData[(z + ZOff) * image->SizeOfPlane + (y + YOff) * image->Bps + x + NewXOff + c];
//TempData[(z + ZOff) * image->SizeOfPlane + (y + YOff) * image->Bps + (x + XOff) * image->Bpp + c];
}
}
}
}
if (TempData != image->Data)
ifree(TempData);
return IL_TRUE;
}
ILboolean ilSetPixels1D(ILimage* image, ILint XOff, ILuint Width, void *Data)
{
ILuint c, SkipX = 0, PixBpp;
ILint x, NewWidth;
ILubyte *Temp = (ILubyte*)Data, *TempData = image->Data;
if (ilIsEnabled(IL_ORIGIN_SET)) {
if ((ILenum)ilGetInteger(IL_ORIGIN_MODE) != image->Origin) {
TempData = iGetFlipped(image);
if (TempData == NULL)
return IL_FALSE;
}
}
PixBpp = image->Bpp * image->Bpc;
if (XOff < 0) {
SkipX = abs(XOff);
XOff = 0;
}
if (image->Width < XOff + Width) {
NewWidth = image->Width - XOff;
}
else {
NewWidth = Width;
}
NewWidth -= SkipX;
for (x = 0; x < NewWidth; x++) {
for (c = 0; c < PixBpp; c++) {
TempData[(x + XOff) * PixBpp + c] = Temp[(x + SkipX) * PixBpp + c];
}
}
if (TempData != image->Data) {
ifree(image->Data);
image->Data = TempData;
}
return IL_TRUE;
}
// Copies a 2d block of pixels to the buffer pointed to by Data.
ILboolean ilCopyPixels2D(ILimage* image, ILuint XOff, ILuint YOff, ILuint Width, ILuint Height, void *Data)
{
ILuint x, y, c, NewBps, DataBps, NewXOff, NewHeight, PixBpp;
ILubyte *Temp = (ILubyte*)Data, *TempData = image->Data;
if (ilIsEnabled(IL_ORIGIN_SET)) {
if ((ILenum)ilGetInteger(IL_ORIGIN_MODE) != image->Origin) {
TempData = iGetFlipped(image);
if (TempData == NULL)
return IL_FALSE;
}
}
PixBpp = image->Bpp * image->Bpc;
if (image->Width < XOff + Width)
NewBps = (image->Width - XOff) * PixBpp;
else
NewBps = Width * PixBpp;
if (image->Height < YOff + Height)
NewHeight = image->Height - YOff;
else
NewHeight = Height;
DataBps = Width * PixBpp;
NewXOff = XOff * PixBpp;
for (y = 0; y < NewHeight; y++) {
for (x = 0; x < NewBps; x += PixBpp) {
for (c = 0; c < PixBpp; c++) {
Temp[y * DataBps + x + c] =
TempData[(y + YOff) * image->Bps + x + NewXOff + c];
}
}
}
if (TempData != image->Data)
ifree(TempData);
return IL_TRUE;
}
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;
}
ILboolean ILAPIENTRY ilBlit(ILuint Source, ILint DestX, ILint DestY, ILint DestZ, ILuint SrcX, ILuint SrcY, ILuint SrcZ, ILuint Width, ILuint Height, ILuint Depth)
{
register ILuint x, y, z, SrcIndex, DestIndex, ConvBps, ConvSizePlane;
ILimage *Dest;
ILubyte *Converted;
ILuint DestName = ilGetCurName();
ILint c;
ILfloat FrontPer, BackPer;
ILenum DestOrigin, SrcOrigin;
ILuint StartX, StartY, StartZ, AlphaOff;
ILboolean DestFlipped = IL_FALSE;
ILubyte *SrcTemp;
if (DestName == 0 || iCurImage == NULL) {
ilSetError(IL_ILLEGAL_OPERATION);
return IL_FALSE;
}
if (iCurImage->Origin == IL_ORIGIN_LOWER_LEFT) { // Dest
DestFlipped = IL_TRUE;
ilFlipImage();
}
Dest = iCurImage;
DestOrigin = iCurImage->Origin;
ilBindImage(Source);
SrcOrigin = iCurImage->Origin;
if (iCurImage->Origin == IL_ORIGIN_LOWER_LEFT) {
SrcTemp = iGetFlipped(iCurImage);
if (SrcTemp == NULL) {
ilBindImage(DestName);
if (DestFlipped)
ilFlipImage();
return IL_FALSE;
}
}
else {
SrcTemp = iCurImage->Data;
}
if (Dest == NULL || iCurImage == NULL) {
ilSetError(IL_INVALID_PARAM);
return IL_FALSE;
}
Converted = ilConvertBuffer(iCurImage->SizeOfData, iCurImage->Format, Dest->Format, iCurImage->Type, Dest->Type, SrcTemp);
if (Converted == NULL)
return IL_FALSE;
ConvBps = Dest->Bpp * iCurImage->Width;
ConvSizePlane = ConvBps * iCurImage->Height;
StartX = DestX >= 0 ? 0 : -DestX;
StartY = DestY >= 0 ? 0 : -DestY;
StartZ = DestZ >= 0 ? 0 : -DestZ;
Width = Width + SrcX < Dest->Width ? Width + SrcX : Dest->Width;
Height = Height + SrcY < Dest->Height ? Height + SrcY : Dest->Height;
Depth = Depth + SrcZ < Dest->Depth ? Depth + SrcZ : Dest->Depth;
if (iCurImage->Format == IL_RGBA || iCurImage->Format == IL_BGRA || iCurImage->Format == IL_LUMINANCE_ALPHA) {
if (iCurImage->Format == IL_LUMINANCE_ALPHA)
AlphaOff = 1;
else
AlphaOff = 3;
for (z = StartZ; z < Depth && z + DestZ < Dest->Depth; z++) {
for (y = StartY; y < Height && y + DestY < Dest->Height; y++) {
for (x = StartX; x < Width && x + DestX < Dest->Width; x++) {
SrcIndex = (z + SrcZ) * ConvSizePlane + (y + SrcY) * ConvBps + (x + SrcX) * Dest->Bpp;
DestIndex = (z + DestZ) * Dest->SizeOfPlane + (y + DestY) * Dest->Bps + (x + DestX) * Dest->Bpp;
// Use the original alpha
FrontPer = iCurImage->Data[(z + SrcZ) * iCurImage->SizeOfPlane + (y + SrcY) * iCurImage->Bps + (x + SrcX) * iCurImage->Bpp + 3] / 255.0f;
BackPer = 1.0f - FrontPer;
for (c = 0; c < Dest->Bpp - 1; c++) {
Dest->Data[DestIndex + c] = (ILubyte)(Converted[SrcIndex + c] * FrontPer
+ Dest->Data[DestIndex + c] * BackPer);
}
// Keep the original alpha.
//Dest->Data[DestIndex + c + 1] = Dest->Data[DestIndex + c + 1];
}
}
}
}
else {
for (z = StartZ; z < Depth && z + DestZ < Dest->Depth; z++) {
for (y = StartY; y < Height && y + DestY < Dest->Height; y++) {
for (x = StartX; x < Width && x + DestX < Dest->Width; x++) {
for (c = 0; c < Dest->Bpp; c++) {
Dest->Data[(z + DestZ) * Dest->SizeOfPlane + (y + DestY) * Dest->Bps + (x + DestX) * Dest->Bpp + c] =
Converted[(z + SrcZ) * ConvSizePlane + (y + SrcY) * ConvBps + (x + SrcX) * Dest->Bpp + c];
}
}
}
}
}
if (SrcTemp != iCurImage->Data)
ifree(SrcTemp);
ilBindImage(DestName);
if (DestFlipped)
ilFlipImage();
ifree(Converted);
return IL_TRUE;
}
//! Overlays the image found in Src on top of the current bound image at the coords specified.
ILboolean ILAPIENTRY ilOverlayImage(ILuint Source, ILint XCoord, ILint YCoord, ILint ZCoord)
{
ILuint x, y, z, SrcIndex, DestIndex, ConvBps, ConvSizePlane;
ILint c;
ILimage *Dest;//, *Src;
ILubyte *Converted;
ILuint DestName = ilGetCurName();
ILfloat FrontPer, BackPer;
ILenum DestOrigin, SrcOrigin;
ILuint StartX, StartY, StartZ, AlphaOff;
ILubyte *SrcTemp = NULL;
ILboolean DestFlipped = IL_FALSE;
if (DestName == 0 || iCurImage == NULL) {
ilSetError(IL_ILLEGAL_OPERATION);
return IL_FALSE;
}
if (iCurImage->Origin == IL_ORIGIN_LOWER_LEFT) { // Dest
DestFlipped = IL_TRUE;
ilFlipImage();
}
Dest = iCurImage;
DestOrigin = iCurImage->Origin;
ilBindImage(Source);
SrcOrigin = iCurImage->Origin;
if (iCurImage->Origin == IL_ORIGIN_LOWER_LEFT) {
SrcTemp = iGetFlipped(iCurImage);
if (SrcTemp == NULL) {
ilBindImage(DestName);
if (DestFlipped)
ilFlipImage();
return IL_FALSE;
}
}
else {
SrcTemp = iCurImage->Data;
}
if (Dest == NULL || iCurImage == NULL) {
ilSetError(IL_INVALID_PARAM);
return IL_FALSE;
}
Converted = ilConvertBuffer(iCurImage->SizeOfData, iCurImage->Format, Dest->Format, iCurImage->Type, Dest->Type, SrcTemp);
if (Converted == NULL)
return IL_FALSE;
ConvBps = Dest->Bpp * iCurImage->Width;
ConvSizePlane = ConvBps * iCurImage->Height;
StartX = XCoord >= 0 ? 0 : -XCoord;
StartY = YCoord >= 0 ? 0 : -YCoord;
StartZ = ZCoord >= 0 ? 0 : -ZCoord;
if (iCurImage->Format == IL_RGBA || iCurImage->Format == IL_BGRA || iCurImage->Format == IL_LUMINANCE_ALPHA) {
if (iCurImage->Format == IL_LUMINANCE_ALPHA)
AlphaOff = 1;
else
AlphaOff = 3;
for (z = StartZ; z < iCurImage->Depth && (ILint)z + ZCoord < (ILint)Dest->Depth; z++) {
for (y = StartY; y < iCurImage->Height && (ILint)y + YCoord < (ILint)Dest->Height; y++) {
for (x = StartX; x < iCurImage->Width && (ILint)x + XCoord < (ILint)Dest->Width; x++) {
SrcIndex = z * ConvSizePlane + y * ConvBps + x * Dest->Bpp;
DestIndex = (z + ZCoord) * Dest->SizeOfPlane + (y + YCoord) * Dest->Bps + (x + XCoord) * Dest->Bpp;
FrontPer = iCurImage->Data[z * iCurImage->SizeOfPlane + y * iCurImage->Bps + x * iCurImage->Bpp + AlphaOff] / 255.0f;
BackPer = 1.0f - FrontPer;
for (c = 0; c < iCurImage->Bpp - 1; c++) {
Dest->Data[DestIndex + c] = (ILubyte)(Converted[SrcIndex + c] * FrontPer
+ Dest->Data[DestIndex + c] * BackPer);
}
// Keep the original alpha.
//Dest->Data[DestIndex + c + 1] = Dest->Data[DestIndex + c + 1];
}
}
}
}
else {
for (z = StartZ; z < iCurImage->Depth && z + ZCoord < Dest->Depth; z++) {
for (y = StartY; y < iCurImage->Height && y + YCoord < Dest->Height; y++) {
for (x = StartX; x < iCurImage->Width && x + XCoord < Dest->Width; x++) {
for (c = 0; c < iCurImage->Bpp; c++) {
Dest->Data[(z + ZCoord) * Dest->SizeOfPlane + (y + YCoord) * Dest->Bps + (x + XCoord) * Dest->Bpp + c] =
Converted[z * ConvSizePlane + y * ConvBps + x * Dest->Bpp + c];
}
}
}
}
}
if (SrcTemp != iCurImage->Data)
ifree(SrcTemp);
ilBindImage(DestName);
if (DestFlipped)
ilFlipImage();
ifree(Converted);
return IL_TRUE;
}
// Internal function used to save the Pnm.
ILboolean iSavePnmInternal()
{
ILuint Bpp, MaxVal = UCHAR_MAX, i = 0, j, k;
ILenum Type = 0;
ILuint LinePos = 0; // Cannot exceed 70 for pnm's!
ILboolean Binary;
ILimage *TempImage;
ILubyte *TempData;
if (iCurImage == NULL) {
ilSetError(IL_ILLEGAL_OPERATION);
return IL_FALSE;
}
if (iCheckExtension(FName, IL_TEXT("pbm")))
Type = IL_PBM_ASCII;
else if (iCheckExtension(FName, IL_TEXT("pgm")))
Type = IL_PGM_ASCII;
else if (iCheckExtension(FName, IL_TEXT("ppm")))
Type = IL_PPM_ASCII;
else
Type = IL_PPM_ASCII;
/*if (!Type) {
ilSetError(IL_INVALID_EXTENSION);
return IL_FALSE;
}*/
if (iGetHint(IL_COMPRESSION_HINT) == IL_USE_COMPRESSION) {
Type += 3;
Binary = IL_TRUE;
}
else {
Binary = IL_FALSE;
}
if (iCurImage->Type == IL_UNSIGNED_BYTE) {
MaxVal = UCHAR_MAX;
}
else if (iCurImage->Type == IL_UNSIGNED_SHORT) {
MaxVal = USHRT_MAX;
}
else {
ilSetError(IL_FORMAT_NOT_SUPPORTED);
return IL_FALSE;
}
if (MaxVal > UCHAR_MAX && Type >= IL_PBM_BINARY) { // binary cannot be higher than 255
ilSetError(IL_FORMAT_NOT_SUPPORTED);
return IL_FALSE;
}
switch (Type)
{
case IL_PBM_ASCII:
Bpp = 1;
ilprintf("P1\n");
TempImage = iConvertImage(iCurImage, IL_LUMINANCE, IL_UNSIGNED_BYTE);
break;
//case IL_PBM_BINARY: // Don't want to mess with saving bits just yet...
//Bpp = 1;
//ilprintf("P4\n");
//break;
case IL_PBM_BINARY:
ilSetError(IL_FORMAT_NOT_SUPPORTED);
return IL_FALSE;
case IL_PGM_ASCII:
Bpp = 1;
ilprintf("P2\n");
TempImage = iConvertImage(iCurImage, IL_COLOUR_INDEX, IL_UNSIGNED_BYTE);
break;
case IL_PGM_BINARY:
Bpp = 1;
ilprintf("P5\n");
TempImage = iConvertImage(iCurImage, IL_COLOUR_INDEX, IL_UNSIGNED_BYTE);
break;
case IL_PPM_ASCII:
Bpp = 3;
ilprintf("P3\n");
TempImage = iConvertImage(iCurImage, IL_RGB, IL_UNSIGNED_BYTE);
break;
case IL_PPM_BINARY:
Bpp = 3;
ilprintf("P6\n");
TempImage = iConvertImage(iCurImage, IL_RGB, IL_UNSIGNED_BYTE);
break;
default:
ilSetError(IL_INTERNAL_ERROR);
return IL_FALSE;
}
if (TempImage == NULL)
return IL_FALSE;
if (Bpp != TempImage->Bpp) {
ilSetError(IL_INVALID_CONVERSION);
return IL_FALSE;
}
if (TempImage->Origin != IL_ORIGIN_UPPER_LEFT) {
TempData = iGetFlipped(TempImage);
if (TempData == NULL) {
ilCloseImage(TempImage);
return IL_FALSE;
}
}
else {
TempData = TempImage->Data;
}
ilprintf("%d %d\n", TempImage->Width, TempImage->Height);
if (Type != IL_PBM_BINARY && Type != IL_PBM_ASCII) // not needed for .pbm's (only 0 and 1)
ilprintf("%d\n", MaxVal);
while (i < TempImage->SizeOfPlane) {
for (j = 0; j < Bpp; j++) {
if (Binary) {
if (Type == IL_PBM_BINARY) {
iputc((ILubyte)(TempData[i] > 127 ? 1 : 0));
}
else {
iputc(TempData[i]);
}
}
else {
if (TempImage->Type == IL_UNSIGNED_BYTE)
k = TempData[i];
else // IL_UNSIGNED_SHORT
k = *((ILushort*)TempData + i);
if (Type == IL_PBM_ASCII) {
LinePos += ilprintf("%d ", TempData[i] > 127 ? 1 : 0);
}
else {
LinePos += ilprintf("%d ", TempData[i]);
}
}
if (TempImage->Type == IL_UNSIGNED_SHORT)
i++;
i++;
}
if (LinePos > 65) { // Just a good number =]
ilprintf("\n");
LinePos = 0;
}
}
if (TempImage->Origin != IL_ORIGIN_UPPER_LEFT)
ifree(TempData);
ilCloseImage(TempImage);
return IL_TRUE;
}
//@NEXT DestX,DestY,DestZ must be set to ILuint
ILboolean ILAPIENTRY il2Blit(ILimage* aSource, ILimage* aTarget, ILint DestX, ILint DestY, ILint DestZ,
ILuint SrcX, ILuint SrcY, ILuint SrcZ, ILuint Width, ILuint Height, ILuint Depth)
{
ILuint x, y, z, ConvBps, ConvSizePlane;
ILubyte *Converted;
ILuint DestName = ilGetCurName();
ILuint c;
ILuint StartX, StartY, StartZ;
ILboolean DestFlipped = IL_FALSE;
ILboolean DoAlphaBlend = IL_FALSE;
ILubyte *SrcTemp;
ILfloat ResultAlpha;
// Check if source and target images really exist
if (aSource == NULL || aTarget == NULL) {
il2SetError(IL_ILLEGAL_OPERATION);
return IL_FALSE;
}
// set the destination image to upper left origin
if (aTarget->Origin == IL_ORIGIN_LOWER_LEFT) { // Dest
DestFlipped = IL_TRUE;
ilFlipImage(aTarget);
}
//determine alpha support
DoAlphaBlend = il2IsEnabled(IL_BLIT_BLEND);
//@TODO test if coordinates are inside the images (hard limit for source)
// set the source image to upper left origin
if (aSource->Origin == IL_ORIGIN_LOWER_LEFT)
{
SrcTemp = iGetFlipped(aSource);
if (SrcTemp == NULL)
{
if (DestFlipped)
ilFlipImage(aTarget);
return IL_FALSE;
}
}
else
{
SrcTemp = aSource->Data;
}
// convert source image to match the destination image type and format
Converted = (ILubyte*)ilConvertBuffer(aSource->SizeOfData, aSource->Format, aTarget->Format,
aSource->Type, aTarget->Type, NULL, SrcTemp);
if (Converted == NULL)
return IL_FALSE;
ConvBps = aTarget->Bpp * aSource->Width;
ConvSizePlane = ConvBps * aSource->Height;
//@NEXT in next version this would have to be removed since Dest* will be unsigned
StartX = DestX >= 0 ? 0 : -DestX;
StartY = DestY >= 0 ? 0 : -DestY;
StartZ = DestZ >= 0 ? 0 : -DestZ;
// Limit the copy of data inside of the destination image
if (Width + DestX > aTarget->Width) Width = aTarget->Width - DestX;
if (Height + DestY > aTarget->Height) Height = aTarget->Height - DestY;
if (Depth + DestZ > aTarget->Depth) Depth = aTarget->Depth - DestZ;
//@TODO: non funziona con rgba
if (aSource->Format == IL_RGBA || aSource->Format == IL_BGRA || aSource->Format == IL_LUMINANCE_ALPHA) {
const ILuint bpp_without_alpha = aTarget->Bpp - 1;
for (z = 0; z < Depth; z++) {
for (y = 0; y < Height; y++) {
for (x = 0; x < Width; x++) {
const ILuint SrcIndex = (z+SrcZ)*ConvSizePlane + (y+SrcY)*ConvBps + (x+SrcX)*aTarget->Bpp;
const ILuint DestIndex = (z+DestZ)*aTarget->SizeOfPlane + (y+DestY)*aTarget->Bps + (x+DestX)*aTarget->Bpp;
const ILuint AlphaIdx = SrcIndex + bpp_without_alpha;
ILfloat FrontAlpha = 0; // foreground opacity
ILfloat BackAlpha = 0; // background opacity
switch (aTarget->Type)
{
case IL_BYTE:
case IL_UNSIGNED_BYTE:
FrontAlpha = Converted[AlphaIdx]/((float)IL_MAX_UNSIGNED_BYTE);
BackAlpha = aTarget->Data[AlphaIdx]/((float)IL_MAX_UNSIGNED_BYTE);
break;
case IL_SHORT:
case IL_UNSIGNED_SHORT:
FrontAlpha = ((ILshort*)Converted)[AlphaIdx]/((float)IL_MAX_UNSIGNED_SHORT);
BackAlpha = ((ILshort*)aTarget->Data)[AlphaIdx]/((float)IL_MAX_UNSIGNED_SHORT);
break;
case IL_INT:
case IL_UNSIGNED_INT:
FrontAlpha = ((ILint*)Converted)[AlphaIdx]/((float)IL_MAX_UNSIGNED_INT);
BackAlpha = ((ILint*)aTarget->Data)[AlphaIdx]/((float)IL_MAX_UNSIGNED_INT);
break;
case IL_FLOAT:
FrontAlpha = ((ILfloat*)Converted)[AlphaIdx];
BackAlpha = ((ILfloat*)aTarget->Data)[AlphaIdx];
break;
case IL_DOUBLE:
FrontAlpha = (ILfloat)(((ILdouble*)Converted)[AlphaIdx]);
BackAlpha = (ILfloat)(((ILdouble*)aTarget->Data)[AlphaIdx]);
break;
}
// In case of Alpha channel, the data is blended.
// Computes composite Alpha
if (DoAlphaBlend)
{
ResultAlpha = FrontAlpha + (1.0f - FrontAlpha) * BackAlpha;
for (c = 0; c < bpp_without_alpha; c++)
{
aTarget->Data[DestIndex + c] = (ILubyte)( 0.5f +
(Converted[SrcIndex + c] * FrontAlpha +
(1.0f - FrontAlpha) * aTarget->Data[DestIndex + c] * BackAlpha)
/ ResultAlpha);
}
aTarget->Data[AlphaIdx] = (ILubyte)(0.5f + ResultAlpha * (float)IL_MAX_UNSIGNED_BYTE);
}
else {
for (c = 0; c < aTarget->Bpp; c++)
{
aTarget->Data[DestIndex + c] = (ILubyte)(Converted[SrcIndex + c]);
}
}
}
}
}
} else {
for( z = 0; z < Depth; z++ ) {
for( y = 0; y < Height; y++ ) {
for( x = 0; x < Width; x++ ) {
for( c = 0; c < aTarget->Bpp; c++ ) {
aTarget->Data[(z+DestZ)*aTarget->SizeOfPlane + (y+DestY)*aTarget->Bps + (x+DestX)*aTarget->Bpp + c] =
Converted[(z+SrcZ)*ConvSizePlane + (y+SrcY)*ConvBps + (x+SrcX)*aTarget->Bpp + c];
}
}
}
}
}
if (SrcTemp != aSource->Data)
ifree(SrcTemp);
if (DestFlipped)
ilFlipImage(aTarget);
ifree(Converted);
return IL_TRUE;
}
ILboolean ilSetPixels3D(ILimage* image, ILint XOff, ILint YOff, ILint ZOff, ILuint Width, ILuint Height, ILuint Depth, void *Data)
{
ILuint SkipX = 0, SkipY = 0, SkipZ = 0, c, NewBps, NewSizePlane, PixBpp;
ILint x, y, z, NewW, NewH, NewD;
ILubyte *Temp = (ILubyte*)Data, *TempData = image->Data;
if (ilIsEnabled(IL_ORIGIN_SET)) {
if ((ILenum)ilGetInteger(IL_ORIGIN_MODE) != image->Origin) {
TempData = iGetFlipped(image);
if (TempData == NULL)
return IL_FALSE;
}
}
PixBpp = image->Bpp * image->Bpc;
if (XOff < 0) {
SkipX = abs(XOff);
XOff = 0;
}
if (YOff < 0) {
SkipY = abs(YOff);
YOff = 0;
}
if (ZOff < 0) {
SkipZ = abs(ZOff);
ZOff = 0;
}
if (image->Width < XOff + Width)
NewW = image->Width - XOff;
else
NewW = Width;
NewBps = Width * PixBpp;
if (image->Height < YOff + Height)
NewH = image->Height - YOff;
else
NewH = Height;
if (image->Depth < ZOff + Depth)
NewD = image->Depth - ZOff;
else
NewD = Depth;
NewSizePlane = NewBps * Height;
NewW -= SkipX;
NewH -= SkipY;
NewD -= SkipZ;
for (z = 0; z < NewD; z++) {
for (y = 0; y < NewH; y++) {
for (x = 0; x < NewW; x++) {
for (c = 0; c < PixBpp; c++) {
TempData[(z + ZOff) * image->SizeOfPlane + (y + YOff) * image->Bps + (x + XOff) * PixBpp + c] =
Temp[(z + SkipZ) * NewSizePlane + (y + SkipY) * NewBps + (x + SkipX) * PixBpp + c];
}
}
}
}
if (TempData != image->Data) {
ifree(image->Data);
image->Data = TempData;
}
return IL_TRUE;
}
// 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;
}
//@NEXT DestX,DestY,DestZ must be set to ILuint
ILboolean ILAPIENTRY ilBlit(ILuint Source, ILint DestX, ILint DestY, ILint DestZ,
ILuint SrcX, ILuint SrcY, ILuint SrcZ,
ILuint Width, ILuint Height, ILuint Depth)
{
ILuint x, y, z, ConvBps, ConvSizePlane;
ILimage *Dest,*Src;
ILubyte *Converted;
ILuint DestName = ilGetCurName();
ILuint c;
ILuint StartX, StartY, StartZ;
ILboolean DestFlipped = IL_FALSE;
ILubyte *SrcTemp;
ILfloat Back;
// Check if the desiination image really exists
if( DestName == 0 || iCurImage == NULL ) {
ilSetError(IL_ILLEGAL_OPERATION);
return IL_FALSE;
}
Dest = iCurImage;
// set the destination image to upper left origin
if( Dest->Origin == IL_ORIGIN_LOWER_LEFT ) { // Dest
DestFlipped = IL_TRUE;
ilFlipImage();
}
//DestOrigin = Dest->Origin;
ilBindImage(Source);
// Check if the source image really exists
if( iCurImage == NULL ) {
ilSetError(IL_INVALID_PARAM);
return IL_FALSE;
}
Src = iCurImage;
//@TODO test if coordinates are inside the images (hard limit for source)
// set the source image to upper left origin
if (Src->Origin == IL_ORIGIN_LOWER_LEFT)
{
SrcTemp = iGetFlipped(iCurImage);
if (SrcTemp == NULL)
{
ilBindImage(DestName);
if (DestFlipped)
ilFlipImage();
return IL_FALSE;
}
}
else
{
SrcTemp = iCurImage->Data;
}
// convert source image to match the destination image type and format
Converted = (ILubyte*)ilConvertBuffer(Src->SizeOfData, Src->Format, Dest->Format, Src->Type, Dest->Type, SrcTemp);
if (Converted == NULL)
return IL_FALSE;
ConvBps = Dest->Bpp * Src->Width;
ConvSizePlane = ConvBps * Src->Height;
//@NEXT in next version this would have to be removed since Dest* will be unsigned
StartX = DestX >= 0 ? 0 : -DestX;
StartY = DestY >= 0 ? 0 : -DestY;
StartZ = DestZ >= 0 ? 0 : -DestZ;
// Limit the copy of data inside of the destination image
if (Width + DestX > Dest->Width) Width = Dest->Width - DestX;
if (Height + DestY > Dest->Height) Height = Dest->Height - DestY;
if (Depth + DestZ > Dest->Depth) Depth = Dest->Depth - DestZ;
//@TODO: non funziona con rgba
if (Src->Format == IL_RGBA || Src->Format == IL_BGRA || Src->Format == IL_LUMINANCE_ALPHA) {
const ILuint bpp_without_alpha = Dest->Bpp - 1;
for (z = 0; z < Depth; z++) {
for (y = 0; y < Height; y++) {
for (x = 0; x < Width; x++) {
const ILuint SrcIndex = (z+SrcZ)*ConvSizePlane + (y+SrcY)*ConvBps + (x+SrcX)*Dest->Bpp;
const ILuint DestIndex = (z+DestZ)*Dest->SizeOfPlane + (y+DestY)*Dest->Bps + (x+DestX)*Dest->Bpp;
const ILuint AlphaIdx = SrcIndex + bpp_without_alpha;
ILfloat Front = 0;
switch (Dest->Type)
{
case IL_BYTE:
case IL_UNSIGNED_BYTE:
Front = Converted[AlphaIdx]/((float)IL_MAX_UNSIGNED_BYTE);
break;
case IL_SHORT:
case IL_UNSIGNED_SHORT:
Front = ((ILshort*)Converted)[AlphaIdx]/((float)IL_MAX_UNSIGNED_SHORT);
break;
case IL_INT:
case IL_UNSIGNED_INT:
Front = ((ILint*)Converted)[AlphaIdx]/((float)IL_MAX_UNSIGNED_INT);
break;
case IL_FLOAT:
Front = ((ILfloat*)Converted)[AlphaIdx];
break;
case IL_DOUBLE:
Front = (ILfloat)(((ILdouble*)Converted)[AlphaIdx]);
break;
}
Back = 1.0f - Front;
// In case of Alpha channel, the data is blended. Keeps the original alpha.
if (ilIsEnabled(IL_BLIT_BLEND)) {
for (c = 0; c < bpp_without_alpha; c++)
{
Dest->Data[DestIndex + c] =
(ILubyte)(Converted[SrcIndex + c] * Front
+ Dest->Data[DestIndex + c] * Back);
}
}
else {
for (c = 0; c < Dest->Bpp; c++)
{
Dest->Data[DestIndex + c] = (ILubyte)(Converted[SrcIndex + c]);
}
}
}
}
}
} else {
for( z = 0; z < Depth; z++ ) {
for( y = 0; y < Height; y++ ) {
for( x = 0; x < Width; x++ ) {
for( c = 0; c < Dest->Bpp; c++ ) {
Dest->Data[(z+DestZ)*Dest->SizeOfPlane + (y+DestY)*Dest->Bps + (x+DestX)*Dest->Bpp + c] =
Converted[(z+SrcZ)*ConvSizePlane + (y+SrcY)*ConvBps + (x+SrcX)*Dest->Bpp + c];
}
}
}
}
}
if (SrcTemp != iCurImage->Data)
ifree(SrcTemp);
ilBindImage(DestName);
if (DestFlipped)
ilFlipImage();
ifree(Converted);
return IL_TRUE;
}
// Internal function used to save the Sgi.
ILboolean iSaveSgiInternal()
{
ILuint i, c;
ILboolean Compress;
ILimage *Temp = iCurImage;
ILubyte *TempData;
if (iCurImage == NULL) {
ilSetError(IL_ILLEGAL_OPERATION);
return IL_FALSE;
}
if (iCurImage->Format != IL_LUMINANCE
//while the sgi spec doesn't directly forbid rgb files with 2
//channels, they are quite uncommon and most apps don't support
//them. so convert lum_a images to rgba before writing.
//&& iCurImage->Format != IL_LUMINANCE_ALPHA
&& iCurImage->Format != IL_RGB
&& iCurImage->Format != IL_RGBA) {
if (iCurImage->Format == IL_BGRA || iCurImage->Format == IL_LUMINANCE_ALPHA)
Temp = iConvertImage(iCurImage, IL_RGBA, DetermineSgiType(iCurImage->Type));
else
Temp = iConvertImage(iCurImage, IL_RGB, DetermineSgiType(iCurImage->Type));
}
else if (iCurImage->Type > IL_UNSIGNED_SHORT) {
Temp = iConvertImage(iCurImage, iCurImage->Format, DetermineSgiType(iCurImage->Type));
}
//compression of images with 2 bytes per channel doesn't work yet
Compress = iGetInt(IL_SGI_RLE) && Temp->Bpc == 1;
if (Temp == NULL)
return IL_FALSE;
SaveBigUShort(SGI_MAGICNUM); // 'Magic' number
if (Compress)
iputc(1);
else
iputc(0);
if (Temp->Type == IL_UNSIGNED_BYTE)
iputc(1);
else if (Temp->Type == IL_UNSIGNED_SHORT)
iputc(2);
// Need to error here if not one of the two...
if (Temp->Format == IL_LUMINANCE || Temp->Format == IL_COLOUR_INDEX)
SaveBigUShort(2);
else
SaveBigUShort(3);
SaveBigUShort((ILushort)Temp->Width);
SaveBigUShort((ILushort)Temp->Height);
SaveBigUShort((ILushort)Temp->Bpp);
switch (Temp->Type)
{
case IL_BYTE:
SaveBigInt(SCHAR_MIN); // Minimum pixel value
SaveBigInt(SCHAR_MAX); // Maximum pixel value
break;
case IL_UNSIGNED_BYTE:
SaveBigInt(0); // Minimum pixel value
SaveBigInt(UCHAR_MAX); // Maximum pixel value
break;
case IL_SHORT:
SaveBigInt(SHRT_MIN); // Minimum pixel value
SaveBigInt(SHRT_MAX); // Maximum pixel value
break;
case IL_UNSIGNED_SHORT:
SaveBigInt(0); // Minimum pixel value
SaveBigInt(USHRT_MAX); // Maximum pixel value
break;
}
SaveBigInt(0); // Dummy value
if (FName) {
c = ilCharStrLen(FName);
c = c < 79 ? 79 : c;
iwrite(FName, 1, c);
c = 80 - c;
for (i = 0; i < c; i++) {
iputc(0);
}
}
else {
for (i = 0; i < 80; i++) {
iputc(0);
}
}
SaveBigUInt(0); // Colormap
// Padding
for (i = 0; i < 101; i++) {
SaveLittleInt(0);
}
if (iCurImage->Origin == IL_ORIGIN_UPPER_LEFT) {
TempData = iGetFlipped(Temp);
if (TempData == NULL) {
if (Temp!= iCurImage)
ilCloseImage(Temp);
return IL_FALSE;
}
}
else {
TempData = Temp->Data;
}
if (!Compress) {
for (c = 0; c < Temp->Bpp; c++) {
for (i = c; i < Temp->SizeOfData; i += Temp->Bpp) {
iputc(TempData[i]); // Have to save each colour plane separately.
}
}
}
else {
iSaveRleSgi(TempData, Temp->Width, Temp->Height, Temp->Bpp, Temp->Bps);
}
if (TempData != Temp->Data)
ifree(TempData);
if (Temp != iCurImage)
ilCloseImage(Temp);
return IL_TRUE;
}
ILboolean ilSaveFromJpegStruct(ILvoid *_JpegInfo)
{
#ifndef IL_NO_JPG
#ifndef IL_USE_IJL
void (*errorHandler)(j_common_ptr);
JSAMPROW row_pointer[1];
ILimage *TempImage;
ILubyte *TempData;
j_compress_ptr JpegInfo = (j_compress_ptr)_JpegInfo;
if (iCurImage == NULL) {
ilSetError(IL_ILLEGAL_OPERATION);
return IL_FALSE;
}
//added on 2003-08-31 as explained in sf bug 596793
jpgErrorOccured = IL_FALSE;
errorHandler = JpegInfo->err->error_exit;
JpegInfo->err->error_exit = ExitErrorHandle;
if ((iCurImage->Format != IL_RGB && iCurImage->Format != IL_LUMINANCE) || iCurImage->Bpc != 1) {
TempImage = iConvertImage(iCurImage, IL_RGB, IL_UNSIGNED_BYTE);
if (TempImage == NULL) {
return IL_FALSE;
}
}
else {
TempImage = 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;
}
JpegInfo->image_width = TempImage->Width; // image width and height, in pixels
JpegInfo->image_height = TempImage->Height;
JpegInfo->input_components = TempImage->Bpp; // # of color components per pixel
jpeg_start_compress(JpegInfo, IL_TRUE);
//row_stride = image_width * 3; // JSAMPLEs per row in image_buffer
while (JpegInfo->next_scanline < JpegInfo->image_height) {
// jpeg_write_scanlines expects an array of pointers to scanlines.
// Here the array is only one element long, but you could pass
// more than one scanline at a time if that's more convenient.
row_pointer[0] = &TempData[JpegInfo->next_scanline * TempImage->Bps];
(void) jpeg_write_scanlines(JpegInfo, row_pointer, 1);
}
if (TempImage->Origin == IL_ORIGIN_LOWER_LEFT)
ifree(TempData);
if (TempImage != iCurImage)
ilCloseImage(TempImage);
return (!jpgErrorOccured);
#endif
#endif
return IL_FALSE;
}
ILboolean iSaveJpegInternal()
{
struct jpeg_compress_struct JpegInfo;
struct jpeg_error_mgr Error;
JSAMPROW row_pointer[1];
ILimage *TempImage;
ILubyte *TempData;
ILenum Type = 0;
if (iCurImage == NULL) {
ilSetError(IL_ILLEGAL_OPERATION);
return IL_FALSE;
}
/*if (iGetHint(IL_COMPRESSION_HINT) == IL_USE_COMPRESSION)
Quality = 85; // Not sure how low we should dare go...
else
Quality = 99;*/
// angua: RGB images also need to be converted to RGBA
if ((iCurImage->Format != IL_RGBA && iCurImage->Format != IL_LUMINANCE) || iCurImage->Bpc != 1) {
// taaaki: since RGB_PIXELSIZE was changed to 4, the conversion to
// RGB is short one colour component, causing screenshots to crash
TempImage = iConvertImage(iCurImage, IL_RGBA, IL_UNSIGNED_BYTE);
if (TempImage == NULL) {
return IL_FALSE;
}
}
else {
TempImage = 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;
}
JpegInfo.err = jpeg_std_error(&Error);
// Now we can initialize the JPEG compression object.
jpeg_create_compress(&JpegInfo);
//jpeg_stdio_dest(&JpegInfo, JpegFile);
devil_jpeg_write_init(&JpegInfo);
JpegInfo.image_width = TempImage->Width; // image width and height, in pixels
JpegInfo.image_height = TempImage->Height;
JpegInfo.input_components = TempImage->Bpp; // # of color components per pixel
// John Villar's addition
if (TempImage->Bpp == 1)
JpegInfo.in_color_space = JCS_GRAYSCALE;
else
JpegInfo.in_color_space = JCS_RGB;
jpeg_set_defaults(&JpegInfo);
/*#ifndef IL_USE_JPEGLIB_UNMODIFIED
Type = iGetInt(IL_JPG_SAVE_FORMAT);
if (Type == IL_EXIF) {
JpegInfo.write_JFIF_header = FALSE;
JpegInfo.write_EXIF_header = TRUE;
}
else if (Type == IL_JFIF) {
JpegInfo.write_JFIF_header = TRUE;
JpegInfo.write_EXIF_header = FALSE;
} EXIF not present int libjpeg...
#else*/
Type = Type;
JpegInfo.write_JFIF_header = TRUE;
//#endif//IL_USE_JPEGLIB_UNMODIFIED
jpeg_set_quality(&JpegInfo, iGetInt(IL_JPG_QUALITY), IL_TRUE);
jpeg_start_compress(&JpegInfo, IL_TRUE);
//row_stride = image_width * 3; // JSAMPLEs per row in image_buffer
while (JpegInfo.next_scanline < JpegInfo.image_height) {
// jpeg_write_scanlines expects an array of pointers to scanlines.
// Here the array is only one element long, but you could pass
// more than one scanline at a time if that's more convenient.
row_pointer[0] = &TempData[JpegInfo.next_scanline * TempImage->Bps];
(void) jpeg_write_scanlines(&JpegInfo, row_pointer, 1);
}
// Step 6: Finish compression
jpeg_finish_compress(&JpegInfo);
// Step 7: release JPEG compression object
// This is an important step since it will release a good deal of memory.
jpeg_destroy_compress(&JpegInfo);
if (TempImage->Origin == IL_ORIGIN_LOWER_LEFT)
ifree(TempData);
if (TempImage != iCurImage)
ilCloseImage(TempImage);
return IL_TRUE;
}
// Internal function used to save the Sgi.
ILboolean iSaveSgiInternal()
{
ILuint i, c;
ILboolean Compress;
ILimage *Temp = iCurImage;
ILubyte *TempData;
Compress = iGetInt(IL_SGI_RLE);
if (iCurImage == NULL) {
ilSetError(IL_ILLEGAL_OPERATION);
return IL_FALSE;
}
if (iCurImage->Format != IL_RGB && iCurImage->Format != IL_RGBA) {
if (iCurImage->Format == IL_BGRA)
Temp = iConvertImage(iCurImage, IL_RGBA, DetermineSgiType(iCurImage->Type));
else
Temp = iConvertImage(iCurImage, IL_RGB, DetermineSgiType(iCurImage->Type));
}
else if (iCurImage->Type > IL_UNSIGNED_SHORT) {
Temp = iConvertImage(iCurImage, iCurImage->Format, DetermineSgiType(iCurImage->Type));
}
if (Temp == NULL)
return IL_FALSE;
SaveBigUShort(SGI_MAGICNUM); // 'Magic' number
if (Compress)
iputc(1);
else
iputc(0);
if (Temp->Type == IL_UNSIGNED_BYTE)
iputc(1);
else if (Temp->Type == IL_UNSIGNED_SHORT)
iputc(2);
// Need to error here if not one of the two...
if (Temp->Format == IL_LUMINANCE || Temp->Format == IL_COLOUR_INDEX)
SaveBigUShort(2);
else
SaveBigUShort(3);
SaveBigUShort((ILushort)Temp->Width);
SaveBigUShort((ILushort)Temp->Height);
SaveBigUShort((ILushort)Temp->Bpp);
switch (Temp->Type)
{
case IL_BYTE:
SaveBigInt(SCHAR_MIN); // Minimum pixel value
SaveBigInt(SCHAR_MAX); // Maximum pixel value
break;
case IL_UNSIGNED_BYTE:
SaveBigInt(0); // Minimum pixel value
SaveBigInt(UCHAR_MAX); // Maximum pixel value
break;
case IL_SHORT:
SaveBigInt(SHRT_MIN); // Minimum pixel value
SaveBigInt(SHRT_MAX); // Maximum pixel value
break;
case IL_UNSIGNED_SHORT:
SaveBigInt(0); // Minimum pixel value
SaveBigInt(USHRT_MAX); // Maximum pixel value
break;
}
SaveBigInt(0); // Dummy value
if (FName) {
c = strlen(FName);
c = c < 79 ? 79 : c;
iwrite(FName, 1, c);
c = 80 - c;
for (i = 0; i < c; i++) {
iputc(0);
}
}
else {
for (i = 0; i < 80; i++) {
iputc(0);
}
}
SaveBigUInt(0); // Colormap
// Padding
for (i = 0; i < 101; i++) {
SaveLittleInt(0);
}
if (iCurImage->Origin == IL_ORIGIN_UPPER_LEFT) {
TempData = iGetFlipped(Temp);
if (TempData == NULL) {
if (Temp!= iCurImage)
ilCloseImage(Temp);
return IL_FALSE;
}
}
else {
TempData = Temp->Data;
}
if (!Compress) {
for (c = 0; c < Temp->Bpp; c++) {
for (i = c; i < Temp->SizeOfData; i += Temp->Bpp) {
iputc(TempData[i]); // Have to save each colour plane separately.
}
}
}
else {
iSaveRleSgi(TempData);
}
if (TempData != Temp->Data)
ifree(TempData);
if (Temp != iCurImage)
ilCloseImage(Temp);
return IL_TRUE;
}
