1 //-----------------------------------------------------------------------------
2 //
3 // ImageLib Sources
4 // Copyright (C) 2000-2009 by Denton Woods
5 // Last modified: 03/07/2009
6 //
7 // Filename: src-IL/src/il_io.c
8 //
9 // Description: Determines image types and loads/saves images
10 //
11 //-----------------------------------------------------------------------------
12
13 #include "il_internal.h"
14 #include "il_register.h"
15 #include "il_pal.h"
16 #include <string.h>
17
18
19 // Returns a widened version of a string.
20 // Make sure to free this after it is used. Code help from
21 // https://buildsecurityin.us-cert.gov/daisy/bsi-rules/home/g1/769-BSI.html
22 #if defined(_UNICODE)
WideFromMultiByte(const char * Multi)23 wchar_t *WideFromMultiByte(const char *Multi)
24 {
25 ILint Length;
26 wchar_t *Temp;
27
28 Length = (ILint)mbstowcs(NULL, (const char*)Multi, 0) + 1; // note error return of -1 is possible
29 if (Length == 0) {
30 ilSetError(IL_INVALID_PARAM);
31 return NULL;
32 }
33 if (Length > ULONG_MAX/sizeof(wchar_t)) {
34 ilSetError(IL_INTERNAL_ERROR);
35 return NULL;
36 }
37 Temp = (wchar_t*)ialloc(Length * sizeof(wchar_t));
38 mbstowcs(Temp, (const char*)Multi, Length);
39
40 return Temp;
41 }
42 #endif
43
44
ilTypeFromExt(ILconst_string FileName)45 ILenum ILAPIENTRY ilTypeFromExt(ILconst_string FileName)
46 {
47 ILenum Type;
48 ILstring Ext;
49
50 if (FileName == NULL || ilStrLen(FileName) < 1) {
51 ilSetError(IL_INVALID_PARAM);
52 return IL_TYPE_UNKNOWN;
53 }
54
55 Ext = iGetExtension(FileName);
56 //added 2003-08-31: fix sf bug 789535
57 if (Ext == NULL) {
58 return IL_TYPE_UNKNOWN;
59 }
60
61 if (!iStrCmp(Ext, IL_TEXT("tga")) || !iStrCmp(Ext, IL_TEXT("vda")) ||
62 !iStrCmp(Ext, IL_TEXT("icb")) || !iStrCmp(Ext, IL_TEXT("vst")))
63 Type = IL_TGA;
64 else if (!iStrCmp(Ext, IL_TEXT("jpg")) || !iStrCmp(Ext, IL_TEXT("jpe")) ||
65 !iStrCmp(Ext, IL_TEXT("jpeg")) || !iStrCmp(Ext, IL_TEXT("jif")) || !iStrCmp(Ext, IL_TEXT("jfif")))
66 Type = IL_JPG;
67 else if (!iStrCmp(Ext, IL_TEXT("jp2")) || !iStrCmp(Ext, IL_TEXT("jpx")) ||
68 !iStrCmp(Ext, IL_TEXT("j2k")) || !iStrCmp(Ext, IL_TEXT("j2c")))
69 Type = IL_JP2;
70 else if (!iStrCmp(Ext, IL_TEXT("dds")))
71 Type = IL_DDS;
72 else if (!iStrCmp(Ext, IL_TEXT("png")))
73 Type = IL_PNG;
74 else if (!iStrCmp(Ext, IL_TEXT("bmp")) || !iStrCmp(Ext, IL_TEXT("dib")))
75 Type = IL_BMP;
76 else if (!iStrCmp(Ext, IL_TEXT("gif")))
77 Type = IL_GIF;
78 else if (!iStrCmp(Ext, IL_TEXT("blp")))
79 Type = IL_BLP;
80 else if (!iStrCmp(Ext, IL_TEXT("cut")))
81 Type = IL_CUT;
82 else if (!iStrCmp(Ext, IL_TEXT("dcm")) || !iStrCmp(Ext, IL_TEXT("dicom")))
83 Type = IL_DICOM;
84 else if (!iStrCmp(Ext, IL_TEXT("dpx")))
85 Type = IL_DPX;
86 else if (!iStrCmp(Ext, IL_TEXT("exr")))
87 Type = IL_EXR;
88 else if (!iStrCmp(Ext, IL_TEXT("fit")) || !iStrCmp(Ext, IL_TEXT("fits")))
89 Type = IL_FITS;
90 else if (!iStrCmp(Ext, IL_TEXT("ftx")))
91 Type = IL_FTX;
92 else if (!iStrCmp(Ext, IL_TEXT("hdr")))
93 Type = IL_HDR;
94 else if (!iStrCmp(Ext, IL_TEXT("iff")))
95 Type = IL_IFF;
96 else if (!iStrCmp(Ext, IL_TEXT("ilbm")) || !iStrCmp(Ext, IL_TEXT("lbm")) ||
97 !iStrCmp(Ext, IL_TEXT("ham")))
98 Type = IL_ILBM;
99 else if (!iStrCmp(Ext, IL_TEXT("ico")) || !iStrCmp(Ext, IL_TEXT("cur")))
100 Type = IL_ICO;
101 else if (!iStrCmp(Ext, IL_TEXT("icns")))
102 Type = IL_ICNS;
103 else if (!iStrCmp(Ext, IL_TEXT("iwi")))
104 Type = IL_IWI;
105 else if (!iStrCmp(Ext, IL_TEXT("iwi")))
106 Type = IL_IWI;
107 else if (!iStrCmp(Ext, IL_TEXT("jng")))
108 Type = IL_JNG;
109 else if (!iStrCmp(Ext, IL_TEXT("lif")))
110 Type = IL_LIF;
111 else if (!iStrCmp(Ext, IL_TEXT("mdl")))
112 Type = IL_MDL;
113 else if (!iStrCmp(Ext, IL_TEXT("mng")) || !iStrCmp(Ext, IL_TEXT("jng")))
114 Type = IL_MNG;
115 else if (!iStrCmp(Ext, IL_TEXT("mp3")))
116 Type = IL_MP3;
117 else if (!iStrCmp(Ext, IL_TEXT("pcd")))
118 Type = IL_PCD;
119 else if (!iStrCmp(Ext, IL_TEXT("pcx")))
120 Type = IL_PCX;
121 else if (!iStrCmp(Ext, IL_TEXT("pic")))
122 Type = IL_PIC;
123 else if (!iStrCmp(Ext, IL_TEXT("pix")))
124 Type = IL_PIX;
125 else if (!iStrCmp(Ext, IL_TEXT("pbm")) || !iStrCmp(Ext, IL_TEXT("pgm")) ||
126 !iStrCmp(Ext, IL_TEXT("pnm")) || !iStrCmp(Ext, IL_TEXT("ppm")))
127 Type = IL_PNM;
128 else if (!iStrCmp(Ext, IL_TEXT("psd")) || !iStrCmp(Ext, IL_TEXT("pdd")))
129 Type = IL_PSD;
130 else if (!iStrCmp(Ext, IL_TEXT("psp")))
131 Type = IL_PSP;
132 else if (!iStrCmp(Ext, IL_TEXT("pxr")))
133 Type = IL_PXR;
134 else if (!iStrCmp(Ext, IL_TEXT("rot")))
135 Type = IL_ROT;
136 else if (!iStrCmp(Ext, IL_TEXT("sgi")) || !iStrCmp(Ext, IL_TEXT("bw")) ||
137 !iStrCmp(Ext, IL_TEXT("rgb")) || !iStrCmp(Ext, IL_TEXT("rgba")))
138 Type = IL_SGI;
139 else if (!iStrCmp(Ext, IL_TEXT("sun")) || !iStrCmp(Ext, IL_TEXT("ras")) ||
140 !iStrCmp(Ext, IL_TEXT("rs")) || !iStrCmp(Ext, IL_TEXT("im1")) ||
141 !iStrCmp(Ext, IL_TEXT("im8")) || !iStrCmp(Ext, IL_TEXT("im24")) ||
142 !iStrCmp(Ext, IL_TEXT("im32")))
143 Type = IL_SUN;
144 else if (!iStrCmp(Ext, IL_TEXT("texture")))
145 Type = IL_TEXTURE;
146 else if (!iStrCmp(Ext, IL_TEXT("tif")) || !iStrCmp(Ext, IL_TEXT("tiff")))
147 Type = IL_TIF;
148 else if (!iStrCmp(Ext, IL_TEXT("tpl")))
149 Type = IL_TPL;
150 else if (!iStrCmp(Ext, IL_TEXT("utx")))
151 Type = IL_UTX;
152 else if (!iStrCmp(Ext, IL_TEXT("vtf")))
153 Type = IL_VTF;
154 else if (!iStrCmp(Ext, IL_TEXT("wal")))
155 Type = IL_WAL;
156 else if (!iStrCmp(Ext, IL_TEXT("wbmp")))
157 Type = IL_WBMP;
158 else if (!iStrCmp(Ext, IL_TEXT("wdp")) || !iStrCmp(Ext, IL_TEXT("hdp")))
159 Type = IL_WDP;
160 else if (!iStrCmp(Ext, IL_TEXT("xpm")))
161 Type = IL_XPM;
162 else
163 Type = IL_TYPE_UNKNOWN;
164
165 return Type;
166 }
167
168
169 //changed 2003-09-17 to ILAPIENTRY
ilDetermineType(ILconst_string FileName)170 ILenum ILAPIENTRY ilDetermineType(ILconst_string FileName)
171 {
172 ILHANDLE File;
173 ILenum Type;
174
175 if (FileName == NULL)
176 return IL_TYPE_UNKNOWN;
177
178 File = iopenr(FileName);
179 if (File == NULL) {
180 ilSetError(IL_COULD_NOT_OPEN_FILE);
181 return IL_FALSE;
182 }
183 Type = ilDetermineTypeF(File);
184 icloser(File);
185
186 return Type;
187 }
188
189
ilDetermineTypeF(ILHANDLE File)190 ILenum ILAPIENTRY ilDetermineTypeF(ILHANDLE File)
191 {
192 if (File == NULL)
193 return IL_TYPE_UNKNOWN;
194
195 #ifndef IL_NO_JPG
196 if (ilIsValidJpegF(File))
197 return IL_JPG;
198 #endif
199
200 #ifndef IL_NO_DDS
201 if (ilIsValidDdsF(File))
202 return IL_DDS;
203 #endif
204
205 #ifndef IL_NO_PNG
206 if (ilIsValidPngF(File))
207 return IL_PNG;
208 #endif
209
210 #ifndef IL_NO_BMP
211 if (ilIsValidBmpF(File))
212 return IL_BMP;
213 #endif
214
215 #ifndef IL_NO_EXR
216 if (ilIsValidExrF(File))
217 return IL_EXR;
218 #endif
219
220 #ifndef IL_NO_GIF
221 if (ilIsValidGifF(File))
222 return IL_GIF;
223 #endif
224
225 #ifndef IL_NO_HDR
226 if (ilIsValidHdrF(File))
227 return IL_HDR;
228 #endif
229
230 #ifndef IL_NO_ICNS
231 if (ilIsValidIcnsF(File))
232 return IL_ICNS;
233 #endif
234
235 #ifndef IL_NO_ILBM
236 if (ilIsValidIlbmF(File))
237 return IL_ILBM;
238 #endif
239
240 #ifndef IL_NO_IWI
241 if (ilIsValidIwiF(File))
242 return IL_IWI;
243 #endif
244
245 #ifndef IL_NO_JP2
246 if (ilIsValidJp2F(File))
247 return IL_JP2;
248 #endif
249
250 #ifndef IL_NO_LIF
251 if (ilIsValidLifF(File))
252 return IL_LIF;
253 #endif
254
255 #ifndef IL_NO_MDL
256 if (ilIsValidMdlF(File))
257 return IL_MDL;
258 #endif
259
260 #ifndef IL_NO_MDL
261 if (ilIsValidMp3F(File))
262 return IL_MP3;
263 #endif
264
265 #ifndef IL_NO_PCX
266 if (ilIsValidPcxF(File))
267 return IL_PCX;
268 #endif
269
270 #ifndef IL_NO_PIC
271 if (ilIsValidPicF(File))
272 return IL_PIC;
273 #endif
274
275 #ifndef IL_NO_PNM
276 if (ilIsValidPnmF(File))
277 return IL_PNM;
278 #endif
279
280 #ifndef IL_NO_PSD
281 if (ilIsValidPsdF(File))
282 return IL_PSD;
283 #endif
284
285 #ifndef IL_NO_PSP
286 if (ilIsValidPspF(File))
287 return IL_PSP;
288 #endif
289
290 #ifndef IL_NO_SGI
291 if (ilIsValidSgiF(File))
292 return IL_SGI;
293 #endif
294
295 #ifndef IL_NO_SUN
296 if (ilIsValidSunF(File))
297 return IL_SUN;
298 #endif
299
300 #ifndef IL_NO_TIF
301 if (ilIsValidTiffF(File))
302 return IL_TIF;
303 #endif
304
305 #ifndef IL_NO_TPL
306 if (ilIsValidTplF(File))
307 return IL_TPL;
308 #endif
309
310 #ifndef IL_NO_VTF
311 if (ilIsValidVtfF(File))
312 return IL_VTF;
313 #endif
314
315 #ifndef IL_NO_XPM
316 if (ilIsValidXpmF(File))
317 return IL_XPM;
318 #endif
319
320 //moved tga to end of list because it has no magic number
321 //in header to assure that this is really a tga... (20040218)
322 #ifndef IL_NO_TGA
323 if (ilIsValidTgaF(File))
324 return IL_TGA;
325 #endif
326
327 return IL_TYPE_UNKNOWN;
328 }
329
330
ilDetermineTypeL(const void * Lump,ILuint Size)331 ILenum ILAPIENTRY ilDetermineTypeL(const void *Lump, ILuint Size)
332 {
333 if (Lump == NULL)
334 return IL_TYPE_UNKNOWN;
335
336 #ifndef IL_NO_JPG
337 if (ilIsValidJpegL(Lump, Size))
338 return IL_JPG;
339 #endif
340
341 #ifndef IL_NO_DDS
342 if (ilIsValidDdsL(Lump, Size))
343 return IL_DDS;
344 #endif
345
346 #ifndef IL_NO_PNG
347 if (ilIsValidPngL(Lump, Size))
348 return IL_PNG;
349 #endif
350
351 #ifndef IL_NO_BMP
352 if (ilIsValidBmpL(Lump, Size))
353 return IL_BMP;
354 #endif
355
356 #ifndef IL_NO_EXR
357 if (ilIsValidExrL(Lump, Size))
358 return IL_EXR;
359 #endif
360
361 #ifndef IL_NO_GIF
362 if (ilIsValidGifL(Lump, Size))
363 return IL_GIF;
364 #endif
365
366 #ifndef IL_NO_HDR
367 if (ilIsValidHdrL(Lump, Size))
368 return IL_HDR;
369 #endif
370
371 #ifndef IL_NO_ICNS
372 if (ilIsValidIcnsL(Lump, Size))
373 return IL_ICNS;
374 #endif
375
376 #ifndef IL_NO_IWI
377 if (ilIsValidIwiL(Lump, Size))
378 return IL_IWI;
379 #endif
380
381 #ifndef IL_NO_ILBM
382 if (ilIsValidIlbmL(Lump,Size))
383 return IL_ILBM;
384 #endif
385
386 #ifndef IL_NO_JP2
387 if (ilIsValidJp2L(Lump, Size))
388 return IL_JP2;
389 #endif
390
391 #ifndef IL_NO_LIF
392 if (ilIsValidLifL(Lump, Size))
393 return IL_LIF;
394 #endif
395
396 #ifndef IL_NO_MDL
397 if (ilIsValidMdlL(Lump, Size))
398 return IL_MDL;
399 #endif
400
401 #ifndef IL_NO_MP3
402 if (ilIsValidMp3L(Lump, Size))
403 return IL_MP3;
404 #endif
405
406 #ifndef IL_NO_PCX
407 if (ilIsValidPcxL(Lump, Size))
408 return IL_PCX;
409 #endif
410
411 #ifndef IL_NO_PIC
412 if (ilIsValidPicL(Lump, Size))
413 return IL_PIC;
414 #endif
415
416 #ifndef IL_NO_PNM
417 if (ilIsValidPnmL(Lump, Size))
418 return IL_PNM;
419 #endif
420
421 #ifndef IL_NO_PSD
422 if (ilIsValidPsdL(Lump, Size))
423 return IL_PSD;
424 #endif
425
426 #ifndef IL_NO_PSP
427 if (ilIsValidPspL(Lump, Size))
428 return IL_PSP;
429 #endif
430
431 #ifndef IL_NO_SGI
432 if (ilIsValidSgiL(Lump, Size))
433 return IL_SGI;
434 #endif
435
436 #ifndef IL_NO_SUN
437 if (ilIsValidSunL(Lump, Size))
438 return IL_SUN;
439 #endif
440
441 #ifndef IL_NO_TIF
442 if (ilIsValidTiffL(Lump, Size))
443 return IL_TIF;
444 #endif
445
446 #ifndef IL_NO_TPL
447 if (ilIsValidTplL(Lump, Size))
448 return IL_TPL;
449 #endif
450
451 #ifndef IL_NO_VTF
452 if (ilIsValidVtfL(Lump, Size))
453 return IL_VTF;
454 #endif
455
456 #ifndef IL_NO_XPM
457 if (ilIsValidXpmL(Lump, Size))
458 return IL_XPM;
459 #endif
460
461 //Moved Targa to end of list because it has no magic number
462 // in header to assure that this is really a tga... (20040218).
463 #ifndef IL_NO_TGA
464 if (ilIsValidTgaL(Lump, Size))
465 return IL_TGA;
466 #endif
467
468 return IL_TYPE_UNKNOWN;
469 }
470
471
ilIsValid(ILenum Type,ILconst_string FileName)472 ILboolean ILAPIENTRY ilIsValid(ILenum Type, ILconst_string FileName)
473 {
474 if (FileName == NULL) {
475 ilSetError(IL_INVALID_PARAM);
476 return IL_FALSE;
477 }
478
479 switch (Type)
480 {
481 #ifndef IL_NO_TGA
482 case IL_TGA:
483 return ilIsValidTga(FileName);
484 #endif
485
486 #ifndef IL_NO_JPG
487 case IL_JPG:
488 return ilIsValidJpeg(FileName);
489 #endif
490
491 #ifndef IL_NO_DDS
492 case IL_DDS:
493 return ilIsValidDds(FileName);
494 #endif
495
496 #ifndef IL_NO_PNG
497 case IL_PNG:
498 return ilIsValidPng(FileName);
499 #endif
500
501 #ifndef IL_NO_BMP
502 case IL_BMP:
503 return ilIsValidBmp(FileName);
504 #endif
505
506 #ifndef IL_NO_DICOM
507 case IL_DICOM:
508 return ilIsValidDicom(FileName);
509 #endif
510
511 #ifndef IL_NO_EXR
512 case IL_EXR:
513 return ilIsValidExr(FileName);
514 #endif
515
516 #ifndef IL_NO_GIF
517 case IL_GIF:
518 return ilIsValidGif(FileName);
519 #endif
520
521 #ifndef IL_NO_HDR
522 case IL_HDR:
523 return ilIsValidHdr(FileName);
524 #endif
525
526 #ifndef IL_NO_ICNS
527 case IL_ICNS:
528 return ilIsValidIcns(FileName);
529 #endif
530
531 #ifndef IL_NO_IWI
532 case IL_IWI:
533 return ilIsValidIwi(FileName);
534 #endif
535
536 #ifndef IL_NO_ILBM
537 case IL_ILBM:
538 return ilIsValidIlbm(FileName);
539 #endif
540
541 #ifndef IL_NO_JP2
542 case IL_JP2:
543 return ilIsValidJp2(FileName);
544 #endif
545
546 #ifndef IL_NO_LIF
547 case IL_LIF:
548 return ilIsValidLif(FileName);
549 #endif
550
551 #ifndef IL_NO_MDL
552 case IL_MDL:
553 return ilIsValidMdl(FileName);
554 #endif
555
556 #ifndef IL_NO_MP3
557 case IL_MP3:
558 return ilIsValidMp3(FileName);
559 #endif
560
561 #ifndef IL_NO_PCX
562 case IL_PCX:
563 return ilIsValidPcx(FileName);
564 #endif
565
566 #ifndef IL_NO_PIC
567 case IL_PIC:
568 return ilIsValidPic(FileName);
569 #endif
570
571 #ifndef IL_NO_PNM
572 case IL_PNM:
573 return ilIsValidPnm(FileName);
574 #endif
575
576 #ifndef IL_NO_PSD
577 case IL_PSD:
578 return ilIsValidPsd(FileName);
579 #endif
580
581 #ifndef IL_NO_PSP
582 case IL_PSP:
583 return ilIsValidPsp(FileName);
584 #endif
585
586 #ifndef IL_NO_SGI
587 case IL_SGI:
588 return ilIsValidSgi(FileName);
589 #endif
590
591 #ifndef IL_NO_SUN
592 case IL_SUN:
593 return ilIsValidSun(FileName);
594 #endif
595
596 #ifndef IL_NO_TIF
597 case IL_TIF:
598 return ilIsValidTiff(FileName);
599 #endif
600
601 #ifndef IL_NO_TPL
602 case IL_TPL:
603 return ilIsValidTpl(FileName);
604 #endif
605
606 #ifndef IL_NO_VTF
607 case IL_VTF:
608 return ilIsValidVtf(FileName);
609 #endif
610
611 #ifndef IL_NO_XPM
612 case IL_XPM:
613 return ilIsValidXpm(FileName);
614 #endif
615 }
616
617 ilSetError(IL_INVALID_ENUM);
618 return IL_FALSE;
619 }
620
621
ilIsValidF(ILenum Type,ILHANDLE File)622 ILboolean ILAPIENTRY ilIsValidF(ILenum Type, ILHANDLE File)
623 {
624 if (File == NULL) {
625 ilSetError(IL_INVALID_PARAM);
626 return IL_FALSE;
627 }
628
629 switch (Type)
630 {
631 #ifndef IL_NO_TGA
632 case IL_TGA:
633 return ilIsValidTgaF(File);
634 #endif
635
636 #ifndef IL_NO_JPG
637 case IL_JPG:
638 return ilIsValidJpegF(File);
639 #endif
640
641 #ifndef IL_NO_DDS
642 case IL_DDS:
643 return ilIsValidDdsF(File);
644 #endif
645
646 #ifndef IL_NO_PNG
647 case IL_PNG:
648 return ilIsValidPngF(File);
649 #endif
650
651 #ifndef IL_NO_BMP
652 case IL_BMP:
653 return ilIsValidBmpF(File);
654 #endif
655
656 #ifndef IL_NO_DICOM
657 case IL_DICOM:
658 return ilIsValidDicomF(File);
659 #endif
660
661 #ifndef IL_NO_EXR
662 case IL_EXR:
663 return ilIsValidExrF(File);
664 #endif
665
666 #ifndef IL_NO_GIF
667 case IL_GIF:
668 return ilIsValidGifF(File);
669 #endif
670
671 #ifndef IL_NO_HDR
672 case IL_HDR:
673 return ilIsValidHdrF(File);
674 #endif
675
676 #ifndef IL_NO_ICNS
677 case IL_ICNS:
678 return ilIsValidIcnsF(File);
679 #endif
680
681 #ifndef IL_NO_IWI
682 case IL_IWI:
683 return ilIsValidIwiF(File);
684 #endif
685
686 #ifndef IL_NO_ILBM
687 case IL_ILBM:
688 return ilIsValidIlbmF(File);
689 #endif
690
691 #ifndef IL_NO_JP2
692 case IL_JP2:
693 return ilIsValidJp2F(File);
694 #endif
695
696 #ifndef IL_NO_LIF
697 case IL_LIF:
698 return ilIsValidLifF(File);
699 #endif
700
701 #ifndef IL_NO_MDL
702 case IL_MDL:
703 return ilIsValidMdlF(File);
704 #endif
705
706 #ifndef IL_NO_MP3
707 case IL_MP3:
708 return ilIsValidMp3F(File);
709 #endif
710
711 #ifndef IL_NO_PCX
712 case IL_PCX:
713 return ilIsValidPcxF(File);
714 #endif
715
716 #ifndef IL_NO_PIC
717 case IL_PIC:
718 return ilIsValidPicF(File);
719 #endif
720
721 #ifndef IL_NO_PNM
722 case IL_PNM:
723 return ilIsValidPnmF(File);
724 #endif
725
726 #ifndef IL_NO_PSD
727 case IL_PSD:
728 return ilIsValidPsdF(File);
729 #endif
730
731 #ifndef IL_NO_PSP
732 case IL_PSP:
733 return ilIsValidPspF(File);
734 #endif
735
736 #ifndef IL_NO_SGI
737 case IL_SGI:
738 return ilIsValidSgiF(File);
739 #endif
740
741 #ifndef IL_NO_SUN
742 case IL_SUN:
743 return ilIsValidSunF(File);
744 #endif
745
746 #ifndef IL_NO_TIF
747 case IL_TIF:
748 return ilIsValidTiffF(File);
749 #endif
750
751 #ifndef IL_NO_TPL
752 case IL_TPL:
753 return ilIsValidTplF(File);
754 #endif
755
756 #ifndef IL_NO_VTF
757 case IL_VTF:
758 return ilIsValidVtfF(File);
759 #endif
760
761 #ifndef IL_NO_XPM
762 case IL_XPM:
763 return ilIsValidXpmF(File);
764 #endif
765 }
766
767 ilSetError(IL_INVALID_ENUM);
768 return IL_FALSE;
769 }
770
771
ilIsValidL(ILenum Type,void * Lump,ILuint Size)772 ILboolean ILAPIENTRY ilIsValidL(ILenum Type, void *Lump, ILuint Size)
773 {
774 if (Lump == NULL) {
775 ilSetError(IL_INVALID_PARAM);
776 return IL_FALSE;
777 }
778
779 switch (Type)
780 {
781 #ifndef IL_NO_TGA
782 case IL_TGA:
783 return ilIsValidTgaL(Lump, Size);
784 #endif
785
786 #ifndef IL_NO_JPG
787 case IL_JPG:
788 return ilIsValidJpegL(Lump, Size);
789 #endif
790
791 #ifndef IL_NO_DDS
792 case IL_DDS:
793 return ilIsValidDdsL(Lump, Size);
794 #endif
795
796 #ifndef IL_NO_PNG
797 case IL_PNG:
798 return ilIsValidPngL(Lump, Size);
799 #endif
800
801 #ifndef IL_NO_BMP
802 case IL_BMP:
803 return ilIsValidBmpL(Lump, Size);
804 #endif
805
806 #ifndef IL_NO_DICOM
807 case IL_DICOM:
808 return ilIsValidDicomL(Lump, Size);
809 #endif
810
811 #ifndef IL_NO_EXR
812 case IL_EXR:
813 return ilIsValidExrL(Lump, Size);
814 #endif
815
816 #ifndef IL_NO_GIF
817 case IL_GIF:
818 return ilIsValidGifL(Lump, Size);
819 #endif
820
821 #ifndef IL_NO_HDR
822 case IL_HDR:
823 return ilIsValidHdrL(Lump, Size);
824 #endif
825
826 #ifndef IL_NO_ICNS
827 case IL_ICNS:
828 return ilIsValidIcnsL(Lump, Size);
829 #endif
830
831 #ifndef IL_NO_IWI
832 case IL_IWI:
833 return ilIsValidIwiL(Lump, Size);
834 #endif
835
836 #ifndef IL_NO_ILBM
837 case IL_ILBM:
838 return ilIsValidIlbmL(Lump, Size);
839 #endif
840
841 #ifndef IL_NO_JP2
842 case IL_JP2:
843 return ilIsValidJp2L(Lump, Size);
844 #endif
845
846 #ifndef IL_NO_LIF
847 case IL_LIF:
848 return ilIsValidLifL(Lump, Size);
849 #endif
850
851 #ifndef IL_NO_MDL
852 case IL_MDL:
853 return ilIsValidMdlL(Lump, Size);
854 #endif
855
856 #ifndef IL_NO_MP3
857 case IL_MP3:
858 return ilIsValidMp3L(Lump, Size);
859 #endif
860
861 #ifndef IL_NO_PCX
862 case IL_PCX:
863 return ilIsValidPcxL(Lump, Size);
864 #endif
865
866 #ifndef IL_NO_PIC
867 case IL_PIC:
868 return ilIsValidPicL(Lump, Size);
869 #endif
870
871 #ifndef IL_NO_PNM
872 case IL_PNM:
873 return ilIsValidPnmL(Lump, Size);
874 #endif
875
876 #ifndef IL_NO_PSD
877 case IL_PSD:
878 return ilIsValidPsdL(Lump, Size);
879 #endif
880
881 #ifndef IL_NO_PSP
882 case IL_PSP:
883 return ilIsValidPspL(Lump, Size);
884 #endif
885
886 #ifndef IL_NO_SGI
887 case IL_SGI:
888 return ilIsValidSgiL(Lump, Size);
889 #endif
890
891 #ifndef IL_NO_SUN
892 case IL_SUN:
893 return ilIsValidSunL(Lump, Size);
894 #endif
895
896 #ifndef IL_NO_TIF
897 case IL_TIF:
898 return ilIsValidTiffL(Lump, Size);
899 #endif
900
901 #ifndef IL_NO_TPL
902 case IL_TPL:
903 return ilIsValidTplL(Lump, Size);
904 #endif
905
906 #ifndef IL_NO_VTF
907 case IL_VTF:
908 return ilIsValidVtfL(Lump, Size);
909 #endif
910
911 #ifndef IL_NO_XPM
912 case IL_XPM:
913 return ilIsValidXpmL(Lump, Size);
914 #endif
915 }
916
917 ilSetError(IL_INVALID_ENUM);
918 return IL_FALSE;
919 }
920
921
922 //! Attempts to load an image from a file. The file format is specified by the user.
923 /*! \param Type Format of this file. Acceptable values are IL_BLP, IL_BMP, IL_CUT, IL_DCX, IL_DDS,
924 IL_DICOM, IL_DOOM, IL_DOOM_FLAT, IL_DPX, IL_EXR, IL_FITS, IL_FTX, IL_GIF, IL_HDR, IL_ICO, IL_ICNS,
925 IL_IFF, IL_IWI, IL_JP2, IL_JPG, IL_LIF, IL_MDL, IL_MNG, IL_MP3, IL_PCD, IL_PCX, IL_PIX, IL_PNG,
926 IL_PNM, IL_PSD, IL_PSP, IL_PXR, IL_ROT, IL_SGI, IL_SUN, IL_TEXTURE, IL_TGA, IL_TIF, IL_TPL,
927 IL_UTX, IL_VTF, IL_WAL, IL_WBMP, IL_XPM, IL_RAW, IL_JASC_PAL and IL_TYPE_UNKNOWN.
928 If IL_TYPE_UNKNOWN is specified, ilLoad will try to determine the type of the file and load it.
929 \param FileName Ansi or Unicode string, depending on the compiled version of DevIL, that gives
930 the filename of the file to load.
931 \return Boolean value of failure or success. Returns IL_FALSE if all three loading methods
932 have been tried and failed.*/
ilLoad(ILenum Type,ILconst_string FileName)933 ILboolean ILAPIENTRY ilLoad(ILenum Type, ILconst_string FileName)
934 {
935 ILboolean bRet;
936
937 if (FileName == NULL || ilStrLen(FileName) < 1) {
938 ilSetError(IL_INVALID_PARAM);
939 return IL_FALSE;
940 }
941
942 switch (Type)
943 {
944 case IL_TYPE_UNKNOWN:
945 bRet = ilLoadImage(FileName);
946 break;
947
948 #ifndef IL_NO_TGA
949 case IL_TGA:
950 bRet = ilLoadTarga(FileName);
951 break;
952 #endif
953
954 #ifndef IL_NO_JPG
955 case IL_JPG:
956 bRet = ilLoadJpeg(FileName);
957 break;
958 #endif
959
960 #ifndef IL_NO_JP2
961 case IL_JP2:
962 bRet = ilLoadJp2(FileName);
963 break;
964 #endif
965
966 #ifndef IL_NO_DDS
967 case IL_DDS:
968 bRet = ilLoadDds(FileName);
969 break;
970 #endif
971
972 #ifndef IL_NO_PNG
973 case IL_PNG:
974 bRet = ilLoadPng(FileName);
975 break;
976 #endif
977
978 #ifndef IL_NO_BLP
979 case IL_BLP:
980 bRet = ilLoadBlp(FileName);
981 break;
982 #endif
983
984 #ifndef IL_NO_BMP
985 case IL_BMP:
986 bRet = ilLoadBmp(FileName);
987 break;
988 #endif
989
990 #ifndef IL_NO_DPX
991 case IL_DPX:
992 bRet = ilLoadDpx(FileName);
993 break;
994 #endif
995
996 #ifndef IL_NO_GIF
997 case IL_GIF:
998 bRet = ilLoadGif(FileName);
999 break;
1000 #endif
1001
1002 #ifndef IL_NO_HDR
1003 case IL_HDR:
1004 bRet = ilLoadHdr(FileName);
1005 break;
1006 #endif
1007
1008 #ifndef IL_NO_CUT
1009 case IL_CUT:
1010 bRet = ilLoadCut(FileName);
1011 break;
1012 #endif
1013
1014 #ifndef IL_NO_DICOM
1015 case IL_DICOM:
1016 bRet = ilLoadDicom(FileName);
1017 break;
1018 #endif
1019
1020 #ifndef IL_NO_DOOM
1021 case IL_DOOM:
1022 bRet = ilLoadDoom(FileName);
1023 break;
1024 case IL_DOOM_FLAT:
1025 bRet = ilLoadDoomFlat(FileName);
1026 break;
1027 #endif
1028
1029 #ifndef IL_NO_EXR
1030 case IL_EXR:
1031 bRet = ilLoadExr(FileName);
1032 break;
1033 #endif
1034
1035 #ifndef IL_NO_FITS
1036 case IL_FITS:
1037 bRet = ilLoadFits(FileName);
1038 break;
1039 #endif
1040
1041 #ifndef IL_NO_FTX
1042 case IL_FTX:
1043 bRet = ilLoadFtx(FileName);
1044 break;
1045 #endif
1046
1047 #ifndef IL_NO_ICO
1048 case IL_ICO:
1049 bRet = ilLoadIcon(FileName);
1050 break;
1051 #endif
1052
1053 #ifndef IL_NO_ICNS
1054 case IL_ICNS:
1055 bRet = ilLoadIcns(FileName);
1056 break;
1057 #endif
1058
1059 #ifndef IL_NO_IFF
1060 case IL_IFF:
1061 bRet = ilLoadIff(FileName);
1062 break;
1063 #endif
1064
1065 #ifndef IL_NO_ILBM
1066 case IL_ILBM:
1067 bRet = ilLoadIlbm(FileName);
1068 break;
1069 #endif
1070
1071 #ifndef IL_NO_IWI
1072 case IL_IWI:
1073 bRet = ilLoadIwi(FileName);
1074 break;
1075 #endif
1076
1077 #ifndef IL_NO_LIF
1078 case IL_LIF:
1079 bRet = ilLoadLif(FileName);
1080 break;
1081 #endif
1082
1083 #ifndef IL_NO_MDL
1084 case IL_MDL:
1085 bRet = ilLoadMdl(FileName);
1086 break;
1087 #endif
1088
1089 #ifndef IL_NO_MNG
1090 case IL_MNG:
1091 bRet = ilLoadMng(FileName);
1092 break;
1093 #endif
1094
1095 #ifndef IL_NO_MP3
1096 case IL_MP3:
1097 bRet = ilLoadMp3(FileName);
1098 break;
1099 #endif
1100
1101 #ifndef IL_NO_PCD
1102 case IL_PCD:
1103 ilLoadPcd(FileName);
1104 break;
1105 #endif
1106
1107 #ifndef IL_NO_PCX
1108 case IL_PCX:
1109 bRet = ilLoadPcx(FileName);
1110 break;
1111 #endif
1112
1113 #ifndef IL_NO_PIC
1114 case IL_PIC:
1115 bRet = ilLoadPic(FileName);
1116 break;
1117 #endif
1118
1119 #ifndef IL_NO_PIX
1120 case IL_PIX:
1121 bRet = ilLoadPix(FileName);
1122 break;
1123 #endif
1124
1125 #ifndef IL_NO_PNM
1126 case IL_PNM:
1127 bRet = ilLoadPnm(FileName);
1128 break;
1129 #endif
1130
1131 #ifndef IL_NO_PSD
1132 case IL_PSD:
1133 bRet = ilLoadPsd(FileName);
1134 break;
1135 #endif
1136
1137 #ifndef IL_NO_PSP
1138 case IL_PSP:
1139 bRet = ilLoadPsp(FileName);
1140 break;
1141 #endif
1142
1143 #ifndef IL_NO_PXR
1144 case IL_PXR:
1145 bRet = ilLoadPxr(FileName);
1146 break;
1147 #endif
1148
1149 #ifndef IL_NO_RAW
1150 case IL_RAW:
1151 bRet = ilLoadRaw(FileName);
1152 break;
1153 #endif
1154
1155 #ifndef IL_NO_ROT
1156 case IL_ROT:
1157 bRet = ilLoadRot(FileName);
1158 break;
1159 #endif
1160
1161 #ifndef IL_NO_SGI
1162 case IL_SGI:
1163 bRet = ilLoadSgi(FileName);
1164 break;
1165 #endif
1166
1167 #ifndef IL_NO_SUN
1168 case IL_SUN:
1169 bRet = ilLoadSun(FileName);
1170 break;
1171 #endif
1172
1173 #ifndef IL_NO_TEXTURE
1174 case IL_TEXTURE:
1175 bRet = ilLoadTexture(FileName);
1176 break;
1177 #endif
1178
1179 #ifndef IL_NO_TIF
1180 case IL_TIF:
1181 bRet = ilLoadTiff(FileName);
1182 break;
1183 #endif
1184
1185 #ifndef IL_NO_TPL
1186 case IL_TPL:
1187 bRet = ilLoadTpl(FileName);
1188 break;
1189 #endif
1190
1191 #ifndef IL_NO_UTX
1192 case IL_UTX:
1193 bRet = ilLoadUtx(FileName);
1194 break;
1195 #endif
1196
1197 #ifndef IL_NO_VTF
1198 case IL_VTF:
1199 bRet = ilLoadVtf(FileName);
1200 break;
1201 #endif
1202
1203 #ifndef IL_NO_WAL
1204 case IL_WAL:
1205 bRet = ilLoadWal(FileName);
1206 break;
1207 #endif
1208
1209 #ifndef IL_NO_WBMP
1210 case IL_WBMP:
1211 bRet = ilLoadWbmp(FileName);
1212 break;
1213 #endif
1214
1215 #ifndef IL_NO_XPM
1216 case IL_XPM:
1217 bRet = ilLoadXpm(FileName);
1218 break;
1219 #endif
1220
1221 #ifndef IL_NO_WDP
1222 case IL_WDP:
1223 bRet = ilLoadWdp(FileName);
1224 break;
1225 #endif
1226
1227 default:
1228 ilSetError(IL_INVALID_ENUM);
1229 bRet = IL_FALSE;
1230 }
1231
1232 return bRet;
1233 }
1234
1235
1236 //! Attempts to load an image from a file stream. The file format is specified by the user.
1237 /*! \param Type Format of this file. Acceptable values are IL_BLP, IL_BMP, IL_CUT, IL_DCX, IL_DDS,
1238 IL_DICOM, IL_DOOM, IL_DOOM_FLAT, IL_DPX, IL_EXR, IL_FITS, IL_FTX, IL_GIF, IL_HDR, IL_ICO, IL_ICNS,
1239 IL_IFF, IL_IWI, IL_JP2, IL_JPG, IL_LIF, IL_MDL, IL_MNG, IL_MP3, IL_PCD, IL_PCX, IL_PIX, IL_PNG,
1240 IL_PNM, IL_PSD, IL_PSP, IL_PXR, IL_ROT, IL_SGI, IL_SUN, IL_TEXTURE, IL_TGA, IL_TIF, IL_TPL,
1241 IL_UTX, IL_VTF, IL_WAL, IL_WBMP, IL_XPM, IL_RAW, IL_JASC_PAL and IL_TYPE_UNKNOWN.
1242 If IL_TYPE_UNKNOWN is specified, ilLoadF will try to determine the type of the file and load it.
1243 \param File File stream to load from.
1244 \return Boolean value of failure or success. Returns IL_FALSE if loading fails.*/
ilLoadF(ILenum Type,ILHANDLE File)1245 ILboolean ILAPIENTRY ilLoadF(ILenum Type, ILHANDLE File)
1246 {
1247 if (File == NULL) {
1248 ilSetError(IL_INVALID_PARAM);
1249 return IL_FALSE;
1250 }
1251
1252 if (Type == IL_TYPE_UNKNOWN)
1253 Type = ilDetermineTypeF(File);
1254
1255 switch (Type)
1256 {
1257 case IL_TYPE_UNKNOWN:
1258 return IL_FALSE;
1259
1260 #ifndef IL_NO_TGA
1261 case IL_TGA:
1262 return ilLoadTargaF(File);
1263 #endif
1264
1265 #ifndef IL_NO_JPG
1266 #ifndef IL_USE_IJL
1267 case IL_JPG:
1268 return ilLoadJpegF(File);
1269 #endif
1270 #endif
1271
1272 #ifndef IL_NO_JP2
1273 case IL_JP2:
1274 return ilLoadJp2F(File);
1275 #endif
1276
1277 #ifndef IL_NO_DDS
1278 case IL_DDS:
1279 return ilLoadDdsF(File);
1280 #endif
1281
1282 #ifndef IL_NO_PNG
1283 case IL_PNG:
1284 return ilLoadPngF(File);
1285 #endif
1286
1287 #ifndef IL_NO_BLP
1288 case IL_BLP:
1289 return ilLoadBlpF(File);
1290 #endif
1291
1292 #ifndef IL_NO_BMP
1293 case IL_BMP:
1294 return ilLoadBmpF(File);
1295 #endif
1296
1297 #ifndef IL_NO_CUT
1298 case IL_CUT:
1299 return ilLoadCutF(File);
1300 #endif
1301
1302 #ifndef IL_NO_DICOM
1303 case IL_DICOM:
1304 return ilLoadDicomF(File);
1305 #endif
1306
1307 #ifndef IL_NO_DOOM
1308 case IL_DOOM:
1309 return ilLoadDoomF(File);
1310 case IL_DOOM_FLAT:
1311 return ilLoadDoomFlatF(File);
1312 #endif
1313
1314 #ifndef IL_NO_DPX
1315 case IL_DPX:
1316 return ilLoadDpxF(File);
1317 #endif
1318
1319 #ifndef IL_NO_EXR
1320 case IL_EXR:
1321 return ilLoadExrF(File);
1322 #endif
1323
1324 #ifndef IL_NO_FITS
1325 case IL_FITS:
1326 return ilLoadFitsF(File);
1327 #endif
1328
1329 #ifndef IL_NO_FTX
1330 case IL_FTX:
1331 return ilLoadFtxF(File);
1332 #endif
1333
1334 #ifndef IL_NO_GIF
1335 case IL_GIF:
1336 return ilLoadGifF(File);
1337 #endif
1338
1339 #ifndef IL_NO_HDR
1340 case IL_HDR:
1341 return ilLoadHdrF(File);
1342 #endif
1343
1344 #ifndef IL_NO_ICO
1345 case IL_ICO:
1346 return ilLoadIconF(File);
1347 #endif
1348
1349 #ifndef IL_NO_ICNS
1350 case IL_ICNS:
1351 return ilLoadIcnsF(File);
1352 #endif
1353
1354 #ifndef IL_NO_IFF
1355 case IL_IFF:
1356 return ilLoadIffF(File);
1357 #endif
1358
1359 #ifndef IL_NO_ILBM
1360 case IL_ILBM:
1361 return ilLoadIlbmF(File);
1362 #endif
1363
1364 #ifndef IL_NO_IWI
1365 case IL_IWI:
1366 return ilLoadIwiF(File);
1367 #endif
1368
1369 #ifndef IL_NO_LIF
1370 case IL_LIF:
1371 return ilLoadLifF(File);
1372 #endif
1373
1374 #ifndef IL_NO_MDL
1375 case IL_MDL:
1376 return ilLoadMdlF(File);
1377 #endif
1378
1379 #ifndef IL_NO_MNG
1380 case IL_MNG:
1381 return ilLoadMngF(File);
1382 #endif
1383
1384 #ifndef IL_NO_MP3
1385 case IL_MP3:
1386 return ilLoadMp3F(File);
1387 #endif
1388
1389 #ifndef IL_NO_PCD
1390 case IL_PCD:
1391 return ilLoadPcdF(File);
1392 #endif
1393
1394 #ifndef IL_NO_PCX
1395 case IL_PCX:
1396 return ilLoadPcxF(File);
1397 #endif
1398
1399 #ifndef IL_NO_PIC
1400 case IL_PIC:
1401 return ilLoadPicF(File);
1402 #endif
1403
1404 #ifndef IL_NO_PIX
1405 case IL_PIX:
1406 return ilLoadPixF(File);
1407 #endif
1408
1409 #ifndef IL_NO_PNM
1410 case IL_PNM:
1411 return ilLoadPnmF(File);
1412 #endif
1413
1414 #ifndef IL_NO_PSD
1415 case IL_PSD:
1416 return ilLoadPsdF(File);
1417 #endif
1418
1419 #ifndef IL_NO_PSP
1420 case IL_PSP:
1421 return ilLoadPspF(File);
1422 #endif
1423
1424 #ifndef IL_NO_PXR
1425 case IL_PXR:
1426 return ilLoadPxrF(File);
1427 #endif
1428
1429 #ifndef IL_NO_RAW
1430 case IL_RAW:
1431 return ilLoadRawF(File);
1432 #endif
1433
1434 #ifndef IL_NO_ROT
1435 case IL_ROT:
1436 return ilLoadRotF(File);
1437 #endif
1438
1439 #ifndef IL_NO_SGI
1440 case IL_SGI:
1441 return ilLoadSgiF(File);
1442 #endif
1443
1444 #ifndef IL_NO_SUN
1445 case IL_SUN:
1446 return ilLoadSunF(File);
1447 #endif
1448
1449 #ifndef IL_NO_TEXTURE
1450 case IL_TEXTURE:
1451 return ilLoadTextureF(File);
1452 #endif
1453
1454 #ifndef IL_NO_TIF
1455 case IL_TIF:
1456 return ilLoadTiffF(File);
1457 #endif
1458
1459 #ifndef IL_NO_TPL
1460 case IL_TPL:
1461 return ilLoadTplF(File);
1462 #endif
1463
1464 #ifndef IL_NO_UTX
1465 case IL_UTX:
1466 return ilLoadUtxF(File);
1467 #endif
1468
1469 #ifndef IL_NO_VTF
1470 case IL_VTF:
1471 return ilLoadVtfF(File);
1472 #endif
1473
1474 #ifndef IL_NO_WAL
1475 case IL_WAL:
1476 return ilLoadWalF(File);
1477 #endif
1478
1479 #ifndef IL_NO_WBMP
1480 case IL_WBMP:
1481 return ilLoadWbmpF(File);
1482 #endif
1483
1484 #ifndef IL_NO_XPM
1485 case IL_XPM:
1486 return ilLoadXpmF(File);
1487 #endif
1488 }
1489
1490 ilSetError(IL_INVALID_ENUM);
1491 return IL_FALSE;
1492 }
1493
1494
1495 //! Attempts to load an image from a memory buffer. The file format is specified by the user.
1496 /*! \param Type Format of this file. Acceptable values are IL_BLP, IL_BMP, IL_CUT, IL_DCX, IL_DDS,
1497 IL_DICOM, IL_DOOM, IL_DOOM_FLAT, IL_DPX, IL_EXR, IL_FITS, IL_FTX, IL_GIF, IL_HDR, IL_ICO, IL_ICNS,
1498 IL_IFF, IL_IWI, IL_JP2, IL_JPG, IL_LIF, IL_MDL, IL_MNG, IL_MP3, IL_PCD, IL_PCX, IL_PIX, IL_PNG,
1499 IL_PNM, IL_PSD, IL_PSP, IL_PXR, IL_ROT, IL_SGI, IL_SUN, IL_TEXTURE, IL_TGA, IL_TIF, IL_TPL,
1500 IL_UTX, IL_VTF, IL_WAL, IL_WBMP, IL_XPM, IL_RAW, IL_JASC_PAL and IL_TYPE_UNKNOWN.
1501 If IL_TYPE_UNKNOWN is specified, ilLoadL will try to determine the type of the file and load it.
1502 \param Lump The buffer where the file data is located
1503 \param Size Size of the buffer
1504 \return Boolean value of failure or success. Returns IL_FALSE if loading fails.*/
ilLoadL(ILenum Type,const void * Lump,ILuint Size)1505 ILboolean ILAPIENTRY ilLoadL(ILenum Type, const void *Lump, ILuint Size)
1506 {
1507 if (Lump == NULL || Size == 0) {
1508 ilSetError(IL_INVALID_PARAM);
1509 return IL_FALSE;
1510 }
1511
1512 if (Type == IL_TYPE_UNKNOWN)
1513 Type = ilDetermineTypeL(Lump, Size);
1514
1515 switch (Type)
1516 {
1517 case IL_TYPE_UNKNOWN:
1518 return IL_FALSE;
1519
1520 #ifndef IL_NO_TGA
1521 case IL_TGA:
1522 return ilLoadTargaL(Lump, Size);
1523 #endif
1524
1525 #ifndef IL_NO_JPG
1526 case IL_JPG:
1527 return ilLoadJpegL(Lump, Size);
1528 #endif
1529
1530 #ifndef IL_NO_JP2
1531 case IL_JP2:
1532 return ilLoadJp2L(Lump, Size);
1533 #endif
1534
1535 #ifndef IL_NO_DDS
1536 case IL_DDS:
1537 return ilLoadDdsL(Lump, Size);
1538 #endif
1539
1540 #ifndef IL_NO_PNG
1541 case IL_PNG:
1542 return ilLoadPngL(Lump, Size);
1543 #endif
1544
1545 #ifndef IL_NO_BLP
1546 case IL_BLP:
1547 return ilLoadBlpL(Lump, Size);
1548 #endif
1549
1550 #ifndef IL_NO_BMP
1551 case IL_BMP:
1552 return ilLoadBmpL(Lump, Size);
1553 #endif
1554
1555 #ifndef IL_NO_CUT
1556 case IL_CUT:
1557 return ilLoadCutL(Lump, Size);
1558 #endif
1559
1560 #ifndef IL_NO_DICOM
1561 case IL_DICOM:
1562 return ilLoadDicomL(Lump, Size);
1563 #endif
1564
1565 #ifndef IL_NO_DOOM
1566 case IL_DOOM:
1567 return ilLoadDoomL(Lump, Size);
1568 case IL_DOOM_FLAT:
1569 return ilLoadDoomFlatL(Lump, Size);
1570 #endif
1571
1572 #ifndef IL_NO_DPX
1573 case IL_DPX:
1574 return ilLoadDpxL(Lump, Size);
1575 #endif
1576
1577 #ifndef IL_NO_EXR
1578 case IL_EXR:
1579 return ilLoadExrL(Lump, Size);
1580 #endif
1581
1582 #ifndef IL_NO_FITS
1583 case IL_FITS:
1584 return ilLoadFitsL(Lump, Size);
1585 #endif
1586
1587 #ifndef IL_NO_FTX
1588 case IL_FTX:
1589 return ilLoadFtxL(Lump, Size);
1590 #endif
1591
1592 #ifndef IL_NO_GIF
1593 case IL_GIF:
1594 return ilLoadGifL(Lump, Size);
1595 #endif
1596
1597 #ifndef IL_NO_HDR
1598 case IL_HDR:
1599 return ilLoadHdrL(Lump, Size);
1600 #endif
1601
1602 #ifndef IL_NO_ICO
1603 case IL_ICO:
1604 return ilLoadIconL(Lump, Size);
1605 #endif
1606
1607 #ifndef IL_NO_ICNS
1608 case IL_ICNS:
1609 return ilLoadIcnsL(Lump, Size);
1610 #endif
1611
1612 #ifndef IL_NO_IFF
1613 case IL_IFF:
1614 return ilLoadIffL(Lump, Size);
1615 #endif
1616
1617 #ifndef IL_NO_ILBM
1618 case IL_ILBM:
1619 return ilLoadIlbmL(Lump, Size);
1620 #endif
1621
1622 #ifndef IL_NO_IWI
1623 case IL_IWI:
1624 return ilLoadIwiL(Lump, Size);
1625 #endif
1626
1627 #ifndef IL_NO_LIF
1628 case IL_LIF:
1629 return ilLoadLifL(Lump, Size);
1630 #endif
1631
1632 #ifndef IL_NO_MDL
1633 case IL_MDL:
1634 return ilLoadMdlL(Lump, Size);
1635 #endif
1636
1637 #ifndef IL_NO_MNG
1638 case IL_MNG:
1639 return ilLoadMngL(Lump, Size);
1640 #endif
1641
1642 #ifndef IL_NO_MP3
1643 case IL_MP3:
1644 return ilLoadMp3L(Lump, Size);
1645 #endif
1646
1647 #ifndef IL_NO_PCD
1648 case IL_PCD:
1649 return ilLoadPcdL(Lump, Size);
1650 #endif
1651
1652 #ifndef IL_NO_PCX
1653 case IL_PCX:
1654 return ilLoadPcxL(Lump, Size);
1655 #endif
1656
1657 #ifndef IL_NO_PIC
1658 case IL_PIC:
1659 return ilLoadPicL(Lump, Size);
1660 #endif
1661
1662 #ifndef IL_NO_PIX
1663 case IL_PIX:
1664 return ilLoadPixL(Lump, Size);
1665 #endif
1666
1667 #ifndef IL_NO_PNM
1668 case IL_PNM:
1669 return ilLoadPnmL(Lump, Size);
1670 #endif
1671
1672 #ifndef IL_NO_PSD
1673 case IL_PSD:
1674 return ilLoadPsdL(Lump, Size);
1675 #endif
1676
1677 #ifndef IL_NO_PSP
1678 case IL_PSP:
1679 return ilLoadPspL(Lump, Size);
1680 #endif
1681
1682 #ifndef IL_NO_PXR
1683 case IL_PXR:
1684 return ilLoadPxrL(Lump, Size);
1685 #endif
1686
1687 #ifndef IL_NO_RAW
1688 case IL_RAW:
1689 return ilLoadRawL(Lump, Size);
1690 #endif
1691
1692 #ifndef IL_NO_ROT
1693 case IL_ROT:
1694 return ilLoadRotL(Lump, Size);
1695 #endif
1696
1697 #ifndef IL_NO_SGI
1698 case IL_SGI:
1699 return ilLoadSgiL(Lump, Size);
1700 #endif
1701
1702 #ifndef IL_NO_SUN
1703 case IL_SUN:
1704 return ilLoadSunL(Lump, Size);
1705 #endif
1706
1707 #ifndef IL_NO_TEXTURE
1708 case IL_TEXTURE:
1709 return ilLoadTextureL(Lump, Size);
1710 #endif
1711
1712 #ifndef IL_NO_TIF
1713 case IL_TIF:
1714 return ilLoadTiffL(Lump, Size);
1715 #endif
1716
1717 #ifndef IL_NO_TPL
1718 case IL_TPL:
1719 return ilLoadTplL(Lump, Size);
1720 #endif
1721
1722 #ifndef IL_NO_UTX
1723 case IL_UTX:
1724 return ilLoadUtxL(Lump, Size);
1725 #endif
1726
1727 #ifndef IL_NO_VTF
1728 case IL_VTF:
1729 return ilLoadVtfL(Lump, Size);
1730 #endif
1731
1732 #ifndef IL_NO_WAL
1733 case IL_WAL:
1734 return ilLoadWalL(Lump, Size);
1735 #endif
1736
1737 #ifndef IL_NO_WBMP
1738 case IL_WBMP:
1739 return ilLoadWbmpL(Lump, Size);
1740 #endif
1741
1742 #ifndef IL_NO_XPM
1743 case IL_XPM:
1744 return ilLoadXpmL(Lump, Size);
1745 #endif
1746 }
1747
1748 ilSetError(IL_INVALID_ENUM);
1749 return IL_FALSE;
1750 }
1751
1752
1753 //! Attempts to load an image from a file with various different methods before failing - very generic.
1754 /*! The ilLoadImage function allows a general interface to the specific internal file-loading
1755 routines. First, it finds the extension and checks to see if any user-registered functions
1756 (registered through ilRegisterLoad) match the extension. If nothing matches, it takes the
1757 extension and determines which function to call based on it. Lastly, it attempts to identify
1758 the image based on various image header verification functions, such as ilIsValidPngF.
1759 If all this checking fails, IL_FALSE is returned with no modification to the current bound image.
1760 \param FileName Ansi or Unicode string, depending on the compiled version of DevIL, that gives
1761 the filename of the file to load.
1762 \return Boolean value of failure or success. Returns IL_FALSE if all three loading methods
1763 have been tried and failed.*/
ilLoadImage(ILconst_string FileName)1764 ILboolean ILAPIENTRY ilLoadImage(ILconst_string FileName)
1765 {
1766 ILstring Ext;
1767 ILenum Type;
1768 ILboolean bRet = IL_FALSE;
1769
1770 if (iCurImage == NULL) {
1771 ilSetError(IL_ILLEGAL_OPERATION);
1772 return IL_FALSE;
1773 }
1774
1775 if (FileName == NULL || ilStrLen(FileName) < 1) {
1776 ilSetError(IL_INVALID_PARAM);
1777 return IL_FALSE;
1778 }
1779
1780 Ext = iGetExtension(FileName);
1781
1782 // Try registered procedures first (so users can override default lib functions).
1783 if (Ext) {
1784 if (iRegisterLoad(FileName))
1785 return IL_TRUE;
1786
1787 #ifndef IL_NO_TGA
1788 if (!iStrCmp(Ext, IL_TEXT("tga")) || !iStrCmp(Ext, IL_TEXT("vda")) ||
1789 !iStrCmp(Ext, IL_TEXT("icb")) || !iStrCmp(Ext, IL_TEXT("vst"))) {
1790 bRet = ilLoadTarga(FileName);
1791 goto finish;
1792 }
1793 #endif
1794
1795 #ifndef IL_NO_JPG
1796 if (!iStrCmp(Ext, IL_TEXT("jpg")) || !iStrCmp(Ext, IL_TEXT("jpe")) ||
1797 !iStrCmp(Ext, IL_TEXT("jpeg")) || !iStrCmp(Ext, IL_TEXT("jif")) || !iStrCmp(Ext, IL_TEXT("jfif"))) {
1798 bRet = ilLoadJpeg(FileName);
1799 goto finish;
1800 }
1801 #endif
1802
1803 #ifndef IL_NO_JP2
1804 if (!iStrCmp(Ext, IL_TEXT("jp2")) || !iStrCmp(Ext, IL_TEXT("jpx")) ||
1805 !iStrCmp(Ext, IL_TEXT("j2k")) || !iStrCmp(Ext, IL_TEXT("j2c"))) {
1806 bRet = ilLoadJp2(FileName);
1807 goto finish;
1808 }
1809 #endif
1810
1811 #ifndef IL_NO_DDS
1812 if (!iStrCmp(Ext, IL_TEXT("dds"))) {
1813 bRet = ilLoadDds(FileName);
1814 goto finish;
1815 }
1816 #endif
1817
1818 #ifndef IL_NO_PNG
1819 if (!iStrCmp(Ext, IL_TEXT("png"))) {
1820 bRet = ilLoadPng(FileName);
1821 goto finish;
1822 }
1823 #endif
1824
1825 #ifndef IL_NO_BMP
1826 if (!iStrCmp(Ext, IL_TEXT("bmp")) || !iStrCmp(Ext, IL_TEXT("dib"))) {
1827 bRet = ilLoadBmp(FileName);
1828 goto finish;
1829 }
1830 #endif
1831
1832 #ifndef IL_NO_BLP
1833 if (!iStrCmp(Ext, IL_TEXT("blp"))) {
1834 bRet = ilLoadBlp(FileName);
1835 goto finish;
1836 }
1837 #endif
1838
1839 #ifndef IL_NO_DPX
1840 if (!iStrCmp(Ext, IL_TEXT("dpx"))) {
1841 bRet = ilLoadDpx(FileName);
1842 goto finish;
1843 }
1844 #endif
1845
1846 #ifndef IL_NO_EXR
1847 if (!iStrCmp(Ext, IL_TEXT("exr"))) {
1848 bRet = ilLoadExr(FileName);
1849 goto finish;
1850 }
1851 #endif
1852
1853 #ifndef IL_NO_GIF
1854 if (!iStrCmp(Ext, IL_TEXT("gif"))) {
1855 bRet = ilLoadGif(FileName);
1856 goto finish;
1857 }
1858 #endif
1859
1860 #ifndef IL_NO_HDR
1861 if (!iStrCmp(Ext, IL_TEXT("hdr"))) {
1862 bRet = ilLoadHdr(FileName);
1863 goto finish;
1864 }
1865 #endif
1866
1867 #ifndef IL_NO_CUT
1868 if (!iStrCmp(Ext, IL_TEXT("cut"))) {
1869 bRet = ilLoadCut(FileName);
1870 goto finish;
1871 }
1872 #endif
1873
1874 #ifndef IL_NO_DCX
1875 if (!iStrCmp(Ext, IL_TEXT("dcx"))) {
1876 bRet = ilLoadDcx(FileName);
1877 goto finish;
1878 }
1879 #endif
1880
1881 #ifndef IL_NO_DICOM
1882 if (!iStrCmp(Ext, IL_TEXT("dicom")) || !iStrCmp(Ext, IL_TEXT("dcm"))) {
1883 bRet = ilLoadDicom(FileName);
1884 goto finish;
1885 }
1886 #endif
1887
1888 #ifndef IL_NO_FITS
1889 if (!iStrCmp(Ext, IL_TEXT("fits")) || !iStrCmp(Ext, IL_TEXT("fit"))) {
1890 bRet = ilLoadFits(FileName);
1891 goto finish;
1892 }
1893 #endif
1894
1895 #ifndef IL_NO_FTX
1896 if (!iStrCmp(Ext, IL_TEXT("ftx"))) {
1897 bRet = ilLoadFtx(FileName);
1898 goto finish;
1899 }
1900 #endif
1901
1902 #ifndef IL_NO_ICO
1903 if (!iStrCmp(Ext, IL_TEXT("ico")) || !iStrCmp(Ext, IL_TEXT("cur"))) {
1904 bRet = ilLoadIcon(FileName);
1905 goto finish;
1906 }
1907 #endif
1908
1909 #ifndef IL_NO_ICNS
1910 if (!iStrCmp(Ext, IL_TEXT("icns"))) {
1911 bRet = ilLoadIcns(FileName);
1912 goto finish;
1913 }
1914 #endif
1915
1916 #ifndef IL_NO_IFF
1917 if (!iStrCmp(Ext, IL_TEXT("iff"))) {
1918 bRet = ilLoadIff(FileName);
1919 goto finish;
1920 }
1921 #endif
1922
1923 #ifndef IL_NO_ILBM
1924 if (!iStrCmp(Ext, IL_TEXT("ilbm")) || !iStrCmp(Ext, IL_TEXT("lbm")) ||
1925 !iStrCmp(Ext, IL_TEXT("ham")) ) {
1926 bRet = ilLoadIlbm(FileName);
1927 goto finish;
1928 }
1929 #endif
1930
1931 #ifndef IL_NO_IWI
1932 if (!iStrCmp(Ext, IL_TEXT("iwi"))) {
1933 bRet = ilLoadIwi(FileName);
1934 goto finish;
1935 }
1936 #endif
1937
1938 #ifndef IL_NO_LIF
1939 if (!iStrCmp(Ext, IL_TEXT("lif"))) {
1940 bRet = ilLoadLif(FileName);
1941 goto finish;
1942 }
1943 #endif
1944
1945 #ifndef IL_NO_MDL
1946 if (!iStrCmp(Ext, IL_TEXT("mdl"))) {
1947 bRet = ilLoadMdl(FileName);
1948 goto finish;
1949 }
1950 #endif
1951
1952 #ifndef IL_NO_MNG
1953 if (!iStrCmp(Ext, IL_TEXT("mng")) || !iStrCmp(Ext, IL_TEXT("jng"))) {
1954 bRet = ilLoadMng(FileName);
1955 goto finish;
1956 }
1957 #endif
1958
1959 #ifndef IL_NO_MP3
1960 if (!iStrCmp(Ext, IL_TEXT("mp3"))) {
1961 bRet = ilLoadMp3(FileName);
1962 goto finish;
1963 }
1964 #endif
1965
1966 #ifndef IL_NO_PCD
1967 if (!iStrCmp(Ext, IL_TEXT("pcd"))) {
1968 bRet = ilLoadPcd(FileName);
1969 goto finish;
1970 }
1971 #endif
1972
1973 #ifndef IL_NO_PCX
1974 if (!iStrCmp(Ext, IL_TEXT("pcx"))) {
1975 bRet = ilLoadPcx(FileName);
1976 goto finish;
1977 }
1978 #endif
1979
1980 #ifndef IL_NO_PIC
1981 if (!iStrCmp(Ext, IL_TEXT("pic"))) {
1982 bRet = ilLoadPic(FileName);
1983 goto finish;
1984 }
1985 #endif
1986
1987 #ifndef IL_NO_PIX
1988 if (!iStrCmp(Ext, IL_TEXT("pix"))) {
1989 bRet = ilLoadPix(FileName);
1990 goto finish;
1991 }
1992 #endif
1993
1994 #ifndef IL_NO_PNM
1995 if (!iStrCmp(Ext, IL_TEXT("pbm"))) {
1996 bRet = ilLoadPnm(FileName);
1997 goto finish;
1998 }
1999 if (!iStrCmp(Ext, IL_TEXT("pgm"))) {
2000 bRet = ilLoadPnm(FileName);
2001 goto finish;
2002 }
2003 if (!iStrCmp(Ext, IL_TEXT("pnm"))) {
2004 bRet = ilLoadPnm(FileName);
2005 goto finish;
2006 }
2007 if (!iStrCmp(Ext, IL_TEXT("ppm"))) {
2008 bRet = ilLoadPnm(FileName);
2009 goto finish;
2010 }
2011 #endif
2012
2013 #ifndef IL_NO_PSD
2014 if (!iStrCmp(Ext, IL_TEXT("psd")) || !iStrCmp(Ext, IL_TEXT("pdd"))) {
2015 bRet = ilLoadPsd(FileName);
2016 goto finish;
2017 }
2018 #endif
2019
2020 #ifndef IL_NO_PSP
2021 if (!iStrCmp(Ext, IL_TEXT("psp"))) {
2022 bRet = ilLoadPsp(FileName);
2023 goto finish;
2024 }
2025 #endif
2026
2027 #ifndef IL_NO_PXR
2028 if (!iStrCmp(Ext, IL_TEXT("pxr"))) {
2029 bRet = ilLoadPxr(FileName);
2030 goto finish;
2031 }
2032 #endif
2033
2034 #ifndef IL_NO_ROT
2035 if (!iStrCmp(Ext, IL_TEXT("rot"))) {
2036 bRet = ilLoadRot(FileName);
2037 goto finish;
2038 }
2039 #endif
2040
2041 #ifndef IL_NO_SGI
2042 if (!iStrCmp(Ext, IL_TEXT("sgi")) || !iStrCmp(Ext, IL_TEXT("bw")) ||
2043 !iStrCmp(Ext, IL_TEXT("rgb")) || !iStrCmp(Ext, IL_TEXT("rgba"))) {
2044 bRet = ilLoadSgi(FileName);
2045 goto finish;
2046 }
2047 #endif
2048
2049 #ifndef IL_NO_SUN
2050 if (!iStrCmp(Ext, IL_TEXT("sun")) || !iStrCmp(Ext, IL_TEXT("ras")) ||
2051 !iStrCmp(Ext, IL_TEXT("rs")) || !iStrCmp(Ext, IL_TEXT("im1")) ||
2052 !iStrCmp(Ext, IL_TEXT("im8")) || !iStrCmp(Ext, IL_TEXT("im24")) ||
2053 !iStrCmp(Ext, IL_TEXT("im32"))) {
2054 bRet = ilLoadSun(FileName);
2055 goto finish;
2056 }
2057 #endif
2058
2059 #ifndef IL_NO_TEXTURE
2060 if (!iStrCmp(Ext, IL_TEXT("texture"))) {
2061 bRet = ilLoadTexture(FileName);
2062 goto finish;
2063 }
2064 #endif
2065
2066 #ifndef IL_NO_TIF
2067 if (!iStrCmp(Ext, IL_TEXT("tif")) || !iStrCmp(Ext, IL_TEXT("tiff"))) {
2068 bRet = ilLoadTiff(FileName);
2069 goto finish;
2070 }
2071 #endif
2072
2073 #ifndef IL_NO_TPL
2074 if (!iStrCmp(Ext, IL_TEXT("tpl"))) {
2075 bRet = ilLoadTpl(FileName);
2076 goto finish;
2077 }
2078 #endif
2079
2080 #ifndef IL_NO_UTX
2081 if (!iStrCmp(Ext, IL_TEXT("utx"))) {
2082 bRet = ilLoadUtx(FileName);
2083 goto finish;
2084 }
2085 #endif
2086
2087 #ifndef IL_NO_VTF
2088 if (!iStrCmp(Ext, IL_TEXT("vtf"))) {
2089 bRet = ilLoadVtf(FileName);
2090 goto finish;
2091 }
2092 #endif
2093
2094 #ifndef IL_NO_WAL
2095 if (!iStrCmp(Ext, IL_TEXT("wal"))) {
2096 bRet = ilLoadWal(FileName);
2097 goto finish;
2098 }
2099 #endif
2100
2101 #ifndef IL_NO_WBMP
2102 if (!iStrCmp(Ext, IL_TEXT("wbmp"))) {
2103 bRet = ilLoadWbmp(FileName);
2104 goto finish;
2105 }
2106 #endif
2107
2108 #ifndef IL_NO_WDP
2109 if (!iStrCmp(Ext, IL_TEXT("wdp")) || !iStrCmp(Ext, IL_TEXT("hdp")) ) {
2110 bRet = ilLoadWdp(FileName);
2111 goto finish;
2112 }
2113 #endif
2114
2115 #ifndef IL_NO_XPM
2116 if (!iStrCmp(Ext, IL_TEXT("xpm"))) {
2117 bRet = ilLoadXpm(FileName);
2118 goto finish;
2119 }
2120 #endif
2121 }
2122
2123 // As a last-ditch effort, try to identify the image
2124 Type = ilDetermineType(FileName);
2125 if (Type == IL_TYPE_UNKNOWN) {
2126 ilSetError(IL_INVALID_EXTENSION);
2127 return IL_FALSE;
2128 }
2129 return ilLoad(Type, FileName);
2130
2131 finish:
2132 return bRet;
2133 }
2134
2135
2136 //! Attempts to save an image to a file. The file format is specified by the user.
2137 /*! \param Type Format of this file. Acceptable values are IL_BMP, IL_CHEAD, IL_DDS, IL_EXR,
2138 IL_HDR, IL_JP2, IL_JPG, IL_PCX, IL_PNG, IL_PNM, IL_PSD, IL_RAW, IL_SGI, IL_TGA, IL_TIF,
2139 IL_VTF, IL_WBMP and IL_JASC_PAL.
2140 \param FileName Ansi or Unicode string, depending on the compiled version of DevIL, that gives
2141 the filename to save to.
2142 \return Boolean value of failure or success. Returns IL_FALSE if saving failed.*/
ilSave(ILenum Type,ILconst_string FileName)2143 ILboolean ILAPIENTRY ilSave(ILenum Type, ILconst_string FileName)
2144 {
2145 switch (Type)
2146 {
2147 case IL_TYPE_UNKNOWN:
2148 return ilSaveImage(FileName);
2149
2150 #ifndef IL_NO_BMP
2151 case IL_BMP:
2152 return ilSaveBmp(FileName);
2153 #endif
2154
2155 #ifndef IL_NO_CHEAD
2156 case IL_CHEAD:
2157 return ilSaveCHeader(FileName, "IL_IMAGE");
2158 #endif
2159
2160 #ifndef IL_NO_DDS
2161 case IL_DDS:
2162 return ilSaveDds(FileName);
2163 #endif
2164
2165 #ifndef IL_NO_EXR
2166 case IL_EXR:
2167 return ilSaveExr(FileName);
2168 #endif
2169
2170 #ifndef IL_NO_HDR
2171 case IL_HDR:
2172 return ilSaveHdr(FileName);
2173 #endif
2174
2175 #ifndef IL_NO_JP2
2176 case IL_JP2:
2177 return ilSaveJp2(FileName);
2178 #endif
2179
2180 #ifndef IL_NO_JPG
2181 case IL_JPG:
2182 return ilSaveJpeg(FileName);
2183 #endif
2184
2185 #ifndef IL_NO_PCX
2186 case IL_PCX:
2187 return ilSavePcx(FileName);
2188 #endif
2189
2190 #ifndef IL_NO_PNG
2191 case IL_PNG:
2192 return ilSavePng(FileName);
2193 #endif
2194
2195 #ifndef IL_NO_PNM
2196 case IL_PNM:
2197 return ilSavePnm(FileName);
2198 #endif
2199
2200 #ifndef IL_NO_PSD
2201 case IL_PSD:
2202 return ilSavePsd(FileName);
2203 #endif
2204
2205 #ifndef IL_NO_RAW
2206 case IL_RAW:
2207 return ilSaveRaw(FileName);
2208 #endif
2209
2210 #ifndef IL_NO_SGI
2211 case IL_SGI:
2212 return ilSaveSgi(FileName);
2213 #endif
2214
2215 #ifndef IL_NO_TGA
2216 case IL_TGA:
2217 return ilSaveTarga(FileName);
2218 #endif
2219
2220 #ifndef IL_NO_TIF
2221 case IL_TIF:
2222 return ilSaveTiff(FileName);
2223 #endif
2224
2225 #ifndef IL_NO_VTF
2226 case IL_VTF:
2227 return ilSaveVtf(FileName);
2228 #endif
2229
2230 #ifndef IL_NO_WBMP
2231 case IL_WBMP:
2232 return ilSaveWbmp(FileName);
2233 #endif
2234
2235 case IL_JASC_PAL:
2236 return ilSaveJascPal(FileName);
2237 }
2238
2239 ilSetError(IL_INVALID_ENUM);
2240 return IL_FALSE;
2241 }
2242
2243
2244 //! Attempts to save an image to a file stream. The file format is specified by the user.
2245 /*! \param Type Format of this file. Acceptable values are IL_BMP, IL_CHEAD, IL_DDS, IL_EXR,
2246 IL_HDR, IL_JP2, IL_JPG, IL_PCX, IL_PNG, IL_PNM, IL_PSD, IL_RAW, IL_SGI, IL_TGA, IL_TIF,
2247 IL_VTF, IL_WBMP and IL_JASC_PAL.
2248 \param File File stream to save to.
2249 \return Boolean value of failure or success. Returns IL_FALSE if saving failed.*/
ilSaveF(ILenum Type,ILHANDLE File)2250 ILuint ILAPIENTRY ilSaveF(ILenum Type, ILHANDLE File)
2251 {
2252 ILboolean Ret;
2253
2254 if (File == NULL) {
2255 ilSetError(IL_INVALID_PARAM);
2256 return 0;
2257 }
2258
2259 switch (Type)
2260 {
2261 #ifndef IL_NO_BMP
2262 case IL_BMP:
2263 Ret = ilSaveBmpF(File);
2264 break;
2265 #endif
2266
2267 #ifndef IL_NO_DDS
2268 case IL_DDS:
2269 Ret = ilSaveDdsF(File);
2270 break;
2271 #endif
2272
2273 #ifndef IL_NO_EXR
2274 case IL_EXR:
2275 Ret = ilSaveExrF(File);
2276 break;
2277 #endif
2278
2279 #ifndef IL_NO_HDR
2280 case IL_HDR:
2281 Ret = ilSaveHdrF(File);
2282 break;
2283 #endif
2284
2285 #ifndef IL_NO_JP2
2286 case IL_JP2:
2287 Ret = ilSaveJp2F(File);
2288 break;
2289 #endif
2290
2291 #ifndef IL_NO_JPG
2292 #ifndef IL_USE_IJL
2293 case IL_JPG:
2294 Ret = ilSaveJpegF(File);
2295 break;
2296 #endif
2297 #endif
2298
2299 #ifndef IL_NO_PNM
2300 case IL_PNM:
2301 Ret = ilSavePnmF(File);
2302 break;
2303 #endif
2304
2305 #ifndef IL_NO_PNG
2306 case IL_PNG:
2307 Ret = ilSavePngF(File);
2308 break;
2309 #endif
2310
2311 #ifndef IL_NO_PSD
2312 case IL_PSD:
2313 Ret = ilSavePsdF(File);
2314 break;
2315 #endif
2316
2317 #ifndef IL_NO_RAW
2318 case IL_RAW:
2319 Ret = ilSaveRawF(File);
2320 break;
2321 #endif
2322
2323 #ifndef IL_NO_SGI
2324 case IL_SGI:
2325 Ret = ilSaveSgiF(File);
2326 break;
2327 #endif
2328
2329 #ifndef IL_NO_TGA
2330 case IL_TGA:
2331 Ret = ilSaveTargaF(File);
2332 break;
2333 #endif
2334
2335 #ifndef IL_NO_VTF
2336 case IL_VTF:
2337 Ret = ilSaveVtfF(File);
2338 break;
2339 #endif
2340
2341 #ifndef IL_NO_WBMP
2342 case IL_WBMP:
2343 Ret = ilSaveWbmpF(File);
2344 break;
2345 #endif
2346
2347 #ifndef IL_NO_TIF
2348 case IL_TIF:
2349 Ret = ilSaveTiffF(File);
2350 break;
2351 #endif
2352
2353 default:
2354 ilSetError(IL_INVALID_ENUM);
2355 return 0;
2356 }
2357
2358 if (Ret == IL_FALSE)
2359 return 0;
2360
2361 return itellw();
2362 }
2363
2364
2365 //! Attempts to save an image to a memory buffer. The file format is specified by the user.
2366 /*! \param Type Format of this image file. Acceptable values are IL_BMP, IL_CHEAD, IL_DDS, IL_EXR,
2367 IL_HDR, IL_JP2, IL_JPG, IL_PCX, IL_PNG, IL_PNM, IL_PSD, IL_RAW, IL_SGI, IL_TGA, IL_TIF,
2368 IL_VTF, IL_WBMP and IL_JASC_PAL.
2369 \param Lump Memory buffer to save to
2370 \param Size Size of the memory buffer
2371 \return Boolean value of failure or success. Returns IL_FALSE if saving failed.*/
ilSaveL(ILenum Type,void * Lump,ILuint Size)2372 ILuint ILAPIENTRY ilSaveL(ILenum Type, void *Lump, ILuint Size)
2373 {
2374 if (Lump == NULL) {
2375 if (Size != 0) {
2376 ilSetError(IL_INVALID_PARAM);
2377 return 0;
2378 }
2379 // The user wants to know how large of a buffer they need.
2380 else {
2381 return ilDetermineSize(Type);
2382 }
2383 }
2384
2385 switch (Type)
2386 {
2387 #ifndef IL_NO_BMP
2388 case IL_BMP:
2389 return ilSaveBmpL(Lump, Size);
2390 #endif
2391
2392 #ifndef IL_NO_EXR
2393 case IL_EXR:
2394 return ilSaveExrL(Lump, Size);
2395 #endif
2396
2397 #ifndef IL_NO_HDR
2398 case IL_HDR:
2399 return ilSaveHdrL(Lump, Size);
2400 #endif
2401
2402 #ifndef IL_NO_JP2
2403 case IL_JP2:
2404 return ilSaveJp2L(Lump, Size);
2405 #endif
2406
2407 #ifndef IL_NO_JPG
2408 case IL_JPG:
2409 return ilSaveJpegL(Lump, Size);
2410 #endif
2411
2412 #ifndef IL_NO_PNG
2413 case IL_PNG:
2414 return ilSavePngL(Lump, Size);
2415 #endif
2416
2417 #ifndef IL_NO_PNM
2418 case IL_PNM:
2419 return ilSavePnmL(Lump, Size);
2420 #endif
2421
2422 #ifndef IL_NO_PSD
2423 case IL_PSD:
2424 return ilSavePsdL(Lump, Size);
2425 #endif
2426
2427 #ifndef IL_NO_RAW
2428 case IL_RAW:
2429 return ilSaveRawL(Lump, Size);
2430 #endif
2431
2432 #ifndef IL_NO_SGI
2433 case IL_SGI:
2434 return ilSaveSgiL(Lump, Size);
2435 #endif
2436
2437 #ifndef IL_NO_TGA
2438 case IL_TGA:
2439 return ilSaveTargaL(Lump, Size);
2440 #endif
2441
2442 #ifndef IL_NO_DDS
2443 case IL_DDS:
2444 return ilSaveDdsL(Lump, Size);
2445 #endif
2446
2447 #ifndef IL_NO_VTF
2448 case IL_VTF:
2449 return ilSaveVtfL(Lump, Size);
2450 #endif
2451
2452 #ifndef IL_NO_WBMP
2453 case IL_WBMP:
2454 return ilSaveWbmpL(Lump, Size);
2455 #endif
2456
2457 #ifndef IL_NO_TIF
2458 case IL_TIF:
2459 return ilSaveTiffL(Lump, Size);
2460 #endif
2461 }
2462
2463 ilSetError(IL_INVALID_ENUM);
2464 return 0;
2465 }
2466
2467
2468 //! Saves the current image based on the extension given in FileName.
2469 /*! \param FileName Ansi or Unicode string, depending on the compiled version of DevIL, that gives
2470 the filename to save to.
2471 \return Boolean value of failure or success. Returns IL_FALSE if saving failed.*/
ilSaveImage(ILconst_string FileName)2472 ILboolean ILAPIENTRY ilSaveImage(ILconst_string FileName)
2473 {
2474 ILstring Ext;
2475 ILboolean bRet = IL_FALSE;
2476
2477 if (FileName == NULL || ilStrLen(FileName) < 1) {
2478 ilSetError(IL_INVALID_PARAM);
2479 return IL_FALSE;
2480 }
2481
2482 if (iCurImage == NULL) {
2483 ilSetError(IL_ILLEGAL_OPERATION);
2484 return IL_FALSE;
2485 }
2486
2487 Ext = iGetExtension(FileName);
2488 if (Ext == NULL) {
2489 ilSetError(IL_INVALID_PARAM);
2490 return IL_FALSE;
2491 }
2492
2493 #ifndef IL_NO_BMP
2494 if (!iStrCmp(Ext, IL_TEXT("bmp"))) {
2495 bRet = ilSaveBmp(FileName);
2496 goto finish;
2497 }
2498 #endif
2499
2500 #ifndef IL_NO_CHEAD
2501 if (!iStrCmp(Ext, IL_TEXT("h"))) {
2502 bRet = ilSaveCHeader(FileName, "IL_IMAGE");
2503 goto finish;
2504 }
2505 #endif
2506
2507 #ifndef IL_NO_DDS
2508 if (!iStrCmp(Ext, IL_TEXT("dds"))) {
2509 bRet = ilSaveDds(FileName);
2510 goto finish;
2511 }
2512 #endif
2513
2514 #ifndef IL_NO_EXR
2515 if (!iStrCmp(Ext, IL_TEXT("exr"))) {
2516 bRet = ilSaveExr(FileName);
2517 goto finish;
2518 }
2519 #endif
2520
2521 #ifndef IL_NO_HDR
2522 if (!iStrCmp(Ext, IL_TEXT("hdr"))) {
2523 bRet = ilSaveHdr(FileName);
2524 goto finish;
2525 }
2526 #endif
2527
2528 #ifndef IL_NO_JP2
2529 if (!iStrCmp(Ext, IL_TEXT("jp2"))) {
2530 bRet = ilSaveJp2(FileName);
2531 goto finish;
2532 }
2533 #endif
2534
2535 #ifndef IL_NO_JPG
2536 if (!iStrCmp(Ext, IL_TEXT("jpg")) || !iStrCmp(Ext, IL_TEXT("jpeg")) || !iStrCmp(Ext, IL_TEXT("jpe"))) {
2537 bRet = ilSaveJpeg(FileName);
2538 goto finish;
2539 }
2540 #endif
2541
2542 #ifndef IL_NO_PCX
2543 if (!iStrCmp(Ext, IL_TEXT("pcx"))) {
2544 bRet = ilSavePcx(FileName);
2545 goto finish;
2546 }
2547 #endif
2548
2549 #ifndef IL_NO_PNG
2550 if (!iStrCmp(Ext, IL_TEXT("png"))) {
2551 bRet = ilSavePng(FileName);
2552 goto finish;
2553 }
2554 #endif
2555
2556 #ifndef IL_NO_PNM // Not sure if binary or ascii should be defaulted...maybe an option?
2557 if (!iStrCmp(Ext, IL_TEXT("pbm"))) {
2558 bRet = ilSavePnm(FileName);
2559 goto finish;
2560 }
2561 if (!iStrCmp(Ext, IL_TEXT("pgm"))) {
2562 bRet = ilSavePnm(FileName);
2563 goto finish;
2564 }
2565 if (!iStrCmp(Ext, IL_TEXT("ppm"))) {
2566 bRet = ilSavePnm(FileName);
2567 goto finish;
2568 }
2569 #endif
2570
2571 #ifndef IL_NO_PSD
2572 if (!iStrCmp(Ext, IL_TEXT("psd"))) {
2573 bRet = ilSavePsd(FileName);
2574 goto finish;
2575 }
2576 #endif
2577
2578 #ifndef IL_NO_RAW
2579 if (!iStrCmp(Ext, IL_TEXT("raw"))) {
2580 bRet = ilSaveRaw(FileName);
2581 goto finish;
2582 }
2583 #endif
2584
2585 #ifndef IL_NO_SGI
2586 if (!iStrCmp(Ext, IL_TEXT("sgi")) || !iStrCmp(Ext, IL_TEXT("bw")) ||
2587 !iStrCmp(Ext, IL_TEXT("rgb")) || !iStrCmp(Ext, IL_TEXT("rgba"))) {
2588 bRet = ilSaveSgi(FileName);
2589 goto finish;
2590 }
2591 #endif
2592
2593 #ifndef IL_NO_TGA
2594 if (!iStrCmp(Ext, IL_TEXT("tga"))) {
2595 bRet = ilSaveTarga(FileName);
2596 goto finish;
2597 }
2598 #endif
2599
2600 #ifndef IL_NO_TIF
2601 if (!iStrCmp(Ext, IL_TEXT("tif")) || !iStrCmp(Ext, IL_TEXT("tiff"))) {
2602 bRet = ilSaveTiff(FileName);
2603 goto finish;
2604 }
2605 #endif
2606
2607 #ifndef IL_NO_VTF
2608 if (!iStrCmp(Ext, IL_TEXT("vtf"))) {
2609 bRet = ilSaveVtf(FileName);
2610 goto finish;
2611 }
2612 #endif
2613
2614 #ifndef IL_NO_WBMP
2615 if (!iStrCmp(Ext, IL_TEXT("wbmp"))) {
2616 bRet = ilSaveWbmp(FileName);
2617 goto finish;
2618 }
2619 #endif
2620
2621 #ifndef IL_NO_MNG
2622 if (!iStrCmp(Ext, IL_TEXT("mng"))) {
2623 bRet = ilSaveMng(FileName);
2624 goto finish;
2625 }
2626 #endif
2627
2628 // Check if we just want to save the palette.
2629 if (!iStrCmp(Ext, IL_TEXT("pal"))) {
2630 bRet = ilSavePal(FileName);
2631 goto finish;
2632 }
2633
2634 // Try registered procedures
2635 if (iRegisterSave(FileName))
2636 return IL_TRUE;
2637
2638 ilSetError(IL_INVALID_EXTENSION);
2639 return IL_FALSE;
2640
2641 finish:
2642 return bRet;
2643 }
2644