← Back to branch summary

~ubuntu-branches/ubuntu/precise/devil/precise

« back to all changes in this revision

Viewing changes to src-IL/include/il_internal.h

  • Committer: Bazaar Package Importer
  • Author(s): Bradley Smith
  • Date: 2009-01-17 15:01:18 UTC
  • mfrom: (6.1.3 sid)
  • Revision ID: james.westby@ubuntu.com-20090117150118-4bwb6nmvbz4srsjl
Tags: 1.7.5-4
http://bugs.debian.org/512122
Actually fix CVE-2008-5262. Closes: #512122.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src-IL/include/il_internal.h
1
1
//-----------------------------------------------------------------------------
2
2
//
3
3
// ImageLib Sources
4
 
// Copyright (C) 2000-2002 by Denton Woods
5
 
// Last modified: 02/19/2002 <--Y2K Compliant! =]
 
4
// Copyright (C) 2000-2008 by Denton Woods
 
5
// Last modified: 12/14/2008
6
6
//
7
7
// Filename: src-IL/include/il_internal.h
8
8
//
13
13
#define INTERNAL_H
14
14
#define _IL_BUILD_LIBRARY
15
15
 
 
16
 
 
17
// Local headers
 
18
#if (defined(_WIN32) || defined(_WIN64)) && !defined(HAVE_CONFIG_H)
 
19
        #define HAVE_CONFIG_H
 
20
#endif
 
21
#ifdef HAVE_CONFIG_H
 
22
#include <IL/config.h>
 
23
#endif
 
24
 
16
25
// Standard headers
17
26
#include <stdlib.h>
18
27
#include <stdio.h>
19
28
#include <math.h>
20
29
#include <string.h>
21
30
 
22
 
// Local headers
23
 
#if defined(_WIN32) && !defined(HAVE_CONFIG_H)
24
 
#define HAVE_CONFIG_H
25
 
#endif
26
 
#ifdef HAVE_CONFIG_H
27
 
        #include <IL/config.h>
28
 
#endif
 
31
#ifdef __cplusplus
 
32
extern "C" {
 
33
#endif
 
34
 
29
35
#include <IL/il.h>
30
36
#include <IL/devil_internal_exports.h>
31
37
#include "il_files.h"
41
47
                        #pragma intrinsic(strcmp)
42
48
                        #pragma intrinsic(strlen)
43
49
                        #pragma intrinsic(strcpy)
44
 
                        /*
45
 
                        #if _MSC_VER >= 1300  // Erroneous size_t conversion warnings
46
 
                                pragma warning(disable : 4267)
 
50
                        
 
51
                        #if _MSC_VER >= 1300
 
52
                                #pragma warning(disable : 4996)  // MSVC++ 8/9 deprecation warnings
47
53
                        #endif
48
 
                        pragma comment(linker, "/NODEFAULTLIB:libc")
49
 
                        pragma comment(linker, "/NODEFAULTLIB:libcd")
50
 
                        pragma comment(linker, "/NODEFAULTLIB:libcmt.lib")
51
 
                        #ifdef _DEBUG
52
 
                                pragma comment(linker, "/NODEFAULTLIB:libcmtd")
53
 
                                pragma comment(linker, "/NODEFAULTLIB:msvcrt.lib")
54
 
                        #endif // _DEBUG
55
 
                        */
 
54
                        //pragma comment(linker, "/NODEFAULTLIB:libc")
 
55
                        //pragma comment(linker, "/NODEFAULTLIB:libcd")
 
56
                        //pragma comment(linker, "/NODEFAULTLIB:libcmt.lib")
 
57
                        //#ifdef _DEBUG
 
58
                        //      pragma comment(linker, "/NODEFAULTLIB:libcmtd")
 
59
                        //      pragma comment(linker, "/NODEFAULTLIB:msvcrt.lib")
 
60
                        //#endif // _DEBUG
56
61
                #endif // _MSC_VER > 1000
57
62
        #endif
58
63
        #define WIN32_LEAN_AND_MEAN  // Exclude rarely-used stuff from Windows headers
70
75
        #define IL_TEXT(s) (s)
71
76
        #define TEXT(s) (s)
72
77
#endif*/
 
78
 
73
79
#ifdef _UNICODE
74
80
        #define IL_TEXT(s) L##s
 
81
        #ifndef _WIN32  // At least in Linux, fopen works fine, and wcsicmp is not defined.
 
82
                #define wcsicmp wcsncasecmp
 
83
                #define _wcsicmp wcsncasecmp
 
84
                #define _wfopen fopen
 
85
        #endif
 
86
        #define iStrCpy wcscpy
75
87
#else
76
88
        #define IL_TEXT(s) (s)
 
89
        #define iStrCpy strcpy
77
90
#endif
 
91
 
78
92
#ifdef IL_INLINE_ASM
79
 
        #ifdef _MSC_VER  // MSVC++ only
 
93
        #if (defined (_MSC_VER) && defined(_WIN32))  // MSVC++ only
80
94
                #define USE_WIN32_ASM
81
95
        #endif
 
96
 
 
97
        #ifdef _WIN64
 
98
                #undef USE_WIN32_ASM
 
99
        //@TODO: Windows 64 compiler cannot use inline ASM, so we need to
 
100
        //  generate some MASM code at some point.
 
101
        #endif
82
102
#endif
83
103
extern ILimage *iCurImage;
84
104
#define BIT_0   0x00000001
118
138
        int stricmp(const char *src1, const char *src2);
119
139
        int strnicmp(const char *src1, const char *src2, size_t max);
120
140
#endif//_WIN32
121
 
int iStrCmp(const ILstring src1, const ILstring src2);
 
141
int iStrCmp(ILconst_string src1, ILconst_string src2);
 
142
 
122
143
//
123
144
// Some math functions
124
145
//
130
151
//
131
152
// Useful miscellaneous functions
132
153
//
133
 
ILboolean       iCheckExtension(const ILstring Arg, const ILstring Ext);
 
154
ILboolean       iCheckExtension(ILconst_string Arg, ILconst_string Ext);
134
155
ILbyte*         iFgets(char *buffer, ILuint maxlen);
135
 
ILboolean       iFileExists(const ILstring FileName);
136
 
ILstring        iGetExtension(const ILstring FileName);
137
 
char*           ilStrDup(const char *Str);
138
 
ILuint          ilStrLen(const char *Str);
 
156
ILboolean       iFileExists(ILconst_string FileName);
 
157
ILstring        iGetExtension(ILconst_string FileName);
 
158
ILstring        ilStrDup(ILconst_string Str);
 
159
ILuint          ilStrLen(ILconst_string Str);
 
160
ILuint          ilCharStrLen(const char *Str);
139
161
// Miscellaneous functions
140
 
ILvoid                                  ilDefaultStates(ILvoid);
 
162
void                                    ilDefaultStates(void);
141
163
ILenum                                  iGetHint(ILenum Target);
142
164
ILint                                   iGetInt(ILenum Mode);
143
 
ILvoid                                  ilRemoveRegistered(ILvoid);
144
 
ILAPI ILvoid ILAPIENTRY ilSetCurImage(ILimage *Image);
 
165
void                                    ilRemoveRegistered(void);
 
166
ILAPI void ILAPIENTRY   ilSetCurImage(ILimage *Image);
145
167
//
146
168
// Rle compression
147
169
//
151
173
#define     IL_BMPCOMP 0x04
152
174
ILboolean       ilRleCompressLine(ILubyte *ScanLine, ILuint Width, ILubyte Bpp, ILubyte *Dest, ILuint *DestWidth, ILenum CompressMode);
153
175
ILuint          ilRleCompress(ILubyte *Data, ILuint Width, ILuint Height, ILuint Depth, ILubyte Bpp, ILubyte *Dest, ILenum CompressMode, ILuint *ScanTable);
154
 
ILvoid          iSetImage0(ILvoid);
 
176
void            iSetImage0(void);
155
177
// Conversion functions
156
 
ILboolean       ilAddAlpha(ILvoid);
 
178
ILboolean       ilAddAlpha(void);
157
179
ILboolean       ilAddAlphaKey(ILimage *Image);
158
180
ILboolean       iFastConvert(ILenum DestFormat);
159
 
ILboolean       ilFixImage(ILvoid);
160
 
ILboolean       ilRemoveAlpha(ILvoid);
161
 
ILboolean       ilSwapColours(ILvoid);
 
181
ILboolean       ilFixImage(void);
 
182
ILboolean       ilRemoveAlpha(void);
 
183
ILboolean       ilSwapColours(void);
162
184
// Miscellaneous functions
163
 
char *iGetString(ILenum StringName);  // Internal version of ilGetString
 
185
char*           iGetString(ILenum StringName);  // Internal version of ilGetString
164
186
// Library usage
165
187
#if _MSC_VER && !_WIN32_WCE
166
188
        #ifndef IL_NO_JPG
170
192
                        #ifndef IL_DEBUG
171
193
                                //pragma comment(lib, "libjpeg.lib")
172
194
                        #else
173
 
                                //ragma comment(lib, "debug/libjpeg.lib")
 
195
                                //pragma comment(lib, "debug/libjpeg.lib")
174
196
                        #endif
175
197
                #endif
176
198
        #endif
208
230
//
209
231
// Image loading/saving functions
210
232
//
211
 
ILboolean ilIsValidBmp(const ILstring FileName);
 
233
ILboolean ilIsValidBmp(ILconst_string CONST_RESTRICT FileName);
212
234
ILboolean ilIsValidBmpF(ILHANDLE File);
213
 
ILboolean ilIsValidBmpL(const ILvoid *Lump, ILuint Size);
214
 
ILboolean ilLoadBmp(const ILstring FileName);
 
235
ILboolean ilIsValidBmpL(const void *Lump, const ILuint Size);
 
236
ILboolean ilLoadBmp(ILconst_string FileName);
215
237
ILboolean ilLoadBmpF(ILHANDLE File);
216
 
ILboolean ilLoadBmpL(const ILvoid *Lump, ILuint Size);
217
 
ILboolean ilSaveBmp(const ILstring FileName);
 
238
ILboolean ilLoadBmpL(const void *Lump, const ILuint Size);
 
239
ILboolean ilSaveBmp(ILconst_string FileName);
218
240
ILboolean ilSaveBmpF(ILHANDLE File);
219
 
ILboolean ilSaveBmpL(ILvoid *Lump, ILuint Size);
220
 
ILboolean ilSaveCHeader(const ILstring FileName, const char *InternalName);
221
 
ILboolean ilLoadCut(const ILstring FileName);
 
241
ILboolean ilSaveBmpL(void *Lump, ILuint Size);
 
242
ILboolean ilSaveCHeader(ILconst_string FileName, char *InternalName);
 
243
ILboolean ilLoadCut(ILconst_string FileName);
222
244
ILboolean ilLoadCutF(ILHANDLE File);
223
 
ILboolean ilLoadCutL(const ILvoid *Lump, ILuint Size);
224
 
ILboolean ilIsValidDcx(const ILstring FileName);
 
245
ILboolean ilLoadCutL(const void *Lump, ILuint Size);
 
246
ILboolean ilIsValidDcx(ILconst_string FileName);
225
247
ILboolean ilIsValidDcxF(ILHANDLE File);
226
 
ILboolean ilIsValidDcxL(const ILvoid *Lump, ILuint Size);
227
 
ILboolean ilLoadDcx(const ILstring FileName);
 
248
ILboolean ilIsValidDcxL(const void *Lump, ILuint Size);
 
249
ILboolean ilLoadDcx(ILconst_string FileName);
228
250
ILboolean ilLoadDcxF(ILHANDLE File);
229
 
ILboolean ilLoadDcxL(const ILvoid *Lump, ILuint Size);
230
 
ILboolean ilIsValidDds(const ILstring FileName);
 
251
ILboolean ilLoadDcxL(const void *Lump, ILuint Size);
 
252
ILboolean ilIsValidDds(ILconst_string FileName);
231
253
ILboolean ilIsValidDdsF(ILHANDLE File);
232
 
ILboolean ilIsValidDdsL(const ILvoid *Lump, ILuint Size);
233
 
ILboolean ilLoadDds(const ILstring FileName);
 
254
ILboolean ilIsValidDdsL(const void *Lump, ILuint Size);
 
255
ILboolean ilLoadDds(ILconst_string FileName);
234
256
ILboolean ilLoadDdsF(ILHANDLE File);
235
 
ILboolean ilLoadDdsL(const ILvoid *Lump, ILuint Size);
236
 
ILboolean ilSaveDds(const ILstring FileName);
 
257
ILboolean ilLoadDdsL(const void *Lump, ILuint Size);
 
258
ILboolean ilSaveDds(ILconst_string FileName);
237
259
ILboolean ilSaveDdsF(ILHANDLE File);
238
 
ILboolean ilSaveDdsL(ILvoid *Lump, ILuint Size);
239
 
ILboolean ilLoadDoom(const ILstring FileName);
 
260
ILboolean ilSaveDdsL(void *Lump, ILuint Size);
 
261
ILboolean ilLoadDoom(ILconst_string FileName);
240
262
ILboolean ilLoadDoomF(ILHANDLE File);
241
 
ILboolean ilLoadDoomL(const ILvoid *Lump, ILuint Size);
242
 
ILboolean ilLoadDoomFlat(const ILstring FileName);
 
263
ILboolean ilLoadDoomL(const void *Lump, ILuint Size);
 
264
ILboolean ilLoadDoomFlat(ILconst_string FileName);
243
265
ILboolean ilLoadDoomFlatF(ILHANDLE File);
244
 
ILboolean ilLoadDoomFlatL(const ILvoid *Lump, ILuint Size);
245
 
ILboolean ilIsValidGif(const ILstring FileName);
 
266
ILboolean ilLoadDoomFlatL(const void *Lump, ILuint Size);
 
267
ILboolean ilIsValidGif(ILconst_string FileName);
246
268
ILboolean ilIsValidGifF(ILHANDLE File);
247
 
ILboolean ilIsValidGifL(const ILvoid *Lump, ILuint Size);
248
 
ILboolean ilLoadGif(const ILstring FileName);
 
269
ILboolean ilIsValidGifL(const void *Lump, ILuint Size);
 
270
ILboolean ilLoadGif(ILconst_string FileName);
249
271
ILboolean ilLoadGifF(ILHANDLE File);
250
 
ILboolean ilLoadGifL(const ILvoid *Lump, ILuint Size);
251
 
ILboolean ilIsValidHdr(const ILstring FileName);
 
272
ILboolean ilLoadGifL(const void *Lump, ILuint Size);
 
273
ILboolean ilIsValidHdr(ILconst_string FileName);
252
274
ILboolean ilIsValidHdrF(ILHANDLE File);
253
 
ILboolean ilIsValidHdrL(const ILvoid *Lump, ILuint Size);
254
 
ILboolean ilLoadHdr(const ILstring FileName);
 
275
ILboolean ilIsValidHdrL(const void *Lump, ILuint Size);
 
276
ILboolean ilLoadHdr(ILconst_string FileName);
255
277
ILboolean ilLoadHdrF(ILHANDLE File);
256
 
ILboolean ilLoadHdrL(const ILvoid *Lump, ILuint Size);
257
 
ILboolean ilLoadIcon(const ILstring FileName);
 
278
ILboolean ilLoadHdrL(const void *Lump, ILuint Size);
 
279
ILboolean ilSaveHdr(ILconst_string FileName);
 
280
ILboolean ilSaveHdrF(ILHANDLE File);
 
281
ILboolean ilSaveHdrL(void *Lump, ILuint Size);
 
282
ILboolean ilLoadIcon(ILconst_string FileName);
258
283
ILboolean ilLoadIconF(ILHANDLE File);
259
 
ILboolean ilLoadIconL(const ILvoid *Lump, ILuint Size);
260
 
ILboolean ilIsValidJpg(const ILstring FileName);
 
284
ILboolean ilLoadIconL(const void *Lump, ILuint Size);
 
285
ILboolean ilLoadIcns(ILconst_string FileName);
 
286
ILboolean ilLoadIcnsF(ILHANDLE File);
 
287
ILboolean ilLoadIcnsL(const void *Lump, ILuint Size);
 
288
ILboolean ilIsValidJpg(ILconst_string FileName);
261
289
ILboolean ilIsValidJpgF(ILHANDLE File);
262
 
ILboolean ilIsValidJpgL(const ILvoid *Lump, ILuint Size);
263
 
ILboolean ilLoadJpeg(const ILstring FileName);
 
290
ILboolean ilIsValidJpgL(const void *Lump, ILuint Size);
 
291
ILboolean ilLoadJp2(ILconst_string FileName);
 
292
ILboolean ilLoadJp2F(ILHANDLE File);
 
293
ILboolean ilLoadJp2L(const void *Lump, ILuint Size);
 
294
ILboolean ilLoadJp2LInternal(const void *Lump, ILuint Size, ILimage *Image);
 
295
ILboolean ilLoadJpeg(ILconst_string FileName);
264
296
ILboolean ilLoadJpegF(ILHANDLE File);
265
 
ILboolean ilLoadJpegL(const ILvoid *Lump, ILuint Size);
266
 
ILboolean ilSaveJpeg(const ILstring FileName);
 
297
ILboolean ilLoadJpegL(const void *Lump, ILuint Size);
 
298
ILboolean ilSaveJpeg(ILconst_string FileName);
267
299
ILboolean ilSaveJpegF(ILHANDLE File);
268
 
ILboolean ilSaveJpegL(ILvoid *Lump, ILuint Size);
269
 
ILboolean ilIsValidLif(const ILstring FileName);
 
300
ILboolean ilSaveJpegL(void *Lump, ILuint Size);
 
301
ILboolean ilIsValidLif(ILconst_string FileName);
270
302
ILboolean ilIsValidLifF(ILHANDLE File);
271
 
ILboolean ilIsValidLifL(const ILvoid *Lump, ILuint Size);
272
 
ILboolean ilLoadLif(const ILstring FileName);
 
303
ILboolean ilIsValidLifL(const void *Lump, ILuint Size);
 
304
ILboolean ilLoadLif(ILconst_string FileName);
273
305
ILboolean ilLoadLifF(ILHANDLE File);
274
 
ILboolean ilLoadLifL(const ILvoid *Lump, ILuint Size);
275
 
ILboolean ilLoadMdl(const ILstring FileName);
 
306
ILboolean ilLoadLifL(const void *Lump, ILuint Size);
 
307
ILboolean ilLoadMdl(ILconst_string FileName);
276
308
ILboolean ilLoadMdlF(ILHANDLE File);
277
 
ILboolean ilLoadMdlL(const ILvoid *Lump, ILuint Size);
278
 
ILboolean ilLoadMng(const ILstring FileName);
 
309
ILboolean ilLoadMdlL(const void *Lump, ILuint Size);
 
310
ILboolean ilLoadMng(ILconst_string FileName);
279
311
ILboolean ilLoadMngF(ILHANDLE File);
280
 
ILboolean ilLoadMngL(const ILvoid *Lump, ILuint Size);
281
 
ILboolean ilSaveMng(const ILstring FileName);
 
312
ILboolean ilLoadMngL(const void *Lump, ILuint Size);
 
313
ILboolean ilSaveMng(ILconst_string FileName);
282
314
ILboolean ilSaveMngF(ILHANDLE File);
283
 
ILboolean ilSaveMngL(ILvoid *Lump, ILuint Size);
284
 
ILboolean ilLoadPcd(const ILstring FileName);
 
315
ILboolean ilSaveMngL(void *Lump, ILuint Size);
 
316
ILboolean ilLoadPcd(ILconst_string FileName);
285
317
ILboolean ilLoadPcdF(ILHANDLE File);
286
 
ILboolean ilLoadPcdL(const ILvoid *Lump, ILuint Size);
287
 
ILboolean ilIsValidPcx(const ILstring FileName);
 
318
ILboolean ilLoadPcdL(const void *Lump, ILuint Size);
 
319
ILboolean ilIsValidPcx(ILconst_string FileName);
288
320
ILboolean ilIsValidPcxF(ILHANDLE File);
289
 
ILboolean ilIsValidPcxL(const ILvoid *Lump, ILuint Size);
290
 
ILboolean ilLoadPcx(const ILstring FileName);
 
321
ILboolean ilIsValidPcxL(const void *Lump, ILuint Size);
 
322
ILboolean ilLoadPcx(ILconst_string FileName);
291
323
ILboolean ilLoadPcxF(ILHANDLE File);
292
 
ILboolean ilLoadPcxL(const ILvoid *Lump, ILuint Size);
293
 
ILboolean ilSavePcx(const ILstring FileName);
 
324
ILboolean ilLoadPcxL(const void *Lump, ILuint Size);
 
325
ILboolean ilSavePcx(ILconst_string FileName);
294
326
ILboolean ilSavePcxF(ILHANDLE File);
295
 
ILboolean ilSavePcxL(ILvoid *Lump, ILuint Size);
296
 
ILboolean ilIsValidPic(const ILstring FileName);
 
327
ILboolean ilSavePcxL(void *Lump, ILuint Size);
 
328
ILboolean ilIsValidPic(ILconst_string FileName);
297
329
ILboolean ilIsValidPicF(ILHANDLE File);
298
 
ILboolean ilIsValidPicL(const ILvoid *Lump, ILuint Size);
299
 
ILboolean ilLoadPic(const ILstring FileName);
 
330
ILboolean ilIsValidPicL(const void *Lump, ILuint Size);
 
331
ILboolean ilLoadPic(ILconst_string FileName);
300
332
ILboolean ilLoadPicF(ILHANDLE File);
301
 
ILboolean ilLoadPicL(const ILvoid *Lump, ILuint Size);
302
 
ILboolean ilLoadPix(const ILstring FileName);
 
333
ILboolean ilLoadPicL(const void *Lump, ILuint Size);
 
334
ILboolean ilLoadPix(ILconst_string FileName);
303
335
ILboolean ilLoadPixF(ILHANDLE File);
304
 
ILboolean ilLoadPixL(const ILvoid *Lump, ILuint Size);
305
 
ILboolean ilIsValidPng(const ILstring FileName);
 
336
ILboolean ilLoadPixL(const void *Lump, ILuint Size);
 
337
ILboolean ilIsValidPng(ILconst_string FileName);
306
338
ILboolean ilIsValidPngF(ILHANDLE File);
307
 
ILboolean ilIsValidPngL(const ILvoid *Lump, ILuint Size);
308
 
ILboolean ilLoadPng(const ILstring FileName);
 
339
ILboolean ilIsValidPngL(const void *Lump, ILuint Size);
 
340
ILboolean ilLoadPng(ILconst_string FileName);
309
341
ILboolean ilLoadPngF(ILHANDLE File);
310
 
ILboolean ilLoadPngL(const ILvoid *Lump, ILuint Size);
311
 
ILboolean ilSavePng(const ILstring FileName);
 
342
ILboolean ilLoadPngL(const void *Lump, ILuint Size);
 
343
ILboolean ilSavePng(ILconst_string FileName);
312
344
ILboolean ilSavePngF(ILHANDLE File);
313
 
ILboolean ilSavePngL(ILvoid *Lump, ILuint Size);
314
 
ILboolean ilIsValidPnm(const ILstring FileName);
 
345
ILboolean ilSavePngL(void *Lump, ILuint Size);
 
346
ILboolean ilIsValidPnm(ILconst_string FileName);
315
347
ILboolean ilIsValidPnmF(ILHANDLE File);
316
 
ILboolean ilIsValidPnmL(const ILvoid *Lump, ILuint Size);
317
 
ILboolean ilLoadPnm(const ILstring FileName);
 
348
ILboolean ilIsValidPnmL(const void *Lump, ILuint Size);
 
349
ILboolean ilLoadPnm(ILconst_string FileName);
318
350
ILboolean ilLoadPnmF(ILHANDLE File);
319
 
ILboolean ilLoadPnmL(const ILvoid *Lump, ILuint Size);
320
 
ILboolean ilSavePnm(const ILstring FileName);
 
351
ILboolean ilLoadPnmL(const void *Lump, ILuint Size);
 
352
ILboolean ilSavePnm(ILconst_string FileName);
321
353
ILboolean ilSavePnmF(ILHANDLE File);
322
 
ILboolean ilSavePnmL(ILvoid *Lump, ILuint Size);
323
 
ILboolean ilIsValidPsd(const ILstring FileName);
 
354
ILboolean ilSavePnmL(void *Lump, ILuint Size);
 
355
ILboolean ilIsValidPsd(ILconst_string FileName);
324
356
ILboolean ilIsValidPsdF(ILHANDLE File);
325
 
ILboolean ilIsValidPsdL(const ILvoid *Lump, ILuint Size);
326
 
ILboolean ilLoadPsd(const ILstring FileName);
 
357
ILboolean ilIsValidPsdL(const void *Lump, ILuint Size);
 
358
ILboolean ilLoadPsd(ILconst_string FileName);
327
359
ILboolean ilLoadPsdF(ILHANDLE File);
328
 
ILboolean ilLoadPsdL(const ILvoid *Lump, ILuint Size);
329
 
ILboolean ilSavePsd(const ILstring FileName);
 
360
ILboolean ilLoadPsdL(const void *Lump, ILuint Size);
 
361
ILboolean ilSavePsd(ILconst_string FileName);
330
362
ILboolean ilSavePsdF(ILHANDLE File);
331
 
ILboolean ilSavePsdL(ILvoid *Lump, ILuint Size);
332
 
ILboolean ilIsValidPsp(const ILstring FileName);
 
363
ILboolean ilSavePsdL(void *Lump, ILuint Size);
 
364
ILboolean ilIsValidPsp(ILconst_string FileName);
333
365
ILboolean ilIsValidPspF(ILHANDLE File);
334
 
ILboolean ilIsValidPspL(const ILvoid *Lump, ILuint Size);
335
 
ILboolean ilLoadPsp(const ILstring FileName);
 
366
ILboolean ilIsValidPspL(const void *Lump, ILuint Size);
 
367
ILboolean ilLoadPsp(ILconst_string FileName);
336
368
ILboolean ilLoadPspF(ILHANDLE File);
337
 
ILboolean ilLoadPspL(const ILvoid *Lump, ILuint Size);
338
 
ILboolean ilLoadPxr(const ILstring FileName);
 
369
ILboolean ilLoadPspL(const void *Lump, ILuint Size);
 
370
ILboolean ilLoadPxr(ILconst_string FileName);
339
371
ILboolean ilLoadPxrF(ILHANDLE File);
340
 
ILboolean ilLoadPxrL(const ILvoid *Lump, ILuint Size);
341
 
ILboolean ilLoadRaw(const ILstring FileName);
 
372
ILboolean ilLoadPxrL(const void *Lump, ILuint Size);
 
373
ILboolean ilLoadRaw(ILconst_string FileName);
342
374
ILboolean ilLoadRawF(ILHANDLE File);
343
 
ILboolean ilLoadRawL(const ILvoid *Lump, ILuint Size);
344
 
ILboolean ilSaveRaw(const ILstring FileName);
 
375
ILboolean ilLoadRawL(const void *Lump, ILuint Size);
 
376
ILboolean ilSaveRaw(ILconst_string FileName);
345
377
ILboolean ilSaveRawF(ILHANDLE File);
346
 
ILboolean ilSaveRawL(ILvoid *Lump, ILuint Size);
347
 
ILboolean ilIsValidSgi(const ILstring FileName);
 
378
ILboolean ilSaveRawL(void *Lump, ILuint Size);
 
379
ILboolean ilIsValidSgi(ILconst_string FileName);
348
380
ILboolean ilIsValidSgiF(ILHANDLE File);
349
 
ILboolean ilIsValidSgiL(const ILvoid *Lump, ILuint Size);
350
 
ILboolean ilLoadSgi(const ILstring FileName);
 
381
ILboolean ilIsValidSgiL(const void *Lump, ILuint Size);
 
382
ILboolean ilLoadSgi(ILconst_string FileName);
351
383
ILboolean ilLoadSgiF(ILHANDLE File);
352
 
ILboolean ilLoadSgiL(const ILvoid *Lump, ILuint Size);
353
 
ILboolean ilSaveSgi(const ILstring FileName);
 
384
ILboolean ilLoadSgiL(const void *Lump, ILuint Size);
 
385
ILboolean ilSaveSgi(ILconst_string FileName);
354
386
ILboolean ilSaveSgiF(ILHANDLE File);
355
 
ILboolean ilSaveSgiL(ILvoid *Lump, ILuint Size);
356
 
ILboolean ilIsValidTga(const ILstring FileName);
 
387
ILboolean ilSaveSgiL(void *Lump, ILuint Size);
 
388
ILboolean ilIsValidTga(ILconst_string FileName);
357
389
ILboolean ilIsValidTgaF(ILHANDLE File);
358
 
ILboolean ilIsValidTgaL(const ILvoid *Lump, ILuint Size);
359
 
ILboolean ilLoadTarga(const ILstring FileName);
 
390
ILboolean ilIsValidTgaL(const void *Lump, ILuint Size);
 
391
ILboolean ilLoadTarga(ILconst_string FileName);
360
392
ILboolean ilLoadTargaF(ILHANDLE File);
361
 
ILboolean ilLoadTargaL(const ILvoid *Lump, ILuint Size);
362
 
ILboolean ilSaveTarga(const ILstring FileName);
 
393
ILboolean ilLoadTargaL(const void *Lump, ILuint Size);
 
394
ILboolean ilSaveTarga(ILconst_string FileName);
363
395
ILboolean ilSaveTargaF(ILHANDLE File);
364
 
ILboolean ilSaveTargaL(ILvoid *Lump, ILuint Size);
365
 
ILboolean ilIsValidTiff(const ILstring FileName);
 
396
ILboolean ilSaveTargaL(void *Lump, ILuint Size);
 
397
ILboolean ilIsValidTiff(ILconst_string FileName);
366
398
ILboolean ilIsValidTiffF(ILHANDLE File);
367
 
ILboolean ilIsValidTiffL(const ILvoid *Lump, ILuint Size);
368
 
ILboolean ilLoadTiff(const ILstring FileName);
 
399
ILboolean ilIsValidTiffL(const void *Lump, ILuint Size);
 
400
ILboolean ilLoadTiff(ILconst_string FileName);
369
401
ILboolean ilLoadTiffF(ILHANDLE File);
370
 
ILboolean ilLoadTiffL(const ILvoid *Lump, ILuint Size);
371
 
ILboolean ilSaveTiff(const ILstring FileName);
 
402
ILboolean ilLoadTiffL(const void *Lump, ILuint Size);
 
403
ILboolean ilSaveTiff(ILconst_string FileName);
372
404
ILboolean ilSaveTiffF(ILHANDLE File);
373
 
ILboolean ilSaveTiffL(const ILvoid *Lump, ILuint Size);
374
 
ILboolean ilLoadWal(const ILstring FileName);
 
405
ILboolean ilSaveTiffL(const void *Lump, ILuint Size);
 
406
ILboolean ilIsValidVtf(ILconst_string FileName);
 
407
ILboolean ilIsValidVtfF(ILHANDLE File);
 
408
ILboolean ilIsValidVtfL(const void *Lump, ILuint Size);
 
409
ILboolean ilLoadVtf(ILconst_string FileName);
 
410
ILboolean ilLoadVtfF(ILHANDLE File);
 
411
ILboolean ilLoadVtfL(const void *Lump, ILuint Size);
 
412
ILboolean ilLoadWal(ILconst_string FileName);
375
413
ILboolean ilLoadWalF(ILHANDLE File);
376
 
ILboolean ilLoadWalL(const ILvoid *Lump, ILuint Size);
377
 
ILboolean ilLoadXpm(const ILstring FileName);
 
414
ILboolean ilLoadWalL(const void *Lump, ILuint Size);
 
415
ILboolean ilLoadWdp(ILconst_string FileName);
 
416
ILboolean ilLoadWdpF(ILHANDLE File);
 
417
ILboolean ilLoadWdpL(const void *Lump, ILuint Size);
 
418
ILboolean ilIsValidWdp(ILconst_string FileName);
 
419
ILboolean ilIsValidWdpF(ILHANDLE File);
 
420
ILboolean ilIsValidWdpL(const void *Lump, ILuint Size);
 
421
ILboolean ilLoadXpm(ILconst_string FileName);
378
422
ILboolean ilLoadXpmF(ILHANDLE File);
379
 
ILboolean ilLoadXpmL(const ILvoid *Lump, ILuint Size);
 
423
ILboolean ilLoadXpmL(const void *Lump, ILuint Size);
 
424
 
 
425
 
 
426
// OpenEXR is written in C++, so we have to wrap this to avoid linker errors.
 
427
/*#ifndef IL_NO_EXR
 
428
        #ifdef __cplusplus
 
429
        extern "C" {
 
430
        #endif
 
431
                ILboolean ilLoadExr(ILconst_string FileName);
 
432
        #ifdef __cplusplus
 
433
        }
 
434
        #endif
 
435
#endif*/
 
436
 
 
437
ILboolean ilLoadExr(ILconst_string FileName);
 
438
 
 
439
 
 
440
#ifdef __cplusplus
 
441
}
 
442
#endif
 
443
 
380
444
#endif//INTERNAL_H