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