- Main Page
- Data Structures
- Files

- File List

# E:/DevIL/src-IL/src/il_io.c

    00001 //-----------------------------------------------------------------------------
    00002 //
    00003 // ImageLib Sources
    00004 // Copyright (C) 2000-2009 by Denton Woods
    00005 // Last modified: 01/24/2009
    00006 //
    00007 // Filename: src-IL/src/il_io.c
    00008 //
    00009 // Description: Determines image types and loads images
    00010 //
    00011 //-----------------------------------------------------------------------------
    00012
    00013 #include "il_internal.h"
    00014 #include "il_register.h"
    00015 #include "il_pal.h"
    00016 #include <string.h>
    00017
    00018
    00019 // Returns a widened version of a string.
    00020 // Make sure to free this after it is used.  Code help from
    00021 //  https://buildsecurityin.us-cert.gov/daisy/bsi-rules/home/g1/769-BSI.html
    00022 #if defined(_UNICODE)
    00023 wchar_t *WideFromMultiByte(const char *Multi)
    00024 {
    00025         ILint   Length;
    00026         wchar_t *Temp;
    00027
    00028         Length = (ILint)mbstowcs(NULL, (const char*)Multi, 0) + 1; // note error return of -1 is possible
    00029         if (Length == 0) {
    00030                 ilSetError(IL_INVALID_PARAM);
    00031                 return NULL;
    00032         }
    00033         if (Length > ULONG_MAX/sizeof(wchar_t)) {
    00034                 ilSetError(IL_INTERNAL_ERROR);
    00035                 return NULL;
    00036         }
    00037         Temp = (wchar_t*)ialloc(Length * sizeof(wchar_t));
    00038         mbstowcs(Temp, (const char*)Multi, Length);
    00039
    00040         return Temp;
    00041 }
    00042 #endif
    00043
    00044
    00045 ILenum ILAPIENTRY ilTypeFromExt(ILconst_string FileName)
    00046 {
    00047         ILenum          Type;
    00048         ILstring        Ext;
    00049
    00050         if (FileName == NULL || ilStrLen(FileName) < 1) {
    00051                 ilSetError(IL_INVALID_PARAM);
    00052                 return IL_TYPE_UNKNOWN;
    00053         }
    00054
    00055         Ext = iGetExtension(FileName);
    00056         //added 2003-08-31: fix sf bug 789535
    00057         if (Ext == NULL) {
    00058                 return IL_TYPE_UNKNOWN;
    00059         }
    00060
    00061         if (!iStrCmp(Ext, IL_TEXT("tga")) || !iStrCmp(Ext, IL_TEXT("vda")) ||
    00062                 !iStrCmp(Ext, IL_TEXT("icb")) || !iStrCmp(Ext, IL_TEXT("vst")))
    00063                 Type = IL_TGA;
    00064         else if (!iStrCmp(Ext, IL_TEXT("jpg")) || !iStrCmp(Ext, IL_TEXT("jpe")) || !iStrCmp(Ext, IL_TEXT("jpeg")))
    00065                 Type = IL_JPG;
    00066         else if (!iStrCmp(Ext, IL_TEXT("jp2")))
    00067                 Type = IL_JP2;
    00068         else if (!iStrCmp(Ext, IL_TEXT("dds")))
    00069                 Type = IL_DDS;
    00070         else if (!iStrCmp(Ext, IL_TEXT("exr")))
    00071                 Type = IL_EXR;
    00072         else if (!iStrCmp(Ext, IL_TEXT("png")))
    00073                 Type = IL_PNG;
    00074         else if (!iStrCmp(Ext, IL_TEXT("bmp")) || !iStrCmp(Ext, IL_TEXT("dib")))
    00075                 Type = IL_BMP;
    00076         else if (!iStrCmp(Ext, IL_TEXT("gif")))
    00077                 Type = IL_GIF;
    00078         else if (!iStrCmp(Ext, IL_TEXT("cut")))
    00079                 Type = IL_CUT;
    00080         else if (!iStrCmp(Ext, IL_TEXT("hdr")))
    00081                 Type = IL_HDR;
    00082         else if (!iStrCmp(Ext, IL_TEXT("iff")))
    00083                 Type = IL_IFF;
    00084         else if (!iStrCmp(Ext, IL_TEXT("ico")) || !iStrCmp(Ext, IL_TEXT("cur")))
    00085                 Type = IL_ICO;
    00086         else if (!iStrCmp(Ext, IL_TEXT("icns")))
    00087                 Type = IL_ICNS;
    00088         else if (!iStrCmp(Ext, IL_TEXT("jng")))
    00089                 Type = IL_JNG;
    00090         else if (!iStrCmp(Ext, IL_TEXT("lif")))
    00091                 Type = IL_LIF;
    00092         else if (!iStrCmp(Ext, IL_TEXT("mdl")))
    00093                 Type = IL_MDL;
    00094         else if (!iStrCmp(Ext, IL_TEXT("mng")) || !iStrCmp(Ext, IL_TEXT("jng")))
    00095                 Type = IL_MNG;
    00096         else if (!iStrCmp(Ext, IL_TEXT("pcd")))
    00097                 Type = IL_PCD;
    00098         else if (!iStrCmp(Ext, IL_TEXT("pcx")))
    00099                 Type = IL_PCX;
    00100         else if (!iStrCmp(Ext, IL_TEXT("pic")))
    00101                 Type = IL_PIC;
    00102         else if (!iStrCmp(Ext, IL_TEXT("pix")))
    00103                 Type = IL_PIX;
    00104         else if (!iStrCmp(Ext, IL_TEXT("pbm")) || !iStrCmp(Ext, IL_TEXT("pgm")) ||
    00105                 !iStrCmp(Ext, IL_TEXT("pnm")) || !iStrCmp(Ext, IL_TEXT("ppm")))
    00106                 Type = IL_PNM;
    00107         else if (!iStrCmp(Ext, IL_TEXT("psd")) || !iStrCmp(Ext, IL_TEXT("pdd")))
    00108                 Type = IL_PSD;
    00109         else if (!iStrCmp(Ext, IL_TEXT("psp")))
    00110                 Type = IL_PSP;
    00111         else if (!iStrCmp(Ext, IL_TEXT("pxr")))
    00112                 Type = IL_PXR;
    00113         else if (!iStrCmp(Ext, IL_TEXT("sgi")) || !iStrCmp(Ext, IL_TEXT("bw")) ||
    00114                 !iStrCmp(Ext, IL_TEXT("rgb")) || !iStrCmp(Ext, IL_TEXT("rgba")))
    00115                 Type = IL_SGI;
    00116         else if (!iStrCmp(Ext, IL_TEXT("sun")) || !iStrCmp(Ext, IL_TEXT("ras")) ||
    00117                          !iStrCmp(Ext, IL_TEXT("rs")) || !iStrCmp(Ext, IL_TEXT("im1")) ||
    00118                          !iStrCmp(Ext, IL_TEXT("im8")) || !iStrCmp(Ext, IL_TEXT("im24")) ||
    00119                          !iStrCmp(Ext, IL_TEXT("im32")))
    00120                 Type = IL_SUN;
    00121         else if (!iStrCmp(Ext, IL_TEXT("tif")) || !iStrCmp(Ext, IL_TEXT("tiff")))
    00122                 Type = IL_TIF;
    00123         else if (!iStrCmp(Ext, IL_TEXT("tpl")))
    00124                 Type = IL_TPL;
    00125         else if (!iStrCmp(Ext, IL_TEXT("vtf")))
    00126                 Type = IL_VTF;
    00127         else if (!iStrCmp(Ext, IL_TEXT("wal")))
    00128                 Type = IL_WAL;
    00129         else if (!iStrCmp(Ext, IL_TEXT("wbmp")))
    00130                 Type = IL_WBMP;
    00131         else if (!iStrCmp(Ext, IL_TEXT("wdp")) || !iStrCmp(Ext, IL_TEXT("hdp")))
    00132                 Type = IL_WDP;
    00133         else if (!iStrCmp(Ext, IL_TEXT("xpm")))
    00134                 Type = IL_XPM;
    00135         else
    00136                 Type = IL_TYPE_UNKNOWN;
    00137
    00138         return Type;
    00139 }
    00140
    00141
    00142 //changed 2003-09-17 to ILAPIENTRY
    00143 ILenum ILAPIENTRY ilDetermineType(ILconst_string FileName)
    00144 {
    00145         ILHANDLE        File;
    00146         ILenum          Type;
    00147
    00148         if (FileName == NULL)
    00149                 return IL_TYPE_UNKNOWN;
    00150
    00151         File = iopenr(FileName);
    00152         if (File == NULL) {
    00153                 ilSetError(IL_COULD_NOT_OPEN_FILE);
    00154                 return IL_FALSE;
    00155         }
    00156         Type = ilDetermineTypeF(File);
    00157         icloser(File);
    00158
    00159         return Type;
    00160 }
    00161
    00162
    00163 ILenum ILAPIENTRY ilDetermineTypeF(ILHANDLE File)
    00164 {
    00165         if (File == NULL)
    00166                 return IL_TYPE_UNKNOWN;
    00167
    00168         #ifndef IL_NO_JPG
    00169         if (ilIsValidJpegF(File))
    00170                 return IL_JPG;
    00171         #endif
    00172
    00173         #ifndef IL_NO_DDS
    00174         if (ilIsValidDdsF(File))
    00175                 return IL_DDS;
    00176         #endif
    00177
    00178         #ifndef IL_NO_PNG
    00179         if (ilIsValidPngF(File))
    00180                 return IL_PNG;
    00181         #endif
    00182
    00183         #ifndef IL_NO_BMP
    00184         if (ilIsValidBmpF(File))
    00185                 return IL_BMP;
    00186         #endif
    00187
    00188         #ifndef IL_NO_EXR
    00189         if (ilIsValidExrF(File))
    00190                 return IL_EXR;
    00191         #endif
    00192
    00193         #ifndef IL_NO_GIF
    00194         if (ilIsValidGifF(File))
    00195                 return IL_GIF;
    00196         #endif
    00197
    00198         #ifndef IL_NO_HDR
    00199         if (ilIsValidHdrF(File))
    00200                 return IL_HDR;
    00201         #endif
    00202
    00203         #ifndef IL_NO_ICNS
    00204         if (ilIsValidIcnsF(File))
    00205                 return IL_ICNS;
    00206         #endif
    00207
    00208         #ifndef IL_NO_JP2
    00209         if (ilIsValidJp2F(File))
    00210                 return IL_JP2;
    00211         #endif
    00212
    00213         #ifndef IL_NO_LIF
    00214         if (ilIsValidLifF(File))
    00215                 return IL_LIF;
    00216         #endif
    00217
    00218         #ifndef IL_NO_MDL
    00219         if (ilIsValidMdlF(File))
    00220                 return IL_MDL;
    00221         #endif
    00222
    00223         #ifndef IL_NO_PCX
    00224         if (ilIsValidPcxF(File))
    00225                 return IL_PCX;
    00226         #endif
    00227
    00228         #ifndef IL_NO_PIC
    00229         if (ilIsValidPicF(File))
    00230                 return IL_PIC;
    00231         #endif
    00232
    00233         #ifndef IL_NO_PNM
    00234         if (ilIsValidPnmF(File))
    00235                 return IL_PNM;
    00236         #endif
    00237
    00238         #ifndef IL_NO_PSD
    00239         if (ilIsValidPsdF(File))
    00240                 return IL_PSD;
    00241         #endif
    00242
    00243         #ifndef IL_NO_PSP
    00244         if (ilIsValidPspF(File))
    00245                 return IL_PSP;
    00246         #endif
    00247
    00248         #ifndef IL_NO_SGI
    00249         if (ilIsValidSgiF(File))
    00250                 return IL_SGI;
    00251         #endif
    00252
    00253         #ifndef IL_NO_SUN
    00254         if (ilIsValidSunF(File))
    00255                 return IL_SUN;
    00256         #endif
    00257
    00258         #ifndef IL_NO_TIF
    00259         if (ilIsValidTiffF(File))
    00260                 return IL_TIF;
    00261         #endif
    00262
    00263         #ifndef IL_NO_TPL
    00264         if (ilIsValidTplF(File))
    00265                 return IL_TPL;
    00266         #endif
    00267
    00268         #ifndef IL_NO_VTF
    00269         if (ilIsValidVtfF(File))
    00270                 return IL_VTF;
    00271         #endif
    00272
    00273         #ifndef IL_NO_XPM
    00274         if (ilIsValidXpmF(File))
    00275                 return IL_XPM;
    00276         #endif
    00277
    00278         //moved tga to end of list because it has no magic number
    00279         //in header to assure that this is really a tga... (20040218)
    00280         #ifndef IL_NO_TGA
    00281         if (ilIsValidTgaF(File))
    00282                 return IL_TGA;
    00283         #endif
    00284
    00285         return IL_TYPE_UNKNOWN;
    00286 }
    00287
    00288
    00289 ILenum ILAPIENTRY ilDetermineTypeL(const void *Lump, ILuint Size)
    00290 {
    00291         if (Lump == NULL)
    00292                 return IL_TYPE_UNKNOWN;
    00293
    00294         #ifndef IL_NO_JPG
    00295         if (ilIsValidJpegL(Lump, Size))
    00296                 return IL_JPG;
    00297         #endif
    00298
    00299         #ifndef IL_NO_DDS
    00300         if (ilIsValidDdsL(Lump, Size))
    00301                 return IL_DDS;
    00302         #endif
    00303
    00304         #ifndef IL_NO_PNG
    00305         if (ilIsValidPngL(Lump, Size))
    00306                 return IL_PNG;
    00307         #endif
    00308
    00309         #ifndef IL_NO_BMP
    00310         if (ilIsValidBmpL(Lump, Size))
    00311                 return IL_BMP;
    00312         #endif
    00313
    00314         #ifndef IL_NO_EXR
    00315         if (ilIsValidExrL(Lump, Size))
    00316                 return IL_EXR;
    00317         #endif
    00318
    00319         #ifndef IL_NO_GIF
    00320         if (ilIsValidGifL(Lump, Size))
    00321                 return IL_GIF;
    00322         #endif
    00323
    00324         #ifndef IL_NO_HDR
    00325         if (ilIsValidHdrL(Lump, Size))
    00326                 return IL_HDR;
    00327         #endif
    00328
    00329         #ifndef IL_NO_ICNS
    00330         if (ilIsValidIcnsL(Lump, Size))
    00331                 return IL_ICNS;
    00332         #endif
    00333
    00334         #ifndef IL_NO_JP2
    00335         if (ilIsValidJp2L(Lump, Size))
    00336                 return IL_JP2;
    00337         #endif
    00338
    00339         #ifndef IL_NO_LIF
    00340         if (ilIsValidLifL(Lump, Size))
    00341                 return IL_LIF;
    00342         #endif
    00343
    00344         #ifndef IL_NO_MDL
    00345         if (ilIsValidMdlL(Lump, Size))
    00346                 return IL_MDL;
    00347         #endif
    00348
    00349         #ifndef IL_NO_PCX
    00350         if (ilIsValidPcxL(Lump, Size))
    00351                 return IL_PCX;
    00352         #endif
    00353
    00354         #ifndef IL_NO_PIC
    00355         if (ilIsValidPicL(Lump, Size))
    00356                 return IL_PIC;
    00357         #endif
    00358
    00359         #ifndef IL_NO_PNM
    00360         if (ilIsValidPnmL(Lump, Size))
    00361                 return IL_PNM;
    00362         #endif
    00363
    00364         #ifndef IL_NO_PSD
    00365         if (ilIsValidPsdL(Lump, Size))
    00366                 return IL_PSD;
    00367         #endif
    00368
    00369         #ifndef IL_NO_PSP
    00370         if (ilIsValidPspL(Lump, Size))
    00371                 return IL_PSP;
    00372         #endif
    00373
    00374         #ifndef IL_NO_SGI
    00375         if (ilIsValidSgiL(Lump, Size))
    00376                 return IL_SGI;
    00377         #endif
    00378
    00379         #ifndef IL_NO_SUN
    00380         if (ilIsValidSunL(Lump, Size))
    00381                 return IL_SUN;
    00382         #endif
    00383
    00384         #ifndef IL_NO_TIF
    00385         if (ilIsValidTiffL(Lump, Size))
    00386                 return IL_TIF;
    00387         #endif
    00388
    00389         #ifndef IL_NO_TPL
    00390         if (ilIsValidTplL(Lump, Size))
    00391                 return IL_TPL;
    00392         #endif
    00393
    00394         #ifndef IL_NO_VTF
    00395         if (ilIsValidVtfL(Lump, Size))
    00396                 return IL_VTF;
    00397         #endif
    00398
    00399         #ifndef IL_NO_XPM
    00400         if (ilIsValidXpmL(Lump, Size))
    00401                 return IL_XPM;
    00402         #endif
    00403
    00404         //moved tga to end of list because it has no magic number
    00405         //in header to assure that this is really a tga... (20040218)
    00406         #ifndef IL_NO_TGA
    00407         if (ilIsValidTgaL(Lump, Size))
    00408                 return IL_TGA;
    00409         #endif
    00410
    00411         return IL_TYPE_UNKNOWN;
    00412 }
    00413
    00414
    00415 ILboolean ILAPIENTRY ilIsValid(ILenum Type, ILconst_string FileName)
    00416 {
    00417         if (FileName == NULL) {
    00418                 ilSetError(IL_INVALID_PARAM);
    00419                 return IL_FALSE;
    00420         }
    00421
    00422         switch (Type)
    00423         {
    00424                 #ifndef IL_NO_TGA
    00425                 case IL_TGA:
    00426                         return ilIsValidTga(FileName);
    00427                 #endif
    00428
    00429                 #ifndef IL_NO_JPG
    00430                 case IL_JPG:
    00431                         return ilIsValidJpeg(FileName);
    00432                 #endif
    00433
    00434                 #ifndef IL_NO_DDS
    00435                 case IL_DDS:
    00436                         return ilIsValidDds(FileName);
    00437                 #endif
    00438
    00439                 #ifndef IL_NO_PNG
    00440                 case IL_PNG:
    00441                         return ilIsValidPng(FileName);
    00442                 #endif
    00443
    00444                 #ifndef IL_NO_BMP
    00445                 case IL_BMP:
    00446                         return ilIsValidBmp(FileName);
    00447                 #endif
    00448
    00449                 #ifndef IL_NO_EXR
    00450                 case IL_EXR:
    00451                         return ilIsValidExr(FileName);
    00452                 #endif
    00453
    00454                 #ifndef IL_NO_GIF
    00455                 case IL_GIF:
    00456                         return ilIsValidGif(FileName);
    00457                 #endif
    00458
    00459                 #ifndef IL_NO_HDR
    00460                 case IL_HDR:
    00461                         return ilIsValidHdr(FileName);
    00462                 #endif
    00463
    00464                 #ifndef IL_NO_ICNS
    00465                 case IL_ICNS:
    00466                         return ilIsValidIcns(FileName);
    00467                 #endif
    00468
    00469                 #ifndef IL_NO_JP2
    00470                 case IL_JP2:
    00471                         return ilIsValidJp2(FileName);
    00472                 #endif
    00473
    00474                 #ifndef IL_NO_LIF
    00475                 case IL_LIF:
    00476                         return ilIsValidLif(FileName);
    00477                 #endif
    00478
    00479                 #ifndef IL_NO_MDL
    00480                 case IL_MDL:
    00481                         return ilIsValidMdl(FileName);
    00482                 #endif
    00483
    00484                 #ifndef IL_NO_PCX
    00485                 case IL_PCX:
    00486                         return ilIsValidPcx(FileName);
    00487                 #endif
    00488
    00489                 #ifndef IL_NO_PIC
    00490                 case IL_PIC:
    00491                         return ilIsValidPic(FileName);
    00492                 #endif
    00493
    00494                 #ifndef IL_NO_PNM
    00495                 case IL_PNM:
    00496                         return ilIsValidPnm(FileName);
    00497                 #endif
    00498
    00499                 #ifndef IL_NO_PSD
    00500                 case IL_PSD:
    00501                         return ilIsValidPsd(FileName);
    00502                 #endif
    00503
    00504                 #ifndef IL_NO_PSP
    00505                 case IL_PSP:
    00506                         return ilIsValidPsp(FileName);
    00507                 #endif
    00508
    00509                 #ifndef IL_NO_SGI
    00510                 case IL_SGI:
    00511                         return ilIsValidSgi(FileName);
    00512                 #endif
    00513
    00514                 #ifndef IL_NO_SUN
    00515                 case IL_SUN:
    00516                         return ilIsValidSun(FileName);
    00517                 #endif
    00518
    00519                 #ifndef IL_NO_TIF
    00520                 case IL_TIF:
    00521                         return ilIsValidTiff(FileName);
    00522                 #endif
    00523
    00524                 #ifndef IL_NO_TPL
    00525                 case IL_TPL:
    00526                         return ilIsValidTpl(FileName);
    00527                 #endif
    00528
    00529                 #ifndef IL_NO_VTF
    00530                 case IL_VTF:
    00531                         return ilIsValidVtf(FileName);
    00532                 #endif
    00533
    00534                 #ifndef IL_NO_XPM
    00535                 case IL_XPM:
    00536                         return ilIsValidXpm(FileName);
    00537                 #endif
    00538         }
    00539
    00540         ilSetError(IL_INVALID_ENUM);
    00541         return IL_FALSE;
    00542 }
    00543
    00544
    00545 ILboolean ILAPIENTRY ilIsValidF(ILenum Type, ILHANDLE File)
    00546 {
    00547         if (File == NULL) {
    00548                 ilSetError(IL_INVALID_PARAM);
    00549                 return IL_FALSE;
    00550         }
    00551
    00552         switch (Type)
    00553         {
    00554                 #ifndef IL_NO_TGA
    00555                 case IL_TGA:
    00556                         return ilIsValidTgaF(File);
    00557                 #endif
    00558
    00559                 #ifndef IL_NO_JPG
    00560                 case IL_JPG:
    00561                         return ilIsValidJpegF(File);
    00562                 #endif
    00563
    00564                 #ifndef IL_NO_DDS
    00565                 case IL_DDS:
    00566                         return ilIsValidDdsF(File);
    00567                 #endif
    00568
    00569                 #ifndef IL_NO_PNG
    00570                 case IL_PNG:
    00571                         return ilIsValidPngF(File);
    00572                 #endif
    00573
    00574                 #ifndef IL_NO_BMP
    00575                 case IL_BMP:
    00576                         return ilIsValidBmpF(File);
    00577                 #endif
    00578
    00579                 #ifndef IL_NO_EXR
    00580                 case IL_EXR:
    00581                         return ilIsValidExrF(File);
    00582                 #endif
    00583
    00584                 #ifndef IL_NO_GIF
    00585                 case IL_GIF:
    00586                         return ilIsValidGifF(File);
    00587                 #endif
    00588
    00589                 #ifndef IL_NO_HDR
    00590                 case IL_HDR:
    00591                         return ilIsValidHdrF(File);
    00592                 #endif
    00593
    00594                 #ifndef IL_NO_ICNS
    00595                 case IL_ICNS:
    00596                         return ilIsValidIcnsF(File);
    00597                 #endif
    00598
    00599                 #ifndef IL_NO_JP2
    00600                 case IL_JP2:
    00601                         return ilIsValidJp2F(File);
    00602                 #endif
    00603
    00604                 #ifndef IL_NO_LIF
    00605                 case IL_LIF:
    00606                         return ilIsValidLifF(File);
    00607                 #endif
    00608
    00609                 #ifndef IL_NO_MDL
    00610                 case IL_MDL:
    00611                         return ilIsValidMdlF(File);
    00612                 #endif
    00613
    00614                 #ifndef IL_NO_PCX
    00615                 case IL_PCX:
    00616                         return ilIsValidPcxF(File);
    00617                 #endif
    00618
    00619                 #ifndef IL_NO_PIC
    00620                 case IL_PIC:
    00621                         return ilIsValidPicF(File);
    00622                 #endif
    00623
    00624                 #ifndef IL_NO_PNM
    00625                 case IL_PNM:
    00626                         return ilIsValidPnmF(File);
    00627                 #endif
    00628
    00629                 #ifndef IL_NO_PSD
    00630                 case IL_PSD:
    00631                         return ilIsValidPsdF(File);
    00632                 #endif
    00633
    00634                 #ifndef IL_NO_PSP
    00635                 case IL_PSP:
    00636                         return ilIsValidPspF(File);
    00637                 #endif
    00638
    00639                 #ifndef IL_NO_SGI
    00640                 case IL_SGI:
    00641                         return ilIsValidSgiF(File);
    00642                 #endif
    00643
    00644                 #ifndef IL_NO_SUN
    00645                 case IL_SUN:
    00646                         return ilIsValidSunF(File);
    00647                 #endif
    00648
    00649                 #ifndef IL_NO_TIF
    00650                 case IL_TIF:
    00651                         return ilIsValidTiffF(File);
    00652                 #endif
    00653
    00654                 #ifndef IL_NO_TPL
    00655                 case IL_TPL:
    00656                         return ilIsValidTplF(File);
    00657                 #endif
    00658
    00659                 #ifndef IL_NO_VTF
    00660                 case IL_VTF:
    00661                         return ilIsValidVtfF(File);
    00662                 #endif
    00663
    00664                 #ifndef IL_NO_XPM
    00665                 case IL_XPM:
    00666                         return ilIsValidXpmF(File);
    00667                 #endif
    00668         }
    00669
    00670         ilSetError(IL_INVALID_ENUM);
    00671         return IL_FALSE;
    00672 }
    00673
    00674
    00675 ILboolean ILAPIENTRY ilIsValidL(ILenum Type, void *Lump, ILuint Size)
    00676 {
    00677         if (Lump == NULL) {
    00678                 ilSetError(IL_INVALID_PARAM);
    00679                 return IL_FALSE;
    00680         }
    00681
    00682         switch (Type)
    00683         {
    00684                 #ifndef IL_NO_TGA
    00685                 case IL_TGA:
    00686                         return ilIsValidTgaL(Lump, Size);
    00687                 #endif
    00688
    00689                 #ifndef IL_NO_JPG
    00690                 case IL_JPG:
    00691                         return ilIsValidJpegL(Lump, Size);
    00692                 #endif
    00693
    00694                 #ifndef IL_NO_DDS
    00695                 case IL_DDS:
    00696                         return ilIsValidDdsL(Lump, Size);
    00697                 #endif
    00698
    00699                 #ifndef IL_NO_PNG
    00700                 case IL_PNG:
    00701                         return ilIsValidPngL(Lump, Size);
    00702                 #endif
    00703
    00704                 #ifndef IL_NO_BMP
    00705                 case IL_BMP:
    00706                         return ilIsValidBmpL(Lump, Size);
    00707                 #endif
    00708
    00709                 #ifndef IL_NO_EXR
    00710                 case IL_EXR:
    00711                         return ilIsValidExrL(Lump, Size);
    00712                 #endif
    00713
    00714                 #ifndef IL_NO_GIF
    00715                 case IL_GIF:
    00716                         return ilIsValidGifL(Lump, Size);
    00717                 #endif
    00718
    00719                 #ifndef IL_NO_HDR
    00720                 case IL_HDR:
    00721                         return ilIsValidHdrL(Lump, Size);
    00722                 #endif
    00723
    00724                 #ifndef IL_NO_ICNS
    00725                 case IL_ICNS:
    00726                         return ilIsValidIcnsL(Lump, Size);
    00727                 #endif
    00728
    00729                 #ifndef IL_NO_JP2
    00730                 case IL_JP2:
    00731                         return ilIsValidJp2L(Lump, Size);
    00732                 #endif
    00733
    00734                 #ifndef IL_NO_LIF
    00735                 case IL_LIF:
    00736                         return ilIsValidLifL(Lump, Size);
    00737                 #endif
    00738
    00739                 #ifndef IL_NO_MDL
    00740                 case IL_MDL:
    00741                         return ilIsValidMdlL(Lump, Size);
    00742                 #endif
    00743
    00744                 #ifndef IL_NO_PCX
    00745                 case IL_PCX:
    00746                         return ilIsValidPcxL(Lump, Size);
    00747                 #endif
    00748
    00749                 #ifndef IL_NO_PIC
    00750                 case IL_PIC:
    00751                         return ilIsValidPicL(Lump, Size);
    00752                 #endif
    00753
    00754                 #ifndef IL_NO_PNM
    00755                 case IL_PNM:
    00756                         return ilIsValidPnmL(Lump, Size);
    00757                 #endif
    00758
    00759                 #ifndef IL_NO_PSD
    00760                 case IL_PSD:
    00761                         return ilIsValidPsdL(Lump, Size);
    00762                 #endif
    00763
    00764                 #ifndef IL_NO_PSP
    00765                 case IL_PSP:
    00766                         return ilIsValidPspL(Lump, Size);
    00767                 #endif
    00768
    00769                 #ifndef IL_NO_SGI
    00770                 case IL_SGI:
    00771                         return ilIsValidSgiL(Lump, Size);
    00772                 #endif
    00773
    00774                 #ifndef IL_NO_SUN
    00775                 case IL_SUN:
    00776                         return ilIsValidSunL(Lump, Size);
    00777                 #endif
    00778
    00779                 #ifndef IL_NO_TIF
    00780                 case IL_TIF:
    00781                         return ilIsValidTiffL(Lump, Size);
    00782                 #endif
    00783
    00784                 #ifndef IL_NO_TPL
    00785                 case IL_TPL:
    00786                         return ilIsValidTplL(Lump, Size);
    00787                 #endif
    00788
    00789                 #ifndef IL_NO_VTF
    00790                 case IL_VTF:
    00791                         return ilIsValidVtfL(Lump, Size);
    00792                 #endif
    00793
    00794                 #ifndef IL_NO_XPM
    00795                 case IL_XPM:
    00796                         return ilIsValidXpmL(Lump, Size);
    00797                 #endif
    00798         }
    00799
    00800         ilSetError(IL_INVALID_ENUM);
    00801         return IL_FALSE;
    00802 }
    00803
    00804
    00805 ILboolean ILAPIENTRY ilLoad(ILenum Type, ILconst_string FileName)
    00806 {
    00807         ILboolean       bRet;
    00808
    00809         if (FileName == NULL || ilStrLen(FileName) < 1) {
    00810                 ilSetError(IL_INVALID_PARAM);
    00811                 return IL_FALSE;
    00812         }
    00813
    00814         switch (Type)
    00815         {
    00816                 case IL_TYPE_UNKNOWN:
    00817                         bRet = ilLoadImage(FileName);
    00818                         break;
    00819
    00820                 #ifndef IL_NO_TGA
    00821                 case IL_TGA:
    00822                         bRet = ilLoadTarga(FileName);
    00823                         break;
    00824                 #endif
    00825
    00826                 #ifndef IL_NO_JPG
    00827                 case IL_JPG:
    00828                         bRet = ilLoadJpeg(FileName);
    00829                         break;
    00830                 #endif
    00831
    00832                 #ifndef IL_NO_JP2
    00833                 case IL_JP2:
    00834                         bRet = ilLoadJp2(FileName);
    00835                         break;
    00836                 #endif
    00837
    00838                 #ifndef IL_NO_DDS
    00839                 case IL_DDS:
    00840                         bRet = ilLoadDds(FileName);
    00841                         break;
    00842                 #endif
    00843
    00844                 #ifndef IL_NO_PNG
    00845                 case IL_PNG:
    00846                         bRet = ilLoadPng(FileName);
    00847                         break;
    00848                 #endif
    00849
    00850                 #ifndef IL_NO_BMP
    00851                 case IL_BMP:
    00852                         bRet = ilLoadBmp(FileName);
    00853                         break;
    00854                 #endif
    00855
    00856                 #ifndef IL_NO_GIF
    00857                 case IL_GIF:
    00858                         bRet = ilLoadGif(FileName);
    00859                         break;
    00860                 #endif
    00861
    00862                 #ifndef IL_NO_HDR
    00863                 case IL_HDR:
    00864                         bRet = ilLoadHdr(FileName);
    00865                         break;
    00866                 #endif
    00867
    00868                 #ifndef IL_NO_CUT
    00869                 case IL_CUT:
    00870                         bRet = ilLoadCut(FileName);
    00871                         break;
    00872                 #endif
    00873
    00874                 #ifndef IL_NO_DOOM
    00875                 case IL_DOOM:
    00876                         bRet = ilLoadDoom(FileName);
    00877                         break;
    00878                 case IL_DOOM_FLAT:
    00879                         bRet = ilLoadDoomFlat(FileName);
    00880                         break;
    00881                 #endif
    00882
    00883                 #ifndef IL_NO_IFF
    00884                 case IL_IFF:
    00885                         bRet = ilLoadIff(FileName);
    00886                         break;
    00887                 #endif
    00888
    00889                 #ifndef IL_NO_ICO
    00890                 case IL_ICO:
    00891                         bRet = ilLoadIcon(FileName);
    00892                         break;
    00893                 #endif
    00894
    00895                 #ifndef IL_NO_ICNS
    00896                 case IL_ICNS:
    00897                         bRet = ilLoadIcns(FileName);
    00898                         break;
    00899                 #endif
    00900
    00901                 #ifndef IL_NO_LIF
    00902                 case IL_LIF:
    00903                         bRet = ilLoadLif(FileName);
    00904                         break;
    00905                 #endif
    00906
    00907                 #ifndef IL_NO_MDL
    00908                 case IL_MDL:
    00909                         bRet = ilLoadMdl(FileName);
    00910                         break;
    00911                 #endif
    00912
    00913                 #ifndef IL_NO_MNG
    00914                 case IL_MNG:
    00915                         bRet = ilLoadMng(FileName);
    00916                         break;
    00917                 #endif
    00918
    00919                 #ifndef IL_NO_PCD
    00920                 case IL_PCD:
    00921                         ilLoadPcd(FileName);
    00922                         break;
    00923                 #endif
    00924
    00925                 #ifndef IL_NO_PCX
    00926                 case IL_PCX:
    00927                         bRet = ilLoadPcx(FileName);
    00928                         break;
    00929                 #endif
    00930
    00931                 #ifndef IL_NO_PIC
    00932                 case IL_PIC:
    00933                         bRet = ilLoadPic(FileName);
    00934                         break;
    00935                 #endif
    00936
    00937                 #ifndef IL_NO_PIX
    00938                 case IL_PIX:
    00939                         bRet = ilLoadPix(FileName);
    00940                         break;
    00941                 #endif
    00942
    00943                 #ifndef IL_NO_PNM
    00944                 case IL_PNM:
    00945                         bRet = ilLoadPnm(FileName);
    00946                         break;
    00947                 #endif
    00948
    00949                 #ifndef IL_NO_PSD
    00950                 case IL_PSD:
    00951                         bRet = ilLoadPsd(FileName);
    00952                         break;
    00953                 #endif
    00954
    00955                 #ifndef IL_NO_PSP
    00956                 case IL_PSP:
    00957                         bRet = ilLoadPsp(FileName);
    00958                         break;
    00959                 #endif
    00960
    00961                 #ifndef IL_NO_PXR
    00962                 case IL_PXR:
    00963                         bRet = ilLoadPxr(FileName);
    00964                         break;
    00965                 #endif
    00966
    00967                 #ifndef IL_NO_RAW
    00968                 case IL_RAW:
    00969                         bRet = ilLoadRaw(FileName);
    00970                         break;
    00971                 #endif
    00972
    00973                 #ifndef IL_NO_SGI
    00974                 case IL_SGI:
    00975                         bRet = ilLoadSgi(FileName);
    00976                         break;
    00977                 #endif
    00978
    00979                 #ifndef IL_NO_SUN
    00980                 case IL_SUN:
    00981                         bRet = ilLoadSun(FileName);
    00982                         break;
    00983                 #endif
    00984
    00985                 #ifndef IL_NO_TIF
    00986                 case IL_TIF:
    00987                         bRet = ilLoadTiff(FileName);
    00988                         break;
    00989                 #endif
    00990
    00991                 #ifndef IL_NO_TPL
    00992                 case IL_TPL:
    00993                         bRet = ilLoadTpl(FileName);
    00994                         break;
    00995                 #endif
    00996
    00997                 #ifndef IL_NO_VTF
    00998                 case IL_VTF:
    00999                         bRet = ilLoadVtf(FileName);
    01000                         break;
    01001                 #endif
    01002
    01003                 #ifndef IL_NO_WAL
    01004                 case IL_WAL:
    01005                         bRet = ilLoadWal(FileName);
    01006                         break;
    01007                 #endif
    01008
    01009                 #ifndef IL_NO_WBMP
    01010                 case IL_WBMP:
    01011                         bRet = ilLoadWbmp(FileName);
    01012                         break;
    01013                 #endif
    01014
    01015                 #ifndef IL_NO_XPM
    01016                 case IL_XPM:
    01017                         bRet = ilLoadXpm(FileName);
    01018                         break;
    01019                 #endif
    01020
    01021                 #ifndef IL_NO_WDP
    01022                 case IL_WDP:
    01023                         bRet = ilLoadWdp(FileName);
    01024                         break;
    01025                 #endif
    01026
    01027                 #ifndef IL_NO_EXR
    01028                 case IL_EXR:
    01029                         bRet = ilLoadExr(FileName);
    01030                         break;
    01031                 #endif
    01032
    01033                 default:
    01034                         ilSetError(IL_INVALID_ENUM);
    01035                         bRet = IL_FALSE;
    01036         }
    01037
    01038         return bRet;
    01039 }
    01040
    01041
    01042 ILboolean ILAPIENTRY ilLoadF(ILenum Type, ILHANDLE File)
    01043 {
    01044         if (File == NULL) {
    01045                 ilSetError(IL_INVALID_PARAM);
    01046                 return IL_FALSE;
    01047         }
    01048
    01049         if (Type == IL_TYPE_UNKNOWN)
    01050                 Type = ilDetermineTypeF(File);
    01051
    01052         switch (Type)
    01053         {
    01054                 case IL_TYPE_UNKNOWN:
    01055                         return IL_FALSE;
    01056
    01057                 #ifndef IL_NO_TGA
    01058                 case IL_TGA:
    01059                         return ilLoadTargaF(File);
    01060                 #endif
    01061
    01062                 #ifndef IL_NO_JPG
    01063                         #ifndef IL_USE_IJL
    01064                         case IL_JPG:
    01065                                 return ilLoadJpegF(File);
    01066                         #endif
    01067                 #endif
    01068
    01069                 #ifndef IL_NO_JP2
    01070                 case IL_JP2:
    01071                         return ilLoadJp2F(File);
    01072                 #endif
    01073
    01074                 #ifndef IL_NO_DDS
    01075                 case IL_DDS:
    01076                         return ilLoadDdsF(File);
    01077                 #endif
    01078
    01079                 #ifndef IL_NO_PNG
    01080                 case IL_PNG:
    01081                         return ilLoadPngF(File);
    01082                 #endif
    01083
    01084                 #ifndef IL_NO_BMP
    01085                 case IL_BMP:
    01086                         return ilLoadBmpF(File);
    01087                 #endif
    01088
    01089                 #ifndef IL_NO_CUT
    01090                 case IL_CUT:
    01091                         return ilLoadCutF(File);
    01092                 #endif
    01093
    01094                 #ifndef IL_NO_DOOM
    01095                 case IL_DOOM:
    01096                         return ilLoadDoomF(File);
    01097                 case IL_DOOM_FLAT:
    01098                         return ilLoadDoomFlatF(File);
    01099                 #endif
    01100
    01101                 #ifndef IL_NO_EXR
    01102                 case IL_EXR:
    01103                         return ilLoadExrF(File);
    01104                 #endif
    01105
    01106                 #ifndef IL_NO_GIF
    01107                 case IL_GIF:
    01108                         return ilLoadGifF(File);
    01109                 #endif
    01110
    01111                 #ifndef IL_NO_HDR
    01112                 case IL_HDR:
    01113                         return ilLoadHdrF(File);
    01114                 #endif
    01115
    01116                 #ifndef IL_NO_ICO
    01117                 case IL_ICO:
    01118                         return ilLoadIconF(File);
    01119                 #endif
    01120
    01121                 #ifndef IL_NO_IFF
    01122                 case IL_IFF:
    01123                         return ilLoadIffF(File);
    01124                 #endif
    01125
    01126                 #ifndef IL_NO_ICNS
    01127                 case IL_ICNS:
    01128                         return ilLoadIcnsF(File);
    01129                 #endif
    01130
    01131                 #ifndef IL_NO_LIF
    01132                 case IL_LIF:
    01133                         return ilLoadLifF(File);
    01134                 #endif
    01135
    01136                 #ifndef IL_NO_MDL
    01137                 case IL_MDL:
    01138                         return ilLoadMdlF(File);
    01139                 #endif
    01140
    01141                 #ifndef IL_NO_MNG
    01142                 case IL_MNG:
    01143                         return ilLoadMngF(File);
    01144                 #endif
    01145
    01146                 #ifndef IL_NO_PCD
    01147                 case IL_PCD:
    01148                         return ilLoadPcdF(File);
    01149                 #endif
    01150
    01151                 #ifndef IL_NO_PCX
    01152                 case IL_PCX:
    01153                         return ilLoadPcxF(File);
    01154                 #endif
    01155
    01156                 #ifndef IL_NO_PIC
    01157                 case IL_PIC:
    01158                         return ilLoadPicF(File);
    01159                 #endif
    01160
    01161                 #ifndef IL_NO_PIX
    01162                 case IL_PIX:
    01163                         return ilLoadPixF(File);
    01164                 #endif
    01165
    01166                 #ifndef IL_NO_PNM
    01167                 case IL_PNM:
    01168                         return ilLoadPnmF(File);
    01169                 #endif
    01170
    01171                 #ifndef IL_NO_PSD
    01172                 case IL_PSD:
    01173                         return ilLoadPsdF(File);
    01174                 #endif
    01175
    01176                 #ifndef IL_NO_PSP
    01177                 case IL_PSP:
    01178                         return ilLoadPspF(File);
    01179                 #endif
    01180
    01181                 #ifndef IL_NO_PXR
    01182                 case IL_PXR:
    01183                         return ilLoadPxrF(File);
    01184                 #endif
    01185
    01186                 #ifndef IL_NO_RAW
    01187                 case IL_RAW:
    01188                         return ilLoadRawF(File);
    01189                 #endif
    01190
    01191                 #ifndef IL_NO_SGI
    01192                 case IL_SGI:
    01193                         return ilLoadSgiF(File);
    01194                 #endif
    01195
    01196                 #ifndef IL_NO_SUN
    01197                 case IL_SUN:
    01198                         return ilLoadSunF(File);
    01199                 #endif
    01200
    01201                 #ifndef IL_NO_TIF
    01202                 case IL_TIF:
    01203                         return ilLoadTiffF(File);
    01204                 #endif
    01205
    01206                 #ifndef IL_NO_TPL
    01207                 case IL_TPL:
    01208                         return ilLoadTplF(File);
    01209                 #endif
    01210
    01211                 #ifndef IL_NO_VTF
    01212                 case IL_VTF:
    01213                         return ilLoadVtfF(File);
    01214                 #endif
    01215
    01216                 #ifndef IL_NO_WAL
    01217                 case IL_WAL:
    01218                         return ilLoadWalF(File);
    01219                 #endif
    01220
    01221                 #ifndef IL_NO_WBMP
    01222                 case IL_WBMP:
    01223                         return ilLoadWbmpF(File);
    01224                 #endif
    01225
    01226                 #ifndef IL_NO_XPM
    01227                 case IL_XPM:
    01228                         return ilLoadXpmF(File);
    01229                 #endif
    01230         }
    01231
    01232         ilSetError(IL_INVALID_ENUM);
    01233         return IL_FALSE;
    01234 }
    01235
    01236
    01237 ILboolean ILAPIENTRY ilLoadL(ILenum Type, const void *Lump, ILuint Size)
    01238 {
    01239         if (Lump == NULL || Size == 0) {
    01240                 ilSetError(IL_INVALID_PARAM);
    01241                 return IL_FALSE;
    01242         }
    01243
    01244         if (Type == IL_TYPE_UNKNOWN)
    01245                 Type = ilDetermineTypeL(Lump, Size);
    01246
    01247         switch (Type)
    01248         {
    01249                 case IL_TYPE_UNKNOWN:
    01250                         return IL_FALSE;
    01251
    01252                 #ifndef IL_NO_TGA
    01253                 case IL_TGA:
    01254                         return ilLoadTargaL(Lump, Size);
    01255                 #endif
    01256
    01257                 #ifndef IL_NO_JPG
    01258                 case IL_JPG:
    01259                         return ilLoadJpegL(Lump, Size);
    01260                 #endif
    01261
    01262                 #ifndef IL_NO_JP2
    01263                 case IL_JP2:
    01264                         return ilLoadJp2L(Lump, Size);
    01265                 #endif
    01266
    01267                 #ifndef IL_NO_DDS
    01268                 case IL_DDS:
    01269                         return ilLoadDdsL(Lump, Size);
    01270                 #endif
    01271
    01272                 #ifndef IL_NO_PNG
    01273                 case IL_PNG:
    01274                         return ilLoadPngL(Lump, Size);
    01275                 #endif
    01276
    01277                 #ifndef IL_NO_BMP
    01278                 case IL_BMP:
    01279                         return ilLoadBmpL(Lump, Size);
    01280                 #endif
    01281
    01282                 #ifndef IL_NO_CUT
    01283                 case IL_CUT:
    01284                         return ilLoadCutL(Lump, Size);
    01285                 #endif
    01286
    01287                 #ifndef IL_NO_DOOM
    01288                 case IL_DOOM:
    01289                         return ilLoadDoomL(Lump, Size);
    01290                 case IL_DOOM_FLAT:
    01291                         return ilLoadDoomFlatL(Lump, Size);
    01292                 #endif
    01293
    01294                 #ifndef IL_NO_EXR
    01295                 case IL_EXR:
    01296                         return ilLoadExrL(Lump, Size);
    01297                 #endif
    01298
    01299                 #ifndef IL_NO_GIF
    01300                 case IL_GIF:
    01301                         return ilLoadGifL(Lump, Size);
    01302                 #endif
    01303
    01304                 #ifndef IL_NO_HDR
    01305                 case IL_HDR:
    01306                         return ilLoadHdrL(Lump, Size);
    01307                 #endif
    01308
    01309                 #ifndef IL_NO_ICO
    01310                 case IL_ICO:
    01311                         return ilLoadIconL(Lump, Size);
    01312                 #endif
    01313
    01314                 #ifndef IL_NO_IFF
    01315                 case IL_IFF:
    01316                         return ilLoadIffL(Lump, Size);
    01317                 #endif
    01318
    01319                 #ifndef IL_NO_ICNS
    01320                 case IL_ICNS:
    01321                         return ilLoadIcnsL(Lump, Size);
    01322                 #endif
    01323
    01324                 #ifndef IL_NO_LIF
    01325                 case IL_LIF:
    01326                         return ilLoadLifL(Lump, Size);
    01327                 #endif
    01328
    01329                 #ifndef IL_NO_MDL
    01330                 case IL_MDL:
    01331                         return ilLoadMdlL(Lump, Size);
    01332                 #endif
    01333
    01334                 #ifndef IL_NO_MNG
    01335                 case IL_MNG:
    01336                         return ilLoadMngL(Lump, Size);
    01337                 #endif
    01338
    01339                 #ifndef IL_NO_PCD
    01340                 case IL_PCD:
    01341                         return ilLoadPcdL(Lump, Size);
    01342                 #endif
    01343
    01344                 #ifndef IL_NO_PCX
    01345                 case IL_PCX:
    01346                         return ilLoadPcxL(Lump, Size);
    01347                 #endif
    01348
    01349                 #ifndef IL_NO_PIC
    01350                 case IL_PIC:
    01351                         return ilLoadPicL(Lump, Size);
    01352                 #endif
    01353
    01354                 #ifndef IL_NO_PIX
    01355                 case IL_PIX:
    01356                         return ilLoadPixL(Lump, Size);
    01357                 #endif
    01358
    01359                 #ifndef IL_NO_PNM
    01360                 case IL_PNM:
    01361                         return ilLoadPnmL(Lump, Size);
    01362                 #endif
    01363
    01364                 #ifndef IL_NO_PSD
    01365                 case IL_PSD:
    01366                         return ilLoadPsdL(Lump, Size);
    01367                 #endif
    01368
    01369                 #ifndef IL_NO_PSP
    01370                 case IL_PSP:
    01371                         return ilLoadPspL(Lump, Size);
    01372                 #endif
    01373
    01374                 #ifndef IL_NO_PXR
    01375                 case IL_PXR:
    01376                         return ilLoadPxrL(Lump, Size);
    01377                 #endif
    01378
    01379                 #ifndef IL_NO_RAW
    01380                 case IL_RAW:
    01381                         return ilLoadRawL(Lump, Size);
    01382                 #endif
    01383
    01384                 #ifndef IL_NO_SGI
    01385                 case IL_SGI:
    01386                         return ilLoadSgiL(Lump, Size);
    01387                 #endif
    01388
    01389                 #ifndef IL_NO_SUN
    01390                 case IL_SUN:
    01391                         return ilLoadSunL(Lump, Size);
    01392                 #endif
    01393
    01394                 #ifndef IL_NO_TIF
    01395                 case IL_TIF:
    01396                         return ilLoadTiffL(Lump, Size);
    01397                 #endif
    01398
    01399                 #ifndef IL_NO_TPL
    01400                 case IL_TPL:
    01401                         return ilLoadTplL(Lump, Size);
    01402                 #endif
    01403
    01404                 #ifndef IL_NO_VTF
    01405                 case IL_VTF:
    01406                         return ilLoadVtfL(Lump, Size);
    01407                 #endif
    01408
    01409                 #ifndef IL_NO_WAL
    01410                 case IL_WAL:
    01411                         return ilLoadWalL(Lump, Size);
    01412                 #endif
    01413
    01414                 #ifndef IL_NO_WBMP
    01415                 case IL_WBMP:
    01416                         return ilLoadWbmpL(Lump, Size);
    01417                 #endif
    01418
    01419                 #ifndef IL_NO_XPM
    01420                 case IL_XPM:
    01421                         return ilLoadXpmL(Lump, Size);
    01422                 #endif
    01423         }
    01424
    01425         ilSetError(IL_INVALID_ENUM);
    01426         return IL_FALSE;
    01427 }
    01428
    01429
    01431 ILboolean ILAPIENTRY ilLoadImage(ILconst_string FileName)
    01432 {
    01433         ILstring        Ext;
    01434         ILenum          Type;
    01435         ILboolean       bRet = IL_FALSE;
    01436
    01437         if (iCurImage == NULL) {
    01438                 ilSetError(IL_ILLEGAL_OPERATION);
    01439                 return IL_FALSE;
    01440         }
    01441
    01442         if (FileName == NULL || ilStrLen(FileName) < 1) {
    01443                 ilSetError(IL_INVALID_PARAM);
    01444                 return IL_FALSE;
    01445         }
    01446
    01447         Ext = iGetExtension(FileName);
    01448
    01449         // Try registered procedures first (so users can override default lib functions).
    01450         if (Ext) {
    01451                 if (iRegisterLoad(FileName))
    01452                         return IL_TRUE;
    01453
    01454                 #ifndef IL_NO_TGA
    01455                 if (!iStrCmp(Ext, IL_TEXT("tga")) || !iStrCmp(Ext, IL_TEXT("vda")) ||
    01456                         !iStrCmp(Ext, IL_TEXT("icb")) || !iStrCmp(Ext, IL_TEXT("vst"))) {
    01457                         bRet = ilLoadTarga(FileName);
    01458                         goto finish;
    01459                 }
    01460                 #endif
    01461
    01462                 #ifndef IL_NO_JPG
    01463                 if (!iStrCmp(Ext, IL_TEXT("jpg")) || !iStrCmp(Ext, IL_TEXT("jpe")) ||
    01464                         !iStrCmp(Ext, IL_TEXT("jpeg"))) {
    01465                         bRet = ilLoadJpeg(FileName);
    01466                         goto finish;
    01467                 }
    01468                 #endif
    01469
    01470                 #ifndef IL_NO_JP2
    01471                 if (!iStrCmp(Ext, IL_TEXT("jp2"))) {
    01472                         bRet = ilLoadJp2(FileName);
    01473                         goto finish;
    01474                 }
    01475                 #endif
    01476
    01477                 #ifndef IL_NO_DDS
    01478                 if (!iStrCmp(Ext, IL_TEXT("dds"))) {
    01479                         bRet = ilLoadDds(FileName);
    01480                         goto finish;
    01481                 }
    01482                 #endif
    01483
    01484                 #ifndef IL_NO_PNG
    01485                 if (!iStrCmp(Ext, IL_TEXT("png"))) {
    01486                         bRet = ilLoadPng(FileName);
    01487                         goto finish;
    01488                 }
    01489                 #endif
    01490
    01491                 #ifndef IL_NO_BMP
    01492                 if (!iStrCmp(Ext, IL_TEXT("bmp")) || !iStrCmp(Ext, IL_TEXT("dib"))) {
    01493                         bRet = ilLoadBmp(FileName);
    01494                         goto finish;
    01495                 }
    01496                 #endif
    01497
    01498                 #ifndef IL_NO_EXR
    01499                 if (!iStrCmp(Ext, IL_TEXT("exr"))) {
    01500                         bRet = ilLoadExr(FileName);
    01501                         goto finish;
    01502                 }
    01503                 #endif
    01504
    01505                 #ifndef IL_NO_GIF
    01506                 if (!iStrCmp(Ext, IL_TEXT("gif"))) {
    01507                         bRet = ilLoadGif(FileName);
    01508                         goto finish;
    01509                 }
    01510                 #endif
    01511
    01512                 #ifndef IL_NO_HDR
    01513                 if (!iStrCmp(Ext, IL_TEXT("hdr"))) {
    01514                         bRet = ilLoadHdr(FileName);
    01515                         goto finish;
    01516                 }
    01517                 #endif
    01518
    01519                 #ifndef IL_NO_CUT
    01520                 if (!iStrCmp(Ext, IL_TEXT("cut"))) {
    01521                         bRet = ilLoadCut(FileName);
    01522                         goto finish;
    01523                 }
    01524                 #endif
    01525
    01526                 #ifndef IL_NO_DCX
    01527                 if (!iStrCmp(Ext, IL_TEXT("dcx"))) {
    01528                         bRet = ilLoadDcx(FileName);
    01529                         goto finish;
    01530                 }
    01531                 #endif
    01532
    01533                 #ifndef IL_NO_ICO
    01534                 if (!iStrCmp(Ext, IL_TEXT("ico")) || !iStrCmp(Ext, IL_TEXT("cur"))) {
    01535                         bRet = ilLoadIcon(FileName);
    01536                         goto finish;
    01537                 }
    01538                 #endif
    01539
    01540                 #ifndef IL_NO_IFF
    01541                 if (!iStrCmp(Ext, IL_TEXT("iff"))) {
    01542                         bRet = ilLoadIff(FileName);
    01543                         goto finish;
    01544                 }
    01545                 #endif
    01546
    01547                 #ifndef IL_NO_ICNS
    01548                 if (!iStrCmp(Ext, IL_TEXT("icns"))) {
    01549                         bRet = ilLoadIcns(FileName);
    01550                         goto finish;
    01551                 }
    01552                 #endif
    01553
    01554                 #ifndef IL_NO_LIF
    01555                 if (!iStrCmp(Ext, IL_TEXT("lif"))) {
    01556                         bRet = ilLoadLif(FileName);
    01557                         goto finish;
    01558                 }
    01559                 #endif
    01560
    01561                 #ifndef IL_NO_MDL
    01562                 if (!iStrCmp(Ext, IL_TEXT("mdl"))) {
    01563                         bRet = ilLoadMdl(FileName);
    01564                         goto finish;
    01565                 }
    01566                 #endif
    01567
    01568                 #ifndef IL_NO_MNG
    01569                 if (!iStrCmp(Ext, IL_TEXT("mng")) || !iStrCmp(Ext, IL_TEXT("jng"))) {
    01570                         bRet = ilLoadMng(FileName);
    01571                         goto finish;
    01572                 }
    01573                 #endif
    01574
    01575                 #ifndef IL_NO_PCD
    01576                 if (!iStrCmp(Ext, IL_TEXT("pcd"))) {
    01577                         bRet = ilLoadPcd(FileName);
    01578                         goto finish;
    01579                 }
    01580                 #endif
    01581
    01582                 #ifndef IL_NO_PCX
    01583                 if (!iStrCmp(Ext, IL_TEXT("pcx"))) {
    01584                         bRet = ilLoadPcx(FileName);
    01585                         goto finish;
    01586                 }
    01587                 #endif
    01588
    01589                 #ifndef IL_NO_PIC
    01590                 if (!iStrCmp(Ext, IL_TEXT("pic"))) {
    01591                         bRet = ilLoadPic(FileName);
    01592                         goto finish;
    01593                 }
    01594                 #endif
    01595
    01596                 #ifndef IL_NO_PIX
    01597                 if (!iStrCmp(Ext, IL_TEXT("pix"))) {
    01598                         bRet = ilLoadPix(FileName);
    01599                         goto finish;
    01600                 }
    01601                 #endif
    01602
    01603                 #ifndef IL_NO_PNM
    01604                 if (!iStrCmp(Ext, IL_TEXT("pbm"))) {
    01605                         bRet = ilLoadPnm(FileName);
    01606                         goto finish;
    01607                 }
    01608                 if (!iStrCmp(Ext, IL_TEXT("pgm"))) {
    01609                         bRet = ilLoadPnm(FileName);
    01610                         goto finish;
    01611                 }
    01612                 if (!iStrCmp(Ext, IL_TEXT("pnm"))) {
    01613                         bRet = ilLoadPnm(FileName);
    01614                         goto finish;
    01615                 }
    01616                 if (!iStrCmp(Ext, IL_TEXT("ppm"))) {
    01617                         bRet = ilLoadPnm(FileName);
    01618                         goto finish;
    01619                 }
    01620                 #endif
    01621
    01622                 #ifndef IL_NO_PSD
    01623                 if (!iStrCmp(Ext, IL_TEXT("psd")) || !iStrCmp(Ext, IL_TEXT("pdd"))) {
    01624                         bRet = ilLoadPsd(FileName);
    01625                         goto finish;
    01626                 }
    01627                 #endif
    01628
    01629                 #ifndef IL_NO_PSP
    01630                 if (!iStrCmp(Ext, IL_TEXT("psp"))) {
    01631                         bRet = ilLoadPsp(FileName);
    01632                         goto finish;
    01633                 }
    01634                 #endif
    01635
    01636                 #ifndef IL_NO_PXR
    01637                 if (!iStrCmp(Ext, IL_TEXT("pxr"))) {
    01638                         bRet = ilLoadPxr(FileName);
    01639                         goto finish;
    01640                 }
    01641                 #endif
    01642
    01643                 #ifndef IL_NO_SGI
    01644                 if (!iStrCmp(Ext, IL_TEXT("sgi")) || !iStrCmp(Ext, IL_TEXT("bw")) ||
    01645                         !iStrCmp(Ext, IL_TEXT("rgb")) || !iStrCmp(Ext, IL_TEXT("rgba"))) {
    01646                         bRet = ilLoadSgi(FileName);
    01647                         goto finish;
    01648                 }
    01649                 #endif
    01650
    01651                 #ifndef IL_NO_SUN
    01652                 if (!iStrCmp(Ext, IL_TEXT("sun")) || !iStrCmp(Ext, IL_TEXT("ras")) ||
    01653                         !iStrCmp(Ext, IL_TEXT("rs")) || !iStrCmp(Ext, IL_TEXT("im1")) ||
    01654                         !iStrCmp(Ext, IL_TEXT("im8")) || !iStrCmp(Ext, IL_TEXT("im24")) ||
    01655                         !iStrCmp(Ext, IL_TEXT("im32"))) {
    01656                         bRet = ilLoadSun(FileName);
    01657                         goto finish;
    01658                 }
    01659                 #endif
    01660
    01661                 #ifndef IL_NO_TIF
    01662                 if (!iStrCmp(Ext, IL_TEXT("tif")) || !iStrCmp(Ext, IL_TEXT("tiff"))) {
    01663                         bRet = ilLoadTiff(FileName);
    01664                         goto finish;
    01665                 }
    01666                 #endif
    01667
    01668                 #ifndef IL_NO_TPL
    01669                 if (!iStrCmp(Ext, IL_TEXT("tpl"))) {
    01670                         bRet = ilLoadTpl(FileName);
    01671                         goto finish;
    01672                 }
    01673                 #endif
    01674
    01675                 #ifndef IL_NO_VTF
    01676                 if (!iStrCmp(Ext, IL_TEXT("vtf"))) {
    01677                         bRet = ilLoadVtf(FileName);
    01678                         goto finish;
    01679                 }
    01680                 #endif
    01681
    01682                 #ifndef IL_NO_WAL
    01683                 if (!iStrCmp(Ext, IL_TEXT("wal"))) {
    01684                         bRet = ilLoadWal(FileName);
    01685                         goto finish;
    01686                 }
    01687                 #endif
    01688
    01689                 #ifndef IL_NO_WBMP
    01690                 if (!iStrCmp(Ext, IL_TEXT("wbmp"))) {
    01691                         bRet = ilLoadWbmp(FileName);
    01692                         goto finish;
    01693                 }
    01694                 #endif
    01695
    01696                 #ifndef IL_NO_WDP
    01697                 if (!iStrCmp(Ext, IL_TEXT("wdp")) || !iStrCmp(Ext, IL_TEXT("hdp")) ) {
    01698                         bRet = ilLoadWdp(FileName);
    01699                         goto finish;
    01700                 }
    01701                 #endif
    01702
    01703                 #ifndef IL_NO_XPM
    01704                 if (!iStrCmp(Ext, IL_TEXT("xpm"))) {
    01705                         bRet = ilLoadXpm(FileName);
    01706                         goto finish;
    01707                 }
    01708                 #endif
    01709         }
    01710
    01711         // As a last-ditch effort, try to identify the image
    01712         Type = ilDetermineType(FileName);
    01713         if (Type == IL_TYPE_UNKNOWN) {
    01714                 ilSetError(IL_INVALID_EXTENSION);
    01715                 return IL_FALSE;
    01716         }
    01717         return ilLoad(Type, FileName);
    01718
    01719 finish:
    01720         return bRet;
    01721 }
    01722
    01723
    01724 ILboolean ILAPIENTRY ilSave(ILenum Type, ILconst_string FileName)
    01725 {
    01726         switch (Type)
    01727         {
    01728                 case IL_TYPE_UNKNOWN:
    01729                         return ilSaveImage(FileName);
    01730
    01731                 #ifndef IL_NO_BMP
    01732                 case IL_BMP:
    01733                         return ilSaveBmp(FileName);
    01734                 #endif
    01735
    01736                 #ifndef IL_NO_CHEAD
    01737                 case IL_CHEAD:
    01738                         return ilSaveCHeader(FileName, "IL_IMAGE");
    01739                 #endif
    01740
    01741                 #ifndef IL_NO_DDS
    01742                 case IL_DDS:
    01743                 return ilSaveDds(FileName);
    01744                 #endif
    01745
    01746                 #ifndef IL_NO_EXR
    01747                 case IL_EXR:
    01748                 return ilSaveExr(FileName);
    01749                 #endif
    01750
    01751                 #ifndef IL_NO_HDR
    01752                 case IL_HDR:
    01753                         return ilSaveHdr(FileName);
    01754                 #endif
    01755
    01756                 #ifndef IL_NO_JP2
    01757                 case IL_JP2:
    01758                         return ilSaveJp2(FileName);
    01759                 #endif
    01760
    01761                 #ifndef IL_NO_JPG
    01762                 case IL_JPG:
    01763                         return ilSaveJpeg(FileName);
    01764                 #endif
    01765
    01766                 #ifndef IL_NO_PCX
    01767                 case IL_PCX:
    01768                         return ilSavePcx(FileName);
    01769                 #endif
    01770
    01771                 #ifndef IL_NO_PNG
    01772                 case IL_PNG:
    01773                         return ilSavePng(FileName);
    01774                 #endif
    01775
    01776                 #ifndef IL_NO_PNM
    01777                 case IL_PNM:
    01778                         return ilSavePnm(FileName);
    01779                 #endif
    01780
    01781                 #ifndef IL_NO_PSD
    01782                 case IL_PSD:
    01783                         return ilSavePsd(FileName);
    01784                 #endif
    01785
    01786                 #ifndef IL_NO_RAW
    01787                 case IL_RAW:
    01788                         return ilSaveRaw(FileName);
    01789                 #endif
    01790
    01791                 #ifndef IL_NO_SGI
    01792                 case IL_SGI:
    01793                         return ilSaveSgi(FileName);
    01794                 #endif
    01795
    01796                 #ifndef IL_NO_TGA
    01797                 case IL_TGA:
    01798                         return ilSaveTarga(FileName);
    01799                 #endif
    01800
    01801                 #ifndef IL_NO_TIF
    01802                 case IL_TIF:
    01803                         return ilSaveTiff(FileName);
    01804                 #endif
    01805
    01806                 #ifndef IL_NO_WBMP
    01807                 case IL_WBMP:
    01808                         return ilSaveWbmp(FileName);
    01809                 #endif
    01810
    01811                 case IL_JASC_PAL:
    01812                         return ilSaveJascPal(FileName);
    01813         }
    01814
    01815         ilSetError(IL_INVALID_ENUM);
    01816         return IL_FALSE;
    01817 }
    01818
    01819
    01820 ILuint ILAPIENTRY ilSaveF(ILenum Type, ILHANDLE File)
    01821 {
    01822         ILboolean Ret;
    01823
    01824         if (File == NULL) {
    01825                 ilSetError(IL_INVALID_PARAM);
    01826                 return 0;
    01827         }
    01828
    01829         switch (Type)
    01830         {
    01831                 #ifndef IL_NO_BMP
    01832                 case IL_BMP:
    01833                         Ret = ilSaveBmpF(File);
    01834                         break;
    01835                 #endif
    01836
    01837                 #ifndef IL_NO_DDS
    01838                 case IL_DDS:
    01839                         Ret = ilSaveDdsF(File);
    01840                         break;
    01841                 #endif
    01842
    01843                 #ifndef IL_NO_EXR
    01844                 case IL_EXR:
    01845                         Ret = ilSaveExrF(File);
    01846                         break;
    01847                 #endif
    01848
    01849                 #ifndef IL_NO_HDR
    01850                 case IL_HDR:
    01851                         Ret = ilSaveHdrF(File);
    01852                         break;
    01853                 #endif
    01854
    01855                 #ifndef IL_NO_JP2
    01856                 case IL_JP2:
    01857                         Ret = ilSaveJp2F(File);
    01858                         break;
    01859                 #endif
    01860
    01861                 #ifndef IL_NO_JPG
    01862                         #ifndef IL_USE_IJL
    01863                         case IL_JPG:
    01864                                 Ret = ilSaveJpegF(File);
    01865                                 break;
    01866                         #endif
    01867                 #endif
    01868
    01869                 #ifndef IL_NO_PNM
    01870                 case IL_PNM:
    01871                         Ret = ilSavePnmF(File);
    01872                         break;
    01873                 #endif
    01874
    01875                 #ifndef IL_NO_PNG
    01876                 case IL_PNG:
    01877                         Ret = ilSavePngF(File);
    01878                         break;
    01879                 #endif
    01880
    01881                 #ifndef IL_NO_PSD
    01882                 case IL_PSD:
    01883                         Ret = ilSavePsdF(File);
    01884                         break;
    01885                 #endif
    01886
    01887                 #ifndef IL_NO_RAW
    01888                 case IL_RAW:
    01889                         Ret = ilSaveRawF(File);
    01890                         break;
    01891                 #endif
    01892
    01893                 #ifndef IL_NO_SGI
    01894                 case IL_SGI:
    01895                         Ret = ilSaveSgiF(File);
    01896                         break;
    01897                 #endif
    01898
    01899                 #ifndef IL_NO_TGA
    01900                 case IL_TGA:
    01901                         Ret = ilSaveTargaF(File);
    01902                         break;
    01903                 #endif
    01904
    01905                 #ifndef IL_NO_WBMP
    01906                 case IL_WBMP:
    01907                         Ret = ilSaveWbmpF(File);
    01908                         break;
    01909                 #endif
    01910
    01911                 #ifndef IL_NO_TIF
    01912                 case IL_TIF:
    01913                         Ret = ilSaveTiffF(File);
    01914                         break;
    01915                 #endif
    01916
    01917                 default:
    01918                         ilSetError(IL_INVALID_ENUM);
    01919                         return 0;
    01920         }
    01921
    01922         if (Ret == IL_FALSE)
    01923                 return 0;
    01924
    01925         return itellw();
    01926 }
    01927
    01928
    01929 ILuint ILAPIENTRY ilSaveL(ILenum Type, void *Lump, ILuint Size)
    01930 {
    01931         ILboolean Ret;
    01932
    01933         if (Lump == NULL) {
    01934                 if (Size != 0) {
    01935                         ilSetError(IL_INVALID_PARAM);
    01936                         return 0;
    01937                 }
    01938                 // The user wants to know how large of a buffer they need.
    01939                 else {
    01940                         return ilDetermineSize(Type);
    01941                 }
    01942         }
    01943
    01944         switch (Type)
    01945         {
    01946                 #ifndef IL_NO_BMP
    01947                 case IL_BMP:
    01948                         Ret = ilSaveBmpL(Lump, Size);
    01949                         break;
    01950                 #endif
    01951
    01952                 #ifndef IL_NO_EXR
    01953                 case IL_EXR:
    01954                         Ret = ilSaveExrL(Lump, Size);
    01955                         break;
    01956                 #endif
    01957
    01958                 #ifndef IL_NO_HDR
    01959                 case IL_HDR:
    01960                         Ret = ilSaveHdrL(Lump, Size);
    01961                         break;
    01962                 #endif
    01963
    01964                 #ifndef IL_NO_JP2
    01965                 case IL_JP2:
    01966                         Ret = ilSaveJp2L(Lump, Size);
    01967                         break;
    01968                 #endif
    01969
    01970                 #ifndef IL_NO_JPG
    01971                 case IL_JPG:
    01972                         Ret = ilSaveJpegL(Lump, Size);
    01973                         break;
    01974                 #endif
    01975
    01976                 #ifndef IL_NO_PNG
    01977                 case IL_PNG:
    01978                         Ret = ilSavePngL(Lump, Size);
    01979                         break;
    01980                 #endif
    01981
    01982                 #ifndef IL_NO_PNM
    01983                 case IL_PNM:
    01984                         Ret = ilSavePnmL(Lump, Size);
    01985                         break;
    01986                 #endif
    01987
    01988                 #ifndef IL_NO_PSD
    01989                 case IL_PSD:
    01990                         Ret = ilSavePsdL(Lump, Size);
    01991                         break;
    01992                 #endif
    01993
    01994                 #ifndef IL_NO_RAW
    01995                 case IL_RAW:
    01996                         Ret = ilSaveRawL(Lump, Size);
    01997                         break;
    01998                 #endif
    01999
    02000                 #ifndef IL_NO_SGI
    02001                 case IL_SGI:
    02002                         Ret = ilSaveSgiL(Lump, Size);
    02003                         break;
    02004                 #endif
    02005
    02006                 #ifndef IL_NO_TGA
    02007                 case IL_TGA:
    02008                         Ret = ilSaveTargaL(Lump, Size);
    02009                         break;
    02010                 #endif
    02011
    02012                 #ifndef IL_NO_DDS
    02013                 case IL_DDS:
    02014                         Ret = ilSaveDdsL(Lump, Size);
    02015                         break;
    02016                 #endif
    02017
    02018                 #ifndef IL_NO_WBMP
    02019                 case IL_WBMP:
    02020                         Ret = ilSaveWbmpL(Lump, Size);
    02021                         break;
    02022                 #endif
    02023
    02024                 #ifndef IL_NO_TIF
    02025                 case IL_TIF:
    02026                         Ret = ilSaveTiffL(Lump, Size);
    02027                         break;
    02028                 #endif
    02029
    02030                 default:
    02031                         ilSetError(IL_INVALID_ENUM);
    02032                         return 0;
    02033         }
    02034
    02035         if (Ret == IL_FALSE)
    02036                 return 0;
    02037
    02038         return itellw();
    02039 }
    02040
    02041
    02043 //      the current image based on the extension given in FileName.
    02044 ILboolean ILAPIENTRY ilSaveImage(ILconst_string FileName)
    02045 {
    02046         ILstring Ext;
    02047         ILboolean       bRet = IL_FALSE;
    02048
    02049         if (FileName == NULL || ilStrLen(FileName) < 1) {
    02050                 ilSetError(IL_INVALID_PARAM);
    02051                 return IL_FALSE;
    02052         }
    02053
    02054         if (iCurImage == NULL) {
    02055                 ilSetError(IL_ILLEGAL_OPERATION);
    02056                 return IL_FALSE;
    02057         }
    02058
    02059         Ext = iGetExtension(FileName);
    02060         if (Ext == NULL) {
    02061                 ilSetError(IL_INVALID_PARAM);
    02062                 return IL_FALSE;
    02063         }
    02064
    02065         #ifndef IL_NO_BMP
    02066         if (!iStrCmp(Ext, IL_TEXT("bmp"))) {
    02067                 bRet = ilSaveBmp(FileName);
    02068                 goto finish;
    02069         }
    02070         #endif
    02071
    02072         #ifndef IL_NO_CHEAD
    02073         if (!iStrCmp(Ext, IL_TEXT("h"))) {
    02074                 bRet = ilSaveCHeader(FileName, "IL_IMAGE");
    02075                 goto finish;
    02076         }
    02077         #endif
    02078
    02079         #ifndef IL_NO_DDS
    02080         if (!iStrCmp(Ext, IL_TEXT("dds"))) {
    02081                 bRet = ilSaveDds(FileName);
    02082                 goto finish;
    02083         }
    02084         #endif
    02085
    02086         #ifndef IL_NO_EXR
    02087         if (!iStrCmp(Ext, IL_TEXT("exr"))) {
    02088                 bRet = ilSaveExr(FileName);
    02089                 goto finish;
    02090         }
    02091         #endif
    02092
    02093         #ifndef IL_NO_HDR
    02094         if (!iStrCmp(Ext, IL_TEXT("hdr"))) {
    02095                 bRet = ilSaveHdr(FileName);
    02096                 goto finish;
    02097         }
    02098         #endif
    02099
    02100         #ifndef IL_NO_JP2
    02101         if (!iStrCmp(Ext, IL_TEXT("jp2"))) {
    02102                 bRet = ilSaveJp2(FileName);
    02103                 goto finish;
    02104         }
    02105         #endif
    02106
    02107         #ifndef IL_NO_JPG
    02108         if (!iStrCmp(Ext, IL_TEXT("jpg")) || !iStrCmp(Ext, IL_TEXT("jpeg")) || !iStrCmp(Ext, IL_TEXT("jpe"))) {
    02109                 bRet = ilSaveJpeg(FileName);
    02110                 goto finish;
    02111         }
    02112         #endif
    02113
    02114         #ifndef IL_NO_PCX
    02115         if (!iStrCmp(Ext, IL_TEXT("pcx"))) {
    02116                 bRet = ilSavePcx(FileName);
    02117                 goto finish;
    02118         }
    02119         #endif
    02120
    02121         #ifndef IL_NO_PNG
    02122         if (!iStrCmp(Ext, IL_TEXT("png"))) {
    02123                 bRet = ilSavePng(FileName);
    02124                 goto finish;
    02125         }
    02126         #endif
    02127
    02128         #ifndef IL_NO_PNM  // Not sure if binary or ascii should be defaulted...maybe an option?
    02129         if (!iStrCmp(Ext, IL_TEXT("pbm"))) {
    02130                 bRet = ilSavePnm(FileName);
    02131                 goto finish;
    02132         }
    02133         if (!iStrCmp(Ext, IL_TEXT("pgm"))) {
    02134                 bRet = ilSavePnm(FileName);
    02135                 goto finish;
    02136         }
    02137         if (!iStrCmp(Ext, IL_TEXT("ppm"))) {
    02138                 bRet = ilSavePnm(FileName);
    02139                 goto finish;
    02140         }
    02141         #endif
    02142
    02143         #ifndef IL_NO_PSD
    02144         if (!iStrCmp(Ext, IL_TEXT("psd"))) {
    02145                 bRet = ilSavePsd(FileName);
    02146                 goto finish;
    02147         }
    02148         #endif
    02149
    02150         #ifndef IL_NO_RAW
    02151         if (!iStrCmp(Ext, IL_TEXT("raw"))) {
    02152                 bRet = ilSaveRaw(FileName);
    02153                 goto finish;
    02154         }
    02155         #endif
    02156
    02157         #ifndef IL_NO_SGI
    02158         if (!iStrCmp(Ext, IL_TEXT("sgi")) || !iStrCmp(Ext, IL_TEXT("bw")) ||
    02159                 !iStrCmp(Ext, IL_TEXT("rgb")) || !iStrCmp(Ext, IL_TEXT("rgba"))) {
    02160                 bRet = ilSaveSgi(FileName);
    02161                 goto finish;
    02162         }
    02163         #endif
    02164
    02165         #ifndef IL_NO_TGA
    02166         if (!iStrCmp(Ext, IL_TEXT("tga"))) {
    02167                 bRet = ilSaveTarga(FileName);
    02168                 goto finish;
    02169         }
    02170         #endif
    02171
    02172         #ifndef IL_NO_TIF
    02173         if (!iStrCmp(Ext, IL_TEXT("tif")) || !iStrCmp(Ext, IL_TEXT("tiff"))) {
    02174                 bRet = ilSaveTiff(FileName);
    02175                 goto finish;
    02176         }
    02177         #endif
    02178
    02179         #ifndef IL_NO_WBMP
    02180         if (!iStrCmp(Ext, IL_TEXT("wbmp"))) {
    02181                 bRet = ilSaveWbmp(FileName);
    02182                 goto finish;
    02183         }
    02184         #endif
    02185
    02186         #ifndef IL_NO_MNG
    02187         if (!iStrCmp(Ext, IL_TEXT("mng"))) {
    02188                 bRet = ilSaveMng(FileName);
    02189                 goto finish;
    02190         }
    02191         #endif
    02192
    02193         // Check if we just want to save the palette.
    02194         if (!iStrCmp(Ext, IL_TEXT("pal"))) {
    02195                 bRet = ilSavePal(FileName);
    02196                 goto finish;
    02197         }
    02198
    02199         // Try registered procedures
    02200         if (iRegisterSave(FileName))
    02201                 return IL_TRUE;
    02202
    02203         ilSetError(IL_INVALID_EXTENSION);
    02204         return IL_FALSE;
    02205
    02206 finish:
    02207         return bRet;
    02208 }