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(); }
ILboolean iLoadBlp1() { BLP1HEAD Header; ILubyte *DataAndAlpha, *Palette; ILuint i; ILimage *Image = iCurImage; ILboolean BaseCreated = IL_FALSE; #ifndef IL_NO_JPG ILubyte *JpegHeader, *JpegData; ILuint JpegHeaderSize; #endif//IL_NO_JPG if (!iGetBlp1Head(&Header)) return IL_FALSE; if (!iCheckBlp1(&Header)) { ilSetError(IL_INVALID_FILE_HEADER); return IL_FALSE; } //@TODO: Remove this. i = 0; switch (Header.Compression) { case BLP_TYPE_JPG: #ifdef IL_NO_JPG // We can only do the Jpeg decoding if we do not have IL_NO_JPEG defined. return IL_FALSE; #else JpegHeaderSize = GetLittleUInt(); JpegHeader = (ILubyte*)ialloc(JpegHeaderSize); if (JpegHeader == NULL) return IL_FALSE; // Read the shared Jpeg header. if (iread(JpegHeader, 1, JpegHeaderSize) != JpegHeaderSize) { ifree(JpegHeader); return IL_FALSE; } //for (i = 0; i < 16; i++) { // Possible maximum of 16 mipmaps //@TODO: Check return value? iseek(Header.MipOffsets[i], IL_SEEK_SET); JpegData = (ILubyte*)ialloc(JpegHeaderSize + Header.MipLengths[i]); if (JpegData == NULL) { ifree(JpegHeader); return IL_FALSE; } memcpy(JpegData, JpegHeader, JpegHeaderSize); if (iread(JpegData + JpegHeaderSize, Header.MipLengths[i], 1) != 1) return IL_FALSE; // Just send the data straight to the Jpeg loader. if (!ilLoadJpegL(JpegData, JpegHeaderSize + Header.MipLengths[i])) return IL_FALSE; // The image data is in BGR(A) order, even though it is Jpeg-compressed. if (Image->Format == IL_RGBA) Image->Format = IL_BGRA; if (Image->Format == IL_RGB) Image->Format = IL_BGR; ifree(JpegData); //} ifree(JpegHeader); #endif//IL_NO_JPG break; case BLP_RAW: switch (Header.PictureType) { // There is no alpha list, so we just read like a normal indexed image. case BLP_RAW_NO_ALPHA: for (i = 0; i < 16; i++) { // Possible maximum of 16 mipmaps if (!BaseCreated) { // Have not created the base image yet, so use ilTexImage. if (!ilTexImage(Header.Width, Header.Height, 1, 1, IL_COLOUR_INDEX, IL_UNSIGNED_BYTE, NULL)) return IL_FALSE; Image = iCurImage; BaseCreated = IL_TRUE; // We have a BGRA palette. Image->Pal.Palette = (ILubyte*)ialloc(256 * 4); if (Image->Pal.Palette == NULL) return IL_FALSE; Image->Pal.PalSize = 1024; Image->Pal.PalType = IL_PAL_BGRA32; // Read in the palette ... if (iread(Image->Pal.Palette, 1, 1024) != 1024) return IL_FALSE; } else { if (Image->Width == 1 && Image->Height == 1) // Already at the smallest mipmap (1x1), so we are done. break; if (Header.MipOffsets[i] == 0 || Header.MipLengths[i] == 0) // No more mipmaps in the file. break; Image->Mipmaps = ilNewImageFull(Image->Width >> 1, Image->Height >> 1, 1, 1, IL_COLOR_INDEX, IL_UNSIGNED_BYTE, NULL); if (Image->Mipmaps == NULL) return IL_FALSE; // Copy the palette from the first image before we change our Image pointer. Image->Mipmaps->Pal.Palette = (ILubyte*)ialloc(256 * 4); if (Image->Mipmaps->Pal.Palette == NULL) return IL_FALSE; Image->Mipmaps->Pal.PalSize = 1024; Image->Mipmaps->Pal.PalType = IL_PAL_BGRA32; memcpy(Image->Mipmaps->Pal.Palette, Image->Pal.Palette, 1024); // Move to the next mipmap in the linked list. Image = Image->Mipmaps; } // The origin should be in the upper left. Image->Origin = IL_ORIGIN_UPPER_LEFT; // Seek to the data and read it. iseek(Header.MipOffsets[i], IL_SEEK_SET); if (iread(Image->Data, 1, Image->SizeOfData) != Image->SizeOfData) return IL_FALSE; } break; // These cases are identical and have an alpha list following the image data. case BLP_RAW_PLUS_ALPHA1: case BLP_RAW_PLUS_ALPHA2: // Create the image. if (!ilTexImage(Header.Width, Header.Height, 1, 4, IL_BGRA, IL_UNSIGNED_BYTE, NULL)) return IL_FALSE; DataAndAlpha = (ILubyte*)ialloc(Header.Width * Header.Height); Palette = (ILubyte*)ialloc(256 * 4); if (DataAndAlpha == NULL || Palette == NULL) { ifree(DataAndAlpha); ifree(Palette); return IL_FALSE; } // Read in the data and the palette. if (iread(Palette, 1, 1024) != 1024) { ifree(Palette); return IL_FALSE; } // Seek to the data and read it. iseek(Header.MipOffsets[i], IL_SEEK_SET); if (iread(DataAndAlpha, Header.Width * Header.Height, 1) != 1) { ifree(DataAndAlpha); ifree(Palette); return IL_FALSE; } // Convert the color-indexed data to BGRX. for (i = 0; i < Header.Width * Header.Height; i++) { Image->Data[i*4] = Palette[DataAndAlpha[i]*4]; Image->Data[i*4+1] = Palette[DataAndAlpha[i]*4+1]; Image->Data[i*4+2] = Palette[DataAndAlpha[i]*4+2]; } // Read in the alpha list. if (iread(DataAndAlpha, Header.Width * Header.Height, 1) != 1) { ifree(DataAndAlpha); ifree(Palette); return IL_FALSE; } // Finally put the alpha data into the image data. for (i = 0; i < Header.Width * Header.Height; i++) { Image->Data[i*4+3] = DataAndAlpha[i]; } ifree(DataAndAlpha); ifree(Palette); break; } break; //default: // Should already be checked by iCheckBlp1. } // Set the origin (always upper left). Image->Origin = IL_ORIGIN_UPPER_LEFT; return ilFixImage(); }