Category

Development Platform
Home > SourceCode/Document > Compress-Decompress algrithms > View Code
il_states.c
Package: devil-1.7.99.tar.gz　[view]
Upload User: wmy0603
Upload Date: 2022-05-02
Package Size: 1808k
Code Size: 31k
Category:

Compress-Decompress algrithms

Development Platform:

Visual C++

il_states.c：Code Content
  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_states.c
  8. //
  9. // Description: State machine
  10. //
  11. //
  12. // 20040223 XIX : now has a ilPngAlphaIndex member, so we can spit out png files with a transparent index, set to -1 for none
  13. //
  14. //-----------------------------------------------------------------------------
  17. #include "il_internal.h"
  18. #include "il_states.h"
  19. #include <stdlib.h>
  21. ILconst_string _ilVendor = IL_TEXT("Abysmal Software");
  22. ILconst_string _ilVersion = IL_TEXT("Developer's Image Library (DevIL) 1.7.8");
  25. char* _ilLoadExt = "" IL_BLP_EXT IL_BMP_EXT IL_CUT_EXT IL_DCX_EXT IL_DDS_EXT
  26. IL_DCM_EXT IL_DPX_EXT IL_EXR_EXT IL_FITS_EXT IL_FTX_EXT
  27. IL_GIF_EXT IL_HDR_EXT IL_ICNS_EXT IL_ICO_EXT IL_IFF_EXT
  28. IL_IWI_EXT IL_JPG_EXT IL_JP2_EXT IL_LIF_EXT IL_MDL_EXT
  29. IL_MNG_EXT IL_MP3_EXT IL_PCD_EXT IL_PCX_EXT IL_PIC_EXT
  30. IL_PIX_EXT IL_PNG_EXT IL_PNM_EXT IL_PSD_EXT IL_PSP_EXT
  31. IL_PXR_EXT IL_RAW_EXT IL_ROT_EXT IL_SGI_EXT IL_SUN_EXT
  32. IL_TEX_EXT IL_TGA_EXT IL_TIFF_EXT IL_TPL_EXT IL_UTX_EXT
  33. IL_VTF_EXT IL_WAL_EXT IL_WDP_EXT IL_XPM_EXT;
  35. char* _ilSaveExt = "" IL_BMP_EXT IL_CHEAD_EXT IL_DDS_EXT IL_EXR_EXT
  36. IL_HDR_EXT IL_JP2_EXT IL_JPG_EXT IL_PCX_EXT
  37. IL_PNG_EXT IL_PNM_EXT IL_PSD_EXT IL_RAW_EXT
  38. IL_SGI_EXT IL_TGA_EXT IL_TIFF_EXT IL_VTF_EXT
  39. IL_WBMP_EXT;
  42. //! Set all states to their defaults.
  43. void ilDefaultStates()
  44. {
  45. ilStates[ilCurrentPos].ilOriginSet = IL_FALSE;
  46. ilStates[ilCurrentPos].ilOriginMode = IL_ORIGIN_LOWER_LEFT;
  47. ilStates[ilCurrentPos].ilFormatSet = IL_FALSE;
  48. ilStates[ilCurrentPos].ilFormatMode = IL_BGRA;
  49. ilStates[ilCurrentPos].ilTypeSet = IL_FALSE;
  50. ilStates[ilCurrentPos].ilTypeMode = IL_UNSIGNED_BYTE;
  51. ilStates[ilCurrentPos].ilOverWriteFiles = IL_FALSE;
  52. ilStates[ilCurrentPos].ilAutoConvPal = IL_FALSE;
  53. ilStates[ilCurrentPos].ilDefaultOnFail = IL_FALSE;
  54. ilStates[ilCurrentPos].ilUseKeyColour = IL_FALSE;
  55. ilStates[ilCurrentPos].ilBlitBlend = IL_TRUE;
  56. ilStates[ilCurrentPos].ilCompression = IL_COMPRESS_ZLIB;
  57. ilStates[ilCurrentPos].ilInterlace = IL_FALSE;
  59. ilStates[ilCurrentPos].ilTgaCreateStamp = IL_FALSE;
  60. ilStates[ilCurrentPos].ilJpgQuality = 99;
  61. ilStates[ilCurrentPos].ilPngInterlace = IL_FALSE;
  62. ilStates[ilCurrentPos].ilTgaRle = IL_FALSE;
  63. ilStates[ilCurrentPos].ilBmpRle = IL_FALSE;
  64. ilStates[ilCurrentPos].ilSgiRle = IL_FALSE;
  65. ilStates[ilCurrentPos].ilJpgFormat = IL_JFIF;
  66. ilStates[ilCurrentPos].ilJpgProgressive = IL_FALSE;
  67. ilStates[ilCurrentPos].ilDxtcFormat = IL_DXT1;
  68. ilStates[ilCurrentPos].ilPcdPicNum = 2;
  69. ilStates[ilCurrentPos].ilPngAlphaIndex = -1;
  71. ilStates[ilCurrentPos].ilTgaId = NULL;
  72. ilStates[ilCurrentPos].ilTgaAuthName = NULL;
  73. ilStates[ilCurrentPos].ilTgaAuthComment = NULL;
  74. ilStates[ilCurrentPos].ilPngAuthName = NULL;
  75. ilStates[ilCurrentPos].ilPngTitle = NULL;
  76. ilStates[ilCurrentPos].ilPngDescription = NULL;
  78. //2003-09-01: added tiff strings
  79. ilStates[ilCurrentPos].ilTifDescription = NULL;
  80. ilStates[ilCurrentPos].ilTifHostComputer = NULL;
  81. ilStates[ilCurrentPos].ilTifDocumentName = NULL;
  82. ilStates[ilCurrentPos].ilTifAuthName = NULL;
  83. ilStates[ilCurrentPos].ilCHeader = NULL;
  85. ilStates[ilCurrentPos].ilQuantMode = IL_WU_QUANT;
  86. ilStates[ilCurrentPos].ilNeuSample = 15;
  87. ilStates[ilCurrentPos].ilQuantMaxIndexs = 256;
  89. ilStates[ilCurrentPos].ilKeepDxtcData = IL_FALSE;
  90. ilStates[ilCurrentPos].ilUseNVidiaDXT = IL_FALSE;
  91. ilStates[ilCurrentPos].ilUseSquishDXT = IL_FALSE;
  96. ilHints.MemVsSpeedHint = IL_FASTEST;
  97. ilHints.CompressHint = IL_USE_COMPRESSION;
  99. while (ilGetError() != IL_NO_ERROR);
  101. return;
  102. }
  105. //! Returns a constant string detailing aspects about this library.
  106. ILconst_string ILAPIENTRY ilGetString(ILenum StringName)
  107. {
  108. switch (StringName)
  109. {
  110. case IL_VENDOR:
  111. return (ILconst_string)_ilVendor;
  112. case IL_VERSION_NUM: //changed 2003-08-30: IL_VERSION changes //switch define ;-)
  113. return (ILconst_string)_ilVersion;
  114. case IL_LOAD_EXT:
  115. return (ILconst_string)_ilLoadExt;
  116. case IL_SAVE_EXT:
  117. return (ILconst_string)_ilSaveExt;
  118. case IL_TGA_ID_STRING:
  119. return (ILconst_string)ilStates[ilCurrentPos].ilTgaId;
  120. case IL_TGA_AUTHNAME_STRING:
  121. return (ILconst_string)ilStates[ilCurrentPos].ilTgaAuthName;
  122. case IL_TGA_AUTHCOMMENT_STRING:
  123. return (ILconst_string)ilStates[ilCurrentPos].ilTgaAuthComment;
  124. case IL_PNG_AUTHNAME_STRING:
  125. return (ILconst_string)ilStates[ilCurrentPos].ilPngAuthName;
  126. case IL_PNG_TITLE_STRING:
  127. return (ILconst_string)ilStates[ilCurrentPos].ilPngTitle;
  128. case IL_PNG_DESCRIPTION_STRING:
  129. return (ILconst_string)ilStates[ilCurrentPos].ilPngDescription;
  130. //2003-08-31: added tif strings
  131. case IL_TIFF_DESCRIPTION_STRING:
  132. return (ILconst_string)ilStates[ilCurrentPos].ilTifDescription;
  133. case IL_TIFF_HOSTCOMPUTER_STRING:
  134. return (ILconst_string)ilStates[ilCurrentPos].ilTifHostComputer;
  135. case IL_TIFF_DOCUMENTNAME_STRING:
  136. return (ILconst_string)ilStates[ilCurrentPos].ilTifDocumentName;
  137. case IL_TIFF_AUTHNAME_STRING:
  138. return (ILconst_string)ilStates[ilCurrentPos].ilTifAuthName;
  139. case IL_CHEAD_HEADER_STRING:
  140. return (ILconst_string)ilStates[ilCurrentPos].ilCHeader;
  141. default:
  142. ilSetError(IL_INVALID_ENUM);
  143. break;
  144. }
  145. return NULL;
  146. }
  149. // Clips a string to a certain length and returns a new string.
  150. char *iClipString(char *String, ILuint MaxLen)
  151. {
  152. char *Clipped;
  153. ILuint Length;
  155. if (String == NULL)
  156. return NULL;
  158. Length = ilCharStrLen(String);  //ilStrLen(String);
  160. Clipped = (char*)ialloc((MaxLen + 1) * sizeof(char) /*sizeof(ILchar)*/);  // Terminating NULL makes it +1.
  161. if (Clipped == NULL) {
  162. return NULL;
  163. }
  165. memcpy(Clipped, String, MaxLen * sizeof(char) /*sizeof(ILchar)*/);
  166. Clipped[Length] = 0;
  168. return Clipped;
  169. }
  172. // Returns format-specific strings, truncated to MaxLen (not counting the terminating NULL).
  173. char *iGetString(ILenum StringName)
  174. {
  175. switch (StringName)
  176. {
  177. case IL_TGA_ID_STRING:
  178. return iClipString(ilStates[ilCurrentPos].ilTgaId, 254);
  179. case IL_TGA_AUTHNAME_STRING:
  180. return iClipString(ilStates[ilCurrentPos].ilTgaAuthName, 40);
  181. case IL_TGA_AUTHCOMMENT_STRING:
  182. return iClipString(ilStates[ilCurrentPos].ilTgaAuthComment, 80);
  183. case IL_PNG_AUTHNAME_STRING:
  184. return iClipString(ilStates[ilCurrentPos].ilPngAuthName, 255);
  185. case IL_PNG_TITLE_STRING:
  186. return iClipString(ilStates[ilCurrentPos].ilPngTitle, 255);
  187. case IL_PNG_DESCRIPTION_STRING:
  188. return iClipString(ilStates[ilCurrentPos].ilPngDescription, 255);
  190. //changed 2003-08-31...here was a serious copy and paste bug ;-)
  191. case IL_TIFF_DESCRIPTION_STRING:
  192. return iClipString(ilStates[ilCurrentPos].ilTifDescription, 255);
  193. case IL_TIFF_HOSTCOMPUTER_STRING:
  194. return iClipString(ilStates[ilCurrentPos].ilTifHostComputer, 255);
  195. case IL_TIFF_DOCUMENTNAME_STRING:
  196. return iClipString(ilStates[ilCurrentPos].ilTifDocumentName, 255);
  197. case IL_TIFF_AUTHNAME_STRING:
  198. return iClipString(ilStates[ilCurrentPos].ilTifAuthName, 255);
  199. case IL_CHEAD_HEADER_STRING:
  200. return iClipString(ilStates[ilCurrentPos].ilCHeader, 32);
  201. default:
  202. ilSetError(IL_INVALID_ENUM);
  203. }
  204. return NULL;
  205. }
  208. //! Enables a mode
  209. ILboolean ILAPIENTRY ilEnable(ILenum Mode)
  210. {
  211. return ilAble(Mode, IL_TRUE);
  212. }
  215. //! Disables a mode
  216. ILboolean ILAPIENTRY ilDisable(ILenum Mode)
  217. {
  218. return ilAble(Mode, IL_FALSE);
  219. }
  222. // Internal function that sets the Mode equal to Flag
  223. ILboolean ilAble(ILenum Mode, ILboolean Flag)
  224. {
  225. switch (Mode)
  226. {
  227. case IL_ORIGIN_SET:
  228. ilStates[ilCurrentPos].ilOriginSet = Flag;
  229. break;
  230. case IL_FORMAT_SET:
  231. ilStates[ilCurrentPos].ilFormatSet = Flag;
  232. break;
  233. case IL_TYPE_SET:
  234. ilStates[ilCurrentPos].ilTypeSet = Flag;
  235. break;
  236. case IL_FILE_OVERWRITE:
  237. ilStates[ilCurrentPos].ilOverWriteFiles = Flag;
  238. break;
  239. case IL_CONV_PAL:
  240. ilStates[ilCurrentPos].ilAutoConvPal = Flag;
  241. break;
  242. case IL_DEFAULT_ON_FAIL:
  243. ilStates[ilCurrentPos].ilDefaultOnFail = Flag;
  244. break;
  245. case IL_USE_KEY_COLOUR:
  246. ilStates[ilCurrentPos].ilUseKeyColour = Flag;
  247. break;
  248. case IL_BLIT_BLEND:
  249. ilStates[ilCurrentPos].ilBlitBlend = Flag;
  250. break;
  251. case IL_SAVE_INTERLACED:
  252. ilStates[ilCurrentPos].ilInterlace = Flag;
  253. break;
  254. case IL_JPG_PROGRESSIVE:
  255. ilStates[ilCurrentPos].ilJpgProgressive = Flag;
  256. break;
  257. case IL_NVIDIA_COMPRESS:
  258. ilStates[ilCurrentPos].ilUseNVidiaDXT = Flag;
  259. break;
  260. case IL_SQUISH_COMPRESS:
  261. ilStates[ilCurrentPos].ilUseSquishDXT = Flag;
  262. break;
  264. default:
  265. ilSetError(IL_INVALID_ENUM);
  266. return IL_FALSE;
  267. }
  269. return IL_TRUE;
  270. }
  273. //! Checks whether the mode is enabled.
  274. ILboolean ILAPIENTRY ilIsEnabled(ILenum Mode)
  275. {
  276. switch (Mode)
  277. {
  278. case IL_ORIGIN_SET:
  279. return ilStates[ilCurrentPos].ilOriginSet;
  280. case IL_FORMAT_SET:
  281. return ilStates[ilCurrentPos].ilFormatSet;
  282. case IL_TYPE_SET:
  283. return ilStates[ilCurrentPos].ilTypeSet;
  284. case IL_FILE_OVERWRITE:
  285. return ilStates[ilCurrentPos].ilOverWriteFiles;
  286. case IL_CONV_PAL:
  287. return ilStates[ilCurrentPos].ilAutoConvPal;
  288. case IL_DEFAULT_ON_FAIL:
  289. return ilStates[ilCurrentPos].ilDefaultOnFail;
  290. case IL_USE_KEY_COLOUR:
  291. return ilStates[ilCurrentPos].ilUseKeyColour;
  292. case IL_BLIT_BLEND:
  293. return ilStates[ilCurrentPos].ilBlitBlend;
  294. case IL_SAVE_INTERLACED:
  295. return ilStates[ilCurrentPos].ilInterlace;
  296. case IL_JPG_PROGRESSIVE:
  297. return ilStates[ilCurrentPos].ilJpgProgressive;
  298. case IL_NVIDIA_COMPRESS:
  299. return ilStates[ilCurrentPos].ilUseNVidiaDXT;
  300. case IL_SQUISH_COMPRESS:
  301. return ilStates[ilCurrentPos].ilUseSquishDXT;
  303. default:
  304. ilSetError(IL_INVALID_ENUM);
  305. }
  307. return IL_FALSE;
  308. }
  311. //! Checks whether the mode is disabled.
  312. ILboolean ILAPIENTRY ilIsDisabled(ILenum Mode)
  313. {
  314. return !ilIsEnabled(Mode);
  315. }
  318. //! Sets Param equal to the current value of the Mode
  319. void ILAPIENTRY ilGetBooleanv(ILenum Mode, ILboolean *Param)
  320. {
  321. if (Param == NULL) {
  322. ilSetError(IL_INVALID_PARAM);
  323. return;
  324. }
  326. *Param = ilGetInteger(Mode);
  328. return;
  329. }
  332. //! Returns the current value of the Mode
  333. ILboolean ILAPIENTRY ilGetBoolean(ILenum Mode)
  334. {
  335. ILboolean Temp;
  336. Temp = IL_FALSE;
  337. ilGetBooleanv(Mode, &Temp);
  338. return Temp;
  339. }
  342. ILimage *iGetBaseImage(void);
  344. //! Internal function to figure out where we are in an image chain.
  345. //@TODO: This may get much more complex with mipmaps under faces, etc.
  346. ILuint iGetActiveNum(ILenum Type)
  347. {
  348. ILimage *BaseImage;
  349. ILuint Num = 0;
  351. if (iCurImage == NULL) {
  352. ilSetError(IL_ILLEGAL_OPERATION);
  353. return 0;
  354. }
  356. BaseImage = iGetBaseImage();
  357. if (BaseImage == iCurImage)
  358. return 0;
  360. switch (Type)
  361. {
  362. case IL_ACTIVE_IMAGE:
  363. BaseImage = BaseImage->Next;
  364. do {
  365. if (BaseImage == NULL)
  366. return 0;
  367. Num++;
  368. if (BaseImage == iCurImage)
  369. return Num;
  370. } while ((BaseImage = BaseImage->Next));
  371. break;
  372. case IL_ACTIVE_MIPMAP:
  373. BaseImage = BaseImage->Mipmaps;
  374. do {
  375. if (BaseImage == NULL)
  376. return 0;
  377. Num++;
  378. if (BaseImage == iCurImage)
  379. return Num;
  380. } while ((BaseImage = BaseImage->Mipmaps));
  381. break;
  382. case IL_ACTIVE_LAYER:
  383. BaseImage = BaseImage->Layers;
  384. do {
  385. if (BaseImage == NULL)
  386. return 0;
  387. Num++;
  388. if (BaseImage == iCurImage)
  389. return Num;
  390. } while ((BaseImage = BaseImage->Layers));
  391. break;
  392. case IL_ACTIVE_FACE:
  393. BaseImage = BaseImage->Faces;
  394. do {
  395. if (BaseImage == NULL)
  396. return 0;
  397. Num++;
  398. if (BaseImage == iCurImage)
  399. return Num;
  400. } while ((BaseImage = BaseImage->Faces));
  401. break;
  402. }
  404. //@TODO: Any error needed here?
  406. return 0;
  407. }
  410. //! Sets Param equal to the current value of the Mode
  411. void ILAPIENTRY ilGetIntegerv(ILenum Mode, ILint *Param)
  412. {
  413. if (Param == NULL) {
  414. ilSetError(IL_INVALID_PARAM);
  415. return;
  416. }
  418. *Param = 0;
  420. switch (Mode) {
  421. // Integer values
  422. case IL_COMPRESS_MODE:
  423. *Param = ilStates[ilCurrentPos].ilCompression;
  424. break;
  425. case IL_CUR_IMAGE:
  426. if (iCurImage == NULL) {
  427. ilSetError(IL_ILLEGAL_OPERATION);
  428. break;
  429. }
  430. *Param = ilGetCurName();
  431. break;
  432. case IL_FORMAT_MODE:
  433. *Param = ilStates[ilCurrentPos].ilFormatMode;
  434. break;
  435. case IL_INTERLACE_MODE:
  436. *Param = ilStates[ilCurrentPos].ilInterlace;
  437. break;
  438. case IL_KEEP_DXTC_DATA:
  439. *Param = ilStates[ilCurrentPos].ilKeepDxtcData;
  440. break;
  441. case IL_ORIGIN_MODE:
  442. *Param = ilStates[ilCurrentPos].ilOriginMode;
  443. break;
  444. case IL_MAX_QUANT_INDICES:
  445. *Param = ilStates[ilCurrentPos].ilQuantMaxIndexs;
  446. break;
  447. case IL_NEU_QUANT_SAMPLE:
  448. *Param = ilStates[ilCurrentPos].ilNeuSample;
  449. break;
  450. case IL_QUANTIZATION_MODE:
  451. *Param = ilStates[ilCurrentPos].ilQuantMode;
  452. break;
  453. case IL_TYPE_MODE:
  454. *Param = ilStates[ilCurrentPos].ilTypeMode;
  455. break;
  456. case IL_VERSION_NUM:
  457. *Param = IL_VERSION;
  458. break;
  460. // Image specific values
  461. case IL_ACTIVE_IMAGE:
  462. case IL_ACTIVE_MIPMAP:
  463. case IL_ACTIVE_LAYER:
  464. *Param = iGetActiveNum(Mode);
  465. break;
  467. // Format-specific values
  468. case IL_BMP_RLE:
  469. *Param = ilStates[ilCurrentPos].ilBmpRle;
  470. break;
  471. case IL_DXTC_FORMAT:
  472. *Param = ilStates[ilCurrentPos].ilDxtcFormat;
  473. break;
  474. case IL_JPG_QUALITY:
  475. *Param = ilStates[ilCurrentPos].ilJpgQuality;
  476. break;
  477. case IL_JPG_SAVE_FORMAT:
  478. *Param = ilStates[ilCurrentPos].ilJpgFormat;
  479. break;
  480. case IL_PCD_PICNUM:
  481. *Param = ilStates[ilCurrentPos].ilPcdPicNum;
  482. break;
  483. case IL_PNG_ALPHA_INDEX:
  484. *Param = ilStates[ilCurrentPos].ilPngAlphaIndex;
  485. break;
  486. case IL_PNG_INTERLACE:
  487. *Param = ilStates[ilCurrentPos].ilPngInterlace;
  488. break;
  489. case IL_SGI_RLE:
  490. *Param = ilStates[ilCurrentPos].ilSgiRle;
  491. break;
  492. case IL_TGA_CREATE_STAMP:
  493. *Param = ilStates[ilCurrentPos].ilTgaCreateStamp;
  494. break;
  495. case IL_TGA_RLE:
  496. *Param = ilStates[ilCurrentPos].ilTgaRle;
  497. break;
  499. // Boolean values
  500. case IL_CONV_PAL:
  501. *Param = ilStates[ilCurrentPos].ilAutoConvPal;
  502. break;
  503. case IL_DEFAULT_ON_FAIL:
  504. *Param = ilStates[ilCurrentPos].ilDefaultOnFail;
  505. break;
  506. case IL_FILE_MODE:
  507. *Param = ilStates[ilCurrentPos].ilOverWriteFiles;
  508. break;
  509. case IL_FORMAT_SET:
  510. *Param = ilStates[ilCurrentPos].ilFormatSet;
  511. break;
  512. case IL_ORIGIN_SET:
  513. *Param = ilStates[ilCurrentPos].ilOriginSet;
  514. break;
  515. case IL_TYPE_SET:
  516. *Param = ilStates[ilCurrentPos].ilTypeSet;
  517. break;
  518. case IL_USE_KEY_COLOUR:
  519. *Param = ilStates[ilCurrentPos].ilUseKeyColour;
  520. break;
  521. case IL_BLIT_BLEND:
  522. *Param = ilStates[ilCurrentPos].ilBlitBlend;
  523. break;
  524. case IL_JPG_PROGRESSIVE:
  525. *Param = ilStates[ilCurrentPos].ilJpgProgressive;
  526. break;
  527. case IL_NVIDIA_COMPRESS:
  528. *Param = ilStates[ilCurrentPos].ilUseNVidiaDXT;
  529. break;
  530. case IL_SQUISH_COMPRESS:
  531. *Param = ilStates[ilCurrentPos].ilUseSquishDXT;
  532. break;
  534. default:
  535.             iGetIntegervImage(iCurImage, Mode, Param);
  536. }
  538. return;
  539. }
  541. //@TODO rename to ilGetImageIntegerv for 1.6.9 and make it public
  542. //! Sets Param equal to the current value of the Mode
  543. void ILAPIENTRY iGetIntegervImage(ILimage *Image, ILenum Mode, ILint *Param)
  544. {
  545.     ILimage *SubImage;
  546.     if (Image == NULL) {
  547.         ilSetError(IL_ILLEGAL_OPERATION);
  548.         return;
  549.     }
  550.     if (Param == NULL) {
  551.         ilSetError(IL_INVALID_PARAM);
  552.         return;
  553.     }
  554.     *Param = 0;
  556.     switch (Mode)
  557.     {
  558.         case IL_DXTC_DATA_FORMAT:
  559.             if (Image->DxtcData == NULL || Image->DxtcSize == 0) {
  560.                  *Param = IL_DXT_NO_COMP;
  561.                  break;
  562.             }
  563.             *Param = Image->DxtcFormat;
  564.             break;
  565.             ////
  566.         case IL_IMAGE_BITS_PER_PIXEL:
  567.             //changed 20040610 to channel count (Bpp) times Bytes per channel
  568.             *Param = (Image->Bpp << 3)*Image->Bpc;
  569.             break;
  570.         case IL_IMAGE_BYTES_PER_PIXEL:
  571.             //changed 20040610 to channel count (Bpp) times Bytes per channel
  572.             *Param = Image->Bpp*Image->Bpc;
  573.             break;
  574.         case IL_IMAGE_BPC:
  575.             *Param = Image->Bpc;
  576.             break;
  577.         case IL_IMAGE_CHANNELS:
  578.             *Param = Image->Bpp;
  579.             break;
  580.         case IL_IMAGE_CUBEFLAGS:
  581.             *Param = Image->CubeFlags;
  582.             break;
  583.         case IL_IMAGE_DEPTH:
  584.             *Param = Image->Depth;
  585.             break;
  586.         case IL_IMAGE_DURATION:
  587.             *Param = Image->Duration;
  588.             break;
  589.         case IL_IMAGE_FORMAT:
  590.             *Param = Image->Format;
  591.             break;
  592.         case IL_IMAGE_HEIGHT:
  593.             *Param = Image->Height;
  594.             break;
  595.         case IL_IMAGE_SIZE_OF_DATA:
  596.             *Param = Image->SizeOfData;
  598.             break;
  599.         case IL_IMAGE_OFFX:
  600.             *Param = Image->OffX;
  601.             break;
  602.         case IL_IMAGE_OFFY:
  603.             *Param = Image->OffY;
  604.             break;
  605.         case IL_IMAGE_ORIGIN:
  606.             *Param = Image->Origin;
  607.             break;
  608.         case IL_IMAGE_PLANESIZE:
  609.             *Param = Image->SizeOfPlane;
  610.             break;
  611.         case IL_IMAGE_TYPE:
  612.             *Param = Image->Type;
  613.             break;
  614.         case IL_IMAGE_WIDTH:
  615.             *Param = Image->Width;
  616.             break;
  617.         case IL_NUM_FACES:
  618.             for (SubImage = Image->Faces; SubImage; SubImage = SubImage->Faces)
  619.                 (*Param)++;
  620.             break;
  621.         case IL_NUM_IMAGES:
  622.             for (SubImage = Image->Next; SubImage; SubImage = SubImage->Next)
  623.                 (*Param)++;
  624.             break;
  625.         case IL_NUM_LAYERS:
  626.             for (SubImage = Image->Layers; SubImage; SubImage = SubImage->Layers)
  627.                 (*Param)++;
  628.             break;
  629.         case IL_NUM_MIPMAPS:
  630. for (SubImage = Image->Mipmaps; SubImage; SubImage = SubImage->Mipmaps)
  631.                 (*Param)++;
  632.             break;
  634.         case IL_PALETTE_TYPE:
  635.              *Param = Image->Pal.PalType;
  636.              break;
  637.         case IL_PALETTE_BPP:
  638.              *Param = ilGetBppPal(Image->Pal.PalType);
  639.              break;
  640.         case IL_PALETTE_NUM_COLS:
  641.              if (!Image->Pal.Palette || !Image->Pal.PalSize || Image->Pal.PalType == IL_PAL_NONE)
  642.                   *Param = 0;
  643.              else
  644.                   *Param = Image->Pal.PalSize / ilGetBppPal(Image->Pal.PalType);
  645.              break;
  646.         case IL_PALETTE_BASE_TYPE:
  647.              switch (Image->Pal.PalType)
  648.              {
  649.                   case IL_PAL_RGB24:
  650.                       *Param = IL_RGB;
  651.       break;
  652.                   case IL_PAL_RGB32:
  653.                       *Param = IL_RGBA; // Not sure
  654.       break;
  655.                   case IL_PAL_RGBA32:
  656.                       *Param = IL_RGBA;
  657.       break;
  658.                   case IL_PAL_BGR24:
  659.                       *Param = IL_BGR;
  660.       break;
  661.                   case IL_PAL_BGR32:
  662.                       *Param = IL_BGRA; // Not sure
  663.       break;
  664.                   case IL_PAL_BGRA32:
  665.                       *Param = IL_BGRA;
  666.       break;
  667.              }
  668.              break;
  669.         default:
  670.              ilSetError(IL_INVALID_ENUM);
  671.     }
  672. }
  676. //! Returns the current value of the Mode
  677. ILint ILAPIENTRY ilGetInteger(ILenum Mode)
  678. {
  679. ILint Temp;
  680. Temp = 0;
  681. ilGetIntegerv(Mode, &Temp);
  682. return Temp;
  683. }
  686. //! Sets the default origin to be used.
  687. ILboolean ILAPIENTRY ilOriginFunc(ILenum Mode)
  688. {
  689. switch (Mode)
  690. {
  691. case IL_ORIGIN_LOWER_LEFT:
  692. case IL_ORIGIN_UPPER_LEFT:
  693. ilStates[ilCurrentPos].ilOriginMode = Mode;
  694. break;
  695. default:
  696. ilSetError(IL_INVALID_PARAM);
  697. return IL_FALSE;
  698. }
  699. return IL_TRUE;
  700. }
  703. //! Sets the default format to be used.
  704. ILboolean ILAPIENTRY ilFormatFunc(ILenum Mode)
  705. {
  706. switch (Mode)
  707. {
  708. //case IL_COLOUR_INDEX:
  709. case IL_RGB:
  710. case IL_RGBA:
  711. case IL_BGR:
  712. case IL_BGRA:
  713. case IL_LUMINANCE:
  714. case IL_LUMINANCE_ALPHA:
  715. ilStates[ilCurrentPos].ilFormatMode = Mode;
  716. break;
  717. default:
  718. ilSetError(IL_INVALID_PARAM);
  719. return IL_FALSE;
  720. }
  721. return IL_TRUE;
  722. }
  725. //! Sets the default type to be used.
  726. ILboolean ILAPIENTRY ilTypeFunc(ILenum Mode)
  727. {
  728. switch (Mode)
  729. {
  730. case IL_BYTE:
  731. case IL_UNSIGNED_BYTE:
  732. case IL_SHORT:
  733. case IL_UNSIGNED_SHORT:
  734. case IL_INT:
  735. case IL_UNSIGNED_INT:
  736. case IL_FLOAT:
  737. case IL_DOUBLE:
  738. ilStates[ilCurrentPos].ilTypeMode = Mode;
  739. break;
  740. default:
  741. ilSetError(IL_INVALID_PARAM);
  742. return IL_FALSE;
  743. }
  744. return IL_TRUE;
  745. }
  748. ILboolean ILAPIENTRY ilCompressFunc(ILenum Mode)
  749. {
  750. switch (Mode)
  751. {
  752. case IL_COMPRESS_NONE:
  753. case IL_COMPRESS_RLE:
  754. //case IL_COMPRESS_LZO:
  755. case IL_COMPRESS_ZLIB:
  756. ilStates[ilCurrentPos].ilCompression = Mode;
  757. break;
  758. default:
  759. ilSetError(IL_INVALID_PARAM);
  760. return IL_FALSE;
  761. }
  762. return IL_TRUE;
  763. }
  766. //! Pushes the states indicated by Bits onto the state stack
  767. void ILAPIENTRY ilPushAttrib(ILuint Bits)
  768. {
  769. // Should we check here to see if ilCurrentPos is negative?
  771. if (ilCurrentPos >= IL_ATTRIB_STACK_MAX - 1) {
  772. ilCurrentPos = IL_ATTRIB_STACK_MAX - 1;
  773. ilSetError(IL_STACK_OVERFLOW);
  774. return;
  775. }
  777. ilCurrentPos++;
  779. // memcpy(&ilStates[ilCurrentPos], &ilStates[ilCurrentPos - 1], sizeof(IL_STATES));
  781. ilDefaultStates();
  783. if (Bits & IL_ORIGIN_BIT) {
  784. ilStates[ilCurrentPos].ilOriginMode = ilStates[ilCurrentPos-1].ilOriginMode;
  785. ilStates[ilCurrentPos].ilOriginSet  = ilStates[ilCurrentPos-1].ilOriginSet;
  786. }
  787. if (Bits & IL_FORMAT_BIT) {
  788. ilStates[ilCurrentPos].ilFormatMode = ilStates[ilCurrentPos-1].ilFormatMode;
  789. ilStates[ilCurrentPos].ilFormatSet  = ilStates[ilCurrentPos-1].ilFormatSet;
  790. }
  791. if (Bits & IL_TYPE_BIT) {
  792. ilStates[ilCurrentPos].ilTypeMode = ilStates[ilCurrentPos-1].ilTypeMode;
  793. ilStates[ilCurrentPos].ilTypeSet  = ilStates[ilCurrentPos-1].ilTypeSet;
  794. }
  795. if (Bits & IL_FILE_BIT) {
  796. ilStates[ilCurrentPos].ilOverWriteFiles = ilStates[ilCurrentPos-1].ilOverWriteFiles;
  797. }
  798. if (Bits & IL_PAL_BIT) {
  799. ilStates[ilCurrentPos].ilAutoConvPal = ilStates[ilCurrentPos-1].ilAutoConvPal;
  800. }
  801. if (Bits & IL_LOADFAIL_BIT) {
  802. ilStates[ilCurrentPos].ilDefaultOnFail = ilStates[ilCurrentPos-1].ilDefaultOnFail;
  803. }
  804. if (Bits & IL_COMPRESS_BIT) {
  805. ilStates[ilCurrentPos].ilCompression = ilStates[ilCurrentPos-1].ilCompression;
  806. }
  807. if (Bits & IL_FORMAT_SPECIFIC_BIT) {
  808. ilStates[ilCurrentPos].ilTgaCreateStamp = ilStates[ilCurrentPos-1].ilTgaCreateStamp;
  809. ilStates[ilCurrentPos].ilJpgQuality = ilStates[ilCurrentPos-1].ilJpgQuality;
  810. ilStates[ilCurrentPos].ilPngInterlace = ilStates[ilCurrentPos-1].ilPngInterlace;
  811. ilStates[ilCurrentPos].ilTgaRle = ilStates[ilCurrentPos-1].ilTgaRle;
  812. ilStates[ilCurrentPos].ilBmpRle = ilStates[ilCurrentPos-1].ilBmpRle;
  813. ilStates[ilCurrentPos].ilSgiRle = ilStates[ilCurrentPos-1].ilSgiRle;
  814. ilStates[ilCurrentPos].ilJpgFormat = ilStates[ilCurrentPos-1].ilJpgFormat;
  815. ilStates[ilCurrentPos].ilDxtcFormat = ilStates[ilCurrentPos-1].ilDxtcFormat;
  816. ilStates[ilCurrentPos].ilPcdPicNum = ilStates[ilCurrentPos-1].ilPcdPicNum;
  818. ilStates[ilCurrentPos].ilPngAlphaIndex = ilStates[ilCurrentPos-1].ilPngAlphaIndex;
  820. // Strings
  821. if (ilStates[ilCurrentPos].ilTgaId)
  822. ifree(ilStates[ilCurrentPos].ilTgaId);
  823. if (ilStates[ilCurrentPos].ilTgaAuthName)
  824. ifree(ilStates[ilCurrentPos].ilTgaAuthName);
  825. if (ilStates[ilCurrentPos].ilTgaAuthComment)
  826. ifree(ilStates[ilCurrentPos].ilTgaAuthComment);
  827. if (ilStates[ilCurrentPos].ilPngAuthName)
  828. ifree(ilStates[ilCurrentPos].ilPngAuthName);
  829. if (ilStates[ilCurrentPos].ilPngTitle)
  830. ifree(ilStates[ilCurrentPos].ilPngTitle);
  831. if (ilStates[ilCurrentPos].ilPngDescription)
  832. ifree(ilStates[ilCurrentPos].ilPngDescription);
  834. //2003-09-01: added tif strings
  835. if (ilStates[ilCurrentPos].ilTifDescription)
  836. ifree(ilStates[ilCurrentPos].ilTifDescription);
  837. if (ilStates[ilCurrentPos].ilTifHostComputer)
  838. ifree(ilStates[ilCurrentPos].ilTifHostComputer);
  839. if (ilStates[ilCurrentPos].ilTifDocumentName)
  840. ifree(ilStates[ilCurrentPos].ilTifDocumentName);
  841. if (ilStates[ilCurrentPos].ilTifAuthName)
  842. ifree(ilStates[ilCurrentPos].ilTifAuthName);
  844. if (ilStates[ilCurrentPos].ilCHeader)
  845. ifree(ilStates[ilCurrentPos].ilCHeader);
  847. ilStates[ilCurrentPos].ilTgaId = strdup(ilStates[ilCurrentPos-1].ilTgaId);
  848. ilStates[ilCurrentPos].ilTgaAuthName = strdup(ilStates[ilCurrentPos-1].ilTgaAuthName);
  849. ilStates[ilCurrentPos].ilTgaAuthComment = strdup(ilStates[ilCurrentPos-1].ilTgaAuthComment);
  850. ilStates[ilCurrentPos].ilPngAuthName = strdup(ilStates[ilCurrentPos-1].ilPngAuthName);
  851. ilStates[ilCurrentPos].ilPngTitle = strdup(ilStates[ilCurrentPos-1].ilPngTitle);
  852. ilStates[ilCurrentPos].ilPngDescription = strdup(ilStates[ilCurrentPos-1].ilPngDescription);
  854. //2003-09-01: added tif strings
  855. ilStates[ilCurrentPos].ilTifDescription = strdup(ilStates[ilCurrentPos-1].ilTifDescription);
  856. ilStates[ilCurrentPos].ilTifHostComputer = strdup(ilStates[ilCurrentPos-1].ilTifHostComputer);
  857. ilStates[ilCurrentPos].ilTifDocumentName = strdup(ilStates[ilCurrentPos-1].ilTifDocumentName);
  858. ilStates[ilCurrentPos].ilTifAuthName = strdup(ilStates[ilCurrentPos-1].ilTifAuthName);
  860. ilStates[ilCurrentPos].ilCHeader = strdup(ilStates[ilCurrentPos-1].ilCHeader);
  861. }
  863. return;
  864. }
  867. // @TODO:  Find out how this affects strings!!!
  869. //! Pops the last entry off the state stack into the current states
  870. void ILAPIENTRY ilPopAttrib()
  871. {
  872. if (ilCurrentPos <= 0) {
  873. ilCurrentPos = 0;
  874. ilSetError(IL_STACK_UNDERFLOW);
  875. return;
  876. }
  878. // Should we check here to see if ilCurrentPos is too large?
  879. ilCurrentPos--;
  881. return;
  882. }
  885. //! Specifies implementation-dependent performance hints
  886. void ILAPIENTRY ilHint(ILenum Target, ILenum Mode)
  887. {
  888. switch (Target)
  889. {
  890. case IL_MEM_SPEED_HINT:
  891. switch (Mode)
  892. {
  893. case IL_FASTEST:
  894. ilHints.MemVsSpeedHint = Mode;
  895. break;
  896. case IL_LESS_MEM:
  897. ilHints.MemVsSpeedHint = Mode;
  898. break;
  899. case IL_DONT_CARE:
  900. ilHints.MemVsSpeedHint = IL_FASTEST;
  901. break;
  902. default:
  903. ilSetError(IL_INVALID_ENUM);
  904. return;
  905. }
  906. break;
  908. case IL_COMPRESSION_HINT:
  909. switch (Mode)
  910. {
  911. case IL_USE_COMPRESSION:
  912. ilHints.CompressHint = Mode;
  913. break;
  914. case IL_NO_COMPRESSION:
  915. ilHints.CompressHint = Mode;
  916. break;
  917. case IL_DONT_CARE:
  918. ilHints.CompressHint = IL_NO_COMPRESSION;
  919. break;
  920. default:
  921. ilSetError(IL_INVALID_ENUM);
  922. return;
  923. }
  924. break;
  927. default:
  928. ilSetError(IL_INVALID_ENUM);
  929. return;
  930. }
  932. return;
  933. }
  936. ILenum iGetHint(ILenum Target)
  937. {
  938. switch (Target)
  939. {
  940. case IL_MEM_SPEED_HINT:
  941. return ilHints.MemVsSpeedHint;
  942. case IL_COMPRESSION_HINT:
  943. return ilHints.CompressHint;
  944. default:
  945. ilSetError(IL_INTERNAL_ERROR);
  946. return 0;
  947. }
  948. }
  951. void ILAPIENTRY ilSetString(ILenum Mode, const char *String)
  952. {
  953. if (String == NULL) {
  954. ilSetError(IL_INVALID_PARAM);
  955. return;
  956. }
  958. switch (Mode)
  959. {
  960. case IL_TGA_ID_STRING:
  961. if (ilStates[ilCurrentPos].ilTgaId)
  962. ifree(ilStates[ilCurrentPos].ilTgaId);
  963. ilStates[ilCurrentPos].ilTgaId = strdup(String);
  964. break;
  965. case IL_TGA_AUTHNAME_STRING:
  966. if (ilStates[ilCurrentPos].ilTgaAuthName)
  967. ifree(ilStates[ilCurrentPos].ilTgaAuthName);
  968. ilStates[ilCurrentPos].ilTgaAuthName = strdup(String);
  969. break;
  970. case IL_TGA_AUTHCOMMENT_STRING:
  971. if (ilStates[ilCurrentPos].ilTgaAuthComment)
  972. ifree(ilStates[ilCurrentPos].ilTgaAuthComment);
  973. ilStates[ilCurrentPos].ilTgaAuthComment = strdup(String);
  974. break;
  975. case IL_PNG_AUTHNAME_STRING:
  976. if (ilStates[ilCurrentPos].ilPngAuthName)
  977. ifree(ilStates[ilCurrentPos].ilPngAuthName);
  978. ilStates[ilCurrentPos].ilPngAuthName = strdup(String);
  979. break;
  980. case IL_PNG_TITLE_STRING:
  981. if (ilStates[ilCurrentPos].ilPngTitle)
  982. ifree(ilStates[ilCurrentPos].ilPngTitle);
  983. ilStates[ilCurrentPos].ilPngTitle = strdup(String);
  984. break;
  985. case IL_PNG_DESCRIPTION_STRING:
  986. if (ilStates[ilCurrentPos].ilPngDescription)
  987. ifree(ilStates[ilCurrentPos].ilPngDescription);
  988. ilStates[ilCurrentPos].ilPngDescription = strdup(String);
  989. break;
  991. //2003-09-01: added tif strings
  992. case IL_TIFF_DESCRIPTION_STRING:
  993. if (ilStates[ilCurrentPos].ilTifDescription)
  994. ifree(ilStates[ilCurrentPos].ilTifDescription);
  995. ilStates[ilCurrentPos].ilTifDescription = strdup(String);
  996. break;
  997. case IL_TIFF_HOSTCOMPUTER_STRING:
  998. if (ilStates[ilCurrentPos].ilTifHostComputer)
  999. ifree(ilStates[ilCurrentPos].ilTifHostComputer);
  1000. ilStates[ilCurrentPos].ilTifHostComputer = strdup(String);
  1001. break;
  1002. case IL_TIFF_DOCUMENTNAME_STRING:
  1003. if (ilStates[ilCurrentPos].ilTifDocumentName)
  1004. ifree(ilStates[ilCurrentPos].ilTifDocumentName);
  1005. ilStates[ilCurrentPos].ilTifDocumentName = strdup(String);
  1006. break;
  1007. case IL_TIFF_AUTHNAME_STRING:
  1008. if (ilStates[ilCurrentPos].ilTifAuthName)
  1009. ifree(ilStates[ilCurrentPos].ilTifAuthName);
  1010. ilStates[ilCurrentPos].ilTifAuthName = strdup(String);
  1011. break;
  1013. case IL_CHEAD_HEADER_STRING:
  1014. if (ilStates[ilCurrentPos].ilCHeader)
  1015. ifree(ilStates[ilCurrentPos].ilCHeader);
  1016. ilStates[ilCurrentPos].ilCHeader = strdup(String);
  1017. break;
  1019. default:
  1020. ilSetError(IL_INVALID_ENUM);
  1021. }
  1023. return;
  1024. }
  1027. void ILAPIENTRY ilSetInteger(ILenum Mode, ILint Param)
  1028. {
  1029. LOG_ADVANCED(IL_LOG_INFO, "ilInteger %u set to %d", Mode, Param);
  1030. switch (Mode)
  1031. {
  1032. // Integer values
  1033. case IL_FORMAT_MODE:
  1034. ilFormatFunc(Param);
  1035. return;
  1036. case IL_KEEP_DXTC_DATA:
  1037. if (Param == IL_FALSE || Param == IL_TRUE) {
  1038. ilStates[ilCurrentPos].ilKeepDxtcData = Param;
  1039. return;
  1040. }
  1041. break;
  1042. case IL_MAX_QUANT_INDICES:
  1043. if (Param >= 2 && Param <= 256) {
  1044. ilStates[ilCurrentPos].ilQuantMaxIndexs = Param;
  1045. return;
  1046. }
  1047. break;
  1048. case IL_NEU_QUANT_SAMPLE:
  1049. if (Param >= 1 && Param <= 30) {
  1050. ilStates[ilCurrentPos].ilNeuSample = Param;
  1051. return;
  1052. }
  1053. break;
  1054. case IL_ORIGIN_MODE:
  1055. ilOriginFunc(Param);
  1056. return;
  1057. case IL_QUANTIZATION_MODE:
  1058. if (Param == IL_WU_QUANT || Param == IL_NEU_QUANT) {
  1059. ilStates[ilCurrentPos].ilQuantMode = Param;
  1060. return;
  1061. }
  1062. break;
  1063. case IL_TYPE_MODE:
  1064. ilTypeFunc(Param);
  1065. return;
  1067. // Image specific values
  1068. case IL_IMAGE_DURATION:
  1069. if (iCurImage == NULL) {
  1070. ilSetError(IL_ILLEGAL_OPERATION);
  1071. break;
  1072. }
  1073. iCurImage->Duration = Param;
  1074. return;
  1075. case IL_IMAGE_OFFX:
  1076. if (iCurImage == NULL) {
  1077. ilSetError(IL_ILLEGAL_OPERATION);
  1078. break;
  1079. }
  1080. iCurImage->OffX = Param;
  1081. return;
  1082. case IL_IMAGE_OFFY:
  1083. if (iCurImage == NULL) {
  1084. ilSetError(IL_ILLEGAL_OPERATION);
  1085. break;
  1086. }
  1087. iCurImage->OffY = Param;
  1088. return;
  1089. case IL_IMAGE_CUBEFLAGS:
  1090. if (iCurImage == NULL) {
  1091. ilSetError(IL_ILLEGAL_OPERATION);
  1092. break;
  1093. }
  1094. iCurImage->CubeFlags = Param;
  1095. break;
  1096.  
  1097. // Format specific values
  1098. case IL_BMP_RLE:
  1099. if (Param == IL_FALSE || Param == IL_TRUE) {
  1100. ilStates[ilCurrentPos].ilBmpRle = Param;
  1101. return;
  1102. }
  1103. break;
  1104. case IL_DXTC_FORMAT:
  1105. if (Param >= IL_DXT1 || Param <= IL_DXT5 || Param == IL_DXT1A) {
  1106. ilStates[ilCurrentPos].ilDxtcFormat = Param;
  1107. return;
  1108. }
  1109. break;
  1110. case IL_JPG_SAVE_FORMAT:
  1111. if (Param == IL_JFIF || Param == IL_EXIF) {
  1112. ilStates[ilCurrentPos].ilJpgFormat = Param;
  1113. return;
  1114. }
  1115. break;
  1116. case IL_JPG_QUALITY:
  1117. if (Param >= 0 && Param <= 99) {
  1118. ilStates[ilCurrentPos].ilJpgQuality = Param;
  1119. return;
  1120. }
  1121. break;
  1122. case IL_PNG_INTERLACE:
  1123. if (Param == IL_FALSE || Param == IL_TRUE) {
  1124. ilStates[ilCurrentPos].ilPngInterlace = Param;
  1125. return;
  1126. }
  1127. break;
  1128. case IL_PCD_PICNUM:
  1129. if (Param >= 0 || Param <= 2) {
  1130. ilStates[ilCurrentPos].ilPcdPicNum = Param;
  1131. return;
  1132. }
  1133. break;
  1134. case IL_PNG_ALPHA_INDEX:
  1135. if (Param >= -1 || Param <= 255) {
  1136. ilStates[ilCurrentPos].ilPngAlphaIndex=Param;
  1137. return;
  1138. }
  1139. break;
  1140. case IL_SGI_RLE:
  1141. if (Param == IL_FALSE || Param == IL_TRUE) {
  1142. ilStates[ilCurrentPos].ilSgiRle = Param;
  1143. return;
  1144. }
  1145. break;
  1146. case IL_TGA_CREATE_STAMP:
  1147. if (Param == IL_FALSE || Param == IL_TRUE) {
  1148. ilStates[ilCurrentPos].ilTgaCreateStamp = Param;
  1149. return;
  1150. }
  1151. break;
  1152. case IL_TGA_RLE:
  1153. if (Param == IL_FALSE || Param == IL_TRUE) {
  1154. ilStates[ilCurrentPos].ilTgaRle = Param;
  1155. return;
  1156. }
  1157. break;
  1159. default:
  1160. ilSetError(IL_INVALID_ENUM);
  1161. return;
  1162. }
  1164. ilSetError(IL_INVALID_PARAM);  // Parameter not in valid bounds.
  1165. return;
  1166. }
  1170. ILint iGetInt(ILenum Mode)
  1171. {
  1172. //like ilGetInteger(), but sets another error on failure
  1174. //call ilGetIntegerv() for more robust code
  1175. ILenum err;
  1176. ILint r = -1;
  1178. ilGetIntegerv(Mode, &r);
  1180. //check if an error occured, set another error
  1181. err = ilGetError();
  1182. if (r == -1 && err == IL_INVALID_ENUM)
  1183. ilSetError(IL_INTERNAL_ERROR);
  1184. else
  1185. ilSetError(err); //restore error
  1187. return r;
  1188. }