static toff_t _tiffFileSizeProc(thandle_t fd) { ILint Offset, Size; Offset = itell(); iseek(0, IL_SEEK_END); Size = itell(); iseek(Offset, IL_SEEK_SET); return Size; }
ILboolean ILAPIENTRY iDefaultEof(ILHANDLE Handle) { ILuint OrigPos, FileSize; // Find out the filesize for checking for the end of file OrigPos = itell(); iseek(0, IL_SEEK_END); FileSize = itell(); iseek(OrigPos, IL_SEEK_SET); if (itell() >= FileSize) return IL_TRUE; return IL_FALSE; }
//! Reads an already-opened Jpeg2000 file. ILboolean ilLoadJp2F(ILHANDLE File) { ILuint FirstPos; ILboolean bRet; jas_stream_t *Stream; iSetInputFile(File); FirstPos = itell(); if (jas_init()) { ilSetError(IL_LIB_JP2_ERROR); return IL_FALSE; } Stream = iJp2ReadStream(); if (!Stream) { ilSetError(IL_COULD_NOT_OPEN_FILE); return IL_FALSE; } bRet = iLoadJp2Internal(Stream, NULL); // Close the input stream. jas_stream_close(Stream); iseek(FirstPos, IL_SEEK_SET); return bRet; }
iff_chunk iff_begin_read_chunk() { chunkDepth++; if (chunkDepth >= CHUNK_STACK_SIZE){ ilSetError(IL_STACK_OVERFLOW); return chunkStack[0]; } if (chunkDepth < 0) { ilSetError(IL_STACK_UNDERFLOW); return chunkStack[0]; } chunkStack[chunkDepth].start = itell(); chunkStack[chunkDepth].tag = GetBigInt(); chunkStack[chunkDepth].size = GetBigInt(); if (chunkStack[chunkDepth].tag == IFF_TAG_FOR4) { // -- We have a form, so read the form type tag as well. chunkStack[chunkDepth].chunkType = GetBigInt(); } else { chunkStack[chunkDepth].chunkType = 0; } return chunkStack[chunkDepth]; }
// Tells DevIL that we're reading from a file, not a lump ILvoid iSetInputFile(ILHANDLE File) { ieof = iEofFile; igetc = iGetcFile; iread = iReadFile; iseek = iSeekRFile; itell = iTellRFile; FileRead = File; ReadFileStart = itell(); }
ILboolean ParseChunks() { BLOCKHEAD Block; ILuint Pos; do { if (iread(&Block, 1, sizeof(Block)) != sizeof(Block)) { ilGetError(); // Get rid of the erroneous IL_FILE_READ_ERROR. return IL_TRUE; } if (Header.MajorVersion == 3) Block.BlockLen = GetLittleUInt(); else UInt(&Block.BlockLen); if (Block.HeadID[0] != 0x7E || Block.HeadID[1] != 0x42 || Block.HeadID[2] != 0x4B || Block.HeadID[3] != 0x00) { return IL_TRUE; } UShort(&Block.BlockID); UInt(&Block.BlockLen); Pos = itell(); switch (Block.BlockID) { case PSP_LAYER_START_BLOCK: if (!ReadLayerBlock(Block.BlockLen)) return IL_FALSE; break; case PSP_ALPHA_BANK_BLOCK: if (!ReadAlphaBlock(Block.BlockLen)) return IL_FALSE; break; case PSP_COLOR_BLOCK: if (!ReadPalette(Block.BlockLen)) return IL_FALSE; break; // Gets done in the next iseek, so this is now commented out. //default: //iseek(Block.BlockLen, IL_SEEK_CUR); } // Skip to next block just in case we didn't read the entire block. iseek(Pos + Block.BlockLen, IL_SEEK_SET); // @TODO: Do stuff here. } while (1); return IL_TRUE; }
//! Checks if the ILHANDLE contains a valid .bmp file at the current position. ILboolean ilIsValidBmpF(ILHANDLE File) { ILuint FirstPos; ILboolean bRet; iSetInputFile(File); FirstPos = itell(); bRet = iIsValidBmp(); iseek(FirstPos, IL_SEEK_SET); return bRet; }
ERR iGetPosWS_File(struct WMPStream* pWS, size_t* poffPos) { ERR err = WMP_errSuccess; long lOff = 0; //FailIf(-1 == (lOff = ftell(pWS->state.file.pFile)), WMP_errFileIO); lOff = itell(); *poffPos = (size_t)lOff; Cleanup: return err; }
//! Reads an already-opened Pix file ILboolean ilLoadPixF(ILHANDLE File) { ILuint FirstPos; ILboolean bRet; iSetInputFile(File); FirstPos = itell(); bRet = iLoadPixInternal(); iseek(FirstPos, IL_SEEK_SET); return bRet; }
//! Reads an already-opened raw data file ILboolean ILAPIENTRY ilLoadDataF(ILHANDLE File, ILuint Width, ILuint Height, ILuint Depth, ILubyte Bpp) { ILuint FirstPos; ILboolean bRet; iSetInputFile(File); FirstPos = itell(); bRet = iLoadDataInternal(Width, Height, Depth, Bpp); iseek(FirstPos, IL_SEEK_SET); return bRet; }
//! Checks if the ILHANDLE contains a valid tiff file at the current position. ILboolean ilIsValidF_TIFF(ILHANDLE File) { ILuint FirstPos; ILboolean bRet; iSetInputFile(File); FirstPos = itell(); bRet = ilisValidTiffFunc(); iseek(FirstPos, IL_SEEK_SET); return bRet; }
// Internal function to get the header and check it. ILboolean iIsValidXpm(void) { ILubyte Buffer[10]; ILuint Pos = itell(); XpmGetsInternal(Buffer, 10); iseek(Pos, IL_SEEK_SET); // Restore position if (strncmp("/* XPM */", (char*)Buffer, strlen("/* XPM */"))) return IL_FALSE; return IL_TRUE; }
// Internal function to get the header and check it. ILboolean iIsValidDicom(void) { DICOMHEAD Header; ILuint Pos = itell(); // Clear the header to all 0s to make checks later easier. memset(&Header, 0, sizeof(DICOMHEAD)); if (!iGetDicomHead(&Header)) return IL_FALSE; // The length of the header varies, so we just go back to the original position. iseek(Pos, IL_SEEK_CUR); return iCheckDicom(&Header); }
//! Reads an already-opened IFF file ILboolean ilLoadIffF(ILHANDLE File) { ILuint FirstPos; ILboolean bRet; iSetInputFile(File); FirstPos = itell(); bRet = iLoadIffInternal(); iseek(FirstPos, IL_SEEK_SET); // Lbm files can have the .iff extension as well, so if Iff-loading failed, // try to load it as a Lbm. if (bRet == IL_FALSE) return ilLoadIlbmF(File); return bRet; }
//! Reads from a memory "lump" that contains an IFF ILboolean ilLoadIffL(const void *Lump, ILuint Size) { ILuint FirstPos; ILboolean bRet; iSetInputLump(Lump, Size); FirstPos = itell(); bRet = iLoadIffInternal(); iseek(FirstPos, IL_SEEK_SET); // Lbm files can have the .iff extension as well, so if Iff-loading failed, // try to load it as a Lbm. if (bRet == IL_FALSE) return ilLoadIlbmL(Lump, Size); return IL_TRUE; }
ILboolean iPreCache(ILuint Size) { // Reading from a memory lump, so don't cache. if (iread == iReadLump) { //iUnCache(); // DW: Removed 06-10-2002. return IL_TRUE; } if (Cache) { ifree(Cache); } if (Size == 0) { Size = 1; } Cache = (ILubyte*)ialloc(Size); if (Cache == NULL) { return IL_FALSE; } UseCache = IL_FALSE; CacheStartPos = itell(); CacheSize = iread(Cache, 1, Size); if (CacheSize != Size) ilGetError(); // Get rid of the IL_FILE_READ_ERROR. //2003-09-09: uncommented the following line to prevent //an infinite loop in ilPreCache() CacheSize = Size; CachePos = 0; UseCache = IL_TRUE; CacheBytesRead = 0; return IL_TRUE; }
// Internal function used to load the icon. ILboolean iLoadIcnsInternal() { ICNSHEAD Header; ICNSDATA Entry; ILimage *Image = NULL; ILboolean BaseCreated = IL_FALSE; if (iCurImage == NULL) { ilSetError(IL_ILLEGAL_OPERATION); return IL_FALSE; } iread(Header.Head, 4, 1); Header.Size = GetBigInt(); if (strncmp(Header.Head, "icns", 4)) // First 4 bytes have to be 'icns'. return IL_FALSE; while ((ILint)itell() < Header.Size && !ieof()) { iread(Entry.ID, 4, 1); Entry.Size = GetBigInt(); if (!strncmp(Entry.ID, "it32", 4)) // 128x128 24-bit { if (iIcnsReadData(&BaseCreated, IL_FALSE, 128, &Entry, &Image) == IL_FALSE) goto icns_error; } else if (!strncmp(Entry.ID, "t8mk", 4)) // 128x128 alpha mask { if (iIcnsReadData(&BaseCreated, IL_TRUE, 128, &Entry, &Image) == IL_FALSE) goto icns_error; } else if (!strncmp(Entry.ID, "ih32", 4)) // 48x48 24-bit { if (iIcnsReadData(&BaseCreated, IL_FALSE, 48, &Entry, &Image) == IL_FALSE) goto icns_error; } else if (!strncmp(Entry.ID, "h8mk", 4)) // 48x48 alpha mask { if (iIcnsReadData(&BaseCreated, IL_TRUE, 48, &Entry, &Image) == IL_FALSE) goto icns_error; } else if (!strncmp(Entry.ID, "il32", 4)) // 32x32 24-bit { if (iIcnsReadData(&BaseCreated, IL_FALSE, 32, &Entry, &Image) == IL_FALSE) goto icns_error; } else if (!strncmp(Entry.ID, "l8mk", 4)) // 32x32 alpha mask { if (iIcnsReadData(&BaseCreated, IL_TRUE, 32, &Entry, &Image) == IL_FALSE) goto icns_error; } else if (!strncmp(Entry.ID, "is32", 4)) // 16x16 24-bit { if (iIcnsReadData(&BaseCreated, IL_FALSE, 16, &Entry, &Image) == IL_FALSE) goto icns_error; } else if (!strncmp(Entry.ID, "s8mk", 4)) // 16x16 alpha mask { if (iIcnsReadData(&BaseCreated, IL_TRUE, 16, &Entry, &Image) == IL_FALSE) goto icns_error; } #ifndef IL_NO_JP2 else if (!strncmp(Entry.ID, "ic09", 4)) // 512x512 JPEG2000 encoded - Uses JasPer { if (iIcnsReadData(&BaseCreated, IL_FALSE, 512, &Entry, &Image) == IL_FALSE) goto icns_error; } else if (!strncmp(Entry.ID, "ic08", 4)) // 256x256 JPEG2000 encoded - Uses JasPer { if (iIcnsReadData(&BaseCreated, IL_FALSE, 256, &Entry, &Image) == IL_FALSE) goto icns_error; } #endif//IL_NO_JP2 else // Not a valid format or one that we can use { iseek(Entry.Size - 8, IL_SEEK_CUR); } } return ilFixImage(); icns_error: return IL_FALSE; }
ILboolean iLoadMdlInternal() { ILuint Id, Version, NumTex, TexOff, TexDataOff, Position, ImageNum; ILubyte *TempPal; TEX_HEAD TexHead; ILimage *BaseImage=NULL; ILboolean BaseCreated = IL_FALSE; if (iCurImage == NULL) { ilSetError(IL_ILLEGAL_OPERATION); return IL_FALSE; } Id = GetLittleUInt(); Version = GetLittleUInt(); // 0x54534449 == "IDST" if (Id != 0x54534449 || Version != 10) { ilSetError(IL_INVALID_FILE_HEADER); return IL_FALSE; } // Skips the actual model header. iseek(172, IL_SEEK_CUR); NumTex = GetLittleUInt(); TexOff = GetLittleUInt(); TexDataOff = GetLittleUInt(); if (NumTex == 0 || TexOff == 0 || TexDataOff == 0) { ilSetError(IL_ILLEGAL_FILE_VALUE); return IL_FALSE; } iseek(TexOff, IL_SEEK_SET); for (ImageNum = 0; ImageNum < NumTex; ImageNum++) { if (iread(TexHead.Name, 1, 64) != 64) return IL_FALSE; TexHead.Flags = GetLittleUInt(); TexHead.Width = GetLittleUInt(); TexHead.Height = GetLittleUInt(); TexHead.Offset = GetLittleUInt(); Position = itell(); if (TexHead.Offset == 0) { ilSetError(IL_ILLEGAL_FILE_VALUE); return IL_FALSE; } if (!BaseCreated) { ilTexImage(TexHead.Width, TexHead.Height, 1, 1, IL_COLOUR_INDEX, IL_UNSIGNED_BYTE, NULL); iCurImage->Origin = IL_ORIGIN_LOWER_LEFT; BaseCreated = IL_TRUE; BaseImage = iCurImage; //iCurImage->NumNext = NumTex - 1; // Don't count the first image. } else { //iCurImage->Next = ilNewImage(TexHead.Width, TexHead.Height, 1, 1, 1); iCurImage = iCurImage->Next; iCurImage->Format = IL_COLOUR_INDEX; iCurImage->Type = IL_UNSIGNED_BYTE; } TempPal = (ILubyte*)ialloc(768); if (TempPal == NULL) { iCurImage = BaseImage; return IL_FALSE; } iCurImage->Pal.Palette = TempPal; iCurImage->Pal.PalSize = 768; iCurImage->Pal.PalType = IL_PAL_RGB24; iseek(TexHead.Offset, IL_SEEK_SET); if (iread(iCurImage->Data, TexHead.Width * TexHead.Height, 1) != 1) return IL_FALSE; if (iread(iCurImage->Pal.Palette, 1, 768) != 768) return IL_FALSE; if (ilGetBoolean(IL_CONV_PAL) == IL_TRUE) { ilConvertImage(IL_RGB, IL_UNSIGNED_BYTE); } iseek(Position, IL_SEEK_SET); } iCurImage = BaseImage; return ilFixImage(); }
// Internal function to uncompress the .pcx (all .pcx files are rle compressed) ILboolean iUncompressPcx(PCXHEAD *Header) { //changed decompression loop 2003-09-01 //From the pcx spec: "There should always //be a decoding break at the end of each scan line. //But there will not be a decoding break at the end of //each plane within each scan line." //This is now handled correctly (hopefully ;) ) ILubyte ByteHead, Colour, *ScanLine /* For all planes */; ILuint ScanLineSize; ILuint c, i, x, y; if (Header->Bpp < 8) { /*ilSetError(IL_FORMAT_NOT_SUPPORTED); return IL_FALSE;*/ return iUncompressSmall(Header); } if (!ilTexImage(Header->Xmax - Header->Xmin + 1, Header->Ymax - Header->Ymin + 1, 1, Header->NumPlanes, 0, IL_UNSIGNED_BYTE, NULL)) return IL_FALSE; iCurImage->Origin = IL_ORIGIN_UPPER_LEFT; switch (iCurImage->Bpp) { case 1: iCurImage->Format = IL_COLOUR_INDEX; iCurImage->Pal.PalType = IL_PAL_RGB24; iCurImage->Pal.PalSize = 256 * 3; // Need to find out for sure... iCurImage->Pal.Palette = (ILubyte*)ialloc(iCurImage->Pal.PalSize); if (iCurImage->Pal.Palette == NULL) { return IL_FALSE; } break; //case 2: // No 16-bit images in the pcx format! case 3: iCurImage->Format = IL_RGB; iCurImage->Pal.Palette = NULL; iCurImage->Pal.PalSize = 0; iCurImage->Pal.PalType = IL_PAL_NONE; break; case 4: iCurImage->Format = IL_RGBA; iCurImage->Pal.Palette = NULL; iCurImage->Pal.PalSize = 0; iCurImage->Pal.PalType = IL_PAL_NONE; break; default: ilSetError(IL_ILLEGAL_FILE_VALUE); return IL_FALSE; } ScanLineSize = iCurImage->Bpp*Header->Bps; ScanLine = (ILubyte*)ialloc(ScanLineSize); if (ScanLine == NULL) { return IL_FALSE; } //changed 2003-09-01 //having the decoding code twice is error-prone, //so I made iUnCache() smart enough to grasp //if iPreCache() wasn't called and call it //anyways. if (iGetHint(IL_MEM_SPEED_HINT) == IL_FASTEST) iPreCache(iCurImage->SizeOfData / 4); for (y = 0; y < iCurImage->Height; y++) { x = 0; //read scanline while (x < ScanLineSize) { if (iread(&ByteHead, 1, 1) != 1) { iUnCache(); goto file_read_error; } if ((ByteHead & 0xC0) == 0xC0) { ByteHead &= 0x3F; if (iread(&Colour, 1, 1) != 1) { iUnCache(); goto file_read_error; } if (x + ByteHead > ScanLineSize) { iUnCache(); goto file_read_error; } for (i = 0; i < ByteHead; i++) { ScanLine[x++] = Colour; } } else { ScanLine[x++] = ByteHead; } } //convert plane-separated scanline into index, rgb or rgba pixels. //there might be a padding byte at the end of each scanline... for (x = 0; x < iCurImage->Width; x++) { for(c = 0; c < iCurImage->Bpp; c++) { iCurImage->Data[y * iCurImage->Bps + x * iCurImage->Bpp + c] = ScanLine[x + c * Header->Bps]; } } } iUnCache(); // Read in the palette if (Header->Version == 5 && iCurImage->Bpp == 1) { x = itell(); if (iread(&ByteHead, 1, 1) == 0) { // If true, assume that we have a luminance image. ilGetError(); // Get rid of the IL_FILE_READ_ERROR. iCurImage->Format = IL_LUMINANCE; if (iCurImage->Pal.Palette) ifree(iCurImage->Pal.Palette); iCurImage->Pal.PalSize = 0; iCurImage->Pal.PalType = IL_PAL_NONE; } else { if (ByteHead != 12) // Some Quake2 .pcx files don't have this byte for some reason. iseek(-1, IL_SEEK_CUR); if (iread(iCurImage->Pal.Palette, 1, iCurImage->Pal.PalSize) != iCurImage->Pal.PalSize) goto file_read_error; } } ifree(ScanLine); return IL_TRUE; file_read_error: ifree(ScanLine); //added 2003-09-01 ilSetError(IL_FILE_READ_ERROR); return IL_FALSE; }
ILboolean GetImages(ILpal *GlobalPal, GIFHEAD *GifHead) { IMAGEDESC ImageDesc, OldImageDesc; GFXCONTROL Gfx; ILboolean BaseImage = IL_TRUE; ILimage *Image = iCurImage, *TempImage = NULL; ILuint NumImages = 0, i; ILint input; Gfx.Used = IL_TRUE; while (!ieof()) { ILubyte DisposalMethod = 1; i = itell(); if (!SkipExtensions(&Gfx)) goto error_clean; i = itell(); if (!Gfx.Used) DisposalMethod = (Gfx.Packed & 0x1C) >> 2; //read image descriptor ImageDesc.Separator = igetc(); if (ImageDesc.Separator != 0x2C) //end of image break; ImageDesc.OffX = GetLittleUShort(); ImageDesc.OffY = GetLittleUShort(); ImageDesc.Width = GetLittleUShort(); ImageDesc.Height = GetLittleUShort(); ImageDesc.ImageInfo = igetc(); if (ieof()) { ilGetError(); // Gets rid of the IL_FILE_READ_ERROR that inevitably results. break; } if (!BaseImage) { NumImages++; Image->Next = ilNewImage(iCurImage->Width, iCurImage->Height, 1, 1, 1); if (Image->Next == NULL) goto error_clean; //20040612: DisposalMethod controls how the new images data is to be combined //with the old image. 0 means that it doesn't matter how they are combined, //1 means keep the old image, 2 means set to background color, 3 is //load the image that was in place before the current (this is not implemented //here! (TODO?)) if (DisposalMethod == 2 || DisposalMethod == 3) //Note that this is actually wrong, too: If the image has a local //color table, we should really search for the best fit of the //background color table and use that index (?). Furthermore, //we should only memset the part of the image that is not read //later (if we are sure that no parts of the read image are transparent). if (!Gfx.Used && Gfx.Packed & 0x1) memset(Image->Next->Data, Gfx.Transparent, Image->SizeOfData); else memset(Image->Next->Data, GifHead->Background, Image->SizeOfData); else if (DisposalMethod == 1 || DisposalMethod == 0) memcpy(Image->Next->Data, Image->Data, Image->SizeOfData); //Interlacing has to be removed after the image was copied (line above) if (OldImageDesc.ImageInfo & (1 << 6)) { // Image is interlaced. if (!RemoveInterlace(Image)) goto error_clean; } Image = Image->Next; Image->Format = IL_COLOUR_INDEX; Image->Origin = IL_ORIGIN_UPPER_LEFT; } else { BaseImage = IL_FALSE; if (!Gfx.Used && Gfx.Packed & 0x1) memset(Image->Data, Gfx.Transparent, Image->SizeOfData); else memset(Image->Data, GifHead->Background, Image->SizeOfData); //memset(Image->Data, GifHead->Background, Image->SizeOfData); } Image->OffX = ImageDesc.OffX; Image->OffY = ImageDesc.OffY; // Check to see if the image has its own palette. if (ImageDesc.ImageInfo & (1 << 7)) { if (!iGetPalette(ImageDesc.ImageInfo, &Image->Pal)) { goto error_clean; } } else { if (!iCopyPalette(&Image->Pal, GlobalPal)) { goto error_clean; } } if (!GifGetData(Image->Data + ImageDesc.OffX + ImageDesc.OffY*Image->Width, Image->SizeOfData, ImageDesc.Width, ImageDesc.Height, Image->Width, &Gfx)) { ilSetError(IL_ILLEGAL_FILE_VALUE); goto error_clean; } // See if there was a valid graphics control extension. if (!Gfx.Used) { Gfx.Used = IL_TRUE; Image->Duration = Gfx.Delay * 10; // We want it in milliseconds. // See if a transparent colour is defined. if (Gfx.Packed & 1) { if (!ConvertTransparent(Image, Gfx.Transparent)) { goto error_clean; } } } i = itell(); // Terminates each block. if((input = igetc()) == IL_EOF) goto error_clean; if (input != 0x00) iseek(-1, IL_SEEK_CUR); // break; OldImageDesc = ImageDesc; } //Deinterlace last image if (OldImageDesc.ImageInfo & (1 << 6)) { // Image is interlaced. if (!RemoveInterlace(Image)) goto error_clean; } iCurImage->NumNext = NumImages; if (BaseImage) // Was not able to load any images in... return IL_FALSE; return IL_TRUE; error_clean: Image = iCurImage->Next; while (Image) { TempImage = Image; Image = Image->Next; ilCloseImage(TempImage); } return IL_FALSE; }
ILboolean iLoadPcdInternal() { ILubyte VertOrientation; ILuint Width, Height, i, Total, x, CurPos = 0; ILubyte *Y1=NULL, *Y2=NULL, *CbCr=NULL, r = 0, g = 0, b = 0; ILuint PicNum; if (iCurImage == NULL) { ilSetError(IL_ILLEGAL_OPERATION); return IL_FALSE; } iseek(72, IL_SEEK_CUR); if (iread(&VertOrientation, 1, 1) != 1) return IL_FALSE; iseek(-72, IL_SEEK_CUR); // Can't rewind PicNum = iGetInt(IL_PCD_PICNUM); switch (PicNum) { case 0: iseek(0x02000, IL_SEEK_CUR); Width = 192; Height = 128; break; case 1: iseek(0x0b800, IL_SEEK_CUR); Width = 384; Height = 256; break; case 2: iseek(0x30000, IL_SEEK_CUR); Width = 768; Height = 512; break; default: ilSetError(IL_INVALID_PARAM); return IL_FALSE; } if (itell() == IL_EOF) // Supposed to have data here. return IL_FALSE; Y1 = (ILubyte*)ialloc(Width); Y2 = (ILubyte*)ialloc(Width); CbCr = (ILubyte*)ialloc(Width); if (Y1 == NULL || Y2 == NULL || CbCr == NULL) { ifree(Y1); ifree(Y2); ifree(CbCr); return IL_FALSE; } if (!ilTexImage(Width, Height, 1, 3, IL_RGB, IL_UNSIGNED_BYTE, NULL)) { return IL_FALSE; } iCurImage->Origin = IL_ORIGIN_LOWER_LEFT; Total = Height >> 1; for (i = 0; i < Total; i++) { iread(Y1, 1, Width); iread(Y2, 1, Width); if (iread(CbCr, 1, Width) != Width) { // Only really need to check the last one. ifree(Y1); ifree(Y2); ifree(CbCr); return IL_FALSE; } for (x = 0; x < Width; x++) { YCbCr2RGB(Y1[x], CbCr[x / 2], CbCr[(Width / 2) + (x / 2)], &r, &g, &b); iCurImage->Data[CurPos++] = r; iCurImage->Data[CurPos++] = g; iCurImage->Data[CurPos++] = b; } for (x = 0; x < Width; x++) { YCbCr2RGB(Y2[x], CbCr[x / 2], CbCr[(Width / 2) + (x / 2)], &r, &g, &b); iCurImage->Data[CurPos++] = r; iCurImage->Data[CurPos++] = g; iCurImage->Data[CurPos++] = b; } } ifree(Y1); ifree(Y2); ifree(CbCr); // Not sure how it is...the documentation is hard to understand if ((VertOrientation & 0x3F) != 8) iCurImage->Origin = IL_ORIGIN_LOWER_LEFT; else iCurImage->Origin = IL_ORIGIN_UPPER_LEFT; return ilFixImage(); }
// From the DTE sources (mostly by Denton Woods with corrections by Randy Heit) ILboolean iLoadDoomInternal() { ILshort width, height, graphic_header[2], column_loop, row_loop; ILint column_offset, pointer_position, first_pos; ILubyte post, topdelta, length; ILubyte *NewData; ILuint i; if (iCurImage == NULL) { ilSetError(IL_ILLEGAL_OPERATION); return IL_FALSE; } first_pos = itell(); // Needed to go back to the offset table width = GetLittleShort(); height = GetLittleShort(); graphic_header[0] = GetLittleShort(); // Not even used graphic_header[1] = GetLittleShort(); // Not even used if (!ilTexImage(width, height, 1, 1, IL_COLOUR_INDEX, IL_UNSIGNED_BYTE, NULL)) { return IL_FALSE; } iCurImage->Origin = IL_ORIGIN_UPPER_LEFT; iCurImage->Pal.Palette = (ILubyte*)ialloc(IL_DOOMPAL_SIZE); if (iCurImage->Pal.Palette == NULL) { return IL_FALSE; } iCurImage->Pal.PalSize = IL_DOOMPAL_SIZE; iCurImage->Pal.PalType = IL_PAL_RGB24; memcpy(iCurImage->Pal.Palette, ilDefaultDoomPal, IL_DOOMPAL_SIZE); // 247 is always the transparent colour (usually cyan) memset(iCurImage->Data, 247, iCurImage->SizeOfData); for (column_loop = 0; column_loop < width; column_loop++) { column_offset = GetLittleInt(); pointer_position = itell(); iseek(first_pos + column_offset, IL_SEEK_SET); while (1) { if (iread(&topdelta, 1, 1) != 1) return IL_FALSE; if (topdelta == 255) break; if (iread(&length, 1, 1) != 1) return IL_FALSE; if (iread(&post, 1, 1) != 1) return IL_FALSE; // Skip extra byte for scaling for (row_loop = 0; row_loop < length; row_loop++) { if (iread(&post, 1, 1) != 1) return IL_FALSE; if (row_loop + topdelta < height) iCurImage->Data[(row_loop+topdelta) * width + column_loop] = post; } iread(&post, 1, 1); // Skip extra scaling byte } iseek(pointer_position, IL_SEEK_SET); } // Converts palette entry 247 (cyan) to transparent. if (ilGetBoolean(IL_CONV_PAL) == IL_TRUE) { NewData = (ILubyte*)ialloc(iCurImage->SizeOfData * 4); if (NewData == NULL) { return IL_FALSE; } for (i = 0; i < iCurImage->SizeOfData; i++) { NewData[i * 4] = iCurImage->Pal.Palette[iCurImage->Data[i]]; NewData[i * 4] = iCurImage->Pal.Palette[iCurImage->Data[i]]; NewData[i * 4] = iCurImage->Pal.Palette[iCurImage->Data[i]]; NewData[i * 4 + 3] = iCurImage->Data[i] != 247 ? 255 : 0; } if (!ilTexImage(iCurImage->Width, iCurImage->Height, iCurImage->Depth, 4, IL_RGBA, iCurImage->Type, NewData)) { ifree(NewData); return IL_FALSE; } iCurImage->Origin = IL_ORIGIN_UPPER_LEFT; ifree(NewData); } ilFixImage(); return IL_TRUE; }
ILboolean ILAPIENTRY ilLoad(ILenum Type, const ILstring FileName) { #ifndef _UNICODE if (FileName == NULL || strlen(FileName) < 1) { #else char AnsiName[512]; if (FileName == NULL || wcslen(FileName) < 1) { #endif//_UNICODE ilSetError(IL_INVALID_PARAM); return IL_FALSE; } switch (Type) { case IL_TYPE_UNKNOWN: return ilLoadImage(FileName); #ifndef IL_NO_TGA case IL_TGA: return ilLoadTarga(FileName); #endif #ifndef IL_NO_JPG case IL_JPG: return ilLoadJpeg(FileName); #endif #ifndef IL_NO_DDS case IL_DDS: return ilLoadDds(FileName); #endif #ifndef IL_NO_PNG case IL_PNG: return ilLoadPng(FileName); #endif #ifndef IL_NO_BMP case IL_BMP: return ilLoadBmp(FileName); #endif #ifndef IL_NO_GIF case IL_GIF: return ilLoadGif(FileName); #endif #ifndef IL_NO_HDR case IL_HDR: return ilLoadHdr(FileName); #endif #ifndef IL_NO_CUT case IL_CUT: return ilLoadCut(FileName); #endif #ifndef IL_NO_DOOM case IL_DOOM: return ilLoadDoom(FileName); case IL_DOOM_FLAT: return ilLoadDoomFlat(FileName); #endif #ifndef IL_NO_ICO case IL_ICO: return ilLoadIcon(FileName); #endif #ifndef IL_NO_LIF case IL_LIF: return ilLoadLif(FileName); #endif #ifndef IL_NO_MDL case IL_MDL: return ilLoadMdl(FileName); #endif #ifndef IL_NO_MNG case IL_MNG: return ilLoadMng(FileName); #endif #ifndef IL_NO_PCD case IL_PCD: return IL_FALSE;//ilLoadPcd(FileName); #endif #ifndef IL_NO_PCX case IL_PCX: return ilLoadPcx(FileName); #endif #ifndef IL_NO_PIC case IL_PIC: return ilLoadPic(FileName); #endif #ifndef IL_NO_PIX case IL_PIX: return ilLoadPix(FileName); #endif #ifndef IL_NO_PNM case IL_PNM: return ilLoadPnm(FileName); #endif #ifndef IL_NO_PSD case IL_PSD: return ilLoadPsd(FileName); #endif #ifndef IL_NO_PSP case IL_PSP: return ilLoadPsp(FileName); #endif #ifndef IL_NO_PXR case IL_PXR: return ilLoadPxr(FileName); #endif #ifndef IL_NO_RAW case IL_RAW: return ilLoadRaw(FileName); #endif #ifndef IL_NO_SGI case IL_SGI: return ilLoadSgi(FileName); #endif #ifndef IL_NO_TIF case IL_TIF: #ifndef _UNICODE return ilLoadTiff(FileName); #else wcstombs(AnsiName, FileName, 512); //WideCharToMultiByte(CP_ACP, 0, FileName, -1, AnsiName, 512, NULL, NULL); return ilLoadTiff(AnsiName); #endif//_UNICODE #endif #ifndef IL_NO_WAL case IL_WAL: return ilLoadWal(FileName); #endif #ifndef IL_NO_XPM case IL_XPM: return ilLoadXpm(FileName); #endif } ilSetError(IL_INVALID_ENUM); return IL_FALSE; } ILboolean ILAPIENTRY ilLoadF(ILenum Type, ILHANDLE File) { if (File == NULL) { ilSetError(IL_INVALID_PARAM); return IL_FALSE; } if (Type == IL_TYPE_UNKNOWN) Type = ilDetermineTypeF(File); switch (Type) { case IL_TYPE_UNKNOWN: return IL_FALSE; #ifndef IL_NO_TGA case IL_TGA: return ilLoadTargaF(File); #endif #ifndef IL_NO_JPG #ifndef IL_USE_IJL case IL_JPG: return ilLoadJpegF(File); #endif #endif #ifndef IL_NO_DDS case IL_DDS: return ilLoadDdsF(File); #endif #ifndef IL_NO_PNG case IL_PNG: return ilLoadPngF(File); #endif #ifndef IL_NO_BMP case IL_BMP: return ilLoadBmpF(File); #endif #ifndef IL_NO_GIF case IL_GIF: return ilLoadGifF(File); #endif #ifndef IL_NO_HDR case IL_HDR: return ilLoadHdrF(File); #endif #ifndef IL_NO_CUT case IL_CUT: return ilLoadCutF(File); #endif #ifndef IL_NO_DOOM case IL_DOOM: return ilLoadDoomF(File); case IL_DOOM_FLAT: return ilLoadDoomFlatF(File); #endif #ifndef IL_NO_ICO case IL_ICO: return ilLoadIconF(File); #endif #ifndef IL_NO_LIF case IL_LIF: return ilLoadLifF(File); #endif #ifndef IL_NO_MDL case IL_MDL: return ilLoadMdlF(File); #endif #ifndef IL_NO_MNG case IL_MNG: return ilLoadMngF(File); #endif #ifndef IL_NO_PCD case IL_PCD: return IL_FALSE;//return ilLoadPcdF(File); #endif #ifndef IL_NO_PCX case IL_PCX: return ilLoadPcxF(File); #endif #ifndef IL_NO_PIC case IL_PIC: return ilLoadPicF(File); #endif #ifndef IL_NO_PIX case IL_PIX: return ilLoadPixF(File); #endif #ifndef IL_NO_PNM case IL_PNM: return ilLoadPnmF(File); #endif #ifndef IL_NO_PSD case IL_PSD: return ilLoadPsdF(File); #endif #ifndef IL_NO_PSP case IL_PSP: return ilLoadPspF(File); #endif #ifndef IL_NO_PXR case IL_PXR: return ilLoadPxrF(File); #endif #ifndef IL_NO_RAW case IL_RAW: return ilLoadRawF(File); #endif #ifndef IL_NO_SGI case IL_SGI: return ilLoadSgiF(File); #endif #ifndef IL_NO_TIF case IL_TIF: return ilLoadTiffF(File); #endif #ifndef IL_NO_WAL case IL_WAL: return ilLoadWalF(File); #endif #ifndef IL_NO_XPM case IL_XPM: return ilLoadXpmF(File); #endif } ilSetError(IL_INVALID_ENUM); return IL_FALSE; } ILboolean ILAPIENTRY ilLoadL(ILenum Type, const ILvoid *Lump, ILuint Size) { if (Lump == NULL || Size == 0) { ilSetError(IL_INVALID_PARAM); return IL_FALSE; } if (Type == IL_TYPE_UNKNOWN) Type = ilDetermineTypeL(Lump, Size); switch (Type) { case IL_TYPE_UNKNOWN: return IL_FALSE; #ifndef IL_NO_TGA case IL_TGA: return ilLoadTargaL(Lump, Size); #endif #ifndef IL_NO_JPG case IL_JPG: return ilLoadJpegL(Lump, Size); #endif #ifndef IL_NO_DDS case IL_DDS: return ilLoadDdsL(Lump, Size); #endif #ifndef IL_NO_PNG case IL_PNG: return ilLoadPngL(Lump, Size); #endif #ifndef IL_NO_BMP case IL_BMP: return ilLoadBmpL(Lump, Size); #endif #ifndef IL_NO_GIF case IL_GIF: return ilLoadGifL(Lump, Size); #endif #ifndef IL_NO_HDR case IL_HDR: return ilLoadHdrL(Lump, Size); #endif #ifndef IL_NO_CUT case IL_CUT: return ilLoadCutL(Lump, Size); #endif #ifndef IL_NO_DOOM case IL_DOOM: return ilLoadDoomL(Lump, Size); case IL_DOOM_FLAT: return ilLoadDoomFlatL(Lump, Size); #endif #ifndef IL_NO_ICO case IL_ICO: return ilLoadIconL(Lump, Size); #endif #ifndef IL_NO_LIF case IL_LIF: return ilLoadLifL(Lump, Size); #endif #ifndef IL_NO_MDL case IL_MDL: return ilLoadMdlL(Lump, Size); #endif #ifndef IL_NO_MNG case IL_MNG: return ilLoadMngL(Lump, Size); #endif #ifndef IL_NO_PCD case IL_PCD: return IL_FALSE;//return ilLoadPcdL(Lump, Size); #endif #ifndef IL_NO_PCX case IL_PCX: return ilLoadPcxL(Lump, Size); #endif #ifndef IL_NO_PIC case IL_PIC: return ilLoadPicL(Lump, Size); #endif #ifndef IL_NO_PIX case IL_PIX: return ilLoadPixL(Lump, Size); #endif #ifndef IL_NO_PNM case IL_PNM: return ilLoadPnmL(Lump, Size); #endif #ifndef IL_NO_PSD case IL_PSD: return ilLoadPsdL(Lump, Size); #endif #ifndef IL_NO_PSP case IL_PSP: return ilLoadPspL(Lump, Size); #endif #ifndef IL_NO_PXR case IL_PXR: return ilLoadPxrL(Lump, Size); #endif #ifndef IL_NO_RAW case IL_RAW: return ilLoadRawL(Lump, Size); #endif #ifndef IL_NO_SGI case IL_SGI: return ilLoadSgiL(Lump, Size); #endif #ifndef IL_NO_TIF case IL_TIF: return ilLoadTiffL(Lump, Size); #endif #ifndef IL_NO_WAL case IL_WAL: return ilLoadWalL(Lump, Size); #endif #ifndef IL_NO_XPM case IL_XPM: return ilLoadXpmL(Lump, Size); #endif } ilSetError(IL_INVALID_ENUM); return IL_FALSE; } //! Attempts to load an image with various different methods before failing - very generic. ILboolean ILAPIENTRY ilLoadImage(const ILstring FileName) { ILstring Ext = iGetExtension(FileName); ILenum Type; if (iCurImage == NULL) { ilSetError(IL_ILLEGAL_OPERATION); return IL_FALSE; } #ifndef _UNICODE if (FileName == NULL || strlen(FileName) < 1) { #else if (FileName == NULL || wcslen(FileName) < 1) { #endif//_UNICODE ilSetError(IL_INVALID_PARAM); return IL_FALSE; } // Try registered procedures first (so users can override default lib functions). if (Ext) { if (iRegisterLoad(FileName)) return IL_TRUE; #ifndef IL_NO_TGA if (!iStrCmp(Ext, IL_TEXT("tga")) || !iStrCmp(Ext, IL_TEXT("vda")) || !iStrCmp(Ext, IL_TEXT("icb")) || !iStrCmp(Ext, IL_TEXT("vst"))) { return ilLoadTarga(FileName); } #endif #ifndef IL_NO_JPG if (!iStrCmp(Ext, IL_TEXT("jpg")) || !iStrCmp(Ext, IL_TEXT("jpe")) || !iStrCmp(Ext, IL_TEXT("jpeg"))) { return ilLoadJpeg(FileName); } #endif #ifndef IL_NO_DDS if (!iStrCmp(Ext, IL_TEXT("dds"))) { return ilLoadDds(FileName); } #endif #ifndef IL_NO_PNG if (!iStrCmp(Ext, IL_TEXT("png"))) { return ilLoadPng(FileName); } #endif #ifndef IL_NO_BMP if (!iStrCmp(Ext, IL_TEXT("bmp")) || !iStrCmp(Ext, IL_TEXT("dib"))) { return ilLoadBmp(FileName); } #endif #ifndef IL_NO_GIF if (!iStrCmp(Ext, IL_TEXT("gif"))) { return ilLoadGif(FileName); } #endif #ifndef IL_NO_HDR if (!iStrCmp(Ext, IL_TEXT("hdr"))) { return ilLoadHdr(FileName); } #endif #ifndef IL_NO_CUT if (!iStrCmp(Ext, IL_TEXT("cut"))) { return ilLoadCut(FileName); } #endif #ifndef IL_NO_DCX if (!iStrCmp(Ext, IL_TEXT("dcx"))) { return ilLoadDcx(FileName); } #endif #ifndef IL_NO_ICO if (!iStrCmp(Ext, IL_TEXT("ico")) || !iStrCmp(Ext, IL_TEXT("cur"))) { return ilLoadIcon(FileName); } #endif #ifndef IL_NO_LIF if (!iStrCmp(Ext, IL_TEXT("lif"))) { return ilLoadLif(FileName); } #endif #ifndef IL_NO_MDL if (!iStrCmp(Ext, IL_TEXT("mdl"))) { return ilLoadMdl(FileName); } #endif #ifndef IL_NO_MNG if (!iStrCmp(Ext, IL_TEXT("mng")) || !iStrCmp(Ext, IL_TEXT("jng"))) { return ilLoadMng(FileName); } #endif #ifndef IL_NO_PCD if (!iStrCmp(Ext, IL_TEXT("pcd"))) { return IL_FALSE;//return ilLoadPcd(FileName); } #endif #ifndef IL_NO_PCX if (!iStrCmp(Ext, IL_TEXT("pcx"))) { return ilLoadPcx(FileName); } #endif #ifndef IL_NO_PIC if (!iStrCmp(Ext, IL_TEXT("pic"))) { return ilLoadPic(FileName); } #endif #ifndef IL_NO_PIX if (!iStrCmp(Ext, IL_TEXT("pix"))) { return ilLoadPix(FileName); } #endif #ifndef IL_NO_PNM if (!iStrCmp(Ext, IL_TEXT("pbm"))) { return ilLoadPnm(FileName); } if (!iStrCmp(Ext, IL_TEXT("pgm"))) { return ilLoadPnm(FileName); } if (!iStrCmp(Ext, IL_TEXT("pnm"))) { return ilLoadPnm(FileName); } if (!iStrCmp(Ext, IL_TEXT("ppm"))) { return ilLoadPnm(FileName); } #endif #ifndef IL_NO_PSD if (!iStrCmp(Ext, IL_TEXT("psd")) || !iStrCmp(Ext, IL_TEXT("pdd"))) { return ilLoadPsd(FileName); } #endif #ifndef IL_NO_PSP if (!iStrCmp(Ext, IL_TEXT("psp"))) { return ilLoadPsp(FileName); } #endif #ifndef IL_NO_PXR if (!iStrCmp(Ext, IL_TEXT("pxr"))) { return ilLoadPxr(FileName); } #endif #ifndef IL_NO_SGI if (!iStrCmp(Ext, IL_TEXT("sgi")) || !iStrCmp(Ext, IL_TEXT("bw")) || !iStrCmp(Ext, IL_TEXT("rgb")) || !iStrCmp(Ext, IL_TEXT("rgba"))) { return ilLoadSgi(FileName); } #endif #ifndef IL_NO_TIF if (!iStrCmp(Ext, IL_TEXT("tif")) || !iStrCmp(Ext, IL_TEXT("tiff"))) { return ilLoadTiff(FileName); } #endif #ifndef IL_NO_WAL if (!iStrCmp(Ext, IL_TEXT("wal"))) { return ilLoadWal(FileName); } #endif #ifndef IL_NO_XPM if (!iStrCmp(Ext, IL_TEXT("xpm"))) { return ilLoadXpm(FileName); } #endif } // As a last-ditch effort, try to identify the image Type = ilDetermineType(FileName); if (Type == IL_TYPE_UNKNOWN) return IL_FALSE; return ilLoad(Type, FileName); } ILboolean ILAPIENTRY ilSave(ILenum Type, ILstring FileName) { switch (Type) { case IL_TYPE_UNKNOWN: return ilSaveImage(FileName); #ifndef IL_NO_BMP case IL_BMP: return ilSaveBmp(FileName); #endif #ifndef IL_NO_CHEAD case IL_CHEAD: return ilSaveCHeader(FileName, "IL_IMAGE"); #endif #ifndef IL_NO_JPG case IL_JPG: return ilSaveJpeg(FileName); #endif #ifndef IL_NO_PCX case IL_PCX: return ilSavePcx(FileName); #endif #ifndef IL_NO_PNG case IL_PNG: return ilSavePng(FileName); #endif #ifndef IL_NO_PNM case IL_PNM: return ilSavePnm(FileName); #endif #ifndef IL_NO_PSD case IL_PSD: return ilSavePsd(FileName); #endif #ifndef IL_NO_RAW case IL_RAW: return ilSaveRaw(FileName); #endif #ifndef IL_NO_SGI case IL_SGI: return ilSaveSgi(FileName); #endif #ifndef IL_NO_TGA case IL_TGA: return ilSaveTarga(FileName); #endif #ifndef IL_NO_TIF case IL_TIF: return ilSaveTiff(FileName); #endif case IL_JASC_PAL: return ilSaveJascPal(FileName); } ilSetError(IL_INVALID_ENUM); return IL_FALSE; } ILuint ILAPIENTRY ilSaveF(ILenum Type, ILHANDLE File) { ILboolean Ret; if (File == NULL) { ilSetError(IL_INVALID_PARAM); return 0; } switch (Type) { #ifndef IL_NO_BMP case IL_BMP: Ret = ilSaveBmpF(File); break; #endif #ifndef IL_NO_JPG #ifndef IL_USE_IJL case IL_JPG: Ret = ilSaveJpegF(File); break; #endif #endif #ifndef IL_NO_PNM case IL_PNM: Ret = ilSavePnmF(File); break; #endif #ifndef IL_NO_PNG case IL_PNG: Ret = ilSavePngF(File); break; #endif #ifndef IL_NO_PSD case IL_PSD: Ret = ilSavePsdF(File); break; #endif #ifndef IL_NO_RAW case IL_RAW: Ret = ilSaveRawF(File); break; #endif #ifndef IL_NO_SGI case IL_SGI: Ret = ilSaveSgiF(File); break; #endif #ifndef IL_NO_TGA case IL_TGA: Ret = ilSaveTargaF(File); break; #endif /*#ifndef IL_NO_TIF case IL_TIF: Ret = ilSaveTiffF(File); break; #endif*/ default: ilSetError(IL_INVALID_ENUM); return 0; } if (Ret == IL_FALSE) return 0; return itell(); }
// Internal function used to load the UTX. ILboolean iLoadUtxInternal(void) { UTXHEADER Header; UTXENTRYNAME *NameEntries; UTXEXPORTTABLE *ExportTable; UTXIMPORTTABLE *ImportTable; UTXPALETTE *Palettes; ILimage *Image; ILuint NumPal = 0, i, j = 0; ILint Name; ILubyte Type; ILint Val; ILint Size; ILint Width, Height, PalEntry; ILboolean BaseCreated = IL_FALSE, HasPal; ILuint Pos; ILint Format; ILubyte *CompData = NULL; ILubyte ExtraData[9]; if (iCurImage == NULL) { ilSetError(IL_ILLEGAL_OPERATION); return IL_FALSE; } if (!GetUtxHead(&Header)) return IL_FALSE; if (!CheckUtxHead(&Header)) return IL_FALSE; // Now we grab the name table. NameEntries = GetUtxNameTable(&Header); if (NameEntries == NULL) return IL_FALSE; // Then we get the export table. ExportTable = GetUtxExportTable(&Header); if (ExportTable == NULL) { UtxDestroyNameEntries(NameEntries, &Header); return IL_FALSE; } // Then the last table is the import table. ImportTable = GetUtxImportTable(&Header); if (ImportTable == NULL) { UtxDestroyNameEntries(NameEntries, &Header); UtxDestroyExportTable(ExportTable, &Header); return IL_FALSE; } for (i = 0; i < Header.ExportCount; i++) { if (!strcmp(NameEntries[ImportTable[ExportTable[i].Class].ObjectName].Name, "Palette")) NumPal++; } if (NumPal == 0) //@TODO: Take care of UTX files without paletted data. return IL_FALSE; Palettes = (UTXPALETTE*)ialloc(NumPal * sizeof(UTXPALETTE)); if (Palettes == NULL) { UtxDestroyNameEntries(NameEntries, &Header); UtxDestroyExportTable(ExportTable, &Header); UtxDestroyImportTable(ImportTable, &Header); return IL_FALSE; } NumPal = 0; for (i = 0; i < Header.ExportCount; i++) { if (!strcmp(NameEntries[ImportTable[ExportTable[i].Class].ObjectName].Name, "Palette")) { //Palettes[i].Name = strdup(NameEntries[ExportTable[i].ObjectName].Name); Palettes[NumPal].Name = i;//ExportTable[i].ObjectName; iseek(ExportTable[NumPal].SerialOffset, IL_SEEK_SET); Name = igetc(); // Skip the 2. Palettes[NumPal].Count = UtxReadCompactInteger(); Palettes[NumPal].Pal = (ILubyte*)ialloc(Palettes[NumPal].Count * 4); if (/*Palettes[NumPal].Name == NULL || */Palettes[NumPal].Pal == NULL) { UtxDestroyNameEntries(NameEntries, &Header); UtxDestroyExportTable(ExportTable, &Header); UtxDestroyImportTable(ImportTable, &Header); UtxDestroyPalettes(Palettes, NumPal); return IL_FALSE; } if (iread(Palettes[NumPal].Pal, Palettes[NumPal].Count * 4, 1) != 1) //@TODO: Deallocations here! return IL_FALSE; NumPal++; } } for (i = 0; i < Header.ExportCount; i++) { if (!strcmp(NameEntries[ImportTable[ExportTable[i].Class].ObjectName].Name, "Texture")) { iseek(ExportTable[i].SerialOffset, IL_SEEK_SET); Width = -1; Height = -1; PalEntry = NumPal; HasPal = IL_FALSE; Format = -1; ++j; j = j; do { Pos = itell(); Name = UtxReadCompactInteger(); if (!strcmp(NameEntries[Name].Name, "None")) break; Type = igetc(); Size = (Type & 0x70) >> 4; if (/*Name == 0 && */Type == 0xA2) igetc(); // Byte is 1 here... switch (Type & 0x0F) { case 1: Val = igetc(); break; case 2: Val = GetLittleUInt(); break; case 3: // Boolean value is in the info byte. igetc(); break; case 4: GetLittleFloat(); break; case 5: case 6: Val = itell(); Val = UtxReadCompactInteger(); break; case 10: Val = igetc(); switch (Size) { case 0: iseek(1, IL_SEEK_CUR); break; case 1: iseek(2, IL_SEEK_CUR); break; case 2: iseek(4, IL_SEEK_CUR); break; case 3: iseek(12, IL_SEEK_CUR); break; } break; default: // Uhm... Val = Val; break; } //@TODO: What should we do if Name >= Header.NameCount? if ((ILuint)Name < Header.NameCount) { if (!strcmp(NameEntries[Name].Name, "Palette")) { Val--; if (HasPal == IL_FALSE) { for (PalEntry = 0; (ILuint)PalEntry < NumPal; PalEntry++) { if (Val == Palettes[PalEntry].Name) { HasPal = IL_TRUE; break; } } } } if (!strcmp(NameEntries[Name].Name, "Format")) if (Format == -1) Format = Val; if (!strcmp(NameEntries[Name].Name, "USize")) if (Width == -1) Width = Val; if (!strcmp(NameEntries[Name].Name, "VSize")) if (Height == -1) Height = Val; } } while (!ieof()); if (Format == -1) Format = UTX_P8; if (Width == -1 || Height == -1 || (PalEntry == NumPal && Format != UTX_DXT1) || (Format != UTX_P8 && Format != UTX_DXT1)) return IL_FALSE; if (BaseCreated == IL_FALSE) { BaseCreated = IL_TRUE; ilTexImage(Width, Height, 1, UtxFormatToBpp(Format), UtxFormatToDevIL(Format), IL_UNSIGNED_BYTE, NULL); Image = iCurImage; } else { Image->Next = ilNewImageFull(Width, Height, 1, UtxFormatToBpp(Format), UtxFormatToDevIL(Format), IL_UNSIGNED_BYTE, NULL); if (Image->Next == NULL) return IL_FALSE; Image = Image->Next; } iseek(5, IL_SEEK_CUR); UtxReadCompactInteger(); switch (Format) { case UTX_P8: Image->Pal.PalSize = Palettes[PalEntry].Count * 4; Image->Pal.Palette = (ILubyte*)ialloc(Image->Pal.PalSize); if (Image->Pal.Palette == NULL) //@TODO: Do all the deallocations needed here! return IL_FALSE; memcpy(Image->Pal.Palette, Palettes[PalEntry].Pal, Image->Pal.PalSize); Image->Pal.PalType = IL_PAL_RGBA32; if (iread(Image->Data, Image->SizeOfData, 1) != 1) return IL_FALSE; //@TODO: Deallocations... break; case UTX_DXT1: // // // HACK!!! // // //igetc(); //ExtraData[0] = igetc(); //if (ExtraData[0] == 0x0C) //iseek(8, IL_SEEK_CUR); // iread(ExtraData+1, 8, 1); //else //iseek(7, IL_SEEK_CUR); // iread(ExtraData+1, 7, 1); //if (igetc() == 0x80) // igetc(); Image->DxtcSize = IL_MAX(Image->Width * Image->Height / 2, 8); CompData = (ILubyte*)ialloc(Image->DxtcSize); if (CompData == NULL) //@TODO: Do all the deallocations needed here! return IL_FALSE; if (iread(CompData, Image->DxtcSize, 1) != 1) { ifree(CompData); return IL_FALSE; //@TODO: Deallocations... } // Keep a copy of the DXTC data if the user wants it. if (ilGetInteger(IL_KEEP_DXTC_DATA) == IL_TRUE) { Image->DxtcData = CompData; Image->DxtcFormat = IL_DXT1; CompData = NULL; } if (DecompressDXT1(Image, CompData) == IL_FALSE) { ifree(CompData); return IL_FALSE; } ifree(CompData); break; } Image->Origin = IL_ORIGIN_UPPER_LEFT; } }